obj2gltf/specs/lib/createGltfSpec.js

'use strict';
const Cesium = require('cesium');
const obj2gltf = require('../../lib/obj2gltf');
const createGltf = require('../../lib/createGltf');
const loadObj = require('../../lib/loadObj');
const { getDefaultMaterial } = require('../../lib/loadMtl');

const clone = Cesium.clone;
const defined = Cesium.defined;
const WebGLConstants = Cesium.WebGLConstants;

const boxObjPath = 'specs/data/box/box.obj';
const groupObjPath = 'specs/data/box-objects-groups-materials/box-objects-groups-materials.obj';
const complexObjPath = 'specs/data/box-complex-material/box-complex-material.obj';
const noMaterialsObjPath = 'specs/data/box-no-materials/box-no-materials.obj';
const mixedAttributesObjPath = 'specs/data/box-mixed-attributes-2/box-mixed-attributes-2.obj';

let options;

describe('createGltf', () => {
    let boxObjData;
    let groupObjData;
    let complexObjData;
    let noMaterialsObjData;
    let mixedAttributesObjData;

    beforeEach(async () => {
        options = clone(obj2gltf.defaults);
        options.overridingTextures = {};
        options.logger = () => {};

        boxObjData = await loadObj(boxObjPath, options);
        groupObjData = await loadObj(groupObjPath, options);
        complexObjData = await loadObj(complexObjPath, options);
        noMaterialsObjData = await loadObj(noMaterialsObjPath, options);
        mixedAttributesObjData = await loadObj(mixedAttributesObjPath, options);
    });

    it('simple gltf', () => {
        const gltf = createGltf(boxObjData, options);

        expect(gltf.materials.length).toBe(1);
        expect(gltf.scene).toBe(0);
        expect(gltf.scenes[0].nodes[0]).toBe(0);
        expect(gltf.nodes.length).toBe(1);
        expect(gltf.meshes.length).toBe(1);

        const primitives = gltf.meshes[0].primitives;
        const primitive = primitives[0];
        const attributes = primitive.attributes;
        const positionAccessor = gltf.accessors[attributes.POSITION];
        const normalAccessor = gltf.accessors[attributes.NORMAL];
        const uvAccessor = gltf.accessors[attributes.TEXCOORD_0];
        const indexAccessor = gltf.accessors[primitive.indices];

        expect(primitives.length).toBe(1);
        expect(positionAccessor.count).toBe(24);
        expect(normalAccessor.count).toBe(24);
        expect(uvAccessor.count).toBe(24);
        expect(indexAccessor.count).toBe(36);
    });

    it('does not combine buffers when that buffer would exceed the Node buffer size limit', () => {
        spyOn(createGltf, '_getBufferMaxByteLength').and.returnValue(0);
        const clonedOptions = clone(options, true);
        clonedOptions.separate = true;

        const gltf = createGltf(boxObjData, clonedOptions);
        expect(gltf.accessors.length).toBe(4);
        expect(gltf.buffers.length).toBe(4);
        expect(gltf.bufferViews.length).toBe(4);

        const length = gltf.buffers.length;
        for (let i = 0; i < length; ++i) {
            const accessor = gltf.accessors[i];
            const bufferView = gltf.bufferViews[i];
            const buffer = gltf.buffers[i];
            expect(accessor.bufferView).toBe(i);
            expect(accessor.byteOffset).toBe(0);
            expect(bufferView.buffer).toBe(i);
            expect(bufferView.byteOffset).toBe(0);
            expect(bufferView.byteLength).toBe(buffer.byteLength);
        }
    });

    it('multiple nodes, meshes, and primitives', () => {
        const gltf = createGltf(groupObjData, options);

        expect(gltf.materials.length).toBe(3);
        expect(gltf.scene).toBe(0);
        expect(gltf.scenes[0].nodes[0]).toBe(0);
        expect(gltf.nodes.length).toBe(4);
        expect(gltf.nodes[0].mesh).toBeUndefined();
        expect(gltf.nodes[0].children.length).toBe(3);
        expect(gltf.meshes.length).toBe(3);

        // Check for two primitives in each mesh
        const length = gltf.meshes.length;
        for (let i = 0; i < length; ++i) {
            const mesh = gltf.meshes[i];
            expect(mesh.primitives.length).toBe(2);
        }
    });

    it('multiple textures', () => {
        const gltf = createGltf(complexObjData, options);
        const material = gltf.materials[0];
        const pbr = material.pbrMetallicRoughness;
        const textures = [pbr.metallicRoughnessTexture, pbr.baseColorTexture, material.emissiveTexture, material.normalTexture, material.occlusionTexture];
        expect(textures.map((texture) => {
            return texture.index;
        }).sort()).toEqual([0, 1, 2, 3, 4]);
        expect(gltf.samplers[0]).toBeDefined();
    });

    it('creates default material', () => {
        const gltf = createGltf(noMaterialsObjData, options);
        const material = gltf.materials[0];
        const pbr = material.pbrMetallicRoughness;
        expect(material.name).toBe('default');
        expect(pbr.baseColorTexture).toBeUndefined();
        expect(pbr.metallicRoughnessTexture).toBeUndefined();
        expect(pbr.baseColorFactor).toEqual([0.5, 0.5, 0.5, 1.0]);
        expect(pbr.metallicFactor).toBe(0.0); // No metallic
        expect(pbr.roughnessFactor).toBe(1.0); // Fully rough
        expect(material.emissiveTexture).toBeUndefined();
        expect(material.normalTexture).toBeUndefined();
        expect(material.ambientTexture).toBeUndefined();
        expect(material.emissiveFactor).toEqual([0.0, 0.0, 0.0]);
        expect(material.alphaMode).toBe('OPAQUE');
        expect(material.doubleSided).toBe(false);
    });

    it('adds KHR_materials_pbrSpecularGlossiness extension when specularGlossiness is set', () => {
        options.specularGlossiness = true;
        const gltf = createGltf(noMaterialsObjData, options);
        expect(gltf.extensionsUsed).toEqual(['KHR_materials_pbrSpecularGlossiness']);
        expect(gltf.extensionsRequired).toEqual(['KHR_materials_pbrSpecularGlossiness']);
    });

    it('adds KHR_materials_unlit extension when unlit is set', () => {
        options.unlit = true;
        const gltf = createGltf(noMaterialsObjData, options);
        expect(gltf.extensionsUsed).toEqual(['KHR_materials_unlit']);
        expect(gltf.extensionsRequired).toEqual(['KHR_materials_unlit']);
    });

    it('runs without normals', () => {
        boxObjData.nodes[0].meshes[0].primitives[0].normals.length = 0;

        const gltf = createGltf(boxObjData, options);
        const attributes = gltf.meshes[0].primitives[0].attributes;
        expect(attributes.POSITION).toBeDefined();
        expect(attributes.NORMAL).toBeUndefined();
        expect(attributes.TEXCOORD_0).toBeDefined();
    });

    it('runs without uvs', () => {
        boxObjData.nodes[0].meshes[0].primitives[0].uvs.length = 0;

        const gltf = createGltf(boxObjData, options);
        const attributes = gltf.meshes[0].primitives[0].attributes;
        expect(attributes.POSITION).toBeDefined();
        expect(attributes.NORMAL).toBeDefined();
        expect(attributes.TEXCOORD_0).toBeUndefined();
    });

    it('runs without uvs and normals', () => {
        boxObjData.nodes[0].meshes[0].primitives[0].normals.length = 0;
        boxObjData.nodes[0].meshes[0].primitives[0].uvs.length = 0;

        const gltf = createGltf(boxObjData, options);
        const attributes = gltf.meshes[0].primitives[0].attributes;
        expect(attributes.POSITION).toBeDefined();
        expect(attributes.NORMAL).toBeUndefined();
        expect(attributes.TEXCOORD_0).toBeUndefined();
    });

    it('splits incompatible materials', () => {
        const gltf = createGltf(mixedAttributesObjData, options);
        const materials = gltf.materials;
        const meshes = gltf.meshes;

        const referenceMaterial = mixedAttributesObjData.materials[0];
        delete referenceMaterial.name;
        referenceMaterial.pbrMetallicRoughness.baseColorTexture = {
            index : 0
        };

        const referenceMaterialNoTextures = clone(referenceMaterial, true);
        referenceMaterialNoTextures.pbrMetallicRoughness.baseColorTexture = undefined;

        const defaultMaterial = getDefaultMaterial(options);
        delete defaultMaterial.name;

        const materialNames = materials.map((material) => {
            const name = material.name;
            delete material.name;
            return name;
        });

        // Expect three copies of each material for
        // * positions/normals/uvs
        // * positions/normals
        // * positions/uvs
        expect(materialNames).toEqual([
            'default',
            'default-2',
            'default-3',
            'Material',
            'Material-2',
            'Material-3',
            'Missing',
            'Missing-2',
            'Missing-3'
        ]);

        expect(materials.length).toBe(9);
        expect(materials[0]).toEqual(defaultMaterial);
        expect(materials[1]).toEqual(defaultMaterial);
        expect(materials[2]).toEqual(defaultMaterial);
        expect(materials[3]).toEqual(referenceMaterial);
        expect(materials[4]).toEqual(referenceMaterial);
        expect(materials[5]).toEqual(referenceMaterialNoTextures);
        expect(materials[6]).toEqual(defaultMaterial);
        expect(materials[7]).toEqual(defaultMaterial);
        expect(materials[8]).toEqual(defaultMaterial);

        // Test that primitives without uvs reference materials without textures
        const meshesLength = meshes.length;
        for (let i = 0; i < meshesLength; ++i) {
            const mesh = meshes[i];
            const primitives = mesh.primitives;
            const primitivesLength = primitives.length;
            for (let j = 0; j < primitivesLength; ++j) {
                const primitive = primitives[j];
                const material = materials[primitive.material];
                if (!defined(primitive.attributes.TEXCOORD_0)) {
                    expect(material.pbrMetallicRoughness.baseColorTexture).toBeUndefined();
                }
            }
        }
    });

    function expandObjData(objData, duplicatesLength) {
        const primitive = objData.nodes[0].meshes[0].primitives[0];
        const indices = primitive.indices;
        const positions = primitive.positions;
        const normals = primitive.normals;
        const uvs = primitive.uvs;

        const indicesLength = indices.length;
        const vertexCount = positions.length / 3;

        for (let i = 1; i < duplicatesLength; ++i) {
            for (let j = 0; j < vertexCount; ++j) {
                positions.push(0.0);
                positions.push(0.0);
                positions.push(0.0);
                normals.push(0.0);
                normals.push(0.0);
                normals.push(0.0);
                uvs.push(0.0);
                uvs.push(0.0);
            }
            for (let k = 0; k < indicesLength; ++k) {
                indices.push(indices.get(k) + vertexCount * i);
            }
        }
    }

    it('detects need to use uint32 indices', () => {
        expandObjData(boxObjData, 2731); // Right above 65536 limit
        let primitive = boxObjData.nodes[0].meshes[0].primitives[0];
        const indicesLength = primitive.indices.length;
        const vertexCount = primitive.positions.length / 3;

        const gltf = createGltf(boxObjData, options);
        primitive = gltf.meshes[0].primitives[0];
        const indicesAccessor = gltf.accessors[primitive.indices];
        expect(indicesAccessor.count).toBe(indicesLength);
        expect(indicesAccessor.max[0]).toBe(vertexCount - 1);
        expect(indicesAccessor.componentType).toBe(WebGLConstants.UNSIGNED_INT);

        const positionAccessor = gltf.accessors[primitive.attributes.POSITION];
        expect(positionAccessor.count).toBe(vertexCount);
    });
});