Class LoopBlock

comments

inputsAreExclusive

onCodeIsReadyObservable

uniqueId

visibleInInspector

visibleOnFrame

buildId

• get buildId(): number

  Gets or sets the build Id

  Returns number

• set buildId(value: number): void

  Parameters

  • value: number

  Returns void

codeIsReady

• get codeIsReady(): boolean

  Gets a boolean indicating that this block has is code ready to be used

  Returns boolean

inputs

• get inputs(): NodeMaterialConnectionPoint[]

  Gets the list of input points

  Returns NodeMaterialConnectionPoint[]

isFinalMerger

• get isFinalMerger(): boolean

  Gets a boolean indicating that this block is an end block (e.g. it is generating a system value)

  Returns boolean

isInput

• get isInput(): boolean

  Gets a boolean indicating that this block is an input (e.g. it sends data to the shader)

  Returns boolean

isLoop

• get isLoop(): boolean

  Gets a boolean indicating if this block is a loop

  Returns boolean

isTeleportIn

• get isTeleportIn(): boolean

  Gets a boolean indicating if this block is a teleport in

  Returns boolean

isTeleportOut

• get isTeleportOut(): boolean

  Gets a boolean indicating if this block is a teleport out

  Returns boolean

isUnique

• get isUnique(): boolean

  Gets a boolean indicating that this block can only be used once per NodeMaterial

  Returns boolean

name

• get name(): string

  Gets the name of the block

  Returns string

• set name(newName: string): void

  Sets the name of the block. Will check if the name is valid.

  Parameters

  • newName: string

  Returns void

outputs

• get outputs(): NodeMaterialConnectionPoint[]

  Gets the list of output points

  Returns NodeMaterialConnectionPoint[]

target

• get target(): NodeMaterialBlockTargets

  Gets or sets the target of the block

  Returns NodeMaterialBlockTargets

• set target(value: NodeMaterialBlockTargets): void

  Parameters

  • value: NodeMaterialBlockTargets

  Returns void

willBeGeneratedIntoVertexShaderFromFragmentShader

• get willBeGeneratedIntoVertexShaderFromFragmentShader(): boolean

  Gets a boolean indicating that the code of this block will be promoted to vertex shader even if connected to fragment output

  Returns boolean

autoConfigure

• autoConfigure(
      material: NodeMaterial,
      additionalFilteringInfo?: (node: NodeMaterialBlock) => boolean,
  ): void

  Lets the block try to connect some inputs automatically

  Parameters

  • material: NodeMaterial

    defines the hosting NodeMaterial

  • additionalFilteringInfo: (node: NodeMaterialBlock) => boolean = ...

    optional additional filtering condition when looking for compatible blocks

  Returns void

bind

• bind(
      effect: Effect,
      nodeMaterial: NodeMaterial,
      mesh?: Mesh,
      subMesh?: SubMesh,
  ): void

  Bind data to effect. Will only be called for blocks with isBindable === true

  Parameters

  • effect: Effect

    defines the effect to bind data to

  • nodeMaterial: NodeMaterial

    defines the hosting NodeMaterial

  • Optionalmesh: Mesh

    defines the mesh that will be rendered

  • OptionalsubMesh: SubMesh

    defines the submesh that will be rendered

  Returns void

build

• build(state: NodeMaterialBuildState, activeBlocks: NodeMaterialBlock[]): boolean

  Compile the current node and generate the shader code

  Parameters

  • state: NodeMaterialBuildState

    defines the current compilation state (uniforms, samplers, current string)

  • activeBlocks: NodeMaterialBlock[]

    defines the list of active blocks (i.e. blocks to compile)

  Returns boolean

  true if already built

clone

• clone(scene: Scene, rootUrl?: string): NodeMaterialBlock | null

  Clone the current block to a new identical block

  Parameters

  • scene: Scene

    defines the hosting scene

  • rootUrl: string = ""

    defines the root URL to use to load textures and relative dependencies

  Returns NodeMaterialBlock | null

  a copy of the current block

connectTo

• connectTo(
      other: NodeMaterialBlock,
      options?: { input?: string; output?: string; outputSwizzle?: string },
  ): LoopBlock | undefined

  Connect current block with another block

  Parameters

  • other: NodeMaterialBlock

    defines the block to connect with

  • Optionaloptions: { input?: string; output?: string; outputSwizzle?: string }

    define the various options to help pick the right connections

  Returns LoopBlock | undefined

  the current block

dispose

• dispose(): void

  Release resources

  Returns void

getFirstAvailableInput

• getFirstAvailableInput(
      forOutput?: Nullable<NodeMaterialConnectionPoint>,
  ): NodeMaterialConnectionPoint | null

  Will return the first available input e.g. the first one which is not an uniform or an attribute

  Parameters

  • forOutput: Nullable<NodeMaterialConnectionPoint> = null

    defines an optional connection point to check compatibility with

  Returns NodeMaterialConnectionPoint | null

  the first available input or null

getFirstAvailableOutput

• getFirstAvailableOutput(
      forBlock?: Nullable<NodeMaterialBlock>,
  ): NodeMaterialConnectionPoint | null

  Will return the first available output e.g. the first one which is not yet connected and not a varying

  Parameters

  • forBlock: Nullable<NodeMaterialBlock> = null

    defines an optional block to check compatibility with

  Returns NodeMaterialConnectionPoint | null

  the first available input or null

getInputByName

• getInputByName(name: string): NodeMaterialConnectionPoint | null

  Find an input by its name

  Parameters

  • name: string

    defines the name of the input to look for

  Returns NodeMaterialConnectionPoint | null

  the input or null if not found

getOutputByName

