lythreeframe 1.0.1 → 1.0.5

package/src/lythreeframe/Object/Pawn/TopView.ts

@@ -0,0 +1,205 @@
+// import {Euler, Quaternion, Vector3,OrthographicCamera} from "three";
+
+// import {PawnBase} from "./PawnBase";
+// import {LYThreeWorld} from "../../Frame";
+// import {OrbitControls} from "three/examples/jsm/controls/OrbitControls";
+// import {OrthographicCameraStatus} from "./CameraStatus";
+
+
+// export class LYTopView extends PawnBase
+// {
+
+//     override camera :OrthographicCamera
+//     override control:OrbitControls
+//     override cameraStatus:OrthographicCameraStatus
+//     override get Control(): any
+//     {
+//         return this.control;
+//     }
+
+//     constructor(world: LYThreeWorld)
+//     {
+//         let camera = new OrthographicCamera()
+//         camera.near = 0.1
+//         camera.far = 2000
+        
+//         let control = null
+//         if(world.renderer && world.renderer.domElement)
+//         {
+//             control = new OrbitControls(camera, world.renderer.domElement)
+//             control.enableRotate = false
+//         }
+    
+//         super(world, camera, control);
+//         this.camera = camera
+//         this.control = control
+//         this.control.enableRotate = false
+//         this.cameraStatus = new OrthographicCameraStatus(this.Camera, this.Camera.position.clone().add(new Vector3(0,-1000,0)))
+
+
+//     }
+
+//    override get Camera(): OrthographicCamera
+//    {
+//        return this.camera
+//    }
+
+//     tick(deltaTime)
+//     {
+//         super.tick(deltaTime);
+//     }
+    
+    
+//     possess()
+//     {
+        
+//         this.Control.addEventListener('change', this.changeEvent)
+//         this.World.markRenderStateDirty();
+//     }
+
+//     unpossess()
+//     {
+//         this.onCameraMove = null
+//         this.Control.removeEventListener("change", this.changeEvent)
+//     }
+
+
+//     setCamera(newCamera)
+//     {
+//         super.setCamera(newCamera)
+//         // this.Control.object = newCamera
+//         // this.Control.update();
+//         this.World.markRenderStateDirty();
+//     }
+
+//     setPosition(param1, param2 = undefined, param3 = undefined)
+//     {
+//         // super.setPosition(param1, param2, param3);
+//         // this.Control.update();
+//         // this.World.markRenderStateDirty();
+//     }
+
+//     setQuaternion(newQuat)
+//     {
+//         // super.setQuaternion(newQuat);
+//         // this.Control.update()
+//         // this.World.markRenderStateDirty();
+//     }
+
+//     // focusTo
+//     // @targetPos 
+//     focusTo(targetPos: Vector3, targetQuat: Quaternion | Euler, distance: number, time: number = 0, onGoing: Function | null = null, onFinished: Function | null = null)
+//     {
+//         // this.Camera.position.set(targetPos.x,targetPos.y + 1000, targetPos.z);
+//         let quat1 = new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI * 0.5).normalize();
+
+//         this.Camera.quaternion.copy(quat1)
+//         this.Control.object.position.set(targetPos.x, targetPos.y + distance, targetPos.z);
+//         this.Control.target.copy(targetPos);
+       
+//         //1.计算透视相机到场景 scene 的深度距离 depth
+//         let depth  = distance;
+//         let ele = this.world.OuterElement;
+//         //2.得到透视相机的宽高比和垂直可视角度
+//         let aspect = ele.clientWidth/ele.clientHeight;
+//         let fov    = 60;
+//         let top_ortho    = depth * Math.atan((Math.PI / 180) * (fov) / 2);
+//         let right_ortho  = top_ortho * aspect;
+//         let bottom_ortho = -top_ortho;
+//         let left_ortho   = -right_ortho;
+//         this.Camera.right = right_ortho
+//         this.Camera.left = left_ortho
+//         this.Camera.top = top_ortho
+//         this.Camera.bottom = bottom_ortho
+//         this.Camera.updateProjectionMatrix()
+//         this.control.update()
+//         if (onFinished)
+//         {
+//             onFinished();
+//         }
+//         this.World.markRenderStateDirty();
+//         this.cameraStatus.updateTargetPosition(targetPos)
+//         this.cameraStatus.updateCameraPosition(this.Camera.position)
+//     }
+
+//     stopFocusing()
+//     {
+
+//     }
+
+//     zoomIn()
+//     {
+//         this.Camera.zoom *= 1.1
+//         this.cameraStatus.updateCameraZoom(this.Camera.zoom)
+//         this.Camera.updateProjectionMatrix()
+//         this.World.markRenderStateDirty();
+//     }
+
+//     zoomOut()
+//     {
+//         this.Camera.zoom *= 0.9
+//         this.cameraStatus.updateCameraZoom(this.Camera.zoom)
+//         this.Camera.updateProjectionMatrix()
+//         this.World.markRenderStateDirty();
+//     }
+    
+//     restore(status: OrthographicCameraStatus)
+//     {
+//         super.restore(status);
+//         this.cameraStatus.copy(status)
+        
+//         this.Control.object.position.copy(status.cameraPosition.clone());
+//         this.Control.target.copy(status.targetPosition);
+
+//         let quat1 = new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), Math.PI * 0.5).normalize();
+//         this.Camera.quaternion.copy(quat1)
+
+//         //1.计算透视相机到场景 scene 的深度距离 depth
+//         let depth  = this.Camera.position.clone().sub(status.targetPosition).length();
+//         let ele = this.world.OuterElement;
+        
+//         //2.得到透视相机的宽高比和垂直可视角度
+//         let aspect = ele.clientWidth/ele.clientHeight;
+//         let fov    = 60;
+
+//         //3.根据上述变量计算正交投影相机的视口矩形
+//         let top_ortho    = depth * Math.atan((Math.PI / 180) * (fov) / 2);
+//         let right_ortho  = top_ortho * aspect;
+//         let bottom_ortho = -top_ortho;
+//         let left_ortho   = -right_ortho;
+
+//         this.Camera.right = right_ortho
+//         this.Camera.left = left_ortho
+//         this.Camera.top = top_ortho
+//         this.Camera.bottom = bottom_ortho
+//         this.Camera.zoom = status.zoom
+
+//         this.Camera.updateProjectionMatrix()
+//         this.Control.update()
+      
+//         this.World.markRenderStateDirty();
+
+//         this.cameraStatus.updateCameraZoom(this.Camera.zoom)
+//         this.cameraStatus.updateTargetPosition(status.targetPosition)
+//         this.cameraStatus.updateCameraPosition(this.Camera.position)
+//     }
+
+//     destroy()
+//     {
+//         if (this.Control)
+//         {
+//             this.Control.dispose();
+//         }
+//         super.destroy();
+//     }
+
+//     protected onChangeEvent()
+//     {
+//         super.onChangeEvent();
+//         // this.cameraStatus.updateCameraQuaternion(this.Camera.quaternion)
+//         this.cameraStatus.update(this.Camera, this.Camera.position.clone().add(new Vector3(0,-1000,0)))
+//         this.World.markRenderStateDirty()
+//         let camPos    = this.Control.object.position.clone()
+//         let targetPos = this.Control.target.clone()
+//     }
+// }

