@threepipe/plugin-blend-importer 0.0.4 → 0.0.6

package/src/loader/camera.ts

@@ -0,0 +1,55 @@
+import {Object3D} from 'threepipe'
+import {Ctx} from './ctx'
+
+export function createCamera(object: any, ctx: Ctx): Object3D | undefined {
+    const cdata = object.data
+    // console.log(bakeGetters(object))
+    if (!cdata) return undefined
+
+    // Blender camera types: 0 = Perspective, 1 = Orthographic
+    const type = cdata.type
+    let camera: Object3D
+    if (type === 0) {
+        // Perspective
+        // Convert lens (mm) to field of view (fov) in degrees (vfov)
+        const sensorWidth = cdata.sensor_x || 36
+        const sensorHeight = cdata.sensor_y || 24
+        const lens = cdata.lens || 50
+        const fov = 2 * Math.atan(sensorHeight / (2 * lens)) * (180 / Math.PI)
+
+        camera = new ctx.PerspectiveCamera(
+            fov,
+            sensorWidth / sensorHeight,
+            cdata.clipsta || 0.1,
+            cdata.clipend || 1000
+        )
+        if ('shiftx' in cdata) camera.userData.shiftX = cdata.shiftx // todo?
+        if ('shiftx' in cdata) camera.userData.shiftX = cdata.shiftx // todo?
+        if ('shifty' in cdata) camera.userData.shiftY = cdata.shifty
+    } else if (type === 1) {
+        // Orthographic
+        const scale = cdata.ortho_scale || 1
+        const aspect = (cdata.sensor_x || 36) / (cdata.sensor_y || 24)
+        const left = -scale * aspect / 2
+        const right = scale * aspect / 2
+        const top = scale / 2
+        const bottom = -scale / 2
+        camera = new ctx.OrthographicCamera(
+            left, right, top, bottom,
+            cdata.clipsta || 0.1,
+            cdata.clipend || 1000
+        )
+        if ('shiftx' in cdata) camera.userData.shiftX = cdata.shiftx
+        if ('shifty' in cdata) camera.userData.shiftY = cdata.shifty
+    } else {
+        // Unknown camera type
+        camera = new ctx.PerspectiveCamera()
+        console.warn('Unsupported camera type', type)
+    }
+
+    // const obj = new Object3D()
+    // camera.rotation.x = -Math.PI / 2
+    // obj.add(camera)
+
+    return camera
+}

package/src/loader/ctx.ts

@@ -0,0 +1,29 @@
+import {
+    AmbientLight,
+    BufferAttribute,
+    BufferGeometry,
+    DirectionalLight,
+    Mesh,
+    MeshBasicMaterial,
+    MeshPhysicalMaterial,
+    Object3D,
+    OrthographicCamera,
+    PerspectiveCamera,
+    PointLight,
+    SpotLight,
+} from 'threepipe'
+
+export interface Ctx {
+    PointLight: typeof PointLight
+    SpotLight: typeof SpotLight
+    DirectionalLight: typeof DirectionalLight
+    AmbientLight: typeof AmbientLight
+    Object3D: typeof Object3D
+    PerspectiveCamera: typeof PerspectiveCamera
+    OrthographicCamera: typeof OrthographicCamera
+    Mesh: typeof Mesh
+    BufferGeometry: typeof BufferGeometry
+    BufferAttribute: typeof BufferAttribute
+    MeshPhysicalMaterial: typeof MeshPhysicalMaterial
+    MeshBasicMaterial: typeof MeshBasicMaterial
+}

package/src/loader/geometry.ts

@@ -1,13 +1,227 @@
-import {BufferAttribute, BufferGeometry, Vector3Tuple} from 'threepipe'
+import {Ctx} from './ctx'
 
