Options
All
  • Public
  • Public/Protected
  • All
Menu

Viewer - Interaction

Index

Enumerations

Classes

Interfaces

Type Aliases

Functions

Type Aliases

AngularRestrictionProperties

AngularRestrictionProperties: { angleStep?: number; angleStepEditable?: boolean } & SnapRestrictionProperties

AxisRestrictionProperties

AxisRestrictionProperties: { activationKeyPlane?: string; activationKeyX?: string; activationKeyY?: string; activationKeyZ?: string } & SnapRestrictionProperties

GridRestrictionProperties

GridRestrictionProperties: { gridUnit?: number; gridUnitEditable?: boolean } & SnapRestrictionProperties

Properties for the grid restriction

IAmbientLightApi

IAmbientLightApi: ILightApi

The api for an ambient light. An ambient light can be created by calling the addAmbientLight method.

IInteractionFilterOptions

IInteractionFilterOptions: ((interactionState: INTERACTION_STATE) => IIntersectionFilter)

Type declaration

InteractionEventResponseMapping

InteractionEventResponseMapping: { interaction.drag.end: IDragEvent; interaction.drag.move: IDragEvent; interaction.drag.start: IDragEvent; interaction.hover.off: IHoverEvent; interaction.hover.on: IHoverEvent; interaction.multiSelect.maximumNodes: IMultiSelectEvent; interaction.multiSelect.minimumNodes: IMultiSelectEvent; interaction.multiSelect.off: IMultiSelectEvent; interaction.multiSelect.on: IMultiSelectEvent; interaction.select.off: ISelectEvent; interaction.select.on: ISelectEvent }

Definition of the event response mapping for interaction events. This mapping is used to map the event type to the corresponding event interface.

Type declaration

NodeNameFilterPattern

NodeNameFilterPattern: string[]

Type declaration for a filter pattern used to hierarchically filter nodes of the scene tree by name.

OutputNodeNameFilterPatterns

OutputNodeNameFilterPatterns: {}

Dictionary type declaration for filter patterns used to filter nodes of the scene tree by name. The dictionary keys correspond to the IDs of outputs of a ShapeDiver model. The dictionary values are arrays of patterns for hierarchical matching of node names of the output. Each pattern is defined by an array of strings, which represent regular expressions that are applied to nodes of the hierarchy.

Example (simplified, disregarding the regular expression syntax):

{
   "OUTPUT_ID": [
     	["Node_a", "Node_b"], // matches nodes with the name "Node_a.Node_b" in the output with the ID "OUTPUT_ID"
     	["Node_a", "Node_c"], // matches nodes with the name "Node_a.Node_c" in the output with the ID "OUTPUT_ID"
     	["Node_a", "Node_d", "Node_e"] // matches nodes with the name "Node_a.Node_d.Node_e" in the output with the ID "OUTPUT_ID"
  ]
}

Type declaration

RestrictionDefinition

RestrictionDefinition: IPointRestrictionDefinition | ILineRestrictionDefinition | IPlaneRestrictionDefinition | ICameraPlaneRestrictionDefinition | IGeometryRestrictionDefinition

RestrictionProperties

RestrictionProperties: PointRestrictionProperties | PlaneRestrictionProperties | LineRestrictionProperties | GeometryRestrictionProperties | CameraPlaneRestrictionProperties

SnapRestrictionProperties

SnapRestrictionProperties: { activationKey?: string; enabled?: boolean; enabledEditable?: boolean; priority?: number }

Type declaration

  • Optional activationKey?: string

    The activation key of the restriction. If the key is not provided, no key is assigned. If the key is provided, the restriction is only active when the key is pressed.

  • Optional enabled?: boolean

    If the restriction should be enabled by default.

  • Optional enabledEditable?: boolean

    If the enabling or disabling of the restriction is allowed to the end user. If it is not editable, the default value for enabling or disabling the restriction is used.

  • Optional priority?: number

    Priority of the restriction. The higher the priority, the sooner the restriction is applied. If the priority is the same, the result that is closer to the original point is chosen.

Functions

addInteractionData

  • addInteractionData(node: ITreeNode, interactionDataSettings: { drag?: boolean; dragAnchors?: { id: string; position: vec3; rotation?: { angle: number; axis: vec3 } }[]; dragOrigin?: vec3; hover?: boolean; select?: boolean }, componentId: string): void

  • Add interaction data to the node.

    If the node already has interaction data, the function will remove the interaction data and add the new interaction data. Then the function will update the version of the node.

    Parameters

    • node: ITreeNode
    • interactionDataSettings: { drag?: boolean; dragAnchors?: { id: string; position: vec3; rotation?: { angle: number; axis: vec3 } }[]; dragOrigin?: vec3; hover?: boolean; select?: boolean }
      • Optional drag?: boolean
      • Optional dragAnchors?: { id: string; position: vec3; rotation?: { angle: number; axis: vec3 } }[]
      • Optional dragOrigin?: vec3
      • Optional hover?: boolean
      • Optional select?: boolean
    • componentId: string

    Returns void

