shop-components 0.4.24 → 0.4.25

package/dist/dev/src/amr.d.ts

@@ -7,6 +7,7 @@ import { AMRAssembly } from './assembly';
 import EventEmitter from 'eventemitter3';
 import { GoodsBox } from './goods-box';
 import { Logo } from './logo';
+import { AmrIKController } from './ik/amr-ik';
 export declare const textureLoader: TextureLoader;
 export interface CropperConfigs {
     canvasWidth: number;
@@ -53,6 +54,10 @@ export declare class Amr extends Object3D {
     private _rollerBaffle;
     private _liftBrackets;
     private _rollerTop;
+    private _ikChains;
+    ikControllers: AmrIKController[];
+    private _ikDraggingControllers;
+    private _ikControllersTimer;
     private _shelfSyncCache;
     private _rollerPools;
     private _videoCache;
@@ -114,6 +119,17 @@ export declare class Amr extends Object3D {
     getShapeKeyTargets(key: string): Object3D<import("three").Object3DEventMap>[];
     setShapeKey(key: string, value: number, useDebance?: boolean): void;
     private _generateAmr;
+    private _syncIkDraggingState;
+    private _onIkDraggingChanged;
+    private _disposeIkControllers;
+    private _buildJointChain;
+    private _findIkChainByNode;
+    updateIkJointChainByTool(toolRoot: Object3D, action: 'install' | 'uninstall'): void;
+    private _buildIKChainParams;
+    private _fillInitialRotationValues;
+    private _axisFromLetter;
+    private _parseIkAxes;
+    private _parseIkOrientation;
     setHeight(height: number): void;
     setWeight(width: number): void;
     setLength(length: number): void;

package/dist/dev/src/controls/FreeTransformControls.d.ts

@@ -0,0 +1,165 @@
+import { EventDispatcher, Mesh, Object3D, Quaternion, Raycaster, Vector3 } from 'three';
+type FreeMode = 'default' | 'translate' | 'rotate';
+type FreeAxis = 'XYZ' | 'E' | null;
+declare class FreeTransformControlsRoot extends Object3D {
+    controls: FreeTransformControls;
+    isTransformControlsRoot: boolean;
+    constructor(controls: FreeTransformControls);
+    updateMatrixWorld(force?: boolean): void;
+    dispose(): void;
+}
+declare class FreeTransformControlsGizmo extends Object3D {
+    controls: FreeTransformControls;
+    picker: Object3D<import("three").Object3DEventMap>;
+    gizmo: Object3D<import("three").Object3DEventMap>;
+    helper: Object3D<import("three").Object3DEventMap>;
+    private _matMove;
+    private _matRing;
+    private _matInvisible;
+    private _matHelper;
+    private _moveMesh;
+    private _ringMesh;
+    private _arcLine;
+    private _arcGeom;
+    private _arcSegments;
+    private _arcPositions;
+    private _arcStartAngleOffset;
+    private _moveColorDefault;
+    private _moveColorActive;
+    private _moveOpacityDefault;
+    private _moveOpacityRingActive;
+    private _ringColorDefault;
+    private _ringColorActive;
+    private _ringOpacityDefault;
+    private _ringOpacityActive;
+    private _ringScale;
+    private _ringTargetScale;
+    private _ringScaleTweening;
+    private _moveColorTween?;
+    private _ringColorTween?;
+    private _ringScaleTween?;
+    private _isMoveActive;
+    private _isRingActive;
+    private _isMoveHover;
+    private _isDragging;
+    private _startMarker;
+    private _endMarker;
+    private _deltaLine;
+    private _deltaGeom;
+    private static RING_RADIUS;
+    private static RING_TUBE;
+    private static PICKER_RING_TUBE;
+    private static MOVE_RADIUS;
+    private static PICKER_MOVE_RADIUS;
+    private _isExpanded;
+    get isExpanded(): boolean;
+    set isExpanded(value: boolean);
+    get isRingScaleTweening(): boolean;
+    constructor(controls: FreeTransformControls);
+    updateMatrixWorld(force?: boolean): void;
+}
+declare class FreeTransformControlsPlane extends Mesh {
+    isTransformControlsPlane: boolean;
+    constructor();
+    updateMatrixWorld(force?: boolean): void;
+}
+export declare class FreeTransformControls extends EventDispatcher<{
+    [key: string]: any;
+}> {
+    _root: FreeTransformControlsRoot;
+    _gizmo: FreeTransformControlsGizmo;
+    _plane: FreeTransformControlsPlane;
+    domElement: HTMLElement | null;
+    camera: any;
+    object: any;
+    enabled: boolean;
+    axis: FreeAxis;
+    mode: FreeMode;
+    size: number;
+    dragging: boolean;
+    gizmoPriority: boolean;
+    worldPosition: Vector3;
+    worldPositionStart: Vector3;
+    worldQuaternion: Quaternion;
+    worldQuaternionStart: Quaternion;
+    cameraPosition: Vector3;
+    cameraQuaternion: Quaternion;
+    pointStart: Vector3;
+    pointEnd: Vector3;
+    rotationAxis: Vector3;
+    rotationAngle: number;
+    eye: Vector3;
+    _offset: Vector3;
+    _startNorm: Vector3;
+    _endNorm: Vector3;
+    _cameraScale: Vector3;
+    _parentPosition: Vector3;
+    _parentQuaternion: Quaternion;
+    _parentQuaternionInv: Quaternion;
+    _parentScale: Vector3;
+    _worldScaleStart: Vector3;
+    _worldQuaternionInv: Quaternion;
+    _worldScale: Vector3;
+    _positionStart: Vector3;
+    _quaternionStart: Quaternion;
+    _scaleStart: Vector3;
+    _getPointer: (event: PointerEvent) => {
+        x: number;
+        y: number;
+        button: number;
+    };
+    _onPointerDown: (event: PointerEvent) => void;
+    _onPointerHover: (event: PointerEvent) => void;
+    _onPointerMove: (event: PointerEvent) => void;
+    _onPointerUp: (event: PointerEvent) => void;
+    _onPointerDownCapture: (event: PointerEvent) => void;
+    _onPointerMoveCapture: (event: PointerEvent) => void;
+    _onPointerUpCapture: (event: PointerEvent) => void;
+    _onMouseMoveCapture: (event: MouseEvent) => void;
+    _capturePointerId: number | null;
+    _captureDocument: Document | null;
+    _hoverShieldActive: boolean;
+    constructor(camera: any, domElement?: HTMLElement | null);
+    connect(element: HTMLElement): void;
+    disconnect(): void;
+    getHelper(): FreeTransformControlsRoot;
+    dispose(): void;
+    attach(object: Object3D): this;
+    detach(): this;
+    getMode(): FreeMode;
+    setMode(mode: FreeMode): void;
+    setSize(size: number): void;
+    getRaycaster(): Raycaster;
+    private _handlePointerHover;
+    private _handlePointerDown;
+    private _handlePointerMove;
+    private _handlePointerUp;
+    private _setHoverShieldActive;
+    private _handlePointerDownCapture;
+    private _handlePointerMoveCapture;
+    private _handleMouseMoveCapture;
+    private _handlePointerUpCapture;
+    pointerHover(pointer: {
+        x: number;
+        y: number;
+        button: number;
+    } | null): void;
+    pointerDown(pointer: {
+        x: number;
+        y: number;
+        button: number;
+    } | null): void;
+    pointerMove(pointer: {
+        x: number;
+        y: number;
+        button: number;
+    } | null): void;
+    pointerUp(pointer: {
+        x: number;
+        y: number;
+        button: number;
+    } | null): void;
+    private _updateCursor;
+    private _isAxisAllowed;
+}
+export { FreeTransformControlsGizmo, FreeTransformControlsPlane };

package/dist/dev/src/ik/CCDIKSolver.d.ts

@@ -0,0 +1,109 @@
+import { Object3D, Vector3, Quaternion } from 'three';
+export interface IKAxisConfig {
+    axis: Vector3;
+    min?: number;
+    max?: number;
+    value?: number;
+}
+export interface IKLinkConfig {
+    object: Object3D;
+    ikTcp?: boolean;
+    weight?: number;
+    axes?: IKAxisConfig[];
+}
+interface JointState {
+    currentAngle: number;
+    prevAngle: number;
+    currentAngles?: number[];
+    prevAngles?: number[];
+}
+export interface IKContext {
+    iterations?: number;
+    minDistance?: number;
+    maxStep?: number;
+    damping?: number;
+    maxAngleDelta?: number;
+    orientation?: OrientationConstraintConfig;
+    weightProfile?: IKWeightProfile;
+}
+export interface IKWeightProfile {
+    root?: number;
+    middle?: number;
+    end?: number;
+    curve?: number;
+}
+export interface OrientationConstraintConfig {
+    enabled?: boolean;
+    forwardAxis?: Vector3;
+    upAxis?: Vector3;
+    targetForwardAxis?: Vector3;
+    targetUpAxis?: Vector3;
+    forwardWeight?: number;
+    upWeight?: number;
+    minAngle?: number;
+}
+export declare class CCDIKSolver {
+    links: IKLinkConfig[];
+    target: Vector3;
+    targetQuaternion: Quaternion;
+    iterations: number;
+    minDistance: number;
+    maxStep: number;
+    damping: number;
+    maxAngleDelta: number;
+    orientation: OrientationConstraintConfig | undefined;
+    private _restQuaternions;
+    private _initialRestQuaternions;
+    private _axesLocal;
+    private _axisMins;
+    private _axisMaxs;
+    private _jointStates;
+    private _frameAppliedAbsDelta;
+    private _jointWeights;
+    private _stableFrameCount;
+    private _lastFramePosErrSq;
+    private _lastFrameOriErr;
+    private _tmpEffectorPos;
+    private _tmpTargetPos;
+    private _tmpLinkPos;
+    private _tmpAxisWorld;
+    private _tmpVToEff;
+    private _tmpVToTar;
+    private _tmpProjE;
+    private _tmpProjT;
+    private _tmpCross;
+    private _tmpEffWorldQ;
+    private _tmpTarWorldQ;
+    private _tmpDirCurP;
+    private _tmpDirTarP;
+    private _tmpDirCurS;
+    private _tmpDirTarS;
+    private _tmpAxisQ;
+    private _tmpParentWorldQ;
+    private _tmpLocalBeforeQ;
+    private _tmpWorldBeforeQ;
+    constructor(links: IKLinkConfig[], context?: IKContext);
+    private _buildJointWeights;
+    private _normalizeAxesForLink;
+    private _getAxisMinsForLink;
+    private _getAxisMaxsForLink;
+    private _applyLinkAngles;
+    private _getAxisWorld;
+    resetToInitialPose(): void;
+    get restQuaternions(): ReadonlyArray<Quaternion>;
+    private _isOrientationEnabled;
+    private _getEndIndices;
+    private _getOrientationDefaults;
+    private _orientationErrorAngle;
+    private _angleBetweenNormalized;
+    private _getOrientationChainStartIndex;
+    bindRestPose(): void;
+    updateJointStateFromCurrentPose(): void;
+    rebindRestPoseWithBase(restQuaternions: (Quaternion | undefined)[]): void;
+    private _updateLinkAnglesFromQuaternion;
+    get jointStates(): ReadonlyArray<JointState>;
+    private _clamp;
+    private _signedAngleAroundAxis;
+    update(): void;
+}
+export {};

package/dist/dev/src/ik/amr-ik.d.ts

@@ -0,0 +1,72 @@
+import { Object3D, Vector3, Camera } from 'three';
+import { CCDIKSolver, IKContext, IKLinkConfig, OrientationConstraintConfig } from './CCDIKSolver';
+import { FreeTransformControls } from '../controls/FreeTransformControls';
+import EventEmitter from 'eventemitter3';
+export type TransformControlMode = 'translate' | 'rotate';
+export interface AmrIKConfig {
+    joints: IKLinkConfig[];
+    container: Object3D;
+    context?: IKContext;
+    resetHierarchy?: boolean;
+}
+export interface GizmoContext {
+    camera: Camera;
+    domElement: HTMLElement;
+}
+export interface IKChainConfig {
+    name: string;
+    joints: IKLinkConfig[];
+    orientation?: OrientationConstraintConfig;
+}
+export declare class AmrIKController {
+    readonly isController = true;
+    solver: CCDIKSolver | undefined;
+    targetObject: Object3D;
+    transformControls: FreeTransformControls;
+    private _enabled;
+    private _effector;
+    private _container;
+    private _tmpQ;
+    private _tmpContainerQ;
+    private _tmpV;
+    private _context;
+    private _resetHierarchy;
+    private _defaultPoseQuats;
+    private _zeroPoseQuats;
+    private _emitter;
+    addListener: <T extends string | symbol>(event: T, fn: (...args: any[]) => void, context?: any) => EventEmitter<string | symbol, any>;
+    removeAllListeners: (event?: string | symbol | undefined) => EventEmitter<string | symbol, any>;
+    private _initialTargetPos;
+    private _initialTargetQuat;
+    get enabled(): boolean;
+    set enabled(v: boolean);
+    private _axesHelpers;
+    private _showAxes;
+    get showAxes(): boolean;
+    set showAxes(v: boolean);
+    constructor(config: AmrIKConfig, gizmoContext: GizmoContext);
+    private getEffectorLocalPos;
+    private getEffectorLocalQuat;
+    private setupHierarchy;
+    syncTargetToEffector(): void;
+    syncTargetToSolver(): void;
+    setControlMode(mode: TransformControlMode): void;
+    setOrientation(orientation: {
+        forwardAxis: Vector3;
+        upAxis: Vector3;
+    }): void;
+    updateJointChain(joints: IKLinkConfig[]): void;
+    update(): void;
+    toggleOrientation(enabled: boolean): void;
+    setSolverContext(context: {
+        iterations?: number;
+        damping?: number;
+    }): void;
+    reset(): void;
+    dispose(): void;
+}
+export interface CreateIkControllersOptions {
+    resetHierarchy?: boolean;
+    onDraggingChanged?: (controller: AmrIKController, value: boolean) => void;
+}
+export declare const createIkControllers: (chains: IKChainConfig[], container: Object3D, gizmoContext: GizmoContext, options?: CreateIkControllersOptions) => AmrIKController[];

package/dist/dev/src/mechanism/mechanism.d.ts

@@ -15,6 +15,7 @@ export interface MechanismProps {
 export declare class Mechanism extends CSS2DObject {
     props: MechanismProps;
     amr: Object3D;
+    readonly isController = true;
     private _direction;
     private _controllingRotate;
     private _controlling;

package/dist/dev/src/slot.d.ts

@@ -63,6 +63,7 @@ export declare class Slot extends CSS2DObject {
     mirrorTarget: Slot | undefined;
     private _showSlot;
     private _isMirror;
+    private _currentDeivceLoaded;
     get isMirror(): boolean;
     beforeInstall: ((info: DeviceInfo) => Promise<void>) | undefined;
     constructor(props: SlotProps);