lythreeframe 1.0.1 → 1.0.5

package/src/lythreeframe/Library/MaterialLibrary.ts

@@ -0,0 +1,292 @@
+// import {
+//     AdditiveBlending,
+//     Color, CustomBlending,
+//     Material,
+//     MeshStandardMaterial,
+//     MultiplyBlending,
+//     NoBlending,
+//     NormalBlending,
+//     RepeatWrapping,
+
+//     SubtractiveBlending,
+//     Texture,
+//     TextureLoader,
+//     Vector2
+// } from "three";
+// import {LYThreeWorld} from "@/script/scene/LYCustomFrame/src/Frame";
+// import {Blending} from "three/src/constants";
+// import {AssetType} from "../AssetManagement/AssetDefines";
+
+// export class LYMaterialLibrary
+// {
+//     static Deserialize(data, world: LYThreeWorld, onFinished:Function = ()=>{})
+//     {
+//         let mat = new MeshStandardMaterial();
+//         LYMaterialLibrary.UpdateMatererialByData(data, mat, world, onFinished)
+//         return mat
+//     }
+
+//     static UpdateMatererialByData(data, mat: MeshStandardMaterial, world: LYThreeWorld, onFinished:Function = ()=>{})
+//     {
+//         let params = data;
+//         // color
+//         if (params.color)
+//         {
+//             mat.color = new Color(params.color)
+//         }
+//         // roughness
+//         if (params.roughness)
+//         {
+//             mat.roughness = params.roughness;
+//         }
+//         // metalness
+//         if (params.metalness)
+//         {
+//             mat.metalness = params.metalness;
+//         }
+//         // side
+//         if (params.side)
+//         {
+//             mat.side = params.side;
+//         }
+//         // blending
+//         function toBlendingType(value) {
+//             switch (value) {
+//                 case 0:
+//                     return NoBlending;
+//                 case 1:
+//                     return NormalBlending;
+//                 case 2:
+//                     return AdditiveBlending;
+//                 case 3:
+//                     return SubtractiveBlending;
+//                 case 4:
+//                     return MultiplyBlending;
+//                 case 5:
+//                     return CustomBlending;
+//                 default:
+//                     console.log("no blending type matched")
+//                     return NormalBlending; // 默认值或其他错误处理
+//             }
+//         }
+//         if (params.blending)
+//         {
+//             mat.blending = toBlendingType(Number.parseInt(params.blending))
+//         }
+//         // opacity
+//         if (params.opacity)
+//         {
+//             mat.opacity = params.opacity;
+//         }
+//         // transparent
+//         mat.transparent = params.transparent ? true : false;
+//         // depthTest
+//         // mat.depthTest   = params.depthTest === false ? false : true;
+//         // // depthWrite
+//         // mat.depthWrite  = params.depthWrite === false ? false : true;
+
+//         // depthTest7
+//         mat.depthTest  = true;
+//         // depthWrite
+//         mat.depthWrite = true;
+//         // wireframe
+//         mat.wireframe  = params.wireframe ? true : false;
+//         if(params.name)
+//         {
+//             mat.name = params.name
+//         }
+//         let processCount = 0
+//         let onTextureLoaded = ()=>{}
+//         if(onFinished)
+//         {
+//             onTextureLoaded = ()=>{
+//                 processCount--
+//                 if(processCount===0)
+//                 {
+//                     console.log("onfin")
+//                     onFinished()
+//                 }
+//             }
+//         }
+
+//         // map
+//         if (params.map)
+//         {
+//             processCount++
+//             LYMaterialLibrary.loadTexture("map", mat, world, params.map, onTextureLoaded)
+//         }
+
+//         // emissiveMap
+//         if (params.emissiveMap)
+//         {
+//             processCount++
+//             LYMaterialLibrary.loadTexture("emissiveMap", mat, world, params.emissiveMap, onTextureLoaded)
+//         }
+
+//         // bump map
+//         if (params.alphaMap)
+//         {
+//             processCount++
+//             LYMaterialLibrary.loadTexture("alphaMap", mat, world, params.alphaMap, onTextureLoaded)
+//         }
+//         // normalMap
+//         if (params.normalMap)
+//         {
+//             processCount++
+//             LYMaterialLibrary.loadTexture("normalMap", mat, world, params.normalMap, onTextureLoaded)
+//         }
+
+//         // roughnessMap
+//         if (params.roughnessMap)
+//         {
+//             processCount++
+//             LYMaterialLibrary.loadTexture("roughnessMap", mat, world, params.roughnessMap, onTextureLoaded)
+//         }
+
+//         // metalnessMap
+//         if (params.metalnessMap)
+//         {
+//             processCount++
+//             LYMaterialLibrary.loadTexture("metalnessMap", mat, world, params.metalnessMap, onTextureLoaded)
+//         }
+//         mat.needsUpdate = true
+//     }
+
+//     static Serialize(mat: MeshStandardMaterial, world: LYThreeWorld)
+//     {
+//         interface obj
+//         {
+//             [idx: string]: any
+//         }
+
+//         let params: obj = {}
+
+//         if (mat.color)
+//         {
+//             params.color = `rgb\(${Math.trunc(mat.color.r * 255)}, ${Math.trunc(mat.color.g * 255)}, ${Math.trunc(mat.color.b * 255)}\)`
+//         }
+//         // roughness
+//         if (mat.roughness)
+//         {
+//             params.roughness = mat.roughness;
+//         }
+//         if (mat.metalness)
+//         {
+//             params.metalness = mat.metalness;
+//         }
+//         // side
+//         if (mat.side)
+//         {
+//             params.side = mat.side;
+//         }
+//         // blending
+//         if (mat.blending)
+//         {
+//             params.blending = mat.blending;
+//         }
+//         // opacity
+//         if (mat.opacity)
+//         {
+//             params.opacity = mat.opacity;
+//         }
+//         // transparent
+//         params.transparent = mat.transparent ? true : false;
+//         // depthTest
+//         params.depthTest   = mat.depthTest ? true : false;
+//         // depthWrite
+//         params.depthWrite  = mat.depthWrite ? true : false;
+//         // wireframe
+//         params.wireframe   = mat.wireframe ? true : false;
+
+//         params.name = mat.name
+//         // world.AssetManager?.findAssetByName(AssetType.texture, )
+//         // map
+        
+//         LYMaterialLibrary.SerializeTexture("map", mat, world, params)
+//         LYMaterialLibrary.SerializeTexture("emissiveMap", mat, world, params)
+//         LYMaterialLibrary.SerializeTexture("alphaMap", mat, world, params)
+//         LYMaterialLibrary.SerializeTexture("normalMap", mat, world, params)
+//         LYMaterialLibrary.SerializeTexture("roughnessMap", mat, world, params)
+//         LYMaterialLibrary.SerializeTexture("metalnessMap", mat, world, params)
+
+//         return {
+//             type  : "material",
+//             params: params,
+//         }
+//     }
+
+//     static SerializeTexture(key: string, material: Material, world: LYThreeWorld, paramsToMod)
+//     {
+//         if (!(key in material) || !(material[key] instanceof Texture))
+//         {
+//             return
+//         }
+//         let asset = world.AssetManager?.findAssetByUUID(AssetType.texture, material[key].uuid)
+//         if (asset && asset.Path !== "")
+//         {
+//             paramsToMod[key] = {
+//                 url   : asset.Path,
+//                 offset: material[key].offset.toArray(),
+//                 repeat: material[key].repeat.toArray()
+//             }
+//         }
+//     }
+
+//     static loadTexture(key: string, material: Material, world: LYThreeWorld, data, onTextureLoaded: Function = ()=>{})
+//     {
+//         if (!data.url || data.url.length == 0)
+//         {
+//             material[key]        = null;
+//             material.needsUpdate = true
+//             onTextureLoaded()
+
+//             return
+//         }
+//         let texture   = new TextureLoader(world.AssetManager.LoadingManager).load(data.url, (dataLoad: Texture) =>
+//         {
+//             console.log("loadTexture")
+//             onTextureLoaded()
+//             world.markRenderStateDirty();
+//         }, (event: ProgressEvent) => {}, (err: unknown) => {});
+//         texture.wrapS = RepeatWrapping;
+//         texture.wrapT = RepeatWrapping;
+//         texture.flipY = false
+//         if (data.repeat)
+//         {
+//             texture.repeat = new Vector2().fromArray(data.repeat);
+//         }
+//         else
+//         {
+//             texture.repeat = new Vector2().fromArray([1, 1]);
+//         }
+//         if (data.offset)
+//         {
+//             texture.offset = new Vector2().fromArray(data.offset);
+//         }
+//         else
+//         {
+//             texture.offset = new Vector2().fromArray([0, 0]);
+//         }
+//         material[key] = texture;
+//         world.AssetManager?.addTextureAsset(texture, data.url, data.url);
+//         world.markRenderStateDirty();
+//     }
+
+//     static convertTextureToBase64(texture: Texture)
+//     {
+//         // 创建一个canvas元素
+//         let canvas    = document.createElement('canvas');
+//         canvas.width  = texture.image.width;
+//         canvas.height = texture.image.height;
+
+//         // 将贴图绘制到canvas上
+//         let ctx = canvas.getContext('2d');
+//         if(!ctx)
+//         {
+//             return null
+//         }
+//         ctx.drawImage(texture.image, 0, 0, canvas.width, canvas.height);
+//         return canvas.toDataURL()
+//     }
+// }
+

