EntropyEngine::Networking::NetworkSession

EntropyEngine::Networking::NetworkSession

NetworkSession - High-level session that manages a peer connection. More…

#include <NetworkSession.h>

Inherits from EntropyEngine::Core::EntropyObject

Public Classes

	Name
struct	TextureMetadataData
struct	ShaderParameterDefData
struct	ShaderModuleData Shader module for network transfer.
struct	ShaderMetadataData
struct	PropertyRegistrationInfo Property registration info passed with EntityCreated callback.
struct	PropertyBatchStats
struct	MaterialPropertyData
struct	MaterialAssetData
struct	GetShaderResponseData Get shader response data.
class	EntityBuilder Builder for creating entities with components in ECS style.
class	ComponentHandle Component attachment on an entity, allows setting property values.
struct	ComponentGroupData Component group data for wire protocol - groups properties under a component.
struct	AssetUploadCompleteResponseData
struct	AssetUploadCompleteData
struct	AssetUploadChunkResponseData
struct	AssetUploadChunkData
struct	AssetUploadBeginResponseData
struct	AssetUploadBeginData
struct	AssetResolveResponseData
struct	AssetMetadataData
struct	AssetEntryData

Public Types

	Name
using std::function< void(bool success, uint64_t newVersion, const std::string &errorMessage)>	UpdateMaterialPropertyResponseCallback
using std::function< void(const std::array< uint8_t, 32 > &materialId, const std::string &propertyName, const PropertyValue &value, uint64_t requestId)>	UpdateMaterialPropertyCallback
using std::function< void(bool success, uint64_t newVersion, const std::string &errorMessage)>	UpdateMaterialPropertiesBatchResponseCallback
using std::function< void(const std::array< uint8_t, 32 > &materialId, const std::vector< MaterialPropertyData > &properties, uint64_t requestId)>	UpdateMaterialPropertiesBatchCallback
using std::function< void(bool success, const std::string &errorMessage)>	UnpublishSchemaResponseCallback
using std::function< void(bool success, const std::string &errorMessage)>	SetSceneEnabledResponseCallback
using std::function< void(uint64_t sceneId, bool enabled)>	SetSceneEnabledCallback
using std::function< void(ComponentTypeHash typeHash, const std::string &reason, uint64_t timestamp)>	SchemaNackCallback
using std::function< void(ComponentTypeHash typeHash, const std::string &appId, const std::string &componentName, uint32_t schemaVersion)>	SchemaAdvertisementCallback
using std::function< void(const std::vector< uint8_t > &data)>	SceneSnapshotCallback
using std::function< void(bool success, const std::string &errorMessage)>	RegisterSchemaResponseCallback
using std::function< void(const std::vector< ComponentSchema > &schemas)>	QueryPublicSchemasResponseCallback
using std::function< void(bool success, const std::string &errorMessage)>	PublishSchemaResponseCallback
using std::function< void(const std::vector< uint8_t > &data)>	PropertyUpdateCallback
using std::function< void( uint64_t entityId, const std::vector< std::array< uint8_t, 32 > > &materialIds, uint64_t originSessionId)>	MeshMaterialBindingUpdateCallback
using std::function< void(bool success, const std::string &errorMessage, uint64_t requestId)>	MeshMaterialBindingResponseCallback
using std::function< void( uint64_t entityId, const std::vector< std::array< uint8_t, 32 > > &materialIds, uint64_t requestId)>	MeshMaterialBindingCallback
using std::function< void(bool success, const std::string &errorMessage)>	MaterialUnsubscribeResponseCallback
using std::function< void(const std::array< uint8_t, 32 > &materialId, uint64_t requestId)>	MaterialUnsubscribeCallback
using std::function< void(bool success, const MaterialAssetData &material, const std::string &errorMessage, uint64_t requestId)>	MaterialSubscribeResponseCallback
using std::function< void(const std::array< uint8_t, 32 > &materialId, uint64_t requestId)>	MaterialSubscribeCallback
using std::function< void(const std::array< uint8_t, 32 > &materialId, const MaterialAssetData &material)>	MaterialResolvedCallback
using std::function< void(const std::array< uint8_t, 32 > &materialId, const std::string &propertyName, const PropertyValue &value, uint64_t newVersion, uint64_t originSessionId)>	MaterialPropertyUpdateCallback
using std::function< void(uint64_t clientTimestamp, uint64_t serverTime)>	HeartbeatResponseCallback
using std::function< void(uint64_t timestamp)>	HeartbeatCallback
using std::function< void(const std::string &clientType, const std::string &clientId)>	HandshakeCallback
using std::function< void(const GetShaderResponseData &response, uint64_t requestId)>	GetShaderResponseCallback
using std::function< void(const std::array< uint8_t, 32 > &shaderAssetId, uint64_t requestId)>	GetShaderCallback
using std::function< void(bool success, const MaterialAssetData &material, const std::string &errorMessage)>	GetMaterialResponseCallback
using std::function< void(const std::array< uint8_t, 32 > &materialId, uint64_t requestId)>	GetMaterialCallback
using std::function< void(NetworkError error, const std::string &message)>	ErrorCallback
using std::function< void(uint64_t entityId)>	EntityDestroyedCallback
using std::function< void( uint64_t entityId, const std::string &appId, const std::string &typeName, uint64_t parentId, const std::vector< ComponentGroupData > &components, uint64_t targetSceneId, const std::string &entityName)>	EntityCreatedCallback
using std::function< void(ConnectionState state, const std::string &reason)>	DisconnectCallback
using std::function< void(bool success, const std::string &errorMessage)>	DestroySceneResponseCallback
using std::function< void(uint64_t sceneId)>	DestroySceneCallback
using std::function< void(bool success, uint64_t sceneId, const std::string &errorMessage)>	CreateSceneResponseCallback
using std::function< void(const std::string &sceneName, bool transient)>	CreateSceneCallback
using std::function< void(bool success, const std::array< uint8_t, 32 > &materialId, const std::string &errorMessage, uint64_t requestId)>	CreateMaterialResponseCallback
using std::function< void(const MaterialAssetData &material, uint64_t requestId)>	CreateMaterialCallback
using std::function< void(bool success, uint32_t removedCount, const std::string &errorMessage, uint64_t requestId)>	AssetWithdrawResponseCallback
using std::function< void(const std::vector< std::array< uint8_t, 32 > > &assetIds, uint64_t requestId)>	AssetWithdrawCallback
using std::function< void(bool success, uint32_t removedCount, const std::string &errorMessage, uint64_t requestId)>	AssetWithdrawAllResponseCallback
using std::function< void(const std::string &appId, uint64_t requestId)>	AssetWithdrawAllCallback
using std::function< void(bool success, const std::array< uint8_t, 32 > &assetId, const std::string &uri, const std::string &errorMessage, uint64_t requestId)>	AssetUploadResponseCallback
using std::function< void(const AssetUploadCompleteResponseData &data)>	AssetUploadCompleteResponseCallback
using std::function< void(const AssetUploadCompleteData &data)>	AssetUploadCompleteCallback
using std::function< void(const AssetUploadChunkResponseData &data)>	AssetUploadChunkResponseCallback
using std::function< void(const AssetUploadChunkData &data)>	AssetUploadChunkCallback
using std::function< void(bool success, const std::string &errorMessage)>	AssetUploadCancelResponseCallback
using std::function< void(const std::array< uint8_t, 16 > &uploadId)>	AssetUploadCancelCallback
using std::function< void(const std::string &appId, const std::vector< uint8_t > &data, uint8_t contentType, bool persistent, uint64_t requestId, const AssetMetadataData &metadata)>	AssetUploadCallback
using std::function< void(const AssetUploadBeginResponseData &data)>	AssetUploadBeginResponseCallback
using std::function< void(const AssetUploadBeginData &data)>	AssetUploadBeginCallback
using std::function< void(const AssetResolveResponseData &response)>	AssetResolveResponseCallback
using std::function< void(const std::array< uint8_t, 32 > &assetId, uint64_t requestId)>	AssetResolveCallback
using std::function< void(const std::vector< AssetResolveResponseData > &responses, uint64_t requestId)>	AssetResolveBatchResponseCallback
using std::function< void(const std::vector< std::array< uint8_t, 32 > > &assetIds, uint64_t requestId)>	AssetResolveBatchCallback
using std::function< void(bool success, const std::string &errorMessage, uint64_t requestId)>	AssetProvideKeyResponseCallback
using std::function< void(const std::array< uint8_t, 32 > &assetId, const std::array< uint8_t, 32 > &key, uint64_t requestId)>	AssetProvideKeyCallback
enum class uint8_t	AssetMetadataType { Texture = 2, Shader = 1, None = 0}
using std::function< void(bool found, const AssetMetadataData &metadata, uint64_t requestId)>	AssetMetadataResponseCallback
using std::function< void(const std::array< uint8_t, 32 > &assetId, uint64_t requestId)>	AssetMetadataCallback
using std::function< void(bool found, const std::vector< uint8_t > &data, const std::string &errorMessage, uint64_t requestId)>	AssetFetchResponseCallback
using std::function< void(const std::array< uint8_t, 32 > &assetId, uint64_t requestId)>	AssetFetchCallback
using std::function< void(bool success, const std::string &errorMessage, uint64_t requestId)>	AssetAdvertiseResponseCallback
using std::function< void(const std::string &appId, const std::vector< AssetEntryData > &entries, uint64_t requestId)>	AssetAdvertiseCallback
using std::function< void(bool success, const std::string &errorMessage)>	AddEntityToSceneResponseCallback
using std::function< void(uint64_t entityId, uint64_t sceneId)>	AddEntityToSceneCallback

