11288745256

Committed 11 Oct 2024 08:10AM UTC coverage: 86.87% (-0.08%) from 86.948%

Build # 11288745256

Build Type

Pull #2435

github

Committed by

web-flow

Commit Message

Merge 9d41dfcee into a4f0d2284

Pull Request Pull Request #2435: fix(OGC3DTilesLayer): handle multiple views

Run Details

2790 of 3703 branches covered (75.34%)

Branch coverage included in aggregate %.

9 of 24 new or added lines in 2 files covered. (37.5%)

8 existing lines in 1 file now uncovered.

24324 of 27509 relevant lines covered (88.42%)

1023.92 hits per line

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

69.18

/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();
const viewers = [];
// 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());

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.
     * @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=1] Minimum scale used by 'ATTENUATED' size mode.
     * @param {Number} [config.pntsMaxAttenuatedSize=7] 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,
                autoRefreshToken: true,
            }));
        } else if (config.source.isOGC3DTilesGoogleSource) {
            this.tilesRenderer.registerPlugin(new GoogleCloudAuthPlugin({
                apiToken: config.source.key,
                autoRefreshToken: true,
            }));
        }
        this.tilesRenderer.registerPlugin(new ImplicitTilingPlugin());

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

        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 || 1;
        this.pntsMaxAttenuatedSize = config.pntsMaxAttenuatedSize || 7;
    }


    /**
     * Sets the lruCache and download and parse queues so they are shared amongst all tilesets.
    * @param {String} id - viewer id.
    * @private
    */
    _setupCacheAndQueues(id) {
        if (viewers[id]) {
            this.tilesRenderer.lruCache = viewers[id].lruCache;
            this.tilesRenderer.downloadQueue = viewers[id].downloadQueue;
            this.tilesRenderer.parseQueue = viewers[id].parseQueue;
        } else {
            viewers[id] = {
                lruCache: this.tilesRenderer.lruCache,
                downloadQueue: this.tilesRenderer.downloadQueue,
                parseQueue: this.tilesRenderer.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);
        });


        this._setupCacheAndQueues(view.id);
        this._setupEvents();


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

iTowns / itowns / 11288745256

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