three-base 1.0.62 → 1.0.65

package/lib/lib/ApngTextureManage.d.ts

@@ -0,0 +1,18 @@
+import { Texture, TextureLoader } from "three";
+/**
+ * apng 纹理管理对象
+ */
+declare class apngTextureManage {
+    constructor();
+    static TextureLoader: TextureLoader;
+    static isInit: boolean;
+    static TimeTemp: number;
+    playTimes: Map<any, any>;
+    anpgTextList: {
+        [key: string]: Texture[];
+    };
+    getTexture(path: string): Texture;
+    loadApng(url: string): Promise<void>;
+}
+declare const ApngTextureManage: apngTextureManage;
+export default ApngTextureManage;

package/lib/lib/EventMesh.d.ts

@@ -0,0 +1,18 @@
+import { BoxGeometry, BufferGeometry, CylinderGeometry, Material, Mesh, MeshNormalMaterial } from "three";
+export declare enum CollisionShaere {
+    cube = "cube",
+    cylinder = "cylinder"
+}
+/**
+ * 碰撞检测用的模型
+ */
+export default class EventMesh extends Mesh<BufferGeometry, Material> {
+    constructor(type?: CollisionShaere);
+    static type: typeof CollisionShaere;
+    static material: MeshNormalMaterial;
+    renderOrder: number;
+    static cubeGeo: BoxGeometry;
+    static cylinderGeo: CylinderGeometry;
+    isEventMesh: boolean;
+    setType(type: CollisionShaere): void;
+}

package/lib/lib/ExtrudeMesh.d.ts

@@ -0,0 +1,111 @@
+import { BufferGeometry, Material, Matrix4, Mesh, Vector2, Vector3 } from "three";
+export type ExtrudePath = {
+    vector3: [number, number, number];
+    radius: number;
+    segments: number;
+    scale: {
+        x: number;
+        y: number;
+    };
+    name: string;
+};
+export interface ExtrudeMeshProps {
+    paths: Array<ExtrudePath>;
+    shapePath: Array<[number, number]>;
+    closed: boolean;
+}
+/**
+ * 挤出模型
+ * 此组件适合自动生成 公路 河流山川等 2d 平面上的模型
+ *
+ * @export
+ * @class ExtrudeMesh
+ * @extends {Mesh<BufferGeometry, Material>}
+ */
+export default class ExtrudeMesh extends Mesh<BufferGeometry, Material> {
+    static temp1Vector2: Vector2;
+    static temp2Vector2: Vector2;
+    static temp3Vector2: Vector2;
+    static tempVector3: Vector3;
+    static temp1Vector3: Vector3;
+    static temp2Vector3: Vector3;
+    static temp3Vector3: Vector3;
+    static temp1Matrix4: Matrix4;
+    static temp2Matrix4: Matrix4;
+    static temp3Matrix4: Matrix4;
+    constructor(props: ExtrudeMeshProps, material?: Material);
+    pointerWidthRadius: Array<{
+        vector3: [number, number, number];
+        matrix: [
+            number,
+            number,
+            number,
+            number,
+            number,
+            number,
+            number,
+            number,
+            number,
+            number,
+            number,
+            number,
+            number,
+            number,
+            number,
+            number
+        ];
+    }>;
+    computerMatrix(vector1: [number, number, number], vector2: [number, number, number], scale: [number, number, number]): import("three").Matrix4Tuple;
+    /**
+     * @计算渐变值 computerGradient([3,2,4], 0.3);
+     * @渐变区间 values:number[]
+     * @百分比 percentage:number
+     */
+    computerGradient(values: number[], percentage: number): number;
+    computerPointerWidthRadius(paths: Array<ExtrudePath>, closed: boolean): void;
+    computerPathLength(points: [number, number, number][]): number;
+    setExtrudeMesh(startP: [number, number, number], // 起点位置
+    startMatrix4: [
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number
+    ], // 起点位置的矩阵
+    endP: [number, number, number], // 终点位置
+    endMatrix4: [
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number
+    ], // 终点位置的矩阵
+    uvx: number, // uv.x 的起始位置
+    shapePath: Array<[number, number]>): {
+        geometryPoint: number[];
+        uvPoint: number[];
+    };
+    updateGeometry(props: ExtrudeMeshProps): void;
+}

