Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

1 files changed, 414 insertions, 0 deletions

diff --git a/APEX_1.4/NvParameterized/src/PlatformABI.cpp b/APEX_1.4/NvParameterized/src/PlatformABI.cpp
new file mode 100644
index 00000000..6062cdfe
--- /dev/null
+++ b/APEX_1.4/NvParameterized/src/PlatformABI.cpp
@@ -0,0 +1,414 @@
+// 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;
+	}
+
+	//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
+}