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

13 files changed, 12734 insertions, 12734 deletions

diff --git a/sdk/extensions/import/apexmodules/NvParameterized/src/BinSerializer.cpp b/sdk/extensions/import/apexmodules/NvParameterized/src/BinSerializer.cpp
index 623c020..420a171 100644..100755
--- a/sdk/extensions/import/apexmodules/NvParameterized/src/BinSerializer.cpp
+++ b/sdk/extensions/import/apexmodules/NvParameterized/src/BinSerializer.cpp
@@ -1,1828 +1,1828 @@
-// 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) 2008-2013 NVIDIA Corporation. All rights reserved.
-
-/*
-	Binary serialization is very complex and error-prone
-	process. Ensuring that it works properly is _critically_
-	important for the engine.
-
-	Before you do any significant changes to this code
-	please get familiar with C/C++ object layouts.
-	You may find these links helpful:
-
-	* APEX binary file format
-		https://wiki.nvidia.com/engwiki/index.php/PhysX/APEX/architecture/design/File_Formats
-		(may not be up-to-date)
-
-	* C++ data alignment and portability
-		http://www.codesynthesis.com/~boris/blog/2009/04/06/cxx-data-alignment-portability/
-
-	* Data structure alignment
-		http://en.wikipedia.org/wiki/Data_structure_alignment
-
-	* About Data Alignment
-		http://msdn.microsoft.com/en-us/library/ms253949%28v=VS.80%29.aspx
-
-	* Types and Storage
-		http://msdn.microsoft.com/en-us/library/02c56cw3.aspx
-
-	* Jan Gray's article in "C++: Under the Hood"
-		http://www.openrce.org/articles/files/jangrayhood.pdf
-
-	* Windows Data Alignment on IPF, x86, and x64
-		http://msdn.microsoft.com/en-us/library/aa290049%28VS.71%29.aspx
-
-	* GCC alignment in classes gotcha
-		https://ps3.scedev.net/forums/thread/41593/
-
-	* all messages in thread http://compilers.iecc.com/comparch/article/94-08-119
-
-	* Memory Layout for Multiple and Virtual Inheritance
-		http://www.phpcompiler.org/articles/virtualinheritance.html
-
-	* The "Empty Member" C++ Optimization
-		http://www.cantrip.org/emptyopt.html
-
-	You may also want to see examples of existing ABI
-	for various platforms:
-
-	* Agner Fog's Calling conventions for different C++ compilers
-		and operating systems,
-		http://www.agner.org/optimize/calling_conventions.pdf
-
-	* Itanium C++ ABI Data Layout
-		http://www.codesourcery.com/public/cxx-abi/abi.html#layout
-
-	* Introduction to Mac OS X ABI Function Call Guide
-		http://developer.apple.com/library/mac/#documentation/DeveloperTools/Conceptual/LowLevelABI/000-Introduction/introduction.html
-
-	After you implement you changes be sure to check that ALL
-	NvParameterized unit tests
-	* Test/MediaTest
-	* Test/RandomClasses
-	* Test/ParamRandomTest
-	run without errors on ALL supported platforms:
-	* Win32
-	* Win64
-	* PS3
-	* XBOX 360
-	(in future we may also have Mac, Tegra, Linux on PC, etc.).
-
-	If you need to add new platform to this list, be sure to
-	analyze it's ABI with ABIDumper
-	(//sw/nvidia/shared/general/ABIDumper) and check whether
-	it requires special changes in current serialization code
-	(Mac does).
-
-	If you ever implement new features be sure to cover them
-	in random schema generator
-	NvParameterized/scripts/RandomSchema.pl, generate a bunch
-	(10 at least) of new random schemas for Test/RandomClasses
-	and add them to p4 (and verify that they work on all
-	platforms!).
-*/
-
-#include <PxSimpleTypes.h>
-
-#include "PsArray.h"
-#include "PsHash.h"
-#include "PsHashMap.h"
-
-#include "NvParameters.h"
-#include "nvparameterized/NvParamUtils.h"
-#include "NvTraitsInternal.h"
-
-#include "BinaryHelper.h"
-
-#include "PlatformABI.h"
-#include "PlatformInputStream.h"
-#include "PlatformOutputStream.h"
-
-#include "BinSerializer.h"
-
-namespace NvParameterized
-{
-
-// Verify that file header is ok
-Serializer::ErrorType BinSerializer::verifyFileHeader(
-	const BinaryHeader &hdr,
-	const BinaryHeaderExt *ext,
-	uint32_t dataLen ) const
-{
-	NV_BOOL_ERR_CHECK_WARN_RETURN( BinSerializer::Magic == hdr.magic, Serializer::ERROR_INVALID_MAGIC, "Invalid APB file: magic number does not match: %x", hdr.magic );
-	NV_BOOL_ERR_CHECK_WARN_RETURN( (uint32_t)BINARY_TYPE_PLAIN == hdr.type, Serializer::ERROR_INVALID_FILE_FORMAT, "Invalid APB file: unknown file format: %d", hdr.type );
-
-	NV_BOOL_ERR_CHECK_WARN_RETURN(
-		BinVersions::WithExtendedHeader == hdr.version || BinVersions::WithAlignment == hdr.version,
-		Serializer::ERROR_INVALID_FILE_VERSION, "Invalid APB header: unexpected version: %x", hdr.version );
-
-	// Verify offsets
-	NV_BOOL_ERR_CHECK_WARN_RETURN( hdr.fileLength <= dataLen
-			&& hdr.dataOffset < hdr.fileLength
-			&& hdr.relocOffset < hdr.fileLength
-			&& hdr.dictOffset < hdr.fileLength
-			&& hdr.metadataOffset < hdr.fileLength,
-		Serializer::ERROR_INVALID_INTERNAL_PTR,
-		"Invalid APB file: section offsets do not match file length" );
-
-	if( ext )
-	{
-		NV_BOOL_ERR_CHECK_WARN_RETURN(
-			0 == memcmp((const char *)&ext->vcsSafetyFlags, VCS_SAFETY_FLAGS, 4),
-			Serializer::ERROR_INVALID_CHAR,
-			"Invalid APB file: perhaps your editor inserts redundant carriage returns?"
-		);
-	}
-
-	return Serializer::ERROR_NONE;
-}
-
-// Peeks APB header from stream
-static Serializer::ErrorType peekFileHeader(physx::PxFileBuf &stream, BinaryHeader &hdr, BinaryHeaderExt &ext, bool doDecanonize = true)
-{
-	NV_BOOL_ERR_CHECK_RETURN(
-		sizeof(BinaryHeader) == stream.peek(&hdr, sizeof(BinaryHeader)),
-		Serializer::ERROR_INVALID_FILE_FORMAT );
-
-	if( hdr.version >= BinVersions::WithExtendedHeader )
-	{
-		uint32_t fileOff = stream.tellRead();
-
-		stream.seekRead(fileOff + sizeof(BinaryHeader));
-		NV_BOOL_ERR_CHECK_RETURN(
-			sizeof(BinaryHeaderExt) == stream.peek(&ext, sizeof(BinaryHeaderExt)),
-			Serializer::ERROR_INVALID_FILE_FORMAT );
-
-		stream.seekRead(fileOff);
-	}
-
-	if( doDecanonize )
-		hdr.decanonize();
-
-	return Serializer::ERROR_NONE;
-}
-
-// Extract platform ABI from file header
-Serializer::ErrorType BinSerializer::getPlatformInfo(
-	BinaryHeader &hdr,
-	BinaryHeaderExt *ext,
-	PlatformABI &abi ) const
-{
-	//Difference between these versions is not important for non-inplace serializer
-	if( hdr.version == BinVersions::Initial || hdr.version == BinVersions::AllRefsCounted )
-		hdr.version = BinVersions::WithAlignment;
-
-	NV_ERR_CHECK_RETURN( verifyFileHeader(hdr, ext, hdr.fileLength) );
-
-	SerializePlatform platform;
-	NV_ERR_CHECK_WARN_RETURN(hdr.getPlatform(platform), "Invalid platform");
-
-	NV_ERR_CHECK_WARN_RETURN( PlatformABI::GetPredefinedABI(platform, abi), "Unknown platform" );
-
-	return Serializer::ERROR_NONE;
-}
-
-Serializer::ErrorType BinSerializer::peekInplaceAlignment(physx::PxFileBuf& stream, uint32_t& align)
-{
-	BinaryHeader hdr;
-	BinaryHeaderExt ext;
-	NV_ERR_CHECK_RETURN( peekFileHeader(stream, hdr, ext, false) );
-	align = Canonize(hdr.alignment);
-	return Serializer::ERROR_NONE;
-}
-
-// Verify that object matches its header
-Serializer::ErrorType BinSerializer::verifyObjectHeader(const ObjHeader &hdr, const Interface *obj, Traits *traits) const
-{
-	DEBUG_ASSERT(obj);
-	NV_BOOL_ERR_CHECK_WARN_RETURN(
-		obj->version() == hdr.version,
-		Serializer::ERROR_UNKNOWN,
-		"Invalid object: version does not match object header" );
-
-	PX_UNUSED(traits);
-
-	uint32_t bits = UINT32_MAX;
-	const uint32_t *checksum = obj->checksum(bits);
-
-	if( !DoIgnoreChecksum(*obj) || hdr.version != obj->version() )
-	{
-		if( bits != 32 * hdr.checksumSize )
-			NV_PARAM_TRAITS_WARNING(
-				traits,
-				"Schema checksum is different for object of class %s and version %u, asset may be corrupted",
-				hdr.className, (unsigned)hdr.version
-			);
-		else
-		{
-			for(uint32_t i = 0; i < hdr.checksumSize; ++i)
-				if( checksum[i] != hdr.checksum[i] )
-				{
-					NV_PARAM_TRAITS_WARNING(
-						traits,
-						"Schema checksum is different for object of class %s and version %u, asset may be corrupted",
-						hdr.className, (unsigned)hdr.version
-					);
-					break;
-				}
-		}
-	}
-
-	return Serializer::ERROR_NONE;
-}
-
-#if 0
-//TODO: this is just for tests, remove it after metadata works
-static void DumpDefinition(const Definition *def, const char *className, uint32_t version, uint32_t off = 0)
-{
-	char *tab = (char *)::malloc(off + 1);
-	memset(tab, ' ', off);
-	tab[off] = 0;
-
-	if( className )
-		printf("%sClass %s:%d\n", tab, className, version);
-
-	printf("%sDefinition at 0x%p:\n", tab, def);
-	printf("%s  name =  %s\n", tab, def->name());
-	printf("%s  type =  %s\n", tab, typeToStr(def->type()));
-	printf("%s  align = %d\n", tab, def->alignment());
-	printf("%s  pad = %d\n", tab, def->padding());
-
-	printf("%s  %d hints:\n", tab, def->numHints());
-	for(uint32_t i = 0; i < def->numHints(); ++i)
-	{
-		const Hint *hint = def->hint(i);
-
-		printf("%s    %s => ", tab, hint->name());
-		switch( hint->type() )
-		{
-		case TYPE_U64:
-			printf("%llu", hint->asUInt());
-			break;
-		case TYPE_F64:
-			printf("%f", hint->asFloat());
-			break;
-		case TYPE_STRING:
-			printf("\"%s\"", hint->asString());
-			break;
-		default:
-			DEBUG_ALWAYS_ASSERT();
-		}
-		printf("\n");
-	}
-
-	printf("%s  %d enums: ", tab, def->numEnumVals());
-	for(uint32_t i = 0; i < def->numEnumVals(); ++i)
-		printf("\"%s\", ", def->enumVal(i));
-	printf("\n");
-
-	printf("%s  %d refVariants: ", tab, def->numRefVariants());
-	for(uint32_t i = 0; i < def->numRefVariants(); ++i)
-		printf("\"%s\", ", def->refVariantVal(i));
-	printf("\n");
-
-	printf("%s  %d children:\n", tab, def->numChildren());
-	for(uint32_t i = 0; i < def->numChildren(); ++i)
-	{
-		printf("%sChild %d:\n", tab, i);
-		DumpDefinition(def->child(i), 0, 0, off + 1);
-	}
-
-	::free(tab);
-
-	fflush(stdout);
-}
-#endif
-
-Serializer::ErrorType BinSerializer::peekNumObjects(physx::PxFileBuf &stream, uint32_t &numObjects)
-{
-	BinaryHeader hdr;
-	BinaryHeaderExt ext;
-	NV_ERR_CHECK_RETURN( peekFileHeader(stream, hdr, ext, false) );
-	
-	return peekNumObjectsInplace((const void *)&hdr, sizeof(hdr), numObjects);
-}
-
-Serializer::ErrorType BinSerializer::peekNumObjectsInplace(const void *data, uint32_t dataLen, uint32_t &numObjects)
-{
-	NV_BOOL_ERR_CHECK_RETURN( dataLen >= sizeof(BinaryHeader), Serializer::ERROR_INVALID_FILE_FORMAT );
-	numObjects = static_cast<uint32_t>(Canonize( ((const BinaryHeader *)data)->numObjects));
-	return Serializer::ERROR_NONE;
-}
-
-Serializer::ErrorType BinSerializer::peekClassNames(physx::PxFileBuf &stream, char **classNames, uint32_t &numClassNames)
-{
-	BinaryHeader hdr;
-	BinaryHeaderExt ext;
-	NV_ERR_CHECK_RETURN( peekFileHeader(stream, hdr, ext) );
-
-	PlatformABI targetParams;
-	NV_ERR_CHECK_RETURN(getPlatformInfo(
-		hdr,
-		hdr.version >= BinVersions::WithExtendedHeader ? &ext : 0,
-		targetParams
-	));
-
-	PlatformInputStream objectTable(stream, targetParams, mTraits);
-	objectTable.skipBytes(hdr.dataOffset);
-
-	numClassNames = physx::PxMin(numClassNames, (uint32_t)hdr.numObjects);
-	for(uint32_t i = 0; i < numClassNames; ++i)
-	{
-		uint32_t tmp;
-		NV_ERR_CHECK_RETURN( objectTable.readPtr(tmp) ); // Pointer to object data
-
-		uint32_t classNameOff;
-		NV_ERR_CHECK_RETURN( objectTable.readPtr(classNameOff) ); // Pointer to className
-
-		const char *className;
-		NV_ERR_CHECK_RETURN( objectTable.readString(classNameOff, className) );
-		classNames[i] = mTraits->strdup(className); //User will call Traits::strfree
-		mTraits->free((void *)className);
-
-		NV_ERR_CHECK_RETURN( objectTable.readPtr(tmp) ); // Pointer to name
-		NV_ERR_CHECK_RETURN( objectTable.readPtr(tmp) ); // Pointer to filename
-	}
-
-	return Serializer::ERROR_NONE;
-}
-
-Serializer::ErrorType BinSerializer::readMetadataInfo(const BinaryHeader &hdr, PlatformInputStream &s, DefinitionImpl *def)
-{
-	PX_PLACEMENT_NEW(def, DefinitionImpl)(*mTraits, false);
-
-	s.beginStruct(s.getTargetABI().getMetaInfoAlignment());
-
-	//type
-	uint32_t type;
-	NV_ERR_CHECK_RETURN( s.read(type) );
-	NV_BOOL_ERR_CHECK_WARN_RETURN( type < TYPE_LAST, Serializer::ERROR_INVALID_DATA_TYPE, "Unknown data type: %d", (int)type);
-
-	//arraySize
-	int32_t arraySize;
-	NV_ERR_CHECK_RETURN( s.read(arraySize) );
-
-	//shortName
-	uint32_t nameOff;
-	NV_ERR_CHECK_RETURN( s.readPtr(nameOff) );
-
-	const char *name;
-	NV_ERR_CHECK_RETURN( s.readString(nameOff, name) ); //NOTE: we do not release name because DefinitionImpl does not copy it
-
-	//structName
-	uint32_t structNameOff;
-	NV_ERR_CHECK_RETURN( s.readPtr(structNameOff) );
-
-	const char *structName;
-	NV_ERR_CHECK_RETURN( s.readString(structNameOff, structName) ); //NOTE: we do not release name because DefinitionImpl does not copy it
-
-	// We do not have metadata for older formats without alignment
-	NV_BOOL_ERR_CHECK_WARN_RETURN( hdr.version >= BinVersions::WithAlignment, Serializer::ERROR_INVALID_FILE_VERSION, "Unable to deserialize metadata: file format does not support it" );
-
-	//alignment
-	uint32_t alignment;
-	NV_ERR_CHECK_RETURN( s.read(alignment) );
-
-	//padding
-	uint32_t padding;
-	NV_ERR_CHECK_RETURN( s.read(padding) );
-
-	def->init(name, (DataType)type, structName);
-	def->setArraySize(arraySize);
-	if( alignment ) def->setAlignment(alignment);
-	if( padding ) def->setPadding(padding);
-
-	//numChildren
-	uint32_t numChildren;
-	NV_ERR_CHECK_RETURN( s.read(numChildren) );
-
-	//children
-	for(uint32_t i = 0; i < numChildren; ++i)
-	{
-		DefinitionImpl *childDef = (DefinitionImpl *)mTraits->alloc(sizeof(DefinitionImpl));
-
-		uint32_t off;
-		NV_ERR_CHECK_RETURN( s.readPtr(off) );
-
-		NV_ERR_CHECK_RETURN( s.pushPos(off) );
-		NV_ERR_CHECK_RETURN( readMetadataInfo(hdr, s, childDef) );
-		s.popPos();
-
-		def->addChild(childDef);
-	}
-
-	//numHints
-	uint32_t numHints;
-	NV_ERR_CHECK_RETURN( s.read(numHints) );
-
-	//hints
-	for(uint32_t i = 0; i < numHints; ++i)
-	{
-		HintImpl *hint = (HintImpl *)mTraits->alloc(sizeof(HintImpl));
-		PX_PLACEMENT_NEW(hint, HintImpl)();
-
-		s.beginStruct(s.getTargetABI().getHintAlignment());
-
-		//type
-		uint32_t hintType;
-		NV_ERR_CHECK_RETURN( s.read(hintType) );
-
-		//name
-		uint32_t hintNameOff;
-		NV_ERR_CHECK_RETURN( s.readPtr(hintNameOff) );
-
-		const char *hintName;
-		NV_ERR_CHECK_RETURN( s.readString(hintNameOff, hintName) );
-		Releaser releaseName((void *)hintName, mTraits);
-
-		//val
-		s.beginStruct(s.getTargetABI().getHintValueAlignment());
-		switch( hintType )
-		{
-		case TYPE_U64:
-			{
-				uint64_t val;
-				NV_ERR_CHECK_RETURN( s.read(val) );
-				hint->init(hintName, val, false);
-
-				break;
-			}
-		case TYPE_F64:
-			{
-				double val;
-				NV_ERR_CHECK_RETURN( s.read(val) );
-				hint->init(hintName, val, false);
-
-				break;
-			}
-		case TYPE_STRING:
-			{
-				uint32_t off;
-				NV_ERR_CHECK_RETURN( s.readPtr(off) );
-
-				const char *val;
-				NV_ERR_CHECK_RETURN( s.readString(off, val) );
-				Releaser releaseVal((void *)val, mTraits);
-
-				hint->init(hintName, val, false);
-
-				break;
-			}
-		default:
-			DEBUG_ALWAYS_ASSERT();
-			return Serializer::ERROR_INVALID_DATA_TYPE;
-		}
-		s.align(s.getTargetABI().getHintValueSize());
-		s.closeStruct();
-
-		s.closeStruct();
-
-		def->addHint(hint);
-	} //i
-
-	//numEnumVals
-	uint32_t numEnumVals;
-	NV_ERR_CHECK_RETURN( s.read(numEnumVals) );
-
-	//enumVals
-	for(uint32_t i = 0; i < numEnumVals; ++i)
-	{
-		uint32_t off;
-		NV_ERR_CHECK_RETURN( s.readPtr(off) );
-
-		const char *val;
-		NV_ERR_CHECK_RETURN( s.readString(off, val) );
-		Releaser releaseVal((void *)val, mTraits);
-
-		def->addEnumVal(val);
-	}
-
-	//numRefVariants
-	uint32_t numRefVariants;
-	NV_ERR_CHECK_RETURN( s.read(numRefVariants) );
-
-	//refVariants
-	for(uint32_t i = 0; i < numRefVariants; ++i)
-	{
-		uint32_t off;
-		NV_ERR_CHECK_RETURN( s.readPtr(off) );
-
-		const char *val;
-		NV_ERR_CHECK_RETURN( s.readString(off, val) );
-		Releaser releaseVal((void *)val, mTraits);
-
-		def->addRefVariantVal(val);
-	}
-
-	s.closeStruct();
-
-	return Serializer::ERROR_NONE;
-}
-
-Serializer::ErrorType BinSerializer::deserializeMetadata(physx::PxFileBuf &stream, DeserializedMetadata &desData)
-{
-	BinaryHeader hdr;
-	BinaryHeaderExt ext;
-	NV_ERR_CHECK_RETURN( peekFileHeader(stream, hdr, ext) );
-	NV_ERR_CHECK_RETURN(verifyFileHeader(
-		hdr,
-		hdr.version >= BinVersions::WithExtendedHeader ? &ext : 0,
-		hdr.fileLength
-	));
-
-	PlatformABI targetParams;
-	NV_ERR_CHECK_RETURN(getPlatformInfo(
-		hdr,
-		hdr.version >= BinVersions::WithExtendedHeader ? &ext : 0,
-		targetParams
-	));
-
-	PlatformInputStream s(stream, targetParams, mTraits);
-	s.skipBytes(hdr.metadataOffset);
-
-	uint32_t numMetadata = hdr.numMetadata;
-
-	desData.init(mTraits, numMetadata);
-
-	for(uint32_t i = 0; i < numMetadata; ++i)
-	{
-		uint32_t classNameOff;
-		NV_ERR_CHECK_RETURN( s.readPtr(classNameOff) );
-
-		const char *className;
-		NV_ERR_CHECK_RETURN( s.readString(classNameOff, className) );
-
-		uint32_t version;
-		NV_ERR_CHECK_RETURN( s.read(version) );
-
-		uint32_t entryOff;
-		NV_ERR_CHECK_RETURN( s.readPtr(entryOff) );
-
-		s.pushPos(entryOff);
-
-		DefinitionImpl *def = (DefinitionImpl *)mTraits->alloc(sizeof(DefinitionImpl));
-		NV_ERR_CHECK_WARN_RETURN( readMetadataInfo(hdr, s, def), "Failed to read metadata info" );
-
-//		DumpDefinition(def, className, version);
-
-		desData[i].def = def;
-		desData[i].version = version;
-		desData[i].className = className;
-
-		s.popPos();
-	}
-
-	return Serializer::ERROR_NONE;
-}
-
-Serializer::ErrorType BinSerializer::internalDeserialize(physx::PxFileBuf &stream, Serializer::DeserializedData &res, bool & /*doesNeedUpdate*/)
-{
-	NV_BOOL_ERR_CHECK_WARN_RETURN(
-		PlatformABI::VerifyCurrentPlatform(),
-		Serializer::ERROR_INVALID_PLATFORM,
-		"Current platform is not supported, aborting" );
-
-	NV_BOOL_ERR_CHECK_RETURN( BinaryHeader::CheckAlignment(), Serializer::ERROR_INVALID_PLATFORM );
-
-	BinaryHeader hdr;
-	BinaryHeaderExt ext;
-	NV_ERR_CHECK_RETURN( peekFileHeader(stream, hdr, ext) );
-
-	PlatformABI abi;
-	NV_ERR_CHECK_RETURN(getPlatformInfo(
-		hdr,
-		hdr.version >= BinVersions::WithExtendedHeader ? &ext : 0,
-		abi
-	));
-
-	uint32_t fileOff = stream.tellRead();
-
-	PlatformInputStream data(stream, abi, mTraits);
-	NV_ERR_CHECK_RETURN( data.skipBytes(hdr.dataOffset) );
-
-	res.init(mTraits, static_cast<uint32_t>(hdr.numObjects));
-	for(uint32_t i = 0; i < static_cast<uint32_t>(hdr.numObjects); ++i)
-	{
-		uint32_t objOff;
-		NV_ERR_CHECK_RETURN( data.readPtr(objOff) );
-
-		if( !objOff )
-			res[i] = 0;
-		else
-		{
-			NV_ERR_CHECK_RETURN( data.pushPos(objOff) );
-
-			Serializer::ErrorType error = readObject(res[i], data);
-			if( Serializer::ERROR_NONE != error )
-			{
-				for(uint32_t j = 0; j < i; ++j) //Last object was destroyed in readObject
-					res[j]->destroy();
-
-				res.init(0, 0);
-
-				return error;
-			}
-
-			data.popPos();
-		}
-
-		uint32_t tmp;
-		NV_ERR_CHECK_RETURN( data.readPtr(tmp) ); // className
-		NV_ERR_CHECK_RETURN( data.readPtr(tmp) ); // name
-		NV_ERR_CHECK_RETURN( data.readPtr(tmp) ); // filename
-	} //i
-
-	stream.seekRead(fileOff + hdr.fileLength); //Goto end of stream
-
-	return Serializer::ERROR_NONE;
-}
-
-static BinaryReloc *getRelocationTable(const BinaryHeader &hdr, char *start, uint32_t &nrelocs)
-{
-	char *ptrTable = start + hdr.relocOffset;
-	nrelocs = *reinterpret_cast<uint32_t *>(ptrTable);
-
-	ptrTable += PlatformABI::align(4, GetAlignment<BinaryReloc>::value);
-
-	return reinterpret_cast<BinaryReloc *>(ptrTable); //Alignment is ok
-}
-
-Serializer::ErrorType BinSerializer::internalDeserializeInplace(void *mdata, uint32_t dataLen, Serializer::DeserializedData &res, bool & doesNeedUpdate)
-{
-	doesNeedUpdate = false;
-
-	NV_BOOL_ERR_CHECK_WARN_RETURN(
-		PlatformABI::VerifyCurrentPlatform(),
-		Serializer::ERROR_INVALID_PLATFORM,
-		"Current platform is not supported, aborting" );
-
-	char *start = (char *)mdata;
-
-	//Header
-	BinaryHeader &hdr = *reinterpret_cast<BinaryHeader *>(start);
-	hdr.decanonize(); //Make platform-dependent
-
-	//Extended header
-	BinaryHeaderExt *ext = hdr.version >= BinVersions::WithExtendedHeader
-		? reinterpret_cast<BinaryHeaderExt *>(start + sizeof(BinaryHeader))
-		: 0;
-	if( ext ) ext->decanonize();
-
-	//This particular updates can be done on the fly
-	//Probably there is no need to set isUpdated because updates can be done on the fly
-
-	if( hdr.version == BinVersions::Initial )
-		NV_ERR_CHECK_WARN_RETURN( updateInitial2AllCounted(hdr, start), "Failed to update binary asset from 1.0 to 1.1" );
-
-	if( hdr.version == BinVersions::AllRefsCounted )
-		NV_ERR_CHECK_WARN_RETURN( updateAllCounted2WithAlignment(hdr, start), "Failed to update binary asset from 1.1 to 1.2" );
-
-	NV_ERR_CHECK_RETURN( verifyFileHeader(hdr, ext, dataLen) );
-
-	NV_BOOL_ERR_CHECK_RETURN( IsAligned(mdata, hdr.alignment), Serializer::ERROR_UNALIGNED_MEMORY);
-
-	//Verify platform
-	SerializePlatform filePlatform;
-	NV_ERR_CHECK_WARN_RETURN( hdr.getPlatform(filePlatform), "Unknown platform" );
-	NV_BOOL_ERR_CHECK_WARN_RETURN(
-		GetCurrentPlatform() == filePlatform,
-		Serializer::ERROR_INVALID_PLATFORM,
-		"Failed to inplace deserialize: platforms do not match" );
-
-	//Fix pointers
-
-	uint32_t nrelocs;
-	BinaryReloc *relocs = getRelocationTable(hdr, start, nrelocs);
-
-	//Using refOffs-array causes a memory allocation hence it's bad.
-	//But we have to fix all pointers prior to calling finishNvParameterized().
-	//Basically we have 3 opportunities:
-	//	- reorder relocs s.t. NvParameterized-objects go after all other relocs (strings, etc.)
-	//		(but this limits our binary file format + it turns out to be tricky to implement)
-	//	- walk through array once again
-	//		(but this may have a significant time penalty)
-	//	- reuse space in relocation table to store offsets of references
-	//		(this sounds nice and easy enough!)
-	//	- or maybe just process relocations in reverse order
-	//		(this one should be the fastest but once again this limits our format)
-	//For now we just keep the dynamic array as it seems to be pretty fast.
-
-	physx::shdfnd::Array<uint32_t, Traits::Allocator> refOffs((Traits::Allocator(mTraits)));
-	refOffs.reserve(nrelocs / 10);
-
-	for(uint32_t i = 0; i < nrelocs; ++i)
-	{
-		BinaryReloc &reloc = relocs[i];
-
-		NV_BOOL_ERR_CHECK_RETURN(
-			reloc.type < static_cast<uint32_t>(RELOC_LAST),
-			Serializer::ERROR_INVALID_RELOC_TYPE );
-
-		switch( reloc.type )
-		{
-		case uint32_t(RELOC_ABS_RAW):
-			//Raw data, do nothing
-			break;
-		case uint32_t(RELOC_ABS_REF):
-			//Reference, init later
-			refOffs.pushBack(reloc.off);
-			break;
-		default:
-			DEBUG_ALWAYS_ASSERT();
-			return Serializer::ERROR_INVALID_INTERNAL_PTR;
-		}
-
-		char *&ptr = *reinterpret_cast<char **>(start + reloc.off);
-
-		size_t off = reinterpret_cast<size_t>(ptr); //size_t == uintptr_t
-		NV_BOOL_ERR_CHECK_RETURN( off < dataLen, Serializer::ERROR_INVALID_INTERNAL_PTR );
-
-		ptr = start + off;
-	}
-
-	uint32_t *refCount = reinterpret_cast<uint32_t*>(&hdr.numObjects);
-
-	//Init references (vtables and stuff)
-	for(uint32_t i = 0; i < refOffs.size(); ++i)
-	{
-		char *&p = *reinterpret_cast<char **>(start + refOffs[i]);
-
-		const ObjHeader &objHdr = *reinterpret_cast<const ObjHeader *>(p);
-
-		const char *className = objHdr.className;
-		NV_BOOL_ERR_CHECK_RETURN( className, Serializer::ERROR_INVALID_INTERNAL_PTR );
-
-		p += objHdr.dataOffset;
-
-		if( !objHdr.isIncluded )
-		{
-			Interface *obj = PX_PLACEMENT_NEW(p, NvParameters)(mTraits, start, reinterpret_cast<int32_t*>(refCount));
-			PX_UNUSED(obj);
-
-			//We do not want objHdr.verify() here
-		}
-		else
-		{
-			Interface *obj = mTraits->finishNvParameterized(className, objHdr.version, p, start, reinterpret_cast<int32_t*>(refCount));
-			NV_BOOL_ERR_CHECK_RETURN( obj, Serializer::ERROR_OBJECT_CREATION_FAILED );
-			NV_ERR_CHECK_RETURN( verifyObjectHeader(objHdr, obj, mTraits) );
-
-			if( objHdr.version != mTraits->getCurrentVersion(className) )
-				doesNeedUpdate = true;
-		} //if( !objHdr.isIncluded )
-	} //i
-
-	// Table of root references
-	ObjectTableEntry *objectTable = reinterpret_cast<ObjectTableEntry *>(start + hdr.dataOffset); //At start of data section
-
-	//Init results
-	res.init(mTraits, static_cast<uint32_t>(hdr.numObjects));
-	for(uint32_t i = 0; i < static_cast<uint32_t>(hdr.numObjects); ++i)
-		res[i] = objectTable[i].obj;
-
-	*refCount = refOffs.size(); //Release after all inplace references are destroyed
-
-	// Conversion will be done after deserialization to avoid releasing inplace memory if all objects are destroyed
-	//(otherwise we may have data corruption)
-
-	return Serializer::ERROR_NONE;
-}
-
-Serializer::ErrorType BinSerializer::updateAllCounted2WithAlignment(BinaryHeader &hdr, char * /*start*/)
-{
-	hdr.version = BinVersions::WithAlignment;
-	hdr.alignment = 8;
-	return Serializer::ERROR_NONE;
-}
-
-Serializer::ErrorType BinSerializer::updateInitial2AllCounted(BinaryHeader &hdr, char *start)
-{
-	// versionAllRefsCounted counts all references instead of just top-level references;
-	// to achieve this we simply set mDoDeallocateSelf to true in all references
-
-	uint32_t nrelocs;
-	BinaryReloc *relocs = getRelocationTable(hdr, start, nrelocs);
-
-	for(uint32_t i = 0; i < nrelocs; ++i)
-	{
-		BinaryReloc &reloc = relocs[i];
-
-		if( reloc.type != static_cast<uint32_t>(RELOC_ABS_REF) )
-			continue;
-
-		size_t targetOff = *reinterpret_cast<size_t *>(start + reloc.off); //size_t == uintptr_t
-
-		const ObjHeader &objHdr = *reinterpret_cast<const ObjHeader *>(start + targetOff);
-
-		targetOff += objHdr.dataOffset; //Points to start of NvParameters
-
-#if PX_PS4 == 1
-#pragma GCC diagnostic ignored "-Wunused-private-field"
-#endif
-		// MyNvParameters has the same layout as NvParameters
-		class MyNvParameters
-		{
-			void *vtable;
-			void *mParameterizedTraits;
-			void *mSerializationCb;
-			void *mCbUserData;
-			void *mBuffer;
-			void *mRefCount;
-			void *mName;
-			void *mClassName;
-			bool mDoDeallocateSelf;
-			bool mDoDeallocateName;
-			bool mDoDeallocateClassName;
-
-		public:
-			void setDoDeallocateSelf() { mDoDeallocateSelf = true; }
-		};
-#if PX_PS4 == 1
-#pragma GCC diagnostic warning "-Wunused-private-field"
-#endif
-		MyNvParameters *pAsNvParameters = reinterpret_cast<MyNvParameters *>(start + targetOff);
-		pAsNvParameters->setDoDeallocateSelf();
-	}
-
-	hdr.version = BinVersions::AllRefsCounted;
-
-	return Serializer::ERROR_NONE;
-}
-
-Serializer::ErrorType BinSerializer::readArraySlow(Handle &handle, PlatformInputStream &s)
-{
-	int32_t n;
-	NV_PARAM_ERR_CHECK_RETURN( handle.getArraySize(n), Serializer::ERROR_INVALID_ARRAY );
-
-	for(int32_t i = 0; i < n; ++i)
-	{
-		handle.set(i);
-		NV_ERR_CHECK_RETURN( readBinaryData(handle, s) );
-		handle.popIndex();
-	}
-
-	return Serializer::ERROR_NONE;
-}
-
-static bool IsSimpleStruct(const Definition *pd)
-{
-	// Empty structs are special
-	if( 0 == pd->numChildren() )
-		return false;
-
-	for(int32_t i = 0; i < pd->numChildren(); ++i)
-	{
-		if (pd->child(i)->type() == TYPE_STRING || pd->child(i)->type() == TYPE_ENUM || pd->child(i)->type() == TYPE_ARRAY || 
-			pd->child(i)->type() == TYPE_REF    || pd->child(i)->type() == TYPE_STRUCT
-			)
-		{
-			return false;
-		}
-	}
-
-	return true;
-}
-
-#ifndef WITHOUT_APEX_SERIALIZATION
-
-Serializer::ErrorType BinSerializer::internalSerialize(physx::PxFileBuf &stream, const Interface **objs, uint32_t nobjs, bool doMetadata)
-{
-	NV_BOOL_ERR_CHECK_WARN_RETURN(
-		PlatformABI::VerifyCurrentPlatform(),
-		Serializer::ERROR_INVALID_PLATFORM ,
-		"Current platform is not supported, aborting" );
-
-	NV_BOOL_ERR_CHECK_RETURN( BinaryHeader::CheckAlignment(), Serializer::ERROR_INVALID_PLATFORM );
-
-	PlatformABI targetParams;
-	NV_ERR_CHECK_WARN_RETURN( PlatformABI::GetPredefinedABI(mPlatform, targetParams), "Unknown platform" );
-	NV_BOOL_ERR_CHECK_WARN_RETURN(
-		targetParams.isNormal(),
-		Serializer::ERROR_INVALID_PLATFORM,
-		"Target platform is not supported, aborting" );
-
-	PlatformABI curParams;
-	NV_ERR_CHECK_WARN_RETURN( PlatformABI::GetPredefinedABI(GetCurrentPlatform(), curParams), "Unknown platform" );
-	NV_BOOL_ERR_CHECK_RETURN( curParams.isNormal(), Serializer::ERROR_INVALID_PLATFORM );
-
-	Dictionary dict(mTraits); //Dictionary is updated in other routines
-
-	// Compute object data
-
-	typedef physx::shdfnd::Array<PlatformOutputStream, Traits::Allocator> StreamArray;
-	StreamArray dataStreams((Traits::Allocator(mTraits)));
-	dataStreams.reserve(nobjs);
-	for(uint32_t i = 0; i < nobjs; ++i)
-	{
-		Handle handle(*objs[i], "");
-		NV_BOOL_ERR_CHECK_RETURN( handle.isValid(), Serializer::ERROR_UNKNOWN );
-
-		dataStreams.pushBack(PlatformOutputStream(targetParams, mTraits, dict));
-		dataStreams.back().setAlignment(16); // 16 for safety
-
-		NV_ERR_CHECK_WARN_RETURN( storeBinaryData(*objs[i], handle, dataStreams.back()), "Failed to serialize data for object %d", i );
-	}
-
-	// Compute metadata
-
-	PlatformOutputStream metadataStream(targetParams, mTraits, dict);
-	metadataStream.setAlignment(16); // 16 for safety
-	uint32_t numMetadata = 0;
-	if( doMetadata )
-	{
-		typedef physx::shdfnd::Pair<const char *, uint32_t> VersionedClass;
-		typedef physx::shdfnd::HashMap<VersionedClass, const Definition *, physx::shdfnd::Hash<VersionedClass>, Traits::Allocator> MapClass2Def;
-		MapClass2Def mapClass2Def((Traits::Allocator(mTraits)));
-
-		//We track all classes that were saved to avoid duplicate metadata info
-		class MyRefCallback: public ReferenceInterface
-		{
-			MapClass2Def &mapClass2Def;
-
-			//Silence warnings on unable to generate assignment operator
-			void operator =(MyRefCallback) {}
-		public:
-			MyRefCallback(MapClass2Def &mapClass2Def_): mapClass2Def(mapClass2Def_) {}
-
-			void referenceCallback(Handle &handle)
-			{
-				Interface *iface;
-				handle.getParamRef(iface);
-				if( iface )
-					mapClass2Def[ VersionedClass(iface->className(), iface->version()) ] = iface->rootParameterDefinition();
-			}
-		} cb(mapClass2Def);
-
-		for(uint32_t i = 0; i < nobjs; ++i)
-		{
-			if( !objs[i] )
-				continue;
-
-			mapClass2Def[ VersionedClass(objs[i]->className(), objs[i]->version()) ] = objs[i]->rootParameterDefinition();
-			getReferences(*objs[i], cb, false, true, true);
-		}
-
-		numMetadata = mapClass2Def.size();
-
-		for(MapClass2Def::Iterator i = mapClass2Def.getIterator(); !i.done(); ++i)
-		{
-			metadataStream.beginStruct(targetParams.getMetaEntryAlignment());
-
-			metadataStream.storeStringPtr(i->first.first); //className
-			metadataStream.storeSimple<uint32_t>(i->first.second); //classVersion
-
-			//info
-			Reloc &reloc = metadataStream.storePtr(RELOC_ABS_RAW, targetParams.getMetaInfoAlignment());
-			NV_ERR_CHECK_RETURN( storeMetadataInfo(i->second, *reloc.ptrData) );
-
-			metadataStream.closeStruct();
-		} //i
-	}
-
-	// Init header
-
-	BinaryHeader hdr;
-
-	hdr.magic = Magic;
-	hdr.type = BINARY_TYPE_PLAIN;
-	hdr.version = Version;
-	hdr.numObjects = static_cast<int32_t>(nobjs);
-	hdr.fileLength = 0;
-	hdr.dictOffset = 0;
-	hdr.dataOffset = 0;
-	hdr.relocOffset = 0;
-	hdr.metadataOffset = 0;
-
-	hdr.archType = static_cast<uint32_t>(mPlatform.archType);
-	hdr.compilerType = static_cast<uint32_t>(mPlatform.compilerType);
-	hdr.compilerVer = mPlatform.compilerVer;
-	hdr.osType = static_cast<uint32_t>(mPlatform.osType);
-	hdr.osVer = mPlatform.osVer;
-
-	hdr.numMetadata = numMetadata;
-	hdr.alignment = 0;
-
-	BinaryHeaderExt ext;
-	memset(&ext, 0, sizeof(ext));
-	memcpy(&ext.vcsSafetyFlags, VCS_SAFETY_FLAGS, 4);
-
-	// Resulting stream
-
-	PlatformOutputStream joinStream(targetParams, mTraits, dict);
-
-	// Merge header
-
-	joinStream.storeBytes(reinterpret_cast<const char *>(&hdr), sizeof(hdr));
-	joinStream.storeBytes(reinterpret_cast<const char *>(&ext), sizeof(ext));
-	joinStream.align(16);
-
-	// Merge dictionary
-
-	uint32_t dictOffset = joinStream.size();
-	joinStream.mergeDict();
-
-	// Merge data
-
-	uint32_t dataOffset = 0;
-	{
-		joinStream.align(joinStream.getTargetABI().aligns.pointer);
-		dataOffset = joinStream.size();
-
-		//Create object table
-		for(uint32_t i = 0; i < nobjs; ++i)
-		{
-			dataStreams[i].flatten();
-
-			Reloc &reloc = joinStream.storePtr(RELOC_ABS_REF, dataStreams[i].alignment());
-			reloc.ptrData->merge(dataStreams[i]);
-
-			//This was requested for faster peeking of contained assets
-			joinStream.storeStringPtr(objs[i]->className());
-			joinStream.storeStringPtr(objs[i]->name());
-
-			//UE3 was once using this
-			joinStream.storeNullPtr();
-		}
-
-		joinStream.flatten(); //Merge all data-related pointers
-	}
-
-	// Merge metadata
-
-	uint32_t metadataOffset = 0;
-	if( doMetadata )
-	{
-		metadataOffset = joinStream.merge(metadataStream);
-		joinStream.flatten(); //Merge all metadata-related pointers
-	}
-
-	// Merge relocation data
-
-	uint32_t relocOffset = joinStream.writeRelocs();
-
-	// Update offsets in header
-
-	void *data = joinStream.getData();
-
-	BinaryHeader &hdrFinal = *reinterpret_cast<BinaryHeader *>(data);
-	hdrFinal.fileLength = joinStream.size();
-	hdrFinal.dictOffset = dictOffset;
-	hdrFinal.dataOffset = dataOffset;
-	hdrFinal.metadataOffset = metadataOffset;
-	hdrFinal.relocOffset = relocOffset;
-	hdrFinal.alignment = joinStream.alignment();
-
-	BinaryHeaderExt &extFinal = *reinterpret_cast<BinaryHeaderExt *>((char *)data + sizeof(BinaryHeader));
-
-	//Make platform-independent
-	hdrFinal.canonize();
-	extFinal.canonize();
-
-	// Write data to stream
-
-	if( stream.tellWrite() % joinStream.alignment() )
-	{
-		NV_PARAM_TRAITS_WARNING(
-			mTraits,
-			"Input stream is unaligned, "
-				"you will not be able to inplace deserialize it "
-				"without copying to intermediate buffer"
-		);
-	}
-
-	NV_BOOL_ERR_CHECK_RETURN(
-		joinStream.size() == stream.write(data, joinStream.size()),
-		Serializer::ERROR_STREAM_ERROR );
-
-	return Serializer::ERROR_NONE;
-}
-
-Serializer::ErrorType BinSerializer::storeMetadataInfo(const Definition *def, PlatformOutputStream &s)
-{
-	s.beginStruct(s.getTargetABI().getMetaInfoAlignment());
-
-	//type
-	s.storeSimple((uint32_t)def->type());
-
-	//arraySize
-	s.storeSimple(TYPE_ARRAY == def->type() ? (int32_t)def->arraySize() : -1);
-
-	//shortName
-	s.storeStringPtr(def->name());
-
-	//structName
-	s.storeStringPtr(def->structName());
-
-	//alignment
-	s.storeSimple(def->alignment());
-
-	//padding
-	s.storeSimple(def->padding());
-
-	//numChildren
-	s.storeSimple(def->numChildren());
-
-	//children
-	for(int32_t i = 0; i < def->numChildren(); ++i)
-	{
-		Reloc &childrenReloc = s.storePtr(RELOC_ABS_RAW, s.getTargetABI().getMetaInfoAlignment());
-		NV_ERR_CHECK_RETURN( storeMetadataInfo(def->child(i), *childrenReloc.ptrData) );
-	}
-
-	//numHints
-	s.storeSimple(def->numHints());
-
-	//hints
-	for(int32_t i = 0; i < def->numHints(); ++i)
-	{
-		const Hint *hint = def->hint(i);
-
-		s.beginStruct(s.getTargetABI().getHintAlignment());
-
-		s.storeSimple((uint32_t)hint->type());
-		s.storeStringPtr(hint->name());
-
-		s.beginStruct(s.getTargetABI().getHintValueAlignment());
-		switch( hint->type() )
-		{
-		case TYPE_U64:
-			s.storeSimple(hint->asUInt());
-			break;
-		case TYPE_F64:
-			s.storeSimple(hint->asFloat());
-			break;
-		case TYPE_STRING:
-			s.storeStringPtr(hint->asString());
-			break;
-
-NV_PARAMETRIZED_LINAL_DATATYPE_LABELS
-NV_PARAMETRIZED_REF_DATATYPE_LABELS
-NV_PARAMETRIZED_ENUM_DATATYPE_LABELS
-NV_PARAMETRIZED_SERVICE_DATATYPE_LABELS
-NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS
-NV_PARAMETRIZED_AGGREGATE_DATATYPE_LABELS
-		case TYPE_F32:
-		case TYPE_U32: case TYPE_U16: case TYPE_U8:
-		case TYPE_I64: case TYPE_I32: case TYPE_I16: case TYPE_I8: case TYPE_BOOL:
-		default:
-			DEBUG_ALWAYS_ASSERT();
-			return Serializer::ERROR_INVALID_DATA_TYPE;
-		}
-		s.align(s.getTargetABI().getHintValueSize());
-		s.closeStruct();
-
-		s.closeStruct();
-	}
-
-	//numEnumVals
-	s.storeSimple(def->numEnumVals());
-
-	//enumVals
-	for(int32_t i = 0; i < def->numEnumVals(); ++i)
-		s.storeStringPtr(def->enumVal(i));
-
-	//numRefVariantVals
-	s.storeSimple(def->numRefVariants());
-
-	//refVariants
-	for(int32_t i = 0; i < def->numRefVariants(); ++i)
-		s.storeStringPtr(def->refVariantVal(i));
-
-	s.closeStruct();
-
-	return Serializer::ERROR_NONE;
-}
-
-//Store array of arbitrary type (slow version)
-Serializer::ErrorType BinSerializer::storeArraySlow(Handle &handle, PlatformOutputStream &s)
-{
-	int32_t size;
-	NV_PARAM_ERR_CHECK_RETURN( handle.getArraySize(size), Serializer::ERROR_INVALID_ARRAY );
-
-	const Interface &obj = *handle.getConstInterface();
-	for(int32_t i = 0; i < size; ++i)
-	{
-		handle.set(i);
-		NV_ERR_CHECK_RETURN( storeBinaryData(obj, handle, s) );
-		handle.popIndex();
-	}
-
-	return Serializer::ERROR_NONE;
-}
-
-//Print binary data for part of NvParameterized object addressed by handle
-Serializer::ErrorType BinSerializer::storeBinaryData(const Interface &obj, Handle &handle, PlatformOutputStream &res, bool isRootObject)
-{
-	bool isObject = !handle.numIndexes();
-
-	if( isObject )
-		res.storeObjHeader(obj);
-
-	const Definition *pd = handle.parameterDefinition();
-
-	bool doNotSerialize = 0 != pd->hint("DONOTSERIALIZE"),
-		isDynamicArray = pd->type() == TYPE_ARRAY && !pd->arraySizeIsFixed();
-
-	// Alignment in dynamic array means alignment of dynamic memory
-	// so we do not insert it here
-	if( pd->alignment() && !isDynamicArray )
-		res.align(pd->alignment());
-
-	//Dynamic arrays are special because we need some of their fields for correct inplace deserialization
-	if( doNotSerialize && !isDynamicArray )
-	{
-		//Simply skip bytes
-		res.align(res.getTargetAlignment(pd));
-		res.skipBytes(res.getTargetSize(pd));
-
-		return Serializer::ERROR_NONE;
-	}
-
-	switch( pd->type() )
-	{
-	case TYPE_ARRAY:
-		{
-			if( pd->arraySizeIsFixed() )
-			{
-				res.beginArray(pd);
-				storeArraySlow(handle, res);
-				res.closeArray();
-			}
-			else
-			{
-				res.beginStruct(pd); //Dynamic arrays are implemented as structs
-
-				bool isEmpty = false;
-				if( doNotSerialize )
-					isEmpty = true;
-				else
-				{
-					for(int32_t i = 0; i < pd->arrayDimension(); ++i)
-					{
-						int32_t size = 0;
-						NV_PARAM_ERR_CHECK_RETURN( handle.getArraySize(size, i), Serializer::ERROR_INVALID_ARRAY );
-
-						if( 0 == size )
-						{
-							isEmpty = true;
-							break;
-						}
-					}
-				}
-
-				const Definition *elemPd = pd;
-				for(int32_t i = 0; i < pd->arrayDimension(); ++i)
-					elemPd = elemPd->child(0);
-
-				//Pointer-to-data
-				Reloc *reloc = 0;
-				if( isEmpty )
-					res.storeNullPtr();
-				else
-				{
-					reloc = &res.storePtr(RELOC_ABS_RAW, elemPd);
-					if( pd->alignment() )
-						reloc->ptrData->setAlignment(physx::PxMax(reloc->ptrData->alignment(), pd->alignment()));
-				}
-
-				//isAllocated
-				res.storeSimple(false);
-
-				//elementSize
-				res.storeSimple<uint32_t>(res.getTargetSize(elemPd));
-
-				//arraySizes
-				const Definition *subArrayPd = pd;
-				res.beginArray(res.getTargetABI().getAlignment<int32_t>());
-				for(int32_t dim = 0; dim < pd->arrayDimension(); ++dim)
-				{
-					// Store size of static dimensions even if doNotSerialize is on
-					int32_t size = 0;
-					if( !doNotSerialize || subArrayPd->arraySizeIsFixed() )
-						NV_PARAM_ERR_CHECK_RETURN( handle.getArraySize(size, dim), Serializer::ERROR_INVALID_ARRAY );
-
-					res.storeSimple(size);
-
-					NV_BOOL_ERR_CHECK_RETURN( 1 == subArrayPd->numChildren(), Serializer::ERROR_UNKNOWN );
-					subArrayPd = subArrayPd->child(0);
-				}
-				res.closeArray();
-
-				//Data
-				if( !isEmpty )
-				{
-					reloc->ptrData->beginArray(elemPd);
-
-					int32_t size = -1;
-					NV_PARAM_ERR_CHECK_RETURN( handle.getArraySize(size), Serializer::ERROR_INVALID_ARRAY );
-
-					const Definition *child = pd->child(0);
-					switch( child->type() )
-					{
-#					define NV_PARAMETERIZED_TYPES_NO_LEGACY_TYPES
-#					define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES
-#					define NV_PARAMETERIZED_TYPES_NO_STRING_TYPES
-#					define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \
-					case TYPE_##enum_name: \
-					{ \
-						reloc->ptrData->storeSimpleArray<c_type>(handle); \
-						break; \
-					}
-#					include "nvparameterized/NvParameterized_types.h"
-
-					case TYPE_STRUCT:
-						if( IsSimpleStruct(child) )
-						{
-							//Fast path for simple structs
-							reloc->ptrData->storeSimpleStructArray(handle);
-							break;
-						}
-
-					//Else fall through to default, includes TYPE_MAT34 case
-NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS
-NV_PARAMETRIZED_LEGACY_DATATYPE_LABELS
-NV_PARAMETRIZED_STRING_DATATYPE_LABELS
-NV_PARAMETRIZED_REF_DATATYPE_LABELS
-NV_PARAMETRIZED_ENUM_DATATYPE_LABELS
-NV_PARAMETRIZED_SERVICE_DATATYPE_LABELS
-					case TYPE_ARRAY:
-					default:
-						storeArraySlow(handle, *reloc->ptrData);
-						break;
-					}
-
-					reloc->ptrData->closeArray();
-				}
-
-				res.closeStruct();
-			}
-			break;
-		}
-
-	case TYPE_STRUCT:
-		{
-			uint32_t oldSize = isObject ? res.beginObject(obj, isRootObject, pd) : res.beginStruct(pd);
-
-			for(int32_t i = 0; i < pd->numChildren(); ++i)
-			{
-				handle.set(i);
-				NV_ERR_CHECK_RETURN( storeBinaryData(obj, handle, res) );
-				handle.popIndex();
-			}
-
-			//Empty structs are at least 1 char long
-			if( res.size() == oldSize )
-				res.storeSimple((uint8_t)0);
-
-			if( isObject )
-				res.closeObject();
-			else
-				res.closeStruct();
-
-			break;
-		}
-
-	case TYPE_STRING:
-		{
-			const char *s = 0;
-			handle.getParamString(s);
-
-			res.beginString();
-
-			//buf
-			res.storeStringPtr(s);
-
-			//isAllocated
-			res.storeSimple(false);
-
-			res.closeString();
-
-			break;
-		}
-
-	case TYPE_ENUM:
-		{
-			const char *s = 0;
-			handle.getParamEnum(s);
-
-			res.storeStringPtr(s);
-
-			break;
-		}
-
-	case TYPE_REF:
-		{
-			Interface *refObj = 0;
-			handle.getParamRef(refObj);
-
-			if( !refObj )
-				res.storeNullPtr();
-			else if( pd->isIncludedRef() )
-			{
-				Handle refHandle(*refObj, "");
-				NV_BOOL_ERR_CHECK_RETURN( refHandle.isValid(), Serializer::ERROR_UNKNOWN );
-
-				Reloc &reloc = res.storePtr(RELOC_ABS_REF, 16); //16 for safety
-				NV_ERR_CHECK_RETURN( storeBinaryData(*refObj, refHandle, *reloc.ptrData, false) );
-			}
-			else //Named reference
-			{
-				Reloc &reloc = res.storePtr(RELOC_ABS_REF, 16); //16 for safety
-				reloc.ptrData->storeObjHeader(*refObj, false);
-				reloc.ptrData->beginObject(*refObj, false, 0);
-				reloc.ptrData->closeObject(); //Named references are instances of NvParameters => no additional fields
-			}
-
-			break;
-		}
-
-	case TYPE_POINTER:
-		{
-			res.storeNullPtr();
-			break;
-		}
-
-
-#	define NV_PARAMETERIZED_TYPES_NO_LEGACY_TYPES
-#	define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES
-#	define NV_PARAMETERIZED_TYPES_NO_STRING_TYPES
-#	define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \
-	case TYPE_##enum_name: \
-	{ \
-		c_type val; \
-		NV_PARAM_ERR_CHECK_RETURN( handle.getParam##type_name(val), Serializer::ERROR_INVALID_VALUE ); \
-		res.storeSimple<c_type>(val); \
-		break; \
-	}
-#	include "nvparameterized/NvParameterized_types.h"
-
-	case TYPE_MAT34:
-	{
-		float val[12];
-		NV_PARAM_ERR_CHECK_RETURN( handle.getParamMat34Legacy(val), Serializer::ERROR_INVALID_VALUE );
-		res.storeSimple(val, 12);
-		break;
-	}
-
-NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS
-	default:
-		DEBUG_ASSERT(0 && "Unknown type");
-		return Serializer::ERROR_INVALID_DATA_TYPE;
-	}
-
-	return Serializer::ERROR_NONE;
-}
-
-#endif
-
-//Read NvParameterized object data
-Serializer::ErrorType BinSerializer::readObject(Interface *&obj, PlatformInputStream &data)
-{
-	ObjHeader objHdr;
-	NV_ERR_CHECK_WARN_RETURN( data.readObjHeader(objHdr), "Failed to deserialize object header" );
-	Releaser releaseClassName((void *)objHdr.className, mTraits),
-		releaseName((void *)objHdr.name, mTraits),
-		releaseChecksum((void *)objHdr.checksum, mTraits);
-
-	if( !objHdr.isIncluded )
-	{
-		void *buf = mTraits->alloc(sizeof(NvParameters));
-		NV_BOOL_ERR_CHECK_RETURN( buf, Serializer::ERROR_MEMORY_ALLOCATION_FAILURE );
-
-		obj = PX_PLACEMENT_NEW(buf, NvParameters)(mTraits);
-		obj->setClassName(objHdr.className);
-
-		if( objHdr.name )
-			obj->setName(objHdr.name);
-
-		//We do not want objHdr.verify() here
-	}
-	else
-	{
-		NV_BOOL_ERR_CHECK_RETURN( objHdr.className, Serializer::ERROR_OBJECT_CREATION_FAILED );
-
-		obj = mTraits->createNvParameterized(objHdr.className, objHdr.version);
-		NV_BOOL_ERR_CHECK_RETURN( obj, Serializer::ERROR_OBJECT_CREATION_FAILED );
-
-		if( objHdr.name )
-			obj->setName(objHdr.name);
-
-		NV_ERR_CHECK_RETURN( verifyObjectHeader(objHdr, obj, mTraits) );
-
-		Handle handle(*obj, "");
-		NV_BOOL_ERR_CHECK_RETURN( handle.isValid(), Serializer::ERROR_UNKNOWN );
-
-		NV_ERR_CHECK_RETURN( data.pushPos(objHdr.dataOffset) );
-		NV_ERR_CHECK_RETURN( readBinaryData(handle, data) );
-		data.popPos();
-	}
-
-	return Serializer::ERROR_NONE;
-}
-
-//Read binary data of NvParameterized object addressed by handle
-Serializer::ErrorType BinSerializer::readBinaryData(Handle &handle, PlatformInputStream &data)
-{
-	const Definition *pd = handle.parameterDefinition();
-
-	bool isDynamicArray = TYPE_ARRAY == pd->type() && !pd->arraySizeIsFixed();
-
-	// See comment in storeBinaryData
-	if( pd->alignment() && !isDynamicArray )
-		data.align(pd->alignment());
-
-	if( pd->hint("DONOTSERIALIZE") )
-	{
-		//Simply skip DONOTSERIALIZE
-		data.align(data.getTargetAlignment(pd));
-		NV_ERR_CHECK_RETURN( data.skipBytes(data.getTargetSize(pd)) );
-		return Serializer::ERROR_NONE;
-	}
-
-	switch( pd->type() )
-	{
-	case TYPE_ARRAY:
-		{
-			if( pd->arraySizeIsFixed() )
-			{
-				data.beginArray(pd);
-				for(int32_t i = 0; i < pd->arraySize(); ++i)
-				{
-					handle.set(i);
-					NV_ERR_CHECK_RETURN( readBinaryData(handle, data) );
-					handle.popIndex();
-				}
-				data.closeArray();
-			}
-			else
-			{
-				data.beginStruct(pd); //Dynamic arrays are implemented as structs
-
-				uint32_t elemOff;
-				NV_ERR_CHECK_RETURN( data.readPtr(elemOff) );
-
-				bool isAllocated;
-				NV_ERR_CHECK_RETURN( data.read(isAllocated) );
-
-				int32_t elementSize;
-				NV_ERR_CHECK_RETURN( data.read(elementSize) ); //elementSize
-
-				data.beginStruct(data.getTargetABI().aligns.i32); //Start array of sizes
-
-				int32_t arraySize;
-				NV_ERR_CHECK_RETURN( data.read(arraySize) ); //We need only the first size
-
-				const Definition *subArrayPd = pd->child(0);
-				for(int32_t dim = 1; dim < pd->arrayDimension(); ++dim)
-				{
-					int32_t size;
-					NV_ERR_CHECK_RETURN( data.read(size) );
-
-					// We do not support nested dynamic arrays
-					if( subArrayPd->arraySizeIsFixed() )
-						NV_BOOL_ERR_CHECK_RETURN( size == subArrayPd->arraySize(), Serializer::ERROR_INVALID_ARRAY );
-
-					subArrayPd = subArrayPd->child(0);
-				}
-				data.closeStruct(); //End array of sizes
-
-				NV_PARAM_ERR_CHECK_RETURN( handle.resizeArray(arraySize), Serializer::ERROR_INVALID_ARRAY );
-
-				if( elemOff )
-				{
-					// Check alignment
-					uint32_t align = pd->alignment();
-					if( align && elemOff % align ) {
-						char longName[256];
-						handle.getLongName(longName, sizeof(longName));
-						NV_PARAM_TRAITS_WARNING(
-							mTraits,
-							"%s: array is unaligned, "
-								"you will not be able to inplace deserialize it "
-								"without copying to intermediate buffer.",
-							longName
-						);
-					}
-
-					NV_ERR_CHECK_RETURN( data.pushPos(elemOff) );
-
-					switch( pd->child(0)->type() )
-					{
-#					define NV_PARAMETERIZED_TYPES_NO_LEGACY_TYPES
-#					define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES
-#					define NV_PARAMETERIZED_TYPES_NO_STRING_TYPES
-#					define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \
-					case TYPE_##enum_name: \
-					{ \
-						NV_ERR_CHECK_RETURN( data.readSimpleArray<c_type>(handle) ); \
-						break; \
-					}
-#					include "nvparameterized/NvParameterized_types.h"
-
-					case TYPE_STRUCT:
-						{
-							const Definition *child = pd->child(0);
-							if( IsSimpleStruct(child) )
-							{
-								//Fast path for simple structs
-								NV_ERR_CHECK_RETURN( data.readSimpleStructArray(handle) );
-								break;
-							}
-
-							//Else fall through to default, including TYPE_MAT34 case
-						}
-
-NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS
-NV_PARAMETRIZED_LEGACY_DATATYPE_LABELS
-NV_PARAMETRIZED_STRING_DATATYPE_LABELS
-NV_PARAMETRIZED_REF_DATATYPE_LABELS
-NV_PARAMETRIZED_ENUM_DATATYPE_LABELS
-NV_PARAMETRIZED_SERVICE_DATATYPE_LABELS
-case TYPE_ARRAY:
-					default:
-						NV_ERR_CHECK_RETURN( readArraySlow(handle, data) );
-						break;
-					}
-
-					data.popPos();
-				}
-
-				data.closeStruct();
-			}
-			break;
-		}
-
-	case TYPE_STRUCT:
-		{
-			uint32_t oldPos = data.getPos();
-
-			data.beginStruct(pd);
-			for(int32_t i = 0; i < pd->numChildren(); ++i)
-			{
-				handle.set(i);
-				NV_ERR_CHECK_RETURN( readBinaryData(handle, data) );
-				handle.popIndex();
-			}
-
-			//Empty structs are at least 1 char long
-			if( data.getPos() == oldPos )
-			{
-				uint8_t tmp;
-				NV_ERR_CHECK_RETURN( data.read(tmp) );
-			}
-
-			data.closeStruct();
-
-			break;
-		}
-
-	case TYPE_STRING:
-		{
-			data.beginString();
-
-			uint32_t off;
-			NV_ERR_CHECK_RETURN( data.readPtr(off) );
-
-			const char *s;
-			NV_ERR_CHECK_RETURN( data.readString(off, s) );
-
-			NV_PARAM_ERR_CHECK_RETURN( handle.setParamString(s), Serializer::ERROR_INVALID_VALUE );
-			mTraits->free((char *)s);
-
-			bool isAllocated;
-			NV_ERR_CHECK_RETURN( data.read(isAllocated) );
-
-			data.closeString();
-
-			break;
-		}
-
-	case TYPE_ENUM:
-		{
-			uint32_t off;
-			NV_ERR_CHECK_RETURN( data.readPtr(off) );
-
-			const char *s;
-			NV_ERR_CHECK_RETURN( data.readString(off, s) );
-
-			NV_BOOL_ERR_CHECK_RETURN( s, Serializer::ERROR_INVALID_VALUE );
-			NV_PARAM_ERR_CHECK_RETURN( handle.setParamEnum(s), Serializer::ERROR_INVALID_VALUE );
-
-			mTraits->free((char *)s);
-
-			break;
-		}
-
-	case TYPE_REF:
-		{
-			uint32_t objPos;
-			NV_ERR_CHECK_RETURN( data.readPtr(objPos) );
-
-			Interface *refObj = 0;
-
-			if( objPos )
-			{
-				NV_ERR_CHECK_RETURN( data.pushPos(objPos) );
-				NV_ERR_CHECK_RETURN( readObject(refObj, data) );
-				data.popPos();
-			}
-
-			if( refObj && (-1 == handle.parameterDefinition()->refVariantValIndex(refObj->className())) )
-			{
-				char longName[256];
-				handle.getLongName(longName, sizeof(longName));
-				NV_PARAM_TRAITS_WARNING(
-					mTraits,
-					"%s: setting reference of invalid class %s",
-					longName,
-					refObj->className()
-				);
-			}
-
-			NV_PARAM_ERR_CHECK_RETURN( handle.setParamRef(refObj), Serializer::ERROR_INVALID_REFERENCE );
-
-			break;
-		}
-
-	case TYPE_POINTER:
-		{
-			void *tmp;
-			NV_ERR_CHECK_RETURN( data.read(tmp) );
-			break;
-		}
-
-
-#	define NV_PARAMETERIZED_TYPES_NO_LEGACY_TYPES
-#	define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES
-#	define NV_PARAMETERIZED_TYPES_NO_STRING_TYPES
-#	define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \
-	case TYPE_##enum_name: \
-	{ \
-		c_type val; \
-		NV_ERR_CHECK_RETURN(data.read(val)); \
-		NV_PARAM_ERR_CHECK_RETURN( handle.setParam##type_name(val), Serializer::ERROR_INVALID_VALUE ); \
-		break; \
-	}
-#	include "nvparameterized/NvParameterized_types.h"
-
-	case TYPE_MAT34:
-	{
-		float val[12];
-		for (int k = 0; k < 12; ++k)
-		{
-			NV_ERR_CHECK_RETURN(data.read(val[k]));
-		}
-		NV_PARAM_ERR_CHECK_RETURN( handle.setParamMat34Legacy(val), Serializer::ERROR_INVALID_VALUE );
-		break;
-	}
-
-NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS
-	default:
-		DEBUG_ASSERT(0 && "Unknown type");
-		return Serializer::ERROR_INVALID_DATA_TYPE;
-	}
-
-	return Serializer::ERROR_NONE;
-}
-
-bool isBinaryFormat(physx::PxFileBuf &stream)
-{
-	uint32_t magic;
-	stream.peek(&magic, 4);
-	return Canonize(magic) == BinSerializer::Magic;
-}
-
-Serializer::ErrorType peekBinaryPlatform(physx::PxFileBuf &stream, SerializePlatform &platform)
-{
-	BinaryHeader hdr;
-	BinaryHeaderExt ext;
-	NV_ERR_CHECK_RETURN( peekFileHeader(stream, hdr, ext) );
-	NV_ERR_CHECK_RETURN( hdr.getPlatform(platform) );
-	return Serializer::ERROR_NONE;
-}
-
-} // namespace NvParameterized
+// 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) 2008-2013 NVIDIA Corporation. All rights reserved.

+

+/*

+	Binary serialization is very complex and error-prone

+	process. Ensuring that it works properly is _critically_

+	important for the engine.

+

+	Before you do any significant changes to this code

+	please get familiar with C/C++ object layouts.

+	You may find these links helpful:

+

+	* APEX binary file format

+		https://wiki.nvidia.com/engwiki/index.php/PhysX/APEX/architecture/design/File_Formats

+		(may not be up-to-date)

+

+	* C++ data alignment and portability

+		http://www.codesynthesis.com/~boris/blog/2009/04/06/cxx-data-alignment-portability/

+

+	* Data structure alignment

+		http://en.wikipedia.org/wiki/Data_structure_alignment

+

+	* About Data Alignment

+		http://msdn.microsoft.com/en-us/library/ms253949%28v=VS.80%29.aspx

+

+	* Types and Storage

+		http://msdn.microsoft.com/en-us/library/02c56cw3.aspx

+

+	* Jan Gray's article in "C++: Under the Hood"

+		http://www.openrce.org/articles/files/jangrayhood.pdf

+

+	* Windows Data Alignment on IPF, x86, and x64

+		http://msdn.microsoft.com/en-us/library/aa290049%28VS.71%29.aspx

+

+	* GCC alignment in classes gotcha

+		https://ps3.scedev.net/forums/thread/41593/

+

+	* all messages in thread http://compilers.iecc.com/comparch/article/94-08-119

+

+	* Memory Layout for Multiple and Virtual Inheritance

+		http://www.phpcompiler.org/articles/virtualinheritance.html

+

+	* The "Empty Member" C++ Optimization

+		http://www.cantrip.org/emptyopt.html

+

+	You may also want to see examples of existing ABI

+	for various platforms:

+

+	* Agner Fog's Calling conventions for different C++ compilers

+		and operating systems,

+		http://www.agner.org/optimize/calling_conventions.pdf

+

+	* Itanium C++ ABI Data Layout

+		http://www.codesourcery.com/public/cxx-abi/abi.html#layout

+

+	* Introduction to Mac OS X ABI Function Call Guide

+		http://developer.apple.com/library/mac/#documentation/DeveloperTools/Conceptual/LowLevelABI/000-Introduction/introduction.html

+

+	After you implement you changes be sure to check that ALL

+	NvParameterized unit tests

+	* Test/MediaTest

+	* Test/RandomClasses

+	* Test/ParamRandomTest

+	run without errors on ALL supported platforms:

+	* Win32

+	* Win64

+	* PS3

+	* XBOX 360

+	(in future we may also have Mac, Tegra, Linux on PC, etc.).

+

+	If you need to add new platform to this list, be sure to

+	analyze it's ABI with ABIDumper

+	(//sw/nvidia/shared/general/ABIDumper) and check whether

+	it requires special changes in current serialization code

+	(Mac does).

+

+	If you ever implement new features be sure to cover them

+	in random schema generator

+	NvParameterized/scripts/RandomSchema.pl, generate a bunch

+	(10 at least) of new random schemas for Test/RandomClasses

+	and add them to p4 (and verify that they work on all

+	platforms!).

+*/

+

+#include <PxSimpleTypes.h>

+

+#include "PsArray.h"

+#include "PsHash.h"

+#include "PsHashMap.h"

+

+#include "NvParameters.h"

+#include "nvparameterized/NvParamUtils.h"

+#include "NvTraitsInternal.h"

+

+#include "BinaryHelper.h"

+

+#include "PlatformABI.h"

+#include "PlatformInputStream.h"

+#include "PlatformOutputStream.h"

+

+#include "BinSerializer.h"

+

+namespace NvParameterized

+{

+

+// Verify that file header is ok

+Serializer::ErrorType BinSerializer::verifyFileHeader(

+	const BinaryHeader &hdr,

+	const BinaryHeaderExt *ext,

+	uint32_t dataLen ) const

+{

+	NV_BOOL_ERR_CHECK_WARN_RETURN( BinSerializer::Magic == hdr.magic, Serializer::ERROR_INVALID_MAGIC, "Invalid APB file: magic number does not match: %x", hdr.magic );

+	NV_BOOL_ERR_CHECK_WARN_RETURN( (uint32_t)BINARY_TYPE_PLAIN == hdr.type, Serializer::ERROR_INVALID_FILE_FORMAT, "Invalid APB file: unknown file format: %d", hdr.type );

+

+	NV_BOOL_ERR_CHECK_WARN_RETURN(

+		BinVersions::WithExtendedHeader == hdr.version || BinVersions::WithAlignment == hdr.version,

+		Serializer::ERROR_INVALID_FILE_VERSION, "Invalid APB header: unexpected version: %x", hdr.version );

+

+	// Verify offsets

+	NV_BOOL_ERR_CHECK_WARN_RETURN( hdr.fileLength <= dataLen

+			&& hdr.dataOffset < hdr.fileLength

+			&& hdr.relocOffset < hdr.fileLength

+			&& hdr.dictOffset < hdr.fileLength

+			&& hdr.metadataOffset < hdr.fileLength,

+		Serializer::ERROR_INVALID_INTERNAL_PTR,

+		"Invalid APB file: section offsets do not match file length" );

+

+	if( ext )

+	{

+		NV_BOOL_ERR_CHECK_WARN_RETURN(

+			0 == memcmp((const char *)&ext->vcsSafetyFlags, VCS_SAFETY_FLAGS, 4),

+			Serializer::ERROR_INVALID_CHAR,

+			"Invalid APB file: perhaps your editor inserts redundant carriage returns?"

+		);

+	}

+

+	return Serializer::ERROR_NONE;

+}

+

+// Peeks APB header from stream

+static Serializer::ErrorType peekFileHeader(physx::PxFileBuf &stream, BinaryHeader &hdr, BinaryHeaderExt &ext, bool doDecanonize = true)

+{

+	NV_BOOL_ERR_CHECK_RETURN(

+		sizeof(BinaryHeader) == stream.peek(&hdr, sizeof(BinaryHeader)),

+		Serializer::ERROR_INVALID_FILE_FORMAT );

+

+	if( hdr.version >= BinVersions::WithExtendedHeader )

+	{

+		uint32_t fileOff = stream.tellRead();

+

+		stream.seekRead(fileOff + sizeof(BinaryHeader));

+		NV_BOOL_ERR_CHECK_RETURN(

+			sizeof(BinaryHeaderExt) == stream.peek(&ext, sizeof(BinaryHeaderExt)),

+			Serializer::ERROR_INVALID_FILE_FORMAT );

+

+		stream.seekRead(fileOff);

+	}

+

+	if( doDecanonize )

+		hdr.decanonize();

+

+	return Serializer::ERROR_NONE;

+}

+

+// Extract platform ABI from file header

+Serializer::ErrorType BinSerializer::getPlatformInfo(

+	BinaryHeader &hdr,

+	BinaryHeaderExt *ext,

+	PlatformABI &abi ) const

+{

+	//Difference between these versions is not important for non-inplace serializer

+	if( hdr.version == BinVersions::Initial || hdr.version == BinVersions::AllRefsCounted )

+		hdr.version = BinVersions::WithAlignment;

+

+	NV_ERR_CHECK_RETURN( verifyFileHeader(hdr, ext, hdr.fileLength) );

+

+	SerializePlatform platform;

+	NV_ERR_CHECK_WARN_RETURN(hdr.getPlatform(platform), "Invalid platform");

+

+	NV_ERR_CHECK_WARN_RETURN( PlatformABI::GetPredefinedABI(platform, abi), "Unknown platform" );

+

+	return Serializer::ERROR_NONE;

+}

+

+Serializer::ErrorType BinSerializer::peekInplaceAlignment(physx::PxFileBuf& stream, uint32_t& align)

+{

+	BinaryHeader hdr;

+	BinaryHeaderExt ext;

+	NV_ERR_CHECK_RETURN( peekFileHeader(stream, hdr, ext, false) );

+	align = Canonize(hdr.alignment);

+	return Serializer::ERROR_NONE;

+}

+

+// Verify that object matches its header

+Serializer::ErrorType BinSerializer::verifyObjectHeader(const ObjHeader &hdr, const Interface *obj, Traits *traits) const

+{

+	DEBUG_ASSERT(obj);

+	NV_BOOL_ERR_CHECK_WARN_RETURN(

+		obj->version() == hdr.version,

+		Serializer::ERROR_UNKNOWN,

+		"Invalid object: version does not match object header" );

+

+	PX_UNUSED(traits);

+

+	uint32_t bits = UINT32_MAX;

+	const uint32_t *checksum = obj->checksum(bits);

+

+	if( !DoIgnoreChecksum(*obj) || hdr.version != obj->version() )

+	{

+		if( bits != 32 * hdr.checksumSize )

+			NV_PARAM_TRAITS_WARNING(

+				traits,

+				"Schema checksum is different for object of class %s and version %u, asset may be corrupted",

+				hdr.className, (unsigned)hdr.version

+			);

+		else

+		{

+			for(uint32_t i = 0; i < hdr.checksumSize; ++i)

+				if( checksum[i] != hdr.checksum[i] )

+				{

+					NV_PARAM_TRAITS_WARNING(

+						traits,

+						"Schema checksum is different for object of class %s and version %u, asset may be corrupted",

+						hdr.className, (unsigned)hdr.version

+					);

+					break;

+				}

+		}

+	}

+

+	return Serializer::ERROR_NONE;

+}

+

+#if 0

+//TODO: this is just for tests, remove it after metadata works

+static void DumpDefinition(const Definition *def, const char *className, uint32_t version, uint32_t off = 0)

+{

+	char *tab = (char *)::malloc(off + 1);

+	memset(tab, ' ', off);

+	tab[off] = 0;

+

+	if( className )

+		printf("%sClass %s:%d\n", tab, className, version);

+

+	printf("%sDefinition at 0x%p:\n", tab, def);

+	printf("%s  name =  %s\n", tab, def->name());

+	printf("%s  type =  %s\n", tab, typeToStr(def->type()));

+	printf("%s  align = %d\n", tab, def->alignment());

+	printf("%s  pad = %d\n", tab, def->padding());

+

+	printf("%s  %d hints:\n", tab, def->numHints());

+	for(uint32_t i = 0; i < def->numHints(); ++i)

+	{

+		const Hint *hint = def->hint(i);

+

+		printf("%s    %s => ", tab, hint->name());

+		switch( hint->type() )

+		{

+		case TYPE_U64:

+			printf("%llu", hint->asUInt());

+			break;

+		case TYPE_F64:

+			printf("%f", hint->asFloat());

+			break;

+		case TYPE_STRING:

+			printf("\"%s\"", hint->asString());

+			break;

+		default:

+			DEBUG_ALWAYS_ASSERT();

+		}

+		printf("\n");

+	}

+

+	printf("%s  %d enums: ", tab, def->numEnumVals());

+	for(uint32_t i = 0; i < def->numEnumVals(); ++i)

+		printf("\"%s\", ", def->enumVal(i));

+	printf("\n");

+

+	printf("%s  %d refVariants: ", tab, def->numRefVariants());

+	for(uint32_t i = 0; i < def->numRefVariants(); ++i)

+		printf("\"%s\", ", def->refVariantVal(i));

+	printf("\n");

+

+	printf("%s  %d children:\n", tab, def->numChildren());

+	for(uint32_t i = 0; i < def->numChildren(); ++i)

+	{

+		printf("%sChild %d:\n", tab, i);

+		DumpDefinition(def->child(i), 0, 0, off + 1);

+	}

+

+	::free(tab);

+

+	fflush(stdout);

+}

+#endif

+

+Serializer::ErrorType BinSerializer::peekNumObjects(physx::PxFileBuf &stream, uint32_t &numObjects)

+{

+	BinaryHeader hdr;

+	BinaryHeaderExt ext;

+	NV_ERR_CHECK_RETURN( peekFileHeader(stream, hdr, ext, false) );

+	

+	return peekNumObjectsInplace((const void *)&hdr, sizeof(hdr), numObjects);

+}

+

+Serializer::ErrorType BinSerializer::peekNumObjectsInplace(const void *data, uint32_t dataLen, uint32_t &numObjects)

+{

+	NV_BOOL_ERR_CHECK_RETURN( dataLen >= sizeof(BinaryHeader), Serializer::ERROR_INVALID_FILE_FORMAT );

+	numObjects = static_cast<uint32_t>(Canonize( ((const BinaryHeader *)data)->numObjects));

+	return Serializer::ERROR_NONE;

+}

+

+Serializer::ErrorType BinSerializer::peekClassNames(physx::PxFileBuf &stream, char **classNames, uint32_t &numClassNames)

+{

+	BinaryHeader hdr;

+	BinaryHeaderExt ext;

+	NV_ERR_CHECK_RETURN( peekFileHeader(stream, hdr, ext) );

+

+	PlatformABI targetParams;

+	NV_ERR_CHECK_RETURN(getPlatformInfo(

+		hdr,

+		hdr.version >= BinVersions::WithExtendedHeader ? &ext : 0,

+		targetParams

+	));

+

+	PlatformInputStream objectTable(stream, targetParams, mTraits);

+	objectTable.skipBytes(hdr.dataOffset);

+

+	numClassNames = physx::PxMin(numClassNames, (uint32_t)hdr.numObjects);

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

+	{

+		uint32_t tmp;

+		NV_ERR_CHECK_RETURN( objectTable.readPtr(tmp) ); // Pointer to object data

+

+		uint32_t classNameOff;

+		NV_ERR_CHECK_RETURN( objectTable.readPtr(classNameOff) ); // Pointer to className

+

+		const char *className;

+		NV_ERR_CHECK_RETURN( objectTable.readString(classNameOff, className) );

+		classNames[i] = mTraits->strdup(className); //User will call Traits::strfree

+		mTraits->free((void *)className);

+

+		NV_ERR_CHECK_RETURN( objectTable.readPtr(tmp) ); // Pointer to name

+		NV_ERR_CHECK_RETURN( objectTable.readPtr(tmp) ); // Pointer to filename

+	}

+

+	return Serializer::ERROR_NONE;

+}

+

+Serializer::ErrorType BinSerializer::readMetadataInfo(const BinaryHeader &hdr, PlatformInputStream &s, DefinitionImpl *def)

+{

+	PX_PLACEMENT_NEW(def, DefinitionImpl)(*mTraits, false);

+

+	s.beginStruct(s.getTargetABI().getMetaInfoAlignment());

+

+	//type

+	uint32_t type;

+	NV_ERR_CHECK_RETURN( s.read(type) );

+	NV_BOOL_ERR_CHECK_WARN_RETURN( type < TYPE_LAST, Serializer::ERROR_INVALID_DATA_TYPE, "Unknown data type: %d", (int)type);

+

+	//arraySize

+	int32_t arraySize;

+	NV_ERR_CHECK_RETURN( s.read(arraySize) );

+

+	//shortName

+	uint32_t nameOff;

+	NV_ERR_CHECK_RETURN( s.readPtr(nameOff) );

+

+	const char *name;

+	NV_ERR_CHECK_RETURN( s.readString(nameOff, name) ); //NOTE: we do not release name because DefinitionImpl does not copy it

+

+	//structName

+	uint32_t structNameOff;

+	NV_ERR_CHECK_RETURN( s.readPtr(structNameOff) );

+

+	const char *structName;

+	NV_ERR_CHECK_RETURN( s.readString(structNameOff, structName) ); //NOTE: we do not release name because DefinitionImpl does not copy it

+

+	// We do not have metadata for older formats without alignment

+	NV_BOOL_ERR_CHECK_WARN_RETURN( hdr.version >= BinVersions::WithAlignment, Serializer::ERROR_INVALID_FILE_VERSION, "Unable to deserialize metadata: file format does not support it" );

+

+	//alignment

+	uint32_t alignment;

+	NV_ERR_CHECK_RETURN( s.read(alignment) );

+

+	//padding

+	uint32_t padding;

+	NV_ERR_CHECK_RETURN( s.read(padding) );

+

+	def->init(name, (DataType)type, structName);

+	def->setArraySize(arraySize);

+	if( alignment ) def->setAlignment(alignment);

+	if( padding ) def->setPadding(padding);

+

+	//numChildren

+	uint32_t numChildren;

+	NV_ERR_CHECK_RETURN( s.read(numChildren) );

+

+	//children

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

+	{

+		DefinitionImpl *childDef = (DefinitionImpl *)mTraits->alloc(sizeof(DefinitionImpl));

+

+		uint32_t off;

+		NV_ERR_CHECK_RETURN( s.readPtr(off) );

+

+		NV_ERR_CHECK_RETURN( s.pushPos(off) );

+		NV_ERR_CHECK_RETURN( readMetadataInfo(hdr, s, childDef) );

+		s.popPos();

+

+		def->addChild(childDef);

+	}

+

+	//numHints

+	uint32_t numHints;

+	NV_ERR_CHECK_RETURN( s.read(numHints) );

+

+	//hints

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

+	{

+		HintImpl *hint = (HintImpl *)mTraits->alloc(sizeof(HintImpl));

+		PX_PLACEMENT_NEW(hint, HintImpl)();

+

+		s.beginStruct(s.getTargetABI().getHintAlignment());

+

+		//type

+		uint32_t hintType;

+		NV_ERR_CHECK_RETURN( s.read(hintType) );

+

+		//name

+		uint32_t hintNameOff;

+		NV_ERR_CHECK_RETURN( s.readPtr(hintNameOff) );

+

+		const char *hintName;

+		NV_ERR_CHECK_RETURN( s.readString(hintNameOff, hintName) );

+		Releaser releaseName((void *)hintName, mTraits);

+

+		//val

+		s.beginStruct(s.getTargetABI().getHintValueAlignment());

+		switch( hintType )

+		{

+		case TYPE_U64:

+			{

+				uint64_t val;

+				NV_ERR_CHECK_RETURN( s.read(val) );

+				hint->init(hintName, val, false);

+

+				break;

+			}

+		case TYPE_F64:

+			{

+				double val;

+				NV_ERR_CHECK_RETURN( s.read(val) );

+				hint->init(hintName, val, false);

+

+				break;

+			}

+		case TYPE_STRING:

+			{

+				uint32_t off;

+				NV_ERR_CHECK_RETURN( s.readPtr(off) );

+

+				const char *val;

+				NV_ERR_CHECK_RETURN( s.readString(off, val) );

+				Releaser releaseVal((void *)val, mTraits);

+

+				hint->init(hintName, val, false);

+

+				break;

+			}

+		default:

+			DEBUG_ALWAYS_ASSERT();

+			return Serializer::ERROR_INVALID_DATA_TYPE;

+		}

+		s.align(s.getTargetABI().getHintValueSize());

+		s.closeStruct();

+

+		s.closeStruct();

+

+		def->addHint(hint);

+	} //i

+

+	//numEnumVals

+	uint32_t numEnumVals;

+	NV_ERR_CHECK_RETURN( s.read(numEnumVals) );

+

+	//enumVals

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

+	{

+		uint32_t off;

+		NV_ERR_CHECK_RETURN( s.readPtr(off) );

+

+		const char *val;

+		NV_ERR_CHECK_RETURN( s.readString(off, val) );

+		Releaser releaseVal((void *)val, mTraits);

+

+		def->addEnumVal(val);

+	}

+

+	//numRefVariants

+	uint32_t numRefVariants;

+	NV_ERR_CHECK_RETURN( s.read(numRefVariants) );

+

+	//refVariants

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

+	{

+		uint32_t off;

+		NV_ERR_CHECK_RETURN( s.readPtr(off) );

+

+		const char *val;

+		NV_ERR_CHECK_RETURN( s.readString(off, val) );

+		Releaser releaseVal((void *)val, mTraits);

+

+		def->addRefVariantVal(val);

+	}

+

+	s.closeStruct();

+

+	return Serializer::ERROR_NONE;

+}

+

+Serializer::ErrorType BinSerializer::deserializeMetadata(physx::PxFileBuf &stream, DeserializedMetadata &desData)

+{

+	BinaryHeader hdr;

+	BinaryHeaderExt ext;

+	NV_ERR_CHECK_RETURN( peekFileHeader(stream, hdr, ext) );

+	NV_ERR_CHECK_RETURN(verifyFileHeader(

+		hdr,

+		hdr.version >= BinVersions::WithExtendedHeader ? &ext : 0,

+		hdr.fileLength

+	));

+

+	PlatformABI targetParams;

+	NV_ERR_CHECK_RETURN(getPlatformInfo(

+		hdr,

+		hdr.version >= BinVersions::WithExtendedHeader ? &ext : 0,

+		targetParams

+	));

+

+	PlatformInputStream s(stream, targetParams, mTraits);

+	s.skipBytes(hdr.metadataOffset);

+

+	uint32_t numMetadata = hdr.numMetadata;

+

+	desData.init(mTraits, numMetadata);

+

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

+	{

+		uint32_t classNameOff;

+		NV_ERR_CHECK_RETURN( s.readPtr(classNameOff) );

+

+		const char *className;

+		NV_ERR_CHECK_RETURN( s.readString(classNameOff, className) );

+

+		uint32_t version;

+		NV_ERR_CHECK_RETURN( s.read(version) );

+

+		uint32_t entryOff;

+		NV_ERR_CHECK_RETURN( s.readPtr(entryOff) );

+

+		s.pushPos(entryOff);

+

+		DefinitionImpl *def = (DefinitionImpl *)mTraits->alloc(sizeof(DefinitionImpl));

+		NV_ERR_CHECK_WARN_RETURN( readMetadataInfo(hdr, s, def), "Failed to read metadata info" );

+

+//		DumpDefinition(def, className, version);

+

+		desData[i].def = def;

+		desData[i].version = version;

+		desData[i].className = className;

+

+		s.popPos();

+	}

+

+	return Serializer::ERROR_NONE;

+}

+

+Serializer::ErrorType BinSerializer::internalDeserialize(physx::PxFileBuf &stream, Serializer::DeserializedData &res, bool & /*doesNeedUpdate*/)

+{

+	NV_BOOL_ERR_CHECK_WARN_RETURN(

+		PlatformABI::VerifyCurrentPlatform(),

+		Serializer::ERROR_INVALID_PLATFORM,

+		"Current platform is not supported, aborting" );

+

+	NV_BOOL_ERR_CHECK_RETURN( BinaryHeader::CheckAlignment(), Serializer::ERROR_INVALID_PLATFORM );

+

+	BinaryHeader hdr;

+	BinaryHeaderExt ext;

+	NV_ERR_CHECK_RETURN( peekFileHeader(stream, hdr, ext) );

+

+	PlatformABI abi;

+	NV_ERR_CHECK_RETURN(getPlatformInfo(

+		hdr,

+		hdr.version >= BinVersions::WithExtendedHeader ? &ext : 0,

+		abi

+	));

+

+	uint32_t fileOff = stream.tellRead();

+

+	PlatformInputStream data(stream, abi, mTraits);

+	NV_ERR_CHECK_RETURN( data.skipBytes(hdr.dataOffset) );

+

+	res.init(mTraits, static_cast<uint32_t>(hdr.numObjects));

+	for(uint32_t i = 0; i < static_cast<uint32_t>(hdr.numObjects); ++i)

+	{

+		uint32_t objOff;

+		NV_ERR_CHECK_RETURN( data.readPtr(objOff) );

+

+		if( !objOff )

+			res[i] = 0;

+		else

+		{

+			NV_ERR_CHECK_RETURN( data.pushPos(objOff) );

+

+			Serializer::ErrorType error = readObject(res[i], data);

+			if( Serializer::ERROR_NONE != error )

+			{

+				for(uint32_t j = 0; j < i; ++j) //Last object was destroyed in readObject

+					res[j]->destroy();

+

+				res.init(0, 0);

+

+				return error;

+			}

+

+			data.popPos();

+		}

+

+		uint32_t tmp;

+		NV_ERR_CHECK_RETURN( data.readPtr(tmp) ); // className

+		NV_ERR_CHECK_RETURN( data.readPtr(tmp) ); // name

+		NV_ERR_CHECK_RETURN( data.readPtr(tmp) ); // filename

+	} //i

+

+	stream.seekRead(fileOff + hdr.fileLength); //Goto end of stream

+

+	return Serializer::ERROR_NONE;

+}

+

+static BinaryReloc *getRelocationTable(const BinaryHeader &hdr, char *start, uint32_t &nrelocs)

+{

+	char *ptrTable = start + hdr.relocOffset;

+	nrelocs = *reinterpret_cast<uint32_t *>(ptrTable);

+

+	ptrTable += PlatformABI::align(4, GetAlignment<BinaryReloc>::value);

+

+	return reinterpret_cast<BinaryReloc *>(ptrTable); //Alignment is ok

+}

+

+Serializer::ErrorType BinSerializer::internalDeserializeInplace(void *mdata, uint32_t dataLen, Serializer::DeserializedData &res, bool & doesNeedUpdate)

+{

+	doesNeedUpdate = false;

+

+	NV_BOOL_ERR_CHECK_WARN_RETURN(

+		PlatformABI::VerifyCurrentPlatform(),

+		Serializer::ERROR_INVALID_PLATFORM,

+		"Current platform is not supported, aborting" );

+

+	char *start = (char *)mdata;

+

+	//Header

+	BinaryHeader &hdr = *reinterpret_cast<BinaryHeader *>(start);

+	hdr.decanonize(); //Make platform-dependent

+

+	//Extended header

+	BinaryHeaderExt *ext = hdr.version >= BinVersions::WithExtendedHeader

+		? reinterpret_cast<BinaryHeaderExt *>(start + sizeof(BinaryHeader))

+		: 0;

+	if( ext ) ext->decanonize();

+

+	//This particular updates can be done on the fly

+	//Probably there is no need to set isUpdated because updates can be done on the fly

+

+	if( hdr.version == BinVersions::Initial )

+		NV_ERR_CHECK_WARN_RETURN( updateInitial2AllCounted(hdr, start), "Failed to update binary asset from 1.0 to 1.1" );

+

+	if( hdr.version == BinVersions::AllRefsCounted )

+		NV_ERR_CHECK_WARN_RETURN( updateAllCounted2WithAlignment(hdr, start), "Failed to update binary asset from 1.1 to 1.2" );

+

+	NV_ERR_CHECK_RETURN( verifyFileHeader(hdr, ext, dataLen) );

+

+	NV_BOOL_ERR_CHECK_RETURN( IsAligned(mdata, hdr.alignment), Serializer::ERROR_UNALIGNED_MEMORY);

+

+	//Verify platform

+	SerializePlatform filePlatform;

+	NV_ERR_CHECK_WARN_RETURN( hdr.getPlatform(filePlatform), "Unknown platform" );

+	NV_BOOL_ERR_CHECK_WARN_RETURN(

+		GetCurrentPlatform() == filePlatform,

+		Serializer::ERROR_INVALID_PLATFORM,

+		"Failed to inplace deserialize: platforms do not match" );

+

+	//Fix pointers

+

+	uint32_t nrelocs;

+	BinaryReloc *relocs = getRelocationTable(hdr, start, nrelocs);

+

+	//Using refOffs-array causes a memory allocation hence it's bad.

+	//But we have to fix all pointers prior to calling finishNvParameterized().

+	//Basically we have 3 opportunities:

+	//	- reorder relocs s.t. NvParameterized-objects go after all other relocs (strings, etc.)

+	//		(but this limits our binary file format + it turns out to be tricky to implement)

+	//	- walk through array once again

+	//		(but this may have a significant time penalty)

+	//	- reuse space in relocation table to store offsets of references

+	//		(this sounds nice and easy enough!)

+	//	- or maybe just process relocations in reverse order

+	//		(this one should be the fastest but once again this limits our format)

+	//For now we just keep the dynamic array as it seems to be pretty fast.

+

+	physx::shdfnd::Array<uint32_t, Traits::Allocator> refOffs((Traits::Allocator(mTraits)));

+	refOffs.reserve(nrelocs / 10);

+

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

+	{

+		BinaryReloc &reloc = relocs[i];

+

+		NV_BOOL_ERR_CHECK_RETURN(

+			reloc.type < static_cast<uint32_t>(RELOC_LAST),

+			Serializer::ERROR_INVALID_RELOC_TYPE );

+

+		switch( reloc.type )

+		{

+		case uint32_t(RELOC_ABS_RAW):

+			//Raw data, do nothing

+			break;

+		case uint32_t(RELOC_ABS_REF):

+			//Reference, init later

+			refOffs.pushBack(reloc.off);

+			break;

+		default:

+			DEBUG_ALWAYS_ASSERT();

+			return Serializer::ERROR_INVALID_INTERNAL_PTR;

+		}

+

+		char *&ptr = *reinterpret_cast<char **>(start + reloc.off);

+

+		size_t off = reinterpret_cast<size_t>(ptr); //size_t == uintptr_t

+		NV_BOOL_ERR_CHECK_RETURN( off < dataLen, Serializer::ERROR_INVALID_INTERNAL_PTR );

+

+		ptr = start + off;

+	}

+

+	uint32_t *refCount = reinterpret_cast<uint32_t*>(&hdr.numObjects);

+

+	//Init references (vtables and stuff)

+	for(uint32_t i = 0; i < refOffs.size(); ++i)

+	{

+		char *&p = *reinterpret_cast<char **>(start + refOffs[i]);

+

+		const ObjHeader &objHdr = *reinterpret_cast<const ObjHeader *>(p);

+

+		const char *className = objHdr.className;

+		NV_BOOL_ERR_CHECK_RETURN( className, Serializer::ERROR_INVALID_INTERNAL_PTR );

+

+		p += objHdr.dataOffset;

+

+		if( !objHdr.isIncluded )

+		{

+			Interface *obj = PX_PLACEMENT_NEW(p, NvParameters)(mTraits, start, reinterpret_cast<int32_t*>(refCount));

+			PX_UNUSED(obj);

+

+			//We do not want objHdr.verify() here

+		}

+		else

+		{

+			Interface *obj = mTraits->finishNvParameterized(className, objHdr.version, p, start, reinterpret_cast<int32_t*>(refCount));

+			NV_BOOL_ERR_CHECK_RETURN( obj, Serializer::ERROR_OBJECT_CREATION_FAILED );

+			NV_ERR_CHECK_RETURN( verifyObjectHeader(objHdr, obj, mTraits) );

+

+			if( objHdr.version != mTraits->getCurrentVersion(className) )

+				doesNeedUpdate = true;

+		} //if( !objHdr.isIncluded )

+	} //i

+

+	// Table of root references

+	ObjectTableEntry *objectTable = reinterpret_cast<ObjectTableEntry *>(start + hdr.dataOffset); //At start of data section

+

+	//Init results

+	res.init(mTraits, static_cast<uint32_t>(hdr.numObjects));

+	for(uint32_t i = 0; i < static_cast<uint32_t>(hdr.numObjects); ++i)

+		res[i] = objectTable[i].obj;

+

+	*refCount = refOffs.size(); //Release after all inplace references are destroyed

+

+	// Conversion will be done after deserialization to avoid releasing inplace memory if all objects are destroyed

+	//(otherwise we may have data corruption)

+

+	return Serializer::ERROR_NONE;

+}

+

+Serializer::ErrorType BinSerializer::updateAllCounted2WithAlignment(BinaryHeader &hdr, char * /*start*/)

+{

+	hdr.version = BinVersions::WithAlignment;

+	hdr.alignment = 8;

+	return Serializer::ERROR_NONE;

+}

+

+Serializer::ErrorType BinSerializer::updateInitial2AllCounted(BinaryHeader &hdr, char *start)

+{

+	// versionAllRefsCounted counts all references instead of just top-level references;

+	// to achieve this we simply set mDoDeallocateSelf to true in all references

+

+	uint32_t nrelocs;

+	BinaryReloc *relocs = getRelocationTable(hdr, start, nrelocs);

+

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

+	{

+		BinaryReloc &reloc = relocs[i];

+

+		if( reloc.type != static_cast<uint32_t>(RELOC_ABS_REF) )

+			continue;

+

+		size_t targetOff = *reinterpret_cast<size_t *>(start + reloc.off); //size_t == uintptr_t

+

+		const ObjHeader &objHdr = *reinterpret_cast<const ObjHeader *>(start + targetOff);

+

+		targetOff += objHdr.dataOffset; //Points to start of NvParameters

+

+#if PX_PS4 == 1

+#pragma GCC diagnostic ignored "-Wunused-private-field"

+#endif

+		// MyNvParameters has the same layout as NvParameters

+		class MyNvParameters

+		{

+			void *vtable;

+			void *mParameterizedTraits;

+			void *mSerializationCb;

+			void *mCbUserData;

+			void *mBuffer;

+			void *mRefCount;

+			void *mName;

+			void *mClassName;

+			bool mDoDeallocateSelf;

+			bool mDoDeallocateName;

+			bool mDoDeallocateClassName;

+

+		public:

+			void setDoDeallocateSelf() { mDoDeallocateSelf = true; }

+		};

+#if PX_PS4 == 1

+#pragma GCC diagnostic warning "-Wunused-private-field"

+#endif

+		MyNvParameters *pAsNvParameters = reinterpret_cast<MyNvParameters *>(start + targetOff);

+		pAsNvParameters->setDoDeallocateSelf();

+	}

+

+	hdr.version = BinVersions::AllRefsCounted;

+

+	return Serializer::ERROR_NONE;

+}

+

+Serializer::ErrorType BinSerializer::readArraySlow(Handle &handle, PlatformInputStream &s)

+{

+	int32_t n;

+	NV_PARAM_ERR_CHECK_RETURN( handle.getArraySize(n), Serializer::ERROR_INVALID_ARRAY );

+

+	for(int32_t i = 0; i < n; ++i)

+	{

+		handle.set(i);

+		NV_ERR_CHECK_RETURN( readBinaryData(handle, s) );

+		handle.popIndex();

+	}

+

+	return Serializer::ERROR_NONE;

+}

+

+static bool IsSimpleStruct(const Definition *pd)

+{

+	// Empty structs are special

+	if( 0 == pd->numChildren() )

+		return false;

+

+	for(int32_t i = 0; i < pd->numChildren(); ++i)

+	{

+		if (pd->child(i)->type() == TYPE_STRING || pd->child(i)->type() == TYPE_ENUM || pd->child(i)->type() == TYPE_ARRAY || 

+			pd->child(i)->type() == TYPE_REF    || pd->child(i)->type() == TYPE_STRUCT

+			)

+		{

+			return false;

+		}

+	}

+

+	return true;

+}

+

+#ifndef WITHOUT_APEX_SERIALIZATION

+

+Serializer::ErrorType BinSerializer::internalSerialize(physx::PxFileBuf &stream, const Interface **objs, uint32_t nobjs, bool doMetadata)

+{

+	NV_BOOL_ERR_CHECK_WARN_RETURN(

+		PlatformABI::VerifyCurrentPlatform(),

+		Serializer::ERROR_INVALID_PLATFORM ,

+		"Current platform is not supported, aborting" );

+

+	NV_BOOL_ERR_CHECK_RETURN( BinaryHeader::CheckAlignment(), Serializer::ERROR_INVALID_PLATFORM );

+

+	PlatformABI targetParams;

+	NV_ERR_CHECK_WARN_RETURN( PlatformABI::GetPredefinedABI(mPlatform, targetParams), "Unknown platform" );

+	NV_BOOL_ERR_CHECK_WARN_RETURN(

+		targetParams.isNormal(),

+		Serializer::ERROR_INVALID_PLATFORM,

+		"Target platform is not supported, aborting" );

+

+	PlatformABI curParams;

+	NV_ERR_CHECK_WARN_RETURN( PlatformABI::GetPredefinedABI(GetCurrentPlatform(), curParams), "Unknown platform" );

+	NV_BOOL_ERR_CHECK_RETURN( curParams.isNormal(), Serializer::ERROR_INVALID_PLATFORM );

+

+	Dictionary dict(mTraits); //Dictionary is updated in other routines

+

+	// Compute object data

+

+	typedef physx::shdfnd::Array<PlatformOutputStream, Traits::Allocator> StreamArray;

+	StreamArray dataStreams((Traits::Allocator(mTraits)));

+	dataStreams.reserve(nobjs);

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

+	{

+		Handle handle(*objs[i], "");

+		NV_BOOL_ERR_CHECK_RETURN( handle.isValid(), Serializer::ERROR_UNKNOWN );

+

+		dataStreams.pushBack(PlatformOutputStream(targetParams, mTraits, dict));

+		dataStreams.back().setAlignment(16); // 16 for safety

+

+		NV_ERR_CHECK_WARN_RETURN( storeBinaryData(*objs[i], handle, dataStreams.back()), "Failed to serialize data for object %d", i );

+	}

+

+	// Compute metadata

+

+	PlatformOutputStream metadataStream(targetParams, mTraits, dict);

+	metadataStream.setAlignment(16); // 16 for safety

+	uint32_t numMetadata = 0;

+	if( doMetadata )

+	{

+		typedef physx::shdfnd::Pair<const char *, uint32_t> VersionedClass;

+		typedef physx::shdfnd::HashMap<VersionedClass, const Definition *, physx::shdfnd::Hash<VersionedClass>, Traits::Allocator> MapClass2Def;

+		MapClass2Def mapClass2Def((Traits::Allocator(mTraits)));

+

+		//We track all classes that were saved to avoid duplicate metadata info

+		class MyRefCallback: public ReferenceInterface

+		{

+			MapClass2Def &mapClass2Def;

+

+			//Silence warnings on unable to generate assignment operator

+			void operator =(MyRefCallback) {}

+		public:

+			MyRefCallback(MapClass2Def &mapClass2Def_): mapClass2Def(mapClass2Def_) {}

+

+			void referenceCallback(Handle &handle)

+			{

+				Interface *iface;

+				handle.getParamRef(iface);

+				if( iface )

+					mapClass2Def[ VersionedClass(iface->className(), iface->version()) ] = iface->rootParameterDefinition();

+			}

+		} cb(mapClass2Def);

+

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

+		{

+			if( !objs[i] )

+				continue;

+

+			mapClass2Def[ VersionedClass(objs[i]->className(), objs[i]->version()) ] = objs[i]->rootParameterDefinition();

+			getReferences(*objs[i], cb, false, true, true);

+		}

+

+		numMetadata = mapClass2Def.size();

+

+		for(MapClass2Def::Iterator i = mapClass2Def.getIterator(); !i.done(); ++i)

+		{

+			metadataStream.beginStruct(targetParams.getMetaEntryAlignment());

+

+			metadataStream.storeStringPtr(i->first.first); //className

+			metadataStream.storeSimple<uint32_t>(i->first.second); //classVersion

+

+			//info

+			Reloc &reloc = metadataStream.storePtr(RELOC_ABS_RAW, targetParams.getMetaInfoAlignment());

+			NV_ERR_CHECK_RETURN( storeMetadataInfo(i->second, *reloc.ptrData) );

+

+			metadataStream.closeStruct();

+		} //i

+	}

+

+	// Init header

+

+	BinaryHeader hdr;

+

+	hdr.magic = Magic;

+	hdr.type = BINARY_TYPE_PLAIN;

+	hdr.version = Version;

+	hdr.numObjects = static_cast<int32_t>(nobjs);

+	hdr.fileLength = 0;

+	hdr.dictOffset = 0;

+	hdr.dataOffset = 0;

+	hdr.relocOffset = 0;

+	hdr.metadataOffset = 0;

+

+	hdr.archType = static_cast<uint32_t>(mPlatform.archType);

+	hdr.compilerType = static_cast<uint32_t>(mPlatform.compilerType);

+	hdr.compilerVer = mPlatform.compilerVer;

+	hdr.osType = static_cast<uint32_t>(mPlatform.osType);

+	hdr.osVer = mPlatform.osVer;

+

+	hdr.numMetadata = numMetadata;

+	hdr.alignment = 0;

+

+	BinaryHeaderExt ext;

+	memset(&ext, 0, sizeof(ext));

+	memcpy(&ext.vcsSafetyFlags, VCS_SAFETY_FLAGS, 4);

+

+	// Resulting stream

+

+	PlatformOutputStream joinStream(targetParams, mTraits, dict);

+

+	// Merge header

+

+	joinStream.storeBytes(reinterpret_cast<const char *>(&hdr), sizeof(hdr));

+	joinStream.storeBytes(reinterpret_cast<const char *>(&ext), sizeof(ext));

+	joinStream.align(16);

+

+	// Merge dictionary

+

+	uint32_t dictOffset = joinStream.size();

+	joinStream.mergeDict();

+

+	// Merge data

+

+	uint32_t dataOffset = 0;

+	{

+		joinStream.align(joinStream.getTargetABI().aligns.pointer);

+		dataOffset = joinStream.size();

+

+		//Create object table

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

+		{

+			dataStreams[i].flatten();

+

+			Reloc &reloc = joinStream.storePtr(RELOC_ABS_REF, dataStreams[i].alignment());

+			reloc.ptrData->merge(dataStreams[i]);

+

+			//This was requested for faster peeking of contained assets

+			joinStream.storeStringPtr(objs[i]->className());

+			joinStream.storeStringPtr(objs[i]->name());

+

+			//UE3 was once using this

+			joinStream.storeNullPtr();

+		}

+

+		joinStream.flatten(); //Merge all data-related pointers

+	}

+

+	// Merge metadata

+

+	uint32_t metadataOffset = 0;

+	if( doMetadata )

+	{

+		metadataOffset = joinStream.merge(metadataStream);

+		joinStream.flatten(); //Merge all metadata-related pointers

+	}

+

+	// Merge relocation data

+

+	uint32_t relocOffset = joinStream.writeRelocs();

+

+	// Update offsets in header

+

+	void *data = joinStream.getData();

+

+	BinaryHeader &hdrFinal = *reinterpret_cast<BinaryHeader *>(data);

+	hdrFinal.fileLength = joinStream.size();

+	hdrFinal.dictOffset = dictOffset;

+	hdrFinal.dataOffset = dataOffset;

+	hdrFinal.metadataOffset = metadataOffset;

+	hdrFinal.relocOffset = relocOffset;

+	hdrFinal.alignment = joinStream.alignment();

+

+	BinaryHeaderExt &extFinal = *reinterpret_cast<BinaryHeaderExt *>((char *)data + sizeof(BinaryHeader));

+

+	//Make platform-independent

+	hdrFinal.canonize();

+	extFinal.canonize();

+

+	// Write data to stream

+

+	if( stream.tellWrite() % joinStream.alignment() )

+	{

+		NV_PARAM_TRAITS_WARNING(

+			mTraits,

+			"Input stream is unaligned, "

+				"you will not be able to inplace deserialize it "

+				"without copying to intermediate buffer"

+		);

+	}

+

+	NV_BOOL_ERR_CHECK_RETURN(

+		joinStream.size() == stream.write(data, joinStream.size()),

+		Serializer::ERROR_STREAM_ERROR );

+

+	return Serializer::ERROR_NONE;

+}

+

+Serializer::ErrorType BinSerializer::storeMetadataInfo(const Definition *def, PlatformOutputStream &s)

+{

+	s.beginStruct(s.getTargetABI().getMetaInfoAlignment());

+

+	//type

+	s.storeSimple((uint32_t)def->type());

+

+	//arraySize

+	s.storeSimple(TYPE_ARRAY == def->type() ? (int32_t)def->arraySize() : -1);

+

+	//shortName

+	s.storeStringPtr(def->name());

+

+	//structName

+	s.storeStringPtr(def->structName());

+

+	//alignment

+	s.storeSimple(def->alignment());

+

+	//padding

+	s.storeSimple(def->padding());

+

+	//numChildren

+	s.storeSimple(def->numChildren());

+

+	//children

+	for(int32_t i = 0; i < def->numChildren(); ++i)

+	{

+		Reloc &childrenReloc = s.storePtr(RELOC_ABS_RAW, s.getTargetABI().getMetaInfoAlignment());

+		NV_ERR_CHECK_RETURN( storeMetadataInfo(def->child(i), *childrenReloc.ptrData) );

+	}

+

+	//numHints

+	s.storeSimple(def->numHints());

+

+	//hints

+	for(int32_t i = 0; i < def->numHints(); ++i)

+	{

+		const Hint *hint = def->hint(i);

+

+		s.beginStruct(s.getTargetABI().getHintAlignment());

+

+		s.storeSimple((uint32_t)hint->type());

+		s.storeStringPtr(hint->name());

+

+		s.beginStruct(s.getTargetABI().getHintValueAlignment());

+		switch( hint->type() )

+		{

+		case TYPE_U64:

+			s.storeSimple(hint->asUInt());

+			break;

+		case TYPE_F64:

+			s.storeSimple(hint->asFloat());

+			break;

+		case TYPE_STRING:

+			s.storeStringPtr(hint->asString());

+			break;

+

+NV_PARAMETRIZED_LINAL_DATATYPE_LABELS

+NV_PARAMETRIZED_REF_DATATYPE_LABELS

+NV_PARAMETRIZED_ENUM_DATATYPE_LABELS

+NV_PARAMETRIZED_SERVICE_DATATYPE_LABELS

+NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS

+NV_PARAMETRIZED_AGGREGATE_DATATYPE_LABELS

+		case TYPE_F32:

+		case TYPE_U32: case TYPE_U16: case TYPE_U8:

+		case TYPE_I64: case TYPE_I32: case TYPE_I16: case TYPE_I8: case TYPE_BOOL:

+		default:

+			DEBUG_ALWAYS_ASSERT();

+			return Serializer::ERROR_INVALID_DATA_TYPE;

+		}

+		s.align(s.getTargetABI().getHintValueSize());

+		s.closeStruct();

+

+		s.closeStruct();

+	}

+

+	//numEnumVals

+	s.storeSimple(def->numEnumVals());

+

+	//enumVals

+	for(int32_t i = 0; i < def->numEnumVals(); ++i)

+		s.storeStringPtr(def->enumVal(i));

+

+	//numRefVariantVals

+	s.storeSimple(def->numRefVariants());

+

+	//refVariants

+	for(int32_t i = 0; i < def->numRefVariants(); ++i)

+		s.storeStringPtr(def->refVariantVal(i));

+

+	s.closeStruct();

+

+	return Serializer::ERROR_NONE;

+}

+

+//Store array of arbitrary type (slow version)

+Serializer::ErrorType BinSerializer::storeArraySlow(Handle &handle, PlatformOutputStream &s)

+{

+	int32_t size;

+	NV_PARAM_ERR_CHECK_RETURN( handle.getArraySize(size), Serializer::ERROR_INVALID_ARRAY );

+

+	const Interface &obj = *handle.getConstInterface();

+	for(int32_t i = 0; i < size; ++i)

+	{

+		handle.set(i);

+		NV_ERR_CHECK_RETURN( storeBinaryData(obj, handle, s) );

+		handle.popIndex();

+	}

+

+	return Serializer::ERROR_NONE;

+}

+

+//Print binary data for part of NvParameterized object addressed by handle

+Serializer::ErrorType BinSerializer::storeBinaryData(const Interface &obj, Handle &handle, PlatformOutputStream &res, bool isRootObject)

+{

+	bool isObject = !handle.numIndexes();

+

+	if( isObject )

+		res.storeObjHeader(obj);

+

+	const Definition *pd = handle.parameterDefinition();

+

+	bool doNotSerialize = 0 != pd->hint("DONOTSERIALIZE"),

+		isDynamicArray = pd->type() == TYPE_ARRAY && !pd->arraySizeIsFixed();

+

+	// Alignment in dynamic array means alignment of dynamic memory

+	// so we do not insert it here

+	if( pd->alignment() && !isDynamicArray )

+		res.align(pd->alignment());

+

+	//Dynamic arrays are special because we need some of their fields for correct inplace deserialization

+	if( doNotSerialize && !isDynamicArray )

+	{

+		//Simply skip bytes

+		res.align(res.getTargetAlignment(pd));

+		res.skipBytes(res.getTargetSize(pd));

+

+		return Serializer::ERROR_NONE;

+	}

+

+	switch( pd->type() )

+	{

+	case TYPE_ARRAY:

+		{

+			if( pd->arraySizeIsFixed() )

+			{

+				res.beginArray(pd);

+				storeArraySlow(handle, res);

+				res.closeArray();

+			}

+			else

+			{

+				res.beginStruct(pd); //Dynamic arrays are implemented as structs

+

+				bool isEmpty = false;

+				if( doNotSerialize )

+					isEmpty = true;

+				else

+				{

+					for(int32_t i = 0; i < pd->arrayDimension(); ++i)

+					{

+						int32_t size = 0;

+						NV_PARAM_ERR_CHECK_RETURN( handle.getArraySize(size, i), Serializer::ERROR_INVALID_ARRAY );

+

+						if( 0 == size )

+						{

+							isEmpty = true;

+							break;

+						}

+					}

+				}

+

+				const Definition *elemPd = pd;

+				for(int32_t i = 0; i < pd->arrayDimension(); ++i)

+					elemPd = elemPd->child(0);

+

+				//Pointer-to-data

+				Reloc *reloc = 0;

+				if( isEmpty )

+					res.storeNullPtr();

+				else

+				{

+					reloc = &res.storePtr(RELOC_ABS_RAW, elemPd);

+					if( pd->alignment() )

+						reloc->ptrData->setAlignment(physx::PxMax(reloc->ptrData->alignment(), pd->alignment()));

+				}

+

+				//isAllocated

+				res.storeSimple(false);

+

+				//elementSize

+				res.storeSimple<uint32_t>(res.getTargetSize(elemPd));

+

+				//arraySizes

+				const Definition *subArrayPd = pd;

+				res.beginArray(res.getTargetABI().getAlignment<int32_t>());

+				for(int32_t dim = 0; dim < pd->arrayDimension(); ++dim)

+				{

+					// Store size of static dimensions even if doNotSerialize is on

+					int32_t size = 0;

+					if( !doNotSerialize || subArrayPd->arraySizeIsFixed() )

+						NV_PARAM_ERR_CHECK_RETURN( handle.getArraySize(size, dim), Serializer::ERROR_INVALID_ARRAY );

+

+					res.storeSimple(size);

+

+					NV_BOOL_ERR_CHECK_RETURN( 1 == subArrayPd->numChildren(), Serializer::ERROR_UNKNOWN );

+					subArrayPd = subArrayPd->child(0);

+				}

+				res.closeArray();

+

+				//Data

+				if( !isEmpty )

+				{

+					reloc->ptrData->beginArray(elemPd);

+

+					int32_t size = -1;

+					NV_PARAM_ERR_CHECK_RETURN( handle.getArraySize(size), Serializer::ERROR_INVALID_ARRAY );

+

+					const Definition *child = pd->child(0);

+					switch( child->type() )

+					{

+#					define NV_PARAMETERIZED_TYPES_NO_LEGACY_TYPES

+#					define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES

+#					define NV_PARAMETERIZED_TYPES_NO_STRING_TYPES

+#					define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \

+					case TYPE_##enum_name: \

+					{ \

+						reloc->ptrData->storeSimpleArray<c_type>(handle); \

+						break; \

+					}

+#					include "nvparameterized/NvParameterized_types.h"

+

+					case TYPE_STRUCT:

+						if( IsSimpleStruct(child) )

+						{

+							//Fast path for simple structs

+							reloc->ptrData->storeSimpleStructArray(handle);

+							break;

+						}

+

+					//Else fall through to default, includes TYPE_MAT34 case

+NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS

+NV_PARAMETRIZED_LEGACY_DATATYPE_LABELS

+NV_PARAMETRIZED_STRING_DATATYPE_LABELS

+NV_PARAMETRIZED_REF_DATATYPE_LABELS

+NV_PARAMETRIZED_ENUM_DATATYPE_LABELS

+NV_PARAMETRIZED_SERVICE_DATATYPE_LABELS

+					case TYPE_ARRAY:

+					default:

+						storeArraySlow(handle, *reloc->ptrData);

+						break;

+					}

+

+					reloc->ptrData->closeArray();

+				}

+

+				res.closeStruct();

+			}

+			break;

+		}

+

+	case TYPE_STRUCT:

+		{

+			uint32_t oldSize = isObject ? res.beginObject(obj, isRootObject, pd) : res.beginStruct(pd);

+

+			for(int32_t i = 0; i < pd->numChildren(); ++i)

+			{

+				handle.set(i);

+				NV_ERR_CHECK_RETURN( storeBinaryData(obj, handle, res) );

+				handle.popIndex();

+			}

+

+			//Empty structs are at least 1 char long

+			if( res.size() == oldSize )

+				res.storeSimple((uint8_t)0);

+

+			if( isObject )

+				res.closeObject();

+			else

+				res.closeStruct();

+

+			break;

+		}

+

+	case TYPE_STRING:

+		{

+			const char *s = 0;

+			handle.getParamString(s);

+

+			res.beginString();

+

+			//buf

+			res.storeStringPtr(s);

+

+			//isAllocated

+			res.storeSimple(false);

+

+			res.closeString();

+

+			break;

+		}

+

+	case TYPE_ENUM:

+		{

+			const char *s = 0;

+			handle.getParamEnum(s);

+

+			res.storeStringPtr(s);

+

+			break;

+		}

+

+	case TYPE_REF:

+		{

+			Interface *refObj = 0;

+			handle.getParamRef(refObj);

+

+			if( !refObj )

+				res.storeNullPtr();

+			else if( pd->isIncludedRef() )

+			{

+				Handle refHandle(*refObj, "");

+				NV_BOOL_ERR_CHECK_RETURN( refHandle.isValid(), Serializer::ERROR_UNKNOWN );

+

+				Reloc &reloc = res.storePtr(RELOC_ABS_REF, 16); //16 for safety

+				NV_ERR_CHECK_RETURN( storeBinaryData(*refObj, refHandle, *reloc.ptrData, false) );

+			}

+			else //Named reference

+			{

+				Reloc &reloc = res.storePtr(RELOC_ABS_REF, 16); //16 for safety

+				reloc.ptrData->storeObjHeader(*refObj, false);

+				reloc.ptrData->beginObject(*refObj, false, 0);

+				reloc.ptrData->closeObject(); //Named references are instances of NvParameters => no additional fields

+			}

+

+			break;

+		}

+

+	case TYPE_POINTER:

+		{

+			res.storeNullPtr();

+			break;

+		}

+

+

+#	define NV_PARAMETERIZED_TYPES_NO_LEGACY_TYPES

+#	define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES

+#	define NV_PARAMETERIZED_TYPES_NO_STRING_TYPES

+#	define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \

+	case TYPE_##enum_name: \

+	{ \

+		c_type val; \

+		NV_PARAM_ERR_CHECK_RETURN( handle.getParam##type_name(val), Serializer::ERROR_INVALID_VALUE ); \

+		res.storeSimple<c_type>(val); \

+		break; \

+	}

+#	include "nvparameterized/NvParameterized_types.h"

+

+	case TYPE_MAT34:

+	{

+		float val[12];

+		NV_PARAM_ERR_CHECK_RETURN( handle.getParamMat34Legacy(val), Serializer::ERROR_INVALID_VALUE );

+		res.storeSimple(val, 12);

+		break;

+	}

+

+NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS

+	default:

+		DEBUG_ASSERT(0 && "Unknown type");

+		return Serializer::ERROR_INVALID_DATA_TYPE;

+	}

+

+	return Serializer::ERROR_NONE;

+}

+

+#endif

+

+//Read NvParameterized object data

+Serializer::ErrorType BinSerializer::readObject(Interface *&obj, PlatformInputStream &data)

+{

+	ObjHeader objHdr;

+	NV_ERR_CHECK_WARN_RETURN( data.readObjHeader(objHdr), "Failed to deserialize object header" );

+	Releaser releaseClassName((void *)objHdr.className, mTraits),

+		releaseName((void *)objHdr.name, mTraits),

+		releaseChecksum((void *)objHdr.checksum, mTraits);

+

+	if( !objHdr.isIncluded )

+	{

+		void *buf = mTraits->alloc(sizeof(NvParameters));

+		NV_BOOL_ERR_CHECK_RETURN( buf, Serializer::ERROR_MEMORY_ALLOCATION_FAILURE );

+

+		obj = PX_PLACEMENT_NEW(buf, NvParameters)(mTraits);

+		obj->setClassName(objHdr.className);

+

+		if( objHdr.name )

+			obj->setName(objHdr.name);

+

+		//We do not want objHdr.verify() here

+	}

+	else

+	{

+		NV_BOOL_ERR_CHECK_RETURN( objHdr.className, Serializer::ERROR_OBJECT_CREATION_FAILED );

+

+		obj = mTraits->createNvParameterized(objHdr.className, objHdr.version);

+		NV_BOOL_ERR_CHECK_RETURN( obj, Serializer::ERROR_OBJECT_CREATION_FAILED );

+

+		if( objHdr.name )

+			obj->setName(objHdr.name);

+

+		NV_ERR_CHECK_RETURN( verifyObjectHeader(objHdr, obj, mTraits) );

+

+		Handle handle(*obj, "");

+		NV_BOOL_ERR_CHECK_RETURN( handle.isValid(), Serializer::ERROR_UNKNOWN );

+

+		NV_ERR_CHECK_RETURN( data.pushPos(objHdr.dataOffset) );

+		NV_ERR_CHECK_RETURN( readBinaryData(handle, data) );

+		data.popPos();

+	}

+

+	return Serializer::ERROR_NONE;

+}

+

+//Read binary data of NvParameterized object addressed by handle

+Serializer::ErrorType BinSerializer::readBinaryData(Handle &handle, PlatformInputStream &data)

+{

+	const Definition *pd = handle.parameterDefinition();

+

+	bool isDynamicArray = TYPE_ARRAY == pd->type() && !pd->arraySizeIsFixed();

+

+	// See comment in storeBinaryData

+	if( pd->alignment() && !isDynamicArray )

+		data.align(pd->alignment());

+

+	if( pd->hint("DONOTSERIALIZE") )

+	{

+		//Simply skip DONOTSERIALIZE

+		data.align(data.getTargetAlignment(pd));

+		NV_ERR_CHECK_RETURN( data.skipBytes(data.getTargetSize(pd)) );

+		return Serializer::ERROR_NONE;

+	}

+

+	switch( pd->type() )

+	{

+	case TYPE_ARRAY:

+		{

+			if( pd->arraySizeIsFixed() )

+			{

+				data.beginArray(pd);

+				for(int32_t i = 0; i < pd->arraySize(); ++i)

+				{

+					handle.set(i);

+					NV_ERR_CHECK_RETURN( readBinaryData(handle, data) );

+					handle.popIndex();

+				}

+				data.closeArray();

+			}

+			else

+			{

+				data.beginStruct(pd); //Dynamic arrays are implemented as structs

+

+				uint32_t elemOff;

+				NV_ERR_CHECK_RETURN( data.readPtr(elemOff) );

+

+				bool isAllocated;

+				NV_ERR_CHECK_RETURN( data.read(isAllocated) );

+

+				int32_t elementSize;

+				NV_ERR_CHECK_RETURN( data.read(elementSize) ); //elementSize

+

+				data.beginStruct(data.getTargetABI().aligns.i32); //Start array of sizes

+

+				int32_t arraySize;

+				NV_ERR_CHECK_RETURN( data.read(arraySize) ); //We need only the first size

+

+				const Definition *subArrayPd = pd->child(0);

+				for(int32_t dim = 1; dim < pd->arrayDimension(); ++dim)

+				{

+					int32_t size;

+					NV_ERR_CHECK_RETURN( data.read(size) );

+

+					// We do not support nested dynamic arrays

+					if( subArrayPd->arraySizeIsFixed() )

+						NV_BOOL_ERR_CHECK_RETURN( size == subArrayPd->arraySize(), Serializer::ERROR_INVALID_ARRAY );

+

+					subArrayPd = subArrayPd->child(0);

+				}

+				data.closeStruct(); //End array of sizes

+

+				NV_PARAM_ERR_CHECK_RETURN( handle.resizeArray(arraySize), Serializer::ERROR_INVALID_ARRAY );

+

+				if( elemOff )

+				{

+					// Check alignment

+					uint32_t align = pd->alignment();

+					if( align && elemOff % align ) {

+						char longName[256];

+						handle.getLongName(longName, sizeof(longName));

+						NV_PARAM_TRAITS_WARNING(

+							mTraits,

+							"%s: array is unaligned, "

+								"you will not be able to inplace deserialize it "

+								"without copying to intermediate buffer.",

+							longName

+						);

+					}

+

+					NV_ERR_CHECK_RETURN( data.pushPos(elemOff) );

+

+					switch( pd->child(0)->type() )

+					{

+#					define NV_PARAMETERIZED_TYPES_NO_LEGACY_TYPES

+#					define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES

+#					define NV_PARAMETERIZED_TYPES_NO_STRING_TYPES

+#					define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \

+					case TYPE_##enum_name: \

+					{ \

+						NV_ERR_CHECK_RETURN( data.readSimpleArray<c_type>(handle) ); \

+						break; \

+					}

+#					include "nvparameterized/NvParameterized_types.h"

+

+					case TYPE_STRUCT:

+						{

+							const Definition *child = pd->child(0);

+							if( IsSimpleStruct(child) )

+							{

+								//Fast path for simple structs

+								NV_ERR_CHECK_RETURN( data.readSimpleStructArray(handle) );

+								break;

+							}

+

+							//Else fall through to default, including TYPE_MAT34 case

+						}

+

+NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS

+NV_PARAMETRIZED_LEGACY_DATATYPE_LABELS

+NV_PARAMETRIZED_STRING_DATATYPE_LABELS

+NV_PARAMETRIZED_REF_DATATYPE_LABELS

+NV_PARAMETRIZED_ENUM_DATATYPE_LABELS

+NV_PARAMETRIZED_SERVICE_DATATYPE_LABELS

+case TYPE_ARRAY:

+					default:

+						NV_ERR_CHECK_RETURN( readArraySlow(handle, data) );

+						break;

+					}

+

+					data.popPos();

+				}

+

+				data.closeStruct();

+			}

+			break;

+		}

+

+	case TYPE_STRUCT:

+		{

+			uint32_t oldPos = data.getPos();

+

+			data.beginStruct(pd);

+			for(int32_t i = 0; i < pd->numChildren(); ++i)

+			{

+				handle.set(i);

+				NV_ERR_CHECK_RETURN( readBinaryData(handle, data) );

+				handle.popIndex();

+			}

+

+			//Empty structs are at least 1 char long

+			if( data.getPos() == oldPos )

+			{

+				uint8_t tmp;

+				NV_ERR_CHECK_RETURN( data.read(tmp) );

+			}

+

+			data.closeStruct();

+

+			break;

+		}

+

+	case TYPE_STRING:

+		{

+			data.beginString();

+

+			uint32_t off;

+			NV_ERR_CHECK_RETURN( data.readPtr(off) );

+

+			const char *s;

+			NV_ERR_CHECK_RETURN( data.readString(off, s) );

+

+			NV_PARAM_ERR_CHECK_RETURN( handle.setParamString(s), Serializer::ERROR_INVALID_VALUE );

+			mTraits->free((char *)s);

+

+			bool isAllocated;

+			NV_ERR_CHECK_RETURN( data.read(isAllocated) );

+

+			data.closeString();

+

+			break;

+		}

+

+	case TYPE_ENUM:

+		{

+			uint32_t off;

+			NV_ERR_CHECK_RETURN( data.readPtr(off) );

+

+			const char *s;

+			NV_ERR_CHECK_RETURN( data.readString(off, s) );

+

+			NV_BOOL_ERR_CHECK_RETURN( s, Serializer::ERROR_INVALID_VALUE );

+			NV_PARAM_ERR_CHECK_RETURN( handle.setParamEnum(s), Serializer::ERROR_INVALID_VALUE );

+

+			mTraits->free((char *)s);

+

+			break;

+		}

+

+	case TYPE_REF:

+		{

+			uint32_t objPos;

+			NV_ERR_CHECK_RETURN( data.readPtr(objPos) );

+

+			Interface *refObj = 0;

+

+			if( objPos )

+			{

+				NV_ERR_CHECK_RETURN( data.pushPos(objPos) );

+				NV_ERR_CHECK_RETURN( readObject(refObj, data) );

+				data.popPos();

+			}

+

+			if( refObj && (-1 == handle.parameterDefinition()->refVariantValIndex(refObj->className())) )

+			{

+				char longName[256];

+				handle.getLongName(longName, sizeof(longName));

+				NV_PARAM_TRAITS_WARNING(

+					mTraits,

+					"%s: setting reference of invalid class %s",

+					longName,

+					refObj->className()

+				);

+			}

+

+			NV_PARAM_ERR_CHECK_RETURN( handle.setParamRef(refObj), Serializer::ERROR_INVALID_REFERENCE );

+

+			break;

+		}

+

+	case TYPE_POINTER:

+		{

+			void *tmp;

+			NV_ERR_CHECK_RETURN( data.read(tmp) );

+			break;

+		}

+

+

+#	define NV_PARAMETERIZED_TYPES_NO_LEGACY_TYPES

+#	define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES

+#	define NV_PARAMETERIZED_TYPES_NO_STRING_TYPES

+#	define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \

+	case TYPE_##enum_name: \

+	{ \

+		c_type val; \

+		NV_ERR_CHECK_RETURN(data.read(val)); \

+		NV_PARAM_ERR_CHECK_RETURN( handle.setParam##type_name(val), Serializer::ERROR_INVALID_VALUE ); \

+		break; \

+	}

+#	include "nvparameterized/NvParameterized_types.h"

+

+	case TYPE_MAT34:

+	{

+		float val[12];

+		for (int k = 0; k < 12; ++k)

+		{

+			NV_ERR_CHECK_RETURN(data.read(val[k]));

+		}

+		NV_PARAM_ERR_CHECK_RETURN( handle.setParamMat34Legacy(val), Serializer::ERROR_INVALID_VALUE );

+		break;

+	}

+

+NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS

+	default:

+		DEBUG_ASSERT(0 && "Unknown type");

+		return Serializer::ERROR_INVALID_DATA_TYPE;

+	}

+

+	return Serializer::ERROR_NONE;

+}

+

+bool isBinaryFormat(physx::PxFileBuf &stream)

+{

+	uint32_t magic;

+	stream.peek(&magic, 4);

+	return Canonize(magic) == BinSerializer::Magic;

+}

+

+Serializer::ErrorType peekBinaryPlatform(physx::PxFileBuf &stream, SerializePlatform &platform)

+{

+	BinaryHeader hdr;

+	BinaryHeaderExt ext;

+	NV_ERR_CHECK_RETURN( peekFileHeader(stream, hdr, ext) );

+	NV_ERR_CHECK_RETURN( hdr.getPlatform(platform) );

+	return Serializer::ERROR_NONE;

+}

+

+} // namespace NvParameterized

diff --git a/sdk/extensions/import/apexmodules/NvParameterized/src/BinaryHelper.cpp b/sdk/extensions/import/apexmodules/NvParameterized/src/BinaryHelper.cpp
index e3fff8e..b80a4db 100644..100755
--- a/sdk/extensions/import/apexmodules/NvParameterized/src/BinaryHelper.cpp
+++ b/sdk/extensions/import/apexmodules/NvParameterized/src/BinaryHelper.cpp
@@ -1,123 +1,123 @@
-// 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) 2008-2013 NVIDIA Corporation. All rights reserved.
-
-// WARNING: before doing any changes to this file
-// check comments at the head of BinSerializer.cpp
-
-#include <ctype.h>
-#include <stdio.h>
-
-#include "BinaryHelper.h"
-
-namespace NvParameterized
-{
-
-void dumpBytes(const char *data, uint32_t nbytes)
-{
-	printf("Total = %d bytes\n", nbytes);
-
-	for(uint32_t i = 0; i < nbytes; i += 16)
-	{
-		printf("%08x: ", i);
-
-		//Print bytes
-		for(uint32_t j = i; j < i + 16; ++j)
-		{
-			if( nbytes < j )
-			{
-				//Pad with whites
-				for(; j < i + 16; ++j)
-					printf("   ");
-
-				break;
-			}
-
-			unsigned char c = static_cast<unsigned char>(data[j]);
-			printf("%02x ", c);
-		}
-
-		//Print chars
-		for(uint32_t j = i; j < i + 16; ++j)
-		{
-			if( nbytes < j )
-				break;
-
-			unsigned char c = static_cast<unsigned char>(data[j]);
-			printf("%c", isprint(c) ? c : '.');
-		}
-
-		printf("\n");
-	}
-}
-
-void Dictionary::setOffset(const char *s, uint32_t off)
-{
-	for(uint32_t i = 0; i < entries.size(); ++i)
-		if( 0 == strcmp(s, entries[i].s) )
-		{
-			entries[i].offset = off;
-			return;
-		}
-
-	PX_ASSERT(0 && "String not found");
-}
-
-uint32_t Dictionary::getOffset(const char *s) const
-{
-	for(uint32_t i = 0; i < entries.size(); ++i)
-		if( 0 == strcmp(s, entries[i].s) )
-			return entries[i].offset;
-
-	PX_ASSERT(0 && "String not found");
-	return (uint32_t)-1;
-}
-
-void Dictionary::serialize(StringBuf &res) const
-{
-	res.append(Canonize(entries.size()));
-
-	for(uint32_t i = 0; i < entries.size(); ++i)
-	{
-		const char *s = entries[i].s;
-		res.appendBytes(s, 1 + (uint32_t)strlen(s));
-	}
-}
-
-uint32_t Dictionary::put(const char *s)
-{
-	PX_ASSERT(s && "NULL in dictionary");
-
-	for(uint32_t i = 0; i < entries.size(); ++i)
-		if( 0 == strcmp(s, entries[i].s) )
-			return i;
-
-	Entry e = {s, 0};
-	entries.pushBack(e);
-	return entries.size() - 1;
-}
-
+// 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) 2008-2013 NVIDIA Corporation. All rights reserved.

+

+// WARNING: before doing any changes to this file

+// check comments at the head of BinSerializer.cpp

+

+#include <ctype.h>

+#include <stdio.h>

+

+#include "BinaryHelper.h"

+

+namespace NvParameterized

+{

+

+void dumpBytes(const char *data, uint32_t nbytes)

+{

+	printf("Total = %d bytes\n", nbytes);

+

+	for(uint32_t i = 0; i < nbytes; i += 16)

+	{

+		printf("%08x: ", i);

+

+		//Print bytes

+		for(uint32_t j = i; j < i + 16; ++j)

+		{

+			if( nbytes < j )

+			{

+				//Pad with whites

+				for(; j < i + 16; ++j)

+					printf("   ");

+

+				break;

+			}

+

+			unsigned char c = static_cast<unsigned char>(data[j]);

+			printf("%02x ", c);

+		}

+

+		//Print chars

+		for(uint32_t j = i; j < i + 16; ++j)

+		{

+			if( nbytes < j )

+				break;

+

+			unsigned char c = static_cast<unsigned char>(data[j]);

+			printf("%c", isprint(c) ? c : '.');

+		}

+

+		printf("\n");

+	}

+}

+

+void Dictionary::setOffset(const char *s, uint32_t off)

+{

+	for(uint32_t i = 0; i < entries.size(); ++i)

+		if( 0 == strcmp(s, entries[i].s) )

+		{

+			entries[i].offset = off;

+			return;

+		}

+

+	PX_ASSERT(0 && "String not found");

+}

+

+uint32_t Dictionary::getOffset(const char *s) const

+{

+	for(uint32_t i = 0; i < entries.size(); ++i)

+		if( 0 == strcmp(s, entries[i].s) )

+			return entries[i].offset;

+

+	PX_ASSERT(0 && "String not found");

+	return (uint32_t)-1;

+}

+

+void Dictionary::serialize(StringBuf &res) const

+{

+	res.append(Canonize(entries.size()));

+

+	for(uint32_t i = 0; i < entries.size(); ++i)

+	{

+		const char *s = entries[i].s;

+		res.appendBytes(s, 1 + (uint32_t)strlen(s));

+	}

+}

+

+uint32_t Dictionary::put(const char *s)

+{

+	PX_ASSERT(s && "NULL in dictionary");

+

+	for(uint32_t i = 0; i < entries.size(); ++i)

+		if( 0 == strcmp(s, entries[i].s) )

+			return i;

+

+	Entry e = {s, 0};

+	entries.pushBack(e);

+	return entries.size() - 1;

+}

+

 }
\ No newline at end of file
diff --git a/sdk/extensions/import/apexmodules/NvParameterized/src/NvParameterized.cpp b/sdk/extensions/import/apexmodules/NvParameterized/src/NvParameterized.cpp
index 76feef2..e84b0e4 100644..100755
--- a/sdk/extensions/import/apexmodules/NvParameterized/src/NvParameterized.cpp
+++ b/sdk/extensions/import/apexmodules/NvParameterized/src/NvParameterized.cpp
@@ -1,5960 +1,5960 @@
-// 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) 2008-2013 NVIDIA Corporation. All rights reserved.
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <PxSimpleTypes.h>
-#include <PsIntrinsics.h>
-
-#if PX_VC && !PX_PS4
-#pragma warning(disable:4996 4310)
-#endif
-
-#include "PsAsciiConversion.h"
-
-#include "nvparameterized/NvParameterized.h"
-
-#include "NvParameters.h"
-#include "NvTraitsInternal.h"
-#include "PsString.h"
-
-
-namespace NvParameterized
-{
-
-#define NV_ERR_CHECK_RETURN(x) if(x!=ERROR_NONE) return(x);
-#define NV_BOOL_RETURN(x) if((x)!=ERROR_NONE) return(false);
-
-#define DEBUG_ASSERT(x)
-//#define DEBUG_ASSERT(x) PX_ASSERT(x)
-
-char Spog[] = "test";
-
-#define COND_DUP(str) (mStaticAllocation) ? (char *)(str) : local_strdup(str)
-
-template <typename T>
-void swap(T& a, T&b)
-{
-	T tmp = b;
-	b = a;
-	a = tmp;
-}
-
-
-int32_t local_strcmp(const char* s1, const char* s2)
-{
-	return physx::shdfnd::strcmp(s1, s2);
-}
-
-int32_t local_stricmp(const char* s1, const char* s2)
-{
-	return physx::shdfnd::stricmp(s1, s2);
-}
-
-int32_t local_sprintf_s( char * _DstBuf, size_t _DstSize, const char * _Format, ...)
-{
-	if ( _DstBuf == NULL || _Format == NULL )
-	{
-		return -1;
-	}
-
-	va_list arg;
-	va_start( arg, _Format );
-	int32_t r = physx::shdfnd::vsnprintf( _DstBuf, _DstSize, _Format, arg );
-	va_end(arg);
-
-	return r;
-}
-
-
-static PX_INLINE void* allocAligned(NvParameterized::Traits* t, uint32_t size, uint32_t align)
-{
-	void* buf = t->alloc(size, align);
-	if( (size_t)buf & (align - 1) )
-	{
-		t->free(buf);
-		return 0;
-	}
-
-	return buf;
-}
-
-static PX_INLINE double RandomF64()
-{
-	return (double)rand() / RAND_MAX;
-}
-
-static PX_INLINE float RandomF32()
-{
-	return (float)RandomF64();
-}
-
-static PX_INLINE uint32_t RandomIdx(uint32_t m, uint32_t M)
-{
-	return uint32_t(m + RandomF64() * (M - m) + 0.99); // FIXME: round
-}
-
-static PX_INLINE physx::PxVec2 RandomVec2()
-{
-	return physx::PxVec2(RandomF32(), RandomF32());
-}
-
-static PX_INLINE physx::PxVec3 RandomVec3()
-{
-	return physx::PxVec3(RandomF32(), RandomF32(), RandomF32());
-}
-
-static PX_INLINE physx::PxVec4 RandomVec4()
-{
-	return physx::PxVec4(RandomF32(), RandomF32(), RandomF32(), RandomF32());
-}
-
-static PX_INLINE physx::PxQuat RandomQuat()
-{
-	return physx::PxQuat(RandomF32(), RandomF32(), RandomF32(), RandomF32());
-}
-
-static PX_INLINE uint32_t RandomU32()
-{
-	return (uint32_t)rand();
-}
-
-static PX_INLINE uint64_t RandomU64()
-{
-	uint32_t u32s[2];
-	u32s[0] = RandomU32();
-	u32s[1] = RandomU32();
-
-	return *(uint64_t*)&u32s[0];
-}
-
-static PX_INLINE bool notEqual(const char *a, const char *b)
-{
-	if(a == NULL && b == NULL)
-		return(false);
-
-	return (a == NULL && b != NULL)
-		|| (a != NULL && b == NULL)
-		|| 0 != strcmp(a, b);
-}
-
-static PX_INLINE bool notEqual(uint8_t a,uint8_t b)
-{
-	return a!=b;
-}
-static PX_INLINE bool notEqual(uint16_t a,uint16_t b)
-{
-	return a!=b;
-}
-
-static PX_INLINE bool notEqual(uint32_t a,uint32_t b)
-{
-	return a!=b;
-}
-
-static PX_INLINE bool notEqual(uint64_t a,uint64_t b)
-{
-	return a!=b;
-}
-
-static PX_INLINE bool notEqual(int8_t a,int8_t b)
-{
-	return a!=b;
-}
-static PX_INLINE bool notEqual(int16_t a,int16_t b)
-{
-	return a!=b;
-}
-
-static PX_INLINE bool notEqual(int32_t a,int32_t b)
-{
-	return a!=b;
-}
-
-static PX_INLINE bool notEqual(int64_t a,int64_t b)
-{
-	return a!=b;
-}
-
-static PX_INLINE bool notEqual(float a,float b)
-{
-	return a!=b;
-}
-
-static PX_INLINE bool notEqual(float (&a)[12],float (&b)[12])
-{
-	return a[0] != b[0] || a[1] != b[1] || a[2] != b[2] || 
-			a[3] != b[3] || a[4] != b[4] || a[5] != b[5] || 
-			a[6] != b[6] || a[7] != b[7] || a[8] != b[8] || 
-			a[9] != b[9] || a[10] != b[10] || a[11] != b[11];
-}
-
-static PX_INLINE bool notEqual(double a,double b)
-{
-	return a!=b;
-}
-
-static PX_INLINE bool notEqual(bool a,bool b)
-{
-	return a!=b;
-}
-
-static PX_INLINE bool notEqual(const physx::PxVec2 &a,const physx::PxVec2 &b)
-{
-	return a!=b;
-}
-
-static PX_INLINE bool notEqual(const physx::PxVec3 &a,const physx::PxVec3 &b)
-{
-	return a!=b;
-}
-
-static PX_INLINE bool notEqual(const physx::PxVec4 &a,const physx::PxVec4 &b)
-{
-	return a!=b;
-}
-
-// This was formerly in the NvQuat.h file but was removed due to other code bases requiring it to be gone
-static PX_INLINE bool operator!=( const physx::PxQuat& a, const physx::PxQuat& b )
-{
-	return a.x != b.x
-		|| a.y != b.y
-		|| a.z != b.z
-		|| a.w != b.w;
-}
-
-static PX_INLINE bool notEqual(const physx::PxQuat &a,physx::PxQuat &b)
-{
-	return a != b;
-}
-
-static PX_INLINE bool notEqual(const physx::PxMat33 &a,physx::PxMat33 &b)
-{
-	const float *qa = a.front();
-	const float *qb = b.front();
-	return qa[0] != qb[0] || qa[1] != qb[1] || qa[2] != qb[2] || qa[3] != qb[3] ||
-		   qa[4] != qb[4] || qa[5] != qb[5] || qa[6] != qb[6] || qa[7] != qb[7] ||
-		   qa[8] != qb[8];
-}
-
-static PX_INLINE bool notEqual(const physx::PxMat44 &a,physx::PxMat44 &b)
-{
-	return a.column0.w != b.column0.w || a.column0.x != b.column0.x || a.column0.y != b.column0.y || a.column0.z != b.column0.z ||
-		a.column1.w != b.column1.w || a.column1.x != b.column1.x || a.column1.y != b.column1.y || a.column1.z != b.column1.z ||
-		a.column2.w != b.column2.w || a.column2.x != b.column2.x || a.column2.y != b.column2.y || a.column2.z != b.column2.z ||
-		a.column3.w != b.column3.w || a.column3.x != b.column3.x || a.column3.y != b.column3.y || a.column3.z != b.column3.z;
-}
-
-static PX_INLINE bool notEqual(const physx::PxBounds3 &a,const physx::PxBounds3 &b)
-{
-	return a.minimum != b.minimum || a.maximum != b.maximum;
-}
-
-static PX_INLINE bool notEqual(const physx::PxTransform &a,const physx::PxTransform &b)
-{
-	return a.p != b.p || a.q != b.q;
-}
-
-#define CHECK_FINITE(t) { \
-	const t* _fs = (const t*)&val; \
-	for(size_t _j = 0; _j < sizeof(val) / sizeof(t); ++_j) \
-	{ \
-		if( physx::PxIsFinite(_fs[_j]) ) continue; \
-		char _longName[256]; \
-		handle.getLongName(_longName, sizeof(_longName)); \
-		NV_PARAM_TRAITS_WARNING(mParameterizedTraits, "%s: setting non-finite floating point value", _longName); \
-		break; \
-	} \
-}
-
-#define CHECK_FINITE_ARRAY(t) { \
-	for(int32_t _i = 0; _i < int32_t(n); ++_i) \
-	{ \
-		const t* _fs = (const t*)(&array[_i]); \
-		for(size_t _j = 0; _j < sizeof(array[0]) / sizeof(t); ++_j) \
-		{ \
-			if( physx::PxIsFinite(_fs[_j]) ) continue; \
-			char _longName[256]; \
-			handle.getLongName(_longName, sizeof(_longName)); \
-			NV_PARAM_TRAITS_WARNING(mParameterizedTraits, "%s[%d]: setting non-finite floating point value", _longName, (int)_i); \
-			break; \
-		} \
-	} \
-}
-
-#define CHECK_F32_FINITE \
-	CHECK_FINITE(float)
-
-#define CHECK_F32_FINITE_ARRAY \
-	CHECK_FINITE_ARRAY(float)
-
-#define CHECK_F64_FINITE \
-	CHECK_FINITE(double)
-
-#define CHECK_F64_FINITE_ARRAY \
-	CHECK_FINITE_ARRAY(double)
-
-//******************************************************************************
-//*** Local functions
-//******************************************************************************
-
-#if 0
-static void *local_malloc(uint32_t bytes)
-{
-	return(NV_ALLOC(bytes, NV_DEBUG_EXP("NvParameterized::local_malloc")));
-}
-
-static void *local_realloc(void *buf, uint32_t bytes)
-{
-    return(GetApexAllocator()->realloc(buf, bytes));
-}
-
-static void local_free(void *buf)
-{
-    NV_FREE(buf);
-}
-#else
-
-static void *local_malloc(uint32_t bytes)
-{
-    return(malloc(bytes));
-}
-
-static void *local_realloc(void *buf, uint32_t bytes)
-{
-    return(realloc(buf, bytes));
-}
-
-static void local_free(void *buf)
-{
-    free(buf);
-}
-
-#endif
-
-static char *local_strdup(const char *str)
-{
-	if(str == NULL)
-		return NULL;
-
-	uint32_t len = (uint32_t)strlen(str);
-
-	char *result = (char *)local_malloc(sizeof(char) * (len + 1));
-	physx::shdfnd::strlcpy(result, len+1, str);
-	return result;
-}
-
-static void local_strncpy(char *dst, const char *src, uint32_t n)
-{
-	physx::shdfnd::strlcpy(dst, n, src);
-}
-
-
-static void local_strncat(char *dst, const char *src, uint32_t n)
-{
-	PX_UNUSED(n);
-	physx::shdfnd::strlcat(dst, strlen(dst) + strlen(src) + 1,src);
-}
-
-static int32_t safe_strcmp(const char *str1, const char *str2)
-{
-	if( str1 != NULL && str2 != NULL )
-		return strcmp(str1, str2);
-	else if( str1 == NULL && str2 == NULL )
-		return 0;
-	else
-		return -1;
-}
-
-void *dupBuf(void *buf, uint32_t n)
-{
-    PX_ASSERT(buf != NULL);
-    PX_ASSERT(n > 0);
-
-    void *Ret = local_malloc(n);
-    physx::intrinsics::memCopy(Ret, buf, n);
-
-    return(Ret);
-}
-
-DataType strToType(const char *str)
-{
-#   define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \
-        if(!strcmp(str, #type_name)) \
-            return(TYPE_##enum_name);
-
-#   include "nvparameterized/NvParameterized_types.h"
-
-	if(!strcmp(str, "Pointer"))
-		return(TYPE_POINTER);
-
-	if(!strcmp(str, "Mat34"))
-		return(TYPE_MAT34);
-
-    return(TYPE_UNDEFINED);
-}
-
-const char *typeToStr(DataType type)
-{
-    switch(type)
-    {
-
-#   define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \
-        case TYPE_##enum_name : \
-            return(#type_name);
-#       include "nvparameterized/NvParameterized_types.h"
-		
-		case TYPE_MAT34:
-			return "Mat34";
-
-		case TYPE_POINTER:
-			return "Pointer";
-
-NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS
-		default:
-			return NULL;
-    }
-}
-
-//******************************************************************************
-//*** class HintImpl
-//******************************************************************************
-
-HintImpl::HintImpl()
-{
-    mStaticAllocation = true;
-}
-
-HintImpl::HintImpl(const char *name, uint64_t value)
-{
-    PX_ASSERT(name != NULL);
-
-    init(name, value);
-}
-
-HintImpl::HintImpl(const char *name, double value)
-{
-    PX_ASSERT(name != NULL);
-
-    init(name, value);
-}
-
-HintImpl::HintImpl(const char *name, const char *value)
-{
-    PX_ASSERT(name != NULL);
-    PX_ASSERT(value != NULL);
-
-    init(name, value);
-}
-
-HintImpl::~HintImpl()
-{
-    cleanup();
-}
-
-void HintImpl::init(const char *name, uint64_t value, bool static_allocation)
-{
-    PX_ASSERT(name != NULL);
-
-    mStaticAllocation = static_allocation;
-    mType = TYPE_U64;
-    mName = COND_DUP(name);
-    mUIntValue = value;
-}
-
-void HintImpl::init(const char *name, double value, bool static_allocation)
-{
-    PX_ASSERT(name != NULL);
-
-    mStaticAllocation = static_allocation;
-    mType = TYPE_F64;
-    mName = COND_DUP(name);
-    mFloatValue = value;
-}
-
-void HintImpl::init(const char *name, const char *value, bool static_allocation)
-{
-    PX_ASSERT(name != NULL);
-    PX_ASSERT(value != NULL);
-
-    mStaticAllocation = static_allocation;
-    mType = TYPE_STRING;
-    mName = COND_DUP(name);
-    mStringValue = COND_DUP(value);
-}
-
-void HintImpl::cleanup(void)
-{
-    PX_ASSERT(mName != NULL);
-
-    if(!mStaticAllocation)
-    {
-        local_free(mName);
-
-        if(type() == TYPE_STRING)
-        {
-            PX_ASSERT(mStringValue != NULL);
-            local_free(mStringValue);
-        }
-    }
-}
-
-bool HintImpl::setAsUInt(uint64_t v) 
-{
-	bool ret = false;
-  PX_ASSERT(type() == TYPE_U64);
-  if ( type() == TYPE_U64 )
-  {
-	mUIntValue = v;
-	ret = true;
-  }
-  return ret;
-}
-
-uint64_t HintImpl::asUInt(void) const
-{
-	PX_ASSERT(type() == TYPE_U64);
-	return(mUIntValue);
-}
-
-double HintImpl::asFloat(void) const
-{
-  PX_ASSERT(type() == TYPE_U64 || type() == TYPE_F64);
-  return(type() == TYPE_U64 ? static_cast<int64_t>(mUIntValue) : mFloatValue);
-}
-
-const char *HintImpl::asString(void)const
-{
-  PX_ASSERT(type() == TYPE_STRING);
-  return(mStringValue);
-}
-
-
-//******************************************************************************
-//*** class Handle
-//******************************************************************************
-
-
-
-//******************************************************************************
-//*** class DefinitionImpl
-//******************************************************************************
-
-void DefinitionImpl::setDefaults(void)
-{
-    mName = NULL;
-
-	mLongName = NULL;
-	mLongNameAllocated = false;
-
-	mStructName = NULL;
-
-    mType = TYPE_UNDEFINED;
-
-    mArraySize = 0;
-
-    mParent = NULL;
-
-    mNumChildren = 0;
-    mChildren = NULL;
-
-    mNumHints = 0;
-    mHints = NULL;
-
-    mEnumVals = NULL;
-    mNumEnumVals = 0;
-
-	mNumRefVariants = 0;
-	mRefVariantVals = NULL;
-
-	mNumDynamicHandleIndices = 0;
-	mDynamicHandleIndices = NULL;
-
-	mAlign = mPad = 0;
-}
-
-DefinitionImpl::DefinitionImpl(Traits &traits, bool staticAlloc)
-{
-    mStaticAllocation = staticAlloc;
-	mTraits = &traits;
-    setDefaults();
-}
-
-DefinitionImpl::DefinitionImpl(const char *name, DataType t, const char *structName, Traits &traits, bool staticAlloc)
-{
-    mStaticAllocation = staticAlloc;
-	mTraits = &traits;
-	mLongNameAllocated = false;
-    init(name, t, structName, false);
-}
-
-
-DefinitionImpl::~DefinitionImpl()
-{
-    cleanup();
-}
-
-void DefinitionImpl::setAlignment(uint32_t align)
-{
-	mAlign = align;
-}
-
-uint32_t DefinitionImpl::alignment(void) const
-{
-	return mAlign;
-}
-
-void DefinitionImpl::setPadding(uint32_t pad)
-{
-	mPad = pad;
-}
-
-uint32_t DefinitionImpl::padding(void) const
-{
-	return mPad;
-}
-
-void DefinitionImpl::init(const char *name, DataType t, const char *structName, bool static_allocation)
-{
-	PX_UNUSED( static_allocation );
-
-    cleanup();
-
-	mName = name;
-    mLongName = name;
-	mStructName = structName;
-	
-    PX_ASSERT(t != TYPE_UNDEFINED);
-    mType = t;
-}
-
-void DefinitionImpl::destroy(void)
-{
-	PX_ASSERT( !mStaticAllocation );
-
-	if( !mStaticAllocation )
-	{
-		this->~DefinitionImpl();
-		mTraits->free(this);
-	}
-}
-
-void DefinitionImpl::cleanup(void)
-{
-    if(!mStaticAllocation)
-    {
-		if( mStructName )
-			mTraits->free((void *)mStructName);
-
-		mTraits->free((void *)mName);
-
-        if(mChildren != NULL)
-        {
-           for(int32_t i=0; i < mNumChildren; ++i)
-			   mChildren[i]->destroy();
-
-		   local_free(mChildren);
-		}
-
-		if(mHints != NULL)
-		{
-			for(int32_t i=0; i < mNumHints; ++i)
-			{
-				mHints[i]->cleanup();
-				mTraits->free(mHints[i]);
-			}
-
-            local_free(mHints);
-		}
-
-		if(mEnumVals != NULL)
-		{
-			for(int32_t i = 0; i < mNumEnumVals; ++i)
-				local_free(mEnumVals[i]);
-
-            local_free(mEnumVals);
-		}
-
-		if(mRefVariantVals != NULL)
-		{
-			for(int32_t i = 0; i < mNumRefVariants; ++i)
-				local_free(mRefVariantVals[i]);
-
-            local_free(mRefVariantVals);
-        }
-    }
-
-	if(mLongNameAllocated && mLongName)
-	{
-		mTraits->strfree( (char *)mLongName );
-		mLongName = NULL;
-		mLongNameAllocated = false;
-	}
-    
-    setDefaults();
-}
-
-const Definition *DefinitionImpl::root(void) const
-{
-    const Definition *root = this;
-    while(root->parent() != NULL)
-        root = root->parent();
-
-    return(root);
-}
-
-int32_t DefinitionImpl::arrayDimension(void) const
-{
-    PX_ASSERT(type() == TYPE_ARRAY);
-
-    int32_t Dim = 0;
-    const Definition *Cur = this;
-    for(;Cur->type() == TYPE_ARRAY; Cur = Cur->child(0))
-    {
-      PX_ASSERT(Cur != NULL);
-      Dim++;
-    }
-
-    return(Dim);
-}
-
-int32_t DefinitionImpl::arraySize(int32_t dimension) const
-{
-    PX_ASSERT(type() == TYPE_ARRAY);
-    PX_ASSERT(dimension >= 0);
-    PX_ASSERT(dimension < arrayDimension());
-
-    const Definition *Cur = this;
-    for(int32_t i=0; i < dimension; ++i)
-        Cur = Cur->child(0);
-
-    if(Cur->type() != TYPE_ARRAY)
-        return(-1);
-
-	const DefinitionImpl *pd = static_cast<const DefinitionImpl *>(Cur);
-
-    return( pd->mArraySize);
-}
-
-bool DefinitionImpl::arraySizeIsFixed(void) const
-{
-    PX_ASSERT(type() == TYPE_ARRAY);
-    return(mArraySize > 0);
-}
-
-bool DefinitionImpl::setArraySize(int32_t size)
-{
-    PX_ASSERT(size >= -1);
-
-    if(size < 0)
-        return(false);
-
-    mArraySize = size;
-
-    return(true);
-}
-
-bool DefinitionImpl::isIncludedRef(void) const
-{
-	const Hint *h = hint("INCLUDED");
-   	return h && h->type() == TYPE_U64 && h->asUInt();
-}
-
-int32_t DefinitionImpl::numChildren(void) const
-{
-    return(mNumChildren);
-}
-
-const Definition * DefinitionImpl::child(int32_t index) const
-{
-    PX_ASSERT(index >= 0);
-    PX_ASSERT(index < numChildren());
-    PX_ASSERT(type() == TYPE_STRUCT || type() == TYPE_ARRAY);
-
-    if(index < 0 || index >= numChildren())
-        return(NULL);
-
-    return(mChildren[index]);
-}
-
-const Definition *  DefinitionImpl::child(const char *name, int32_t &index) const
-{
-    PX_ASSERT(name);
-    PX_ASSERT(type() == TYPE_STRUCT);
-
-    int32_t i;
-    for(i=0; i < numChildren(); ++i)
-        if(!strcmp(mChildren[i]->name(), name))
-        {
-            index = i;
-            return(mChildren[i]);
-        }
-
-    return(NULL);
-}
-
-
-#define PUSH_TO_ARRAY(val, array, obj_type, num_var) \
-    num_var++; \
-    if(array == NULL) \
-        array = (obj_type *)local_malloc(sizeof(obj_type)); \
-    else \
-        array = (obj_type *)local_realloc(array, num_var * sizeof(obj_type)); \
-    PX_ASSERT(array != NULL); \
-    array[num_var-1] = val;
-
-
-static char *GenLongName(char *dst, 
-                         uint32_t n,
-                         const char *parent_long_name,
-                         DataType parent_type, 
-                         const char *child_name)
-{
-    local_strncpy(dst, parent_long_name, n);
-
-    switch(parent_type)
-    {
-        case TYPE_STRUCT:
-            if(parent_long_name[0])
-                local_strncat(dst, ".", n);
-            local_strncat(dst, child_name, n);
-            break;
-
-        case TYPE_ARRAY:
-            local_strncat(dst, "[]", n);
-            break;
-
-		NV_PARAMETRIZED_NO_AGGREGATE_DATATYPE_LABELS
-        default:
-            PX_ASSERT((void *)"Shouldn't be here!" == NULL);
-            break;
-    }
-
-    return(dst);
-}
-
-#define SET_ARRAY(type, src_array_var, dst_array_var, num_var) \
-    PX_ASSERT(src_array_var != NULL); \
-    PX_ASSERT(n > 0); \
-    if(mStaticAllocation) \
-    { \
-        dst_array_var = (type *)src_array_var; \
-        num_var = n; \
-    } \
-    else \
-    { \
-        PX_ASSERT(dst_array_var == NULL); \
-        dst_array_var = (type *)dupBuf(src_array_var, sizeof(type) * n); \
-        num_var = n; \
-    }
-
-void DefinitionImpl::setChildren(Definition **children, int32_t n)
-{
-    SET_ARRAY(Definition *, children, mChildren, mNumChildren);
-
-	char tmpStr[MAX_NAME_LEN];
-
-	for(int32_t i=0; i < n; ++i)
-    {
-        Definition *_child = children[i];
-		DefinitionImpl *child = static_cast< DefinitionImpl *>(_child);
-
-        PX_ASSERT(child->parent() == NULL); // Only one parent allowed
-
-        GenLongName(tmpStr, 
-                    MAX_NAME_LEN, 
-                    mLongName, 
-                    type(),
-                    child->mName);
-
-		child->mLongName = mTraits->strdup( tmpStr );
-		child->mLongNameAllocated = true;
-
-		PX_ASSERT( child != this );
-        child->mParent = this;
-    }
-}
-
-void DefinitionImpl::addChild(Definition *_child)
-{
-    PX_ASSERT(_child != NULL);
-    PX_ASSERT(!mStaticAllocation);
-
-	DefinitionImpl *child = static_cast< DefinitionImpl *>(_child);
-	PX_ASSERT(child->mParent == NULL); // Only one parent allowed
-	
-	char tmpStr[MAX_NAME_LEN];
-
-    GenLongName(tmpStr, 
-                MAX_NAME_LEN, 
-                mLongName, 
-                type(), 
-                child->mName);
-
-	child->mLongName = mTraits->strdup( tmpStr );
-	child->mLongNameAllocated = true;
-
-	PX_ASSERT( child != this );
-    child->mParent = this;
-    PUSH_TO_ARRAY(_child, mChildren, Definition *, mNumChildren)
-}
-
-
-int32_t DefinitionImpl::numHints(void) const
-{
-    return(mNumHints);   
-}
-
-const Hint *DefinitionImpl::hint(int32_t index) const
-{
-    PX_ASSERT(index >= 0);
-    PX_ASSERT(index < numHints());
-
-	if( index >= numHints() )
-	{
-		return(NULL);
-	}
-
-    return(mHints[index]);
-}
-
-const Hint *DefinitionImpl::hint(const char *name) const
-{
-    PX_ASSERT(name != NULL);
-
-    for(int32_t i=0; i < numHints(); ++i)
-        if(!strcmp(mHints[i]->name(), name))
-            return(mHints[i]);
-
-    return(NULL);
-}
-
-void DefinitionImpl::setHints(const Hint **hints, int32_t n)
-{
-    SET_ARRAY(HintImpl *, hints, mHints, mNumHints);
-}
-
-void DefinitionImpl::addHint(Hint *_hint)
-{
-    PX_ASSERT(_hint != NULL);
-	HintImpl *hint = static_cast< HintImpl *>(_hint);
-    PUSH_TO_ARRAY(hint, mHints, HintImpl *, mNumHints)
-}
-
-int32_t DefinitionImpl::numEnumVals(void) const
-{
-   return(mNumEnumVals);
-}
-
-int32_t DefinitionImpl::enumValIndex( const char * enum_val ) const
-{
-	if(!enum_val)
-		return(-1);
-
-	for(int32_t i=0; i < numEnumVals(); ++i)
-	{
-        if( !strcmp( enumVal(i), enum_val ) )
-		{
-            return(i);
-		}
-	}
-
-	return(-1);
-}
-
-const char *DefinitionImpl::enumVal(int32_t index) const
-{
-    PX_ASSERT(index >= 0);
-    PX_ASSERT(index < numEnumVals());
-
-    return(mEnumVals[index]);
-}
-
-void DefinitionImpl::setEnumVals(const char **enum_vals, int32_t n)
-{
-    SET_ARRAY(char *, enum_vals, mEnumVals, mNumEnumVals);
-}
-
-void DefinitionImpl::addEnumVal(const char *enum_val)
-{
-    PX_ASSERT(enum_val != NULL);
-
-    char *NewEnumVal = COND_DUP(enum_val);
-    PUSH_TO_ARRAY(NewEnumVal, mEnumVals, char *, mNumEnumVals)
-}
-
-int32_t DefinitionImpl::refVariantValIndex( const char * ref_val ) const
-{
-	if(!ref_val)
-		return(-1);
-
-	for(int32_t i=0; i < numRefVariants(); ++i)
-	{
-        if( !strcmp( refVariantVal(i), ref_val ) )
-		{
-            return(i);
-		}
-	}
-
-	return(-1);
-}
-
-int32_t DefinitionImpl::numRefVariants(void) const
-{
-	return(mNumRefVariants);
-}
-
-const char *DefinitionImpl::refVariantVal(int32_t index) const
-{
-    PX_ASSERT(index >= 0);
-    PX_ASSERT(index < numRefVariants());
-
-    return(mRefVariantVals[index]);
-}
-
-void DefinitionImpl::setRefVariantVals(const char **ref_vals, int32_t n)
-{
-    SET_ARRAY(char *, ref_vals, mRefVariantVals, mNumRefVariants);
-}
-
-void DefinitionImpl::addRefVariantVal(const char *ref_val)
-{
-    PX_ASSERT(ref_val != NULL);
-
-    char *NewEnumVal = COND_DUP(ref_val);
-    PUSH_TO_ARRAY(NewEnumVal, mRefVariantVals, char *, mNumRefVariants)
-}
-
-void DefinitionImpl::setDynamicHandleIndicesMap(const uint8_t *indices, uint32_t numIndices)
-{
-	mNumDynamicHandleIndices = numIndices;
-	mDynamicHandleIndices = indices;
-}
-
-const uint8_t * DefinitionImpl::getDynamicHandleIndicesMap(uint32_t &outNumIndices) const
-{
-	outNumIndices = mNumDynamicHandleIndices;
-	return mDynamicHandleIndices;
-}
-
-bool DefinitionImpl::isSimpleType(bool simpleStructs, bool simpleStrings) const
-{
-	switch(mType)
-	{
-	case TYPE_STRUCT:
-		if( !simpleStructs )
-			return false;
-
-		for(int32_t i = 0; i < mNumChildren; ++i)
-		{
-			if( !mChildren[i]->isSimpleType(simpleStructs, simpleStrings) )
-				return false;
-		}
-
-		return true;
-
-	case TYPE_ARRAY:
-	case TYPE_REF:
-		return false;
-
-	NV_PARAMETRIZED_NO_AGGREGATE_AND_REF_DATATYPE_LABELS
-	default:
-		PX_ASSERT( mNumChildren == 0 );
-		return true;
-	}
-}
-
-//******************************************************************************
-//*** class NvParameterized
-//******************************************************************************
-
-NvParameters::NvParameters(Traits *traits, void *buf, int32_t *refCount)
-{
-	mParameterizedTraits = traits;
-
-	if( buf )
-	{
-		mBuffer = buf;
-		mRefCount = refCount;
-
-		//Values of other fields are already deserialized
-	}
-	else
-	{
-		mName = mClassName = NULL;
-		mDoDeallocateName = mDoDeallocateClassName = mDoDeallocateSelf = true;
-
-		mSerializationCb = NULL;
-		mCbUserData = NULL;
-
-		mBuffer = NULL;
-		mRefCount = NULL;
-
-		//Other fields are used only for inplace objects => skip them
-	}
-}
-
-NvParameters::~NvParameters()
-{
-	if( mClassName && mDoDeallocateClassName )
-	{
-		mParameterizedTraits->strfree( const_cast<char*>(mClassName) );
-		mClassName = NULL;
-	}
-
-	if( mName && mDoDeallocateName )
-	{
-		mParameterizedTraits->strfree( const_cast<char*>(mName) );
-		mName = NULL;
-	}
-}
-
-// placement delete
-void NvParameters::destroy()
-{
-	// We cache these fields here to avoid overwrite in destructor
-	bool doDeallocateSelf = mDoDeallocateSelf;
-	void *buf = mBuffer;
-	int32_t *refCount = mRefCount;
-	NvParameterized::Traits *traits = mParameterizedTraits;
-
-	this->~NvParameters();
-
-	destroy(this, traits, doDeallocateSelf, refCount, buf);
-}
-
-void NvParameters::destroy(NvParameters *obj, NvParameterized::Traits *traits, bool doDeallocateSelf, int32_t *refCount, void *buf)
-{
-	if( !doDeallocateSelf )
-		return;
-
-	if( !refCount ) //Ordinary object?
-		{
-		traits->free(obj);
-			return;
-		}
-
-		//Inplace object => callback client
-
-	traits->onInplaceObjectDestroyed(buf, obj);
-	if( !traits->decRefCount(refCount) )
-		traits->onAllInplaceObjectsDestroyed(buf);
-}
-
-
-uint16_t NvParameters::getMajorVersion(void) const
-{
-	uint16_t major = version() >> 16;
-	return major;
-}
-
-uint16_t NvParameters::getMinorVersion(void) const
-{
-	uint16_t minor = version() & 0xffff;
-	return minor;
-}
-
-void NvParameters::initRandom(void)
-{
-	Handle handle(*this, "");
-	initRandom(handle);
-}
-
-void NvParameters::initRandom(NvParameterized::Handle& handle)
-{
-	NvParameterized::ErrorType error;
-
-	const Definition* pd = handle.parameterDefinition();
-	switch( pd->type() )
-	{
-	case TYPE_STRUCT:
-		{
-			for(int32_t i = 0; i < pd->numChildren(); ++i)
-			{
-				handle.set(i);
-				initRandom(handle);
-				handle.popIndex();
-			}
-
-			break;
-		}
-
-	case TYPE_ARRAY:
-		{
-			if (!pd->arraySizeIsFixed())
-			{
-				error = handle.resizeArray(int32_t(10 * (double)rand() / RAND_MAX));
-				DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-			}
-
-			int32_t size;
-			error = handle.getArraySize(size);
-			PX_ASSERT(error == ERROR_NONE);
-
-			DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-
-			for(int32_t i = 0; i < size; ++i)
-			{
-				handle.set(i);
-				initRandom(handle);
-				handle.popIndex();
-			}
-
-			break;
-		}
-
-	case TYPE_REF:
-		{
-			if (!pd->numRefVariants())
-				break; // Can't do anything without refVariants-hint
-
-			PX_ASSERT(pd->numRefVariants() > 0);
-			uint32_t refIdx = RandomIdx(0U, pd->numRefVariants() - 1U);
-			const char* className = pd->refVariantVal(static_cast<int32_t>(refIdx));
-			if( mParameterizedTraits->doesFactoryExist(className) ) {
-				error = initParamRef(handle, className, true);
-				DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-
-				NvParameterized::Interface* obj = NULL;
-				error = handle.getParamRef(obj);
-				DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-			}
-
-			break;
-		}
-
-	case TYPE_BOOL:
-		error = handle.setParamBool( 0 == RandomU32() % 2 );
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-
-	case TYPE_STRING:
-		{
-			char s[10];
-			int32_t len = (int32_t)( (size_t)rand() % sizeof(s) );
-			for(int32_t i = 0; i < len; ++i)
-				s[i] = 'a' + rand() % ('z' - 'a');
-			s[len] = 0;
-
-			error = handle.setParamString(s);
-			DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-			break;
-		}
-
-	case TYPE_ENUM:
-		{
-			uint32_t enumIdx = RandomIdx(0U, static_cast<uint32_t>(pd->numEnumVals()-1));
-			error = handle.setParamEnum(pd->enumVal(static_cast<int32_t>(enumIdx)));
-			DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-			break;
-		}
-
-	case TYPE_I8:
-		error = handle.setParamI8((int8_t)(RandomU32() & 0xff));
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-
-	case TYPE_U8:
-		error = handle.setParamU8((uint8_t)(RandomU32() & 0xff));
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-
-	case TYPE_I16:
-		error = handle.setParamI16((int16_t)(RandomU32() & 0xffff));
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-
-	case TYPE_U16:
-		error = handle.setParamU16((uint16_t)(RandomU32() & 0xffff));
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-
-	case TYPE_I32:
-		error = handle.setParamI32((int32_t)RandomU32());
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-
-	case TYPE_U32:
-		error = handle.setParamU32((uint32_t)RandomU32());
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-
-	case TYPE_I64:
-		error = handle.setParamI64((int64_t)RandomU64());
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-
-	case TYPE_U64:
-		error = handle.setParamU64(RandomU64());
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-
-	case TYPE_F32:
-		error = handle.setParamF32(RandomF32());
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-
-	case TYPE_F64:
-		error = handle.setParamF64(RandomF64());
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-
-	case TYPE_VEC2:
-		error = handle.setParamVec2(RandomVec2());
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-
-	case TYPE_VEC3:
-		error = handle.setParamVec3(RandomVec3());
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-
-	case TYPE_VEC4:
-		error = handle.setParamVec4(RandomVec4());
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-
-	case TYPE_QUAT:
-		error = handle.setParamQuat(RandomQuat());
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-
-	case TYPE_MAT33:
-		error = handle.setParamMat33(physx::PxMat33(RandomVec3(), RandomVec3(), RandomVec3()));
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-
-	case TYPE_BOUNDS3:
-		error = handle.setParamBounds3(physx::PxBounds3(RandomVec3(), RandomVec3()));
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-
-	case TYPE_MAT44:
-		error = handle.setParamMat44(physx::PxMat44(RandomVec4(), RandomVec4(), RandomVec4(), RandomVec4()));
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-
-	case TYPE_MAT34:
-		{
-			float f[12] = { RandomF32(), RandomF32(), RandomF32(), RandomF32(), 
-							RandomF32(), RandomF32(), RandomF32(), RandomF32(), 
-							RandomF32(), RandomF32(), RandomF32(), RandomF32() };
-			error = handle.setParamMat34Legacy(f);
-			DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-			break;
-		}
-
-	case TYPE_POINTER:
-		// We can't init pointers :(
-		break;
-
-	case TYPE_TRANSFORM:
-	{
-		// PxTransform asserts if the quat isn't "sane"
-		physx::PxQuat q;
-		do { 
-			q = RandomQuat();
-		} while (!q.isSane());
-
-		error = handle.setParamTransform(physx::PxTransform(RandomVec3(),q));
-		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );
-		break;
-	}
-	NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS
-	default:
-		PX_ALWAYS_ASSERT();
-	}
-
-	PX_UNUSED(error); // Make compiler happy
-}
-
-void NvParameters::setClassName(const char *name) 
-{ 
-	if(mParameterizedTraits)
-	{
-		if( mClassName )
-		{
-			if( !strcmp( mClassName, name ) )
-				return;
-
-			if( mDoDeallocateClassName )
-				mParameterizedTraits->strfree( const_cast<char*>(mClassName) );
-		}
-
-		mClassName = mParameterizedTraits->strdup(name);
-	}
-	else
-	{
-		mClassName = name;
-	}
-
-	mDoDeallocateClassName = true;
-}
-
-void NvParameters::setName(const char *name) 
-{ 
-	if(mParameterizedTraits)
-	{
-		if( mName )
-		{
-			if( !strcmp( mName, name ) )
-				return;
-
-			if( mDoDeallocateName )
-				mParameterizedTraits->strfree( const_cast<char*>(mName) );
-		}
-
-		mName = mParameterizedTraits->strdup(name);
-	}
-	else
-	{
-		mName = name; 
-	}
-
-	mDoDeallocateName = true;
-}
-
-void NvParameters::setSerializationCallback(SerializationCallback *cb, void *userData)
-{
-	mSerializationCb = cb;
-	mCbUserData = userData;
-}
-
-ErrorType NvParameters::callPreSerializeCallback() const
-{
-	if(mSerializationCb)
-	{
-		mSerializationCb->preSerialize(mCbUserData);
-	}
-
-	Handle handle(*this);
-
-	NV_ERR_CHECK_RETURN( getParameterHandle("", handle) );
-
-	return callPreSerializeCallback(handle);
-}
-
-int32_t NvParameters::numParameters(void) 
-{
-    return(rootParameterDefinition()->numChildren());
-}
-
-const Definition *NvParameters::parameterDefinition(int32_t index) 
-{
-    return(rootParameterDefinition()->child(index));
-}
-
-const Definition *NvParameters::rootParameterDefinition(void)
-{
-    return(getParameterDefinitionTree());
-}
-
-const Definition *NvParameters::rootParameterDefinition(void) const
-{
-    return(getParameterDefinitionTree());
-}
-
-ErrorType NvParameters::getParameterHandle(const char *long_name, Handle &handle) const
-{
-	ErrorType result = ERROR_NONE;
-
-	PX_ASSERT( handle.getConstInterface() == this );
-	
-	if( rootParameterDefinition() == NULL )
-	{
-		handle.reset();
-		result = (ERROR_INVALID_CALL_ON_NAMED_REFERENCE);
-	}
-	else
-	{
-		result = handle.set(this,rootParameterDefinition(), long_name);
-	}
-
-	PX_ASSERT(result == ERROR_NONE);
-
-    return result;
-}
-
-ErrorType NvParameters::getParameterHandle(const char *long_name, Handle &handle)
-{
-	ErrorType result = ERROR_NONE;
-
-	PX_ASSERT( handle.getConstInterface() == this );
-
-	if( rootParameterDefinition() == NULL )
-	{
-		handle.reset();
-		result = (ERROR_INVALID_CALL_ON_NAMED_REFERENCE);
-	}
-	else
-	{
-		result = handle.set(this,rootParameterDefinition(), long_name);
-	}
-
-	PX_ASSERT(result == ERROR_NONE);
-
-	return result;
-}
-
-#ifndef NV_CHECKED
-#	define CHECK_HANDLE
-#	define CHECK_IS_SIMPLE_ARRAY(type_enum_name)
-#else
-#	define CHECK_HANDLE \
-		{ \
-	        ErrorType result = checkParameterHandle(handle); \
-			PX_ASSERT(result == ERROR_NONE); \
-		    if(result != ERROR_NONE) \
-			    return(result); \
-		}
-#	define CHECK_IS_SIMPLE_ARRAY(type_enum_name) \
-		{ \
-			PX_ASSERT(offset >= 0);\
-	        PX_ASSERT(n >= 0);\
-		    if(handle.parameterDefinition()->type() != TYPE_ARRAY) \
-			{\
-				PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_NOT_AN_ARRAY");\
-			    return(ERROR_NOT_AN_ARRAY); \
-			}\
-	        if(handle.parameterDefinition()->child(0)->type() != TYPE_##type_enum_name) \
-			{\
-  			    PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");\
-		        return(ERROR_CAST_FAILED); \
-			}\
-			int32_t arraySize; \
-	        ErrorType error; \
-		    if((error = getArraySize(handle, arraySize)) != ERROR_NONE) \
-			{\
-				PX_ASSERT(error == ERROR_NONE); \
-			    return(error); \
-			}\
-	        if( offset + n > arraySize) \
-			{\
-				PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_ARRAY_IS_TOO_SMALL");\
-				return(ERROR_ARRAY_IS_TOO_SMALL); \
-			}\
-		}
-#endif
-
-template <class Type > ErrorType rawGetParam(const Handle &handle,Type &val,const NvParameters *parent)
-{
-	size_t offset;
-	void *ptr=NULL;
-	parent->getVarPtr(handle, ptr, offset);
-	if ( ptr == NULL )
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_TYPE_NOT_SUPPORTED");
-		return ERROR_TYPE_NOT_SUPPORTED;
-	}
-	Type *var = (Type *)((char *)ptr);
-	val = *var;
-	return(ERROR_NONE);
-}
-
-template <class Type > ErrorType rawSetParam(const Handle &handle,const Type &val,NvParameters *parent)
-{
-	size_t offset;
-	void *ptr=NULL;
-	parent->getVarPtr(handle, ptr, offset);
-	if(ptr == NULL)
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");
-		return(ERROR_INDEX_OUT_OF_RANGE);
-	}
-	Type *Var = (Type *)((char *)ptr);
-	*Var = val;
-	return(ERROR_NONE);
-}
-
-template <class Type >ErrorType rawGetParamArray(const Handle &handle,Type *array, int32_t n, int32_t offset,const NvParameters *parent) 
-{
-	int32_t size;
-	NV_ERR_CHECK_RETURN(handle.getArraySize(size));
-	if( size < offset + n )
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");
-		return(ERROR_INDEX_OUT_OF_RANGE);
-	}
-
-	if( n )
-	{
-		Handle memberHandle(handle);
-		NV_ERR_CHECK_RETURN(memberHandle.set(offset));
-
-		size_t tmp;
-		void *ptr=NULL;
-		parent->getVarPtr(memberHandle, ptr, tmp);
-		if(ptr == NULL)
-		{
-			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");
-			return(ERROR_INDEX_OUT_OF_RANGE);
-		}
-
-		physx::intrinsics::memCopy(array, ptr, n * sizeof(Type));
-	}
-
-	return(ERROR_NONE);
-}
-
-template <class Type> ErrorType rawSetParamArray(const Handle &handle, const Type *array, int32_t n, int32_t offset,NvParameters *parent)
-{
-	int32_t size;
-	NV_ERR_CHECK_RETURN(handle.getArraySize(size));
-	if( size < offset + n )
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");
-		return(ERROR_INDEX_OUT_OF_RANGE);
-	}
-
-	if( n )
-	{
-		Handle memberHandle(handle);
-		NV_ERR_CHECK_RETURN(memberHandle.set(offset));
-
-		size_t tmp;
-		void *ptr=NULL;
-		parent->getVarPtr(memberHandle, ptr, tmp);
-		if(ptr == NULL)
-		{
-			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");
-			return(ERROR_INDEX_OUT_OF_RANGE);
-		}
-
-		physx::intrinsics::memCopy(ptr, array, n * sizeof(Type));
-	}
-
-	return(ERROR_NONE);
-}
-
-//******************************************************************************
-//*** Bool
-//******************************************************************************
-
-ErrorType NvParameters::getParamBool(const Handle &handle, bool &val) const
-{
-    CHECK_HANDLE
-
-    if(handle.parameterDefinition()->type() == TYPE_BOOL)
-    {
-		return rawGetParamBool(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::setParamBool(const Handle &handle, bool val)
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_BOOL)
-    {
-        return rawSetParamBool(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamBoolArray(const Handle &handle, bool *array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(BOOL)
-    return(rawGetParamBoolArray(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamBoolArray(const Handle &handle, const bool *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(BOOL)
-    return(rawSetParamBoolArray(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** String
-//******************************************************************************
-
-ErrorType NvParameters::getParamString(const Handle &handle, const char *&val) const
-{
-    CHECK_HANDLE
-
-    if(handle.parameterDefinition()->type() == TYPE_ENUM)
-    {
-        return rawGetParamEnum(handle, val);
-    }
-    
-	if(handle.parameterDefinition()->type() == TYPE_STRING)
-    {
-        return rawGetParamString(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::setParamString(const Handle &handle, const char *val)
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_STRING)
-    {
-        return rawSetParamString(handle, val);
-    }
-
-	if(handle.parameterDefinition()->type() == TYPE_ENUM)
-    {
-        return rawSetParamEnum(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::rawGetParamStringArray(const Handle &handle, char **array, int32_t n, int32_t offset) const
-{
-	Handle memberHandle(handle);
-	for(int32_t i=0; i < n; ++i)
-	{
-		ErrorType error;
-		if((error = memberHandle.set(i + offset)) != ERROR_NONE)
-		{
-			PX_ASSERT(error == ERROR_NONE);
-			return(error);
-		}
-
-		const char * tmp;
-		if((error = rawGetParamString(memberHandle, tmp)) != ERROR_NONE)
-		{
-			PX_ASSERT(error == ERROR_NONE);
-			return(error);
-		}
-
-		array[i] = const_cast<char*>(tmp);
-		memberHandle.popIndex();
-	}
-	return(ERROR_NONE);
-}
-
-
-ErrorType NvParameters::getParamStringArray(const Handle &handle, char **array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(STRING)
-    return(rawGetParamStringArray(handle, array, n, offset));
-}
-
-ErrorType NvParameters::rawSetParamStringArray(const Handle &handle, const char **array, int32_t n, int32_t offset)
-{
-	Handle memberHandle(handle);
-	for(int32_t i=0; i < n; ++i)
-	{
-		ErrorType error;
-		if((error = memberHandle.set(i + offset)) != ERROR_NONE)
-		{
-			PX_ASSERT(error == ERROR_NONE);
-			return(error);
-		}
-
-		if((error = rawSetParamString(memberHandle, array[i] )) != ERROR_NONE)
-		{
-			PX_ASSERT(error == ERROR_NONE);
-			return(error);
-		}
-
-		memberHandle.popIndex();
-	}
-	return(ERROR_NONE);
-}
-
-ErrorType NvParameters::setParamStringArray(const Handle &handle, const char **array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(STRING)
-    return(rawSetParamStringArray(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** Enum
-//******************************************************************************
-
-ErrorType NvParameters::getParamEnum(const Handle &handle, const char *&val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_STRING)
-    {
-        return rawGetParamString(handle, val);
-    }
-
-	if(handle.parameterDefinition()->type() == TYPE_ENUM)
-    {
-        return rawGetParamEnum(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");    
-    return(ERROR_CAST_FAILED);
-}
-
-// returns the actual enum string from the ParameterDefintion object, which should be good for the liftetime
-// of the DefinitionImpl object.  Returns NULL if no such enum exists.
-static const char* getEnumString(const Handle &handle, const char* str)
-{
-    PX_ASSERT(str != NULL);
-
-    const Definition* paramDef = handle.parameterDefinition();
-    PX_ASSERT(paramDef != NULL);
-    PX_ASSERT(paramDef->type() == TYPE_ENUM);
-
-    for (int32_t i = 0; i < paramDef->numEnumVals(); ++i)
-        if(!strcmp(paramDef->enumVal(i), str))
-            return(paramDef->enumVal(i));
-
-    return(NULL);    
-}
-
-ErrorType NvParameters::setParamEnum(const Handle &handle, const char *val)
-{
-    CHECK_HANDLE
-
-    val = getEnumString(handle, val);
-    if(val == NULL)
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_ENUM_VAL");
-        return(ERROR_INVALID_ENUM_VAL);
-	}
-
-	if(handle.parameterDefinition()->type() == TYPE_ENUM)
-    {
-        return rawSetParamEnum(handle, val);
-    }
-
-	if(handle.parameterDefinition()->type() == TYPE_STRING)
-    {
-        return rawSetParamString(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-	return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::rawGetParamEnumArray(const Handle &handle, char **array, int32_t n, int32_t offset) const
-{
-	Handle memberHandle(handle);
-	for(int32_t i=0; i < n; ++i)
-	{
-		ErrorType error; 
-		if((error = memberHandle.set(i + offset)) != ERROR_NONE)
-			return(error);
-		const char * tmp;
-		if((error = rawGetParamEnum(memberHandle, tmp)) != ERROR_NONE)
-			return(error);
-		array[i] = const_cast<char*>(tmp);
-		memberHandle.popIndex();
-	}
-	return(ERROR_NONE);
-}
-
-ErrorType NvParameters::rawSetParamEnumArray(const Handle &handle, const char **array, int32_t n, int32_t offset)
-{
-	Handle memberHandle(handle);
-	for(int32_t i=0; i < n; ++i)
-	{
-		ErrorType error;
-		if((error = memberHandle.set(i + offset)) != ERROR_NONE)
-			return(error);
-		if((error = rawSetParamEnum(memberHandle, array[i])) != ERROR_NONE)
-			return(error);
-		memberHandle.popIndex();
-	}
-	return(ERROR_NONE);
-}
-
-ErrorType NvParameters::getParamEnumArray(const Handle &handle, char **array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(ENUM)
-    return(rawGetParamEnumArray(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamEnumArray(const Handle &handle, const char **array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(ENUM)
-    return(rawSetParamEnumArray(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** Ref
-//******************************************************************************
-
-ErrorType NvParameters::initParamRef(const Handle &handle, const char *inChosenRefStr, bool doDestroyOld)
-{
-	CHECK_HANDLE
-
-	NvParameterized::Interface *param = NULL;
-	const char *chosenRefStr = inChosenRefStr;
-
-	// create NvParam object (depends on if it's included or not)
-	const Hint *hint = handle.parameterDefinition()->hint("INCLUDED");
-	if (hint && hint->type() != TYPE_U64)
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_REFERENCE_INCLUDE_HINT");
-		return(ERROR_INVALID_REFERENCE_INCLUDE_HINT);
-	}
-
-	if (hint != NULL && hint->asUInt() == 1)
-	{
-		// included
-
-		if (chosenRefStr == 0 && handle.parameterDefinition()->numRefVariants() > 1)
-		{
-			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_REFERENCE_VALUE");
-			return(ERROR_INVALID_REFERENCE_VALUE);
-		}
-
-		for (int32_t i = 0; i < handle.parameterDefinition()->numRefVariants(); i++)
-		{
-			if (!strcmp(handle.parameterDefinition()->refVariantVal(i), chosenRefStr))
-			{
-				// create an object of type chosenRefStr, somehow
-				param = mParameterizedTraits->createNvParameterized(chosenRefStr);
-				if (!param)
-				{
-					PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_OBJECT_CONSTRUCTION_FAILED");
-					return ERROR_OBJECT_CONSTRUCTION_FAILED;
-				}
-
-				return setParamRef(handle, param, doDestroyOld);
-			}
-		}
-		// PH: debug hint
-		// If you land here, you should compare chosenRefStr and handle.mParameterDefinition.mRefVariantVals
-		// to see why it couldn't find anything, and then fix the .pl
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_REFERENCE_VALUE");
-		return(ERROR_INVALID_REFERENCE_VALUE);
-	}
-	else
-	{
-		// not included, just create generic NvParameterized
-		param = NV_PARAM_PLACEMENT_NEW(mParameterizedTraits->alloc(sizeof(NvParameters)), NvParameters)(mParameterizedTraits);
-		if (!param)
-		{
-			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_OBJECT_CONSTRUCTION_FAILED");
-			return ERROR_OBJECT_CONSTRUCTION_FAILED;
-		}
-
-		if (chosenRefStr == 0)
-		{
-			param->setClassName(handle.parameterDefinition()->refVariantVal(0));
-		}
-		else
-		{
-			bool found = false;
-			for (int32_t i = 0; i < handle.parameterDefinition()->numRefVariants(); i++)
-			{
-				if (!strcmp(handle.parameterDefinition()->refVariantVal(i), chosenRefStr))
-				{
-					param->setClassName(handle.parameterDefinition()->refVariantVal(i));
-					found = true;
-					break;
-				}
-			}
-			if ( !found )
-			{
-				// ensure that we free this memory that we've allocated
-				mParameterizedTraits->free(param);
-				PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_REFERENCE_VALUE");
-				return(ERROR_INVALID_REFERENCE_VALUE);
-			}
-		}
-		return setParamRef(handle, param, doDestroyOld);
-	}
-}
-
-ErrorType NvParameters::getParamRef(const Handle &handle, NvParameterized::Interface *&val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_REF)
-    {
-        return rawGetParamRef(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::setParamRef(const Handle &handle, NvParameterized::Interface *val, bool doDestroyOld)
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_REF)
-    {
-		if (doDestroyOld)
-		{
-			NvParameterized::Interface *param = NULL;
-
-			getParamRef(handle, param);
-			if(param)
-			{
-				param->destroy();
-				param = NULL;
-			}
-		}
-        return rawSetParamRef(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::rawGetParamRefArray(const Handle &handle, NvParameterized::Interface **array, int32_t n, int32_t offset) const
-{
-	Handle memberHandle(handle);
-	for(int32_t i=0; i < n; ++i)
-	{
-		ErrorType error; 
-		if((error = memberHandle.set(i + offset)) != ERROR_NONE)
-			return(error);
-		NvParameterized::Interface * tmp;
-		if((error = rawGetParamRef(memberHandle, tmp)) != ERROR_NONE)
-			return(error);
-		array[i] = tmp;
-		memberHandle.popIndex();
-	}
-	return(ERROR_NONE);
-}
-
-ErrorType NvParameters::rawSetParamRefArray(const Handle &handle,NvParameterized::Interface **array, int32_t n, int32_t offset)
-{
-	Handle memberHandle(handle);
-	for(int32_t i=0; i < n; ++i) 
-	{ 
-		ErrorType error;
-		if((error = memberHandle.set(i + offset)) != ERROR_NONE) 
-			return(error); 
-		if((error = rawSetParamRef(memberHandle, array[i])) != ERROR_NONE)
-			return(error); 
-		memberHandle.popIndex(); 
-	} 
-
-	return(ERROR_NONE);
-}
-
-ErrorType NvParameters::getParamRefArray(const Handle &handle, NvParameterized::Interface * *array, int32_t n, int32_t offset) const
-{ 
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(REF)
-    return(rawGetParamRefArray(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamRefArray(const Handle &handle, /*const*/ NvParameterized::Interface **array, int32_t n, int32_t offset, bool doDestroyOld)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(REF)
-
-	Handle memberHandle(handle);
-	for(int32_t i = 0; i < n; ++i) 
-	{ 
-		ErrorType error;
-		if((error = memberHandle.set(i + offset)) != ERROR_NONE)
-		{
-			return(error); 
-		}
-
-		if((error = setParamRef(memberHandle, array[i]), doDestroyOld) != ERROR_NONE)
-		{
-			return(error); 
-		}
-		memberHandle.popIndex(); 
-	}
-	return(ERROR_NONE);
-}
-
-//******************************************************************************
-//*** I8
-//******************************************************************************
-
-ErrorType NvParameters::getParamI8(const Handle &handle, int8_t &val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_I8)
-    {
-        return rawGetParamI8(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::setParamI8(const Handle &handle, int8_t val)
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_I8)
-    {
-        return rawSetParamI8(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamI8Array(const Handle &handle, int8_t *array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(I8)
-    return(rawGetParamI8Array(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamI8Array(const Handle &handle, const int8_t *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(I8)
-    return(rawSetParamI8Array(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** I16
-//******************************************************************************
-
-ErrorType NvParameters::getParamI16(const Handle &handle, int16_t &val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_I8)
-    {
-        int8_t tmp;
-        ErrorType result = rawGetParamI8(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (int16_t)tmp;
-        return(ERROR_NONE);
-    }
-
-	if(handle.parameterDefinition()->type() == TYPE_I16)
-    {
-        return rawGetParamI16(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::setParamI16(const Handle &handle, int16_t val)
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_I16)
-    {
-        return rawSetParamI16(handle, val);
-    }
-	if(handle.parameterDefinition()->type() == TYPE_I8)
-    {
-        return rawSetParamI8(handle, (int8_t)val);
-    }
-	if(handle.parameterDefinition()->type() == TYPE_U8)
-    {
-        return rawSetParamU8(handle, (uint8_t)val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamI16Array(const Handle &handle, int16_t *array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(I16)
-    return(rawGetParamI16Array(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamI16Array(const Handle &handle, const int16_t *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(I16)
-    return(rawSetParamI16Array(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** I32
-//******************************************************************************
-
-ErrorType NvParameters::getParamI32(const Handle &handle, int32_t &val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_I8)
-    {
-        int8_t tmp;
-        ErrorType result = rawGetParamI8(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (int32_t)tmp;
-        return(ERROR_NONE);
-    }
-	
-	if(handle.parameterDefinition()->type() == TYPE_I16)
-    {
-        int16_t tmp;
-        ErrorType result = rawGetParamI16(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (int32_t)tmp;
-        return(ERROR_NONE);
-    }
-
-	if(handle.parameterDefinition()->type() == TYPE_I32)
-    {
-        int32_t tmp;
-        ErrorType result = rawGetParamI32(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (int32_t)tmp;
-        return(ERROR_NONE);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::setParamI32(const Handle &handle, int32_t val)
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_I32)
-    {
-        return rawSetParamI32(handle, val);
-    }
-	if(handle.parameterDefinition()->type() == TYPE_I16)
-    {
-        return rawSetParamI16(handle, (int16_t)val);
-    }
-	if(handle.parameterDefinition()->type() == TYPE_U16)
-    {
-        return rawSetParamU16(handle, (uint16_t)val);
-    }
-	if(handle.parameterDefinition()->type() == TYPE_I8)
-    {
-        return rawSetParamI8(handle, (int8_t) val);
-    }
-	if(handle.parameterDefinition()->type() == TYPE_U8)
-    {
-        return rawSetParamU8(handle, (uint8_t) val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamI32Array(const Handle &handle, int32_t *array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(I32)
-    return(rawGetParamI32Array(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamI32Array(const Handle &handle, const int32_t *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(I32)
-    return(rawSetParamI32Array(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** I64
-//******************************************************************************
-
-ErrorType NvParameters::getParamI64(const Handle &handle, int64_t &val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_I8)
-    {
-        int8_t tmp;
-        ErrorType result = rawGetParamI8(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (int64_t)tmp;
-        return(ERROR_NONE);
-    }
-	
-	if(handle.parameterDefinition()->type() == TYPE_I16)
-    {
-        int16_t tmp;
-        ErrorType result = rawGetParamI16(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (int64_t)tmp;
-        return(ERROR_NONE);
-    }
-
-	if(handle.parameterDefinition()->type() == TYPE_I32)
-    {
-        int32_t tmp;
-        ErrorType result = rawGetParamI32(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (int64_t)tmp;
-        return(ERROR_NONE);
-    }
-
-	if(handle.parameterDefinition()->type() == TYPE_I64)
-    {
-        int64_t tmp;
-        ErrorType result = rawGetParamI64(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (int64_t)tmp;
-        return(ERROR_NONE);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::setParamI64(const Handle &handle, int64_t val)
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_I64)
-    {
-        return rawSetParamI64(handle, val);
-    }
-	if(handle.parameterDefinition()->type() == TYPE_U32)
-    {
-        return rawSetParamU32(handle, (uint32_t)val);
-    }
-	if(handle.parameterDefinition()->type() == TYPE_I32)
-    {
-        return rawSetParamI32(handle, (int32_t)val);
-    }
-	if(handle.parameterDefinition()->type() == TYPE_I16)
-    {
-        return rawSetParamI16(handle, (int16_t)val);
-    }
-	if(handle.parameterDefinition()->type() == TYPE_U16)
-    {
-        return rawSetParamU16(handle, (uint16_t) val);
-    }
-	if(handle.parameterDefinition()->type() == TYPE_I8)
-    {
-        return rawSetParamI8(handle, (int8_t)val);
-    }
-	if(handle.parameterDefinition()->type() == TYPE_U8)
-    {
-        return rawSetParamU8(handle, (uint8_t)val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamI64Array(const Handle &handle, int64_t *array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(I64)
-    return(rawGetParamI64Array(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamI64Array(const Handle &handle, const int64_t *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(I64)
-    return(rawSetParamI64Array(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** U8
-//******************************************************************************
-
-ErrorType NvParameters::getParamU8(const Handle &handle, uint8_t &val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_U8)
-    {
-        return rawGetParamU8(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::setParamU8(const Handle &handle, uint8_t val)
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_U8)
-    {
-        return rawSetParamU8(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::setParamU8Array(const Handle &handle, const uint8_t *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(U8)
-    return(rawSetParamU8Array(handle, array, n, offset));
-}
-
-
-//******************************************************************************
-//*** U16
-//******************************************************************************
-
-ErrorType NvParameters::getParamU16(const Handle &handle, uint16_t &val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_U8)
-    {
-        uint8_t tmp;
-        ErrorType result = rawGetParamU8(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (uint16_t)tmp;
-        return(ERROR_NONE);
-    }
-
-	if(handle.parameterDefinition()->type() == TYPE_U16)
-    {
-        uint16_t tmp;
-        ErrorType result = rawGetParamU16(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (uint16_t)tmp;
-        return(ERROR_NONE);
-    }
-	
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-	return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::setParamU16(const Handle &handle, uint16_t val)
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_U16)
-    {
-        return rawSetParamU16(handle, val);
-    }
-	if(handle.parameterDefinition()->type() == TYPE_U8)
-    {
-        return rawSetParamU8(handle, (uint8_t)val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamU16Array(const Handle &handle, uint16_t *array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(U16)
-    return(rawGetParamU16Array(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamU16Array(const Handle &handle, const uint16_t *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(U16)
-    return(rawSetParamU16Array(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** U32
-//******************************************************************************
-
-ErrorType NvParameters::getParamU32(const Handle &handle, uint32_t &val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_U8)
-    {
-        uint8_t tmp;
-        ErrorType result = rawGetParamU8(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (uint32_t)tmp;
-        return(ERROR_NONE);
-    }
-
-	if(handle.parameterDefinition()->type() == TYPE_U16)
-    {
-        uint16_t tmp;
-        ErrorType result = rawGetParamU16(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (uint32_t)tmp;
-        return(ERROR_NONE);
-    }
-
-	if(handle.parameterDefinition()->type() == TYPE_U32)
-    {
-        uint32_t tmp;
-        ErrorType result = rawGetParamU32(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (uint32_t)tmp;
-        return(ERROR_NONE);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::setParamU32(const Handle &handle, uint32_t val)
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_U32)
-    {
-        return rawSetParamU32(handle, val);
-    }
-	if(handle.parameterDefinition()->type() == TYPE_U16)
-    {
-        return rawSetParamU16(handle, (uint16_t)val);
-    }
-	if(handle.parameterDefinition()->type() == TYPE_U8)
-    {
-        return rawSetParamU8(handle, (uint8_t)val);
-    }
-	
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamU32Array(const Handle &handle, uint32_t *array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(U32)
-    return(rawGetParamU32Array(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamU32Array(const Handle &handle, const uint32_t *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(U32)
-    return(rawSetParamU32Array(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** U64
-//******************************************************************************
-
-ErrorType NvParameters::getParamU64(const Handle &handle, uint64_t &val) const
-{
-    CHECK_HANDLE
-
-	if (handle.parameterDefinition()->type() == TYPE_BOOL)
-	{
-		bool tmp;
-		ErrorType result = rawGetParamBool(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-		if (result != ERROR_NONE)
-			return(result);
-		val = (uint64_t)tmp;
-		return(ERROR_NONE);
-	}
-
-	if (handle.parameterDefinition()->type() == TYPE_U8)
-    {
-        uint8_t tmp;
-        ErrorType result = rawGetParamU8(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (uint64_t)tmp;
-        return(ERROR_NONE);
-    }
-
-	if(handle.parameterDefinition()->type() == TYPE_U16)
-    {
-        uint16_t tmp;
-        ErrorType result = rawGetParamU16(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (uint64_t)tmp;
-        return(ERROR_NONE);
-    }
-
-	if(handle.parameterDefinition()->type() == TYPE_U32)
-    {
-        uint32_t tmp;
-        ErrorType result = rawGetParamU32(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (uint64_t)tmp;
-        return(ERROR_NONE);
-    }
-
-	if(handle.parameterDefinition()->type() == TYPE_U64)
-    {
-        uint64_t tmp;
-        ErrorType result = rawGetParamU64(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (uint64_t)tmp;
-        return(ERROR_NONE);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::setParamU64(const Handle &handle, uint64_t val)
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_U64)
-    {
-        return rawSetParamU64(handle, val);
-    }
-
-	if(handle.parameterDefinition()->type() == TYPE_U32)
-    {
-        return rawSetParamU32(handle, (uint32_t)val);
-    }
-
-	if(handle.parameterDefinition()->type() == TYPE_U16)
-    {
-        return rawSetParamU16(handle, (uint16_t)val);
-    }
-
-	if(handle.parameterDefinition()->type() == TYPE_U8)
-    {
-        return rawSetParamU8(handle, (uint8_t)val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamU64Array(const Handle &handle, uint64_t *array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(U64)
-    return(rawGetParamU64Array(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamU64Array(const Handle &handle, const uint64_t *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(U64)
-    return(rawSetParamU64Array(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** F32
-//******************************************************************************
-
-ErrorType NvParameters::getParamF32(const Handle &handle, float &val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_F32)
-    {
-        return rawGetParamF32(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::setParamF32(const Handle &handle, float val)
-{
-    CHECK_HANDLE
-    CHECK_F32_FINITE
-
-	if(handle.parameterDefinition()->type() == TYPE_F32)
-    {
-        return rawSetParamF32(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamF32Array(const Handle &handle, float *array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(F32)
-    return(rawGetParamF32Array(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamF32Array(const Handle &handle, const float *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(F32)
-    CHECK_F32_FINITE_ARRAY
-    return(rawSetParamF32Array(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** F64
-//******************************************************************************
-
-ErrorType NvParameters::getParamF64(const Handle &handle, double &val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_F32)
-    {
-        float tmp;
-        ErrorType result = rawGetParamF32(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (double)tmp;
-        return(ERROR_NONE);
-    }
-	
-	if(handle.parameterDefinition()->type() == TYPE_F64)
-    {
-        double tmp;
-        ErrorType result = rawGetParamF64(handle, tmp);
-		PX_ASSERT(result == ERROR_NONE);
-
-        if(result != ERROR_NONE)
-            return(result);
-        val = (double)tmp;
-        return(ERROR_NONE);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::setParamF64(const Handle &handle, double val)
-{
-    CHECK_HANDLE
-    CHECK_F64_FINITE
-
-	if(handle.parameterDefinition()->type() == TYPE_F64)
-    {
-        return rawSetParamF64(handle, val);
-    }
-	else if(handle.parameterDefinition()->type() == TYPE_F32)
-    {
-		return rawSetParamF32(handle, (float)val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::setParamF64Array(const Handle &handle, const double *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(F64)
-    CHECK_F64_FINITE_ARRAY
-    return(rawSetParamF64Array(handle, array, n, offset));
-}
-
-/**
-# When shrinking a dynamic array, the array may contain dynamically allocated Refs or Strings.
-# It may also contain Structs that contain these items, we'll call them all "dynamic parameters".
-#
-# To handle this, we generate, for every dynamic array with dynamic parameters, handle indices in 
-# the Parameter Definition that help the NvParameters::rawResizeArray() method find these parameters
-# and destroy them quickly (without having to recursively traverse the parameters).
-#
-# The handle indices are layed out like this for the following struct:
-# [ handleDepth0, 3, handleDepth1, 5 ] - handleDepth0 = handleDepth1 = 1 
-# struct myStruct {
-#   float a;
-#   float b;
-#   float c;
-#   string myString;
-#   float a;
-#   ref myRef;
-# }
-#
-# You can see that myString and myRef are the only two dynamically allocated members that need
-# to be destroyed, so only their indices appear in the list.
-# 
-# Note: Currently, we only support 1D arrays with dynamic parameters in the top most struct.  
-# array[i].myString is supported
-# array[i].structa.myString is supported
-# array[i].structa.structb.myString is NOT supported
-*/
-ErrorType NvParameters::releaseDownsizedParameters(const Handle &handle, int newSize, int oldSize)
-{
-	// if downsizing array, release dynamic parameters
-	// for now, just do 1D arrays
-	if( newSize >= oldSize )
-	{
-		return ERROR_NONE;
-	}
-
-	uint32_t numIndices=0;
-	Handle tmpHandle(handle);
-
-	const uint8_t *hIndices = tmpHandle.parameterDefinition()->getDynamicHandleIndicesMap(numIndices);
-
-	if( numIndices )
-	{
-		// from array[new_size] to array[old_size]
-		for( int i=newSize; i<oldSize; i++ )
-		{
-			tmpHandle.set( i );
-
-			for( uint32_t j=0; j<numIndices; )
-			{
-				// set the handle up to point to the right dynamic parameter
-				uint8_t indexDepth = hIndices[j];
-				int k=0;
-				for( ; k<indexDepth; k++ )
-				{
-					tmpHandle.set( hIndices[j+k+1] );
-				}
-				j += k + 1;
-				
-				// now we have a handle that's pointing to the dynamic parameter, release it
-				DataType type = tmpHandle.parameterDefinition()->type();
-				if( type == TYPE_STRING )
-				{
-					tmpHandle.setParamString( NULL );
-				}
-				else if( type == TYPE_REF )
-				{
-					NvParameterized::Interface * paramPtr = 0;
-					tmpHandle.getParamRef( paramPtr );
-					if( paramPtr )
-					{
-						paramPtr->destroy();
-						tmpHandle.setParamRef( NULL );
-					}
-				}
-				else if( type == TYPE_ENUM )
-				{
-					// nothing to do on a downsize
-				}
-				else
-				{
-					PX_ASSERT( 0 && "Invalid dynamically allocated type defined in Definition handle list" );
-				}
-				
-				// reset the handle
-				if( indexDepth > 0 )
-				{
-					tmpHandle.popIndex( indexDepth );
-				}
-			}
-
-			tmpHandle.popIndex();
-		}
-	}
-
-	return ERROR_NONE;
-}
-
-
-
-/**
-# When growing a dynamic array, the array may contain Enums or Structs that contain enums.
-#
-# To handle this, we generate, for every dynamic array with enums, handle indices in 
-# the Parameter Definition that help the NvParameters::rawResizeArray() method find these parameters
-# and initialized them quickly (without having to recursively traverse the parameters).
-#
-# Note: Currently, we only support 1D arrays with enums in the top most struct.  
-# array[i].enumA is supported
-# array[i].structa.enumA is supported
-# array[i].structa.structb.enumA is NOT supported
-*/
-ErrorType NvParameters::initNewResizedParameters(const Handle &handle, int newSize, int oldSize)
-{
-	// if downsizing array, release dynamic parameters
-	// for now, just do 1D arrays
-	if( newSize <= oldSize )
-	{
-		return ERROR_NONE;
-	}
-
-	uint32_t numIndices=0;
-	Handle tmpHandle(handle);
-
-	const uint8_t *hIndices = tmpHandle.parameterDefinition()->getDynamicHandleIndicesMap(numIndices);
-
-	if( numIndices )
-	{
-		// from array[new_size] to array[old_size]
-		for( int i=oldSize; i<newSize; i++ )
-		{
-			tmpHandle.set( i );
-
-			for( uint32_t j=0; j<numIndices; )
-			{
-				// set the handle up to point to the right dynamic parameter
-				uint8_t indexDepth = hIndices[j];
-				int k=0;
-				for( ; k<indexDepth; k++ )
-				{
-					tmpHandle.set( hIndices[j+k+1] );
-				}
-				j += k + 1;
-				
-				// now we have a handle that's pointing to the dynamic parameter, release it
-				DataType type = tmpHandle.parameterDefinition()->type();
-				if( type == TYPE_STRING || type == TYPE_REF )
-				{
-					// nothing to do on an array growth
-				}
-				else if( type == TYPE_ENUM )
-				{
-					// this is not the default value, but that's not available from here
-					// we could possibly store the enum default values, or just always make them first
-					tmpHandle.setParamEnum( tmpHandle.parameterDefinition()->enumVal(0) );
-				}
-				else if( type == TYPE_ARRAY )
-				{
-					// FIXME: we do not fully support arrays here, this is just a brain-dead stub
-
-					const Definition *pd = 0;
-					for(pd = tmpHandle.parameterDefinition(); pd->type() == TYPE_ARRAY; pd = pd->child(0))
-					{
-						PX_ASSERT( pd->numChildren() == 1 );
-					}
-
-					if( pd->type() != TYPE_STRING && pd->type() != TYPE_REF )
-						PX_ASSERT( 0 && "Invalid dynamically allocated type defined in Definition handle list" );
-				}
-				else
-				{
-					PX_ASSERT( 0 && "Invalid dynamically allocated type defined in Definition handle list" );
-				}
-				
-				// reset the handle
-				if( indexDepth > 0 )
-				{
-					tmpHandle.popIndex( indexDepth );
-				}
-			}
-
-			tmpHandle.popIndex();
-		}
-	}
-
-	return ERROR_NONE;
-}
-
-ErrorType NvParameters::rawResizeArray(const Handle &handle, int new_size)
-{
-	size_t offset;
-	ErrorType ret;
-	void *ptr=NULL;
-
-	Handle arrayRootHandle(handle);
-
-	// We should consider storing alignment in dynamic array struct at some point
-	uint32_t align = arrayRootHandle.parameterDefinition()->alignment();
-	if( 0 == align )
-		align = 8; // Default alignment
-
-	int dimension = 0;
-
-	while(arrayRootHandle.parameterDefinition()->parent() &&
-		arrayRootHandle.parameterDefinition()->parent()->type() == TYPE_ARRAY)
-	{
-		arrayRootHandle.popIndex();
-		dimension++;
-	}
-
-	getVarPtr(arrayRootHandle, ptr, offset);
-	if ( ptr == NULL )
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_TYPE_NOT_SUPPORTED");
-		return ERROR_TYPE_NOT_SUPPORTED;
-	}
-
-	DummyDynamicArrayStruct *dynArray = (DummyDynamicArrayStruct *)ptr;
-	int old_size = dynArray->arraySizes[0];
-
-	releaseDownsizedParameters(handle, new_size, old_size);
-
-	ret = resizeArray(mParameterizedTraits,
-					  dynArray->buf, 
-					  dynArray->arraySizes, 
-					  arrayRootHandle.parameterDefinition()->arrayDimension(), 
-					  dimension, 
-					  new_size,
-					  dynArray->isAllocated,
-					  dynArray->elementSize,
-					  align,
-					  dynArray->isAllocated); 
-
-	initNewResizedParameters(handle, new_size, old_size);
-
-	return ret;
-}
-
-ErrorType NvParameters::rawGetArraySize(const Handle &array_handle, int &size, int dimension) const
-{
-	size_t offset;
-	void *ptr=NULL;
-	getVarPtr(array_handle, ptr, offset);
-	if ( ptr == NULL )
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_TYPE_NOT_SUPPORTED");
-		return ERROR_TYPE_NOT_SUPPORTED;
-	}
-
-	DummyDynamicArrayStruct *dynArray = (DummyDynamicArrayStruct *)ptr;
-	size = dynArray->arraySizes[dimension];
-	return(ERROR_NONE);
-}
-
-ErrorType NvParameters::rawSwapArrayElements(const Handle &array_handle, unsigned int firstElement, unsigned int secondElement)
-{
-	size_t offset = 0;
-	void* ptr = NULL;
-	Handle arrayRootHandle(array_handle);
-
-	getVarPtr(arrayRootHandle, ptr, offset);
-	if ( ptr == NULL )
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_TYPE_NOT_SUPPORTED");
-		return ERROR_TYPE_NOT_SUPPORTED;
-	}
-
-	DummyDynamicArrayStruct* dynArray = reinterpret_cast<DummyDynamicArrayStruct*>(ptr);
-
-	const int elementSize = dynArray->elementSize;
-
-	char tempDataStack[64];
-	void* tempData = tempDataStack;
-
-	void* tempDataHeap = NULL;
-	PX_ASSERT(elementSize > 0);
-	PX_ASSERT(sizeof(elementSize) <= sizeof(uint32_t));
-	if (elementSize > 64)
-	{
-		tempDataHeap = mParameterizedTraits->alloc(static_cast<uint32_t>(elementSize));
-		tempData = tempDataHeap;
-	}
-
-	char* firstPtr = (char*)dynArray->buf + elementSize * firstElement;
-	char* secondPtr = (char*)dynArray->buf + elementSize * secondElement;
-
-	physx::intrinsics::memCopy(tempData, firstPtr, static_cast<uint32_t>(elementSize));
-	physx::intrinsics::memCopy(firstPtr, secondPtr, static_cast<uint32_t>(elementSize));
-	physx::intrinsics::memCopy(secondPtr, tempData, static_cast<uint32_t>(elementSize));
-
-	if (tempDataHeap != NULL)
-	{
-		mParameterizedTraits->free(tempDataHeap);
-	}
-
-	return(ERROR_NONE);
-}
-
-#define ARRAY_HANDLE_CHECKS \
-    if(!array_handle.isValid()) \
-	{ \
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_PARAMETER_HANDLE");\
-        return(ERROR_INVALID_PARAMETER_HANDLE); \
-	}\
-    if(array_handle.parameterDefinition()->type() != TYPE_ARRAY) \
-	{\
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_NOT_AN_ARRAY"); \
-        return(ERROR_NOT_AN_ARRAY); \
-	}
-
-
-ErrorType NvParameters::resizeArray(const Handle &array_handle, int32_t new_size)
-{
-    ARRAY_HANDLE_CHECKS
-
-    if(new_size < 0)
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_ARRAY_SIZE");
-        return(ERROR_INVALID_ARRAY_SIZE);
-	}
-
-    if(array_handle.parameterDefinition()->arraySizeIsFixed())
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_ARRAY_SIZE_IS_FIXED");
-        return(ERROR_ARRAY_SIZE_IS_FIXED);
-	}
-
-    return(rawResizeArray(array_handle, new_size));
-}
-
-ErrorType NvParameters::swapArrayElements(const Handle &array_handle, uint32_t firstElement, uint32_t secondElement)
-{
-	ARRAY_HANDLE_CHECKS;
-
-	if (firstElement == secondElement)
-		return(ERROR_NONE);
-
-	int array_size = 0;
-	rawGetArraySize(array_handle, array_size, 0);
-
-	if (array_size < 1)
-		return(ERROR_NONE);
-
-	if (firstElement >= (unsigned int)array_size)
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");
-		return(ERROR_INDEX_OUT_OF_RANGE);
-	}
-
-	if (secondElement >= (unsigned int)array_size)
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");
-		return(ERROR_INDEX_OUT_OF_RANGE);
-	}
-
-	// well, maybe swapping will work on fixed size arrays as well...
-	if (array_handle.parameterDefinition()->arraySizeIsFixed())
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_ARRAY_SIZE_IS_FIXED");
-		return(ERROR_ARRAY_SIZE_IS_FIXED);
-	}
-
-	return rawSwapArrayElements(array_handle, firstElement, secondElement);
-}
-
-ErrorType NvParameters::
-    getArraySize(const Handle &array_handle, int32_t &size, int32_t dimension) const
-{
-    ARRAY_HANDLE_CHECKS
-
-    if(dimension < 0 || dimension >= array_handle.parameterDefinition()->arrayDimension())
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_ARRAY_DIMENSION");
-        return(ERROR_INVALID_ARRAY_DIMENSION);
-	}
-
-    if(array_handle.parameterDefinition()->arraySizeIsFixed())
-    {
-        size = array_handle.parameterDefinition()->arraySize(dimension);
-        return(ERROR_NONE);
-    }
-
-    return(rawGetArraySize(array_handle, size, dimension));
-}
-
-ErrorType NvParameters::callPreSerializeCallback(Handle& handle) const
-{
-	const Definition* def = handle.parameterDefinition();
-	if (def->type() == TYPE_REF)
-	{
-		// don't preSerialize Named References
-		const Hint *hint = def->hint("INCLUDED");
-		if( hint && 
-			hint->type() == TYPE_U64 && 
-			hint->asUInt() == 1 )
-		{
-			// included
-			NvParameterized::Interface* ref = NULL;
-			NV_ERR_CHECK_RETURN( getParamRef(handle, ref) );
-			if( ref )
-			{
-				NV_ERR_CHECK_RETURN( ref->callPreSerializeCallback() );
-			}
-		}
-	}
-	else if (def->type() == TYPE_ARRAY)
-	{
-		int32_t arraySize = 0;
-		getArraySize(handle, arraySize);
-
-		for (int32_t i = 0; i < arraySize; i++)
-		{
-			handle.set(i);
-
-			NV_ERR_CHECK_RETURN( callPreSerializeCallback(handle) );
-
-			handle.popIndex();
-		}
-	}
-	else if (def->type() == TYPE_STRUCT)
-	{
-		const int32_t numChildren = def->numChildren();
-
-		for (int32_t childIndex = 0; childIndex < numChildren; childIndex++)
-		{
-			handle.set(childIndex);
-
-			NV_ERR_CHECK_RETURN( callPreSerializeCallback(handle) );
-
-			handle.popIndex();
-		}
-	}
-
-	return ERROR_NONE;
-}
-
-ErrorType NvParameters::checkParameterHandle(const Handle &handle) const
-{
-	PX_ASSERT( handle.getConstInterface() );
-	PX_ASSERT( handle.getConstInterface() == this );
-	
-	if (!handle.isValid()) 
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_PARAMETER_HANDLE");
-		return(ERROR_INVALID_PARAMETER_HANDLE);
-	}
-
-	if (handle.getConstInterface() == NULL ) 
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_HANDLE_MISSING_INTERFACE_POINTER");
-		return(ERROR_HANDLE_MISSING_INTERFACE_POINTER);
-	}
-
-	if (handle.getConstInterface() != this ) 
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_HANDLE_INVALID_INTERFACE_POINTER");
-		return(ERROR_HANDLE_INVALID_INTERFACE_POINTER); 
-	}
-
-    if(handle.parameterDefinition()->root() != rootParameterDefinition()) 
-	{
-        return(ERROR_PARAMETER_HANDLE_DOES_NOT_MATCH_CLASS);
-	}
-
-
-    const Definition *ptr = rootParameterDefinition();
-    for(int32_t i=0; i < handle.numIndexes(); ++i)
-    {
-        PX_ASSERT(ptr != NULL);
-
-        switch(ptr->type())
-        {
-            case TYPE_STRUCT:
-                if(handle.index(i) >= ptr->numChildren())
-				{
-					PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");
-                    return(ERROR_INDEX_OUT_OF_RANGE);
-				}
-                ptr = ptr->child(handle.index(i));
-                break;
-
-            case TYPE_ARRAY:
-                {
-                    int32_t size = ptr->arraySize();
-                    Handle tmpHandle(handle);
-					tmpHandle.popIndex(handle.numIndexes() - i);
-
-                    if(size <= 0)
-                        if(getArraySize(tmpHandle, size) != ERROR_NONE)
-						{
-							PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");
-                            return(ERROR_INDEX_OUT_OF_RANGE);
-						}
-
-                    if(handle.index(i) >= size)
-					{
-						PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");
-						return(ERROR_INDEX_OUT_OF_RANGE);
-					}
-
-                    ptr = ptr->child(0);
-                }
-                break;
-
-			NV_PARAMETRIZED_NO_AGGREGATE_DATATYPE_LABELS
-            default:
-                PX_ALWAYS_ASSERT();
-                ptr = NULL;
-        }
-    }
-
-    return(ERROR_NONE);
-}
-
-ErrorType NvParameters::clone(NvParameterized::Interface *&nullDestObject) const
-{
-	PX_ASSERT(nullDestObject == NULL );
-	nullDestObject = mParameterizedTraits->createNvParameterized(className(), version());
-	if( !nullDestObject )
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_OBJECT_CONSTRUCTION_FAILED");
-		return ERROR_OBJECT_CONSTRUCTION_FAILED;
-	}
-
-	ErrorType err = nullDestObject->copy(*this);
-	if( ERROR_NONE != err )
-	{
-		nullDestObject->destroy();
-		nullDestObject = NULL;
-	}
-
-	return err;
-}
-
-ErrorType NvParameters::copy(const NvParameterized::Interface &other,
-                             Handle &thisHandle)
-{
-   const Definition *paramDef = thisHandle.parameterDefinition();
-   ErrorType error = ERROR_NONE;
-
-    if( paramDef->type() == TYPE_STRUCT )
-	{
-        for(int32_t i=0; i < paramDef->numChildren(); ++i)
-        {
-            thisHandle.set(i);
-			error = copy(other, thisHandle);
-            NV_ERR_CHECK_RETURN(error);
-
-            thisHandle.popIndex();
-        }
-        return(error);
-	}
-	else if( paramDef->type() == TYPE_ARRAY )
-    {
-        int32_t thisSize, otherSize;
-
-		error = thisHandle.getArraySize(thisSize);
-        NV_ERR_CHECK_RETURN(error);
-
-		Handle otherHandle = thisHandle;
-		otherHandle.setInterface(&other);
-        error = otherHandle.getArraySize(otherSize);
-        NV_ERR_CHECK_RETURN(error);
-
-		thisHandle.setInterface(this);
-
-		if(thisSize != otherSize)
-		{
-			error = thisHandle.resizeArray(otherSize);
-			NV_ERR_CHECK_RETURN(error);
-			thisSize = otherSize;
-		}
-
-        for(int32_t i=0; i < otherSize; ++i)
-        {
-            thisHandle.set(i);
-
-			error = this->copy(other, thisHandle);
-			NV_ERR_CHECK_RETURN(error);
-
-            thisHandle.popIndex();
-        }
-        return(error);
-    }
-
-	Handle otherHandle = thisHandle; 
-	otherHandle.setInterface(&other);
-    switch(paramDef->type()) 
-    {
-		case TYPE_BOOL: 
-			{ 
-				bool otherVal; 
-				error = otherHandle.getParamBool(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamBool(otherVal) );
-			}
-
-		case TYPE_I8: 
-			{ 
-				int8_t otherVal; 
-				error = otherHandle.getParamI8(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamI8(otherVal) );
-			}
-
-		case TYPE_I16 : 
-			{ 
-				int16_t otherVal; 
-				error = otherHandle.getParamI16(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamI16(otherVal) );
-			}
-		case TYPE_I32 : 
-			{
-				int32_t otherVal;
-				error = otherHandle.getParamI32(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamI32(otherVal) );
-			}
-		case TYPE_I64 : 
-			{
-				int64_t otherVal;
-				error = otherHandle.getParamI64(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamI64(otherVal) );
-			}
-
-		case TYPE_U8 : 
-			{
-				uint8_t otherVal;
-				error = otherHandle.getParamU8(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamU8(otherVal) );
-			}
-		case TYPE_U16 : 
-			{
-				uint16_t otherVal;
-				error = otherHandle.getParamU16(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamU16(otherVal) );
-			}
-		case TYPE_U32 : 
-			{
-				uint32_t otherVal;
-				error = otherHandle.getParamU32(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamU32(otherVal) );
-			}
-		case TYPE_U64 : 
-			{
-				uint64_t otherVal;
-				error = otherHandle.getParamU64(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamU64(otherVal) );
-			}
-
-		case TYPE_F32 : 
-			{
-				float otherVal;
-				error = otherHandle.getParamF32(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamF32(otherVal) );
-			}
-		case TYPE_F64 : 
-			{
-				double otherVal;
-				error = otherHandle.getParamF64(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamF64(otherVal) );
-			}
-
-		case TYPE_VEC2 : 
-			{
-				physx::PxVec2 otherVal;
-				error = otherHandle.getParamVec2(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamVec2(otherVal) );
-			}
-		case TYPE_VEC3 : 
-			{
-				physx::PxVec3 otherVal;
-				error = otherHandle.getParamVec3(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamVec3(otherVal) );
-			}
-		case TYPE_VEC4 : 
-			{
-				physx::PxVec4 otherVal;
-				error = otherHandle.getParamVec4(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamVec4(otherVal) );
-			}
-		case TYPE_QUAT : 
-			{
-				physx::PxQuat otherVal;
-				error = otherHandle.getParamQuat(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamQuat(otherVal) );
-			}
-		case TYPE_MAT33 : 
-			{
-				physx::PxMat33 otherVal;
-				error = otherHandle.getParamMat33(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamMat33(otherVal) );
-			}
-		case TYPE_MAT44 : 
-			{ 
-				physx::PxMat44 otherVal;
-				error = otherHandle.getParamMat44(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamMat44(otherVal) );
-			}
-		case TYPE_MAT34 : 
-			{ 
-				float otherVal[12];
-				error = otherHandle.getParamMat34Legacy(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamMat34Legacy(otherVal) );
-			}
-		case TYPE_BOUNDS3 : 
-			{ 
-				physx::PxBounds3 otherVal;
-				error = otherHandle.getParamBounds3(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamBounds3(otherVal) );
-			}
-		case TYPE_TRANSFORM : 
-			{ 
-				physx::PxTransform otherVal;
-				error = otherHandle.getParamTransform(otherVal);
-				NV_ERR_CHECK_RETURN( error );
-				return( thisHandle.setParamTransform(otherVal) );
-			}
-        case TYPE_STRING:
-            {
-                const char *val1;
-				error = otherHandle.getParamString(val1);
-                NV_ERR_CHECK_RETURN(error);
-				return(thisHandle.setParamString(val1));
-            }
-
-        case TYPE_ENUM:
-            {
-                const char *val1;
-                error = otherHandle.getParamEnum(val1);
-                NV_ERR_CHECK_RETURN(error);
-				return val1 ? thisHandle.setParamEnum(val1) : ERROR_NONE;
-            }
-
-		case TYPE_REF:
-			{
-				NvParameterized::Interface *thisRef, *otherRef;
-				error = thisHandle.getParamRef(thisRef);
-				NV_ERR_CHECK_RETURN(error);
-				
-				error = otherHandle.getParamRef(otherRef);
-				NV_ERR_CHECK_RETURN(error);
-
-				if(thisRef)
-				{
-					thisRef->destroy();
-					thisHandle.setParamRef(NULL);
-				}
-
-				if(otherRef)
-				{
-					error = thisHandle.initParamRef(otherRef->className(), true);
-					NV_ERR_CHECK_RETURN(error);
-
-					error = thisHandle.getParamRef(thisRef);
-					NV_ERR_CHECK_RETURN(error);
-
-					if(thisRef == NULL)
-					{
-						PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_PARAMETER_HANDLE_NOT_INITIALIZED");
-						return(ERROR_PARAMETER_HANDLE_NOT_INITIALIZED);
-					}
-
-					return(thisRef->copy(*otherRef));
-				}
-			}
-			break;
-
-		case TYPE_POINTER:
-			//Just don't do anything with pointers
-			break;
-
-		NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS
-		NV_PARAMETRIZED_AGGREGATE_DATATYPE_LABELS
-		default:
-            PX_ALWAYS_ASSERT();
-            break;
-    }
-
-	return ERROR_NONE;
-}
-
-bool NvParameters::areParamsOK(Handle &handle, Handle *invalidHandles, uint32_t numInvalidHandles, uint32_t &numRemainingHandles)
-{
-	class Constraints
-	{
-		const Hint *min, *max, *multOf, *powOf;
-
-		static int64_t abs(int64_t x)
-		{
-			return x >= 0 ? x : -x;
-		}
-
-	public:
-		Constraints(const Hint *min_, const Hint *max_, const Hint *multOf_, const Hint *powOf_):
-			min(min_), max(max_), multOf(multOf_), powOf(powOf_) {}
-
-		bool isOK(uint64_t val)
-		{
-			bool res = true;
-
-			if( min )
-				res = res && val >= min->asUInt();
-
-			if( max )
-				res = res && val <= max->asUInt();
-
-			if( multOf )
-				res = res && 0 == val % multOf->asUInt();
-
-			if( powOf  )
-			{
-				//TODO: this is too slow
-				uint64_t base = powOf->asUInt(), acc = 1;
-				while( acc < val )
-					acc *= base;
-				res = res && acc == base;
-			}
-
-			return res;
-		}
-
-		bool isOK(int64_t val)
-		{
-			bool res = true;
-
-			if( min )
-				res = res && val >= int64_t(min->asUInt());
-
-			if( max )
-				res = res && val <= int64_t(max->asUInt());
-
-			if( multOf )
-				res = res && 0 == val % int64_t(multOf->asUInt());
-
-			if( powOf  )
-			{
-				//TODO: this is too slow
-				int64_t base = int64_t(powOf->asUInt()), acc = 1;
-				while( abs(acc) < val )
-					acc *= base;
-				res = res && abs(acc) == base;
-			}
-
-			return res;
-		}
-
-		bool isOK(float val)
-		{
-			bool res = true;
-
-			if( min )
-				res = res && val >= float(min->asFloat());
-
-			if( max )
-				res = res && val <= float(max->asFloat());
-
-			if( multOf )
-				res = res && 0.0f == (float)fmod(val, float(multOf->asFloat()));
-
-			//TODO
-			if( powOf)
-			{
-				PX_ALWAYS_ASSERT();
-				return false;
-			}
-
-			return res;
-		}
-
-		bool isOK(double val)
-		{
-			bool res = true;
-
-			if( min )
-				res = res && val >= min->asFloat();
-
-			if( max )
-				res = res && val <= max->asFloat();
-
-			if( multOf )
-				res = res && 0.0f == (float)fmod((float)val, (float)multOf->asFloat());
-
-			//TODO
-			if( powOf )
-			{
-				PX_ALWAYS_ASSERT();
-				return false;
-			}
-
-			return res;
-		}
-	};
-	
-	bool res = true;
-
-    const Definition *pd = handle.parameterDefinition();
-
-	Constraints con(pd->hint("min"), pd->hint("max"), pd->hint("multipleOf"), pd->hint("powerOf"));
-
-	switch( pd->type() ) 
-    {
-        case TYPE_STRUCT:
-            {
-                for(int32_t i = 0; i < pd->numChildren(); ++i)
-                {
-                    handle.set(i);
-                    res &= areParamsOK(handle, invalidHandles, numInvalidHandles, numRemainingHandles);
-                    handle.popIndex();
-                }
-	            return res;
-            }
-
-        case TYPE_ARRAY:
-            {
-                int32_t arraySize = -1;
-                NV_BOOL_RETURN( handle.getArraySize(arraySize) );
-
-                for(int32_t i=0; i < arraySize; ++i)
-                {
-                    handle.set(i);
-                    res &= areParamsOK(handle, invalidHandles, numInvalidHandles, numRemainingHandles);
-                    handle.popIndex();
-                }
-	            return res;
-            }
-
-		case TYPE_BOOL:
-		case TYPE_U8:
-		case TYPE_U16:
-		case TYPE_U32:
-		case TYPE_U64:
-			{
-				uint64_t val;
-				NV_BOOL_RETURN( handle.getParamU64(val) );
-				res = con.isOK(val);
-				if( !res && numRemainingHandles > 0 )
-					invalidHandles[numRemainingHandles++ - 1] = handle;
-				return res;
-			}
-
-		case TYPE_I8:
-		case TYPE_I16:
-		case TYPE_I32:
-		case TYPE_I64:
-			{
-				int64_t val;
-				NV_BOOL_RETURN( handle.getParamI64(val) );
-				res = con.isOK(val);
-				if( !res && numRemainingHandles > 0 )
-					invalidHandles[numRemainingHandles++ - 1] = handle;
-				return res;
-			}
-
-		case TYPE_F32:
-			{
-				float val = -1;
-				NV_BOOL_RETURN( handle.getParamF32(val) );
-				res = con.isOK(val);
-				if( !res && numRemainingHandles > 0 )
-					invalidHandles[numRemainingHandles++ - 1] = handle;
-				return res;
-			}
-
-		case TYPE_F64:
-			{
-				double val = -1;
-				NV_BOOL_RETURN( handle.getParamF64(val) );
-				res = con.isOK(val);
-				if( !res && numRemainingHandles > 0 )
-					invalidHandles[numRemainingHandles++ - 1] = handle;
-				return res;
-			}
-
-		NV_PARAMETRIZED_NO_AGGREGATE_AND_ARITHMETIC_DATATYPE_LABELS
-		default:
-			return true;
-	}
-}
-
-bool NvParameters::equals(const NvParameterized::Interface &obj,
-						  Handle &param_handle,
-						  Handle *handlesOfInequality,
-						  uint32_t numHandlesOfInequality,
-						  bool doCompareNotSerialized) const
-{
-    const Definition *paramDef = param_handle.parameterDefinition();
-
-	if (!doCompareNotSerialized && paramDef->hint("DONOTSERIALIZE") )
-		return true;
-
-	DataType type = paramDef->type();
-    switch(type) 
-    {
-#define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES
-#define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \
-	case TYPE_ ## enum_name: \
-	{ \
-		c_type a; \
-		c_type b; \
-		param_handle.setInterface(this); \
-		NV_BOOL_RETURN( param_handle.getParam ## type_name(a) ); \
-		param_handle.setInterface(&obj); \
-		NV_BOOL_RETURN( param_handle.getParam ## type_name(b) ); \
-		return !notEqual(a, b); \
-	}
-#include "nvparameterized/NvParameterized_types.h"
-
-		case TYPE_MAT34:
-		{
-			float a[12];
-			float b[12];
-			param_handle.setInterface(this);
-			NV_BOOL_RETURN( param_handle.getParamMat34Legacy(a) );
-			param_handle.setInterface(&obj);
-			NV_BOOL_RETURN( param_handle.getParamMat34Legacy(b) );
-			return !notEqual(a, b);
-		}
-
-		case TYPE_REF:
-			{
-				NvParameterized::Interface *val1, *val2;
-
-				param_handle.setInterface( this );
-				if(param_handle.getParamRef(val1) != ERROR_NONE)
-					return(false);
-
-				param_handle.setInterface( &obj );
-				if(param_handle.getParamRef(val2) != ERROR_NONE)
-					return(false);
-
-				if(val1 == NULL && val2 == NULL)
-					return(true);
-				else if(val1 == NULL || val2 == NULL)
-					return(false);
-
-				return val2->equals(
-					*val1,
-					handlesOfInequality != NULL ? handlesOfInequality+1 : NULL,
-					numHandlesOfInequality > 0 ? numHandlesOfInequality-1 : 0,
-					doCompareNotSerialized );
-			}
-
-		case TYPE_STRUCT:
-	        for(int32_t i = 0; i < paramDef->numChildren(); ++i)
-		    {
-			    param_handle.set(i);
-				if (!equals(obj, param_handle, handlesOfInequality, numHandlesOfInequality, doCompareNotSerialized))
-					return(false);
-	            param_handle.popIndex();
-		    }
-	        return(true);
-
-		case TYPE_ARRAY:
-	    {
-		    int32_t arraySize1, arraySize2;
-
-			param_handle.setInterface (this);
-		    if (param_handle.getArraySize(arraySize1) != ERROR_NONE)
-			    return(false);
-
-			param_handle.setInterface (&obj);
-		    if (param_handle.getArraySize(arraySize2) != ERROR_NONE)
-			    return(false);
-
-	        if(arraySize1 != arraySize2)
-		        return(false);
-
-			if( arraySize1 > 100 && paramDef->isSimpleType(false, false) )
-			{
-				// Large array of simple types, fast path
-
-				switch( type)
-				{
-				NV_PARAMETRIZED_NO_ARITHMETIC_AND_LINAL_DATATYPE_LABELS
-				NV_PARAMETRIZED_LEGACY_DATATYPE_LABELS
-				default:
-					// Fall to slow path, including TYPE_MAT34 case
-					break;
-
-#define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES
-#define NV_PARAMETERIZED_TYPES_NO_STRING_TYPES
-#define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \
-	case TYPE_ ## enum_name: { \
-		uint32_t byteSize = static_cast<uint32_t>(sizeof(c_type)) * arraySize1; \
-		c_type *data1 = (c_type *)mParameterizedTraits->alloc(byteSize), \
-			*data2 = (c_type *)mParameterizedTraits->alloc(byteSize); \
-		\
-		param_handle.setInterface(this); \
-		NV_BOOL_RETURN(param_handle.getParam ## type_name ## Array(data1, arraySize1)); \
-		\
-		param_handle.setInterface(&obj); \
-		NV_BOOL_RETURN(param_handle.getParam ## type_name ## Array(data2, arraySize2)); \
-		\
-		int ret = memcmp(data1, data2, byteSize); \
-		mParameterizedTraits->free(data1); \
-		mParameterizedTraits->free(data2); \
-		\
-		return ret == 0; \
-	}
-#include "nvparameterized/NvParameterized_types.h"
-				}
-			}
-
-			// Array of aggregates, slow path
-
-			param_handle.setInterface(this);
-
-			for (int32_t i = 0; i < arraySize1; ++i)
-		    {
-			    param_handle.set(i);
-				if (!equals(obj, param_handle, handlesOfInequality, numHandlesOfInequality, doCompareNotSerialized))
-					return(false);
-				param_handle.popIndex();
-			}
-
-			return(true);
-		}
-
-		case TYPE_POINTER:
-			return true;
-
-NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS
-        default:
-			PX_ALWAYS_ASSERT();
-            break;
-    }
-
-    return(false);
-}
-                   
-ErrorType NvParameters::copy(const NvParameterized::Interface &other)
-{
-	if (this == &other)
-	{
-		return(ERROR_NONE);
-	}
-
-    if (rootParameterDefinition() != other.rootParameterDefinition())
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_PARAMETER_DEFINITIONS_DO_NOT_MATCH");
-		return(ERROR_PARAMETER_DEFINITIONS_DO_NOT_MATCH);
-	}
-
-	// support empty, named references
-	if (rootParameterDefinition() == NULL)
-	{
-		// the name or className could be NULL, strcmp doesn't like NULL strings...
-		setClassName(other.className());
-		setName(other.name());
-		return(ERROR_NONE);
-	}
-	else
-	{
-		Handle handle (*this);
-		if (getParameterHandle("", handle) != ERROR_NONE)
-		{
-			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_PARAMETER_HANDLE");
-			return(ERROR_INVALID_PARAMETER_HANDLE);
-		}
-
-		return(copy(other, handle));
-	}
-}
-
-bool NvParameters::areParamsOK(Handle *invalidHandles, uint32_t numInvalidHandles)
-{
-    Handle handle(*this);
-	NV_BOOL_RETURN( getParameterHandle("", handle) );
-
-	uint32_t numRemainingHandles = numInvalidHandles;
-	return areParamsOK(handle, invalidHandles, numInvalidHandles, numRemainingHandles);
-}
-
-bool NvParameters::equals(const NvParameterized::Interface &obj, Handle* handleOfInequality, uint32_t numHandlesOfInequality, bool doCompareNotSerialized) const
-{
-	if( this == &obj )
-		return(true);
-
-    if(rootParameterDefinition() != obj.rootParameterDefinition())
-        return(false);
-
-	// support empty, named references
-	if(rootParameterDefinition() == NULL)
-	{
-		// the name or className could be NULL, strcmp doesn't like NULL strings...
-		return 0 == safe_strcmp(name(), obj.name()) && 0 == safe_strcmp(className(), obj.className());
-	}
-
-	// This should be a handle that can not set any values!
-    Handle constHandle(*this);
-	NV_BOOL_RETURN( getParameterHandle("", constHandle) );
-
-	bool theSame = equals(obj, constHandle, handleOfInequality, numHandlesOfInequality, doCompareNotSerialized);
-
-	if (!theSame && numHandlesOfInequality > 0)
-		*handleOfInequality = constHandle;
-
-	return theSame;
-}
-
-ErrorType NvParameters::valueToStr(const Handle &handle,
-                                   char *buf,
-                                   uint32_t n,
-                                   const char *&ret)
-{
-    PX_ASSERT(buf != NULL);
-    PX_ASSERT(n > 0);
-
-    if(!handle.isValid())
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_PARAMETER_HANDLE");
-        return(ERROR_INVALID_PARAMETER_HANDLE);
-	}
-
-    const Definition *paramDef = handle.parameterDefinition();
-
-    ErrorType error = ERROR_TYPE_NOT_SUPPORTED;
-
-    switch(paramDef->type())
-    {
-    	case TYPE_VEC2:
-    		{
-        		physx::PxVec2 val;
-                if ((error = getParamVec2(handle, val)) == ERROR_NONE)
-                {
-					char f[2][physx::PxAsc::PxF32StrLen];
-					physx::shdfnd::snprintf(buf, n,"%s %s",
-						 physx::PxAsc::valueToStr(val.x, f[0], physx::PxAsc::PxF32StrLen),
-						 physx::PxAsc::valueToStr(val.y, f[1], physx::PxAsc::PxF32StrLen));
-    				ret = buf;
-    			}
-			}
-    		break;
-    	case TYPE_VEC3:
-    		{
-        		physx::PxVec3 val;
-                if ((error = getParamVec3(handle, val)) == ERROR_NONE)
-                {
-					char f[3][physx::PxAsc::PxF32StrLen];
-					physx::shdfnd::snprintf(buf, n,"%s %s %s",
-						 physx::PxAsc::valueToStr(val.x, f[0], physx::PxAsc::PxF32StrLen),
-						 physx::PxAsc::valueToStr(val.y, f[1], physx::PxAsc::PxF32StrLen),
-						 physx::PxAsc::valueToStr(val.z, f[2], physx::PxAsc::PxF32StrLen));
-    				ret = buf;
-    			}
-			}
-    		break;
-    	case TYPE_VEC4:
-    		{
-        		physx::PxVec4 val;
-                if ((error = getParamVec4(handle, val)) == ERROR_NONE)
-                {
-					char f[4][physx::PxAsc::PxF32StrLen];
-					physx::shdfnd::snprintf(buf, n,"%s %s %s %s",
-						 physx::PxAsc::valueToStr(val.x, f[0], physx::PxAsc::PxF32StrLen),
-						 physx::PxAsc::valueToStr(val.y, f[1], physx::PxAsc::PxF32StrLen),
-						 physx::PxAsc::valueToStr(val.z, f[2], physx::PxAsc::PxF32StrLen),
-						 physx::PxAsc::valueToStr(val.w, f[3], physx::PxAsc::PxF32StrLen));
-    				ret = buf;
-    			}
-			}
-    		break;
-    	case TYPE_QUAT:
-			{
-				physx::PxQuat val;
-				if ((error = getParamQuat(handle, val)) == ERROR_NONE)
-				{
-					float quat[4];
-					//val.getXYZW(quat);
-					quat[0] = val.x; quat[1] = val.y; quat[2] = val.z; quat[3] = val.w;
-					char f[4][physx::PxAsc::PxF32StrLen];
-					physx::shdfnd::snprintf(buf, n,"%s %s %s %s",
-						 physx::PxAsc::valueToStr(quat[0], f[0], physx::PxAsc::PxF32StrLen),
-						 physx::PxAsc::valueToStr(quat[1], f[1], physx::PxAsc::PxF32StrLen),
-						 physx::PxAsc::valueToStr(quat[2], f[2], physx::PxAsc::PxF32StrLen),
-						 physx::PxAsc::valueToStr(quat[3], f[3], physx::PxAsc::PxF32StrLen));
-
-					ret = buf;
-				}
-			}
-    		break;
-    	case TYPE_MAT33:
-			{
-				physx::PxMat33 val;
-				if ((error = getParamMat33(handle, val)) == ERROR_NONE)
-				{
-					char f[9][physx::PxAsc::PxF32StrLen];
-					const float *vals = val.front();
-					physx::shdfnd::snprintf(buf, n,"%s %s %s  %s %s %s  %s %s %s",
-						physx::PxAsc::valueToStr(vals[0], f[0], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[1], f[1], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[2], f[2], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[3], f[3], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[4], f[4], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[5], f[5], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[6], f[6], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[7], f[7], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[8], f[8], physx::PxAsc::PxF32StrLen));
-					ret = buf;
-				}
-			}
-    		break;
-    	case TYPE_MAT44:
-			{
-				physx::PxMat44 val;
-				if ((error = getParamMat44(handle, val)) == ERROR_NONE)
-				{
-					char f[16][physx::PxAsc::PxF32StrLen];
-					const float *vals = val.front();
-					physx::shdfnd::snprintf(buf, n,"%s %s %s %s  %s %s %s %s  %s %s %s %s  %s %s %s %s",
-						physx::PxAsc::valueToStr(vals[0], f[0], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[1], f[1], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[2], f[2], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[3], f[3], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[4], f[4], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[5], f[5], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[6], f[6], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[7], f[7], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[8], f[8], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[9], f[9], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[10], f[10], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[11], f[11], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[12], f[12], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[13], f[13], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[14], f[14], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[15], f[15], physx::PxAsc::PxF32StrLen));
-					ret = buf;
-				}
-			}
-    		break;
-    	case TYPE_MAT34:
-			{
-				float vals[12];
-				if ((error = getParamMat34Legacy(handle, vals)) == ERROR_NONE)
-				{
-					char f[16][physx::PxAsc::PxF32StrLen];
-					physx::shdfnd::snprintf(buf, n,"%s %s %s  %s %s %s  %s %s %s  %s %s %s",
-						physx::PxAsc::valueToStr(vals[0], f[0], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[1], f[1], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[2], f[2], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[3], f[3], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[4], f[4], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[5], f[5], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[6], f[6], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[7], f[7], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[8], f[8], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[9], f[9], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[10], f[10], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(vals[11], f[11], physx::PxAsc::PxF32StrLen));
-					ret = buf;
-				}
-			}
-    		break;
-		case TYPE_BOUNDS3:
-			{
-				char f[6][physx::PxAsc::PxF32StrLen];
-				physx::PxBounds3 val;
-				if ((error = getParamBounds3(handle, val)) == ERROR_NONE)
-				{
-					physx::shdfnd::snprintf(buf, n,"%s %s %s  %s %s %s ",
-						physx::PxAsc::valueToStr(val.minimum.x, f[0], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(val.minimum.y, f[1], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(val.minimum.z, f[2], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(val.maximum.x, f[3], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(val.maximum.y, f[4], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(val.maximum.z, f[5], physx::PxAsc::PxF32StrLen));
-					ret = buf;
-				}
-			}
-    		break;
-    	case TYPE_TRANSFORM:
-			{
-				char f[7][physx::PxAsc::PxF32StrLen];
-				physx::PxTransform val;
-				if ((error = getParamTransform(handle, val)) == ERROR_NONE)
-				{
-					physx::shdfnd::snprintf(buf, n,"%s %s %s %s  %s %s %s ",
-						physx::PxAsc::valueToStr(val.q.x, f[0], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(val.q.y, f[1], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(val.q.z, f[2], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(val.q.w, f[3], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(val.p.x, f[4], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(val.p.y, f[5], physx::PxAsc::PxF32StrLen),
-						physx::PxAsc::valueToStr(val.p.z, f[6], physx::PxAsc::PxF32StrLen));
-					ret = buf;
-				}
-			}
-    		break;
-        case TYPE_UNDEFINED:
-        case TYPE_ARRAY:
-        case TYPE_STRUCT:
-			break;
-        case TYPE_STRING:
-            error = getParamString(handle, ret);
-			break;
-        case TYPE_ENUM:
-            error = getParamEnum(handle, ret);
-			break;
-		case TYPE_REF:
-		{
-			const Hint *hint = paramDef->hint("INCLUDED");
-			if( hint && hint->type() != TYPE_U64 )
-			{
-				PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_REFERENCE_INCLUDE_HINT");
-				return(ERROR_INVALID_REFERENCE_INCLUDE_HINT);
-			}
-
-			if( hint != NULL && hint->asUInt() == 1 )
-			{
-				// included, output the entire struct
-			}
-			else
-			{
-				//not included, get the "name" from the NvParameterized pointer
-				NvParameterized::Interface *paramPtr = 0;
-				ErrorType err = getParamRef(handle, paramPtr);
-				PX_ASSERT(err == ERROR_NONE);
-
-				if(err != ERROR_NONE)
-				{
-					return err;
-				}
-
-				ret = NULL;
-				if(paramPtr)
-				{
-					ret = paramPtr->name();
-				}
-			}
-			error = ERROR_NONE;
-		}
-		break;
-		case TYPE_BOOL:
-    		{
-        		bool val;
-                if ((error = getParamBool(handle, val)) == ERROR_NONE)
-                {
-					ret = physx::PxAsc::valueToStr(val, buf, n);
-    			}
-			}
-			break;
-		case TYPE_I8:
-    		{
-        		int8_t val;
-                if ((error = getParamI8(handle, val)) == ERROR_NONE)
-                {
-					ret = physx::PxAsc::valueToStr(val, buf, n);
-    			}
-			}
-			break;
-		case TYPE_I16:
-    		{
-        		int16_t val;
-                if ((error = getParamI16(handle, val)) == ERROR_NONE)
-                {
-                	ret = physx::PxAsc::valueToStr(val, buf, n);
-    			}
-			}
-			break;
-		case TYPE_I32:
-    		{
-        		int32_t val;
-                if ((error = getParamI32(handle, val)) == ERROR_NONE)
-                {
-                	ret = physx::PxAsc::valueToStr(val, buf, n);
-    			}
-			}
-			break;
-		case TYPE_I64:
-    		{
-        		int64_t val;
-                if ((error = getParamI64(handle, val)) == ERROR_NONE)
-                {
-           			ret = physx::PxAsc::valueToStr(val, buf, n);
-    			}
-			}
-			break;
-		case TYPE_U8:
-    		{
-        		uint8_t val;
-                if ((error = getParamU8(handle, val)) == ERROR_NONE)
-                {
-					ret = physx::PxAsc::valueToStr(val, buf, n);
-    			}
-			}
-			break;
-		case TYPE_U16:
-    		{
-        		uint16_t val;
-                if ((error = getParamU16(handle, val)) == ERROR_NONE)
-                {
-                	ret = physx::PxAsc::valueToStr(val, buf, n);
-    			}
-			}
-			break;
-		case TYPE_U32:
-    		{
-        		uint32_t val;
-                if ((error = getParamU32(handle, val)) == ERROR_NONE)
-                {
-                	ret = physx::PxAsc::valueToStr(val, buf, n);
-    			}
-			}
-			break;
-		case TYPE_U64:
-    		{
-        		uint64_t val;
-                if ((error = getParamU64(handle, val)) == ERROR_NONE)
-                {
-              		ret = physx::PxAsc::valueToStr(val, buf, n);
-    			}
-			}
-			break;
-		case TYPE_F32:
-    		{
-        		float val;
-                if ((error = getParamF32(handle, val)) == ERROR_NONE)
-                {
-					ret = physx::PxAsc::valueToStr(val, buf, n);
-    			}
-			}
-			break;
-		case TYPE_F64:
-    		{
-        		double val;
-                if ((error = getParamF64(handle, val)) == ERROR_NONE)
-                {
-					ret = physx::PxAsc::valueToStr(val, buf, n);
-    			}
-			}
-			break;
-
-		// Make compiler happy
-		case TYPE_POINTER:
-		case TYPE_LAST:
-			break;
-    }
-
-	PX_ASSERT(error == ERROR_NONE);
-
-    return error;
-}
-
-ErrorType NvParameters::strToValue(Handle &handle, const char *str, const char **endptr) // assigns this string to the value
-{
-	ErrorType ret = ERROR_NONE;
-
-	const Definition *pd = handle.parameterDefinition();
-
-	switch ( pd->type() )
-	{
-        case TYPE_UNDEFINED:
-        case TYPE_ARRAY:
-		case TYPE_STRUCT:    ret = ERROR_TYPE_NOT_SUPPORTED;                                  break;
-
-		case TYPE_STRING:    ret = setParamString(handle,str);                                break;
-        case TYPE_ENUM:      ret = setParamEnum(handle,str);                                  break;
-		case TYPE_REF:       ret = ERROR_TYPE_NOT_SUPPORTED;                                  break;
-		case TYPE_BOOL:	     ret = setParamBool(handle,physx::PxAsc::strToBool(str, endptr)); break;
-        case TYPE_I8:  	     ret = setParamI8(handle,physx::PxAsc::strToI8(str, endptr));     break;
-        case TYPE_I16:       ret = setParamI16(handle,physx::PxAsc::strToI16(str, endptr));   break;
-        case TYPE_I32:       ret = setParamI32(handle,physx::PxAsc::strToI32(str, endptr));   break;
-        case TYPE_I64:       ret = setParamI64(handle,physx::PxAsc::strToI64(str, endptr));   break;
-        case TYPE_U8:        ret = setParamU8(handle,physx::PxAsc::strToU8(str, endptr));     break;
-        case TYPE_U16:       ret = setParamU16(handle,physx::PxAsc::strToU16(str, endptr));   break;
-        case TYPE_U32:       ret = setParamU32(handle,physx::PxAsc::strToU32(str, endptr));   break;
-        case TYPE_U64:       ret = setParamU64(handle,physx::PxAsc::strToU64(str, endptr));   break;
-        case TYPE_F32:       ret = setParamF32(handle,physx::PxAsc::strToF32(str, endptr));   break;
-        case TYPE_F64:       ret = setParamF64(handle,physx::PxAsc::strToF64(str, endptr));   break;
-        case TYPE_VEC2:      ret = setParamVec2(handle,getVec2(str, endptr));                 break;
-        case TYPE_VEC3:      ret = setParamVec3(handle,getVec3(str, endptr));                 break;
-        case TYPE_VEC4:      ret = setParamVec4(handle,getVec4(str, endptr));                 break;
-        case TYPE_QUAT:      ret = setParamQuat(handle,getQuat(str, endptr));                 break;
-        case TYPE_MAT33:     ret = setParamMat33(handle,getMat33(str, endptr));               break;
-        case TYPE_MAT34:     
-			{
-				float f[12];
-				getMat34Legacy(str, endptr, f);
-				ret = setParamMat34Legacy(handle,f);   
-				break;
-			}
-        case TYPE_MAT44:     ret = setParamMat44(handle,getMat44(str, endptr));               break;
-        case TYPE_BOUNDS3:   ret = setParamBounds3(handle,getBounds3(str, endptr));           break;
-        case TYPE_TRANSFORM: ret = setParamTransform(handle,getTransform(str, endptr));       break;
-
-NV_PARAMETRIZED_SERVICE_AND_LAST_DATATYPE_LABELS
-		default:             ret = ERROR_TYPE_NOT_SUPPORTED;                                  break;
-    }
-
-	PX_ASSERT(ret == ERROR_NONE);
-
-    return ret;
-}
-
-physx::PxVec2 		NvParameters::getVec2(const char *str, const char **endptr)
-{
-	physx::PxVec2 ret(0,0);
-	physx::PxAsc::strToF32s(&ret.x,2,str,endptr);
-
-	return ret;
-}
-
-physx::PxVec3 		NvParameters::getVec3(const char *str, const char **endptr)
-{
-	physx::PxVec3 ret(0,0,0);
-	physx::PxAsc::strToF32s(&ret.x,3,str,endptr);
-
-	return ret;
-}
-
-physx::PxVec4 		NvParameters::getVec4(const char *str, const char **endptr)
-{
-	physx::PxVec4 ret(0,0,0,0);
-	physx::PxAsc::strToF32s(&ret.x,4,str,endptr);
-
-	return ret;
-}
-
-physx::PxQuat 		NvParameters::getQuat(const char *str, const char **endptr)
-{
-	physx::PxQuat ret;
-	//ret.identity();
-	float quat[4];
-	//ret.getXYZW(quat);
-	physx::PxAsc::strToF32s(quat,4,str,endptr);
-	//ret.setXYZW(quat);
-	ret = physx::PxQuat(quat[0], quat[1], quat[2], quat[3]);
-
-	return ret;
-}
-
-physx::PxMat33 		NvParameters::getMat33(const char *str, const char **endptr)
-{
-	physx::PxMat33 ret;
-	float *vals = const_cast<float *>(ret.front());
-	physx::PxAsc::strToF32s(vals,9,str,endptr);
-	return ret;
-}
-
-physx::PxMat44 		NvParameters::getMat44(const char *str, const char **endptr)
-{
-	physx::PxMat44 ret;
-	float *vals = const_cast<float *>(ret.front());
-	physx::PxAsc::strToF32s(vals,16,str,endptr);
-	return ret;
-}
-
-void NvParameters::getMat34Legacy(const char *str, const char **endptr, float (&val)[12])
-{
-	physx::PxAsc::strToF32s(val,12,str,endptr);
-}
-
-physx::PxBounds3    NvParameters::getBounds3(const char *str, const char **endptr)
-{
-	physx::PxBounds3 ret;
-	ret.setEmpty();
-	physx::PxAsc::strToF32s(&ret.minimum.x,6,str,endptr);
-	return ret;
-}
-
-//******************************************************************************
-//*** Vec2
-//******************************************************************************
-
-ErrorType NvParameters::setParamVec2(const Handle &handle, const physx::PxVec2 &val)
-{
-    CHECK_HANDLE
-    CHECK_F32_FINITE
-
-	if(handle.parameterDefinition()->type() == TYPE_VEC2)
-    {
-        return rawSetParamVec2(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamVec2(const Handle &handle, physx::PxVec2 &val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_VEC2)
-    {
-        return rawGetParamVec2(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamVec2Array(const Handle &handle, physx::PxVec2 *array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(VEC2)
-    return(rawGetParamVec2Array(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamVec2Array(const Handle &handle, const physx::PxVec2 *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(VEC2)
-    CHECK_F32_FINITE_ARRAY
-    return(rawSetParamVec2Array(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** Vec3
-//******************************************************************************
-
-ErrorType NvParameters::setParamVec3(const Handle &handle, const physx::PxVec3 &val)
-{
-    CHECK_HANDLE
-    CHECK_F32_FINITE
-
-	if(handle.parameterDefinition()->type() == TYPE_VEC3)
-    {
-        return rawSetParamVec3(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamVec3(const Handle &handle, physx::PxVec3 &val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_VEC3)
-    {
-        return rawGetParamVec3(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamVec3Array(const Handle &handle, physx::PxVec3 *array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(VEC3)
-    return(rawGetParamVec3Array(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamVec3Array(const Handle &handle, const physx::PxVec3 *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(VEC3)
-    CHECK_F32_FINITE_ARRAY
-    return(rawSetParamVec3Array(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** Vec4
-//******************************************************************************
-
-ErrorType NvParameters::setParamVec4(const Handle &handle, const physx::PxVec4 &val)
-{
-    CHECK_HANDLE
-    CHECK_F32_FINITE
-
-	if(handle.parameterDefinition()->type() == TYPE_VEC4)
-    {
-        return rawSetParamVec4(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamVec4(const Handle &handle, physx::PxVec4 &val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_VEC4)
-    {
-        return rawGetParamVec4(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamVec4Array(const Handle &handle, physx::PxVec4 *array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(VEC4)
-    return(rawGetParamVec4Array(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamVec4Array(const Handle &handle, const physx::PxVec4 *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(VEC4)
-    CHECK_F32_FINITE_ARRAY
-    return(rawSetParamVec4Array(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** Quat
-//******************************************************************************
-
-ErrorType NvParameters::setParamQuat(const Handle &handle, const physx::PxQuat &val)
-{
-    CHECK_HANDLE
-    CHECK_F32_FINITE
-
-	if(handle.parameterDefinition()->type() == TYPE_QUAT)
-    {
-        return rawSetParamQuat(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamQuat(const Handle &handle, physx::PxQuat &val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_QUAT)
-    {
-        return rawGetParamQuat(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamQuatArray(const Handle &handle, physx::PxQuat *array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(QUAT)
-    return(rawGetParamQuatArray(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamQuatArray(const Handle &handle, const physx::PxQuat *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(QUAT)
-    CHECK_F32_FINITE_ARRAY
-    return(rawSetParamQuatArray(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** Mat33
-//******************************************************************************
-
-ErrorType NvParameters::setParamMat33(const Handle &handle, const physx::PxMat33 &val)
-{
-    CHECK_HANDLE
-    CHECK_F32_FINITE
-
-    	if(handle.parameterDefinition()->type() == TYPE_MAT33)
-    {
-        return rawSetParamMat33(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamMat33(const Handle &handle, physx::PxMat33 &val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_MAT33)
-    {
-        return rawGetParamMat33(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamMat33Array(const Handle &handle, physx::PxMat33 *array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(MAT33)
-    return(rawGetParamMat33Array(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamMat33Array(const Handle &handle, const physx::PxMat33 *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(MAT33)
-    CHECK_F32_FINITE_ARRAY
-    return(rawSetParamMat33Array(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** Mat34Legacy
-//******************************************************************************
-
-ErrorType NvParameters::setParamMat34Legacy(const Handle &handle, const float (&val)[12])
-{
-    CHECK_HANDLE
-    CHECK_F32_FINITE
-
-   	if(handle.parameterDefinition()->type() == TYPE_MAT34)
-    {
-        return rawSetParamMat34Legacy(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamMat34Legacy(const Handle &handle, float (&val)[12]) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_MAT34)
-    {
-        return rawGetParamMat34Legacy(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamMat34LegacyArray(const Handle &handle, float *array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(MAT34)
-    return(rawGetParamMat34LegacyArray(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamMat34LegacyArray(const Handle &handle, const float *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(MAT34)
-    CHECK_F32_FINITE_ARRAY
-    return(rawSetParamMat34LegacyArray(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** Mat44
-//******************************************************************************
-
-ErrorType NvParameters::setParamMat44(const Handle &handle, const physx::PxMat44 &val)
-{
-    CHECK_HANDLE
-    CHECK_F32_FINITE
-
-   	if(handle.parameterDefinition()->type() == TYPE_MAT44)
-    {
-        return rawSetParamMat44(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamMat44(const Handle &handle, physx::PxMat44 &val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_MAT44)
-    {
-        return rawGetParamMat44(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamMat44Array(const Handle &handle, physx::PxMat44 *array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(MAT44)
-    return(rawGetParamMat44Array(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamMat44Array(const Handle &handle, const physx::PxMat44 *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(MAT44)
-    CHECK_F32_FINITE_ARRAY
-    return(rawSetParamMat44Array(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** Bounds3
-//******************************************************************************
-
-ErrorType NvParameters::setParamBounds3(const Handle &handle, const physx::PxBounds3 &val)
-{
-    CHECK_HANDLE
-    CHECK_F32_FINITE
-
-	if(handle.parameterDefinition()->type() == TYPE_BOUNDS3)
-    {
-        return rawSetParamBounds3(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamBounds3(const Handle &handle, physx::PxBounds3 &val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_BOUNDS3)
-    {
-        return rawGetParamBounds3(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamBounds3Array(const Handle &handle, physx::PxBounds3 *array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(BOUNDS3)
-    return(rawGetParamBounds3Array(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamBounds3Array(const Handle &handle, const physx::PxBounds3 *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(BOUNDS3)
-    CHECK_F32_FINITE_ARRAY
-    return(rawSetParamBounds3Array(handle, array, n, offset));
-}
-
-//******************************************************************************
-//*** Transform
-//******************************************************************************
-
-ErrorType NvParameters::setParamTransform(const Handle &handle, const physx::PxTransform &val)
-{
-    CHECK_HANDLE
-    CHECK_F32_FINITE
-
-   	if(handle.parameterDefinition()->type() == TYPE_TRANSFORM)
-    {
-        return rawSetParamTransform(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-	return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamTransform(const Handle &handle, physx::PxTransform &val) const
-{
-    CHECK_HANDLE
-
-	if(handle.parameterDefinition()->type() == TYPE_TRANSFORM)
-    {
-        return rawGetParamTransform(handle, val);
-    }
-
-	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");
-    return(ERROR_CAST_FAILED);
-}
-
-ErrorType NvParameters::getParamTransformArray(const Handle &handle, physx::PxTransform *array, int32_t n, int32_t offset) const
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(TRANSFORM)
-    return(rawGetParamTransformArray(handle, array, n, offset));
-}
-
-ErrorType NvParameters::setParamTransformArray(const Handle &handle, const physx::PxTransform *array, int32_t n, int32_t offset)
-{
-    CHECK_HANDLE
-    CHECK_IS_SIMPLE_ARRAY(TRANSFORM)
-    CHECK_F32_FINITE_ARRAY
-    return(rawSetParamTransformArray(handle, array, n, offset));
-}
-
-physx::PxTransform    NvParameters::getTransform(const char *str, const char **endptr)
-{
-	physx::PxTransform ret;
-	physx::PxAsc::strToF32s((float*)&ret,7,str,endptr);
-	return ret;
-}
-
-
-//***********************************************
-physx::PxVec2 NvParameters::init(float x,float y)
-{
-	physx::PxVec2 ret(x,y);
-	return ret;
-}
-
-physx::PxVec3 NvParameters::init(float x,float y,float z)
-{
-	physx::PxVec3 ret(x,y,z);
-	return ret;
-}
-
-physx::PxVec4 NvParameters::initVec4(float x,float y,float z,float w)
-{
-	physx::PxVec4 ret(x,y,z,w);
-	return ret;
-}
-
-physx::PxQuat NvParameters::init(float x,float y,float z,float w)
-{
-	physx::PxQuat ret;
-	//ret.setXYZW(x,y,z,w);
-	ret = physx::PxQuat(x,y,z,w);
-	return ret;
-}
-
-physx::PxMat33 NvParameters::init(float _11,float _12,float _13,float _21,float _22,float _23,float _31,float _32,float _33)
-{
-	physx::PxMat33 ret;
-
-	ret.column0.x = _11;
-	ret.column0.y = _21;
-	ret.column0.z = _31;
-
-	ret.column1.x = _12;
-	ret.column1.y = _22;
-	ret.column1.z = _32;
-
-	ret.column2.x = _13;
-	ret.column2.y = _23;
-	ret.column2.z = _33;
-
-	return ret;
-}
-
-physx::PxMat44 NvParameters::init(float _11,float _12,float _13,float _14,float _21,float _22,float _23,float _24,float _31,float _32,float _33,float _34,float _41,float _42,float _43,float _44)
-{
-	physx::PxMat44 ret;
-
-	ret.column0.x = _11;
-	ret.column0.y = _21;
-	ret.column0.z = _31;
-	ret.column0.w = _41;
-
-	ret.column1.x = _12;
-	ret.column1.y = _22;
-	ret.column1.z = _32;
-	ret.column1.w = _42;
-
-	ret.column2.x = _13;
-	ret.column2.y = _23;
-	ret.column2.z = _33;
-	ret.column2.w = _43;
-
-	ret.column3.x = _14;
-	ret.column3.y = _24;
-	ret.column3.z = _34;
-	ret.column3.w = _44;
-
-	return ret;
-}
-
-physx::PxTransform NvParameters::init(float x,float y,float z,float qx,float qy,float qz,float qw)
-{
-	return physx::PxTransform(physx::PxVec3(x,y,z), physx::PxQuat(qx,qy,qz,qw));
-}
-
-
-physx::PxBounds3 NvParameters::init(float minx,float miny,float minz,float maxx,float maxy,float maxz)
-{
-	physx::PxBounds3 ret;
-	ret.minimum = physx::PxVec3(minx,miny,minz);
-	ret.maximum = physx::PxVec3(maxx,maxy,maxz);
-	return ret;
-}
-
-
-
-int32_t NvParameters::MultIntArray(const int32_t *array, int32_t n)
-{
-    PX_ASSERT(array != NULL);
-    PX_ASSERT(n > 0);
-
-    int32_t ret = array[0];
-
-    for(int32_t i=1; i < n; ++i)
-        ret *= array[i];
-
-    return(ret);
-}
-
-
-ErrorType NvParameters::resizeArray(Traits *parameterizedTraits,
-													 void *&buf, 
-													 int32_t *array_sizes, 
-													 int32_t dimension, 
-													 int32_t resize_dim,
-													 int32_t new_size,
-													 bool doFree,
-													 int32_t element_size,
-													 uint32_t element_align,
-													 bool &isMemAllocated)
-{
-    PX_ASSERT(array_sizes != NULL);
-    PX_ASSERT(dimension > 0);
-    PX_ASSERT(resize_dim >= 0 && resize_dim < dimension);
-    PX_ASSERT(new_size >= 0);
-	PX_ASSERT(element_size > 0 );
-
-    if(array_sizes[resize_dim] == new_size)
-        return(ERROR_NONE); //isMemAllocated is unchanged
-
-    int32_t newSizes[Handle::MAX_DEPTH];
-    physx::intrinsics::memCopy(newSizes, array_sizes, dimension * sizeof(int32_t));
-
-    newSizes[resize_dim] = new_size;
-
-    int32_t currentNumElems = MultIntArray(array_sizes, dimension);
-    int32_t newNumElems = MultIntArray(newSizes, dimension);
-
-    if(newNumElems <= 0)
-    {
-        if(buf != NULL && doFree) 
-            parameterizedTraits->free(buf);
-
-        buf = NULL;
-        goto no_error;
-    }
-
-    if(buf == NULL) 
-    {
-		PX_ASSERT(element_size * newNumElems >= 0);
-        if((buf = allocAligned(parameterizedTraits, static_cast<uint32_t>(element_size * newNumElems), element_align)) == NULL)
-		{
-			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_MEMORY_ALLOCATION_FAILURE");
-            return(ERROR_MEMORY_ALLOCATION_FAILURE);
-		}
-
-		isMemAllocated = true;
-        
-        //initialize the array to 0's (for strings)
-		physx::intrinsics::memZero(buf, uint32_t(element_size * newNumElems));
-
-        goto no_error;
-    }
-
-    if(resize_dim == 0)
-    {
-        void *newBuf;
-        char *newBufDataStart;
-        int32_t newBufDataSize;
-        
-		PX_ASSERT(element_size * newNumElems >= 0);
-        // alloc new buffer
-        if((newBuf = allocAligned(parameterizedTraits, static_cast<uint32_t>(element_size * newNumElems), element_align)) == NULL)
-		{
-			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_MEMORY_ALLOCATION_FAILURE");
-            return(ERROR_MEMORY_ALLOCATION_FAILURE);
-		}
-
-		isMemAllocated = true;
-        
-        // copy existing data to new buffer
-		if(newNumElems < currentNumElems)
-			physx::intrinsics::memCopy(newBuf, buf, uint32_t(element_size * newNumElems));
-		else
-			physx::intrinsics::memCopy(newBuf, buf, uint32_t(element_size * currentNumElems));
-        
-        // zero the new part of the array
-        if(newNumElems > currentNumElems)
-        {
-            newBufDataStart = (char *)newBuf + (currentNumElems * element_size);
-            newBufDataSize = (newNumElems - currentNumElems) * element_size;
-
-			PX_ASSERT(newBufDataSize >= 0);
-            memset(newBufDataStart, 0, static_cast<uint32_t>(newBufDataSize));
-        }
-        
-        if( doFree )
-        parameterizedTraits->free(buf);
-        buf = newBuf;
-    }
-    else
-    {
-		PX_ASSERT(element_size * newNumElems >= 0);
-        void *newBuf = allocAligned(parameterizedTraits, static_cast<uint32_t>(element_size * newNumElems), element_align);
-        if(newBuf == NULL)
-		{
-			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_MEMORY_ALLOCATION_FAILURE");
-            return(ERROR_MEMORY_ALLOCATION_FAILURE);
-		}
-
-		isMemAllocated = true;
-
-        //initialize the array to 0's (for strings)
-		physx::intrinsics::memSet(newBuf, 0U, uint32_t(element_size * newNumElems));
-        recursiveCopy(buf, array_sizes, newBuf, newSizes, dimension, element_size);
-
-		if( doFree )
-        parameterizedTraits->free(buf);
-        buf = newBuf;
-    }
-      
-
-no_error:
-
-    array_sizes[resize_dim] = new_size;
-    return(ERROR_NONE);
-}
-
-void NvParameters::recursiveCopy(const void *src, 
-								 const int32_t *src_sizes, 
-								 void *dst, 
-								 const int32_t *dst_sizes, 
-								 int32_t dimension, 
-								 int32_t element_size,
-								 int32_t *indexes, 
-								 int32_t level)
-{
-    int32_t srcSize = src_sizes[level];
-    int32_t dstSize = dst_sizes[level];
-
-    int32_t size = physx::PxMin(srcSize, dstSize);
-
-    int32_t indexStore[Handle::MAX_DEPTH];
-
-    if(indexes == NULL)
-    {
-        indexes = indexStore;
-        memset(indexes, 0, Handle::MAX_DEPTH * sizeof(int32_t));
-    }
-
-    if(level == dimension - 1)
-    {
-        int32_t srcIndex = indexes[0];
-        int32_t dstIndex = indexes[0];
-
-        for(int32_t i=1; i < dimension; ++i)
-        {
-            srcIndex = src_sizes[i] * (srcIndex) + indexes[i];
-            dstIndex = dst_sizes[i] * (dstIndex) + indexes[i];
-        }
-
-		char *copy_dst = (char *)dst + dstIndex * element_size;
-		char *copy_src = (char *)src + srcIndex * element_size;
-		PX_ASSERT(element_size * size > 0);
-		physx::intrinsics::memCopy(copy_dst, copy_src, uint32_t(element_size * size));
-        return;
-    }
-
-    for(int32_t i=0; i < size; ++i)
-    {
-        indexes[level] = i;
-        recursiveCopy(src, src_sizes, dst, dst_sizes, dimension, element_size, indexes, level + 1);
-    }
-}
-
-ErrorType NvParameters::getParamU8Array(const Handle &handle, uint8_t *array, int32_t n, int32_t offset) const
-{
-	CHECK_HANDLE
-	CHECK_IS_SIMPLE_ARRAY(U8)
-	return(rawGetParamArray<uint8_t>(handle, array, n, offset,this));
-}
-
-ErrorType NvParameters::getParamF64Array(const Handle &handle, double *array, int32_t n, int32_t offset) const
-{
-	CHECK_HANDLE
-	CHECK_IS_SIMPLE_ARRAY(F64)
-	return(rawGetParamArray<double>(handle, array, n, offset,this));
-}
-
-
-
-
-ErrorType NvParameters::rawSetParamBool(const Handle &handle, bool val)
-{
-	return rawSetParam<bool>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamBool(const Handle &handle, bool &val) const
-{
-	return rawGetParam<bool>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamBoolArray(const Handle &handle, bool *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<bool>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamBoolArray(const Handle &handle, const bool *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<bool>(handle,array,n,offset,this);
-}
-
-
-ErrorType NvParameters::rawGetParamString(const Handle &handle, const char *&val) const
-{
-	size_t offset;
-	void *ptr=NULL;
-	getVarPtr(handle, ptr, offset);
-	if ( ptr == NULL )
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_TYPE_NOT_SUPPORTED");
-		return ERROR_TYPE_NOT_SUPPORTED;
-	}
-
-	DummyStringStruct *var = (DummyStringStruct *)(char *)ptr;
-	val = var->buf;
-	return(ERROR_NONE);
-}
-
-ErrorType NvParameters::rawSetParamString(const Handle &handle, const char *val)
-{
-	size_t offset;
-	void *ptr=NULL;
-	getVarPtr(handle, ptr, offset);
-	if(ptr == NULL)
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");
-		return(ERROR_INDEX_OUT_OF_RANGE);
-	}
-
-	DummyStringStruct *var = (DummyStringStruct *)(char *)ptr;
-	if( var->isAllocated )
-	{
-		getTraits()->strfree((char *)var->buf);
-	}
-
-	var->buf = getTraits()->strdup(val);
-	var->isAllocated = true;
-
-	return(ERROR_NONE);
-}
-
-ErrorType NvParameters::rawGetParamEnum(const Handle &handle, const char *&val) const
-{
-	size_t offset;
-	void *ptr=NULL;
-	getVarPtr(handle, ptr, offset);
-	if ( ptr == NULL )
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_TYPE_NOT_SUPPORTED");
-		return ERROR_TYPE_NOT_SUPPORTED;
-	}
-	const char * *var = (const char * *)((char *)ptr);
-	val = *var;
-	return(ERROR_NONE);
-}
-
-ErrorType NvParameters::rawSetParamEnum(const Handle &handle, const char *val)
-{
-	size_t offset;
-	void *ptr=NULL;
-	getVarPtr(handle, ptr, offset);
-	if(ptr == NULL)
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");
-		return(ERROR_INDEX_OUT_OF_RANGE);
-	}
-	const char * *Var = (const char * *)((char *)ptr);
-	*Var = val;
-	return(ERROR_NONE);
-}
-
-ErrorType NvParameters::rawGetParamRef(const Handle &handle, NvParameterized::Interface *&val) const
-{
-	size_t offset;
-	void *ptr=NULL;
-	getVarPtr(handle, ptr, offset);
-	if ( ptr == NULL )
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_TYPE_NOT_SUPPORTED");
-		return ERROR_TYPE_NOT_SUPPORTED;
-	}
-
-	NvParameterized::Interface * *var = (NvParameterized::Interface * *)((char *)ptr);
-	val = *var;
-	return(ERROR_NONE);
-}
-
-ErrorType NvParameters::rawSetParamRef(const Handle &handle, NvParameterized::Interface * val)
-{
-	size_t offset;
-	void *ptr=NULL;
-	getVarPtr(handle, ptr, offset);
-	if(ptr == NULL)
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");
-		return(ERROR_INDEX_OUT_OF_RANGE);
-	}
-
-	NvParameterized::Interface * *Var = (NvParameterized::Interface * *)((char *)ptr);
-	*Var = val;
-	return(ERROR_NONE);
-}
-
-ErrorType NvParameters::rawGetParamI8(const Handle &handle, int8_t &val) const
-{
-	return rawGetParam<int8_t>(handle,val,this);
-}
-
-ErrorType NvParameters::rawSetParamI8(const Handle &handle, int8_t val)
-{
-	return rawSetParam<int8_t>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamI8Array(const Handle &handle, int8_t *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<int8_t>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamI8Array(const Handle &handle, const int8_t *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<int8_t>(handle,array,n,offset,this);
-}
-
-
-ErrorType NvParameters::rawGetParamI16(const Handle &handle, int16_t &val) const
-{
-	return rawGetParam<int16_t>(handle,val,this);
-}
-
-ErrorType NvParameters::rawSetParamI16(const Handle &handle, int16_t val)
-{
-	return rawSetParam<int16_t>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamI16Array(const Handle &handle, int16_t *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<int16_t>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamI16Array(const Handle &handle, const int16_t *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<int16_t>(handle,array,n,offset,this);
-}
-
-
-ErrorType NvParameters::rawGetParamI32(const Handle &handle, int32_t &val) const
-{
-	return rawGetParam<int32_t>(handle,val,this);
-}
-
-ErrorType NvParameters::rawSetParamI32(const Handle &handle, int32_t val)
-{
-	return rawSetParam<int32_t>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamI32Array(const Handle &handle, int32_t *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<int32_t>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamI32Array(const Handle &handle, const int32_t *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<int32_t>(handle,array,n,offset,this);
-}
-
-
-ErrorType NvParameters::rawGetParamI64(const Handle &handle, int64_t &val) const
-{
-	return rawGetParam<int64_t>(handle,val,this);
-}
-
-ErrorType NvParameters::rawSetParamI64(const Handle &handle, int64_t val)
-{
-	return rawSetParam<int64_t>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamI64Array(const Handle &handle, int64_t *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<int64_t>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamI64Array(const Handle &handle, const int64_t *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<int64_t>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawGetParamU8(const Handle &handle, uint8_t &val) const
-{
-	return rawGetParam<uint8_t>(handle,val,this);
-}
-
-ErrorType NvParameters::rawSetParamU8(const Handle &handle, uint8_t val)
-{
-	return rawSetParam<uint8_t>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamU8Array(const Handle &handle, uint8_t *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<uint8_t>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamU8Array(const Handle &handle, const uint8_t *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<uint8_t>(handle,array,n,offset,this);
-}
-
-
-ErrorType NvParameters::rawGetParamU16(const Handle &handle, uint16_t &val) const
-{
-	return rawGetParam<uint16_t>(handle,val,this);
-}
-
-ErrorType NvParameters::rawSetParamU16(const Handle &handle, uint16_t val)
-{
-	return rawSetParam<uint16_t>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamU16Array(const Handle &handle, uint16_t *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<uint16_t>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamU16Array(const Handle &handle, const uint16_t *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<uint16_t>(handle,array,n,offset,this);
-}
-
-
-ErrorType NvParameters::rawGetParamU32(const Handle &handle, uint32_t &val) const
-{
-	return rawGetParam<uint32_t>(handle,val,this);
-}
-
-ErrorType NvParameters::rawSetParamU32(const Handle &handle, uint32_t val)
-{
-	return rawSetParam<uint32_t>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamU32Array(const Handle &handle, uint32_t *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<uint32_t>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamU32Array(const Handle &handle, const uint32_t *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<uint32_t>(handle,array,n,offset,this);
-}
-
-
-ErrorType NvParameters::rawSetParamU64(const Handle &handle, uint64_t val)
-{
-	return rawSetParam<uint64_t>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamU64(const Handle &handle, uint64_t &val) const
-{
-	return rawGetParam<uint64_t>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamU64Array(const Handle &handle, uint64_t *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<uint64_t>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamU64Array(const Handle &handle, const uint64_t *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<uint64_t>(handle,array,n,offset,this);
-}
-
-
-ErrorType NvParameters::rawGetParamF32(const Handle &handle, float &val) const
-{
-	return rawGetParam<float>(handle,val,this);
-}
-
-ErrorType NvParameters::rawSetParamF32(const Handle &handle, float val)
-{
-	return rawSetParam<float>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamF32Array(const Handle &handle, float *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<float>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamF32Array(const Handle &handle, const float *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<float>(handle,array,n,offset,this);
-}
-
-
-ErrorType NvParameters::rawGetParamF64(const Handle &handle, double &val) const
-{
-	return rawGetParam<double>(handle,val,this);
-}
-
-ErrorType NvParameters::rawSetParamF64(const Handle &handle, double val)
-{
-	return rawSetParam<double>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamF64Array(const Handle &handle, double *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<double>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamF64Array(const Handle &handle, const double *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<double>(handle,array,n,offset,this);
-}
-
-
-ErrorType NvParameters::rawSetParamVec2(const Handle &handle,physx::PxVec2 val)
-{
-	return rawSetParam<physx::PxVec2>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamVec2(const Handle &handle,physx::PxVec2 &val) const
-{
-	return rawGetParam<physx::PxVec2>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamVec2Array(const Handle &handle,physx::PxVec2 *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<physx::PxVec2>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamVec2Array(const Handle &handle, const physx::PxVec2 *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<physx::PxVec2>(handle,array,n,offset,this);
-}
-
-
-ErrorType NvParameters::rawSetParamVec3(const Handle &handle,physx::PxVec3 val)
-{
-	return rawSetParam<physx::PxVec3>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamVec3(const Handle &handle,physx::PxVec3 &val) const
-{
-	return rawGetParam<physx::PxVec3>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamVec3Array(const Handle &handle,physx::PxVec3 *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<physx::PxVec3>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamVec3Array(const Handle &handle, const physx::PxVec3 *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<physx::PxVec3>(handle,array,n,offset,this);
-}
-
-
-ErrorType NvParameters::rawSetParamVec4(const Handle &handle,physx::PxVec4 val)
-{
-	return rawSetParam<physx::PxVec4>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamVec4(const Handle &handle,physx::PxVec4 &val) const
-{
-	return rawGetParam<physx::PxVec4>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamVec4Array(const Handle &handle,physx::PxVec4 *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<physx::PxVec4>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamVec4Array(const Handle &handle, const physx::PxVec4 *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<physx::PxVec4>(handle,array,n,offset,this);
-}
-
-
-ErrorType NvParameters::rawSetParamQuat(const Handle &handle,physx::PxQuat val)
-{
-	return rawSetParam<physx::PxQuat>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamQuat(const Handle &handle,physx::PxQuat &val) const
-{
-	return rawGetParam<physx::PxQuat>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamQuatArray(const Handle &handle,physx::PxQuat *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<physx::PxQuat>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamQuatArray(const Handle &handle, const physx::PxQuat *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<physx::PxQuat>(handle,array,n,offset,this);
-}
-
-
-ErrorType NvParameters::rawSetParamMat33(const Handle &handle,physx::PxMat33 val)
-{
-	return rawSetParam<physx::PxMat33>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamMat33(const Handle &handle,physx::PxMat33 &val) const
-{
-	return rawGetParam<physx::PxMat33>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamMat33Array(const Handle &handle,physx::PxMat33 *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<physx::PxMat33>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamMat33Array(const Handle &handle, const physx::PxMat33 *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<physx::PxMat33>(handle,array,n,offset,this);
-}
-
-
-ErrorType NvParameters::rawSetParamMat34Legacy(const Handle &handle, const float (&val)[12])
-{
-	Handle memberHandle(handle);
-
-	size_t tmp;
-	void *ptr = NULL;
-	this->getVarPtr(memberHandle, ptr, tmp);
-	if(ptr == NULL)
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");
-		return(ERROR_INDEX_OUT_OF_RANGE);
-	}
-
-	physx::intrinsics::memCopy(ptr, val, 12 * sizeof(float));
-
-#if APEX_UE4
-	// swap raw-column major
-	swap(static_cast<float*>(ptr)[1], static_cast<float*>(ptr)[3]);
-	swap(static_cast<float*>(ptr)[2], static_cast<float*>(ptr)[6]);
-	swap(static_cast<float*>(ptr)[5], static_cast<float*>(ptr)[7]);
-#endif
-	return(ERROR_NONE);
-}
-
-ErrorType NvParameters::rawGetParamMat34Legacy(const Handle &handle, float (&val)[12]) const
-{
-	Handle memberHandle(handle);
-
-	size_t tmp;
-	void *ptr = NULL;
-	this->getVarPtr(memberHandle, ptr, tmp);
-	if(ptr == NULL)
-	{
-		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");
-		return(ERROR_INDEX_OUT_OF_RANGE);
-	}
-
-	physx::intrinsics::memCopy(val, ptr, 12 * sizeof(float));
-
-	return(ERROR_NONE);
-}
-
-ErrorType NvParameters::rawGetParamMat34LegacyArray(const Handle &handle, float *array, int32_t n, int32_t offset) const
-{
-	if( n )
-	{
-		Handle memberHandle(handle);
-		NV_ERR_CHECK_RETURN(memberHandle.set(offset * 12));
-
-		size_t tmp;
-		void *ptr = NULL;
-		this->getVarPtr(memberHandle, ptr, tmp);
-		if(ptr == NULL)
-		{
-			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");
-			return(ERROR_INDEX_OUT_OF_RANGE);
-		}
-
-		physx::intrinsics::memCopy(array, ptr, 12 * n * sizeof(float));
-	}
-
-	return(ERROR_NONE);
-}
-
-ErrorType NvParameters::rawSetParamMat34LegacyArray(const Handle &handle, const float *array, int32_t n, int32_t offset)
-{
-	if( n )
-	{
-		Handle memberHandle(handle);
-		NV_ERR_CHECK_RETURN(memberHandle.set(offset * 12));
-
-		size_t tmp;
-		void *ptr = NULL;
-		this->getVarPtr(memberHandle, ptr, tmp);
-		if(ptr == NULL)
-		{
-			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");
-			return(ERROR_INDEX_OUT_OF_RANGE);
-		}
-
-		for (int32_t i = 0; i < n; ++i)
-		{
-			float* dst = static_cast<float*>(ptr) + 12 * sizeof(float) * i;
-			const float* src = array + 12 * sizeof(float) * i;
-
-			physx::intrinsics::memCopy(dst, src, 12 * sizeof(float));
-#if APEX_UE4
-			swap(dst[1], dst[3]);
-			swap(dst[2], dst[6]);
-			swap(dst[5], dst[7]);
-#endif
-		}
-	}
-
-	return(ERROR_NONE);
-}
-
-ErrorType NvParameters::rawSetParamMat44(const Handle &handle,physx::PxMat44 val)
-{
-	return rawSetParam<physx::PxMat44>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamMat44(const Handle &handle,physx::PxMat44 &val) const
-{
-	return rawGetParam<physx::PxMat44>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamMat44Array(const Handle &handle,physx::PxMat44 *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<physx::PxMat44>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamMat44Array(const Handle &handle, const physx::PxMat44 *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<physx::PxMat44>(handle,array,n,offset,this);
-}
-
-
-ErrorType NvParameters::rawSetParamBounds3(const Handle &handle,physx::PxBounds3 val)
-{
-	return rawSetParam<physx::PxBounds3>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamBounds3(const Handle &handle,physx::PxBounds3 &val) const
-{
-	return rawGetParam<physx::PxBounds3>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamBounds3Array(const Handle &handle,physx::PxBounds3 *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<physx::PxBounds3>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamBounds3Array(const Handle &handle, const physx::PxBounds3 *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<physx::PxBounds3>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamTransform(const Handle &handle,physx::PxTransform val)
-{
-	return rawSetParam<physx::PxTransform>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamTransform(const Handle &handle,physx::PxTransform  &val) const
-{
-	return rawGetParam<physx::PxTransform>(handle,val,this);
-}
-
-ErrorType NvParameters::rawGetParamTransformArray(const Handle &handle,physx::PxTransform *array, int32_t n, int32_t offset) const
-{
-	return rawGetParamArray<physx::PxTransform>(handle,array,n,offset,this);
-}
-
-ErrorType NvParameters::rawSetParamTransformArray(const Handle &handle, const physx::PxTransform *array, int32_t n, int32_t offset)
-{
-	return rawSetParamArray<physx::PxTransform>(handle,array,n,offset,this);
-}
-
-void *NvParameters::getVarPtrHelper(const ParamLookupNode *rootNode, void *paramStruct, const Handle &handle, size_t &offset) const
-{
-	const ParamLookupNode* curNode = rootNode;
-
-	bool hasDynamicArray = false;
-	offset = curNode->offset;
-
-	void *ptr = const_cast<void *>(paramStruct);
-	for(int32_t i = 0; i < handle.numIndexes(); ++i)
-	{
-		int index = handle.index(i);
-
-		if (curNode->type == TYPE_ARRAY)
-		{
-			PX_ASSERT(curNode->numChildren);
-
-			if (curNode->isDynamicArrayRoot)
-			{
-				ptr = ((DummyDynamicArrayStruct*)ptr)->buf;
-				hasDynamicArray = true;
-				if (ptr == NULL)
-				{
-					offset = 0;
-					return 0;
-				}
-			}
-
-			// don't get the next curNode until after we've checked that the "parent" is dynamic
-			curNode = &rootNode[curNode->children[0]];
-
-			size_t localOffset = index * curNode->offset;
-			offset += localOffset;
-			ptr = (char*)ptr + localOffset;
-		}
-		else
-		{
-			PX_ASSERT(index >= 0 && index < curNode->numChildren);
-			curNode = &rootNode[curNode->children[index]];
-			offset += curNode->offset;
-			ptr = (char*)ptr + curNode->offset;
-		}
-	}
-
-	if (hasDynamicArray)
-	{
-		offset = 0;
-	}
-
-	return ptr;
-}
-
-bool NvParameters::checkAlignments() const
-{
-	// support empty, named references
-	if(rootParameterDefinition() == NULL)
-	{
-		return IsAligned(this, 8);
-	}
-
-    Handle constHandle(*this, "");
-	if( !constHandle.isValid() )
-	{
-		return false;
-	}
-
-	return checkAlignments(constHandle);
-}
-
-bool NvParameters::checkAlignments(Handle &param_handle) const
-{
-    const Definition *paramDef = param_handle.parameterDefinition();
-
-	uint32_t align = paramDef->alignment();
-
-	bool isDynamicArray = TYPE_ARRAY == paramDef->type() && !paramDef->arraySizeIsFixed();
-
-	// For dynamic array alignment means alignment of it's first element
-	if( !isDynamicArray )
-	{
-		size_t offset;
-		void *ptr;
-		getVarPtr(param_handle, ptr, offset);
-		if( align > 0 && !IsAligned(ptr, align) )
-		{
-			return false;
-		}
-	}
-
-	switch( paramDef->type() )
-	{
-	case TYPE_STRUCT:
-		{
-			for(int32_t i = 0; i < paramDef->numChildren(); ++i)
-			{
-				param_handle.set(i);
-				if( !checkAlignments(param_handle) )
-				{
-					return false;
-				}
-				param_handle.popIndex();
-			}
-			break;
-		}
-
-	case TYPE_REF:
-		{
-			Interface *refObj;
-			if( ERROR_NONE != param_handle.getParamRef(refObj) )
-			{
-				return false;
-			}
-
-			return 0 == refObj || refObj->checkAlignments();
-		}
-
-	case TYPE_ARRAY:
-		{
-			int32_t size;
-			if( ERROR_NONE != param_handle.getArraySize(size) )
-			{
-				return false;
-			}
-
-			// See comment above
-			if( isDynamicArray && align > 0 && size > 0 )
-			{
-				param_handle.set(0);
-
-				size_t offset;
-				void *ptr;
-				getVarPtr(param_handle, ptr, offset);
-				if( !IsAligned(ptr, align) )
-				{
-					return false;
-				}
-
-				param_handle.popIndex();
-			}
-
-			bool isSimpleType = paramDef->child(0)->isSimpleType();
-
-			// Only check for first 10 elements if simple type
-			size = physx::PxMin(size, isSimpleType ? 10 : INT32_MAX);
-
-			for(int32_t i = 0; i < size; ++i)
-			{
-				param_handle.set(i);
-				if( !checkAlignments(param_handle) )
-				{
-					return false;
-				}
-				param_handle.popIndex();
-			}
-
-			break;
-		}
-	NV_PARAMETRIZED_NO_AGGREGATE_AND_REF_DATATYPE_LABELS
-	default:
-		break;
-    }
-
-    return(true);
-}
-} // namespace NvParameterized
+// 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) 2008-2013 NVIDIA Corporation. All rights reserved.

+

+#include <stdlib.h>

+#include <stdio.h>

+#include <string.h>

+#include <PxSimpleTypes.h>

+#include <PsIntrinsics.h>

+

+#if PX_VC && !PX_PS4

+#pragma warning(disable:4996 4310)

+#endif

+

+#include "PsAsciiConversion.h"

+

+#include "nvparameterized/NvParameterized.h"

+

+#include "NvParameters.h"

+#include "NvTraitsInternal.h"

+#include "PsString.h"

+

+

+namespace NvParameterized

+{

+

+#define NV_ERR_CHECK_RETURN(x) if(x!=ERROR_NONE) return(x);

+#define NV_BOOL_RETURN(x) if((x)!=ERROR_NONE) return(false);

+

+#define DEBUG_ASSERT(x)

+//#define DEBUG_ASSERT(x) PX_ASSERT(x)

+

+char Spog[] = "test";

+

+#define COND_DUP(str) (mStaticAllocation) ? (char *)(str) : local_strdup(str)

+

+template <typename T>

+void swap(T& a, T&b)

+{

+	T tmp = b;

+	b = a;

+	a = tmp;

+}

+

+

+int32_t local_strcmp(const char* s1, const char* s2)

+{

+	return physx::shdfnd::strcmp(s1, s2);

+}

+

+int32_t local_stricmp(const char* s1, const char* s2)

+{

+	return physx::shdfnd::stricmp(s1, s2);

+}

+

+int32_t local_sprintf_s( char * _DstBuf, size_t _DstSize, const char * _Format, ...)

+{

+	if ( _DstBuf == NULL || _Format == NULL )

+	{

+		return -1;

+	}

+

+	va_list arg;

+	va_start( arg, _Format );

+	int32_t r = physx::shdfnd::vsnprintf( _DstBuf, _DstSize, _Format, arg );

+	va_end(arg);

+

+	return r;

+}

+

+

+static PX_INLINE void* allocAligned(NvParameterized::Traits* t, uint32_t size, uint32_t align)

+{

+	void* buf = t->alloc(size, align);

+	if( (size_t)buf & (align - 1) )

+	{

+		t->free(buf);

+		return 0;

+	}

+

+	return buf;

+}

+

+static PX_INLINE double RandomF64()

+{

+	return (double)rand() / RAND_MAX;

+}

+

+static PX_INLINE float RandomF32()

+{

+	return (float)RandomF64();

+}

+

+static PX_INLINE uint32_t RandomIdx(uint32_t m, uint32_t M)

+{

+	return uint32_t(m + RandomF64() * (M - m) + 0.99); // FIXME: round

+}

+

+static PX_INLINE physx::PxVec2 RandomVec2()

+{

+	return physx::PxVec2(RandomF32(), RandomF32());

+}

+

+static PX_INLINE physx::PxVec3 RandomVec3()

+{

+	return physx::PxVec3(RandomF32(), RandomF32(), RandomF32());

+}

+

+static PX_INLINE physx::PxVec4 RandomVec4()

+{

+	return physx::PxVec4(RandomF32(), RandomF32(), RandomF32(), RandomF32());

+}

+

+static PX_INLINE physx::PxQuat RandomQuat()

+{

+	return physx::PxQuat(RandomF32(), RandomF32(), RandomF32(), RandomF32());

+}

+

+static PX_INLINE uint32_t RandomU32()

+{

+	return (uint32_t)rand();

+}

+

+static PX_INLINE uint64_t RandomU64()

+{

+	uint32_t u32s[2];

+	u32s[0] = RandomU32();

+	u32s[1] = RandomU32();

+

+	return *(uint64_t*)&u32s[0];

+}

+

+static PX_INLINE bool notEqual(const char *a, const char *b)

+{

+	if(a == NULL && b == NULL)

+		return(false);

+

+	return (a == NULL && b != NULL)

+		|| (a != NULL && b == NULL)

+		|| 0 != strcmp(a, b);

+}

+

+static PX_INLINE bool notEqual(uint8_t a,uint8_t b)

+{

+	return a!=b;

+}

+static PX_INLINE bool notEqual(uint16_t a,uint16_t b)

+{

+	return a!=b;

+}

+

+static PX_INLINE bool notEqual(uint32_t a,uint32_t b)

+{

+	return a!=b;

+}

+

+static PX_INLINE bool notEqual(uint64_t a,uint64_t b)

+{

+	return a!=b;

+}

+

+static PX_INLINE bool notEqual(int8_t a,int8_t b)

+{

+	return a!=b;

+}

+static PX_INLINE bool notEqual(int16_t a,int16_t b)

+{

+	return a!=b;

+}

+

+static PX_INLINE bool notEqual(int32_t a,int32_t b)

+{

+	return a!=b;

+}

+

+static PX_INLINE bool notEqual(int64_t a,int64_t b)

+{

+	return a!=b;

+}

+

+static PX_INLINE bool notEqual(float a,float b)

+{

+	return a!=b;

+}

+

+static PX_INLINE bool notEqual(float (&a)[12],float (&b)[12])

+{

+	return a[0] != b[0] || a[1] != b[1] || a[2] != b[2] || 

+			a[3] != b[3] || a[4] != b[4] || a[5] != b[5] || 

+			a[6] != b[6] || a[7] != b[7] || a[8] != b[8] || 

+			a[9] != b[9] || a[10] != b[10] || a[11] != b[11];

+}

+

+static PX_INLINE bool notEqual(double a,double b)

+{

+	return a!=b;

+}

+

+static PX_INLINE bool notEqual(bool a,bool b)

+{

+	return a!=b;

+}

+

+static PX_INLINE bool notEqual(const physx::PxVec2 &a,const physx::PxVec2 &b)

+{

+	return a!=b;

+}

+

+static PX_INLINE bool notEqual(const physx::PxVec3 &a,const physx::PxVec3 &b)

+{

+	return a!=b;

+}

+

+static PX_INLINE bool notEqual(const physx::PxVec4 &a,const physx::PxVec4 &b)

+{

+	return a!=b;

+}

+

+// This was formerly in the NvQuat.h file but was removed due to other code bases requiring it to be gone

+static PX_INLINE bool operator!=( const physx::PxQuat& a, const physx::PxQuat& b )

+{

+	return a.x != b.x

+		|| a.y != b.y

+		|| a.z != b.z

+		|| a.w != b.w;

+}

+

+static PX_INLINE bool notEqual(const physx::PxQuat &a,physx::PxQuat &b)

+{

+	return a != b;

+}

+

+static PX_INLINE bool notEqual(const physx::PxMat33 &a,physx::PxMat33 &b)

+{

+	const float *qa = a.front();

+	const float *qb = b.front();

+	return qa[0] != qb[0] || qa[1] != qb[1] || qa[2] != qb[2] || qa[3] != qb[3] ||

+		   qa[4] != qb[4] || qa[5] != qb[5] || qa[6] != qb[6] || qa[7] != qb[7] ||

+		   qa[8] != qb[8];

+}

+

+static PX_INLINE bool notEqual(const physx::PxMat44 &a,physx::PxMat44 &b)

+{

+	return a.column0.w != b.column0.w || a.column0.x != b.column0.x || a.column0.y != b.column0.y || a.column0.z != b.column0.z ||

+		a.column1.w != b.column1.w || a.column1.x != b.column1.x || a.column1.y != b.column1.y || a.column1.z != b.column1.z ||

+		a.column2.w != b.column2.w || a.column2.x != b.column2.x || a.column2.y != b.column2.y || a.column2.z != b.column2.z ||

+		a.column3.w != b.column3.w || a.column3.x != b.column3.x || a.column3.y != b.column3.y || a.column3.z != b.column3.z;

+}

+

+static PX_INLINE bool notEqual(const physx::PxBounds3 &a,const physx::PxBounds3 &b)

+{

+	return a.minimum != b.minimum || a.maximum != b.maximum;

+}

+

+static PX_INLINE bool notEqual(const physx::PxTransform &a,const physx::PxTransform &b)

+{

+	return a.p != b.p || a.q != b.q;

+}

+

+#define CHECK_FINITE(t) { \

+	const t* _fs = (const t*)&val; \

+	for(size_t _j = 0; _j < sizeof(val) / sizeof(t); ++_j) \

+	{ \

+		if( physx::PxIsFinite(_fs[_j]) ) continue; \

+		char _longName[256]; \

+		handle.getLongName(_longName, sizeof(_longName)); \

+		NV_PARAM_TRAITS_WARNING(mParameterizedTraits, "%s: setting non-finite floating point value", _longName); \

+		break; \

+	} \

+}

+

+#define CHECK_FINITE_ARRAY(t) { \

+	for(int32_t _i = 0; _i < int32_t(n); ++_i) \

+	{ \

+		const t* _fs = (const t*)(&array[_i]); \

+		for(size_t _j = 0; _j < sizeof(array[0]) / sizeof(t); ++_j) \

+		{ \

+			if( physx::PxIsFinite(_fs[_j]) ) continue; \

+			char _longName[256]; \

+			handle.getLongName(_longName, sizeof(_longName)); \

+			NV_PARAM_TRAITS_WARNING(mParameterizedTraits, "%s[%d]: setting non-finite floating point value", _longName, (int)_i); \

+			break; \

+		} \

+	} \

+}

+

+#define CHECK_F32_FINITE \

+	CHECK_FINITE(float)

+

+#define CHECK_F32_FINITE_ARRAY \

+	CHECK_FINITE_ARRAY(float)

+

+#define CHECK_F64_FINITE \

+	CHECK_FINITE(double)

+

+#define CHECK_F64_FINITE_ARRAY \

+	CHECK_FINITE_ARRAY(double)

+

+//******************************************************************************

+//*** Local functions

+//******************************************************************************

+

+#if 0

+static void *local_malloc(uint32_t bytes)

+{

+	return(NV_ALLOC(bytes, NV_DEBUG_EXP("NvParameterized::local_malloc")));

+}

+

+static void *local_realloc(void *buf, uint32_t bytes)

+{

+    return(GetApexAllocator()->realloc(buf, bytes));

+}

+

+static void local_free(void *buf)

+{

+    NV_FREE(buf);

+}

+#else

+

+static void *local_malloc(uint32_t bytes)

+{

+    return(malloc(bytes));

+}

+

+static void *local_realloc(void *buf, uint32_t bytes)

+{

+    return(realloc(buf, bytes));

+}

+

+static void local_free(void *buf)

+{

+    free(buf);

+}

+

+#endif

+

+static char *local_strdup(const char *str)

+{

+	if(str == NULL)

+		return NULL;

+

+	uint32_t len = (uint32_t)strlen(str);

+

+	char *result = (char *)local_malloc(sizeof(char) * (len + 1));

+	physx::shdfnd::strlcpy(result, len+1, str);

+	return result;

+}

+

+static void local_strncpy(char *dst, const char *src, uint32_t n)

+{

+	physx::shdfnd::strlcpy(dst, n, src);

+}

+

+

+static void local_strncat(char *dst, const char *src, uint32_t n)

+{

+	PX_UNUSED(n);

+	physx::shdfnd::strlcat(dst, strlen(dst) + strlen(src) + 1,src);

+}

+

+static int32_t safe_strcmp(const char *str1, const char *str2)

+{

+	if( str1 != NULL && str2 != NULL )

+		return strcmp(str1, str2);

+	else if( str1 == NULL && str2 == NULL )

+		return 0;

+	else

+		return -1;

+}

+

+void *dupBuf(void *buf, uint32_t n)

+{

+    PX_ASSERT(buf != NULL);

+    PX_ASSERT(n > 0);

+

+    void *Ret = local_malloc(n);

+    physx::intrinsics::memCopy(Ret, buf, n);

+

+    return(Ret);

+}

+

+DataType strToType(const char *str)

+{

+#   define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \

+        if(!strcmp(str, #type_name)) \

+            return(TYPE_##enum_name);

+

+#   include "nvparameterized/NvParameterized_types.h"

+

+	if(!strcmp(str, "Pointer"))

+		return(TYPE_POINTER);

+

+	if(!strcmp(str, "Mat34"))

+		return(TYPE_MAT34);

+

+    return(TYPE_UNDEFINED);

+}

+

+const char *typeToStr(DataType type)

+{

+    switch(type)

+    {

+

+#   define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \

+        case TYPE_##enum_name : \

+            return(#type_name);

+#       include "nvparameterized/NvParameterized_types.h"

+		

+		case TYPE_MAT34:

+			return "Mat34";

+

+		case TYPE_POINTER:

+			return "Pointer";

+

+NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS

+		default:

+			return NULL;

+    }

+}

+

+//******************************************************************************

+//*** class HintImpl

+//******************************************************************************

+

+HintImpl::HintImpl()

+{

+    mStaticAllocation = true;

+}

+

+HintImpl::HintImpl(const char *name, uint64_t value)

+{

+    PX_ASSERT(name != NULL);

+

+    init(name, value);

+}

+

+HintImpl::HintImpl(const char *name, double value)

+{

+    PX_ASSERT(name != NULL);

+

+    init(name, value);

+}

+

+HintImpl::HintImpl(const char *name, const char *value)

+{

+    PX_ASSERT(name != NULL);

+    PX_ASSERT(value != NULL);

+

+    init(name, value);

+}

+

+HintImpl::~HintImpl()

+{

+    cleanup();

+}

+

+void HintImpl::init(const char *name, uint64_t value, bool static_allocation)

+{

+    PX_ASSERT(name != NULL);

+

+    mStaticAllocation = static_allocation;

+    mType = TYPE_U64;

+    mName = COND_DUP(name);

+    mUIntValue = value;

+}

+

+void HintImpl::init(const char *name, double value, bool static_allocation)

+{

+    PX_ASSERT(name != NULL);

+

+    mStaticAllocation = static_allocation;

+    mType = TYPE_F64;

+    mName = COND_DUP(name);

+    mFloatValue = value;

+}

+

+void HintImpl::init(const char *name, const char *value, bool static_allocation)

+{

+    PX_ASSERT(name != NULL);

+    PX_ASSERT(value != NULL);

+

+    mStaticAllocation = static_allocation;

+    mType = TYPE_STRING;

+    mName = COND_DUP(name);

+    mStringValue = COND_DUP(value);

+}

+

+void HintImpl::cleanup(void)

+{

+    PX_ASSERT(mName != NULL);

+

+    if(!mStaticAllocation)

+    {

+        local_free(mName);

+

+        if(type() == TYPE_STRING)

+        {

+            PX_ASSERT(mStringValue != NULL);

+            local_free(mStringValue);

+        }

+    }

+}

+

+bool HintImpl::setAsUInt(uint64_t v) 

+{

+	bool ret = false;

+  PX_ASSERT(type() == TYPE_U64);

+  if ( type() == TYPE_U64 )

+  {

+	mUIntValue = v;

+	ret = true;

+  }

+  return ret;

+}

+

+uint64_t HintImpl::asUInt(void) const

+{

+	PX_ASSERT(type() == TYPE_U64);

+	return(mUIntValue);

+}

+

+double HintImpl::asFloat(void) const

+{

+  PX_ASSERT(type() == TYPE_U64 || type() == TYPE_F64);

+  return(type() == TYPE_U64 ? static_cast<int64_t>(mUIntValue) : mFloatValue);

+}

+

+const char *HintImpl::asString(void)const

+{

+  PX_ASSERT(type() == TYPE_STRING);

+  return(mStringValue);

+}

+

+

+//******************************************************************************

+//*** class Handle

+//******************************************************************************

+

+

+

+//******************************************************************************

+//*** class DefinitionImpl

+//******************************************************************************

+

+void DefinitionImpl::setDefaults(void)

+{

+    mName = NULL;

+

+	mLongName = NULL;

+	mLongNameAllocated = false;

+

+	mStructName = NULL;

+

+    mType = TYPE_UNDEFINED;

+

+    mArraySize = 0;

+

+    mParent = NULL;

+

+    mNumChildren = 0;

+    mChildren = NULL;

+

+    mNumHints = 0;

+    mHints = NULL;

+

+    mEnumVals = NULL;

+    mNumEnumVals = 0;

+

+	mNumRefVariants = 0;

+	mRefVariantVals = NULL;

+

+	mNumDynamicHandleIndices = 0;

+	mDynamicHandleIndices = NULL;

+

+	mAlign = mPad = 0;

+}

+

+DefinitionImpl::DefinitionImpl(Traits &traits, bool staticAlloc)

+{

+    mStaticAllocation = staticAlloc;

+	mTraits = &traits;

+    setDefaults();

+}

+

+DefinitionImpl::DefinitionImpl(const char *name, DataType t, const char *structName, Traits &traits, bool staticAlloc)

+{

+    mStaticAllocation = staticAlloc;

+	mTraits = &traits;

+	mLongNameAllocated = false;

+    init(name, t, structName, false);

+}

+

+

+DefinitionImpl::~DefinitionImpl()

+{

+    cleanup();

+}

+

+void DefinitionImpl::setAlignment(uint32_t align)

+{

+	mAlign = align;

+}

+

+uint32_t DefinitionImpl::alignment(void) const

+{

+	return mAlign;

+}

+

+void DefinitionImpl::setPadding(uint32_t pad)

+{

+	mPad = pad;

+}

+

+uint32_t DefinitionImpl::padding(void) const

+{

+	return mPad;

+}

+

+void DefinitionImpl::init(const char *name, DataType t, const char *structName, bool static_allocation)

+{

+	PX_UNUSED( static_allocation );

+

+    cleanup();

+

+	mName = name;

+    mLongName = name;

+	mStructName = structName;

+	

+    PX_ASSERT(t != TYPE_UNDEFINED);

+    mType = t;

+}

+

+void DefinitionImpl::destroy(void)

+{

+	PX_ASSERT( !mStaticAllocation );

+

+	if( !mStaticAllocation )

+	{

+		this->~DefinitionImpl();

+		mTraits->free(this);

+	}

+}

+

+void DefinitionImpl::cleanup(void)

+{

+    if(!mStaticAllocation)

+    {

+		if( mStructName )

+			mTraits->free((void *)mStructName);

+

+		mTraits->free((void *)mName);

+

+        if(mChildren != NULL)

+        {

+           for(int32_t i=0; i < mNumChildren; ++i)

+			   mChildren[i]->destroy();

+

+		   local_free(mChildren);

+		}

+

+		if(mHints != NULL)

+		{

+			for(int32_t i=0; i < mNumHints; ++i)

+			{

+				mHints[i]->cleanup();

+				mTraits->free(mHints[i]);

+			}

+

+            local_free(mHints);

+		}

+

+		if(mEnumVals != NULL)

+		{

+			for(int32_t i = 0; i < mNumEnumVals; ++i)

+				local_free(mEnumVals[i]);

+

+            local_free(mEnumVals);

+		}

+

+		if(mRefVariantVals != NULL)

+		{

+			for(int32_t i = 0; i < mNumRefVariants; ++i)

+				local_free(mRefVariantVals[i]);

+

+            local_free(mRefVariantVals);

+        }

+    }

+

+	if(mLongNameAllocated && mLongName)

+	{

+		mTraits->strfree( (char *)mLongName );

+		mLongName = NULL;

+		mLongNameAllocated = false;

+	}

+    

+    setDefaults();

+}

+

+const Definition *DefinitionImpl::root(void) const

+{

+    const Definition *root = this;

+    while(root->parent() != NULL)

+        root = root->parent();

+

+    return(root);

+}

+

+int32_t DefinitionImpl::arrayDimension(void) const

+{

+    PX_ASSERT(type() == TYPE_ARRAY);

+

+    int32_t Dim = 0;

+    const Definition *Cur = this;

+    for(;Cur->type() == TYPE_ARRAY; Cur = Cur->child(0))

+    {

+      PX_ASSERT(Cur != NULL);

+      Dim++;

+    }

+

+    return(Dim);

+}

+

+int32_t DefinitionImpl::arraySize(int32_t dimension) const

+{

+    PX_ASSERT(type() == TYPE_ARRAY);

+    PX_ASSERT(dimension >= 0);

+    PX_ASSERT(dimension < arrayDimension());

+

+    const Definition *Cur = this;

+    for(int32_t i=0; i < dimension; ++i)

+        Cur = Cur->child(0);

+

+    if(Cur->type() != TYPE_ARRAY)

+        return(-1);

+

+	const DefinitionImpl *pd = static_cast<const DefinitionImpl *>(Cur);

+

+    return( pd->mArraySize);

+}

+

+bool DefinitionImpl::arraySizeIsFixed(void) const

+{

+    PX_ASSERT(type() == TYPE_ARRAY);

+    return(mArraySize > 0);

+}

+

+bool DefinitionImpl::setArraySize(int32_t size)

+{

+    PX_ASSERT(size >= -1);

+

+    if(size < 0)

+        return(false);

+

+    mArraySize = size;

+

+    return(true);

+}

+

+bool DefinitionImpl::isIncludedRef(void) const

+{

+	const Hint *h = hint("INCLUDED");

+   	return h && h->type() == TYPE_U64 && h->asUInt();

+}

+

+int32_t DefinitionImpl::numChildren(void) const

+{

+    return(mNumChildren);

+}

+

+const Definition * DefinitionImpl::child(int32_t index) const

+{

+    PX_ASSERT(index >= 0);

+    PX_ASSERT(index < numChildren());

+    PX_ASSERT(type() == TYPE_STRUCT || type() == TYPE_ARRAY);

+

+    if(index < 0 || index >= numChildren())

+        return(NULL);

+

+    return(mChildren[index]);

+}

+

+const Definition *  DefinitionImpl::child(const char *name, int32_t &index) const

+{

+    PX_ASSERT(name);

+    PX_ASSERT(type() == TYPE_STRUCT);

+

+    int32_t i;

+    for(i=0; i < numChildren(); ++i)

+        if(!strcmp(mChildren[i]->name(), name))

+        {

+            index = i;

+            return(mChildren[i]);

+        }

+

+    return(NULL);

+}

+

+

+#define PUSH_TO_ARRAY(val, array, obj_type, num_var) \

+    num_var++; \

+    if(array == NULL) \

+        array = (obj_type *)local_malloc(sizeof(obj_type)); \

+    else \

+        array = (obj_type *)local_realloc(array, num_var * sizeof(obj_type)); \

+    PX_ASSERT(array != NULL); \

+    array[num_var-1] = val;

+

+

+static char *GenLongName(char *dst, 

+                         uint32_t n,

+                         const char *parent_long_name,

+                         DataType parent_type, 

+                         const char *child_name)

+{

+    local_strncpy(dst, parent_long_name, n);

+

+    switch(parent_type)

+    {

+        case TYPE_STRUCT:

+            if(parent_long_name[0])

+                local_strncat(dst, ".", n);

+            local_strncat(dst, child_name, n);

+            break;

+

+        case TYPE_ARRAY:

+            local_strncat(dst, "[]", n);

+            break;

+

+		NV_PARAMETRIZED_NO_AGGREGATE_DATATYPE_LABELS

+        default:

+            PX_ASSERT((void *)"Shouldn't be here!" == NULL);

+            break;

+    }

+

+    return(dst);

+}

+

+#define SET_ARRAY(type, src_array_var, dst_array_var, num_var) \

+    PX_ASSERT(src_array_var != NULL); \

+    PX_ASSERT(n > 0); \

+    if(mStaticAllocation) \

+    { \

+        dst_array_var = (type *)src_array_var; \

+        num_var = n; \

+    } \

+    else \

+    { \

+        PX_ASSERT(dst_array_var == NULL); \

+        dst_array_var = (type *)dupBuf(src_array_var, sizeof(type) * n); \

+        num_var = n; \

+    }

+

+void DefinitionImpl::setChildren(Definition **children, int32_t n)

+{

+    SET_ARRAY(Definition *, children, mChildren, mNumChildren);

+

+	char tmpStr[MAX_NAME_LEN];

+

+	for(int32_t i=0; i < n; ++i)

+    {

+        Definition *_child = children[i];

+		DefinitionImpl *child = static_cast< DefinitionImpl *>(_child);

+

+        PX_ASSERT(child->parent() == NULL); // Only one parent allowed

+

+        GenLongName(tmpStr, 

+                    MAX_NAME_LEN, 

+                    mLongName, 

+                    type(),

+                    child->mName);

+

+		child->mLongName = mTraits->strdup( tmpStr );

+		child->mLongNameAllocated = true;

+

+		PX_ASSERT( child != this );

+        child->mParent = this;

+    }

+}

+

+void DefinitionImpl::addChild(Definition *_child)

+{

+    PX_ASSERT(_child != NULL);

+    PX_ASSERT(!mStaticAllocation);

+

+	DefinitionImpl *child = static_cast< DefinitionImpl *>(_child);

+	PX_ASSERT(child->mParent == NULL); // Only one parent allowed

+	

+	char tmpStr[MAX_NAME_LEN];

+

+    GenLongName(tmpStr, 

+                MAX_NAME_LEN, 

+                mLongName, 

+                type(), 

+                child->mName);

+

+	child->mLongName = mTraits->strdup( tmpStr );

+	child->mLongNameAllocated = true;

+

+	PX_ASSERT( child != this );

+    child->mParent = this;

+    PUSH_TO_ARRAY(_child, mChildren, Definition *, mNumChildren)

+}

+

+

+int32_t DefinitionImpl::numHints(void) const

+{

+    return(mNumHints);   

+}

+

+const Hint *DefinitionImpl::hint(int32_t index) const

+{

+    PX_ASSERT(index >= 0);

+    PX_ASSERT(index < numHints());

+

+	if( index >= numHints() )

+	{

+		return(NULL);

+	}

+

+    return(mHints[index]);

+}

+

+const Hint *DefinitionImpl::hint(const char *name) const

+{

+    PX_ASSERT(name != NULL);

+

+    for(int32_t i=0; i < numHints(); ++i)

+        if(!strcmp(mHints[i]->name(), name))

+            return(mHints[i]);

+

+    return(NULL);

+}

+

+void DefinitionImpl::setHints(const Hint **hints, int32_t n)

+{

+    SET_ARRAY(HintImpl *, hints, mHints, mNumHints);

+}

+

+void DefinitionImpl::addHint(Hint *_hint)

+{

+    PX_ASSERT(_hint != NULL);

+	HintImpl *hint = static_cast< HintImpl *>(_hint);

+    PUSH_TO_ARRAY(hint, mHints, HintImpl *, mNumHints)

+}

+

+int32_t DefinitionImpl::numEnumVals(void) const

+{

+   return(mNumEnumVals);

+}

+

+int32_t DefinitionImpl::enumValIndex( const char * enum_val ) const

+{

+	if(!enum_val)

+		return(-1);

+

+	for(int32_t i=0; i < numEnumVals(); ++i)

+	{

+        if( !strcmp( enumVal(i), enum_val ) )

+		{

+            return(i);

+		}

+	}

+

+	return(-1);

+}

+

+const char *DefinitionImpl::enumVal(int32_t index) const

+{

+    PX_ASSERT(index >= 0);

+    PX_ASSERT(index < numEnumVals());

+

+    return(mEnumVals[index]);

+}

+

+void DefinitionImpl::setEnumVals(const char **enum_vals, int32_t n)

+{

+    SET_ARRAY(char *, enum_vals, mEnumVals, mNumEnumVals);

+}

+

+void DefinitionImpl::addEnumVal(const char *enum_val)

+{

+    PX_ASSERT(enum_val != NULL);

+

+    char *NewEnumVal = COND_DUP(enum_val);

+    PUSH_TO_ARRAY(NewEnumVal, mEnumVals, char *, mNumEnumVals)

+}

+

+int32_t DefinitionImpl::refVariantValIndex( const char * ref_val ) const

+{

+	if(!ref_val)

+		return(-1);

+

+	for(int32_t i=0; i < numRefVariants(); ++i)

+	{

+        if( !strcmp( refVariantVal(i), ref_val ) )

+		{

+            return(i);

+		}

+	}

+

+	return(-1);

+}

+

+int32_t DefinitionImpl::numRefVariants(void) const

+{

+	return(mNumRefVariants);

+}

+

+const char *DefinitionImpl::refVariantVal(int32_t index) const

+{

+    PX_ASSERT(index >= 0);

+    PX_ASSERT(index < numRefVariants());

+

+    return(mRefVariantVals[index]);

+}

+

+void DefinitionImpl::setRefVariantVals(const char **ref_vals, int32_t n)

+{

+    SET_ARRAY(char *, ref_vals, mRefVariantVals, mNumRefVariants);

+}

+

+void DefinitionImpl::addRefVariantVal(const char *ref_val)

+{

+    PX_ASSERT(ref_val != NULL);

+

+    char *NewEnumVal = COND_DUP(ref_val);

+    PUSH_TO_ARRAY(NewEnumVal, mRefVariantVals, char *, mNumRefVariants)

+}

+

+void DefinitionImpl::setDynamicHandleIndicesMap(const uint8_t *indices, uint32_t numIndices)

+{

+	mNumDynamicHandleIndices = numIndices;

+	mDynamicHandleIndices = indices;

+}

+

+const uint8_t * DefinitionImpl::getDynamicHandleIndicesMap(uint32_t &outNumIndices) const

+{

+	outNumIndices = mNumDynamicHandleIndices;

+	return mDynamicHandleIndices;

+}

+

+bool DefinitionImpl::isSimpleType(bool simpleStructs, bool simpleStrings) const

+{

+	switch(mType)

+	{

+	case TYPE_STRUCT:

+		if( !simpleStructs )

+			return false;

+

+		for(int32_t i = 0; i < mNumChildren; ++i)

+		{

+			if( !mChildren[i]->isSimpleType(simpleStructs, simpleStrings) )

+				return false;

+		}

+

+		return true;

+

+	case TYPE_ARRAY:

+	case TYPE_REF:

+		return false;

+

+	NV_PARAMETRIZED_NO_AGGREGATE_AND_REF_DATATYPE_LABELS

+	default:

+		PX_ASSERT( mNumChildren == 0 );

+		return true;

+	}

+}

+

+//******************************************************************************

+//*** class NvParameterized

+//******************************************************************************

+

+NvParameters::NvParameters(Traits *traits, void *buf, int32_t *refCount)

+{

+	mParameterizedTraits = traits;

+

+	if( buf )

+	{

+		mBuffer = buf;

+		mRefCount = refCount;

+

+		//Values of other fields are already deserialized

+	}

+	else

+	{

+		mName = mClassName = NULL;

+		mDoDeallocateName = mDoDeallocateClassName = mDoDeallocateSelf = true;

+

+		mSerializationCb = NULL;

+		mCbUserData = NULL;

+

+		mBuffer = NULL;

+		mRefCount = NULL;

+

+		//Other fields are used only for inplace objects => skip them

+	}

+}

+

+NvParameters::~NvParameters()

+{

+	if( mClassName && mDoDeallocateClassName )

+	{

+		mParameterizedTraits->strfree( const_cast<char*>(mClassName) );

+		mClassName = NULL;

+	}

+

+	if( mName && mDoDeallocateName )

+	{

+		mParameterizedTraits->strfree( const_cast<char*>(mName) );

+		mName = NULL;

+	}

+}

+

+// placement delete

+void NvParameters::destroy()

+{

+	// We cache these fields here to avoid overwrite in destructor

+	bool doDeallocateSelf = mDoDeallocateSelf;

+	void *buf = mBuffer;

+	int32_t *refCount = mRefCount;

+	NvParameterized::Traits *traits = mParameterizedTraits;

+

+	this->~NvParameters();

+

+	destroy(this, traits, doDeallocateSelf, refCount, buf);

+}

+

+void NvParameters::destroy(NvParameters *obj, NvParameterized::Traits *traits, bool doDeallocateSelf, int32_t *refCount, void *buf)

+{

+	if( !doDeallocateSelf )

+		return;

+

+	if( !refCount ) //Ordinary object?

+		{

+		traits->free(obj);

+			return;

+		}

+

+		//Inplace object => callback client

+

+	traits->onInplaceObjectDestroyed(buf, obj);

+	if( !traits->decRefCount(refCount) )

+		traits->onAllInplaceObjectsDestroyed(buf);

+}

+

+

+uint16_t NvParameters::getMajorVersion(void) const

+{

+	uint16_t major = version() >> 16;

+	return major;

+}

+

+uint16_t NvParameters::getMinorVersion(void) const

+{

+	uint16_t minor = version() & 0xffff;

+	return minor;

+}

+

+void NvParameters::initRandom(void)

+{

+	Handle handle(*this, "");

+	initRandom(handle);

+}

+

+void NvParameters::initRandom(NvParameterized::Handle& handle)

+{

+	NvParameterized::ErrorType error;

+

+	const Definition* pd = handle.parameterDefinition();

+	switch( pd->type() )

+	{

+	case TYPE_STRUCT:

+		{

+			for(int32_t i = 0; i < pd->numChildren(); ++i)

+			{

+				handle.set(i);

+				initRandom(handle);

+				handle.popIndex();

+			}

+

+			break;

+		}

+

+	case TYPE_ARRAY:

+		{

+			if (!pd->arraySizeIsFixed())

+			{

+				error = handle.resizeArray(int32_t(10 * (double)rand() / RAND_MAX));

+				DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+			}

+

+			int32_t size;

+			error = handle.getArraySize(size);

+			PX_ASSERT(error == ERROR_NONE);

+

+			DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+

+			for(int32_t i = 0; i < size; ++i)

+			{

+				handle.set(i);

+				initRandom(handle);

+				handle.popIndex();

+			}

+

+			break;

+		}

+

+	case TYPE_REF:

+		{

+			if (!pd->numRefVariants())

+				break; // Can't do anything without refVariants-hint

+

+			PX_ASSERT(pd->numRefVariants() > 0);

+			uint32_t refIdx = RandomIdx(0U, pd->numRefVariants() - 1U);

+			const char* className = pd->refVariantVal(static_cast<int32_t>(refIdx));

+			if( mParameterizedTraits->doesFactoryExist(className) ) {

+				error = initParamRef(handle, className, true);

+				DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+

+				NvParameterized::Interface* obj = NULL;

+				error = handle.getParamRef(obj);

+				DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+			}

+

+			break;

+		}

+

+	case TYPE_BOOL:

+		error = handle.setParamBool( 0 == RandomU32() % 2 );

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+

+	case TYPE_STRING:

+		{

+			char s[10];

+			int32_t len = (int32_t)( (size_t)rand() % sizeof(s) );

+			for(int32_t i = 0; i < len; ++i)

+				s[i] = 'a' + rand() % ('z' - 'a');

+			s[len] = 0;

+

+			error = handle.setParamString(s);

+			DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+			break;

+		}

+

+	case TYPE_ENUM:

+		{

+			uint32_t enumIdx = RandomIdx(0U, static_cast<uint32_t>(pd->numEnumVals()-1));

+			error = handle.setParamEnum(pd->enumVal(static_cast<int32_t>(enumIdx)));

+			DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+			break;

+		}

+

+	case TYPE_I8:

+		error = handle.setParamI8((int8_t)(RandomU32() & 0xff));

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+

+	case TYPE_U8:

+		error = handle.setParamU8((uint8_t)(RandomU32() & 0xff));

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+

+	case TYPE_I16:

+		error = handle.setParamI16((int16_t)(RandomU32() & 0xffff));

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+

+	case TYPE_U16:

+		error = handle.setParamU16((uint16_t)(RandomU32() & 0xffff));

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+

+	case TYPE_I32:

+		error = handle.setParamI32((int32_t)RandomU32());

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+

+	case TYPE_U32:

+		error = handle.setParamU32((uint32_t)RandomU32());

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+

+	case TYPE_I64:

+		error = handle.setParamI64((int64_t)RandomU64());

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+

+	case TYPE_U64:

+		error = handle.setParamU64(RandomU64());

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+

+	case TYPE_F32:

+		error = handle.setParamF32(RandomF32());

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+

+	case TYPE_F64:

+		error = handle.setParamF64(RandomF64());

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+

+	case TYPE_VEC2:

+		error = handle.setParamVec2(RandomVec2());

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+

+	case TYPE_VEC3:

+		error = handle.setParamVec3(RandomVec3());

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+

+	case TYPE_VEC4:

+		error = handle.setParamVec4(RandomVec4());

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+

+	case TYPE_QUAT:

+		error = handle.setParamQuat(RandomQuat());

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+

+	case TYPE_MAT33:

+		error = handle.setParamMat33(physx::PxMat33(RandomVec3(), RandomVec3(), RandomVec3()));

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+

+	case TYPE_BOUNDS3:

+		error = handle.setParamBounds3(physx::PxBounds3(RandomVec3(), RandomVec3()));

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+

+	case TYPE_MAT44:

+		error = handle.setParamMat44(physx::PxMat44(RandomVec4(), RandomVec4(), RandomVec4(), RandomVec4()));

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+

+	case TYPE_MAT34:

+		{

+			float f[12] = { RandomF32(), RandomF32(), RandomF32(), RandomF32(), 

+							RandomF32(), RandomF32(), RandomF32(), RandomF32(), 

+							RandomF32(), RandomF32(), RandomF32(), RandomF32() };

+			error = handle.setParamMat34Legacy(f);

+			DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+			break;

+		}

+

+	case TYPE_POINTER:

+		// We can't init pointers :(

+		break;

+

+	case TYPE_TRANSFORM:

+	{

+		// PxTransform asserts if the quat isn't "sane"

+		physx::PxQuat q;

+		do { 

+			q = RandomQuat();

+		} while (!q.isSane());

+

+		error = handle.setParamTransform(physx::PxTransform(RandomVec3(),q));

+		DEBUG_ASSERT( NvParameterized::ERROR_NONE == error );

+		break;

+	}

+	NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS

+	default:

+		PX_ALWAYS_ASSERT();

+	}

+

+	PX_UNUSED(error); // Make compiler happy

+}

+

+void NvParameters::setClassName(const char *name) 

+{ 

+	if(mParameterizedTraits)

+	{

+		if( mClassName )

+		{

+			if( !strcmp( mClassName, name ) )

+				return;

+

+			if( mDoDeallocateClassName )

+				mParameterizedTraits->strfree( const_cast<char*>(mClassName) );

+		}

+

+		mClassName = mParameterizedTraits->strdup(name);

+	}

+	else

+	{

+		mClassName = name;

+	}

+

+	mDoDeallocateClassName = true;

+}

+

+void NvParameters::setName(const char *name) 

+{ 

+	if(mParameterizedTraits)

+	{

+		if( mName )

+		{

+			if( !strcmp( mName, name ) )

+				return;

+

+			if( mDoDeallocateName )

+				mParameterizedTraits->strfree( const_cast<char*>(mName) );

+		}

+

+		mName = mParameterizedTraits->strdup(name);

+	}

+	else

+	{

+		mName = name; 

+	}

+

+	mDoDeallocateName = true;

+}

+

+void NvParameters::setSerializationCallback(SerializationCallback *cb, void *userData)

+{

+	mSerializationCb = cb;

+	mCbUserData = userData;

+}

+

+ErrorType NvParameters::callPreSerializeCallback() const

+{

+	if(mSerializationCb)

+	{

+		mSerializationCb->preSerialize(mCbUserData);

+	}

+

+	Handle handle(*this);

+

+	NV_ERR_CHECK_RETURN( getParameterHandle("", handle) );

+

+	return callPreSerializeCallback(handle);

+}

+

+int32_t NvParameters::numParameters(void) 

+{

+    return(rootParameterDefinition()->numChildren());

+}

+

+const Definition *NvParameters::parameterDefinition(int32_t index) 

+{

+    return(rootParameterDefinition()->child(index));

+}

+

+const Definition *NvParameters::rootParameterDefinition(void)

+{

+    return(getParameterDefinitionTree());

+}

+

+const Definition *NvParameters::rootParameterDefinition(void) const

+{

+    return(getParameterDefinitionTree());

+}

+

+ErrorType NvParameters::getParameterHandle(const char *long_name, Handle &handle) const

+{

+	ErrorType result = ERROR_NONE;

+

+	PX_ASSERT( handle.getConstInterface() == this );

+	

+	if( rootParameterDefinition() == NULL )

+	{

+		handle.reset();

+		result = (ERROR_INVALID_CALL_ON_NAMED_REFERENCE);

+	}

+	else

+	{

+		result = handle.set(this,rootParameterDefinition(), long_name);

+	}

+

+	PX_ASSERT(result == ERROR_NONE);

+

+    return result;

+}

+

+ErrorType NvParameters::getParameterHandle(const char *long_name, Handle &handle)

+{

+	ErrorType result = ERROR_NONE;

+

+	PX_ASSERT( handle.getConstInterface() == this );

+

+	if( rootParameterDefinition() == NULL )

+	{

+		handle.reset();

+		result = (ERROR_INVALID_CALL_ON_NAMED_REFERENCE);

+	}

+	else

+	{

+		result = handle.set(this,rootParameterDefinition(), long_name);

+	}

+

+	PX_ASSERT(result == ERROR_NONE);

+

+	return result;

+}

+

+#ifndef NV_CHECKED

+#	define CHECK_HANDLE

+#	define CHECK_IS_SIMPLE_ARRAY(type_enum_name)

+#else

+#	define CHECK_HANDLE \

+		{ \

+	        ErrorType result = checkParameterHandle(handle); \

+			PX_ASSERT(result == ERROR_NONE); \

+		    if(result != ERROR_NONE) \

+			    return(result); \

+		}

+#	define CHECK_IS_SIMPLE_ARRAY(type_enum_name) \

+		{ \

+			PX_ASSERT(offset >= 0);\

+	        PX_ASSERT(n >= 0);\

+		    if(handle.parameterDefinition()->type() != TYPE_ARRAY) \

+			{\

+				PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_NOT_AN_ARRAY");\

+			    return(ERROR_NOT_AN_ARRAY); \

+			}\

+	        if(handle.parameterDefinition()->child(0)->type() != TYPE_##type_enum_name) \

+			{\

+  			    PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");\

+		        return(ERROR_CAST_FAILED); \

+			}\

+			int32_t arraySize; \

+	        ErrorType error; \

+		    if((error = getArraySize(handle, arraySize)) != ERROR_NONE) \

+			{\

+				PX_ASSERT(error == ERROR_NONE); \

+			    return(error); \

+			}\

+	        if( offset + n > arraySize) \

+			{\

+				PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_ARRAY_IS_TOO_SMALL");\

+				return(ERROR_ARRAY_IS_TOO_SMALL); \

+			}\

+		}

+#endif

+

+template <class Type > ErrorType rawGetParam(const Handle &handle,Type &val,const NvParameters *parent)

+{

+	size_t offset;

+	void *ptr=NULL;

+	parent->getVarPtr(handle, ptr, offset);

+	if ( ptr == NULL )

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_TYPE_NOT_SUPPORTED");

+		return ERROR_TYPE_NOT_SUPPORTED;

+	}

+	Type *var = (Type *)((char *)ptr);

+	val = *var;

+	return(ERROR_NONE);

+}

+

+template <class Type > ErrorType rawSetParam(const Handle &handle,const Type &val,NvParameters *parent)

+{

+	size_t offset;

+	void *ptr=NULL;

+	parent->getVarPtr(handle, ptr, offset);

+	if(ptr == NULL)

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");

+		return(ERROR_INDEX_OUT_OF_RANGE);

+	}

+	Type *Var = (Type *)((char *)ptr);

+	*Var = val;

+	return(ERROR_NONE);

+}

+

+template <class Type >ErrorType rawGetParamArray(const Handle &handle,Type *array, int32_t n, int32_t offset,const NvParameters *parent) 

+{

+	int32_t size;

+	NV_ERR_CHECK_RETURN(handle.getArraySize(size));

+	if( size < offset + n )

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");

+		return(ERROR_INDEX_OUT_OF_RANGE);

+	}

+

+	if( n )

+	{

+		Handle memberHandle(handle);

+		NV_ERR_CHECK_RETURN(memberHandle.set(offset));

+

+		size_t tmp;

+		void *ptr=NULL;

+		parent->getVarPtr(memberHandle, ptr, tmp);

+		if(ptr == NULL)

+		{

+			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");

+			return(ERROR_INDEX_OUT_OF_RANGE);

+		}

+

+		physx::intrinsics::memCopy(array, ptr, n * sizeof(Type));

+	}

+

+	return(ERROR_NONE);

+}

+

+template <class Type> ErrorType rawSetParamArray(const Handle &handle, const Type *array, int32_t n, int32_t offset,NvParameters *parent)

+{

+	int32_t size;

+	NV_ERR_CHECK_RETURN(handle.getArraySize(size));

+	if( size < offset + n )

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");

+		return(ERROR_INDEX_OUT_OF_RANGE);

+	}

+

+	if( n )

+	{

+		Handle memberHandle(handle);

+		NV_ERR_CHECK_RETURN(memberHandle.set(offset));

+

+		size_t tmp;

+		void *ptr=NULL;

+		parent->getVarPtr(memberHandle, ptr, tmp);

+		if(ptr == NULL)

+		{

+			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");

+			return(ERROR_INDEX_OUT_OF_RANGE);

+		}

+

+		physx::intrinsics::memCopy(ptr, array, n * sizeof(Type));

+	}

+

+	return(ERROR_NONE);

+}

+

+//******************************************************************************

+//*** Bool

+//******************************************************************************

+

+ErrorType NvParameters::getParamBool(const Handle &handle, bool &val) const

+{

+    CHECK_HANDLE

+

+    if(handle.parameterDefinition()->type() == TYPE_BOOL)

+    {

+		return rawGetParamBool(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::setParamBool(const Handle &handle, bool val)

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_BOOL)

+    {

+        return rawSetParamBool(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamBoolArray(const Handle &handle, bool *array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(BOOL)

+    return(rawGetParamBoolArray(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamBoolArray(const Handle &handle, const bool *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(BOOL)

+    return(rawSetParamBoolArray(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** String

+//******************************************************************************

+

+ErrorType NvParameters::getParamString(const Handle &handle, const char *&val) const

+{

+    CHECK_HANDLE

+

+    if(handle.parameterDefinition()->type() == TYPE_ENUM)

+    {

+        return rawGetParamEnum(handle, val);

+    }

+    

+	if(handle.parameterDefinition()->type() == TYPE_STRING)

+    {

+        return rawGetParamString(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::setParamString(const Handle &handle, const char *val)

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_STRING)

+    {

+        return rawSetParamString(handle, val);

+    }

+

+	if(handle.parameterDefinition()->type() == TYPE_ENUM)

+    {

+        return rawSetParamEnum(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::rawGetParamStringArray(const Handle &handle, char **array, int32_t n, int32_t offset) const

+{

+	Handle memberHandle(handle);

+	for(int32_t i=0; i < n; ++i)

+	{

+		ErrorType error;

+		if((error = memberHandle.set(i + offset)) != ERROR_NONE)

+		{

+			PX_ASSERT(error == ERROR_NONE);

+			return(error);

+		}

+

+		const char * tmp;

+		if((error = rawGetParamString(memberHandle, tmp)) != ERROR_NONE)

+		{

+			PX_ASSERT(error == ERROR_NONE);

+			return(error);

+		}

+

+		array[i] = const_cast<char*>(tmp);

+		memberHandle.popIndex();

+	}

+	return(ERROR_NONE);

+}

+

+

+ErrorType NvParameters::getParamStringArray(const Handle &handle, char **array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(STRING)

+    return(rawGetParamStringArray(handle, array, n, offset));

+}

+

+ErrorType NvParameters::rawSetParamStringArray(const Handle &handle, const char **array, int32_t n, int32_t offset)

+{

+	Handle memberHandle(handle);

+	for(int32_t i=0; i < n; ++i)

+	{

+		ErrorType error;

+		if((error = memberHandle.set(i + offset)) != ERROR_NONE)

+		{

+			PX_ASSERT(error == ERROR_NONE);

+			return(error);

+		}

+

+		if((error = rawSetParamString(memberHandle, array[i] )) != ERROR_NONE)

+		{

+			PX_ASSERT(error == ERROR_NONE);

+			return(error);

+		}

+

+		memberHandle.popIndex();

+	}

+	return(ERROR_NONE);

+}

+

+ErrorType NvParameters::setParamStringArray(const Handle &handle, const char **array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(STRING)

+    return(rawSetParamStringArray(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** Enum

+//******************************************************************************

+

+ErrorType NvParameters::getParamEnum(const Handle &handle, const char *&val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_STRING)

+    {

+        return rawGetParamString(handle, val);

+    }

+

+	if(handle.parameterDefinition()->type() == TYPE_ENUM)

+    {

+        return rawGetParamEnum(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");    

+    return(ERROR_CAST_FAILED);

+}

+

+// returns the actual enum string from the ParameterDefintion object, which should be good for the liftetime

+// of the DefinitionImpl object.  Returns NULL if no such enum exists.

+static const char* getEnumString(const Handle &handle, const char* str)

+{

+    PX_ASSERT(str != NULL);

+

+    const Definition* paramDef = handle.parameterDefinition();

+    PX_ASSERT(paramDef != NULL);

+    PX_ASSERT(paramDef->type() == TYPE_ENUM);

+

+    for (int32_t i = 0; i < paramDef->numEnumVals(); ++i)

+        if(!strcmp(paramDef->enumVal(i), str))

+            return(paramDef->enumVal(i));

+

+    return(NULL);    

+}

+

+ErrorType NvParameters::setParamEnum(const Handle &handle, const char *val)

+{

+    CHECK_HANDLE

+

+    val = getEnumString(handle, val);

+    if(val == NULL)

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_ENUM_VAL");

+        return(ERROR_INVALID_ENUM_VAL);

+	}

+

+	if(handle.parameterDefinition()->type() == TYPE_ENUM)

+    {

+        return rawSetParamEnum(handle, val);

+    }

+

+	if(handle.parameterDefinition()->type() == TYPE_STRING)

+    {

+        return rawSetParamString(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+	return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::rawGetParamEnumArray(const Handle &handle, char **array, int32_t n, int32_t offset) const

+{

+	Handle memberHandle(handle);

+	for(int32_t i=0; i < n; ++i)

+	{

+		ErrorType error; 

+		if((error = memberHandle.set(i + offset)) != ERROR_NONE)

+			return(error);

+		const char * tmp;

+		if((error = rawGetParamEnum(memberHandle, tmp)) != ERROR_NONE)

+			return(error);

+		array[i] = const_cast<char*>(tmp);

+		memberHandle.popIndex();

+	}

+	return(ERROR_NONE);

+}

+

+ErrorType NvParameters::rawSetParamEnumArray(const Handle &handle, const char **array, int32_t n, int32_t offset)

+{

+	Handle memberHandle(handle);

+	for(int32_t i=0; i < n; ++i)

+	{

+		ErrorType error;

+		if((error = memberHandle.set(i + offset)) != ERROR_NONE)

+			return(error);

+		if((error = rawSetParamEnum(memberHandle, array[i])) != ERROR_NONE)

+			return(error);

+		memberHandle.popIndex();

+	}

+	return(ERROR_NONE);

+}

+

+ErrorType NvParameters::getParamEnumArray(const Handle &handle, char **array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(ENUM)

+    return(rawGetParamEnumArray(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamEnumArray(const Handle &handle, const char **array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(ENUM)

+    return(rawSetParamEnumArray(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** Ref

+//******************************************************************************

+

+ErrorType NvParameters::initParamRef(const Handle &handle, const char *inChosenRefStr, bool doDestroyOld)

+{

+	CHECK_HANDLE

+

+	NvParameterized::Interface *param = NULL;

+	const char *chosenRefStr = inChosenRefStr;

+

+	// create NvParam object (depends on if it's included or not)

+	const Hint *hint = handle.parameterDefinition()->hint("INCLUDED");

+	if (hint && hint->type() != TYPE_U64)

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_REFERENCE_INCLUDE_HINT");

+		return(ERROR_INVALID_REFERENCE_INCLUDE_HINT);

+	}

+

+	if (hint != NULL && hint->asUInt() == 1)

+	{

+		// included

+

+		if (chosenRefStr == 0 && handle.parameterDefinition()->numRefVariants() > 1)

+		{

+			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_REFERENCE_VALUE");

+			return(ERROR_INVALID_REFERENCE_VALUE);

+		}

+

+		for (int32_t i = 0; i < handle.parameterDefinition()->numRefVariants(); i++)

+		{

+			if (!strcmp(handle.parameterDefinition()->refVariantVal(i), chosenRefStr))

+			{

+				// create an object of type chosenRefStr, somehow

+				param = mParameterizedTraits->createNvParameterized(chosenRefStr);

+				if (!param)

+				{

+					PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_OBJECT_CONSTRUCTION_FAILED");

+					return ERROR_OBJECT_CONSTRUCTION_FAILED;

+				}

+

+				return setParamRef(handle, param, doDestroyOld);

+			}

+		}

+		// PH: debug hint

+		// If you land here, you should compare chosenRefStr and handle.mParameterDefinition.mRefVariantVals

+		// to see why it couldn't find anything, and then fix the .pl

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_REFERENCE_VALUE");

+		return(ERROR_INVALID_REFERENCE_VALUE);

+	}

+	else

+	{

+		// not included, just create generic NvParameterized

+		param = NV_PARAM_PLACEMENT_NEW(mParameterizedTraits->alloc(sizeof(NvParameters)), NvParameters)(mParameterizedTraits);

+		if (!param)

+		{

+			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_OBJECT_CONSTRUCTION_FAILED");

+			return ERROR_OBJECT_CONSTRUCTION_FAILED;

+		}

+

+		if (chosenRefStr == 0)

+		{

+			param->setClassName(handle.parameterDefinition()->refVariantVal(0));

+		}

+		else

+		{

+			bool found = false;

+			for (int32_t i = 0; i < handle.parameterDefinition()->numRefVariants(); i++)

+			{

+				if (!strcmp(handle.parameterDefinition()->refVariantVal(i), chosenRefStr))

+				{

+					param->setClassName(handle.parameterDefinition()->refVariantVal(i));

+					found = true;

+					break;

+				}

+			}

+			if ( !found )

+			{

+				// ensure that we free this memory that we've allocated

+				mParameterizedTraits->free(param);

+				PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_REFERENCE_VALUE");

+				return(ERROR_INVALID_REFERENCE_VALUE);

+			}

+		}

+		return setParamRef(handle, param, doDestroyOld);

+	}

+}

+

+ErrorType NvParameters::getParamRef(const Handle &handle, NvParameterized::Interface *&val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_REF)

+    {

+        return rawGetParamRef(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::setParamRef(const Handle &handle, NvParameterized::Interface *val, bool doDestroyOld)

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_REF)

+    {

+		if (doDestroyOld)

+		{

+			NvParameterized::Interface *param = NULL;

+

+			getParamRef(handle, param);

+			if(param)

+			{

+				param->destroy();

+				param = NULL;

+			}

+		}

+        return rawSetParamRef(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::rawGetParamRefArray(const Handle &handle, NvParameterized::Interface **array, int32_t n, int32_t offset) const

+{

+	Handle memberHandle(handle);

+	for(int32_t i=0; i < n; ++i)

+	{

+		ErrorType error; 

+		if((error = memberHandle.set(i + offset)) != ERROR_NONE)

+			return(error);

+		NvParameterized::Interface * tmp;

+		if((error = rawGetParamRef(memberHandle, tmp)) != ERROR_NONE)

+			return(error);

+		array[i] = tmp;

+		memberHandle.popIndex();

+	}

+	return(ERROR_NONE);

+}

+

+ErrorType NvParameters::rawSetParamRefArray(const Handle &handle,NvParameterized::Interface **array, int32_t n, int32_t offset)

+{

+	Handle memberHandle(handle);

+	for(int32_t i=0; i < n; ++i) 

+	{ 

+		ErrorType error;

+		if((error = memberHandle.set(i + offset)) != ERROR_NONE) 

+			return(error); 

+		if((error = rawSetParamRef(memberHandle, array[i])) != ERROR_NONE)

+			return(error); 

+		memberHandle.popIndex(); 

+	} 

+

+	return(ERROR_NONE);

+}

+

+ErrorType NvParameters::getParamRefArray(const Handle &handle, NvParameterized::Interface * *array, int32_t n, int32_t offset) const

+{ 

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(REF)

+    return(rawGetParamRefArray(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamRefArray(const Handle &handle, /*const*/ NvParameterized::Interface **array, int32_t n, int32_t offset, bool doDestroyOld)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(REF)

+

+	Handle memberHandle(handle);

+	for(int32_t i = 0; i < n; ++i) 

+	{ 

+		ErrorType error;

+		if((error = memberHandle.set(i + offset)) != ERROR_NONE)

+		{

+			return(error); 

+		}

+

+		if((error = setParamRef(memberHandle, array[i]), doDestroyOld) != ERROR_NONE)

+		{

+			return(error); 

+		}

+		memberHandle.popIndex(); 

+	}

+	return(ERROR_NONE);

+}

+

+//******************************************************************************

+//*** I8

+//******************************************************************************

+

+ErrorType NvParameters::getParamI8(const Handle &handle, int8_t &val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_I8)

+    {

+        return rawGetParamI8(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::setParamI8(const Handle &handle, int8_t val)

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_I8)

+    {

+        return rawSetParamI8(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamI8Array(const Handle &handle, int8_t *array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(I8)

+    return(rawGetParamI8Array(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamI8Array(const Handle &handle, const int8_t *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(I8)

+    return(rawSetParamI8Array(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** I16

+//******************************************************************************

+

+ErrorType NvParameters::getParamI16(const Handle &handle, int16_t &val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_I8)

+    {

+        int8_t tmp;

+        ErrorType result = rawGetParamI8(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (int16_t)tmp;

+        return(ERROR_NONE);

+    }

+

+	if(handle.parameterDefinition()->type() == TYPE_I16)

+    {

+        return rawGetParamI16(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::setParamI16(const Handle &handle, int16_t val)

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_I16)

+    {

+        return rawSetParamI16(handle, val);

+    }

+	if(handle.parameterDefinition()->type() == TYPE_I8)

+    {

+        return rawSetParamI8(handle, (int8_t)val);

+    }

+	if(handle.parameterDefinition()->type() == TYPE_U8)

+    {

+        return rawSetParamU8(handle, (uint8_t)val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamI16Array(const Handle &handle, int16_t *array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(I16)

+    return(rawGetParamI16Array(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamI16Array(const Handle &handle, const int16_t *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(I16)

+    return(rawSetParamI16Array(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** I32

+//******************************************************************************

+

+ErrorType NvParameters::getParamI32(const Handle &handle, int32_t &val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_I8)

+    {

+        int8_t tmp;

+        ErrorType result = rawGetParamI8(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (int32_t)tmp;

+        return(ERROR_NONE);

+    }

+	

+	if(handle.parameterDefinition()->type() == TYPE_I16)

+    {

+        int16_t tmp;

+        ErrorType result = rawGetParamI16(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (int32_t)tmp;

+        return(ERROR_NONE);

+    }

+

+	if(handle.parameterDefinition()->type() == TYPE_I32)

+    {

+        int32_t tmp;

+        ErrorType result = rawGetParamI32(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (int32_t)tmp;

+        return(ERROR_NONE);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::setParamI32(const Handle &handle, int32_t val)

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_I32)

+    {

+        return rawSetParamI32(handle, val);

+    }

+	if(handle.parameterDefinition()->type() == TYPE_I16)

+    {

+        return rawSetParamI16(handle, (int16_t)val);

+    }

+	if(handle.parameterDefinition()->type() == TYPE_U16)

+    {

+        return rawSetParamU16(handle, (uint16_t)val);

+    }

+	if(handle.parameterDefinition()->type() == TYPE_I8)

+    {

+        return rawSetParamI8(handle, (int8_t) val);

+    }

+	if(handle.parameterDefinition()->type() == TYPE_U8)

+    {

+        return rawSetParamU8(handle, (uint8_t) val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamI32Array(const Handle &handle, int32_t *array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(I32)

+    return(rawGetParamI32Array(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamI32Array(const Handle &handle, const int32_t *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(I32)

+    return(rawSetParamI32Array(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** I64

+//******************************************************************************

+

+ErrorType NvParameters::getParamI64(const Handle &handle, int64_t &val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_I8)

+    {

+        int8_t tmp;

+        ErrorType result = rawGetParamI8(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (int64_t)tmp;

+        return(ERROR_NONE);

+    }

+	

+	if(handle.parameterDefinition()->type() == TYPE_I16)

+    {

+        int16_t tmp;

+        ErrorType result = rawGetParamI16(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (int64_t)tmp;

+        return(ERROR_NONE);

+    }

+

+	if(handle.parameterDefinition()->type() == TYPE_I32)

+    {

+        int32_t tmp;

+        ErrorType result = rawGetParamI32(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (int64_t)tmp;

+        return(ERROR_NONE);

+    }

+

+	if(handle.parameterDefinition()->type() == TYPE_I64)

+    {

+        int64_t tmp;

+        ErrorType result = rawGetParamI64(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (int64_t)tmp;

+        return(ERROR_NONE);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::setParamI64(const Handle &handle, int64_t val)

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_I64)

+    {

+        return rawSetParamI64(handle, val);

+    }

+	if(handle.parameterDefinition()->type() == TYPE_U32)

+    {

+        return rawSetParamU32(handle, (uint32_t)val);

+    }

+	if(handle.parameterDefinition()->type() == TYPE_I32)

+    {

+        return rawSetParamI32(handle, (int32_t)val);

+    }

+	if(handle.parameterDefinition()->type() == TYPE_I16)

+    {

+        return rawSetParamI16(handle, (int16_t)val);

+    }

+	if(handle.parameterDefinition()->type() == TYPE_U16)

+    {

+        return rawSetParamU16(handle, (uint16_t) val);

+    }

+	if(handle.parameterDefinition()->type() == TYPE_I8)

+    {

+        return rawSetParamI8(handle, (int8_t)val);

+    }

+	if(handle.parameterDefinition()->type() == TYPE_U8)

+    {

+        return rawSetParamU8(handle, (uint8_t)val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamI64Array(const Handle &handle, int64_t *array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(I64)

+    return(rawGetParamI64Array(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamI64Array(const Handle &handle, const int64_t *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(I64)

+    return(rawSetParamI64Array(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** U8

+//******************************************************************************

+

+ErrorType NvParameters::getParamU8(const Handle &handle, uint8_t &val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_U8)

+    {

+        return rawGetParamU8(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::setParamU8(const Handle &handle, uint8_t val)

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_U8)

+    {

+        return rawSetParamU8(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::setParamU8Array(const Handle &handle, const uint8_t *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(U8)

+    return(rawSetParamU8Array(handle, array, n, offset));

+}

+

+

+//******************************************************************************

+//*** U16

+//******************************************************************************

+

+ErrorType NvParameters::getParamU16(const Handle &handle, uint16_t &val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_U8)

+    {

+        uint8_t tmp;

+        ErrorType result = rawGetParamU8(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (uint16_t)tmp;

+        return(ERROR_NONE);

+    }

+

+	if(handle.parameterDefinition()->type() == TYPE_U16)

+    {

+        uint16_t tmp;

+        ErrorType result = rawGetParamU16(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (uint16_t)tmp;

+        return(ERROR_NONE);

+    }

+	

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+	return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::setParamU16(const Handle &handle, uint16_t val)

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_U16)

+    {

+        return rawSetParamU16(handle, val);

+    }

+	if(handle.parameterDefinition()->type() == TYPE_U8)

+    {

+        return rawSetParamU8(handle, (uint8_t)val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamU16Array(const Handle &handle, uint16_t *array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(U16)

+    return(rawGetParamU16Array(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamU16Array(const Handle &handle, const uint16_t *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(U16)

+    return(rawSetParamU16Array(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** U32

+//******************************************************************************

+

+ErrorType NvParameters::getParamU32(const Handle &handle, uint32_t &val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_U8)

+    {

+        uint8_t tmp;

+        ErrorType result = rawGetParamU8(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (uint32_t)tmp;

+        return(ERROR_NONE);

+    }

+

+	if(handle.parameterDefinition()->type() == TYPE_U16)

+    {

+        uint16_t tmp;

+        ErrorType result = rawGetParamU16(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (uint32_t)tmp;

+        return(ERROR_NONE);

+    }

+

+	if(handle.parameterDefinition()->type() == TYPE_U32)

+    {

+        uint32_t tmp;

+        ErrorType result = rawGetParamU32(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (uint32_t)tmp;

+        return(ERROR_NONE);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::setParamU32(const Handle &handle, uint32_t val)

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_U32)

+    {

+        return rawSetParamU32(handle, val);

+    }

+	if(handle.parameterDefinition()->type() == TYPE_U16)

+    {

+        return rawSetParamU16(handle, (uint16_t)val);

+    }

+	if(handle.parameterDefinition()->type() == TYPE_U8)

+    {

+        return rawSetParamU8(handle, (uint8_t)val);

+    }

+	

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamU32Array(const Handle &handle, uint32_t *array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(U32)

+    return(rawGetParamU32Array(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamU32Array(const Handle &handle, const uint32_t *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(U32)

+    return(rawSetParamU32Array(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** U64

+//******************************************************************************

+

+ErrorType NvParameters::getParamU64(const Handle &handle, uint64_t &val) const

+{

+    CHECK_HANDLE

+

+	if (handle.parameterDefinition()->type() == TYPE_BOOL)

+	{

+		bool tmp;

+		ErrorType result = rawGetParamBool(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+		if (result != ERROR_NONE)

+			return(result);

+		val = (uint64_t)tmp;

+		return(ERROR_NONE);

+	}

+

+	if (handle.parameterDefinition()->type() == TYPE_U8)

+    {

+        uint8_t tmp;

+        ErrorType result = rawGetParamU8(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (uint64_t)tmp;

+        return(ERROR_NONE);

+    }

+

+	if(handle.parameterDefinition()->type() == TYPE_U16)

+    {

+        uint16_t tmp;

+        ErrorType result = rawGetParamU16(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (uint64_t)tmp;

+        return(ERROR_NONE);

+    }

+

+	if(handle.parameterDefinition()->type() == TYPE_U32)

+    {

+        uint32_t tmp;

+        ErrorType result = rawGetParamU32(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (uint64_t)tmp;

+        return(ERROR_NONE);

+    }

+

+	if(handle.parameterDefinition()->type() == TYPE_U64)

+    {

+        uint64_t tmp;

+        ErrorType result = rawGetParamU64(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (uint64_t)tmp;

+        return(ERROR_NONE);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::setParamU64(const Handle &handle, uint64_t val)

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_U64)

+    {

+        return rawSetParamU64(handle, val);

+    }

+

+	if(handle.parameterDefinition()->type() == TYPE_U32)

+    {

+        return rawSetParamU32(handle, (uint32_t)val);

+    }

+

+	if(handle.parameterDefinition()->type() == TYPE_U16)

+    {

+        return rawSetParamU16(handle, (uint16_t)val);

+    }

+

+	if(handle.parameterDefinition()->type() == TYPE_U8)

+    {

+        return rawSetParamU8(handle, (uint8_t)val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamU64Array(const Handle &handle, uint64_t *array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(U64)

+    return(rawGetParamU64Array(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamU64Array(const Handle &handle, const uint64_t *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(U64)

+    return(rawSetParamU64Array(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** F32

+//******************************************************************************

+

+ErrorType NvParameters::getParamF32(const Handle &handle, float &val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_F32)

+    {

+        return rawGetParamF32(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::setParamF32(const Handle &handle, float val)

+{

+    CHECK_HANDLE

+    CHECK_F32_FINITE

+

+	if(handle.parameterDefinition()->type() == TYPE_F32)

+    {

+        return rawSetParamF32(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamF32Array(const Handle &handle, float *array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(F32)

+    return(rawGetParamF32Array(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamF32Array(const Handle &handle, const float *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(F32)

+    CHECK_F32_FINITE_ARRAY

+    return(rawSetParamF32Array(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** F64

+//******************************************************************************

+

+ErrorType NvParameters::getParamF64(const Handle &handle, double &val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_F32)

+    {

+        float tmp;

+        ErrorType result = rawGetParamF32(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (double)tmp;

+        return(ERROR_NONE);

+    }

+	

+	if(handle.parameterDefinition()->type() == TYPE_F64)

+    {

+        double tmp;

+        ErrorType result = rawGetParamF64(handle, tmp);

+		PX_ASSERT(result == ERROR_NONE);

+

+        if(result != ERROR_NONE)

+            return(result);

+        val = (double)tmp;

+        return(ERROR_NONE);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::setParamF64(const Handle &handle, double val)

+{

+    CHECK_HANDLE

+    CHECK_F64_FINITE

+

+	if(handle.parameterDefinition()->type() == TYPE_F64)

+    {

+        return rawSetParamF64(handle, val);

+    }

+	else if(handle.parameterDefinition()->type() == TYPE_F32)

+    {

+		return rawSetParamF32(handle, (float)val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::setParamF64Array(const Handle &handle, const double *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(F64)

+    CHECK_F64_FINITE_ARRAY

+    return(rawSetParamF64Array(handle, array, n, offset));

+}

+

+/**

+# When shrinking a dynamic array, the array may contain dynamically allocated Refs or Strings.

+# It may also contain Structs that contain these items, we'll call them all "dynamic parameters".

+#

+# To handle this, we generate, for every dynamic array with dynamic parameters, handle indices in 

+# the Parameter Definition that help the NvParameters::rawResizeArray() method find these parameters

+# and destroy them quickly (without having to recursively traverse the parameters).

+#

+# The handle indices are layed out like this for the following struct:

+# [ handleDepth0, 3, handleDepth1, 5 ] - handleDepth0 = handleDepth1 = 1 

+# struct myStruct {

+#   float a;

+#   float b;

+#   float c;

+#   string myString;

+#   float a;

+#   ref myRef;

+# }

+#

+# You can see that myString and myRef are the only two dynamically allocated members that need

+# to be destroyed, so only their indices appear in the list.

+# 

+# Note: Currently, we only support 1D arrays with dynamic parameters in the top most struct.  

+# array[i].myString is supported

+# array[i].structa.myString is supported

+# array[i].structa.structb.myString is NOT supported

+*/

+ErrorType NvParameters::releaseDownsizedParameters(const Handle &handle, int newSize, int oldSize)

+{

+	// if downsizing array, release dynamic parameters

+	// for now, just do 1D arrays

+	if( newSize >= oldSize )

+	{

+		return ERROR_NONE;

+	}

+

+	uint32_t numIndices=0;

+	Handle tmpHandle(handle);

+

+	const uint8_t *hIndices = tmpHandle.parameterDefinition()->getDynamicHandleIndicesMap(numIndices);

+

+	if( numIndices )

+	{

+		// from array[new_size] to array[old_size]

+		for( int i=newSize; i<oldSize; i++ )

+		{

+			tmpHandle.set( i );

+

+			for( uint32_t j=0; j<numIndices; )

+			{

+				// set the handle up to point to the right dynamic parameter

+				uint8_t indexDepth = hIndices[j];

+				int k=0;

+				for( ; k<indexDepth; k++ )

+				{

+					tmpHandle.set( hIndices[j+k+1] );

+				}

+				j += k + 1;

+				

+				// now we have a handle that's pointing to the dynamic parameter, release it

+				DataType type = tmpHandle.parameterDefinition()->type();

+				if( type == TYPE_STRING )

+				{

+					tmpHandle.setParamString( NULL );

+				}

+				else if( type == TYPE_REF )

+				{

+					NvParameterized::Interface * paramPtr = 0;

+					tmpHandle.getParamRef( paramPtr );

+					if( paramPtr )

+					{

+						paramPtr->destroy();

+						tmpHandle.setParamRef( NULL );

+					}

+				}

+				else if( type == TYPE_ENUM )

+				{

+					// nothing to do on a downsize

+				}

+				else

+				{

+					PX_ASSERT( 0 && "Invalid dynamically allocated type defined in Definition handle list" );

+				}

+				

+				// reset the handle

+				if( indexDepth > 0 )

+				{

+					tmpHandle.popIndex( indexDepth );

+				}

+			}

+

+			tmpHandle.popIndex();

+		}

+	}

+

+	return ERROR_NONE;

+}

+

+

+

+/**

+# When growing a dynamic array, the array may contain Enums or Structs that contain enums.

+#

+# To handle this, we generate, for every dynamic array with enums, handle indices in 

+# the Parameter Definition that help the NvParameters::rawResizeArray() method find these parameters

+# and initialized them quickly (without having to recursively traverse the parameters).

+#

+# Note: Currently, we only support 1D arrays with enums in the top most struct.  

+# array[i].enumA is supported

+# array[i].structa.enumA is supported

+# array[i].structa.structb.enumA is NOT supported

+*/

+ErrorType NvParameters::initNewResizedParameters(const Handle &handle, int newSize, int oldSize)

+{

+	// if downsizing array, release dynamic parameters

+	// for now, just do 1D arrays

+	if( newSize <= oldSize )

+	{

+		return ERROR_NONE;

+	}

+

+	uint32_t numIndices=0;

+	Handle tmpHandle(handle);

+

+	const uint8_t *hIndices = tmpHandle.parameterDefinition()->getDynamicHandleIndicesMap(numIndices);

+

+	if( numIndices )

+	{

+		// from array[new_size] to array[old_size]

+		for( int i=oldSize; i<newSize; i++ )

+		{

+			tmpHandle.set( i );

+

+			for( uint32_t j=0; j<numIndices; )

+			{

+				// set the handle up to point to the right dynamic parameter

+				uint8_t indexDepth = hIndices[j];

+				int k=0;

+				for( ; k<indexDepth; k++ )

+				{

+					tmpHandle.set( hIndices[j+k+1] );

+				}

+				j += k + 1;

+				

+				// now we have a handle that's pointing to the dynamic parameter, release it

+				DataType type = tmpHandle.parameterDefinition()->type();

+				if( type == TYPE_STRING || type == TYPE_REF )

+				{

+					// nothing to do on an array growth

+				}

+				else if( type == TYPE_ENUM )

+				{

+					// this is not the default value, but that's not available from here

+					// we could possibly store the enum default values, or just always make them first

+					tmpHandle.setParamEnum( tmpHandle.parameterDefinition()->enumVal(0) );

+				}

+				else if( type == TYPE_ARRAY )

+				{

+					// FIXME: we do not fully support arrays here, this is just a brain-dead stub

+

+					const Definition *pd = 0;

+					for(pd = tmpHandle.parameterDefinition(); pd->type() == TYPE_ARRAY; pd = pd->child(0))

+					{

+						PX_ASSERT( pd->numChildren() == 1 );

+					}

+

+					if( pd->type() != TYPE_STRING && pd->type() != TYPE_REF )

+						PX_ASSERT( 0 && "Invalid dynamically allocated type defined in Definition handle list" );

+				}

+				else

+				{

+					PX_ASSERT( 0 && "Invalid dynamically allocated type defined in Definition handle list" );

+				}

+				

+				// reset the handle

+				if( indexDepth > 0 )

+				{

+					tmpHandle.popIndex( indexDepth );

+				}

+			}

+

+			tmpHandle.popIndex();

+		}

+	}

+

+	return ERROR_NONE;

+}

+

+ErrorType NvParameters::rawResizeArray(const Handle &handle, int new_size)

+{

+	size_t offset;

+	ErrorType ret;

+	void *ptr=NULL;

+

+	Handle arrayRootHandle(handle);

+

+	// We should consider storing alignment in dynamic array struct at some point

+	uint32_t align = arrayRootHandle.parameterDefinition()->alignment();

+	if( 0 == align )

+		align = 8; // Default alignment

+

+	int dimension = 0;

+

+	while(arrayRootHandle.parameterDefinition()->parent() &&

+		arrayRootHandle.parameterDefinition()->parent()->type() == TYPE_ARRAY)

+	{

+		arrayRootHandle.popIndex();

+		dimension++;

+	}

+

+	getVarPtr(arrayRootHandle, ptr, offset);

+	if ( ptr == NULL )

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_TYPE_NOT_SUPPORTED");

+		return ERROR_TYPE_NOT_SUPPORTED;

+	}

+

+	DummyDynamicArrayStruct *dynArray = (DummyDynamicArrayStruct *)ptr;

+	int old_size = dynArray->arraySizes[0];

+

+	releaseDownsizedParameters(handle, new_size, old_size);

+

+	ret = resizeArray(mParameterizedTraits,

+					  dynArray->buf, 

+					  dynArray->arraySizes, 

+					  arrayRootHandle.parameterDefinition()->arrayDimension(), 

+					  dimension, 

+					  new_size,

+					  dynArray->isAllocated,

+					  dynArray->elementSize,

+					  align,

+					  dynArray->isAllocated); 

+

+	initNewResizedParameters(handle, new_size, old_size);

+

+	return ret;

+}

+

+ErrorType NvParameters::rawGetArraySize(const Handle &array_handle, int &size, int dimension) const

+{

+	size_t offset;

+	void *ptr=NULL;

+	getVarPtr(array_handle, ptr, offset);

+	if ( ptr == NULL )

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_TYPE_NOT_SUPPORTED");

+		return ERROR_TYPE_NOT_SUPPORTED;

+	}

+

+	DummyDynamicArrayStruct *dynArray = (DummyDynamicArrayStruct *)ptr;

+	size = dynArray->arraySizes[dimension];

+	return(ERROR_NONE);

+}

+

+ErrorType NvParameters::rawSwapArrayElements(const Handle &array_handle, unsigned int firstElement, unsigned int secondElement)

+{

+	size_t offset = 0;

+	void* ptr = NULL;

+	Handle arrayRootHandle(array_handle);

+

+	getVarPtr(arrayRootHandle, ptr, offset);

+	if ( ptr == NULL )

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_TYPE_NOT_SUPPORTED");

+		return ERROR_TYPE_NOT_SUPPORTED;

+	}

+

+	DummyDynamicArrayStruct* dynArray = reinterpret_cast<DummyDynamicArrayStruct*>(ptr);

+

+	const int elementSize = dynArray->elementSize;

+

+	char tempDataStack[64];

+	void* tempData = tempDataStack;

+

+	void* tempDataHeap = NULL;

+	PX_ASSERT(elementSize > 0);

+	PX_ASSERT(sizeof(elementSize) <= sizeof(uint32_t));

+	if (elementSize > 64)

+	{

+		tempDataHeap = mParameterizedTraits->alloc(static_cast<uint32_t>(elementSize));

+		tempData = tempDataHeap;

+	}

+

+	char* firstPtr = (char*)dynArray->buf + elementSize * firstElement;

+	char* secondPtr = (char*)dynArray->buf + elementSize * secondElement;

+

+	physx::intrinsics::memCopy(tempData, firstPtr, static_cast<uint32_t>(elementSize));

+	physx::intrinsics::memCopy(firstPtr, secondPtr, static_cast<uint32_t>(elementSize));

+	physx::intrinsics::memCopy(secondPtr, tempData, static_cast<uint32_t>(elementSize));

+

+	if (tempDataHeap != NULL)

+	{

+		mParameterizedTraits->free(tempDataHeap);

+	}

+

+	return(ERROR_NONE);

+}

+

+#define ARRAY_HANDLE_CHECKS \

+    if(!array_handle.isValid()) \

+	{ \

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_PARAMETER_HANDLE");\

+        return(ERROR_INVALID_PARAMETER_HANDLE); \

+	}\

+    if(array_handle.parameterDefinition()->type() != TYPE_ARRAY) \

+	{\

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_NOT_AN_ARRAY"); \

+        return(ERROR_NOT_AN_ARRAY); \

+	}

+

+

+ErrorType NvParameters::resizeArray(const Handle &array_handle, int32_t new_size)

+{

+    ARRAY_HANDLE_CHECKS

+

+    if(new_size < 0)

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_ARRAY_SIZE");

+        return(ERROR_INVALID_ARRAY_SIZE);

+	}

+

+    if(array_handle.parameterDefinition()->arraySizeIsFixed())

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_ARRAY_SIZE_IS_FIXED");

+        return(ERROR_ARRAY_SIZE_IS_FIXED);

+	}

+

+    return(rawResizeArray(array_handle, new_size));

+}

+

+ErrorType NvParameters::swapArrayElements(const Handle &array_handle, uint32_t firstElement, uint32_t secondElement)

+{

+	ARRAY_HANDLE_CHECKS;

+

+	if (firstElement == secondElement)

+		return(ERROR_NONE);

+

+	int array_size = 0;

+	rawGetArraySize(array_handle, array_size, 0);

+

+	if (array_size < 1)

+		return(ERROR_NONE);

+

+	if (firstElement >= (unsigned int)array_size)

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");

+		return(ERROR_INDEX_OUT_OF_RANGE);

+	}

+

+	if (secondElement >= (unsigned int)array_size)

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");

+		return(ERROR_INDEX_OUT_OF_RANGE);

+	}

+

+	// well, maybe swapping will work on fixed size arrays as well...

+	if (array_handle.parameterDefinition()->arraySizeIsFixed())

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_ARRAY_SIZE_IS_FIXED");

+		return(ERROR_ARRAY_SIZE_IS_FIXED);

+	}

+

+	return rawSwapArrayElements(array_handle, firstElement, secondElement);

+}

+

+ErrorType NvParameters::

+    getArraySize(const Handle &array_handle, int32_t &size, int32_t dimension) const

+{

+    ARRAY_HANDLE_CHECKS

+

+    if(dimension < 0 || dimension >= array_handle.parameterDefinition()->arrayDimension())

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_ARRAY_DIMENSION");

+        return(ERROR_INVALID_ARRAY_DIMENSION);

+	}

+

+    if(array_handle.parameterDefinition()->arraySizeIsFixed())

+    {

+        size = array_handle.parameterDefinition()->arraySize(dimension);

+        return(ERROR_NONE);

+    }

+

+    return(rawGetArraySize(array_handle, size, dimension));

+}

+

+ErrorType NvParameters::callPreSerializeCallback(Handle& handle) const

+{

+	const Definition* def = handle.parameterDefinition();

+	if (def->type() == TYPE_REF)

+	{

+		// don't preSerialize Named References

+		const Hint *hint = def->hint("INCLUDED");

+		if( hint && 

+			hint->type() == TYPE_U64 && 

+			hint->asUInt() == 1 )

+		{

+			// included

+			NvParameterized::Interface* ref = NULL;

+			NV_ERR_CHECK_RETURN( getParamRef(handle, ref) );

+			if( ref )

+			{

+				NV_ERR_CHECK_RETURN( ref->callPreSerializeCallback() );

+			}

+		}

+	}

+	else if (def->type() == TYPE_ARRAY)

+	{

+		int32_t arraySize = 0;

+		getArraySize(handle, arraySize);

+

+		for (int32_t i = 0; i < arraySize; i++)

+		{

+			handle.set(i);

+

+			NV_ERR_CHECK_RETURN( callPreSerializeCallback(handle) );

+

+			handle.popIndex();

+		}

+	}

+	else if (def->type() == TYPE_STRUCT)

+	{

+		const int32_t numChildren = def->numChildren();

+

+		for (int32_t childIndex = 0; childIndex < numChildren; childIndex++)

+		{

+			handle.set(childIndex);

+

+			NV_ERR_CHECK_RETURN( callPreSerializeCallback(handle) );

+

+			handle.popIndex();

+		}

+	}

+

+	return ERROR_NONE;

+}

+

+ErrorType NvParameters::checkParameterHandle(const Handle &handle) const

+{

+	PX_ASSERT( handle.getConstInterface() );

+	PX_ASSERT( handle.getConstInterface() == this );

+	

+	if (!handle.isValid()) 

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_PARAMETER_HANDLE");

+		return(ERROR_INVALID_PARAMETER_HANDLE);

+	}

+

+	if (handle.getConstInterface() == NULL ) 

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_HANDLE_MISSING_INTERFACE_POINTER");

+		return(ERROR_HANDLE_MISSING_INTERFACE_POINTER);

+	}

+

+	if (handle.getConstInterface() != this ) 

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_HANDLE_INVALID_INTERFACE_POINTER");

+		return(ERROR_HANDLE_INVALID_INTERFACE_POINTER); 

+	}

+

+    if(handle.parameterDefinition()->root() != rootParameterDefinition()) 

+	{

+        return(ERROR_PARAMETER_HANDLE_DOES_NOT_MATCH_CLASS);

+	}

+

+

+    const Definition *ptr = rootParameterDefinition();

+    for(int32_t i=0; i < handle.numIndexes(); ++i)

+    {

+        PX_ASSERT(ptr != NULL);

+

+        switch(ptr->type())

+        {

+            case TYPE_STRUCT:

+                if(handle.index(i) >= ptr->numChildren())

+				{

+					PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");

+                    return(ERROR_INDEX_OUT_OF_RANGE);

+				}

+                ptr = ptr->child(handle.index(i));

+                break;

+

+            case TYPE_ARRAY:

+                {

+                    int32_t size = ptr->arraySize();

+                    Handle tmpHandle(handle);

+					tmpHandle.popIndex(handle.numIndexes() - i);

+

+                    if(size <= 0)

+                        if(getArraySize(tmpHandle, size) != ERROR_NONE)

+						{

+							PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");

+                            return(ERROR_INDEX_OUT_OF_RANGE);

+						}

+

+                    if(handle.index(i) >= size)

+					{

+						PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");

+						return(ERROR_INDEX_OUT_OF_RANGE);

+					}

+

+                    ptr = ptr->child(0);

+                }

+                break;

+

+			NV_PARAMETRIZED_NO_AGGREGATE_DATATYPE_LABELS

+            default:

+                PX_ALWAYS_ASSERT();

+                ptr = NULL;

+        }

+    }

+

+    return(ERROR_NONE);

+}

+

+ErrorType NvParameters::clone(NvParameterized::Interface *&nullDestObject) const

+{

+	PX_ASSERT(nullDestObject == NULL );

+	nullDestObject = mParameterizedTraits->createNvParameterized(className(), version());

+	if( !nullDestObject )

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_OBJECT_CONSTRUCTION_FAILED");

+		return ERROR_OBJECT_CONSTRUCTION_FAILED;

+	}

+

+	ErrorType err = nullDestObject->copy(*this);

+	if( ERROR_NONE != err )

+	{

+		nullDestObject->destroy();

+		nullDestObject = NULL;

+	}

+

+	return err;

+}

+

+ErrorType NvParameters::copy(const NvParameterized::Interface &other,

+                             Handle &thisHandle)

+{

+   const Definition *paramDef = thisHandle.parameterDefinition();

+   ErrorType error = ERROR_NONE;

+

+    if( paramDef->type() == TYPE_STRUCT )

+	{

+        for(int32_t i=0; i < paramDef->numChildren(); ++i)

+        {

+            thisHandle.set(i);

+			error = copy(other, thisHandle);

+            NV_ERR_CHECK_RETURN(error);

+

+            thisHandle.popIndex();

+        }

+        return(error);

+	}

+	else if( paramDef->type() == TYPE_ARRAY )

+    {

+        int32_t thisSize, otherSize;

+

+		error = thisHandle.getArraySize(thisSize);

+        NV_ERR_CHECK_RETURN(error);

+

+		Handle otherHandle = thisHandle;

+		otherHandle.setInterface(&other);

+        error = otherHandle.getArraySize(otherSize);

+        NV_ERR_CHECK_RETURN(error);

+

+		thisHandle.setInterface(this);

+

+		if(thisSize != otherSize)

+		{

+			error = thisHandle.resizeArray(otherSize);

+			NV_ERR_CHECK_RETURN(error);

+			thisSize = otherSize;

+		}

+

+        for(int32_t i=0; i < otherSize; ++i)

+        {

+            thisHandle.set(i);

+

+			error = this->copy(other, thisHandle);

+			NV_ERR_CHECK_RETURN(error);

+

+            thisHandle.popIndex();

+        }

+        return(error);

+    }

+

+	Handle otherHandle = thisHandle; 

+	otherHandle.setInterface(&other);

+    switch(paramDef->type()) 

+    {

+		case TYPE_BOOL: 

+			{ 

+				bool otherVal; 

+				error = otherHandle.getParamBool(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamBool(otherVal) );

+			}

+

+		case TYPE_I8: 

+			{ 

+				int8_t otherVal; 

+				error = otherHandle.getParamI8(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamI8(otherVal) );

+			}

+

+		case TYPE_I16 : 

+			{ 

+				int16_t otherVal; 

+				error = otherHandle.getParamI16(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamI16(otherVal) );

+			}

+		case TYPE_I32 : 

+			{

+				int32_t otherVal;

+				error = otherHandle.getParamI32(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamI32(otherVal) );

+			}

+		case TYPE_I64 : 

+			{

+				int64_t otherVal;

+				error = otherHandle.getParamI64(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamI64(otherVal) );

+			}

+

+		case TYPE_U8 : 

+			{

+				uint8_t otherVal;

+				error = otherHandle.getParamU8(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamU8(otherVal) );

+			}

+		case TYPE_U16 : 

+			{

+				uint16_t otherVal;

+				error = otherHandle.getParamU16(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamU16(otherVal) );

+			}

+		case TYPE_U32 : 

+			{

+				uint32_t otherVal;

+				error = otherHandle.getParamU32(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamU32(otherVal) );

+			}

+		case TYPE_U64 : 

+			{

+				uint64_t otherVal;

+				error = otherHandle.getParamU64(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamU64(otherVal) );

+			}

+

+		case TYPE_F32 : 

+			{

+				float otherVal;

+				error = otherHandle.getParamF32(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamF32(otherVal) );

+			}

+		case TYPE_F64 : 

+			{

+				double otherVal;

+				error = otherHandle.getParamF64(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamF64(otherVal) );

+			}

+

+		case TYPE_VEC2 : 

+			{

+				physx::PxVec2 otherVal;

+				error = otherHandle.getParamVec2(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamVec2(otherVal) );

+			}

+		case TYPE_VEC3 : 

+			{

+				physx::PxVec3 otherVal;

+				error = otherHandle.getParamVec3(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamVec3(otherVal) );

+			}

+		case TYPE_VEC4 : 

+			{

+				physx::PxVec4 otherVal;

+				error = otherHandle.getParamVec4(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamVec4(otherVal) );

+			}

+		case TYPE_QUAT : 

+			{

+				physx::PxQuat otherVal;

+				error = otherHandle.getParamQuat(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamQuat(otherVal) );

+			}

+		case TYPE_MAT33 : 

+			{

+				physx::PxMat33 otherVal;

+				error = otherHandle.getParamMat33(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamMat33(otherVal) );

+			}

+		case TYPE_MAT44 : 

+			{ 

+				physx::PxMat44 otherVal;

+				error = otherHandle.getParamMat44(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamMat44(otherVal) );

+			}

+		case TYPE_MAT34 : 

+			{ 

+				float otherVal[12];

+				error = otherHandle.getParamMat34Legacy(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamMat34Legacy(otherVal) );

+			}

+		case TYPE_BOUNDS3 : 

+			{ 

+				physx::PxBounds3 otherVal;

+				error = otherHandle.getParamBounds3(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamBounds3(otherVal) );

+			}

+		case TYPE_TRANSFORM : 

+			{ 

+				physx::PxTransform otherVal;

+				error = otherHandle.getParamTransform(otherVal);

+				NV_ERR_CHECK_RETURN( error );

+				return( thisHandle.setParamTransform(otherVal) );

+			}

+        case TYPE_STRING:

+            {

+                const char *val1;

+				error = otherHandle.getParamString(val1);

+                NV_ERR_CHECK_RETURN(error);

+				return(thisHandle.setParamString(val1));

+            }

+

+        case TYPE_ENUM:

+            {

+                const char *val1;

+                error = otherHandle.getParamEnum(val1);

+                NV_ERR_CHECK_RETURN(error);

+				return val1 ? thisHandle.setParamEnum(val1) : ERROR_NONE;

+            }

+

+		case TYPE_REF:

+			{

+				NvParameterized::Interface *thisRef, *otherRef;

+				error = thisHandle.getParamRef(thisRef);

+				NV_ERR_CHECK_RETURN(error);

+				

+				error = otherHandle.getParamRef(otherRef);

+				NV_ERR_CHECK_RETURN(error);

+

+				if(thisRef)

+				{

+					thisRef->destroy();

+					thisHandle.setParamRef(NULL);

+				}

+

+				if(otherRef)

+				{

+					error = thisHandle.initParamRef(otherRef->className(), true);

+					NV_ERR_CHECK_RETURN(error);

+

+					error = thisHandle.getParamRef(thisRef);

+					NV_ERR_CHECK_RETURN(error);

+

+					if(thisRef == NULL)

+					{

+						PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_PARAMETER_HANDLE_NOT_INITIALIZED");

+						return(ERROR_PARAMETER_HANDLE_NOT_INITIALIZED);

+					}

+

+					return(thisRef->copy(*otherRef));

+				}

+			}

+			break;

+

+		case TYPE_POINTER:

+			//Just don't do anything with pointers

+			break;

+

+		NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS

+		NV_PARAMETRIZED_AGGREGATE_DATATYPE_LABELS

+		default:

+            PX_ALWAYS_ASSERT();

+            break;

+    }

+

+	return ERROR_NONE;

+}

+

+bool NvParameters::areParamsOK(Handle &handle, Handle *invalidHandles, uint32_t numInvalidHandles, uint32_t &numRemainingHandles)

+{

+	class Constraints

+	{

+		const Hint *min, *max, *multOf, *powOf;

+

+		static int64_t abs(int64_t x)

+		{

+			return x >= 0 ? x : -x;

+		}

+

+	public:

+		Constraints(const Hint *min_, const Hint *max_, const Hint *multOf_, const Hint *powOf_):

+			min(min_), max(max_), multOf(multOf_), powOf(powOf_) {}

+

+		bool isOK(uint64_t val)

+		{

+			bool res = true;

+

+			if( min )

+				res = res && val >= min->asUInt();

+

+			if( max )

+				res = res && val <= max->asUInt();

+

+			if( multOf )

+				res = res && 0 == val % multOf->asUInt();

+

+			if( powOf  )

+			{

+				//TODO: this is too slow

+				uint64_t base = powOf->asUInt(), acc = 1;

+				while( acc < val )

+					acc *= base;

+				res = res && acc == base;

+			}

+

+			return res;

+		}

+

+		bool isOK(int64_t val)

+		{

+			bool res = true;

+

+			if( min )

+				res = res && val >= int64_t(min->asUInt());

+

+			if( max )

+				res = res && val <= int64_t(max->asUInt());

+

+			if( multOf )

+				res = res && 0 == val % int64_t(multOf->asUInt());

+

+			if( powOf  )

+			{

+				//TODO: this is too slow

+				int64_t base = int64_t(powOf->asUInt()), acc = 1;

+				while( abs(acc) < val )

+					acc *= base;

+				res = res && abs(acc) == base;

+			}

+

+			return res;

+		}

+

+		bool isOK(float val)

+		{

+			bool res = true;

+

+			if( min )

+				res = res && val >= float(min->asFloat());

+

+			if( max )

+				res = res && val <= float(max->asFloat());

+

+			if( multOf )

+				res = res && 0.0f == (float)fmod(val, float(multOf->asFloat()));

+

+			//TODO

+			if( powOf)

+			{

+				PX_ALWAYS_ASSERT();

+				return false;

+			}

+

+			return res;

+		}

+

+		bool isOK(double val)

+		{

+			bool res = true;

+

+			if( min )

+				res = res && val >= min->asFloat();

+

+			if( max )

+				res = res && val <= max->asFloat();

+

+			if( multOf )

+				res = res && 0.0f == (float)fmod((float)val, (float)multOf->asFloat());

+

+			//TODO

+			if( powOf )

+			{

+				PX_ALWAYS_ASSERT();

+				return false;

+			}

+

+			return res;

+		}

+	};

+	

+	bool res = true;

+

+    const Definition *pd = handle.parameterDefinition();

+

+	Constraints con(pd->hint("min"), pd->hint("max"), pd->hint("multipleOf"), pd->hint("powerOf"));

+

+	switch( pd->type() ) 

+    {

+        case TYPE_STRUCT:

+            {

+                for(int32_t i = 0; i < pd->numChildren(); ++i)

+                {

+                    handle.set(i);

+                    res &= areParamsOK(handle, invalidHandles, numInvalidHandles, numRemainingHandles);

+                    handle.popIndex();

+                }

+	            return res;

+            }

+

+        case TYPE_ARRAY:

+            {

+                int32_t arraySize = -1;

+                NV_BOOL_RETURN( handle.getArraySize(arraySize) );

+

+                for(int32_t i=0; i < arraySize; ++i)

+                {

+                    handle.set(i);

+                    res &= areParamsOK(handle, invalidHandles, numInvalidHandles, numRemainingHandles);

+                    handle.popIndex();

+                }

+	            return res;

+            }

+

+		case TYPE_BOOL:

+		case TYPE_U8:

+		case TYPE_U16:

+		case TYPE_U32:

+		case TYPE_U64:

+			{

+				uint64_t val;

+				NV_BOOL_RETURN( handle.getParamU64(val) );

+				res = con.isOK(val);

+				if( !res && numRemainingHandles > 0 )

+					invalidHandles[numRemainingHandles++ - 1] = handle;

+				return res;

+			}

+

+		case TYPE_I8:

+		case TYPE_I16:

+		case TYPE_I32:

+		case TYPE_I64:

+			{

+				int64_t val;

+				NV_BOOL_RETURN( handle.getParamI64(val) );

+				res = con.isOK(val);

+				if( !res && numRemainingHandles > 0 )

+					invalidHandles[numRemainingHandles++ - 1] = handle;

+				return res;

+			}

+

+		case TYPE_F32:

+			{

+				float val = -1;

+				NV_BOOL_RETURN( handle.getParamF32(val) );

+				res = con.isOK(val);

+				if( !res && numRemainingHandles > 0 )

+					invalidHandles[numRemainingHandles++ - 1] = handle;

+				return res;

+			}

+

+		case TYPE_F64:

+			{

+				double val = -1;

+				NV_BOOL_RETURN( handle.getParamF64(val) );

+				res = con.isOK(val);

+				if( !res && numRemainingHandles > 0 )

+					invalidHandles[numRemainingHandles++ - 1] = handle;

+				return res;

+			}

+

+		NV_PARAMETRIZED_NO_AGGREGATE_AND_ARITHMETIC_DATATYPE_LABELS

+		default:

+			return true;

+	}

+}

+

+bool NvParameters::equals(const NvParameterized::Interface &obj,

+						  Handle &param_handle,

+						  Handle *handlesOfInequality,

+						  uint32_t numHandlesOfInequality,

+						  bool doCompareNotSerialized) const

+{

+    const Definition *paramDef = param_handle.parameterDefinition();

+

+	if (!doCompareNotSerialized && paramDef->hint("DONOTSERIALIZE") )

+		return true;

+

+	DataType type = paramDef->type();

+    switch(type) 

+    {

+#define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES

+#define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \

+	case TYPE_ ## enum_name: \

+	{ \

+		c_type a; \

+		c_type b; \

+		param_handle.setInterface(this); \

+		NV_BOOL_RETURN( param_handle.getParam ## type_name(a) ); \

+		param_handle.setInterface(&obj); \

+		NV_BOOL_RETURN( param_handle.getParam ## type_name(b) ); \

+		return !notEqual(a, b); \

+	}

+#include "nvparameterized/NvParameterized_types.h"

+

+		case TYPE_MAT34:

+		{

+			float a[12];

+			float b[12];

+			param_handle.setInterface(this);

+			NV_BOOL_RETURN( param_handle.getParamMat34Legacy(a) );

+			param_handle.setInterface(&obj);

+			NV_BOOL_RETURN( param_handle.getParamMat34Legacy(b) );

+			return !notEqual(a, b);

+		}

+

+		case TYPE_REF:

+			{

+				NvParameterized::Interface *val1, *val2;

+

+				param_handle.setInterface( this );

+				if(param_handle.getParamRef(val1) != ERROR_NONE)

+					return(false);

+

+				param_handle.setInterface( &obj );

+				if(param_handle.getParamRef(val2) != ERROR_NONE)

+					return(false);

+

+				if(val1 == NULL && val2 == NULL)

+					return(true);

+				else if(val1 == NULL || val2 == NULL)

+					return(false);

+

+				return val2->equals(

+					*val1,

+					handlesOfInequality != NULL ? handlesOfInequality+1 : NULL,

+					numHandlesOfInequality > 0 ? numHandlesOfInequality-1 : 0,

+					doCompareNotSerialized );

+			}

+

+		case TYPE_STRUCT:

+	        for(int32_t i = 0; i < paramDef->numChildren(); ++i)

+		    {

+			    param_handle.set(i);

+				if (!equals(obj, param_handle, handlesOfInequality, numHandlesOfInequality, doCompareNotSerialized))

+					return(false);

+	            param_handle.popIndex();

+		    }

+	        return(true);

+

+		case TYPE_ARRAY:

+	    {

+		    int32_t arraySize1, arraySize2;

+

+			param_handle.setInterface (this);

+		    if (param_handle.getArraySize(arraySize1) != ERROR_NONE)

+			    return(false);

+

+			param_handle.setInterface (&obj);

+		    if (param_handle.getArraySize(arraySize2) != ERROR_NONE)

+			    return(false);

+

+	        if(arraySize1 != arraySize2)

+		        return(false);

+

+			if( arraySize1 > 100 && paramDef->isSimpleType(false, false) )

+			{

+				// Large array of simple types, fast path

+

+				switch( type)

+				{

+				NV_PARAMETRIZED_NO_ARITHMETIC_AND_LINAL_DATATYPE_LABELS

+				NV_PARAMETRIZED_LEGACY_DATATYPE_LABELS

+				default:

+					// Fall to slow path, including TYPE_MAT34 case

+					break;

+

+#define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES

+#define NV_PARAMETERIZED_TYPES_NO_STRING_TYPES

+#define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \

+	case TYPE_ ## enum_name: { \

+		uint32_t byteSize = static_cast<uint32_t>(sizeof(c_type)) * arraySize1; \

+		c_type *data1 = (c_type *)mParameterizedTraits->alloc(byteSize), \

+			*data2 = (c_type *)mParameterizedTraits->alloc(byteSize); \

+		\

+		param_handle.setInterface(this); \

+		NV_BOOL_RETURN(param_handle.getParam ## type_name ## Array(data1, arraySize1)); \

+		\

+		param_handle.setInterface(&obj); \

+		NV_BOOL_RETURN(param_handle.getParam ## type_name ## Array(data2, arraySize2)); \

+		\

+		int ret = memcmp(data1, data2, byteSize); \

+		mParameterizedTraits->free(data1); \

+		mParameterizedTraits->free(data2); \

+		\

+		return ret == 0; \

+	}

+#include "nvparameterized/NvParameterized_types.h"

+				}

+			}

+

+			// Array of aggregates, slow path

+

+			param_handle.setInterface(this);

+

+			for (int32_t i = 0; i < arraySize1; ++i)

+		    {

+			    param_handle.set(i);

+				if (!equals(obj, param_handle, handlesOfInequality, numHandlesOfInequality, doCompareNotSerialized))

+					return(false);

+				param_handle.popIndex();

+			}

+

+			return(true);

+		}

+

+		case TYPE_POINTER:

+			return true;

+

+NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS

+        default:

+			PX_ALWAYS_ASSERT();

+            break;

+    }

+

+    return(false);

+}

+                   

+ErrorType NvParameters::copy(const NvParameterized::Interface &other)

+{

+	if (this == &other)

+	{

+		return(ERROR_NONE);

+	}

+

+    if (rootParameterDefinition() != other.rootParameterDefinition())

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_PARAMETER_DEFINITIONS_DO_NOT_MATCH");

+		return(ERROR_PARAMETER_DEFINITIONS_DO_NOT_MATCH);

+	}

+

+	// support empty, named references

+	if (rootParameterDefinition() == NULL)

+	{

+		// the name or className could be NULL, strcmp doesn't like NULL strings...

+		setClassName(other.className());

+		setName(other.name());

+		return(ERROR_NONE);

+	}

+	else

+	{

+		Handle handle (*this);

+		if (getParameterHandle("", handle) != ERROR_NONE)

+		{

+			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_PARAMETER_HANDLE");

+			return(ERROR_INVALID_PARAMETER_HANDLE);

+		}

+

+		return(copy(other, handle));

+	}

+}

+

+bool NvParameters::areParamsOK(Handle *invalidHandles, uint32_t numInvalidHandles)

+{

+    Handle handle(*this);

+	NV_BOOL_RETURN( getParameterHandle("", handle) );

+

+	uint32_t numRemainingHandles = numInvalidHandles;

+	return areParamsOK(handle, invalidHandles, numInvalidHandles, numRemainingHandles);

+}

+

+bool NvParameters::equals(const NvParameterized::Interface &obj, Handle* handleOfInequality, uint32_t numHandlesOfInequality, bool doCompareNotSerialized) const

+{

+	if( this == &obj )

+		return(true);

+

+    if(rootParameterDefinition() != obj.rootParameterDefinition())

+        return(false);

+

+	// support empty, named references

+	if(rootParameterDefinition() == NULL)

+	{

+		// the name or className could be NULL, strcmp doesn't like NULL strings...

+		return 0 == safe_strcmp(name(), obj.name()) && 0 == safe_strcmp(className(), obj.className());

+	}

+

+	// This should be a handle that can not set any values!

+    Handle constHandle(*this);

+	NV_BOOL_RETURN( getParameterHandle("", constHandle) );

+

+	bool theSame = equals(obj, constHandle, handleOfInequality, numHandlesOfInequality, doCompareNotSerialized);

+

+	if (!theSame && numHandlesOfInequality > 0)

+		*handleOfInequality = constHandle;

+

+	return theSame;

+}

+

+ErrorType NvParameters::valueToStr(const Handle &handle,

+                                   char *buf,

+                                   uint32_t n,

+                                   const char *&ret)

+{

+    PX_ASSERT(buf != NULL);

+    PX_ASSERT(n > 0);

+

+    if(!handle.isValid())

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_PARAMETER_HANDLE");

+        return(ERROR_INVALID_PARAMETER_HANDLE);

+	}

+

+    const Definition *paramDef = handle.parameterDefinition();

+

+    ErrorType error = ERROR_TYPE_NOT_SUPPORTED;

+

+    switch(paramDef->type())

+    {

+    	case TYPE_VEC2:

+    		{

+        		physx::PxVec2 val;

+                if ((error = getParamVec2(handle, val)) == ERROR_NONE)

+                {

+					char f[2][physx::PxAsc::PxF32StrLen];

+					physx::shdfnd::snprintf(buf, n,"%s %s",

+						 physx::PxAsc::valueToStr(val.x, f[0], physx::PxAsc::PxF32StrLen),

+						 physx::PxAsc::valueToStr(val.y, f[1], physx::PxAsc::PxF32StrLen));

+    				ret = buf;

+    			}

+			}

+    		break;

+    	case TYPE_VEC3:

+    		{

+        		physx::PxVec3 val;

+                if ((error = getParamVec3(handle, val)) == ERROR_NONE)

+                {

+					char f[3][physx::PxAsc::PxF32StrLen];

+					physx::shdfnd::snprintf(buf, n,"%s %s %s",

+						 physx::PxAsc::valueToStr(val.x, f[0], physx::PxAsc::PxF32StrLen),

+						 physx::PxAsc::valueToStr(val.y, f[1], physx::PxAsc::PxF32StrLen),

+						 physx::PxAsc::valueToStr(val.z, f[2], physx::PxAsc::PxF32StrLen));

+    				ret = buf;

+    			}

+			}

+    		break;

+    	case TYPE_VEC4:

+    		{

+        		physx::PxVec4 val;

+                if ((error = getParamVec4(handle, val)) == ERROR_NONE)

+                {

+					char f[4][physx::PxAsc::PxF32StrLen];

+					physx::shdfnd::snprintf(buf, n,"%s %s %s %s",

+						 physx::PxAsc::valueToStr(val.x, f[0], physx::PxAsc::PxF32StrLen),

+						 physx::PxAsc::valueToStr(val.y, f[1], physx::PxAsc::PxF32StrLen),

+						 physx::PxAsc::valueToStr(val.z, f[2], physx::PxAsc::PxF32StrLen),

+						 physx::PxAsc::valueToStr(val.w, f[3], physx::PxAsc::PxF32StrLen));

+    				ret = buf;

+    			}

+			}

+    		break;

+    	case TYPE_QUAT:

+			{

+				physx::PxQuat val;

+				if ((error = getParamQuat(handle, val)) == ERROR_NONE)

+				{

+					float quat[4];

+					//val.getXYZW(quat);

+					quat[0] = val.x; quat[1] = val.y; quat[2] = val.z; quat[3] = val.w;

+					char f[4][physx::PxAsc::PxF32StrLen];

+					physx::shdfnd::snprintf(buf, n,"%s %s %s %s",

+						 physx::PxAsc::valueToStr(quat[0], f[0], physx::PxAsc::PxF32StrLen),

+						 physx::PxAsc::valueToStr(quat[1], f[1], physx::PxAsc::PxF32StrLen),

+						 physx::PxAsc::valueToStr(quat[2], f[2], physx::PxAsc::PxF32StrLen),

+						 physx::PxAsc::valueToStr(quat[3], f[3], physx::PxAsc::PxF32StrLen));

+

+					ret = buf;

+				}

+			}

+    		break;

+    	case TYPE_MAT33:

+			{

+				physx::PxMat33 val;

+				if ((error = getParamMat33(handle, val)) == ERROR_NONE)

+				{

+					char f[9][physx::PxAsc::PxF32StrLen];

+					const float *vals = val.front();

+					physx::shdfnd::snprintf(buf, n,"%s %s %s  %s %s %s  %s %s %s",

+						physx::PxAsc::valueToStr(vals[0], f[0], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[1], f[1], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[2], f[2], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[3], f[3], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[4], f[4], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[5], f[5], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[6], f[6], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[7], f[7], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[8], f[8], physx::PxAsc::PxF32StrLen));

+					ret = buf;

+				}

+			}

+    		break;

+    	case TYPE_MAT44:

+			{

+				physx::PxMat44 val;

+				if ((error = getParamMat44(handle, val)) == ERROR_NONE)

+				{

+					char f[16][physx::PxAsc::PxF32StrLen];

+					const float *vals = val.front();

+					physx::shdfnd::snprintf(buf, n,"%s %s %s %s  %s %s %s %s  %s %s %s %s  %s %s %s %s",

+						physx::PxAsc::valueToStr(vals[0], f[0], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[1], f[1], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[2], f[2], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[3], f[3], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[4], f[4], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[5], f[5], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[6], f[6], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[7], f[7], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[8], f[8], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[9], f[9], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[10], f[10], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[11], f[11], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[12], f[12], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[13], f[13], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[14], f[14], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[15], f[15], physx::PxAsc::PxF32StrLen));

+					ret = buf;

+				}

+			}

+    		break;

+    	case TYPE_MAT34:

+			{

+				float vals[12];

+				if ((error = getParamMat34Legacy(handle, vals)) == ERROR_NONE)

+				{

+					char f[16][physx::PxAsc::PxF32StrLen];

+					physx::shdfnd::snprintf(buf, n,"%s %s %s  %s %s %s  %s %s %s  %s %s %s",

+						physx::PxAsc::valueToStr(vals[0], f[0], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[1], f[1], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[2], f[2], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[3], f[3], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[4], f[4], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[5], f[5], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[6], f[6], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[7], f[7], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[8], f[8], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[9], f[9], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[10], f[10], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(vals[11], f[11], physx::PxAsc::PxF32StrLen));

+					ret = buf;

+				}

+			}

+    		break;

+		case TYPE_BOUNDS3:

+			{

+				char f[6][physx::PxAsc::PxF32StrLen];

+				physx::PxBounds3 val;

+				if ((error = getParamBounds3(handle, val)) == ERROR_NONE)

+				{

+					physx::shdfnd::snprintf(buf, n,"%s %s %s  %s %s %s ",

+						physx::PxAsc::valueToStr(val.minimum.x, f[0], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(val.minimum.y, f[1], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(val.minimum.z, f[2], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(val.maximum.x, f[3], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(val.maximum.y, f[4], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(val.maximum.z, f[5], physx::PxAsc::PxF32StrLen));

+					ret = buf;

+				}

+			}

+    		break;

+    	case TYPE_TRANSFORM:

+			{

+				char f[7][physx::PxAsc::PxF32StrLen];

+				physx::PxTransform val;

+				if ((error = getParamTransform(handle, val)) == ERROR_NONE)

+				{

+					physx::shdfnd::snprintf(buf, n,"%s %s %s %s  %s %s %s ",

+						physx::PxAsc::valueToStr(val.q.x, f[0], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(val.q.y, f[1], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(val.q.z, f[2], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(val.q.w, f[3], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(val.p.x, f[4], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(val.p.y, f[5], physx::PxAsc::PxF32StrLen),

+						physx::PxAsc::valueToStr(val.p.z, f[6], physx::PxAsc::PxF32StrLen));

+					ret = buf;

+				}

+			}

+    		break;

+        case TYPE_UNDEFINED:

+        case TYPE_ARRAY:

+        case TYPE_STRUCT:

+			break;

+        case TYPE_STRING:

+            error = getParamString(handle, ret);

+			break;

+        case TYPE_ENUM:

+            error = getParamEnum(handle, ret);

+			break;

+		case TYPE_REF:

+		{

+			const Hint *hint = paramDef->hint("INCLUDED");

+			if( hint && hint->type() != TYPE_U64 )

+			{

+				PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INVALID_REFERENCE_INCLUDE_HINT");

+				return(ERROR_INVALID_REFERENCE_INCLUDE_HINT);

+			}

+

+			if( hint != NULL && hint->asUInt() == 1 )

+			{

+				// included, output the entire struct

+			}

+			else

+			{

+				//not included, get the "name" from the NvParameterized pointer

+				NvParameterized::Interface *paramPtr = 0;

+				ErrorType err = getParamRef(handle, paramPtr);

+				PX_ASSERT(err == ERROR_NONE);

+

+				if(err != ERROR_NONE)

+				{

+					return err;

+				}

+

+				ret = NULL;

+				if(paramPtr)

+				{

+					ret = paramPtr->name();

+				}

+			}

+			error = ERROR_NONE;

+		}

+		break;

+		case TYPE_BOOL:

+    		{

+        		bool val;

+                if ((error = getParamBool(handle, val)) == ERROR_NONE)

+                {

+					ret = physx::PxAsc::valueToStr(val, buf, n);

+    			}

+			}

+			break;

+		case TYPE_I8:

+    		{

+        		int8_t val;

+                if ((error = getParamI8(handle, val)) == ERROR_NONE)

+                {

+					ret = physx::PxAsc::valueToStr(val, buf, n);

+    			}

+			}

+			break;

+		case TYPE_I16:

+    		{

+        		int16_t val;

+                if ((error = getParamI16(handle, val)) == ERROR_NONE)

+                {

+                	ret = physx::PxAsc::valueToStr(val, buf, n);

+    			}

+			}

+			break;

+		case TYPE_I32:

+    		{

+        		int32_t val;

+                if ((error = getParamI32(handle, val)) == ERROR_NONE)

+                {

+                	ret = physx::PxAsc::valueToStr(val, buf, n);

+    			}

+			}

+			break;

+		case TYPE_I64:

+    		{

+        		int64_t val;

+                if ((error = getParamI64(handle, val)) == ERROR_NONE)

+                {

+           			ret = physx::PxAsc::valueToStr(val, buf, n);

+    			}

+			}

+			break;

+		case TYPE_U8:

+    		{

+        		uint8_t val;

+                if ((error = getParamU8(handle, val)) == ERROR_NONE)

+                {

+					ret = physx::PxAsc::valueToStr(val, buf, n);

+    			}

+			}

+			break;

+		case TYPE_U16:

+    		{

+        		uint16_t val;

+                if ((error = getParamU16(handle, val)) == ERROR_NONE)

+                {

+                	ret = physx::PxAsc::valueToStr(val, buf, n);

+    			}

+			}

+			break;

+		case TYPE_U32:

+    		{

+        		uint32_t val;

+                if ((error = getParamU32(handle, val)) == ERROR_NONE)

+                {

+                	ret = physx::PxAsc::valueToStr(val, buf, n);

+    			}

+			}

+			break;

+		case TYPE_U64:

+    		{

+        		uint64_t val;

+                if ((error = getParamU64(handle, val)) == ERROR_NONE)

+                {

+              		ret = physx::PxAsc::valueToStr(val, buf, n);

+    			}

+			}

+			break;

+		case TYPE_F32:

+    		{

+        		float val;

+                if ((error = getParamF32(handle, val)) == ERROR_NONE)

+                {

+					ret = physx::PxAsc::valueToStr(val, buf, n);

+    			}

+			}

+			break;

+		case TYPE_F64:

+    		{

+        		double val;

+                if ((error = getParamF64(handle, val)) == ERROR_NONE)

+                {

+					ret = physx::PxAsc::valueToStr(val, buf, n);

+    			}

+			}

+			break;

+

+		// Make compiler happy

+		case TYPE_POINTER:

+		case TYPE_LAST:

+			break;

+    }

+

+	PX_ASSERT(error == ERROR_NONE);

+

+    return error;

+}

+

+ErrorType NvParameters::strToValue(Handle &handle, const char *str, const char **endptr) // assigns this string to the value

+{

+	ErrorType ret = ERROR_NONE;

+

+	const Definition *pd = handle.parameterDefinition();

+

+	switch ( pd->type() )

+	{

+        case TYPE_UNDEFINED:

+        case TYPE_ARRAY:

+		case TYPE_STRUCT:    ret = ERROR_TYPE_NOT_SUPPORTED;                                  break;

+

+		case TYPE_STRING:    ret = setParamString(handle,str);                                break;

+        case TYPE_ENUM:      ret = setParamEnum(handle,str);                                  break;

+		case TYPE_REF:       ret = ERROR_TYPE_NOT_SUPPORTED;                                  break;

+		case TYPE_BOOL:	     ret = setParamBool(handle,physx::PxAsc::strToBool(str, endptr)); break;

+        case TYPE_I8:  	     ret = setParamI8(handle,physx::PxAsc::strToI8(str, endptr));     break;

+        case TYPE_I16:       ret = setParamI16(handle,physx::PxAsc::strToI16(str, endptr));   break;

+        case TYPE_I32:       ret = setParamI32(handle,physx::PxAsc::strToI32(str, endptr));   break;

+        case TYPE_I64:       ret = setParamI64(handle,physx::PxAsc::strToI64(str, endptr));   break;

+        case TYPE_U8:        ret = setParamU8(handle,physx::PxAsc::strToU8(str, endptr));     break;

+        case TYPE_U16:       ret = setParamU16(handle,physx::PxAsc::strToU16(str, endptr));   break;

+        case TYPE_U32:       ret = setParamU32(handle,physx::PxAsc::strToU32(str, endptr));   break;

+        case TYPE_U64:       ret = setParamU64(handle,physx::PxAsc::strToU64(str, endptr));   break;

+        case TYPE_F32:       ret = setParamF32(handle,physx::PxAsc::strToF32(str, endptr));   break;

+        case TYPE_F64:       ret = setParamF64(handle,physx::PxAsc::strToF64(str, endptr));   break;

+        case TYPE_VEC2:      ret = setParamVec2(handle,getVec2(str, endptr));                 break;

+        case TYPE_VEC3:      ret = setParamVec3(handle,getVec3(str, endptr));                 break;

+        case TYPE_VEC4:      ret = setParamVec4(handle,getVec4(str, endptr));                 break;

+        case TYPE_QUAT:      ret = setParamQuat(handle,getQuat(str, endptr));                 break;

+        case TYPE_MAT33:     ret = setParamMat33(handle,getMat33(str, endptr));               break;

+        case TYPE_MAT34:     

+			{

+				float f[12];

+				getMat34Legacy(str, endptr, f);

+				ret = setParamMat34Legacy(handle,f);   

+				break;

+			}

+        case TYPE_MAT44:     ret = setParamMat44(handle,getMat44(str, endptr));               break;

+        case TYPE_BOUNDS3:   ret = setParamBounds3(handle,getBounds3(str, endptr));           break;

+        case TYPE_TRANSFORM: ret = setParamTransform(handle,getTransform(str, endptr));       break;

+

+NV_PARAMETRIZED_SERVICE_AND_LAST_DATATYPE_LABELS

+		default:             ret = ERROR_TYPE_NOT_SUPPORTED;                                  break;

+    }

+

+	PX_ASSERT(ret == ERROR_NONE);

+

+    return ret;

+}

+

+physx::PxVec2 		NvParameters::getVec2(const char *str, const char **endptr)

+{

+	physx::PxVec2 ret(0,0);

+	physx::PxAsc::strToF32s(&ret.x,2,str,endptr);

+

+	return ret;

+}

+

+physx::PxVec3 		NvParameters::getVec3(const char *str, const char **endptr)

+{

+	physx::PxVec3 ret(0,0,0);

+	physx::PxAsc::strToF32s(&ret.x,3,str,endptr);

+

+	return ret;

+}

+

+physx::PxVec4 		NvParameters::getVec4(const char *str, const char **endptr)

+{

+	physx::PxVec4 ret(0,0,0,0);

+	physx::PxAsc::strToF32s(&ret.x,4,str,endptr);

+

+	return ret;

+}

+

+physx::PxQuat 		NvParameters::getQuat(const char *str, const char **endptr)

+{

+	physx::PxQuat ret;

+	//ret.identity();

+	float quat[4];

+	//ret.getXYZW(quat);

+	physx::PxAsc::strToF32s(quat,4,str,endptr);

+	//ret.setXYZW(quat);

+	ret = physx::PxQuat(quat[0], quat[1], quat[2], quat[3]);

+

+	return ret;

+}

+

+physx::PxMat33 		NvParameters::getMat33(const char *str, const char **endptr)

+{

+	physx::PxMat33 ret;

+	float *vals = const_cast<float *>(ret.front());

+	physx::PxAsc::strToF32s(vals,9,str,endptr);

+	return ret;

+}

+

+physx::PxMat44 		NvParameters::getMat44(const char *str, const char **endptr)

+{

+	physx::PxMat44 ret;

+	float *vals = const_cast<float *>(ret.front());

+	physx::PxAsc::strToF32s(vals,16,str,endptr);

+	return ret;

+}

+

+void NvParameters::getMat34Legacy(const char *str, const char **endptr, float (&val)[12])

+{

+	physx::PxAsc::strToF32s(val,12,str,endptr);

+}

+

+physx::PxBounds3    NvParameters::getBounds3(const char *str, const char **endptr)

+{

+	physx::PxBounds3 ret;

+	ret.setEmpty();

+	physx::PxAsc::strToF32s(&ret.minimum.x,6,str,endptr);

+	return ret;

+}

+

+//******************************************************************************

+//*** Vec2

+//******************************************************************************

+

+ErrorType NvParameters::setParamVec2(const Handle &handle, const physx::PxVec2 &val)

+{

+    CHECK_HANDLE

+    CHECK_F32_FINITE

+

+	if(handle.parameterDefinition()->type() == TYPE_VEC2)

+    {

+        return rawSetParamVec2(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamVec2(const Handle &handle, physx::PxVec2 &val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_VEC2)

+    {

+        return rawGetParamVec2(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamVec2Array(const Handle &handle, physx::PxVec2 *array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(VEC2)

+    return(rawGetParamVec2Array(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamVec2Array(const Handle &handle, const physx::PxVec2 *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(VEC2)

+    CHECK_F32_FINITE_ARRAY

+    return(rawSetParamVec2Array(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** Vec3

+//******************************************************************************

+

+ErrorType NvParameters::setParamVec3(const Handle &handle, const physx::PxVec3 &val)

+{

+    CHECK_HANDLE

+    CHECK_F32_FINITE

+

+	if(handle.parameterDefinition()->type() == TYPE_VEC3)

+    {

+        return rawSetParamVec3(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamVec3(const Handle &handle, physx::PxVec3 &val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_VEC3)

+    {

+        return rawGetParamVec3(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamVec3Array(const Handle &handle, physx::PxVec3 *array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(VEC3)

+    return(rawGetParamVec3Array(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamVec3Array(const Handle &handle, const physx::PxVec3 *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(VEC3)

+    CHECK_F32_FINITE_ARRAY

+    return(rawSetParamVec3Array(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** Vec4

+//******************************************************************************

+

+ErrorType NvParameters::setParamVec4(const Handle &handle, const physx::PxVec4 &val)

+{

+    CHECK_HANDLE

+    CHECK_F32_FINITE

+

+	if(handle.parameterDefinition()->type() == TYPE_VEC4)

+    {

+        return rawSetParamVec4(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamVec4(const Handle &handle, physx::PxVec4 &val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_VEC4)

+    {

+        return rawGetParamVec4(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamVec4Array(const Handle &handle, physx::PxVec4 *array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(VEC4)

+    return(rawGetParamVec4Array(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamVec4Array(const Handle &handle, const physx::PxVec4 *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(VEC4)

+    CHECK_F32_FINITE_ARRAY

+    return(rawSetParamVec4Array(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** Quat

+//******************************************************************************

+

+ErrorType NvParameters::setParamQuat(const Handle &handle, const physx::PxQuat &val)

+{

+    CHECK_HANDLE

+    CHECK_F32_FINITE

+

+	if(handle.parameterDefinition()->type() == TYPE_QUAT)

+    {

+        return rawSetParamQuat(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamQuat(const Handle &handle, physx::PxQuat &val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_QUAT)

+    {

+        return rawGetParamQuat(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamQuatArray(const Handle &handle, physx::PxQuat *array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(QUAT)

+    return(rawGetParamQuatArray(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamQuatArray(const Handle &handle, const physx::PxQuat *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(QUAT)

+    CHECK_F32_FINITE_ARRAY

+    return(rawSetParamQuatArray(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** Mat33

+//******************************************************************************

+

+ErrorType NvParameters::setParamMat33(const Handle &handle, const physx::PxMat33 &val)

+{

+    CHECK_HANDLE

+    CHECK_F32_FINITE

+

+    	if(handle.parameterDefinition()->type() == TYPE_MAT33)

+    {

+        return rawSetParamMat33(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamMat33(const Handle &handle, physx::PxMat33 &val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_MAT33)

+    {

+        return rawGetParamMat33(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamMat33Array(const Handle &handle, physx::PxMat33 *array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(MAT33)

+    return(rawGetParamMat33Array(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamMat33Array(const Handle &handle, const physx::PxMat33 *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(MAT33)

+    CHECK_F32_FINITE_ARRAY

+    return(rawSetParamMat33Array(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** Mat34Legacy

+//******************************************************************************

+

+ErrorType NvParameters::setParamMat34Legacy(const Handle &handle, const float (&val)[12])

+{

+    CHECK_HANDLE

+    CHECK_F32_FINITE

+

+   	if(handle.parameterDefinition()->type() == TYPE_MAT34)

+    {

+        return rawSetParamMat34Legacy(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamMat34Legacy(const Handle &handle, float (&val)[12]) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_MAT34)

+    {

+        return rawGetParamMat34Legacy(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamMat34LegacyArray(const Handle &handle, float *array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(MAT34)

+    return(rawGetParamMat34LegacyArray(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamMat34LegacyArray(const Handle &handle, const float *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(MAT34)

+    CHECK_F32_FINITE_ARRAY

+    return(rawSetParamMat34LegacyArray(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** Mat44

+//******************************************************************************

+

+ErrorType NvParameters::setParamMat44(const Handle &handle, const physx::PxMat44 &val)

+{

+    CHECK_HANDLE

+    CHECK_F32_FINITE

+

+   	if(handle.parameterDefinition()->type() == TYPE_MAT44)

+    {

+        return rawSetParamMat44(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamMat44(const Handle &handle, physx::PxMat44 &val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_MAT44)

+    {

+        return rawGetParamMat44(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamMat44Array(const Handle &handle, physx::PxMat44 *array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(MAT44)

+    return(rawGetParamMat44Array(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamMat44Array(const Handle &handle, const physx::PxMat44 *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(MAT44)

+    CHECK_F32_FINITE_ARRAY

+    return(rawSetParamMat44Array(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** Bounds3

+//******************************************************************************

+

+ErrorType NvParameters::setParamBounds3(const Handle &handle, const physx::PxBounds3 &val)

+{

+    CHECK_HANDLE

+    CHECK_F32_FINITE

+

+	if(handle.parameterDefinition()->type() == TYPE_BOUNDS3)

+    {

+        return rawSetParamBounds3(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamBounds3(const Handle &handle, physx::PxBounds3 &val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_BOUNDS3)

+    {

+        return rawGetParamBounds3(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamBounds3Array(const Handle &handle, physx::PxBounds3 *array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(BOUNDS3)

+    return(rawGetParamBounds3Array(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamBounds3Array(const Handle &handle, const physx::PxBounds3 *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(BOUNDS3)

+    CHECK_F32_FINITE_ARRAY

+    return(rawSetParamBounds3Array(handle, array, n, offset));

+}

+

+//******************************************************************************

+//*** Transform

+//******************************************************************************

+

+ErrorType NvParameters::setParamTransform(const Handle &handle, const physx::PxTransform &val)

+{

+    CHECK_HANDLE

+    CHECK_F32_FINITE

+

+   	if(handle.parameterDefinition()->type() == TYPE_TRANSFORM)

+    {

+        return rawSetParamTransform(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+	return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamTransform(const Handle &handle, physx::PxTransform &val) const

+{

+    CHECK_HANDLE

+

+	if(handle.parameterDefinition()->type() == TYPE_TRANSFORM)

+    {

+        return rawGetParamTransform(handle, val);

+    }

+

+	PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_CAST_FAILED");

+    return(ERROR_CAST_FAILED);

+}

+

+ErrorType NvParameters::getParamTransformArray(const Handle &handle, physx::PxTransform *array, int32_t n, int32_t offset) const

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(TRANSFORM)

+    return(rawGetParamTransformArray(handle, array, n, offset));

+}

+

+ErrorType NvParameters::setParamTransformArray(const Handle &handle, const physx::PxTransform *array, int32_t n, int32_t offset)

+{

+    CHECK_HANDLE

+    CHECK_IS_SIMPLE_ARRAY(TRANSFORM)

+    CHECK_F32_FINITE_ARRAY

+    return(rawSetParamTransformArray(handle, array, n, offset));

+}

+

+physx::PxTransform    NvParameters::getTransform(const char *str, const char **endptr)

+{

+	physx::PxTransform ret;

+	physx::PxAsc::strToF32s((float*)&ret,7,str,endptr);

+	return ret;

+}

+

+

+//***********************************************

+physx::PxVec2 NvParameters::init(float x,float y)

+{

+	physx::PxVec2 ret(x,y);

+	return ret;

+}

+

+physx::PxVec3 NvParameters::init(float x,float y,float z)

+{

+	physx::PxVec3 ret(x,y,z);

+	return ret;

+}

+

+physx::PxVec4 NvParameters::initVec4(float x,float y,float z,float w)

+{

+	physx::PxVec4 ret(x,y,z,w);

+	return ret;

+}

+

+physx::PxQuat NvParameters::init(float x,float y,float z,float w)

+{

+	physx::PxQuat ret;

+	//ret.setXYZW(x,y,z,w);

+	ret = physx::PxQuat(x,y,z,w);

+	return ret;

+}

+

+physx::PxMat33 NvParameters::init(float _11,float _12,float _13,float _21,float _22,float _23,float _31,float _32,float _33)

+{

+	physx::PxMat33 ret;

+

+	ret.column0.x = _11;

+	ret.column0.y = _21;

+	ret.column0.z = _31;

+

+	ret.column1.x = _12;

+	ret.column1.y = _22;

+	ret.column1.z = _32;

+

+	ret.column2.x = _13;

+	ret.column2.y = _23;

+	ret.column2.z = _33;

+

+	return ret;

+}

+

+physx::PxMat44 NvParameters::init(float _11,float _12,float _13,float _14,float _21,float _22,float _23,float _24,float _31,float _32,float _33,float _34,float _41,float _42,float _43,float _44)

+{

+	physx::PxMat44 ret;

+

+	ret.column0.x = _11;

+	ret.column0.y = _21;

+	ret.column0.z = _31;

+	ret.column0.w = _41;

+

+	ret.column1.x = _12;

+	ret.column1.y = _22;

+	ret.column1.z = _32;

+	ret.column1.w = _42;

+

+	ret.column2.x = _13;

+	ret.column2.y = _23;

+	ret.column2.z = _33;

+	ret.column2.w = _43;

+

+	ret.column3.x = _14;

+	ret.column3.y = _24;

+	ret.column3.z = _34;

+	ret.column3.w = _44;

+

+	return ret;

+}

+

+physx::PxTransform NvParameters::init(float x,float y,float z,float qx,float qy,float qz,float qw)

+{

+	return physx::PxTransform(physx::PxVec3(x,y,z), physx::PxQuat(qx,qy,qz,qw));

+}

+

+

+physx::PxBounds3 NvParameters::init(float minx,float miny,float minz,float maxx,float maxy,float maxz)

+{

+	physx::PxBounds3 ret;

+	ret.minimum = physx::PxVec3(minx,miny,minz);

+	ret.maximum = physx::PxVec3(maxx,maxy,maxz);

+	return ret;

+}

+

+

+

+int32_t NvParameters::MultIntArray(const int32_t *array, int32_t n)

+{

+    PX_ASSERT(array != NULL);

+    PX_ASSERT(n > 0);

+

+    int32_t ret = array[0];

+

+    for(int32_t i=1; i < n; ++i)

+        ret *= array[i];

+

+    return(ret);

+}

+

+

+ErrorType NvParameters::resizeArray(Traits *parameterizedTraits,

+													 void *&buf, 

+													 int32_t *array_sizes, 

+													 int32_t dimension, 

+													 int32_t resize_dim,

+													 int32_t new_size,

+													 bool doFree,

+													 int32_t element_size,

+													 uint32_t element_align,

+													 bool &isMemAllocated)

+{

+    PX_ASSERT(array_sizes != NULL);

+    PX_ASSERT(dimension > 0);

+    PX_ASSERT(resize_dim >= 0 && resize_dim < dimension);

+    PX_ASSERT(new_size >= 0);

+	PX_ASSERT(element_size > 0 );

+

+    if(array_sizes[resize_dim] == new_size)

+        return(ERROR_NONE); //isMemAllocated is unchanged

+

+    int32_t newSizes[Handle::MAX_DEPTH];

+    physx::intrinsics::memCopy(newSizes, array_sizes, dimension * sizeof(int32_t));

+

+    newSizes[resize_dim] = new_size;

+

+    int32_t currentNumElems = MultIntArray(array_sizes, dimension);

+    int32_t newNumElems = MultIntArray(newSizes, dimension);

+

+    if(newNumElems <= 0)

+    {

+        if(buf != NULL && doFree) 

+            parameterizedTraits->free(buf);

+

+        buf = NULL;

+        goto no_error;

+    }

+

+    if(buf == NULL) 

+    {

+		PX_ASSERT(element_size * newNumElems >= 0);

+        if((buf = allocAligned(parameterizedTraits, static_cast<uint32_t>(element_size * newNumElems), element_align)) == NULL)

+		{

+			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_MEMORY_ALLOCATION_FAILURE");

+            return(ERROR_MEMORY_ALLOCATION_FAILURE);

+		}

+

+		isMemAllocated = true;

+        

+        //initialize the array to 0's (for strings)

+		physx::intrinsics::memZero(buf, uint32_t(element_size * newNumElems));

+

+        goto no_error;

+    }

+

+    if(resize_dim == 0)

+    {

+        void *newBuf;

+        char *newBufDataStart;

+        int32_t newBufDataSize;

+        

+		PX_ASSERT(element_size * newNumElems >= 0);

+        // alloc new buffer

+        if((newBuf = allocAligned(parameterizedTraits, static_cast<uint32_t>(element_size * newNumElems), element_align)) == NULL)

+		{

+			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_MEMORY_ALLOCATION_FAILURE");

+            return(ERROR_MEMORY_ALLOCATION_FAILURE);

+		}

+

+		isMemAllocated = true;

+        

+        // copy existing data to new buffer

+		if(newNumElems < currentNumElems)

+			physx::intrinsics::memCopy(newBuf, buf, uint32_t(element_size * newNumElems));

+		else

+			physx::intrinsics::memCopy(newBuf, buf, uint32_t(element_size * currentNumElems));

+        

+        // zero the new part of the array

+        if(newNumElems > currentNumElems)

+        {

+            newBufDataStart = (char *)newBuf + (currentNumElems * element_size);

+            newBufDataSize = (newNumElems - currentNumElems) * element_size;

+

+			PX_ASSERT(newBufDataSize >= 0);

+            memset(newBufDataStart, 0, static_cast<uint32_t>(newBufDataSize));

+        }

+        

+        if( doFree )

+        parameterizedTraits->free(buf);

+        buf = newBuf;

+    }

+    else

+    {

+		PX_ASSERT(element_size * newNumElems >= 0);

+        void *newBuf = allocAligned(parameterizedTraits, static_cast<uint32_t>(element_size * newNumElems), element_align);

+        if(newBuf == NULL)

+		{

+			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_MEMORY_ALLOCATION_FAILURE");

+            return(ERROR_MEMORY_ALLOCATION_FAILURE);

+		}

+

+		isMemAllocated = true;

+

+        //initialize the array to 0's (for strings)

+		physx::intrinsics::memSet(newBuf, 0U, uint32_t(element_size * newNumElems));

+        recursiveCopy(buf, array_sizes, newBuf, newSizes, dimension, element_size);

+

+		if( doFree )

+        parameterizedTraits->free(buf);

+        buf = newBuf;

+    }

+      

+

+no_error:

+

+    array_sizes[resize_dim] = new_size;

+    return(ERROR_NONE);

+}

+

+void NvParameters::recursiveCopy(const void *src, 

+								 const int32_t *src_sizes, 

+								 void *dst, 

+								 const int32_t *dst_sizes, 

+								 int32_t dimension, 

+								 int32_t element_size,

+								 int32_t *indexes, 

+								 int32_t level)

+{

+    int32_t srcSize = src_sizes[level];

+    int32_t dstSize = dst_sizes[level];

+

+    int32_t size = physx::PxMin(srcSize, dstSize);

+

+    int32_t indexStore[Handle::MAX_DEPTH];

+

+    if(indexes == NULL)

+    {

+        indexes = indexStore;

+        memset(indexes, 0, Handle::MAX_DEPTH * sizeof(int32_t));

+    }

+

+    if(level == dimension - 1)

+    {

+        int32_t srcIndex = indexes[0];

+        int32_t dstIndex = indexes[0];

+

+        for(int32_t i=1; i < dimension; ++i)

+        {

+            srcIndex = src_sizes[i] * (srcIndex) + indexes[i];

+            dstIndex = dst_sizes[i] * (dstIndex) + indexes[i];

+        }

+

+		char *copy_dst = (char *)dst + dstIndex * element_size;

+		char *copy_src = (char *)src + srcIndex * element_size;

+		PX_ASSERT(element_size * size > 0);

+		physx::intrinsics::memCopy(copy_dst, copy_src, uint32_t(element_size * size));

+        return;

+    }

+

+    for(int32_t i=0; i < size; ++i)

+    {

+        indexes[level] = i;

+        recursiveCopy(src, src_sizes, dst, dst_sizes, dimension, element_size, indexes, level + 1);

+    }

+}

+

+ErrorType NvParameters::getParamU8Array(const Handle &handle, uint8_t *array, int32_t n, int32_t offset) const

+{

+	CHECK_HANDLE

+	CHECK_IS_SIMPLE_ARRAY(U8)

+	return(rawGetParamArray<uint8_t>(handle, array, n, offset,this));

+}

+

+ErrorType NvParameters::getParamF64Array(const Handle &handle, double *array, int32_t n, int32_t offset) const

+{

+	CHECK_HANDLE

+	CHECK_IS_SIMPLE_ARRAY(F64)

+	return(rawGetParamArray<double>(handle, array, n, offset,this));

+}

+

+

+

+

+ErrorType NvParameters::rawSetParamBool(const Handle &handle, bool val)

+{

+	return rawSetParam<bool>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamBool(const Handle &handle, bool &val) const

+{

+	return rawGetParam<bool>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamBoolArray(const Handle &handle, bool *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<bool>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamBoolArray(const Handle &handle, const bool *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<bool>(handle,array,n,offset,this);

+}

+

+

+ErrorType NvParameters::rawGetParamString(const Handle &handle, const char *&val) const

+{

+	size_t offset;

+	void *ptr=NULL;

+	getVarPtr(handle, ptr, offset);

+	if ( ptr == NULL )

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_TYPE_NOT_SUPPORTED");

+		return ERROR_TYPE_NOT_SUPPORTED;

+	}

+

+	DummyStringStruct *var = (DummyStringStruct *)(char *)ptr;

+	val = var->buf;

+	return(ERROR_NONE);

+}

+

+ErrorType NvParameters::rawSetParamString(const Handle &handle, const char *val)

+{

+	size_t offset;

+	void *ptr=NULL;

+	getVarPtr(handle, ptr, offset);

+	if(ptr == NULL)

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");

+		return(ERROR_INDEX_OUT_OF_RANGE);

+	}

+

+	DummyStringStruct *var = (DummyStringStruct *)(char *)ptr;

+	if( var->isAllocated )

+	{

+		getTraits()->strfree((char *)var->buf);

+	}

+

+	var->buf = getTraits()->strdup(val);

+	var->isAllocated = true;

+

+	return(ERROR_NONE);

+}

+

+ErrorType NvParameters::rawGetParamEnum(const Handle &handle, const char *&val) const

+{

+	size_t offset;

+	void *ptr=NULL;

+	getVarPtr(handle, ptr, offset);

+	if ( ptr == NULL )

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_TYPE_NOT_SUPPORTED");

+		return ERROR_TYPE_NOT_SUPPORTED;

+	}

+	const char * *var = (const char * *)((char *)ptr);

+	val = *var;

+	return(ERROR_NONE);

+}

+

+ErrorType NvParameters::rawSetParamEnum(const Handle &handle, const char *val)

+{

+	size_t offset;

+	void *ptr=NULL;

+	getVarPtr(handle, ptr, offset);

+	if(ptr == NULL)

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");

+		return(ERROR_INDEX_OUT_OF_RANGE);

+	}

+	const char * *Var = (const char * *)((char *)ptr);

+	*Var = val;

+	return(ERROR_NONE);

+}

+

+ErrorType NvParameters::rawGetParamRef(const Handle &handle, NvParameterized::Interface *&val) const

+{

+	size_t offset;

+	void *ptr=NULL;

+	getVarPtr(handle, ptr, offset);

+	if ( ptr == NULL )

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_TYPE_NOT_SUPPORTED");

+		return ERROR_TYPE_NOT_SUPPORTED;

+	}

+

+	NvParameterized::Interface * *var = (NvParameterized::Interface * *)((char *)ptr);

+	val = *var;

+	return(ERROR_NONE);

+}

+

+ErrorType NvParameters::rawSetParamRef(const Handle &handle, NvParameterized::Interface * val)

+{

+	size_t offset;

+	void *ptr=NULL;

+	getVarPtr(handle, ptr, offset);

+	if(ptr == NULL)

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");

+		return(ERROR_INDEX_OUT_OF_RANGE);

+	}

+

+	NvParameterized::Interface * *Var = (NvParameterized::Interface * *)((char *)ptr);

+	*Var = val;

+	return(ERROR_NONE);

+}

+

+ErrorType NvParameters::rawGetParamI8(const Handle &handle, int8_t &val) const

+{

+	return rawGetParam<int8_t>(handle,val,this);

+}

+

+ErrorType NvParameters::rawSetParamI8(const Handle &handle, int8_t val)

+{

+	return rawSetParam<int8_t>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamI8Array(const Handle &handle, int8_t *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<int8_t>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamI8Array(const Handle &handle, const int8_t *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<int8_t>(handle,array,n,offset,this);

+}

+

+

+ErrorType NvParameters::rawGetParamI16(const Handle &handle, int16_t &val) const

+{

+	return rawGetParam<int16_t>(handle,val,this);

+}

+

+ErrorType NvParameters::rawSetParamI16(const Handle &handle, int16_t val)

+{

+	return rawSetParam<int16_t>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamI16Array(const Handle &handle, int16_t *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<int16_t>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamI16Array(const Handle &handle, const int16_t *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<int16_t>(handle,array,n,offset,this);

+}

+

+

+ErrorType NvParameters::rawGetParamI32(const Handle &handle, int32_t &val) const

+{

+	return rawGetParam<int32_t>(handle,val,this);

+}

+

+ErrorType NvParameters::rawSetParamI32(const Handle &handle, int32_t val)

+{

+	return rawSetParam<int32_t>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamI32Array(const Handle &handle, int32_t *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<int32_t>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamI32Array(const Handle &handle, const int32_t *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<int32_t>(handle,array,n,offset,this);

+}

+

+

+ErrorType NvParameters::rawGetParamI64(const Handle &handle, int64_t &val) const

+{

+	return rawGetParam<int64_t>(handle,val,this);

+}

+

+ErrorType NvParameters::rawSetParamI64(const Handle &handle, int64_t val)

+{

+	return rawSetParam<int64_t>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamI64Array(const Handle &handle, int64_t *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<int64_t>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamI64Array(const Handle &handle, const int64_t *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<int64_t>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawGetParamU8(const Handle &handle, uint8_t &val) const

+{

+	return rawGetParam<uint8_t>(handle,val,this);

+}

+

+ErrorType NvParameters::rawSetParamU8(const Handle &handle, uint8_t val)

+{

+	return rawSetParam<uint8_t>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamU8Array(const Handle &handle, uint8_t *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<uint8_t>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamU8Array(const Handle &handle, const uint8_t *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<uint8_t>(handle,array,n,offset,this);

+}

+

+

+ErrorType NvParameters::rawGetParamU16(const Handle &handle, uint16_t &val) const

+{

+	return rawGetParam<uint16_t>(handle,val,this);

+}

+

+ErrorType NvParameters::rawSetParamU16(const Handle &handle, uint16_t val)

+{

+	return rawSetParam<uint16_t>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamU16Array(const Handle &handle, uint16_t *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<uint16_t>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamU16Array(const Handle &handle, const uint16_t *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<uint16_t>(handle,array,n,offset,this);

+}

+

+

+ErrorType NvParameters::rawGetParamU32(const Handle &handle, uint32_t &val) const

+{

+	return rawGetParam<uint32_t>(handle,val,this);

+}

+

+ErrorType NvParameters::rawSetParamU32(const Handle &handle, uint32_t val)

+{

+	return rawSetParam<uint32_t>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamU32Array(const Handle &handle, uint32_t *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<uint32_t>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamU32Array(const Handle &handle, const uint32_t *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<uint32_t>(handle,array,n,offset,this);

+}

+

+

+ErrorType NvParameters::rawSetParamU64(const Handle &handle, uint64_t val)

+{

+	return rawSetParam<uint64_t>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamU64(const Handle &handle, uint64_t &val) const

+{

+	return rawGetParam<uint64_t>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamU64Array(const Handle &handle, uint64_t *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<uint64_t>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamU64Array(const Handle &handle, const uint64_t *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<uint64_t>(handle,array,n,offset,this);

+}

+

+

+ErrorType NvParameters::rawGetParamF32(const Handle &handle, float &val) const

+{

+	return rawGetParam<float>(handle,val,this);

+}

+

+ErrorType NvParameters::rawSetParamF32(const Handle &handle, float val)

+{

+	return rawSetParam<float>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamF32Array(const Handle &handle, float *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<float>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamF32Array(const Handle &handle, const float *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<float>(handle,array,n,offset,this);

+}

+

+

+ErrorType NvParameters::rawGetParamF64(const Handle &handle, double &val) const

+{

+	return rawGetParam<double>(handle,val,this);

+}

+

+ErrorType NvParameters::rawSetParamF64(const Handle &handle, double val)

+{

+	return rawSetParam<double>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamF64Array(const Handle &handle, double *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<double>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamF64Array(const Handle &handle, const double *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<double>(handle,array,n,offset,this);

+}

+

+

+ErrorType NvParameters::rawSetParamVec2(const Handle &handle,physx::PxVec2 val)

+{

+	return rawSetParam<physx::PxVec2>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamVec2(const Handle &handle,physx::PxVec2 &val) const

+{

+	return rawGetParam<physx::PxVec2>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamVec2Array(const Handle &handle,physx::PxVec2 *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<physx::PxVec2>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamVec2Array(const Handle &handle, const physx::PxVec2 *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<physx::PxVec2>(handle,array,n,offset,this);

+}

+

+

+ErrorType NvParameters::rawSetParamVec3(const Handle &handle,physx::PxVec3 val)

+{

+	return rawSetParam<physx::PxVec3>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamVec3(const Handle &handle,physx::PxVec3 &val) const

+{

+	return rawGetParam<physx::PxVec3>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamVec3Array(const Handle &handle,physx::PxVec3 *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<physx::PxVec3>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamVec3Array(const Handle &handle, const physx::PxVec3 *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<physx::PxVec3>(handle,array,n,offset,this);

+}

+

+

+ErrorType NvParameters::rawSetParamVec4(const Handle &handle,physx::PxVec4 val)

+{

+	return rawSetParam<physx::PxVec4>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamVec4(const Handle &handle,physx::PxVec4 &val) const

+{

+	return rawGetParam<physx::PxVec4>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamVec4Array(const Handle &handle,physx::PxVec4 *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<physx::PxVec4>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamVec4Array(const Handle &handle, const physx::PxVec4 *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<physx::PxVec4>(handle,array,n,offset,this);

+}

+

+

+ErrorType NvParameters::rawSetParamQuat(const Handle &handle,physx::PxQuat val)

+{

+	return rawSetParam<physx::PxQuat>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamQuat(const Handle &handle,physx::PxQuat &val) const

+{

+	return rawGetParam<physx::PxQuat>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamQuatArray(const Handle &handle,physx::PxQuat *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<physx::PxQuat>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamQuatArray(const Handle &handle, const physx::PxQuat *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<physx::PxQuat>(handle,array,n,offset,this);

+}

+

+

+ErrorType NvParameters::rawSetParamMat33(const Handle &handle,physx::PxMat33 val)

+{

+	return rawSetParam<physx::PxMat33>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamMat33(const Handle &handle,physx::PxMat33 &val) const

+{

+	return rawGetParam<physx::PxMat33>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamMat33Array(const Handle &handle,physx::PxMat33 *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<physx::PxMat33>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamMat33Array(const Handle &handle, const physx::PxMat33 *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<physx::PxMat33>(handle,array,n,offset,this);

+}

+

+

+ErrorType NvParameters::rawSetParamMat34Legacy(const Handle &handle, const float (&val)[12])

+{

+	Handle memberHandle(handle);

+

+	size_t tmp;

+	void *ptr = NULL;

+	this->getVarPtr(memberHandle, ptr, tmp);

+	if(ptr == NULL)

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");

+		return(ERROR_INDEX_OUT_OF_RANGE);

+	}

+

+	physx::intrinsics::memCopy(ptr, val, 12 * sizeof(float));

+

+#if APEX_UE4

+	// swap raw-column major

+	swap(static_cast<float*>(ptr)[1], static_cast<float*>(ptr)[3]);

+	swap(static_cast<float*>(ptr)[2], static_cast<float*>(ptr)[6]);

+	swap(static_cast<float*>(ptr)[5], static_cast<float*>(ptr)[7]);

+#endif

+	return(ERROR_NONE);

+}

+

+ErrorType NvParameters::rawGetParamMat34Legacy(const Handle &handle, float (&val)[12]) const

+{

+	Handle memberHandle(handle);

+

+	size_t tmp;

+	void *ptr = NULL;

+	this->getVarPtr(memberHandle, ptr, tmp);

+	if(ptr == NULL)

+	{

+		PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");

+		return(ERROR_INDEX_OUT_OF_RANGE);

+	}

+

+	physx::intrinsics::memCopy(val, ptr, 12 * sizeof(float));

+

+	return(ERROR_NONE);

+}

+

+ErrorType NvParameters::rawGetParamMat34LegacyArray(const Handle &handle, float *array, int32_t n, int32_t offset) const

+{

+	if( n )

+	{

+		Handle memberHandle(handle);

+		NV_ERR_CHECK_RETURN(memberHandle.set(offset * 12));

+

+		size_t tmp;

+		void *ptr = NULL;

+		this->getVarPtr(memberHandle, ptr, tmp);

+		if(ptr == NULL)

+		{

+			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");

+			return(ERROR_INDEX_OUT_OF_RANGE);

+		}

+

+		physx::intrinsics::memCopy(array, ptr, 12 * n * sizeof(float));

+	}

+

+	return(ERROR_NONE);

+}

+

+ErrorType NvParameters::rawSetParamMat34LegacyArray(const Handle &handle, const float *array, int32_t n, int32_t offset)

+{

+	if( n )

+	{

+		Handle memberHandle(handle);

+		NV_ERR_CHECK_RETURN(memberHandle.set(offset * 12));

+

+		size_t tmp;

+		void *ptr = NULL;

+		this->getVarPtr(memberHandle, ptr, tmp);

+		if(ptr == NULL)

+		{

+			PX_ASSERT_WITH_MESSAGE(0, "NVPARAMETERIZED.ERROR_INDEX_OUT_OF_RANGE");

+			return(ERROR_INDEX_OUT_OF_RANGE);

+		}

+

+		for (int32_t i = 0; i < n; ++i)

+		{

+			float* dst = static_cast<float*>(ptr) + 12 * sizeof(float) * i;

+			const float* src = array + 12 * sizeof(float) * i;

+

+			physx::intrinsics::memCopy(dst, src, 12 * sizeof(float));

+#if APEX_UE4

+			swap(dst[1], dst[3]);

+			swap(dst[2], dst[6]);

+			swap(dst[5], dst[7]);

+#endif

+		}

+	}

+

+	return(ERROR_NONE);

+}

+

+ErrorType NvParameters::rawSetParamMat44(const Handle &handle,physx::PxMat44 val)

+{

+	return rawSetParam<physx::PxMat44>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamMat44(const Handle &handle,physx::PxMat44 &val) const

+{

+	return rawGetParam<physx::PxMat44>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamMat44Array(const Handle &handle,physx::PxMat44 *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<physx::PxMat44>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamMat44Array(const Handle &handle, const physx::PxMat44 *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<physx::PxMat44>(handle,array,n,offset,this);

+}

+

+

+ErrorType NvParameters::rawSetParamBounds3(const Handle &handle,physx::PxBounds3 val)

+{

+	return rawSetParam<physx::PxBounds3>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamBounds3(const Handle &handle,physx::PxBounds3 &val) const

+{

+	return rawGetParam<physx::PxBounds3>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamBounds3Array(const Handle &handle,physx::PxBounds3 *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<physx::PxBounds3>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamBounds3Array(const Handle &handle, const physx::PxBounds3 *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<physx::PxBounds3>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamTransform(const Handle &handle,physx::PxTransform val)

+{

+	return rawSetParam<physx::PxTransform>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamTransform(const Handle &handle,physx::PxTransform  &val) const

+{

+	return rawGetParam<physx::PxTransform>(handle,val,this);

+}

+

+ErrorType NvParameters::rawGetParamTransformArray(const Handle &handle,physx::PxTransform *array, int32_t n, int32_t offset) const

+{

+	return rawGetParamArray<physx::PxTransform>(handle,array,n,offset,this);

+}

+

+ErrorType NvParameters::rawSetParamTransformArray(const Handle &handle, const physx::PxTransform *array, int32_t n, int32_t offset)

+{

+	return rawSetParamArray<physx::PxTransform>(handle,array,n,offset,this);

+}

+

+void *NvParameters::getVarPtrHelper(const ParamLookupNode *rootNode, void *paramStruct, const Handle &handle, size_t &offset) const

+{

+	const ParamLookupNode* curNode = rootNode;

+

+	bool hasDynamicArray = false;

+	offset = curNode->offset;

+

+	void *ptr = const_cast<void *>(paramStruct);

+	for(int32_t i = 0; i < handle.numIndexes(); ++i)

+	{

+		int index = handle.index(i);

+

+		if (curNode->type == TYPE_ARRAY)

+		{

+			PX_ASSERT(curNode->numChildren);

+

+			if (curNode->isDynamicArrayRoot)

+			{

+				ptr = ((DummyDynamicArrayStruct*)ptr)->buf;

+				hasDynamicArray = true;

+				if (ptr == NULL)

+				{

+					offset = 0;

+					return 0;

+				}

+			}

+

+			// don't get the next curNode until after we've checked that the "parent" is dynamic

+			curNode = &rootNode[curNode->children[0]];

+

+			size_t localOffset = index * curNode->offset;

+			offset += localOffset;

+			ptr = (char*)ptr + localOffset;

+		}

+		else

+		{

+			PX_ASSERT(index >= 0 && index < curNode->numChildren);

+			curNode = &rootNode[curNode->children[index]];

+			offset += curNode->offset;

+			ptr = (char*)ptr + curNode->offset;

+		}

+	}

+

+	if (hasDynamicArray)

+	{

+		offset = 0;

+	}

+

+	return ptr;

+}

+

+bool NvParameters::checkAlignments() const

+{

+	// support empty, named references

+	if(rootParameterDefinition() == NULL)

+	{

+		return IsAligned(this, 8);

+	}

+

+    Handle constHandle(*this, "");

+	if( !constHandle.isValid() )

+	{

+		return false;

+	}

+

+	return checkAlignments(constHandle);

+}

+

+bool NvParameters::checkAlignments(Handle &param_handle) const

+{

+    const Definition *paramDef = param_handle.parameterDefinition();

+

+	uint32_t align = paramDef->alignment();

+

+	bool isDynamicArray = TYPE_ARRAY == paramDef->type() && !paramDef->arraySizeIsFixed();

+

+	// For dynamic array alignment means alignment of it's first element

+	if( !isDynamicArray )

+	{

+		size_t offset;

+		void *ptr;

+		getVarPtr(param_handle, ptr, offset);

+		if( align > 0 && !IsAligned(ptr, align) )

+		{

+			return false;

+		}

+	}

+

+	switch( paramDef->type() )

+	{

+	case TYPE_STRUCT:

+		{

+			for(int32_t i = 0; i < paramDef->numChildren(); ++i)

+			{

+				param_handle.set(i);

+				if( !checkAlignments(param_handle) )

+				{

+					return false;

+				}

+				param_handle.popIndex();

+			}

+			break;

+		}

+

+	case TYPE_REF:

+		{

+			Interface *refObj;

+			if( ERROR_NONE != param_handle.getParamRef(refObj) )

+			{

+				return false;

+			}

+

+			return 0 == refObj || refObj->checkAlignments();

+		}

+

+	case TYPE_ARRAY:

+		{

+			int32_t size;

+			if( ERROR_NONE != param_handle.getArraySize(size) )

+			{

+				return false;

+			}

+

+			// See comment above

+			if( isDynamicArray && align > 0 && size > 0 )

+			{

+				param_handle.set(0);

+

+				size_t offset;

+				void *ptr;

+				getVarPtr(param_handle, ptr, offset);

+				if( !IsAligned(ptr, align) )

+				{

+					return false;

+				}

+

+				param_handle.popIndex();

+			}

+

+			bool isSimpleType = paramDef->child(0)->isSimpleType();

+

+			// Only check for first 10 elements if simple type

+			size = physx::PxMin(size, isSimpleType ? 10 : INT32_MAX);

+

+			for(int32_t i = 0; i < size; ++i)

+			{

+				param_handle.set(i);

+				if( !checkAlignments(param_handle) )

+				{

+					return false;

+				}

+				param_handle.popIndex();

+			}

+

+			break;

+		}

+	NV_PARAMETRIZED_NO_AGGREGATE_AND_REF_DATATYPE_LABELS

+	default:

+		break;

+    }

+

+    return(true);

+}

+} // namespace NvParameterized

diff --git a/sdk/extensions/import/apexmodules/NvParameterized/src/NvParameterizedTraits.cpp b/sdk/extensions/import/apexmodules/NvParameterized/src/NvParameterizedTraits.cpp
index 0cc8357..f9d58eb 100644..100755
--- a/sdk/extensions/import/apexmodules/NvParameterized/src/NvParameterizedTraits.cpp
+++ b/sdk/extensions/import/apexmodules/NvParameterized/src/NvParameterizedTraits.cpp
@@ -1,363 +1,363 @@
-// 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) 2008-2013 NVIDIA Corporation. All rights reserved.
-
-#include <PsHashMap.h>
-#include <PsHash.h>
-#include <PxAssert.h>
-#include <PsUserAllocated.h>
-
-#include "nvparameterized/NvParameterized.h"
-#include "nvparameterized/NvParameterizedTraits.h"
-#include "NvTraitsInternal.h"
-#include "SerializerCommon.h"
-
-namespace NvParameterized
-{
-
-class DefaultParamConversion: public Conversion
-{
-	Traits *mTraits;
-	RefConversionMode::Enum mRefMode;
-
-	typedef physx::shdfnd::HashMap<const char *, uint32_t, physx::shdfnd::Hash<const char *>, Traits::Allocator> MapName2Ver;
-	MapName2Ver mapName2Ver;
-
-	bool copy(Handle &legacyHandle, Handle &handle)
-	{
-		const Definition *pdLegacy = legacyHandle.parameterDefinition(),
-			*pd = handle.parameterDefinition();
-
-		if( pdLegacy->type() != pd->type() )
-			return true;
-
-		switch( pdLegacy->type() )
-		{
-		case TYPE_STRUCT:
-			for(int32_t i = 0; i < pdLegacy->numChildren(); ++i)
-			{
-				legacyHandle.set(i);
-
-				int32_t j = -1;
-				if( pd->child(pdLegacy->child(i)->name(), j) )
-				{
-					handle.set(j);
-					if( !copy(legacyHandle, handle) )
-					{
-						char longName[128];
-						legacyHandle.getLongName(longName, sizeof(longName));
-						NV_PARAM_TRAITS_WARNING(
-							mTraits,
-							"%s: failed to copy legacy data",
-							longName
-						);
-
-						return false;
-					}
-					handle.popIndex();
-				}
-
-				legacyHandle.popIndex();
-			}
-			break;
-
-		case TYPE_ARRAY:
-			{
-				//FIXME: this is too harsh e.g. we can convert static to dynamic
-				if( pdLegacy->arraySizeIsFixed() != pd->arraySizeIsFixed() )
-					return true;
-
-				int32_t size;
-				if( pdLegacy->arraySizeIsFixed() )
-				{
-					//FIXME: this is too harsh e.g. we may just copy first elements
-					if( pdLegacy->arraySize() != pd->arraySize() )
-						return true;
-
-					size = pd->arraySize();
-				}
-				else
-				{
-					if( ERROR_NONE != legacyHandle.getArraySize(size) )
-						return false;
-
-					handle.resizeArray(size);
-				}
-
-				if( size > 100 && pdLegacy->isSimpleType(false, false) && pdLegacy->type() == pd->type() )
-				{
-					// Large array of simple types, fast path
-
-					switch( pdLegacy->type() )
-					{
-					NV_PARAMETRIZED_NO_MATH_DATATYPE_LABELS
-					NV_PARAMETRIZED_LEGACY_DATATYPE_LABELS
-					default:
-						// Fall to slow path
-						break;
-
-#define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES
-#define NV_PARAMETERIZED_TYPES_NO_STRING_TYPES
-#define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \
-	case TYPE_ ## enum_name: { \
-		c_type *data = (c_type *)mTraits->alloc(sizeof(c_type) * size); \
-		if( ERROR_NONE != legacyHandle.getParam ## type_name ## Array(data, size) ) return false; \
-		if( ERROR_NONE != handle.setParam ## type_name ## Array(data, size) ) return false; \
-		mTraits->free(data); \
-		break; \
-	}
-#include "nvparameterized/NvParameterized_types.h"
-
-					}
-				}
-
-				// Slow path for arrays of aggregates, including TYPE_MAT34
-
-				for(int32_t i = 0; i < size; ++i)
-				{
-					legacyHandle.set(i);
-					handle.set(i);
-
-					copy(legacyHandle, handle);
-
-					handle.popIndex();
-					legacyHandle.popIndex();
-				}
-
-				break;
-			}
-
-		case TYPE_REF:
-			{
-				Interface *legacyRefObj;
-				legacyHandle.getParamRef(legacyRefObj);
-
-				// Skip references which have unsupported classes (keep default version)
-				if( legacyRefObj && -1 == handle.parameterDefinition()->refVariantValIndex(legacyRefObj->className()) )
-					return true;
-
-				Interface *refObj;
-				handle.getParamRef(refObj);
-
-				switch( mRefMode )
-				{
-				case RefConversionMode::REF_CONVERT_LAST:
-				default:
-					DEBUG_ALWAYS_ASSERT();
-					break;
-
-				case RefConversionMode::REF_CONVERT_SKIP:
-					break;
-
-				case RefConversionMode::REF_CONVERT_COPY:
-					{
-						// TODO: check that this class is allowed in new version?
-
-						// Update to preferred version if necessary
-						if( legacyRefObj && pdLegacy->isIncludedRef() )
-						{
-							const char *className = legacyRefObj->className();
-
-							const MapName2Ver::Entry *e = mapName2Ver.find(pd->longName());
-							if( e )
-							{
-								uint32_t prefVer = e->second,
-									curVer = legacyRefObj->version();
-
-								if( curVer > prefVer )
-								{
-									NV_PARAM_TRAITS_WARNING(
-										mTraits,
-										"Unable to upgrade included reference of class %s, "
-											"actual version (%u) is higher than preferred version (%u), "
-											"your conversion may not work properly",
-										className,
-										(unsigned)curVer,
-										(unsigned)prefVer
-									);
-									DEBUG_ALWAYS_ASSERT();
-									return false;
-								}
-								else if( curVer < prefVer )
-								{
-									Interface *newLegacyRefObj = mTraits->createNvParameterized(className, prefVer);
-
-									if( !mTraits->updateLegacyNvParameterized(*legacyRefObj, *newLegacyRefObj) )
-									{
-										NV_PARAM_TRAITS_WARNING(
-											mTraits,
-											"Failed to upgrade reference of class %s to version %u",
-											className,
-											(unsigned)prefVer
-										);
-										DEBUG_ALWAYS_ASSERT();
-										newLegacyRefObj->destroy();
-										return false;
-									}
-
-									legacyRefObj->destroy();
-									legacyRefObj = newLegacyRefObj;
-
-									legacyHandle.setParamRef(legacyRefObj);
-								}
-								else
-								{
-									// Object has preferred version => do not do anything
-								}
-							}
-						}
-
-						if( ERROR_NONE != handle.setParamRef(legacyRefObj) )
-							return true;
-
-						if( ERROR_NONE != legacyHandle.setParamRef(0) ) { //Prevent destruction in legacyObj->destroy()
-							handle.setParamRef(0);
-							return false;
-						}
-
-						if( refObj )
-							refObj->destroy();
-
-						return true;
-					}
-
-				case RefConversionMode::REF_CONVERT_UPDATE:
-					{
-						DEBUG_ASSERT( 0 && "This was not used/tested for a long time" );
-						return false;
-
-/*						if( !refObj )
-						{
-							//TODO: do we need to create refObj here?
-							return false;
-						}
-
-						if( 0 != strcmp(legacyRefObj->className(), refObj->className()) )
-						{
-							if( NvParameterized::ERROR_NONE != handle.initParamRef(legacyRefObj->className(), true) )
-								return false;
-
-							if( NvParameterized::ERROR_NONE != handle.getParamRef(refObj) )
-								return false;
-						}
-
-						if( legacyRefObj->version() != refObj->version() )
-							return mTraits->updateLegacyNvParameterized(*legacyRefObj, *refObj);
-
-						//Same version => recursive copy
-
-						Handle refHandle(*refObj, "");
-						DEBUG_ASSERT( refHandle.isValid() );
-
-						Handle legacyRefHandle(*legacyRefObj, "");
-						DEBUG_ASSERT( legacyRefHandle.isValid() );
-
-						return copy(legacyRefHandle, refHandle);*/
-					}
-				} //switch( mRefMode )
-
-				break;
-			}
-
-		case TYPE_POINTER:
-			// do nothing?
-			break;
-
-		case TYPE_ENUM:
-			{
-				const char *val;
-				legacyHandle.getParamEnum(val);
-
-				int32_t valIdx = handle.parameterDefinition()->enumValIndex(val);
-				if(-1 != valIdx)
-				{
-					const char *canonicVal = handle.parameterDefinition()->enumVal(valIdx);
-					if( ERROR_NONE != handle.setParamEnum(canonicVal) )
-					{
-						NV_PARAM_TRAITS_WARNING(
-							mTraits, "Internal error while setting enum value %s", canonicVal ? canonicVal : "" );
-						DEBUG_ALWAYS_ASSERT();
-						return false;
-					}
-				}
-
-				break;
-			}
-
-#		define NV_PARAMETERIZED_TYPES_NO_STRING_TYPES
-#		define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES
-#		define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \
-		case TYPE_##enum_name: { c_type val; legacyHandle.getParam##type_name(val); handle.setParam##type_name(val); break; }
-
-		NV_PARAMETERIZED_TYPE(String, STRING, const char *)
-
-#		include "nvparameterized/NvParameterized_types.h"
-
-		case TYPE_MAT34: { float val[12]; legacyHandle.getParamMat34Legacy(val); handle.setParamMat34Legacy(val); break; }
-
-NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS
-		default:
-			DEBUG_ALWAYS_ASSERT();
-		}
-
-		return true;
-	}
-
-public:
-	DefaultParamConversion(Traits *traits, const PrefVer *prefVers, RefConversionMode::Enum refMode)
-		: mTraits(traits), mRefMode(refMode), mapName2Ver(0, 0.75, Traits::Allocator(traits))
-	{
-		for(; prefVers && prefVers->longName; ++prefVers)
-			mapName2Ver[prefVers->longName] = prefVers->ver;
-	}
-
-	bool operator()(NvParameterized::Interface &legacyObj, NvParameterized::Interface &obj)
-	{
-		obj.initDefaults();
-
-		Handle legacyHandle(legacyObj, "");
-		DEBUG_ASSERT( legacyHandle.isValid() );
-
-		Handle handle(obj, "");
-		DEBUG_ASSERT( handle.isValid() );
-
-		return copy(legacyHandle, handle);
-	}
-
-	void release()
-	{
-		this->~DefaultParamConversion();
-		mTraits->free(this);
-	}
-};
-
-Conversion *internalCreateDefaultConversion(Traits *traits, const PrefVer *prefVers, RefConversionMode::Enum refMode)
-{
-	void *buf = traits->alloc(sizeof(DefaultParamConversion));
-	return PX_PLACEMENT_NEW(buf, DefaultParamConversion)(traits, prefVers, refMode);
-}
-
-}; // end of namespace
+// 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) 2008-2013 NVIDIA Corporation. All rights reserved.

+

+#include <PsHashMap.h>

+#include <PsHash.h>

+#include <PxAssert.h>

+#include <PsUserAllocated.h>

+

+#include "nvparameterized/NvParameterized.h"

+#include "nvparameterized/NvParameterizedTraits.h"

+#include "NvTraitsInternal.h"

+#include "SerializerCommon.h"

+

+namespace NvParameterized

+{

+

+class DefaultParamConversion: public Conversion

+{

+	Traits *mTraits;

+	RefConversionMode::Enum mRefMode;

+

+	typedef physx::shdfnd::HashMap<const char *, uint32_t, physx::shdfnd::Hash<const char *>, Traits::Allocator> MapName2Ver;

+	MapName2Ver mapName2Ver;

+

+	bool copy(Handle &legacyHandle, Handle &handle)

+	{

+		const Definition *pdLegacy = legacyHandle.parameterDefinition(),

+			*pd = handle.parameterDefinition();

+

+		if( pdLegacy->type() != pd->type() )

+			return true;

+

+		switch( pdLegacy->type() )

+		{

+		case TYPE_STRUCT:

+			for(int32_t i = 0; i < pdLegacy->numChildren(); ++i)

+			{

+				legacyHandle.set(i);

+

+				int32_t j = -1;

+				if( pd->child(pdLegacy->child(i)->name(), j) )

+				{

+					handle.set(j);

+					if( !copy(legacyHandle, handle) )

+					{

+						char longName[128];

+						legacyHandle.getLongName(longName, sizeof(longName));

+						NV_PARAM_TRAITS_WARNING(

+							mTraits,

+							"%s: failed to copy legacy data",

+							longName

+						);

+

+						return false;

+					}

+					handle.popIndex();

+				}

+

+				legacyHandle.popIndex();

+			}

+			break;

+

+		case TYPE_ARRAY:

+			{

+				//FIXME: this is too harsh e.g. we can convert static to dynamic

+				if( pdLegacy->arraySizeIsFixed() != pd->arraySizeIsFixed() )

+					return true;

+

+				int32_t size;

+				if( pdLegacy->arraySizeIsFixed() )

+				{

+					//FIXME: this is too harsh e.g. we may just copy first elements

+					if( pdLegacy->arraySize() != pd->arraySize() )

+						return true;

+

+					size = pd->arraySize();

+				}

+				else

+				{

+					if( ERROR_NONE != legacyHandle.getArraySize(size) )

+						return false;

+

+					handle.resizeArray(size);

+				}

+

+				if( size > 100 && pdLegacy->isSimpleType(false, false) && pdLegacy->type() == pd->type() )

+				{

+					// Large array of simple types, fast path

+

+					switch( pdLegacy->type() )

+					{

+					NV_PARAMETRIZED_NO_MATH_DATATYPE_LABELS

+					NV_PARAMETRIZED_LEGACY_DATATYPE_LABELS

+					default:

+						// Fall to slow path

+						break;

+

+#define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES

+#define NV_PARAMETERIZED_TYPES_NO_STRING_TYPES

+#define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \

+	case TYPE_ ## enum_name: { \

+		c_type *data = (c_type *)mTraits->alloc(sizeof(c_type) * size); \

+		if( ERROR_NONE != legacyHandle.getParam ## type_name ## Array(data, size) ) return false; \

+		if( ERROR_NONE != handle.setParam ## type_name ## Array(data, size) ) return false; \

+		mTraits->free(data); \

+		break; \

+	}

+#include "nvparameterized/NvParameterized_types.h"

+

+					}

+				}

+

+				// Slow path for arrays of aggregates, including TYPE_MAT34

+

+				for(int32_t i = 0; i < size; ++i)

+				{

+					legacyHandle.set(i);

+					handle.set(i);

+

+					copy(legacyHandle, handle);

+

+					handle.popIndex();

+					legacyHandle.popIndex();

+				}

+

+				break;

+			}

+

+		case TYPE_REF:

+			{

+				Interface *legacyRefObj;

+				legacyHandle.getParamRef(legacyRefObj);

+

+				// Skip references which have unsupported classes (keep default version)

+				if( legacyRefObj && -1 == handle.parameterDefinition()->refVariantValIndex(legacyRefObj->className()) )

+					return true;

+

+				Interface *refObj;

+				handle.getParamRef(refObj);

+

+				switch( mRefMode )

+				{

+				case RefConversionMode::REF_CONVERT_LAST:

+				default:

+					DEBUG_ALWAYS_ASSERT();

+					break;

+

+				case RefConversionMode::REF_CONVERT_SKIP:

+					break;

+

+				case RefConversionMode::REF_CONVERT_COPY:

+					{

+						// TODO: check that this class is allowed in new version?

+

+						// Update to preferred version if necessary

+						if( legacyRefObj && pdLegacy->isIncludedRef() )

+						{

+							const char *className = legacyRefObj->className();

+

+							const MapName2Ver::Entry *e = mapName2Ver.find(pd->longName());

+							if( e )

+							{

+								uint32_t prefVer = e->second,

+									curVer = legacyRefObj->version();

+

+								if( curVer > prefVer )

+								{

+									NV_PARAM_TRAITS_WARNING(

+										mTraits,

+										"Unable to upgrade included reference of class %s, "

+											"actual version (%u) is higher than preferred version (%u), "

+											"your conversion may not work properly",

+										className,

+										(unsigned)curVer,

+										(unsigned)prefVer

+									);

+									DEBUG_ALWAYS_ASSERT();

+									return false;

+								}

+								else if( curVer < prefVer )

+								{

+									Interface *newLegacyRefObj = mTraits->createNvParameterized(className, prefVer);

+

+									if( !mTraits->updateLegacyNvParameterized(*legacyRefObj, *newLegacyRefObj) )

+									{

+										NV_PARAM_TRAITS_WARNING(

+											mTraits,

+											"Failed to upgrade reference of class %s to version %u",

+											className,

+											(unsigned)prefVer

+										);

+										DEBUG_ALWAYS_ASSERT();

+										newLegacyRefObj->destroy();

+										return false;

+									}

+

+									legacyRefObj->destroy();

+									legacyRefObj = newLegacyRefObj;

+

+									legacyHandle.setParamRef(legacyRefObj);

+								}

+								else

+								{

+									// Object has preferred version => do not do anything

+								}

+							}

+						}

+

+						if( ERROR_NONE != handle.setParamRef(legacyRefObj) )

+							return true;

+

+						if( ERROR_NONE != legacyHandle.setParamRef(0) ) { //Prevent destruction in legacyObj->destroy()

+							handle.setParamRef(0);

+							return false;

+						}

+

+						if( refObj )

+							refObj->destroy();

+

+						return true;

+					}

+

+				case RefConversionMode::REF_CONVERT_UPDATE:

+					{

+						DEBUG_ASSERT( 0 && "This was not used/tested for a long time" );

+						return false;

+

+/*						if( !refObj )

+						{

+							//TODO: do we need to create refObj here?

+							return false;

+						}

+

+						if( 0 != strcmp(legacyRefObj->className(), refObj->className()) )

+						{

+							if( NvParameterized::ERROR_NONE != handle.initParamRef(legacyRefObj->className(), true) )

+								return false;

+

+							if( NvParameterized::ERROR_NONE != handle.getParamRef(refObj) )

+								return false;

+						}

+

+						if( legacyRefObj->version() != refObj->version() )

+							return mTraits->updateLegacyNvParameterized(*legacyRefObj, *refObj);

+

+						//Same version => recursive copy

+

+						Handle refHandle(*refObj, "");

+						DEBUG_ASSERT( refHandle.isValid() );

+

+						Handle legacyRefHandle(*legacyRefObj, "");

+						DEBUG_ASSERT( legacyRefHandle.isValid() );

+

+						return copy(legacyRefHandle, refHandle);*/

+					}

+				} //switch( mRefMode )

+

+				break;

+			}

+

+		case TYPE_POINTER:

+			// do nothing?

+			break;

+

+		case TYPE_ENUM:

+			{

+				const char *val;

+				legacyHandle.getParamEnum(val);

+

+				int32_t valIdx = handle.parameterDefinition()->enumValIndex(val);

+				if(-1 != valIdx)

+				{

+					const char *canonicVal = handle.parameterDefinition()->enumVal(valIdx);

+					if( ERROR_NONE != handle.setParamEnum(canonicVal) )

+					{

+						NV_PARAM_TRAITS_WARNING(

+							mTraits, "Internal error while setting enum value %s", canonicVal ? canonicVal : "" );

+						DEBUG_ALWAYS_ASSERT();

+						return false;

+					}

+				}

+

+				break;

+			}

+

+#		define NV_PARAMETERIZED_TYPES_NO_STRING_TYPES

+#		define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES

+#		define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \

+		case TYPE_##enum_name: { c_type val; legacyHandle.getParam##type_name(val); handle.setParam##type_name(val); break; }

+

+		NV_PARAMETERIZED_TYPE(String, STRING, const char *)

+

+#		include "nvparameterized/NvParameterized_types.h"

+

+		case TYPE_MAT34: { float val[12]; legacyHandle.getParamMat34Legacy(val); handle.setParamMat34Legacy(val); break; }

+

+NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS

+		default:

+			DEBUG_ALWAYS_ASSERT();

+		}

+

+		return true;

+	}

+

+public:

+	DefaultParamConversion(Traits *traits, const PrefVer *prefVers, RefConversionMode::Enum refMode)

+		: mTraits(traits), mRefMode(refMode), mapName2Ver(0, 0.75, Traits::Allocator(traits))

+	{

+		for(; prefVers && prefVers->longName; ++prefVers)

+			mapName2Ver[prefVers->longName] = prefVers->ver;

+	}

+

+	bool operator()(NvParameterized::Interface &legacyObj, NvParameterized::Interface &obj)

+	{

+		obj.initDefaults();

+

+		Handle legacyHandle(legacyObj, "");

+		DEBUG_ASSERT( legacyHandle.isValid() );

+

+		Handle handle(obj, "");

+		DEBUG_ASSERT( handle.isValid() );

+

+		return copy(legacyHandle, handle);

+	}

+

+	void release()

+	{

+		this->~DefaultParamConversion();

+		mTraits->free(this);

+	}

+};

+

+Conversion *internalCreateDefaultConversion(Traits *traits, const PrefVer *prefVers, RefConversionMode::Enum refMode)

+{

+	void *buf = traits->alloc(sizeof(DefaultParamConversion));

+	return PX_PLACEMENT_NEW(buf, DefaultParamConversion)(traits, prefVers, refMode);

+}

+

+}; // end of namespace

diff --git a/sdk/extensions/import/apexmodules/NvParameterized/src/NvSerializer.cpp b/sdk/extensions/import/apexmodules/NvParameterized/src/NvSerializer.cpp
index 0101798..6e2a423 100644..100755
--- a/sdk/extensions/import/apexmodules/NvParameterized/src/NvSerializer.cpp
+++ b/sdk/extensions/import/apexmodules/NvParameterized/src/NvSerializer.cpp
@@ -1,386 +1,386 @@
-// 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) 2008-2013 NVIDIA Corporation. All rights reserved.
-
-/*!
-\file
-\brief NvParameterized serializer implementation
-*/
-
-#include <string.h>
-#include <ctype.h>
-#include <new> // for placement new
-
-#include "PxSimpleTypes.h"
-
-#include "nvparameterized/NvSerializer.h"
-#include "XmlSerializer.h"
-#include "BinSerializer.h"
-#include "nvparameterized/NvParameterizedTraits.h"
-
-namespace
-{
-	static bool isInitialized = false;
-	static NvParameterized::SerializePlatform platform;
-}
-
-namespace NvParameterized
-{
-
-const SerializePlatform &GetCurrentPlatform()
-{
-	if( isInitialized )
-		return platform;
-
-	platform.osVer = SerializePlatform::ANY_VERSION; //Do we need this at all???
-
-	//Determine compiler
-#	if PX_PS4 == 1
-		platform.compilerType = SerializePlatform::COMP_GCC;
-		platform.compilerVer = SerializePlatform::ANY_VERSION;
-#	elif PX_VC != 0
-		platform.compilerType = SerializePlatform::COMP_VC;
-		platform.compilerVer = _MSC_VER;
-#	elif PX_XBOXONE == 1
-		platform.compilerType = SerializePlatform::COMP_VC;
-		platform.compilerVer = _MSC_VER;
-#	elif PX_GCC_FAMILY == 1
-		platform.compilerType =SerializePlatform:: COMP_GCC;
-		platform.compilerVer = (__GNUC__ << 16) + __GNUC_MINOR__;
-#	elif PX_CW == 1
-		platform.compilerType = SerializePlatform::COMP_MW;
-#		error "TODO: define version of Metrowerks compiler"
-#	else
-#		error "Unknown compiler"
-#	endif
-
-	//Determine OS
-#	if PX_WINDOWS_FAMILY == 1
-		platform.osType = SerializePlatform::OS_WINDOWS;
-#	elif PX_APPLE_FAMILY == 1
-		platform.osType = SerializePlatform::OS_MACOSX;
-#	elif PX_PS3 == 1
-		platform.osType = SerializePlatform::OS_LV2;
-#	elif PX_X360 == 1
-		platform.osType = SerializePlatform::OS_XBOX;
-		platform.osVer = _XBOX_VER;
-#	elif PX_XBOXONE == 1
-		platform.osType = SerializePlatform::OS_XBOXONE;
-#	elif PX_PS4 == 1
-		platform.osType = SerializePlatform::OS_PS4;
-#	elif PX_ANDROID == 1
-		platform.osType = SerializePlatform::OS_ANDROID;
-#	elif PX_LINUX == 1
-		platform.osType = SerializePlatform::OS_LINUX;
-#	elif PX_SWITCH == 1
-		platform.osType = SerializePlatform::OS_HOS;		
-#	else
-#		error "Undefined OS"
-#	endif
-
-	//Determine arch
-#	if PX_X86 == 1
-		platform.archType = SerializePlatform::ARCH_X86;
-#	elif PX_APPLE_FAMILY == 1
-		platform.archType = SerializePlatform::ARCH_X86;
-#	elif PX_X64 == 1
-		platform.archType = SerializePlatform::ARCH_X86_64;
-#	elif PX_PPC == 1
-		platform.archType = SerializePlatform::ARCH_PPC;
-#	elif PX_PS3 == 1
-		platform.archType = SerializePlatform::ARCH_CELL;
-#	elif PX_ARM == 1
-		platform.archType = SerializePlatform::ARCH_ARM;
-#	elif PX_A64 == 1
-		platform.archType = SerializePlatform::ARCH_ARM_64;		
-#	else
-#		error "Unknown architecture"
-#	endif
-
-	isInitialized = true;
-	return platform;
-}
-
-bool GetPlatform(const char *name, SerializePlatform &platform_)
-{
-	platform_.osVer = platform_.compilerVer = SerializePlatform::ANY_VERSION;
-
-	if( 0 == strcmp("VcXbox", name) || 0 == strcmp("VcXbox360", name))
-	{
-		platform_.archType = SerializePlatform::ARCH_PPC;
-		platform_.compilerType = SerializePlatform::COMP_VC;
-		platform_.osType = SerializePlatform::OS_XBOX;
-	}
-	else if( 0 == strcmp("VcXboxOne", name) )
-	{
-		platform_.archType = SerializePlatform::ARCH_X86_64;
-		platform_.compilerType = SerializePlatform::COMP_VC;
-		platform_.osType = SerializePlatform::OS_XBOXONE;
-	}
-	else if( 0 == strcmp("GccPs4", name) )
-	{
-		platform_.archType = SerializePlatform::ARCH_X86_64;
-		platform_.compilerType = SerializePlatform::COMP_GCC;
-		platform_.osType = SerializePlatform::OS_PS4;
-	}
-	else if( 0 == strcmp("VcWin32", name) )
-	{
-		platform_.archType = SerializePlatform::ARCH_X86;
-		platform_.compilerType = SerializePlatform::COMP_VC;
-		platform_.osType = SerializePlatform::OS_WINDOWS;
-	}
-	else if( 0 == strcmp("VcWin64", name) )
-	{
-		platform_.archType = SerializePlatform::ARCH_X86_64;
-		platform_.compilerType = SerializePlatform::COMP_VC;
-		platform_.osType = SerializePlatform::OS_WINDOWS;
-	}
-	else if( 0 == strcmp("GccPs3", name) )
-	{
-		platform_.archType = SerializePlatform::ARCH_CELL;
-		platform_.compilerType = SerializePlatform::COMP_GCC;
-		platform_.osType = SerializePlatform::OS_LV2;
-	}
-	else if( 0 == strcmp("GccOsX32", name) )
-	{
-		platform_.archType = SerializePlatform::ARCH_X86;
-		platform_.compilerType = SerializePlatform::COMP_GCC;
-		platform_.osType = SerializePlatform::OS_MACOSX;
-	}
-	else if( 0 == strcmp("GccOsX64", name) )
-	{
-		platform_.archType = SerializePlatform::ARCH_X86_64;
-		platform_.compilerType = SerializePlatform::COMP_GCC;
-		platform_.osType = SerializePlatform::OS_MACOSX;
-	}
-	else if( 0 == strcmp("AndroidARM", name) )
-	{
-		platform_.archType = SerializePlatform::ARCH_ARM;
-		platform_.compilerType = SerializePlatform::COMP_GCC;
-		platform_.osType = SerializePlatform::OS_ANDROID;
-	}
-	else if (0 == strcmp("HOSARM32", name))
-	{
-		platform_.archType = SerializePlatform::ARCH_ARM;
-		platform_.compilerType = SerializePlatform::COMP_GCC;
-		platform_.osType = SerializePlatform::OS_HOS;
-	}
-	else if (0 == strcmp("HOSARM64", name))
-	{
-		platform_.archType = SerializePlatform::ARCH_ARM_64;
-		platform_.compilerType = SerializePlatform::COMP_GCC;
-		platform_.osType = SerializePlatform::OS_HOS;
-	}	
-	else if( 0 == strcmp("GccLinux32", name) )
-	{
-		platform_.archType = SerializePlatform::ARCH_X86;
-		platform_.compilerType = SerializePlatform::COMP_GCC;
-		platform_.osType = SerializePlatform::OS_LINUX;
-	}
-	else if( 0 == strcmp("GccLinux64", name) )
-	{
-		platform_.archType = SerializePlatform::ARCH_X86_64;
-		platform_.compilerType = SerializePlatform::COMP_GCC;
-		platform_.osType = SerializePlatform::OS_LINUX;
-	}
-	else if( 0 == strcmp("Pib", name) ) //Abstract platform for platform-independent serialization
-	{
-		platform_.archType = SerializePlatform::ARCH_GEN;
-		platform_.compilerType = SerializePlatform::COMP_GEN;
-		platform_.osType = SerializePlatform::OS_GEN;
-	}
-	else
-		return false;
-
-	return true;
-}
-
-const char *GetPlatformName(const SerializePlatform &platform_)
-{
-	static const char *unknown = "<Unknown>";
-
-	switch(platform_.osType )
-	{
-	case SerializePlatform::OS_XBOX:
-		return SerializePlatform::COMP_VC == platform_.compilerType
-			? "VcXbox360" : unknown;
-
-	case SerializePlatform::OS_XBOXONE:
-		return SerializePlatform::COMP_VC == platform_.compilerType
-			? "VcXboxOne" : unknown;
-
-	case SerializePlatform::OS_PS4:
-		return SerializePlatform::COMP_GCC == platform_.compilerType
-			? "GccPs4" : unknown;
-
-	case SerializePlatform::OS_WINDOWS:
-		if( SerializePlatform::COMP_VC != platform_.compilerType )
-			return unknown;
-
-		switch(platform_.archType )
-		{
-		case SerializePlatform::ARCH_X86:
-			return "VcWin32";
-
-		case SerializePlatform::ARCH_X86_64:
-			return "VcWin64";
-
-		case SerializePlatform::ARCH_GEN:
-		case SerializePlatform::ARCH_PPC:
-		case SerializePlatform::ARCH_CELL:
-		case SerializePlatform::ARCH_ARM:
-		case SerializePlatform::ARCH_LAST:
-		default:
-			return unknown;
-		}
-
-	case SerializePlatform::OS_MACOSX:
-			if( SerializePlatform::COMP_GCC != platform_.compilerType )
-				return unknown;
-
-			switch( platform_.archType )
-		{
-			case SerializePlatform::ARCH_X86:
-				return "GccOsX32";
-
-			case SerializePlatform::ARCH_X86_64:
-				return "GccOsX64";
-
-			default:
-				return unknown;
-		}
-
-	case SerializePlatform::OS_LV2:
-		return SerializePlatform::COMP_GCC == platform_.compilerType
-			? "GccPs3" : unknown;
-
-	case SerializePlatform::OS_GEN:
-		return "Pib";
-
-	case SerializePlatform::OS_ANDROID:
-		return SerializePlatform::ARCH_ARM == platform_.archType
-			? "AndroidARM" : 0;
-
-	case SerializePlatform::OS_LINUX:
-		if( SerializePlatform::COMP_GCC != platform_.compilerType )
-			return unknown;
-
-		switch(platform_.archType )
-		{
-		case SerializePlatform::ARCH_X86:
-			return "GccLinux32";
-
-		case SerializePlatform::ARCH_X86_64:
-			return "GccLinux64";
-
-		case SerializePlatform::ARCH_GEN:
-		case SerializePlatform::ARCH_PPC:
-		case SerializePlatform::ARCH_CELL:
-		case SerializePlatform::ARCH_ARM:
-		case SerializePlatform::ARCH_LAST:
-		default:
-			return unknown;
-		}
-
-	case SerializePlatform::OS_HOS:
-		switch (platform.archType)
-		{
-		case SerializePlatform::ARCH_ARM:
-			return "HOSARM32";
-		case SerializePlatform::ARCH_ARM_64:
-			return "HOSARM64";
-
-		default:
-			return unknown;
-		}
-
-	case SerializePlatform::OS_LAST:
-	default:
-		return unknown;
-	}
-}
-
-Serializer *internalCreateSerializer(Serializer::SerializeType type, Traits *traits)
-{
-	switch ( type )
-	{
-		case Serializer::NST_XML:
-			{
-				void *buf = serializerMemAlloc(sizeof(XmlSerializer), traits);
-				return buf ? PX_PLACEMENT_NEW(buf, XmlSerializer)(traits) : 0;
-			}
-		case Serializer::NST_BINARY:
-			{
-				void *buf = serializerMemAlloc(sizeof(BinSerializer), traits);
-				return buf ? PX_PLACEMENT_NEW(buf, BinSerializer)(traits) : 0;
-			}
-		case Serializer::NST_LAST:
-		default:
-			NV_PARAM_TRAITS_WARNING(
-				traits,
-				"Unknown serializer type: %d",
-				(int)type );
-			break;
-	}
-
-	return 0;
-}
-
-Serializer::SerializeType Serializer::peekSerializeType(physx::PxFileBuf &stream)
-{
-	return isBinaryFormat(stream) ? Serializer::NST_BINARY
-		: isXmlFormat(stream) ? Serializer::NST_XML : Serializer::NST_LAST;
-}
-
-Serializer::ErrorType Serializer::peekPlatform(physx::PxFileBuf &stream, SerializePlatform &platform_)
-{
-	if( isBinaryFormat(stream) )
-		return peekBinaryPlatform(stream, platform_);
-	
-	//Xml has no native platform
-	platform_ = GetCurrentPlatform();
-	return Serializer::ERROR_NONE;
-}
-
-Serializer::ErrorType Serializer::deserializeMetadata(physx::PxFileBuf & /*stream*/, DeserializedMetadata & /*desData*/)
-{
-	//Xml currently does not implement this
-	return Serializer::ERROR_NOT_IMPLEMENTED;
-}
-
-Serializer::ErrorType Serializer::deserialize(physx::PxFileBuf &stream, Serializer::DeserializedData &desData)
-{
-	bool tmp;
-	return deserialize(stream, desData, tmp);
-}
-
-Serializer::ErrorType Serializer::deserializeInplace(void *data, uint32_t dataLen, Serializer::DeserializedData &desData)
-{
-	bool tmp;
-	return deserializeInplace(data, dataLen, desData, tmp);
-}
-
-}; // end of namespace
+// 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) 2008-2013 NVIDIA Corporation. All rights reserved.

+

+/*!

+\file

+\brief NvParameterized serializer implementation

+*/

+

+#include <string.h>

+#include <ctype.h>

+#include <new> // for placement new

+

+#include "PxSimpleTypes.h"

+

+#include "nvparameterized/NvSerializer.h"

+#include "XmlSerializer.h"

+#include "BinSerializer.h"

+#include "nvparameterized/NvParameterizedTraits.h"

+

+namespace

+{

+	static bool isInitialized = false;

+	static NvParameterized::SerializePlatform platform;

+}

+

+namespace NvParameterized

+{

+

+const SerializePlatform &GetCurrentPlatform()

+{

+	if( isInitialized )

+		return platform;

+

+	platform.osVer = SerializePlatform::ANY_VERSION; //Do we need this at all???

+

+	//Determine compiler

+#	if PX_PS4 == 1

+		platform.compilerType = SerializePlatform::COMP_GCC;

+		platform.compilerVer = SerializePlatform::ANY_VERSION;

+#	elif PX_VC != 0

+		platform.compilerType = SerializePlatform::COMP_VC;

+		platform.compilerVer = _MSC_VER;

+#	elif PX_XBOXONE == 1

+		platform.compilerType = SerializePlatform::COMP_VC;

+		platform.compilerVer = _MSC_VER;

+#	elif PX_GCC_FAMILY == 1

+		platform.compilerType =SerializePlatform:: COMP_GCC;

+		platform.compilerVer = (__GNUC__ << 16) + __GNUC_MINOR__;

+#	elif PX_CW == 1

+		platform.compilerType = SerializePlatform::COMP_MW;

+#		error "TODO: define version of Metrowerks compiler"

+#	else

+#		error "Unknown compiler"

+#	endif

+

+	//Determine OS

+#	if PX_WINDOWS_FAMILY == 1

+		platform.osType = SerializePlatform::OS_WINDOWS;

+#	elif PX_APPLE_FAMILY == 1

+		platform.osType = SerializePlatform::OS_MACOSX;

+#	elif PX_PS3 == 1

+		platform.osType = SerializePlatform::OS_LV2;

+#	elif PX_X360 == 1

+		platform.osType = SerializePlatform::OS_XBOX;

+		platform.osVer = _XBOX_VER;

+#	elif PX_XBOXONE == 1

+		platform.osType = SerializePlatform::OS_XBOXONE;

+#	elif PX_PS4 == 1

+		platform.osType = SerializePlatform::OS_PS4;

+#	elif PX_ANDROID == 1

+		platform.osType = SerializePlatform::OS_ANDROID;

+#	elif PX_LINUX == 1

+		platform.osType = SerializePlatform::OS_LINUX;

+#	elif PX_SWITCH == 1

+		platform.osType = SerializePlatform::OS_HOS;		

+#	else

+#		error "Undefined OS"

+#	endif

+

+	//Determine arch

+#	if PX_X86 == 1

+		platform.archType = SerializePlatform::ARCH_X86;

+#	elif PX_APPLE_FAMILY == 1

+		platform.archType = SerializePlatform::ARCH_X86;

+#	elif PX_X64 == 1

+		platform.archType = SerializePlatform::ARCH_X86_64;

+#	elif PX_PPC == 1

+		platform.archType = SerializePlatform::ARCH_PPC;

+#	elif PX_PS3 == 1

+		platform.archType = SerializePlatform::ARCH_CELL;

+#	elif PX_ARM == 1

+		platform.archType = SerializePlatform::ARCH_ARM;

+#	elif PX_A64 == 1

+		platform.archType = SerializePlatform::ARCH_ARM_64;		

+#	else

+#		error "Unknown architecture"

+#	endif

+

+	isInitialized = true;

+	return platform;

+}

+

+bool GetPlatform(const char *name, SerializePlatform &platform_)

+{

+	platform_.osVer = platform_.compilerVer = SerializePlatform::ANY_VERSION;

+

+	if( 0 == strcmp("VcXbox", name) || 0 == strcmp("VcXbox360", name))

+	{

+		platform_.archType = SerializePlatform::ARCH_PPC;

+		platform_.compilerType = SerializePlatform::COMP_VC;

+		platform_.osType = SerializePlatform::OS_XBOX;

+	}

+	else if( 0 == strcmp("VcXboxOne", name) )

+	{

+		platform_.archType = SerializePlatform::ARCH_X86_64;

+		platform_.compilerType = SerializePlatform::COMP_VC;

+		platform_.osType = SerializePlatform::OS_XBOXONE;

+	}

+	else if( 0 == strcmp("GccPs4", name) )

+	{

+		platform_.archType = SerializePlatform::ARCH_X86_64;

+		platform_.compilerType = SerializePlatform::COMP_GCC;

+		platform_.osType = SerializePlatform::OS_PS4;

+	}

+	else if( 0 == strcmp("VcWin32", name) )

+	{

+		platform_.archType = SerializePlatform::ARCH_X86;

+		platform_.compilerType = SerializePlatform::COMP_VC;

+		platform_.osType = SerializePlatform::OS_WINDOWS;

+	}

+	else if( 0 == strcmp("VcWin64", name) )

+	{

+		platform_.archType = SerializePlatform::ARCH_X86_64;

+		platform_.compilerType = SerializePlatform::COMP_VC;

+		platform_.osType = SerializePlatform::OS_WINDOWS;

+	}

+	else if( 0 == strcmp("GccPs3", name) )

+	{

+		platform_.archType = SerializePlatform::ARCH_CELL;

+		platform_.compilerType = SerializePlatform::COMP_GCC;

+		platform_.osType = SerializePlatform::OS_LV2;

+	}

+	else if( 0 == strcmp("GccOsX32", name) )

+	{

+		platform_.archType = SerializePlatform::ARCH_X86;

+		platform_.compilerType = SerializePlatform::COMP_GCC;

+		platform_.osType = SerializePlatform::OS_MACOSX;

+	}

+	else if( 0 == strcmp("GccOsX64", name) )

+	{

+		platform_.archType = SerializePlatform::ARCH_X86_64;

+		platform_.compilerType = SerializePlatform::COMP_GCC;

+		platform_.osType = SerializePlatform::OS_MACOSX;

+	}

+	else if( 0 == strcmp("AndroidARM", name) )

+	{

+		platform_.archType = SerializePlatform::ARCH_ARM;

+		platform_.compilerType = SerializePlatform::COMP_GCC;

+		platform_.osType = SerializePlatform::OS_ANDROID;

+	}

+	else if (0 == strcmp("HOSARM32", name))

+	{

+		platform_.archType = SerializePlatform::ARCH_ARM;

+		platform_.compilerType = SerializePlatform::COMP_GCC;

+		platform_.osType = SerializePlatform::OS_HOS;

+	}

+	else if (0 == strcmp("HOSARM64", name))

+	{

+		platform_.archType = SerializePlatform::ARCH_ARM_64;

+		platform_.compilerType = SerializePlatform::COMP_GCC;

+		platform_.osType = SerializePlatform::OS_HOS;

+	}	

+	else if( 0 == strcmp("GccLinux32", name) )

+	{

+		platform_.archType = SerializePlatform::ARCH_X86;

+		platform_.compilerType = SerializePlatform::COMP_GCC;

+		platform_.osType = SerializePlatform::OS_LINUX;

+	}

+	else if( 0 == strcmp("GccLinux64", name) )

+	{

+		platform_.archType = SerializePlatform::ARCH_X86_64;

+		platform_.compilerType = SerializePlatform::COMP_GCC;

+		platform_.osType = SerializePlatform::OS_LINUX;

+	}

+	else if( 0 == strcmp("Pib", name) ) //Abstract platform for platform-independent serialization

+	{

+		platform_.archType = SerializePlatform::ARCH_GEN;

+		platform_.compilerType = SerializePlatform::COMP_GEN;

+		platform_.osType = SerializePlatform::OS_GEN;

+	}

+	else

+		return false;

+

+	return true;

+}

+

+const char *GetPlatformName(const SerializePlatform &platform_)

+{

+	static const char *unknown = "<Unknown>";

+

+	switch(platform_.osType )

+	{

+	case SerializePlatform::OS_XBOX:

+		return SerializePlatform::COMP_VC == platform_.compilerType

+			? "VcXbox360" : unknown;

+

+	case SerializePlatform::OS_XBOXONE:

+		return SerializePlatform::COMP_VC == platform_.compilerType

+			? "VcXboxOne" : unknown;

+

+	case SerializePlatform::OS_PS4:

+		return SerializePlatform::COMP_GCC == platform_.compilerType

+			? "GccPs4" : unknown;

+

+	case SerializePlatform::OS_WINDOWS:

+		if( SerializePlatform::COMP_VC != platform_.compilerType )

+			return unknown;

+

+		switch(platform_.archType )

+		{

+		case SerializePlatform::ARCH_X86:

+			return "VcWin32";

+

+		case SerializePlatform::ARCH_X86_64:

+			return "VcWin64";

+

+		case SerializePlatform::ARCH_GEN:

+		case SerializePlatform::ARCH_PPC:

+		case SerializePlatform::ARCH_CELL:

+		case SerializePlatform::ARCH_ARM:

+		case SerializePlatform::ARCH_LAST:

+		default:

+			return unknown;

+		}

+

+	case SerializePlatform::OS_MACOSX:

+			if( SerializePlatform::COMP_GCC != platform_.compilerType )

+				return unknown;

+

+			switch( platform_.archType )

+		{

+			case SerializePlatform::ARCH_X86:

+				return "GccOsX32";

+

+			case SerializePlatform::ARCH_X86_64:

+				return "GccOsX64";

+

+			default:

+				return unknown;

+		}

+

+	case SerializePlatform::OS_LV2:

+		return SerializePlatform::COMP_GCC == platform_.compilerType

+			? "GccPs3" : unknown;

+

+	case SerializePlatform::OS_GEN:

+		return "Pib";

+

+	case SerializePlatform::OS_ANDROID:

+		return SerializePlatform::ARCH_ARM == platform_.archType

+			? "AndroidARM" : 0;

+

+	case SerializePlatform::OS_LINUX:

+		if( SerializePlatform::COMP_GCC != platform_.compilerType )

+			return unknown;

+

+		switch(platform_.archType )

+		{

+		case SerializePlatform::ARCH_X86:

+			return "GccLinux32";

+

+		case SerializePlatform::ARCH_X86_64:

+			return "GccLinux64";

+

+		case SerializePlatform::ARCH_GEN:

+		case SerializePlatform::ARCH_PPC:

+		case SerializePlatform::ARCH_CELL:

+		case SerializePlatform::ARCH_ARM:

+		case SerializePlatform::ARCH_LAST:

+		default:

+			return unknown;

+		}

+

+	case SerializePlatform::OS_HOS:

+		switch (platform.archType)

+		{

+		case SerializePlatform::ARCH_ARM:

+			return "HOSARM32";

+		case SerializePlatform::ARCH_ARM_64:

+			return "HOSARM64";

+

+		default:

+			return unknown;

+		}

+

+	case SerializePlatform::OS_LAST:

+	default:

+		return unknown;

+	}

+}

+

+Serializer *internalCreateSerializer(Serializer::SerializeType type, Traits *traits)

+{

+	switch ( type )

+	{

+		case Serializer::NST_XML:

+			{

+				void *buf = serializerMemAlloc(sizeof(XmlSerializer), traits);

+				return buf ? PX_PLACEMENT_NEW(buf, XmlSerializer)(traits) : 0;

+			}

+		case Serializer::NST_BINARY:

+			{

+				void *buf = serializerMemAlloc(sizeof(BinSerializer), traits);

+				return buf ? PX_PLACEMENT_NEW(buf, BinSerializer)(traits) : 0;

+			}

+		case Serializer::NST_LAST:

+		default:

+			NV_PARAM_TRAITS_WARNING(

+				traits,

+				"Unknown serializer type: %d",

+				(int)type );

+			break;

+	}

+

+	return 0;

+}

+

+Serializer::SerializeType Serializer::peekSerializeType(physx::PxFileBuf &stream)

+{

+	return isBinaryFormat(stream) ? Serializer::NST_BINARY

+		: isXmlFormat(stream) ? Serializer::NST_XML : Serializer::NST_LAST;

+}

+

+Serializer::ErrorType Serializer::peekPlatform(physx::PxFileBuf &stream, SerializePlatform &platform_)

+{

+	if( isBinaryFormat(stream) )

+		return peekBinaryPlatform(stream, platform_);

+	

+	//Xml has no native platform

+	platform_ = GetCurrentPlatform();

+	return Serializer::ERROR_NONE;

+}

+

+Serializer::ErrorType Serializer::deserializeMetadata(physx::PxFileBuf & /*stream*/, DeserializedMetadata & /*desData*/)

+{

+	//Xml currently does not implement this

+	return Serializer::ERROR_NOT_IMPLEMENTED;

+}

+

+Serializer::ErrorType Serializer::deserialize(physx::PxFileBuf &stream, Serializer::DeserializedData &desData)

+{

+	bool tmp;

+	return deserialize(stream, desData, tmp);

+}

+

+Serializer::ErrorType Serializer::deserializeInplace(void *data, uint32_t dataLen, Serializer::DeserializedData &desData)

+{

+	bool tmp;

+	return deserializeInplace(data, dataLen, desData, tmp);

+}

+

+}; // end of namespace

diff --git a/sdk/extensions/import/apexmodules/NvParameterized/src/NvTraits.cpp b/sdk/extensions/import/apexmodules/NvParameterized/src/NvTraits.cpp
index f1983a1..b340c8e 100644..100755
--- a/sdk/extensions/import/apexmodules/NvParameterized/src/NvTraits.cpp
+++ b/sdk/extensions/import/apexmodules/NvParameterized/src/NvTraits.cpp
@@ -1,446 +1,446 @@
-#include "NvTraits.h"
-#include "nvparameterized/NvParameterizedTraits.h"
-#include "PsUserAllocated.h"
-#include "PsArray.h"
-#include "PsAtomic.h"
-#include "PsAlignedMalloc.h"
-#include "PxFoundation.h"
-#include "PxErrorCallback.h"
-#include "PsString.h"
-
-#define ALIGNED_ALLOC(n, align) physx::shdfnd::AlignedAllocator<align>().allocate(n, __FILE__, __LINE__)
-
-// Does not depend on alignment in AlignedAllocator
-#define ALIGNED_FREE(p) physx::shdfnd::AlignedAllocator<16>().deallocate(p)
-
-
-namespace NvParameterized
-{
-
-class NvTraits : public Traits, public physx::shdfnd::UserAllocated
-{
-public:
-	NvTraits(void)
-	{
-
-	}
-
-	virtual ~NvTraits(void)
-	{
-	}
-
-	virtual void release(void)
-	{
-		delete this;
-	}
-
-	/**
-	\brief Register NvParameterized class factory
-	*/
-	virtual void registerFactory( ::NvParameterized::Factory & factory ) 
-	{
-		bool ok = true;
-
-		for (uint32_t i=0; i<mFactories.size(); ++i)
-		{
-			Factory *f = mFactories[i];
-			if ( f == &factory )
-			{
-				ok = false;
-				traitsWarn("Factory already registered.");
-				break;
-			}
-			if ( strcmp(f->getClassName(),factory.getClassName()) == 0 && f->getVersion() == factory.getVersion() )
-			{
-				ok = false;
-				traitsWarn("factory with this name and version already registered.");
-				break;
-			}
-		}
-		if ( ok )
-		{
-			mFactories.pushBack(&factory);
-		}
-	}
-
-	/**
-	\brief Remove NvParameterized class factory for current version of class
-	\return Removed factory or NULL if it is not found
-	*/
-	virtual ::NvParameterized::Factory *removeFactory( const char * className ) 
-	{
-		NvParameterized::Factory *f = NULL;
-		uint32_t index=0;
-		uint32_t maxVersion = 0;
-		for (uint32_t i=0; i<mFactories.size(); i++)
-		{
-			if ( strcmp(mFactories[i]->getClassName(),className) == 0 )
-			{
-				if ( mFactories[i]->getVersion() >= maxVersion )
-				{
-					f = mFactories[i];
-					maxVersion = f->getVersion();
-					index = i;
-				}
-			}
-		}
-		if ( f )
-		{
-			mFactories.remove(index);
-		}
-		else
-		{
-			traitsWarn("Unable to remove factory.");
-		}
-		return f;
-	}
-
-	/**
-	\brief Remove NvParameterized class factory for given version of class
-	\return Removed factory or NULL if it is not found
-	*/
-	virtual ::NvParameterized::Factory *removeFactory( const char * className, uint32_t version ) 
-	{
-		Factory *f = NULL;
-		for (uint32_t i=0; i<mFactories.size(); ++i)
-		{
-			if ( strcmp(mFactories[i]->getClassName(),className) == 0 && mFactories[i]->getVersion() == version )
-			{
-				f = mFactories[i];
-				mFactories.remove(i);
-				break;
-			}
-		}
-		if ( !f )
-		{
-			traitsWarn("Unable to remove factory, not found");
-		}
-		return f;
-	}
-
-	/**
-	\brief Checks whether any class factory is registered
-	*/
-	virtual bool doesFactoryExist(const char* className) 
-	{
-		bool ret = false;
-		for (uint32_t i=0; i<mFactories.size(); ++i)
-		{
-			if ( strcmp(mFactories[i]->getClassName(),className) == 0 )
-			{
-				ret = true;
-				break;
-			}
-		}
-		return ret;
-	}
-
-	/**
-	\brief Checks whether class factory for given version is registered
-	*/
-	virtual bool doesFactoryExist(const char* className, uint32_t version) 
-	{
-		bool ret = false;
-		for (uint32_t i=0; i<mFactories.size(); ++i)
-		{
-			if ( strcmp(mFactories[i]->getClassName(),className) == 0 && mFactories[i]->getVersion() == version )
-			{
-				ret = true;
-				break;
-			}
-		}
-		return ret;
-	}
-
-	// Helper method, locate a factory of this name and exact version, of it specific version not being searched for, return the highest registered version number.
-	Factory * locateFactory(const char *className,uint32_t version,bool useVersion) const
-	{
-		NvParameterized::Factory *f = NULL;
-		uint32_t maxVersion = 0;
-		for (uint32_t i=0; i<mFactories.size(); i++)
-		{
-			if ( strcmp(mFactories[i]->getClassName(),className) == 0 )
-			{
-				if ( useVersion )
-				{
-					if ( mFactories[i]->getVersion() == version )
-					{
-						f = mFactories[i];
-					}
-				}
-				else if ( mFactories[i]->getVersion() >= maxVersion )
-				{
-					f = mFactories[i];
-					maxVersion = f->getVersion();
-				}
-			}
-		}
-		return f;
-	}
-
-	/**
-	\brief Create object of NvParameterized class
-	
-	Most probably this just calls Factory::create on appropriate factory.
-	*/
-	virtual ::NvParameterized::Interface * createNvParameterized( const char * name ) 
-	{
-		NvParameterized::Interface *ret = NULL;
-		Factory *f = locateFactory(name,0,false);
-		if ( f )
-		{
-			ret = f->create(this);
-		}
-		return ret;
-	}
-
-	/**
-	\brief Create object of NvParameterized class
-	
-	Most probably this just calls Factory::create on appropriate factory.
-	*/
-	virtual ::NvParameterized::Interface * createNvParameterized( const char * name, uint32_t ver )
-	{
-		NvParameterized::Interface *ret = NULL;
-		Factory *f = locateFactory(name,ver,true);
-		if ( f )
-		{
-			ret = f->create(this);
-		}
-		return ret;
-	}
-
-	/**
-	\brief Finish construction of inplace object of NvParameterized class
-	
-	Most probably this just calls Factory::finish using appropriate factory.
-	*/
-	virtual ::NvParameterized::Interface * finishNvParameterized( const char * name, void *obj, void *buf, int32_t *refCount ) 
-	{
-		Factory *f = locateFactory(name,0,false);
-		return f ? f->finish(this,obj,buf,refCount) : NULL;
-	}
-
-	/**
-	\brief Finish construction of inplace object of NvParameterized class
-	
-	Most probably this just calls Factory::finish using appropriate factory.
-	*/
-	virtual ::NvParameterized::Interface * finishNvParameterized( const char * name, uint32_t ver, void *obj, void *buf, int32_t *refCount ) 
-	{
-		Factory *f = locateFactory(name,ver,true);
-		return f ? f->finish(this,obj,buf,refCount) : NULL;
-	}
-
-	/**
-	\brief Get version of class which is currently used
-	*/
-	virtual uint32_t getCurrentVersion(const char *className) const 
-	{
-		Factory *f = locateFactory(className,0,false);
-		return f ? f->getVersion() : 0;
-	}
-
-	/**
-	\brief Get memory alignment required for objects of class
-	*/
-	virtual uint32_t getAlignment(const char *className, uint32_t classVersion) const 
-	{
-		Factory *f = locateFactory(className,classVersion,true);
-		return f ? f->getAlignment() : 16;
-	}
-
-	/**
-	\brief Register converter for legacy version of class
-	*/
-	virtual void registerConversion(const char * /*className*/, uint32_t /*from*/, uint32_t /*to*/, Conversion & /*conv*/) 
-	{
-		PX_ALWAYS_ASSERT(); // TODO : Not yet implemented
-	}
-
-	/**
-	\brief Remove converter for legacy version of class
-	*/
-	virtual ::NvParameterized::Conversion *removeConversion(const char * /*className*/, uint32_t /*from*/, uint32_t /*to*/) 
-	{ 
-		PX_ALWAYS_ASSERT(); // TODO : Not yet implemented
-		return 0; 
-	}
-
-	/**
-	\brief Update legacy object (most probably using appropriate registered converter)
-	\param [in] legacyObj legacy object to be converted
-	\param [in] obj destination object
-	\return True if conversion was successful, false otherwise
-	\warning Note that update is intrusive - legacyObj may be modified as a result of update
-	*/
-	virtual bool updateLegacyNvParameterized(::NvParameterized::Interface &legacyObj, ::NvParameterized::Interface &obj)
-	{
-		PX_ALWAYS_ASSERT(); // TODO : Not yet implemented		
-		PX_UNUSED(&legacyObj);
-		PX_UNUSED(&obj);
-
-		return false;
-	}
-
-	/**
-	\brief Get a list of the NvParameterized class type names
-
-	\param [in] names buffer for names
-	\param [out] outCount minimal required length of buffer
-	\param [in] inCount length of buffer
-	\return False if 'inCount' is not large enough to contain all of the names, true otherwise
-	
-	\warning The memory for the strings returned is owned by the traits class
-	         and should only be read, not written or freed.
-	*/
-	virtual bool getNvParameterizedNames( const char ** names, uint32_t &outCount, uint32_t inCount) const 
-	{
-		bool ret = true;
-
-		outCount = 0;
-		for (uint32_t i=0; i<mFactories.size(); i++)
-		{
-			Factory *f = mFactories[i];
-			const char *name = f->getClassName();
-			for (uint32_t j=0; j<outCount; j++)
-			{
-				if ( strcmp(name,names[j]) == 0 )
-				{
-					name = NULL;
-					break;
-				}
-			}
-			if ( name )
-			{
-				if ( outCount == inCount )
-				{
-					ret = false;
-					break;
-				}
-				else
-				{
-					names[outCount] = name;
-					outCount++;
-				}
-			}
-		}
-		return ret;
-	}
-
-	/**
-	\brief Get a list of versions of particular NvParameterized class
-
-	\param [in] className Name of the class
-	\param [in] versions buffer for versions
-	\param [out] outCount minimal required length of buffer
-	\param [in] inCount length of buffer
-	\return False if 'inCount' is not large enough to contain all of version names, true otherwise
-	
-	\warning The memory for the strings returned is owned by the traits class
-	         and should only be read, not written or freed.
-	*/
-	virtual bool getNvParameterizedVersions(const char* className, uint32_t* versions, uint32_t &outCount, uint32_t inCount) const 
-	{
-		bool ret = true;
-
-		outCount = 0;
-		for (uint32_t i=0; i<mFactories.size(); i++)
-		{
-			Factory *f = mFactories[i];
-			const char *name = f->getClassName();
-			if ( strcmp(name,className) == 0 )
-			{
-				if ( outCount == inCount )
-				{
-					ret = false;
-					break;
-				}
-				else
-				{
-					versions[outCount] = f->getVersion();
-					outCount++;
-				}
-			}
-		}
-		return ret;
-	}
-
-	/**
-	\brief Called when inplace object is destroyed
-	*/
-	virtual void onInplaceObjectDestroyed(void * /*buf*/, ::NvParameterized::Interface * /*obj*/) 
-	{
-
-	}
-
-	/**
-	\brief Called when all inplace objects are destroyed
-	*/
-	virtual void onAllInplaceObjectsDestroyed(void *buf) 
-	{ 
-		free(buf); 
-	}
-
-	void* alloc(uint32_t nbytes)
-	{
-		return alloc(nbytes, 16);
-	}
-
-	void* alloc(uint32_t nbytes, uint32_t align)
-	{
-		if (align <= 16)
-		{
-			return ALIGNED_ALLOC(nbytes, 16);
-		}
-		else switch (align)
-		{
-		case 32:
-			return ALIGNED_ALLOC(nbytes, 32);
-		case 64:
-			return ALIGNED_ALLOC(nbytes, 64);
-		case 128:
-			return ALIGNED_ALLOC(nbytes, 128);
-		}
-
-		// Do not support larger alignments
-
-		return 0;
-	}
-
-	void free(void* buf)
-	{
-		ALIGNED_FREE(buf);
-	}
-
-	int32_t incRefCount(int32_t* refCount)
-	{
-		return physx::shdfnd::atomicIncrement(refCount);
-	}
-
-	virtual int32_t decRefCount(int32_t* refCount)
-	{
-		return physx::shdfnd::atomicDecrement(refCount);
-	}
-
-
- 	/**
-	\brief Warns user
-	*/
-	virtual void traitsWarn(const char * msg) const 
-	{
-		char scratch[512];
-		physx::shdfnd::snprintf(scratch,512,"NvParameterized::Traits::Warning(%s)", msg);
-		PxGetFoundation().getErrorCallback().reportError(physx::PxErrorCode::eDEBUG_WARNING,scratch,__FILE__,__LINE__ );
-	}
-
-	physx::shdfnd::Array< Factory * > mFactories;
-};
-
-Traits *createTraits(void)
-{
-	NvTraits *n = PX_NEW(NvTraits);
-	return static_cast< Traits *>(n);
-}
-
-}
+#include "NvTraits.h"

+#include "nvparameterized/NvParameterizedTraits.h"

+#include "PsUserAllocated.h"

+#include "PsArray.h"

+#include "PsAtomic.h"

+#include "PsAlignedMalloc.h"

+#include "PxFoundation.h"

+#include "PxErrorCallback.h"

+#include "PsString.h"

+

+#define ALIGNED_ALLOC(n, align) physx::shdfnd::AlignedAllocator<align>().allocate(n, __FILE__, __LINE__)

+

+// Does not depend on alignment in AlignedAllocator

+#define ALIGNED_FREE(p) physx::shdfnd::AlignedAllocator<16>().deallocate(p)

+

+

+namespace NvParameterized

+{

+

+class NvTraits : public Traits, public physx::shdfnd::UserAllocated

+{

+public:

+	NvTraits(void)

+	{

+

+	}

+

+	virtual ~NvTraits(void)

+	{

+	}

+

+	virtual void release(void)

+	{

+		delete this;

+	}

+

+	/**

+	\brief Register NvParameterized class factory

+	*/

+	virtual void registerFactory( ::NvParameterized::Factory & factory ) 

+	{

+		bool ok = true;

+

+		for (uint32_t i=0; i<mFactories.size(); ++i)

+		{

+			Factory *f = mFactories[i];

+			if ( f == &factory )

+			{

+				ok = false;

+				traitsWarn("Factory already registered.");

+				break;

+			}

+			if ( strcmp(f->getClassName(),factory.getClassName()) == 0 && f->getVersion() == factory.getVersion() )

+			{

+				ok = false;

+				traitsWarn("factory with this name and version already registered.");

+				break;

+			}

+		}

+		if ( ok )

+		{

+			mFactories.pushBack(&factory);

+		}

+	}

+

+	/**

+	\brief Remove NvParameterized class factory for current version of class

+	\return Removed factory or NULL if it is not found

+	*/

+	virtual ::NvParameterized::Factory *removeFactory( const char * className ) 

+	{

+		NvParameterized::Factory *f = NULL;

+		uint32_t index=0;

+		uint32_t maxVersion = 0;

+		for (uint32_t i=0; i<mFactories.size(); i++)

+		{

+			if ( strcmp(mFactories[i]->getClassName(),className) == 0 )

+			{

+				if ( mFactories[i]->getVersion() >= maxVersion )

+				{

+					f = mFactories[i];

+					maxVersion = f->getVersion();

+					index = i;

+				}

+			}

+		}

+		if ( f )

+		{

+			mFactories.remove(index);

+		}

+		else

+		{

+			traitsWarn("Unable to remove factory.");

+		}

+		return f;

+	}

+

+	/**

+	\brief Remove NvParameterized class factory for given version of class

+	\return Removed factory or NULL if it is not found

+	*/

+	virtual ::NvParameterized::Factory *removeFactory( const char * className, uint32_t version ) 

+	{

+		Factory *f = NULL;

+		for (uint32_t i=0; i<mFactories.size(); ++i)

+		{

+			if ( strcmp(mFactories[i]->getClassName(),className) == 0 && mFactories[i]->getVersion() == version )

+			{

+				f = mFactories[i];

+				mFactories.remove(i);

+				break;

+			}

+		}

+		if ( !f )

+		{

+			traitsWarn("Unable to remove factory, not found");

+		}

+		return f;

+	}

+

+	/**

+	\brief Checks whether any class factory is registered

+	*/

+	virtual bool doesFactoryExist(const char* className) 

+	{

+		bool ret = false;

+		for (uint32_t i=0; i<mFactories.size(); ++i)

+		{

+			if ( strcmp(mFactories[i]->getClassName(),className) == 0 )

+			{

+				ret = true;

+				break;

+			}

+		}

+		return ret;

+	}

+

+	/**

+	\brief Checks whether class factory for given version is registered

+	*/

+	virtual bool doesFactoryExist(const char* className, uint32_t version) 

+	{

+		bool ret = false;

+		for (uint32_t i=0; i<mFactories.size(); ++i)

+		{

+			if ( strcmp(mFactories[i]->getClassName(),className) == 0 && mFactories[i]->getVersion() == version )

+			{

+				ret = true;

+				break;

+			}

+		}

+		return ret;

+	}

+

+	// Helper method, locate a factory of this name and exact version, of it specific version not being searched for, return the highest registered version number.

+	Factory * locateFactory(const char *className,uint32_t version,bool useVersion) const

+	{

+		NvParameterized::Factory *f = NULL;

+		uint32_t maxVersion = 0;

+		for (uint32_t i=0; i<mFactories.size(); i++)

+		{

+			if ( strcmp(mFactories[i]->getClassName(),className) == 0 )

+			{

+				if ( useVersion )

+				{

+					if ( mFactories[i]->getVersion() == version )

+					{

+						f = mFactories[i];

+					}

+				}

+				else if ( mFactories[i]->getVersion() >= maxVersion )

+				{

+					f = mFactories[i];

+					maxVersion = f->getVersion();

+				}

+			}

+		}

+		return f;

+	}

+

+	/**

+	\brief Create object of NvParameterized class

+	

+	Most probably this just calls Factory::create on appropriate factory.

+	*/

+	virtual ::NvParameterized::Interface * createNvParameterized( const char * name ) 

+	{

+		NvParameterized::Interface *ret = NULL;

+		Factory *f = locateFactory(name,0,false);

+		if ( f )

+		{

+			ret = f->create(this);

+		}

+		return ret;

+	}

+

+	/**

+	\brief Create object of NvParameterized class

+	

+	Most probably this just calls Factory::create on appropriate factory.

+	*/

+	virtual ::NvParameterized::Interface * createNvParameterized( const char * name, uint32_t ver )

+	{

+		NvParameterized::Interface *ret = NULL;

+		Factory *f = locateFactory(name,ver,true);

+		if ( f )

+		{

+			ret = f->create(this);

+		}

+		return ret;

+	}

+

+	/**

+	\brief Finish construction of inplace object of NvParameterized class

+	

+	Most probably this just calls Factory::finish using appropriate factory.

+	*/

+	virtual ::NvParameterized::Interface * finishNvParameterized( const char * name, void *obj, void *buf, int32_t *refCount ) 

+	{

+		Factory *f = locateFactory(name,0,false);

+		return f ? f->finish(this,obj,buf,refCount) : NULL;

+	}

+

+	/**

+	\brief Finish construction of inplace object of NvParameterized class

+	

+	Most probably this just calls Factory::finish using appropriate factory.

+	*/

+	virtual ::NvParameterized::Interface * finishNvParameterized( const char * name, uint32_t ver, void *obj, void *buf, int32_t *refCount ) 

+	{

+		Factory *f = locateFactory(name,ver,true);

+		return f ? f->finish(this,obj,buf,refCount) : NULL;

+	}

+

+	/**

+	\brief Get version of class which is currently used

+	*/

+	virtual uint32_t getCurrentVersion(const char *className) const 

+	{

+		Factory *f = locateFactory(className,0,false);

+		return f ? f->getVersion() : 0;

+	}

+

+	/**

+	\brief Get memory alignment required for objects of class

+	*/

+	virtual uint32_t getAlignment(const char *className, uint32_t classVersion) const 

+	{

+		Factory *f = locateFactory(className,classVersion,true);

+		return f ? f->getAlignment() : 16;

+	}

+

+	/**

+	\brief Register converter for legacy version of class

+	*/

+	virtual void registerConversion(const char * /*className*/, uint32_t /*from*/, uint32_t /*to*/, Conversion & /*conv*/) 

+	{

+		PX_ALWAYS_ASSERT(); // TODO : Not yet implemented

+	}

+

+	/**

+	\brief Remove converter for legacy version of class

+	*/

+	virtual ::NvParameterized::Conversion *removeConversion(const char * /*className*/, uint32_t /*from*/, uint32_t /*to*/) 

+	{ 

+		PX_ALWAYS_ASSERT(); // TODO : Not yet implemented

+		return 0; 

+	}

+

+	/**

+	\brief Update legacy object (most probably using appropriate registered converter)

+	\param [in] legacyObj legacy object to be converted

+	\param [in] obj destination object

+	\return True if conversion was successful, false otherwise

+	\warning Note that update is intrusive - legacyObj may be modified as a result of update

+	*/

+	virtual bool updateLegacyNvParameterized(::NvParameterized::Interface &legacyObj, ::NvParameterized::Interface &obj)

+	{

+		PX_ALWAYS_ASSERT(); // TODO : Not yet implemented		

+		PX_UNUSED(&legacyObj);

+		PX_UNUSED(&obj);

+

+		return false;

+	}

+

+	/**

+	\brief Get a list of the NvParameterized class type names

+

+	\param [in] names buffer for names

+	\param [out] outCount minimal required length of buffer

+	\param [in] inCount length of buffer

+	\return False if 'inCount' is not large enough to contain all of the names, true otherwise

+	

+	\warning The memory for the strings returned is owned by the traits class

+	         and should only be read, not written or freed.

+	*/

+	virtual bool getNvParameterizedNames( const char ** names, uint32_t &outCount, uint32_t inCount) const 

+	{

+		bool ret = true;

+

+		outCount = 0;

+		for (uint32_t i=0; i<mFactories.size(); i++)

+		{

+			Factory *f = mFactories[i];

+			const char *name = f->getClassName();

+			for (uint32_t j=0; j<outCount; j++)

+			{

+				if ( strcmp(name,names[j]) == 0 )

+				{

+					name = NULL;

+					break;

+				}

+			}

+			if ( name )

+			{

+				if ( outCount == inCount )

+				{

+					ret = false;

+					break;

+				}

+				else

+				{

+					names[outCount] = name;

+					outCount++;

+				}

+			}

+		}

+		return ret;

+	}

+

+	/**

+	\brief Get a list of versions of particular NvParameterized class

+

+	\param [in] className Name of the class

+	\param [in] versions buffer for versions

+	\param [out] outCount minimal required length of buffer

+	\param [in] inCount length of buffer

+	\return False if 'inCount' is not large enough to contain all of version names, true otherwise

+	

+	\warning The memory for the strings returned is owned by the traits class

+	         and should only be read, not written or freed.

+	*/

+	virtual bool getNvParameterizedVersions(const char* className, uint32_t* versions, uint32_t &outCount, uint32_t inCount) const 

+	{

+		bool ret = true;

+

+		outCount = 0;

+		for (uint32_t i=0; i<mFactories.size(); i++)

+		{

+			Factory *f = mFactories[i];

+			const char *name = f->getClassName();

+			if ( strcmp(name,className) == 0 )

+			{

+				if ( outCount == inCount )

+				{

+					ret = false;

+					break;

+				}

+				else

+				{

+					versions[outCount] = f->getVersion();

+					outCount++;

+				}

+			}

+		}

+		return ret;

+	}

+

+	/**

+	\brief Called when inplace object is destroyed

+	*/

+	virtual void onInplaceObjectDestroyed(void * /*buf*/, ::NvParameterized::Interface * /*obj*/) 

+	{

+

+	}

+

+	/**

+	\brief Called when all inplace objects are destroyed

+	*/

+	virtual void onAllInplaceObjectsDestroyed(void *buf) 

+	{ 

+		free(buf); 

+	}

+

+	void* alloc(uint32_t nbytes)

+	{

+		return alloc(nbytes, 16);

+	}

+

+	void* alloc(uint32_t nbytes, uint32_t align)

+	{

+		if (align <= 16)

+		{

+			return ALIGNED_ALLOC(nbytes, 16);

+		}

+		else switch (align)

+		{

+		case 32:

+			return ALIGNED_ALLOC(nbytes, 32);

+		case 64:

+			return ALIGNED_ALLOC(nbytes, 64);

+		case 128:

+			return ALIGNED_ALLOC(nbytes, 128);

+		}

+

+		// Do not support larger alignments

+

+		return 0;

+	}

+

+	void free(void* buf)

+	{

+		ALIGNED_FREE(buf);

+	}

+

+	int32_t incRefCount(int32_t* refCount)

+	{

+		return physx::shdfnd::atomicIncrement(refCount);

+	}

+

+	virtual int32_t decRefCount(int32_t* refCount)

+	{

+		return physx::shdfnd::atomicDecrement(refCount);

+	}

+

+

+ 	/**

+	\brief Warns user

+	*/

+	virtual void traitsWarn(const char * msg) const 

+	{

+		char scratch[512];

+		physx::shdfnd::snprintf(scratch,512,"NvParameterized::Traits::Warning(%s)", msg);

+		PxGetFoundation().getErrorCallback().reportError(physx::PxErrorCode::eDEBUG_WARNING,scratch,__FILE__,__LINE__ );

+	}

+

+	physx::shdfnd::Array< Factory * > mFactories;

+};

+

+Traits *createTraits(void)

+{

+	NvTraits *n = PX_NEW(NvTraits);

+	return static_cast< Traits *>(n);

+}

+

+}

diff --git a/sdk/extensions/import/apexmodules/NvParameterized/src/NvTraits.h b/sdk/extensions/import/apexmodules/NvParameterized/src/NvTraits.h
index 159662a..60dd512 100644..100755
--- a/sdk/extensions/import/apexmodules/NvParameterized/src/NvTraits.h
+++ b/sdk/extensions/import/apexmodules/NvParameterized/src/NvTraits.h
@@ -1,41 +1,41 @@
-// 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) 2008-2013 NVIDIA Corporation. All rights reserved.
-
-#ifndef PX_TRAITS_H
-
-#define PX_TRAITS_H
-
-namespace NvParameterized
-{
-
-class Traits;
-
-Traits *createTraits(void);
-
-}
-
-#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) 2008-2013 NVIDIA Corporation. All rights reserved.

+

+#ifndef PX_TRAITS_H

+

+#define PX_TRAITS_H

+

+namespace NvParameterized

+{

+

+class Traits;

+

+Traits *createTraits(void);

+

+}

+

+#endif

diff --git a/sdk/extensions/import/apexmodules/NvParameterized/src/PlatformABI.cpp b/sdk/extensions/import/apexmodules/NvParameterized/src/PlatformABI.cpp
index c2d32b6..e22a73a 100644..100755
--- a/sdk/extensions/import/apexmodules/NvParameterized/src/PlatformABI.cpp
+++ b/sdk/extensions/import/apexmodules/NvParameterized/src/PlatformABI.cpp
@@ -1,429 +1,429 @@
-// 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) 2008-2013 NVIDIA Corporation. All rights reserved.
-
-// WARNING: before doing any changes to this file
-// check comments at the head of BinSerializer.cpp
-
-#include "PxSimpleTypes.h"
-#include "PlatformABI.h"
-#include "NvSerializerInternal.h"
-#include "SerializerCommon.h"
-
-using namespace NvParameterized;
-
-//Returns ABI for predefined platforms
-Serializer::ErrorType PlatformABI::GetPredefinedABI(const SerializePlatform &platform, PlatformABI &params)
-{
-	//Most common parameters
-	params.endian = LITTLE;
-	params.sizes.Char = 1;
-	params.sizes.Bool = 1;
-	params.sizes.pointer = 4;
-	params.sizes.real = 4; //float
-	params.aligns.Char = 1;
-	params.aligns.pointer = 4;
-	params.aligns.Bool = 1;
-	params.aligns.i8 = 1;
-	params.aligns.i16 = 2;
-	params.aligns.i32 = 4;
-	params.aligns.i64 = 8;
-	params.aligns.f32 = 4;
-	params.aligns.f64 = 8;
-	params.aligns.real = params.aligns.f32;
-	params.doReuseParentPadding = false;
-	params.doEbo = true;
-
-	SerializePlatform knownPlatform;
-
-	//TODO: all those GetPlatforms are ugly
-
-	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("VcWin32", knownPlatform), Serializer::ERROR_UNKNOWN );
-	if( knownPlatform == platform )
-	{
-		//Default params are ok
-		return Serializer::ERROR_NONE;
-	}
-
-	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("VcWin64", knownPlatform), Serializer::ERROR_UNKNOWN );
-	if( knownPlatform == platform )
-	{
-		params.sizes.pointer = params.aligns.pointer = 8;
-		return Serializer::ERROR_NONE;
-	}
-
-	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("VcXbox360", knownPlatform), Serializer::ERROR_UNKNOWN );
-	if( knownPlatform == platform )
-	{
-		//Pointers remain 32-bit
-		params.endian = BIG;
-		return Serializer::ERROR_NONE;
-	}
-
-	// Snc says that it's binary compatible with Gcc...
-	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("GccPs3", knownPlatform), Serializer::ERROR_UNKNOWN );
-	if( knownPlatform == platform )
-	{
-		//Pointers remain 32-bit
-		params.doReuseParentPadding = true;
-		params.endian = BIG;
-		return Serializer::ERROR_NONE;
-	}
-
-	// Same as ps3 but little endian
-	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("AndroidARM", knownPlatform), Serializer::ERROR_UNKNOWN );
-	if( knownPlatform == platform )
-	{
-		//Pointers remain 32-bit
-		params.doReuseParentPadding = true;
-		params.endian = LITTLE;
-		return Serializer::ERROR_NONE;
-	}
-
-	NV_BOOL_ERR_CHECK_RETURN(GetPlatform("GccLinux32", knownPlatform), Serializer::ERROR_UNKNOWN);
-	if (knownPlatform == platform)
-	{
-		return Serializer::ERROR_NONE;
-	}
-
-	NV_BOOL_ERR_CHECK_RETURN(GetPlatform("GccLinux64", knownPlatform), Serializer::ERROR_UNKNOWN);
-	if (knownPlatform == platform)
-	{
-		params.doReuseParentPadding = true;
-		params.sizes.pointer = params.aligns.pointer = 8;
-		return Serializer::ERROR_NONE;
-	}
-
-	// FIXME: true ABI is much more complicated (sizeof(bool) is 4, etc.)
-	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("GccOsX32", knownPlatform), Serializer::ERROR_UNKNOWN );
-	if( knownPlatform == platform )
-	{
-		params.doReuseParentPadding = true; // TODO (JPB): Is this correct?
-		return Serializer::ERROR_NONE;
-	}
-
-	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("GccOsX64", knownPlatform), Serializer::ERROR_UNKNOWN );
-	if( knownPlatform == platform )
-	{
-		params.doReuseParentPadding = true;
-		params.sizes.pointer = params.aligns.pointer = 8;
-		return Serializer::ERROR_NONE;
-	}
-
-	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("Pib", knownPlatform), Serializer::ERROR_UNKNOWN );
-	if( knownPlatform == platform )
-	{
-		params.endian = BIG;
-
-		params.sizes.Char = params.sizes.Bool = 1;
-		params.sizes.pointer = 4;
-		params.sizes.real = 4; //float
-
-		//All alignments are 1 to minimize space
-		uint32_t *aligns = (uint32_t *)&params.aligns;
-		for(uint32_t i = 0; i < sizeof(params.aligns)/sizeof(uint32_t); ++i)
-			aligns[i] = 1;
-
-		return Serializer::ERROR_NONE;
-	}
-
-	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("VcXboxOne", knownPlatform), Serializer::ERROR_UNKNOWN );
-	if( knownPlatform == platform )
-	{
-		params.sizes.pointer = params.aligns.pointer = 8;
-		return Serializer::ERROR_NONE;
-	}
-
-	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("GccPs4", knownPlatform), Serializer::ERROR_UNKNOWN );
-	if( knownPlatform == platform )
-	{
-		// if you don't set this then the in-place binary files could contain padding
-		// between the NvParameters class and the parameterized data.
-		params.doReuseParentPadding = true;
-		params.sizes.pointer = params.aligns.pointer = 8;
-		return Serializer::ERROR_NONE;
-	}
-
-	NV_BOOL_ERR_CHECK_RETURN(GetPlatform("HOSARM32", knownPlatform), Serializer::ERROR_UNKNOWN);
-	if (knownPlatform == platform)
-	{
-		//Default params are ok
-		return Serializer::ERROR_NONE;
-	}
-
-	NV_BOOL_ERR_CHECK_RETURN(GetPlatform("HOSARM64", knownPlatform), Serializer::ERROR_UNKNOWN);
-	if (knownPlatform == platform)
-	{
-		params.doReuseParentPadding = true;
-		params.sizes.pointer = params.aligns.pointer = 8;
-		return Serializer::ERROR_NONE;
-	}	
-
-	//Add new platforms here
-
-	return Serializer::ERROR_INVALID_PLATFORM_NAME;
-}
-
-uint32_t PlatformABI::getNatAlignment(const Definition *pd) const
-{
-	switch( pd->type() )
-	{
-	case TYPE_ARRAY:
-		return pd->arraySizeIsFixed()
-			? getAlignment(pd->child(0)) //Array alignment = mermber alignment
-			: NvMax3(aligns.pointer, aligns.Bool, aligns.i32); //Dynamic array is DummyDynamicArrayStruct
-
-	case TYPE_STRUCT:
-		{
-			//Struct alignment is max of fields' alignment
-			uint32_t align = 1;
-			for(int32_t i = 0; i < pd->numChildren(); ++i)
-				align = physx::PxMax(align, getAlignment(pd->child(i)));
-
-			return align;
-		}
-
-	case TYPE_STRING:
-		return physx::PxMax(aligns.pointer, aligns.Bool); //String = DummyDynamicStringStruct
-
-	case TYPE_I8:
-	case TYPE_U8:
-		return aligns.i8;
-
-	case TYPE_I16:
-	case TYPE_U16:
-		return aligns.i16;
-
-	case TYPE_I32:
-	case TYPE_U32:
-		return aligns.i32;
-
-	case TYPE_I64:
-	case TYPE_U64:
-		return aligns.i64;
-
-	case TYPE_F32:
-	case TYPE_VEC2:
-	case TYPE_VEC3:
-	case TYPE_VEC4:
-	case TYPE_QUAT:
-	case TYPE_MAT33:
-	case TYPE_BOUNDS3:
-	case TYPE_MAT34:
-	case TYPE_MAT44:
-	case TYPE_TRANSFORM:
-		return aligns.f32;
-
-	case TYPE_F64:
-		return aligns.f64;
-
-	case TYPE_ENUM:
-	case TYPE_REF:
-	case TYPE_POINTER:
-		return aligns.pointer;
-
-	case TYPE_BOOL:
-		return aligns.Bool;
-
-	NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS
-	default:
-		PX_ASSERT( 0 && "Unexpected type" );
-	}
-
-	return UINT32_MAX;
-}
-
-//Returns alignment of given DataType
-uint32_t PlatformABI::getAlignment(const Definition *pd) const
-{
-	uint32_t natAlign = getNatAlignment(pd),
-		customAlign = pd->alignment();
-
-	// Alignment of dynamic array means alignment of dynamic memory
-	return !customAlign || ( TYPE_ARRAY == pd->type() && !pd->arraySizeIsFixed() )
-		? natAlign
-		: physx::PxMax(natAlign, customAlign);
-}
-
-//Returns alignment of given DataType
-uint32_t PlatformABI::getPadding(const Definition *pd) const
-{
-	uint32_t natAlign = getNatAlignment(pd),
-		customPad = pd->padding();
-
-	// Alignment of dynamic array means alignment of dynamic memory
-	return !customPad || ( TYPE_ARRAY == pd->type() && !pd->arraySizeIsFixed() )
-		? natAlign
-		: physx::PxMax(natAlign, customPad);
-}
-
-//Returns size of given DataType
-uint32_t PlatformABI::getSize(const Definition *pd) const
-{
-	switch( pd->type() )
-	{
-	case TYPE_ARRAY:
-		if( pd->arraySizeIsFixed() )
-		{
-			//Size of static array = number of elements * size of element
-			const Definition *elemPd = pd;
-			uint32_t totalSize = 1;
-			for(int32_t i = 0; i < pd->arrayDimension(); ++i)
-			{
-				// Currently no nested dynamic arrays
-				NV_BOOL_ERR_CHECK_RETURN( elemPd->arraySizeIsFixed(), Serializer::ERROR_NOT_IMPLEMENTED );
-
-				int32_t size = elemPd->arraySize();
-				totalSize *= size;
-
-				elemPd = elemPd->child(0);
-			}
-			return totalSize * getSize(elemPd);
-		}
-		else
-		{
-			//Dynamic array = DummyDynamicArrayStruct
-
-			uint32_t totalAlign = NvMax3(aligns.pointer, aligns.Bool, aligns.i32);
-
-			uint32_t size = sizes.pointer; //buf
-			size = align(size, aligns.Bool) + 1U; //isAllocated
-			size = align(size, aligns.i32) + 4U; //elementSize
-			size = align(size, aligns.i32) + pd->arrayDimension() * 4U; //arraySizes
-
-			uint32_t paddedSize = align(size, totalAlign);
-
-			return paddedSize;
-		}
-
-	case TYPE_STRUCT:
-		{
-			if( !pd->numChildren() )
-				return 1;
-
-			//Size of struct = sum of member sizes + sum of padding bytes + tail padding
-
-			uint32_t totalAlign = 1, size = 0;
-			for(int32_t i = 0; i < pd->numChildren(); ++i)
-			{
-				uint32_t childAlign = getAlignment(pd->child(i));
-				totalAlign = physx::PxMax(totalAlign, childAlign);
-				size = align(size, childAlign) + getSize(pd->child(i));
-			}
-
-			uint32_t customPad = pd->padding();
-			if( customPad )
-				totalAlign = physx::PxMax(totalAlign, customPad);
-
-			return align(size, totalAlign); //Tail padding bytes
-		}
-
-	case TYPE_STRING:
-		{
-			//String = DummyDynamicStringStruct
-
-			uint32_t totalAlign = physx::PxMax(aligns.pointer, aligns.Bool);
-
-			uint32_t size = sizes.pointer; //buf
-			size = align(size, aligns.Bool) + 1U; //isAllocated
-
-			uint32_t paddedSize = align(size, totalAlign);
-
-			return paddedSize;
-		}
-
-	case TYPE_I8:
-	case TYPE_U8:
-		return 1;
-
-	case TYPE_I16:
-	case TYPE_U16:
-		return 2;
-
-	case TYPE_I32:
-	case TYPE_U32:
-	case TYPE_F32:
-		return 4;
-
-	case TYPE_I64:
-	case TYPE_U64:
-	case TYPE_F64:
-		return 8;
-
-	// Vectors and matrices are structs so we need tail padding
-
-	case TYPE_VEC2:
-		return align(2 * sizes.real, aligns.real);
-	case TYPE_VEC3:
-		return align(3 * sizes.real, aligns.real);
-	case TYPE_VEC4:
-		return align(4 * sizes.real, aligns.real);
-	case TYPE_QUAT:
-		return align(4 * sizes.real, aligns.real);
-	case TYPE_MAT33:
-		return align(9 * sizes.real, aligns.real);
-	case TYPE_MAT34:
-		return align(12 * sizes.real, aligns.real);
-	case TYPE_MAT44:
-		return align(16 * sizes.real, aligns.real);
-	case TYPE_BOUNDS3:
-		return align(6 * sizes.real, aligns.real);
-	case TYPE_TRANSFORM:
-		return align(7 * sizes.real, aligns.real);
-
-	case TYPE_ENUM:
-	case TYPE_REF:
-	case TYPE_POINTER:
-		return sizes.pointer;
-
-	case TYPE_BOOL:
-		return sizes.Bool;
-
-	NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS
-	default:
-		PX_ASSERT( 0 && "Unexpected type" );
-	}
-
-	return UINT32_MAX; //This is never reached
-}
-
-bool PlatformABI::VerifyCurrentPlatform()
-{
-	//See PlatformABI::isNormal
-
-	uint8_t one = 1,
-		zero = 0;
-
-	struct Empty {};
-
-	return 1 == GetAlignment<bool>::value && 1 == sizeof(bool)
-		&& 1 == GetAlignment<uint8_t>::value
-		&& 1 == GetAlignment<char>::value
-		&& 4 == sizeof(float)
-		&& *(bool *)&one //We assume that 0x1 corresponds to true internally
-		&& !*(bool *)&zero //We assume that 0x0 corresponds to false internally
-		&& 1 == sizeof(Empty); // Serializer expects sizeof empty struct to be 1
-}
+// 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) 2008-2013 NVIDIA Corporation. All rights reserved.

+

+// WARNING: before doing any changes to this file

+// check comments at the head of BinSerializer.cpp

+

+#include "PxSimpleTypes.h"

+#include "PlatformABI.h"

+#include "NvSerializerInternal.h"

+#include "SerializerCommon.h"

+

+using namespace NvParameterized;

+

+//Returns ABI for predefined platforms

+Serializer::ErrorType PlatformABI::GetPredefinedABI(const SerializePlatform &platform, PlatformABI &params)

+{

+	//Most common parameters

+	params.endian = LITTLE;

+	params.sizes.Char = 1;

+	params.sizes.Bool = 1;

+	params.sizes.pointer = 4;

+	params.sizes.real = 4; //float

+	params.aligns.Char = 1;

+	params.aligns.pointer = 4;

+	params.aligns.Bool = 1;

+	params.aligns.i8 = 1;

+	params.aligns.i16 = 2;

+	params.aligns.i32 = 4;

+	params.aligns.i64 = 8;

+	params.aligns.f32 = 4;

+	params.aligns.f64 = 8;

+	params.aligns.real = params.aligns.f32;

+	params.doReuseParentPadding = false;

+	params.doEbo = true;

+

+	SerializePlatform knownPlatform;

+

+	//TODO: all those GetPlatforms are ugly

+

+	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("VcWin32", knownPlatform), Serializer::ERROR_UNKNOWN );

+	if( knownPlatform == platform )

+	{

+		//Default params are ok

+		return Serializer::ERROR_NONE;

+	}

+

+	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("VcWin64", knownPlatform), Serializer::ERROR_UNKNOWN );

+	if( knownPlatform == platform )

+	{

+		params.sizes.pointer = params.aligns.pointer = 8;

+		return Serializer::ERROR_NONE;

+	}

+

+	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("VcXbox360", knownPlatform), Serializer::ERROR_UNKNOWN );

+	if( knownPlatform == platform )

+	{

+		//Pointers remain 32-bit

+		params.endian = BIG;

+		return Serializer::ERROR_NONE;

+	}

+

+	// Snc says that it's binary compatible with Gcc...

+	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("GccPs3", knownPlatform), Serializer::ERROR_UNKNOWN );

+	if( knownPlatform == platform )

+	{

+		//Pointers remain 32-bit

+		params.doReuseParentPadding = true;

+		params.endian = BIG;

+		return Serializer::ERROR_NONE;

+	}

+

+	// Same as ps3 but little endian

+	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("AndroidARM", knownPlatform), Serializer::ERROR_UNKNOWN );

+	if( knownPlatform == platform )

+	{

+		//Pointers remain 32-bit

+		params.doReuseParentPadding = true;

+		params.endian = LITTLE;

+		return Serializer::ERROR_NONE;

+	}

+

+	NV_BOOL_ERR_CHECK_RETURN(GetPlatform("GccLinux32", knownPlatform), Serializer::ERROR_UNKNOWN);

+	if (knownPlatform == platform)

+	{

+		return Serializer::ERROR_NONE;

+	}

+

+	NV_BOOL_ERR_CHECK_RETURN(GetPlatform("GccLinux64", knownPlatform), Serializer::ERROR_UNKNOWN);

+	if (knownPlatform == platform)

+	{

+		params.doReuseParentPadding = true;

+		params.sizes.pointer = params.aligns.pointer = 8;

+		return Serializer::ERROR_NONE;

+	}

+

+	// FIXME: true ABI is much more complicated (sizeof(bool) is 4, etc.)

+	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("GccOsX32", knownPlatform), Serializer::ERROR_UNKNOWN );

+	if( knownPlatform == platform )

+	{

+		params.doReuseParentPadding = true; // TODO (JPB): Is this correct?

+		return Serializer::ERROR_NONE;

+	}

+

+	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("GccOsX64", knownPlatform), Serializer::ERROR_UNKNOWN );

+	if( knownPlatform == platform )

+	{

+		params.doReuseParentPadding = true;

+		params.sizes.pointer = params.aligns.pointer = 8;

+		return Serializer::ERROR_NONE;

+	}

+

+	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("Pib", knownPlatform), Serializer::ERROR_UNKNOWN );

+	if( knownPlatform == platform )

+	{

+		params.endian = BIG;

+

+		params.sizes.Char = params.sizes.Bool = 1;

+		params.sizes.pointer = 4;

+		params.sizes.real = 4; //float

+

+		//All alignments are 1 to minimize space

+		uint32_t *aligns = (uint32_t *)&params.aligns;

+		for(uint32_t i = 0; i < sizeof(params.aligns)/sizeof(uint32_t); ++i)

+			aligns[i] = 1;

+

+		return Serializer::ERROR_NONE;

+	}

+

+	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("VcXboxOne", knownPlatform), Serializer::ERROR_UNKNOWN );

+	if( knownPlatform == platform )

+	{

+		params.sizes.pointer = params.aligns.pointer = 8;

+		return Serializer::ERROR_NONE;

+	}

+

+	NV_BOOL_ERR_CHECK_RETURN( GetPlatform("GccPs4", knownPlatform), Serializer::ERROR_UNKNOWN );

+	if( knownPlatform == platform )

+	{

+		// if you don't set this then the in-place binary files could contain padding

+		// between the NvParameters class and the parameterized data.

+		params.doReuseParentPadding = true;

+		params.sizes.pointer = params.aligns.pointer = 8;

+		return Serializer::ERROR_NONE;

+	}

+

+	NV_BOOL_ERR_CHECK_RETURN(GetPlatform("HOSARM32", knownPlatform), Serializer::ERROR_UNKNOWN);

+	if (knownPlatform == platform)

+	{

+		//Default params are ok

+		return Serializer::ERROR_NONE;

+	}

+

+	NV_BOOL_ERR_CHECK_RETURN(GetPlatform("HOSARM64", knownPlatform), Serializer::ERROR_UNKNOWN);

+	if (knownPlatform == platform)

+	{

+		params.doReuseParentPadding = true;

+		params.sizes.pointer = params.aligns.pointer = 8;

+		return Serializer::ERROR_NONE;

+	}	

+

+	//Add new platforms here

+

+	return Serializer::ERROR_INVALID_PLATFORM_NAME;

+}

+

+uint32_t PlatformABI::getNatAlignment(const Definition *pd) const

+{

+	switch( pd->type() )

+	{

+	case TYPE_ARRAY:

+		return pd->arraySizeIsFixed()

+			? getAlignment(pd->child(0)) //Array alignment = mermber alignment

+			: NvMax3(aligns.pointer, aligns.Bool, aligns.i32); //Dynamic array is DummyDynamicArrayStruct

+

+	case TYPE_STRUCT:

+		{

+			//Struct alignment is max of fields' alignment

+			uint32_t align = 1;

+			for(int32_t i = 0; i < pd->numChildren(); ++i)

+				align = physx::PxMax(align, getAlignment(pd->child(i)));

+

+			return align;

+		}

+

+	case TYPE_STRING:

+		return physx::PxMax(aligns.pointer, aligns.Bool); //String = DummyDynamicStringStruct

+

+	case TYPE_I8:

+	case TYPE_U8:

+		return aligns.i8;

+

+	case TYPE_I16:

+	case TYPE_U16:

+		return aligns.i16;

+

+	case TYPE_I32:

+	case TYPE_U32:

+		return aligns.i32;

+

+	case TYPE_I64:

+	case TYPE_U64:

+		return aligns.i64;

+

+	case TYPE_F32:

+	case TYPE_VEC2:

+	case TYPE_VEC3:

+	case TYPE_VEC4:

+	case TYPE_QUAT:

+	case TYPE_MAT33:

+	case TYPE_BOUNDS3:

+	case TYPE_MAT34:

+	case TYPE_MAT44:

+	case TYPE_TRANSFORM:

+		return aligns.f32;

+

+	case TYPE_F64:

+		return aligns.f64;

+

+	case TYPE_ENUM:

+	case TYPE_REF:

+	case TYPE_POINTER:

+		return aligns.pointer;

+

+	case TYPE_BOOL:

+		return aligns.Bool;

+

+	NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS

+	default:

+		PX_ASSERT( 0 && "Unexpected type" );

+	}

+

+	return UINT32_MAX;

+}

+

+//Returns alignment of given DataType

+uint32_t PlatformABI::getAlignment(const Definition *pd) const

+{

+	uint32_t natAlign = getNatAlignment(pd),

+		customAlign = pd->alignment();

+

+	// Alignment of dynamic array means alignment of dynamic memory

+	return !customAlign || ( TYPE_ARRAY == pd->type() && !pd->arraySizeIsFixed() )

+		? natAlign

+		: physx::PxMax(natAlign, customAlign);

+}

+

+//Returns alignment of given DataType

+uint32_t PlatformABI::getPadding(const Definition *pd) const

+{

+	uint32_t natAlign = getNatAlignment(pd),

+		customPad = pd->padding();

+

+	// Alignment of dynamic array means alignment of dynamic memory

+	return !customPad || ( TYPE_ARRAY == pd->type() && !pd->arraySizeIsFixed() )

+		? natAlign

+		: physx::PxMax(natAlign, customPad);

+}

+

+//Returns size of given DataType

+uint32_t PlatformABI::getSize(const Definition *pd) const

+{

+	switch( pd->type() )

+	{

+	case TYPE_ARRAY:

+		if( pd->arraySizeIsFixed() )

+		{

+			//Size of static array = number of elements * size of element

+			const Definition *elemPd = pd;

+			uint32_t totalSize = 1;

+			for(int32_t i = 0; i < pd->arrayDimension(); ++i)

+			{

+				// Currently no nested dynamic arrays

+				NV_BOOL_ERR_CHECK_RETURN( elemPd->arraySizeIsFixed(), Serializer::ERROR_NOT_IMPLEMENTED );

+

+				int32_t size = elemPd->arraySize();

+				totalSize *= size;

+

+				elemPd = elemPd->child(0);

+			}

+			return totalSize * getSize(elemPd);

+		}

+		else

+		{

+			//Dynamic array = DummyDynamicArrayStruct

+

+			uint32_t totalAlign = NvMax3(aligns.pointer, aligns.Bool, aligns.i32);

+

+			uint32_t size = sizes.pointer; //buf

+			size = align(size, aligns.Bool) + 1U; //isAllocated

+			size = align(size, aligns.i32) + 4U; //elementSize

+			size = align(size, aligns.i32) + pd->arrayDimension() * 4U; //arraySizes

+

+			uint32_t paddedSize = align(size, totalAlign);

+

+			return paddedSize;

+		}

+

+	case TYPE_STRUCT:

+		{

+			if( !pd->numChildren() )

+				return 1;

+

+			//Size of struct = sum of member sizes + sum of padding bytes + tail padding

+

+			uint32_t totalAlign = 1, size = 0;

+			for(int32_t i = 0; i < pd->numChildren(); ++i)

+			{

+				uint32_t childAlign = getAlignment(pd->child(i));

+				totalAlign = physx::PxMax(totalAlign, childAlign);

+				size = align(size, childAlign) + getSize(pd->child(i));

+			}

+

+			uint32_t customPad = pd->padding();

+			if( customPad )

+				totalAlign = physx::PxMax(totalAlign, customPad);

+

+			return align(size, totalAlign); //Tail padding bytes

+		}

+

+	case TYPE_STRING:

+		{

+			//String = DummyDynamicStringStruct

+

+			uint32_t totalAlign = physx::PxMax(aligns.pointer, aligns.Bool);

+

+			uint32_t size = sizes.pointer; //buf

+			size = align(size, aligns.Bool) + 1U; //isAllocated

+

+			uint32_t paddedSize = align(size, totalAlign);

+

+			return paddedSize;

+		}

+

+	case TYPE_I8:

+	case TYPE_U8:

+		return 1;

+

+	case TYPE_I16:

+	case TYPE_U16:

+		return 2;

+

+	case TYPE_I32:

+	case TYPE_U32:

+	case TYPE_F32:

+		return 4;

+

+	case TYPE_I64:

+	case TYPE_U64:

+	case TYPE_F64:

+		return 8;

+

+	// Vectors and matrices are structs so we need tail padding

+

+	case TYPE_VEC2:

+		return align(2 * sizes.real, aligns.real);

+	case TYPE_VEC3:

+		return align(3 * sizes.real, aligns.real);

+	case TYPE_VEC4:

+		return align(4 * sizes.real, aligns.real);

+	case TYPE_QUAT:

+		return align(4 * sizes.real, aligns.real);

+	case TYPE_MAT33:

+		return align(9 * sizes.real, aligns.real);

+	case TYPE_MAT34:

+		return align(12 * sizes.real, aligns.real);

+	case TYPE_MAT44:

+		return align(16 * sizes.real, aligns.real);

+	case TYPE_BOUNDS3:

+		return align(6 * sizes.real, aligns.real);

+	case TYPE_TRANSFORM:

+		return align(7 * sizes.real, aligns.real);

+

+	case TYPE_ENUM:

+	case TYPE_REF:

+	case TYPE_POINTER:

+		return sizes.pointer;

+

+	case TYPE_BOOL:

+		return sizes.Bool;

+

+	NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS

+	default:

+		PX_ASSERT( 0 && "Unexpected type" );

+	}

+

+	return UINT32_MAX; //This is never reached

+}

+

+bool PlatformABI::VerifyCurrentPlatform()

+{

+	//See PlatformABI::isNormal

+

+	uint8_t one = 1,

+		zero = 0;

+

+	struct Empty {};

+

+	return 1 == GetAlignment<bool>::value && 1 == sizeof(bool)

+		&& 1 == GetAlignment<uint8_t>::value

+		&& 1 == GetAlignment<char>::value

+		&& 4 == sizeof(float)

+		&& *(bool *)&one //We assume that 0x1 corresponds to true internally

+		&& !*(bool *)&zero //We assume that 0x0 corresponds to false internally

+		&& 1 == sizeof(Empty); // Serializer expects sizeof empty struct to be 1

+}

diff --git a/sdk/extensions/import/apexmodules/NvParameterized/src/PlatformInputStream.cpp b/sdk/extensions/import/apexmodules/NvParameterized/src/PlatformInputStream.cpp
index f3c6ace..04ba6c3 100644..100755
--- a/sdk/extensions/import/apexmodules/NvParameterized/src/PlatformInputStream.cpp
+++ b/sdk/extensions/import/apexmodules/NvParameterized/src/PlatformInputStream.cpp
@@ -1,336 +1,336 @@
-// 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) 2008-2013 NVIDIA Corporation. All rights reserved.
-
-// WARNING: before doing any changes to this file
-// check comments at the head of BinSerializer.cpp
-
-#include "PlatformInputStream.h"
-
-using namespace NvParameterized;
-
-PlatformInputStream::PlatformInputStream(physx::PxFileBuf &stream, const PlatformABI &targetParams, Traits *traits)
-	: PlatformStream(targetParams, traits), mStream(stream), mPos(traits), mStartPos(stream.tellRead())
-{}
-
-Serializer::ErrorType PlatformInputStream::skipBytes(uint32_t nbytes)
-{
-	uint32_t newPos = mStream.tellRead() + nbytes;
-
-	if( newPos >= mStream.getFileLength() )
-	{
-		DEBUG_ALWAYS_ASSERT();
-		return Serializer::ERROR_INVALID_INTERNAL_PTR;
-	}
-
-	mStream.seekRead(newPos);
-
-	return Serializer::ERROR_NONE;
-}
-
-Serializer::ErrorType PlatformInputStream::pushPos(uint32_t newPos)
-{
-	if( !newPos )
-	{
-		//Trying to access NULL
-		DEBUG_ALWAYS_ASSERT();
-		return Serializer::ERROR_INVALID_INTERNAL_PTR;
-	}
-
-	if( mStartPos + newPos >= mStream.getFileLength() )
-	{
-		DEBUG_ALWAYS_ASSERT();
-		return Serializer::ERROR_INVALID_INTERNAL_PTR;
-	}
-
-	mPos.pushBack(mStream.tellRead());
-	mStream.seekRead(mStartPos + newPos);
-
-	return Serializer::ERROR_NONE;
-}
-
-void PlatformInputStream::popPos()
-{
-	mStream.seekRead(mPos.back());
-	mPos.popBack();
-}
-
-uint32_t PlatformInputStream::getPos() const
-{
-	return mStream.tellRead() - mStartPos;
-}
-
-Serializer::ErrorType PlatformInputStream::readString(uint32_t off, const char *&s)
-{
-	if( !off )
-	{
-		s = 0;
-		return Serializer::ERROR_NONE;
-	}
-
-	NV_ERR_CHECK_RETURN( pushPos(off) );
-
-	StringBuf buf(mTraits);
-	buf.reserve(10);
-
-	int8_t c;
-	do
-	{
-		NV_ERR_CHECK_RETURN( read(c) );
-		buf.append((char)c);
-	} while( c );
-
-	popPos();
-
-	s = buf.getBuffer();
-	return Serializer::ERROR_NONE;
-}
-
-Serializer::ErrorType PlatformInputStream::readObjHeader(ObjHeader &hdr)
-{
-	uint32_t align_ = NvMax3(mTargetParams.aligns.Bool, mTargetParams.aligns.i32, mTargetParams.aligns.pointer);
-
-	beginStruct(align_);
-
-	uint32_t prevPos = getPos();
-
-	uint32_t relOffset;
-	NV_ERR_CHECK_RETURN(read(relOffset));
-
-	hdr.dataOffset = prevPos + relOffset; //Convert relative offset to absolute
-
-	uint32_t classNameOff;
-	NV_ERR_CHECK_RETURN( readPtr(classNameOff) );
-	NV_ERR_CHECK_RETURN( readString(classNameOff, hdr.className) );
-
-	uint32_t nameOff;
-	NV_ERR_CHECK_RETURN( readPtr(nameOff) );
-	NV_ERR_CHECK_RETURN( readString(nameOff, hdr.name) );
-
-	NV_ERR_CHECK_RETURN( read(hdr.isIncluded) );
-	NV_ERR_CHECK_RETURN( read(hdr.version) );
-	NV_ERR_CHECK_RETURN( read(hdr.checksumSize) );
-
-	uint32_t chkOff;
-	NV_ERR_CHECK_RETURN( readPtr(chkOff) );
-
-	if( !chkOff )
-		hdr.checksum = 0;
-	else
-	{
-		NV_ERR_CHECK_RETURN( pushPos(chkOff) );
-
-		//TODO: usually we can avoid memory allocation here because checksumSize is 4
-		hdr.checksum = (uint32_t *)mTraits->alloc(4 * hdr.checksumSize);
-		for(uint32_t i = 0; i < hdr.checksumSize; ++i)
-			NV_ERR_CHECK_RETURN( read( const_cast<uint32_t &>(hdr.checksum[i]) ) );
-
-		popPos();
-	}
-
-	closeStruct();
-
-	NV_ERR_CHECK_RETURN( pushPos(hdr.dataOffset) );
-
-	//Skip NvParameters fields
-	//WARN: this depends on implementation of NvParameters
-
-	beginStruct(physx::PxMax(mTargetParams.aligns.pointer, mTargetParams.aligns.Bool));
-
-	uint32_t tmp;
-	for(uint32_t i = 0; i < 8; readPtr(tmp), ++i); //vtable and other fields
-
-	bool mDoDeallocateSelf;
-	NV_ERR_CHECK_RETURN( read(mDoDeallocateSelf) );
-
-	bool mDoDeallocateName;
-	NV_ERR_CHECK_RETURN( read(mDoDeallocateName) );
-
-	bool mDoDeallocateClassName;
-	NV_ERR_CHECK_RETURN( read(mDoDeallocateClassName) );
-
-	//See note in beginObject
-	if( !mTargetParams.doReuseParentPadding )
-		closeStruct();
-
-	hdr.dataOffset = getPos();
-
-	popPos();
-
-	return Serializer::ERROR_NONE;
-}
-
-Serializer::ErrorType PlatformInputStream::readSimpleStructArray(Handle &handle)
-{
-	int32_t n;
-	handle.getArraySize(n);
-
-	const NvParameterized::Definition *pdStruct = handle.parameterDefinition()->child(0);
-	int32_t nfields = pdStruct->numChildren();
-
-	uint32_t align_ = getTargetAlignment(pdStruct),
-		pad_ = getTargetPadding(pdStruct); 
-
-	align(align_);
-
-	for(int32_t i = 0; i < n; ++i)
-	{
-		beginStruct(align_, pad_);
-		handle.set(i);
-
-		for(int32_t j = 0; j < nfields; ++j)
-		{
-			handle.set(j);
-
-			const Definition *pdField = pdStruct->child(j);
-
-			if( pdField->alignment() )
-				align( pdField->alignment() );
-
-			if( pdField->hint("DONOTSERIALIZE") )
-			{
-				//Simply skip bytes
-				align(getTargetAlignment(pdField));
-				NV_ERR_CHECK_RETURN( skipBytes(getTargetSize(pdField)) );
-			}
-			else
-			{
-				//No need to align structs because of tail padding
-				switch( pdField->type() )
-				{
-#				define NV_PARAMETERIZED_TYPES_NO_LEGACY_TYPES
-#				define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES
-#				define NV_PARAMETERIZED_TYPES_NO_STRING_TYPES
-#				define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \
-				case TYPE_##enum_name: \
-					{ \
-						c_type val; \
-						NV_ERR_CHECK_RETURN(read(val)); \
-						handle.setParam##type_name(val); \
-						break; \
-					}
-#					include "nvparameterized/NvParameterized_types.h"
-
-				case TYPE_MAT34:
-					{
-						float val[12];
-						for (int k = 0; k < 12; ++k)
-						{
-							NV_ERR_CHECK_RETURN(read(val[k]));
-						}
-						handle.setParamMat34Legacy(val);
-						break;
-					}
-				NV_PARAMETRIZED_NO_MATH_DATATYPE_LABELS
-				default:
-					DEBUG_ASSERT( 0 && "Unexpected type" );
-					return Serializer::ERROR_UNKNOWN;
-				}
-			}
-
-			handle.popIndex();
-		} //j
-
-		handle.popIndex();
-		closeStruct();
-	} //i
-
-	return Serializer::ERROR_NONE;
-}
-
-void PlatformInputStream::beginStruct(uint32_t align_, uint32_t pad_)
-{
-	mStack.pushBack(Agregate(Agregate::STRUCT, pad_));
-	align(align_); // Align _after_ we push array because otherwise align() would be ignored
-}
-
-void PlatformInputStream::beginStruct(uint32_t align_)
-{
-	beginStruct(align_, align_);
-}
-
-void PlatformInputStream::beginStruct(const Definition *pd)
-{
-	beginStruct(getTargetAlignment(pd), getTargetPadding(pd));
-}
-
-void PlatformInputStream::closeStruct()
-{
-	PX_ASSERT(mStack.size() > 0);
-
-	align(mStack.back().align); //Tail padding
-	mStack.popBack();
-}
-
-void PlatformInputStream::beginString()
-{
-	beginStruct(physx::PxMax(mTargetParams.aligns.pointer, mTargetParams.aligns.Bool));
-}
-
-void PlatformInputStream::closeString()
-{
-	closeStruct();
-}
-
-void PlatformInputStream::beginArray(const Definition *pd)
-{
-	uint32_t align_ = getTargetAlignment(pd);
-	align(align_);  // Align _before_ we push array because otherwise align() would be ignored
-	mStack.pushBack(Agregate(Agregate::ARRAY, align_));
-}
-
-void PlatformInputStream::closeArray()
-{
-	// No padding in arrays
-	mStack.popBack();
-}
-
-void PlatformInputStream::align(uint32_t border)
-{
-	mStream.seekRead(mStartPos + getAlign(getPos(), border));
-}
-
-Serializer::ErrorType PlatformInputStream::readPtr(uint32_t &val)
-{
-	//Do not align on uint32_t or uint64_t boundary (already aligned at pointer boundary)
-	align(mTargetParams.aligns.pointer);
-	if( 4 == mTargetParams.sizes.pointer )
-	{
-		return read(val, false);
-	}
-	else
-	{
-		PX_ASSERT( 8 == mTargetParams.sizes.pointer );
-
-		uint64_t val64;
-		NV_ERR_CHECK_RETURN( read(val64, false) );
-
-		val = (uint32_t)val64;
-		PX_ASSERT( val == val64 );
-
-		return Serializer::ERROR_NONE;
-	}
-}
+// 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) 2008-2013 NVIDIA Corporation. All rights reserved.

+

+// WARNING: before doing any changes to this file

+// check comments at the head of BinSerializer.cpp

+

+#include "PlatformInputStream.h"

+

+using namespace NvParameterized;

+

+PlatformInputStream::PlatformInputStream(physx::PxFileBuf &stream, const PlatformABI &targetParams, Traits *traits)

+	: PlatformStream(targetParams, traits), mStream(stream), mPos(traits), mStartPos(stream.tellRead())

+{}

+

+Serializer::ErrorType PlatformInputStream::skipBytes(uint32_t nbytes)

+{

+	uint32_t newPos = mStream.tellRead() + nbytes;

+

+	if( newPos >= mStream.getFileLength() )

+	{

+		DEBUG_ALWAYS_ASSERT();

+		return Serializer::ERROR_INVALID_INTERNAL_PTR;

+	}

+

+	mStream.seekRead(newPos);

+

+	return Serializer::ERROR_NONE;

+}

+

+Serializer::ErrorType PlatformInputStream::pushPos(uint32_t newPos)

+{

+	if( !newPos )

+	{

+		//Trying to access NULL

+		DEBUG_ALWAYS_ASSERT();

+		return Serializer::ERROR_INVALID_INTERNAL_PTR;

+	}

+

+	if( mStartPos + newPos >= mStream.getFileLength() )

+	{

+		DEBUG_ALWAYS_ASSERT();

+		return Serializer::ERROR_INVALID_INTERNAL_PTR;

+	}

+

+	mPos.pushBack(mStream.tellRead());

+	mStream.seekRead(mStartPos + newPos);

+

+	return Serializer::ERROR_NONE;

+}

+

+void PlatformInputStream::popPos()

+{

+	mStream.seekRead(mPos.back());

+	mPos.popBack();

+}

+

+uint32_t PlatformInputStream::getPos() const

+{

+	return mStream.tellRead() - mStartPos;

+}

+

+Serializer::ErrorType PlatformInputStream::readString(uint32_t off, const char *&s)

+{

+	if( !off )

+	{

+		s = 0;

+		return Serializer::ERROR_NONE;

+	}

+

+	NV_ERR_CHECK_RETURN( pushPos(off) );

+

+	StringBuf buf(mTraits);

+	buf.reserve(10);

+

+	int8_t c;

+	do

+	{

+		NV_ERR_CHECK_RETURN( read(c) );

+		buf.append((char)c);

+	} while( c );

+

+	popPos();

+

+	s = buf.getBuffer();

+	return Serializer::ERROR_NONE;

+}

+

+Serializer::ErrorType PlatformInputStream::readObjHeader(ObjHeader &hdr)

+{

+	uint32_t align_ = NvMax3(mTargetParams.aligns.Bool, mTargetParams.aligns.i32, mTargetParams.aligns.pointer);

+

+	beginStruct(align_);

+

+	uint32_t prevPos = getPos();

+

+	uint32_t relOffset;

+	NV_ERR_CHECK_RETURN(read(relOffset));

+

+	hdr.dataOffset = prevPos + relOffset; //Convert relative offset to absolute

+

+	uint32_t classNameOff;

+	NV_ERR_CHECK_RETURN( readPtr(classNameOff) );

+	NV_ERR_CHECK_RETURN( readString(classNameOff, hdr.className) );

+

+	uint32_t nameOff;

+	NV_ERR_CHECK_RETURN( readPtr(nameOff) );

+	NV_ERR_CHECK_RETURN( readString(nameOff, hdr.name) );

+

+	NV_ERR_CHECK_RETURN( read(hdr.isIncluded) );

+	NV_ERR_CHECK_RETURN( read(hdr.version) );

+	NV_ERR_CHECK_RETURN( read(hdr.checksumSize) );

+

+	uint32_t chkOff;

+	NV_ERR_CHECK_RETURN( readPtr(chkOff) );

+

+	if( !chkOff )

+		hdr.checksum = 0;

+	else

+	{

+		NV_ERR_CHECK_RETURN( pushPos(chkOff) );

+

+		//TODO: usually we can avoid memory allocation here because checksumSize is 4

+		hdr.checksum = (uint32_t *)mTraits->alloc(4 * hdr.checksumSize);

+		for(uint32_t i = 0; i < hdr.checksumSize; ++i)

+			NV_ERR_CHECK_RETURN( read( const_cast<uint32_t &>(hdr.checksum[i]) ) );

+

+		popPos();

+	}

+

+	closeStruct();

+

+	NV_ERR_CHECK_RETURN( pushPos(hdr.dataOffset) );

+

+	//Skip NvParameters fields

+	//WARN: this depends on implementation of NvParameters

+

+	beginStruct(physx::PxMax(mTargetParams.aligns.pointer, mTargetParams.aligns.Bool));

+

+	uint32_t tmp;

+	for(uint32_t i = 0; i < 8; readPtr(tmp), ++i); //vtable and other fields

+

+	bool mDoDeallocateSelf;

+	NV_ERR_CHECK_RETURN( read(mDoDeallocateSelf) );

+

+	bool mDoDeallocateName;

+	NV_ERR_CHECK_RETURN( read(mDoDeallocateName) );

+

+	bool mDoDeallocateClassName;

+	NV_ERR_CHECK_RETURN( read(mDoDeallocateClassName) );

+

+	//See note in beginObject

+	if( !mTargetParams.doReuseParentPadding )

+		closeStruct();

+

+	hdr.dataOffset = getPos();

+

+	popPos();

+

+	return Serializer::ERROR_NONE;

+}

+

+Serializer::ErrorType PlatformInputStream::readSimpleStructArray(Handle &handle)

+{

+	int32_t n;

+	handle.getArraySize(n);

+

+	const NvParameterized::Definition *pdStruct = handle.parameterDefinition()->child(0);

+	int32_t nfields = pdStruct->numChildren();

+

+	uint32_t align_ = getTargetAlignment(pdStruct),

+		pad_ = getTargetPadding(pdStruct); 

+

+	align(align_);

+

+	for(int32_t i = 0; i < n; ++i)

+	{

+		beginStruct(align_, pad_);

+		handle.set(i);

+

+		for(int32_t j = 0; j < nfields; ++j)

+		{

+			handle.set(j);

+

+			const Definition *pdField = pdStruct->child(j);

+

+			if( pdField->alignment() )

+				align( pdField->alignment() );

+

+			if( pdField->hint("DONOTSERIALIZE") )

+			{

+				//Simply skip bytes

+				align(getTargetAlignment(pdField));

+				NV_ERR_CHECK_RETURN( skipBytes(getTargetSize(pdField)) );

+			}

+			else

+			{

+				//No need to align structs because of tail padding

+				switch( pdField->type() )

+				{

+#				define NV_PARAMETERIZED_TYPES_NO_LEGACY_TYPES

+#				define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES

+#				define NV_PARAMETERIZED_TYPES_NO_STRING_TYPES

+#				define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \

+				case TYPE_##enum_name: \

+					{ \

+						c_type val; \

+						NV_ERR_CHECK_RETURN(read(val)); \

+						handle.setParam##type_name(val); \

+						break; \

+					}

+#					include "nvparameterized/NvParameterized_types.h"

+

+				case TYPE_MAT34:

+					{

+						float val[12];

+						for (int k = 0; k < 12; ++k)

+						{

+							NV_ERR_CHECK_RETURN(read(val[k]));

+						}

+						handle.setParamMat34Legacy(val);

+						break;

+					}

+				NV_PARAMETRIZED_NO_MATH_DATATYPE_LABELS

+				default:

+					DEBUG_ASSERT( 0 && "Unexpected type" );

+					return Serializer::ERROR_UNKNOWN;

+				}

+			}

+

+			handle.popIndex();

+		} //j

+

+		handle.popIndex();

+		closeStruct();

+	} //i

+

+	return Serializer::ERROR_NONE;

+}

+

+void PlatformInputStream::beginStruct(uint32_t align_, uint32_t pad_)

+{

+	mStack.pushBack(Agregate(Agregate::STRUCT, pad_));

+	align(align_); // Align _after_ we push array because otherwise align() would be ignored

+}

+

+void PlatformInputStream::beginStruct(uint32_t align_)

+{

+	beginStruct(align_, align_);

+}

+

+void PlatformInputStream::beginStruct(const Definition *pd)

+{

+	beginStruct(getTargetAlignment(pd), getTargetPadding(pd));

+}

+

+void PlatformInputStream::closeStruct()

+{

+	PX_ASSERT(mStack.size() > 0);

+

+	align(mStack.back().align); //Tail padding

+	mStack.popBack();

+}

+

+void PlatformInputStream::beginString()

+{

+	beginStruct(physx::PxMax(mTargetParams.aligns.pointer, mTargetParams.aligns.Bool));

+}

+

+void PlatformInputStream::closeString()

+{

+	closeStruct();

+}

+

+void PlatformInputStream::beginArray(const Definition *pd)

+{

+	uint32_t align_ = getTargetAlignment(pd);

+	align(align_);  // Align _before_ we push array because otherwise align() would be ignored

+	mStack.pushBack(Agregate(Agregate::ARRAY, align_));

+}

+

+void PlatformInputStream::closeArray()

+{

+	// No padding in arrays

+	mStack.popBack();

+}

+

+void PlatformInputStream::align(uint32_t border)

+{

+	mStream.seekRead(mStartPos + getAlign(getPos(), border));

+}

+

+Serializer::ErrorType PlatformInputStream::readPtr(uint32_t &val)

+{

+	//Do not align on uint32_t or uint64_t boundary (already aligned at pointer boundary)

+	align(mTargetParams.aligns.pointer);

+	if( 4 == mTargetParams.sizes.pointer )

+	{

+		return read(val, false);

+	}

+	else

+	{

+		PX_ASSERT( 8 == mTargetParams.sizes.pointer );

+

+		uint64_t val64;

+		NV_ERR_CHECK_RETURN( read(val64, false) );

+

+		val = (uint32_t)val64;

+		PX_ASSERT( val == val64 );

+

+		return Serializer::ERROR_NONE;

+	}

+}

diff --git a/sdk/extensions/import/apexmodules/NvParameterized/src/PlatformOutputStream.cpp b/sdk/extensions/import/apexmodules/NvParameterized/src/PlatformOutputStream.cpp
index 74ae68e..437e72c 100644..100755
--- a/sdk/extensions/import/apexmodules/NvParameterized/src/PlatformOutputStream.cpp
+++ b/sdk/extensions/import/apexmodules/NvParameterized/src/PlatformOutputStream.cpp
@@ -1,560 +1,560 @@
-// 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) 2008-2013 NVIDIA Corporation. All rights reserved.
-
-// WARNING: before doing any changes to this file
-// check comments at the head of BinSerializer.cpp
-
-#include "PlatformOutputStream.h"
-#include <stdint.h>
-
-using namespace NvParameterized;
-
-#ifndef WITHOUT_APEX_SERIALIZATION
-
-Reloc::Reloc(RelocType type_, uint32_t ptrPos_, const PlatformOutputStream &parent)
-	: type(type_),
-	ptrPos(ptrPos_),
-	traits(parent.mTraits)
-{
-	ptrData = reinterpret_cast<PlatformOutputStream *>(traits->alloc(sizeof(PlatformOutputStream)));
-	PX_PLACEMENT_NEW(ptrData, PlatformOutputStream)(parent.mTargetParams, parent.mTraits, parent.dict);
-}
-
-Reloc::Reloc(const Reloc &cinfo): type(cinfo.type), ptrPos(cinfo.ptrPos), traits(cinfo.traits)
-{
-	Reloc &info = (Reloc &)cinfo;
-
-	//Take ownership of stream to avoid slow recursive copies (especially when reallocating array elements)
-	ptrData = info.ptrData;
-	info.ptrData = 0;
-}
-
-Reloc::~Reloc()
-{
-	if( ptrData )
-	{
-		ptrData->~PlatformOutputStream();
-		traits->free(ptrData);
-	}
-}
-
-PlatformOutputStream::PlatformOutputStream(const PlatformABI &targetParams, Traits *traits, Dictionary &dict_)
-	: PlatformStream(targetParams, traits),
-	data(traits),
-	mRelocs(Traits::Allocator(traits)),
-	mStrings(Traits::Allocator(traits)),
-	mMerges(Traits::Allocator(traits)),
-	dict(dict_),
-	mTotalAlign(1)
-{}
-
-PlatformOutputStream::PlatformOutputStream(const PlatformOutputStream &s)
-	: PlatformStream(s),
-	data(s.data),
-	mRelocs(Traits::Allocator(s.mTraits)),
-	mStrings(Traits::Allocator(s.mTraits)),
-	mMerges(Traits::Allocator(s.mTraits)),
-	dict(s.dict),
-	mTotalAlign(1)
-{
-	mRelocs.reserve(s.mRelocs.size());
-	for(uint32_t i = 0; i < s.mRelocs.size(); ++i)
-		mRelocs.pushBack(s.mRelocs[i]);
-
-	mStrings.reserve(s.mStrings.size());
-	for(uint32_t i = 0; i < s.mStrings.size(); ++i)
-		mStrings.pushBack(s.mStrings[i]);
-
-	mMerges.reserve(s.mMerges.size());
-	for(uint32_t i = 0; i < s.mMerges.size(); ++i)
-		mMerges.pushBack(s.mMerges[i]);
-}
-
-#ifndef NDEBUG
-void PlatformOutputStream::dump() const
-{
-	PlatformStream::dump();
-
-	dumpBytes(data, size());
-
-	fflush(stdout);
-	for(uint32_t i = 0; i < mRelocs.size(); ++i)
-	{
-		printf("Relocation %d at %x:\n", (int)i, mRelocs[i].ptrPos);
-		mRelocs[i].ptrData->dump();
-	}
-
-	fflush(stdout);
-}
-#endif
-
-void PlatformOutputStream::storeU32At(uint32_t x, uint32_t i)
-{
-	if( mCurParams.endian != mTargetParams.endian )
-		SwapBytes(reinterpret_cast<char *>(&x), 4U, TYPE_U32);
-
-	*reinterpret_cast<uint32_t *>(&data[i]) = x;
-}
-
-uint32_t PlatformOutputStream::storeString(const char *s)
-{
-	uint32_t off = storeSimple((uint8_t)*s);
-	while( *s++ )
-		storeSimple((uint8_t)*s);
-
-	return off;
-}
-
-uint32_t PlatformOutputStream::storeBytes(const char *s, uint32_t n)
-{
-	if( !n )
-		return size();
-
-	uint32_t off = storeSimple((uint8_t)s[0]);
-	for(uint32_t i = 1; i < n; ++i)
-		storeSimple((uint8_t)s[i]);
-
-	return off;
-}
-
-uint32_t PlatformOutputStream::beginStruct(uint32_t align_, uint32_t pad_)
-{
-	uint32_t off = size();
-	mStack.pushBack(Agregate(Agregate::STRUCT, pad_));
-	align(align_); // Align _after_ we push struct to avoid ignored align() when inside array
-	return off;
-}
-
-uint32_t PlatformOutputStream::beginStruct(uint32_t align_)
-{
-	return beginStruct(align_, align_);
-}
-
-uint32_t PlatformOutputStream::beginStruct(const Definition *pd)
-{
-	return beginStruct(getTargetAlignment(pd), getTargetPadding(pd));
-}
-
-void PlatformOutputStream::closeStruct()
-{
-	PX_ASSERT(mStack.size() > 0);
-
-	//Tail padding
-	align(mStack.back().align);// Align _before_ we pop struct to avoid ignored align() when inside array
-	mStack.popBack();
-}
-
-uint32_t PlatformOutputStream::beginString()
-{
-	return beginStruct(physx::PxMax(mTargetParams.aligns.pointer, mTargetParams.aligns.Bool));
-}
-
-void PlatformOutputStream::closeString()
-{
-	closeStruct();
-}
-
-uint32_t PlatformOutputStream::beginArray(const Definition *pd)
-{
-	return beginArray(getTargetAlignment(pd));
-}
-
-uint32_t PlatformOutputStream::beginArray(uint32_t align_)
-{
-	align(align_); // Align _before_ we push array because otherwise align() would be ignored
-	uint32_t off = size();
-	mStack.pushBack(Agregate(Agregate::ARRAY, align_));
-	return off;
-}
-
-void PlatformOutputStream::closeArray()
-{
-	// No tail padding when in array
-	mStack.popBack();
-}
-
-void PlatformOutputStream::skipBytes(uint32_t nbytes)
-{
-	data.skipBytes(nbytes);
-}
-
-void PlatformOutputStream::align(uint32_t border)
-{
-	bool isAligned;
-	uint32_t newSize = getAlign(size(), border, isAligned);
-
-	if( isAligned )
-		mTotalAlign = physx::PxMax(mTotalAlign, border);
-
-	data.skipBytes(newSize - size());
-}
-
-void PlatformOutputStream::mergeDict()
-{
-	for(uint32_t i = 0; i < dict.size(); ++i)
-	{
-		const char *s = dict.get(i);
-		uint32_t off = storeString(s);
-		dict.setOffset(s, off);
-	}
-}
-
-uint32_t PlatformOutputStream::storeNullPtr()
-{
-	//Do not align on uint32_t or uint64_t boundary (already aligned at pointer boundary)
-	align(mTargetParams.aligns.pointer);
-	uint32_t off = size();
-	if( 4 == mTargetParams.sizes.pointer )
-		data.skipBytes(4);
-	else
-	{
-		PX_ASSERT( 8 == mTargetParams.sizes.pointer );
-		data.skipBytes(8);
-	}
-	return off;
-}
-
-Reloc &PlatformOutputStream::storePtr(RelocType type, uint32_t align)
-{
-	uint32_t off = storeNullPtr();
-	mRelocs.pushBack(Reloc(type, off, *this));
-	mRelocs.back().ptrData->setAlignment(align);
-	return mRelocs.back();
-}
-
-Reloc &PlatformOutputStream::storePtr(RelocType type, const Definition *pd)
-{
-	return storePtr(type, getTargetAlignment(pd));
-}
-
-void PlatformOutputStream::storeStringPtr(const char *s)
-{
-	uint32_t off = storeNullPtr();
-	if( s )
-	{
-		mStrings.pushBack(StringReloc(off, s));
-		dict.put(s);
-	}
-}
-
-uint32_t PlatformOutputStream::storeSimpleStructArray(Handle &handle)
-{
-	int32_t n;
-	handle.getArraySize(n);
-
-	const NvParameterized::Definition *pdStruct = handle.parameterDefinition()->child(0);
-	int32_t nfields = pdStruct->numChildren();
-
-	uint32_t align_ = getTargetAlignment(pdStruct),
-		size_ = getTargetSize(pdStruct),
-		pad_ = getTargetPadding(pdStruct);
-
-	align(align_);
-	uint32_t off = size();
-
-	data.reserve(size() + n * physx::PxMax(align_, size_));
-
-	char *p = data;
-	p += data.size();
-
-	for(int32_t i = 0; i < n; ++i)
-	{
-		beginStruct(align_, pad_);
-		handle.set(i);
-
-		for(int32_t j = 0; j < nfields; ++j)
-		{
-			handle.set(j);
-
-			const Definition *pdField = pdStruct->child(j);
-
-			if( pdField->alignment() )
-				align( pdField->alignment() );
-
-			if( pdField->hint("DONOTSERIALIZE") )
-			{
-				//Simply skip bytes
-				align(getTargetAlignment(pdField));
-				skipBytes(getTargetSize(pdField));
-			}
-			else
-			{
-				//No need to align structs because of tail padding
-				switch( pdField->type() )
-				{
-#				define NV_PARAMETERIZED_TYPES_NO_LEGACY_TYPES
-#				define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES
-#				define NV_PARAMETERIZED_TYPES_NO_STRING_TYPES
-#				define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \
-					case TYPE_##enum_name: \
-					{ \
-						c_type val; \
-						handle.getParam##type_name(val); \
-						storeSimple<c_type>(val); \
-						break; \
-					}
-#					include "nvparameterized/NvParameterized_types.h"
-
-				case TYPE_MAT34:
-				{
-					float val[12];
-					handle.getParamMat34Legacy(val);
-					storeSimple(val, 12);
-					break;
-				}
-
-				NV_PARAMETRIZED_NO_MATH_DATATYPE_LABELS 
-				default:
-					DEBUG_ASSERT( 0 && "Unexpected type" );
-					return UINT32_MAX;
-				}
-			}
-
-			handle.popIndex();
-		} //j
-
-		handle.popIndex();
-		closeStruct();
-	} //i
-
-	return off;
-}
-
-uint32_t PlatformOutputStream::storeObjHeader(const NvParameterized::Interface &obj, bool isIncluded)
-{
-	uint32_t align_ = NvMax3(mTargetParams.aligns.Bool, mTargetParams.aligns.i32, mTargetParams.aligns.pointer);
-
-	uint32_t off = beginStruct(align_);
-
-	uint32_t hdrOff = data.size();
-	PX_ASSERT( hdrOff % sizeof(uint32_t) == 0 );
-
-	storeSimple(uint32_t(0)); //Data offset
-
-	//className
-	storeStringPtr(obj.className());
-
-	//name
-	storeStringPtr(obj.name());
-
-	//isIncluded
-	storeSimple(isIncluded);
-
-	//version
-	storeSimple<uint32_t>(obj.version());
-
-	//checksum size
-	uint32_t bits = (uint32_t)-1;
-	const uint32_t *checksum = obj.checksum(bits);
-	PX_ASSERT( bits % 32 == 0 ); //32 bits in uint32_t
-	uint32_t i32s = bits / 32;
-	storeSimple(i32s);
-
-	//checksum pointer
-	Reloc &reloc = storePtr(RELOC_ABS_RAW, mTargetParams.aligns.i32);
-	for(uint32_t i = 0; i < i32s; ++i)
-		reloc.ptrData->storeSimple(checksum[i]);
-
-	closeStruct();
-
-	//We force alignment to calculate dataOffset
-	//(when object is inserted no additional padding will be inserted)
-
-	const Definition *pd = obj.rootParameterDefinition();
-	uint32_t customAlign = pd ? getTargetAlignment(pd) : 1;
-	align(physx::PxMax(16U, customAlign)); //16 for safety
-
-	storeU32At(data.size() - hdrOff, hdrOff); //Now we know object data offset
-
-	return off;
-}
-
-uint32_t PlatformOutputStream::beginObject(const NvParameterized::Interface &obj, bool /*isRoot*/, const Definition *pd)
-{
-	//NvParameterized objects is derived from NvParameters so we need to store its fields as well.
-
-	//WARN: this implementation _heavily_ depends on implementation of NvParameters
-
-	//Alignment of NvParameters
-	uint32_t parentAlign = physx::PxMax(mTargetParams.aligns.pointer, mTargetParams.aligns.Bool),
-		childAlign = pd ? getTargetAlignment(pd) : 1,
-		totalAlign = physx::PxMax(parentAlign, childAlign);
-
-	uint32_t off = beginStruct(totalAlign);
-
-	//NvParameters fields
-	for(uint32_t i = 0; i < 6; storeNullPtr(), ++i); //vtable and other fields
-	storeStringPtr(obj.name()); //mName
-	storeStringPtr(obj.className()); //mClassName
-	storeSimple(true); //mDoDeallocateSelf (all objects are responsible for memory deallocation)
-	storeSimple(false); //mDoDeallocateName
-	storeSimple(false); //mDoDeallocateClassName
-
-	//Some general theory of alignment handling
-	//Imagine that we have class:
-	//class A: A1, A2, ... An
-	//{
-	//	T1 f1;
-	//	T2 f2;
-	//};
-	//Then all Ai/fi are aligned on natural boundary. Whether or not padding bytes for Ai are inserted
-	//and whether or not Ai+1 or fi may reuse those bytes depends on compiler;
-	//we store this info in PlatformABI's doReusePadding flag.
-	//doReusePadding == false means that padding bytes are always there.
-	//doReusePadding == true means that padding bytes are _not_ inserted for non-POD Ai but are inserted for POD Ai.
-	//(I have yet to see compiler that does not insert padding bytes for POD base class!).
-
-	//Compilers may handle derived classes in two different ways.
-	//Say we have
-	//	class B {int x; char y; };
-	//	class A: public B {char z; };
-	//Then in pure C code this may look like either as
-	//	struct A { struct { int x; char y; } b; char z; };
-	//or as
-	//	struct A { int x; char y; char z; };
-	//(the latter is usual if B is not POD).
-	//Take care of that here (NvParameters is not POD!).
-	if( !mTargetParams.doReuseParentPadding )
-		align(parentAlign); //Insert tail padding for NvParameters
-
-	//ParametersStruct is aligned on natural boundary
-	align(childAlign);
-
-	return off;
-}
-
-uint32_t PlatformOutputStream::merge(const PlatformOutputStream &mergee)
-{
-	//All structs should be closed
-	PX_ASSERT( !mergee.mStack.size() );
-
-	align(mergee.alignment());
-
-	uint32_t base = data.size();
-
-	data.appendBytes(mergee.data, mergee.data.size());
-
-	//Update relocations
-
-	mRelocs.reserve(mRelocs.size() + mergee.mRelocs.size());
-	for(uint32_t i = 0; i < mergee.mRelocs.size(); ++i)
-	{
-		mRelocs.pushBack(mergee.mRelocs[i]);
-		mRelocs.back().ptrPos += base;
-	}
-
-	mStrings.reserve(mStrings.size() + mergee.mStrings.size());
-	for(uint32_t i = 0; i < mergee.mStrings.size(); ++i)
-	{
-		mStrings.pushBack(mergee.mStrings[i]);
-		mStrings.back().ptrPos += base;
-	}
-
-	mMerges.reserve(mMerges.size() + mergee.mMerges.size());
-	for(uint32_t i = 0; i < mergee.mMerges.size(); ++i)
-	{
-		mMerges.pushBack(mergee.mMerges[i]);
-
-		mMerges.back().ptrPos += base;
-		if( !mergee.mMerges[i].isExtern )
-			mMerges.back().targetPos += base;
-	}
-
-	return base;
-}
-
-void PlatformOutputStream::flatten()
-{
-	//It's very important that data for child objects is stored
-	//after current object to allow safe initialization
-
-	//Generic pointers
-	for(uint32_t i = 0; i < mRelocs.size(); ++i)
-	{
-		Reloc &reloc = mRelocs[i];
-
-		//Recursively add data which is pointed-to
-
-		align( reloc.ptrData->alignment() );
-
-		MergedReloc m = { reloc.ptrPos, data.size(), reloc.type, false };
-		mMerges.pushBack(m);
-
-		merge(*reloc.ptrData); //Internal pointers are recursively added here
-	}
-
-	//String pointers
-	for(uint32_t i = 0; i < mStrings.size(); ++i)
-	{
-		//String pointers are external and absolute
-		MergedReloc m = { mStrings[i].ptrPos, dict.getOffset(mStrings[i].s), RELOC_ABS_RAW, true };
-		mMerges.pushBack(m);
-	}
-
-	mRelocs.clear();
-	mStrings.clear();
-}
-
-uint32_t PlatformOutputStream::writeRelocs()
-{
-	uint32_t ptrOff = storeSimple<uint32_t>(mMerges.size()); //Offset of relocation table
-
-	data.reserve(mMerges.size() * 2 * physx::PxMax(4U, mTargetParams.aligns.i32));
-
-	for(uint32_t i = 0; i < mMerges.size(); ++i)
-	{
-		char *ptr = &data[mMerges[i].ptrPos];
-		if( 4 == mTargetParams.sizes.pointer )
-		{
-			uint32_t *ptrAsInt = reinterpret_cast<uint32_t *>(ptr);
-			*ptrAsInt = mMerges[i].targetPos;
-			if( mTargetParams.endian != mCurParams.endian )
-				SwapBytes(ptr, 4U, TYPE_U32);
-		}
-		else
-		{
-			PX_ASSERT(8 == mTargetParams.sizes.pointer);
-
-			uint64_t *ptrAsInt = reinterpret_cast<uint64_t *>(ptr);
-			*ptrAsInt = mMerges[i].targetPos;
-			if( mTargetParams.endian != mCurParams.endian )
-				SwapBytes(ptr, 8U, TYPE_U64);
-		}
-
-		//BinaryReloc struct
-		beginStruct(mTargetParams.aligns.i32);
-		storeSimple<uint32_t>(static_cast<uint32_t>(mMerges[i].type));
-		storeSimple<uint32_t>(mMerges[i].ptrPos);
-		closeStruct();
-	}
-
-	mMerges.clear();
-
-	return ptrOff;
-}
-
-#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) 2008-2013 NVIDIA Corporation. All rights reserved.

+

+// WARNING: before doing any changes to this file

+// check comments at the head of BinSerializer.cpp

+

+#include "PlatformOutputStream.h"

+#include <stdint.h>

+

+using namespace NvParameterized;

+

+#ifndef WITHOUT_APEX_SERIALIZATION

+

+Reloc::Reloc(RelocType type_, uint32_t ptrPos_, const PlatformOutputStream &parent)

+	: type(type_),

+	ptrPos(ptrPos_),

+	traits(parent.mTraits)

+{

+	ptrData = reinterpret_cast<PlatformOutputStream *>(traits->alloc(sizeof(PlatformOutputStream)));

+	PX_PLACEMENT_NEW(ptrData, PlatformOutputStream)(parent.mTargetParams, parent.mTraits, parent.dict);

+}

+

+Reloc::Reloc(const Reloc &cinfo): type(cinfo.type), ptrPos(cinfo.ptrPos), traits(cinfo.traits)

+{

+	Reloc &info = (Reloc &)cinfo;

+

+	//Take ownership of stream to avoid slow recursive copies (especially when reallocating array elements)

+	ptrData = info.ptrData;

+	info.ptrData = 0;

+}

+

+Reloc::~Reloc()

+{

+	if( ptrData )

+	{

+		ptrData->~PlatformOutputStream();

+		traits->free(ptrData);

+	}

+}

+

+PlatformOutputStream::PlatformOutputStream(const PlatformABI &targetParams, Traits *traits, Dictionary &dict_)

+	: PlatformStream(targetParams, traits),

+	data(traits),

+	mRelocs(Traits::Allocator(traits)),

+	mStrings(Traits::Allocator(traits)),

+	mMerges(Traits::Allocator(traits)),

+	dict(dict_),

+	mTotalAlign(1)

+{}

+

+PlatformOutputStream::PlatformOutputStream(const PlatformOutputStream &s)

+	: PlatformStream(s),

+	data(s.data),

+	mRelocs(Traits::Allocator(s.mTraits)),

+	mStrings(Traits::Allocator(s.mTraits)),

+	mMerges(Traits::Allocator(s.mTraits)),

+	dict(s.dict),

+	mTotalAlign(1)

+{

+	mRelocs.reserve(s.mRelocs.size());

+	for(uint32_t i = 0; i < s.mRelocs.size(); ++i)

+		mRelocs.pushBack(s.mRelocs[i]);

+

+	mStrings.reserve(s.mStrings.size());

+	for(uint32_t i = 0; i < s.mStrings.size(); ++i)

+		mStrings.pushBack(s.mStrings[i]);

+

+	mMerges.reserve(s.mMerges.size());

+	for(uint32_t i = 0; i < s.mMerges.size(); ++i)

+		mMerges.pushBack(s.mMerges[i]);

+}

+

+#ifndef NDEBUG

+void PlatformOutputStream::dump() const

+{

+	PlatformStream::dump();

+

+	dumpBytes(data, size());

+

+	fflush(stdout);

+	for(uint32_t i = 0; i < mRelocs.size(); ++i)

+	{

+		printf("Relocation %d at %x:\n", (int)i, mRelocs[i].ptrPos);

+		mRelocs[i].ptrData->dump();

+	}

+

+	fflush(stdout);

+}

+#endif

+

+void PlatformOutputStream::storeU32At(uint32_t x, uint32_t i)

+{

+	if( mCurParams.endian != mTargetParams.endian )

+		SwapBytes(reinterpret_cast<char *>(&x), 4U, TYPE_U32);

+

+	*reinterpret_cast<uint32_t *>(&data[i]) = x;

+}

+

+uint32_t PlatformOutputStream::storeString(const char *s)

+{

+	uint32_t off = storeSimple((uint8_t)*s);

+	while( *s++ )

+		storeSimple((uint8_t)*s);

+

+	return off;

+}

+

+uint32_t PlatformOutputStream::storeBytes(const char *s, uint32_t n)

+{

+	if( !n )

+		return size();

+

+	uint32_t off = storeSimple((uint8_t)s[0]);

+	for(uint32_t i = 1; i < n; ++i)

+		storeSimple((uint8_t)s[i]);

+

+	return off;

+}

+

+uint32_t PlatformOutputStream::beginStruct(uint32_t align_, uint32_t pad_)

+{

+	uint32_t off = size();

+	mStack.pushBack(Agregate(Agregate::STRUCT, pad_));

+	align(align_); // Align _after_ we push struct to avoid ignored align() when inside array

+	return off;

+}

+

+uint32_t PlatformOutputStream::beginStruct(uint32_t align_)

+{

+	return beginStruct(align_, align_);

+}

+

+uint32_t PlatformOutputStream::beginStruct(const Definition *pd)

+{

+	return beginStruct(getTargetAlignment(pd), getTargetPadding(pd));

+}

+

+void PlatformOutputStream::closeStruct()

+{

+	PX_ASSERT(mStack.size() > 0);

+

+	//Tail padding

+	align(mStack.back().align);// Align _before_ we pop struct to avoid ignored align() when inside array

+	mStack.popBack();

+}

+

+uint32_t PlatformOutputStream::beginString()

+{

+	return beginStruct(physx::PxMax(mTargetParams.aligns.pointer, mTargetParams.aligns.Bool));

+}

+

+void PlatformOutputStream::closeString()

+{

+	closeStruct();

+}

+

+uint32_t PlatformOutputStream::beginArray(const Definition *pd)

+{

+	return beginArray(getTargetAlignment(pd));

+}

+

+uint32_t PlatformOutputStream::beginArray(uint32_t align_)

+{

+	align(align_); // Align _before_ we push array because otherwise align() would be ignored

+	uint32_t off = size();

+	mStack.pushBack(Agregate(Agregate::ARRAY, align_));

+	return off;

+}

+

+void PlatformOutputStream::closeArray()

+{

+	// No tail padding when in array

+	mStack.popBack();

+}

+

+void PlatformOutputStream::skipBytes(uint32_t nbytes)

+{

+	data.skipBytes(nbytes);

+}

+

+void PlatformOutputStream::align(uint32_t border)

+{

+	bool isAligned;

+	uint32_t newSize = getAlign(size(), border, isAligned);

+

+	if( isAligned )

+		mTotalAlign = physx::PxMax(mTotalAlign, border);

+

+	data.skipBytes(newSize - size());

+}

+

+void PlatformOutputStream::mergeDict()

+{

+	for(uint32_t i = 0; i < dict.size(); ++i)

+	{

+		const char *s = dict.get(i);

+		uint32_t off = storeString(s);

+		dict.setOffset(s, off);

+	}

+}

+

+uint32_t PlatformOutputStream::storeNullPtr()

+{

+	//Do not align on uint32_t or uint64_t boundary (already aligned at pointer boundary)

+	align(mTargetParams.aligns.pointer);

+	uint32_t off = size();

+	if( 4 == mTargetParams.sizes.pointer )

+		data.skipBytes(4);

+	else

+	{

+		PX_ASSERT( 8 == mTargetParams.sizes.pointer );

+		data.skipBytes(8);

+	}

+	return off;

+}

+

+Reloc &PlatformOutputStream::storePtr(RelocType type, uint32_t align)

+{

+	uint32_t off = storeNullPtr();

+	mRelocs.pushBack(Reloc(type, off, *this));

+	mRelocs.back().ptrData->setAlignment(align);

+	return mRelocs.back();

+}

+

+Reloc &PlatformOutputStream::storePtr(RelocType type, const Definition *pd)

+{

+	return storePtr(type, getTargetAlignment(pd));

+}

+

+void PlatformOutputStream::storeStringPtr(const char *s)

+{

+	uint32_t off = storeNullPtr();

+	if( s )

+	{

+		mStrings.pushBack(StringReloc(off, s));

+		dict.put(s);

+	}

+}

+

+uint32_t PlatformOutputStream::storeSimpleStructArray(Handle &handle)

+{

+	int32_t n;

+	handle.getArraySize(n);

+

+	const NvParameterized::Definition *pdStruct = handle.parameterDefinition()->child(0);

+	int32_t nfields = pdStruct->numChildren();

+

+	uint32_t align_ = getTargetAlignment(pdStruct),

+		size_ = getTargetSize(pdStruct),

+		pad_ = getTargetPadding(pdStruct);

+

+	align(align_);

+	uint32_t off = size();

+

+	data.reserve(size() + n * physx::PxMax(align_, size_));

+

+	char *p = data;

+	p += data.size();

+

+	for(int32_t i = 0; i < n; ++i)

+	{

+		beginStruct(align_, pad_);

+		handle.set(i);

+

+		for(int32_t j = 0; j < nfields; ++j)

+		{

+			handle.set(j);

+

+			const Definition *pdField = pdStruct->child(j);

+

+			if( pdField->alignment() )

+				align( pdField->alignment() );

+

+			if( pdField->hint("DONOTSERIALIZE") )

+			{

+				//Simply skip bytes

+				align(getTargetAlignment(pdField));

+				skipBytes(getTargetSize(pdField));

+			}

+			else

+			{

+				//No need to align structs because of tail padding

+				switch( pdField->type() )

+				{

+#				define NV_PARAMETERIZED_TYPES_NO_LEGACY_TYPES

+#				define NV_PARAMETERIZED_TYPES_ONLY_SIMPLE_TYPES

+#				define NV_PARAMETERIZED_TYPES_NO_STRING_TYPES

+#				define NV_PARAMETERIZED_TYPE(type_name, enum_name, c_type) \

+					case TYPE_##enum_name: \

+					{ \

+						c_type val; \

+						handle.getParam##type_name(val); \

+						storeSimple<c_type>(val); \

+						break; \

+					}

+#					include "nvparameterized/NvParameterized_types.h"

+

+				case TYPE_MAT34:

+				{

+					float val[12];

+					handle.getParamMat34Legacy(val);

+					storeSimple(val, 12);

+					break;

+				}

+

+				NV_PARAMETRIZED_NO_MATH_DATATYPE_LABELS 

+				default:

+					DEBUG_ASSERT( 0 && "Unexpected type" );

+					return UINT32_MAX;

+				}

+			}

+

+			handle.popIndex();

+		} //j

+

+		handle.popIndex();

+		closeStruct();

+	} //i

+

+	return off;

+}

+

+uint32_t PlatformOutputStream::storeObjHeader(const NvParameterized::Interface &obj, bool isIncluded)

+{

+	uint32_t align_ = NvMax3(mTargetParams.aligns.Bool, mTargetParams.aligns.i32, mTargetParams.aligns.pointer);

+

+	uint32_t off = beginStruct(align_);

+

+	uint32_t hdrOff = data.size();

+	PX_ASSERT( hdrOff % sizeof(uint32_t) == 0 );

+

+	storeSimple(uint32_t(0)); //Data offset

+

+	//className

+	storeStringPtr(obj.className());

+

+	//name

+	storeStringPtr(obj.name());

+

+	//isIncluded

+	storeSimple(isIncluded);

+

+	//version

+	storeSimple<uint32_t>(obj.version());

+

+	//checksum size

+	uint32_t bits = (uint32_t)-1;

+	const uint32_t *checksum = obj.checksum(bits);

+	PX_ASSERT( bits % 32 == 0 ); //32 bits in uint32_t

+	uint32_t i32s = bits / 32;

+	storeSimple(i32s);

+

+	//checksum pointer

+	Reloc &reloc = storePtr(RELOC_ABS_RAW, mTargetParams.aligns.i32);

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

+		reloc.ptrData->storeSimple(checksum[i]);

+

+	closeStruct();

+

+	//We force alignment to calculate dataOffset

+	//(when object is inserted no additional padding will be inserted)

+

+	const Definition *pd = obj.rootParameterDefinition();

+	uint32_t customAlign = pd ? getTargetAlignment(pd) : 1;

+	align(physx::PxMax(16U, customAlign)); //16 for safety

+

+	storeU32At(data.size() - hdrOff, hdrOff); //Now we know object data offset

+

+	return off;

+}

+

+uint32_t PlatformOutputStream::beginObject(const NvParameterized::Interface &obj, bool /*isRoot*/, const Definition *pd)

+{

+	//NvParameterized objects is derived from NvParameters so we need to store its fields as well.

+

+	//WARN: this implementation _heavily_ depends on implementation of NvParameters

+

+	//Alignment of NvParameters

+	uint32_t parentAlign = physx::PxMax(mTargetParams.aligns.pointer, mTargetParams.aligns.Bool),

+		childAlign = pd ? getTargetAlignment(pd) : 1,

+		totalAlign = physx::PxMax(parentAlign, childAlign);

+

+	uint32_t off = beginStruct(totalAlign);

+

+	//NvParameters fields

+	for(uint32_t i = 0; i < 6; storeNullPtr(), ++i); //vtable and other fields

+	storeStringPtr(obj.name()); //mName

+	storeStringPtr(obj.className()); //mClassName

+	storeSimple(true); //mDoDeallocateSelf (all objects are responsible for memory deallocation)

+	storeSimple(false); //mDoDeallocateName

+	storeSimple(false); //mDoDeallocateClassName

+

+	//Some general theory of alignment handling

+	//Imagine that we have class:

+	//class A: A1, A2, ... An

+	//{

+	//	T1 f1;

+	//	T2 f2;

+	//};

+	//Then all Ai/fi are aligned on natural boundary. Whether or not padding bytes for Ai are inserted

+	//and whether or not Ai+1 or fi may reuse those bytes depends on compiler;

+	//we store this info in PlatformABI's doReusePadding flag.

+	//doReusePadding == false means that padding bytes are always there.

+	//doReusePadding == true means that padding bytes are _not_ inserted for non-POD Ai but are inserted for POD Ai.

+	//(I have yet to see compiler that does not insert padding bytes for POD base class!).

+

+	//Compilers may handle derived classes in two different ways.

+	//Say we have

+	//	class B {int x; char y; };

+	//	class A: public B {char z; };

+	//Then in pure C code this may look like either as

+	//	struct A { struct { int x; char y; } b; char z; };

+	//or as

+	//	struct A { int x; char y; char z; };

+	//(the latter is usual if B is not POD).

+	//Take care of that here (NvParameters is not POD!).

+	if( !mTargetParams.doReuseParentPadding )

+		align(parentAlign); //Insert tail padding for NvParameters

+

+	//ParametersStruct is aligned on natural boundary

+	align(childAlign);

+

+	return off;

+}

+

+uint32_t PlatformOutputStream::merge(const PlatformOutputStream &mergee)

+{

+	//All structs should be closed

+	PX_ASSERT( !mergee.mStack.size() );

+

+	align(mergee.alignment());

+

+	uint32_t base = data.size();

+

+	data.appendBytes(mergee.data, mergee.data.size());

+

+	//Update relocations

+

+	mRelocs.reserve(mRelocs.size() + mergee.mRelocs.size());

+	for(uint32_t i = 0; i < mergee.mRelocs.size(); ++i)

+	{

+		mRelocs.pushBack(mergee.mRelocs[i]);

+		mRelocs.back().ptrPos += base;

+	}

+

+	mStrings.reserve(mStrings.size() + mergee.mStrings.size());

+	for(uint32_t i = 0; i < mergee.mStrings.size(); ++i)

+	{

+		mStrings.pushBack(mergee.mStrings[i]);

+		mStrings.back().ptrPos += base;

+	}

+

+	mMerges.reserve(mMerges.size() + mergee.mMerges.size());

+	for(uint32_t i = 0; i < mergee.mMerges.size(); ++i)

+	{

+		mMerges.pushBack(mergee.mMerges[i]);

+

+		mMerges.back().ptrPos += base;

+		if( !mergee.mMerges[i].isExtern )

+			mMerges.back().targetPos += base;

+	}

+

+	return base;

+}

+

+void PlatformOutputStream::flatten()

+{

+	//It's very important that data for child objects is stored

+	//after current object to allow safe initialization

+

+	//Generic pointers

+	for(uint32_t i = 0; i < mRelocs.size(); ++i)

+	{

+		Reloc &reloc = mRelocs[i];

+

+		//Recursively add data which is pointed-to

+

+		align( reloc.ptrData->alignment() );

+

+		MergedReloc m = { reloc.ptrPos, data.size(), reloc.type, false };

+		mMerges.pushBack(m);

+

+		merge(*reloc.ptrData); //Internal pointers are recursively added here

+	}

+

+	//String pointers

+	for(uint32_t i = 0; i < mStrings.size(); ++i)

+	{

+		//String pointers are external and absolute

+		MergedReloc m = { mStrings[i].ptrPos, dict.getOffset(mStrings[i].s), RELOC_ABS_RAW, true };

+		mMerges.pushBack(m);

+	}

+

+	mRelocs.clear();

+	mStrings.clear();

+}

+

+uint32_t PlatformOutputStream::writeRelocs()

+{

+	uint32_t ptrOff = storeSimple<uint32_t>(mMerges.size()); //Offset of relocation table

+

+	data.reserve(mMerges.size() * 2 * physx::PxMax(4U, mTargetParams.aligns.i32));

+

+	for(uint32_t i = 0; i < mMerges.size(); ++i)

+	{

+		char *ptr = &data[mMerges[i].ptrPos];

+		if( 4 == mTargetParams.sizes.pointer )

+		{

+			uint32_t *ptrAsInt = reinterpret_cast<uint32_t *>(ptr);

+			*ptrAsInt = mMerges[i].targetPos;

+			if( mTargetParams.endian != mCurParams.endian )

+				SwapBytes(ptr, 4U, TYPE_U32);

+		}

+		else

+		{

+			PX_ASSERT(8 == mTargetParams.sizes.pointer);

+

+			uint64_t *ptrAsInt = reinterpret_cast<uint64_t *>(ptr);

+			*ptrAsInt = mMerges[i].targetPos;

+			if( mTargetParams.endian != mCurParams.endian )

+				SwapBytes(ptr, 8U, TYPE_U64);

+		}

+

+		//BinaryReloc struct

+		beginStruct(mTargetParams.aligns.i32);

+		storeSimple<uint32_t>(static_cast<uint32_t>(mMerges[i].type));

+		storeSimple<uint32_t>(mMerges[i].ptrPos);

+		closeStruct();

+	}

+

+	mMerges.clear();

+

+	return ptrOff;

+}

+

+#endif

diff --git a/sdk/extensions/import/apexmodules/NvParameterized/src/SerializerCommon.cpp b/sdk/extensions/import/apexmodules/NvParameterized/src/SerializerCommon.cpp
index b00a80f..bc65fb4 100644..100755
--- a/sdk/extensions/import/apexmodules/NvParameterized/src/SerializerCommon.cpp
+++ b/sdk/extensions/import/apexmodules/NvParameterized/src/SerializerCommon.cpp
@@ -1,234 +1,234 @@
-// 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) 2008-2013 NVIDIA Corporation. All rights reserved.
-
-#include "PxSimpleTypes.h"
-#include "SerializerCommon.h"
-#include "NvTraitsInternal.h"
-
-namespace NvParameterized
-{
-
-#define CHECK(x) NV_BOOL_ERR_CHECK_RETURN(x, 0)
-
-bool UpgradeLegacyObjects(Serializer::DeserializedData &data, bool &isUpdated, Traits *t)
-{
-	isUpdated = false;
-
-	for(uint32_t i = 0; i < data.size(); ++i)
-	{
-		Interface *obj = data[i];
-		if( !obj )
-			continue;
-
-		Interface *newObj = UpgradeObject(*obj, isUpdated, t);
-		if( !newObj )
-		{
-			NV_PARAM_TRAITS_WARNING(
-				t,
-				"Failed to upgrade object of class %s and version %u",
-				obj->className(),
-				(unsigned)obj->version());
-
-			DEBUG_ALWAYS_ASSERT();
-
-			for(uint32_t j = 0; j < data.size(); ++j)
-				data[i]->destroy();
-
-			data.init(0, 0);
-
-			return false;
-		}
-
-		if( newObj != obj )
-		{
-			// Need to retain the name of the old object into the new object
-			const char *name = obj->name();
-			newObj->setName(name);
-			obj->destroy();
-			data[i] = newObj;
-		}
-	}
-
-	return true;
-}
-
-bool UpgradeIncludedRefs(Handle &h, bool &isUpdated, Traits *t)
-{
-	const Definition *pd = h.parameterDefinition();
-
-	switch( pd->type() )
-	{
-	case TYPE_ARRAY:
-		{
-			if( pd->child(0)->isSimpleType() )
-				break;
-
-			int32_t size;
-			CHECK( NvParameterized::ERROR_NONE == h.getArraySize(size) );
-
-			for(int32_t i = 0; i < size; ++i)
-			{
-				h.set(i);
-				CHECK( UpgradeIncludedRefs(h, isUpdated, t) );
-				h.popIndex();
-			}
-
-			break;
-		}
-
-	case TYPE_STRUCT:
-		{
-			if( pd->isSimpleType() )
-				break;
-
-			for(int32_t i = 0; i < pd->numChildren(); ++i)
-			{
-				h.set(i);
-				CHECK( UpgradeIncludedRefs(h, isUpdated, t) );
-				h.popIndex();
-			}
-
-			break;
-		}
-
-	case TYPE_REF:
-		{
-			if( !pd->isIncludedRef() )
-				break;
-
-			Interface *refObj = 0;
-			h.getParamRef(refObj);
-
-			if( !refObj ) // No reference there?
-				break;
-
-			Interface *newRefObj = UpgradeObject(*refObj, isUpdated, t);
-			CHECK( newRefObj );
-
-			if( newRefObj == refObj ) // No update?
-				break;
-
-			refObj->destroy();
-
-			if( NvParameterized::ERROR_NONE != h.setParamRef(newRefObj) )
-			{
-				DEBUG_ALWAYS_ASSERT();
-				newRefObj->destroy();
-				return false;
-			}
-
-			break;
-		}
-	NV_PARAMETRIZED_NO_AGGREGATE_AND_REF_DATATYPE_LABELS 
-	default:
-		{
-			break;
-		}
-
-	}
-
-	return true;
-}
-
-bool UpgradeIncludedRefs(Interface &obj, bool &isUpdated, Traits *t)
-{
-	Handle h(obj, "");
-	CHECK( h.isValid() );
-
-	return UpgradeIncludedRefs(h, isUpdated, t);
-}
-
-Interface *UpgradeObject(Interface &obj, bool &isUpdated, Traits *t)
-{
-	const char *className = obj.className();
-
-	Interface *newObj = &obj;
-
-	if( obj.version() != t->getCurrentVersion(className) )
-	{
-		isUpdated = true;
-
-		newObj = t->createNvParameterized(className);
-
-		if( !newObj )
-		{
-			NV_PARAM_TRAITS_WARNING(t, "Failed to create object of class %s", className);
-			DEBUG_ALWAYS_ASSERT();
-			return 0;
-		}
-
-		if( !t->updateLegacyNvParameterized(obj, *newObj) )
-		{
-			NV_PARAM_TRAITS_WARNING(t, "Failed to upgrade object of class %s and version %u",
-				className,
-				(unsigned)obj.version() );
-			newObj->destroy();
-			return 0;
-		}
-	}
-
-	if( !UpgradeIncludedRefs(*newObj, isUpdated, t) )
-	{
-		newObj->destroy();
-		return 0;
-	}
-
-	return newObj;
-}
-
-void *serializerMemAlloc(uint32_t size, Traits *t)
-{
-	if( t )
-		return t->alloc(size);
-	else
-	{
-		DEBUG_ALWAYS_ASSERT(); // indicates a memory leak
-		return ::malloc(size);
-	}
-}
-
-void serializerMemFree(void *data, Traits *t)
-{
-	if( t )
-		t->free(data);
-	else
-	{
-		DEBUG_ALWAYS_ASSERT();
-		::free(data);
-	}
-}
-
-bool DoIgnoreChecksum(const NvParameterized::Interface &obj)
-{
-	// Most of our classes initially do not have classVersion field.
-	// When it is finally added (e.g. after adding new version)
-	// schema checksum changes and we get invalid "checksum not equal" warnings;
-	// because of that we ignore checksum differences for all 0.0 classes.
-	return 0 == obj.version();
-}
-
-} // namespace NvParameterized
+// 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) 2008-2013 NVIDIA Corporation. All rights reserved.

+

+#include "PxSimpleTypes.h"

+#include "SerializerCommon.h"

+#include "NvTraitsInternal.h"

+

+namespace NvParameterized

+{

+

+#define CHECK(x) NV_BOOL_ERR_CHECK_RETURN(x, 0)

+

+bool UpgradeLegacyObjects(Serializer::DeserializedData &data, bool &isUpdated, Traits *t)

+{

+	isUpdated = false;

+

+	for(uint32_t i = 0; i < data.size(); ++i)

+	{

+		Interface *obj = data[i];

+		if( !obj )

+			continue;

+

+		Interface *newObj = UpgradeObject(*obj, isUpdated, t);

+		if( !newObj )

+		{

+			NV_PARAM_TRAITS_WARNING(

+				t,

+				"Failed to upgrade object of class %s and version %u",

+				obj->className(),

+				(unsigned)obj->version());

+

+			DEBUG_ALWAYS_ASSERT();

+

+			for(uint32_t j = 0; j < data.size(); ++j)

+				data[i]->destroy();

+

+			data.init(0, 0);

+

+			return false;

+		}

+

+		if( newObj != obj )

+		{

+			// Need to retain the name of the old object into the new object

+			const char *name = obj->name();

+			newObj->setName(name);

+			obj->destroy();

+			data[i] = newObj;

+		}

+	}

+

+	return true;

+}

+

+bool UpgradeIncludedRefs(Handle &h, bool &isUpdated, Traits *t)

+{

+	const Definition *pd = h.parameterDefinition();

+

+	switch( pd->type() )

+	{

+	case TYPE_ARRAY:

+		{

+			if( pd->child(0)->isSimpleType() )

+				break;

+

+			int32_t size;

+			CHECK( NvParameterized::ERROR_NONE == h.getArraySize(size) );

+

+			for(int32_t i = 0; i < size; ++i)

+			{

+				h.set(i);

+				CHECK( UpgradeIncludedRefs(h, isUpdated, t) );

+				h.popIndex();

+			}

+

+			break;

+		}

+

+	case TYPE_STRUCT:

+		{

+			if( pd->isSimpleType() )

+				break;

+

+			for(int32_t i = 0; i < pd->numChildren(); ++i)

+			{

+				h.set(i);

+				CHECK( UpgradeIncludedRefs(h, isUpdated, t) );

+				h.popIndex();

+			}

+

+			break;

+		}

+

+	case TYPE_REF:

+		{

+			if( !pd->isIncludedRef() )

+				break;

+

+			Interface *refObj = 0;

+			h.getParamRef(refObj);

+

+			if( !refObj ) // No reference there?

+				break;

+

+			Interface *newRefObj = UpgradeObject(*refObj, isUpdated, t);

+			CHECK( newRefObj );

+

+			if( newRefObj == refObj ) // No update?

+				break;

+

+			refObj->destroy();

+

+			if( NvParameterized::ERROR_NONE != h.setParamRef(newRefObj) )

+			{

+				DEBUG_ALWAYS_ASSERT();

+				newRefObj->destroy();

+				return false;

+			}

+

+			break;

+		}

+	NV_PARAMETRIZED_NO_AGGREGATE_AND_REF_DATATYPE_LABELS 

+	default:

+		{

+			break;

+		}

+

+	}

+

+	return true;

+}

+

+bool UpgradeIncludedRefs(Interface &obj, bool &isUpdated, Traits *t)

+{

+	Handle h(obj, "");

+	CHECK( h.isValid() );

+

+	return UpgradeIncludedRefs(h, isUpdated, t);

+}

+

+Interface *UpgradeObject(Interface &obj, bool &isUpdated, Traits *t)

+{

+	const char *className = obj.className();

+

+	Interface *newObj = &obj;

+

+	if( obj.version() != t->getCurrentVersion(className) )

+	{

+		isUpdated = true;

+

+		newObj = t->createNvParameterized(className);

+

+		if( !newObj )

+		{

+			NV_PARAM_TRAITS_WARNING(t, "Failed to create object of class %s", className);

+			DEBUG_ALWAYS_ASSERT();

+			return 0;

+		}

+

+		if( !t->updateLegacyNvParameterized(obj, *newObj) )

+		{

+			NV_PARAM_TRAITS_WARNING(t, "Failed to upgrade object of class %s and version %u",

+				className,

+				(unsigned)obj.version() );

+			newObj->destroy();

+			return 0;

+		}

+	}

+

+	if( !UpgradeIncludedRefs(*newObj, isUpdated, t) )

+	{

+		newObj->destroy();

+		return 0;

+	}

+

+	return newObj;

+}

+

+void *serializerMemAlloc(uint32_t size, Traits *t)

+{

+	if( t )

+		return t->alloc(size);

+	else

+	{

+		DEBUG_ALWAYS_ASSERT(); // indicates a memory leak

+		return ::malloc(size);

+	}

+}

+

+void serializerMemFree(void *data, Traits *t)

+{

+	if( t )

+		t->free(data);

+	else

+	{

+		DEBUG_ALWAYS_ASSERT();

+		::free(data);

+	}

+}

+

+bool DoIgnoreChecksum(const NvParameterized::Interface &obj)

+{

+	// Most of our classes initially do not have classVersion field.

+	// When it is finally added (e.g. after adding new version)

+	// schema checksum changes and we get invalid "checksum not equal" warnings;

+	// because of that we ignore checksum differences for all 0.0 classes.

+	return 0 == obj.version();

+}

+

+} // namespace NvParameterized

diff --git a/sdk/extensions/import/apexmodules/NvParameterized/src/XmlDeserializer.cpp b/sdk/extensions/import/apexmodules/NvParameterized/src/XmlDeserializer.cpp
index 69253e6..cf1eaad 100644..100755
--- a/sdk/extensions/import/apexmodules/NvParameterized/src/XmlDeserializer.cpp
+++ b/sdk/extensions/import/apexmodules/NvParameterized/src/XmlDeserializer.cpp
@@ -1,759 +1,759 @@
-// 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) 2008-2013 NVIDIA Corporation. All rights reserved.
-
-#include "PxSimpleTypes.h"
-#include "NvParameters.h"
-#include "nvparameterized/NvParameterizedTraits.h"
-
-#include "NvTraitsInternal.h"
-
-#include "XmlDeserializer.h"
-
-#define XML_WARNING(_format, ...) \
-	NV_PARAM_TRAITS_WARNING(mTraits, "XML serializer: " _format, ##__VA_ARGS__)
-
-
-
-namespace NvParameterized
-{
-
-/*!
-Get number of elements in array
-*/
-template <typename T, size_t N>
-char (&ArraySizeHelper(T (&array)[N]))[N];
-#define PX_ARRAY_SIZE(_array) (sizeof(ArraySizeHelper(_array)))
-
-	static uint32_t ReadVersion(const physx::shdfnd::FastXml::AttributePairs& attr)
-	{
-		const char *versionText = attr.get("version");
-
-		// If there's no version, assume version is 0.0
-		if( !versionText )
-			return 0;
-
-		//XML stores versions in "x.y"-format
-		//FIXME: strtoul is unsafe
-
-		const char *dot = strchr(versionText, '.');
-		uint32_t minor = dot ? strtoul(dot + 1, 0, 10) : 0;
-
-		uint32_t major = strtoul(versionText, 0, 10);
-
-		return (major << 16) + minor;
-	}
-
-	static PX_INLINE bool isWhiteSpace(char c)
-	{
-		return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == ',';
-	}
-
-	static PX_INLINE const char * skipWhiteSpace(const char *scan)
-	{
-		while ( isWhiteSpace(*scan) && *scan ) scan++;
-		return *scan ? scan : 0;
-	}
-
-	static PX_FORCE_INLINE const char * skipNonWhiteSpace(const char* scan)
-	{
-		while ( !isWhiteSpace(*scan) && *scan ) scan++;
-		return *scan ? scan : 0;
-	}
-
-	bool XmlDeserializer::verifyObject(Interface *obj, const physx::shdfnd::FastXml::AttributePairs& attr)
-	{
-		if( ReadVersion(attr) != obj->version() )
-		{
-			XML_WARNING("unknown error");
-			DEBUG_ALWAYS_ASSERT();
-			mError = Serializer::ERROR_UNKNOWN;
-			return false;
-		}
-
-		char *checksum = (char *)attr.get("checksum");
-		if( checksum && !DoIgnoreChecksum(*obj) )
-		{
-			uint32_t objBits;
-			const uint32_t *objChecksum = obj->checksum(objBits);
-
-			uint32_t bits = 0;
-
-			char *cur = checksum, *next = 0;
-			bool sameBits = true;
-			for(uint32_t i = 0; ; ++i, cur = next)
-			{
-				uint32_t val = (uint32_t)strtoul(cur, &next, 0); //FIXME: strtoul is not safe
-				if( cur == next )
-					break;
-
-				bits += 32;
-				if( bits > objBits || val != objChecksum[i] )
-				{
-					NV_PARAM_TRAITS_WARNING(
-						mTraits,
-						"Schema checksum is different for object of class %s and version %u, "
-							"asset may be corrupted",
-						obj->className(),
-						(unsigned)obj->version()
-						);
-					sameBits = false;
-					break;
-				}
-			}
-
-			if( objBits != bits && sameBits )
-			{
-				NV_PARAM_TRAITS_WARNING(
-					mTraits,
-					"Schema checksum is different for object of class %s and version %u, "
-						"asset may be corrupted",
-					obj->className(),
-					(unsigned)obj->version()
-					);
-			}
-		} //if( checksum )
-
-		return true;
-	}
-
-	bool XmlDeserializer::initAddressString(char *dest, uint32_t len, const char *name)
-	{
-		char *end = dest + len;
-
-		for (uint32_t i = 0; i < tos().getIndex(); i++)
-		{
-			FieldInfo &field = tos().getFieldInfo(i);
-
-			const char *n = field.name;
-			FieldType type = field.type;
-
-			if( SKIP == type )
-				continue;
-
-			while ( n && *n && dest < end )
-				*dest++ = *n++;
-
-			if ( ARRAY == type )
-			{
-				char temp[512];
-				physx::shdfnd::snprintf(temp, 512, "[%d]", field.idx);
-
-				if( dest + ::strlen(temp) >= end )
-				{
-					XML_WARNING("buffer overflow");
-					DEBUG_ALWAYS_ASSERT();
-					mError = Serializer::ERROR_INTERNAL_BUFFER_OVERFLOW;
-					return false;
-				}
-
-				const char *scan = temp;
-				while ( *scan && dest < end )
-				{
-					*dest++ = *scan++;
-				}
-			}
-			else
-			{
-				if( dest + 1 >= end )
-				{
-					XML_WARNING("buffer overflow");
-					DEBUG_ALWAYS_ASSERT();
-					mError = Serializer::ERROR_INTERNAL_BUFFER_OVERFLOW;
-					return false;
-				}
-
-				*dest++ = '.';
-			}
-		}
-
-		while ( name && *name && dest < end )
-		{
-			*dest++ = *name++;
-		}
-
-		*dest = 0;
-		//printf("Fully qualified name: %s\n", scratch );
-
-		return true;
-	}
-
-	bool XmlDeserializer::processClose(const char *tag,uint32_t depth,bool &isError)
-	{
-		isError = true; //By default if we return with false it's due to error
-
-		if( strcmp(tag, "NxParameters") == 0 ||
-			strcmp(tag, "NvParameters") == 0)
-		{
-			mInRootElement = false;
-
-			// in xml there's only 1 root element allowed,
-			// so we want to stop after the first NvParameters
-			isError = false;
-			return false;
-		}
-
-		static const char *validTags[] = {
-			"struct",
-			"value",
-			"array"
-		};
-
-		for(uint32_t i = 0; i < PX_ARRAY_SIZE(validTags); ++i)
-		{
-			if( 0 != ::strcmp(validTags[i], tag) )
-				continue;
-
-#	ifndef NDEBUG
-			uint32_t idx = tos().getIndex();
-			DEBUG_ASSERT( idx > 0 );
-
-			static FieldType validTypes[] = {
-				STRUCT,
-				VALUE,
-				ARRAY
-			};
-
-			// Make gcc happy
-			const FieldType* tmp = &validTypes[0];
-			PX_UNUSED(tmp);
-
-			FieldType type = tos().getFieldInfo(idx - 1).type;
-			PX_UNUSED(type);
-			DEBUG_ASSERT( type == SKIP || type == validTypes[i] );
-#	endif
-
-			if( !popField() )
-				return false;
-
-			if (depth == 1 && mRootIndex > MAX_ROOT_OBJ)
-			{
-				DEBUG_ASSERT(i == 1);
-				mObjects[0].getObject()->destroy();
-			}
-
-			return tos().getIndex() ? depth != 0 : popObj();
-		}
-
-		return false;
-	}
-
-	bool XmlDeserializer::processElement(
-		const char *elementName,
-		const char *elementData,
-		const physx::shdfnd::FastXml::AttributePairs& attr,
-		int32_t /*lineno*/)
-	{
-		//Force DOCTYPE
-		if( !mHasDoctype )
-		{
-			XML_WARNING("DOCTYPE is missing");
-			DEBUG_ALWAYS_ASSERT();
-			mError = Serializer::ERROR_MISSING_DOCTYPE;
-			return false;
-		}
-
-		if( strcmp(elementName, "NxParameters")  == 0 ||
-			strcmp(elementName, "NvParameters")  == 0)
-		{
-			if( mObjIndex )
-			{
-				XML_WARNING("NvParameters must be root element");
-				DEBUG_ALWAYS_ASSERT();
-				mError = Serializer::ERROR_MISSING_ROOT_ELEMENT;
-				return false;
-			}
-
-			if( mInRootElement )
-			{
-				XML_WARNING("More than one root element encountered");
-				DEBUG_ALWAYS_ASSERT();
-				mError = Serializer::ERROR_INVALID_NESTING;
-				return false;
-			}
-
-			uint32_t ver = ReadVersion(attr);
-			if( ver != mVer )
-			{
-				XML_WARNING("unknown version of APX file format: %u", (unsigned)ver);
-				DEBUG_ALWAYS_ASSERT();
-				mError = Serializer::ERROR_INVALID_FILE_VERSION;
-				return false;
-			}
-
-			const char* numObjects = attr.get("numObjects");
-			if (numObjects != NULL)
-			{
-				PX_ASSERT(atoi(numObjects) >= 0);
-				const uint32_t num = static_cast<uint32_t>(atoi(numObjects));
-				if (num > MAX_ROOT_OBJ)
-				{
-					XML_WARNING("APX file has more than %d root objects, only %d will be read", num, MAX_ROOT_OBJ);
-				}
-			}
-
-
-			++mRootTags;
-			mInRootElement = true;
-
-			return true;
-		}
-
-		if( mRootTags > 0 && !mInRootElement )
-		{
-			XML_WARNING("element %s not under root element", elementName);
-			DEBUG_ALWAYS_ASSERT();
-			mError = Serializer::ERROR_MISSING_ROOT_ELEMENT;
-			return false;
-		}
-
-		if ( strcmp(elementName, "struct") == 0 )
-		{
-			const char *name = attr.get("name");
-
-			if( !mObjIndex )
-			{
-				XML_WARNING("struct-element %s not under value-element", name);
-				DEBUG_ALWAYS_ASSERT();
-				mError = Serializer::ERROR_INVALID_NESTING;
-				return false;
-			}
-
-			pushField(name, STRUCT);
-		}
-		else if ( strcmp(elementName, "value") == 0 )
-		{
-			if( !mObjIndex ) //Root object?
-			{
-				const char *className = attr.get("className");
-
-				uint32_t version = ReadVersion(attr);
-
-				Interface *obj = mTraits->createNvParameterized(className, version);
-				if( !obj )
-				{
-					XML_WARNING("failed to create object of type %s and version %u", className, (unsigned)version);
-					DEBUG_ALWAYS_ASSERT();
-					mError = Serializer::ERROR_OBJECT_CREATION_FAILED;
-					return false;
-				}
-
-				const char *objectName = attr.get("objectName");
-				if( objectName )
-					obj->setName(objectName);
-
-				if (mRootIndex < MAX_ROOT_OBJ)
-				{
-					mRootObjs[mRootIndex] = obj;
-				}
-				mRootIndex++;
-
-				pushObj(obj);
-				pushField("", SKIP); //Root <value> should not be used in initAddressString
-
-				return true;
-			}
-
-			const char *name = attr.get("name");
-
-			char scratch[2048];
-			if( !initAddressString(scratch, sizeof(scratch), name) )
-			{
-				return false;
-			}
-
-			pushField(name, VALUE);
-
-			Interface *obj = tos().getObject();
-			if( !obj )
-			{
-				XML_WARNING("unknown error");
-				DEBUG_ALWAYS_ASSERT();
-				mError = Serializer::ERROR_UNKNOWN;
-				return false;
-			}
-
-			Handle handle(*obj, scratch);
-			if( !handle.isValid() )
-			{
-				XML_WARNING("%s: invalid path", scratch);
-				DEBUG_ALWAYS_ASSERT();
-//				mError = Serializer::ERROR_INVALID_PARAM_HANDLE;
-				return true;
-			}
-
-			const char *type = attr.get("type");
-			const char *expectedType = typeToStr(handle.parameterDefinition()->type());
-			if ( type && 0 != physx::shdfnd::stricmp(type, expectedType) )
-			{
-				XML_WARNING("%s: invalid type %s (expected %s)", scratch, type, expectedType);
-				DEBUG_ALWAYS_ASSERT();
-				mError = Serializer::ERROR_INVALID_ATTR;
-				return false;
-			}
-
-			const char *included = attr.get("included");
-			if ( included )
-			{
-				bool isIncludedRef = 0 != atoi(included);
-				if( isIncludedRef != handle.parameterDefinition()->isIncludedRef() )
-				{
-					XML_WARNING("%s: unexpected included-attribute", scratch);
-					DEBUG_ALWAYS_ASSERT();
-					mError = Serializer::ERROR_INVALID_ATTR;
-					return false;
-				}
-
-				const char *className = attr.get("className");
-				if( !className )
-				{
-					if( attr.get("classNames") )
-					{
-						// Ref is NULL
-
-						Interface *oldObj = 0;
-						if( NvParameterized::ERROR_NONE != handle.getParamRef(oldObj) )
-							return false;
-						if( oldObj )
-							oldObj->destroy();
-
-						handle.setParamRef(0);
-
-						return true;
-					}
-					else
-					{
-						XML_WARNING("%s: missing both className and classNames attribute", scratch);
-						DEBUG_ALWAYS_ASSERT();
-						mError = Serializer::ERROR_INVALID_ATTR;
-						return false;
-					}
-				}
-
-				uint32_t version = ReadVersion(attr);
-
-				Interface *refObj = 0;
-				if( isIncludedRef )
-					refObj = mTraits->createNvParameterized(className, version);
-				else
-				{
-					void *buf = mTraits->alloc(sizeof(NvParameters));
-					refObj = PX_PLACEMENT_NEW(buf, NvParameters)(mTraits);
-
-					refObj->setClassName(className);
-				}
-
-				if( !refObj )
-				{
-					XML_WARNING("%s: failed to create object of type %s and version %u", scratch, className, (unsigned)version);
-					DEBUG_ALWAYS_ASSERT();
-					mError = Serializer::ERROR_OBJECT_CREATION_FAILED;
-					return false;
-				}
-
-				if( refObj && (-1 == handle.parameterDefinition()->refVariantValIndex(refObj->className())) )
-				{
-					char longName[256];
-					handle.getLongName(longName, sizeof(longName));
-					NV_PARAM_TRAITS_WARNING(
-						mTraits,
-						"%s: setting reference of invalid class %s",
-						longName,
-						refObj->className()
-						);
-				}
-
-				if( NvParameterized::ERROR_NONE != handle.setParamRef(refObj) )
-				{
-					XML_WARNING("%s: failed to set reference of type %s", scratch, className);
-					DEBUG_ALWAYS_ASSERT();
-					mError = Serializer::ERROR_INVALID_REFERENCE;
-					return false;
-				}
-
-				const char *objectName = attr.get("objectName");
-				if( objectName && refObj )
-					refObj->setName(objectName);
-
-				if( isIncludedRef )
-					pushObj(refObj);
-				else if ( elementData && refObj )
-					refObj->setName(elementData);
-			}
-			else
-			{
-				if ( elementData == 0 )
-					elementData = "";
-
-				const char *isNull = attr.get("null");
-				if( isNull && 0 != atoi(isNull) )
-				{
-					//Only strings and enums may be NULL so it's safe to call setParamString
-
-					DataType t = handle.parameterDefinition()->type();
-					PX_UNUSED(t);
-					DEBUG_ASSERT( TYPE_STRING == t || TYPE_ENUM == t );
-
-					handle.setParamString(0);
-				}
-				else
-				{
-					if( NvParameterized::ERROR_NONE != handle.strToValue(elementData, 0) )
-					{
-						XML_WARNING("%s: failed to convert string to value: %10s", scratch, elementData);
-						DEBUG_ALWAYS_ASSERT();
-						mError = Serializer::ERROR_STRING2VAL_FAILED;
-						return false;
-					}
-				}
-			} //if ( included )
-		}
-		else if ( strcmp(elementName, "array") == 0 )
-		{
-			const char *name = attr.get("name");
-
-			if( !mObjIndex )
-			{
-				XML_WARNING("array-element %s not under value-element", name);
-				DEBUG_ALWAYS_ASSERT();
-				mError = Serializer::ERROR_INVALID_NESTING;
-				return false;
-			}
-
-			int32_t arraySize = 0;
-			if ( const char *sz = attr.get("size") )
-			{
-				PX_ASSERT(atoi(sz) >= 0);
-				arraySize = (int32_t)atoi(sz);
-			}
-
-			if ( arraySize > 0 )
-			{
-				Interface *obj = tos().getObject();
-				if( !obj )
-				{
-					XML_WARNING("unknown error");
-					DEBUG_ALWAYS_ASSERT();
-					mError = Serializer::ERROR_UNKNOWN;
-					return false;
-				}
-
-				char scratch[2048];
-				if( !initAddressString(scratch, sizeof(scratch), name) )
-				{
-					return false;
-				}
-
-				Handle handle(*obj, scratch);
-				if( !handle.isValid() )
-				{
-
-					mError = Serializer::ERROR_INVALID_PARAM_HANDLE;
-					XML_WARNING("%s: invalid path", scratch);
-					DEBUG_ALWAYS_ASSERT();
-
-					return false;
-				}
-
-				if( !handle.parameterDefinition()->arraySizeIsFixed() )
-					if( NvParameterized::ERROR_NONE != handle.resizeArray(arraySize) )
-					{
-						XML_WARNING("%s: failed to resize array", scratch);
-						DEBUG_ALWAYS_ASSERT();
-						mError = Serializer::ERROR_INVALID_ARRAY;
-						return false;
-					}
-					if ( elementData )
-					{
-						const char *scan = elementData;
-
-						handle.set(0);
-						const Definition *paramDef = handle.parameterDefinition();
-						handle.popIndex();
-
-
-						if ( paramDef->type() == TYPE_STRUCT )
-						{
-							// read the structElements field
-							const char* structElements = attr.get("structElements");
-
-							int32_t* simpleStructRedirect = getSimpleStructRedirect(static_cast<uint32_t>(paramDef->numChildren()));
-							uint32_t numRedirects = 0;
-							while (structElements && *structElements)
-							{
-								char fieldName[64];
-								char type[16];
-
-								size_t count = 0;
-								while(*structElements != 0 && *structElements != ',' && *structElements != '(')
-									fieldName[count++] = *structElements++;
-								if( count >= sizeof(fieldName) )
-								{
-									DEBUG_ALWAYS_ASSERT();
-									mError = Serializer::ERROR_INTERNAL_BUFFER_OVERFLOW;
-									return false;
-								}
-								fieldName[count] = 0;
-
-								if (*structElements == '(')
-								{
-									structElements++;
-									count = 0;
-									while(*structElements != 0 && *structElements != ',' && *structElements != ')')
-										type[count++] = *structElements++;
-									if( count >= sizeof(type) )
-									{
-										DEBUG_ALWAYS_ASSERT();
-										mError = Serializer::ERROR_INTERNAL_BUFFER_OVERFLOW;
-										return false;
-									}
-									type[count] = 0;
-
-								}
-								if (*structElements == ')')
-									structElements++;
-								if (*structElements == ',')
-									structElements++;
-
-								const Definition* childDef = paramDef->child(fieldName, simpleStructRedirect[numRedirects]);
-								const char* trueType = childDef ? typeToStr(childDef->type()) : 0;
-								if (childDef && ::strcmp(trueType, type) != 0)
-								{
-									XML_WARNING(
-										"%s[].%s: unexpected type: %s (must be %s)",
-										scratch, fieldName, type, trueType ? trueType : "");
-									DEBUG_ALWAYS_ASSERT();
-									mError = Serializer::ERROR_INVALID_DATA_TYPE;
-									return false;
-								}
-
-								// -2 means to reed the data but not storing it
-								// -1 means to not read the data as it was not serialized'
-								// i = [0 .. n] means to read the data and store it in child i
-								if (childDef == NULL)
-								{
-									simpleStructRedirect[numRedirects] = -2;
-
-									// Fail fast
-									XML_WARNING("%s[]: unexpected structure field: %s", scratch, fieldName);
-									DEBUG_ALWAYS_ASSERT();
-									mError = Serializer::ERROR_INVALID_PARAM_HANDLE;
-									return false;
-								}
-
-								numRedirects++;
-							}
-
-							const int32_t numChildren = paramDef->numChildren();
-							for(int32_t i = 0; i < arraySize; ++i)
-							{
-								handle.set(i);
-								for( int32_t j=0; j<numChildren; j++ )
-								{
-									if (simpleStructRedirect[j] < 0)
-									{
-										if (simpleStructRedirect[j] < -1)
-										{
-											// read the data anyways
-											scan = skipWhiteSpace(scan);
-											if (scan != NULL)
-												scan = skipNonWhiteSpace(scan);
-										}
-										continue;
-									}
-
-									scan = skipWhiteSpace(scan);
-									if ( !scan ) break;
-
-									handle.set(simpleStructRedirect[j]);
-
-									if( NvParameterized::ERROR_NONE != handle.strToValue(scan, &scan) )
-									{
-										XML_WARNING("%s: failed to convert string to value: %10s...", scan);
-										DEBUG_ALWAYS_ASSERT();
-										mError = Serializer::ERROR_STRING2VAL_FAILED;
-										return false;
-									}
-
-									handle.popIndex();
-									if ( !scan ) break;
-								}
-								handle.popIndex();
-								if ( !scan ) break;
-							}
-						}
-						else
-						{
-							// LRR: wall clock time is the same for this simple loop as the previous
-							//      "unrolled" version
-							for (int32_t i = 0; i<arraySize; i++)
-							{
-								handle.set(i);
-								if( NvParameterized::ERROR_NONE != handle.strToValue(scan, &scan) )
-								{
-									XML_WARNING("%s: failed to convert string to value: %10s", scratch, scan);
-									DEBUG_ALWAYS_ASSERT();
-									mError = Serializer::ERROR_STRING2VAL_FAILED;
-									return false;
-								}
-								handle.popIndex();
-							}
-						}
-					} //if( elementData )
-			} //if ( arraySize > 0 )
-
-			pushField(name, ARRAY);
-		}
-		else
-		{
-			XML_WARNING("unknown element %s", elementName);
-			DEBUG_ALWAYS_ASSERT();
-			mError = Serializer::ERROR_UNKNOWN_XML_TAG;
-			return false;
-		}
-
-		return true;
-	}
-
-	int32_t* XmlDeserializer::getSimpleStructRedirect(uint32_t size)
-	{
-		if (mSimpleStructRedirectSize < size)
-		{
-			if (mSimpleStructRedirect != NULL)
-				mTraits->free(mSimpleStructRedirect);
-
-			if (size < 16)
-				size = 16; // just to not allocate all these small things more than once
-
-			mSimpleStructRedirect = (int32_t*)mTraits->alloc(sizeof(int32_t) * size);
-			mSimpleStructRedirectSize = size;
-		}
-
-		memset(mSimpleStructRedirect, -1, sizeof(int32_t) * size);
-		return mSimpleStructRedirect;
-	}
-
-}
+// 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) 2008-2013 NVIDIA Corporation. All rights reserved.

+

+#include "PxSimpleTypes.h"

+#include "NvParameters.h"

+#include "nvparameterized/NvParameterizedTraits.h"

+

+#include "NvTraitsInternal.h"

+

+#include "XmlDeserializer.h"

+

+#define XML_WARNING(_format, ...) \

+	NV_PARAM_TRAITS_WARNING(mTraits, "XML serializer: " _format, ##__VA_ARGS__)

+

+

+

+namespace NvParameterized

+{

+

+/*!

+Get number of elements in array

+*/

+template <typename T, size_t N>

+char (&ArraySizeHelper(T (&array)[N]))[N];

+#define PX_ARRAY_SIZE(_array) (sizeof(ArraySizeHelper(_array)))

+

+	static uint32_t ReadVersion(const physx::shdfnd::FastXml::AttributePairs& attr)

+	{

+		const char *versionText = attr.get("version");

+

+		// If there's no version, assume version is 0.0

+		if( !versionText )

+			return 0;

+

+		//XML stores versions in "x.y"-format

+		//FIXME: strtoul is unsafe

+

+		const char *dot = strchr(versionText, '.');

+		uint32_t minor = dot ? strtoul(dot + 1, 0, 10) : 0;

+

+		uint32_t major = strtoul(versionText, 0, 10);

+

+		return (major << 16) + minor;

+	}

+

+	static PX_INLINE bool isWhiteSpace(char c)

+	{

+		return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == ',';

+	}

+

+	static PX_INLINE const char * skipWhiteSpace(const char *scan)

+	{

+		while ( isWhiteSpace(*scan) && *scan ) scan++;

+		return *scan ? scan : 0;

+	}

+

+	static PX_FORCE_INLINE const char * skipNonWhiteSpace(const char* scan)

+	{

+		while ( !isWhiteSpace(*scan) && *scan ) scan++;

+		return *scan ? scan : 0;

+	}

+

+	bool XmlDeserializer::verifyObject(Interface *obj, const physx::shdfnd::FastXml::AttributePairs& attr)

+	{

+		if( ReadVersion(attr) != obj->version() )

+		{

+			XML_WARNING("unknown error");

+			DEBUG_ALWAYS_ASSERT();

+			mError = Serializer::ERROR_UNKNOWN;

+			return false;

+		}

+

+		char *checksum = (char *)attr.get("checksum");

+		if( checksum && !DoIgnoreChecksum(*obj) )

+		{

+			uint32_t objBits;

+			const uint32_t *objChecksum = obj->checksum(objBits);

+

+			uint32_t bits = 0;

+

+			char *cur = checksum, *next = 0;

+			bool sameBits = true;

+			for(uint32_t i = 0; ; ++i, cur = next)

+			{

+				uint32_t val = (uint32_t)strtoul(cur, &next, 0); //FIXME: strtoul is not safe

+				if( cur == next )

+					break;

+

+				bits += 32;

+				if( bits > objBits || val != objChecksum[i] )

+				{

+					NV_PARAM_TRAITS_WARNING(

+						mTraits,

+						"Schema checksum is different for object of class %s and version %u, "

+							"asset may be corrupted",

+						obj->className(),

+						(unsigned)obj->version()

+						);

+					sameBits = false;

+					break;

+				}

+			}

+

+			if( objBits != bits && sameBits )

+			{

+				NV_PARAM_TRAITS_WARNING(

+					mTraits,

+					"Schema checksum is different for object of class %s and version %u, "

+						"asset may be corrupted",

+					obj->className(),

+					(unsigned)obj->version()

+					);

+			}

+		} //if( checksum )

+

+		return true;

+	}

+

+	bool XmlDeserializer::initAddressString(char *dest, uint32_t len, const char *name)

+	{

+		char *end = dest + len;

+

+		for (uint32_t i = 0; i < tos().getIndex(); i++)

+		{

+			FieldInfo &field = tos().getFieldInfo(i);

+

+			const char *n = field.name;

+			FieldType type = field.type;

+

+			if( SKIP == type )

+				continue;

+

+			while ( n && *n && dest < end )

+				*dest++ = *n++;

+

+			if ( ARRAY == type )

+			{

+				char temp[512];

+				physx::shdfnd::snprintf(temp, 512, "[%d]", field.idx);

+

+				if( dest + ::strlen(temp) >= end )

+				{

+					XML_WARNING("buffer overflow");

+					DEBUG_ALWAYS_ASSERT();

+					mError = Serializer::ERROR_INTERNAL_BUFFER_OVERFLOW;

+					return false;

+				}

+

+				const char *scan = temp;

+				while ( *scan && dest < end )

+				{

+					*dest++ = *scan++;

+				}

+			}

+			else

+			{

+				if( dest + 1 >= end )

+				{

+					XML_WARNING("buffer overflow");

+					DEBUG_ALWAYS_ASSERT();

+					mError = Serializer::ERROR_INTERNAL_BUFFER_OVERFLOW;

+					return false;

+				}

+

+				*dest++ = '.';

+			}

+		}

+

+		while ( name && *name && dest < end )

+		{

+			*dest++ = *name++;

+		}

+

+		*dest = 0;

+		//printf("Fully qualified name: %s\n", scratch );

+

+		return true;

+	}

+

+	bool XmlDeserializer::processClose(const char *tag,uint32_t depth,bool &isError)

+	{

+		isError = true; //By default if we return with false it's due to error

+

+		if( strcmp(tag, "NxParameters") == 0 ||

+			strcmp(tag, "NvParameters") == 0)

+		{

+			mInRootElement = false;

+

+			// in xml there's only 1 root element allowed,

+			// so we want to stop after the first NvParameters

+			isError = false;

+			return false;

+		}

+

+		static const char *validTags[] = {

+			"struct",

+			"value",

+			"array"

+		};

+

+		for(uint32_t i = 0; i < PX_ARRAY_SIZE(validTags); ++i)

+		{

+			if( 0 != ::strcmp(validTags[i], tag) )

+				continue;

+

+#	ifndef NDEBUG

+			uint32_t idx = tos().getIndex();

+			DEBUG_ASSERT( idx > 0 );

+

+			static FieldType validTypes[] = {

+				STRUCT,

+				VALUE,

+				ARRAY

+			};

+

+			// Make gcc happy

+			const FieldType* tmp = &validTypes[0];

+			PX_UNUSED(tmp);

+

+			FieldType type = tos().getFieldInfo(idx - 1).type;

+			PX_UNUSED(type);

+			DEBUG_ASSERT( type == SKIP || type == validTypes[i] );

+#	endif

+

+			if( !popField() )

+				return false;

+

+			if (depth == 1 && mRootIndex > MAX_ROOT_OBJ)

+			{

+				DEBUG_ASSERT(i == 1);

+				mObjects[0].getObject()->destroy();

+			}

+

+			return tos().getIndex() ? depth != 0 : popObj();

+		}

+

+		return false;

+	}

+

+	bool XmlDeserializer::processElement(

+		const char *elementName,

+		const char *elementData,

+		const physx::shdfnd::FastXml::AttributePairs& attr,

+		int32_t /*lineno*/)

+	{

+		//Force DOCTYPE

+		if( !mHasDoctype )

+		{

+			XML_WARNING("DOCTYPE is missing");

+			DEBUG_ALWAYS_ASSERT();

+			mError = Serializer::ERROR_MISSING_DOCTYPE;

+			return false;

+		}

+

+		if( strcmp(elementName, "NxParameters")  == 0 ||

+			strcmp(elementName, "NvParameters")  == 0)

+		{

+			if( mObjIndex )

+			{

+				XML_WARNING("NvParameters must be root element");

+				DEBUG_ALWAYS_ASSERT();

+				mError = Serializer::ERROR_MISSING_ROOT_ELEMENT;

+				return false;

+			}

+

+			if( mInRootElement )

+			{

+				XML_WARNING("More than one root element encountered");

+				DEBUG_ALWAYS_ASSERT();

+				mError = Serializer::ERROR_INVALID_NESTING;

+				return false;

+			}

+

+			uint32_t ver = ReadVersion(attr);

+			if( ver != mVer )

+			{

+				XML_WARNING("unknown version of APX file format: %u", (unsigned)ver);

+				DEBUG_ALWAYS_ASSERT();

+				mError = Serializer::ERROR_INVALID_FILE_VERSION;

+				return false;

+			}

+

+			const char* numObjects = attr.get("numObjects");

+			if (numObjects != NULL)

+			{

+				PX_ASSERT(atoi(numObjects) >= 0);

+				const uint32_t num = static_cast<uint32_t>(atoi(numObjects));

+				if (num > MAX_ROOT_OBJ)

+				{

+					XML_WARNING("APX file has more than %d root objects, only %d will be read", num, MAX_ROOT_OBJ);

+				}

+			}

+

+

+			++mRootTags;

+			mInRootElement = true;

+

+			return true;

+		}

+

+		if( mRootTags > 0 && !mInRootElement )

+		{

+			XML_WARNING("element %s not under root element", elementName);

+			DEBUG_ALWAYS_ASSERT();

+			mError = Serializer::ERROR_MISSING_ROOT_ELEMENT;

+			return false;

+		}

+

+		if ( strcmp(elementName, "struct") == 0 )

+		{

+			const char *name = attr.get("name");

+

+			if( !mObjIndex )

+			{

+				XML_WARNING("struct-element %s not under value-element", name);

+				DEBUG_ALWAYS_ASSERT();

+				mError = Serializer::ERROR_INVALID_NESTING;

+				return false;

+			}

+

+			pushField(name, STRUCT);

+		}

+		else if ( strcmp(elementName, "value") == 0 )

+		{

+			if( !mObjIndex ) //Root object?

+			{

+				const char *className = attr.get("className");

+

+				uint32_t version = ReadVersion(attr);

+

+				Interface *obj = mTraits->createNvParameterized(className, version);

+				if( !obj )

+				{

+					XML_WARNING("failed to create object of type %s and version %u", className, (unsigned)version);

+					DEBUG_ALWAYS_ASSERT();

+					mError = Serializer::ERROR_OBJECT_CREATION_FAILED;

+					return false;

+				}

+

+				const char *objectName = attr.get("objectName");

+				if( objectName )

+					obj->setName(objectName);

+

+				if (mRootIndex < MAX_ROOT_OBJ)

+				{

+					mRootObjs[mRootIndex] = obj;

+				}

+				mRootIndex++;

+

+				pushObj(obj);

+				pushField("", SKIP); //Root <value> should not be used in initAddressString

+

+				return true;

+			}

+

+			const char *name = attr.get("name");

+

+			char scratch[2048];

+			if( !initAddressString(scratch, sizeof(scratch), name) )

+			{

+				return false;

+			}

+

+			pushField(name, VALUE);

+

+			Interface *obj = tos().getObject();

+			if( !obj )

+			{

+				XML_WARNING("unknown error");

+				DEBUG_ALWAYS_ASSERT();

+				mError = Serializer::ERROR_UNKNOWN;

+				return false;

+			}

+

+			Handle handle(*obj, scratch);

+			if( !handle.isValid() )

+			{

+				XML_WARNING("%s: invalid path", scratch);

+				DEBUG_ALWAYS_ASSERT();

+//				mError = Serializer::ERROR_INVALID_PARAM_HANDLE;

+				return true;

+			}

+

+			const char *type = attr.get("type");

+			const char *expectedType = typeToStr(handle.parameterDefinition()->type());

+			if ( type && 0 != physx::shdfnd::stricmp(type, expectedType) )

+			{

+				XML_WARNING("%s: invalid type %s (expected %s)", scratch, type, expectedType);

+				DEBUG_ALWAYS_ASSERT();

+				mError = Serializer::ERROR_INVALID_ATTR;

+				return false;

+			}

+

+			const char *included = attr.get("included");

+			if ( included )

+			{

+				bool isIncludedRef = 0 != atoi(included);

+				if( isIncludedRef != handle.parameterDefinition()->isIncludedRef() )

+				{

+					XML_WARNING("%s: unexpected included-attribute", scratch);

+					DEBUG_ALWAYS_ASSERT();

+					mError = Serializer::ERROR_INVALID_ATTR;

+					return false;

+				}

+

+				const char *className = attr.get("className");

+				if( !className )

+				{

+					if( attr.get("classNames") )

+					{

+						// Ref is NULL

+

+						Interface *oldObj = 0;

+						if( NvParameterized::ERROR_NONE != handle.getParamRef(oldObj) )

+							return false;

+						if( oldObj )

+							oldObj->destroy();

+

+						handle.setParamRef(0);

+

+						return true;

+					}

+					else

+					{

+						XML_WARNING("%s: missing both className and classNames attribute", scratch);

+						DEBUG_ALWAYS_ASSERT();

+						mError = Serializer::ERROR_INVALID_ATTR;

+						return false;

+					}

+				}

+

+				uint32_t version = ReadVersion(attr);

+

+				Interface *refObj = 0;

+				if( isIncludedRef )

+					refObj = mTraits->createNvParameterized(className, version);

+				else

+				{

+					void *buf = mTraits->alloc(sizeof(NvParameters));

+					refObj = PX_PLACEMENT_NEW(buf, NvParameters)(mTraits);

+

+					refObj->setClassName(className);

+				}

+

+				if( !refObj )

+				{

+					XML_WARNING("%s: failed to create object of type %s and version %u", scratch, className, (unsigned)version);

+					DEBUG_ALWAYS_ASSERT();

+					mError = Serializer::ERROR_OBJECT_CREATION_FAILED;

+					return false;

+				}

+

+				if( refObj && (-1 == handle.parameterDefinition()->refVariantValIndex(refObj->className())) )

+				{

+					char longName[256];

+					handle.getLongName(longName, sizeof(longName));

+					NV_PARAM_TRAITS_WARNING(

+						mTraits,

+						"%s: setting reference of invalid class %s",

+						longName,

+						refObj->className()

+						);

+				}

+

+				if( NvParameterized::ERROR_NONE != handle.setParamRef(refObj) )

+				{

+					XML_WARNING("%s: failed to set reference of type %s", scratch, className);

+					DEBUG_ALWAYS_ASSERT();

+					mError = Serializer::ERROR_INVALID_REFERENCE;

+					return false;

+				}

+

+				const char *objectName = attr.get("objectName");

+				if( objectName && refObj )

+					refObj->setName(objectName);

+

+				if( isIncludedRef )

+					pushObj(refObj);

+				else if ( elementData && refObj )

+					refObj->setName(elementData);

+			}

+			else

+			{

+				if ( elementData == 0 )

+					elementData = "";

+

+				const char *isNull = attr.get("null");

+				if( isNull && 0 != atoi(isNull) )

+				{

+					//Only strings and enums may be NULL so it's safe to call setParamString

+

+					DataType t = handle.parameterDefinition()->type();

+					PX_UNUSED(t);

+					DEBUG_ASSERT( TYPE_STRING == t || TYPE_ENUM == t );

+

+					handle.setParamString(0);

+				}

+				else

+				{

+					if( NvParameterized::ERROR_NONE != handle.strToValue(elementData, 0) )

+					{

+						XML_WARNING("%s: failed to convert string to value: %10s", scratch, elementData);

+						DEBUG_ALWAYS_ASSERT();

+						mError = Serializer::ERROR_STRING2VAL_FAILED;

+						return false;

+					}

+				}

+			} //if ( included )

+		}

+		else if ( strcmp(elementName, "array") == 0 )

+		{

+			const char *name = attr.get("name");

+

+			if( !mObjIndex )

+			{

+				XML_WARNING("array-element %s not under value-element", name);

+				DEBUG_ALWAYS_ASSERT();

+				mError = Serializer::ERROR_INVALID_NESTING;

+				return false;

+			}

+

+			int32_t arraySize = 0;

+			if ( const char *sz = attr.get("size") )

+			{

+				PX_ASSERT(atoi(sz) >= 0);

+				arraySize = (int32_t)atoi(sz);

+			}

+

+			if ( arraySize > 0 )

+			{

+				Interface *obj = tos().getObject();

+				if( !obj )

+				{

+					XML_WARNING("unknown error");

+					DEBUG_ALWAYS_ASSERT();

+					mError = Serializer::ERROR_UNKNOWN;

+					return false;

+				}

+

+				char scratch[2048];

+				if( !initAddressString(scratch, sizeof(scratch), name) )

+				{

+					return false;

+				}

+

+				Handle handle(*obj, scratch);

+				if( !handle.isValid() )

+				{

+

+					mError = Serializer::ERROR_INVALID_PARAM_HANDLE;

+					XML_WARNING("%s: invalid path", scratch);

+					DEBUG_ALWAYS_ASSERT();

+

+					return false;

+				}

+

+				if( !handle.parameterDefinition()->arraySizeIsFixed() )

+					if( NvParameterized::ERROR_NONE != handle.resizeArray(arraySize) )

+					{

+						XML_WARNING("%s: failed to resize array", scratch);

+						DEBUG_ALWAYS_ASSERT();

+						mError = Serializer::ERROR_INVALID_ARRAY;

+						return false;

+					}

+					if ( elementData )

+					{

+						const char *scan = elementData;

+

+						handle.set(0);

+						const Definition *paramDef = handle.parameterDefinition();

+						handle.popIndex();

+

+

+						if ( paramDef->type() == TYPE_STRUCT )

+						{

+							// read the structElements field

+							const char* structElements = attr.get("structElements");

+

+							int32_t* simpleStructRedirect = getSimpleStructRedirect(static_cast<uint32_t>(paramDef->numChildren()));

+							uint32_t numRedirects = 0;

+							while (structElements && *structElements)

+							{

+								char fieldName[64];

+								char type[16];

+

+								size_t count = 0;

+								while(*structElements != 0 && *structElements != ',' && *structElements != '(')

+									fieldName[count++] = *structElements++;

+								if( count >= sizeof(fieldName) )

+								{

+									DEBUG_ALWAYS_ASSERT();

+									mError = Serializer::ERROR_INTERNAL_BUFFER_OVERFLOW;

+									return false;

+								}

+								fieldName[count] = 0;

+

+								if (*structElements == '(')

+								{

+									structElements++;

+									count = 0;

+									while(*structElements != 0 && *structElements != ',' && *structElements != ')')

+										type[count++] = *structElements++;

+									if( count >= sizeof(type) )

+									{

+										DEBUG_ALWAYS_ASSERT();

+										mError = Serializer::ERROR_INTERNAL_BUFFER_OVERFLOW;

+										return false;

+									}

+									type[count] = 0;

+

+								}

+								if (*structElements == ')')

+									structElements++;

+								if (*structElements == ',')

+									structElements++;

+

+								const Definition* childDef = paramDef->child(fieldName, simpleStructRedirect[numRedirects]);

+								const char* trueType = childDef ? typeToStr(childDef->type()) : 0;

+								if (childDef && ::strcmp(trueType, type) != 0)

+								{

+									XML_WARNING(

+										"%s[].%s: unexpected type: %s (must be %s)",

+										scratch, fieldName, type, trueType ? trueType : "");

+									DEBUG_ALWAYS_ASSERT();

+									mError = Serializer::ERROR_INVALID_DATA_TYPE;

+									return false;

+								}

+

+								// -2 means to reed the data but not storing it

+								// -1 means to not read the data as it was not serialized'

+								// i = [0 .. n] means to read the data and store it in child i

+								if (childDef == NULL)

+								{

+									simpleStructRedirect[numRedirects] = -2;

+

+									// Fail fast

+									XML_WARNING("%s[]: unexpected structure field: %s", scratch, fieldName);

+									DEBUG_ALWAYS_ASSERT();

+									mError = Serializer::ERROR_INVALID_PARAM_HANDLE;

+									return false;

+								}

+

+								numRedirects++;

+							}

+

+							const int32_t numChildren = paramDef->numChildren();

+							for(int32_t i = 0; i < arraySize; ++i)

+							{

+								handle.set(i);

+								for( int32_t j=0; j<numChildren; j++ )

+								{

+									if (simpleStructRedirect[j] < 0)

+									{

+										if (simpleStructRedirect[j] < -1)

+										{

+											// read the data anyways

+											scan = skipWhiteSpace(scan);

+											if (scan != NULL)

+												scan = skipNonWhiteSpace(scan);

+										}

+										continue;

+									}

+

+									scan = skipWhiteSpace(scan);

+									if ( !scan ) break;

+

+									handle.set(simpleStructRedirect[j]);

+

+									if( NvParameterized::ERROR_NONE != handle.strToValue(scan, &scan) )

+									{

+										XML_WARNING("%s: failed to convert string to value: %10s...", scan);

+										DEBUG_ALWAYS_ASSERT();

+										mError = Serializer::ERROR_STRING2VAL_FAILED;

+										return false;

+									}

+

+									handle.popIndex();

+									if ( !scan ) break;

+								}

+								handle.popIndex();

+								if ( !scan ) break;

+							}

+						}

+						else

+						{

+							// LRR: wall clock time is the same for this simple loop as the previous

+							//      "unrolled" version

+							for (int32_t i = 0; i<arraySize; i++)

+							{

+								handle.set(i);

+								if( NvParameterized::ERROR_NONE != handle.strToValue(scan, &scan) )

+								{

+									XML_WARNING("%s: failed to convert string to value: %10s", scratch, scan);

+									DEBUG_ALWAYS_ASSERT();

+									mError = Serializer::ERROR_STRING2VAL_FAILED;

+									return false;

+								}

+								handle.popIndex();

+							}

+						}

+					} //if( elementData )

+			} //if ( arraySize > 0 )

+

+			pushField(name, ARRAY);

+		}

+		else

+		{

+			XML_WARNING("unknown element %s", elementName);

+			DEBUG_ALWAYS_ASSERT();

+			mError = Serializer::ERROR_UNKNOWN_XML_TAG;

+			return false;

+		}

+

+		return true;

+	}

+

+	int32_t* XmlDeserializer::getSimpleStructRedirect(uint32_t size)

+	{

+		if (mSimpleStructRedirectSize < size)

+		{

+			if (mSimpleStructRedirect != NULL)

+				mTraits->free(mSimpleStructRedirect);

+

+			if (size < 16)

+				size = 16; // just to not allocate all these small things more than once

+

+			mSimpleStructRedirect = (int32_t*)mTraits->alloc(sizeof(int32_t) * size);

+			mSimpleStructRedirectSize = size;

+		}

+

+		memset(mSimpleStructRedirect, -1, sizeof(int32_t) * size);

+		return mSimpleStructRedirect;

+	}

+

+}

diff --git a/sdk/extensions/import/apexmodules/NvParameterized/src/XmlSerializer.cpp b/sdk/extensions/import/apexmodules/NvParameterized/src/XmlSerializer.cpp
index b3f3c22..120815e 100644..100755
--- a/sdk/extensions/import/apexmodules/NvParameterized/src/XmlSerializer.cpp
+++ b/sdk/extensions/import/apexmodules/NvParameterized/src/XmlSerializer.cpp
@@ -1,1270 +1,1270 @@
-// 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) 2008-2013 NVIDIA Corporation. All rights reserved.
-
-#include "PxSimpleTypes.h"
-#include "PxAssert.h"
-#include "PsArray.h"
-#include "PxVec3.h"
-#include "PxQuat.h"
-#include "PxBounds3.h"
-#include "PsFastXml.h"
-#include "PsIOStream.h"
-
-#include "nvparameterized/NvSerializer.h"
-#include "XmlSerializer.h"
-#include "nvparameterized/NvParameterized.h"
-#include "nvparameterized/NvParameterizedTraits.h"
-#include "NvParameters.h"
-
-#include "NvTraitsInternal.h"
-#include "XmlDeserializer.h"
-
-#define PRINT_ELEMENT_HINTS 0
-#define PRINT_ELEMENTS_WITHIN_EMPTY_ARRAYS 0
-
-#define UNOPTIMIZED_XML 0
-
-namespace NvParameterized
-{
-
-static const char indentStr[] = "  ";
-
-struct traversalState
-{
-	traversalState()
-	{
-		indent[0] = 0;
-		indentLen = 0;
-		level = 0;
-	}
-
-	void incLevel()
-	{
-		physx::shdfnd::strlcat(indent, (uint32_t)strlen(indent) + (uint32_t)strlen(indentStr) + 1, indentStr);
-		level++;
-	}
-
-	void decLevel()
-	{
-		level--;
-		indentLen = (sizeof(indentStr) - 1) * level;
-		if(indentLen < sizeof(indent))
-			indent[indentLen] = 0;
-	}
-
-	char indent[4096];
-	uint32_t indentLen;
-	int32_t level;
-};
-
-Serializer::ErrorType XmlSerializer::peekNumObjects(char *data, uint32_t len, uint32_t &numObjects)
-{
-	//FIXME: this code is not robust
-
-	data[len-1] = 0;
-
-	const char *root = ::strstr(data, "<NvParameters");
-	if( !root )
-	{
-		root = ::strstr(data, "<NvParameters");
-		if (!root)
-		{
-			return Serializer::ERROR_MISSING_ROOT_ELEMENT;
-		}
-	}
-
-	const char *numObjectsString = ::strstr(root, "numObjects");
-	if( !numObjectsString )
-		return Serializer::ERROR_INVALID_ATTR;
-
-	numObjectsString = ::strstr(numObjectsString, "\"");
-	if( !numObjectsString )
-		return Serializer::ERROR_INVALID_ATTR;
-
-	numObjects = strtoul(numObjectsString + 1, 0, 0); //Skip leading quote
-	return Serializer::ERROR_NONE;
-}
-
-class InputDataFromPxFileBuf: public physx::PxInputData
-{
-public:
-	InputDataFromPxFileBuf(physx::PxFileBuf& fileBuf): mFileBuf(fileBuf) {}
-
-	// physx::PxInputData interface
-	virtual uint32_t	getLength() const
-	{
-		return mFileBuf.getFileLength();
-	}
-
-	virtual void	seek(uint32_t offset)
-	{
-		mFileBuf.seekRead(offset);
-	}
-
-	virtual uint32_t	tell() const
-	{
-		return mFileBuf.tellRead();
-	}
-
-	// physx::PxInputStream interface
-	virtual uint32_t read(void* dest, uint32_t count)
-	{
-		return mFileBuf.read(dest, count);
-	}
-
-	PX_NOCOPY(InputDataFromPxFileBuf)
-private:
-	physx::PxFileBuf& mFileBuf;
-};
-
-Serializer::ErrorType XmlSerializer::peekClassNames(physx::PxFileBuf &stream, char **classNames, uint32_t &numClassNames)
-{
-	class ClassNameReader: public physx::shdfnd::FastXml::Callback
-	{
-		uint32_t mDepth;
-		uint32_t mNumObjs;
-
-		char **mClassNames;
-		uint32_t mNumClassNames;
-
-		Traits *mTraits;
-
-	public:
-		ClassNameReader(char **classNames, uint32_t &numClassNames, Traits *traits)
-			: mDepth(0), mNumObjs(0), mClassNames(classNames), mNumClassNames(numClassNames), mTraits(traits) {}
-
-		uint32_t numObjs() const { return mNumObjs; }
-
-		bool processComment(const char * /*comment*/) { return true; }
-
-		bool processClose(const char * /*element*/,uint32_t /*depth*/,bool & /*isError*/)
-		{
-			--mDepth;
-			return true;
-		}
-
-		bool processElement(
-			const char *elementName,
-			const char  * /*elementData*/,
-			const physx::shdfnd::FastXml::AttributePairs& attr,
-			int32_t /*lineno*/)
-		{
-			//Ignore top-level element
-			if( 0 == strcmp(elementName, "NvParameters") ||  0 == strcmp(elementName, "NxParameters"))
-				return true;
-
-			++mDepth;
-
-			if( 1 != mDepth || 0 != strcmp(elementName, "value") )
-				return true;
-
-			//Top-level <value> => read className
-			mClassNames[mNumObjs] = mTraits->strdup( attr.get("className") );
-			++mNumObjs;
-
-			return mNumObjs < mNumClassNames;
-		}
-
-		void *allocate(uint32_t size) { return ::malloc(size); }
-		void deallocate(void *ptr) { ::free(ptr); };
-	};
-
-	ClassNameReader myReader(classNames, numClassNames, mTraits);
-	physx::shdfnd::FastXml *xmlParser = physx::shdfnd::createFastXml(&myReader);
-
-	InputDataFromPxFileBuf inputData(stream);
-	xmlParser->processXml(inputData);
-	numClassNames = myReader.numObjs();
-
-	return Serializer::ERROR_NONE;
-}
-
-Serializer::ErrorType XmlSerializer::peekNumObjectsInplace(const void * data, uint32_t dataLen, uint32_t & numObjects)
-{
-	if ( !dataLen || ! data )
-		return ERROR_STREAM_ERROR;
-
-	char hdr[100];
-	uint32_t len = physx::PxMin<uint32_t>(dataLen, sizeof(hdr) - 1);
-	physx::shdfnd::strlcpy(hdr, len+1, (const char *)data);
-
-	return peekNumObjects(hdr, len, numObjects);
-}
-
-Serializer::ErrorType XmlSerializer::peekNumObjects(physx::PxFileBuf &stream, uint32_t &numObjects)
-{
-	//FIXME: this code is not robust
-
-	char hdr[100];
-	uint32_t len = stream.peek(hdr, sizeof(hdr));
-
-	return peekNumObjects(hdr, len, numObjects);
-}
-
-#ifndef WITHOUT_APEX_SERIALIZATION
-
-static void storeVersionAndChecksum(physx::PsIOStream &stream, const Interface *obj)
-{
-	uint16_t major = obj->getMajorVersion(),
-		minor = obj->getMinorVersion(); 
-
-	stream << " version=\"" << major << '.' << minor << '"';
-
-	uint32_t bits;
-	const uint32_t *checksum = obj->checksum(bits);
-
-	uint32_t u32s = bits / 32;
-	PX_ASSERT( 0 == bits % 32 );
-
-	stream << " checksum=\"";
-	for(uint32_t i = 0; i < u32s; ++i)
-	{
-		char hex[20];
-		physx::shdfnd::snprintf(hex, sizeof(hex), "0x%x", checksum[i]);
-		stream << hex;
-		if( u32s - 1 != i )
-			stream << ' ';
-	}
-	stream << '"';
-}
-
-static bool IsSimpleType(const Definition *d)
-{
-	//We do not consider strings simple because it causes errors with NULL and ""
-	if (d->type() == TYPE_ARRAY  || d->type() == TYPE_STRUCT ||
-		d->type() == TYPE_REF || d->type() == TYPE_STRING ||
-		d->type() == TYPE_ENUM)
-	{
-		return false;
-	}
-	else
-	{
-		PX_ASSERT( d->numChildren() == 0 );
-		return true;
-	}
-}
-
-static bool IsSimpleStruct(const Definition *pd)
-{
-	bool ret = true;
-
-	int32_t count = pd->numChildren();
-	for (int32_t i=0; i < count; i++)
-	{
-		const Definition *d = pd->child(i);
-		if ( !IsSimpleType(d) )
-		{
-			ret = false;
-			break;
-		}
-	}
-
-	return ret;
-}
-
-static bool DoesNeedQuote(const char *c)
-{
-	bool ret = false;
-	while ( *c )
-	{
-		if ( *c == 32 || *c == ',' || *c == '<' || *c == '>' || *c == 9 )
-		{
-			ret = true;
-			break;
-		}
-		c++;
-	}
-
-	return ret;
-}
-	
-Serializer::ErrorType XmlSerializer::traverseParamDefTree(
-	const Interface &obj,
-	physx::PsIOStream &stream,
-	traversalState &state,
-	Handle &handle,
-	bool printValues)
-{
-	bool isRoot = !handle.numIndexes() && 0 == state.level;
-
-	if( !handle.numIndexes() )
-	{
-		NV_PARAM_ERR_CHECK_RETURN( obj.getParameterHandle("", handle), Serializer::ERROR_UNKNOWN );
-
-		if( isRoot )
-		{
-			NV_ERR_CHECK_RETURN( emitElement(obj, stream, "value", handle, false, true, true) );
-			stream << "\n";
-
-			state.incLevel();
-		}
-	}
-
-	const Definition *paramDef = handle.parameterDefinition();
-
-	if( !paramDef->hint("DONOTSERIALIZE") )
-	{
-
-#	if PRINT_ELEMENT_HINTS
-	bool includedRef = false;
-
-	NV_ERR_CHECK_RETURN( emitElementNxHints(stream, handle, state, includedRef) );
-#	else
-	bool includedRef = paramDef->isIncludedRef();
-#	endif
-
-	switch( paramDef->type() )
-	{
-	case TYPE_STRUCT:
-		{
-			stream << state.indent;
-			NV_ERR_CHECK_RETURN( emitElement(obj, stream, "struct", handle, false, true) );
-			stream << "\n";
-
-			state.incLevel();
-			for(int32_t i = 0; i < paramDef->numChildren(); ++i)
-			{
-				handle.set(i);
-				NV_ERR_CHECK_RETURN( traverseParamDefTree(obj, stream, state, handle, printValues) );
-				handle.popIndex();
-			}
-
-			state.decLevel();
-
-			stream << state.indent << "</struct>\n";
-
-			break;
-		}
-
-	case TYPE_ARRAY:
-		{
-			stream << state.indent;
-			NV_ERR_CHECK_RETURN( emitElement(obj, stream, "array", handle, false, true) );
-
-			int32_t arraySize;
-			NV_PARAM_ERR_CHECK_RETURN( handle.getArraySize(arraySize), Serializer::ERROR_INVALID_ARRAY );
-
-			if( arraySize)
-				stream << "\n";
-
-			state.incLevel();
-
-			if ( arraySize > 0 )
-			{
-#if UNOPTIMIZED_XML
-				for(int32_t i = 0; i < arraySize; ++i)
-				{
-					handle.set(i);
-					NV_ERR_CHECK_RETURN( traverseParamDefTree(obj, stream, state, handle, printValues) );
-					handle.popIndex();
-				}
-#else
-				handle.set(0);
-				const Definition *pd = handle.parameterDefinition();
-				handle.popIndex();
-				switch ( pd->type() )
-				{
-					case TYPE_STRUCT:
-						{
-							if ( IsSimpleStruct(pd) )
-							{
-								for(int32_t i = 0; i < arraySize; ++i)
-								{
-
-									if ( (i&3) == 0 )
-									{
-										if ( i )
-											stream << "\n";
-										stream << state.indent;
-									}
-
-									handle.set(i);
-
-									for( int32_t j=0; j<pd->numChildren(); j++ )
-									{
-										if (pd->child(j)->hint("DONOTSERIALIZE"))
-											continue;
-
-										handle.set(j);
-
-										char buf[512];
-										const char *str = 0;
-										NV_PARAM_ERR_CHECK_RETURN( handle.valueToStr(buf, sizeof(buf), str), Serializer::ERROR_VAL2STRING_FAILED );
-
-										stream << str;
-
-										if ( (j+1) < pd->numChildren() )
-										{
-											stream << " ";
-										}
-
-										handle.popIndex();
-									}
-
-									if ( (i+1) < arraySize )
-									{
-										stream << ",";
-									}
-
-									handle.popIndex();
-								} //i
-								stream << "\n";
-							}
-							else
-							{
-								for(int32_t i = 0; i < arraySize; ++i)
-								{
-									handle.set(i);
-									NV_ERR_CHECK_RETURN( traverseParamDefTree(obj, stream, state, handle, printValues) );
-									handle.popIndex();
-								}
-							}
-						}
-						break;
-
-					case TYPE_REF:
-						for(int32_t i = 0; i < arraySize; ++i)
-						{
-							handle.set(i);
-							NV_ERR_CHECK_RETURN( traverseParamDefTree(obj, stream, state, handle, printValues) );
-							handle.popIndex();
-						}
-						break;
-
-					case TYPE_BOOL:
-						{
-							bool v = false;
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamBoolArray(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								stream << (uint32_t)v;
-								if ( (i+1) < arraySize )
-								{
-									stream << " ";
-								}
-								if ( ((i+1)&63) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-						break;
-
-    				case TYPE_I8:
-						{
-							int8_t v = 0;
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamI8Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								stream << v;
-								if ( (i+1) < arraySize )
-								{
-									stream << " ";
-								}
-								if ( ((i+1)&63) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-    					break;
-
-    				case TYPE_I16:
-						{
-							int16_t v = 0;
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamI16Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								stream << v;
-								if ( (i+1) < arraySize )
-								{
-									stream << " ";
-								}
-								if ( ((i+1)&31) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-    					break;
-
-    				case TYPE_I32:
-						{
-							int32_t v = 0;
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamI32Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								stream << v;
-								if ( (i+1) < arraySize )
-								{
-									stream << " ";
-								}
-								if ( ((i+1)&31) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-    					break;
-
-    				case TYPE_I64:
-						{
-							int64_t v = 0;
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamI64Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								stream << v;
-								if ( (i+1) < arraySize )
-								{
-									stream << " ";
-								}
-								if ( ((i+1)&31) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-    					break;
-
-    				case TYPE_U8:
-						{
-							uint8_t v = 0;
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamU8Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								stream << v;
-								if ( (i+1) < arraySize )
-								{
-									stream << " ";
-								}
-								if ( ((i+1)&63) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-    					break;
-
-    				case TYPE_U16:
-						{
-							uint16_t v = 0;
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamU16Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								stream << v;
-								if ( (i+1) < arraySize )
-								{
-									stream << " ";
-								}
-								if ( ((i+1)&63) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-    					break;
-
-    				case TYPE_U32:
-						{
-							uint32_t v = 0;
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamU32Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								stream << v;
-								if ( (i+1) < arraySize )
-								{
-									stream << " ";
-								}
-								if ( ((i+1)&31) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-    					break;
-
-    				case TYPE_U64:
-						{
-							uint64_t v = 0;
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamU64Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								stream << v;
-								if ( (i+1) < arraySize )
-								{
-									stream << " ";
-								}
-								if ( ((i+1)&31) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-    					break;
-
-    				case TYPE_F32:
-						{
-							float v = 0;
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamF32Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								stream << v;
-								if ( (i+1) < arraySize )
-								{
-									stream << " ";
-								}
-								if ( ((i+1)&31) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-    					break;
-
-    				case TYPE_F64:
-						{
-							double v = 0;
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamF64Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								stream << v;
-								if ( (i+1) < arraySize )
-								{
-									stream << " ";
-								}
-								if ( ((i+1)&31) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-    					break;
-
-					case TYPE_VEC2:
-						{
-							physx::PxVec2 v(0,0);
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamVec2Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								stream << v.x << " " << v.y;
-								if ( (i+1) < arraySize )
-								{
-									stream << ", ";
-								}
-								if ( ((i+1)&15) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-						break;
-
-					case TYPE_VEC3:
-						{
-							physx::PxVec3 v(0,0,0);
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamVec3Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								stream << v.x << " " << v.y << " " << v.z;
-								if ( (i+1) < arraySize )
-								{
-									stream << ", ";
-								}
-								if ( ((i+1)&15) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-						break;
-
-					case TYPE_VEC4:
-						{
-							physx::PxVec4 v(0,0,0,0);
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamVec4Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								stream << v.x << " " << v.y << " " << v.z << " " << v.w;
-								if ( (i+1) < arraySize )
-								{
-									stream << ", ";
-								}
-								if ( ((i+1)&15) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-						break;
-
-					case TYPE_QUAT:
-						{
-							physx::PxQuat v(0,0,0,1);
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamQuatArray(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								stream << v.x << " " << v.y << " " << v.z << " " << v.w;
-								if ( (i+1) < arraySize )
-								{
-									stream << ", ";
-								}
-								if ( ((i+1)&15) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-						break;
-
-					case TYPE_MAT33:
-						{
-							physx::PxMat33 m = physx::PxMat33(physx::PxIdentity);
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamMat33Array(&m,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								const float *f = (const float *)m.front();
-								stream << f[0] << " " << f[1] << " " << f[2] << " " ;
-								stream << f[3] << " " << f[4] << " " << f[5] << " ";
-								stream << f[6] << " " << f[7] << " " << f[8];
-								if ( (i+1) < arraySize )
-								{
-									stream << ", ";
-								}
-								if ( ((i+1)&15) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-						break;
-
-					case TYPE_BOUNDS3:
-						{
-							physx::PxBounds3 v;
-							v.minimum = physx::PxVec3(0.0f);
-							v.maximum = physx::PxVec3(0.0f);
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamBounds3Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								stream << v.minimum.x << " " << v.minimum.y << " " << v.minimum.z << " " << v.maximum.x << " " << v.maximum.y << " " << v.maximum.z;
-								if ( (i+1) < arraySize )
-								{
-									stream << ", ";
-								}
-								if ( ((i+1)&15) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-						break;
-
-					case TYPE_MAT44:
-						{
-							physx::PxMat44 v = physx::PxMat44(physx::PxIdentity);
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamMat44Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								const float *f = (const float *)v.front();
-								stream << f[0] << " " << f[1] << " " << f[2] << " " << f[3] << " ";
-								stream << f[4] << " " << f[5] << " " << f[6] << " " << f[7] << " ";
-								stream << f[8] << " " << f[9] << " " << f[10] << " " << f[11] << " ";
-								stream << f[12] << " " << f[13] << " " << f[14] << " " << f[15];
-								if ( (i+1) < arraySize )
-								{
-									stream << ", ";
-								}
-								if ( ((i+1)&15) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-						break;
-
-					case TYPE_TRANSFORM:
-						{
-							physx::PxTransform v = physx::PxTransform(physx::PxIdentity);
-							stream << state.indent;
-							for (int32_t i=0; i<arraySize; i++)
-							{
-								NV_PARAM_ERR_CHECK_RETURN( handle.getParamTransformArray(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );
-								const float *f = (const float *)&v;
-								stream << f[0] << " " << f[1] << " " << f[2] << " " << f[3] << " ";
-								stream << f[4] << " " << f[5] << " " << f[6] << " ";
-								if ( (i+1) < arraySize )
-								{
-									stream << ", ";
-								}
-								if ( ((i+1)&15) == 0 )
-								{
-									stream << "\n";
-									stream << state.indent;
-								}
-							}
-							stream << "\n";
-						}
-						break;
-
-					NV_PARAMETRIZED_STRING_DATATYPE_LABELS
-					NV_PARAMETRIZED_ENUM_DATATYPE_LABELS
-					NV_PARAMETRIZED_SERVICE_DATATYPE_LABELS 
-					NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS
-					NV_PARAMETRIZED_LEGACY_DATATYPE_LABELS
-					case NvParameterized::TYPE_ARRAY:
-					default:
-						for(int32_t i = 0; i < arraySize; ++i)
-						{
-							handle.set(i);
-							NV_ERR_CHECK_RETURN( traverseParamDefTree(obj, stream, state, handle, printValues) );
-							handle.popIndex();
-						}
-						break;
-				}
-#endif
-			}
-
-#	if PRINT_ELEMENTS_WITHIN_EMPTY_ARRAYS
-			if( arraySize == 0 )
-			{
-				handle.set(0);
-				NV_ERR_CHECK_RETURN( traverseParamDefTree(obj, stream, state, handle, false) );
-				handle.popIndex();
-			}
-#	endif
-
-			state.decLevel();
-			if( arraySize)
-				stream << state.indent;
-
-			stream << "</array>\n";
-
-			break;
-		}
-
-	case TYPE_REF:
-		{
-			stream << state.indent;
-			NV_ERR_CHECK_RETURN( emitElement(obj, stream, "value", handle, includedRef, printValues) );
-
-			if( printValues && includedRef )
-			{
-				stream << state.indent << "\n";
-
-				Interface *refObj = 0;
-				NV_PARAM_ERR_CHECK_RETURN( handle.getParamRef(refObj), Serializer::ERROR_UNKNOWN );
-
-				if( refObj )
-				{
-					Handle refHandle(refObj);
-					state.incLevel();
-					NV_ERR_CHECK_RETURN( traverseParamDefTree(*refObj, stream, state, refHandle) );
-					state.decLevel();
-					stream << state.indent;
-				}
-			}
-
-			stream << "</value>\n";
-
-			break;
-		}
-
-	case TYPE_POINTER:
-		//Don't do anything with pointer
-		break;
-
-NV_PARAMETRIZED_LINAL_DATATYPE_LABELS
-NV_PARAMETRIZED_ARITHMETIC_DATATYPE_LABELS
-NV_PARAMETRIZED_STRING_DATATYPE_LABELS
-NV_PARAMETRIZED_ENUM_DATATYPE_LABELS
-NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS
-	default:
-		{
-			stream << state.indent;
-			NV_ERR_CHECK_RETURN( emitElement(obj, stream, "value", handle, includedRef, printValues) );
-
-			char buf[512];
-			const char *str = 0;
-			if(	printValues )
-				NV_PARAM_ERR_CHECK_RETURN( handle.valueToStr(buf, sizeof(buf), str), Serializer::ERROR_VAL2STRING_FAILED );
-
-			if( str )
-				stream << str;
-
-			stream << "</value>\n";
-
-			break;
-		} //default
-	} //switch
-
-	} //DONOTSERIALIZE
-
-	if( isRoot )
-	{
-		state.decLevel();
-		stream << "</value>\n";
-	}
-
-	return Serializer::ERROR_NONE;
-}
-
-Serializer::ErrorType XmlSerializer::emitElementNxHints(
-	physx::PsIOStream &stream,
-	Handle &handle,
-	traversalState &state,
-	bool &includedRef)
-{
-	const Definition *paramDef = handle.parameterDefinition();
-
-	for(int32_t j = 0; j < paramDef->numHints(); ++j)
-	{
-		if( 0 == j )
-			stream << "\n";
-
-		const Hint *hint = paramDef->hint(j);
-
-		stream << state.indent << "<!-- " << hint->name() << ": ";
-
-		if( hint->type() == TYPE_STRING )
-			stream << hint->asString() ;
-		else if( hint->type() == TYPE_U64 )
-			stream << hint->asUInt() ;
-		else if( hint->type() == TYPE_F64 )
-			stream << hint->asFloat() ;
-
-		stream << " -->\n";
-	}
-
-	includedRef = paramDef->isIncludedRef();
-
-	return Serializer::ERROR_NONE;
-}
-
-Serializer::ErrorType XmlSerializer::emitElement(
-	const Interface &obj,
-	physx::PsIOStream &stream,
-	const char *elementName,
-	Handle &handle,
-	bool includedRef,
-	bool printValues,
-	bool isRoot)
-{
-	const Definition *paramDef = handle.parameterDefinition();
-
-	DataType parentType = TYPE_UNDEFINED;
-
-	if( paramDef->parent() )
-		parentType = paramDef->parent()->type();
-
-	stream << '<' << elementName;
-
-	if( isRoot )
-	{
-		stream << " name=\"\""
-			<< " type=\"Ref\""
-			<< " className=\"" << obj.className() << "\"";
-
-		const char *objectName = obj.name();
-		if( objectName )
-			stream << " objectName=\"" << objectName << "\"";
-
-		if( isRoot ) //We only emit version info for root <struct>
-			storeVersionAndChecksum(stream, &obj);
-	}
-	else
-	{
-		if( parentType != TYPE_ARRAY )
-		{
-			const char *name = paramDef->name();
-			stream << " name=\"" << (name ? name : "") << "\"";
-		}
-	}
-
-	switch( paramDef->type() )
-	{
-	case TYPE_STRUCT:
-		break;
-
-	case TYPE_ARRAY:
-		{
-			int32_t arraySize;
-			NV_PARAM_ERR_CHECK_RETURN( handle.getArraySize(arraySize), Serializer::ERROR_INVALID_ARRAY );
-			stream << " size=\"" << arraySize << '"';
-			handle.set(0);
-			const Definition *pd = handle.parameterDefinition();
-			handle.popIndex();
-			stream << " type=\"" << typeToStr(pd->type()) << '"';
-			// ** handle use case for simple structs written out flat..
-#if !UNOPTIMIZED_XML
-			if ( pd->type() == TYPE_STRUCT && IsSimpleStruct(pd) )
-			{
-				stream << " structElements=\"";
-				const int32_t count = pd->numChildren();
-
-				// find how many of them need serialization
-				int32_t serializeCount = 0;
-				for (int32_t i=0; i<count; i++)
-				{
-					const Definition *d = pd->child(i);
-					if (d->hint("DONOTSERIALIZE") == NULL)
-					{
-						serializeCount++;
-					}
-				}
-
-				for (int32_t i=0; i<count; i++)
-				{
-					const Definition *d = pd->child(i);
-					if (d->hint("DONOTSERIALIZE"))
-						continue;
-
-					stream << d->name();
-					stream << "(";
-					stream << typeToStr(d->type());
-					stream << ")";
-					if ( (i+1) < serializeCount )
-					{
-						stream<<",";
-					}
-				}
-				stream << "\"";
-			}
-#endif
-			//
-			break;
-		}
-
-	case TYPE_REF:
-		{
-			stream << " type=\"" << typeToStr(paramDef->type()) << '"';
-
-			Interface *paramPtr = 0;
-			if( printValues )
-				NV_PARAM_ERR_CHECK_RETURN( handle.getParamRef(paramPtr), Serializer::ERROR_UNKNOWN );
-
-			stream << " included=\"" << ( includedRef ? "1" : "0" ) << "\"";
-
-			if( !printValues || !paramPtr )
-			{
-				stream << " classNames=\"";
-				for(int32_t i = 0; i < paramDef->numRefVariants(); ++i)
-				{
-					const char *ref = paramDef->refVariantVal(i);
-					if ( DoesNeedQuote(ref) )
-						stream << "%20" << ref << "%20" << " ";
-					else
-						stream << ref << " ";
-				}
-				stream << '"';
-
-				break;
-			}
-
-			stream << " className=\"" << paramPtr->className() << '"';
-
-			const char *objectName = paramPtr->name();
-			if( objectName )
-				stream << " objectName=\"" << objectName << "\"";
-
-			if( includedRef )
-				storeVersionAndChecksum(stream, paramPtr);
-
-			break;
-		}
-
-	case TYPE_STRING:
-	case TYPE_ENUM:
-		{
-			const char *val;
-			NV_PARAM_ERR_CHECK_RETURN( handle.getParamString(val), Serializer::ERROR_UNKNOWN );
-
-			//Make a note if value is NULL
-			if( !val )
-				stream << " null=\"1\"";
-		}
-
-		//Fall-through to default
-
-NV_PARAMETRIZED_LINAL_DATATYPE_LABELS
-NV_PARAMETRIZED_ARITHMETIC_DATATYPE_LABELS
-NV_PARAMETRIZED_SERVICE_DATATYPE_LABELS
-NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS
-	default:
-		stream << " type=\"" << typeToStr(paramDef->type()) << "\"";
-		break;
-	} //switch
-
-	stream << '>';
-
-	return Serializer::ERROR_NONE;
-}
-
-Serializer::ErrorType XmlSerializer::internalSerialize(physx::PxFileBuf &fbuf, const Interface **objs, uint32_t n, bool doMetadata)
-{
-	PX_UNUSED(doMetadata);
-
-	physx::PsIOStream stream(fbuf, fbuf.getFileLength());
-	stream.setBinary(false);
-
-	uint32_t minor = version() & 0xffffUL,
-		major = version() >> 16;
-
-	stream << "<!DOCTYPE NvParameters>\n"
-		<< "<NvParameters "
-		<< "numObjects=\"" << n << "\" "
-		<< "version=\"" << major << '.' << minor << "\" "
-		<< ">\n";
-
-	for(uint32_t i = 0; i < n; ++i)
-	{
-		const Interface &obj = *objs[i];
-		Handle handle(obj);
-
-		traversalState state;
-		NV_ERR_CHECK_RETURN( traverseParamDefTree(obj, stream, state, handle) );
-	}
-
-	stream << "</NvParameters>\n";
-
-	return Serializer::ERROR_NONE;
-}
-
-#endif
-
-Serializer::ErrorType XmlSerializer::internalDeserialize(
-	physx::PxFileBuf &stream,
-	Serializer::DeserializedData &res,
-	bool & /*doesNeedUpdate*/)
-{
-	XmlDeserializer *d = XmlDeserializer::Create(mTraits, XmlSerializer::version());
-	physx::shdfnd::FastXml *xmlParser = physx::shdfnd::createFastXml(d);
-	InputDataFromPxFileBuf inputData(stream);
-	if( xmlParser && !xmlParser->processXml(inputData) )
-	{
-		Serializer::ErrorType err = d->getLastError();
-		if( Serializer::ERROR_NONE == err ) //Proper error code not set?
-		{
-			DEBUG_ALWAYS_ASSERT(); //XmlDeserializer should set explicit error codes
-			err = Serializer::ERROR_UNKNOWN;
-		}
-
-		xmlParser->release();
-
-		d->releaseAll();
-		d->destroy();
-
-		return err;
-	}
-
-	if ( xmlParser )
-		xmlParser->release();
-
-	res.init(mTraits, d->getObjs(), d->getNobjs());
-
-	d->destroy();
-	
-	return Serializer::ERROR_NONE;
-}
-bool isXmlFormat(physx::PxFileBuf &stream)
-{
-	// if it is at least 32 bytes long and the first 32 byte are all ASCII, then consider it potentially valid XML
-
-	if( stream.getFileLength() < 32 )
-		return false;
-
-	char hdr[32];
-	stream.peek(hdr, sizeof(hdr));
-
-	for(size_t i = 0; i < sizeof(hdr); ++i)
-	{
-		char c = hdr[i];
-		if( !(c == '\r' || c == '\t' || c == '\n' || ( c >= 32 && c < 127)) )
-			return false;
-	}
-
-	const char *magic1 = "<!DOCTYPE NvParameters>";
-	const char *magic2 = "<!DOCTYPE NxParameters>";
-	return 0 == ::strncmp(hdr, magic1, strlen(magic1)) || 
-			0 == ::strncmp(hdr, magic2, strlen(magic2));
-}
-
-} // namespace NvParameterized
-
+// 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) 2008-2013 NVIDIA Corporation. All rights reserved.

+

+#include "PxSimpleTypes.h"

+#include "PxAssert.h"

+#include "PsArray.h"

+#include "PxVec3.h"

+#include "PxQuat.h"

+#include "PxBounds3.h"

+#include "PsFastXml.h"

+#include "PsIOStream.h"

+

+#include "nvparameterized/NvSerializer.h"

+#include "XmlSerializer.h"

+#include "nvparameterized/NvParameterized.h"

+#include "nvparameterized/NvParameterizedTraits.h"

+#include "NvParameters.h"

+

+#include "NvTraitsInternal.h"

+#include "XmlDeserializer.h"

+

+#define PRINT_ELEMENT_HINTS 0

+#define PRINT_ELEMENTS_WITHIN_EMPTY_ARRAYS 0

+

+#define UNOPTIMIZED_XML 0

+

+namespace NvParameterized

+{

+

+static const char indentStr[] = "  ";

+

+struct traversalState

+{

+	traversalState()

+	{

+		indent[0] = 0;

+		indentLen = 0;

+		level = 0;

+	}

+

+	void incLevel()

+	{

+		physx::shdfnd::strlcat(indent, (uint32_t)strlen(indent) + (uint32_t)strlen(indentStr) + 1, indentStr);

+		level++;

+	}

+

+	void decLevel()

+	{

+		level--;

+		indentLen = (sizeof(indentStr) - 1) * level;

+		if(indentLen < sizeof(indent))

+			indent[indentLen] = 0;

+	}

+

+	char indent[4096];

+	uint32_t indentLen;

+	int32_t level;

+};

+

+Serializer::ErrorType XmlSerializer::peekNumObjects(char *data, uint32_t len, uint32_t &numObjects)

+{

+	//FIXME: this code is not robust

+

+	data[len-1] = 0;

+

+	const char *root = ::strstr(data, "<NvParameters");

+	if( !root )

+	{

+		root = ::strstr(data, "<NvParameters");

+		if (!root)

+		{

+			return Serializer::ERROR_MISSING_ROOT_ELEMENT;

+		}

+	}

+

+	const char *numObjectsString = ::strstr(root, "numObjects");

+	if( !numObjectsString )

+		return Serializer::ERROR_INVALID_ATTR;

+

+	numObjectsString = ::strstr(numObjectsString, "\"");

+	if( !numObjectsString )

+		return Serializer::ERROR_INVALID_ATTR;

+

+	numObjects = strtoul(numObjectsString + 1, 0, 0); //Skip leading quote

+	return Serializer::ERROR_NONE;

+}

+

+class InputDataFromPxFileBuf: public physx::PxInputData

+{

+public:

+	InputDataFromPxFileBuf(physx::PxFileBuf& fileBuf): mFileBuf(fileBuf) {}

+

+	// physx::PxInputData interface

+	virtual uint32_t	getLength() const

+	{

+		return mFileBuf.getFileLength();

+	}

+

+	virtual void	seek(uint32_t offset)

+	{

+		mFileBuf.seekRead(offset);

+	}

+

+	virtual uint32_t	tell() const

+	{

+		return mFileBuf.tellRead();

+	}

+

+	// physx::PxInputStream interface

+	virtual uint32_t read(void* dest, uint32_t count)

+	{

+		return mFileBuf.read(dest, count);

+	}

+

+	PX_NOCOPY(InputDataFromPxFileBuf)

+private:

+	physx::PxFileBuf& mFileBuf;

+};

+

+Serializer::ErrorType XmlSerializer::peekClassNames(physx::PxFileBuf &stream, char **classNames, uint32_t &numClassNames)

+{

+	class ClassNameReader: public physx::shdfnd::FastXml::Callback

+	{

+		uint32_t mDepth;

+		uint32_t mNumObjs;

+

+		char **mClassNames;

+		uint32_t mNumClassNames;

+

+		Traits *mTraits;

+

+	public:

+		ClassNameReader(char **classNames, uint32_t &numClassNames, Traits *traits)

+			: mDepth(0), mNumObjs(0), mClassNames(classNames), mNumClassNames(numClassNames), mTraits(traits) {}

+

+		uint32_t numObjs() const { return mNumObjs; }

+

+		bool processComment(const char * /*comment*/) { return true; }

+

+		bool processClose(const char * /*element*/,uint32_t /*depth*/,bool & /*isError*/)

+		{

+			--mDepth;

+			return true;

+		}

+

+		bool processElement(

+			const char *elementName,

+			const char  * /*elementData*/,

+			const physx::shdfnd::FastXml::AttributePairs& attr,

+			int32_t /*lineno*/)

+		{

+			//Ignore top-level element

+			if( 0 == strcmp(elementName, "NvParameters") ||  0 == strcmp(elementName, "NxParameters"))

+				return true;

+

+			++mDepth;

+

+			if( 1 != mDepth || 0 != strcmp(elementName, "value") )

+				return true;

+

+			//Top-level <value> => read className

+			mClassNames[mNumObjs] = mTraits->strdup( attr.get("className") );

+			++mNumObjs;

+

+			return mNumObjs < mNumClassNames;

+		}

+

+		void *allocate(uint32_t size) { return ::malloc(size); }

+		void deallocate(void *ptr) { ::free(ptr); };

+	};

+

+	ClassNameReader myReader(classNames, numClassNames, mTraits);

+	physx::shdfnd::FastXml *xmlParser = physx::shdfnd::createFastXml(&myReader);

+

+	InputDataFromPxFileBuf inputData(stream);

+	xmlParser->processXml(inputData);

+	numClassNames = myReader.numObjs();

+

+	return Serializer::ERROR_NONE;

+}

+

+Serializer::ErrorType XmlSerializer::peekNumObjectsInplace(const void * data, uint32_t dataLen, uint32_t & numObjects)

+{

+	if ( !dataLen || ! data )

+		return ERROR_STREAM_ERROR;

+

+	char hdr[100];

+	uint32_t len = physx::PxMin<uint32_t>(dataLen, sizeof(hdr) - 1);

+	physx::shdfnd::strlcpy(hdr, len+1, (const char *)data);

+

+	return peekNumObjects(hdr, len, numObjects);

+}

+

+Serializer::ErrorType XmlSerializer::peekNumObjects(physx::PxFileBuf &stream, uint32_t &numObjects)

+{

+	//FIXME: this code is not robust

+

+	char hdr[100];

+	uint32_t len = stream.peek(hdr, sizeof(hdr));

+

+	return peekNumObjects(hdr, len, numObjects);

+}

+

+#ifndef WITHOUT_APEX_SERIALIZATION

+

+static void storeVersionAndChecksum(physx::PsIOStream &stream, const Interface *obj)

+{

+	uint16_t major = obj->getMajorVersion(),

+		minor = obj->getMinorVersion(); 

+

+	stream << " version=\"" << major << '.' << minor << '"';

+

+	uint32_t bits;

+	const uint32_t *checksum = obj->checksum(bits);

+

+	uint32_t u32s = bits / 32;

+	PX_ASSERT( 0 == bits % 32 );

+

+	stream << " checksum=\"";

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

+	{

+		char hex[20];

+		physx::shdfnd::snprintf(hex, sizeof(hex), "0x%x", checksum[i]);

+		stream << hex;

+		if( u32s - 1 != i )

+			stream << ' ';

+	}

+	stream << '"';

+}

+

+static bool IsSimpleType(const Definition *d)

+{

+	//We do not consider strings simple because it causes errors with NULL and ""

+	if (d->type() == TYPE_ARRAY  || d->type() == TYPE_STRUCT ||

+		d->type() == TYPE_REF || d->type() == TYPE_STRING ||

+		d->type() == TYPE_ENUM)

+	{

+		return false;

+	}

+	else

+	{

+		PX_ASSERT( d->numChildren() == 0 );

+		return true;

+	}

+}

+

+static bool IsSimpleStruct(const Definition *pd)

+{

+	bool ret = true;

+

+	int32_t count = pd->numChildren();

+	for (int32_t i=0; i < count; i++)

+	{

+		const Definition *d = pd->child(i);

+		if ( !IsSimpleType(d) )

+		{

+			ret = false;

+			break;

+		}

+	}

+

+	return ret;

+}

+

+static bool DoesNeedQuote(const char *c)

+{

+	bool ret = false;

+	while ( *c )

+	{

+		if ( *c == 32 || *c == ',' || *c == '<' || *c == '>' || *c == 9 )

+		{

+			ret = true;

+			break;

+		}

+		c++;

+	}

+

+	return ret;

+}

+	

+Serializer::ErrorType XmlSerializer::traverseParamDefTree(

+	const Interface &obj,

+	physx::PsIOStream &stream,

+	traversalState &state,

+	Handle &handle,

+	bool printValues)

+{

+	bool isRoot = !handle.numIndexes() && 0 == state.level;

+

+	if( !handle.numIndexes() )

+	{

+		NV_PARAM_ERR_CHECK_RETURN( obj.getParameterHandle("", handle), Serializer::ERROR_UNKNOWN );

+

+		if( isRoot )

+		{

+			NV_ERR_CHECK_RETURN( emitElement(obj, stream, "value", handle, false, true, true) );

+			stream << "\n";

+

+			state.incLevel();

+		}

+	}

+

+	const Definition *paramDef = handle.parameterDefinition();

+

+	if( !paramDef->hint("DONOTSERIALIZE") )

+	{

+

+#	if PRINT_ELEMENT_HINTS

+	bool includedRef = false;

+

+	NV_ERR_CHECK_RETURN( emitElementNxHints(stream, handle, state, includedRef) );

+#	else

+	bool includedRef = paramDef->isIncludedRef();

+#	endif

+

+	switch( paramDef->type() )

+	{

+	case TYPE_STRUCT:

+		{

+			stream << state.indent;

+			NV_ERR_CHECK_RETURN( emitElement(obj, stream, "struct", handle, false, true) );

+			stream << "\n";

+

+			state.incLevel();

+			for(int32_t i = 0; i < paramDef->numChildren(); ++i)

+			{

+				handle.set(i);

+				NV_ERR_CHECK_RETURN( traverseParamDefTree(obj, stream, state, handle, printValues) );

+				handle.popIndex();

+			}

+

+			state.decLevel();

+

+			stream << state.indent << "</struct>\n";

+

+			break;

+		}

+

+	case TYPE_ARRAY:

+		{

+			stream << state.indent;

+			NV_ERR_CHECK_RETURN( emitElement(obj, stream, "array", handle, false, true) );

+

+			int32_t arraySize;

+			NV_PARAM_ERR_CHECK_RETURN( handle.getArraySize(arraySize), Serializer::ERROR_INVALID_ARRAY );

+

+			if( arraySize)

+				stream << "\n";

+

+			state.incLevel();

+

+			if ( arraySize > 0 )

+			{

+#if UNOPTIMIZED_XML

+				for(int32_t i = 0; i < arraySize; ++i)

+				{

+					handle.set(i);

+					NV_ERR_CHECK_RETURN( traverseParamDefTree(obj, stream, state, handle, printValues) );

+					handle.popIndex();

+				}

+#else

+				handle.set(0);

+				const Definition *pd = handle.parameterDefinition();

+				handle.popIndex();

+				switch ( pd->type() )

+				{

+					case TYPE_STRUCT:

+						{

+							if ( IsSimpleStruct(pd) )

+							{

+								for(int32_t i = 0; i < arraySize; ++i)

+								{

+

+									if ( (i&3) == 0 )

+									{

+										if ( i )

+											stream << "\n";

+										stream << state.indent;

+									}

+

+									handle.set(i);

+

+									for( int32_t j=0; j<pd->numChildren(); j++ )

+									{

+										if (pd->child(j)->hint("DONOTSERIALIZE"))

+											continue;

+

+										handle.set(j);

+

+										char buf[512];

+										const char *str = 0;

+										NV_PARAM_ERR_CHECK_RETURN( handle.valueToStr(buf, sizeof(buf), str), Serializer::ERROR_VAL2STRING_FAILED );

+

+										stream << str;

+

+										if ( (j+1) < pd->numChildren() )

+										{

+											stream << " ";

+										}

+

+										handle.popIndex();

+									}

+

+									if ( (i+1) < arraySize )

+									{

+										stream << ",";

+									}

+

+									handle.popIndex();

+								} //i

+								stream << "\n";

+							}

+							else

+							{

+								for(int32_t i = 0; i < arraySize; ++i)

+								{

+									handle.set(i);

+									NV_ERR_CHECK_RETURN( traverseParamDefTree(obj, stream, state, handle, printValues) );

+									handle.popIndex();

+								}

+							}

+						}

+						break;

+

+					case TYPE_REF:

+						for(int32_t i = 0; i < arraySize; ++i)

+						{

+							handle.set(i);

+							NV_ERR_CHECK_RETURN( traverseParamDefTree(obj, stream, state, handle, printValues) );

+							handle.popIndex();

+						}

+						break;

+

+					case TYPE_BOOL:

+						{

+							bool v = false;

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamBoolArray(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								stream << (uint32_t)v;

+								if ( (i+1) < arraySize )

+								{

+									stream << " ";

+								}

+								if ( ((i+1)&63) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+						break;

+

+    				case TYPE_I8:

+						{

+							int8_t v = 0;

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamI8Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								stream << v;

+								if ( (i+1) < arraySize )

+								{

+									stream << " ";

+								}

+								if ( ((i+1)&63) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+    					break;

+

+    				case TYPE_I16:

+						{

+							int16_t v = 0;

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamI16Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								stream << v;

+								if ( (i+1) < arraySize )

+								{

+									stream << " ";

+								}

+								if ( ((i+1)&31) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+    					break;

+

+    				case TYPE_I32:

+						{

+							int32_t v = 0;

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamI32Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								stream << v;

+								if ( (i+1) < arraySize )

+								{

+									stream << " ";

+								}

+								if ( ((i+1)&31) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+    					break;

+

+    				case TYPE_I64:

+						{

+							int64_t v = 0;

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamI64Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								stream << v;

+								if ( (i+1) < arraySize )

+								{

+									stream << " ";

+								}

+								if ( ((i+1)&31) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+    					break;

+

+    				case TYPE_U8:

+						{

+							uint8_t v = 0;

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamU8Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								stream << v;

+								if ( (i+1) < arraySize )

+								{

+									stream << " ";

+								}

+								if ( ((i+1)&63) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+    					break;

+

+    				case TYPE_U16:

+						{

+							uint16_t v = 0;

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamU16Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								stream << v;

+								if ( (i+1) < arraySize )

+								{

+									stream << " ";

+								}

+								if ( ((i+1)&63) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+    					break;

+

+    				case TYPE_U32:

+						{

+							uint32_t v = 0;

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamU32Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								stream << v;

+								if ( (i+1) < arraySize )

+								{

+									stream << " ";

+								}

+								if ( ((i+1)&31) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+    					break;

+

+    				case TYPE_U64:

+						{

+							uint64_t v = 0;

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamU64Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								stream << v;

+								if ( (i+1) < arraySize )

+								{

+									stream << " ";

+								}

+								if ( ((i+1)&31) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+    					break;

+

+    				case TYPE_F32:

+						{

+							float v = 0;

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamF32Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								stream << v;

+								if ( (i+1) < arraySize )

+								{

+									stream << " ";

+								}

+								if ( ((i+1)&31) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+    					break;

+

+    				case TYPE_F64:

+						{

+							double v = 0;

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamF64Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								stream << v;

+								if ( (i+1) < arraySize )

+								{

+									stream << " ";

+								}

+								if ( ((i+1)&31) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+    					break;

+

+					case TYPE_VEC2:

+						{

+							physx::PxVec2 v(0,0);

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamVec2Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								stream << v.x << " " << v.y;

+								if ( (i+1) < arraySize )

+								{

+									stream << ", ";

+								}

+								if ( ((i+1)&15) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+						break;

+

+					case TYPE_VEC3:

+						{

+							physx::PxVec3 v(0,0,0);

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamVec3Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								stream << v.x << " " << v.y << " " << v.z;

+								if ( (i+1) < arraySize )

+								{

+									stream << ", ";

+								}

+								if ( ((i+1)&15) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+						break;

+

+					case TYPE_VEC4:

+						{

+							physx::PxVec4 v(0,0,0,0);

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamVec4Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								stream << v.x << " " << v.y << " " << v.z << " " << v.w;

+								if ( (i+1) < arraySize )

+								{

+									stream << ", ";

+								}

+								if ( ((i+1)&15) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+						break;

+

+					case TYPE_QUAT:

+						{

+							physx::PxQuat v(0,0,0,1);

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamQuatArray(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								stream << v.x << " " << v.y << " " << v.z << " " << v.w;

+								if ( (i+1) < arraySize )

+								{

+									stream << ", ";

+								}

+								if ( ((i+1)&15) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+						break;

+

+					case TYPE_MAT33:

+						{

+							physx::PxMat33 m = physx::PxMat33(physx::PxIdentity);

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamMat33Array(&m,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								const float *f = (const float *)m.front();

+								stream << f[0] << " " << f[1] << " " << f[2] << " " ;

+								stream << f[3] << " " << f[4] << " " << f[5] << " ";

+								stream << f[6] << " " << f[7] << " " << f[8];

+								if ( (i+1) < arraySize )

+								{

+									stream << ", ";

+								}

+								if ( ((i+1)&15) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+						break;

+

+					case TYPE_BOUNDS3:

+						{

+							physx::PxBounds3 v;

+							v.minimum = physx::PxVec3(0.0f);

+							v.maximum = physx::PxVec3(0.0f);

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamBounds3Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								stream << v.minimum.x << " " << v.minimum.y << " " << v.minimum.z << " " << v.maximum.x << " " << v.maximum.y << " " << v.maximum.z;

+								if ( (i+1) < arraySize )

+								{

+									stream << ", ";

+								}

+								if ( ((i+1)&15) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+						break;

+

+					case TYPE_MAT44:

+						{

+							physx::PxMat44 v = physx::PxMat44(physx::PxIdentity);

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamMat44Array(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								const float *f = (const float *)v.front();

+								stream << f[0] << " " << f[1] << " " << f[2] << " " << f[3] << " ";

+								stream << f[4] << " " << f[5] << " " << f[6] << " " << f[7] << " ";

+								stream << f[8] << " " << f[9] << " " << f[10] << " " << f[11] << " ";

+								stream << f[12] << " " << f[13] << " " << f[14] << " " << f[15];

+								if ( (i+1) < arraySize )

+								{

+									stream << ", ";

+								}

+								if ( ((i+1)&15) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+						break;

+

+					case TYPE_TRANSFORM:

+						{

+							physx::PxTransform v = physx::PxTransform(physx::PxIdentity);

+							stream << state.indent;

+							for (int32_t i=0; i<arraySize; i++)

+							{

+								NV_PARAM_ERR_CHECK_RETURN( handle.getParamTransformArray(&v,1,i), Serializer::ERROR_ARRAY_INDEX_OUT_OF_RANGE );

+								const float *f = (const float *)&v;

+								stream << f[0] << " " << f[1] << " " << f[2] << " " << f[3] << " ";

+								stream << f[4] << " " << f[5] << " " << f[6] << " ";

+								if ( (i+1) < arraySize )

+								{

+									stream << ", ";

+								}

+								if ( ((i+1)&15) == 0 )

+								{

+									stream << "\n";

+									stream << state.indent;

+								}

+							}

+							stream << "\n";

+						}

+						break;

+

+					NV_PARAMETRIZED_STRING_DATATYPE_LABELS

+					NV_PARAMETRIZED_ENUM_DATATYPE_LABELS

+					NV_PARAMETRIZED_SERVICE_DATATYPE_LABELS 

+					NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS

+					NV_PARAMETRIZED_LEGACY_DATATYPE_LABELS

+					case NvParameterized::TYPE_ARRAY:

+					default:

+						for(int32_t i = 0; i < arraySize; ++i)

+						{

+							handle.set(i);

+							NV_ERR_CHECK_RETURN( traverseParamDefTree(obj, stream, state, handle, printValues) );

+							handle.popIndex();

+						}

+						break;

+				}

+#endif

+			}

+

+#	if PRINT_ELEMENTS_WITHIN_EMPTY_ARRAYS

+			if( arraySize == 0 )

+			{

+				handle.set(0);

+				NV_ERR_CHECK_RETURN( traverseParamDefTree(obj, stream, state, handle, false) );

+				handle.popIndex();

+			}

+#	endif

+

+			state.decLevel();

+			if( arraySize)

+				stream << state.indent;

+

+			stream << "</array>\n";

+

+			break;

+		}

+

+	case TYPE_REF:

+		{

+			stream << state.indent;

+			NV_ERR_CHECK_RETURN( emitElement(obj, stream, "value", handle, includedRef, printValues) );

+

+			if( printValues && includedRef )

+			{

+				stream << state.indent << "\n";

+

+				Interface *refObj = 0;

+				NV_PARAM_ERR_CHECK_RETURN( handle.getParamRef(refObj), Serializer::ERROR_UNKNOWN );

+

+				if( refObj )

+				{

+					Handle refHandle(refObj);

+					state.incLevel();

+					NV_ERR_CHECK_RETURN( traverseParamDefTree(*refObj, stream, state, refHandle) );

+					state.decLevel();

+					stream << state.indent;

+				}

+			}

+

+			stream << "</value>\n";

+

+			break;

+		}

+

+	case TYPE_POINTER:

+		//Don't do anything with pointer

+		break;

+

+NV_PARAMETRIZED_LINAL_DATATYPE_LABELS

+NV_PARAMETRIZED_ARITHMETIC_DATATYPE_LABELS

+NV_PARAMETRIZED_STRING_DATATYPE_LABELS

+NV_PARAMETRIZED_ENUM_DATATYPE_LABELS

+NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS

+	default:

+		{

+			stream << state.indent;

+			NV_ERR_CHECK_RETURN( emitElement(obj, stream, "value", handle, includedRef, printValues) );

+

+			char buf[512];

+			const char *str = 0;

+			if(	printValues )

+				NV_PARAM_ERR_CHECK_RETURN( handle.valueToStr(buf, sizeof(buf), str), Serializer::ERROR_VAL2STRING_FAILED );

+

+			if( str )

+				stream << str;

+

+			stream << "</value>\n";

+

+			break;

+		} //default

+	} //switch

+

+	} //DONOTSERIALIZE

+

+	if( isRoot )

+	{

+		state.decLevel();

+		stream << "</value>\n";

+	}

+

+	return Serializer::ERROR_NONE;

+}

+

+Serializer::ErrorType XmlSerializer::emitElementNxHints(

+	physx::PsIOStream &stream,

+	Handle &handle,

+	traversalState &state,

+	bool &includedRef)

+{

+	const Definition *paramDef = handle.parameterDefinition();

+

+	for(int32_t j = 0; j < paramDef->numHints(); ++j)

+	{

+		if( 0 == j )

+			stream << "\n";

+

+		const Hint *hint = paramDef->hint(j);

+

+		stream << state.indent << "<!-- " << hint->name() << ": ";

+

+		if( hint->type() == TYPE_STRING )

+			stream << hint->asString() ;

+		else if( hint->type() == TYPE_U64 )

+			stream << hint->asUInt() ;

+		else if( hint->type() == TYPE_F64 )

+			stream << hint->asFloat() ;

+

+		stream << " -->\n";

+	}

+

+	includedRef = paramDef->isIncludedRef();

+

+	return Serializer::ERROR_NONE;

+}

+

+Serializer::ErrorType XmlSerializer::emitElement(

+	const Interface &obj,

+	physx::PsIOStream &stream,

+	const char *elementName,

+	Handle &handle,

+	bool includedRef,

+	bool printValues,

+	bool isRoot)

+{

+	const Definition *paramDef = handle.parameterDefinition();

+

+	DataType parentType = TYPE_UNDEFINED;

+

+	if( paramDef->parent() )

+		parentType = paramDef->parent()->type();

+

+	stream << '<' << elementName;

+

+	if( isRoot )

+	{

+		stream << " name=\"\""

+			<< " type=\"Ref\""

+			<< " className=\"" << obj.className() << "\"";

+

+		const char *objectName = obj.name();

+		if( objectName )

+			stream << " objectName=\"" << objectName << "\"";

+

+		if( isRoot ) //We only emit version info for root <struct>

+			storeVersionAndChecksum(stream, &obj);

+	}

+	else

+	{

+		if( parentType != TYPE_ARRAY )

+		{

+			const char *name = paramDef->name();

+			stream << " name=\"" << (name ? name : "") << "\"";

+		}

+	}

+

+	switch( paramDef->type() )

+	{

+	case TYPE_STRUCT:

+		break;

+

+	case TYPE_ARRAY:

+		{

+			int32_t arraySize;

+			NV_PARAM_ERR_CHECK_RETURN( handle.getArraySize(arraySize), Serializer::ERROR_INVALID_ARRAY );

+			stream << " size=\"" << arraySize << '"';

+			handle.set(0);

+			const Definition *pd = handle.parameterDefinition();

+			handle.popIndex();

+			stream << " type=\"" << typeToStr(pd->type()) << '"';

+			// ** handle use case for simple structs written out flat..

+#if !UNOPTIMIZED_XML

+			if ( pd->type() == TYPE_STRUCT && IsSimpleStruct(pd) )

+			{

+				stream << " structElements=\"";

+				const int32_t count = pd->numChildren();

+

+				// find how many of them need serialization

+				int32_t serializeCount = 0;

+				for (int32_t i=0; i<count; i++)

+				{

+					const Definition *d = pd->child(i);

+					if (d->hint("DONOTSERIALIZE") == NULL)

+					{

+						serializeCount++;

+					}

+				}

+

+				for (int32_t i=0; i<count; i++)

+				{

+					const Definition *d = pd->child(i);

+					if (d->hint("DONOTSERIALIZE"))

+						continue;

+

+					stream << d->name();

+					stream << "(";

+					stream << typeToStr(d->type());

+					stream << ")";

+					if ( (i+1) < serializeCount )

+					{

+						stream<<",";

+					}

+				}

+				stream << "\"";

+			}

+#endif

+			//

+			break;

+		}

+

+	case TYPE_REF:

+		{

+			stream << " type=\"" << typeToStr(paramDef->type()) << '"';

+

+			Interface *paramPtr = 0;

+			if( printValues )

+				NV_PARAM_ERR_CHECK_RETURN( handle.getParamRef(paramPtr), Serializer::ERROR_UNKNOWN );

+

+			stream << " included=\"" << ( includedRef ? "1" : "0" ) << "\"";

+

+			if( !printValues || !paramPtr )

+			{

+				stream << " classNames=\"";

+				for(int32_t i = 0; i < paramDef->numRefVariants(); ++i)

+				{

+					const char *ref = paramDef->refVariantVal(i);

+					if ( DoesNeedQuote(ref) )

+						stream << "%20" << ref << "%20" << " ";

+					else

+						stream << ref << " ";

+				}

+				stream << '"';

+

+				break;

+			}

+

+			stream << " className=\"" << paramPtr->className() << '"';

+

+			const char *objectName = paramPtr->name();

+			if( objectName )

+				stream << " objectName=\"" << objectName << "\"";

+

+			if( includedRef )

+				storeVersionAndChecksum(stream, paramPtr);

+

+			break;

+		}

+

+	case TYPE_STRING:

+	case TYPE_ENUM:

+		{

+			const char *val;

+			NV_PARAM_ERR_CHECK_RETURN( handle.getParamString(val), Serializer::ERROR_UNKNOWN );

+

+			//Make a note if value is NULL

+			if( !val )

+				stream << " null=\"1\"";

+		}

+

+		//Fall-through to default

+

+NV_PARAMETRIZED_LINAL_DATATYPE_LABELS

+NV_PARAMETRIZED_ARITHMETIC_DATATYPE_LABELS

+NV_PARAMETRIZED_SERVICE_DATATYPE_LABELS

+NV_PARAMETRIZED_UNDEFINED_AND_LAST_DATATYPE_LABELS

+	default:

+		stream << " type=\"" << typeToStr(paramDef->type()) << "\"";

+		break;

+	} //switch

+

+	stream << '>';

+

+	return Serializer::ERROR_NONE;

+}

+

+Serializer::ErrorType XmlSerializer::internalSerialize(physx::PxFileBuf &fbuf, const Interface **objs, uint32_t n, bool doMetadata)

+{

+	PX_UNUSED(doMetadata);

+

+	physx::PsIOStream stream(fbuf, fbuf.getFileLength());

+	stream.setBinary(false);

+

+	uint32_t minor = version() & 0xffffUL,

+		major = version() >> 16;

+

+	stream << "<!DOCTYPE NvParameters>\n"

+		<< "<NvParameters "

+		<< "numObjects=\"" << n << "\" "

+		<< "version=\"" << major << '.' << minor << "\" "

+		<< ">\n";

+

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

+	{

+		const Interface &obj = *objs[i];

+		Handle handle(obj);

+

+		traversalState state;

+		NV_ERR_CHECK_RETURN( traverseParamDefTree(obj, stream, state, handle) );

+	}

+

+	stream << "</NvParameters>\n";

+

+	return Serializer::ERROR_NONE;

+}

+

+#endif

+

+Serializer::ErrorType XmlSerializer::internalDeserialize(

+	physx::PxFileBuf &stream,

+	Serializer::DeserializedData &res,

+	bool & /*doesNeedUpdate*/)

+{

+	XmlDeserializer *d = XmlDeserializer::Create(mTraits, XmlSerializer::version());

+	physx::shdfnd::FastXml *xmlParser = physx::shdfnd::createFastXml(d);

+	InputDataFromPxFileBuf inputData(stream);

+	if( xmlParser && !xmlParser->processXml(inputData) )

+	{

+		Serializer::ErrorType err = d->getLastError();

+		if( Serializer::ERROR_NONE == err ) //Proper error code not set?

+		{

+			DEBUG_ALWAYS_ASSERT(); //XmlDeserializer should set explicit error codes

+			err = Serializer::ERROR_UNKNOWN;

+		}

+

+		xmlParser->release();

+

+		d->releaseAll();

+		d->destroy();

+

+		return err;

+	}

+

+	if ( xmlParser )

+		xmlParser->release();

+

+	res.init(mTraits, d->getObjs(), d->getNobjs());

+

+	d->destroy();

+	

+	return Serializer::ERROR_NONE;

+}

+bool isXmlFormat(physx::PxFileBuf &stream)

+{

+	// if it is at least 32 bytes long and the first 32 byte are all ASCII, then consider it potentially valid XML

+

+	if( stream.getFileLength() < 32 )

+		return false;

+

+	char hdr[32];

+	stream.peek(hdr, sizeof(hdr));

+

+	for(size_t i = 0; i < sizeof(hdr); ++i)

+	{

+		char c = hdr[i];

+		if( !(c == '\r' || c == '\t' || c == '\n' || ( c >= 32 && c < 127)) )

+			return false;

+	}

+

+	const char *magic1 = "<!DOCTYPE NvParameters>";

+	const char *magic2 = "<!DOCTYPE NxParameters>";

+	return 0 == ::strncmp(hdr, magic1, strlen(magic1)) || 

+			0 == ::strncmp(hdr, magic2, strlen(magic2));

+}

+

+} // namespace NvParameterized

+