package/lib/lib/FPScontrol.d.ts

@@ -0,0 +1,44 @@
+import { Camera, Clock, EventDispatcher, Object3D, Vector3 } from "three";
+import { Capsule } from "three/examples/jsm/math/Capsule";
+import { Octree } from "three/examples/jsm/math/Octree";
+/**
+ * 第一人称控制器
+ *
+ * @export
+ * @class FPScontrol
+ * @extends {EventDispatcher}
+ */
+export default class FPScontrol extends EventDispatcher {
+    canvas: HTMLCanvasElement;
+    constructor(camera: Camera, canvas: HTMLCanvasElement);
+    enable: boolean;
+    GRAVITY: number;
+    STEPS_PER_FRAME: number;
+    camera: Camera;
+    worldOctree: Octree;
+    playerCollider: Capsule;
+    clock: Clock;
+    playerVelocity: Vector3;
+    playerDirection: Vector3;
+    playerOnFloor: boolean;
+    mouseTime: number;
+    isMousedown: boolean;
+    keyStates: {
+        [key: string]: boolean;
+    };
+    init(canvas: HTMLCanvasElement): void;
+    keydown: (event: KeyboardEvent) => void;
+    keyup: (event: KeyboardEvent) => void;
+    mousedown: () => void;
+    mouseup: () => void;
+    mousemove: (event: MouseEvent) => void;
+    fromGraphNode(object3d: Object3D): void;
+    getForwardVector: () => Vector3;
+    getSideVector: () => Vector3;
+    controls: (deltaTime: number) => void;
+    updatePlayer: (deltaTime: number) => void;
+    playerCollisions(): void;
+    teleportPlayerIfOob: () => void;
+    update(): void;
+    disposer(): void;
+}

package/lib/lib/InstancedGroupMesh.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from 'three';
+export default class InstancedGroupMesh extends THREE.Mesh {
+    isInstancedGroupMesh: boolean;
+    count: number;
+    meshCollect: Record<string, THREE.Mesh[]>;
+    instanceCollect: Record<string, THREE.InstancedMesh>;
+    static matrix: THREE.Matrix4;
+    constructor(group: THREE.Group, count: number);
+    setMatrixAt(index: number, matrix: THREE.Matrix4): void;
+}

package/lib/lib/KeyFrameAnimation.d.ts

@@ -0,0 +1,25 @@
+import { Euler, Line, LineBasicMaterial, Object3D, Vector3 } from "three";
+export type Keyframe = {
+    position: Vector3;
+    scale: Vector3;
+    rotation: Euler;
+    timeTemp: number;
+};
+export type KeyframeAnimationProps = {
+    speedScale?: number;
+    object3d: Object3D;
+    keyframes: Array<Keyframe>;
+};
+export default class KeyframeAnimation extends Object3D {
+    constructor(props: KeyframeAnimationProps);
+    speedScale: number;
+    object3d: Object3D;
+    halperLine: Line<any, LineBasicMaterial>;
+    keyframes: Array<Keyframe>;
+    setObject3D(object3d: Object3D): void;
+    getKeyframe(i: number): Keyframe;
+    setKeyframe(i: number, keyframe: Keyframe): void;
+    setKeyframes(keyframes: Array<Keyframe>): void;
+    update(): void;
+    updateMatrix(): void;
+}

package/lib/lib/PlaneText.d.ts

