Class NodeRenderGraph

constructor

• new NodeRenderGraph(name: string, scene: Scene, options?: any): NodeRenderGraph

  Creates a new node render graph

  Parameters

  • name: string

    defines the name of the node render graph

  • scene: Scene

    defines the scene to use to execute the graph

  • Optionaloptions: any

    defines the options to use when creating the graph

  Returns NodeRenderGraph

attachedBlocks

comment

editorData

name

onBeforeBuildObservable

onBuildErrorObservable

outputBlock

snippetId

StaticCustomBlockDescriptions

StaticEditorURL

StaticSnippetUrl

frameGraph

• get frameGraph(): FrameGraph

  Gets the frame graph used by this node render graph

  Returns FrameGraph

onBuildObservable

• get onBuildObservable(): any

  Observable raised after the node render graph is built Note that this is the same observable as the one in the underlying FrameGraph!

  Returns any

options

• get options(): Immutable<INodeRenderGraphCreateOptions>

  Gets the options used to create this node render graph

  Returns Immutable<INodeRenderGraphCreateOptions>

buildAsync

• buildAsync(
      dontBuildFrameGraph?: boolean,
      waitForReadiness?: boolean,
      setAsSceneFrameGraph?: boolean,
  ): Promise<void>

  Build the final list of blocks that will be executed by the "execute" method. It also builds the underlying frame graph unless specified otherwise.

  Parameters

  • dontBuildFrameGraph: boolean = false

    If the underlying frame graph should not be built (default: false)

  • waitForReadiness: boolean = true

    If the method should wait for the frame graph to be ready before resolving (default: true). Note that this parameter has no effect if "dontBuildFrameGraph" is true.

  • setAsSceneFrameGraph: boolean = true

    If the built frame graph must be set as the scene's frame graph (default: true)

  Returns Promise<void>

clear

• clear(): void

  Clear the current graph

  Returns void

clone

• clone(name: string): NodeRenderGraph

  Makes a duplicate of the current node render graph. Note that you should call buildAsync() on the returned graph to make it usable.

  Parameters

  • name: string

    defines the name to use for the new node render graph

  Returns NodeRenderGraph

  the new node render graph

dispose

• dispose(): void

  Disposes the resources

  Returns void

edit

• edit(config?: any): Promise<void>

  Launch the node render graph editor

  Parameters

  • Optionalconfig: any

    Define the configuration of the editor

  Returns Promise<void>

  a promise fulfilled when the node editor is visible

execute

• execute(): void

  Execute the graph (the graph must have been built before!)

  Returns void

generateCode

• generateCode(): string

  Generate a string containing the code declaration required to create an equivalent of this node render graph

  Returns string

  a string

getBlockByName

• getBlockByName<T extends NodeRenderGraphBlock>(name: string): Nullable<T>

  Gets a block by its name

  Type Parameters

  • T extends NodeRenderGraphBlock

  Parameters

  • name: string

    defines the name of the block to retrieve

  Returns Nullable<T>

  the required block or null if not found

getBlockByPredicate

• getBlockByPredicate<T extends NodeRenderGraphBlock>(
      predicate: (block: NodeRenderGraphBlock) => boolean,
  ): Nullable<T>

  Get a block using a predicate

  Type Parameters

  • T extends NodeRenderGraphBlock

  Parameters

  • predicate: (block: NodeRenderGraphBlock) => boolean

    defines the predicate used to find the good candidate

  Returns Nullable<T>

  the required block or null if not found

getBlocksByPredicate

• getBlocksByPredicate<T extends NodeRenderGraphBlock>(
      predicate: (block: NodeRenderGraphBlock) => boolean,
  ): T[]

  Get all blocks that match a predicate

  Type Parameters

  • T extends NodeRenderGraphBlock

  Parameters

  • predicate: (block: NodeRenderGraphBlock) => boolean

    defines the predicate used to find the good candidate(s)

  Returns T[]

  the list of blocks found

getClassName

• getClassName(): string

  Gets the current class name ("NodeRenderGraph")

  Returns string

  the class name

getInputBlocks

• getInputBlocks(): NodeRenderGraphInputBlock[]

  Gets the list of input blocks attached to this material

  Returns NodeRenderGraphInputBlock[]

  an array of InputBlocks

getScene

• getScene(): Scene

  Gets the scene used by this node render graph

  Returns Scene

  the scene used by this node render graph

