CraneManipulator | @motor/core

Hierarchy

CraneManipulator

Index

Constructors

constructor

Properties

Methods

Constructors

constructor

new CraneManipulator(options: { crane: Mod; craneConfig?: CraneConfig; nodeNameMap?: NodeNameMap; targetOpt: { height: number; length: number; weight: number; width: number }; viewer: Viewer; validatePoleLength?: any }): CraneManipulator

Parameters
- options: { crane: Mod; craneConfig?: CraneConfig; nodeNameMap?: NodeNameMap; targetOpt: { height: number; length: number; weight: number; width: number }; viewer: Viewer; validatePoleLength?: any }
  - crane: Mod
  - Optional craneConfig?: CraneConfig
  - Optional nodeNameMap?: NodeNameMap
  - targetOpt: { height: number; length: number; weight: number; width: number }
    - height: number
    - length: number
    - weight: number
    - width: number
  - viewer: Viewer
  - validatePoleLength: function
    - validatePoleLength(poleLength: number, weight: number, distance: number): boolean
    - Parameters
      - poleLength: number
      - weight: number
      - distance: number
      Returns boolean
Returns CraneManipulator

Properties

_curAxisAngle

_curAxisAngle: number

_curHookRopeLength

_curHookRopeLength: number

_curMainPoleAngle

_curMainPoleAngle: number

_curPoleLength

_curPoleLength: number

_dftAxisAngle

_dftAxisAngle: number

_dftHookRopeLength

_dftHookRopeLength: number

_dftMainPoleAngle

_dftMainPoleAngle: number

_dftPoleLength

_dftPoleLength: number

_dftRopeLength

_dftRopeLength: number

_eachPoleLength

_eachPoleLength: number

_enableMainPoleCollision

_enableMainPoleCollision: boolean

_enableRopeCollision

_enableRopeCollision: boolean

_enableTargetCollision

_enableTargetCollision: boolean

_hookHeight

_hookHeight: number

_isUseCombinedAnimation

_isUseCombinedAnimation: boolean

_minRopeLength

_minRopeLength: number

_poleLength

_poleLength: number

_recordFinished

_recordFinished: boolean

_ropeHookOffset

_ropeHookOffset: number

_showTrackLine

_showTrackLine: boolean

_targetHeight

_targetHeight: number

_targetLength

_targetLength: number

_targetRotateZAngle

_targetRotateZAngle: number

_targetWeight

_targetWeight: number

_targetWidth

_targetWidth: number

animateEvent

animateEvent: Event

animateQueue

animateQueue: AnimateItem[]

animatedEndQueue

animatedEndQueue: AnimateItem[]

collisionPointAry

collisionPointAry: { name: string; ptAry: Vector3[]; time: JulianDate }[]

crane

crane: Model

craneMod

craneMod: Mod

craneRotateAngle

craneRotateAngle: number

curAnimateItem

curAnimateItem: undefined | AnimateItem

curAnimateItemIdx

curAnimateItemIdx: number

dftCenter

dftCenter: Vector3

dftPoleEnd

dftPoleEnd: Vector3

dftPoleStart

dftPoleStart: Vector3

endTime

endTime: JulianDate

lineAndTimeAry

lineAndTimeAry: LineAndTime[]

modelMatrix

modelMatrix: Matrix4

nodeNameMap

nodeNameMap: NodeNameMap

pointAndTimeAry

pointAndTimeAry: PointAndTime[]

proj

proj: Proj

startTime

startTime: JulianDate

trackLineAry

trackLineAry: { lineAry: [Vector3, Vector3][]; name: string; time: JulianDate }[]

validatePoleLength

validatePoleLength: (poleLength: number, weight: number, distance: number) => boolean

Type declaration

- (poleLength: number, weight: number, distance: number): boolean
- Parameters
  - poleLength: number
  - weight: number
  - distance: number
  Returns boolean

viewer

viewer: Viewer

Accessors

axisAngle

get axisAngle(): number

Returns number

axisNode

get axisNode(): ModelNode

Returns ModelNode

clockMultiplier

get clockMultiplier(): number
set clockMultiplier(multiplier: number): void

Returns number
Parameters
- multiplier: number
Returns void

