@needle-tools/engine
Version:
Needle Engine is a web-based runtime for 3D apps. It runs on your machine for development with great integrations into editors like Unity or Blender - and can be deployed onto any device! It is flexible, extensible and networking and XR are built-in
81 lines (80 loc) • 3.62 kB
TypeScript
import { Object3D } from "three";
import { AssetReference } from "../../engine/engine_addressables.js";
import type { ComponentInit, IGameObject } from "../../engine/engine_types.js";
import { Behaviour, Component } from "../../engine-components/Component.js";
import { EventList } from "../../engine-components/EventList.js";
declare type PlayerSyncWithAsset = PlayerSync & Required<Pick<PlayerSync, "asset">>;
/**
* This component instantiates an asset for each player that joins a networked room. The asset will be destroyed when the player leaves the room.
* The asset should have a PlayerState component, and can have other components like SyncedTransform, custom components, etc.
* @category Networking
*/
export declare class PlayerSync extends Behaviour {
/**
* This API is experimental and may change or be removed in the future.
* Create a PlayerSync instance at runtime from a given URL
* @example
* ```typescript
* const res = await PlayerSync.setupFrom("/assets/demo.glb");
* addComponent(res.asset?.asset, DragControls);
* addComponent(res.asset?.asset, SyncedTransform);
* scene.add(res.gameObject);
* ```
*/
static setupFrom(url: string, init?: Omit<ComponentInit<PlayerSync>, "asset">): Promise<PlayerSyncWithAsset>;
/** when enabled PlayerSync will automatically load and instantiate the assigned asset when joining a networked room */
autoSync: boolean;
/** This asset will be loaded and instantiated when PlayerSync becomes active and joins a networked room */
asset?: AssetReference;
/** Event called when an instance is spawned */
onPlayerSpawned?: EventList<Object3D>;
private _localInstance?;
awake(): void;
onEnable(): void;
onDisable(): void;
private onJoinedRoom;
getInstance(): Promise<IGameObject | null | undefined>;
destroyInstance: () => void;
private watchTabVisible;
}
export declare enum PlayerStateEvent {
OwnerChanged = "ownerChanged"
}
export declare interface PlayerStateOwnerChangedArgs {
playerState: PlayerState;
oldValue: string;
newValue: string;
}
export declare type PlayerStateEventCallback = (args: CustomEvent<PlayerStateOwnerChangedArgs>) => void;
export declare class PlayerState extends Behaviour {
private static _all;
/** all instances for all players */
static get all(): PlayerState[];
private static _local;
/** all instances for the local player */
static get local(): PlayerState[];
static getFor(obj: Object3D | Component): PlayerState | null | undefined;
static isLocalPlayer(obj: Object3D | Component): boolean;
private static _callbacks;
/**
* Add a callback for a PlayerStateEvent
*/
static addEventListener(event: PlayerStateEvent, cb: PlayerStateEventCallback): PlayerStateEventCallback;
static removeEventListener(event: PlayerStateEvent, cb: PlayerStateEventCallback): void;
private static dispatchEvent;
onOwnerChangeEvent: EventList<any>;
onFirstOwnerChangeEvent: EventList<any>;
hasOwner: boolean;
owner?: string;
/** when enabled PlayerSync will not destroy itself when not connected anymore */
dontDestroy: boolean;
get isLocalPlayer(): boolean;
private onOwnerChange;
awake(): void;
private onUserLeftRoom;
start(): Promise<void>;
/** this tells the server that this client has been destroyed and the networking message for the instantiate will be removed */
doDestroy(): void;
onDestroy(): void;
}
export {};