gl-draw 0.15.0-beta.3 → 0.15.0-beta.30

package/dist/constants.d.ts

@@ -1,3 +1,4 @@
 export declare const ENTIRE_SCENE = 0;
 export declare const BLOOM_SCENE = 1;
+export declare const HIDE_SCENE = 2;
 export declare const IS_DEV: boolean;

package/dist/core/BaseObject/PointerEvent.d.ts

@@ -0,0 +1,13 @@
+import type Lead from "../Lead/Lead";
+import type { PickFunctionsItem } from "../Lead/Pick";
+export default class PointerEvent {
+    lead: Lead;
+    private onPointerIndex;
+    onPointerEvent(type: PickFunctionsItem['type'], cb: PickFunctionsItem['cb']): void;
+    onClick(cb: PickFunctionsItem['cb']): void;
+    onPointerEnter(cb: PickFunctionsItem['cb']): void;
+    onPointerLeave(cb: PickFunctionsItem['cb']): void;
+    onPointerMove(cb: PickFunctionsItem['cb']): void;
+    onPointerDown(cb: PickFunctionsItem['cb']): void;
+    dispose(): void;
+}

package/dist/core/BaseObject/UseMaterial.d.ts

@@ -0,0 +1,23 @@
+import type { Material, Object3D } from 'three';
+import type Lead from "../Lead/Lead";
+import type MList from "../MList/MList";
+import type Pencil from "../Pencil";
+import PointerEvent from './PointerEvent';
+export { CSS2DObject } from 'three/examples/jsm/renderers/CSS2DRenderer';
+export { CSS3DObject, CSS3DSprite, } from 'three/examples/jsm/renderers/CSS3DRenderer';
+export default class UseMaterial extends PointerEvent {
+    pencil: Pencil;
+    lead: Lead;
+    mList: MList;
+    userData: Record<string, any>;
+    object3d: Object3D;
+    cloneMaterial(): Material | Material[] | undefined;
+    materialList: Record<string, Material | Material[]>;
+    setMaterialList(name: string, material: Material | Material[] | 'clone'): Material | Material[] | undefined;
+    useMaterialType: string;
+    useMaterial(name: string): void;
+    useMListById(id: string, slot?: number): void;
+    useMListByName(name: string, slot?: number): void;
+    disposeMaterialIfNotUsed: boolean;
+    dispose(): void;
+}

package/dist/core/{BaseObject.d.ts → BaseObject/index.d.ts}

@@ -1,21 +1,19 @@
-import { Object3D, Mesh, Points, Vector3, SpriteMaterial, Material } from 'three';
-import type Pencil from "./Pencil";
-import type Lead from "./Lead/Lead";
-import type MList from "./MList/MList";
-import type { PickFunctionsItem } from "./Lead/Pick";
-import ResourceTracker from "./ResourceTracker";
-export { CSS3DObject, CSS3DSprite, } from 'three/examples/jsm/renderers/CSS3DRenderer';
+import { Mesh, type Object3D, Points, type SpriteMaterial, Vector3 } from 'three';
+import type Lead from "../Lead/Lead";
+import type MList from "../MList/MList";
+import type Pencil from "../Pencil";
+import UseMaterial from './UseMaterial';
 export { CSS2DObject } from 'three/examples/jsm/renderers/CSS2DRenderer';
