10319921367

Committed 09 Aug 2024 01:17PM UTC coverage: 85.39% (-4.4%) from 89.766%

Build # 10319921367

Build Type

Pull #2345

github

Committed by

web-flow

Commit Message

Merge 8a0888797 into d09120714

Pull Request Pull Request #2345: 3d tiles renderer js migration

Run Details

2854 of 3747 branches covered (76.17%)

Branch coverage included in aggregate %.

1116 of 2901 new or added lines in 8 files covered. (38.47%)

6 existing lines in 2 files now uncovered.

25737 of 29736 relevant lines covered (86.55%)

816.75 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

73.02

/src/Parser/iGLTFLoader.js

import * as THREE from 'three';
import LegacyGLTFLoader from 'Parser/LegacyGLTFLoader';
import { GLTFLoader } from 'ThreeExtended/loaders/GLTFLoader';

class iGLTFLoader extends THREE.Loader {
    /**
     * Parses [glTF](https://www.khronos.org/gltf/) 1.0 and 2.0 files.
     *
     * Under the hood, glTF 2.0 files are parsed with THREE.GLTFLoader and GLTF 1.0 are parsed with the previous THREE
     * GltfLoader (for 1.0 glTF) that has been kept and maintained in iTowns.
     *
     * Beware that gltf convention is y-up while itowns is z-up. You can apply a PI/2 rotation around the X axis to the
     * loaded model to transform from y-up to z-up. Note that you can also use Coordinates.geodesicNormal to get the normal
     * to a position on the globe (i.e. in GlobeView) to correctly orient a model on a GlobeView.
     *
     * @constructor
     * @param {THREE.LoadingManager} [manager] - The loadingManager for the loader to use. Default is THREE.DefaultLoadingManager.
     */
    constructor(manager) {
        super(manager);
        this.legacyGLTFLoader = new LegacyGLTFLoader();
        this.glTFLoader = new GLTFLoader();
    }

    /**
     * Loads a gltf model from url and call the callback function with the parsed response content.
     * Adapted from threejs.
     * @param {String} url - the path/URL of the .gltf or .glb file.
     * @param {Function} onLoad - A function to be called after the loading is successfully completed. The function
     * receives the loaded JSON response returned from {@link parse}.
     * @param {Function} onProgress
     * @param {Function} onError
     */
    load(url, onLoad, onProgress, onError) {
        const scope = this;

        let resourcePath;

        if (this.resourcePath !== '') {
            resourcePath = this.resourcePath;
        } else if (this.path !== '') {
            // If a base path is set, resources will be relative paths from that plus the relative path of the gltf file
            // Example  path = 'https://my-cnd-server.com/', url = 'assets/models/model.gltf'
            // resourcePath = 'https://my-cnd-server.com/assets/models/'
            // referenced resource 'model.bin' will be loaded from 'https://my-cnd-server.com/assets/models/model.bin'
            // referenced resource '../textures/texture.png' will be loaded from 'https://my-cnd-server.com/assets/textures/texture.png'
            const relativeUrl = THREE.LoaderUtils.extractUrlBase(url);
            resourcePath = THREE.LoaderUtils.resolveURL(relativeUrl, this.path);
        } else {
            resourcePath = THREE.LoaderUtils.extractUrlBase(url);
        }

        // Tells the LoadingManager to track an extra item, which resolves after
        // the model is fully loaded. This means the count of items loaded will
        // be incorrect, but ensures manager.onLoad() does not fire early.
        this.manager.itemStart(url);

        const _onError = (e) => {
            if (onError) {
                onError(e);
            } else {
                console.error(e);
            }

            scope.manager.itemError(url);
            scope.manager.itemEnd(url);
        };

        const loader = new THREE.FileLoader(this.manager);

        loader.setPath(this.path);
        loader.setResponseType('arraybuffer');
        loader.setRequestHeader(this.requestHeader);
        loader.setWithCredentials(this.withCredentials);

        loader.load(url, (data) => {
            try {
                scope.parse(data, resourcePath, (gltf) => {
                    onLoad(gltf);

                    scope.manager.itemEnd(url);
                }, _onError);
            } catch (e) {
                _onError(e);
            }
        }, onProgress, _onError);
    }

    /**
     * Sets the draco loader instance for this gltf parser. Enable loading files with
     * [Draco](https://google.github.io/draco/) geometry extension. See Threejs
     * [DracoLoader](https://threejs.org/docs/index.html#examples/en/loaders/DRACOLoader) for more information.
     * Only works for GLTF 2.0 files.
     * @param {THREE.DracoLoader} dracoLoader - the threejs DracoLoader instance.
     */
    setDRACOLoader(dracoLoader) {
        this.glTFLoader.setDRACOLoader(dracoLoader);
    }

