@threepipe/plugin-blend-importer 0.0.1

package/src/js-blend/threejs/blend_three.js

@@ -0,0 +1,91 @@
+/* eslint-disable camelcase, no-unused-vars, no-empty, no-constant-condition */
+import {createThreeJSBufferGeometry} from './mesh.js';
+import {createThreeJSMaterial} from './material.js';
+import {Mesh} from 'threepipe';
+import {createThreeJSLamp} from './light.js';
+
+const blender_object_types = {
+    mesh: 1,
+    lamp: 10,
+};
+
+function createObject (blender_file, object) {
+
+    if (object.data) {
+        // get the mesh
+        const buffered_geometry = createThreeJSBufferGeometry(object.data, [0, 0, 0]);
+
+        console.log(object)
+        const blend_material = object.data.mat[0];
+
+        const material = blend_material ? createThreeJSMaterial(blend_material) : null;
+
+        const mesh = new Mesh(buffered_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;
+    }
+
+    return null;
+}
+
+function loadObject (object_name, blender_file, cache) {
+    const objects = blender_file.Object;
+
+    for (let i = 0; i < objects.length; i++) {
+        let object = objects[i];
+
+        if (object.aname === object_name) {
+            switch (object.type) {
+            case blender_object_types.mesh:
+                return createObject(object, blender_file);
+            case blender_object_types.lamp:
+                return createThreeJSLamp(object, blender_file);
+            default:
+                console.warn('Unsupported object type', object.type);
+            }
+        }
+    }
+
+    return null;
+}
+
+function loadScene (three_scene, blender_file, cache) {
+
+    for (let i = 0; i < blender_file.objects.Object.length; i++) {
+
+        let object = blender_file.objects.Object[i];
+
+        // Load Lights
+        if (object.type === blender_object_types.lamp) {
+            let light = createThreeJSLamp(object, blender_file);
+            three_scene.add(light);
+        }
+
+        // Load Meshes
+        if (object.type === blender_object_types.mesh) {
+            let mesh = createObject(blender_file, object);
+            if(mesh) {
+                three_scene.add(mesh);
+            }
+        }
+    }
+}
+
+export default function (blender_file) {
+
+    const cache = {};
+
+    return {
+        loadScene: (three_scene) => loadScene(three_scene, blender_file, cache),
+        loadObject: (object_name) => loadObject(object_name, blender_file, cache),
+    };
+}

package/src/js-blend/threejs/light.js

@@ -0,0 +1,47 @@
+/* eslint-disable camelcase, no-unused-vars, no-empty, no-constant-condition */
+import {PointLight} from 'threepipe';
+
+const blender_light_types = {
+    point: 0,
+    sun: 1,
+    spot: 0,
+    hemi: 0,
+    area: 0,
+};
+
+export function createThreeJSLamp (blend_lamp) {
+
+    console.log(blend_lamp)
+
+    let ldata = blend_lamp.data;
+
+    let pos_array = [blend_lamp.loc[0], blend_lamp.loc[2], -blend_lamp.loc[1]];
+
+    let color = ((ldata.r * 255) << 16) | ((ldata.g * 255) << 8) | ((ldata.b * 255) << 0);
+    // let intesity = 20;
+    let intesity = ldata.energy;
+    let distance = 0;
+
+    let three_light = null;
+
+    switch (ldata.type) {
+    case blender_light_types.point:
+        three_light = new PointLight(color, intesity, distance);
+        three_light.position.fromArray(pos_array, 0);
+        three_light.castShadow = true;
+        break;
+    case blender_light_types.sun:
+        three_light = new PointLight(color, intesity, distance);
+        three_light.position.fromArray(pos_array, 0);
+        three_light.castShadow = true;
+        three_light.shadow.mapSize.width = 1024;
+        three_light.shadow.mapSize.height = 1024;
+        three_light.shadow.camera.near = 0.01;
+        three_light.shadow.camera.far = 500;
+        break;
+    default:
+        console.warn('Unsupported light type', ldata.type);
+    }
+
+    return three_light;
+}

package/src/js-blend/threejs/material.js

@@ -0,0 +1,175 @@
+/* eslint-disable camelcase, no-unused-vars, no-empty, no-constant-condition */
+import {createThreeJSTexture} from './texture.js';
+import {CubeReflectionMapping, EquirectangularReflectionMapping, MeshPhysicalMaterial} from 'threepipe';
+
+const texture_mappings = {
+    diff_color: 1,
+    normal: 2,
+    mirror: 8,
+    diff_intensity: 16,
+    spec_intensity: 32,
+    emit: 32,
+    alpha: 128,
+    spec_hardness: 256,
+    ray_mirror: 512,
+    translucency: 1024,
+    ambient: 2048,
+    displacement: 4096,
+    warp: 8192,
+};
+
+let blender_specular_types = {
+    cooktorr: 0,
+    phong: 1,
+    blinn: 2,
+    toon: 3,
+    wardiso: 4,
+};
+
+function applyColorMapping (blender_texture, three_texture, material) {
+    if (blender_texture.mapto & texture_mappings.diff_color) {
+        material.map = three_texture;
+    }
+}
+
+function applySpecMapping (blender_texture, three_texture, material) {
+    if (blender_texture.mapto & texture_mappings.spec_color && material.type != 'MeshStandardMaterial') {
+        material.specularMap = three_texture;
+    }
+
+    if (blender_texture.mapto & texture_mappings.spec_intensity && material.type != 'MeshStandardMaterial') {
+        material.roughnessMap = three_texture;
+    }
+}
+
+function applyAlphaMapping (blender_texture, three_texture, material) {
+    if (blender_texture.mapto & texture_mappings.alpha) {
+        material.alphaMap = three_texture;
+    }
+}
+
+function applyNormalMapping (blender_texture, three_texture, material) {
+    if (blender_texture.mapto & texture_mappings.normal) {
+        material.normalMap = three_texture;
+        material.normalScale = {
+            x: blender_texture.norfac,
+            y: blender_texture.norfac,
+        };
+    }
+}
+
+function applyMirrorMapping (blender_texture, three_texture, material) {
+    if (blender_texture.mapto & texture_mappings.mirror) {
+        material.envMap = three_texture;
+        material.envMapIntensity = blender_texture.mirrfac;
+    }
+}
+
+const blender_texture_coordinates = {
+    GENERATED: 1,
+    REFLECTION: 2,
+    NORMAL: 4,
+    GLOBAL: 8,
+    UV: 16,
+    OBJECT: 32,
+    WINDOW: 1024,
+    TANGENT: 4096,
+    PARTICLE: 8192,
+    STRESS: 16384,
+};
+
+const blender_texture_mapping = {
+    FLAT: 0,
+    CUBE: 1,
+    TUBE: 2,
+    SPHERE: 3,
+};
+
+function applyTexture (blender_texture, material) {
+    // extract blender_texture data. Use Only if image has been supplied.
+    if (blender_texture && blender_texture.tex && blender_texture.tex.ima) {
+
+        let three_texture = createThreeJSTexture(blender_texture.tex.ima);
+
+        if(blender_texture.texco == blender_texture_coordinates.REFLECTION) {
+            switch(blender_texture.mapping) {
+            case blender_texture_mapping.FLAT:
+                three_texture.mapping = EquirectangularReflectionMapping;
+                break;
+            case blender_texture_mapping.SPHERE:
+                three_texture.mapping = CubeReflectionMapping;
+                break;
+            default: break;
+            }
+            // three_texture.mapping = EquirectangularRefractionMapping;
+        }
+
+        applyColorMapping(blender_texture, three_texture, material);
+
+        applySpecMapping(blender_texture, three_texture, material);
+
+        applyAlphaMapping(blender_texture, three_texture, material);
+
+        applyNormalMapping(blender_texture, three_texture, material);
+
+        applyMirrorMapping(blender_texture, three_texture, material);
+    }
+}
+
+export function createThreeJSMaterial (blend_mat) {
+
+    console.log(blend_mat)
+
+    let material = new MeshPhysicalMaterial();
+    material.color.setRGB(blend_mat.r, blend_mat.g, blend_mat.b);
+    material.roughness = blend_mat.roughness !== undefined ? blend_mat.roughness : 0.4
+    material.metalness = blend_mat.metallic !== undefined ? blend_mat.metallic : 0.0
+    material.opacity = blend_mat.alpha !== undefined ? blend_mat.alpha : 0.0
+    material.tranparent = material.opacity < 1.0
+
+    // todo textures and nodes
+    // const textures = blend_mat.mtex;
+
+    // switch (blend_mat.spec_shader) {
+    // case blender_specular_types.lambert:
+    //     material = new MeshLambertMaterial();
+    //     material.color.setRGB(blend_mat.r, blend_mat.g, blend_mat.b);
+    //     break;
+    // case blender_specular_types.blinn:
+    // case blender_specular_types.phong:
+    //
+    //     material = new MeshStandardMaterial();
+    //     material.color.setRGB(blend_mat.r, blend_mat.g, blend_mat.b);
+    //     // material.specular.setRGB(blend_mat.specr, blend_mat.specg, blend_mat.specb);
+    //     material.roughness = (1 - (blend_mat.har / 512));
+    //     material.metalness = 1 - blend_mat.ref;
+    //     if(blend_mat.alpha < 0.98) {
+    //         material.transparent = true;
+    //         material.opacity = blend_mat.alpha;
+    //         console.log(blend_mat, material)
+    //     }
+    //     break;
+    // case blender_specular_types.wardiso:
+    // case blender_specular_types.cooktorr:
+    //     material = new MeshPhongMaterial();
+    //     material.color.setRGB(blend_mat.r, blend_mat.g, blend_mat.b);
+    //     material.specular.setRGB(blend_mat.specr, blend_mat.specg, blend_mat.specb);
+    //     material.shininess = blend_mat.har / 512;
+    //     material.reflectivity = blend_mat.ref * 100;
+    //     break;
+    // default:
+    //     material = new MeshStandardMaterial();
+    //     // material = new MeshLambertMaterial();
+    //     material.color.setRGB(blend_mat.r, blend_mat.g, blend_mat.b);
+    //     material.roughness = 0.5;
+    //     material.metalness = 0;
+    //     break;
+    // }
+
+    // const at = (texture) => applyTexture(texture, material);
+    //
+    // if (textures && textures.length) textures.map(at);
+
+    return material;
+}
+

package/src/js-blend/threejs/mesh.js

@@ -0,0 +1,209 @@
+/* eslint-disable camelcase, no-unused-vars, no-empty, no-constant-condition */
+
+import {BufferAttribute, BufferGeometry} from 'threepipe';
+
+export function createBufferGeometry (blender_mesh, origin) {
+    // get materials
+    let pick_material = 0,
+        mesh = blender_mesh,
+        faces = mesh.mpoly,
+        loops = mesh.mloop,
+        UV = mesh.mloopuv,
+        verts = mesh.mvert;
+
+    const geometry = new BufferGeometry();
+
+    if (!faces) return geometry;
+
+    let index_count = 0;
+
+    // precalculate the size of the array needed for faces
+    let face_indice_count = 0;
+    let face_indice_counta = 0;
+
+    for (let i = 0; i < faces.length; i++) {
+        const face = faces[i] || faces;
+        const len = face.totloop;
+        let indexi = 1;
+
+        face_indice_counta += (len * 2 / 3) | 0;
+
+        while (indexi < len) {
+            face_indice_count += 3;
+            indexi += 2;
+        }
+    }
+
+    // extract face info and dump into array buffer;
+    const face_buffer = new Uint32Array(face_indice_count);
+    const uv_buffer = new Float32Array(face_indice_count * 2);
+    const normal_buffer = new Float32Array(face_indice_count * 3);
+    const verts_array_buff = new Float32Array(face_indice_count * 3);
+
+    for (let i = 0; i < faces.length; i++) {
+        const face = faces[i] || faces;
+        const len = face.totloop;
+        const start = face.loopstart;
+        let indexi = 1;
+        const offset = 0;
+
+        while (indexi < len) {
+            const face_normals = [];
+            const face_index_array = [];
+            const face_uvs = [];
+
+            let index = 0;
+
+            for (let l = 0; l < 3; l++) {
+                // Per Vertice
+
+                if ((indexi - 1) + l < len) {
+                    index = start + (indexi - 1) + l;
+                } else {
+                    index = start;
+                }
+
+                const v = loops[index].v;
+                const vert = verts[v];
+                face_buffer[index_count] = index_count;
+                // get normals, which are 16byte ints, and norm them back into floats.
+
+                verts_array_buff[index_count * 3 + 0] = vert.co[0] + origin[0];
+                verts_array_buff[index_count * 3 + 1] = vert.co[2] + origin[2];
+                verts_array_buff[index_count * 3 + 2] = -vert.co[1] + -origin[1];
+
+                normal_buffer[index_count * 3 + 0] = vert.no[0];
+                normal_buffer[index_count * 3 + 1] = vert.no[2];
+                normal_buffer[index_count * 3 + 2] = (-vert.no[1]);
+
+
+                if (UV) {
+                    const uv = UV[index].uv;
+                    uv_buffer[index_count * 2 + 0] = uv[0];
+                    uv_buffer[index_count * 2 + 1] = uv[1];
+                }
+
+                index_count++;
+            }
+
+            indexi += 2;
+        }
+    }
+
+    geometry.setAttribute('position', new BufferAttribute(verts_array_buff, 3));
+    geometry.setIndex(new BufferAttribute(face_buffer, 1));
+    geometry.setAttribute('normal', new BufferAttribute(normal_buffer, 3));
+    geometry.setAttribute('uv', new BufferAttribute(uv_buffer, 2));
+    // geometry.blend_mat = materials[pick_material];
+
+    return geometry;
+}
+
+// function createThreeJSGeometry (blender_mesh, origin) {
+//     // get materials
+//     const mats = blender_mesh.mat,
+//         materials = [];
+//     for (var i = 0; i < mats.length; i++) {
+//         const material = createThreeJSMaterial(mats[i]);
+//         materials.push(material);
+//     }
+//
+//     let pick_material = 0,
+//         mesh = blender_mesh,
+//         faces = mesh.mpoly,
+//         loops = mesh.mloop,
+//         UV = mesh.mloopuv,
+//         verts = mesh.mvert,
+//         vert_array = [],
+//         face_array = [],
+//         uv_array = [],
+//         normal_array = [];
+//
+//     const geometry = new Geometry();
+//
+//     if (!faces) return geometry;
+//
+//
+//     let index_count = 0;
+//
+//     let verts_array_buff = new Float32Array(verts.length * 3);
+//
+//     for (var i = 0; i < verts.length; i++) {
+//         let vert = verts[i];
+//         vert_array.push(new Vector3(vert.co[0] + origin[0], vert.co[2] + origin[2], -vert.co[1] - origin[1]));
+//     }
+//
+//     for (var i = 0; i < faces.length; i++) {
+//         const face = faces[i] || faces;
+//         const len = face.totloop;
+//         const start = face.loopstart;
+//         let indexi = 1;
+//
+//         pick_material = face.mat_nr;
+//
+//         while (indexi < len) {
+//             const face_normals = [];
+//             const face_index_array = [];
+//             const face_uvs = [];
+//
+//             let index = 0;
+//
+//             for (let l = 0; l < 3; l++) {
+//                 // Per Vertice
+//
+//                 if ((indexi - 1) + l < len) {
+//                     index = start + (indexi - 1) + l;
+//                 } else {
+//                     index = start;
+//                 }
+//
+//                 const v = loops[index].v;
+//                 var vert = verts[v];
+//
+//                 face_index_array.push(v);
+//
+//                 index_count++;
+//
+//                 // get normals, which are 16byte ints, and norm them back into floats.
+//
+//                 const n1 = vert.no[0],
+//                     n2 = vert.no[2],
+//                     n3 = -vert.no[1];
+//
+//                 const nl = 1;
+//
+//                 Math.sqrt((n1 * n1) + (n2 * n2) + (n3 * n3));
+//
+//                 face_normals.push(new Vector3(n1 / nl, n2 / nl, n3 / nl));
+//
+//                 if (UV) {
+//                     const uv = UV[index].uv;
+//                     face_uvs.push(new Vector2(uv[0], uv[1]));
+//                 }
+//             }
+//             uv_array.push(face_uvs);
+//             face_array.push(new Face3(
+//                 face_index_array[0], face_index_array[1], face_index_array[2],
+//                 face_normals,
+//             ));
+//
+//             indexi += 2;
+//         }
+//     }
+//     geometry.blend_mat = materials[pick_material];
+//     geometry.vertices = vert_array;
+//     geometry.faces = face_array;
+//     if (uv_array.length > 0) {
+//         geometry.faceVertexUvs = [uv_array];
+//     }
+//
+//     geometry.uvsNeedUpdate = true;
+//
+//     // Well, using blender file normals does not work. Will need to investigate why normals from the blender file do not provide correct results.
+//     // For now, have Three calculate normals.
+//
+//     geometry.computeVertexNormals();
+//
+//
+//     return geometry;
+// }

package/src/js-blend/threejs/texture.js

@@ -0,0 +1,60 @@
+/* eslint-disable camelcase, no-unused-vars, no-empty, no-constant-condition */
+import {arrayBufferToBase64} from 'ts-browser-helpers';
+import {Texture} from 'threepipe';
+
+let blender_texture_cache = {};
+
+export function createThreeJSTexture (image) {
+    let parsed_blend_file = image.__blender_file__;
+    let texture = null;
+    let name = image.aname;
+
+    if (image.packedfile) {
+
+        if (blender_texture_cache[name]) {
+            texture = blender_texture_cache[name];
+        } else {
+
+            // get the extension
+            let ext = name.split('.').pop();
+
+            let data = image.packedfile;
+
+            let size = data.size;
+
+            let offset = data.data.__data_address__;
+
+            let raw_data = parsed_blend_file.byte.slice(offset, offset + size);
+
+            let encodedData = arrayBufferToBase64(raw_data);
+
+            let dataURI;
+
+            switch (ext) {
+            case 'png':
+                dataURI = 'data:image/png;base64,' + encodedData;
+                break;
+            case 'jpg':
+                dataURI = 'data:image/jpeg;base64,' + encodedData;
+                break;
+            default:
+                console.warn('Unsupported image type', ext);
+            }
+
+            // eslint-disable-next-line no-undef
+            let img = new Image();
+
+            img.src = dataURI;
+
+            texture = new Texture(img);
+
+            img.onload = () => {
+                texture.needsUpdate = true;
+                // todo colorspace?
+            };
+
+            blender_texture_cache[name] = texture;
+        }
+    }
+    return texture;
+}

package/src/loader/geometry.ts

@@ -0,0 +1,68 @@
+import {BufferAttribute, BufferGeometry, Vector3Tuple} from 'threepipe'
+
+export function createBufferGeometry(mesh: any, origin: Vector3Tuple) {
+    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()
+
+    if (!faces) return geometry
+
+    const size = faces.reduce((acc, face) => acc + Math.floor(face.totloop * 3.0 / 2), 0)
+    const indices = new Uint32Array(size)
+    const uvs = new Float32Array(size * 2)
+    const normals = new Float32Array(size * 3)
+    const positions = new Float32Array(size * 3)
+
+    let currentIndex = 0
+
+    for (const face of faces) {
+        const len = face.totloop
+        const start = face.loopstart
+        let indexi = 1
+
+        while (indexi < len) {
+
+            let index = 0
+
+            for (let l = 0; l < 3; l++) {
+                // Per Vertex
+
+                index = start
+                if (indexi - 1 + l < len)
+                    index += indexi - 1 + l
+
+                const loop = loops[index]
+                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]
+
+                normals[currentIndex * 3 + 0] = vert.no[0]
+                normals[currentIndex * 3 + 1] = vert.no[2]
+                normals[currentIndex * 3 + 2] = -vert.no[1]
+
+                if (uv) {
+                    uvs[currentIndex * 2 + 0] = uv[index].uv[0]
+                    uvs[currentIndex * 2 + 1] = uv[index].uv[1]
+                }
+
+                currentIndex++
+            }
+
+            indexi += 2
+        }
+    }
+
+    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))
+
+    return geometry
+}

package/src/loader/index.ts

@@ -0,0 +1,26 @@
+import {createLight} from './light'
+import {createMesh} from './mesh'
+import {Object3D} from 'three'
+
+const blenderObjectTypes = {
+    mesh: 1,
+    lamp: 10,
+}
+
+export async function createObjects(file: any) {
+    const objects: (Object3D|null)[] = []
+    const blendObjects = file.objects.Object
+    for (const object of blendObjects) {
+        switch (object.type) {
+        case blenderObjectTypes.mesh:
+            objects.push(createMesh(object))
+            break
+        case blenderObjectTypes.lamp:
+            objects.push(createLight(object))
+            break
+        default:
+            console.warn('Unsupported object type', object.type)
+        }
+    }
+    return objects.filter(o => !!o) as Object3D[]
+}