Class MatrixCloner

The MatrixCloner clones and distributes given meshes in 3D space. If more than one mesh is provided, then the corresponding clones will be placed subsequently one after another starting in the x direction followed by y and z direction. The MatrixCloner returns an object with an important property: root. It is an invisible mesh, it's the anchor and parent of all generated clones, its position is the middle position of all generated clones. Transforming this root affects all underlying clones (childs) at once. The given input meshes will be made inactive during construction.

Param: mesh

The array of meshes/cloners to be cloned, meshes will be made inactive after construction.

Param: scene

Babylon scene.

Param: mcount

The number of clones in x,y and z direction. Default { x: 3, y: 3, z: 3 }.

Param: size

The distance from one clon to another in x,y and z direction. Default { x: 2, y: 2, z: 2 }.

Param: useInstances

Flag if clones should be technical "clones" or "instances". Default true.

Param: isPickable

Flag true if Cloner meshes should be pickable. Default false.

Hierarchy

  • Cloner
    • MatrixCloner

Constructors

constructor

Properties

_clones _count _effectors _frame _iModeRelative _index _instance_nr _mcount _mesh _rootNode _scene _size _useInstances isPickable instance_nr vOne vZero

Accessors

effectors mcount root size state

Methods

addEffector calcPos calcRot calcSize createClone createClones delete ePosition eReset eRotate eScale getScene setEnabled toMatrix toThin toThinOriginals update

Constructors

constructor

  • new MatrixCloner(mesh, scene, __namedParameters?): MatrixCloner

  • Parameters

    • mesh: Mesh[]
    • scene: Scene
    • __namedParameters: {
          iModeRelative: undefined | boolean;
          isPickable: undefined | boolean;
          mcount: undefined | {
              x: number;
              y: number;
              z: number;
          };
          size: undefined | {
              x: number;
              y: number;
              z: number;
          };
          useInstances: undefined | boolean;
      } = {}
      • iModeRelative: undefined | boolean
      • isPickable: undefined | boolean
      • mcount: undefined | {
            x: number;
            y: number;
            z: number;
        }
      • size: undefined | {
            x: number;
            y: number;
            z: number;
        }
      • useInstances: undefined | boolean

    Returns MatrixCloner

Properties

_clones

_clones: CMesh[]

_count

_count: undefined | number

_effectors

_effectors: IEffector[] = []

_frame

_frame: number

Private _iModeRelative

_iModeRelative: boolean

_index

_index: number

Private _instance_nr

_instance_nr: number

Private _mcount

_mcount: ICSVector3

_mesh

_mesh: Mesh[] = []

_rootNode

_rootNode: null | Mesh = null

_scene

_scene: Scene

Private _size

_size: ICSVector3

Private _useInstances

_useInstances: boolean

Private isPickable

isPickable: boolean

Static instance_nr

instance_nr: number

Static vOne

vOne: Vector3 = ...

Static vZero

vZero: Vector3 = ...

Accessors

effectors

  • get effectors(): IEffector[]

  • Returns IEffector[]

mcount

  • get mcount(): ICSVector3

  • Returns ICSVector3

  • set mcount(m): void

  • Sets the number of instances / clones in x, y and z directions.

    Parameters

    • m: ICSVector3

    Returns void

root

  • get root(): null | Mesh

  • Gets Cloner's root - an invisible mesh, the anchor and parent of all generated instances/clones. Transforming this root affects all underlying clones (childs) at once.

    Returns null | Mesh

size

state

  • get state(): {
        mcount: {
            x: number;
            y: number;
            z: number;
        };
        size: {
            x: number;
            y: number;
            z: number;
        };
    }

  • Returns {
        mcount: {
            x: number;
            y: number;
            z: number;
        };
        size: {
            x: number;
            y: number;
            z: number;
        };
    }

    • mcount: {
          x: number;
          y: number;
          z: number;
      }
      • x: number
      • y: number
      • z: number
    • size: {
          x: number;
          y: number;
          z: number;
      }
      • x: number
      • y: number
      • z: number

Methods

addEffector

  • addEffector(effector, sensitivity): void

  • Adds an effector to this Cloner and sets the sensitivity (1=full sensitivity, 0=no sensitivity ==ignore effector)

    Parameters

    Returns void

Private calcPos

Private calcRot

Private calcSize

createClone

  • createClone(parent): null | Mesh

  • Parameters

    • parent: CMesh

    Returns null | Mesh

Private createClones

  • createClones(start?): void

  • Parameters

    • start: number = 0

    Returns void

delete

  • delete(): void

  • Deletes all Cloner's children and disposes the root Node.

    Returns void

ePosition

  • ePosition(vec): Vector3

  • Parameters

    • vec: Vector3

    Returns Vector3

eReset

  • eReset(): void

  • Returns void

eRotate

  • eRotate(vec): Vector3

  • Parameters

    • vec: Vector3

    Returns Vector3

eScale

  • eScale(vec): Vector3

  • Parameters

    • vec: Vector3

    Returns Vector3

getScene

  • getScene(): Scene

  • Returns Scene

setEnabled

  • setEnabled(enabled): void

  • set the cloner's root node to the state of the flag (true=enabled)

    Parameters

    • enabled: boolean

    Returns void

toMatrix

  • toMatrix(): Matrix[]

  • Returns an array of matrices (scaling, rotation, position) of the Cloner meshes.

    Returns Matrix[]

toThin

  • toThin(addSelf?, rootName?): Mesh[]

  • Converts the Cloner to thin instances, then deletes this Cloner and returns an array of Cloner meshes. The source meshes are cloned, their clones set enabled. To display them use addSelf = true. All cloned source meshes get the new parent with the rootName. Be aware that the original Cloner will be disposed, so Cloner methods will not work anymore. Use the root node and its individual child meshes for further processing.

    Parameters

    • Optional addSelf: boolean

      If true, adds the source mesh to the matrix. Default false.

    • Optional rootName: string

      Allow to define the name of the root mesh which will be the parent of cloned source meshes and all thin instances. If empty, Cloner class name will be used for the name.

    Returns Mesh[]

toThinOriginals

  • toThinOriginals(addSelf?): Mesh[]

  • Converts all Cloner meshes to thin instances from the original meshes, then deletes this Cloner and returns an array of Cloner meshes. Be aware that instances of all those original meshes become disabled as well, so if they are used in other Cloners one may want to use toThin() method instead. If you don't need animations and so on you may convert Cloner to thin instances. It greatly reduces the number of objects iterating in the render loop.

    Parameters

    • Optional addSelf: boolean

      If true, adds the source mesh to the matrix. Default false.

    Returns Mesh[]

    The array of original meshes: Mesh[]

update

Settings

Member Visibility

Theme

On This Page

constructor_clones_count_effectors_frame_iModeRelative_index_instance_nr_mcount_mesh_rootNode_scene_size_useInstancesisPickableinstance_nrvOnevZeroeffectorsmcountrootsizestateaddEffectorcalcPoscalcRotcalcSizecreateClonecreateClonesdeleteePositioneReseteRotateeScalegetScenesetEnabledtoMatrixtoThintoThinOriginalsupdate