PolyScene contains all nodes within a scene.






## Methods



### threejsScene
``` typescript
.threejsScene(): Scene
```
Returns the THREE.Scene.





Read more about how to use a THREE.Scene on [THREE's documentation](https://threejs.org/docs/?q=scene#api/en/scenes/Scene)





### mainCamera
``` typescript
.mainCamera(): void
```
Returns the camera object that has been set as main





### waitForCooksCompleted
``` typescript
.waitForCooksCompleted(): Promise<void>
```
Returns a promise to wait for all nodes to have cooked when loading a scene.





### setRaycaster
``` typescript
.setRaycaster(raycaster: Raycaster): void
```
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.





### createNode
``` typescript
.createNode(nodeClass: S, options?: NodeCreateOptions): ObjNodeChildrenMap[S]
```
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





### nodesByType
``` typescript
.nodesByType(type: string): BaseNodeType[]
```
returns all nodes with a given type


- polyScene.nodesByType('box'): returns all BoxSopNodes




### findObjectByMask
``` typescript
.findObjectByMask(mask: string): ObjectContent<T> | undefined
```
returns a THREE.Object3D whose name matches the mask





### objectsByMask
``` typescript
.objectsByMask(mask: string, parent?: ObjectContent<T>): ObjectContent<T>[]
```
returns a list THREE.Object3Ds whose names matche the mask





### update
``` typescript
.update(delta: number, state?: UpdateState): void
```
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)





### setFrame
``` typescript
.setFrame(frame: number): void
```
sets the current frame





### frame
``` typescript
.frame(): number
```
returns the current frame





### time
``` typescript
.time(): number
```
returns the current time





### play
``` typescript
.play(): void
```
starts playing the scene





### pause
``` typescript
.pause(): void
```
pauses the scene





### incrementTime
``` typescript
.incrementTime(options?: TimeControllerUpdateTimeOptions): void
```
increments the time





### incrementTimeIfPlaying
``` typescript
.incrementTimeIfPlaying(options?: TimeControllerUpdateTimeOptions): void
```
increments the time if the scene is playing()





### registerRenderer
``` typescript
.registerRenderer(renderer: WebGLRenderer, options?: RegisterRendererOptions): void
```
registers a renderer





### batchUpdates
``` typescript
.batchUpdates(callback: SceneBatchUpdateCallback): void
```
batchUpdates can be useful to set multiple parameter values without triggering a recook for each update.





### node
``` typescript
.node(path: string): void
```
returns a node based on its path


- polyScene.node('/geo1')





### root
``` typescript
.root(): void
```
returns the root node





### traverseNodes
``` typescript
.traverseNodes(callback: (node: BaseNodeType) => void): void
```
traverse all nodes and runs a callback for each





### registerOnBeforeTick
``` typescript
.registerOnBeforeTick(callbackName: string, callback: onTimeTickHook): void
```
registers a BeforeTick callback. BeforeTick callbacks are run before updating the frame (and therefore before any time dependent node has changed)





### unRegisterOnBeforeTick
``` typescript
.unRegisterOnBeforeTick(callbackName: string): void
```
unregisters BeforeTick callback





### registeredBeforeTickCallbacks
``` typescript
.registeredBeforeTickCallbacks(): Map<string, onTimeTickHook>
```
Returns the list registered BeforeTick callback names





### hasBeforeTickCallback
``` typescript
.hasBeforeTickCallback(callbackName: string): boolean
```
return true if a callback is registered with that name





### registerOnAfterTick
``` typescript
.registerOnAfterTick(callbackName: string, callback: onTimeTickHook): void
```
registers AfterTick callback. AfterTick callbacks are run after updating the frame (and therefore after any time dependent node has changed)





### unRegisterOnAfterTick
``` typescript
.unRegisterOnAfterTick(callbackName: string): void
```
unregisters AfterTick callback





### registeredAfterTickCallbacks
``` typescript
.registeredAfterTickCallbacks(): Map<string, onTimeTickHook>
```
Returns the list registered AfterTick callback names





### hasAfterTickCallback
``` typescript
.hasAfterTickCallback(callbackName: string): boolean
```
return true if a callback is registered with that name