PxPvdObjectModelBaseTypes.h

// 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-2022 NVIDIA Corporation. All rights reserved.
 
#ifndef PX_PVD_OBJECT_MODEL_BASE_TYPES_H
#define PX_PVD_OBJECT_MODEL_BASE_TYPES_H
 
#include "foundation/PxAssert.h"
 
#if !PX_DOXYGEN
namespace physx
{
namespace pvdsdk
{
#endif
 
using namespace physx;
 
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 uint32_t safeStrLen(const char* str)
{
    str = nonNull(str);
    return static_cast<uint32_t>(strlen(str));
}
 
struct ObjectRef
{
    int32_t mInstanceId;
 
    ObjectRef(int32_t iid = -1) : mInstanceId(iid)
    {
    }
    operator int32_t() const
    {
        return mInstanceId;
    }
    bool hasValue() const
    {
        return mInstanceId > 0;
    }
};
 
struct U32Array4
{
    uint32_t mD0;
    uint32_t mD1;
    uint32_t mD2;
    uint32_t mD3;
    U32Array4(uint32_t d0, uint32_t d1, uint32_t d2, uint32_t d3) : mD0(d0), mD1(d1), mD2(d2), mD3(d3)
    {
    }
    U32Array4() : mD0(0), mD1(0), mD2(0), mD3(0)
    {
    }
};
 
typedef bool                PvdBool;
typedef const char*         String;
typedef void*               VoidPtr;
typedef double              PvdF64;
typedef float               PvdF32;
typedef int64_t             PvdI64;
typedef uint64_t            PvdU64;
typedef int32_t             PvdI32;
typedef uint32_t            PvdU32;
typedef int16_t             PvdI16;
typedef uint16_t            PvdU16;
typedef int8_t              PvdI8;
typedef uint8_t             PvdU8;
 
struct PvdColor
{
    uint8_t r;
    uint8_t g;
    uint8_t b;
    uint8_t a;
    PvdColor(uint8_t _r, uint8_t _g, uint8_t _b, uint8_t _a = 255) : r(_r), g(_g), b(_b), a(_a)
    {
    }
    PvdColor() : r(0), g(0), b(0), a(255)
    {
    }
    PvdColor(uint32_t abgr)
    {
        uint8_t* valPtr = reinterpret_cast<uint8_t*>(&abgr);
        r = valPtr[0];
        g = valPtr[1];
        b = valPtr[2];
        a = valPtr[3];
    }
};
 
struct StringHandle
{
    uint32_t mHandle;
    StringHandle(uint32_t val = 0) : mHandle(val)
    {
    }
    operator uint32_t() const
    {
        return mHandle;
    }
};
 
#define DECLARE_TYPES                   \
DECLARE_BASE_PVD_TYPE(PvdI8)            \
DECLARE_BASE_PVD_TYPE(PvdU8)            \
DECLARE_BASE_PVD_TYPE(PvdI16)           \
DECLARE_BASE_PVD_TYPE(PvdU16)           \
DECLARE_BASE_PVD_TYPE(PvdI32)           \
DECLARE_BASE_PVD_TYPE(PvdU32)           \
DECLARE_BASE_PVD_TYPE(PvdI64)           \
DECLARE_BASE_PVD_TYPE(PvdU64)           \
DECLARE_BASE_PVD_TYPE(PvdF32)           \
DECLARE_BASE_PVD_TYPE(PvdF64)           \
DECLARE_BASE_PVD_TYPE(PvdBool)          \
DECLARE_BASE_PVD_TYPE(PvdColor)         \
DECLARE_BASE_PVD_TYPE(String)           \
DECLARE_BASE_PVD_TYPE(StringHandle)     \
DECLARE_BASE_PVD_TYPE(ObjectRef)        \
DECLARE_BASE_PVD_TYPE(VoidPtr)          \
DECLARE_BASE_PVD_TYPE(PxVec2)           \
DECLARE_BASE_PVD_TYPE(PxVec3)           \
DECLARE_BASE_PVD_TYPE(PxVec4)           \
DECLARE_BASE_PVD_TYPE(PxBounds3)        \
DECLARE_BASE_PVD_TYPE(PxQuat)           \
DECLARE_BASE_PVD_TYPE(PxTransform)      \
DECLARE_BASE_PVD_TYPE(PxMat33)          \
DECLARE_BASE_PVD_TYPE(PxMat44)          \
DECLARE_BASE_PVD_TYPE(U32Array4)        
 
struct PvdBaseType
{
    enum Enum
    {
        None          = 0,
        InternalStart = 1,
        InternalStop  = 64,
#define DECLARE_BASE_PVD_TYPE(type) type,
        DECLARE_TYPES
        Last
#undef DECLARE_BASE_PVD_TYPE
    };
};
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;
    uint32_t mValue;
    NamedValue(String nm = "", uint32_t 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)                                          \
        {                                                                                                              \
        }                                                                                                              \
    };
 
DECLARE_TYPES
#undef DECLARE_BASE_PVD_TYPE
 
template <typename TDataType>
inline int32_t 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
{
    uint8_t* mBegin;
    uint8_t* mEnd;
    uint8_t* mCapacity; //>= stop
    ArrayData(uint8_t* beg = NULL, uint8_t* end = NULL, uint8_t* cap = NULL) : mBegin(beg), mEnd(end), mCapacity(cap)
    {
    }
    uint8_t* begin()
    {
        return mBegin;
    }
    uint8_t* end()
    {
        return mEnd;
    }
    uint32_t byteCapacity()
    {
        return static_cast<uint32_t>(mCapacity - mBegin);
    }
    uint32_t byteSize() const
    {
        return static_cast<uint32_t>(mEnd - mBegin);
    } // in bytes
    uint32_t numberOfItems(uint32_t objectByteSize)
    {
        if(objectByteSize)
            return byteSize() / objectByteSize;
        return 0;
    }
 
    void forgetData()
    {
        mBegin = mEnd = mCapacity = 0;
    }
};
 
template <typename T>
class DataRef
{
    const T* mBegin;
    const T* mEnd;
 
  public:
    DataRef(const T* b, uint32_t 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;
    }
    uint32_t size() const
    {
        return static_cast<uint32_t>(mEnd - mBegin);
    }
    const T* begin() const
    {
        return mBegin;
    }
    const T* end() const
    {
        return mEnd;
    }
    const T& operator[](uint32_t idx) const
    {
        PX_ASSERT(idx < size());
        return mBegin[idx];
    }
    const T& back() const
    {
        PX_ASSERT(mEnd > mBegin);
        return *(mEnd - 1);
    }
};
 
struct PropertyType
{
    enum Enum
    {
        Unknown = 0,
        Scalar,
        Array
    };
};
 
// argument to the create property message function
struct PropertyMessageArg
{
    String mPropertyName;
    NamespacedName mDatatypeName;
    // where in the message this property starts.
    uint32_t mMessageOffset;
    // size of this entry object
    uint32_t mByteSize;
 
    PropertyMessageArg(String propName, NamespacedName dtype, uint32_t msgOffset, uint32_t byteSize)
    : mPropertyName(propName), mDatatypeName(dtype), mMessageOffset(msgOffset), mByteSize(byteSize)
    {
    }
    PropertyMessageArg() : mPropertyName(""), mMessageOffset(0), mByteSize(0)
    {
    }
};
 
class PvdUserRenderer;
DEFINE_PVD_TYPE_NAME_MAP(PvdUserRenderer, "_debugger_", "PvdUserRenderer")
 
#if !PX_DOXYGEN
}
}
#endif
 
#endif