@@ -0,0 +1,37 @@
+import { Mesh, MeshBasicMaterial, PlaneGeometry, Vector3 } from "three";
+import SpriteText from "three-spritetext";
+type Props = {
+    text?: string;
+    textHeight?: number;
+    color?: string;
+    backgroundColor?: string;
+    fontFace?: string;
+    fontSize?: number;
+    fontWeight?: string;
+    padding?: number | [number, number];
+    borderWidth?: number;
+    borderRadius?: number;
+    borderColor?: string;
+    strokeWidth?: number;
+    strokeColor?: string;
+};
+export default class PlaneText extends Mesh {
+    constructor(text?: string);
+    type: string;
+    static geometry: PlaneGeometry;
+    spriteText: SpriteText;
+    material: MeshBasicMaterial;
+    set(parame: Props): void;
+    get(prop: keyof SpriteText): string | number | boolean | import("three").BufferGeometry | import("three").Matrix3 | import("three").Matrix4 | import("three").Material | import("three").Object3D<import("three").Event> | Vector3 | import("three").Object3D<import("three").Event>[] | import("three").Euler | import("three").Quaternion | import("three").Layers | import("three").AnimationClip[] | {
+        [key: string]: any;
+    } | ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry, material: import("three").Material, group: import("three").Group) => void) | ((renderer: import("three").WebGLRenderer, scene: import("three").Scene, camera: import("three").Camera, geometry: import("three").BufferGeometry, material: import("three").Material, group: import("three").Group) => void) | ((matrix: import("three").Matrix4) => void) | ((axis: Vector3, angle: number) => void) | ((euler: import("three").Euler) => void) | ((m: import("three").Matrix4) => void) | ((q: import("three").Quaternion) => void) | ((vector: Vector3) => Vector3) | ((vector: Vector3) => Vector3) | {
+        (vector: Vector3): void;
+        (x: number, y: number, z: number): void;
+    } | ((id: number) => import("three").Object3D<import("three").Event>) | ((name: string) => import("three").Object3D<import("three").Event>) | ((name: string, value: any) => import("three").Object3D<import("three").Event>) | ((name: string, value: any) => import("three").Object3D<import("three").Event>[]) | ((target: Vector3) => Vector3) | ((target: import("three").Quaternion) => import("three").Quaternion) | ((target: Vector3) => Vector3) | ((target: Vector3) => Vector3) | ((callback: (object: import("three").Object3D<import("three").Event>) => any) => void) | ((callback: (object: import("three").Object3D<import("three").Event>) => any) => void) | ((callback: (object: import("three").Object3D<import("three").Event>) => any) => void) | (() => void) | ((force?: boolean) => void) | ((updateParents: boolean, updateChildren: boolean) => void) | ((meta?: {
+        geometries: any;
+        materials: any;
+        textures: any;
+        images: any;
+    }) => any) | ((event: import("three").Event) => void) | import("three").Vector2 | import("three").SpriteMaterial | ((quaternion: import("three").Quaternion) => SpriteText) | ((axis: Vector3, angle: number) => SpriteText) | ((axis: Vector3, angle: number) => SpriteText) | ((angle: number) => SpriteText) | ((angle: number) => SpriteText) | ((angle: number) => SpriteText) | ((axis: Vector3, distance: number) => SpriteText) | ((distance: number) => SpriteText) | ((distance: number) => SpriteText) | ((distance: number) => SpriteText) | ((...object: import("three").Object3D<import("three").Event>[]) => SpriteText) | ((...object: import("three").Object3D<import("three").Event>[]) => SpriteText) | (() => SpriteText) | (() => SpriteText) | ((object: import("three").Object3D<import("three").Event>) => SpriteText) | ((raycaster: import("three").Raycaster, intersects: import("three").Intersection<import("three").Object3D<import("three").Event>>[]) => void) | ((recursive?: boolean) => SpriteText) | ((source: SpriteText) => SpriteText) | (<T extends string>(type: T, listener: import("three").EventListener<import("three").Event, T, SpriteText>) => void) | (<T_1 extends string>(type: T_1, listener: import("three").EventListener<import("three").Event, T_1, SpriteText>) => boolean) | (<T_2 extends string>(type: T_2, listener: import("three").EventListener<import("three").Event, T_2, SpriteText>) => void);
+}
+export {};