-export function createBufferGeometry(mesh: any, origin: Vector3Tuple) {
+function getLayer(layers: any, i: number) {
+    if (!Array.isArray(layers)) return layers
+    return layers[i]
+}
+// https://projects.blender.org/blender/blender/pulls/108015/files
+// https://projects.blender.org/blender/blender/commit/1b63a290c68636211b16c5e212a699e6b63031b9
+// https://developer.blender.org/docs/release_notes/4.0/python_api/#breaking-changes
+// https://developer.blender.org/docs/release_notes/4.0/#blend-files
+// https://projects.blender.org/blender/blender/commit/7966cd16d6dc4e66d01f7bd68a090107c1a7978c
+// https://projects.blender.org/blender/blender/issues/95967
+// https://projects.blender.org/blender/blender/pulls/106638
+
+// https://github.com/blender/blender/blob/55e2fd2929b7577e0785c128c8f8069efd990c07/source/blender/blenkernel/intern/mesh.cc#L413
+export function createBufferGeometry(meshData: any, ctx: Ctx) {
+
+    if (meshData.mpoly) return createBufferGeometryOld(meshData, ctx)
+    const geometry = new ctx.BufferGeometry()
+    geometry.name = meshData.aname || ''
+
+    // console.log(bakeGetters(meshData))
+
+    // https://github.com/blender/blender/blob/05dcc0377b62d8e026e1901dfbecbd4b06fda0b5/scripts/addons_core/io_scene_gltf2/blender/exp/primitive_extract.py#L19
+
+    let vertices
+    let indices
+
+    // Extract vertex positions from vdata layers
+    if (meshData.vdata && meshData.vdata.layers && meshData.vdata.totlayer > 0) {
+        for (let i = 0; i < meshData.vdata.totlayer; i++) {
+            const layer = getLayer(meshData.vdata.layers, i)
+            // if (layer.type === 0) {
+            // https://github.com/blender/blender/blob/05dcc0377b62d8e026e1901dfbecbd4b06fda0b5/scripts/addons_core/io_scene_gltf2/blender/exp/primitive_extract.py#L1575
+            const data = layer.data || []
+            // if (layer.name === 'position') { // type = 48 (custom vec3)
+            if (data.length === meshData.totvert) {
+                if (vertices && (layer.name !== 'position' || vertices.name === 'position')) {
+                    // console.warn('BlendLoader - multiple vertices, ignoring', layer)
+                    continue
+                }
+                vertices = layer
+            } else {
+                // console.log('unknown vdata', layer)
+            }
+        }
+    }
+
+    // Blender loops are indexes in three.js/blender. Called dots in gltf exporter
+
+    // // Extract indexes from loop data layers
+    if (meshData.ldata && meshData.ldata.layers) {
+        for (let i = 0; i < meshData.ldata.totlayer; i++) {
+            const layer = getLayer(meshData.ldata.layers, i)
+            // if (layer.type === 0) {
+            const data = layer.data || []
+            // if (layer.name === '.corner_vert') { // type = 11
+            if (data.length === meshData.totloop) { // type = 11
+                if (indices && (layer.name !== '.corner_vert' || indices.name === '.corner_vert')) {
+                    // console.warn('BlendLoader - multiple indices, ignoring', layer)
+                    continue
+                }
+                indices = layer
+            } else {
+                // console.log('unknown ldata', layer)
+            }
+        }
+    }
+    // if (meshData.pdata && meshData.pdata.layers) {
+    //     for (let i = 0; i < meshData.pdata.totlayer; i++) {
+    //         const layer = getLayer(meshData.pdata.layers, i)
+    //         // if (layer.type === 0) {
+    //         // if (layer.name === '.corner_vert') { // type = 11
+    //         // } else {
+    //         console.log('unknown pdata', layer)
+    //         // }
+    //     }
+    // }
+    // if (meshData.fdata && meshData.fdata.layers) {
+    //     for (let i = 0; i < meshData.fdata.totlayer; i++) {
+    //         const layer = getLayer(meshData.fdata.layers, i)
+    //         // if (layer.type === 0) {
+    //         // if (layer.name === '.corner_vert') { // type = 11
+    //         // } else {
+    //         console.log('unknown fdata', layer)
+    //         // }
+    //     }
+    // }
+    // if (meshData.edata && meshData.edata.layers) {
+    //     for (let i = 0; i < meshData.edata.totlayer; i++) {
+    //         const layer = getLayer(meshData.edata.layers, i)
+    //         // if (layer.type === 0) {
+    //         // if (layer.name === '.corner_vert') { // type = 11
+    //         // } else {
+    //         console.log('unknown edata', layer)
+    //         // }
+    //     }
+    // }
+
+    let faceIndices: number[] = []
+    if (meshData.poly_offset_indices && meshData.totpoly > 0) {
+        faceIndices = [...new Int32Array(meshData.poly_offset_indices.__blender_file__.AB, meshData.poly_offset_indices.__data_address__, meshData.totpoly + 1)]
+    }
+    // if (faceSize !== 3 && faceSize !== 4 && !faceIndices.length) {
+    //     console.error('not supported polygons with ', faceSize, 'vertices')
+    //     return geometry
+    // }
+
+    if (vertices?.data && vertices.data.length > 0) {
+        const positions = new Float32Array(vertices.data.length * 3)
+        for (let j = 0; j < vertices.data.length; j++) {
+            const vertex = vertices.data[j]
+            if (vertex.x !== undefined) {
+                positions[j * 3] = vertex.x
+                positions[j * 3 + 1] = vertex.z
+                positions[j * 3 + 2] = -vertex.y
+            } else if (vertex.co !== undefined) {
+                positions[j * 3] = vertex.co[0]
+                positions[j * 3 + 1] = vertex.co[2]
+                positions[j * 3 + 2] = -vertex.co[1]
+            } else {
+                // console.log(bakeGetters(meshData))
+                // const t = [...new Int32Array(vertex.__blender_file__.AB, vertex.__data_address__, 8)]
+                // debugger
+                console.error('BlendLoader - unknown vertex', vertex)
+                break
+            }
+        }
+        geometry.setAttribute('position', new ctx.BufferAttribute(positions, 3))
+    }
+
+    if (indices?.data && indices.data.length > 0 && vertices?.data?.length) {
+        const faceSize = meshData.totloop / meshData.totpoly
+        if (faceIndices.length > 0) {
+            // Use face offset indices for variable-sized faces
+            let totalTriangles = 0
+            for (let i = 0; i < faceIndices.length - 1; i++) {
+                const faceVertCount = faceIndices[i + 1] - faceIndices[i]
+                totalTriangles += Math.max(0, faceVertCount - 2)
+            }
+
+            const indexes = new Uint32Array(totalTriangles * 3)
+            let t = 0
+
+            for (let i = 0; i < faceIndices.length - 1; i++) {
+                const faceStart = faceIndices[i]
+                const faceEnd = faceIndices[i + 1]
+                const faceVertCount = faceEnd - faceStart
+
+                if (faceVertCount >= 3) {
+                    // todo better Triangulate the face using fan triangulation
+                    const firstVert = indices.data[faceStart].i
+                    for (let k = 1; k < faceVertCount - 1; k++) {
+                        indexes[t++] = firstVert
+                        indexes[t++] = indices.data[faceStart + k].i
+                        indexes[t++] = indices.data[faceStart + k + 1].i
+                    }
+                } else {
+                    // debugger
+                }
+            }
+
+            // console.log(indexes)
+            geometry.setIndex(new ctx.BufferAttribute(indexes, 1))
+        } else if (faceSize === 3 || faceSize === 4) {
+            // Fall back to uniform face size approach
+            const isQuad = faceSize === 4
+            const faceCount = indices.length / faceSize
+            const indexes = new Uint32Array(faceCount * 3 * (isQuad ? 2 : 1))
+
+            if (faceSize !== 3 && faceSize !== 4) return geometry
+            for (let j = 0, t = 0; j < indices.length; j += faceSize) {
+                const a = indices[j].i
+                const b = indices[j + 1].i
+                const c = indices[j + 2].i
+                indexes[t++] = a
+                indexes[t++] = b
+                indexes[t++] = c
+
+                if (isQuad) {
+                    const d = indices[j + 3].i
+                    indexes[t++] = a
+                    indexes[t++] = c
+                    indexes[t++] = d
+                }
+            }
+            geometry.setIndex(new ctx.BufferAttribute(indexes, 1))
+        }
+    } else if (faceIndices) {
+        console.error('BlendLoader - no indices data found, but face indices are present', faceIndices)
+    }
+
+    // console.log(geometry.attributes.position)
+    // console.log(geometry.index)
+
+    // compute stuff not present
+    if (geometry.attributes.position && !geometry.attributes.normal)
+        geometry.computeVertexNormals()
+
+    // if (meshData.loc) { // maybe this is the bbox center?
+    //     geometry.translate(meshData.loc[0], meshData.loc[2], -meshData.loc[1])
+    // }
+    // if (meshData.size) { // maybe this is the bbox size?
+    //     geometry.scale(meshData.size[0], meshData.size[2], -meshData.size[1])
+    // }
+
+    return geometry
+}
+//     // https://github.com/blender/blender/blob/05dcc0377b62d8e026e1901dfbecbd4b06fda0b5/scripts/addons_core/io_scene_gltf2/blender/exp/primitive_extract.py#L19
+//             // https://github.com/blender/blender/blob/05dcc0377b62d8e026e1901dfbecbd4b06fda0b5/scripts/addons_core/io_scene_gltf2/blender/exp/primitive_extract.py#L1575
+//             // todo __set_morph_locs_attribute
+//             // todo __set_morph_tangent_attribute
+//     // todo pdata(points), edata(edge), fdata(face? legacy?)
+//     // meshData.eData = domain edge - https://github.com/blender/blender/blob/05dcc0377b62d8e026e1901dfbecbd4b06fda0b5/scripts/addons_core/io_scene_gltf2/blender/exp/primitive_extract.py#L189
+//     // todo normals, tangents
+
+export function createBufferGeometryOld(mesh: any, ctx: Ctx) {
     const
         faces = Array.isArray(mesh.mpoly) ? mesh.mpoly as any[] : [mesh.mpoly],
         loops = mesh.mloop,
         uv = mesh.mloopuv,
         vertices = mesh.mvert
 
-    const geometry = new BufferGeometry()
+    const geometry = new ctx.BufferGeometry()
 
     if (!faces) return geometry
 
@@ -18,6 +232,7 @@ export function createBufferGeometry(mesh: any, origin: Vector3Tuple) {
     const positions = new Float32Array(size * 3)
 
     let currentIndex = 0
+    let computeNormals = false
 
     for (const face of faces) {
         const len = face.totloop
@@ -39,13 +254,17 @@ export function createBufferGeometry(mesh: any, origin: Vector3Tuple) {
                 const vert = vertices[loop.v]
                 indices[currentIndex] = currentIndex
 
-                positions[currentIndex * 3 + 0] = vert.co[0] + origin[0]
-                positions[currentIndex * 3 + 1] = vert.co[2] + origin[2]
-                positions[currentIndex * 3 + 2] = -vert.co[1] + -origin[1]
+                positions[currentIndex * 3 + 0] = vert.co[0]
+                positions[currentIndex * 3 + 1] = vert.co[2]
+                positions[currentIndex * 3 + 2] = -vert.co[1]
 
-                normals[currentIndex * 3 + 0] = vert.no[0]
-                normals[currentIndex * 3 + 1] = vert.no[2]
-                normals[currentIndex * 3 + 2] = -vert.no[1]
+                if (vert.no) {
+                    normals[currentIndex * 3 + 0] = vert.no[0]
+                    normals[currentIndex * 3 + 1] = vert.no[2]
+                    normals[currentIndex * 3 + 2] = -vert.no[1]
+                } else {
+                    computeNormals = true
+                }
 
                 if (uv) {
                     uvs[currentIndex * 2 + 0] = uv[index].uv[0]
@@ -59,10 +278,14 @@ export function createBufferGeometry(mesh: any, origin: Vector3Tuple) {
         }
     }
 
-    geometry.setAttribute('position', new BufferAttribute(positions, 3))
-    geometry.setIndex(new BufferAttribute(indices, 1))
-    geometry.setAttribute('normal', new BufferAttribute(normals, 3))
-    geometry.setAttribute('uv', new BufferAttribute(uvs, 2))
+    geometry.setAttribute('position', new ctx.BufferAttribute(positions, 3))
+    geometry.setIndex(new ctx.BufferAttribute(indices, 1))
+    geometry.setAttribute('normal', new ctx.BufferAttribute(normals, 3))
+    geometry.setAttribute('uv', new ctx.BufferAttribute(uvs, 2))
+
+    if (computeNormals) {
+        geometry.computeVertexNormals()
+    }
 
     return geometry
 }

package/src/loader/index.ts

@@ -1,26 +1,115 @@
+import {createCamera} from './camera'
 import {createLight} from './light'
 import {createMesh} from './mesh'
-import {Object3D} from 'threepipe'
+import {IObject3D, Object3D} from 'threepipe'
+import {Ctx} from './ctx'
+import {Euler, EulerOrder} from 'three/src/math/Euler'
+import {Quaternion, Vector3} from 'three'
 
+// https://github.com/blender/blender/blob/99a4c93081cc2310a09a14f20a1493e8974c10d2/source/blender/makesdna/DNA_object_types.h#L445
 const blenderObjectTypes = {
+    empty: 0,
     mesh: 1,
     lamp: 10,
+    camera: 11,
 }
 
-export async function createObjects(file: any) {
+export async function createObjects(file: any, ctx: Ctx) {
     const objects: (Object3D|null)[] = []
-    const blendObjects = file.objects.Object
+    const childMap = new Map<any, Object3D[]>()
+    const objMap = new Map<any, Object3D>()
+    const blendObjects = file.objects.Object ?? []
+    const loaded = new WeakMap()
+    // console.log(bakeGetters(file))
     for (const object of blendObjects) {
+        if (loaded.has(object)) {
+            console.warn('BlendLoader - duplicate object')
+            continue
+        }
+        let obj: Object3D | undefined = undefined
         switch (object.type) {
+        case blenderObjectTypes.empty:
+            obj = new ctx.Object3D()
+            break
         case blenderObjectTypes.mesh:
-            objects.push(createMesh(object))
+            obj = createMesh(object, loaded, ctx)
             break
         case blenderObjectTypes.lamp:
-            objects.push(createLight(object))
+            obj = createLight(object, ctx)
+            break
+        case blenderObjectTypes.camera:
+            obj = createCamera(object, ctx)
             break
         default:
-            console.warn('Unsupported object type', object.type)
+            obj = new ctx.Object3D()
+            console.warn('Unsupported object type', object.type, object, obj)
+        }
+        if (obj) {
+            setTransform(object, obj as any)
+            const exChildren = childMap.get(object)
+            if (exChildren) {
+                for (const exChild of exChildren) {
+                    obj.add(exChild)
+                }
+                childMap.delete(object)
+            }
+            objMap.set(object, obj)
+            if (object.parent === object) {
+                console.error('BlendLoader - invalid, parent same as object, adding to root', object)
+                objects.push(obj)
+            } else if (!object.parent) { // just in case
+                objects.push(obj)
+            } else {
+                const parent = objMap.get(object.parent)
+                if (!parent) {
+                    const chi = childMap.get(object.parent) ?? []
+                    chi.push(obj)
+                    childMap.set(object, chi)
+                } else {
+                    parent.add(obj)
+                }
+            }
+            loaded.set(object, obj)
         }
     }
+    if (childMap.size) {
+        const vals = [...childMap.values()].flat()
+        console.warn('BlendLoader - unknown objects with parents, adding to root', vals, childMap)
+        objects.push(...vals)
+    }
     return objects.filter(o => !!o) as Object3D[]
 }
+
+
+// https://github.com/blender/blender/blob/458e224587e8c45da20841a283cc1b41adc98950/source/blender/makesdna/DNA_action_types.h#L526
+const eulerModes: Record<number, EulerOrder> = {
+    [1]: 'XYZ',
+    [2]: 'XZY',
+    [3]: 'YXZ',
+    [4]: 'YZX',
+    [5]: 'ZXY',
+    [6]: 'ZYX',
+}
+
+function setTransform(object: any, obj: IObject3D) {
+    obj.name = object.aname
+    obj.scale.set(object.size[0], object.size[2], object.size[1])
+    obj.position.set(object.loc[0], object.loc[2], -object.loc[1])
+
+    if (!object.rotmode || object.rotmode === 0) {
+        // const quat = new Quaternion()
+        obj.quaternion.set(object.quat[1], object.quat[3], -object.quat[2], object.quat[0]) // wxyz
+    } else {
+        // console.log(object.rotmode)
+        // const order = eulerModes[4]
+        const order = eulerModes[object.rotmode] ?? 'XYZ'
+        const quat = new Quaternion().setFromEuler(new Euler(object.rot[0], object.rot[1], object.rot[2], order.split('').reverse().join('') as any))
+        obj.quaternion.set(quat.x, quat.z, -quat.y, quat.w) // wxyz
+    }
+    // because camera is rotated 90d in blender
+    if (object.type === blenderObjectTypes.camera)
+        obj.quaternion.multiply(new Quaternion().setFromAxisAngle(new Vector3(1, 0, 0), -Math.PI / 2))
+
+    obj.updateMatrix()
+    if (obj.setDirty) obj.setDirty()
+}

package/src/loader/light.ts

@@ -1,4 +1,5 @@
-import {PointLight} from 'threepipe'
+import {Light} from 'threepipe'
+import {Ctx} from './ctx'
 
 const blenderLightTypes = {
     point: 0,
@@ -8,7 +9,7 @@ const blenderLightTypes = {
     area: 0,
 }
 
-export function createLight(lamp: any) {
+export function createLight(lamp: any, ctx: Ctx) {
     const ldata = lamp.data
 
     const position = [lamp.loc[0], lamp.loc[2], -lamp.loc[1]]
@@ -17,22 +18,26 @@ export function createLight(lamp: any) {
     const intensity = ldata.energy
     const distance = 0
 
-    let light = null
+    let light: Light | undefined = undefined
 
     switch (ldata.type) {
     case blenderLightTypes.point:
-        light = new PointLight(color, intensity, distance)
-        light.position.fromArray(position, 0)
-        light.castShadow = true
+        light = new ctx.PointLight(color, intensity, distance)
+        light!.position.fromArray(position, 0)
+        light!.castShadow = true
         break
     case blenderLightTypes.sun:
-        light = new PointLight(color, intensity, distance)
-        light.position.fromArray(position, 0)
-        light.castShadow = true
-        light.shadow.mapSize.width = 1024
-        light.shadow.mapSize.height = 1024
-        light.shadow.camera.near = 0.01
-        light.shadow.camera.far = 500
+        light = new ctx.PointLight(color, intensity, distance)
+        light!.position.fromArray(position, 0)
+        light!.castShadow = true
+        if (light!.shadow) {
+            light!.shadow.mapSize.width = 1024
+            light!.shadow.mapSize.height = 1024
+            // @ts-expect-error ??/
+            light!.shadow.camera.near = 0.01
+            // @ts-expect-error ??/
+            light!.shadow.camera.far = 500
+        }
         break
     default:
         console.warn('Unsupported light type', ldata.type)

package/src/loader/material.ts

@@ -1,12 +1,14 @@
-import {MeshPhysicalMaterial} from 'threepipe'
-
 // todo see blender gltf exporter and convert to js. structure is the same
-export function createMaterial(mat: any) {
-    const material = new MeshPhysicalMaterial()
+//   https://github.com/KhronosGroup/glTF-Blender-IO/blob/ed5100ab6c40472b7c3254fddfe0dd0d76d60644/addons/io_scene_gltf2/blender/exp/material/materials.py#L60
+import {Ctx} from './ctx'
+
+export function createMaterial(mat: any, ctx: Ctx) {
+    const material = new ctx.MeshPhysicalMaterial()
     material.color.setRGB(mat.r, mat.g, mat.b)
     material.roughness = mat.roughness !== undefined ? mat.roughness : 0.4
     material.metalness = mat.metallic !== undefined ? mat.metallic : 0.0
-    material.opacity = mat.alpha !== undefined ? mat.alpha : 0.0
+    // material.opacity = mat.alpha !== undefined ? mat.alpha : 0.0
+    material.opacity = 1
     material.transparent = material.opacity < 1.0
     return material
 }

package/src/loader/mesh.ts

@@ -1,26 +1,27 @@
-import {Mesh} from 'threepipe'
 import {createBufferGeometry} from './geometry'
 import {createMaterial} from './material'
+import {Ctx} from './ctx'
 
-export function createMesh(object: any) {
-    if (!object.data) return null
+export function createMesh(object: any, loaded: WeakMap<any, any>, ctx: Ctx) {
+    if (!object.data) {
+        return undefined
+    }
 
-    const geometry = createBufferGeometry(object.data, [0, 0, 0])
+    const geometry = loaded.get(object.data) ?? createBufferGeometry(object.data, ctx)
+    loaded.set(object.data, geometry)
 
     const mat = object.data.mat[0]
 
-    const material = mat ? createMaterial(mat) : undefined
-    const mesh = new Mesh(geometry, material)
+    // const material = mat ? createMaterial(mat) : undefined
+    const material = mat ? loaded.get(mat) ?? createMaterial(mat, ctx) : new ctx.MeshPhysicalMaterial()
+    if (mat) loaded.set(mat, material)
+
+    // console.log(material, mat)
+    // material.side = DoubleSide
+    const mesh = new ctx.Mesh(geometry, material)
 
     mesh.castShadow = true
     mesh.receiveShadow = true
 
-    mesh.rotateZ(object.rot[2])
-    mesh.rotateY(object.rot[1])
-    mesh.rotateX(object.rot[0])
-
-    mesh.scale.fromArray(object.size, 0)
-    mesh.position.fromArray([object.loc[0], object.loc[2], -object.loc[1]], 0)
-
     return mesh
 }