package/{lythreeFrame/src → src/lythreeframe}/Library/Math.ts

@@ -1,4 +1,4 @@
-import {Vector3, Matrix4, Quaternion, Object3D, Box3, Plane} from "three";
+import {Vector3, Matrix4, Quaternion, Object3D, Box3, Plane, Euler} from "three";
 
 export interface Segment
 {
@@ -8,17 +8,17 @@ export interface Segment
 
 export class LYMath
 {
-    static degreeToRadians(degree): number
+    static degreeToRadians(degree:number): number
     {
         return degree * (Math.PI / 180);
     }
 
-    static radiansToDegree(radians): number
+    static radiansToDegree(radians:number): number
     {
         return radians * (180 / Math.PI);
     }
 
-    static threeJsEulerAngleAsDegree(euler)
+    static threeJsEulerAngleAsDegree(euler:Euler)
     {
         return {
             x: LYMath.radiansToDegree(euler.x),

package/{lythreeFrame/src → src/lythreeframe}/Object/Actor.ts

@@ -3,8 +3,8 @@ import {BaseObject} from "./BaseObject";
 import {MeshComponent} from "./Components/Mesh/MeshComponent";
 import {AttachmentRules} from "../Defines";
 
-import {SceneComponent} from "./Components/SceneComponent.ts";
-import { World } from "../Frame/World.ts";
+import {SceneComponent} from "./Components/SceneComponent";
+import { World } from "../Frame/World";
 
 export class Actor extends BaseObject
 {

package/{lythreeFrame/src → src/lythreeframe}/Object/Actors/Camera/CameraActor.ts

@@ -1,4 +1,4 @@
-import {Actor} from "../../Actor.ts";
+import {Actor} from "../../Actor";
 
 export class CameraActor extends Actor
 {

package/{lythreeFrame/src → src/lythreeframe}/Object/Actors/Light/DirectionalLightActor.ts

@@ -1,7 +1,7 @@
 
 import {ColorRepresentation} from "three";
-import {Actor} from "../../Actor.ts";
-import {DirectionalLightComponent} from "../../Components/Light/DirectionalLight/DirectionalLightComponent.ts";
+import {Actor} from "../../Actor";
+import {DirectionalLightComponent} from "../../Components/Light/DirectionalLight/DirectionalLightComponent";
 
 export class DirectionalLightActor extends Actor
 {

package/{lythreeFrame/src → src/lythreeframe}/Object/Actors/Shape/BoxActor.ts

@@ -1,7 +1,7 @@
 
 import {Material, MeshBasicMaterial} from "three";
-import {Actor} from "../../Actor.ts";
-import {BoxComponent} from "../../Components/Mesh/Shape/BoxComponent.ts";
+import {Actor} from "../../Actor";
+import {BoxComponent} from "../../Components/Mesh/Shape/BoxComponent";
 
 export class BoxActor extends Actor
 {

package/{lythreeFrame/src → src/lythreeframe}/Object/Actors/Shape/PlaneActor.ts

@@ -1,7 +1,7 @@
 
 import {Material, MeshBasicMaterial} from "three";
-import {Actor} from "../../Actor.ts";
-import {PlaneComponent} from "../../Components/Mesh/Shape/PlaneComponent.ts";
+import {Actor} from "../../Actor";
+import {PlaneComponent} from "../../Components/Mesh/Shape/PlaneComponent";
 
 export class PlaneActor extends Actor
 {

package/src/lythreeframe/Object/Actors/Shape/TubeActor.ts

@@ -0,0 +1,37 @@
+
+// import {Material, MeshBasicMaterial} from "three";
+// import {Actor} from "../../Actor";
+
+// export class LYTubeActor extends Actor
+// {
+//     constructor(width:number = 1, height:number = 1, depth:number = 1, material:Material = new MeshBasicMaterial())
+//     {
+//         // const points = [{
+//         //     x: 0,
+//         //     y: 0,
+//         //     z: 0
+//         // },
+//         //     {
+//         //         x: 100,
+//         //         y: 0,
+//         //         z: 0
+//         //     },
+//         //     {
+//         //         x: 100,
+//         //         y: 0,
+//         //         z: 200
+//         //     },
+//         // ];
+//         //
+//         // const path = createPath(points);
+//         //
+//         // const pipeGeometry = new TubeGeometry(path, 256, radius, 64);
+//         // const pipeMaterial = new MeshPhongMaterial({
+//         //     color
+//         // });
+//         // const pipe = new Mesh(pipeGeometry, pipeMaterial);
+//         //
+//         // super();
+//         // this.addComponent(new LYBoxComponent(width, height, depth, material))
+//     }
+// }

package/{lythreeFrame/src → src/lythreeframe}/Object/Components/2D/2DComponent.ts

@@ -2,7 +2,7 @@
 
 import { CSS2DObject } from "three/examples/jsm/renderers/CSS2DRenderer.js";
 import { Vector2} from "three";
-import {SceneComponent} from "../SceneComponent.ts";
+import {SceneComponent} from "../SceneComponent";
 
 export class LabelComponent extends SceneComponent
 {

package/{lythreeFrame/src → src/lythreeframe}/Object/Components/Camera/CameraComponent.ts

@@ -1,4 +1,4 @@
-import {SceneComponent} from "../SceneComponent.ts";
+import {SceneComponent} from "../SceneComponent";
 import {OrthographicCamera, PerspectiveCamera} from "three";
 
 interface CameraParam

package/{lythreeFrame/src → src/lythreeframe}/Object/Components/Component.ts

@@ -36,7 +36,7 @@ export abstract class Component extends BaseObject
         this._name = name;
     }
     protected obj:Object3D|null         = null;
-    private   _parentActor:Actor | null = null;
+    protected   _parentActor:Actor | null = null;
     protected _name = "Component";
     protected constructor(newThreeObject:Object3D)
     {

package/{lythreeFrame/src → src/lythreeframe}/Object/Components/Light/LightComponent.ts

@@ -3,7 +3,7 @@
  */
 
 import { ColorRepresentation, Light} from "three";
-import {SceneComponent} from "../SceneComponent.ts";
+import {SceneComponent} from "../SceneComponent";
 
 export abstract class LightComponent extends SceneComponent
 {

package/{lythreeFrame/src → src/lythreeframe}/Object/Components/Mesh/InstanceMesh/MultiInstanceMeshComponent.ts

@@ -1,6 +1,6 @@
 import {Group,  Matrix4, Mesh, Object3D,} from "three";
-import {SceneComponent} from "../../SceneComponent.ts";
-import {LYInstanceMeshComponent} from "./InstanceMeshComponent.ts";
+import {SceneComponent} from "../../SceneComponent";
+import {LYInstanceMeshComponent} from "./InstanceMeshComponent";
 
 interface MeshData
 {

package/{lythreeFrame/src → src/lythreeframe}/Object/Components/Mesh/MeshComponent.ts

@@ -1,7 +1,7 @@
 import {BufferGeometry, Material, Mesh, Texture} from 'three';
 import {Vector3} from "three";
-import {SceneComponent} from "../SceneComponent.ts";
-import {LYAssetManager} from "../../../AssetManagement/AssetManager.ts";
+import {SceneComponent} from "../SceneComponent";
+import { LYAssetManager } from '../../../../index';
 
 export class MeshComponent extends SceneComponent
 {

package/{lythreeFrame/src → src/lythreeframe}/Object/Components/Mesh/Sprite/SpriteComponent.ts

@@ -1,5 +1,5 @@
 import {Sprite, SpriteMaterial, Texture} from "three";
-import {SceneComponent} from "../../SceneComponent.ts";
+import {SceneComponent} from "../../SceneComponent";
 
 export class SpriteComponent extends SceneComponent
 {

package/{lythreeFrame/src → src/lythreeframe}/Object/Components/SceneComponent.ts

@@ -1,23 +1,25 @@
-import {Actor} from "../Actor.ts";
+import {Actor} from "../Actor";
 import {Box3, Euler, Group, Matrix4, Object3D, Quaternion, Vector3} from "three";
-import {Component} from "./Component.ts";
-import { World } from "../../Frame/World.ts";
-import { AttachmentRules } from "@threeframe/src/Defines.ts";
+import {Component} from "./Component";
+import { World } from "../../Frame/World";
+import { AttachmentRules } from "../../Defines";
+
 
 export class SceneComponent extends Component
 {
-    set parentActor(value:Actor | null)
+    override set parentActor(value:Actor | null)
     {
         this.childrenComponents.forEach((elem) =>
         {
             elem.parentActor = value;
         });
-        super.parentActor = value;
+        this._parentActor = value;
     }
 
-    get parentActor():Actor | null
+    override get parentActor():Actor | null
     {
-        return super.parentActor;
+        // 通过 _parentActor 私有字段访问父级 Actor
+        return this._parentActor;
     }
 
     protected bCanHover:boolean         = false;

package/{lythreeFrame/src → src/lythreeframe}/Object/Controller/Controller.ts

@@ -6,8 +6,8 @@
 // import {LYDelegate} from "../../Delegate";
 // import {LYThreeWorld} from "../../Frame";
 
-// import {SceneComponent} from "../Components/SceneComponent.ts";
-// import {PawnBase} from "../Pawn/PawnBase.ts";
+// import {SceneComponent} from "../Components/SceneComponent";
+// import {PawnBase} from "../Pawn/PawnBase";
 
 // const maxClickTime = 0.15; // The time between left mouse button down and left mouse button up if greater than this, will not trigger click event. 
 

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

@@ -1,5 +1,5 @@
 // import {Euler, OrthographicCamera, PerspectiveCamera, Quaternion, Vector3} from "three";
-// import {LYMath} from "../../Math/Math.ts";
+// import {LYMath} from "../../Math/Math";
 
 // export class CameraStatus
 // {