parseSerializedObject

• parseSerializedObject(source: any, merge?: boolean): void

  Clear the current graph and load a new one from a serialization object

  Parameters

  • source: any

    defines the JSON representation of the graph

  • merge: boolean = false

    defines whether or not the source must be merged or replace the current content

  Returns void

removeBlock

• removeBlock(block: NodeRenderGraphBlock): void

  Remove a block from the current graph

  Parameters

  • block: NodeRenderGraphBlock

    defines the block to remove

  Returns void

replaceCameraAsync

• replaceCameraAsync(
      currentCamera: Nullable<Camera>,
      newCamera: Camera,
      updateCameraToUseForPointers?: boolean,
      rebuildGraph?: boolean,
  ): Promise<boolean>

  Replaces a camera in all camera input blocks of this node render graph. If the current camera is found in any input block, it is replaced by the new camera, optionally updating the scene's pointer camera and rebuilding the graph.

  Parameters

  • currentCamera: Nullable<Camera>

    The camera to replace.

  • newCamera: Camera

    The new camera to assign to the matching input blocks.

  • updateCameraToUseForPointers: boolean = true

    If true (default), updates scene.cameraToUseForPointers to the new camera when a replacement occurs.

  • rebuildGraph: boolean = true

    If true (default), rebuilds the graph asynchronously after the replacement.

  Returns Promise<boolean>

  A promise that resolves to true if at least one input block was updated, false otherwise.

serialize

• serialize(selectedBlocks?: NodeRenderGraphBlock[]): any

  Serializes this node render graph in a JSON representation

  Parameters

  • OptionalselectedBlocks: NodeRenderGraphBlock[]

    defines the list of blocks to save (if null the whole node render graph will be saved)

  Returns any

  the serialized node render graph object

setToDefault

• setToDefault(): void

  Clear the current graph and set it to a default state

  Returns void

whenReadyAsync

• whenReadyAsync(timeStep?: number, maxTimeout?: number): Promise<void>

  Returns a promise that resolves when the node render graph is ready to be executed This method must be called after the graph has been built (NodeRenderGraph.build called)!

  Parameters

  • timeStep: number = 16

    Time step in ms between retries (default is 16)

  • maxTimeout: number = 10000

    Maximum time in ms to wait for the graph to be ready (default is 10000)

  Returns Promise<void>

  The promise that resolves when the graph is ready

StaticCreateDefaultAsync

• CreateDefaultAsync(
      name: string,
      scene: Scene,
      nodeRenderGraphOptions?: any,
  ): Promise<NodeRenderGraph>

  Creates a new node render graph set to default basic configuration

  Parameters

  • name: string

    defines the name of the node render graph

  • scene: Scene

    defines the scene to use

  • OptionalnodeRenderGraphOptions: any

    defines options to use when creating the node render graph

  Returns Promise<NodeRenderGraph>

  a new NodeRenderGraph

StaticParse

• Parse(
      source: any,
      scene: Scene,
      nodeRenderGraphOptions?: any,
      skipBuild?: boolean,
  ): NodeRenderGraph

  Creates a node render graph from parsed graph data

  Parameters

  • source: any

    defines the JSON representation of the node render graph

  • scene: Scene

    defines the scene to use

  • OptionalnodeRenderGraphOptions: any

    defines options to use when creating the node render

  • skipBuild: boolean = true

    defines whether to skip building the node render graph (default is true)

  Returns NodeRenderGraph

  a new node render graph

StaticParseFromSnippetAsync

• ParseFromSnippetAsync(
      snippetId: string,
      scene: Scene,
      nodeRenderGraphOptions?: any,
      nodeRenderGraph?: NodeRenderGraph,
      skipBuild?: boolean,
  ): Promise<NodeRenderGraph>

  Creates a node render graph from a snippet saved by the node render graph editor

  Parameters

  • snippetId: string

    defines the snippet to load

  • scene: Scene

    defines the scene to use

  • OptionalnodeRenderGraphOptions: any

    defines options to use when creating the node render graph

  • OptionalnodeRenderGraph: NodeRenderGraph

    defines a node render graph to update (instead of creating a new one)

  • skipBuild: boolean = true

    defines whether to skip building the node render graph (default is true)

  Returns Promise<NodeRenderGraph>

  a promise that will resolve to the new node render graph