11067635867

Committed 27 Sep 2024 08:55AM UTC coverage: 86.96% (+0.003%) from 86.957%

Build # 11067635867

Build Type

Pull #2415

github

Committed by

web-flow

Commit Message

Merge 42cf51a77 into 1d9ffe994

Pull Request Pull Request #2415: Migration to 3D Tiles renderer followup

Run Details

2800 of 3702 branches covered (75.63%)

Branch coverage included in aggregate %.

28 of 30 new or added lines in 3 files covered. (93.33%)

51 existing lines in 1 file now uncovered.

24242 of 27395 relevant lines covered (88.49%)

1027.84 hits per line

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

75.62

/src/Layer/OGC3DTilesLayer.js

import * as THREE from 'three';
import {
    TilesRenderer,
    GLTFStructuralMetadataExtension,
    GLTFMeshFeaturesExtension,
    GLTFCesiumRTCExtension,
    CesiumIonAuthPlugin,
    GoogleCloudAuthPlugin,
    ImplicitTilingPlugin,
} from '3d-tiles-renderer';

import GeometryLayer from 'Layer/GeometryLayer';
import iGLTFLoader from 'Parser/iGLTFLoader';
import { DRACOLoader } from 'ThreeExtended/loaders/DRACOLoader';
import { KTX2Loader } from 'ThreeExtended/loaders/KTX2Loader';
import ReferLayerProperties from 'Layer/ReferencingLayerProperties';
import PointsMaterial, {
    PNTS_MODE,
    PNTS_SHAPE,
    PNTS_SIZE_MODE,
    ClassificationScheme,
} from 'Renderer/PointsMaterial';

const _raycaster = new THREE.Raycaster();

// Internal instance of GLTFLoader, passed to 3d-tiles-renderer-js to support GLTF 1.0 and 2.0
// Temporary exported to be used in deprecated B3dmParser
export const itownsGLTFLoader = new iGLTFLoader();
itownsGLTFLoader.register(() => new GLTFMeshFeaturesExtension());
itownsGLTFLoader.register(() => new GLTFStructuralMetadataExtension());
itownsGLTFLoader.register(() => new GLTFCesiumRTCExtension());

// Instantiated by the first tileset. Used to share cache and download and parse queues between tilesets
let lruCache = null;
let downloadQueue = null;
let parseQueue = null;

export const OGC3DTILES_LAYER_EVENTS = {
    /**
     * Fired when a new root or child tile set is loaded
     * @event OGC3DTilesLayer#load-tile-set
     * @type {Object}
     * @property {Object} tileset - the tileset json parsed in an Object
     * @property {String} url - tileset url
     */
    LOAD_TILE_SET: 'load-tile-set',
    /**
     * Fired when a tile model is loaded
     * @event OGC3DTilesLayer#load-model
     * @type {Object}
     * @property {THREE.Group} scene - the model (tile content) parsed in a THREE.GROUP
     * @property {Object} tile - the tile metadata from the tileset
     */
    LOAD_MODEL: 'load-model',
    /**
     * Fired when a tile model is disposed
     * @event OGC3DTilesLayer#dispose-model
     * @type {Object}
     * @property {THREE.Group} scene - the model (tile content) that is disposed
     * @property {Object} tile - the tile metadata from the tileset
     */
    DISPOSE_MODEL: 'dispose-model',
    /**
     * Fired when a tiles visibility changes
     * @event OGC3DTilesLayer#tile-visibility-change
     * @type {Object}
     * @property {THREE.Group} scene - the model (tile content) parsed in a THREE.GROUP
     * @property {Object} tile - the tile metadata from the tileset
     * @property {boolean} visible - the tile visible state
     */
    TILE_VISIBILITY_CHANGE: 'tile-visibility-change',
};

/**
 * Enable loading 3D Tiles with [Draco](https://google.github.io/draco/) geometry extension.
 *
 * @param {String} path path to draco library folder containing the JS and WASM decoder libraries. They can be found in
 * [itowns examples](https://github.com/iTowns/itowns/tree/master/examples/libs/draco).
 * @param {Object} [config] optional configuration for Draco decoder (see threejs'
 * [setDecoderConfig](https://threejs.org/docs/index.html?q=draco#examples/en/loaders/DRACOLoader.setDecoderConfig) that
 * is called under the hood with this configuration for details.
 */
export function enableDracoLoader(path, config) {
    if (!path) {
        throw new Error('Path to draco folder is mandatory');
    }
    const dracoLoader = new DRACOLoader();
    dracoLoader.setDecoderPath(path);
    if (config) {
        dracoLoader.setDecoderConfig(config);
    }
    itownsGLTFLoader.setDRACOLoader(dracoLoader);
}