package/src/lythreeframe/Object/Pawn/TransformControl.ts

@@ -0,0 +1,215 @@
+// import { PawnBase } from "./PawnBase";
+// import { LYThreeWorld } from "../../Frame";
+// import { Camera, Matrix4, Object3D, PerspectiveCamera } from "three";
+// import { TransformControls } from "three/examples/jsm/controls/TransformControls";
+
+// 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
+// {
+//     // onTransfroming(worldPos:Vector3, worldQuat:Quaternion, worldScale:Vector3):void
+//     isTransformAllowed(): boolean;
+
+//     onTransforming(worldMatrix: Matrix4): void;
+
+//     getMatrixInWorld(): Matrix4;
+
+//     getAllowedTransformType(): TransformType;
+// }
+
+// export class LYTransformControl extends PawnBase
+// {
+//     protected onChange: Function;
+//     protected onDraggingChanged: Function;
+//     protected onObjectChange: Function;
+//     protected onUpdateFunctions: Function[] = [];
+//     protected onDraggingFunctions: Function[] = [];
+//     private helperObject: Object3D = new Object3D();
+//     protected targets: ITransforming[] = [];
+//     protected primaryTarget: ITransforming | null = null;
+//     private targetMatrixMap: Map<ITransforming, Matrix4> = new Map();
+
+//     constructor(world: LYThreeWorld, camera: Camera)
+//     {
+//         camera = camera ? camera : new PerspectiveCamera();
+//         super(world, camera, new TransformControls(camera, world.renderer.domElement));
+//         world.scene?.add(this.helperObject);
+//         this.onUpdateFunctions = [];
+//         this.onChange = () =>
+//         {
+//             this.World.markRenderStateDirty();
+//         };
+//         this.onDraggingChanged = (event) =>
+//         {
+//             if (this.primaryTarget)
+//             {
+//                 let tMatrix = this.primaryTarget.getMatrixInWorld();
+//                 tMatrix.decompose(this.helperObject.position, this.helperObject.quaternion, this.helperObject.scale);
+//             }
+//             this.onDraggingFunctions.forEach((elem) =>
+//             {
+//                 elem(event.value);
+//             });
+//         };
+//         this.onObjectChange = () =>
+//         {
+//             if (this.primaryTarget)
+//             {
+//                 const TA1 = this.primaryTarget.getMatrixInWorld();
+//                 this.helperObject.updateMatrixWorld(true);
+//                 const TA2 = this.helperObject.matrixWorld.clone();
+//                 // 将初始矩阵分解为位置、旋转和缩放
+
+
+//                 this.primaryTarget.onTransforming(TA2);
+
+//                 const TA1Inverse = TA1.clone().invert();
+//                 const transformMatrix = new Matrix4().multiplyMatrices(TA2, TA1Inverse);
+//                 this.targets.forEach((tar) =>
+//                 {
+
+//                     //
+//                     // let TB1 = tar.getMatrixInWorld(); // B 的初始世界矩阵
+//                     // let TB2 = new Matrix4().multiplyMatrices(transformMatrix, TB1); // B 
+//                     //
+//                     // tar.onTransforming(TB2)
+//                     // let TB1 = tar.getMatrixInWorld();
+//                     // const TB_local = TB1.clone().invert().multiply(TA1);
+
+//                     if (tar !== this.primaryTarget)
+//                     {
+//                         let TB2 = new Matrix4().multiplyMatrices(TA2, this.targetMatrixMap.get(tar)); // B 
+
+//                         tar.onTransforming(TB2);
+//                     }
+
+//                 });
+
+//                 // this.primaryTarget.onTransforming(this.helperObject.matrix)
+
+//             }
+//             this.onUpdateFunctions.forEach((elem) =>
+//             {
+//                 elem();
+//             });
+//         };
+//         this.setSize(0.5);
+//         this.World.markRenderStateDirty();
+
+//     }
+
+//     tick(deltaTime)
+//     {
+//         super.tick(deltaTime);
+//     }
+
+//     get Camera()
+//     {
+//         return this.Control.camera;
+//     }
+
+//     set enable(newEnable)
+//     {
+//         this.Control.enabled = newEnable;
+//     }
+
+
+//     setTarget(primaryTarget: ITransforming, multiTargets: ITransforming[], onUpdate: Function | null = null, onDragging: Function | null)
+//     {
+//         this.targetMatrixMap.clear();
+//         let tMatrix = primaryTarget.getMatrixInWorld();
+//         tMatrix.decompose(this.helperObject.position, this.helperObject.quaternion, this.helperObject.scale);
+//         this.Control.attach(this.helperObject);
+//         this.primaryTarget = primaryTarget;
+//         this.targets = multiTargets;
+
+
+//         this.targets.forEach((elem) =>
+//         {
+//             const tarMatrix = elem.getMatrixInWorld();
+//             const TB_local = tMatrix.clone().invert().multiply(tarMatrix);
+
+//             this.targetMatrixMap.set(elem, TB_local);
+//         });
+
+//         if (onUpdate)
+//         {
+//             this.onUpdateFunctions.push(onUpdate);
+//         }
+
+//         if (onUpdate)
+//         {
+//             this.onUpdateFunctions.push(onUpdate);
+//         }
+//         if (onDragging)
+//         {
+//             this.onDraggingFunctions.push(onDragging);
+//         }
+//         this.IsTickable = true;
+//     }
+
+//     getMode(): "translate" | "rotate" | "scale"
+//     {
+//         return this.Control.getMode();
+//     }
+
+//     setMode(mode: "translate" | "rotate" | "scale"): void
+//     {
+//         this.Control.setMode(mode);
+//     }
+
+//     setSpace(space: "world" | "local"): void
+//     {
+//         this.Control.setSpace(space);
+//     }
+
+//     setAxis(axis: "X" | "Y" | "Z" | "E" | "XY" | "YZ" | "XZ" | "XYZ" | "XYZE" | null)
+//     {
+//         this.Control.showX = axis?.indexOf("X") >= 0;
+//         this.Control.showY = axis?.indexOf("Y") >= 0;
+//         this.Control.showZ = axis?.indexOf("Z") >= 0;
+//     }
+
+//     setSize(size: number): void
+//     {
+//         this.Control.setSize(size);
+//     }
+
+//     setCamera(newCamera)
+//     {
+//         super.setCamera(newCamera);
+//         this.Control.camera = newCamera;
+//         this.World.markRenderStateDirty();
+//     }
+
+//     possess()
+//     {
+//         this.World.scene.add(this.Control.getHelper());
+//         this.Control.addEventListener('change', this.onChange);
+//         this.Control.addEventListener('dragging-changed', this.onDraggingChanged);
+//         this.Control.addEventListener('objectChange', this.onObjectChange);
+//     }
+
+//     unpossess()
+//     {
+//         this.World.scene.remove(this.Control.getHelper());
+//         this.onUpdateFunctions = [];
+//         this.Control.removeEventListener('change', this.onChange);
+//         this.Control.removeEventListener('dragging-changed', this.onDraggingChanged);
+//         this.Control.removeEventListener('objectChange', this.onObjectChange);
+//     }
+
+
+//     destroy()
+//     {
+//         this.IsTickable = false;
+//         this.world.scene?.remove(this.helperObject);
+
+//         super.destroy();
+//     }
+// }