curRopeLength

get curRopeLength(): number

Returns number

enableMainPoleCollision

get enableMainPoleCollision(): boolean
set enableMainPoleCollision(enable: boolean): void

Returns boolean
Parameters
- enable: boolean
Returns void

enableRopeCollision

get enableRopeCollision(): boolean
set enableRopeCollision(enable: boolean): void

Returns boolean
Parameters
- enable: boolean
Returns void

enableTargetCollision

get enableTargetCollision(): boolean
set enableTargetCollision(enable: boolean): void

Returns boolean
Parameters
- enable: boolean
Returns void

hookCollectionNode

get hookCollectionNode(): ModelNode

Returns ModelNode

hookNode

get hookNode(): ModelNode

Returns ModelNode

hookPositionWC

get hookPositionWC(): Cartesian3

Returns Cartesian3

hookRopeNode

get hookRopeNode(): ModelNode

Returns ModelNode

hookRopeStartNode

get hookRopeStartNode(): ModelNode

Returns ModelNode

isUseCombinedAnimation

get isUseCombinedAnimation(): boolean
set isUseCombinedAnimation(isUse: boolean): void

Returns boolean
Parameters
- isUse: boolean
Returns void

mainAxisNode

get mainAxisNode(): ModelNode

Returns ModelNode

mainAxisNodePos

get mainAxisNodePos(): Cartesian3

Returns Cartesian3

mainPoleAngle

get mainPoleAngle(): number

Returns number

mainPoleLiftNode

get mainPoleLiftNode(): ModelNode

Returns ModelNode

mainPoleLiftPos

get mainPoleLiftPos(): Cartesian3

Returns Cartesian3

minRopeLength

get minRopeLength(): number
set minRopeLength(minRopeLength: number): void

Returns number
Parameters
- minRopeLength: number
Returns void

multiplier

get multiplier(): number
set multiplier(multiplier: number): void

Returns number
Parameters
- multiplier: number
Returns void

pole0Node

get pole0Node(): ModelNode

Returns ModelNode

pole0NodePos

get pole0NodePos(): Cartesian3

Returns Cartesian3

poleLength

get poleLength(): number

Returns number

ropeLength

get ropeLength(): number

Returns number

ropeStartPos

get ropeStartPos(): Cartesian3

Returns Cartesian3

showTrackLine

get showTrackLine(): boolean
set showTrackLine(show: boolean): void

Returns boolean
Parameters
- show: boolean
Returns void

Methods

_setHookLiftAngle

_setHookLiftAngle(angle: number): void

Parameters
- angle: number
Returns void

_setHookRopeChangeSideEffect

_setHookRopeChangeSideEffect(offsetX: number): void

Parameters
- offsetX: number
Returns void

_setHookRopeLength

_setHookRopeLength(ropeLen: number): void

Parameters
- ropeLen: number
Returns void

_setMainAxisRotate

_setMainAxisRotate(angle: number): void

Parameters
- angle: number
Returns void

_setMainPoleAngle

_setMainPoleAngle(angle: number): void

Parameters
- angle: number
Returns void

_setMainPoleLength

_setMainPoleLength(stretchLength: number): void

Parameters
- stretchLength: number
Returns void

addAnimate

addAnimate(animateItem: AnimateItem): void

Parameters
- animateItem: AnimateItem
Returns void

calcEachPoleLength

calcEachPoleLength(stretchLength: number, eachPoleLength?: number, count?: number): number[]

Parameters
- stretchLength: number
- Optional eachPoleLength: number
- Optional count: number
Returns number[]

calculateHookPos

calculateHookPos(startPos: Vector3, rotateCenter: Vector3, liftCenter: Vector3, rotateAxisAngle: number, liftAngle: number, poleLength: number): void

Parameters
- startPos: Vector3
- rotateCenter: Vector3
- liftCenter: Vector3
- rotateAxisAngle: number
- liftAngle: number
- poleLength: number
Returns void

calculatePole0Pos

calculatePole0Pos(rotateAxisAngle: number, mainPoleAngle: number, poleLength: number, ropeLength: number): void

Parameters
- rotateAxisAngle: number
- mainPoleAngle: number
- poleLength: number
- ropeLength: number
Returns void