package/lib/lib/PointLight.d.ts

@@ -0,0 +1,13 @@
+import { PointLight as THREEPointLight } from "three";
+import threeSpritetext from "three-spritetext";
+/**
+ * 点光源
+ * @export
+ * @class PointLight
+ * @extends {THREEPointLight}
+ */
+export default class PointLight extends THREEPointLight {
+    constructor(color?: string, intensity?: number, distance?: number, decay?: number);
+    sphere: void;
+    label: threeSpritetext;
+}

package/lib/lib/Sky/Sky.d.ts

@@ -0,0 +1,13 @@
+import { Mesh, MeshBasicMaterial, SphereGeometry } from "three";
+/**
+ * 天空球
+ */
+export default class Sky extends Mesh {
+    constructor();
+    static geometry: SphereGeometry;
+    material: MeshBasicMaterial;
+    /**
+     *设置贴图
+     */
+    setMap(src: string): void;
+}

package/lib/lib/Text3D/Text3D.d.ts

@@ -0,0 +1,20 @@
+import { Mesh, MeshStandardMaterial } from "three";
+export type Text3DProps = {
+    text?: string;
+    fontType?: string;
+    size?: number | undefined;
+    height?: number | undefined;
+    curveSegments?: number | undefined;
+    bevelEnabled?: boolean | undefined;
+    bevelThickness?: number | undefined;
+    bevelSize?: number | undefined;
+    bevelOffset?: number | undefined;
+    bevelSegments?: number | undefined;
+};
+export default class Text3D extends Mesh {
+    constructor(text?: string);
+    static path: string;
+    material: MeshStandardMaterial;
+    _config: Text3DProps;
+    setText(text3DProps: Text3DProps): void;
+}

package/lib/lib/Text3D/fontController.d.ts

@@ -0,0 +1,59 @@
+import Dexie, { Table } from "dexie";
+import { Font } from "three/examples/jsm/loaders/FontLoader.js";
+export type saveFontParam = {
+    fontType?: string;
+    fontName: string;
+    fontJson: any;
+};
+export type addFontFamilyParam = {
+    fontType?: string;
+    fontFamilyJson: any;
+};
+export type getFontParam = {
+    fontType?: string;
+    fontName: string;
+};
+export type loadTextParam = {
+    fontBasePath: string;
+    fontType?: string;
+    text?: string;
+    callback?: (font: Font) => void;
+};
+declare class indexBD extends Dexie {
+    constructor(dbName: string);
+    threeFont: Table;
+}
+declare class fontContorl {
+    constructor();
+    THREEFontMap: Map<string, Font>;
+    fontBD: indexBD;
+    /**
+     * 保存 字体json到本地数据库中
+     * @param {saveFontParam} { fontType = "simhei", fontName, fontJson }
+     * @memberof fontContorl
+     */
+    saveFont({ fontType, fontName, fontJson }: saveFontParam): Promise<void>;
+    /**
+     * 通过 fontType 和 fontName 查询 fontJson
+     * @param {getFontParam} { fontType = "simhei", fontName }
+     * @returns
+     * @memberof fontContorl
+     */
+    getFont({ fontType, fontName }: getFontParam): Promise<any>;
+    _loadTextCall: Map<string, Array<() => void>>;
+    loadText({ fontType, text, fontBasePath, callback }: loadTextParam): Promise<void>;
+    _loadFontIndexJson({ fontType, fontBasePath }: loadTextParam): Promise<void>;
+    _loadFontJson({ fontType, fontName, fontBasePath }: {
+        fontType: string;
+        fontName: string;
+        fontBasePath: string;
+    }): Promise<void>;
+    hasFont({ fontType, fontName }: {
+        fontType: string;
+        fontName: string;
+    }): boolean;
+    addFont({ fontType, fontName, fontJson }: saveFontParam): void;
+    addFontFamily({ fontType, fontFamilyJson }: addFontFamilyParam): void;
+}
+declare const fontContorller: fontContorl;
+export default fontContorller;