• getOutputByName(name: string): NodeMaterialConnectionPoint | null

  Find an output by its name

  Parameters

  • name: string

    defines the name of the output to look for

  Returns NodeMaterialConnectionPoint | null

  the output or null if not found

getSiblingOutput

• getSiblingOutput(
      current: NodeMaterialConnectionPoint,
  ): NodeMaterialConnectionPoint | null

  Gets the sibling of the given output

  Parameters

  • current: NodeMaterialConnectionPoint

    defines the current output

  Returns NodeMaterialConnectionPoint | null

  the next output in the list or null

initialize

• initialize(state: NodeMaterialBuildState): void

  Initialize the block and prepare the context for build

  Parameters

  • state: NodeMaterialBuildState

    defines the state that will be used for the build

  Returns void

initializeDefines

• initializeDefines(defines: NodeMaterialDefines): void

  Initialize defines for shader compilation

  Parameters

  • defines: NodeMaterialDefines

    defines the material defines to update

  Returns void

isAnAncestorOf

• isAnAncestorOf(block: NodeMaterialBlock): boolean

  Checks if the current block is an ancestor of a given block

  Parameters

  • block: NodeMaterialBlock

    defines the potential descendant block to check

  Returns boolean

  true if block is a descendant

isConnectedInFragmentShader

• isConnectedInFragmentShader(): boolean

  Gets a boolean indicating that this connection will be used in the fragment shader

  Returns boolean

  true if connected in fragment shader

isReady

• isReady(
      mesh: AbstractMesh,
      nodeMaterial: NodeMaterial,
      defines: NodeMaterialDefines,
      useInstances?: boolean,
  ): boolean

  Checks if the block is ready

  Parameters

  • mesh: AbstractMesh

    defines the mesh to be rendered

  • nodeMaterial: NodeMaterial

    defines the node material requesting the update

  • defines: NodeMaterialDefines

    defines the material defines to update

  • useInstances: boolean = false

    specifies that instances should be used

  Returns boolean

  true if the block is ready

prepareDefines

• prepareDefines(
      defines: NodeMaterialDefines,
      nodeMaterial: NodeMaterial,
      mesh?: AbstractMesh,
      useInstances?: boolean,
      subMesh?: SubMesh,
  ): void

  Update defines for shader compilation

  Parameters

  • defines: NodeMaterialDefines

    defines the material defines to update

  • nodeMaterial: NodeMaterial

    defines the node material requesting the update

  • Optionalmesh: AbstractMesh

    defines the mesh to be rendered

  • useInstances: boolean = false

    specifies that instances should be used

  • OptionalsubMesh: SubMesh

    defines which submesh to render

  Returns void

provideFallbacks

• provideFallbacks(fallbacks: EffectFallbacks, mesh?: AbstractMesh): void

  Add potential fallbacks if shader compilation fails

  Parameters

  • fallbacks: EffectFallbacks

    defines the current prioritized list of fallbacks

  • Optionalmesh: AbstractMesh

    defines the mesh to be rendered

  Returns void

registerInput

• registerInput(
      name: string,
      type: NodeMaterialBlockConnectionPointTypes,
      isOptional?: boolean,
      target?: NodeMaterialBlockTargets,
      point?: NodeMaterialConnectionPoint,
  ): LoopBlock

  Register a new input. Must be called inside a block constructor

  Parameters

  • name: string

    defines the connection point name

  • type: NodeMaterialBlockConnectionPointTypes

    defines the connection point type

  • isOptional: boolean = false

    defines a boolean indicating that this input can be omitted

  • Optionaltarget: NodeMaterialBlockTargets

    defines the target to use to limit the connection point (will be VertexAndFragment by default)

  • Optionalpoint: NodeMaterialConnectionPoint

    an already created connection point. If not provided, create a new one

  Returns LoopBlock

  the current block

registerOutput

• registerOutput(
      name: string,
      type: NodeMaterialBlockConnectionPointTypes,
      target?: NodeMaterialBlockTargets,
      point?: NodeMaterialConnectionPoint,
  ): LoopBlock

  Register a new output. Must be called inside a block constructor

  Parameters

  • name: string

    defines the connection point name

  • type: NodeMaterialBlockConnectionPointTypes

    defines the connection point type

  • Optionaltarget: NodeMaterialBlockTargets

    defines the target to use to limit the connection point (will be VertexAndFragment by default)

  • Optionalpoint: NodeMaterialConnectionPoint

    an already created connection point. If not provided, create a new one

  Returns LoopBlock

  the current block

replaceRepeatableContent

• replaceRepeatableContent(
      vertexShaderState: NodeMaterialBuildState,
      defines: NodeMaterialDefines,
      mesh?: AbstractMesh,
  ): void

  Function called when a block is declared as repeatable content generator

  Parameters

  • vertexShaderState: NodeMaterialBuildState

    defines the current compilation state for the vertex shader

  • defines: NodeMaterialDefines

    defines the material defines to update

  • Optionalmesh: AbstractMesh

    defines the mesh to be rendered

  Returns void

updateUniformsAndSamples

• updateUniformsAndSamples(
      state: NodeMaterialBuildState,
      nodeMaterial: NodeMaterial,
      defines: NodeMaterialDefines,
      uniformBuffers: string[],
  ): void

  Add uniforms, samplers and uniform buffers at compilation time

  Parameters

  • state: NodeMaterialBuildState

    defines the state to update

  • nodeMaterial: NodeMaterial

    defines the node material requesting the update

  • defines: NodeMaterialDefines

    defines the material defines to update

  • uniformBuffers: string[]

    defines the list of uniform buffer names

  Returns void

validateBlockName

• validateBlockName(newName: string): boolean

  Validates the new name for the block node.

  Parameters

  • newName: string

    the new name to be given to the node.

  Returns boolean

  false if the name is a reserve word, else true.