calculatePosLift

calculatePosLift(startPos: Vector3, liftCenter: Vector3, liftAngle: number): Cartesian3

Parameters
- startPos: Vector3
- liftCenter: Vector3
- liftAngle: number
Returns Cartesian3

calculatePosLift2

calculatePosLift2(startPos: Vector3, liftCenter: Vector3, angle: number): Cartesian3

Parameters
- startPos: Vector3
- liftCenter: Vector3
- angle: number
Returns Cartesian3

calculatePosRotate

calculatePosRotate(startPos: Vector3, rotateCenter: Vector3, rotateAxisAngle: number): Cartesian3

Parameters
- startPos: Vector3
- rotateCenter: Vector3
- rotateAxisAngle: number
Returns Cartesian3

checkCollision

checkCollision(): Promise<{ name: string; ptAry: Vector3[]; time: JulianDate }[]>

Returns Promise<{ name: string; ptAry: Vector3[]; time: JulianDate }[]>

checkTargetCollision

checkTargetCollision(): Promise<{ name: string; ptAry: Vector3[]; time: JulianDate }[]>

Returns Promise<{ name: string; ptAry: Vector3[]; time: JulianDate }[]>

clearAllTrackInfo

clearAllTrackInfo(): void

Returns void

clearAnimate

clearAnimate(): void

Returns void

clearDebugLine

clearDebugLine(): void

Returns void

continueAnimate

continueAnimate(): void

Returns void

createCollisionBox

createCollisionBox(): { lineAry: [Vector3, Vector3][]; name: string; time: JulianDate }[]

Returns { lineAry: [Vector3, Vector3][]; name: string; time: JulianDate }[]

debugLines

debugLines(): void

Returns void

detectCollisionLine

detectCollisionLine(startPos: Vector3, endPos: Vector3): Promise<Vector3[]>

Parameters
- startPos: Vector3
- endPos: Vector3
Returns Promise<Vector3[]>

drawAll

drawAll(): void

Returns void

drawAllCollisionPoint

drawAllCollisionPoint(opt?: { showPoleTrackLine: boolean; showRopeTrackLine: boolean; showTargetTrackLine: boolean }): void

Parameters
- Optional opt: { showPoleTrackLine: boolean; showRopeTrackLine: boolean; showTargetTrackLine: boolean }
  - showPoleTrackLine: boolean
  - showRopeTrackLine: boolean
  - showTargetTrackLine: boolean
Returns void

drawAllTrackLine

drawAllTrackLine(opt?: { showPoleTrackLine: boolean; showRopeTrackLine: boolean; showTargetTrackLine: boolean }): void

Parameters
- Optional opt: { showPoleTrackLine: boolean; showRopeTrackLine: boolean; showTargetTrackLine: boolean }
  - showPoleTrackLine: boolean
  - showRopeTrackLine: boolean
  - showTargetTrackLine: boolean
Returns void

getAccumulateStatus

getAccumulateStatus(timeOffset: number): { hookRopeAngle: number; hookRopeLength: number; mainAxisAngle: number; mainPoleAngle: number; mainPoleLength: number }

Parameters
- timeOffset: number
Returns { hookRopeAngle: number; hookRopeLength: number; mainAxisAngle: number; mainPoleAngle: number; mainPoleLength: number }
- hookRopeAngle: number
- hookRopeLength: number
- mainAxisAngle: number
- mainPoleAngle: number
- mainPoleLength: number

getAnimateItemStartEndTime

getAnimateItemStartEndTime(animateItem: AnimateItem): { end: JulianDate; start: JulianDate }

Parameters
- animateItem: AnimateItem
Returns { end: JulianDate; start: JulianDate }
- end: JulianDate
- start: JulianDate

getAnimateQStartEndTime

getAnimateQStartEndTime(): { end: JulianDate; start: JulianDate }

Returns { end: JulianDate; start: JulianDate }
- end: JulianDate
- start: JulianDate

getCubeVertex

getCubeVertex(centerPt: Vector3, size?: { height: number; length: number; width: number }, rotationZAngle?: number): Vector3[]