/**
 * Enable loading 3D Tiles with [KTX2](https://www.khronos.org/ktx/) texture extension.
 *
 * @param {String} path path to ktx2 library folder containing the JS and WASM decoder libraries. They can be found in
 * [itowns examples](https://github.com/iTowns/itowns/tree/master/examples/libs/basis).
 * @param {THREE.WebGLRenderer} renderer the threejs renderer
 */
export function enableKtx2Loader(path, renderer) {
    if (!path || !renderer) {
        throw new Error('Path to ktx2 folder and renderer are mandatory');
    }
    const ktx2Loader = new KTX2Loader();
    ktx2Loader.setTranscoderPath(path);
    ktx2Loader.detectSupport(renderer);
    itownsGLTFLoader.setKTX2Loader(ktx2Loader);
}

class OGC3DTilesLayer extends GeometryLayer {
    /**
     * Layer for [3D Tiles](https://www.ogc.org/standard/3dtiles/) datasets.
     *
     * Advanced configuration note: 3D Tiles rendering is delegated to 3DTilesRendererJS that exposes several
     * configuration options accessible through the tilesRenderer property of this class. see the
     * [3DTilesRendererJS doc](https://github.com/NASA-AMMOS/3DTilesRendererJS/blob/master/README.md). Also note that
     * the cache is shared amongst 3D tiles layers and can be configured through tilesRenderer.lruCache (see the
     * [following documentation](https://github.com/NASA-AMMOS/3DTilesRendererJS/blob/master/README.md#lrucache-1).
     *
     * @extends Layer
     *
     * @param {String} id - unique layer id.
     * @param {Object} config - layer specific configuration
     * @param {OGC3DTilesSource} config.source - data source configuration
     * @param {String} [config.pntsMode= PNTS_MODE.COLOR] Point cloud coloring mode (passed to {@link PointsMaterial}).
     *      Only 'COLOR' or 'CLASSIFICATION' are possible. COLOR uses RGB colors of the points,
     *      CLASSIFICATION uses a classification property of the batch table to color points.
     * @param {ClassificationScheme}  [config.classificationScheme]  {@link PointsMaterial} classification scheme
     * @param {String} [config.pntsShape= PNTS_SHAPE.CIRCLE] Point cloud point shape. Only 'CIRCLE' or 'SQUARE' are possible.
     * (passed to {@link PointsMaterial}).
     * @param {String} [config.pntsSizeMode= PNTS_SIZE_MODE.VALUE] {@link PointsMaterial} Point cloud size mode (passed to {@link PointsMaterial}).
     * Only 'VALUE' or 'ATTENUATED' are possible. VALUE use constant size, ATTENUATED compute size depending on distance
     * from point to camera.
     * @param {Number} [config.pntsMinAttenuatedSize=3] Minimum scale used by 'ATTENUATED' size mode.
     * @param {Number} [config.pntsMaxAttenuatedSize=10] Maximum scale used by 'ATTENUATED' size mode.
     */
    constructor(id, config) {
        super(id, new THREE.Group(), { source: config.source });
        this.isOGC3DTilesLayer = true;

        this._handlePointsMaterialConfig(config);

        this.tilesRenderer = new TilesRenderer(this.source.url);
        if (config.source.isOGC3DTilesIonSource) {
            this.tilesRenderer.registerPlugin(new CesiumIonAuthPlugin({
                apiToken: config.source.accessToken,
                assetId: config.source.assetId,
            }));
        } else if (config.source.isOGC3DTilesGoogleSource) {
            this.tilesRenderer.registerPlugin(new GoogleCloudAuthPlugin({
                apiToken: config.source.key,
            }));
        }
        this.tilesRenderer.registerPlugin(new ImplicitTilingPlugin());

        this.tilesRenderer.manager.addHandler(/\.gltf$/, itownsGLTFLoader);

        this._setupCacheAndQueues();
        this._setupEvents();

        this.object3d.add(this.tilesRenderer.group);

        // Add an initialization step that is resolved when the root tileset is loaded (see this._setup below), meaning
        // that the layer will be marked ready when the tileset has been loaded.
        this._res = this.addInitializationStep();

        /**
         * @type {number}
         */
        this.sseThreshold = this.tilesRenderer.errorTarget;
        Object.defineProperty(this, 'sseThreshold', {
            get() { return this.tilesRenderer.errorTarget; },
            set(value) { this.tilesRenderer.errorTarget = value; },
        });

        if (config.sseThreshold) {
            this.sseThreshold = config.sseThreshold;
        }
    }