package/lib/lib/ThreeBase.d.ts

@@ -0,0 +1,59 @@
+import { BufferGeometry, EventDispatcher, Object3D, PerspectiveCamera, Scene, Texture, Vector2, Vector3, WebGLRenderer, WebGLRenderTarget } from "three";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
+import ThreeMouse from "./ThreeMouse";
+import Transition from "./Transition";
+export default class ThreeBase extends EventDispatcher {
+    constructor();
+    renderTarget: WebGLRenderTarget;
+    renderTarget2: WebGLRenderTarget;
+    tempVector2: Vector2;
+    tempVector3: Vector3;
+    size: Vector2;
+    renderer: WebGLRenderer;
+    camera: PerspectiveCamera;
+    scene: Scene;
+    threeMouse: ThreeMouse;
+    controls: OrbitControls;
+    isRendererContextLost: boolean;
+    setContainer(div: HTMLDivElement | null): Promise<void>;
+    resize(width: number, height: number): void;
+    controlsPosition: Transition;
+    controlsCenter: Transition;
+    init(): void;
+    resetLookAt({ position, center, }: {
+        position?: Vector3;
+        center?: Vector3;
+    }): void;
+    setLookAt({ position, center, duration }: {
+        position?: Vector3;
+        center?: Vector3;
+        duration?: number;
+    }): Promise<void>;
+    getLookAt(): {
+        center: Vector3;
+        position: Vector3;
+        centerPosition: string;
+    };
+    v3tov2(v3: Vector3): Vector2;
+    controlType: "OrbitControls" | "MapControls";
+    originScreenSpacePanning: boolean;
+    setControlType(controlType: "OrbitControls" | "MapControls"): void;
+    autoRender: boolean;
+    needRender: boolean;
+    stopRender(): void;
+    render(): void;
+    renderBindThis: any;
+    download(fileName?: string): void;
+    private _preMesh;
+    private _preRT;
+    preloadTexture(src: string): Promise<void>;
+    preloadGeometry(geometry: BufferGeometry): Promise<void>;
+    clearRendererTargte(rendererTarget: WebGLRenderTarget | null): void;
+    copyTextureToRenderTarget(texture: Texture, rendererTarget: WebGLRenderTarget | null, alpha?: boolean, opactity?: number): void;
+    object3dToRendererTarget(obj: Object3D, rendererTarget: WebGLRenderTarget): void;
+    rendererTagetAddStroke(rendererTarget: WebGLRenderTarget, strockWidth: number, color: string, opacity: number): void;
+    renderObject3dStroke(obj: Object3D, strockWidth: number, color: string, opacity: number): void;
+    renderTargetgaussBlur(rendererTarget: WebGLRenderTarget, radius: number, opacity: number): void;
+    renderTargetAddGlow(renderTarget: WebGLRenderTarget, width: number, color: string): void;
+    renderRendererTarget(renderTarget: WebGLRenderTarget, alpha?: boolean): void;
+}

package/lib/lib/ThreeMouse.d.ts