Parameters
- centerPt: Vector3
- Optional size: { height: number; length: number; width: number }
  - height: number
  - length: number
  - width: number
- Optional rotationZAngle: number
Returns Vector3[]

getQueueStartEndTime

getQueueStartEndTime(): { end: JulianDate; start: JulianDate }

Returns { end: JulianDate; start: JulianDate }
- end: JulianDate
- start: JulianDate

getStretchPoleNodeByIdx

getStretchPoleNodeByIdx(idx: number): ModelNode

Parameters
- idx: number
Returns ModelNode

getValByTime

getValByTime(time: JulianDate, animateItem: AnimateItem): undefined | number

Parameters
- time: JulianDate
- animateItem: AnimateItem
Returns undefined | number

hookTarget

hookTarget(opt: { duration: number; poleLength: number; targetPos: Vector3 }): undefined | AnimateItem[]

Parameters
- opt: { duration: number; poleLength: number; targetPos: Vector3 }
  - duration: number
  - poleLength: number
  - targetPos: Vector3
Returns undefined | AnimateItem[]

hookTarget1

hookTarget1(opt: { mainPoleLength: number; targetOpt: { targetPos: Vector3; targetSize: { height: number; length: number; width: number }; targetWeight: number } }): void

Parameters
- opt: { mainPoleLength: number; targetOpt: { targetPos: Vector3; targetSize: { height: number; length: number; width: number }; targetWeight: number } }
  - mainPoleLength: number
  - targetOpt: { targetPos: Vector3; targetSize: { height: number; length: number; width: number }; targetWeight: number }
    - targetPos: Vector3
    - targetSize: { height: number; length: number; width: number }
      - height: number
      - length: number
      - width: number
    - targetWeight: number
Returns void

hookTarget3

hookTarget3(opt: { mainPoleLength: number; targetOpt: { targetPos: Vector3; targetSize: { height: number; lenth: number; width: number } } }): void

Parameters
- opt: { mainPoleLength: number; targetOpt: { targetPos: Vector3; targetSize: { height: number; lenth: number; width: number } } }
  - mainPoleLength: number
  - targetOpt: { targetPos: Vector3; targetSize: { height: number; lenth: number; width: number } }
    - targetPos: Vector3
    - targetSize: { height: number; lenth: number; width: number }
      - height: number
      - lenth: number
      - width: number
Returns void

initAnimate

initAnimate(): void

Returns void

initPosition

initPosition(): void

Returns void

moveTargetFromAToB

moveTargetFromAToB(opt: { duration: number; endPos: Vector3; poleLength: number; startPos: Vector3 }): AnimateItem[]

Parameters
- opt: { duration: number; endPos: Vector3; poleLength: number; startPos: Vector3 }
  - duration: number
  - endPos: Vector3
  - poleLength: number
  - startPos: Vector3
Returns AnimateItem[]

moveTargetTo

moveTargetTo(opt: { duration: number; endPos: Vector3; startPos: Vector3; targetSize: { height: number; length: number; width: number }; targetWeight: number; useAnimate: boolean }): AnimateItem[]

Parameters
- opt: { duration: number; endPos: Vector3; startPos: Vector3; targetSize: { height: number; length: number; width: number }; targetWeight: number; useAnimate: boolean }
  - duration: number
  - endPos: Vector3
  - startPos: Vector3
  - targetSize: { height: number; length: number; width: number }
    - height: number
    - length: number
    - width: number
  - targetWeight: number
  - useAnimate: boolean
Returns AnimateItem[]

moveTargetTo2

moveTargetTo2(opt: { duration: number; endPos: Vector3; startPos: Vector3; useAnimate: boolean }): void

Parameters
- opt: { duration: number; endPos: Vector3; startPos: Vector3; useAnimate: boolean }
  - duration: number
  - endPos: Vector3
  - startPos: Vector3
  - useAnimate: boolean
Returns void

pauseAnimate

pauseAnimate(): void

Returns void

playAnimateByStartEndOffset

playAnimateByStartEndOffset(startOffset: number, endOffset?: number): void

Parameters
- startOffset: number
- Optional endOffset: number
Returns void

playAnimateByStartTime

playAnimateByStartTime(startOffset: number): void

Parameters
- startOffset: number
Returns void

