988 lines
25 KiB
C++
988 lines
25 KiB
C++
// 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_COMM_STREAM_EVENTS_H
|
|
#define PX_PVD_COMM_STREAM_EVENTS_H
|
|
|
|
#include "foundation/PxVec3.h"
|
|
#include "foundation/PxFlags.h"
|
|
#include "foundation/PxTime.h"
|
|
|
|
#include "PxPvdObjectModelBaseTypes.h"
|
|
|
|
namespace physx
|
|
{
|
|
namespace pvdsdk
|
|
{
|
|
|
|
struct CommStreamFlagTypes
|
|
{
|
|
enum Enum
|
|
{
|
|
Is64BitPtr = 1
|
|
};
|
|
};
|
|
|
|
typedef PxFlags<CommStreamFlagTypes::Enum, uint32_t> CommStreamFlags;
|
|
|
|
template <typename TDataType>
|
|
struct PvdCommVariableSizedEventCheck
|
|
{
|
|
bool variable_size_check;
|
|
};
|
|
|
|
// Pick out the events that are possibly very large.
|
|
// This helps us keep our buffers close to the size the user requested.
|
|
#define DECLARE_TYPE_VARIABLE_SIZED(type) \
|
|
template <> \
|
|
struct PvdCommVariableSizedEventCheck<type> \
|
|
{ \
|
|
uint32_t variable_size_check; \
|
|
};
|
|
|
|
struct NameHandleValue;
|
|
struct StreamPropMessageArg;
|
|
struct StringHandleEvent;
|
|
struct CreateClass;
|
|
struct DeriveClass;
|
|
struct CreateProperty;
|
|
struct CreatePropertyMessage;
|
|
struct CreateInstance;
|
|
struct SetPropertyValue;
|
|
struct BeginSetPropertyValue;
|
|
struct AppendPropertyValueData;
|
|
struct EndSetPropertyValue;
|
|
struct SetPropertyMessage;
|
|
struct BeginPropertyMessageGroup;
|
|
struct SendPropertyMessageFromGroup;
|
|
struct EndPropertyMessageGroup;
|
|
struct CreateDestroyInstanceProperty;
|
|
struct PushBackObjectRef;
|
|
struct RemoveObjectRef;
|
|
struct BeginSection;
|
|
struct EndSection;
|
|
struct SetPickable;
|
|
struct SetColor;
|
|
struct SetIsTopLevel;
|
|
struct SetCamera;
|
|
struct AddProfileZone;
|
|
struct AddProfileZoneEvent;
|
|
struct StreamEndEvent;
|
|
struct ErrorMessage;
|
|
struct OriginShift;
|
|
struct DestroyInstance;
|
|
|
|
#define DECLARE_COMM_STREAM_EVENTS \
|
|
\
|
|
DECLARE_PVD_COMM_STREAM_EVENT(StringHandleEvent) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(CreateClass) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(DeriveClass) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(CreateProperty) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(CreatePropertyMessage) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(CreateInstance) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(SetPropertyValue) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(BeginSetPropertyValue) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(AppendPropertyValueData) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(EndSetPropertyValue) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(SetPropertyMessage) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(BeginPropertyMessageGroup) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(SendPropertyMessageFromGroup) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(EndPropertyMessageGroup) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(DestroyInstance) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(PushBackObjectRef) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(RemoveObjectRef) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(BeginSection) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(EndSection) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(SetPickable) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(SetColor) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(SetIsTopLevel) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(SetCamera) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(AddProfileZone) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(AddProfileZoneEvent) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(StreamEndEvent) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT(ErrorMessage) \
|
|
DECLARE_PVD_COMM_STREAM_EVENT_NO_COMMA(OriginShift)
|
|
|
|
struct PvdCommStreamEventTypes
|
|
{
|
|
enum Enum
|
|
{
|
|
Unknown = 0,
|
|
#define DECLARE_PVD_COMM_STREAM_EVENT(x) x,
|
|
#define DECLARE_PVD_COMM_STREAM_EVENT_NO_COMMA(x) x
|
|
DECLARE_COMM_STREAM_EVENTS
|
|
#undef DECLARE_PVD_COMM_STREAM_EVENT_NO_COMMA
|
|
#undef DECLARE_PVD_COMM_STREAM_EVENT
|
|
, Last
|
|
};
|
|
};
|
|
|
|
template <typename TDataType>
|
|
struct DatatypeToCommEventType
|
|
{
|
|
bool compile_error;
|
|
};
|
|
template <PvdCommStreamEventTypes::Enum TEnumType>
|
|
struct CommEventTypeToDatatype
|
|
{
|
|
bool compile_error;
|
|
};
|
|
|
|
#define DECLARE_PVD_COMM_STREAM_EVENT(x) \
|
|
template <> \
|
|
struct DatatypeToCommEventType<x> \
|
|
{ \
|
|
enum Enum \
|
|
{ \
|
|
EEventTypeMap = PvdCommStreamEventTypes::x \
|
|
}; \
|
|
}; \
|
|
template <> \
|
|
struct CommEventTypeToDatatype<PvdCommStreamEventTypes::x> \
|
|
{ \
|
|
typedef x TEventType; \
|
|
};
|
|
#define DECLARE_PVD_COMM_STREAM_EVENT_NO_COMMA(x) \
|
|
\
|
|
template<> struct DatatypeToCommEventType<x> \
|
|
{ \
|
|
enum Enum \
|
|
{ \
|
|
EEventTypeMap = PvdCommStreamEventTypes::x \
|
|
}; \
|
|
}; \
|
|
\
|
|
template<> struct CommEventTypeToDatatype<PvdCommStreamEventTypes::x> \
|
|
{ \
|
|
typedef x TEventType; \
|
|
};
|
|
|
|
DECLARE_COMM_STREAM_EVENTS
|
|
#undef DECLARE_PVD_COMM_STREAM_EVENT_NO_COMMA
|
|
#undef DECLARE_PVD_COMM_STREAM_EVENT
|
|
|
|
template <typename TDataType>
|
|
PvdCommStreamEventTypes::Enum getCommStreamEventType()
|
|
{
|
|
return static_cast<PvdCommStreamEventTypes::Enum>(DatatypeToCommEventType<TDataType>::EEventTypeMap);
|
|
}
|
|
|
|
struct StreamNamespacedName
|
|
{
|
|
StringHandle mNamespace; // StringHandle handles
|
|
StringHandle mName;
|
|
StreamNamespacedName(StringHandle ns = 0, StringHandle nm = 0) : mNamespace(ns), mName(nm)
|
|
{
|
|
}
|
|
};
|
|
|
|
class EventSerializeable;
|
|
|
|
class PvdEventSerializer
|
|
{
|
|
protected:
|
|
virtual ~PvdEventSerializer()
|
|
{
|
|
}
|
|
|
|
public:
|
|
virtual void streamify(uint8_t& val) = 0;
|
|
virtual void streamify(uint16_t& val) = 0;
|
|
virtual void streamify(uint32_t& val) = 0;
|
|
virtual void streamify(float& val) = 0;
|
|
virtual void streamify(uint64_t& val) = 0;
|
|
virtual void streamify(String& val) = 0;
|
|
virtual void streamify(DataRef<const uint8_t>& data) = 0;
|
|
virtual void streamify(DataRef<NameHandleValue>& data) = 0;
|
|
virtual void streamify(DataRef<StreamPropMessageArg>& data) = 0;
|
|
virtual void streamify(DataRef<StringHandle>& data) = 0;
|
|
|
|
void streamify(StringHandle& hdl)
|
|
{
|
|
streamify(hdl.mHandle);
|
|
}
|
|
void streamify(CommStreamFlags& flags)
|
|
{
|
|
uint32_t val(flags);
|
|
streamify(val);
|
|
flags = CommStreamFlags(val);
|
|
}
|
|
|
|
void streamify(PvdCommStreamEventTypes::Enum& val)
|
|
{
|
|
uint8_t detyped = static_cast<uint8_t>(val);
|
|
streamify(detyped);
|
|
val = static_cast<PvdCommStreamEventTypes::Enum>(detyped);
|
|
}
|
|
void streamify(PropertyType::Enum& val)
|
|
{
|
|
uint8_t detyped = static_cast<uint8_t>(val);
|
|
streamify(detyped);
|
|
val = static_cast<PropertyType::Enum>(detyped);
|
|
}
|
|
|
|
void streamify(bool& val)
|
|
{
|
|
uint8_t detyped = uint8_t(val ? 1 : 0);
|
|
streamify(detyped);
|
|
val = detyped ? true : false;
|
|
}
|
|
|
|
void streamify(StreamNamespacedName& name)
|
|
{
|
|
streamify(name.mNamespace);
|
|
streamify(name.mName);
|
|
}
|
|
|
|
void streamify(PvdColor& color)
|
|
{
|
|
streamify(color.r);
|
|
streamify(color.g);
|
|
streamify(color.b);
|
|
streamify(color.a);
|
|
}
|
|
|
|
void streamify(PxVec3& vec)
|
|
{
|
|
streamify(vec.x);
|
|
streamify(vec.y);
|
|
streamify(vec.z);
|
|
}
|
|
|
|
static uint32_t measure(const EventSerializeable& evt);
|
|
};
|
|
|
|
class EventSerializeable
|
|
{
|
|
protected:
|
|
virtual ~EventSerializeable()
|
|
{
|
|
}
|
|
|
|
public:
|
|
virtual void serialize(PvdEventSerializer& serializer) = 0;
|
|
};
|
|
|
|
/** Numbers generated from random.org
|
|
129919156 17973702 401496246 144984007 336950759
|
|
907025328 837150850 679717896 601529147 269478202
|
|
*/
|
|
struct StreamInitialization : public EventSerializeable
|
|
{
|
|
static uint32_t getStreamId()
|
|
{
|
|
return 837150850;
|
|
}
|
|
static uint32_t getStreamVersion()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
uint32_t mStreamId;
|
|
uint32_t mStreamVersion;
|
|
uint64_t mTimestampNumerator;
|
|
uint64_t mTimestampDenominator;
|
|
CommStreamFlags mStreamFlags;
|
|
StreamInitialization()
|
|
: mStreamId(getStreamId())
|
|
, mStreamVersion(getStreamVersion())
|
|
, mTimestampNumerator(physx::PxTime::getCounterFrequency().mNumerator * 10)
|
|
, mTimestampDenominator(physx::PxTime::getCounterFrequency().mDenominator)
|
|
, mStreamFlags(sizeof(void*) == 4 ? 0 : 1)
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mStreamId);
|
|
s.streamify(mStreamVersion);
|
|
s.streamify(mTimestampNumerator);
|
|
s.streamify(mTimestampDenominator);
|
|
s.streamify(mStreamFlags);
|
|
}
|
|
};
|
|
|
|
struct EventGroup : public EventSerializeable
|
|
{
|
|
uint32_t mDataSize; // in bytes, data directly follows this header
|
|
uint32_t mNumEvents;
|
|
uint64_t mStreamId;
|
|
uint64_t mTimestamp;
|
|
|
|
EventGroup(uint32_t dataSize = 0, uint32_t numEvents = 0, uint64_t streamId = 0, uint64_t ts = 0)
|
|
: mDataSize(dataSize), mNumEvents(numEvents), mStreamId(streamId), mTimestamp(ts)
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mDataSize);
|
|
s.streamify(mNumEvents);
|
|
s.streamify(mStreamId);
|
|
s.streamify(mTimestamp);
|
|
}
|
|
};
|
|
|
|
struct StringHandleEvent : public EventSerializeable
|
|
{
|
|
String mString;
|
|
uint32_t mHandle;
|
|
StringHandleEvent(String str, uint32_t hdl) : mString(str), mHandle(hdl)
|
|
{
|
|
}
|
|
StringHandleEvent()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mString);
|
|
s.streamify(mHandle);
|
|
}
|
|
};
|
|
|
|
DECLARE_TYPE_VARIABLE_SIZED(StringHandleEvent)
|
|
|
|
typedef uint64_t Timestamp;
|
|
|
|
struct CreateClass : public EventSerializeable
|
|
{
|
|
StreamNamespacedName mName;
|
|
CreateClass(StreamNamespacedName nm) : mName(nm)
|
|
{
|
|
}
|
|
CreateClass()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mName);
|
|
}
|
|
};
|
|
|
|
struct DeriveClass : public EventSerializeable
|
|
{
|
|
StreamNamespacedName mParent;
|
|
StreamNamespacedName mChild;
|
|
|
|
DeriveClass(StreamNamespacedName p, StreamNamespacedName c) : mParent(p), mChild(c)
|
|
{
|
|
}
|
|
DeriveClass()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mParent);
|
|
s.streamify(mChild);
|
|
}
|
|
};
|
|
|
|
struct NameHandleValue : public EventSerializeable
|
|
{
|
|
StringHandle mName;
|
|
uint32_t mValue;
|
|
NameHandleValue(StringHandle name, uint32_t val) : mName(name), mValue(val)
|
|
{
|
|
}
|
|
NameHandleValue()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mName);
|
|
s.streamify(mValue);
|
|
}
|
|
};
|
|
/*virtual PvdError createProperty( StreamNamespacedName clsName, StringHandle name, StringHandle semantic
|
|
, StreamNamespacedName dtypeName, PropertyType::Enum propertyType
|
|
, DataRef<NamedValue> values = DataRef<NamedValue>() ) = 0; */
|
|
struct CreateProperty : public EventSerializeable
|
|
{
|
|
StreamNamespacedName mClass;
|
|
StringHandle mName;
|
|
StringHandle mSemantic;
|
|
StreamNamespacedName mDatatypeName;
|
|
PropertyType::Enum mPropertyType;
|
|
DataRef<NameHandleValue> mValues;
|
|
|
|
CreateProperty(StreamNamespacedName cls, StringHandle name, StringHandle semantic, StreamNamespacedName dtypeName,
|
|
PropertyType::Enum ptype, DataRef<NameHandleValue> values)
|
|
: mClass(cls), mName(name), mSemantic(semantic), mDatatypeName(dtypeName), mPropertyType(ptype), mValues(values)
|
|
{
|
|
}
|
|
CreateProperty()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mClass);
|
|
s.streamify(mName);
|
|
s.streamify(mSemantic);
|
|
s.streamify(mDatatypeName);
|
|
s.streamify(mPropertyType);
|
|
s.streamify(mValues);
|
|
}
|
|
};
|
|
|
|
struct StreamPropMessageArg : public EventSerializeable
|
|
{
|
|
StringHandle mPropertyName;
|
|
StreamNamespacedName mDatatypeName;
|
|
uint32_t mMessageOffset;
|
|
uint32_t mByteSize;
|
|
StreamPropMessageArg(StringHandle pname, StreamNamespacedName dtypeName, uint32_t offset, uint32_t byteSize)
|
|
: mPropertyName(pname), mDatatypeName(dtypeName), mMessageOffset(offset), mByteSize(byteSize)
|
|
{
|
|
}
|
|
|
|
StreamPropMessageArg()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mPropertyName);
|
|
s.streamify(mDatatypeName);
|
|
s.streamify(mMessageOffset);
|
|
s.streamify(mByteSize);
|
|
}
|
|
};
|
|
|
|
/*
|
|
virtual PvdError createPropertyMessage( StreamNamespacedName cls, StreamNamespacedName msgName
|
|
, DataRef<PropertyMessageArg> entries, uint32_t messageSizeInBytes ) =
|
|
0;*/
|
|
struct CreatePropertyMessage : public EventSerializeable
|
|
{
|
|
StreamNamespacedName mClass;
|
|
StreamNamespacedName mMessageName;
|
|
DataRef<StreamPropMessageArg> mMessageEntries;
|
|
uint32_t mMessageByteSize;
|
|
|
|
CreatePropertyMessage(StreamNamespacedName cls, StreamNamespacedName msgName, DataRef<StreamPropMessageArg> propArg,
|
|
uint32_t messageByteSize)
|
|
: mClass(cls), mMessageName(msgName), mMessageEntries(propArg), mMessageByteSize(messageByteSize)
|
|
{
|
|
}
|
|
CreatePropertyMessage()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mClass);
|
|
s.streamify(mMessageName);
|
|
s.streamify(mMessageEntries);
|
|
s.streamify(mMessageByteSize);
|
|
}
|
|
};
|
|
|
|
/**Changing immediate data on instances*/
|
|
|
|
// virtual PvdError createInstance( StreamNamespacedName cls, uint64_t instance ) = 0;
|
|
struct CreateInstance : public EventSerializeable
|
|
{
|
|
StreamNamespacedName mClass;
|
|
uint64_t mInstanceId;
|
|
|
|
CreateInstance(StreamNamespacedName cls, uint64_t streamId) : mClass(cls), mInstanceId(streamId)
|
|
{
|
|
}
|
|
CreateInstance()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mClass);
|
|
s.streamify(mInstanceId);
|
|
}
|
|
};
|
|
|
|
// virtual PvdError setPropertyValue( uint64_t instance, StringHandle name, DataRef<const uint8_t> data,
|
|
// StreamNamespacedName incomingTypeName ) = 0;
|
|
struct SetPropertyValue : public EventSerializeable
|
|
{
|
|
uint64_t mInstanceId;
|
|
StringHandle mPropertyName;
|
|
DataRef<const uint8_t> mData;
|
|
StreamNamespacedName mIncomingTypeName;
|
|
uint32_t mNumItems;
|
|
|
|
SetPropertyValue(uint64_t instance, StringHandle name, DataRef<const uint8_t> data,
|
|
StreamNamespacedName incomingTypeName, uint32_t numItems)
|
|
: mInstanceId(instance), mPropertyName(name), mData(data), mIncomingTypeName(incomingTypeName), mNumItems(numItems)
|
|
{
|
|
}
|
|
|
|
SetPropertyValue()
|
|
{
|
|
}
|
|
|
|
void serializeBeginning(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mInstanceId);
|
|
s.streamify(mPropertyName);
|
|
s.streamify(mIncomingTypeName);
|
|
s.streamify(mNumItems);
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
serializeBeginning(s);
|
|
s.streamify(mData);
|
|
}
|
|
};
|
|
|
|
DECLARE_TYPE_VARIABLE_SIZED(SetPropertyValue)
|
|
|
|
struct BeginSetPropertyValue : public EventSerializeable
|
|
{
|
|
uint64_t mInstanceId;
|
|
StringHandle mPropertyName;
|
|
StreamNamespacedName mIncomingTypeName;
|
|
|
|
BeginSetPropertyValue(uint64_t instance, StringHandle name, StreamNamespacedName incomingTypeName)
|
|
: mInstanceId(instance), mPropertyName(name), mIncomingTypeName(incomingTypeName)
|
|
{
|
|
}
|
|
BeginSetPropertyValue()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mInstanceId);
|
|
s.streamify(mPropertyName);
|
|
s.streamify(mIncomingTypeName);
|
|
}
|
|
};
|
|
|
|
// virtual PvdError appendPropertyValueData( DataRef<const uint8_t> data ) = 0;
|
|
struct AppendPropertyValueData : public EventSerializeable
|
|
{
|
|
DataRef<const uint8_t> mData;
|
|
uint32_t mNumItems;
|
|
AppendPropertyValueData(DataRef<const uint8_t> data, uint32_t numItems) : mData(data), mNumItems(numItems)
|
|
{
|
|
}
|
|
AppendPropertyValueData()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mData);
|
|
s.streamify(mNumItems);
|
|
}
|
|
};
|
|
|
|
DECLARE_TYPE_VARIABLE_SIZED(AppendPropertyValueData)
|
|
|
|
// virtual PvdError endSetPropertyValue() = 0;
|
|
struct EndSetPropertyValue : public EventSerializeable
|
|
{
|
|
EndSetPropertyValue()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer&)
|
|
{
|
|
}
|
|
};
|
|
|
|
// virtual PvdError setPropertyMessage( uint64_t instance, StreamNamespacedName msgName, DataRef<const uint8_t> data ) =
|
|
// 0;
|
|
struct SetPropertyMessage : public EventSerializeable
|
|
{
|
|
uint64_t mInstanceId;
|
|
StreamNamespacedName mMessageName;
|
|
DataRef<const uint8_t> mData;
|
|
|
|
SetPropertyMessage(uint64_t instance, StreamNamespacedName msgName, DataRef<const uint8_t> data)
|
|
: mInstanceId(instance), mMessageName(msgName), mData(data)
|
|
{
|
|
}
|
|
|
|
SetPropertyMessage()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mInstanceId);
|
|
s.streamify(mMessageName);
|
|
s.streamify(mData);
|
|
}
|
|
};
|
|
|
|
DECLARE_TYPE_VARIABLE_SIZED(SetPropertyMessage)
|
|
|
|
// virtual PvdError beginPropertyMessageGroup( StreamNamespacedName msgName ) = 0;
|
|
struct BeginPropertyMessageGroup : public EventSerializeable
|
|
{
|
|
StreamNamespacedName mMsgName;
|
|
BeginPropertyMessageGroup(StreamNamespacedName msgName) : mMsgName(msgName)
|
|
{
|
|
}
|
|
BeginPropertyMessageGroup()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mMsgName);
|
|
}
|
|
};
|
|
|
|
// virtual PvdError sendPropertyMessageFromGroup( uint64_t instance, DataRef<const uint8_t*> data ) = 0;
|
|
struct SendPropertyMessageFromGroup : public EventSerializeable
|
|
{
|
|
uint64_t mInstance;
|
|
DataRef<const uint8_t> mData;
|
|
|
|
SendPropertyMessageFromGroup(uint64_t instance, DataRef<const uint8_t> data) : mInstance(instance), mData(data)
|
|
{
|
|
}
|
|
SendPropertyMessageFromGroup()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mInstance);
|
|
s.streamify(mData);
|
|
}
|
|
};
|
|
|
|
DECLARE_TYPE_VARIABLE_SIZED(SendPropertyMessageFromGroup)
|
|
|
|
// virtual PvdError endPropertyMessageGroup() = 0;
|
|
struct EndPropertyMessageGroup : public EventSerializeable
|
|
{
|
|
EndPropertyMessageGroup()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer&)
|
|
{
|
|
}
|
|
};
|
|
|
|
struct PushBackObjectRef : public EventSerializeable
|
|
{
|
|
uint64_t mInstanceId;
|
|
StringHandle mProperty;
|
|
uint64_t mObjectRef;
|
|
|
|
PushBackObjectRef(uint64_t instId, StringHandle prop, uint64_t objRef)
|
|
: mInstanceId(instId), mProperty(prop), mObjectRef(objRef)
|
|
{
|
|
}
|
|
|
|
PushBackObjectRef()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mInstanceId);
|
|
s.streamify(mProperty);
|
|
s.streamify(mObjectRef);
|
|
}
|
|
};
|
|
|
|
struct RemoveObjectRef : public EventSerializeable
|
|
{
|
|
uint64_t mInstanceId;
|
|
StringHandle mProperty;
|
|
uint64_t mObjectRef;
|
|
|
|
RemoveObjectRef(uint64_t instId, StringHandle prop, uint64_t objRef)
|
|
: mInstanceId(instId), mProperty(prop), mObjectRef(objRef)
|
|
{
|
|
}
|
|
|
|
RemoveObjectRef()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mInstanceId);
|
|
s.streamify(mProperty);
|
|
s.streamify(mObjectRef);
|
|
}
|
|
};
|
|
|
|
// virtual PvdError destroyInstance( uint64_t key ) = 0;
|
|
struct DestroyInstance : public EventSerializeable
|
|
{
|
|
uint64_t mInstanceId;
|
|
DestroyInstance(uint64_t instance) : mInstanceId(instance)
|
|
{
|
|
}
|
|
DestroyInstance()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mInstanceId);
|
|
}
|
|
};
|
|
|
|
// virtual PvdError beginSection( uint64_t sectionId, StringHandle name ) = 0;
|
|
struct BeginSection : public EventSerializeable
|
|
{
|
|
uint64_t mSectionId;
|
|
StringHandle mName;
|
|
Timestamp mTimestamp;
|
|
BeginSection(uint64_t sectionId, StringHandle name, uint64_t timestamp)
|
|
: mSectionId(sectionId), mName(name), mTimestamp(timestamp)
|
|
{
|
|
}
|
|
BeginSection()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mSectionId);
|
|
s.streamify(mName);
|
|
s.streamify(mTimestamp);
|
|
}
|
|
};
|
|
// virtual PvdError endSection( uint64_t sectionId, StringHandle name ) = 0;
|
|
struct EndSection : public EventSerializeable
|
|
{
|
|
uint64_t mSectionId;
|
|
StringHandle mName;
|
|
Timestamp mTimestamp;
|
|
EndSection(uint64_t sectionId, StringHandle name, uint64_t timestamp)
|
|
: mSectionId(sectionId), mName(name), mTimestamp(timestamp)
|
|
{
|
|
}
|
|
EndSection()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mSectionId);
|
|
s.streamify(mName);
|
|
s.streamify(mTimestamp);
|
|
}
|
|
};
|
|
|
|
// virtual void setPickable( void* instance, bool pickable ) = 0;
|
|
struct SetPickable : public EventSerializeable
|
|
{
|
|
uint64_t mInstanceId;
|
|
bool mPickable;
|
|
SetPickable(uint64_t instId, bool pick) : mInstanceId(instId), mPickable(pick)
|
|
{
|
|
}
|
|
SetPickable()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mInstanceId);
|
|
s.streamify(mPickable);
|
|
}
|
|
};
|
|
// virtual void setColor( void* instance, const PvdColor& color ) = 0;
|
|
struct SetColor : public EventSerializeable
|
|
{
|
|
uint64_t mInstanceId;
|
|
PvdColor mColor;
|
|
SetColor(uint64_t instId, PvdColor color) : mInstanceId(instId), mColor(color)
|
|
{
|
|
}
|
|
SetColor()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mInstanceId);
|
|
s.streamify(mColor);
|
|
}
|
|
};
|
|
|
|
// virtual void setColor( void* instance, const PvdColor& color ) = 0;
|
|
struct SetIsTopLevel : public EventSerializeable
|
|
{
|
|
uint64_t mInstanceId;
|
|
bool mIsTopLevel;
|
|
|
|
SetIsTopLevel(uint64_t instId, bool topLevel) : mInstanceId(instId), mIsTopLevel(topLevel)
|
|
{
|
|
}
|
|
SetIsTopLevel() : mIsTopLevel(false)
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mInstanceId);
|
|
s.streamify(mIsTopLevel);
|
|
}
|
|
};
|
|
|
|
struct SetCamera : public EventSerializeable
|
|
{
|
|
String mName;
|
|
PxVec3 mPosition;
|
|
PxVec3 mUp;
|
|
PxVec3 mTarget;
|
|
SetCamera(String name, const PxVec3& pos, const PxVec3& up, const PxVec3& target)
|
|
: mName(name), mPosition(pos), mUp(up), mTarget(target)
|
|
{
|
|
}
|
|
SetCamera() : mName(NULL)
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mName);
|
|
s.streamify(mPosition);
|
|
s.streamify(mUp);
|
|
s.streamify(mTarget);
|
|
}
|
|
};
|
|
|
|
struct ErrorMessage : public EventSerializeable
|
|
{
|
|
uint32_t mCode;
|
|
String mMessage;
|
|
String mFile;
|
|
uint32_t mLine;
|
|
|
|
ErrorMessage(uint32_t code, String message, String file, uint32_t line)
|
|
: mCode(code), mMessage(message), mFile(file), mLine(line)
|
|
{
|
|
}
|
|
|
|
ErrorMessage() : mMessage(NULL), mFile(NULL)
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mCode);
|
|
s.streamify(mMessage);
|
|
s.streamify(mFile);
|
|
s.streamify(mLine);
|
|
}
|
|
};
|
|
|
|
struct AddProfileZone : public EventSerializeable
|
|
{
|
|
uint64_t mInstanceId;
|
|
String mName;
|
|
AddProfileZone(uint64_t iid, String nm) : mInstanceId(iid), mName(nm)
|
|
{
|
|
}
|
|
AddProfileZone() : mName(NULL)
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mInstanceId);
|
|
s.streamify(mName);
|
|
}
|
|
};
|
|
|
|
struct AddProfileZoneEvent : public EventSerializeable
|
|
{
|
|
uint64_t mInstanceId;
|
|
String mName;
|
|
uint16_t mEventId;
|
|
bool mCompileTimeEnabled;
|
|
AddProfileZoneEvent(uint64_t iid, String nm, uint16_t eid, bool cte)
|
|
: mInstanceId(iid), mName(nm), mEventId(eid), mCompileTimeEnabled(cte)
|
|
{
|
|
}
|
|
AddProfileZoneEvent()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mInstanceId);
|
|
s.streamify(mName);
|
|
s.streamify(mEventId);
|
|
s.streamify(mCompileTimeEnabled);
|
|
}
|
|
};
|
|
|
|
struct StreamEndEvent : public EventSerializeable
|
|
{
|
|
String mName;
|
|
StreamEndEvent() : mName("StreamEnd")
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mName);
|
|
}
|
|
};
|
|
|
|
struct OriginShift : public EventSerializeable
|
|
{
|
|
uint64_t mInstanceId;
|
|
PxVec3 mShift;
|
|
|
|
OriginShift(uint64_t iid, const PxVec3& shift) : mInstanceId(iid), mShift(shift)
|
|
{
|
|
}
|
|
OriginShift()
|
|
{
|
|
}
|
|
|
|
void serialize(PvdEventSerializer& s)
|
|
{
|
|
s.streamify(mInstanceId);
|
|
s.streamify(mShift);
|
|
}
|
|
};
|
|
} // pvdsdk
|
|
} // physx
|
|
|
|
#endif
|
|
|