calculateCombinedDraggedNodes

  • calculateCombinedDraggedNodes(currentState: { name: string; restrictionId: string; transformation: number[]; dragAnchorId?: string }[], draggedNodes: { name: string; restrictionId: string; transformation: number[]; dragAnchorId?: string }[]): { name: string; restrictionId: string; transformation: number[]; dragAnchorId?: string }[]

  • Parameters

    • currentState: { name: string; restrictionId: string; transformation: number[]; dragAnchorId?: string }[]
    • draggedNodes: { name: string; restrictionId: string; transformation: number[]; dragAnchorId?: string }[]

    Returns { name: string; restrictionId: string; transformation: number[]; dragAnchorId?: string }[]

checkNodeNameMatch

  • checkNodeNameMatch(node: ITreeNode, nameWithoutDisplayComponent: string, strictNaming?: boolean): boolean

  • This function checks if the name of the node matches the given name. The name is provided without the display component in the beginning. It is assumed that the node is in the correct display component.

    Parameters

    • node: ITreeNode
    • nameWithoutDisplayComponent: string
    • strictNaming: boolean = true

    Returns boolean

convertUserDefinedNameFilters

  • Convert the user-defined name-filters to filter patterns as used by useNodeInteractionData.

    The name filter is an array of dot-separated strings. Each string represents a pattern to hierarchically match node names. The first part of the pattern is the output name. The rest of the pattern correspond to hierarchical node names, which may contain the "*" character as a wildcard to match any node name or any part of the node name.

    Parameters

    • nameFilter: string[]

      The user-defined name filters to convert.

    • outputIdsToNamesMapping: {}

      A mapping of output IDs to output names for the session to be used.

      • [key: string]: string

    Returns OutputNodeNameFilterPatterns

    The filter pattern object to be used with useNodeInteractionData, useSelection, and other interaction hooks.

convertUserDefinedNameFiltersForInstances

  • Convert the user-defined name-filters to filter patterns as used by useNodeInteractionData.

    The name filter is an array of dot-separated strings. Each string represents a pattern to hierarchically match node names. The first part of the pattern is the instance ID. The rest of the pattern correspond to hierarchical node names, which may contain the "*" character as a wildcard to match any node name or any part of the node name.

    Parameters

    • nameFilter: string[]

      The user-defined name filters to convert.

    • instanceIds: string[]

      The IDs of the instances to be used.

    Returns OutputNodeNameFilterPatterns

    The filter pattern object to be used with useNodeInteractionData, useSelection, and other interaction hooks.

gatherNodesForPattern

  • gatherNodesForPattern(node: ITreeNode, pattern: NodeNameFilterPattern, outputApiName: string, result: {}, count?: number, strictNaming?: boolean): void

  • Recurse the scene tree downwards starting from the given node, gather all nodes that match the pattern, and add them to the result array.

    Parameters

    • node: ITreeNode

      The node to start traversing from. Typically this is the node of an output of a ShapeDiver model.

    • pattern: NodeNameFilterPattern

      The hierarchical pattern to check for. Each string of the pattern represents a regular expression for matching the node name.

    • outputApiName: string

      The name of the output API to be used for the concatenated node name.

    • result: {}

      The result object, matching nodes will be added here.

      • [nodeId: string]: { name: string; node: ITreeNode }
        • name: string
        • node: ITreeNode
    • count: number = 0

      The current index into the pattern array.

    • strictNaming: boolean = true

    Returns void

getInstanceNodeData

  • getInstanceNodeData(node: ITreeNode, strictNaming?: boolean): undefined | { nodeName: string; outputId: string }

  • Traverse the node hierarchy upwards to find the node that corresponds to an instance node. Return the instance id, and the original names concatenated using dots.

    We know that it is an instance node if it has a session API data in its parent. We return the instanceId as the outputId to be used in the other functions.

    Parameters

    • node: ITreeNode
    • strictNaming: boolean = true

    Returns undefined | { nodeName: string; outputId: string }

getNodeData

  • getNodeData(node: ITreeNode, strictNaming?: boolean): undefined | { nodeName: string; outputId: string; outputName?: string }

  • Traverse the node hierarchy upwards to find the node that corresponds to an output of the ShapeDiver model. Return the node itself, the corresponding output id and name, and the original names concatenated using dots.

    Parameters

    • node: ITreeNode

      The node to start the upwards traversal from.

    • strictNaming: boolean = true

    Returns undefined | { nodeName: string; outputId: string; outputName?: string }

getNodeName

  • getNodeName(node: ITreeNode, strictNaming: boolean): undefined | string

  • Get the name of the node. If the node has a ChunkData, return the name of the ChunkData. If strictNaming is true, return the original name of the node. If strictNaming is false, return the original name if it exists, otherwise return the name of the node.

    Parameters

    • node: ITreeNode
    • strictNaming: boolean

    Returns undefined | string

getNodesByName

  • getNodesByName(sessionApis: ISessionApi[], names: string[], strictNaming?: boolean): { name: string; node: ITreeNode }[]

  • Get the nodes within the session API by their names.

    Parameters

    • sessionApis: ISessionApi[]
    • names: string[]

      The names of the nodes.

    • strictNaming: boolean = true

    Returns { name: string; node: ITreeNode }[]

matchNodesWithPatterns

  • Try to match the given nodes with the patterns. For matching nodes, return the concatenated names of the nodes as required for setting values of interaction parameters.

    Parameters

    • patterns: OutputNodeNameFilterPatterns

      The patterns to match the node names.

    • nodes: ITreeNode[]

      The nodes to process.

    • strictNaming: boolean = true

    Returns string[]

    The concatenated names of the nodes that match the pattern.