    /**
     * Sets the KTX2 loader instance for this gltf parser. Enable loading files with
     * [KTX2](https://www.khronos.org/ktx/) texture extension. See Threejs
     * [KTX2Loader](https://threejs.org/docs/index.html?q=KTX2#examples/en/loaders/KTX2Loader) for more information.
     * Only works for GLTF 2.0 files.
     * @param {THREE.KTX2Loader} ktx2Loader - the threejs KTX2Loader instance.
     */
    setKTX2Loader(ktx2Loader) {
        this.glTFLoader.setKTX2Loader(ktx2Loader);
    }

    /**
     * Sets the Mesh Optimizer decoder instance for this gltf parser. Enable loading files with
     * [MeshOptimizer](https://meshoptimizer.org/) geometry extension.
     * Only works for GLTF 2.0 files.
     * @param {Object} meshoptDecoder - the threejs meshopt decoder instance.
     */
    setMeshoptDecoder(meshoptDecoder) {
        this.glTFLoader.setMeshoptDecoder(meshoptDecoder);
    }

    /**
     * Registers a callback to load specific unknown or not standard GLTF extensions.
     * See Threejs [GltfLoader](https://threejs.org/docs/?q=gltflo#examples/en/loaders/GLTFLoader) for more
     * information.
     * @param {Function} callback - the callback function
     */
    register(callback) {
        this.glTFLoader.register(callback);
    }

    /**
     * Unregisters a load callback.
     * See Threejs [GltfLoader](https://threejs.org/docs/?q=gltflo#examples/en/loaders/GLTFLoader) for more
     * information.
     * @param {Function} callback - the callback function
     */
    unregister(callback) {
        this.glTFLoader.unregister(callback);
    }

    /** Parse a glTF-based ArrayBuffer, JSON string or object and fire onLoad callback when complete.
     * Calls Threejs [GLTFLoader.parse](https://threejs.org/docs/?q=gltflo#examples/en/loaders/GLTFLoader.parse) for
     * glTF 2.0 files and LegacyGLTFLoader.parse for gtTF 1.0 files.
     * @param {ArrayBuffer|String|Object} buffer - the glTF asset to parse, as an ArrayBuffer, JSON string or object.
     * @param {String} path - the base path from which to find subsequent glTF resources such as textures and .bin data files.
     * @param {Function} onLoad — A function to be called when parse completes. The argument to the onLoad function will
     * be an Object that contains loaded parts: .scene, .scenes, .cameras, .animations, and .asset.
     * @param {Function} [onError] — A function to be called if an error occurs during parsing. The function receives error as an argument.
     */
    parse(buffer, path, onLoad, onError) {
        if (!buffer || !path) {
            console.error('[iGLTFLoader]: Buffer and path are mandatory to parse a glTF.');
        }

        const headerView = new DataView(buffer, 0, 20);
        const version = headerView.getUint32(4, true);

        if (version === 1) {
            this.legacyGLTFLoader.parse(buffer, path, onLoad, onError);
        } else {
            this.glTFLoader.parse(buffer, path, onLoad, onError);
        }
    }

    /**
     * Async promise-based parsing of a glTF-based ArrayBuffer, JSON string or object.
     * @param {ArrayBuffer|String|Object} data - the glTF asset to parse, as an ArrayBuffer, JSON string or object.
     * @param {String} path - the base path from which to find subsequent glTF resources such as textures and .bin data files.
     * @returns {Promise<Object>} A promise that resolves an Object that contains loaded parts:
     * .scene, .scenes, .cameras, .animations, and .asset, when parsing is done.
     */
    parseAsync(data, path) {
        const scope = this;

        return new Promise((resolve, reject) => {
            scope.parse(data, path, resolve, reject);
        });
    }
}

export default iGLTFLoader;

