shop-components 0.1.68 → 0.2.1

package/dist/{device-viewer → stories/device-viewer}/amr.d.ts

@@ -1,13 +1,13 @@
-import { Object3D, TextureLoader } from 'three';
+import { Group, Mesh, Object3D, TextureLoader } from 'three';
 import { Scene3D, Skin, Slot } from './scene';
 import { Mechanism } from './mechanism/mechanism';
 import { ObjectSize } from './utils';
 import { SizeBox } from './dimension/size-box';
-import { AMRAssembly } from '../../../../../../../stories/device-viewer/assembly';
+import { AMRAssembly } from './assembly';
 import EventEmitter from 'eventemitter3';
 import { CropperConfigs } from '../cropper';
 import { GoodsBox } from './goods-box';
-import { Logo } from '../../../../../../../stories/device-viewer/logo';
+import { Logo } from './logo';
 export declare const textureLoader: TextureLoader;
 export interface AmrProps {
     url?: string;
@@ -20,6 +20,7 @@ export declare class Amr extends Object3D {
     private _emitter;
     addEventListener: <T extends string | symbol>(event: T, fn: (...args: any[]) => void, context?: any) => EventEmitter<string | symbol, any>;
     private _container;
+    lines: Group<import("three").Object3DEventMap>;
     private _app;
     sizeBox: SizeBox;
     _goodsSize: ObjectSize;
@@ -42,7 +43,6 @@ export declare class Amr extends Object3D {
     private _shelf;
     private _shelves;
     private _shelfMaxLevel;
-    private _shelveAnimateTimes;
     private _url;
     private _showController;
     private _showSlots;
@@ -51,6 +51,12 @@ export declare class Amr extends Object3D {
     private _shapeKeyCache;
     private _materialsCache;
     opacityCache: undefined | number;
+    private _pointCloudMode;
+    private _pointClouds;
+    private _originalMeshes;
+    private _pointCloudAnimations;
+    actions: string[];
+    private _mergedGeometry;
     get shapeKeys(): Map<string, number>;
     get size(): {
         width: number;
@@ -76,7 +82,7 @@ export declare class Amr extends Object3D {
     load(url: string, type?: string): Promise<void>;
     changeSkin(skin: Skin, value: string): void;
     changeLogo(logo: Logo, configs: CropperConfigs): void;
-    setShapeKey(key: string, value: number): void;
+    setShapeKey(key: string, value: number, useDebance?: boolean): void;
     private _generateAmr;
     setHeight(height: number): void;
     setWeight(width: number): void;
@@ -85,6 +91,7 @@ export declare class Amr extends Object3D {
     setForkHeight(height: number): void;
     setForkMaxHeight(height: number): void;
     setLiftHeight(height: number): void;
+    getLiftMaxHeight(): number;
     setLiftMaxHeight(height: number): void;
     setJackMaxHeight(height: number): void;
     setJackHeight(height: number): void;
@@ -94,6 +101,10 @@ export declare class Amr extends Object3D {
         width: number;
         height: number;
     }): void;
+    getShelfMinHeight(): number;
+    getShelfMaxShelfHeight(): number | undefined;
+    get levelOffset(): number;
+    setShapeKeyToMesh(node: Mesh, key: string, val: number): void;
     setShelfLevel(levelMax?: number): void;
     generateOuterLine(): void;
     generateController(m: Object3D, amr: Object3D): void;
@@ -101,4 +112,11 @@ export declare class Amr extends Object3D {
     generateSlot(m: Object3D, scene: Object3D): Slot | undefined;
     clean(): void;
     destroy(): void;
+    setPointCloudMode(enabled: boolean): void;
+    private _createPointClouds;
+    private _generatePointsOnTriangle;
+    private _removeDuplicatePoints;
+    private _clearPointClouds;
+    playAction(name: string, reset?: boolean): void;
+    pauseAction(name: string): void;
 }

package/dist/{device-viewer → stories/device-viewer}/dimension/size-box.d.ts

@@ -31,11 +31,10 @@ export declare class SizeBox extends Object3D {
     get radius(): number;
     init(app: Scene3D): void;
     reset(): void;
-    private _changeSize;
     private _change;
     generate(object?: Object3D, offset?: number): void;
-    show(): void;
-    hide(): void;
+    show(all?: boolean): void;
+    hide(all?: boolean): void;
     destroy(): void;
     update(originOffset?: number): void;
 }

package/dist/stories/device-viewer/dimension/size-line.d.ts

@@ -0,0 +1,24 @@
+import { Group, Vector3 } from 'three';
+import { CSS2DObject } from 'three/examples/jsm/renderers/CSS2DRenderer';
+export declare class SizeText extends CSS2DObject {
+    private _text;
+    onPointMove: (() => void) | undefined;
+    onPointLeave: (() => void) | undefined;
+    constructor(text: string);
+    set text(text: string);
+    dispose(): void;
+}
+export declare class SizeLine extends Group {
+    private _startWith?;
+    private _showText;
+    useStartEnd: boolean;
+    private readonly _line2Length;
+    private _line;
+    private _line2;
+    private _text;
+    constructor(_startWith?: string | undefined, _showText?: boolean, useStartEnd?: boolean);
+    updateMaterial(mat: any): void;
+    reset(): void;
+    update(start: Vector3, end: Vector3, radius?: number): void;
+    destroy(): void;
+}

package/dist/{device-viewer → stories/device-viewer}/goods-box.d.ts

@@ -1,5 +1,6 @@
 import { Object3D } from 'three';
 export declare class GoodsBox extends Object3D {
+    isGoods: boolean;
     constructor(length?: number, width?: number, height?: number);
     updateSize(length?: number, width?: number, height?: number): void;
     clearAll(): void;

package/dist/{device-viewer → stories/device-viewer}/index.d.ts

@@ -1,7 +1,8 @@
 import { LitElement, PropertyValues } from 'lit';
-import { Scene3D, Skin } from './scene';
+import { Scene3D, Skin, Slot } from './scene';
 import { Cropper } from '../cropper';
-import { Logo } from '../../../../../../../stories/device-viewer/logo';
+import { DeviceInfo } from './slot';
+import { Logo } from './logo';
 export interface Props {
     test: string;
     count: number;
@@ -9,8 +10,10 @@ export interface Props {
 }
 export declare class DeviceViewer extends LitElement {
     scene: Scene3D;
+    deviceInfoCache: DeviceInfo | undefined;
     cropper: Cropper;
     container: HTMLDivElement | undefined;
+    canvas: HTMLDivElement | undefined;
     drag: HTMLButtonElement | undefined;
     constructor();
     protected firstUpdated(_changedProperties: PropertyValues): void;
@@ -21,12 +24,16 @@ export declare class DeviceViewer extends LitElement {
     theme: undefined | string;
     onChange: undefined | Function;
     usePathTracing: boolean;
+    showSlots: boolean;
+    showSize: boolean;
+    pointCloudMode: boolean;
     actions: string[];
     shelfLevel: number;
     shapeKeys: Map<any, any>;
     colors: Skin[];
     selectedLogo: Logo | undefined;
     logos: Logo[];
+    slots: Slot[];
     logoSize: {
         width: number;
         height: number;
@@ -40,18 +47,24 @@ export declare class DeviceViewer extends LitElement {
     sizeHeight: HTMLDivElement | undefined;
     fit: () => void;
     generateBVH: () => void;
+    getAmrInfo: () => void;
     download: () => Promise<void>;
     clearAMR: () => void;
     exportAMR: () => Promise<void>;
     addAMR: () => void;
+    slotList: Map<string, Slot>;
+    focusSlot: (s: Slot) => void;
     playAction: (name: string) => void;
     pauseAction: (name: string) => void;
     clean: () => void;
     recreate: () => void;
     setShapeKey: (key: string, val: any) => void;
+    setShowSlots: (showSlots: boolean) => void;
+    setShowSize: (showSize: boolean) => void;
     cancel: () => void;
     changeShelfLevel: (e: any) => void;
     changeAmrHeight: (e: any) => void;
+    togglePointCloudMode: () => void;
     changeAmrLevel: (e: any) => void;
     changeAmrShelvesLevel: (e: any) => void;
     setMaxHeight: (e: any) => void;

package/dist/stories/device-viewer/libs/BVH/index.d.ts

@@ -0,0 +1,342 @@
+import { BufferGeometry, Vector3, Side, Material, Ray, Sphere, Matrix4, Color,
+  Intersection, Box3, Triangle, Vector2, Raycaster, MeshBasicMaterial, Group,
+  LineBasicMaterial, Mesh, DataTexture, BufferAttribute, Line3, Object3D } from 'three';
+
+// Contants
+export enum SplitStrategy {}
+export const CENTER: SplitStrategy;
+export const AVERAGE: SplitStrategy;
+export const SAH: SplitStrategy;
+
+export enum ShapecastIntersection {}
+export const NOT_INTERSECTED: ShapecastIntersection;
+export const INTERSECTED: ShapecastIntersection;
+export const CONTAINED: ShapecastIntersection;
+
+// MeshBVH
+export interface HitPointInfo {
+  point: Vector3;
+  distance: number;
+  faceIndex: number;
+}
+
+export interface MeshBVHOptions {
+  strategy?: SplitStrategy;
+  maxDepth?: number;
+  maxLeafTris?: number;
+  setBoundingBox?: boolean;
+  useSharedArrayBuffer?: boolean;
+  verbose?: boolean;
+  onProgress?: ( progress: number ) => void;
+}
+
+export interface MeshBVHSerializeOptions {
+  cloneBuffers?: boolean;
+}
+
+export interface MeshBVHDeserializeOptions {
+  setIndex?: boolean;
+}
+
+
+export class MeshBVH {
+
+  readonly geometry: BufferGeometry;
+
+  static serialize( bvh: MeshBVH, options?: MeshBVHSerializeOptions ): SerializedBVH;
+
+  static deserialize(
+    data: SerializedBVH,
+    geometry: BufferGeometry,
+    options?: MeshBVHDeserializeOptions
+  ): MeshBVH;
+
+  constructor( geometry: BufferGeometry, options?: MeshBVHOptions );
+
+  raycast( ray: Ray, materialOrSide?: Side | Array<Material> | Material, near?: number, far?: number ): Array<Intersection>
+
+  raycastFirst( ray: Ray, materialOrSide?: Side | Array<Material> | Material, near?: number, far?: number ): Intersection;
+
+  intersectsSphere( sphere: Sphere ): boolean;
+
+  intersectsBox( box: Box3, boxToMesh: Matrix4 ): boolean;
+
+  intersectsGeometry( geometry: BufferGeometry, geometryToBvh: Matrix4 ): boolean;
+
+  closestPointToPoint(
+    point: Vector3,
+    target?: HitPointInfo,
+    minThreshold?: number,
+    maxThreshold?: number
+  ): HitPointInfo | null;
+
+  closestPointToGeometry(
+    geometry: BufferGeometry,
+    geometryToBvh: Matrix4,
+    target1?: HitPointInfo,
+    target2?: HitPointInfo,
+    minThreshold?: number,
+    maxThreshold?: number
+  ): HitPointInfo | null;
+
+  // union types to enable at least one of two functions:
+  // https://stackoverflow.com/a/60617060/9838891
+  shapecast(
+    callbacks: {
+
+      intersectsBounds: (
+        box: Box3,
+        isLeaf: boolean,
+        score: number | undefined,
+        depth: number,
+        nodeIndex: number
+      ) => ShapecastIntersection|boolean,
+
+      boundsTraverseOrder?: (
+        box: Box3
+      ) => number,
+
+    } & ( {
+
+      intersectsRange: (
+        triangleOffset: number,
+        triangleCount: number,
+        contained: boolean,
+        depth: number,
+        nodeIndex: number,
+        box: Box3
+      ) => boolean,
+
+    } | {
+
+      intersectsTriangle: (
+        triangle: ExtendedTriangle,
+        triangleIndex: number,
+        contained: boolean,
+        depth: number
+      ) => boolean|void
+
+    } )
+  ): boolean;
+
+  // union types to enable at least one of two functions:
+  // https://stackoverflow.com/a/60617060/9838891
+  bvhcast(
+    otherBVH: MeshBVH,
+    matrixToLocal: Matrix4,
+    callbacks: ( {
+
+      intersectsRanges: (
+        offset1: number,
+        count1: number,
+        offset2: number,
+        count2: number,
+        depth1: number,
+        index1: number,
+        depth2: number,
+        index2: number
+      ) => boolean
+
+    } | {
+
+      intersectsTriangles: (
+        triangle1: ExtendedTriangle,
+        triangle2: ExtendedTriangle,
+        i1: number,
+        i2: number,
+        depth1: number,
+        index1: number,
+        depth2: number,
+        index2: number,
+      ) => boolean,
+
+    } )
+  ): boolean;
+
+  traverse(
+    callback: (
+      depth: number,
+      isLeaf: boolean,
+      boundingData: ArrayBuffer,
+      offsetOrSplit: number,
+      count: number
+    ) => void,
+    rootIndex?: number
+  ): void;
+
+  refit( nodeIndices?: Array<number> | Set<number> ): void;
+
+  getBoundingBox( target: Box3 ): Box3;
+
+}
+
+// SerializedBVH
+export class SerializedBVH {
+
+  roots: Array<ArrayBuffer>;
+  index: ArrayBufferView;
+
+}
+
+// MeshBVHHelper
+export class MeshBVHHelper extends Group {
+
+  opacity: number;
+  depth: number;
+  displayParents: boolean;
+  displayEdges: boolean;
+  edgeMaterial: LineBasicMaterial;
+  meshMaterial: MeshBasicMaterial;
+
+  constructor( mesh: Mesh, depth?: number );
+
+  update(): void;
+
+  get color(): Color;
+
+}
+
+// THREE.js Extensions
+
+export function computeBoundsTree( options?: MeshBVHOptions ): MeshBVH;
+
+export function disposeBoundsTree(): void;
+
+export function acceleratedRaycast(
+  raycaster: Raycaster,
+  intersects: Array<Intersection>
+): void;
+
+declare module 'three/src/core/BufferGeometry' {
+  export interface BufferGeometry {
+    boundsTree?: MeshBVH;
+    computeBoundsTree: typeof computeBoundsTree;
+    disposeBoundsTree: typeof disposeBoundsTree;
+  }
+}
+
+declare module 'three/src/core/Raycaster' {
+  export interface Raycaster {
+    firstHitOnly?: boolean;
+  }
+}
+
+// GenerateMeshBVHWorker
+// export class GenerateMeshBVHWorker {
+
+//   running: boolean;
+
+//   generate( geometry: BufferGeometry, options?: MeshBVHOptions ): Promise<MeshBVH>;
+
+//   terminate(): boolean;
+
+// }
+
+// Debug functions
+export function estimateMemoryInBytes( bvh: MeshBVH ): number;
+
+export interface ExtremeInfo {
+  nodeCount: number;
+  leafNodeCount: number;
+  surfaceAreaScore: number;
+  depth: {min: number, max: number};
+  tris: {min: number, max: number};
+  splits: [number, number, number];
+}
+
+export function getBVHExtremes( bvh :MeshBVH ): Array<ExtremeInfo>;
+
+export function validateBounds( bvh: MeshBVH ): boolean;
+
+export interface TreeNode {
+  bounds: Box3;
+  count: number;
+  offset: number;
+  left?: TreeNode;
+  right?: TreeNode;
+}
+
+export function getJSONStructure( bvh: MeshBVH ): TreeNode;
+
+// Triangle Utilities
+export interface HitTriangleInfo {
+  face: {
+    a: number,
+    b: number,
+    c: number,
+    materialIndex: number,
+    normal: Vector3
+  },
+  uv: Vector2
+}
+
+export function getTriangleHitPointInfo(
+  point: Vector3,
+  geometry : BufferGeometry,
+  triangleIndex: number,
+  target?: HitTriangleInfo
+): HitTriangleInfo
+
+// Shader Utilities
+declare class VertexAttributeTexture extends DataTexture {
+
+  overrideItemSize: number | null;
+  updateFrom( attribute: BufferAttribute ): void;
+
+}
+
+export class FloatVertexAttributeTexture extends VertexAttributeTexture {}
+export class UIntVertexAttributeTexture extends VertexAttributeTexture {}
+export class IntVertexAttributeTexture extends VertexAttributeTexture {}
+
+export class MeshBVHUniformStruct {
+
+  updateFrom( bvh: MeshBVH ): void;
+  dispose(): void;
+
+}
+
+export const shaderStructs: string;
+export const shaderFunctions: string;
+
+// Math classes
+export class ExtendedTriangle extends Triangle {
+
+  needsUpdate : boolean;
+
+  intersectsTriangle( other : Triangle, target? : Line3 ) : boolean;
+  intersectsSphere( sphere : Sphere ) : boolean;
+  closestPointToSegment( segment : Line3, target1? : Vector3, target2? : Vector3 ) : number;
+  distanceToPoint( point : Vector3 ) : number;
+  distanceToTriangle( tri : Triangle ) : number;
+
+}
+
+export class OrientedBox {
+
+  min: Vector3;
+  max: Vector3;
+  matrix : Matrix4;
+  needsUpdate : boolean;
+
+  constructor( min : Vector3, max : Vector3 );
+  set( min : Vector3, max : Vector3, matrix : Matrix4 ) : OrientedBox;
+  intersectsBox( box : Box3 ) : boolean;
+  intersectsTriangle( tri : Triangle ) : boolean;
+  closestPointToPoint( point : Vector3, target? : Vector3 ) : number;
+  distanceToPoint( point : Vector3 ) : number;
+  distanceToBox( box : Box3, threshold? : number, target1? : Vector3, target2? : Vector3 ) : number;
+
+}
+
+export class StaticGeometryGenerator {
+
+  useGroups : boolean;
+  attributes : Array<string>;
+  applyWorldTransforms : boolean;
+
+  constructor( objects : Array<Object3D> | Object3D );
+  getMaterials() : Array<Material>;
+  generate( target? : BufferGeometry ) : BufferGeometry;
+
+}

package/dist/{device-viewer → stories/device-viewer}/libs/gizmo/gizmo.d.ts

@@ -61,6 +61,8 @@ export declare class OrbitControlsGizmo {
     private _update;
     private createAxes;
     private createCanvas;
+    private updateMouseFromEvent;
+    private updateSelectedAxisUnderMouse;
     private onPointerDown;
     private onPointerUp;
     private onPointerEnter;

package/dist/stories/device-viewer/libs/progress-shadow/ProgressiveShadows.d.ts

@@ -0,0 +1,91 @@
+import { Camera, Color, DirectionalLight, DirectionalLightHelper, Group, Light, Material, Mesh, MeshLambertMaterial, Object3D, Scene, WebGLRenderer, WebGLRenderTarget } from 'three';
+interface ProgressiveShadowsParams {
+    resolution?: number;
+    shadowMapRes?: number;
+    shadowBias?: number;
+    lightCount?: number;
+    size?: number;
+    frames?: number;
+    lightRadius?: number;
+    ambientWeight?: number;
+    alphaTest?: number;
+    paused?: boolean;
+}
+interface InternalParams {
+    enabled: boolean;
+    frames: number;
+    lightRadius: number;
+    ambientWeight: number;
+    alphaTest: number;
+    debugHelpers: boolean;
+    size: number;
+    paused: boolean;
+}
+interface LightInfo {
+    object: Light;
+    intensity: number;
+}
+interface MeshInfo {
+    object: Object3D;
+    material: Material | Material[];
+}
+interface ObjectInfo {
+    object: Object3D;
+    visible: boolean;
+}
+declare class ProgressiveShadows {
+    params: InternalParams;
+    scene: Scene;
+    renderer: WebGLRenderer;
+    buffer1Active: boolean;
+    dirLights: DirectionalLight[];
+    dirLightsHelpers: DirectionalLightHelper[];
+    clearColor: Color;
+    clearAlpha: number;
+    progress: number;
+    discardMaterial: any;
+    lights: LightInfo[];
+    meshes: MeshInfo[];
+    objectsToShow: ObjectInfo[];
+    private autoHiddenObjects;
+    private objectsToShowSet;
+    private objectsToShowAncestors;
+    framesDone: number;
+    fixedCamera: Camera | null;
+    isRendering: boolean;
+    progShadowGrp: Group;
+    lightOrigin: Group;
+    lightGroup: Group;
+    progressiveLightMap1: WebGLRenderTarget;
+    progressiveLightMap2: WebGLRenderTarget;
+    shadowCatcherMaterial: any;
+    shadowCatcherMesh: Mesh;
+    debugHelpersGroup: Group;
+    targetMat: MeshLambertMaterial;
+    previousShadowMap: {
+        value: any;
+    };
+    averagingWindow: {
+        value: number;
+    };
+    private isZUp;
+    get isFinished(): boolean;
+    set visible(v: boolean);
+    get paused(): boolean;
+    set paused(v: boolean);
+    constructor(renderer: WebGLRenderer, scene: Scene, { resolution, shadowMapRes, shadowBias, lightCount, size, frames, lightRadius, ambientWeight, alphaTest, paused, }?: ProgressiveShadowsParams);
+    renderOnRenderTargets(camera: Camera): void;
+    showDebugHelpers(visible: boolean): void;
+    randomiseLights(): void;
+    recalculate(): Promise<void>;
+    prepare(): void;
+    finish(): void;
+    clear(): void;
+    updateShadowObjectsList(): void;
+    private addObjectToShow;
+    private rebuildObjectsToShowAncestors;
+    private isExcludedObject;
+    update(camera: Camera): void;
+    destroy(): void;
+}
+export { ProgressiveShadows };

package/dist/{device-viewer → stories/device-viewer}/logo.d.ts

@@ -1,5 +1,5 @@
 import { Mesh, Object3D, Texture, Vector2 } from 'three';
-import { LogoProps } from '../../../../../../../stories/device-viewer/scene';
+import { LogoProps } from './scene';
 export declare class Logo {
     private _props;
     name: string;

package/dist/{device-viewer → stories/device-viewer}/outerline.d.ts

@@ -5,16 +5,28 @@ export declare class Outerline extends Object3D {
     private _text;
     private _line;
     private _box;
+    private _arc;
+    private _previousPosition;
+    private _updateTimer;
+    private readonly _updateDelay;
+    private _accumulatedAngle;
+    private _lastAngle;
     constructor(radius: number, height: number);
     hide(): void;
     show(): void;
+    dispose(): void;
     update(radius: number): void;
     change(pos: Vector3): void;
+    private _updateArc;
+    private _clearArc;
+    private _createArcGeometry;
 }
 export declare class RadiusText extends CSS2DObject {
     private _wrapper;
+    private _circle;
     constructor(radius: string);
     show(): void;
     hide(): void;
     update(radius: string): void;
+    updateColor(color?: string): void;
 }