lythreeframe 1.0.2 → 1.0.6

package/dist/lythreeframe/Object/Components/SceneComponent.d.ts

@@ -0,0 +1,66 @@
+import { Actor } from "../Actor";
+import { Box3, Euler, Matrix4, Object3D, Quaternion, Vector3 } from "three";
+import { Component } from "./Component";
+import { World } from "../../Frame/World";
+import { AttachmentRules } from "../../Defines";
+export declare class SceneComponent extends Component {
+    set parentActor(value: Actor | null);
+    get parentActor(): Actor | null;
+    protected bCanHover: boolean;
+    protected bCanClick: boolean;
+    protected world: World | null;
+    constructor(newThreeObject: Object3D);
+    createDefaultThreeObject(): void;
+    get isVisible(): boolean;
+    setVisible(bVisible: boolean): void;
+    setLayers(layer: number): void;
+    getBoundsCenterPositionWS(): Vector3;
+    getBoundsTopCenterPositionWS(): Vector3;
+    getBoundsBottomCenterPositionWS(): Vector3;
+    getBounds(): Box3;
+    get parentComponent(): SceneComponent | null;
+    get childrenComponents(): any[];
+    onAddedToWorld(world: World): void;
+    destroy(): void;
+    destroyObject(): void;
+    getPosition(): Vector3;
+    setPosition(position: Vector3): void;
+    setPosition(x: number, y: number, z: number): void;
+    getRotation(): Euler;
+    setRotation(rotation: Euler): void;
+    setRotation(x: number, y: number, z: number): void;
+    getQuaternion(): Quaternion;
+    setQuaternion(quat: Quaternion): void;
+    setQuaternion(x: number, y: number, z: number, w: number): void;
+    getScale(): Vector3;
+    setScale(position: Vector3): void;
+    setScale(x: number, y: number, z: number): void;
+    getMatrix(): Matrix4;
+    setMatrix(matrix: Matrix4): void;
+    getWorldPosition(): Vector3;
+    getWorldRotation(): Euler;
+    getWorldQuaternion(): Quaternion;
+    getWorldScale(): Vector3;
+    getWorldMatrix(): Matrix4;
+    setWorldMatrix(newMatrix: Matrix4): void;
+    getWorldForwardDirection(): Vector3;
+    getWorldUpDirection(): Vector3;
+    getWorldRightDirection(): Vector3;
+    worldToLocal(vec: Vector3): Vector3;
+    localToWorld(vec: Vector3): Vector3;
+    attachComponent(newComponent: SceneComponent): void;
+    detachComponent(target: SceneComponent): void;
+    addChildComponent(newComponent: SceneComponent, attachmentRule?: AttachmentRules): void;
+    removeChildComponent(targetComponent: SceneComponent): void;
+    detachFromParentComponent(): void;
+    detachFromParentActor(): void;
+    destroyChildren(): void;
+    set isHoverEnabled(bCanHorver: boolean);
+    get isHoverEnabled(): boolean;
+    set isClickEnabled(bCanClick: boolean);
+    get isClickEnabled(): boolean;
+    onHorveringBegin(): void;
+    onHorveringEnd(): void;
+    onClicked(): void;
+    onDoubleClicked(): void;
+}

package/dist/lythreeframe/Object/PawnV2/FirstPerson.d.ts

@@ -0,0 +1,5 @@
+import { Pawn } from "./Pawn";
+import { Controller } from "../../Frame/Controller";
+export declare class FirstPerson extends Pawn {
+    constructor(controller: Controller);
+}

package/dist/lythreeframe/Object/PawnV2/Oribital.d.ts

@@ -0,0 +1,12 @@
+import { Pawn } from "./Pawn";
+import { Controller } from "../../Frame/Controller";
+import { OrbitControls } from "three/examples/jsm/Addons.js";
+export declare class Orbital extends Pawn {
+    get control(): OrbitControls;
+    protected _control: OrbitControls;
+    protected changeEvent: () => void;
+    constructor(controller: Controller);
+    possess(): void;
+    unpossess(): void;
+    onChange(): void;
+}

package/dist/lythreeframe/Object/PawnV2/Pawn.d.ts

@@ -0,0 +1,14 @@
+import { Controller } from "../../Frame/Controller";
+export declare abstract class Pawn {
+    get camera(): import("three").PerspectiveCamera | import("three").OrthographicCamera;
+    set enabled(value: boolean);
+    get control(): any;
+    protected _control: any | null;
+    protected controller: Controller;
+    protected isTickEnabled: boolean;
+    protected constructor(controller: Controller);
+    tick(deltaTime: number): void;
+    possess(): void;
+    unpossess(): void;
+    destroy(): void;
+}

package/dist/lythreeframe/Object/PawnV2/TransformControl.d.ts

@@ -0,0 +1,46 @@
+import { Pawn } from "./Pawn";
+import { Matrix4 } from "three";
+import { TransformControls } from "three/examples/jsm/controls/TransformControls.js";
+import { Controller } from "../../Frame/Controller";
+export interface TransformType {
+    rotate: "X" | "Y" | "Z" | "E" | "XY" | "YZ" | "XZ" | "XYZ" | "XYZE" | null;
+    scale: "X" | "Y" | "Z" | "E" | "XY" | "YZ" | "XZ" | "XYZ" | "XYZE" | null;
+    translate: "X" | "Y" | "Z" | "E" | "XY" | "YZ" | "XZ" | "XYZ" | "XYZE" | null;
+}
+export interface ITransforming {
+    isTransformAllowed(): boolean;
+    onTransforming(worldMatrix: Matrix4): void;
+    getMatrixInWorld(): Matrix4;
+    getAllowedTransformType(): TransformType;
+}
+export declare class TransformGizmo extends Pawn {
+    get control(): TransformControls;
+    protected _control: TransformControls | null;
+    private helperObject;
+    private targets;
+    private primaryTarget;
+    private targetMatrixMap;
+    protected onDraggingChangedEvent: (param: {
+        value: unknown;
+    }) => void;
+    protected onObjectChangeEvent: () => void;
+    protected onChangeEvent: () => void;
+    protected onUpdateFunctions: (() => void)[];
+    protected onDraggingFunctions: ((event: any) => void)[];
+    constructor(controller: Controller);
+    possess(): void;
+    unpossess(): void;
+    onChange(): void;
+    onDraggingChanged(event: {
+        value: any;
+    }): void;
+    onObjectChanged(): void;
+    set enable(newEnable: boolean);
+    setTarget(primaryTarget: ITransforming, multiTargets: ITransforming[], onUpdate?: (() => void) | null, onDragging?: ((bDragging: boolean) => void) | null): void;
+    getMode(): "translate" | "rotate" | "scale";
+    setMode(mode: "translate" | "rotate" | "scale"): void;
+    setSpace(space: "world" | "local"): void;
+    setAxis(axis: "X" | "Y" | "Z" | "E" | "XY" | "YZ" | "XZ" | "XYZ" | "XYZE" | null): void;
+    setSize(size: number): void;
+    destroy(): void;
+}

package/dist/lythreeframe/PostProcess/Param/Bloom.d.ts

@@ -0,0 +1,6 @@
+export interface BloomParam {
+    threshold: number;
+    strength: number;
+    radius: number;
+}
+export declare const DefaultBloomParam: BloomParam;

package/dist/lythreeframe/PostProcess/Param/DOF.d.ts

@@ -0,0 +1,6 @@
+export interface DOFParam {
+    focus: number;
+    aperture: number;
+    maxblur: number;
+}
+export declare const DefaultDOFParam: DOFParam;

package/dist/lythreeframe/PostProcess/Param/Denoise.d.ts

@@ -0,0 +1,7 @@
+export interface DenoiseParam {
+    denoiseRadius: number;
+    lumaPhi: number;
+    depthPhi: number;
+    normalPhi: number;
+}
+export declare const DefaultDenoiseParam: DenoiseParam;

package/dist/lythreeframe/PostProcess/Param/GTAO.d.ts

@@ -0,0 +1,11 @@
+import { DenoiseParam } from './Denoise';
+export interface GTAOParam {
+    distanceExponent: number;
+    distanceFallOff: number;
+    radius: number;
+    scale: number;
+    thickness: number;
+    denoised: boolean;
+    denoiseParam: DenoiseParam;
+}
+export declare const DefaultGTAOParam: GTAOParam;

package/dist/lythreeframe/PostProcess/Param/LensFlare.d.ts

@@ -0,0 +1,6 @@
+export interface LensFlareParam {
+    threshold: number;
+    ghostSpacing: number;
+    ghostAttenuationFactor: number;
+}
+export declare const DefaultLensFlareParam: LensFlareParam;

package/dist/lythreeframe/PostProcess/Param/MotionBlur.d.ts

@@ -0,0 +1,4 @@
+export interface MotionBlurParam {
+    blurAmount: number;
+}
+export declare const DefaultMotionBlurParam: MotionBlurParam;