Public Functions

	Name
	~NetworkSession() override
bool	supportsMultipleChannels() const
void	setupCallbacks() Set up connection callbacks to route messages to this session.
void	setUpdateMaterialPropertyResponseCallback(UpdateMaterialPropertyResponseCallback callback)
void	setUpdateMaterialPropertyCallback(UpdateMaterialPropertyCallback callback)
void	setUpdateMaterialPropertiesBatchResponseCallback(UpdateMaterialPropertiesBatchResponseCallback callback)
void	setUpdateMaterialPropertiesBatchCallback(UpdateMaterialPropertiesBatchCallback callback)
void	setUnpublishSchemaResponseCallback(UnpublishSchemaResponseCallback callback)
void	setSetSceneEnabledResponseCallback(SetSceneEnabledResponseCallback callback)
void	setSetSceneEnabledCallback(SetSceneEnabledCallback callback)
void	setSchemaNackCallback(SchemaNackCallback callback)
void	setSchemaAdvertisementCallback(SchemaAdvertisementCallback callback)
void	setSceneSnapshotCallback(SceneSnapshotCallback callback)
void	setRegisterSchemaResponseCallback(RegisterSchemaResponseCallback callback)
void	setQueryPublicSchemasResponseCallback(QueryPublicSchemasResponseCallback callback)
void	setPublishSchemaResponseCallback(PublishSchemaResponseCallback callback)
void	setPropertyUpdateCallback(PropertyUpdateCallback callback)
void	setMeshMaterialBindingUpdateCallback(MeshMaterialBindingUpdateCallback callback)
void	setMeshMaterialBindingResponseCallback(MeshMaterialBindingResponseCallback callback)
void	setMeshMaterialBindingCallback(MeshMaterialBindingCallback callback)
void	setMaterialUnsubscribeResponseCallback(MaterialUnsubscribeResponseCallback callback)
void	setMaterialUnsubscribeCallback(MaterialUnsubscribeCallback callback)
void	setMaterialSubscribeResponseCallback(MaterialSubscribeResponseCallback callback)
void	setMaterialSubscribeCallback(MaterialSubscribeCallback callback)
void	setMaterialResolvedCallback(MaterialResolvedCallback callback)
void	setMaterialPropertyUpdateCallback(MaterialPropertyUpdateCallback callback)
void	setHeartbeatResponseCallback(HeartbeatResponseCallback callback)
void	setHeartbeatCallback(HeartbeatCallback callback)
void	setHandshakeCallback(HandshakeCallback callback)
void	setGetShaderResponseCallback(GetShaderResponseCallback callback)
void	setGetShaderCallback(GetShaderCallback callback)
void	setGetMaterialResponseCallback(GetMaterialResponseCallback callback)
void	setGetMaterialCallback(GetMaterialCallback callback)
void	setErrorCallback(ErrorCallback callback)
void	setEntityDestroyedCallback(EntityDestroyedCallback callback)
void	setEntityCreatedCallback(EntityCreatedCallback callback)
void	setDisconnectCallback(DisconnectCallback callback)
void	setDestroySceneResponseCallback(DestroySceneResponseCallback callback)
void	setDestroySceneCallback(DestroySceneCallback callback)
void	setCreateSceneResponseCallback(CreateSceneResponseCallback callback)
void	setCreateSceneCallback(CreateSceneCallback callback)
void	setCreateMaterialResponseCallback(CreateMaterialResponseCallback callback)
void	setCreateMaterialCallback(CreateMaterialCallback callback)
void	setBatchingEnabled(bool enabled)
void	setAssetWithdrawResponseCallback(AssetWithdrawResponseCallback callback)
void	setAssetWithdrawCallback(AssetWithdrawCallback callback)
void	setAssetWithdrawAllResponseCallback(AssetWithdrawAllResponseCallback callback)
void	setAssetWithdrawAllCallback(AssetWithdrawAllCallback callback)
void	setAssetUploadResponseCallback(AssetUploadResponseCallback callback)
void	setAssetUploadCompleteResponseCallback(AssetUploadCompleteResponseCallback callback)
void	setAssetUploadCompleteCallback(AssetUploadCompleteCallback callback)
void	setAssetUploadChunkResponseCallback(AssetUploadChunkResponseCallback callback)
void	setAssetUploadChunkCallback(AssetUploadChunkCallback callback)
void	setAssetUploadCancelResponseCallback(AssetUploadCancelResponseCallback callback)
void	setAssetUploadCancelCallback(AssetUploadCancelCallback callback)
void	setAssetUploadCallback(AssetUploadCallback callback)
void	setAssetUploadBeginResponseCallback(AssetUploadBeginResponseCallback callback)
void	setAssetUploadBeginCallback(AssetUploadBeginCallback callback)
void	setAssetResolveResponseCallback(AssetResolveResponseCallback callback)
void	setAssetResolveCallback(AssetResolveCallback callback)
void	setAssetResolveBatchResponseCallback(AssetResolveBatchResponseCallback callback)
void	setAssetResolveBatchCallback(AssetResolveBatchCallback callback)
void	setAssetProvideKeyResponseCallback(AssetProvideKeyResponseCallback callback)
void	setAssetProvideKeyCallback(AssetProvideKeyCallback callback)
void	setAssetMetadataResponseCallback(AssetMetadataResponseCallback callback)
void	setAssetMetadataCallback(AssetMetadataCallback callback)
void	setAssetFetchResponseCallback(AssetFetchResponseCallback callback)
void	setAssetFetchCallback(AssetFetchCallback callback)
void	setAssetAdvertiseResponseCallback(AssetAdvertiseResponseCallback callback)
void	setAssetAdvertiseCallback(AssetAdvertiseCallback callback)
void	setAddEntityToSceneResponseCallback(AddEntityToSceneResponseCallback callback)
void	setAddEntityToSceneCallback(AddEntityToSceneCallback callback)
Result< void >	sendUpdateMaterialPropertyResponse(bool success, uint64_t newVersion, const std::string & errorMessage)
Result< void >	sendUpdateMaterialPropertyRequest(const std::array< uint8_t, 32 > & materialId, const std::string & propertyName, const PropertyValue & value, uint64_t requestId =0)
Result< void >	sendUpdateMaterialPropertiesBatchResponse(bool success, uint64_t newVersion, const std::string & errorMessage)
Result< void >	sendUpdateMaterialPropertiesBatchRequest(const std::array< uint8_t, 32 > & materialId, const std::vector< MaterialPropertyData > & properties, uint64_t requestId =0)
Result< void >	sendUnpublishSchema(ComponentTypeHash typeHash)
Result< void >	sendSetSceneEnabledResponse(bool success, const std::string & errorMessage)
Result< void >	sendSetSceneEnabledRequest(uint64_t sceneId, bool enabled)
Result< void >	sendSchemaNack(ComponentTypeHash typeHash, const std::string & reason) Send NACK for unknown schema (optional feedback).
Result< void >	sendSchemaAdvertisement(ComponentTypeHash typeHash, const std::string & appId, const std::string & componentName, uint32_t schemaVersion)
Result< void >	sendSceneSnapshot(const std::vector< uint8_t > & snapshotData)
Result< void >	sendRegisterSchema(const ComponentSchema & schema)
Result< void >	sendQueryPublicSchemas()
Result< void >	sendPublishSchema(ComponentTypeHash typeHash)
Result< void >	sendPropertyUpdateBatch(const std::vector< uint8_t > & batchData)
Result< void >	sendPropertyUpdate(PropertyHash hash, PropertyType type, const PropertyValue & value)
Result< void >	sendMeshMaterialBindingUpdate(uint64_t entityId, const std::vector< std::array< uint8_t, 32 > > & materialIds, uint64_t originSessionId)
Result< void >	sendMeshMaterialBindingResponse(bool success, const std::string & errorMessage, uint64_t requestId =0)
Result< void >	sendMeshMaterialBindingRequest(uint64_t entityId, const std::vector< std::array< uint8_t, 32 > > & materialIds, uint64_t requestId =0)
Result< void >	sendMaterialUnsubscribeResponse(bool success, const std::string & errorMessage)
Result< void >	sendMaterialUnsubscribeRequest(const std::array< uint8_t, 32 > & materialId, uint64_t requestId =0)
Result< void >	sendMaterialSubscribeResponse(bool success, const MaterialAssetData & material, const std::string & errorMessage, uint64_t requestId =0)
Result< void >	sendMaterialSubscribeRequest(const std::array< uint8_t, 32 > & materialId, uint64_t requestId =0)
Result< void >	sendMaterialResolved(const std::array< uint8_t, 32 > & materialId, const MaterialAssetData & material)
Result< void >	sendMaterialPropertyUpdate(const std::array< uint8_t, 32 > & materialId, const std::string & propertyName, const PropertyValue & value, uint64_t newVersion, uint64_t originSessionId)
Result< void >	sendHeartbeatResponse(uint64_t clientTimestamp)
Result< void >	sendHeartbeat()
Result< void >	sendGetShaderResponse(const GetShaderResponseData & response, uint64_t requestId =0)
Result< void >	sendGetShaderRequest(const std::array< uint8_t, 32 > & shaderAssetId, uint64_t requestId =0)
Result< void >	sendGetMaterialResponse(bool success, const MaterialAssetData & material, const std::string & errorMessage)
Result< void >	sendGetMaterialRequest(const std::array< uint8_t, 32 > & materialId, uint64_t requestId =0)
Result< void >	sendEntityDestroyed(uint64_t entityId)
Result< void >	sendEntityCreated(uint64_t entityId, const std::string & appId, const std::string & typeName, uint64_t parentId, const std::vector< ComponentGroupData > & components ={}, uint64_t targetSceneId =0, const std::string & entityName ="")
Result< void >	sendDestroySceneResponse(bool success, const std::string & errorMessage)
Result< void >	sendDestroySceneRequest(uint64_t sceneId)
Result< void >	sendCreateSceneResponse(bool success, uint64_t sceneId, const std::string & errorMessage)
Result< void >	sendCreateSceneRequest(const std::string & sceneName, bool transient)
Result< void >	sendCreateMaterialResponse(bool success, const std::array< uint8_t, 32 > & materialId, const std::string & errorMessage, uint64_t requestId =0)
Result< void >	sendCreateMaterialRequest(const MaterialAssetData & material, uint64_t requestId =0)
Result< void >	sendComponentRemoved(uint64_t entityId, ComponentTypeHash typeHash)
Result< void >	sendComponentAdded(uint64_t entityId, const ComponentGroupData & component)
Result< void >	sendAssetWithdrawResponse(bool success, uint32_t removedCount, const std::string & errorMessage, uint64_t requestId =0)
Result< void >	sendAssetWithdrawAllResponse(bool success, uint32_t removedCount, const std::string & errorMessage, uint64_t requestId =0)
Result< void >	sendAssetWithdrawAll(const std::string & appId, uint64_t requestId =0)
Result< void >	sendAssetWithdraw(const std::vector< std::array< uint8_t, 32 > > & assetIds, uint64_t requestId =0)
Result< void >	sendAssetUploadResponse(bool success, const std::array< uint8_t, 32 > & assetId, const std::string & uri, const std::string & errorMessage, uint64_t requestId =0)
Result< void >	sendAssetUploadCompleteResponse(const AssetUploadCompleteResponseData & data)
Result< void >	sendAssetUploadComplete(const AssetUploadCompleteData & data)
Result< void >	sendAssetUploadChunkResponse(const AssetUploadChunkResponseData & data)
Result< void >	sendAssetUploadChunk(const AssetUploadChunkData & data)
Result< void >	sendAssetUploadCancelResponse(bool success, const std::string & errorMessage)
Result< void >	sendAssetUploadCancel(const std::array< uint8_t, 16 > & uploadId)
Result< void >	sendAssetUploadBeginResponse(const AssetUploadBeginResponseData & data)
Result< void >	sendAssetUploadBegin(const AssetUploadBeginData & data)
Result< void >	sendAssetUpload(const std::string & appId, const std::vector< uint8_t > & data, uint8_t contentType, bool persistent, uint64_t requestId =0)
Result< void >	sendAssetUpload(const std::string & appId, const std::vector< uint8_t > & data, uint8_t contentType, bool persistent, uint64_t requestId, const AssetMetadataData & metadata)
Result< void >	sendAssetResolveResponse(const AssetResolveResponseData & response)
Result< void >	sendAssetResolveBatchResponse(const std::vector< AssetResolveResponseData > & responses, uint64_t requestId =0)
Result< void >	sendAssetResolveBatch(const std::vector< std::array< uint8_t, 32 > > & assetIds, uint64_t requestId =0)
Result< void >	sendAssetResolve(const std::array< uint8_t, 32 > & assetId, uint64_t requestId =0)
Result< void >	sendAssetProvideKeyResponse(bool success, const std::string & errorMessage, uint64_t requestId =0)
Result< void >	sendAssetProvideKey(const std::array< uint8_t, 32 > & assetId, const std::array< uint8_t, 32 > & key, uint64_t requestId =0)
Result< void >	sendAssetFetchResponse(bool found, const std::vector< uint8_t > & data, const std::string & errorMessage, uint64_t requestId =0)
Result< void >	sendAssetFetch(const std::array< uint8_t, 32 > & assetId, uint64_t requestId =0)
Result< void >	sendAssetAdvertiseResponse(bool success, const std::string & errorMessage, uint64_t requestId =0)
Result< void >	sendAssetAdvertise(const std::string & appId, const std::vector< AssetEntryData > & entries, uint64_t requestId =0)
Result< void >	sendAddEntityToSceneResponse(bool success, const std::string & errorMessage)
Result< void >	sendAddEntityToSceneRequest(uint64_t entityId, uint64_t sceneId)
Result< void >	performHandshake(const std::string & clientType, const std::string & clientId)
Result< void >	openChannel(const std::string & channel)
uint64_t	nextEntityId() Get the next available entity ID.
bool	isHandshakeComplete() const
bool	isConnected() const
bool	isBatchingEnabled() const
uint64_t	getUnknownSchemaDropCount() const
ConnectionStats	getStats() const
ConnectionState	getState() const
const std::string &	getSessionId() const
uint64_t	getSequenceUpdateFailureCount() const
ComponentSchemaRegistry *	getSchemaRegistry()
const ComponentSchemaRegistry *	getSchemaRegistry() const
PropertyRegistry &	getPropertyRegistry()
const PropertyRegistry &	getPropertyRegistry() const
PropertyBatchStats	getPropertyBatchStats() const
size_t	getPendingPropertyUpdateCount() const
uint64_t	getPacketLossEventCount() const
std::chrono::steady_clock::time_point	getLastHeartbeatReceived() const
uint64_t	getDuplicatePacketCount() const
Result< void >	flushPropertyUpdates()
Result< void >	disconnect()
EntityBuilder	createEntity(const std::string & typeName, const std::string & appId =“CanvasEngine”, uint64_t parentId =0) Create a new entity with ECS-style API.
Result< void >	connect()
void	clearCallbacks() Clears all callbacks to prevent invocation during/after destruction.
	NetworkSession(NetworkConnection * connection, PropertyRegistry * externalRegistry =nullptr, ComponentSchemaRegistry * schemaRegistry =nullptr) Construct a NetworkSession.

