Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 809 insertions, 0 deletions

diff --git a/APEX_1.4/shared/internal/include/ApexSharedSerialization.h b/APEX_1.4/shared/internal/include/ApexSharedSerialization.h
new file mode 100644
index 00000000..20e8c1d4
--- /dev/null
+++ b/APEX_1.4/shared/internal/include/ApexSharedSerialization.h
@@ -0,0 +1,809 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, related documentation
+ * and any modifications thereto.  Any use, reproduction, disclosure or
+ * distribution of this software and related documentation without an express
+ * license agreement from NVIDIA CORPORATION is strictly prohibited.
+ */
+
+
+#ifndef __APEXSHAREDSERIALIZATION_H__
+#define __APEXSHAREDSERIALIZATION_H__
+
+#include "Apex.h"
+#include "ApexStream.h"
+#include "ApexString.h"
+#include "ApexSharedUtils.h"
+#include "ApexSDKIntl.h"
+#include "nvparameterized/NvParameterized.h"
+
+namespace nvidia
+{
+namespace apex
+{
+
+struct ApexStreamVersion
+{
+	enum Enum
+	{
+		First = 0,
+		ConsolidatedSubmeshes = 1,
+		TriangleFlags = 2,
+		ConvexHull_VolumeStreamed = 3,
+		AddedDestrucibleDeformation = 4,
+		RemovedParticleSizeFromDestructibleParameters = 5,
+		TriangleFlagsChangedToExtraDataIndex = 6,
+		ConvexHull_EdgesStreamed = 7,
+		AddedDestrucibleDebrisParamaters = 8,
+		DestrucibleDebrisParamatersHaveLODRange = 9,
+		UniversalNamedAssetHeader = 10,
+		ClothMeshBindPoses = 10, // PH: This is not a mistake, this enum was added in another branch while other enums were added in //trunk
+		VariableVertexData = 11,
+		SoftBodyNormalsStreamed = 11, // PH: This is not a mistake, this enum was added in another branch while other enums were added in //trunk
+		UsingApexMaterialLibrary_and_NoFlagsInRenderTriangle = 12,
+		AddingTextureTypeInformationToVertexFormat = 13,
+		SoftBodyNormalsInTetraLink = 14,
+		ClothingVertexFlagsStreamed = 15,
+		ConvexHullModifiedForEfficientCollisionTests = 16,
+		RenderMeshAssetRedesign = 17,
+		FixedSerializationAfterRenderMeshAssetRedesign = 18,
+		AddedRenderCullModeToRenderMeshAsset = 19,
+		AddedTextureUVOriginField = 19,	// BRG: merge conflict
+		AddedDynamicVertexBufferField = 20,
+		RenderMeshAssetBufferOverrunFix = 21,
+		CleanupOfApexRenderMesh = 22,
+		RemovedTextureTypeInformationFromVertexFormat = 23,
+		AddedDestructibleFlag_FormExtendedStructures = 24,
+		MarkingDestructibleChunksWithFlagToDenoteUnfracturableDescendant = 25,
+		AddedValidBoundsToDestructibleParameters = 26,
+		ReducingAssetUponDeserializationForReducedLOD = 27,
+		AddedDustMeshParticleFactoryNameToDestructibleAsset = 28,
+		AddedChunkSurfaceTracesToDestructibleAsset = 29,
+		AddedInteriorSubmeshIndexToDestructibleAsset = 30,
+		AddedMaxChunkSpeedAndMassScaleExponentToDestructibleAsset = 31,
+		AddedGrbVolumeLimit = 32,
+		Removing_rollSign_and_rollAxis_fromAPI = 33,
+		AddedFractureImpulseScale = 34,
+		AddedMissingRuntimeFlagsAndAlsoTraceSetAverageNormalToDestructibleAssetStream = 35,
+		CachingChunkOverlapDataInDestructibleAsset = 36,
+		AddedRotationCaps = 37,
+		AddedImpactVelocityThreshold = 37, // SJB: Trust me, this should be 37
+		ChangedVertexColorFormatToReal = 38,
+		AddedEssentialDepthParameter = 39,
+		AddedSeparateBoneBufferFlagToRenderMeshAsset = 40,
+		DoNotNormalizeBoneWeightsOnLoad = 41, // PH: This is a change for deserialization only, we don't need to do additional processing when newer than this
+		MovedChunkSurfaceNormalFromTraceSetToChunk = 41,
+		FlattenedVertexBuffer = 42,
+		RemovedSubmeshTriangleStruct = 43,
+		DestructibleAssetRearrangementForParameterization = 44,
+		AddedDestructibleMaterialStrength = 45,
+		ExposedChunkNeighborPadding = 46,
+		ChangedVertexFormat = 47,
+		UnifiedCustomAndStandardSemantics = 48,
+		AddedAdjacentPlanesToConvexHullStream = 49,
+		//	Always add a new version just before this line
+
+		Count,
+		Current = Count - 1
+	};
+};
+
+/*****************************************************************************/
+//	Non-versioned data (e.g. basic types) may use the << and >> operators
+//	defined in ApexStream.h.  This file contains (de)serialization for
+//	versioned data.
+//
+//	Serialization version is written "upstream" by a versioned parent object.
+//	To add the version number to the streamed data for an object, record this
+//	change in the ApexStreamVersion enum, and add the line:
+//		stream << (uint32_t)ApexStreamVersion_Current;
+//	to the serialize function.
+//
+//  Serialization signature:
+//		void serialize( physx::PxFileBuf& stream, const typename& object )
+//
+//	Deserialization signature:
+//		void deserialize( physx::PxFileBuf& stream, uint32_t version, typename& object )
+/*****************************************************************************/
+
+
+// Template foo
+PX_INLINE void serialize(physx::PxFileBuf& stream, const ExplicitRenderTriangle& t);
+PX_INLINE void deserialize(physx::PxFileBuf& stream, uint32_t version, ExplicitRenderTriangle& t);
+PX_INLINE void serialize(physx::PxFileBuf& stream, const VertexUV& uv);
+PX_INLINE void deserialize(physx::PxFileBuf& stream, uint32_t version, VertexUV& uv);
+PX_INLINE void serialize(physx::PxFileBuf& stream, const Vertex& v);
+PX_INLINE void deserialize(physx::PxFileBuf& stream, uint32_t version, Vertex& v);
+PX_INLINE void serialize(physx::PxFileBuf& stream, const ApexSimpleString& s);
+PX_INLINE void deserialize(physx::PxFileBuf& stream, uint32_t version, ApexSimpleString& s);
+PX_INLINE void serialize(physx::PxFileBuf& stream,
+                         uint32_t headerVersion,
+                         const NvParameterized::Interface* param,
+                         NvParameterized::Handle& childHandle);
+PX_INLINE void serialize(physx::PxFileBuf& stream,
+                         uint32_t headerVersion,
+                         const NvParameterized::Interface* param,
+                         const char* memberName,
+                         NvParameterized::Handle* structHandle = NULL);
+PX_INLINE void deserialize(physx::PxFileBuf& stream,
+                           uint32_t headerVersion,
+                           NvParameterized::Interface* param,
+                           NvParameterized::Handle& childHandle);
+PX_INLINE void deserialize(physx::PxFileBuf& stream,
+                           uint32_t headerVersion,
+                           NvParameterized::Interface* param,
+                           const char* memberName,
+                           NvParameterized::Handle* structHandle = NULL);
+
+// Utility to write an APEX asset stream header
+PX_INLINE void serializeCurrentApexStreamVersion(physx::PxFileBuf& stream, const ApexSimpleString& assetTypeName, uint32_t assetVersion)
+{
+	stream << (uint32_t)ApexStreamVersion::Current;
+	serialize(stream, assetTypeName);
+	stream << assetVersion;
+}
+
+// Utility to read version header from the start of an APEX asset stream
+PX_INLINE ApexStreamVersion::Enum deserializeApexStreamVersion(physx::PxFileBuf& stream, const ApexSimpleString& assetTypeName, uint32_t& assetVersion)
+{
+	uint32_t headerVersion;
+	stream >> headerVersion;
+	if (headerVersion > ApexStreamVersion::Current)
+	{
+		APEX_INTERNAL_ERROR("Stream version (%d) is newer than this library (%d)", headerVersion, ApexStreamVersion::Current);
+		PX_ALWAYS_ASSERT();
+	}
+	else if (headerVersion >= ApexStreamVersion::UniversalNamedAssetHeader)
+	{
+		ApexSimpleString streamedName;
+		deserialize(stream, headerVersion, streamedName);
+		if (streamedName == assetTypeName)
+		{
+			stream >> assetVersion;
+		}
+		else
+		{
+			APEX_INTERNAL_ERROR("Asset type name mismatch.  File <%s> != asset name <%s>",
+			                    assetTypeName.c_str(), streamedName.c_str());
+			PX_ALWAYS_ASSERT();
+		}
+	}
+	return (ApexStreamVersion::Enum)headerVersion;
+}
+
+// Utility to read version header from the start of an APEX asset stream, when the type is unknown
+PX_INLINE ApexStreamVersion::Enum deserializeGenericApexStreamVersion(physx::PxFileBuf& stream, ApexSimpleString& outAssetTypeName, uint32_t& outAssetVersion)
+{
+	uint32_t headerVersion;
+	stream >> headerVersion;
+
+	if (headerVersion > ApexStreamVersion::Current)
+	{
+		APEX_INTERNAL_ERROR("Stream version (%d) is newer than this library (%d)", headerVersion, ApexStreamVersion::Current);
+		PX_ALWAYS_ASSERT();
+	}
+	else if (headerVersion >= ApexStreamVersion::UniversalNamedAssetHeader)
+	{
+		ApexSimpleString streamedName;
+		deserialize(stream, headerVersion, outAssetTypeName);
+		stream >> outAssetVersion;
+	}
+	else
+	{
+		APEX_INTERNAL_ERROR("Stream version (%d) does not contain a universal named asset header, " \
+		                    "use a specific asset creation method to load this asset", headerVersion);
+		PX_ALWAYS_ASSERT();
+	}
+	return (ApexStreamVersion::Enum)headerVersion;
+}
+
+// Versioned wrappers for non-versioned data
+template <class T> PX_INLINE void serialize(physx::PxFileBuf& stream, const T& t)
+{
+	stream << t;
+}
+
+template <class T> PX_INLINE void deserialize(physx::PxFileBuf& stream, uint32_t version, T& t)
+{
+	PX_UNUSED(version);
+	stream >> t;
+}
+
+
+// physx::Array<T>
+template <class T> PX_INLINE void serialize(physx::PxFileBuf& stream, const physx::Array<T>& array)
+{
+	const uint32_t size = array.size();
+	stream << size;
+	for (uint32_t i = 0; i < size; ++i)
+	{
+		serialize(stream, array[i]);
+	}
+}
+
+template <class T> PX_INLINE void deserialize(physx::PxFileBuf& stream, uint32_t version, physx::Array<T>& array)
+{
+	uint32_t size;
+	stream >> size;
+	array.resize(size);
+	for (uint32_t i = 0; i < size; ++i)
+	{
+		deserialize(stream, version, array[i]);
+	}
+}
+
+// Several serialized objects have multiple associated versions
+template <class T> PX_INLINE void deserialize(physx::PxFileBuf& stream, uint32_t version0, uint32_t version1, physx::Array<T>& array)
+{
+	uint32_t size;
+	stream >> size;
+	array.resize(size);
+	for (uint32_t i = 0; i < size; ++i)
+	{
+		deserialize(stream, version0, version1, array[i]);
+	}
+}
+
+// VertexUV
+PX_INLINE void serialize(physx::PxFileBuf& stream, const VertexUV& uv)
+{
+	stream << uv.u << uv.v;
+}
+
+PX_INLINE void deserialize(physx::PxFileBuf& stream, uint32_t version, VertexUV& uv)
+{
+	// original version
+	PX_UNUSED(version);
+	stream >> uv.u >> uv.v;
+}
+
+
+// VertexColor
+PX_INLINE void serialize(physx::PxFileBuf& stream, const VertexColor& c)
+{
+	stream << c.r << c.g << c.b << c.a;
+}
+
+PX_INLINE void deserialize(physx::PxFileBuf& stream, uint32_t version, VertexColor& c)
+{
+	// original version
+	PX_UNUSED(version);
+	stream >> c.r >> c.g >> c.b >> c.a;
+}
+
+
+// Vertex
+PX_INLINE void serialize(physx::PxFileBuf& stream, const Vertex& v)
+{
+	//
+	stream << v.position << v.normal << v.tangent << v.binormal;
+	serialize(stream, v.uv[0]);
+	serialize(stream, v.uv[1]);
+	serialize(stream, v.uv[2]);
+	serialize(stream, v.uv[3]);
+	serialize(stream, v.color);
+	for (uint32_t i = 0; i < 4; i++)
+	{
+		stream << v.boneIndices[i];
+		stream << v.boneWeights[i];
+	}
+}
+
+PX_INLINE void deserialize(physx::PxFileBuf& stream, uint32_t version, Vertex& v)
+{
+	if (version < ApexStreamVersion::RenderMeshAssetRedesign)
+	{
+		// set all other indices and weights to 0
+		v.boneWeights[0] = 1.0f;
+		for (uint32_t i = 1; i < 4; i++)
+		{
+			v.boneIndices[i] = 0;
+			v.boneWeights[i] = 0.0f;
+		}
+	}
+
+	if (version >= ApexStreamVersion::VariableVertexData)
+	{
+		stream >> v.position >> v.normal >> v.tangent >> v.binormal;
+		deserialize(stream, version, v.uv[0]);
+		deserialize(stream, version, v.uv[1]);
+		deserialize(stream, version, v.uv[2]);
+		deserialize(stream, version, v.uv[3]);
+		if (version >= ApexStreamVersion::ChangedVertexColorFormatToReal)
+		{
+			deserialize(stream, version, v.color);
+		}
+		else
+		{
+			uint32_t intColor;
+			stream >> intColor;
+			v.color = VertexColor(ColorRGBA((uint8_t)(intColor & 255), (uint8_t)((intColor >> 8) & 255), (uint8_t)((intColor >> 16) & 255), (uint8_t)(intColor >> 24)));
+		}
+		if (version >= ApexStreamVersion::RenderMeshAssetRedesign)
+		{
+			for (uint32_t i = 0; i < 4; i++)
+			{
+				stream >> v.boneIndices[i];
+				stream >> v.boneWeights[i];
+			}
+			if (version < ApexStreamVersion::RenderMeshAssetBufferOverrunFix)
+			{
+				uint16_t dummyU16;
+				float dummyF32;
+				for (uint32_t i = 0; i < 4; i++)
+				{
+					stream >> dummyU16;
+					stream >> dummyF32;
+				}
+			}
+		}
+		else
+		{
+			uint32_t boneIndex;
+			stream >> boneIndex;
+			v.boneIndices[0] = (uint16_t)boneIndex;
+		}
+	}
+	else
+	{
+		stream >> v.position >> v.normal >> v.tangent >> v.binormal >> v.uv[0][0] >> v.uv[0][1];
+		uint32_t intColor;
+		stream >> intColor;
+		v.color = VertexColor(ColorRGBA((uint8_t)(intColor & 255), (uint8_t)((intColor >> 8) & 255), (uint8_t)((intColor >> 16) & 255), (uint8_t)(intColor >> 24)));
+		stream >> v.boneIndices[0];
+	}
+}
+
+
+// ExplicitRenderTriangle
+PX_INLINE void serialize(physx::PxFileBuf& stream, const ExplicitRenderTriangle& t)
+{
+	serialize(stream, t.vertices[0]);
+	serialize(stream, t.vertices[1]);
+	serialize(stream, t.vertices[2]);
+	stream << t.submeshIndex << t.smoothingMask << t.extraDataIndex;
+}
+
+PX_INLINE void deserialize(physx::PxFileBuf& stream, uint32_t version, ExplicitRenderTriangle& t)
+{
+	deserialize(stream, version, t.vertices[0]);
+	deserialize(stream, version, t.vertices[1]);
+	deserialize(stream, version, t.vertices[2]);
+	stream >> t.submeshIndex >> t.smoothingMask;
+	if (version >= ApexStreamVersion::TriangleFlagsChangedToExtraDataIndex)
+	{
+		stream >> t.extraDataIndex;
+	}
+	else
+	{
+		if (version >= ApexStreamVersion::TriangleFlags)
+		{
+			uint32_t deadData;
+			stream >> deadData;
+		}
+		t.extraDataIndex = 0xFFFFFFFF;
+	}
+}
+
+// ApexSimpleString
+PX_INLINE void serialize(physx::PxFileBuf& stream, const ApexSimpleString& s)
+{
+	s.serialize(stream);
+	//stream << s.len();
+	//stream.storeBuffer( s.c_str(), s.len() );
+}
+
+PX_INLINE void deserialize(physx::PxFileBuf& stream, uint32_t version, ApexSimpleString& s)
+{
+	PX_UNUSED(version);
+	s.deserialize(stream);
+}
+
+
+// ConvexHullImpl
+PX_INLINE void serialize(physx::PxFileBuf& stream, const ConvexHullImpl& h)
+{
+	if (h.mParams == NULL)
+	{
+		PX_ASSERT(!"Attempting to serialize a ConvexHullImpl with NULL NvParameters.");
+		return;
+	}
+
+	Array<physx::PxVec3>	vertices;
+	Array<physx::PxPlane>	uniquePlanes;
+	Array<uint32_t>	edges;
+	Array<uint32_t>	adjacentFaces;
+	Array<float>	widths;
+
+	NvParameterized::Handle handle(*h.mParams);
+
+	// vertices
+	vertices.resize((uint32_t)h.mParams->vertices.arraySizes[0]);
+	h.mParams->getParameterHandle("vertices", handle);
+	h.mParams->getParamVec3Array(handle, vertices.begin(), (int32_t)vertices.size());
+	serialize(stream, vertices);
+
+	// uniquePlanes
+	uniquePlanes.resize((uint32_t)h.mParams->uniquePlanes.arraySizes[0]);
+	for (uint32_t i = 0; i < (uint32_t)h.mParams->uniquePlanes.arraySizes[0]; ++i)
+	{
+		ConvexHullParametersNS::Plane_Type& plane = h.mParams->uniquePlanes.buf[i];
+		uniquePlanes[i] = physx::PxPlane(plane.normal, plane.d);
+	}
+	serialize(stream, uniquePlanes);
+
+	// bounds
+	stream << h.mParams->bounds;
+
+	// volume
+	stream << h.mParams->volume;
+
+	// edges
+	edges.resize((uint32_t)h.mParams->edges.arraySizes[0]);
+	h.mParams->getParameterHandle("edges", handle);
+	h.mParams->getParamU32Array(handle, edges.begin(), (int32_t)edges.size());
+	serialize(stream, edges);
+
+	// adjacentFaces
+	adjacentFaces.resize((uint32_t)h.mParams->adjacentFaces.arraySizes[0]);
+	h.mParams->getParameterHandle("adjacentFaces", handle);
+	h.mParams->getParamU32Array(handle, adjacentFaces.begin(), (int32_t)adjacentFaces.size());
+	serialize(stream, adjacentFaces);
+
+	// widths
+	widths.resize((uint32_t)h.mParams->widths.arraySizes[0]);
+	h.mParams->getParameterHandle("widths", handle);
+	h.mParams->getParamF32Array(handle, widths.begin(), (int32_t)widths.size());
+	serialize(stream, widths);
+
+	// unique direction count
+	stream << h.mParams->uniqueEdgeDirectionCount;
+
+	// plane count
+	stream << h.mParams->planeCount;
+}
+
+PX_INLINE void deserialize(physx::PxFileBuf& stream, uint32_t version, ConvexHullImpl& h)
+{
+	if (h.mParams == NULL)
+	{
+		h.init();
+	}
+
+	Array<physx::PxVec3>	vertices;
+	Array<physx::PxPlane>	uniquePlanes;
+	Array<uint32_t>	edges;
+	Array<uint32_t>	adjacentFaces;
+	Array<float>	widths;
+
+	NvParameterized::Handle handle(*h.mParams);
+
+	// vertices
+	deserialize(stream, version, vertices);
+	h.mParams->getParameterHandle("vertices", handle);
+	h.mParams->resizeArray(handle, (int32_t)vertices.size());
+	h.mParams->setParamVec3Array(handle, vertices.begin(), (int32_t)vertices.size());
+
+	// uniquePlanes
+	deserialize(stream, version, uniquePlanes);
+	h.mParams->getParameterHandle("uniquePlanes", handle);
+	h.mParams->resizeArray(handle, (int32_t)uniquePlanes.size());
+	for (uint32_t i = 0; i < uniquePlanes.size(); ++i)
+	{
+		physx::PxPlane& plane = uniquePlanes[i];
+		ConvexHullParametersNS::Plane_Type& paramPlane = h.mParams->uniquePlanes.buf[i];
+		paramPlane.normal = plane.n;
+		paramPlane.d = plane.d;
+	}
+
+	// bounds
+	stream >> h.mParams->bounds;
+
+	// volume
+	if (version >= ApexStreamVersion::ConvexHull_VolumeStreamed)
+	{
+		stream >> h.mParams->volume;
+	}
+
+	bool needsRebuild = false;
+
+	if (version >= ApexStreamVersion::ConvexHull_EdgesStreamed)
+	{
+		// edges
+		deserialize(stream, version, edges);
+		h.mParams->getParameterHandle("edges", handle);
+		h.mParams->resizeArray(handle, (int32_t)edges.size());
+		h.mParams->setParamU32Array(handle, edges.begin(), (int32_t)edges.size());
+
+		if (version >= ApexStreamVersion::AddedAdjacentPlanesToConvexHullStream)
+		{
+			// adjacentFaces
+			deserialize(stream, version, adjacentFaces);
+			h.mParams->getParameterHandle("adjacentFaces", handle);
+			h.mParams->resizeArray(handle, (int32_t)adjacentFaces.size());
+			h.mParams->setParamU32Array(handle, adjacentFaces.begin(), (int32_t)adjacentFaces.size());
+		}
+		else
+		{
+			needsRebuild = true;
+		}
+
+		if (version >= ApexStreamVersion::ConvexHullModifiedForEfficientCollisionTests)
+		{
+			// widths
+			deserialize(stream, version, widths);
+			h.mParams->getParameterHandle("widths", handle);
+			h.mParams->resizeArray(handle, (int32_t)widths.size());
+			h.mParams->setParamF32Array(handle, widths.begin(), (int32_t)widths.size());
+
+			// unique direction count
+			stream >> h.mParams->uniqueEdgeDirectionCount;
+
+			// plane count
+			stream >> h.mParams->planeCount;
+		}
+		else
+		{
+			// Fix up
+			// Ouch - rebuilding!
+			// \todo - issue load performance warning
+			h.buildFromPoints(vertices.begin(), vertices.size(), sizeof(physx::PxVec3));
+		}
+	}
+	else
+	{
+		needsRebuild = true;
+	}
+
+	if (needsRebuild)
+	{
+		// Ouch - rebuilding!
+		// \todo - issue load performance warning
+		h.buildFromPoints(vertices.begin(), vertices.size(), sizeof(physx::PxVec3));
+	}
+}
+
+// PxParamerized F32, U32, string, enum, and named ref
+PX_INLINE void serialize(physx::PxFileBuf& stream,
+                         uint32_t headerVersion,
+                         const NvParameterized::Interface* param,
+                         NvParameterized::Handle& childHandle)
+{
+	PX_UNUSED(headerVersion);
+	PX_UNUSED(param);
+	PX_ASSERT(childHandle.getConstInterface() == param);
+
+	ApexSimpleString tmpString;
+
+	if (childHandle.parameterDefinition()->type() == NvParameterized::TYPE_REF)
+	{
+		// named reference (we should check that it is not INCLUDED)
+
+		NvParameterized::Interface* childParamPtr = 0;
+
+		// just in case it wasn't initialized
+		//if( param->initParamRef(childHandle, NULL, true) != NvParameterized::ERROR_NONE )
+		//{
+		//	return;
+		//}
+
+		childHandle.getParamRef(childParamPtr);
+
+		if (!childParamPtr)  //Special case hack...
+		{
+			childHandle.initParamRef(NULL, true);
+			childHandle.getParamRef(childParamPtr);
+		}
+
+		if (childParamPtr)
+		{
+			tmpString = childParamPtr->className();
+			tmpString.serialize(stream);
+
+			tmpString = childParamPtr->name();
+			tmpString.serialize(stream);
+		}
+	}
+	else if (childHandle.parameterDefinition()->type() == NvParameterized::TYPE_STRING)
+	{
+		const char* str;
+		childHandle.getParamString(str);
+		tmpString = str;
+		tmpString.serialize(stream);
+	}
+	else if (childHandle.parameterDefinition()->type() == NvParameterized::TYPE_ENUM)
+	{
+		const char* str;
+		childHandle.getParamEnum(str);
+		tmpString = str;
+		tmpString.serialize(stream);
+	}
+	else
+	{
+		switch (childHandle.parameterDefinition()->type())
+		{
+		case NvParameterized::TYPE_VEC3:
+		{
+			physx::PxVec3 d;
+			childHandle.getParamVec3(d);
+			stream << d;
+			break;
+		}
+		case NvParameterized::TYPE_F32:
+		{
+			float d;
+			childHandle.getParamF32(d);
+			stream << d;
+			break;
+		}
+		case NvParameterized::TYPE_U32:
+		{
+			uint32_t d;
+			childHandle.getParamU32(d);
+			stream << d;
+			break;
+		}
+		case NvParameterized::TYPE_BOOL:
+		{
+			bool d;
+			childHandle.getParamBool(d);
+			if (d)
+			{
+				stream.storeByte((uint8_t)1);
+			}
+			else
+			{
+				stream.storeByte((uint8_t)0);
+			}
+			break;
+		}
+		default:
+			PX_ALWAYS_ASSERT();
+		}
+	}
+}
+
+PX_INLINE void serialize(physx::PxFileBuf& stream,
+                         uint32_t headerVersion,
+                         const NvParameterized::Interface* param,
+                         const char* memberName,
+                         NvParameterized::Handle* structHandle)
+{
+	PX_UNUSED(headerVersion);
+
+	NvParameterized::Handle childHandle(*param);
+	if (structHandle)
+	{
+		structHandle->getChildHandle(param, memberName, childHandle);
+	}
+	else
+	{
+		param->getParameterHandle(memberName, childHandle);
+	}
+
+	serialize(stream, headerVersion, param, childHandle);
+}
+
+
+// PxParamerized F32, U32, string, enum, and named ref
+// PxParamerized F32, U32, string, enum, and named ref
+PX_INLINE void deserialize(physx::PxFileBuf& stream,
+                           uint32_t headerVersion,
+                           NvParameterized::Interface* param,
+                           NvParameterized::Handle& childHandle)
+{
+	PX_UNUSED(param);
+	PX_ASSERT(childHandle.getConstInterface() == param);
+	ApexSimpleString tmpString;
+
+	if (childHandle.parameterDefinition()->type() == NvParameterized::TYPE_REF)
+	{
+		deserialize(stream, headerVersion, tmpString);
+
+		// named reference (we should check that it is not INCLUDED
+		NvParameterized::Interface* childParamPtr = 0;
+
+		// tmpString is the className (asset authorable name)
+		childHandle.initParamRef(tmpString.c_str(), true);
+		childHandle.getParamRef(childParamPtr);
+
+		PX_ASSERT(childParamPtr);
+		if (childParamPtr)
+		{
+			deserialize(stream, headerVersion, tmpString);
+			childParamPtr->setName(tmpString.c_str());
+		}
+
+	}
+	else if (childHandle.parameterDefinition()->type() == NvParameterized::TYPE_STRING)
+	{
+		deserialize(stream, headerVersion, tmpString);
+		childHandle.setParamString(tmpString.c_str());
+	}
+	else if (childHandle.parameterDefinition()->type() == NvParameterized::TYPE_ENUM)
+	{
+		deserialize(stream, headerVersion, tmpString);
+		if (childHandle.setParamEnum(tmpString.c_str()) != NvParameterized::ERROR_NONE)
+		{
+			APEX_DEBUG_WARNING("NvParameterized ENUM value not correct: %s, substituting: %s", \
+			                   tmpString.c_str(), childHandle.parameterDefinition()->enumVal(0));
+
+			childHandle.setParamEnum(childHandle.parameterDefinition()->enumVal(0));
+		}
+
+	}
+	else
+	{
+		switch (childHandle.parameterDefinition()->type())
+		{
+		case NvParameterized::TYPE_VEC3:
+		{
+			physx::PxVec3 d;
+			stream >> d;
+			childHandle.setParamVec3(d);
+			break;
+		}
+		case NvParameterized::TYPE_F32:
+		{
+			float d;
+			stream >> d;
+			childHandle.setParamF32(d);
+			break;
+		}
+		case NvParameterized::TYPE_U32:
+		{
+			uint32_t d;
+			stream >> d;
+			childHandle.setParamU32(d);
+			break;
+		}
+		case NvParameterized::TYPE_BOOL:
+		{
+			bool d;
+			uint8_t value = stream.readByte();
+			if (value)
+			{
+				d = true;
+			}
+			else
+			{
+				d = false;
+			}
+
+			childHandle.setParamBool(d);
+			break;
+		}
+		default:
+			PX_ALWAYS_ASSERT();
+		}
+	}
+
+}
+
+PX_INLINE void deserialize(physx::PxFileBuf& stream,
+                           uint32_t headerVersion,
+                           NvParameterized::Interface* param,
+                           const char* memberName,
+                           NvParameterized::Handle* structHandle)
+{
+	NvParameterized::Handle childHandle(*param);
+	if (structHandle)
+	{
+		structHandle->getChildHandle(param, memberName, childHandle);
+	}
+	else
+	{
+		param->getParameterHandle(memberName, childHandle);
+	}
+
+	deserialize(stream, headerVersion, param, childHandle);
+}
+
+
+}
+} // end namespace nvidia::apex
+
+
+#endif	// __APEXSHAREDSERIALIZATIONHELPERS_H__