1	import * as THREE from 'three';	1✔
2	import LegacyGLTFLoader from 'Parser/LegacyGLTFLoader';	1✔
3	import { GLTFLoader } from 'ThreeExtended/loaders/GLTFLoader';	1✔
4		1✔
5	class iGLTFLoader extends THREE.Loader {	1✔
6	/**	1✔
7	* Parses [glTF](https://www.khronos.org/gltf/) 1.0 and 2.0 files.	1✔
8	*	1✔
9	* Under the hood, glTF 2.0 files are parsed with THREE.GLTFLoader and GLTF 1.0 are parsed with the previous THREE	1✔
10	* GltfLoader (for 1.0 glTF) that has been kept and maintained in iTowns.	1✔
11	*	1✔
12	* Beware that gltf convention is y-up while itowns is z-up. You can apply a PI/2 rotation around the X axis to the	1✔
13	* loaded model to transform from y-up to z-up. Note that you can also use Coordinates.geodesicNormal to get the normal	1✔
14	* to a position on the globe (i.e. in GlobeView) to correctly orient a model on a GlobeView.	1✔
15	*	1✔
16	* @constructor	1✔
17	* @param {THREE.LoadingManager} [manager] - The loadingManager for the loader to use. Default is THREE.DefaultLoadingManager.	1✔
18	*/	2✔
19	constructor(manager) {	2✔
20	super(manager);	2✔
21	this.legacyGLTFLoader = new LegacyGLTFLoader();	2✔
22	this.glTFLoader = new GLTFLoader();	1✔
23	}	1✔
24		1✔
25	/**	1✔
26	* Loads a gltf model from url and call the callback function with the parsed response content.	1✔
27	* Adapted from threejs.	1✔
28	* @param {String} url - the path/URL of the .gltf or .glb file.	1✔
29	* @param {Function} onLoad - A function to be called after the loading is successfully completed. The function	1✔
30	* receives the loaded JSON response returned from {@link parse}.	1✔
31	* @param {Function} onProgress	1✔
NEW 32	* @param {Function} onError	×
NEW 33	*/	×
NEW 34	load(url, onLoad, onProgress, onError) {	×
NEW 35	const scope = this;	×
NEW 36		×
NEW 37	let resourcePath;	×
NEW 38		×
NEW 39	if (this.resourcePath !== '') {	×
NEW 40	resourcePath = this.resourcePath;	×
NEW 41	} else if (this.path !== '') {	×
NEW 42	// If a base path is set, resources will be relative paths from that plus the relative path of the gltf file	×
NEW 43	// Example path = 'https://my-cnd-server.com/', url = 'assets/models/model.gltf'	×
NEW 44	// resourcePath = 'https://my-cnd-server.com/assets/models/'	×
NEW 45	// referenced resource 'model.bin' will be loaded from 'https://my-cnd-server.com/assets/models/model.bin'	×
NEW 46	// referenced resource '../textures/texture.png' will be loaded from 'https://my-cnd-server.com/assets/textures/texture.png'	×
NEW 47	const relativeUrl = THREE.LoaderUtils.extractUrlBase(url);	×
NEW 48	resourcePath = THREE.LoaderUtils.resolveURL(relativeUrl, this.path);	×
NEW 49	} else {	×
NEW 50	resourcePath = THREE.LoaderUtils.extractUrlBase(url);	×
NEW 51	}	×
NEW 52		×
NEW 53	// Tells the LoadingManager to track an extra item, which resolves after	×
NEW 54	// the model is fully loaded. This means the count of items loaded will	×
NEW 55	// be incorrect, but ensures manager.onLoad() does not fire early.	×
NEW 56	this.manager.itemStart(url);	×
NEW 57		×
NEW 58	const _onError = (e) => {	×
NEW 59	if (onError) {	×
NEW 60	onError(e);	×
NEW 61	} else {	×
NEW 62	console.error(e);	×
NEW 63	}	×
NEW 64		×
NEW 65	scope.manager.itemError(url);	×
NEW 66	scope.manager.itemEnd(url);	×
NEW 67	};	×
NEW 68		×
NEW 69	const loader = new THREE.FileLoader(this.manager);	×
NEW 70		×
NEW 71	loader.setPath(this.path);	×
NEW 72	loader.setResponseType('arraybuffer');	×
NEW 73	loader.setRequestHeader(this.requestHeader);	×
NEW 74	loader.setWithCredentials(this.withCredentials);	×
NEW 75		×
76	loader.load(url, (data) => {	1✔
77	try {	1✔
78	scope.parse(data, resourcePath, (gltf) => {	1✔
79	onLoad(gltf);	1✔
80		1✔
81	scope.manager.itemEnd(url);	1✔
82	}, _onError);	1✔
83	} catch (e) {	1✔
84	_onError(e);	1✔
85	}	1✔
86	}, onProgress, _onError);	1✔
87	}	1✔
88		1✔
89	/**	1✔
90	* Sets the draco loader instance for this gltf parser. Enable loading files with	1✔
91	* [Draco](https://google.github.io/draco/) geometry extension. See Threejs	1✔
92	* [DracoLoader](https://threejs.org/docs/index.html#examples/en/loaders/DRACOLoader) for more information.	1✔
93	* Only works for GLTF 2.0 files.	1✔
94	* @param {THREE.DracoLoader} dracoLoader - the threejs DracoLoader instance.	1✔
95	*/	1✔
96	setDRACOLoader(dracoLoader) {	1✔
97	this.glTFLoader.setDRACOLoader(dracoLoader);	1✔
98	}	1✔
99		1✔
100	/**	1✔
101	* Sets the KTX2 loader instance for this gltf parser. Enable loading files with	1✔
102	* [KTX2](https://www.khronos.org/ktx/) texture extension. See Threejs	1✔
103	* [KTX2Loader](https://threejs.org/docs/index.html?q=KTX2#examples/en/loaders/KTX2Loader) for more information.	1✔
104	* Only works for GLTF 2.0 files.	1✔
105	* @param {THREE.KTX2Loader} ktx2Loader - the threejs KTX2Loader instance.	1✔
106	*/	1✔
107	setKTX2Loader(ktx2Loader) {	1✔
NEW 108	this.glTFLoader.setKTX2Loader(ktx2Loader);	×
NEW 109	}	×
NEW 110		×
NEW 111	/**	×
112	* Sets the Mesh Optimizer decoder instance for this gltf parser. Enable loading files with	1✔
113	* [MeshOptimizer](https://meshoptimizer.org/) geometry extension.	1✔
114	* Only works for GLTF 2.0 files.	1✔
115	* @param {Object} meshoptDecoder - the threejs meshopt decoder instance.	1✔
116	*/	1✔
117	setMeshoptDecoder(meshoptDecoder) {	1✔
118	this.glTFLoader.setMeshoptDecoder(meshoptDecoder);	1✔
119	}	1✔
120		1✔
121	/**	1✔
122	* Registers a callback to load specific unknown or not standard GLTF extensions.	1✔
123	* See Threejs [GltfLoader](https://threejs.org/docs/?q=gltflo#examples/en/loaders/GLTFLoader) for more	1✔
NEW 124	* information.	×
125	* @param {Function} callback - the callback function	1✔
126	*/	1✔
127	register(callback) {	1✔
128	this.glTFLoader.register(callback);	1✔
129	}	1✔
130		1✔
131	/**	1✔
132	* Unregisters a load callback.	1✔
133	* See Threejs [GltfLoader](https://threejs.org/docs/?q=gltflo#examples/en/loaders/GLTFLoader) for more	1✔
134	* information.	1✔
135	* @param {Function} callback - the callback function	1✔
136	*/	1✔
137	unregister(callback) {	1✔
138	this.glTFLoader.unregister(callback);	1✔
139	}	1✔
140		1✔
141	/** Parse a glTF-based ArrayBuffer, JSON string or object and fire onLoad callback when complete.	1✔
142	* Calls Threejs [GLTFLoader.parse](https://threejs.org/docs/?q=gltflo#examples/en/loaders/GLTFLoader.parse) for	1✔
143	* glTF 2.0 files and LegacyGLTFLoader.parse for gtTF 1.0 files.	1✔
144	* @param {ArrayBuffer\|String\|Object} buffer - the glTF asset to parse, as an ArrayBuffer, JSON string or object.	1✔
145	* @param {String} path - the base path from which to find subsequent glTF resources such as textures and .bin data files.	1✔
146	* @param {Function} onLoad — A function to be called when parse completes. The argument to the onLoad function will	4!
147	* be an Object that contains loaded parts: .scene, .scenes, .cameras, .animations, and .asset.	4✔
148	* @param {Function} [onError] — A function to be called if an error occurs during parsing. The function receives error as an argument.	4!
149	*/	4✔
150	parse(buffer, path, onLoad, onError) {	1✔
151	if (!buffer \|\| !path) {	1✔
152	console.error('[iGLTFLoader]: Buffer and path are mandatory to parse a glTF.');	1✔
153	}	1✔
154		1✔
155	const headerView = new DataView(buffer, 0, 20);	1✔
156	const version = headerView.getUint32(4, true);	1✔
157		1✔
158	if (version === 1) {	1✔
159	this.legacyGLTFLoader.parse(buffer, path, onLoad, onError);	1✔
160	} else {	1✔
161	this.glTFLoader.parse(buffer, path, onLoad, onError);	1✔
162	}	1✔
163	}	1✔
164		1✔
165	/**	1✔
166	* Async promise-based parsing of a glTF-based ArrayBuffer, JSON string or object.	1✔
167	* @param {ArrayBuffer\|String\|Object} data - the glTF asset to parse, as an ArrayBuffer, JSON string or object.	1✔
168	* @param {String} path - the base path from which to find subsequent glTF resources such as textures and .bin data files.	1✔
169	* @returns {Promise<Object>} A promise that resolves an Object that contains loaded parts:	1✔
170	* .scene, .scenes, .cameras, .animations, and .asset, when parsing is done.	1✔
171	*/	1✔
172	parseAsync(data, path) {	1✔
173	const scope = this;	1✔
174		1✔
175	return new Promise((resolve, reject) => {	1✔
176	scope.parse(data, path, resolve, reject);	1✔
177	});	1✔
178	}	1✔
179	}	1✔
180		1✔
181	export default iGLTFLoader;	1✔

iTowns / itowns / 10319921367

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous