@anov/3d 0.0.1 → 0.0.2

package/dist/core/scene.d.ts

@@ -1,17 +1,24 @@
-import type { Color, Object3D } from 'three';
-import { PerspectiveCamera, Raycaster, Scene, Vector3, WebGLRenderer } from 'three';
+import type { Color, ColorRepresentation, Object3D, ToneMapping } from 'three';
+import { AmbientLight, Raycaster, Scene as TScene, Vector3, WebGLRenderer } from 'three';
 import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
-interface Anov3DSceneOptions {
-    /**
-     * renderer options
-     */
+import Cssrenderer from './cssRenderer';
+import { PerspectiveCamera } from './camera';
+interface SceneOptions {
+    /** renderer options */
     rendererOps?: {
         antialias?: boolean;
         logarithmicDepthBuffer?: boolean;
+        alpha?: boolean;
+        shadowMap?: boolean;
+        toneMapping?: ToneMapping;
+        toneMappingExposure?: number;
+        size?: {
+            width: number;
+            height: number;
+            updateStyle?: boolean;
+        };
     };
-    /**
-     * default camera options
-     */
+    /** default camera options */
     defCameraOps?: {
         position?: Vector3;
         fov?: number;
@@ -19,36 +26,66 @@ interface Anov3DSceneOptions {
         near?: number;
         far?: number;
     };
-    /**
-     * default ambient light options
-     */
+    /** default ambient light options */
     defAmbientLightOps?: {
         position?: Vector3;
         color?: Color;
         intensity?: number;
     };
-    /**
-     * Controls
-     */
+    /** 默认射线检测配置 */
+    defRaycasterOps?: {
+        recursive?: boolean;
+    };
+    /** controls */
     orbitControls?: boolean;
-    /**
-     * if need ambient light
-     */
+    /** 是否需要默认环境光 */
     ambientLight?: boolean;
-    /**
-     * on demand render scene, 按需渲染
-     */
+    /** on demand render scene, 按需渲染 */
     onDemand?: boolean;
+    /** 是否开启css2d渲染 */
+    css2DRenderer?: boolean;
+    /** 是否开启css3d渲染 */
+    css3DRenderer?: boolean;
+    /** 是否开启裁剪 */
+    cutout?: boolean;
+    /** 场景背景相关 */
+    background?: {
+        imgs?: Tuple<string>;
+        color?: Color;
+        panorama?: string;
+        alpha?: number;
+    };
 }
-declare class Anov3DScene {
+declare type Tuple<TItem> = [TItem, ...TItem[]] & {
+    length: 6;
+};
+interface CutoutAreaType {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+declare class Scene {
     private opts;
     private pointer;
-    scene: Scene | null;
+    scene: TScene | null;
     raycaster: Raycaster | null;
+    ambientLight: AmbientLight | null;
     camera: PerspectiveCamera | null;
     renderer: WebGLRenderer | null;
+    cssRenderer: Cssrenderer | null;
     controls: OrbitControls | null;
-    constructor(opts: Anov3DSceneOptions);
+    domElement: HTMLElement | null;
+    /** 裁剪相关 */
+    cutoutCamera: PerspectiveCamera | null;
+    cutoutBackground: ColorRepresentation | null;
+    cutoutBackgroundAlpha: number;
+    cutoutArea: CutoutAreaType;
+    constructor(opts?: SceneOptions);
+    /**
+     * init default scene components
+     */
+    private defaultInit;
     /**
      * init scene
      * @param camera
@@ -59,6 +96,22 @@ declare class Anov3DScene {
      * init renderer
      */
     private initRenderer;
+    /**
+     * main view cut
+     * @param renderer
+     */
+    private cutMain;
+    /**
+     * mini view cut
+     * @param renderer
+     */
+    private cutSub;
+    private initCssRenderer;
+    /**
+     * init skybox
+     * @param imgs
+     */
+    private initSkyBox;
     /**
      * init default camera
      */
@@ -73,6 +126,7 @@ declare class Anov3DScene {
     private initAmbientLight;
     /**
      * frame render
+     * @param frameAnimate
      */
     startFrameAnimate(frameAnimate?: (renderer: WebGLRenderer) => void): void;
     /**
@@ -110,7 +164,12 @@ declare class Anov3DScene {
      * @param target
      */
     private registerEvent;
+    /**
+     * render scene
+     * @param target
+     */
     render(target: HTMLElement): void;
+    private updateRenderForCut;
     destroy(): void;
 }
-export default Anov3DScene;
+export default Scene;

package/dist/core/scene.js

@@ -5,30 +5,75 @@ function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _d
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
 function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-import { ACESFilmicToneMapping, AmbientLight, PerspectiveCamera, Raycaster, Scene, Vector2, Vector3, WebGLRenderer } from 'three';
+import { ACESFilmicToneMapping, AmbientLight, CubeTextureLoader, Raycaster, Scene as TScene, Vector2, Vector3, WebGLRenderer } from 'three';
 import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
+import * as TWEEN from '@tweenjs/tween.js';
 import { emitter } from "../utils";
-var Anov3DScene = /*#__PURE__*/function () {
-  function Anov3DScene(opts) {
-    _classCallCheck(this, Anov3DScene);
+import Mesh from "./mesh";
+import Cssrenderer from "./cssRenderer";
+import globalControl from "./global/globalControl";
+import globalObjectManage from "./global/global";
+import { PerspectiveCamera } from "./camera";
+var Scene = /*#__PURE__*/function () {
+  /** 裁剪相关 */
+
+  function Scene(opts) {
+    _classCallCheck(this, Scene);
     _defineProperty(this, "opts", {});
     _defineProperty(this, "pointer", new Vector2());
     _defineProperty(this, "scene", null);
     _defineProperty(this, "raycaster", null);
+    _defineProperty(this, "ambientLight", null);
     _defineProperty(this, "camera", null);
     _defineProperty(this, "renderer", null);
+    _defineProperty(this, "cssRenderer", null);
     _defineProperty(this, "controls", null);
+    _defineProperty(this, "domElement", null);
+    _defineProperty(this, "cutoutCamera", null);
+    _defineProperty(this, "cutoutBackground", null);
+    _defineProperty(this, "cutoutBackgroundAlpha", 1);
+    _defineProperty(this, "cutoutArea", {
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0
+    });
     this.opts = opts !== null && opts !== void 0 ? opts : {};
-    this.scene = new Scene();
+    this.scene = new TScene();
     this.raycaster = new Raycaster();
+    globalObjectManage.addScene(this.scene);
+    this.defaultInit();
   }
 
   /**
-   * init scene
-   * @param camera
-   * @param renderer
+   * init default scene components
    */
-  _createClass(Anov3DScene, [{
+  _createClass(Scene, [{
+    key: "defaultInit",
+    value: function defaultInit() {
+      var _this$opts$background, _this$opts$background2;
+      var camera = this.initDefaultPerspectiveCamera();
+      this.camera = camera;
+      globalObjectManage.setCamera(camera);
+      this.scene.add(camera);
+      if (this.opts.css2DRenderer) {
+        var cssRenderer = this.initCssRenderer();
+        this.cssRenderer = cssRenderer;
+      }
+      if (this.opts.ambientLight) {
+        var ambientLight = this.initAmbientLight();
+        this.ambientLight = ambientLight;
+        this.scene.add(ambientLight);
+      }
+      if ((_this$opts$background = this.opts.background) !== null && _this$opts$background !== void 0 && _this$opts$background.imgs) this.initSkyBox((_this$opts$background2 = this.opts.background) === null || _this$opts$background2 === void 0 ? void 0 : _this$opts$background2.imgs);
+    }
+
+    /**
+     * init scene
+     * @param camera
+     * @param renderer
+     */
+  }, {
     key: "resetScene",
     value: function resetScene(camera, renderer) {
       camera.aspect = window.innerWidth / window.innerHeight;
@@ -43,21 +88,82 @@ var Anov3DScene = /*#__PURE__*/function () {
   }, {
     key: "initRenderer",
     value: function initRenderer() {
-      var _rendererOps$antialia, _rendererOps$logarith;
+      var _rendererOps$antialia, _rendererOps$logarith, _rendererOps$alpha, _rendererOps$shadowMa, _rendererOps$toneMapp, _rendererOps$toneMapp2;
       var rendererOps = this.opts.rendererOps || {};
       var renderer = new WebGLRenderer({
         antialias: (_rendererOps$antialia = rendererOps.antialias) !== null && _rendererOps$antialia !== void 0 ? _rendererOps$antialia : true,
-        logarithmicDepthBuffer: (_rendererOps$logarith = rendererOps.logarithmicDepthBuffer) !== null && _rendererOps$logarith !== void 0 ? _rendererOps$logarith : true
+        logarithmicDepthBuffer: (_rendererOps$logarith = rendererOps.logarithmicDepthBuffer) !== null && _rendererOps$logarith !== void 0 ? _rendererOps$logarith : true,
+        alpha: (_rendererOps$alpha = rendererOps.alpha) !== null && _rendererOps$alpha !== void 0 ? _rendererOps$alpha : false
       });
-      renderer.setSize(window.innerWidth, window.innerHeight);
-      renderer.shadowMap.enabled = true;
-      renderer.toneMapping = ACESFilmicToneMapping;
-      renderer.toneMappingExposure = 0.3;
+      this.cutMain(renderer);
+      renderer.shadowMap.enabled = (_rendererOps$shadowMa = rendererOps.shadowMap) !== null && _rendererOps$shadowMa !== void 0 ? _rendererOps$shadowMa : true;
+      renderer.toneMapping = (_rendererOps$toneMapp = rendererOps.toneMapping) !== null && _rendererOps$toneMapp !== void 0 ? _rendererOps$toneMapp : ACESFilmicToneMapping;
+      renderer.toneMappingExposure = (_rendererOps$toneMapp2 = rendererOps.toneMappingExposure) !== null && _rendererOps$toneMapp2 !== void 0 ? _rendererOps$toneMapp2 : 0.3;
       renderer.setPixelRatio(window.devicePixelRatio);
-      this.renderer = renderer;
       return renderer;
     }
 
+    /**
+     * main view cut
+     * @param renderer
+     */
+  }, {
+    key: "cutMain",
+    value: function cutMain(renderer) {
+      var _rendererOps$size$wid, _rendererOps$size, _rendererOps$size$hei, _rendererOps$size2, _this$opts$background3, _this$opts$background4;
+      var rendererOps = this.opts.rendererOps || {};
+      var w = (_rendererOps$size$wid = (_rendererOps$size = rendererOps.size) === null || _rendererOps$size === void 0 ? void 0 : _rendererOps$size.width) !== null && _rendererOps$size$wid !== void 0 ? _rendererOps$size$wid : window.innerWidth;
+      var h = (_rendererOps$size$hei = (_rendererOps$size2 = rendererOps.size) === null || _rendererOps$size2 === void 0 ? void 0 : _rendererOps$size2.height) !== null && _rendererOps$size$hei !== void 0 ? _rendererOps$size$hei : window.innerHeight;
+      renderer.setClearColor(((_this$opts$background3 = this.opts.background) === null || _this$opts$background3 === void 0 ? void 0 : _this$opts$background3.color) || 0x000000, ((_this$opts$background4 = this.opts.background) === null || _this$opts$background4 === void 0 ? void 0 : _this$opts$background4.alpha) || 1);
+      renderer.setSize(w, h);
+      renderer.setScissor(0, 0, w, h);
+      renderer.render(this.scene, this.camera);
+    }
+
+    /**
+     * mini view cut
+     * @param renderer
+     */
+  }, {
+    key: "cutSub",
+    value: function cutSub(renderer) {
+      var _rendererOps$size$wid2, _rendererOps$size3, _this$cutoutBackgroun;
+      var rendererOps = this.opts.rendererOps || {};
+      var w = (_rendererOps$size$wid2 = (_rendererOps$size3 = rendererOps.size) === null || _rendererOps$size3 === void 0 ? void 0 : _rendererOps$size3.width) !== null && _rendererOps$size$wid2 !== void 0 ? _rendererOps$size$wid2 : window.innerWidth;
+      // const h = rendererOps.size?.height ?? window.innerHeight
+
+      // 位置 目前默认右上角
+      renderer.setClearColor((_this$cutoutBackgroun = this.cutoutBackground) !== null && _this$cutoutBackgroun !== void 0 ? _this$cutoutBackgroun : 0x000000, this.cutoutBackgroundAlpha);
+      renderer.setScissor(w - this.cutoutArea.width, 0, this.cutoutArea.width, this.cutoutArea.height);
+      renderer.setViewport(w - this.cutoutArea.width, 0, this.cutoutArea.width, this.cutoutArea.height);
+      renderer.render(this.scene, this.cutoutCamera);
+    }
+  }, {
+    key: "initCssRenderer",
+    value: function initCssRenderer() {
+      var _rendererOps$size$wid3, _rendererOps$size4, _rendererOps$size$hei2, _rendererOps$size5;
+      var rendererOps = this.opts.rendererOps || {};
+      var w = (_rendererOps$size$wid3 = (_rendererOps$size4 = rendererOps.size) === null || _rendererOps$size4 === void 0 ? void 0 : _rendererOps$size4.width) !== null && _rendererOps$size$wid3 !== void 0 ? _rendererOps$size$wid3 : window.innerWidth;
+      var h = (_rendererOps$size$hei2 = (_rendererOps$size5 = rendererOps.size) === null || _rendererOps$size5 === void 0 ? void 0 : _rendererOps$size5.height) !== null && _rendererOps$size$hei2 !== void 0 ? _rendererOps$size$hei2 : window.innerHeight;
+      var cssRenderer = new Cssrenderer('base');
+      cssRenderer.setSize(w, h);
+      return cssRenderer;
+    }
+
+    /**
+     * init skybox
+     * @param imgs
+     */
+  }, {
+    key: "initSkyBox",
+    value: function initSkyBox(imgs) {
+      var _this = this;
+      var cubeTextureLoader = new CubeTextureLoader();
+      cubeTextureLoader.load([imgs[0], imgs[1], imgs[2], imgs[3], imgs[4], imgs[5]], function (texture) {
+        _this.scene.background = texture;
+      });
+    }
+
     /**
      * init default camera
      */
@@ -65,11 +171,10 @@ var Anov3DScene = /*#__PURE__*/function () {
     key: "initDefaultPerspectiveCamera",
     value: function initDefaultPerspectiveCamera() {
       var rendererOps = this.opts.defCameraOps || {};
-      var camera = new PerspectiveCamera(rendererOps.fov || 90, window.innerWidth / window.innerHeight, rendererOps.near || 0.1, rendererOps.far || 1000);
-      var position = rendererOps.position || new Vector3(0, 3, 10);
+      var aspect = rendererOps.aspect || window.innerWidth / window.innerHeight;
+      var camera = new PerspectiveCamera(rendererOps.fov || 90, aspect, rendererOps.near || 0.1, rendererOps.far || 5000);
+      var position = rendererOps.position || new Vector3(0, 10, 10);
       camera.position.set(position.x, position.y, position.z);
-      this.camera = camera;
-      this.scene.add(camera);
       return camera;
     }
 
@@ -92,20 +197,26 @@ var Anov3DScene = /*#__PURE__*/function () {
 
     /**
      * frame render
+     * @param frameAnimate
      */
   }, {
     key: "startFrameAnimate",
     value: function startFrameAnimate(frameAnimate) {
-      var _this = this;
+      var _this2 = this;
       if (!this.renderer || !this.scene || !this.camera) throw new Error('scene or camera or renderer is not init');
-      if (frameAnimate) {
-        frameAnimate(this.renderer);
-      } else {
-        this.controls && this.controls.update();
-        this.renderer.render(this.scene, this.camera);
-      }
+      if (frameAnimate) frameAnimate(this.renderer);
+      if (globalObjectManage.frameCallbacks.size > 0) globalObjectManage.frameCallbacks.forEach(function (cb) {
+        cb();
+      });
+      globalControl.update();
+      TWEEN.update();
+
+      // if need cutout
+      if (this.opts.cutout) this.updateRenderForCut();else this.renderer.render(this.scene, this.camera);
+      this.cssRenderer && this.cssRenderer.render(this.scene, this.camera);
+      this.controls && this.controls.update();
       requestAnimationFrame(function () {
-        return _this.startFrameAnimate(frameAnimate);
+        return _this2.startFrameAnimate(frameAnimate);
       });
     }
 
@@ -125,14 +236,30 @@ var Anov3DScene = /*#__PURE__*/function () {
   }, {
     key: "updateRaycaster",
     value: function updateRaycaster() {
+      var _raycasterOps$recursi;
+      var raycasterOps = this.opts.defRaycasterOps || {};
       this.raycaster.setFromCamera(this.pointer, this.camera);
-      this.raycaster.intersectObjects(this.scene.children);
+
+      // need expand
+      var object3ds = this.scene.children.filter(function (item) {
+        return item instanceof Mesh;
+      });
+      this.raycaster.intersectObjects(object3ds, (_raycasterOps$recursi = raycasterOps.recursive) !== null && _raycasterOps$recursi !== void 0 ? _raycasterOps$recursi : false);
+
+      // group的拾取，构建一个mesh？
+
+      // const intersects = this.raycaster!.intersectObjects(this.scene!.children, false)
+      // globalObjectManage.groupCatch.forEach((group) => {
+      //   if (intersects.length > 0)
+      //     group.raycastGroup(intersects as Intersection<Object3D<Event>>[])
+      // })
     }
   }, {
     key: "getPointerPosition",
     value: function getPointerPosition(event) {
-      this.pointer.setX(event.clientX / window.innerWidth * 2 - 1);
-      this.pointer.setY(-(event.clientY / window.innerHeight) * 2 + 1);
+      var container = this.domElement;
+      this.pointer.setX((event.clientX - container.getBoundingClientRect().left) / container.getBoundingClientRect().width * 2 - 1);
+      this.pointer.setY(-((event.clientY - container.getBoundingClientRect().top) / container.getBoundingClientRect().height) * 2 + 1);
     }
 
     /**
@@ -142,8 +269,14 @@ var Anov3DScene = /*#__PURE__*/function () {
   }, {
     key: "onPointerPointerup",
     value: function onPointerPointerup(event) {
+      globalObjectManage.setTriggerClickState(false);
+      var transformControls = globalObjectManage.transformControls;
+      if (transformControls.length > 0) {
+        transformControls.forEach(function (transformControl) {
+          transformControl.detach();
+        });
+      }
       this.getPointerPosition(event);
-      emitter.emit('pointerup');
       this.updateRaycaster();
     }
 
@@ -154,8 +287,8 @@ var Anov3DScene = /*#__PURE__*/function () {
   }, {
     key: "onPointerDown",
     value: function onPointerDown(event) {
+      globalObjectManage.setTriggerClickState(true);
       this.getPointerPosition(event);
-      emitter.emit('pointerdown');
       this.updateRaycaster();
     }
 
@@ -167,7 +300,6 @@ var Anov3DScene = /*#__PURE__*/function () {
     key: "onPointerMove",
     value: function onPointerMove(event) {
       this.getPointerPosition(event);
-      emitter.emit('pointermove');
       this.updateRaycaster();
     }
 
@@ -179,7 +311,6 @@ var Anov3DScene = /*#__PURE__*/function () {
     key: "onPointerLeave",
     value: function onPointerLeave(event) {
       this.getPointerPosition(event);
-      emitter.emit('pointerleave');
       this.updateRaycaster();
     }
 
@@ -190,46 +321,69 @@ var Anov3DScene = /*#__PURE__*/function () {
   }, {
     key: "registerEvent",
     value: function registerEvent(target) {
-      var _this2 = this;
+      var _this3 = this;
       target.addEventListener('pointerup', function (e) {
-        return _this2.onPointerPointerup(e);
+        return _this3.onPointerPointerup(e);
       });
       target.addEventListener('pointerdown', function (e) {
-        return _this2.onPointerDown(e);
+        return _this3.onPointerDown(e);
       });
       target.addEventListener('pointermove', function (e) {
-        return _this2.onPointerMove(e);
+        return _this3.onPointerMove(e);
       });
       target.addEventListener('pointerleave', function (e) {
-        return _this2.onPointerLeave(e);
+        return _this3.onPointerLeave(e);
       });
     }
+
+    /**
+     * render scene
+     * @param target
+     */
   }, {
     key: "render",
     value: function render(target) {
-      var _this3 = this;
-      var camera = this.initDefaultPerspectiveCamera();
+      var _this4 = this;
+      emitter.emit('before-render');
       var renderer = this.initRenderer();
-      if (this.opts.orbitControls) this.controls = new OrbitControls(camera, renderer.domElement);
-      if (this.opts.ambientLight) {
-        var ambientLight = this.initAmbientLight();
-        this.scene.add(ambientLight);
+      this.renderer = renderer;
+      var currentControlDom = null;
+      var domElement = this.renderer.domElement;
+      this.domElement = domElement;
+      if (this.cssRenderer) {
+        currentControlDom = this.cssRenderer.cssRenderer.domElement;
+        target.appendChild(currentControlDom);
+        currentControlDom.style.position = 'absolute';
+        currentControlDom.style.top = '0';
       }
-      target.appendChild(renderer.domElement);
-      this.registerEvent(renderer.domElement);
+      if (this.opts.orbitControls) {
+        this.controls = new OrbitControls(this.camera, currentControlDom || domElement);
+        globalObjectManage.setOrbitControls(this.controls);
+      }
+      globalObjectManage.setDomElement(currentControlDom || domElement);
+      target.appendChild(domElement);
+      this.registerEvent(currentControlDom || domElement);
       target.addEventListener('resize', function () {
-        return _this3.resetScene(camera, renderer);
+        return _this4.resetScene(_this4.camera, _this4.renderer);
       });
+      emitter.emit('after-render');
+    }
+  }, {
+    key: "updateRenderForCut",
+    value: function updateRenderForCut() {
+      this.renderer.setScissorTest(true);
+      this.cutMain(this.renderer);
+      this.cutSub(this.renderer);
     }
   }, {
     key: "destroy",
     value: function destroy() {
-      var _this4 = this;
+      var _this5 = this;
       window.removeEventListener('resize', function () {
-        return _this4.resetScene(_this4.camera, _this4.renderer);
+        return _this5.resetScene(_this5.camera, _this5.renderer);
       });
     }
   }]);
-  return Anov3DScene;
+  return Scene;
 }();
-export default Anov3DScene;
+export default Scene;

package/dist/core/use/useScene.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 获取核心场景控件，必须在场景上下文中使用
+ * @returns
+ */
+declare const useScene: () => {
+    scene: import("three").Scene | null;
+    domElement: HTMLElement | null;
+    orbitControls: import("three/examples/jsm/controls/OrbitControls").OrbitControls | null;
+};
+export default useScene;

package/dist/core/use/useScene.js

@@ -0,0 +1,14 @@
+import globalObjectManage from "../global/global";
+
+/**
+ * 获取核心场景控件，必须在场景上下文中使用
+ * @returns
+ */
+var useScene = function useScene() {
+  return {
+    scene: globalObjectManage.scene,
+    domElement: globalObjectManage.domElement,
+    orbitControls: globalObjectManage.orbitControls
+  };
+};
+export default useScene;

package/dist/core/use/useframe.d.ts

@@ -0,0 +1,6 @@
+/**
+ * frame hook
+ * @param cb
+ */
+declare const useframe: (cb: () => void) => () => void;
+export default useframe;

package/dist/core/use/useframe.js

@@ -0,0 +1,11 @@
+import globalObjectManage from "../global/global";
+
+/**
+ * frame hook
+ * @param cb
+ */
+var useframe = function useframe(cb) {
+  globalObjectManage.addFrameCallback(cb);
+  return globalObjectManage.removeFrameCallback.bind(globalObjectManage, cb);
+};
+export default useframe;

package/dist/export.d.ts

@@ -0,0 +1,41 @@
+import Scene from './core/scene';
+import Mesh from './core/mesh';
+import Group from './core/group';
+import { PerspectiveCamera } from './core/camera';
+import ModelLoader from './core/model';
+import { ModelType } from './commonEnu';
+import { createLabel } from './utils/createLabel';
+import { createControlLine } from './core/line';
+import { TransformControls, createTransformControls } from './core/control/transformControls';
+import { Direction } from './utils/move';
+import globalObjectManage from './core/global/global';
+declare const utils: {
+    moveTo: (currentObject3D: import("three").Object3D<import("three").Event>, targetObject3D: import("three").Object3D<import("three").Event>, distance: number, direction: Direction, duration?: number | undefined, animationMethod?: string | undefined) => import("@tweenjs/tween.js").Tween<import("three").Vector3>;
+    moveLine: (currentObject3D: import("three").Object3D<import("three").Event>, targetObject3D: import("three").Object3D<import("three").Event>) => void;
+    moveWithRound: (currentObject3d: import("three").Object3D<import("three").Event>, speed?: number, duration?: number | undefined) => void;
+    moveWithLine: (currentObject: import("three").Object3D<import("three").Event>, curve: import("three").CatmullRomCurve3, points?: number, offset?: import("./utils/move").OffsetType, lookat?: import("three").Vector3 | undefined) => import("./utils/move").ControlsRetuenFuncType;
+};
+declare const dom: {
+    appendChildren: (node: HTMLElement, children: HTMLElement[]) => void;
+    create: (...tags: string[]) => ((options?: import("./utils/createElement").OpsType, children?: HTMLElement[]) => HTMLDivElement)[];
+    createElement: (tag: string, options?: import("./utils/createElement").OpsType, children?: HTMLElement[]) => HTMLDivElement;
+    setAttributes: (el: HTMLElement, attrs?: {
+        [key: string]: string;
+    } | undefined) => void;
+    setClassList: (el: HTMLElement, classList: string[]) => void;
+    setEventListeners: (el: HTMLElement, events?: {
+        [key: string]: () => void;
+    } | undefined) => void;
+};
+declare const use: {
+    useframe: (cb: () => void) => () => void;
+    useScene: () => {
+        scene: import("three").Scene | null;
+        domElement: HTMLElement | null;
+        orbitControls: import("three/examples/jsm/controls/OrbitControls").OrbitControls | null;
+    };
+};
+export * from 'three';
+export { Scene as TScene } from 'three';
+export * from './threeCell';
+export { Scene, Mesh, Group, PerspectiveCamera, ModelLoader, TransformControls, createControlLine, createLabel, ModelType, Direction, createTransformControls, utils, dom, use, globalObjectManage, };

package/dist/export.js

@@ -0,0 +1,37 @@
+/* eslint-disable import/export */
+import Scene from "./core/scene";
+import Mesh from "./core/mesh";
+import Group from "./core/group";
+import { PerspectiveCamera } from "./core/camera";
+import ModelLoader from "./core/model";
+import { ModelType } from "./commonEnu";
+import { createLabel } from "./utils/createLabel";
+import { createControlLine } from "./core/line";
+import { TransformControls, createTransformControls } from "./core/control/transformControls";
+import { Direction, moveLine, moveTo, moveWithLine, moveWithRound } from "./utils/move";
+import { appendChildren, create, createElement, setAttributes, setClassList, setEventListeners } from "./utils/createElement";
+import globalObjectManage from "./core/global/global";
+import useframe from "./core/use/useframe";
+import useScene from "./core/use/useScene";
+var utils = {
+  moveTo: moveTo,
+  moveLine: moveLine,
+  moveWithRound: moveWithRound,
+  moveWithLine: moveWithLine
+};
+var dom = {
+  appendChildren: appendChildren,
+  create: create,
+  createElement: createElement,
+  setAttributes: setAttributes,
+  setClassList: setClassList,
+  setEventListeners: setEventListeners
+};
+var use = {
+  useframe: useframe,
+  useScene: useScene
+};
+export * from 'three';
+export { Scene as TScene } from 'three';
+export * from "./threeCell";
+export { Scene, Mesh, Group, PerspectiveCamera, ModelLoader, TransformControls, createControlLine, createLabel, ModelType, Direction, createTransformControls, utils, dom, use, globalObjectManage };