feat(physics): wire physx sdk into build
This commit is contained in:
481
engine/third_party/physx/source/pvd/src/PxPvdObjectModelMetaData.h
vendored
Normal file
481
engine/third_party/physx/source/pvd/src/PxPvdObjectModelMetaData.h
vendored
Normal file
@@ -0,0 +1,481 @@
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions
|
||||
// are met:
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above copyright
|
||||
// notice, this list of conditions and the following disclaimer in the
|
||||
// documentation and/or other materials provided with the distribution.
|
||||
// * Neither the name of NVIDIA CORPORATION nor the names of its
|
||||
// contributors may be used to endorse or promote products derived
|
||||
// from this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
|
||||
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
||||
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
||||
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
||||
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
||||
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Copyright (c) 2008-2025 NVIDIA Corporation. All rights reserved.
|
||||
|
||||
#ifndef PX_PVD_OBJECT_MODEL_METADATA_H
|
||||
#define PX_PVD_OBJECT_MODEL_METADATA_H
|
||||
|
||||
#include "foundation/PxAssert.h"
|
||||
#include "PxPvdObjectModelBaseTypes.h"
|
||||
#include "PxPvdBits.h"
|
||||
|
||||
namespace physx
|
||||
{
|
||||
namespace pvdsdk
|
||||
{
|
||||
|
||||
class PvdInputStream;
|
||||
class PvdOutputStream;
|
||||
|
||||
struct PropertyDescription
|
||||
{
|
||||
NamespacedName mOwnerClassName;
|
||||
int32_t mOwnerClassId;
|
||||
String mName;
|
||||
String mSemantic;
|
||||
// The datatype this property corresponds to.
|
||||
int32_t mDatatype;
|
||||
// The name of the datatype
|
||||
NamespacedName mDatatypeName;
|
||||
// Scalar or array.
|
||||
PropertyType::Enum mPropertyType;
|
||||
// No other property under any class has this id, it is DB-unique.
|
||||
int32_t mPropertyId;
|
||||
// Offset in bytes into the object's data section where this property starts.
|
||||
uint32_t m32BitOffset;
|
||||
// Offset in bytes into the object's data section where this property starts.
|
||||
uint32_t m64BitOffset;
|
||||
|
||||
PropertyDescription(const NamespacedName& clsName, int32_t classId, String name, String semantic, int32_t datatype,
|
||||
const NamespacedName& datatypeName, PropertyType::Enum propType, int32_t propId,
|
||||
uint32_t offset32, uint32_t offset64)
|
||||
: mOwnerClassName(clsName)
|
||||
, mOwnerClassId(classId)
|
||||
, mName(name)
|
||||
, mSemantic(semantic)
|
||||
, mDatatype(datatype)
|
||||
, mDatatypeName(datatypeName)
|
||||
, mPropertyType(propType)
|
||||
, mPropertyId(propId)
|
||||
, m32BitOffset(offset32)
|
||||
, m64BitOffset(offset64)
|
||||
{
|
||||
}
|
||||
PropertyDescription()
|
||||
: mOwnerClassId(-1)
|
||||
, mName("")
|
||||
, mSemantic("")
|
||||
, mDatatype(-1)
|
||||
, mPropertyType(PropertyType::Unknown)
|
||||
, mPropertyId(-1)
|
||||
, m32BitOffset(0)
|
||||
, m64BitOffset(0)
|
||||
|
||||
{
|
||||
}
|
||||
|
||||
virtual ~PropertyDescription()
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
struct PtrOffsetType
|
||||
{
|
||||
enum Enum
|
||||
{
|
||||
UnknownOffset,
|
||||
VoidPtrOffset,
|
||||
StringOffset
|
||||
};
|
||||
};
|
||||
|
||||
struct PtrOffset
|
||||
{
|
||||
PtrOffsetType::Enum mOffsetType;
|
||||
uint32_t mOffset;
|
||||
PtrOffset(PtrOffsetType::Enum type, uint32_t offset) : mOffsetType(type), mOffset(offset)
|
||||
{
|
||||
}
|
||||
PtrOffset() : mOffsetType(PtrOffsetType::UnknownOffset), mOffset(0)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
inline uint32_t align(uint32_t offset, uint32_t alignment)
|
||||
{
|
||||
uint32_t startOffset = offset;
|
||||
uint32_t alignmentMask = ~(alignment - 1);
|
||||
offset = (offset + alignment - 1) & alignmentMask;
|
||||
PX_ASSERT(offset >= startOffset && (offset % alignment) == 0);
|
||||
(void)startOffset;
|
||||
return offset;
|
||||
}
|
||||
|
||||
struct ClassDescriptionSizeInfo
|
||||
{
|
||||
// The size of the data section of this object, padded to alignment.
|
||||
uint32_t mByteSize;
|
||||
// The last data member goes to here.
|
||||
uint32_t mDataByteSize;
|
||||
// Alignment in bytes of the data section of this object.
|
||||
uint32_t mAlignment;
|
||||
// the offsets of string handles in the binary value of this class
|
||||
DataRef<PtrOffset> mPtrOffsets;
|
||||
ClassDescriptionSizeInfo() : mByteSize(0), mDataByteSize(0), mAlignment(0)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
struct ClassDescription
|
||||
{
|
||||
NamespacedName mName;
|
||||
// No other class has this id, it is DB-unique
|
||||
int32_t mClassId;
|
||||
// Only single derivation supported.
|
||||
int32_t mBaseClass;
|
||||
// If this class has properties that are of uniform type, then we note that.
|
||||
// This means that when deserialization an array of these objects we can just use
|
||||
// single function to endian convert the entire mess at once.
|
||||
int32_t mPackedUniformWidth;
|
||||
// If this class is composed uniformly of members of a given type
|
||||
// Or all of its properties are composed uniformly of members of
|
||||
// a give ntype, then this class's packed type is that type.
|
||||
// PxTransform's packed type would be float.
|
||||
int32_t mPackedClassType;
|
||||
// 0: 32Bit 1: 64Bit
|
||||
ClassDescriptionSizeInfo mSizeInfo[2];
|
||||
// No further property additions allowed.
|
||||
bool mLocked;
|
||||
// True when this datatype has an array on it that needs to be
|
||||
// separately deleted.
|
||||
bool mRequiresDestruction;
|
||||
|
||||
ClassDescription(NamespacedName name, int32_t id)
|
||||
: mName(name)
|
||||
, mClassId(id)
|
||||
, mBaseClass(-1)
|
||||
, mPackedUniformWidth(-1)
|
||||
, mPackedClassType(-1)
|
||||
, mLocked(false)
|
||||
, mRequiresDestruction(false)
|
||||
{
|
||||
}
|
||||
ClassDescription()
|
||||
: mClassId(-1), mBaseClass(-1), mPackedUniformWidth(-1), mPackedClassType(-1), mLocked(false), mRequiresDestruction(false)
|
||||
{
|
||||
}
|
||||
virtual ~ClassDescription()
|
||||
{
|
||||
}
|
||||
|
||||
ClassDescriptionSizeInfo& get32BitSizeInfo()
|
||||
{
|
||||
return mSizeInfo[0];
|
||||
}
|
||||
ClassDescriptionSizeInfo& get64BitSizeInfo()
|
||||
{
|
||||
return mSizeInfo[1];
|
||||
}
|
||||
uint32_t& get32BitSize()
|
||||
{
|
||||
return get32BitSizeInfo().mByteSize;
|
||||
}
|
||||
uint32_t& get64BitSize()
|
||||
{
|
||||
return get64BitSizeInfo().mByteSize;
|
||||
}
|
||||
|
||||
uint32_t get32BitSize() const
|
||||
{
|
||||
return mSizeInfo[0].mByteSize;
|
||||
}
|
||||
const ClassDescriptionSizeInfo& getNativeSizeInfo() const
|
||||
{
|
||||
return mSizeInfo[(sizeof(void*) >> 2) - 1];
|
||||
}
|
||||
uint32_t getNativeSize() const
|
||||
{
|
||||
return getNativeSizeInfo().mByteSize;
|
||||
}
|
||||
};
|
||||
|
||||
struct MarshalQueryResult
|
||||
{
|
||||
int32_t srcType;
|
||||
int32_t dstType;
|
||||
// If canMarshal != needsMarshalling we have a problem.
|
||||
bool canMarshal;
|
||||
bool needsMarshalling;
|
||||
// Non null if marshalling is possible.
|
||||
TBlockMarshaller marshaller;
|
||||
MarshalQueryResult(int32_t _srcType = -1, int32_t _dstType = -1, bool _canMarshal = false, bool _needs = false,
|
||||
TBlockMarshaller _m = NULL)
|
||||
: srcType(_srcType), dstType(_dstType), canMarshal(_canMarshal), needsMarshalling(_needs), marshaller(_m)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
struct PropertyMessageEntry
|
||||
{
|
||||
PropertyDescription mProperty;
|
||||
NamespacedName mDatatypeName;
|
||||
// datatype of the data in the message.
|
||||
int32_t mDatatypeId;
|
||||
// where in the message this property starts.
|
||||
uint32_t mMessageOffset;
|
||||
// size of this entry object
|
||||
uint32_t mByteSize;
|
||||
|
||||
// If the chain of properties doesn't have any array properties this indicates the
|
||||
uint32_t mDestByteSize;
|
||||
|
||||
PropertyMessageEntry(PropertyDescription propName, NamespacedName dtypeName, int32_t dtype, uint32_t messageOff,
|
||||
uint32_t byteSize, uint32_t destByteSize)
|
||||
: mProperty(propName)
|
||||
, mDatatypeName(dtypeName)
|
||||
, mDatatypeId(dtype)
|
||||
, mMessageOffset(messageOff)
|
||||
, mByteSize(byteSize)
|
||||
, mDestByteSize(destByteSize)
|
||||
{
|
||||
}
|
||||
PropertyMessageEntry() : mDatatypeId(-1), mMessageOffset(0), mByteSize(0), mDestByteSize(0)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
// Create a struct that defines a subset of the properties on an object.
|
||||
struct PropertyMessageDescription
|
||||
{
|
||||
NamespacedName mClassName;
|
||||
// No other class has this id, it is DB-unique
|
||||
int32_t mClassId;
|
||||
NamespacedName mMessageName;
|
||||
int32_t mMessageId;
|
||||
DataRef<PropertyMessageEntry> mProperties;
|
||||
uint32_t mMessageByteSize;
|
||||
// Offsets into the property message where const char* items are.
|
||||
DataRef<uint32_t> mStringOffsets;
|
||||
PropertyMessageDescription(const NamespacedName& nm, int32_t clsId, const NamespacedName& msgName, int32_t msgId,
|
||||
uint32_t msgSize)
|
||||
: mClassName(nm), mClassId(clsId), mMessageName(msgName), mMessageId(msgId), mMessageByteSize(msgSize)
|
||||
{
|
||||
}
|
||||
PropertyMessageDescription() : mClassId(-1), mMessageId(-1), mMessageByteSize(0)
|
||||
{
|
||||
}
|
||||
virtual ~PropertyMessageDescription()
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
class StringTable
|
||||
{
|
||||
protected:
|
||||
virtual ~StringTable()
|
||||
{
|
||||
}
|
||||
|
||||
public:
|
||||
virtual uint32_t getNbStrs() = 0;
|
||||
virtual uint32_t getStrs(const char** outStrs, uint32_t bufLen, uint32_t startIdx = 0) = 0;
|
||||
virtual const char* registerStr(const char* str, bool& outAdded) = 0;
|
||||
const char* registerStr(const char* str)
|
||||
{
|
||||
bool ignored;
|
||||
return registerStr(str, ignored);
|
||||
}
|
||||
virtual StringHandle strToHandle(const char* str) = 0;
|
||||
virtual const char* handleToStr(uint32_t hdl) = 0;
|
||||
virtual void release() = 0;
|
||||
|
||||
static StringTable& create();
|
||||
};
|
||||
|
||||
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();
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Create new classes and add properties to some existing ones.
|
||||
* The default classes are created already, the simple types
|
||||
* along with the basic math types.
|
||||
* (uint8_t, int8_t, etc )
|
||||
* (PxVec3, PxQuat, PxTransform, PxMat33, PxMat34, PxMat44)
|
||||
*/
|
||||
class PvdObjectModelMetaData
|
||||
{
|
||||
protected:
|
||||
virtual ~PvdObjectModelMetaData()
|
||||
{
|
||||
}
|
||||
|
||||
public:
|
||||
virtual ClassDescription getOrCreateClass(const NamespacedName& nm) = 0;
|
||||
// get or create parent, lock parent. deriveFrom getOrCreatechild.
|
||||
virtual bool deriveClass(const NamespacedName& parent, const NamespacedName& child) = 0;
|
||||
virtual Option<ClassDescription> findClass(const NamespacedName& nm) const = 0;
|
||||
template <typename TDataType>
|
||||
Option<ClassDescription> findClass()
|
||||
{
|
||||
return findClass(getPvdNamespacedNameForType<TDataType>());
|
||||
}
|
||||
virtual Option<ClassDescription> getClass(int32_t classId) const = 0;
|
||||
virtual ClassDescription* getClassPtr(int32_t classId) const = 0;
|
||||
|
||||
virtual Option<ClassDescription> getParentClass(int32_t classId) const = 0;
|
||||
bool isDerivedFrom(int32_t classId, int32_t parentClass) const
|
||||
{
|
||||
if(classId == parentClass)
|
||||
return true;
|
||||
ClassDescription* p = getClassPtr(getClassPtr(classId)->mBaseClass);
|
||||
while(p != NULL)
|
||||
{
|
||||
if(p->mClassId == parentClass)
|
||||
return true;
|
||||
p = getClassPtr(p->mBaseClass);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
virtual void lockClass(int32_t classId) = 0;
|
||||
|
||||
virtual uint32_t getNbClasses() const = 0;
|
||||
virtual uint32_t getClasses(ClassDescription* outClasses, uint32_t requestCount, uint32_t startIndex = 0) const = 0;
|
||||
|
||||
// Create a nested property.
|
||||
// This way you can have obj.p.x without explicity defining the class p.
|
||||
virtual Option<PropertyDescription> createProperty(int32_t classId, String name, String semantic, int32_t datatype,
|
||||
PropertyType::Enum propertyType = PropertyType::Scalar) = 0;
|
||||
Option<PropertyDescription> createProperty(NamespacedName clsId, String name, String semantic, NamespacedName dtype,
|
||||
PropertyType::Enum propertyType = PropertyType::Scalar)
|
||||
{
|
||||
return createProperty(findClass(clsId)->mClassId, name, semantic, findClass(dtype)->mClassId, propertyType);
|
||||
}
|
||||
Option<PropertyDescription> createProperty(NamespacedName clsId, String name, NamespacedName dtype,
|
||||
PropertyType::Enum propertyType = PropertyType::Scalar)
|
||||
{
|
||||
return createProperty(findClass(clsId)->mClassId, name, "", findClass(dtype)->mClassId, propertyType);
|
||||
}
|
||||
Option<PropertyDescription> createProperty(int32_t clsId, String name, int32_t dtype,
|
||||
PropertyType::Enum propertyType = PropertyType::Scalar)
|
||||
{
|
||||
return createProperty(clsId, name, "", dtype, propertyType);
|
||||
}
|
||||
template <typename TDataType>
|
||||
Option<PropertyDescription> createProperty(int32_t clsId, String name, String semantic = "",
|
||||
PropertyType::Enum propertyType = PropertyType::Scalar)
|
||||
{
|
||||
return createProperty(clsId, name, semantic, getPvdNamespacedNameForType<TDataType>(), propertyType);
|
||||
}
|
||||
virtual Option<PropertyDescription> findProperty(const NamespacedName& cls, String prop) const = 0;
|
||||
virtual Option<PropertyDescription> findProperty(int32_t clsId, String prop) const = 0;
|
||||
virtual Option<PropertyDescription> getProperty(int32_t propId) const = 0;
|
||||
virtual void setNamedPropertyValues(DataRef<NamedValue> values, int32_t propId) = 0;
|
||||
// for enumerations and flags.
|
||||
virtual DataRef<NamedValue> getNamedPropertyValues(int32_t propId) const = 0;
|
||||
|
||||
virtual uint32_t getNbProperties(int32_t classId) const = 0;
|
||||
virtual uint32_t getProperties(int32_t classId, PropertyDescription* outBuffer, uint32_t bufCount,
|
||||
uint32_t startIdx = 0) const = 0;
|
||||
|
||||
// Does one cls id differ marshalling to another and if so return the functions to do it.
|
||||
virtual MarshalQueryResult checkMarshalling(int32_t srcClsId, int32_t dstClsId) const = 0;
|
||||
|
||||
// messages and classes are stored in separate maps, so a property message can have the same name as a class.
|
||||
virtual Option<PropertyMessageDescription> createPropertyMessage(const NamespacedName& cls,
|
||||
const NamespacedName& msgName,
|
||||
DataRef<PropertyMessageArg> entries,
|
||||
uint32_t messageSize) = 0;
|
||||
virtual Option<PropertyMessageDescription> findPropertyMessage(const NamespacedName& msgName) const = 0;
|
||||
virtual Option<PropertyMessageDescription> getPropertyMessage(int32_t msgId) const = 0;
|
||||
|
||||
virtual uint32_t getNbPropertyMessages() const = 0;
|
||||
virtual uint32_t getPropertyMessages(PropertyMessageDescription* msgBuf, uint32_t bufLen,
|
||||
uint32_t startIdx = 0) const = 0;
|
||||
|
||||
virtual StringTable& getStringTable() const = 0;
|
||||
|
||||
virtual void write(PvdOutputStream& stream) const = 0;
|
||||
void save(PvdOutputStream& stream) const
|
||||
{
|
||||
write(stream);
|
||||
}
|
||||
|
||||
virtual void addRef() = 0;
|
||||
virtual void release() = 0;
|
||||
|
||||
static uint32_t getCurrentPvdObjectModelVersion();
|
||||
static PvdObjectModelMetaData& create();
|
||||
static PvdObjectModelMetaData& create(PvdInputStream& stream);
|
||||
};
|
||||
}
|
||||
}
|
||||
#endif
|
||||
Reference in New Issue
Block a user