package/dist/lythreeframe/PostProcess/Param/Outline.d.ts

@@ -0,0 +1,17 @@
+import { ColorRepresentation } from "three";
+export interface OutlineParams {
+    edgeStrength: number;
+    edgeGlow: number;
+    edgeThickness: number;
+    pulsePeriod: number;
+    visibleEdgeColor: ColorRepresentation;
+    hiddenEdgeColor: ColorRepresentation;
+}
+export declare const DefaultOutlineParams: {
+    edgeStrength: number;
+    edgeGlow: number;
+    edgeThickness: number;
+    pulsePeriod: number;
+    visibleEdgeColor: number;
+    hiddenEdgeColor: number;
+};

package/dist/lythreeframe/PostProcess/Param/SSR.d.ts

@@ -0,0 +1,6 @@
+export interface SSRParam {
+    maxDistance: number;
+    opacity: number;
+    thickness: number;
+}
+export declare const DefaultSSRParam: SSRParam;

package/dist/lythreeframe/PostProcess/Param/ToneMapping.d.ts

@@ -0,0 +1,9 @@
+export interface ToneMappingParams {
+    exposure: number;
+    toneMapping: string;
+}
+export declare const DefaultToneMappingParams: {
+    exposure: number;
+    toneMapping: string;
+};
+export declare const ToneMappingOptions: Map<string, 0 | 1 | 2 | 3 | 4 | 6 | 7>;

package/dist/lythreeframe/PostProcess/PostProcessParam.d.ts

@@ -0,0 +1,16 @@
+import { SSRParam } from './Param/SSR';
+import { GTAOParam } from "./Param/GTAO";
+import { BloomParam } from "./Param/Bloom";
+import { ToneMappingParams } from "./Param/ToneMapping";
+import { DOFParam } from "./Param/DOF";
+import { OutlineParams } from './Param/Outline';
+export interface PostProcessParam {
+    toneMapping?: ToneMappingParams;
+    bloom?: BloomParam | null;
+    dof?: DOFParam | null;
+    ssr?: SSRParam | null;
+    gtao?: GTAOParam | null;
+    outline?: OutlineParams | null;
+    aa?: "fxaa" | "smaa" | null;
+}
+export declare const DefaultPostProcessParam: PostProcessParam;

package/dist/lythreeframe/PostProcess/WebGPUPostProcessFactory.d.ts