-export default class BaseObject extends ResourceTracker {
+export { CSS3DObject, CSS3DSprite, } from 'three/examples/jsm/renderers/CSS3DRenderer';
+export default class BaseObject extends UseMaterial {
+    key: string;
     objectType: string;
     objectOptions?: Record<string, any>;
-    key: string;
     pencil: Pencil;
     lead: Lead;
     mList: MList;
     object3d: Object3D;
     userData: Record<string, any>;
-    disposeWithMaterial: boolean;
     prefab: boolean;
     isInstantiate: boolean;
     isBloom: boolean;
@@ -24,18 +22,22 @@ export default class BaseObject extends ResourceTracker {
     get position(): Vector3;
     get rotation(): import("three").Euler;
     get scale(): Vector3;
-    get add(): (...object: Object3D[]) => Object3D<import("three").Object3DEventMap>;
-    get remove(): (...object: Object3D[]) => Object3D<import("three").Object3DEventMap>;
+    get lookAt(): {
+        (vector: Vector3): void;
+        (x: number, y: number, z: number): void;
+    };
+    add(...object: Object3D[]): void;
+    remove(...object: Object3D[]): void;
     get visible(): boolean;
     get visibleWithAncestors(): boolean;
     create(): void;
     render(): void;
-    update(delta: number, elapsed: number): void;
-    resize(width: number, height: number): void;
+    update(_delta: number, _elapsed: number): void;
+    resize(_width: number, _height: number): void;
     show(): this;
     hide(): this;
-    createMesh(...args: ConstructorParameters<typeof Mesh>): this;
     createGroup(): this;
+    createMesh(...args: ConstructorParameters<typeof Mesh>): this;
     createPoints(...args: ConstructorParameters<typeof Points>): this;
     createCSS2DObject(dom: HTMLElement): this;
     createCSS3DObject(dom: HTMLElement): this;
@@ -48,29 +50,22 @@ export default class BaseObject extends ResourceTracker {
         size: Vector3;
         center: Vector3;
     };
+    setTop(onTop: number): void;
     traverse(fn: (o: IBaseObject) => void): void;
-    clone(): Promise<this>;
-    instantiate(meta?: {
-        position: Vector3 | number[] | [number, number, number];
-        scale?: Vector3 | number[] | [number, number, number];
-    }[], ops?: {
+    instantiate(ops?: {
         key?: string;
         target?: IBaseObject;
         create?: ((...args: any[]) => any) | boolean;
         recursive?: boolean;
+        instancedAttr?: {
+            position: Vector3 | number[] | [number, number, number];
+            scale?: Vector3 | number[] | [number, number, number];
+        }[];
     }): Promise<this>;
-    private setInstancedMatrix;
     erase(): void;
-    cloneMaterial(): Material | Material[] | undefined;
-    materialList: Record<string, Material | Material[]>;
-    setMaterialList(name: string, material: Material | Material[] | 'clone', cover?: boolean): Material | Material[] | undefined;
-    useMaterialType: string;
-    useMaterial(name: string): void;
-    setTop(onTop: number): void;
-    private onPointerIndex;
-    onPointerEvent(type: PickFunctionsItem['type'], cb: PickFunctionsItem['cb']): void;
     enableBloom(): void;
     disableBloom(): void;
+    disposeTrack: boolean;
     dispose(): void;
 }
 export interface IBaseObject extends BaseObject {

package/dist/core/Composer.d.ts

@@ -1,14 +1,14 @@
 import { WebGLRenderer, Scene, Camera, Vector2, Layers, Material } from 'three';
-import CameraController from './Camera';
-import SceneController from './Scene';
-import RendererController from './Renderer';
 import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer';
 import { RenderPass } from 'three/examples/jsm/postprocessing/RenderPass';
 import { SSAOPass } from 'three/examples/jsm/postprocessing/SSAOPass';
-import { OutputPass } from './pass/OutputPass';
-import getMixPass from './pass/MixPass';
 import { UnrealBloomPass } from 'three/examples/jsm/postprocessing/UnrealBloomPass';
 import type { IBaseObject } from './BaseObject';
+import CameraController from './Camera';
+import getMixPass from './pass/MixPass';
+import { OutputPass } from './pass/OutputPass';
+import RendererController from './Renderer';
+import SceneController from './Scene';
 export interface BloomParams {
     threshold: number;
     strength: number;

package/dist/core/Lead/Lead.d.ts

@@ -1,27 +1,32 @@
-import { Object3D, Scene } from 'three';
-import { IBaseObject } from "../BaseObject";
-import Group from "../../objects/group";
-import BaseScene from "../../objects/scene";
-import Pencil from "../Pencil";
-import Pick from './Pick';
+import { type Object3D, Scene } from 'three';
+import BaseObject, { type IBaseObject } from "../BaseObject";
 import type MList from "../MList/MList";
+import type Pencil from "../Pencil";
+import Pick from './Pick';
 type KeyOf<T extends object> = Extract<keyof T, string>;
 export default class Draw<T extends {
     [key: string]: new (...args: any[]) => IBaseObject;
 } = any> extends Pick {
     objMap: Map<Object3D<import("three").Object3DEventMap>, IBaseObject>;
     objects: Map<string, IBaseObject>;
-    objectsPm: Map<string, Promise<any>>;
-    scene: BaseScene;
+    objectsPm: Map<IBaseObject, Promise<any>>;
+    objectWrapChindIdMap: Map<IBaseObject, number>;
+    scene: IBaseObject;
     mList: MList;
-    group: Group;
-    prefabGroup: Group;
+    group: IBaseObject;
+    prefabGroup: IBaseObject;
     private objectNamesToFactories;
     get objectsPromise(): IterableIterator<Promise<any>>;
     constructor(pencil: Pencil, ops: {
         scene: Scene;
         mList: MList;
     });
+    createBaseObject(object3d: Object3D, opsO?: {
+        key?: string;
+        name?: string;
+        target?: IBaseObject | null;
+        mList?: boolean;
+    }): BaseObject;
     init<K extends {
         [key: string]: new (...args: any[]) => IBaseObject;
     }>(objectFactories: K): Draw<K>;
@@ -48,6 +53,8 @@ export default class Draw<T extends {
     updateBaseObjectKey(baseObject: IBaseObject, keyOrigin: string): string;
     private addBaseObject;
     erase(...args: (KeyOf<T> | `${KeyOf<T>}#${string}` | InstanceType<T[keyof T]>)[]): void;
+    eraseWithoutMaterial(...args: (KeyOf<T> | `${KeyOf<T>}#${string}` | InstanceType<T[keyof T]>)[]): void;
+    private handleErase;
     update(delta: number, elapsed: number): void;
     setSize(width: number, height: number): void;
     eraseAll(): void;

package/dist/core/Lead/Pick.d.ts

@@ -5,6 +5,7 @@ export type PickFunctionsItem = {
     type: 'move' | 'enter' | 'leave' | 'down' | 'click' | 'downOutside';
     cb: (data: {
         baseObject: IBaseObject;
+        realBaseObject?: IBaseObject;
         mouseEvent: MouseEvent;
         intersectionIndex?: number;
         sp?: () => void;
@@ -18,13 +19,13 @@ export default class Pick {
     private pickFunctionsMapIndex;
     private pickNodeFunctionsMapIndex;
     private activeObjects;
+    private activeObject;
     private prevActiveObjects;
     private objCallbackMap;
     private pickListener;
     private domElement;
     constructor(pencil: Pencil);
     private addPickListener;
-    private sortIntersections;
     private processIntersection;
     private processObjectHierarchy;
     private handleLeaveEvents;

package/dist/core/MList/MList.d.ts

@@ -4,22 +4,28 @@ import Pencil from "../Pencil";
 export default class MaterialList {
     pencil: Pencil;
     private materials;
+    fixBaseObjects: Map<string, IBaseObject>;
     private materialBaseObjectMap;
-    private fixBufferGeometry;
     constructor(pencil: Pencil);
     add(key: string, material: Material): void;
     get(key: string): Material | undefined;
+    getByName(name: string): Material | undefined;
     getKey(material: Material): string | undefined;
+    getKeyByName(name: string): string | undefined;
     addMultiple(key: string, materialMap: Record<string, Material | null>): void;
     getMultiple(key: string): Record<string, Material> | null;
+    copy(sourceKey: string, destinationKey: string, ops?: {
+        name?: string;
+    }): Material | null;
     copyMultiple(sourceKey: string, destinationKey: string): Record<string, Material>;
-    disposeMaterial(material: Material): void;
+    disposeMaterial(material?: Material | Material[]): void;
     remove(key: string): void;
     removeByMaterial(material: Material): void;
     proxyBaseObject(object: IBaseObject): void;
+    private material2array;
     addBaseObjectMap(object: IBaseObject): void;
-    rmBaseObjectMap(object: IBaseObject, targetMaterial?: Material): void;
-    getBaseObjectMaterials(): Record<string, Material>;
-    emitObject3dChange(): void;
+    rmBaseObjectMap(object: IBaseObject, targetMaterial?: Material | Material[], disposeMaterial?: boolean): void;
+    getBaseObjectMap(material: Material): Set<IBaseObject>;
+    syncChangeMaterial(oldMaterial: Material, material: Material): void;
     dispose(): void;
 }

package/dist/core/Pencil.d.ts

@@ -1,18 +1,18 @@
-import { Object3D, Vector3, PerspectiveCamera } from 'three';
-import { Timer } from 'three/examples/jsm/misc/Timer';
 import { EventEmitter } from 'events';
 import Stats from 'stats-gl';
-import RendererController, { RendererParams } from "./Renderer";
-import CameraController, { CameraParams } from "./Camera";
-import SceneController, { SceneParams } from "./Scene";
+import { type Object3D, type PerspectiveCamera, Vector3 } from 'three';
+import { Timer } from 'three/examples/jsm/misc/Timer';
+import CameraController, { type CameraParams } from "./Camera";
+import ComposerController, { type BloomParams, type ComposerParams, type SSAOParams } from "./Composer";
+import ControlsController, { type ControlsParams } from "./Controls";
+import CSSRendererController, { type CSSRendererParams } from "./CSSRenderer";
 import HelperController from "./Helper";
-import ControlsController, { ControlsParams } from "./Controls";
-import TransformController from "./TransformControls";
-import CSSRendererController, { CSSRendererParams } from "./CSSRenderer";
-import ComposerController, { BloomParams, SSAOParams, ComposerParams } from "./Composer";
-import LoaderController, { LoaderParams } from "./Loader";
 import LeadController from "./Lead";
+import LoaderController, { type LoaderParams } from "./Loader";
 import MListController from "./MList";
+import RendererController, { type RendererParams } from "./Renderer";
+import SceneController, { type SceneParams } from "./Scene";
+import TransformController from "./TransformControls";
 import type { Wk } from "../plugins";
 type DeepRequired<T> = T extends Function | HTMLElement ? T : T extends object ? {
     [P in keyof T]-?: DeepRequired<T[P]>;
@@ -158,6 +158,8 @@ export default class Pencil {
     private userSetDprCache;
     private handeleResize;
     setDevicePixelRatio(userSetDprCache: number): void;
+    private viewPadding;
+    setViewPadding(top?: number, right?: number, bottom?: number, left?: number): void;
     pick(event: MouseEvent, objects?: Object3D[], recursive?: boolean): {
         object: Object3D<import("three").Object3DEventMap>;
         index: number | undefined;

package/dist/core/Renderer.d.ts

@@ -44,7 +44,6 @@ export default class {
         scissor?: boolean;
         scissorTest?: boolean;
     }): void;
-    setViewPadding(top?: number, right?: number, bottom?: number, left?: number): void;
     dispose(): void;
 }
 export {};

package/dist/core/ResourceTracker.d.ts

@@ -1,13 +1,11 @@
 import { Material, Object3D, Texture, BufferGeometry } from 'three';
-type Resource = Object3D | Material | Texture | BufferGeometry | ResourceTracker | HTMLVideoElement;
+import BaseObject from './BaseObject';
+type Resource = Object3D | Material | Texture | BufferGeometry | BaseObject | HTMLVideoElement;
 export default class ResourceTracker {
     resources: Set<Resource>;
-    disposeWithMaterial: boolean;
+    disposeMaterial: boolean;
     disposeVideo: boolean;
-    object3d: Object3D;
-    materialList: Record<string, Material | Material[]>;
-    disposeTrack: boolean;
-    track(resource: Resource | Resource[]): Resource | Resource[];
+    track(resource: Resource | Resource[]): Material | Object3D<import("three").Object3DEventMap> | Texture | BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap> | BaseObject | HTMLVideoElement | Resource[];
     dispose(): void;
 }
 export {};