package/src/lythreeframe/Object/Pawn/staticCamera.ts

@@ -0,0 +1,80 @@
+// import { PointerLockControls } from 'three/addons/controls/PointerLockControls.js';
+// import {Euler, PerspectiveCamera, Quaternion} from "three";
+// import {CameraStatus, PawnBase} from "./PawnBase";
+
+// export class LYStaticCamera extends PawnBase
+// {
+//     protected speed: number        = 3
+//     protected cameraHeight: number = 15
+//     protected domElement
+
+//     constructor(world)
+//     {
+//         let ele = world.Element;
+//         let camera = new PerspectiveCamera(90, ele.clientWidth / ele.clientHeight, 0.5, 7000)
+//         super(world, camera, new PointerLockControls(camera, world.renderer.domElement));
+//         this.domElement = world.renderer.domElement
+
+//         camera.position.y = Math.max(camera.position.y, 5)
+
+//         this.World.markRenderStateDirty();
+//     }
+
+//     tick(deltaTime)
+//     {
+//         super.tick(deltaTime)
+//     }
+
+//     get Camera()
+//     {
+//         return this.Control.camera;
+//     }
+
+//     setCamera(newCamera)
+//     {
+//         super.setCamera(newCamera)
+//         this.Control.camera = newCamera
+//         this.World.markRenderStateDirty();
+//     }
+
+//     possess()
+//     {
+//     }
+
+//     unpossess()
+//     {
+
+//     }
+
+//     focusTo(targetPos, targetQuat, distance, time = 0, onFinished = null)
+//     {
+//         this.Camera.position.set(targetPos.x, targetPos.y + this.cameraHeight, targetPos.z);
+//         if (targetQuat instanceof Euler)
+//         {
+//             targetQuat = new Quaternion().setFromEuler(targetQuat)
+//         }
+//         this.Camera.quaternion.set(targetQuat.x, targetQuat.y, targetQuat.z, targetQuat.w)
+//         this.cameraStatus.update(this.Camera.position, this.Camera.quaternion, targetPos)
+
+//         if (onFinished)
+//         {
+//             onFinished();
+//         }
+//         this.World.markRenderStateDirty();
+//     }
+    
+//     restore(status: CameraStatus)
+//     {
+//         super.restore(status);
+//         this.focusTo(status.targetPosition, status.cameraQuaternion, status.targetPosition.clone().sub(status.cameraPosition).length())
+//     }
+
+//     destroy()
+//     {
+//         if (this.Control)
+//         {
+//             this.Control.dispose();
+//         }
+//         super.destroy();
+//     }
+// }