@@ -0,0 +1,43 @@
+import { OutlineParams } from './Param/Outline';
+import { Scene, Camera, Object3D } from "three";
+import BloomNode from "three/examples/jsm/tsl/display/BloomNode.js";
+import DenoiseNode from "three/examples/jsm/tsl/display/DenoiseNode.js";
+import DepthOfFieldNode from "three/examples/jsm/tsl/display/DepthOfFieldNode.js";
+import GTAONode from "three/examples/jsm/tsl/display/GTAONode.js";
+import { ShaderNodeObject, NodeRepresentation } from "three/tsl";
+import { PassNode, Node } from "three/webgpu";
+import { BloomParam } from "./Param/Bloom";
+import { DOFParam } from "./Param/DOF";
+import { GTAOParam } from "./Param/GTAO";
+import SSRNode from "three/examples/jsm/tsl/display/SSRNode.js";
+import { SSRParam } from "./Param/SSR";
+import { LensFlareParam } from "./Param/LensFlare";
+import LensflareNode from "three/examples/jsm/tsl/display/LensflareNode.js";
+import OutlineNode from "three/examples/jsm/tsl/display/OutlineNode.js";
+import { MotionBlurParam } from './Param/MotionBlur';
+import { DenoiseParam } from './Param/Denoise';
+export declare class WebGPUPostProcessFactory {
+    static constructScenePass(scene: Scene, camera: Camera): ShaderNodeObject<PassNode>;
+    static updateScenePass(scenePass: ShaderNodeObject<PassNode>, outputNodes: {
+        [name: string]: Node;
+    }): void;
+    static constructBloomPass(scenePass: ShaderNodeObject<PassNode>, params: BloomParam): ShaderNodeObject<BloomNode>;
+    static updateBloomPass(bloomPass: ShaderNodeObject<BloomNode>, params: BloomParam): void;
+    static constructDOFPass(scenePass: ShaderNodeObject<PassNode>, params: DOFParam): ShaderNodeObject<DepthOfFieldNode>;
+    static updateDOFPass(dofPass: ShaderNodeObject<DepthOfFieldNode>, params: DOFParam): void;
+    static constructMotionBlurPass(lastNode: NodeRepresentation, scenePass: ShaderNodeObject<PassNode>, param: MotionBlurParam): ShaderNodeObject<Node>;
+    static constructSSRPass(scenePass: ShaderNodeObject<PassNode>, param: SSRParam): ShaderNodeObject<SSRNode>;
+    static updateSSRPass(ssrPass: ShaderNodeObject<SSRNode>, params: SSRParam): void;
+    static constructGTAOPass(scenePass: ShaderNodeObject<PassNode>, params: GTAOParam): ShaderNodeObject<GTAONode>;
+    static updateGTAOPass(gtaoPass: ShaderNodeObject<GTAONode>, params: GTAOParam): void;
+    static constructDenoisePass(scenePass: ShaderNodeObject<PassNode>, inputNode: NodeRepresentation, params: DenoiseParam): ShaderNodeObject<DenoiseNode>;
+    static updateDenoisePass(denoisePass: ShaderNodeObject<DenoiseNode>, params: DenoiseParam): void;
+    static constructGTAODenoisePass(scenePass: ShaderNodeObject<PassNode>, gtaoPass: ShaderNodeObject<GTAONode>, params: GTAOParam): ShaderNodeObject<DenoiseNode>;
+    static updateGTAODenoisePass(denoisePass: ShaderNodeObject<DenoiseNode>, params: GTAOParam): void;
+    static constructLensFlarePass(inputNode: NodeRepresentation, params: LensFlareParam): ShaderNodeObject<LensflareNode>;
+    static updateLensFlarPass(lensflarePass: ShaderNodeObject<LensflareNode>, params: LensFlareParam): void;
+    static constructOutlinePass(scene: Scene, camera: Camera, outlineObjects: Object3D[], param: OutlineParams): ShaderNodeObject<OutlineNode>;
+    static updateOutlinePass(outlinePass: ShaderNodeObject<OutlineNode>, outlineObjects: Object3D[], params: OutlineParams): void;
+    static constructFXAAPass(inputNode: NodeRepresentation): ShaderNodeObject<import("three/examples/jsm/tsl/display/FXAANode.js").default>;
+    static constructSMAAPass(inputNode: NodeRepresentation): ShaderNodeObject<import("three/examples/jsm/tsl/display/SMAANode.js").SMAANode>;
+}

package/dist/lythreeframe/Shader/Postprocess/ColorShader.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Brightness and contrast adjustment
+ * https://github.com/evanw/glfx.js
+ * brightness: -1 to 1 (-1 is solid black, 0 is no change, and 1 is solid white)
+ * contrast: -1 to 1 (-1 is solid gray, 0 is no change, and 1 is maximum contrast)
+ */
+declare const ColorShader: {
+    name: string;
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        brightness: {
+            value: number;
+        };
+        contrast: {
+            value: number;
+        };
+        saturation: {
+            value: number;
+        };
+        exposure: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export { ColorShader };

package/dist/lythreeframe/ThreeJsApp.d.ts

@@ -0,0 +1,35 @@
+import { PostProcessParam } from './PostProcess/PostProcessParam';
+import { World } from "./Frame/World";
+import { Viewport } from "./Frame/Viewport";
+import { Controller } from "./Frame/Controller";
+import { Clock, OrthographicCamera, PerspectiveCamera } from "three";
+import { CameraParam } from "./Factory/CameraFactory";
+import { WebGPURendererParameters } from 'three/src/renderers/webgpu/WebGPURenderer.js';
+export interface AppParam {
+    renderParam?: WebGPURendererParameters;
+    cameraParam?: CameraParam;
+    postProcessParam?: PostProcessParam;
+}
+export declare const DefaultRenderParam: WebGPURendererParameters;
+export declare const DefaultCameraParam: CameraParam;
+export declare const DefaultAppParam: AppParam;
+export declare class ThreeJsApp {
+    get camera(): PerspectiveCamera | OrthographicCamera;
+    get clock(): Clock;
+    get world(): World;
+    get viewport(): Viewport;
+    get controller(): Controller;
+    get worldClass(): typeof World;
+    get viewportClass(): typeof Viewport;
+    get controllerClass(): typeof Controller;
+    protected _clock: Clock;
+    protected _camera: PerspectiveCamera | OrthographicCamera;
+    protected _world: World;
+    protected _viewport: Viewport;
+    protected _controller: Controller;
+    constructor(elementId: string, appParam?: AppParam);
+    init(): void;
+    tick(): void;
+    onWindowResize(width: number, height: number): void;
+    destroy(): void;
+}

package/package.json

@@ -1,21 +1,39 @@
 {
   "name": "lythreeframe",
-  "version": "1.0.2",
-  "description": "my custom three ",
-  "main": "index.js",
+  "version": "1.0.6",
+  "description": "Three.js 封装",
+  "main": "dist/bundle.cjs.js",
+  "module": "dist/bundle.esm.js",
+  "type": "module",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "rollup -c",
+    "prepublishOnly": "npm run build"
   },
-  "dependencies": {
-    "@types/three": "^0.173.0",
-    "gsap": "^3.12.7",
-    "three": "^0.173.0"
+  "peerDependencies": {
+    "gsap": "^3.12.2",
+    "three": "^0.173.0",
+    "@types/three": "^0.173.0"
   },
+  "files": [
+    "dist"
+  ],
   "devDependencies": {
-    "@types/node": "^22.13.8",
-    "globals": "^16.0.0",
-    "typescript": "~5.6.2"
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/three": "^0.173.0",
+    "gsap": "3.12.2",
+    "rollup": "^4.35.0",
+    "three": "0.173.0",
+    "tslib": "^2.8.1",
+    "typescript": "^5.8.2"
   },
-  "author": "noegip",
-  "license": "ISC"
+  "keywords": [
+    "three.js",
+    "webgl",
+    "3d",
+    "graphics",
+    "webgpu"
+  ],
+  "author": "notimportant",
+  "license": "MIT"
 }

package/index.js

@@ -1,48 +0,0 @@
-// Loading functionality
-export {LYLoadTask} from "./src/AssetManagement/Task/Task";
-export {LYAssetManager} from "./src/AssetManagement/AssetManager";
-
-// Tools
-export {LYMaterialLibrary} from "./src/Library/MaterialLibrary";
-export {AttachmentRules} from "./src/Defines";
-export {Delegate} from "./src/Delegate";
-
-// Frame
-export {ThreeJsApp} from "./src/ThreeJsApp";
-export {Controller} from "./src/Frame/Controller";
-export {Viewport} from "./src/Frame/Viewport";
-export {World} from "./src/Frame/World";
-
-// Actors
-export {Actor} from "./src/Object/Actor";
-export {DirectionalLightActor} from "./src/Object/Actors/Light/DirectionalLightActor";
-export {BoxActor} from "./src/Object/Actors/Shape/BoxActor";
-export {PlaneActor} from "./src/Object/Actors/Shape/PlaneActor";
-
-// Post process
-export {WebGPUPostProcessFactory} from "./src/PostProcess/WebGPUPostProcessFactory"
-export {PostProcessParam, DefaultPostProcessParam} from "./src/PostProcess/PostProcessParam"
-export {BloomParam, DefaultBloomParam} from "./src/PostProcess/Param/Bloom"
-export {DenoiseParam, DefaultDenoiseParam} from "./src/PostProcess/Param/Denoise"
-export {DOFParam, DefaultDOFParam} from "./src/PostProcess/Param/DOF"
-export {GTAOParam, DefaultGTAOParam} from "./src/PostProcess/Param/GTAO"
-export {OutlineParams, DefaultOutlineParams} from "./src/PostProcess/Param/Outline"
-export {SSRParam, DefaultSSRParam} from "./src/PostProcess/Param/SSR"
-export {ToneMappingParams, DefaultToneMappingParams,ToneMappingOptions} from "./src/PostProcess/Param/ToneMapping"
-// Components
-export {SceneComponent} from "./src/Object/Components/SceneComponent";
-export {MeshComponent} from "./src/Object/Components/Mesh/MeshComponent";
-export {BoxComponent} from "./src/Object/Components/Mesh/Shape/BoxComponent";
-export {PlaneComponent} from "./src/Object/Components/Mesh/Shape/PlaneComponent";
-export {SphereComponent} from "./src/Object/Components/Mesh/Shape/SphereComponent";
-
-export {DirectionalLightComponent} from "./src/Object/Components/Light/DirectionalLight/DirectionalLightComponent";
-export {LabelComponent} from "./src/Object/Components/2D/2DComponent";
-
-// Pawn
-export {Orbital} from "./src/Object/PawnV2/Oribital";
-export {FirstPerson} from "./src/Object/PawnV2/FirstPerson";
-
-
-// Shader
-export {ColorShader} from "./src/Shader/Postprocess/ColorShader";

package/src/AssetManagement/AssetDefines.ts

@@ -1,8 +0,0 @@
-export enum AssetType
-{
-    geometry  = 1,
-    material  = 2,
-    texture   = 3,
-    undefined = -1
-}
-