Friends

	Name
class	SessionManager

Additional inherited members

Protected Classes inherited from EntropyEngine::Core::EntropyObject

	Name
struct	HandleCore Optional handle identity stamped by an owner/registry.

Public Functions inherited from EntropyEngine::Core::EntropyObject

	Name
virtual	~EntropyObject() =default
virtual const TypeSystem::TypeInfo *	typeInfo() const Optional richer type information; may be null.
bool	tryRetain() const Attempts to retain only if the object is still alive.
virtual std::string	toString() const Human-readable short string (class@ptr by default).
void	retain() const Increments the reference count.
void	release() const Decrements the reference count and deletes when it reaches zero.
uint32_t	refCount() const Current reference count (approximate under contention).
EntropyObject &	operator=(const EntropyObject & ) =delete
EntropyObject &	operator=(EntropyObject && ) =delete
bool	hasHandle() const
template <class OwnerT > OwnerT *	handleOwnerAs() const Returns the stamped owner pointer cast to the requested type.
const void *	handleOwner() const
uint32_t	handleIndex() const
uint64_t	handleId() const
uint32_t	handleGeneration() const
WeakControlBlock *	getWeakControlBlock() const Lazily retrieves or creates the weak control block.
virtual std::string	description() const Long-form description; defaults to toString().
virtual std::string	debugString() const Debug-oriented string including refcount and handle when present.
virtual const char *	className() const Runtime class name for diagnostics and reflection.
virtual uint64_t	classHash() const Stable type hash for cross-language identification.
	EntropyObject() =default
	EntropyObject(EntropyObject && ) =delete
	EntropyObject(const EntropyObject & ) =delete