package/{lythreeFrame/src → src/lythreeframe}/Object/PawnV2/FirstPerson.ts

@@ -1,12 +1,12 @@
-import {Pawn} from "./Pawn.ts";
+import {Pawn} from "./Pawn";
 import {PointerLockControls} from "three/examples/jsm/controls/PointerLockControls";
-import {Controller} from "../../Frame/Controller.ts";
+import {Controller} from "../../Frame/Controller";
 
 export class FirstPerson extends Pawn
 {
     constructor(controller:Controller)
     {
         super(controller);
-        this.control = new PointerLockControls(controller.camera, controller.viewPort.canvas)
+        this._control = new PointerLockControls(controller.camera, controller.viewPort.canvas)
     }
 }

package/{lythreeFrame/src → src/lythreeframe}/Object/PawnV2/Oribital.ts

@@ -1,6 +1,6 @@
-import {Pawn} from "./Pawn.ts";
+import {Pawn} from "./Pawn";
 
-import {Controller} from "../../Frame/Controller.ts";
+import {Controller} from "../../Frame/Controller";
 import { OrbitControls } from "three/examples/jsm/Addons.js";
 
 export class Orbital extends Pawn

package/{lythreeFrame/src → src/lythreeframe}/Object/PawnV2/Pawn.ts

