connected-spaces-platform.web 5.17.0 → 5.17.2

package/connectedspacesplatform.ts

@@ -342,6 +342,14 @@ function csp_common_VariantTypeFactory(
 }
 ProxyClassFactories["csp_common_VariantType"] = csp_common_VariantTypeFactory;
 
+function csp_common_RealtimeEngineTypeFactory(
+  nativePointer: NativePointer,
+): Common.RealtimeEngineType {
+  return nativePointer.pointer as Common.RealtimeEngineType;
+}
+ProxyClassFactories["csp_common_RealtimeEngineType"] =
+  csp_common_RealtimeEngineTypeFactory;
+
 function csp_multiplayer_ComponentTypeFactory(
   nativePointer: NativePointer,
 ): Multiplayer.ComponentType {
@@ -1035,6 +1043,14 @@ function csp_common_Vector4Factory(
 }
 ProxyClassFactories["csp_common_Vector4"] = csp_common_Vector4Factory;
 
+function csp_common_IRealtimeEngineFactory(
+  nativePointer: NativePointer,
+): NativeClassWrapper {
+  return new Common.IRealtimeEngine(nativePointer);
+}
+ProxyClassFactories["csp_common_IRealtimeEngine"] =
+  csp_common_IRealtimeEngineFactory;
+
 function csp_multiplayer_ComponentBaseFactory(
   nativePointer: NativePointer,
 ): NativeClassWrapper {
@@ -3102,6 +3118,16 @@ export namespace Common {
   }
 }
 
+export namespace Common {
+  /**
+   * @description Enum of concrete types of RealtimeEngines.
+   */
+  export enum RealtimeEngineType {
+    OnlineMultiUser = 0,
+    OnlineSingleUser,
+  }
+}
+
 export namespace Multiplayer {
   /**
    * @description Represents the type of component.
@@ -21475,6 +21501,505 @@ export namespace Common {
   }
 }
 
+export namespace Common {
+  export class IRealtimeEngine
+    extends NativeClassWrapper
+    implements INativeResource
+  {
+    /** @internal */
+    constructor(pointer: NativePointer) {
+      super(pointer);
+    }
+
+    /**
+     * @description Virtual destructor.
+     */
+    delete(): void {
+      if (this.ownsPointer && !this.disposed) {
+        Module.ccall(
+          "csp_common_IRealtimeEngine_Dtor",
+          "void",
+          ["number"],
+          [this.pointer],
+        );
+
+        this.disposed = true;
+      }
+    }
+
+    /**
+     * @description Returns the concrete type of the instantiation of the abstract IRealtimeEngine.
+     */
+
+    getRealtimeEngineType(): Common.RealtimeEngineType {
+      let _result = Module.ccall(
+        "csp_common_IRealtimeEngine_GetRealtimeEngineTypeC_RealtimeEngineType",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      return _result;
+    }
+
+    /**
+     * @description Create and add a SpaceEntity with type Avatar, and relevant components and default states as specified.
+     * @param name - The entity name of the newly created avatar entity.
+     * @param spaceTransform - The initial transform to set the SpaceEntity to.
+     * @param state - The initial Avatar State to set.
+     * @param avatarId - The ID to be set on the AvatarSpaceComponent
+     * @param avatarPlayMode - The Initial AvatarPlayMode to set.
+     * @param callback - Csp::multiplayer::entitycreatedcallback a callback that executes when the creation is complete,
+     * which will provide a non-owning pointer to the new SpaceEntity so that it can be used on the local client.
+     */
+
+    async createAvatar(
+      name: string,
+      spaceTransform: Multiplayer.SpaceTransform,
+      state: Multiplayer.AvatarState,
+      avatarId: string,
+      avatarPlayMode: Multiplayer.AvatarPlayMode,
+    ): Promise<Multiplayer.SpaceEntity> {
+      var _resolve;
+
+      var _promise = new Promise<Multiplayer.SpaceEntity>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, arg1) => {
+        var _arg1Ptr = getNativePointer(arg1);
+        var _arg1Instance = new Multiplayer.SpaceEntity(_arg1Ptr);
+
+        _resolve(_arg1Instance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_common_IRealtimeEngine_CreateAvatar_void_StringRC_SpaceTransformRC_AvatarStateRC_StringRC_AvatarPlayModeRC_EntityCreatedCallback",
+        "void",
+        [
+          "number",
+          "string",
+          "number",
+          "number",
+          "string",
+          "number",
+          "number",
+          "number",
+        ],
+        [
+          this.pointer,
+          name,
+          spaceTransform.pointer,
+          state,
+          avatarId,
+          avatarPlayMode,
+          _callbackPtr,
+          0,
+        ],
+      );
+
+      return _promise;
+    }
+
+    /**
+     * @description Create and add a SpaceEntity, with relevant default values.
+     * @param name - The name of the newly created SpaceEntity.
+     * @param spaceTransform - The initial transform to set the SpaceEntity to.
+     * @param callback - A callback that executes when the creation is complete,
+     * which will provide a non-owning pointer to the new SpaceEntity so that it can be used on the local client.
+     */
+
+    async createEntity(
+      name: string,
+      spaceTransform: Multiplayer.SpaceTransform,
+    ): Promise<Multiplayer.SpaceEntity> {
+      var _resolve;
+
+      var _promise = new Promise<Multiplayer.SpaceEntity>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, arg1) => {
+        var _arg1Ptr = getNativePointer(arg1);
+        var _arg1Instance = new Multiplayer.SpaceEntity(_arg1Ptr);
+
+        _resolve(_arg1Instance);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_common_IRealtimeEngine_CreateEntity_void_StringRC_SpaceTransformRC_EntityCreatedCallback",
+        "void",
+        ["number", "string", "number", "number", "number"],
+        [this.pointer, name, spaceTransform.pointer, _callbackPtr, 0],
+      );
+
+      return _promise;
+    }
+
+    /**
+     * @description Destroy the specified entity.
+     * @param entity - A non-owning pointer to the entity to be destroyed.
+     * @param callback - A callback that executes when the entity destruction is complete.
+     */
+
+    async destroyEntity(entity: Multiplayer.SpaceEntity): Promise<boolean> {
+      var _resolve;
+
+      var _promise = new Promise<boolean>((_r) => {
+        _resolve = _r;
+      });
+
+      var _callbackPtr: number;
+      var _callback = (_stateObject__: number, arg1) => {
+        _resolve(!!arg1);
+
+        Module.removeFunction(_callbackPtr);
+      };
+
+      _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_common_IRealtimeEngine_DestroyEntity_void_SpaceEntityP_CallbackHandler",
+        "void",
+        ["number", "number", "number", "number"],
+        [this.pointer, entity.pointer, _callbackPtr, 0],
+      );
+
+      return _promise;
+    }
+
+    /**
+     * @description Sets a callback to be executed when an entity is fully created.
+     * /// Only one EntityCreatedCallback may be registered, calling this function again will override whatever was previously set.
+     * /// @param Callback csp::multiplayer::EntityCreatedCallback : the callback to execute.
+     */
+    setEntityCreatedCallback(
+      callback: (arg1: Multiplayer.SpaceEntity) => void,
+    ) {
+      var _callback = (_stateObject__: number, arg1) => {
+        var _arg1 = new Multiplayer.SpaceEntity(getNativePointer(arg1));
+
+        callback(_arg1);
+      };
+
+      var _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_common_IRealtimeEngine_SetEntityCreatedCallback_void_EntityCreatedCallback",
+        "void",
+        ["number", "number", "number"],
+        [this.pointer, _callbackPtr, 0],
+      );
+    }
+
+    /**
+     * @description Finds the first found SpaceEntity of a matching Name.
+     * @param name - The name to search.
+     * @return A non-owning pointer to the first found matching SpaceEntity.
+     */
+
+    findSpaceEntity(name: string): Multiplayer.SpaceEntity {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_common_IRealtimeEngine_FindSpaceEntity_SpaceEntityP_StringRC",
+        "void",
+        ["number", "number", "string"],
+        [_ret, this.pointer, name],
+      );
+      var _nPtr = new Multiplayer.SpaceEntity(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    /**
+     * @description Finds the first found SpaceEntity that has the ID EntityId.
+     * @param entityId - The Id to look for.
+     * @return A non-owning pointer to the first found matching SpaceEntity.
+     */
+
+    findSpaceEntityById(entityId: bigint): Multiplayer.SpaceEntity {
+      assert(entityId >= Limits.UINT64_MIN);
+      assert(entityId <= Limits.UINT64_MAX);
+
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_common_IRealtimeEngine_FindSpaceEntityById_SpaceEntityP_uint64_t",
+        "void",
+        ["number", "number", "bigint"],
+        [_ret, this.pointer, entityId],
+      );
+      var _nPtr = new Multiplayer.SpaceEntity(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    /**
+     * @description Finds the first found SpaceEntity of a matching Name. The found SpaceEntity will contain an AvatarSpaceComponent.
+     * @param name - The name to search for.
+     * @return A pointer to the first found matching SpaceEntity.
+     */
+
+    findSpaceAvatar(name: string): Multiplayer.SpaceEntity {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_common_IRealtimeEngine_FindSpaceAvatar_SpaceEntityP_StringRC",
+        "void",
+        ["number", "number", "string"],
+        [_ret, this.pointer, name],
+      );
+      var _nPtr = new Multiplayer.SpaceEntity(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    /**
+     * @description Finds the first found SpaceEntity of a matching Name. The found SpaceEntity will not contain an AvatarSpaceComponent.
+     * @param name - The name to search for.
+     * @return A pointer to the first found matching SpaceEntity.
+     */
+
+    findSpaceObject(name: string): Multiplayer.SpaceEntity {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_common_IRealtimeEngine_FindSpaceObject_SpaceEntityP_StringRC",
+        "void",
+        ["number", "number", "string"],
+        [_ret, this.pointer, name],
+      );
+      var _nPtr = new Multiplayer.SpaceEntity(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    /**
+     * @description Get an Entity by its index.
+     * /// @param EntityIndex size_t : The index of the entity to get.
+     * @return A non-owning pointer to the entity at the given index.
+     */
+
+    getEntityByIndex(entityIndex: number): Multiplayer.SpaceEntity {
+      assert(Number.isInteger(entityIndex));
+      assert(entityIndex >= Limits.UINT32_MIN);
+      assert(entityIndex <= Limits.UINT32_MAX);
+
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_common_IRealtimeEngine_GetEntityByIndex_SpaceEntityP_size_t",
+        "void",
+        ["number", "number", "number"],
+        [_ret, this.pointer, entityIndex],
+      );
+      var _nPtr = new Multiplayer.SpaceEntity(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    /**
+     * @description Get an Avatar by its index. The returned pointer will be an entity that contains an AvatarSpaceComponent.
+     * /// @param AvatarIndex size_t : The index of the avatar entity to get.
+     * @return A non-owning pointer to the avatar entity with the given index.
+     */
+
+    getAvatarByIndex(avatarIndex: number): Multiplayer.SpaceEntity {
+      assert(Number.isInteger(avatarIndex));
+      assert(avatarIndex >= Limits.UINT32_MIN);
+      assert(avatarIndex <= Limits.UINT32_MAX);
+
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_common_IRealtimeEngine_GetAvatarByIndex_SpaceEntityP_size_t",
+        "void",
+        ["number", "number", "number"],
+        [_ret, this.pointer, avatarIndex],
+      );
+      var _nPtr = new Multiplayer.SpaceEntity(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    /**
+     * @description Get an Object by its index. The returned pointer will be an entity that does not contain an AvatarSpaceComponent.
+     * /// @param ObjectIndex size_t : The index of the object entity to get.
+     * @return A non-owning pointer to the object entity with the given index.
+     */
+
+    getObjectByIndex(objectIndex: number): Multiplayer.SpaceEntity {
+      assert(Number.isInteger(objectIndex));
+      assert(objectIndex >= Limits.UINT32_MIN);
+      assert(objectIndex <= Limits.UINT32_MAX);
+
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_common_IRealtimeEngine_GetObjectByIndex_SpaceEntityP_size_t",
+        "void",
+        ["number", "number", "number"],
+        [_ret, this.pointer, objectIndex],
+      );
+      var _nPtr = new Multiplayer.SpaceEntity(getNativePointer(_ret));
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    /**
+     * @description Get the number of total entities in the system.
+     * @return The total number of entities.
+     */
+
+    getNumEntities(): number {
+      let _result = Module.ccall(
+        "csp_common_IRealtimeEngine_GetNumEntitiesC_size_t",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      const _unfixedValue = _result;
+      let _fixedValue =
+        _unfixedValue < 0 ? _unfixedValue + 2 ** 32 : _unfixedValue;
+      _result = _fixedValue;
+
+      return _result;
+    }
+
+    /**
+     * @description Get the number of total Avatars in the system. Avatars are entities that contain AvatarSpaceComponents.
+     * @return The total number of Avatar entities.
+     */
+
+    getNumAvatars(): number {
+      let _result = Module.ccall(
+        "csp_common_IRealtimeEngine_GetNumAvatarsC_size_t",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      const _unfixedValue = _result;
+      let _fixedValue =
+        _unfixedValue < 0 ? _unfixedValue + 2 ** 32 : _unfixedValue;
+      _result = _fixedValue;
+
+      return _result;
+    }
+
+    /**
+     * @description Get the number of total Objects in the system. Objects are entities that do not contain AvatarSpaceComponents.
+     * @return The total number of object entities.
+     */
+
+    getNumObjects(): number {
+      let _result = Module.ccall(
+        "csp_common_IRealtimeEngine_GetNumObjectsC_size_t",
+        "number",
+        ["number"],
+        [this.pointer],
+      );
+
+      const _unfixedValue = _result;
+      let _fixedValue =
+        _unfixedValue < 0 ? _unfixedValue + 2 ** 32 : _unfixedValue;
+      _result = _fixedValue;
+
+      return _result;
+    }
+
+    /**
+     * @description Retrieves all entities that exist at the root level (do not have a parent entity).
+     * @return A list of root entities containing non-owning pointers to entities.
+     */
+
+    getRootHierarchyEntities(): Common.List<Multiplayer.SpaceEntity> {
+      var _ret = Module._malloc(8);
+
+      Module.ccall(
+        "csp_common_IRealtimeEngine_GetRootHierarchyEntitiesC_ListPC",
+        "void",
+        ["number", "number"],
+        [_ret, this.pointer],
+      );
+      var _nPtr = new Common.List<Multiplayer.SpaceEntity>(
+        getNativePointer(_ret),
+        csp_multiplayer_SpaceEntityFactory,
+        "csp_multiplayer_SpaceEntity",
+      );
+      Module._free(_ret);
+
+      return _nPtr;
+    }
+
+    /**
+     * @description Sets a callback to be executed when all existing entities have been retrieved after entering a space.
+     * @param callback - A callback that executes when all existing entities have been retrieved.
+     */
+    setInitialEntitiesRetrievedCallback(callback: (arg1: boolean) => void) {
+      var _callback = (_stateObject__: number, arg1) => {
+        callback(arg1);
+      };
+
+      var _callbackPtr = Module.addFunction(_callback, "vii");
+
+      Module.ccall(
+        "csp_common_IRealtimeEngine_SetInitialEntitiesRetrievedCallback_void_CallbackHandler",
+        "void",
+        ["number", "number", "number"],
+        [this.pointer, _callbackPtr, 0],
+      );
+    }
+
+    /**
+     * @description Adds an entity to a list of entities to be updated when ProcessPendingEntityOperations is called.
+     * From a client perspective, ProcessPendingEntityOperations is normally called via the CSPFoundation::Tick method.
+     * @param entity - A non-owning pointer to the entity to be marked.
+     */
+
+    markEntityForUpdate(entity: Multiplayer.SpaceEntity): void {
+      Module.ccall(
+        "csp_common_IRealtimeEngine_MarkEntityForUpdate_void_SpaceEntityP",
+        "void",
+        ["number", "number"],
+        [this.pointer, entity.pointer],
+      );
+    }
+
+    /**
+     * @description Applies any pending changes to entities that have been marked for update.
+     */
+
+    processPendingEntityOperations(): void {
+      Module.ccall(
+        "csp_common_IRealtimeEngine_ProcessPendingEntityOperations_void",
+        "void",
+        ["number"],
+        [this.pointer],
+      );
+    }
+  }
+}
+
 export namespace Multiplayer {
   /**
    * @description The base class for all components, provides mechanisms for dirtying properties and subscribing to events on property changes.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "connected-spaces-platform.web",
   "displayName": "connected-spaces-platform.web",
-  "version": "5.17.0+593",
+  "version": "5.17.2+595",
   "description": "This package provides the binaries required to interface with the Connected Spaces Platform API.",
   "license": "Apache-2.0",
   "dependencies": {