Protected Functions inherited from EntropyEngine::Core::EntropyObject

	Name
void	_setHandleIdentity(void * owner, uint32_t index, uint32_t generation)
void	_clearHandleIdentity()

Protected Attributes inherited from EntropyEngine::Core::EntropyObject

	Name
std::atomic< WeakControlBlock * >	_weakBlock Lazily allocated control block for weak refs.
std::atomic< uint32_t >	_refCount Thread-safe retain/release counter.
struct EntropyEngine::Core::EntropyObject::HandleCore	_handle

Friends inherited from EntropyEngine::Core::EntropyObject

	Name
struct	HandleAccess

Detailed Description

class EntropyEngine::Networking::NetworkSession;

NetworkSession - High-level session that manages a peer connection.

Wraps a NetworkConnection and provides protocol-level functionality:

• Message serialization/deserialization
• Automatic routing (reliable vs unreliable channels)
• Property registry management
• Protocol message callbacks

Public Types Documentation

using UpdateMaterialPropertyResponseCallback

using EntropyEngine::Networking::NetworkSession::UpdateMaterialPropertyResponseCallback =
std::function<void(bool success, uint64_t newVersion, const std::string& errorMessage)>;

using UpdateMaterialPropertyCallback

using EntropyEngine::Networking::NetworkSession::UpdateMaterialPropertyCallback =
std::function<void(const std::array<uint8_t, 32>& materialId, const std::string& propertyName,
                   const PropertyValue& value, uint64_t requestId)>;

using UpdateMaterialPropertiesBatchResponseCallback

using EntropyEngine::Networking::NetworkSession::UpdateMaterialPropertiesBatchResponseCallback =
std::function<void(bool success, uint64_t newVersion, const std::string& errorMessage)>;

using UpdateMaterialPropertiesBatchCallback

using EntropyEngine::Networking::NetworkSession::UpdateMaterialPropertiesBatchCallback =
std::function<void(const std::array<uint8_t, 32>& materialId,
                   const std::vector<MaterialPropertyData>& properties, uint64_t requestId)>;

using UnpublishSchemaResponseCallback

using EntropyEngine::Networking::NetworkSession::UnpublishSchemaResponseCallback = std::function<void(bool success, const std::string& errorMessage)>;

using SetSceneEnabledResponseCallback

using EntropyEngine::Networking::NetworkSession::SetSceneEnabledResponseCallback = std::function<void(bool success, const std::string& errorMessage)>;

using SetSceneEnabledCallback

using EntropyEngine::Networking::NetworkSession::SetSceneEnabledCallback = std::function<void(uint64_t sceneId, bool enabled)>;

using SchemaNackCallback

using EntropyEngine::Networking::NetworkSession::SchemaNackCallback =
std::function<void(ComponentTypeHash typeHash, const std::string& reason, uint64_t timestamp)>;

using SchemaAdvertisementCallback

using EntropyEngine::Networking::NetworkSession::SchemaAdvertisementCallback = std::function<void(ComponentTypeHash typeHash, const std::string& appId,
                                                          const std::string& componentName, uint32_t schemaVersion)>;

using SceneSnapshotCallback

using EntropyEngine::Networking::NetworkSession::SceneSnapshotCallback = std::function<void(const std::vector<uint8_t>& data)>;

using RegisterSchemaResponseCallback

using EntropyEngine::Networking::NetworkSession::RegisterSchemaResponseCallback = std::function<void(bool success, const std::string& errorMessage)>;

using QueryPublicSchemasResponseCallback

using EntropyEngine::Networking::NetworkSession::QueryPublicSchemasResponseCallback = std::function<void(const std::vector<ComponentSchema>& schemas)>;

using PublishSchemaResponseCallback

using EntropyEngine::Networking::NetworkSession::PublishSchemaResponseCallback = std::function<void(bool success, const std::string& errorMessage)>;

using PropertyUpdateCallback

using EntropyEngine::Networking::NetworkSession::PropertyUpdateCallback = std::function<void(const std::vector<uint8_t>& data)>;

using MeshMaterialBindingUpdateCallback

using EntropyEngine::Networking::NetworkSession::MeshMaterialBindingUpdateCallback = std::function<void(
       uint64_t entityId, const std::vector<std::array<uint8_t, 32>>& materialIds, uint64_t originSessionId)>;

using MeshMaterialBindingResponseCallback

using EntropyEngine::Networking::NetworkSession::MeshMaterialBindingResponseCallback =
std::function<void(bool success, const std::string& errorMessage, uint64_t requestId)>;

using MeshMaterialBindingCallback

using EntropyEngine::Networking::NetworkSession::MeshMaterialBindingCallback = std::function<void(
       uint64_t entityId, const std::vector<std::array<uint8_t, 32>>& materialIds, uint64_t requestId)>;

using MaterialUnsubscribeResponseCallback

using EntropyEngine::Networking::NetworkSession::MaterialUnsubscribeResponseCallback = std::function<void(bool success, const std::string& errorMessage)>;

using MaterialUnsubscribeCallback

using EntropyEngine::Networking::NetworkSession::MaterialUnsubscribeCallback =
std::function<void(const std::array<uint8_t, 32>& materialId, uint64_t requestId)>;

using MaterialSubscribeResponseCallback

using EntropyEngine::Networking::NetworkSession::MaterialSubscribeResponseCallback = std::function<void(bool success, const MaterialAssetData& material,
                                                                const std::string& errorMessage, uint64_t requestId)>;

using MaterialSubscribeCallback

using EntropyEngine::Networking::NetworkSession::MaterialSubscribeCallback =
std::function<void(const std::array<uint8_t, 32>& materialId, uint64_t requestId)>;

using MaterialResolvedCallback

using EntropyEngine::Networking::NetworkSession::MaterialResolvedCallback =
std::function<void(const std::array<uint8_t, 32>& materialId, const MaterialAssetData& material)>;

using MaterialPropertyUpdateCallback

using EntropyEngine::Networking::NetworkSession::MaterialPropertyUpdateCallback =
std::function<void(const std::array<uint8_t, 32>& materialId, const std::string& propertyName,
                   const PropertyValue& value, uint64_t newVersion, uint64_t originSessionId)>;

using HeartbeatResponseCallback

using EntropyEngine::Networking::NetworkSession::HeartbeatResponseCallback = std::function<void(uint64_t clientTimestamp, uint64_t serverTime)>;

