Source: package/geometry/geometry_file.js

// import { GLTFLoader } from '../../../node_modules/three/build/three.module.js';
import { Reporter } from '../../reporter/reporter.js';
import { LoadableComponent } from '../component/loadable_component.js';
import { checkPropTypes, copyProps, UUIDRegex } from '../../lib.js';
import { LoadingBase } from '../loader/loading_base.js';
// import { GLTFLoader } from '../loader/gltf_loader.js';

// import { DRACOLoader } from '../loader/draco_loader.js';

import { GLTFLoader } from '../../../node_modules/three/examples/jsm/loaders/GLTFLoader.js';
import { DRACOLoader } from '../../../node_modules/three/examples/jsm/loaders/DRACOLoader.js';
// import { DracoDecoderModule } from '../../../node_modules/three/examples/js/libs/draco/draco_decoder.js';


// dit is heel annoying
// ik wil dit includen in de build, niet achteraf "bijladen"


const dracoLoader = new DRACOLoader();
dracoLoader.setDecoderPath('/test/draco/');
const gltfLoader = new GLTFLoader();
gltfLoader.setDRACOLoader(dracoLoader);

/**
 * Refers to loadable file that can hold one or more multiple geometries
 */

class GeometryFile extends LoadableComponent {

    /**
     * @param {Reporter} reporter
     * @param {Object} settings
     * @param {UUID} [settings.id]
     * @param {string} [settings.name]
     * @param {QualitySourceMap} settings.source
     * @param {Array<string>} settings.geometryNames
     */

    constructor(reporter, settings) {

        super(reporter, settings);

        checkPropTypes(
            settings,
            {
                geometryNames: val => Array.isArray(val) && val.every(name => typeof (name) === 'string'),
            },
            {}
        );

        // this.exportName = 'geometryFiles';
    }

    static _exportName = {
        singular: 'geometryFile',
        plural: 'geometryFiles'
    };

    /**
     * @param {LoadingBase} base
     * @param {LoadingQuality} quality 
     */

    async _load(base, quality) {

        const component = this;

        const fileURL = new URL(base.url.href + this._settings.source[quality].path);

        this.report({ msg: `Loading image from ${fileURL}` })

        return new Promise((resolve, reject) => {

            gltfLoader.load(

                fileURL.href,

                // onLoad callback
                function (file) {
                    const geometries = {};

                    for (let geometryName of component._settings.geometryNames) {

                        //deze aanpassen zodat de mesh wordt binnengehaald
                        const obj = file.scene.getObjectByName(geometryName, true);

                        if (!obj) {
                            throw new Error(`Missing specified geometry "${geometryName}" in geometry file at ${fileURL}`);
                        }

                        geometries[geometryName] = obj.geometry 
                    }

                    resolve({ file, geometries });
                    
                    // component._setContent('main', quality, { file, geometries })
                    //     .then( _ => resolve(component));
                },

                // onProgress callback currently not supported
                undefined,

                // onError callback
                function (error) {
                    reject(error);
                }
            );
        });
    }
}

export { GeometryFile };