playAnimateQueue

playAnimateQueue(): void

Returns void

playOneAnimate

playOneAnimate(animateItem: AnimateItem): void

Parameters
- animateItem: AnimateItem
Returns void

printStatus

printStatus(): void

Returns void

recordTrackInfo

recordTrackInfo(time: JulianDate): void

Parameters
- time: JulianDate
Returns void

resetTransformers

resetTransformers(): Promise<void>

Returns Promise<void>

setAxisRotate

setAxisRotate(options: { angle: number; opt?: { duration: number; endT?: JulianDate; startT?: JulianDate } }): AnimateItem

Parameters
- options: { angle: number; opt?: { duration: number; endT?: JulianDate; startT?: JulianDate } }
  - angle: number
  - Optional opt?: { duration: number; endT?: JulianDate; startT?: JulianDate }
    - duration: number
    - Optional endT?: JulianDate
    - Optional startT?: JulianDate
Returns AnimateItem

setCranePosition

setCranePosition(position: Vector3): void

Parameters
- position: Vector3
Returns void

setHookLiftAngle

setHookLiftAngle(oldAngle: number, newAngle: number, opt?: { duration: number; endT?: JulianDate; startT?: JulianDate }): AnimateItem

Parameters
- oldAngle: number
- newAngle: number
- Optional opt: { duration: number; endT?: JulianDate; startT?: JulianDate }
  - duration: number
  - Optional endT?: JulianDate
  - Optional startT?: JulianDate
Returns AnimateItem

setHookRopeLength

setHookRopeLength(oldLength: number, newLength: number, opt?: { duration: number; endT?: JulianDate; startT?: JulianDate }): AnimateItem

Parameters
- oldLength: number
- newLength: number
- Optional opt: { duration: number; endT?: JulianDate; startT?: JulianDate }
  - duration: number
  - Optional endT?: JulianDate
  - Optional startT?: JulianDate
Returns AnimateItem

setMainAxisRotate

setMainAxisRotate(oldAngle: number, angle: number, opt?: { duration: number; endT?: JulianDate; startT?: JulianDate }): AnimateItem

Parameters
- oldAngle: number
- angle: number
- Optional opt: { duration: number; endT?: JulianDate; startT?: JulianDate }
  - duration: number
  - Optional endT?: JulianDate
  - Optional startT?: JulianDate
Returns AnimateItem

setMainPoleAngle

setMainPoleAngle(oldAngle: number, newAngle: number, opt?: { duration: number; endT?: JulianDate; startT?: JulianDate }): AnimateItem

Parameters
- oldAngle: number
- newAngle: number
- Optional opt: { duration: number; endT?: JulianDate; startT?: JulianDate }
  - duration: number
  - Optional endT?: JulianDate
  - Optional startT?: JulianDate
Returns AnimateItem

setMainPoleLength

setMainPoleLength(oldLength: number, newLength: number, opt?: { duration: number; endT?: JulianDate; startT?: JulianDate }): AnimateItem

Parameters
- oldLength: number
- newLength: number
- Optional opt: { duration: number; endT?: JulianDate; startT?: JulianDate }
  - duration: number
  - Optional endT?: JulianDate
  - Optional startT?: JulianDate
Returns AnimateItem

setPoleAngle

setPoleAngle(options: { opt?: { duration: number; endT?: JulianDate; startT?: JulianDate }; poleAngle: number }): AnimateItem

Parameters
- options: { opt?: { duration: number; endT?: JulianDate; startT?: JulianDate }; poleAngle: number }
  - Optional opt?: { duration: number; endT?: JulianDate; startT?: JulianDate }
    - duration: number
    - Optional endT?: JulianDate
    - Optional startT?: JulianDate
  - poleAngle: number
Returns AnimateItem

setPoleLength

setPoleLength(options: { opt?: { duration: number; endT?: JulianDate; startT?: JulianDate }; poleLength: number }): AnimateItem

Parameters
- options: { opt?: { duration: number; endT?: JulianDate; startT?: JulianDate }; poleLength: number }
  - Optional opt?: { duration: number; endT?: JulianDate; startT?: JulianDate }
    - duration: number
    - Optional endT?: JulianDate
    - Optional startT?: JulianDate
  - poleLength: number