using HeartbeatCallback

using EntropyEngine::Networking::NetworkSession::HeartbeatCallback = std::function<void(uint64_t timestamp)>;

using HandshakeCallback

using EntropyEngine::Networking::NetworkSession::HandshakeCallback = std::function<void(const std::string& clientType, const std::string& clientId)>;

using GetShaderResponseCallback

using EntropyEngine::Networking::NetworkSession::GetShaderResponseCallback = std::function<void(const GetShaderResponseData& response, uint64_t requestId)>;

using GetShaderCallback

using EntropyEngine::Networking::NetworkSession::GetShaderCallback = std::function<void(const std::array<uint8_t, 32>& shaderAssetId, uint64_t requestId)>;

using GetMaterialResponseCallback

using EntropyEngine::Networking::NetworkSession::GetMaterialResponseCallback =
std::function<void(bool success, const MaterialAssetData& material, const std::string& errorMessage)>;

using GetMaterialCallback

using EntropyEngine::Networking::NetworkSession::GetMaterialCallback = std::function<void(const std::array<uint8_t, 32>& materialId, uint64_t requestId)>;

using ErrorCallback

using EntropyEngine::Networking::NetworkSession::ErrorCallback = std::function<void(NetworkError error, const std::string& message)>;

using EntityDestroyedCallback

using EntropyEngine::Networking::NetworkSession::EntityDestroyedCallback = std::function<void(uint64_t entityId)>;

using EntityCreatedCallback

using EntropyEngine::Networking::NetworkSession::EntityCreatedCallback = std::function<void(
       uint64_t entityId, const std::string& appId, const std::string& typeName, uint64_t parentId,
       const std::vector<ComponentGroupData>& components, uint64_t targetSceneId, const std::string& entityName)>;

using DisconnectCallback

using EntropyEngine::Networking::NetworkSession::DisconnectCallback = std::function<void(ConnectionState state, const std::string& reason)>;

using DestroySceneResponseCallback

using EntropyEngine::Networking::NetworkSession::DestroySceneResponseCallback = std::function<void(bool success, const std::string& errorMessage)>;

using DestroySceneCallback

using EntropyEngine::Networking::NetworkSession::DestroySceneCallback = std::function<void(uint64_t sceneId)>;

using CreateSceneResponseCallback

using EntropyEngine::Networking::NetworkSession::CreateSceneResponseCallback =
std::function<void(bool success, uint64_t sceneId, const std::string& errorMessage)>;

using CreateSceneCallback

using EntropyEngine::Networking::NetworkSession::CreateSceneCallback = std::function<void(const std::string& sceneName, bool transient)>;

using CreateMaterialResponseCallback

using EntropyEngine::Networking::NetworkSession::CreateMaterialResponseCallback = std::function<void(bool success, const std::array<uint8_t, 32>& materialId,
                                                             const std::string& errorMessage, uint64_t requestId)>;

using CreateMaterialCallback

using EntropyEngine::Networking::NetworkSession::CreateMaterialCallback = std::function<void(const MaterialAssetData& material, uint64_t requestId)>;

using AssetWithdrawResponseCallback

using EntropyEngine::Networking::NetworkSession::AssetWithdrawResponseCallback =
std::function<void(bool success, uint32_t removedCount, const std::string& errorMessage, uint64_t requestId)>;

using AssetWithdrawCallback

using EntropyEngine::Networking::NetworkSession::AssetWithdrawCallback =
std::function<void(const std::vector<std::array<uint8_t, 32>>& assetIds, uint64_t requestId)>;

using AssetWithdrawAllResponseCallback

using EntropyEngine::Networking::NetworkSession::AssetWithdrawAllResponseCallback =
std::function<void(bool success, uint32_t removedCount, const std::string& errorMessage, uint64_t requestId)>;

using AssetWithdrawAllCallback

using EntropyEngine::Networking::NetworkSession::AssetWithdrawAllCallback = std::function<void(const std::string& appId, uint64_t requestId)>;

using AssetUploadResponseCallback

using EntropyEngine::Networking::NetworkSession::AssetUploadResponseCallback =
std::function<void(bool success, const std::array<uint8_t, 32>& assetId, const std::string& uri,
                   const std::string& errorMessage, uint64_t requestId)>;

using AssetUploadCompleteResponseCallback

using EntropyEngine::Networking::NetworkSession::AssetUploadCompleteResponseCallback = std::function<void(const AssetUploadCompleteResponseData& data)>;

using AssetUploadCompleteCallback

using EntropyEngine::Networking::NetworkSession::AssetUploadCompleteCallback = std::function<void(const AssetUploadCompleteData& data)>;

using AssetUploadChunkResponseCallback

using EntropyEngine::Networking::NetworkSession::AssetUploadChunkResponseCallback = std::function<void(const AssetUploadChunkResponseData& data)>;

using AssetUploadChunkCallback

using EntropyEngine::Networking::NetworkSession::AssetUploadChunkCallback = std::function<void(const AssetUploadChunkData& data)>;

using AssetUploadCancelResponseCallback

using EntropyEngine::Networking::NetworkSession::AssetUploadCancelResponseCallback = std::function<void(bool success, const std::string& errorMessage)>;

using AssetUploadCancelCallback

using EntropyEngine::Networking::NetworkSession::AssetUploadCancelCallback = std::function<void(const std::array<uint8_t, 16>& uploadId)>;

using AssetUploadCallback

using EntropyEngine::Networking::NetworkSession::AssetUploadCallback =
std::function<void(const std::string& appId, const std::vector<uint8_t>& data, uint8_t contentType,
                   bool persistent, uint64_t requestId, const AssetMetadataData& metadata)>;

using AssetUploadBeginResponseCallback

using EntropyEngine::Networking::NetworkSession::AssetUploadBeginResponseCallback = std::function<void(const AssetUploadBeginResponseData& data)>;

using AssetUploadBeginCallback

using EntropyEngine::Networking::NetworkSession::AssetUploadBeginCallback = std::function<void(const AssetUploadBeginData& data)>;

using AssetResolveResponseCallback

using EntropyEngine::Networking::NetworkSession::AssetResolveResponseCallback =
std::function<void(const AssetResolveResponseData& response)>;

using AssetResolveCallback

using EntropyEngine::Networking::NetworkSession::AssetResolveCallback = std::function<void(const std::array<uint8_t, 32>& assetId, uint64_t requestId)>;

using AssetResolveBatchResponseCallback

using EntropyEngine::Networking::NetworkSession::AssetResolveBatchResponseCallback =
std::function<void(const std::vector<AssetResolveResponseData>& responses, uint64_t requestId)>;

using AssetResolveBatchCallback

using EntropyEngine::Networking::NetworkSession::AssetResolveBatchCallback =
std::function<void(const std::vector<std::array<uint8_t, 32>>& assetIds, uint64_t requestId)>;

using AssetProvideKeyResponseCallback

using EntropyEngine::Networking::NetworkSession::AssetProvideKeyResponseCallback =
std::function<void(bool success, const std::string& errorMessage, uint64_t requestId)>;

using AssetProvideKeyCallback

using EntropyEngine::Networking::NetworkSession::AssetProvideKeyCallback = std::function<void(const std::array<uint8_t, 32>& assetId,
                                                      const std::array<uint8_t, 32>& key, uint64_t requestId)>;

enum AssetMetadataType

Enumerator	Value	Description
Texture	2
Shader	1
None	0

using AssetMetadataResponseCallback

using EntropyEngine::Networking::NetworkSession::AssetMetadataResponseCallback =
std::function<void(bool found, const AssetMetadataData& metadata, uint64_t requestId)>;

using AssetMetadataCallback

using EntropyEngine::Networking::NetworkSession::AssetMetadataCallback = std::function<void(const std::array<uint8_t, 32>& assetId, uint64_t requestId)>;

using AssetFetchResponseCallback

using EntropyEngine::Networking::NetworkSession::AssetFetchResponseCallback = std::function<void(bool found, const std::vector<uint8_t>& data,
                                                         const std::string& errorMessage, uint64_t requestId)>;

using AssetFetchCallback

using EntropyEngine::Networking::NetworkSession::AssetFetchCallback = std::function<void(const std::array<uint8_t, 32>& assetId, uint64_t requestId)>;