@@ -0,0 +1,39 @@
+import * as THREE from "three";
+import { Object3D, Scene } from "three";
+import type { Intersection } from "three";
+export interface ThreeMouseEvent extends Intersection {
+    renderer: THREE.Renderer;
+    camera: THREE.Camera;
+    type: string;
+    offsetX: number;
+    offsetY: number;
+    x: number;
+    y: number;
+}
+/**
+ *  harp.gl 专用的鼠标拾取模型对象
+ */
+export default class ThreeMouse {
+    constructor(renderer: THREE.WebGLRenderer, camera: THREE.Camera, scene: THREE.Scene);
+    _renderer: THREE.WebGLRenderer;
+    _camera: THREE.Camera;
+    _scene: Scene;
+    _mosePosition: THREE.Vector2;
+    _mouseDownPosition: THREE.Vector2;
+    _mesh_on?: Object3D;
+    _mesh_Down?: Object3D;
+    _raycaster: THREE.Raycaster;
+    _frame: number;
+    _mouseInRenderer: boolean;
+    _mousemoveEvent?: MouseEvent;
+    _object3ds: Object3D[];
+    _click_num: number;
+    _getSelected(object3ds: Object3D[]): Intersection | undefined;
+    hasEvent(object?: Object3D, types?: Array<"leftclick" | "rightclick" | "click" | "dbclick" | "mouseenter" | "mouseleave" | "mousemove" | "mousedown" | "mouseup">): boolean;
+    hasCursor(object?: Object3D): boolean;
+    dispatchEvent(): void;
+    _mouseleave: (e: MouseEvent) => void;
+    _mousemove: (e: MouseEvent) => void;
+    _mousedown: (e: MouseEvent) => void;
+    _mouseup: import("lodash").DebouncedFunc<(e: PointerEvent) => Promise<void>>;
+}

package/lib/lib/Transition.d.ts

@@ -0,0 +1,45 @@
+interface TParam {
+    [key: string]: number;
+}
+export default class Transition {
+    /**
+     *Creates an instance of transition.
+     * @param {{ [key: string]: number }} // 初始值
+     * @param {[0.8, 0, 0.2, 1]} // 贝塞尔曲线
+     * @param {number} [duration=1000]  // 过渡时间
+     * @memberof transition
+     */
+    constructor(param?: TParam, bezier?: [number, number, number, number], duration?: number);
+    _keys: Array<string>;
+    _bezier: [number, number, number, number];
+    _Xbezier: [number, number, number, number];
+    _Ybezier: [number, number, number, number];
+    setBezier(bezier?: [number, number, number, number]): this;
+    timeTemp: number;
+    _duration: number;
+    _delay: number;
+    setDuration(duration?: number): this;
+    setDelay(delay?: number): this;
+    _: {
+        [key: string]: number;
+    };
+    onChangeCall?: (josn: {
+        [key: string]: number;
+    }) => void;
+    run({ timeTemp }: any): this;
+    runbindThis: any;
+    onChange(onChangeCall: (josn: {
+        [key: string]: number;
+    }) => void): this;
+    get(key: string | number): number;
+    set(param: TParam): Promise<this>;
+    reset(param: TParam): this;
+    getKeys(): string[];
+    hasKey(key: string): boolean;
+    getJson(): {
+        [key: string]: number;
+    };
+    _isDone: boolean;
+    isDone(): boolean;
+}
+export {};

package/lib/lib/keyContorls.d.ts

@@ -0,0 +1,25 @@
+import { Event, EventDispatcher, EventListener, Vector3 } from "three";
+/**
+ * 键盘 使用 ↑↓←→ 控制 x z 方向, 小键盘 1 0 控制 y 方向
+ *
+ * @class KeyContorls
+ * @extends {EventDispatcher}
+ */
+declare class KeyContorls extends EventDispatcher {
+    constructor();
+    uuid: string;
+    direction: Vector3;
+    add(e: any): void;
+    delete(e: any): void;
+    enter(e: any): void;
+    keyDown: (e: any) => void;
+    _listeners?: {
+        [key: string]: Array<any>;
+    };
+    removeEvent: import("lodash").DebouncedFunc<(type: string) => void>;
+    addEventListener<T extends string>(type: T, listener: EventListener<Event, T, this>): void;
+    addEvent(): void;
+    dispose(): void;
+}
+declare const keyContorls: KeyContorls;
+export default keyContorls;

