Options
All
  • Public
  • Public/Protected
  • All
Menu

Class CatanaCollision

Manages the communication between Catana's back/frontend and the WebGPU classes This achieves a nice isolation of the WebGPU code, so very few components of Catana have to be aware of its inner workings. This class is one of these few components

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Object literals

Constructors

Private constructor

Properties

Private _collisions

_collisions: null | BitArray = null

A bit array where each bit represents an atom. The atom index in the bit array matches the atom index in the atom store of its structure When more components/structures are taking part in collision detection, the atom indexes in the bit array are offset by the number of atoms of all previous components

Example: Component A has 10 atoms Component B has 30 atoms Component C has 20 atoms _collisions.get(5) -> 6th atom of Component A _collisions.get(12) -> 3rd atom of Component B _collisions.get(40) -> 1st atom of Component C

Private Readonly _componentSignals

_componentSignals: keyof (() => void)[]

Private Readonly _components

_components: keyof AtomicComponent[]

Private Readonly _perComp_atomCount

_perComp_atomCount: keyof number[]

Private Readonly algorithm

algorithm: WgCollisionAlgorithm

Private Readonly boundingBoxMesh

boundingBoxMesh: LineSegments

Private boundingBoxVisible

boundingBoxVisible: boolean = true

Readonly domElement

domElement: HTMLCanvasElement

Private isProcessing

isProcessing: boolean = false

Private lastCamMatrix

lastCamMatrix: null | Matrix4 = null

Private lastCamProjMat

lastCamProjMat: null | Matrix4 = null

Private processing

processing: null | ProcessData = null

Static Private Readonly DEBUG_NAME

DEBUG_NAME: "CatanaCollision" = "CatanaCollision"

Accessors

collisions

components

Protected renderableIndex

  • get renderableIndex(): number

Static pixelwiseDataTarget

  • get pixelwiseDataTarget(): WebGLRenderTarget

Methods

clickLeft

  • clickLeft(x: number, y: number, s: Stage): boolean

Private dispatch

  • dispatch(component: Component, start: number, end: number): void

dispose

  • dispose(): void

downLeft

  • downLeft(x: number, y: number, s: Stage): boolean

dragLeft

  • dragLeft(x: number, y: number, s: Stage): boolean

Private forEachComponent

  • forEachComponent(callback: (c: Component, atomStart: number, atomEnd: number) => void): void

getError

Protected getPixel

  • getPixel(x: number, y: number, r: WebGLRenderer): null | Vector3

hover

  • hover(x: number, y: number, s: Stage): boolean

Private process

recalculate

  • WARNING: This function has not been tested thoroughly. The text below describes the intended behavior This function is not used currently. To recalculate atom positions, simply Stop collision detection and Start again

    See this.updateComponent to understand how discrepancies between CPU atoms and GPU atoms can occur. This method recalculates the atom positions of the given component and uploads those to the GPU so that they again match.

    Parameters

    Returns Promise<void>

render

  • render(r: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera, target: WebGLRenderTarget, superSampleIndex: number): void

setBoxVisible

  • setBoxVisible(visible: boolean): void

setCollisionParams

  • setCollisionParams(params: { lenience: number }): void

setRenderingParams

  • setRenderingParams(params: { color?: undefined | string; lenience?: undefined | number; mode?: "x" | "o" | WgRendCollisionShaderMode; opacity?: undefined | number; radius?: undefined | number; thickness?: undefined | number }): void

  • Parameters

    • params: { color?: undefined | string; lenience?: undefined | number; mode?: "x" | "o" | WgRendCollisionShaderMode; opacity?: undefined | number; radius?: undefined | number; thickness?: undefined | number }
      • Optional color?: undefined | string
      • Optional lenience?: undefined | number
      • Optional mode?: "x" | "o" | WgRendCollisionShaderMode
      • Optional opacity?: undefined | number
      • Optional radius?: undefined | number
      • Optional thickness?: undefined | number

    Returns void

setSize

  • setSize(width: number, height: number): Promise<void>

start

  • start(): Promise<void>

  • Performs the first iteration of the collision detection It is recommended calling this method before performing any updates. Something may break otherwise

    Returns Promise<void>

upLeft

  • upLeft(x: number, y: number, s: Stage): boolean

Private update

  • update(): Promise<void>

  • Download collision data from the GPU and compare with current collision data on the CPU If there are any changes (per component), dispatch a collisionChanged signal (per component)

    Returns Promise<void>

Private updateComponent

  • When a component's matrix is uptated (see this.updateComponent), we do not reupload all atom position to the GPU, instead we upload the new matrix to the GPU and retransform the atoms belonging to this component. This process, however, leads to imprecision in the collision detection, where the GPU atom positions being used for detection do not match the GPU atom positions perfectly.

    To recalculate atom positions, simply Stop collision detection and Start again

    Parameters

    Returns void

Static Private createComponentObject

Static fromComponents

  • Initializes a CatanaCollision instance based on the given components

    Parameters

    • components: AtomicComponent[]

      The components that will take part in collision detection

    • viewer: Viewer

      The viewer where the collision will be visualized

    • radius: number

      The radius value of the collision rendering (negative values have special meaning... see WgRendCollisionShader > WgRendCollisionShaderRadiusMode)

    • mode: "x" | "o" | WgRendCollisionShaderMode

      The mode of the collision rendering markers (like X or O; see WgRendCollisionShader > WgRendCollisionShaderMode)

    • color: string

      The color of the rendered markers

    • opacity: number

      The opacity of the rendered markers

    • lenience: number

      How lenient the collision detection should be (also may have an effect in the rendering)

    • thickness: number

      The thickness of the rendered markers

    Returns Promise<string | CatanaCollision>

Static fromStage

  • Initializes a CatanaCollision instanced based on the given Stage All StructureComponents and CgStructureComponents in the stage will take part in collision detection See CatanaCollision.fromComponents for a more detailed description of all parameters

    Parameters

    Returns Promise<string | CatanaCollision>

Static Private getMode

Object literals

Readonly signals

signals: object

collisionChanged

collisionChanged: Signal<T> = new Signal()

errorChanged

errorChanged: Signal<T> = new Signal()

Generated using TypeDoc