360 lines
11 KiB
C++
360 lines
11 KiB
C++
// 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 PVD_OBJECT_MODEL_BASE_TYPES_H
|
|
#define PVD_OBJECT_MODEL_BASE_TYPES_H
|
|
#include "foundation/PxSimpleTypes.h"
|
|
#include "foundation/PxAssert.h"
|
|
|
|
namespace physx { namespace general_shared3 {
|
|
class PxMat34Legacy;
|
|
}}
|
|
|
|
namespace physx { namespace debugger {
|
|
namespace comm {}
|
|
|
|
using namespace physx;
|
|
using namespace general_shared3;
|
|
|
|
inline const char* nonNull( const char* str ) { return str ? str : ""; }
|
|
//strcmp will crash if passed a null string, however,
|
|
//so we need to make sure that doesn't happen. We do that
|
|
//by equating NULL and the empty string, "".
|
|
inline bool safeStrEq( const char* lhs, const char* rhs )
|
|
{
|
|
return strcmp( nonNull (lhs), nonNull(rhs) ) == 0;
|
|
}
|
|
|
|
//Does this string have useful information in it.
|
|
inline bool isMeaningful( const char* str ) { return *(nonNull( str ) ) > 0; }
|
|
|
|
inline PxU32 safeStrLen( const char* str )
|
|
{
|
|
str = nonNull( str );
|
|
return static_cast<PxU32>( strlen( str ) );
|
|
}
|
|
struct None
|
|
{
|
|
};
|
|
|
|
template<typename T>
|
|
class Option
|
|
{
|
|
T mValue;
|
|
bool mHasValue;
|
|
|
|
public:
|
|
Option( const T& val ) : mValue( val ), mHasValue( true ) {}
|
|
Option( None nothing = None() ) : mHasValue( false ) { (void)nothing; }
|
|
Option( const Option& other ) : mValue( other.mValue ), mHasValue( other.mHasValue ) {}
|
|
Option& operator=( const Option& other )
|
|
{
|
|
mValue = other.mValue;
|
|
mHasValue = other.mHasValue;
|
|
return *this;
|
|
}
|
|
bool hasValue() const { return mHasValue; }
|
|
const T& getValue() const { PX_ASSERT( hasValue() ); return mValue; }
|
|
T& getValue() { PX_ASSERT( hasValue() ); return mValue; }
|
|
operator const T& () const { return getValue(); }
|
|
operator T& () { return getValue(); }
|
|
T* operator->() { return &getValue(); }
|
|
const T* operator->() const { return &getValue(); }
|
|
};
|
|
|
|
class NonNegativeInteger
|
|
{
|
|
PxI32 mValue;
|
|
public:
|
|
NonNegativeInteger( PxI32 val = -1 ) : mValue( val ) {}
|
|
NonNegativeInteger( const NonNegativeInteger& o ) : mValue( o.mValue ) {}
|
|
NonNegativeInteger& operator=( const NonNegativeInteger& o ) { mValue = o.mValue; return *this; }
|
|
bool hasValue() const { return mValue >= 0; }
|
|
PxI32 getValue() const { PX_ASSERT( hasValue() ); return mValue; }
|
|
operator PxI32 () const { return getValue(); }
|
|
PxI32 unsafeGetValue() const { return mValue; }
|
|
bool operator==( const NonNegativeInteger& other ) { return mValue == other.mValue; }
|
|
};
|
|
|
|
struct PvdBaseType
|
|
{
|
|
enum Enum
|
|
{
|
|
None = 0,
|
|
InternalStart = 1,
|
|
InternalStop = 64,
|
|
#define DECLARE_BASE_PVD_TYPE( type ) type,
|
|
#include "physxvisualdebuggersdk/PvdObjectModelBaseTypeDefs.h"
|
|
Last,
|
|
#undef DECLARE_BASE_PVD_TYPE
|
|
};
|
|
};
|
|
|
|
struct ObjectRef
|
|
{
|
|
NonNegativeInteger mInstanceId;
|
|
ObjectRef( NonNegativeInteger iid ) : mInstanceId( iid ) {}
|
|
ObjectRef( PxI32 iid = -1 ) : mInstanceId( iid ) {}
|
|
operator NonNegativeInteger() const { return mInstanceId; }
|
|
operator PxI32 () const { return mInstanceId.getValue(); }
|
|
bool hasValue() const { return mInstanceId.unsafeGetValue() > 0; }
|
|
};
|
|
|
|
struct U32Array4
|
|
{
|
|
PxU32 mD0;
|
|
PxU32 mD1;
|
|
PxU32 mD2;
|
|
PxU32 mD3;
|
|
U32Array4( PxU32 d0, PxU32 d1, PxU32 d2, PxU32 d3 )
|
|
: mD0( d0 ), mD1( d1 ), mD2( d2 ), mD3( d3 ) {}
|
|
U32Array4() : mD0( 0 ), mD1( 0 ), mD2( 0 ), mD3( 0 ) {}
|
|
};
|
|
|
|
#define PVD_POINTER_TO_U64( ptr ) static_cast<PxU64>( reinterpret_cast<size_t>( ptr ) )
|
|
#define PVD_U64_TO_POINTER( ptrtype, val ) reinterpret_cast<ptrtype>( static_cast<size_t>( val ) );
|
|
typedef bool PvdBool;
|
|
typedef const char* String;
|
|
typedef void* VoidPtr;
|
|
|
|
|
|
|
|
struct PvdColor
|
|
{
|
|
PxU8 r;
|
|
PxU8 g;
|
|
PxU8 b;
|
|
PxU8 a;
|
|
PvdColor( PxU8 _r, PxU8 _g, PxU8 _b, PxU8 _a = 255 ) : r( _r ), g( _g ), b( _b ), a( _a ) {}
|
|
PvdColor() : r( 0 ), g( 0 ), b( 0 ), a( 255 ) {}
|
|
PvdColor( PxU32 value )
|
|
{
|
|
PxU8* valPtr = reinterpret_cast<PxU8*>( &value );
|
|
r = valPtr[0];
|
|
g = valPtr[1];
|
|
b = valPtr[2];
|
|
a = valPtr[3];
|
|
}
|
|
};
|
|
|
|
struct StringHandle
|
|
{
|
|
PxU32 mHandle;
|
|
StringHandle( PxU32 val = 0 ) : mHandle( val ) {}
|
|
operator PxU32 () const { return mHandle; }
|
|
};
|
|
|
|
struct NamespacedName
|
|
{
|
|
String mNamespace;
|
|
String mName;
|
|
NamespacedName( String ns, String nm ) : mNamespace( ns ), mName( nm ) {}
|
|
NamespacedName( String nm = "" ) : mNamespace( "" ), mName( nm ) {}
|
|
bool operator==( const NamespacedName& other ) const
|
|
{
|
|
return safeStrEq( mNamespace, other.mNamespace )
|
|
&& safeStrEq( mName, other.mName );
|
|
}
|
|
};
|
|
|
|
|
|
struct NamedValue
|
|
{
|
|
String mName;
|
|
PxU32 mValue;
|
|
NamedValue( String nm = "", PxU32 val = 0 )
|
|
: mName( nm )
|
|
, mValue( val )
|
|
{
|
|
}
|
|
};
|
|
|
|
|
|
template<typename T>
|
|
struct BaseDataTypeToTypeMap
|
|
{
|
|
bool compile_error;
|
|
};
|
|
template<PvdBaseType::Enum>
|
|
struct BaseTypeToDataTypeMap
|
|
{
|
|
bool compile_error;
|
|
};
|
|
|
|
//Users can extend this mapping with new datatypes.
|
|
template<typename T>
|
|
struct PvdDataTypeToNamespacedNameMap
|
|
{
|
|
bool Name;
|
|
};
|
|
//This mapping tells you the what class id to use for the base datatypes
|
|
|
|
#define DECLARE_BASE_PVD_TYPE( type ) \
|
|
template<> struct BaseDataTypeToTypeMap<type> { enum Enum { BaseTypeEnum = PvdBaseType::type }; }; \
|
|
template<> struct BaseDataTypeToTypeMap<const type&> { enum Enum { BaseTypeEnum = PvdBaseType::type }; }; \
|
|
template<> struct BaseTypeToDataTypeMap<PvdBaseType::type> { typedef type TDataType; }; \
|
|
template<> struct PvdDataTypeToNamespacedNameMap<type> { NamespacedName Name; PvdDataTypeToNamespacedNameMap<type>() : Name( "physx3", #type ) {} }; \
|
|
template<> struct PvdDataTypeToNamespacedNameMap<const type&> { NamespacedName Name; PvdDataTypeToNamespacedNameMap<const type&>() : Name( "physx3", #type ) {} };
|
|
|
|
#include "physxvisualdebuggersdk/PvdObjectModelBaseTypeDefs.h"
|
|
#undef DECLARE_BASE_PVD_TYPE
|
|
|
|
template< typename TDataType> inline NonNegativeInteger getPvdTypeForType() { return static_cast<PvdBaseType::Enum>(BaseDataTypeToTypeMap<TDataType>::BaseTypeEnum); }
|
|
template<typename TDataType> inline NamespacedName getPvdNamespacedNameForType() { return PvdDataTypeToNamespacedNameMap<TDataType>().Name; }
|
|
|
|
#define DEFINE_PVD_TYPE_NAME_MAP( type, ns, name ) \
|
|
template<> struct PvdDataTypeToNamespacedNameMap<type> { NamespacedName Name; PvdDataTypeToNamespacedNameMap<type>() : Name( ns, name ) {} };
|
|
|
|
#define DEFINE_PVD_TYPE_ALIAS( newType, oldType ) \
|
|
template<> struct PvdDataTypeToNamespacedNameMap<newType> { NamespacedName Name; PvdDataTypeToNamespacedNameMap<newType>() : Name( PvdDataTypeToNamespacedNameMap<oldType>().Name ) {} };
|
|
|
|
DEFINE_PVD_TYPE_ALIAS( const void*, void* );
|
|
|
|
|
|
struct ArrayData
|
|
{
|
|
PxU8* mBegin;
|
|
PxU8* mEnd;
|
|
PxU8* mCapacity; //>= stop
|
|
ArrayData( PxU8* beg = NULL, PxU8* end = NULL, PxU8* cap = NULL )
|
|
: mBegin(beg )
|
|
, mEnd( end )
|
|
, mCapacity( cap )
|
|
{}
|
|
PxU8* begin() { return mBegin; }
|
|
PxU8* end() { return mEnd; }
|
|
PxU32 byteCapacity() { return static_cast<PxU32>( mCapacity - mBegin ); }
|
|
PxU32 byteSize() const { return static_cast<PxU32>( mEnd - mBegin ); } //in bytes
|
|
PxU32 numberOfItems( PxU32 objectByteSize ) { if ( objectByteSize ) return byteSize() / objectByteSize; return 0; }
|
|
|
|
void forgetData() { mBegin = mEnd = mCapacity = 0; }
|
|
};
|
|
|
|
template<typename TItemType>
|
|
struct PvdScopedItem
|
|
{
|
|
private:
|
|
PvdScopedItem( const PvdScopedItem& );
|
|
PvdScopedItem& operator=( const PvdScopedItem& );
|
|
public:
|
|
|
|
TItemType* mItem;
|
|
PvdScopedItem( TItemType& item ) : mItem( &item ) {}
|
|
PvdScopedItem( TItemType* item ) : mItem( item ) {}
|
|
~PvdScopedItem() { if ( mItem ) mItem->release(); }
|
|
TItemType* operator->() { PX_ASSERT( mItem ); return mItem; }
|
|
TItemType& operator*() { PX_ASSERT( mItem ); return *mItem; }
|
|
operator TItemType* () { return mItem; }
|
|
operator const TItemType* () const { return mItem; }
|
|
};
|
|
|
|
|
|
template<typename T>
|
|
class DataRef
|
|
{
|
|
const T* mBegin;
|
|
const T* mEnd;
|
|
public:
|
|
DataRef( const T* b, PxU32 count ) : mBegin( b ), mEnd( b + count ) {}
|
|
DataRef( const T* b = NULL, const T* e = NULL ) : mBegin( b ), mEnd( e ) {}
|
|
DataRef( const DataRef& o ) : mBegin( o.mBegin ), mEnd( o.mEnd ) {}
|
|
DataRef& operator=( const DataRef& o ) { mBegin = o.mBegin; mEnd = o.mEnd; return *this; }
|
|
PxU32 size() const { return static_cast<PxU32>( mEnd - mBegin ); }
|
|
const T* begin() const { return mBegin; }
|
|
const T* end() const { return mEnd; }
|
|
const T& operator[]( PxU32 idx ) const { PX_ASSERT( idx < size() ); return mBegin[idx]; }
|
|
const T& back() const { PX_ASSERT( mEnd > mBegin ); return *(mEnd - 1); }
|
|
};
|
|
|
|
inline PxU64 toPaddedSize( PxU64 inOriginal, PxU32 inPageSize = 0x1000 )
|
|
{
|
|
return (inOriginal + inPageSize) - inOriginal % inPageSize;
|
|
}
|
|
|
|
template<PxU32 TSize>
|
|
struct Union
|
|
{
|
|
PxU8 mData[TSize];
|
|
Union(){}
|
|
template<typename TDataType>
|
|
void set( const TDataType& inValue ) { PX_COMPILE_TIME_ASSERT( sizeof( TDataType ) <= TSize ); new (mData) TDataType( inValue ); }
|
|
template<typename TDataType>
|
|
TDataType get() const { PX_COMPILE_TIME_ASSERT( sizeof( TDataType ) <= TSize ); return *reinterpret_cast<const TDataType*>( mData ); }
|
|
};
|
|
|
|
struct PropertyType
|
|
{
|
|
enum Enum
|
|
{
|
|
Unknown = 0,
|
|
Scalar,
|
|
Array,
|
|
};
|
|
};
|
|
|
|
template<typename TObjType>
|
|
struct PvdRefPtr
|
|
{
|
|
mutable TObjType* mObj;
|
|
~PvdRefPtr()
|
|
{
|
|
release();
|
|
}
|
|
PvdRefPtr( TObjType* obj = NULL ) : mObj( obj )
|
|
{
|
|
addRef();
|
|
}
|
|
PvdRefPtr( const PvdRefPtr<TObjType>& other )
|
|
{
|
|
mObj = other.mObj;
|
|
addRef();
|
|
}
|
|
PvdRefPtr<TObjType>& operator=( const PvdRefPtr<TObjType>& other )
|
|
{
|
|
if ( mObj != other.mObj )
|
|
release();
|
|
mObj = other.mObj;
|
|
addRef();
|
|
return *this;
|
|
}
|
|
void addRef() { if ( mObj ) mObj->addRef(); }
|
|
void release() { if ( mObj ) mObj->release(); }
|
|
operator TObjType* () { return mObj; }
|
|
operator const TObjType* () const { return mObj; }
|
|
|
|
TObjType* operator->() { PX_ASSERT( mObj ); return mObj; }
|
|
const TObjType* operator->() const { PX_ASSERT( mObj ); return mObj; }
|
|
|
|
TObjType& operator*() { PX_ASSERT( mObj ); return *mObj; }
|
|
const TObjType& operator*() const { PX_ASSERT( mObj ); return *mObj; }
|
|
};
|
|
}}
|
|
|
|
|
|
#endif |