lythreeframe 1.0.0

package/lythreeFrame/src/Library/MaterialLibrary.ts

@@ -0,0 +1,288 @@
+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.ts";
+
+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 (!material[key] || !(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');
+        ctx.drawImage(texture.image, 0, 0, canvas.width, canvas.height);
+        return canvas.toDataURL()
+    }
+}
+

package/lythreeFrame/src/Library/Math.ts

@@ -0,0 +1,154 @@
+import {Vector3, Matrix4, Quaternion, Object3D, Box3, Plane} from "three";
+
+export interface Segment
+{
+    pointA: Vector3
+    pointB: Vector3
+}
+
+export class LYMath
+{
+    static degreeToRadians(degree): number
+    {
+        return degree * (Math.PI / 180);
+    }
+
+    static radiansToDegree(radians): number
+    {
+        return radians * (180 / Math.PI);
+    }
+
+    static threeJsEulerAngleAsDegree(euler)
+    {
+        return {
+            x: LYMath.radiansToDegree(euler.x),
+            y: LYMath.radiansToDegree(euler.y),
+            z: LYMath.radiansToDegree(euler.z),
+        }
+    }
+   
+    
+    static getQuatFromAxis(forwardVector: Vector3, upVector: Vector3 = new Vector3(0, 1, 0))
+    {
+        let f = forwardVector
+        let u = upVector
+        let r = u.clone().cross(f)
+
+        let matrix = new Matrix4(r.x, u.x, f.x, 0, r.y, u.y, f.y, 0, r.z, u.z, f.z, 0, 0, 0, 0, 1)
+        return new Quaternion().setFromRotationMatrix(matrix)
+    }
+
+    static MaxVector(v1: Vector3, v2: Vector3)
+    {
+        return new Vector3(Math.max(v1.x, v2.x), Math.max(v1.y, v2.y), Math.max(v1.z, v2.z))
+    }
+
+    static clamp(value: number, min: number, max: number)
+    {
+        return Math.max(min, Math.min(value, max));
+    }
+
+    static getPlaneConstantFromPointAndNormal(point: Vector3, normal: Vector3): number
+    {
+        return point.dot(normal) * -1;
+    }
+
+
+    static getSizeAndCenterOfObject3D(object: Object3D): { boundingBox: Box3, size: Vector3, center: Vector3 }
+    {
+        let bounds = new Box3()
+        bounds.setFromObject(object)
+        let size   = new Vector3();
+        let center = new Vector3();
+        bounds.getSize(size)
+        bounds.getCenter(center)
+        return {
+            boundingBox: bounds,
+            size       : size,
+            center     : center
+        }
+    }
+
+    static SegmentsIntersection(segmentA: Segment, segmentB: Segment): Vector3 | null
+    {
+        // Define the start and end points of both segments
+        const line1Start = segmentA.pointA.clone();
+        const line1End = segmentA.pointB.clone();
+
+        const line2Start = segmentB.pointA.clone();
+        const line2End = segmentB.pointB.clone();
+
+        // Calculate direction vectors
+        const dir1 = new Vector3().subVectors(line1End, line1Start);
+        const dir2 = new Vector3().subVectors(line2End, line2Start);
+
+        // Calculate the cross product of direction vectors
+        const crossDir = new Vector3().crossVectors(dir1, dir2);
+        const denom = crossDir.lengthSq();
+
+        if (denom === 0) {
+            // Segments are parallel or collinear
+            console.log('Segments are parallel or collinear, no intersection.');
+            return null;
+        }
+
+        // Calculate intersection parameters t1 and t2
+        const diffStart = new Vector3().subVectors(line2Start, line1Start);
+        const t1 = diffStart.clone().cross(dir2).dot(crossDir) / denom;
+        const t2 = diffStart.clone().cross(dir1).dot(crossDir) / denom;
+
+        // Check if intersection lies within both segments
+        const isOnLine1 = t1 > 0 && t1 < 1;
+        const isOnLine2 = t2 > 0 && t2 < 1;
+
+        if (isOnLine1 && isOnLine2) {
+            // Calculate the exact intersection point
+            const intersection = line1Start.add(dir1.multiplyScalar(t1));
+            console.log('Intersection found at:', intersection, t1, t2);
+            return intersection;
+        } else {
+            console.log('Intersection does not lie within the segment bounds.');
+            return null;
+        }
+    }
+
+    static getCenterPointInPoints(points:Vector3[]):Vector3
+    {
+        let center = new Vector3()
+        
+        points.forEach((elem)=>{
+            center.x += elem.x
+            center.y += elem.y
+            center.z += elem.z
+        })
+        
+        return new Vector3(center.x / points.length,center.y / points.length,center.z / points.length)
+    }
+
+    static contructPlane(dirction: Vector3, position: Vector3, quaternion: Quaternion, scale: Vector3) {
+        let matrix = new Matrix4()
+        matrix.makeRotationFromQuaternion(quaternion)
+        matrix.scale(scale)
+
+        let pos = new Vector3(dirction.x * 0.5 * -1, 0.5, dirction.z * 0.5 * -1)
+        pos.applyMatrix4(matrix).add(position)
+        dirction.applyQuaternion(quaternion).normalize()
+        let distanceToOrigin = LYMath.getPlaneConstantFromPointAndNormal(pos, dirction)
+
+        return new Plane(dirction, distanceToOrigin)
+    }
+    
+    static  intersectRayPlane(rayOrigin:Vector3, rayDirection:Vector3, planeNormal:Vector3, planePoint:Vector3) 
+    {
+        let denom = planeNormal.dot(rayDirection);
+        if (Math.abs(denom) > 1e-6) { // 确保射线不是平行于平面
+            var w = new Vector3().subVectors(rayOrigin, planePoint);
+            var t = -planeNormal.dot(w) / denom;
+            if (t >= 0) { // 如果 t >= 0，则交点在射线的前方
+                var point = new Vector3().copy(rayOrigin).addScaledVector(rayDirection, t);
+                return point; // 返回交点
+            }
+        }
+        return null; // 没有交点或者射线与平面平行
+    }
+}

package/lythreeFrame/src/Library/ResourceLibrary.ts

@@ -0,0 +1,21 @@
+import {Mesh} from "three";
+
+export class ResourceLibrary
+{
+    static disposeMeshMaterial(mesh:Mesh)
+    {
+        let mats = Array.isArray(mesh.material) ? mesh.material : [mesh.material]
+        mats.forEach((elem)=>{
+            elem.dispose()
+        })
+    }
+    static disposeMeshGeometry(mesh:Mesh)
+    {
+        mesh.geometry.dispose()
+    }
+    static disposeMeshResource(mesh:Mesh)
+    {
+        ResourceLibrary.disposeMeshMaterial(mesh)
+        ResourceLibrary.disposeMeshGeometry(mesh)
+    }
+}