    /**
     * Store points material config so they can be used later to substitute points tiles material by our own PointsMaterial
     * These properties should eventually be managed through the Style API (see https://github.com/iTowns/itowns/issues/2336)
     * @param {Object} config - points material configuration as passed to the layer constructor.
     * @private
     */
    _handlePointsMaterialConfig(config) {
        this.pntsMode = config.pntsMode ?? PNTS_MODE.COLOR;
        this.pntsShape = config.pntsShape ?? PNTS_SHAPE.CIRCLE;
        this.classification = config.classification ?? ClassificationScheme.DEFAULT;
        this.pntsSizeMode = config.pntsSizeMode ?? PNTS_SIZE_MODE.VALUE;
        this.pntsMinAttenuatedSize = config.pntsMinAttenuatedSize || 3;
        this.pntsMaxAttenuatedSize = config.pntsMaxAttenuatedSize || 10;
    }

    /**
     * Sets the lruCache and download and parse queues so they are shared amongst all tilesets.
     * @private
     */
    _setupCacheAndQueues() {
        if (lruCache === null) {
            lruCache = this.tilesRenderer.lruCache;
        } else {
            this.tilesRenderer.lruCache = lruCache;
        }
        if (downloadQueue === null) {
            downloadQueue = this.tilesRenderer.downloadQueue;
        } else {
            this.tilesRenderer.downloadQueue = downloadQueue;
        }
        if (parseQueue === null) {
            parseQueue = this.tilesRenderer.parseQueue;
        } else {
            this.tilesRenderer.parseQueue = parseQueue;
        }
    }

    /**
     * Binds 3d-tiles-renderer events to this layer.
     * @private
     */
    _setupEvents() {
        for (const ev of Object.values(OGC3DTILES_LAYER_EVENTS)) {
            this.tilesRenderer.addEventListener(ev, (e) => {
                this.dispatchEvent(e);
            });
        }
    }

    /**
     * Setup 3D tiles renderer js TilesRenderer with the camera, binds events and start updating. Executed when the
     * layer has been added to the view.
     * @param {View} view - the view the layer has been added to.
     * @private
     */
    _setup(view) {
        this.tilesRenderer.setCamera(view.camera3D);
        this.tilesRenderer.setResolutionFromRenderer(view.camera3D, view.renderer);
        // Setup whenReady to be fullfiled when the root tileset has been loaded
        let rootTilesetLoaded = false;
        this.tilesRenderer.addEventListener('load-tile-set', () => {
            view.notifyChange(this);
            if (!rootTilesetLoaded) {
                rootTilesetLoaded = true;
                this._res();
            }
        });
        this.tilesRenderer.addEventListener('load-model', ({ scene }) => {
            scene.traverse((obj) => {
                this._assignFinalMaterial(obj);
                this._assignFinalAttributes(obj);
            });
            view.notifyChange(this);
        });
        // Start loading tileset and tiles
        this.tilesRenderer.update();
    }

    /**
     * Replace materials from GLTFLoader by our own custom materials. Note that
     * the replaced materials are not compiled yet and will be disposed by the
     * GC.
     * @param {Object3D} model
     * @private
     */
    _assignFinalMaterial(model) {
        let material = model.material;

        if (model.isPoints) {
            const pointsMaterial = new PointsMaterial({
                mode: this.pntsMode,
                shape: this.pntsShape,
                classificationScheme: this.classification,
                sizeMode: this.pntsSizeMode,
                minAttenuatedSize: this.pntsMinAttenuatedSize,
                maxAttenuatedSize: this.pntsMaxAttenuatedSize,
            });
            pointsMaterial.copy(material);

            material = pointsMaterial;
        }

        if (material) {
            ReferLayerProperties(material, this);
        }

        model.material = material;
    }

    /**
     * @param {Object3D} model
     * @private
     */
    _assignFinalAttributes(model) {
        const geometry = model.geometry;
        const batchTable = model.batchTable;

        // Setup classification bufferAttribute
        if (model.isPoints) {
            const classificationData = batchTable?.getData('Classification');
            if (classificationData) {
                geometry.setAttribute('classification',
                    new THREE.BufferAttribute(classificationData, 1),
                );
            }
        }
    }

    preUpdate(context) {
        this.scale = context.camera._preSSE;
        this.tilesRenderer.update();
        return null; // don't return any element because 3d-tiles-renderer already updates them
    }

    update() {
        // empty, elements are updated by 3d-tiles-renderer
    }

    /**
     * Deletes the layer and frees associated memory
     */
    delete() {
        this.tilesRenderer.dispose();
    }

    /**
     * Get the attributes for the closest intersection from a list of
     * intersects.
     * @param {Array} intersects -  An array containing all
     * objects picked under mouse coordinates computed with view.pickObjectsAt(..).
     * @returns {Object | null} - An object containing
     */
    getC3DTileFeatureFromIntersectsArray(intersects) {
        if (!intersects.length) { return null; }

        const { face, index, object } = intersects[0];

        /** @type{number|null} */
        let batchId;
        if (object.isPoints && index) {
            batchId = object.geometry.getAttribute('_BATCHID')?.getX(index) ?? index;
        } else if (object.isMesh && face) {
            batchId = object.geometry.getAttribute('_BATCHID')?.getX(face.a);
        }

        if (batchId === undefined) {
            return null;
        }

        let tileObject = object;
        while (!tileObject.batchTable) {
            tileObject = tileObject.parent;
        }

        return tileObject.batchTable.getDataFromId(batchId);
    }