using AssetAdvertiseResponseCallback

using EntropyEngine::Networking::NetworkSession::AssetAdvertiseResponseCallback =
std::function<void(bool success, const std::string& errorMessage, uint64_t requestId)>;

using AssetAdvertiseCallback

using EntropyEngine::Networking::NetworkSession::AssetAdvertiseCallback =
std::function<void(const std::string& appId, const std::vector<AssetEntryData>& entries, uint64_t requestId)>;

using AddEntityToSceneResponseCallback

using EntropyEngine::Networking::NetworkSession::AddEntityToSceneResponseCallback = std::function<void(bool success, const std::string& errorMessage)>;

using AddEntityToSceneCallback

using EntropyEngine::Networking::NetworkSession::AddEntityToSceneCallback = std::function<void(uint64_t entityId, uint64_t sceneId)>;

Public Functions Documentation

function ~NetworkSession

~NetworkSession() override

function supportsMultipleChannels

bool supportsMultipleChannels() const

function setupCallbacks

void setupCallbacks()

Set up connection callbacks to route messages to this session.

Note: Must be called before any messages will be received

This method registers this session’s message and state callbacks with the underlying connection. SessionManager calls this automatically, but direct users (like tests) must call it manually after construction.

function setUpdateMaterialPropertyResponseCallback

void setUpdateMaterialPropertyResponseCallback(
    UpdateMaterialPropertyResponseCallback callback
)

function setUpdateMaterialPropertyCallback

void setUpdateMaterialPropertyCallback(
    UpdateMaterialPropertyCallback callback
)

function setUpdateMaterialPropertiesBatchResponseCallback

void setUpdateMaterialPropertiesBatchResponseCallback(
    UpdateMaterialPropertiesBatchResponseCallback callback
)

function setUpdateMaterialPropertiesBatchCallback

void setUpdateMaterialPropertiesBatchCallback(
    UpdateMaterialPropertiesBatchCallback callback
)

function setUnpublishSchemaResponseCallback

void setUnpublishSchemaResponseCallback(
    UnpublishSchemaResponseCallback callback
)

function setSetSceneEnabledResponseCallback

void setSetSceneEnabledResponseCallback(
    SetSceneEnabledResponseCallback callback
)

function setSetSceneEnabledCallback

void setSetSceneEnabledCallback(
    SetSceneEnabledCallback callback
)

function setSchemaNackCallback

void setSchemaNackCallback(
    SchemaNackCallback callback
)

function setSchemaAdvertisementCallback

void setSchemaAdvertisementCallback(
    SchemaAdvertisementCallback callback
)

function setSceneSnapshotCallback

void setSceneSnapshotCallback(
    SceneSnapshotCallback callback
)

function setRegisterSchemaResponseCallback

void setRegisterSchemaResponseCallback(
    RegisterSchemaResponseCallback callback
)

function setQueryPublicSchemasResponseCallback

void setQueryPublicSchemasResponseCallback(
    QueryPublicSchemasResponseCallback callback
)

function setPublishSchemaResponseCallback

void setPublishSchemaResponseCallback(
    PublishSchemaResponseCallback callback
)

function setPropertyUpdateCallback

void setPropertyUpdateCallback(
    PropertyUpdateCallback callback
)

function setMeshMaterialBindingUpdateCallback

void setMeshMaterialBindingUpdateCallback(
    MeshMaterialBindingUpdateCallback callback
)

function setMeshMaterialBindingResponseCallback

void setMeshMaterialBindingResponseCallback(
    MeshMaterialBindingResponseCallback callback
)

function setMeshMaterialBindingCallback

void setMeshMaterialBindingCallback(
    MeshMaterialBindingCallback callback
)

function setMaterialUnsubscribeResponseCallback

void setMaterialUnsubscribeResponseCallback(
    MaterialUnsubscribeResponseCallback callback
)

function setMaterialUnsubscribeCallback

void setMaterialUnsubscribeCallback(
    MaterialUnsubscribeCallback callback
)

function setMaterialSubscribeResponseCallback

void setMaterialSubscribeResponseCallback(
    MaterialSubscribeResponseCallback callback
)

function setMaterialSubscribeCallback

void setMaterialSubscribeCallback(
    MaterialSubscribeCallback callback
)

function setMaterialResolvedCallback

void setMaterialResolvedCallback(
    MaterialResolvedCallback callback
)

function setMaterialPropertyUpdateCallback

void setMaterialPropertyUpdateCallback(
    MaterialPropertyUpdateCallback callback
)

function setHeartbeatResponseCallback

void setHeartbeatResponseCallback(
    HeartbeatResponseCallback callback
)

function setHeartbeatCallback

void setHeartbeatCallback(
    HeartbeatCallback callback
)

function setHandshakeCallback

void setHandshakeCallback(
    HandshakeCallback callback
)

function setGetShaderResponseCallback

void setGetShaderResponseCallback(
    GetShaderResponseCallback callback
)

function setGetShaderCallback

void setGetShaderCallback(
    GetShaderCallback callback
)

function setGetMaterialResponseCallback

void setGetMaterialResponseCallback(
    GetMaterialResponseCallback callback
)

function setGetMaterialCallback

void setGetMaterialCallback(
    GetMaterialCallback callback
)

function setErrorCallback

void setErrorCallback(
    ErrorCallback callback
)

function setEntityDestroyedCallback

void setEntityDestroyedCallback(
    EntityDestroyedCallback callback
)

function setEntityCreatedCallback

void setEntityCreatedCallback(
    EntityCreatedCallback callback
)

function setDisconnectCallback

void setDisconnectCallback(
    DisconnectCallback callback
)

function setDestroySceneResponseCallback

void setDestroySceneResponseCallback(
    DestroySceneResponseCallback callback
)

function setDestroySceneCallback

void setDestroySceneCallback(
    DestroySceneCallback callback
)

function setCreateSceneResponseCallback

void setCreateSceneResponseCallback(
    CreateSceneResponseCallback callback
)

function setCreateSceneCallback

void setCreateSceneCallback(
    CreateSceneCallback callback
)

function setCreateMaterialResponseCallback

void setCreateMaterialResponseCallback(
    CreateMaterialResponseCallback callback
)

function setCreateMaterialCallback

void setCreateMaterialCallback(
    CreateMaterialCallback callback
)

function setBatchingEnabled

void setBatchingEnabled(
    bool enabled
)

function setAssetWithdrawResponseCallback

void setAssetWithdrawResponseCallback(
    AssetWithdrawResponseCallback callback
)

function setAssetWithdrawCallback

void setAssetWithdrawCallback(
    AssetWithdrawCallback callback
)

function setAssetWithdrawAllResponseCallback

void setAssetWithdrawAllResponseCallback(
    AssetWithdrawAllResponseCallback callback
)

function setAssetWithdrawAllCallback

void setAssetWithdrawAllCallback(
    AssetWithdrawAllCallback callback
)

function setAssetUploadResponseCallback

void setAssetUploadResponseCallback(
    AssetUploadResponseCallback callback
)

function setAssetUploadCompleteResponseCallback

void setAssetUploadCompleteResponseCallback(
    AssetUploadCompleteResponseCallback callback
)

function setAssetUploadCompleteCallback

void setAssetUploadCompleteCallback(
    AssetUploadCompleteCallback callback
)

function setAssetUploadChunkResponseCallback

void setAssetUploadChunkResponseCallback(
    AssetUploadChunkResponseCallback callback
)

function setAssetUploadChunkCallback

void setAssetUploadChunkCallback(
    AssetUploadChunkCallback callback
)

function setAssetUploadCancelResponseCallback

void setAssetUploadCancelResponseCallback(
    AssetUploadCancelResponseCallback callback
)

function setAssetUploadCancelCallback

void setAssetUploadCancelCallback(
    AssetUploadCancelCallback callback
)

function setAssetUploadCallback

void setAssetUploadCallback(
    AssetUploadCallback callback
)

function setAssetUploadBeginResponseCallback

void setAssetUploadBeginResponseCallback(
    AssetUploadBeginResponseCallback callback
)

function setAssetUploadBeginCallback

void setAssetUploadBeginCallback(
    AssetUploadBeginCallback callback
)

function setAssetResolveResponseCallback