@@ -1,5 +1,5 @@
 
-import {Controller} from "../../Frame/Controller.ts";
+import {Controller} from "../../Frame/Controller";
 
 export abstract class Pawn
 {

package/{lythreeFrame/src → src/lythreeframe}/Object/PawnV2/TransformControl.ts

@@ -1,12 +1,13 @@
-import { Controller } from "@threeframe/LYCustomFrame.ts";
-import {Pawn} from "./Pawn.ts";
+
+import {Pawn} from "./Pawn";
 import { Matrix4, Object3D } 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;
+    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

package/{lythreeFrame/src → src/lythreeframe}/PostProcess/Param/DOF.ts

@@ -1,5 +1,4 @@
-import {uniform} from "three/src/Three.TSL";
-
+
 export interface DOFParam
 {
     focus:number,

package/{lythreeFrame/src → src/lythreeframe}/PostProcess/PostProcessParam.ts

@@ -1,10 +1,10 @@
 
 import { SSRParam } from './Param/SSR';
-import {GTAOParam} from "./Param/GTAO.ts";
-import {BloomParam} from "./Param/Bloom.ts";
-import {ToneMappingParams} from "./Param/ToneMapping.ts";
-import {DOFParam} from "./Param/DOF.ts";
-import { OutlineParams } from './Param/Outline.ts';
+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
 {

package/{lythreeFrame/src → src/lythreeframe}/ThreeJsApp.ts

@@ -1,10 +1,10 @@
 
 import { DefaultPostProcessParam, PostProcessParam } from './PostProcess/PostProcessParam';
-import {World} from "./Frame/World.ts";
-import {Viewport} from "./Frame/Viewport.ts";
-import {Controller} from "./Frame/Controller.ts";
+import {World} from "./Frame/World";
+import {Viewport} from "./Frame/Viewport";
+import {Controller} from "./Frame/Controller";
 import { Clock, OrthographicCamera, PerspectiveCamera} from "three";
-import {CameraFactory, CameraParam} from "./Factory/CameraFactory.ts";
+import {CameraFactory, CameraParam} from "./Factory/CameraFactory";
 import { WebGPURendererParameters } from 'three/src/renderers/webgpu/WebGPURenderer.js';
 
 export interface AppParam