    /**
     * Get all 3D objects (mesh and points primitives) as intersects at the
     * given non-normalized screen coordinates.
     * @param {View} view - The view instance.
     * @param {THREE.Vector2} coords - The coordinates to pick in the view. It
     * should have at least `x` and `y` properties.
     * @param {number} radius - Radius of the picking circle.
     * @param {Array} [target=[]] - Target array to push results too
     * @returns {Array} Array containing all target objects picked under the
     * specified coordinates.
     */
    pickObjectsAt(view, coords, radius, target = []) {
        const camera = view.camera.camera3D;
        _raycaster.setFromCamera(view.viewToNormalizedCoords(coords), camera);
        _raycaster.near = camera.near;
        _raycaster.far = camera.far;

        _raycaster.firstHitOnly = true;
        _raycaster.intersectObject(this.tilesRenderer.group, true, target);

        return target;
    }

    // eslint-disable-next-line no-unused-vars
    attach(layer) {
        console.warn('[OGC3DTilesLayer]: Attaching / detaching layers is not yet implemented for OGC3DTilesLayer.');
    }

    // eslint-disable-next-line no-unused-vars
    detach(layer) {
        console.warn('[OGC3DTilesLayer]: Attaching / detaching layers is not yet implemented for OGC3DTilesLayer.');
        return true;
    }

    // eslint-disable-next-line no-unused-vars
    getObjectToUpdateForAttachedLayers(obj) {
        return null;
    }

    /**
     * Executes a callback for each tile of this layer tileset.
     *
     * @param {Function} callback The callback to execute for each tile. Has the following two parameters:
     *  1. tile (Object) - the JSON tile
     *  2. scene (THREE.Object3D | null) - The tile content. Contains a `batchTable` property. Can be null if the tile
     *  has not yet been loaded.
    */
    forEachTile(callback) {
        this.tilesRenderer.traverse((tile) => {
            callback(tile, tile.cached.scene);
        });
    }
}

export default OGC3DTilesLayer;