void setAssetResolveResponseCallback(
    AssetResolveResponseCallback callback
)

function setAssetResolveCallback

void setAssetResolveCallback(
    AssetResolveCallback callback
)

function setAssetResolveBatchResponseCallback

void setAssetResolveBatchResponseCallback(
    AssetResolveBatchResponseCallback callback
)

function setAssetResolveBatchCallback

void setAssetResolveBatchCallback(
    AssetResolveBatchCallback callback
)

function setAssetProvideKeyResponseCallback

void setAssetProvideKeyResponseCallback(
    AssetProvideKeyResponseCallback callback
)

function setAssetProvideKeyCallback

void setAssetProvideKeyCallback(
    AssetProvideKeyCallback callback
)

function setAssetMetadataResponseCallback

void setAssetMetadataResponseCallback(
    AssetMetadataResponseCallback callback
)

function setAssetMetadataCallback

void setAssetMetadataCallback(
    AssetMetadataCallback callback
)

function setAssetFetchResponseCallback

void setAssetFetchResponseCallback(
    AssetFetchResponseCallback callback
)

function setAssetFetchCallback

void setAssetFetchCallback(
    AssetFetchCallback callback
)

function setAssetAdvertiseResponseCallback

void setAssetAdvertiseResponseCallback(
    AssetAdvertiseResponseCallback callback
)

function setAssetAdvertiseCallback

void setAssetAdvertiseCallback(
    AssetAdvertiseCallback callback
)

function setAddEntityToSceneResponseCallback

void setAddEntityToSceneResponseCallback(
    AddEntityToSceneResponseCallback callback
)

function setAddEntityToSceneCallback

void setAddEntityToSceneCallback(
    AddEntityToSceneCallback callback
)

function sendUpdateMaterialPropertyResponse

Result< void > sendUpdateMaterialPropertyResponse(
    bool success,
    uint64_t newVersion,
    const std::string & errorMessage
)

function sendUpdateMaterialPropertyRequest

Result< void > sendUpdateMaterialPropertyRequest(
    const std::array< uint8_t, 32 > & materialId,
    const std::string & propertyName,
    const PropertyValue & value,
    uint64_t requestId =0
)

function sendUpdateMaterialPropertiesBatchResponse

Result< void > sendUpdateMaterialPropertiesBatchResponse(
    bool success,
    uint64_t newVersion,
    const std::string & errorMessage
)

function sendUpdateMaterialPropertiesBatchRequest

Result< void > sendUpdateMaterialPropertiesBatchRequest(
    const std::array< uint8_t, 32 > & materialId,
    const std::vector< MaterialPropertyData > & properties,
    uint64_t requestId =0
)

function sendUnpublishSchema

Result< void > sendUnpublishSchema(
    ComponentTypeHash typeHash
)

function sendSetSceneEnabledResponse

Result< void > sendSetSceneEnabledResponse(
    bool success,
    const std::string & errorMessage
)

function sendSetSceneEnabledRequest

Result< void > sendSetSceneEnabledRequest(
    uint64_t sceneId,
    bool enabled
)

function sendSchemaNack

Result< void > sendSchemaNack(
    ComponentTypeHash typeHash,
    const std::string & reason
)

Send NACK for unknown schema (optional feedback).

Parameters:

• typeHash Unknown ComponentTypeHash that triggered the NACK
• reason Human-readable reason (e.g., “Schema not found in registry”)

Return: Result indicating success or error (Ok if policy disabled or rate limited)

Sends a SchemaNack message to notify the peer about an unknown ComponentTypeHash. This is OPTIONAL feedback controlled by SchemaNackPolicy:

• Only sent when SchemaNackPolicy::instance().isEnabled() == true
• Subject to per-schema rate limiting via SchemaNackTracker (default: 1000ms interval)
• Uses non-blocking reliable send path (MPSC queue)

Typical usage: Called automatically by handleUnknownSchema() when processing ENTITY_CREATED messages with unknown ComponentTypeHash values.

function sendSchemaAdvertisement

Result< void > sendSchemaAdvertisement(
    ComponentTypeHash typeHash,
    const std::string & appId,
    const std::string & componentName,
    uint32_t schemaVersion
)

function sendSceneSnapshot

Result< void > sendSceneSnapshot(
    const std::vector< uint8_t > & snapshotData
)

function sendRegisterSchema

Result< void > sendRegisterSchema(
    const ComponentSchema & schema
)

function sendQueryPublicSchemas

Result< void > sendQueryPublicSchemas()

function sendPublishSchema

Result< void > sendPublishSchema(
    ComponentTypeHash typeHash
)

function sendPropertyUpdateBatch

Result< void > sendPropertyUpdateBatch(
    const std::vector< uint8_t > & batchData
)

function sendPropertyUpdate

Result< void > sendPropertyUpdate(
    PropertyHash hash,
    PropertyType type,
    const PropertyValue & value
)

function sendMeshMaterialBindingUpdate

Result< void > sendMeshMaterialBindingUpdate(
    uint64_t entityId,
    const std::vector< std::array< uint8_t, 32 > > & materialIds,
    uint64_t originSessionId
)

function sendMeshMaterialBindingResponse

Result< void > sendMeshMaterialBindingResponse(
    bool success,
    const std::string & errorMessage,
    uint64_t requestId =0
)

function sendMeshMaterialBindingRequest

Result< void > sendMeshMaterialBindingRequest(
    uint64_t entityId,
    const std::vector< std::array< uint8_t, 32 > > & materialIds,
    uint64_t requestId =0
)

function sendMaterialUnsubscribeResponse

Result< void > sendMaterialUnsubscribeResponse(
    bool success,
    const std::string & errorMessage
)

function sendMaterialUnsubscribeRequest

Result< void > sendMaterialUnsubscribeRequest(
    const std::array< uint8_t, 32 > & materialId,
    uint64_t requestId =0
)

function sendMaterialSubscribeResponse

Result< void > sendMaterialSubscribeResponse(
    bool success,
    const MaterialAssetData & material,
    const std::string & errorMessage,
    uint64_t requestId =0
)

function sendMaterialSubscribeRequest

Result< void > sendMaterialSubscribeRequest(
    const std::array< uint8_t, 32 > & materialId,
    uint64_t requestId =0
)

function sendMaterialResolved

Result< void > sendMaterialResolved(
    const std::array< uint8_t, 32 > & materialId,
    const MaterialAssetData & material
)

function sendMaterialPropertyUpdate

Result< void > sendMaterialPropertyUpdate(
    const std::array< uint8_t, 32 > & materialId,
    const std::string & propertyName,
    const PropertyValue & value,
    uint64_t newVersion,
    uint64_t originSessionId
)

function sendHeartbeatResponse

Result< void > sendHeartbeatResponse(
    uint64_t clientTimestamp
)

function sendHeartbeat

Result< void > sendHeartbeat()

function sendGetShaderResponse

Result< void > sendGetShaderResponse(
    const GetShaderResponseData & response,
    uint64_t requestId =0
)

function sendGetShaderRequest

Result< void > sendGetShaderRequest(
    const std::array< uint8_t, 32 > & shaderAssetId,
    uint64_t requestId =0
)

function sendGetMaterialResponse

Result< void > sendGetMaterialResponse(
    bool success,
    const MaterialAssetData & material,
    const std::string & errorMessage
)

function sendGetMaterialRequest

Result< void > sendGetMaterialRequest(
    const std::array< uint8_t, 32 > & materialId,
    uint64_t requestId =0
)

function sendEntityDestroyed

Result< void > sendEntityDestroyed(
    uint64_t entityId
)

function sendEntityCreated

Result< void > sendEntityCreated(
    uint64_t entityId,
    const std::string & appId,
    const std::string & typeName,
    uint64_t parentId,
    const std::vector< ComponentGroupData > & components ={},
    uint64_t targetSceneId =0,
    const std::string & entityName =""
)

function sendDestroySceneResponse

Result< void > sendDestroySceneResponse(
    bool success,
    const std::string & errorMessage
)

function sendDestroySceneRequest

Result< void > sendDestroySceneRequest(
    uint64_t sceneId
)

function sendCreateSceneResponse

Result< void > sendCreateSceneResponse(
    bool success,
    uint64_t sceneId,
    const std::string & errorMessage
)

function sendCreateSceneRequest

Result< void > sendCreateSceneRequest(
    const std::string & sceneName,
    bool transient
)

function sendCreateMaterialResponse

Result< void > sendCreateMaterialResponse(
    bool success,
    const std::array< uint8_t, 32 > & materialId,
    const std::string & errorMessage,
    uint64_t requestId =0
)

function sendCreateMaterialRequest

Result< void > sendCreateMaterialRequest(
    const MaterialAssetData & material,
    uint64_t requestId =0
)

function sendComponentRemoved

Result< void > sendComponentRemoved(
    uint64_t entityId,
    ComponentTypeHash typeHash
)

function sendComponentAdded

Result< void > sendComponentAdded(
    uint64_t entityId,
    const ComponentGroupData & component
)

function sendAssetWithdrawResponse

Result< void > sendAssetWithdrawResponse(
    bool success,
    uint32_t removedCount,
    const std::string & errorMessage,
    uint64_t requestId =0
)

function sendAssetWithdrawAllResponse

Result< void > sendAssetWithdrawAllResponse(
    bool success,
    uint32_t removedCount,
    const std::string & errorMessage,
    uint64_t requestId =0
)

function sendAssetWithdrawAll

Result< void > sendAssetWithdrawAll(
    const std::string & appId,
    uint64_t requestId =0
)

function sendAssetWithdraw

Result< void > sendAssetWithdraw(
    const std::vector< std::array< uint8_t, 32 > > & assetIds,
    uint64_t requestId =0
)

function sendAssetUploadResponse

Result< void > sendAssetUploadResponse(
    bool success,
    const std::array< uint8_t, 32 > & assetId,
    const std::string & uri,
    const std::string & errorMessage,
    uint64_t requestId =0
)

function sendAssetUploadCompleteResponse

Result< void > sendAssetUploadCompleteResponse(
    const AssetUploadCompleteResponseData & data
)

function sendAssetUploadComplete

Result< void > sendAssetUploadComplete(
    const AssetUploadCompleteData & data
)

function sendAssetUploadChunkResponse

Result< void > sendAssetUploadChunkResponse(
    const AssetUploadChunkResponseData & data
)

function sendAssetUploadChunk

Result< void > sendAssetUploadChunk(
    const AssetUploadChunkData & data
)

function sendAssetUploadCancelResponse

Result< void > sendAssetUploadCancelResponse(
    bool success,
    const std::string & errorMessage
)

function sendAssetUploadCancel

Result< void > sendAssetUploadCancel(
    const std::array< uint8_t, 16 > & uploadId
)

function sendAssetUploadBeginResponse

Result< void > sendAssetUploadBeginResponse(
    const AssetUploadBeginResponseData & data
)

function sendAssetUploadBegin

Result< void > sendAssetUploadBegin(
    const AssetUploadBeginData & data
)

function sendAssetUpload

Result< void > sendAssetUpload(
    const std::string & appId,
    const std::vector< uint8_t > & data,
    uint8_t contentType,
    bool persistent,
    uint64_t requestId =0
)

function sendAssetUpload

Result< void > sendAssetUpload(
    const std::string & appId,
    const std::vector< uint8_t > & data,
    uint8_t contentType,
    bool persistent,
    uint64_t requestId,
    const AssetMetadataData & metadata
)

function sendAssetResolveResponse

Result< void > sendAssetResolveResponse(
    const AssetResolveResponseData & response
)

function sendAssetResolveBatchResponse

Result< void > sendAssetResolveBatchResponse(
    const std::vector< AssetResolveResponseData > & responses,
    uint64_t requestId =0
)

function sendAssetResolveBatch

Result< void > sendAssetResolveBatch(
    const std::vector< std::array< uint8_t, 32 > > & assetIds,
    uint64_t requestId =0
)

function sendAssetResolve

Result< void > sendAssetResolve(
    const std::array< uint8_t, 32 > & assetId,
    uint64_t requestId =0
)

function sendAssetProvideKeyResponse

Result< void > sendAssetProvideKeyResponse(
    bool success,
    const std::string & errorMessage,
    uint64_t requestId =0
)

function sendAssetProvideKey

Result< void > sendAssetProvideKey(
    const std::array< uint8_t, 32 > & assetId,
    const std::array< uint8_t, 32 > & key,
    uint64_t requestId =0
)

function sendAssetFetchResponse

Result< void > sendAssetFetchResponse(
    bool found,
    const std::vector< uint8_t > & data,
    const std::string & errorMessage,
    uint64_t requestId =0
)

function sendAssetFetch

Result< void > sendAssetFetch(
    const std::array< uint8_t, 32 > & assetId,
    uint64_t requestId =0
)

function sendAssetAdvertiseResponse

Result< void > sendAssetAdvertiseResponse(
    bool success,
    const std::string & errorMessage,
    uint64_t requestId =0
)

function sendAssetAdvertise

Result< void > sendAssetAdvertise(
    const std::string & appId,
    const std::vector< AssetEntryData > & entries,
    uint64_t requestId =0
)

function sendAddEntityToSceneResponse

Result< void > sendAddEntityToSceneResponse(
    bool success,
    const std::string & errorMessage
)

function sendAddEntityToSceneRequest

Result< void > sendAddEntityToSceneRequest(
    uint64_t entityId,
    uint64_t sceneId
)

function performHandshake

Result< void > performHandshake(
    const std::string & clientType,
    const std::string & clientId
)

function openChannel

Result< void > openChannel(
    const std::string & channel
)

function nextEntityId

inline uint64_t nextEntityId()

Get the next available entity ID.

Return: Unique entity ID for this session

function isHandshakeComplete

inline bool isHandshakeComplete() const

function isConnected

bool isConnected() const

function isBatchingEnabled

inline bool isBatchingEnabled() const

function getUnknownSchemaDropCount

inline uint64_t getUnknownSchemaDropCount() const

function getStats

ConnectionStats getStats() const

function getState

ConnectionState getState() const

function getSessionId

inline const std::string & getSessionId() const

function getSequenceUpdateFailureCount

inline uint64_t getSequenceUpdateFailureCount() const

function getSchemaRegistry

inline ComponentSchemaRegistry * getSchemaRegistry()

function getSchemaRegistry

inline const ComponentSchemaRegistry * getSchemaRegistry() const

function getPropertyRegistry

inline PropertyRegistry & getPropertyRegistry()

function getPropertyRegistry

inline const PropertyRegistry & getPropertyRegistry() const

function getPropertyBatchStats

PropertyBatchStats getPropertyBatchStats() const

function getPendingPropertyUpdateCount

size_t getPendingPropertyUpdateCount() const

function getPacketLossEventCount

inline uint64_t getPacketLossEventCount() const

function getLastHeartbeatReceived

std::chrono::steady_clock::time_point getLastHeartbeatReceived() const

function getDuplicatePacketCount

inline uint64_t getDuplicatePacketCount() const

function flushPropertyUpdates

Result< void > flushPropertyUpdates()

function disconnect

Result< void > disconnect()

function createEntity

EntityBuilder createEntity(
    const std::string & typeName,
    const std::string & appId ="CanvasEngine",
    uint64_t parentId =0
)

Create a new entity with ECS-style API.

Parameters:

• typeName Entity type name (e.g., “Mesh”, “Light”, “Camera”)
• appId Application ID (default: “CanvasEngine”)
• parentId Parent entity ID (default: 0 = root)

Return: EntityBuilder for attaching components and setting properties

function connect

Result< void > connect()

function clearCallbacks

void clearCallbacks()

Clears all callbacks to prevent invocation during/after destruction.

Called by SessionManager::destroySession before returning slot to free list.

function NetworkSession

NetworkSession(
    NetworkConnection * connection,
    PropertyRegistry * externalRegistry =nullptr,
    ComponentSchemaRegistry * schemaRegistry =nullptr
)

Construct a NetworkSession.

Parameters:

• connection Network connection to wrap
• externalRegistry Optional external PropertyRegistry to share across sessions. If nullptr, creates an internal registry (for single-session use).
• schemaRegistry Optional ComponentSchemaRegistry for schema operations. If nullptr, schema operations will not be available.

Friends

friend SessionManager

friend class SessionManager(
    SessionManager
);

---

Updated on 2026-01-26 at 16:50:32 -0500