package/lib/lib/planeModal1/PlaneModal1.d.ts

@@ -0,0 +1,32 @@
+import { MeshBasicMaterial, Mesh, CanvasTexture, PlaneGeometry } from "three";
+export type PlaneModal1Config = {
+    size?: number;
+    title?: string;
+    titleColor?: string;
+    texts?: Array<{
+        text?: string;
+        color?: string;
+        size?: number;
+    }>;
+};
+export default class PlaneModal1 extends Mesh {
+    constructor(config?: PlaneModal1Config);
+    renderOrder: number;
+    geometry: PlaneGeometry;
+    material: MeshBasicMaterial;
+    static img: HTMLImageElement;
+    canvas: HTMLCanvasElement;
+    context: CanvasRenderingContext2D;
+    texture: CanvasTexture;
+    _config: {
+        size: number;
+        title: string;
+        titleColor: string;
+        texts: Array<{
+            text: string;
+            color: string;
+            size: number;
+        }>;
+    };
+    updata(config: PlaneModal1Config): Promise<void>;
+}

package/lib/lib/shaders.d.ts

@@ -0,0 +1,17 @@
+import { Mesh, OrthographicCamera, ShaderMaterial, WebGLRenderer } from "three";
+declare class FullScreenQuad {
+    constructor();
+    _mesh: Mesh;
+    dispose(): void;
+    render(renderer: WebGLRenderer): void;
+    get material(): import("three").Material | import("three").Material[];
+    set material(value: import("three").Material | import("three").Material[]);
+}
+export declare const fullScreenMesh: FullScreenQuad;
+export declare const orthographicCamera: OrthographicCamera;
+export declare const clearShader: ShaderMaterial;
+export declare const intersectionShader: ShaderMaterial;
+export declare const coptyShader: ShaderMaterial;
+export declare const strokeShader: ShaderMaterial;
+export declare const gaussBlurShader: ShaderMaterial;
+export {};

package/lib/lib/spriteModal1/SpriteModal1.d.ts

@@ -0,0 +1,31 @@
+import { Sprite, CanvasTexture, Raycaster, Intersection } from "three";
+export type SpritModal1Config = {
+    size?: number;
+    title?: string;
+    titleColor?: string;
+    texts?: Array<{
+        text?: string;
+        color?: string;
+        size?: number;
+    }>;
+};
+export default class SpritModal1 extends Sprite {
+    constructor(config?: SpritModal1Config);
+    renderOrder: number;
+    static img: HTMLImageElement;
+    canvas: HTMLCanvasElement;
+    context: CanvasRenderingContext2D;
+    texture: CanvasTexture;
+    _config: {
+        size: number;
+        title: string;
+        titleColor: string;
+        texts: Array<{
+            text: string;
+            color: string;
+            size: number;
+        }>;
+    };
+    updata(config: SpritModal1Config): Promise<void>;
+    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
+}

package/lib/lib/threeLoader.d.ts

@@ -0,0 +1,20 @@
+import { EventDispatcher, Texture, TextureLoader } from "three";
+import { FBXLoader } from "three/examples/jsm/loaders/FBXLoader";
+import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader";
+import { MTLLoader } from "three/examples/jsm/loaders/MTLLoader";
+import { OBJLoader } from "three/examples/jsm/loaders/OBJLoader";
+declare class ThreeLoader extends EventDispatcher {
+    constructor();
+    anisotropy: number;
+    setAnisotropy(v: number): void;
+    textureMap: Map<string, Texture>;
+    textureLoader: TextureLoader;
+    getTexture(src: string): Texture;
+    fbxLoader: FBXLoader;
+    objLoader: OBJLoader;
+    mtlLoader: MTLLoader;
+    gltfLoader: GLTFLoader;
+    onload: boolean;
+}
+declare const threeLoader: ThreeLoader;
+export default threeLoader;