1	import * as THREE from 'three';	1✔
2	import {	1✔
3	TilesRenderer,	1✔
4	GLTFStructuralMetadataExtension,	1✔
5	GLTFMeshFeaturesExtension,	1✔
6	GLTFCesiumRTCExtension,	1✔
7	CesiumIonAuthPlugin,	1✔
8	GoogleCloudAuthPlugin,	1✔
9	ImplicitTilingPlugin,	1✔
10	} from '3d-tiles-renderer';	1✔
11		1✔
12	import GeometryLayer from 'Layer/GeometryLayer';	1✔
13	import iGLTFLoader from 'Parser/iGLTFLoader';	1✔
14	import { DRACOLoader } from 'ThreeExtended/loaders/DRACOLoader';	1✔
15	import { KTX2Loader } from 'ThreeExtended/loaders/KTX2Loader';	1✔
16	import ReferLayerProperties from 'Layer/ReferencingLayerProperties';	1✔
17	import PointsMaterial, {	1✔
18	PNTS_MODE,	1✔
19	PNTS_SHAPE,	1✔
20	PNTS_SIZE_MODE,	1✔
21	ClassificationScheme,	1✔
22	} from 'Renderer/PointsMaterial';	1✔
23		1✔
24	const _raycaster = new THREE.Raycaster();	1✔
25		1✔
26	// Internal instance of GLTFLoader, passed to 3d-tiles-renderer-js to support GLTF 1.0 and 2.0	1✔
27	// Temporary exported to be used in deprecated B3dmParser	1✔
28	export const itownsGLTFLoader = new iGLTFLoader();	1✔
29	itownsGLTFLoader.register(() => new GLTFMeshFeaturesExtension());	1✔
30	itownsGLTFLoader.register(() => new GLTFStructuralMetadataExtension());	1✔
31	itownsGLTFLoader.register(() => new GLTFCesiumRTCExtension());	1✔
32		1✔
33	// Instantiated by the first tileset. Used to share cache and download and parse queues between tilesets	1✔
34	let lruCache = null;	1✔
35	let downloadQueue = null;	1✔
36	let parseQueue = null;	1✔
37		1✔
38	export const OGC3DTILES_LAYER_EVENTS = {	1✔
39	/**	1✔
40	* Fired when a new root or child tile set is loaded	1✔
41	* @event OGC3DTilesLayer#load-tile-set	1✔
42	* @type {Object}	1✔
43	* @property {Object} tileset - the tileset json parsed in an Object	1✔
44	* @property {String} url - tileset url	1✔
45	*/	1✔
46	LOAD_TILE_SET: 'load-tile-set',	1✔
47	/**	1✔
48	* Fired when a tile model is loaded	1✔
49	* @event OGC3DTilesLayer#load-model	1✔
50	* @type {Object}	1✔
51	* @property {THREE.Group} scene - the model (tile content) parsed in a THREE.GROUP	1✔
52	* @property {Object} tile - the tile metadata from the tileset	1✔
53	*/	1✔
54	LOAD_MODEL: 'load-model',	1✔
55	/**	1✔
56	* Fired when a tile model is disposed	1✔
57	* @event OGC3DTilesLayer#dispose-model	1✔
58	* @type {Object}	1✔
59	* @property {THREE.Group} scene - the model (tile content) that is disposed	1✔
60	* @property {Object} tile - the tile metadata from the tileset	1✔
61	*/	1✔
62	DISPOSE_MODEL: 'dispose-model',	1✔
63	/**	1✔
64	* Fired when a tiles visibility changes	1✔
65	* @event OGC3DTilesLayer#tile-visibility-change	1✔
66	* @type {Object}	1✔
67	* @property {THREE.Group} scene - the model (tile content) parsed in a THREE.GROUP	1✔
68	* @property {Object} tile - the tile metadata from the tileset	1✔
69	* @property {boolean} visible - the tile visible state	1✔
70	*/	1✔
71	TILE_VISIBILITY_CHANGE: 'tile-visibility-change',	1✔
72	};	1✔
73		1✔
74	/**	1✔
75	* Enable loading 3D Tiles with [Draco](https://google.github.io/draco/) geometry extension.	1✔
76	*	1✔
77	* @param {String} path path to draco library folder containing the JS and WASM decoder libraries. They can be found in	1✔
78	* [itowns examples](https://github.com/iTowns/itowns/tree/master/examples/libs/draco).	1✔
79	* @param {Object} [config] optional configuration for Draco decoder (see threejs'	1✔
80	* [setDecoderConfig](https://threejs.org/docs/index.html?q=draco#examples/en/loaders/DRACOLoader.setDecoderConfig) that	1✔
81	* is called under the hood with this configuration for details.	1✔
82	*/	1✔
83	export function enableDracoLoader(path, config) {	1✔
84	if (!path) {	3✔
85	throw new Error('Path to draco folder is mandatory');	1✔
86	}	1✔
87	const dracoLoader = new DRACOLoader();	2✔
88	dracoLoader.setDecoderPath(path);	2✔
89	if (config) {	3✔
90	dracoLoader.setDecoderConfig(config);	1✔
91	}	1✔
92	itownsGLTFLoader.setDRACOLoader(dracoLoader);	2✔
93	}	2✔
94		1✔
95	/**	1✔
96	* Enable loading 3D Tiles with [KTX2](https://www.khronos.org/ktx/) texture extension.	1✔
97	*	1✔
98	* @param {String} path path to ktx2 library folder containing the JS and WASM decoder libraries. They can be found in	1✔
99	* [itowns examples](https://github.com/iTowns/itowns/tree/master/examples/libs/basis).	1✔
100	* @param {THREE.WebGLRenderer} renderer the threejs renderer	1✔
101	*/	1✔
102	export function enableKtx2Loader(path, renderer) {	1✔
103	if (!path \|\| !renderer) {	3✔
104	throw new Error('Path to ktx2 folder and renderer are mandatory');	2✔
105	}	2✔
106	const ktx2Loader = new KTX2Loader();	1✔
107	ktx2Loader.setTranscoderPath(path);	1✔
108	ktx2Loader.detectSupport(renderer);	1✔
109	itownsGLTFLoader.setKTX2Loader(ktx2Loader);	1✔
110	}	1✔
111		1✔
112	class OGC3DTilesLayer extends GeometryLayer {	1✔
113	/**	1✔
114	* Layer for [3D Tiles](https://www.ogc.org/standard/3dtiles/) datasets.	1✔
115	*	1✔
116	* Advanced configuration note: 3D Tiles rendering is delegated to 3DTilesRendererJS that exposes several	1✔
117	* configuration options accessible through the tilesRenderer property of this class. see the	1✔
118	* [3DTilesRendererJS doc](https://github.com/NASA-AMMOS/3DTilesRendererJS/blob/master/README.md). Also note that	1✔
119	* the cache is shared amongst 3D tiles layers and can be configured through tilesRenderer.lruCache (see the	1✔
120	* [following documentation](https://github.com/NASA-AMMOS/3DTilesRendererJS/blob/master/README.md#lrucache-1).	1✔
121	*	1✔
122	* @extends Layer	1✔
123	*	1✔
124	* @param {String} id - unique layer id.	1✔
125	* @param {Object} config - layer specific configuration	1✔
126	* @param {OGC3DTilesSource} config.source - data source configuration	1✔
127	* @param {String} [config.pntsMode= PNTS_MODE.COLOR] Point cloud coloring mode (passed to {@link PointsMaterial}).	1✔
128	* Only 'COLOR' or 'CLASSIFICATION' are possible. COLOR uses RGB colors of the points,	1✔
129	* CLASSIFICATION uses a classification property of the batch table to color points.	1✔
130	* @param {ClassificationScheme} [config.classificationScheme] {@link PointsMaterial} classification scheme	1✔
131	* @param {String} [config.pntsShape= PNTS_SHAPE.CIRCLE] Point cloud point shape. Only 'CIRCLE' or 'SQUARE' are possible.	1✔
132	* (passed to {@link PointsMaterial}).	1✔
133	* @param {String} [config.pntsSizeMode= PNTS_SIZE_MODE.VALUE] {@link PointsMaterial} Point cloud size mode (passed to {@link PointsMaterial}).	1✔
134	* Only 'VALUE' or 'ATTENUATED' are possible. VALUE use constant size, ATTENUATED compute size depending on distance	1✔
135	* from point to camera.	1✔
136	* @param {Number} [config.pntsMinAttenuatedSize=3] Minimum scale used by 'ATTENUATED' size mode.	1✔
137	* @param {Number} [config.pntsMaxAttenuatedSize=10] Maximum scale used by 'ATTENUATED' size mode.	1✔
138	*/	1✔
139	constructor(id, config) {	1✔
140	super(id, new THREE.Group(), { source: config.source });	4✔
141	this.isOGC3DTilesLayer = true;	4✔
142		4✔
143	this._handlePointsMaterialConfig(config);	4✔
144		4✔
145	this.tilesRenderer = new TilesRenderer(this.source.url);	4✔
146	if (config.source.isOGC3DTilesIonSource) {	4✔
147	this.tilesRenderer.registerPlugin(new CesiumIonAuthPlugin({	1✔
148	apiToken: config.source.accessToken,	1✔
149	assetId: config.source.assetId,	1✔
150	}));	1✔
151	} else if (config.source.isOGC3DTilesGoogleSource) {	4✔
152	this.tilesRenderer.registerPlugin(new GoogleCloudAuthPlugin({	1✔
153	apiToken: config.source.key,	1✔
154	}));	1✔
155	}	1✔
156	this.tilesRenderer.registerPlugin(new ImplicitTilingPlugin());	4✔
157		4✔
158	this.tilesRenderer.manager.addHandler(/\.gltf$/, itownsGLTFLoader);	4✔
159		4✔
160	this._setupCacheAndQueues();	4✔
161	this._setupEvents();	4✔
162		4✔
163	this.object3d.add(this.tilesRenderer.group);	4✔
164		4✔
165	// Add an initialization step that is resolved when the root tileset is loaded (see this._setup below), meaning	4✔
166	// that the layer will be marked ready when the tileset has been loaded.	4✔
167	this._res = this.addInitializationStep();	4✔
168		4✔
169	/**	4✔
170	* @type {number}	4✔
171	*/	4✔
172	this.sseThreshold = this.tilesRenderer.errorTarget;	4✔
173	Object.defineProperty(this, 'sseThreshold', {	4✔
174	get() { return this.tilesRenderer.errorTarget; },	4✔
175	set(value) { this.tilesRenderer.errorTarget = value; },	4✔
176	});	4✔
177		4✔
178	if (config.sseThreshold) {	4✔
179	this.sseThreshold = config.sseThreshold;	1✔
180	}	1✔
181	}	4✔
182		1✔
183	/**	1✔
184	* Store points material config so they can be used later to substitute points tiles material by our own PointsMaterial	1✔
185	* These properties should eventually be managed through the Style API (see https://github.com/iTowns/itowns/issues/2336)	1✔
186	* @param {Object} config - points material configuration as passed to the layer constructor.	1✔
187	* @private	1✔
188	*/	1✔
189	_handlePointsMaterialConfig(config) {	1✔
190	this.pntsMode = config.pntsMode ?? PNTS_MODE.COLOR;	4✔
191	this.pntsShape = config.pntsShape ?? PNTS_SHAPE.CIRCLE;	4✔
192	this.classification = config.classification ?? ClassificationScheme.DEFAULT;	4✔
193	this.pntsSizeMode = config.pntsSizeMode ?? PNTS_SIZE_MODE.VALUE;	4✔
194	this.pntsMinAttenuatedSize = config.pntsMinAttenuatedSize \|\| 3;	4✔
195	this.pntsMaxAttenuatedSize = config.pntsMaxAttenuatedSize \|\| 10;	4✔
196	}	4✔
197		1✔
198	/**	1✔
199	* Sets the lruCache and download and parse queues so they are shared amongst all tilesets.	1✔
200	* @private	1✔
201	*/	1✔
202	_setupCacheAndQueues() {	1✔
203	if (lruCache === null) {	4✔
204	lruCache = this.tilesRenderer.lruCache;	1✔
205	} else {	4✔
206	this.tilesRenderer.lruCache = lruCache;	3✔
207	}	3✔
208	if (downloadQueue === null) {	4✔
209	downloadQueue = this.tilesRenderer.downloadQueue;	1✔
210	} else {	4✔
211	this.tilesRenderer.downloadQueue = downloadQueue;	3✔
212	}	3✔
213	if (parseQueue === null) {	4✔
214	parseQueue = this.tilesRenderer.parseQueue;	1✔
215	} else {	4✔
216	this.tilesRenderer.parseQueue = parseQueue;	3✔
217	}	3✔
218	}	4✔
219		1✔
220	/**	1✔
221	* Binds 3d-tiles-renderer events to this layer.	1✔
222	* @private	1✔
223	*/	1✔
224	_setupEvents() {	1✔
225	for (const ev of Object.values(OGC3DTILES_LAYER_EVENTS)) {	4✔
226	this.tilesRenderer.addEventListener(ev, (e) => {	16✔
UNCOV 227	this.dispatchEvent(e);	×
228	});	16✔
229	}	16✔
230	}	4✔
231		1✔
232	/**	1✔
233	* Setup 3D tiles renderer js TilesRenderer with the camera, binds events and start updating. Executed when the	1✔
234	* layer has been added to the view.	1✔
235	* @param {View} view - the view the layer has been added to.	1✔
236	* @private	1✔
237	*/	1✔
238	_setup(view) {	1✔
239	this.tilesRenderer.setCamera(view.camera3D);	×
UNCOV 240	this.tilesRenderer.setResolutionFromRenderer(view.camera3D, view.renderer);	×
UNCOV 241	// Setup whenReady to be fullfiled when the root tileset has been loaded	×
UNCOV 242	let rootTilesetLoaded = false;	×
UNCOV 243	this.tilesRenderer.addEventListener('load-tile-set', () => {	×
UNCOV 244	view.notifyChange(this);	×
UNCOV 245	if (!rootTilesetLoaded) {	×
UNCOV 246	rootTilesetLoaded = true;	×
UNCOV 247	this._res();	×
UNCOV 248	}	×
UNCOV 249	});	×
UNCOV 250	this.tilesRenderer.addEventListener('load-model', ({ scene }) => {	×
251	scene.traverse((obj) => {	×
252	this._assignFinalMaterial(obj);	×
253	this._assignFinalAttributes(obj);	×
254	});	×
255	view.notifyChange(this);	×
256	});	×
257	// Start loading tileset and tiles	×
258	this.tilesRenderer.update();	×
259	}	×
260		1✔
261	/**	1✔
262	* Replace materials from GLTFLoader by our own custom materials. Note that	1✔
263	* the replaced materials are not compiled yet and will be disposed by the	1✔
264	* GC.	1✔
265	* @param {Object3D} model	1✔
266	* @private	1✔
267	*/	1✔
268	_assignFinalMaterial(model) {	1✔
269	let material = model.material;	×
270		×
271	if (model.isPoints) {	×
UNCOV 272	const pointsMaterial = new PointsMaterial({	×
UNCOV 273	mode: this.pntsMode,	×
UNCOV 274	shape: this.pntsShape,	×
UNCOV 275	classificationScheme: this.classification,	×
UNCOV 276	sizeMode: this.pntsSizeMode,	×
UNCOV 277	minAttenuatedSize: this.pntsMinAttenuatedSize,	×
UNCOV 278	maxAttenuatedSize: this.pntsMaxAttenuatedSize,	×
UNCOV 279	});	×
UNCOV 280	pointsMaterial.copy(material);	×
281		×
282	material = pointsMaterial;	×
283	}	×
284		×
285	if (material) {	×
286	ReferLayerProperties(material, this);	×
287	}	×
288		×
289	model.material = material;	×
290	}	×
291		1✔
292	/**	1✔
293	* @param {Object3D} model	1✔
294	* @private	1✔
295	*/	1✔
296	_assignFinalAttributes(model) {	1✔
297	const geometry = model.geometry;	×
298	const batchTable = model.batchTable;	×
299		×
300	// Setup classification bufferAttribute	×
301	if (model.isPoints) {	×
302	const classificationData = batchTable?.getData('Classification');	×
UNCOV 303	if (classificationData) {	×
UNCOV 304	geometry.setAttribute('classification',	×
UNCOV 305	new THREE.BufferAttribute(classificationData, 1),	×
UNCOV 306	);	×
UNCOV 307	}	×
UNCOV 308	}	×
309	}	×
310		1✔
311	preUpdate(context) {	1✔
312	this.scale = context.camera._preSSE;	×
313	this.tilesRenderer.update();	×
314	return null; // don't return any element because 3d-tiles-renderer already updates them	×
315	}	×
316		1✔
317	update() {	1✔
318	// empty, elements are updated by 3d-tiles-renderer	×
319	}	1✔
320		1✔
321	/**	1✔
322	* Deletes the layer and frees associated memory	1✔
323	*/	1✔
324	delete() {	1✔
325	this.tilesRenderer.dispose();	×
326	}	×
327		1✔
328	/**	1✔
329	* Get the attributes for the closest intersection from a list of	1✔
330	* intersects.	1✔
331	* @param {Array} intersects - An array containing all	1✔
332	* objects picked under mouse coordinates computed with view.pickObjectsAt(..).	1✔
333	* @returns {Object \| null} - An object containing	1✔
334	*/	1✔
335	getC3DTileFeatureFromIntersectsArray(intersects) {	1✔
UNCOV 336	if (!intersects.length) { return null; }	×
337		×
338	const { face, index, object } = intersects[0];	×
UNCOV 339		×
UNCOV 340	/** @type{number\|null} */	×
UNCOV 341	let batchId;	×
UNCOV 342	if (object.isPoints && index) {	×
UNCOV 343	batchId = object.geometry.getAttribute('_BATCHID')?.getX(index) ?? index;	×
UNCOV 344	} else if (object.isMesh && face) {	×
UNCOV 345	batchId = object.geometry.getAttribute('_BATCHID')?.getX(face.a);	×
UNCOV 346	}	×
UNCOV 347		×
348	if (batchId === undefined) {	×
349	return null;	×
350	}	×
351		×
352	let tileObject = object;	×
353	while (!tileObject.batchTable) {	×
354	tileObject = tileObject.parent;	×
355	}	×
356		×
357	return tileObject.batchTable.getDataFromId(batchId);	×
358	}	×
359		1✔
360	/**	1✔
361	* Get all 3D objects (mesh and points primitives) as intersects at the	1✔
362	* given non-normalized screen coordinates.	1✔
363	* @param {View} view - The view instance.	1✔
364	* @param {THREE.Vector2} coords - The coordinates to pick in the view. It	1✔
365	* should have at least `x` and `y` properties.	1✔
366	* @param {number} radius - Radius of the picking circle.	1✔
367	* @param {Array} [target=[]] - Target array to push results too	1✔
368	* @returns {Array} Array containing all target objects picked under the	1✔
369	* specified coordinates.	1✔
370	*/	1✔
371	pickObjectsAt(view, coords, radius, target = []) {	1✔
UNCOV 372	const camera = view.camera.camera3D;	×
UNCOV 373	_raycaster.setFromCamera(view.viewToNormalizedCoords(coords), camera);	×
UNCOV 374	_raycaster.near = camera.near;	×
UNCOV 375	_raycaster.far = camera.far;	×
UNCOV 376		×
UNCOV 377	_raycaster.firstHitOnly = true;	×
UNCOV 378	_raycaster.intersectObject(this.tilesRenderer.group, true, target);	×
UNCOV 379		×
UNCOV 380	return target;	×
UNCOV 381	}	×
382		1✔
383	// eslint-disable-next-line no-unused-vars	1✔
384	attach(layer) {	1✔
385	console.warn('[OGC3DTilesLayer]: Attaching / detaching layers is not yet implemented for OGC3DTilesLayer.');	×
386	}	×
387		1✔
388	// eslint-disable-next-line no-unused-vars	1✔
389	detach(layer) {	1✔
390	console.warn('[OGC3DTilesLayer]: Attaching / detaching layers is not yet implemented for OGC3DTilesLayer.');	×
391	return true;	×
NEW 392	}	×
393		1✔
394	// eslint-disable-next-line no-unused-vars	1✔
395	getObjectToUpdateForAttachedLayers(obj) {	1✔
NEW 396	return null;	×
UNCOV 397	}	×
398		1✔
399	/**	1✔
400	* Executes a callback for each tile of this layer tileset.	1✔
401	*	1✔
402	* @param {Function} callback The callback to execute for each tile. Has the following two parameters:	1✔
403	* 1. tile (Object) - the JSON tile	1✔
404	* 2. scene (THREE.Object3D \| null) - The tile content. Contains a `batchTable` property. Can be null if the tile	1✔
405	* has not yet been loaded.	1✔
406	*/	1✔
407	forEachTile(callback) {	1✔
408	this.tilesRenderer.traverse((tile) => {	×
UNCOV 409	callback(tile, tile.cached.scene);	×
UNCOV 410	});	×
UNCOV 411	}	×
412	}	1✔
413		1✔
414	export default OGC3DTilesLayer;	1✔

iTowns / itowns / 11067635867

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