@polygonjs/polygonjs
Version:
node-based WebGL 3D engine https://polygonjs.com
272 lines (271 loc) • 10.2 kB
TypeScript
import { ActorsManager } from './utils/ActorsManager';
import { SceneCamerasController } from './utils/SceneCamerasController';
import { Cooker } from './utils/Cooker';
import { SceneCookController } from './utils/CookController';
import { CoreGraph } from '../../core/graph/CoreGraph';
import { CorePerformance } from '../../core/performance/CorePerformance';
import { DispatchController } from './utils/DispatchController';
import { SceneExpressionsController } from './utils/SceneExpressionsController';
import { SceneLifeCycleController } from './utils/LifeCycleController';
import { LoadingController } from './utils/LoadingController';
import { MissingReferencesController } from './utils/missingReferences/MissingReferencesController';
import { GraphNodesController } from './utils/GraphNodesController';
import { NodesController } from './utils/NodesController';
import { SceneEventsDispatcher } from './utils/events/EventsDispatcher';
import { ObjectsController } from './utils/ObjectsController';
import { ScenePerformanceMonitor } from './utils/ScenePerformanceMonitor';
import { ReferencesController } from './utils/ReferencesController';
import { onTimeTickHook, TimeController, TimeControllerUpdateTimeOptions } from './utils/TimeController';
import { UniformsController } from './utils/UniformsController';
import { ViewersRegister } from './utils/ViewersRegister';
import { SceneWebGLController } from './utils/WebGLController';
import { WindowController } from './utils/WindowController';
import { SceneAssetsController } from './utils/AssetsController';
import { SceneTraverserController } from './utils/SceneTraverser';
import { BaseNodeType } from '../nodes/_Base';
import { ObjNodeChildrenMap } from '../poly/registers/nodes/Obj';
import { Constructor, valueof } from '../../types/GlobalTypes';
import { Raycaster, Scene, WebGLRenderer } from 'three';
import { SceneRenderersRegister, RegisterRendererOptions } from './utils/SceneRenderersRegister';
import { NodeCreateOptions } from '../nodes/utils/hierarchy/ChildrenController';
import { SceneWebXRController } from './utils/WebXREventsController';
import { CoreObjectType, ObjectContent } from '../../core/geometry/ObjectContent';
import { CoreParamSerializer } from '../params/utils/CoreParamSerializer';
import type { ParamType } from '../poly/ParamType';
interface PolySceneCreateOptions {
root: NodeCreateOptions;
paramsSerializerClass?: typeof CoreParamSerializer<ParamType>;
}
type SceneBatchUpdateCallback = () => void | Promise<void>;
interface UpdateState {
scene: Scene;
}
/**
*
*
* PolyScene contains all nodes within a scene.
*
*/
export declare class PolyScene {
/**
* Returns the THREE.Scene.
*
* @remarks
*
* Read more about how to use a THREE.Scene on [THREE's documentation](https://threejs.org/docs/?q=scene#api/en/scenes/Scene)
*
*/
threejsScene(): Scene;
private _uuid;
setUuid(uuid: string): string;
get uuid(): string;
private _name;
setName(newName: string): string;
static sanitizeName(newName: string): string;
name(): string | undefined;
protected _camerasController: SceneCamerasController | undefined;
get camerasController(): SceneCamerasController;
/**
* Returns the camera object that has been set as main
*
*/
mainCamera(): Promise<import("three").Camera | null>;
private _cooker;
get cooker(): Cooker;
private _actorsManager;
get actorsManager(): ActorsManager;
private _assetsController;
get assets(): SceneAssetsController;
readonly cookController: SceneCookController;
/**
* Returns a promise to wait for all nodes to have cooked when loading a scene.
*
*/
waitForCooksCompleted(): Promise<void>;
private _dispatchController;
get dispatchController(): DispatchController;
private _eventsDispatcher;
get eventsDispatcher(): SceneEventsDispatcher;
private _webXRController;
get webXR(): SceneWebXRController;
/**
* When using Polygonjs viewers, a raycaster is created to use mouse events and detect if there are any object under the cursor.
* But if no viewer is created, such as when [importing a scene in react three fiber](/docs/integrations/react_three_fiber),
* It is then useful to give a raycaster.
*
*/
setRaycaster(raycaster: Raycaster): void;
private _graph;
get graph(): CoreGraph;
readonly lifecycleController: SceneLifeCycleController;
readonly loadingController: LoadingController;
readonly missingExpressionReferencesController: MissingReferencesController;
readonly expressionsController: SceneExpressionsController;
readonly nodesController: NodesController;
readonly graphNodesController: GraphNodesController;
readonly renderersRegister: SceneRenderersRegister;
/**
* Creates a new node.
*
* nodeClass can be either a string or a node class. Both examples below work:
*
* - polyScene.createNode('box'): returns a BoxSopNode
* - polyScene.createNode(boxSopNode): returns a BoxSopNode
*
*/
createNode<S extends keyof ObjNodeChildrenMap>(nodeClass: S, options?: NodeCreateOptions): ObjNodeChildrenMap[S];
createNode<K extends valueof<ObjNodeChildrenMap>>(nodeClass: Constructor<K>, options?: NodeCreateOptions): K;
/**
* returns all nodes with a given type
*
* - polyScene.nodesByType('box'): returns all BoxSopNodes
*/
nodesByType(type: string): BaseNodeType[];
protected _objectsController: ObjectsController;
get objectsController(): ObjectsController;
/**
* returns a THREE.Object3D whose name matches the mask
*
*/
findObjectByMask<T extends CoreObjectType>(mask: string): ObjectContent<T> | undefined;
/**
* returns a list THREE.Object3Ds whose names matche the mask
*
*/
objectsByMask<T extends CoreObjectType>(mask: string, parent?: ObjectContent<T>): ObjectContent<T>[];
protected _referencesController: ReferencesController;
get referencesController(): ReferencesController;
protected _performance: CorePerformance | undefined;
get performance(): CorePerformance;
readonly perfMonitor: ScenePerformanceMonitor;
protected _viewersRegister: ViewersRegister | undefined;
get viewersRegister(): ViewersRegister;
readonly sceneTraverser: SceneTraverserController;
/**
* updates Polygonjs scene internals. This is called automatically when using Polygonjs viewers,
* but you would need to call it yourself in the render loop when adding your scene to threejs or react-three-fiber.
* See [https://polygonjs.com/docs/integrations](https://polygonjs.com/docs/integrations)
*
*/
update(delta: number, state?: UpdateState): void;
readonly timeController: TimeController;
/**
* sets the current frame
*
*/
setFrame(frame: number): void;
setFrameToStart(): void;
/**
* returns the current frame
*
*/
frame(): number;
/**
* returns the current time
*
*/
time(): number;
maxFrame(): number;
/**
* starts playing the scene
*
*/
play(): void;
/**
* pauses the scene
*
*/
pause(): void;
/**
* increments the time
*
*/
incrementTime(options?: TimeControllerUpdateTimeOptions): void;
/**
* increments the time if the scene is playing()
*
*/
incrementTimeIfPlaying(options?: TimeControllerUpdateTimeOptions): void;
/**
* registers a renderer
*
*/
registerRenderer(renderer: WebGLRenderer, options?: RegisterRendererOptions): void;
private _uniformsController;
get uniformsController(): UniformsController;
private _webglController;
get webglController(): SceneWebGLController;
private _windowController;
get windowController(): WindowController;
constructor(options?: PolySceneCreateOptions);
private _disposed;
dispose(): void;
disposed(): boolean;
private _paramSerializerClass?;
paramSerializerClass(): {
new (param: import("../params/_Base").TypedParam<ParamType>): CoreParamSerializer<ParamType>;
} | undefined;
/**
* batchUpdates can be useful to set multiple parameter values without triggering a recook for each update.
*
*/
batchUpdates(callback: SceneBatchUpdateCallback): Promise<void>;
/**
* returns a node based on its path
*
* - polyScene.node('/geo1')
*
*/
node(path: string): BaseNodeType | import("../nodes/manager/Root").RootManagerNode | null;
/**
* returns the root node
*
*/
root(): import("../nodes/manager/Root").RootManagerNode;
/**
* traverse all nodes and runs a callback for each
*
*/
traverseNodes(callback: (node: BaseNodeType) => void): void;
/**
* registers a BeforeTick callback. BeforeTick callbacks are run before updating the frame (and therefore before any time dependent node has changed)
*
*/
registerOnBeforeTick(callbackName: string, callback: onTimeTickHook): void;
/**
* unregisters BeforeTick callback
*
*/
unRegisterOnBeforeTick(callbackName: string): void;
/**
* Returns the list registered BeforeTick callback names
*
*/
registeredBeforeTickCallbacks(): Map<string, onTimeTickHook>;
/**
* return true if a callback is registered with that name
*
*/
hasBeforeTickCallback(callbackName: string): boolean;
/**
* registers AfterTick callback. AfterTick callbacks are run after updating the frame (and therefore after any time dependent node has changed)
*
*/
registerOnAfterTick(callbackName: string, callback: onTimeTickHook): void;
/**
* unregisters AfterTick callback
*
*/
unRegisterOnAfterTick(callbackName: string): void;
/**
* Returns the list registered AfterTick callback names
*
*/
registeredAfterTickCallbacks(): Map<string, onTimeTickHook>;
/**
* return true if a callback is registered with that name
*
*/
hasAfterTickCallback(callbackName: string): boolean;
}
export {};