Returns AnimateItem

setRopeLength

setRopeLength(options: { opt?: { duration: number; endT?: JulianDate; startT?: JulianDate }; ropeLength: number }): AnimateItem

Parameters
- options: { opt?: { duration: number; endT?: JulianDate; startT?: JulianDate }; ropeLength: number }
  - Optional opt?: { duration: number; endT?: JulianDate; startT?: JulianDate }
    - duration: number
    - Optional endT?: JulianDate
    - Optional startT?: JulianDate
  - ropeLength: number
Returns AnimateItem

setTarget

setTarget(opt: { height: number; length: number; rotateZAngle: number; weight: number; width: number }): void

Parameters
- opt: { height: number; length: number; rotateZAngle: number; weight: number; width: number }
  - height: number
  - length: number
  - rotateZAngle: number
  - weight: number
  - width: number
Returns void

setWorldMatrix

setWorldMatrix(matrix: Matrix4): void

Parameters
- matrix: Matrix4
Returns void

showDebugLine

showDebugLine(ptA?: Vector3, ptB?: Vector3): void

Parameters
- Optional ptA: Vector3
- Optional ptB: Vector3
Returns void

startAnimate

startAnimate(): void

Returns void

startCollisionCheck

startCollisionCheck(): Promise<void>

Returns Promise<void>

stopAnimate

stopAnimate(): void

Returns void

test

test(angle: number, index: number): void

Parameters
- angle: number
- index: number
Returns void

testGetValByTime

testGetValByTime(timeOffset: number): void

Parameters
- timeOffset: number
Returns void

undrawAll

undrawAll(): void

Returns void

undrawAllTrackLine

undrawAllTrackLine(): void

Returns void

undrawAllTrackPoint

undrawAllTrackPoint(): void

Returns void

updateAnimate

updateAnimate(): void

Returns void

updateStartEndTime

updateStartEndTime(opt: { duration?: number; endT?: JulianDate; startT?: JulianDate }): { curStartTime: JulianDate; nextStartTime: JulianDate }

Parameters
- opt: { duration?: number; endT?: JulianDate; startT?: JulianDate }
  - Optional duration?: number
  - Optional endT?: JulianDate
  - Optional startT?: JulianDate
Returns { curStartTime: JulianDate; nextStartTime: JulianDate }
- curStartTime: JulianDate
- nextStartTime: JulianDate

wait

wait(time: number): Promise<void>

Parameters
- time: number
Returns Promise<void>

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

options: { crane: Mod; craneConfig?: CraneConfig; nodeNameMap?: NodeNameMap; targetOpt: { height: number; length: number; weight: number; width: number }; viewer: Viewer; validatePoleLength?: any }

crane: Mod

Optional craneConfig?: CraneConfig

Optional nodeNameMap?: NodeNameMap

targetOpt: { height: number; length: number; weight: number; width: number }

height: number

length: number

weight: number

width: number

viewer: Viewer

validatePoleLength: function

Parameters

poleLength: number

weight: number

distance: number

Returns boolean

Returns CraneManipulator

Properties

_curAxisAngle

_curHookRopeLength

_curMainPoleAngle

_curPoleLength

_dftAxisAngle

_dftHookRopeLength

_dftMainPoleAngle

_dftPoleLength

_dftRopeLength

_eachPoleLength

_enableMainPoleCollision

_enableRopeCollision

_enableTargetCollision

_hookHeight

_isUseCombinedAnimation

_minRopeLength

_poleLength

_recordFinished

_ropeHookOffset

_showTrackLine

_targetHeight

_targetLength

_targetRotateZAngle

_targetWeight

_targetWidth

animateEvent

animateQueue

animatedEndQueue

collisionPointAry

crane

craneMod

craneRotateAngle

curAnimateItem

curAnimateItemIdx

dftCenter

dftPoleEnd

dftPoleStart

endTime

lineAndTimeAry

modelMatrix

nodeNameMap

pointAndTimeAry

proj

startTime

trackLineAry

validatePoleLength

Type declaration

Parameters

poleLength: number

weight: number

distance: number

Returns boolean

viewer