11179762037

Committed 04 Oct 2024 12:17PM UTC coverage: 86.947% (+0.003%) from 86.944%

Build # 11179762037

Build Type

Pull #2415

github

Committed by

web-flow

Commit Message

Merge 73e5c3f7b into c862ca737

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

Run Details

2795 of 3710 branches covered (75.34%)

Branch coverage included in aggregate %.

27 of 30 new or added lines in 3 files covered. (90.0%)

50 existing lines in 1 file now uncovered.

24349 of 27509 relevant lines covered (88.51%)

1022.71 hits per line

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

75.73

/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,
                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._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?.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		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	autoRefreshToken: true,	1✔
151	}));	1✔
152	} else if (config.source.isOGC3DTilesGoogleSource) {	4✔
153	this.tilesRenderer.registerPlugin(new GoogleCloudAuthPlugin({	1✔
154	apiToken: config.source.key,	1✔
155	autoRefreshToken: true,	1✔
156	}));	1✔
157	}	1✔
158	this.tilesRenderer.registerPlugin(new ImplicitTilingPlugin());	4✔
159		4✔
160	this.tilesRenderer.manager.addHandler(/\.gltf$/, itownsGLTFLoader);	4✔
161		4✔
162	this._setupCacheAndQueues();	4✔
163	this._setupEvents();	4✔
164		4✔
165	this.object3d.add(this.tilesRenderer.group);	4✔
166		4✔
167	// Add an initialization step that is resolved when the root tileset is loaded (see this._setup below), meaning	4✔
168	// that the layer will be marked ready when the tileset has been loaded.	4✔
169	this._res = this.addInitializationStep();	4✔
170		4✔
171	/**	4✔
172	* @type {number}	4✔
173	*/	4✔
174	this.sseThreshold = this.tilesRenderer.errorTarget;	4✔
175	Object.defineProperty(this, 'sseThreshold', {	4✔
176	get() { return this.tilesRenderer.errorTarget; },	4✔
177	set(value) { this.tilesRenderer.errorTarget = value; },	4✔
178	});	4✔
179		4✔
180	if (config.sseThreshold) {	4✔
181	this.sseThreshold = config.sseThreshold;	1✔
182	}	1✔
183	}	4✔
184		1✔
185	/**	1✔
186	* Store points material config so they can be used later to substitute points tiles material by our own PointsMaterial	1✔
187	* These properties should eventually be managed through the Style API (see https://github.com/iTowns/itowns/issues/2336)	1✔
188	* @param {Object} config - points material configuration as passed to the layer constructor.	1✔
189	* @private	1✔
190	*/	1✔
191	_handlePointsMaterialConfig(config) {	1✔
192	this.pntsMode = config.pntsMode ?? PNTS_MODE.COLOR;	4✔
193	this.pntsShape = config.pntsShape ?? PNTS_SHAPE.CIRCLE;	4✔
194	this.classification = config.classification ?? ClassificationScheme.DEFAULT;	4✔
195	this.pntsSizeMode = config.pntsSizeMode ?? PNTS_SIZE_MODE.VALUE;	4✔
196	this.pntsMinAttenuatedSize = config.pntsMinAttenuatedSize \|\| 3;	4✔
197	this.pntsMaxAttenuatedSize = config.pntsMaxAttenuatedSize \|\| 10;	4✔
198	}	4✔
199		1✔
200	/**	1✔
201	* Sets the lruCache and download and parse queues so they are shared amongst all tilesets.	1✔
202	* @private	1✔
203	*/	1✔
204	_setupCacheAndQueues() {	1✔
205	if (lruCache === null) {	4✔
206	lruCache = this.tilesRenderer.lruCache;	1✔
207	} else {	4✔
208	this.tilesRenderer.lruCache = lruCache;	3✔
209	}	3✔
210	if (downloadQueue === null) {	4✔
211	downloadQueue = this.tilesRenderer.downloadQueue;	1✔
212	} else {	4✔
213	this.tilesRenderer.downloadQueue = downloadQueue;	3✔
214	}	3✔
215	if (parseQueue === null) {	4✔
216	parseQueue = this.tilesRenderer.parseQueue;	1✔
217	} else {	4✔
218	this.tilesRenderer.parseQueue = parseQueue;	3✔
219	}	3✔
220	}	4✔
221		1✔
222	/**	1✔
223	* Binds 3d-tiles-renderer events to this layer.	1✔
224	* @private	1✔
225	*/	1✔
226	_setupEvents() {	1✔
227	for (const ev of Object.values(OGC3DTILES_LAYER_EVENTS)) {	4✔
228	this.tilesRenderer.addEventListener(ev, (e) => {	16✔
UNCOV 229	this.dispatchEvent(e);	×
230	});	16✔
231	}	16✔
232	}	4✔
233		1✔
234	/**	1✔
235	* Setup 3D tiles renderer js TilesRenderer with the camera, binds events and start updating. Executed when the	1✔
236	* layer has been added to the view.	1✔
237	* @param {View} view - the view the layer has been added to.	1✔
238	* @private	1✔
239	*/	1✔
240	_setup(view) {	1✔
241	this.tilesRenderer.setCamera(view.camera3D);	×
UNCOV 242	this.tilesRenderer.setResolutionFromRenderer(view.camera3D, view.renderer);	×
UNCOV 243	// Setup whenReady to be fullfiled when the root tileset has been loaded	×
UNCOV 244	let rootTilesetLoaded = false;	×
UNCOV 245	this.tilesRenderer.addEventListener('load-tile-set', () => {	×
UNCOV 246	view.notifyChange(this);	×
UNCOV 247	if (!rootTilesetLoaded) {	×
UNCOV 248	rootTilesetLoaded = true;	×
UNCOV 249	this._res();	×
UNCOV 250	}	×
UNCOV 251	});	×
UNCOV 252	this.tilesRenderer.addEventListener('load-model', ({ scene }) => {	×
253	scene.traverse((obj) => {	×
254	this._assignFinalMaterial(obj);	×
255	this._assignFinalAttributes(obj);	×
256	});	×
257	view.notifyChange(this);	×
258	});	×
259	// Start loading tileset and tiles	×
260	this.tilesRenderer.update();	×
261	}	×
262		1✔
263	/**	1✔
264	* Replace materials from GLTFLoader by our own custom materials. Note that	1✔
265	* the replaced materials are not compiled yet and will be disposed by the	1✔
266	* GC.	1✔
267	* @param {Object3D} model	1✔
268	* @private	1✔
269	*/	1✔
270	_assignFinalMaterial(model) {	1✔
271	let material = model.material;	×
272		×
273	if (model.isPoints) {	×
UNCOV 274	const pointsMaterial = new PointsMaterial({	×
UNCOV 275	mode: this.pntsMode,	×
UNCOV 276	shape: this.pntsShape,	×
UNCOV 277	classificationScheme: this.classification,	×
UNCOV 278	sizeMode: this.pntsSizeMode,	×
UNCOV 279	minAttenuatedSize: this.pntsMinAttenuatedSize,	×
UNCOV 280	maxAttenuatedSize: this.pntsMaxAttenuatedSize,	×
UNCOV 281	});	×
UNCOV 282	pointsMaterial.copy(material);	×
283		×
284	material = pointsMaterial;	×
285	}	×
286		×
287	if (material) {	×
288	ReferLayerProperties(material, this);	×
289	}	×
290		×
291	model.material = material;	×
292	}	×
293		1✔
294	/**	1✔
295	* @param {Object3D} model	1✔
296	* @private	1✔
297	*/	1✔
298	_assignFinalAttributes(model) {	1✔
299	const geometry = model.geometry;	×
300	const batchTable = model.batchTable;	×
301		×
302	// Setup classification bufferAttribute	×
303	if (model.isPoints) {	×
304	const classificationData = batchTable?.getPropertyArray('Classification');	×
UNCOV 305	if (classificationData) {	×
UNCOV 306	geometry.setAttribute('classification',	×
UNCOV 307	new THREE.BufferAttribute(classificationData, 1),	×
UNCOV 308	);	×
UNCOV 309	}	×
UNCOV 310	}	×
311	}	×
312		1✔
313	preUpdate(context) {	1✔
314	this.scale = context.camera._preSSE;	×
315	this.tilesRenderer.update();	×
316	return null; // don't return any element because 3d-tiles-renderer already updates them	×
317	}	×
318		1✔
319	update() {	1✔
320	// empty, elements are updated by 3d-tiles-renderer	×
321	}	1✔
322		1✔
323	/**	1✔
324	* Deletes the layer and frees associated memory	1✔
325	*/	1✔
326	delete() {	1✔
327	this.tilesRenderer.dispose();	×
328	}	×
329		1✔
330	/**	1✔
331	* Get the attributes for the closest intersection from a list of	1✔
332	* intersects.	1✔
333	* @param {Array} intersects - An array containing all	1✔
334	* objects picked under mouse coordinates computed with view.pickObjectsAt(..).	1✔
335	* @returns {Object \| null} - An object containing	1✔
336	*/	1✔
337	getC3DTileFeatureFromIntersectsArray(intersects) {	1✔
UNCOV 338	if (!intersects.length) { return null; }	×
339		×
340	const { face, index, object } = intersects[0];	×
UNCOV 341		×
UNCOV 342	/** @type{number\|null} */	×
UNCOV 343	let batchId;	×
UNCOV 344	if (object.isPoints && index) {	×
UNCOV 345	batchId = object.geometry.getAttribute('_BATCHID')?.getX(index) ?? index;	×
UNCOV 346	} else if (object.isMesh && face) {	×
UNCOV 347	batchId = object.geometry.getAttribute('_BATCHID')?.getX(face.a);	×
UNCOV 348	}	×
UNCOV 349		×
350	if (batchId === undefined) {	×
351	return null;	×
352	}	×
353		×
354	let tileObject = object;	×
355	while (!tileObject.batchTable) {	×
356	tileObject = tileObject.parent;	×
357	}	×
358		×
359	return tileObject.batchTable.getDataFromId(batchId);	×
360	}	×
361		1✔
362	/**	1✔
363	* Get all 3D objects (mesh and points primitives) as intersects at the	1✔
364	* given non-normalized screen coordinates.	1✔
365	* @param {View} view - The view instance.	1✔
366	* @param {THREE.Vector2} coords - The coordinates to pick in the view. It	1✔
367	* should have at least `x` and `y` properties.	1✔
368	* @param {number} radius - Radius of the picking circle.	1✔
369	* @param {Array} [target=[]] - Target array to push results too	1✔
370	* @returns {Array} Array containing all target objects picked under the	1✔
371	* specified coordinates.	1✔
372	*/	1✔
373	pickObjectsAt(view, coords, radius, target = []) {	1✔
UNCOV 374	const camera = view.camera.camera3D;	×
UNCOV 375	_raycaster.setFromCamera(view.viewToNormalizedCoords(coords), camera);	×
UNCOV 376	_raycaster.near = camera.near;	×
UNCOV 377	_raycaster.far = camera.far;	×
UNCOV 378		×
UNCOV 379	_raycaster.firstHitOnly = true;	×
UNCOV 380	_raycaster.intersectObject(this.tilesRenderer.group, true, target);	×
UNCOV 381		×
UNCOV 382	return target;	×
UNCOV 383	}	×
384		1✔
385	// eslint-disable-next-line no-unused-vars	1✔
386	attach(layer) {	1✔
387	console.warn('[OGC3DTilesLayer]: Attaching / detaching layers is not yet implemented for OGC3DTilesLayer.');	×
388	}	×
389		1✔
390	// eslint-disable-next-line no-unused-vars	1✔
391	detach(layer) {	1✔
NEW 392	console.warn('[OGC3DTilesLayer]: Attaching / detaching layers is not yet implemented for OGC3DTilesLayer.');	×
NEW 393	return true;	×
NEW 394	}	×
395		1✔
396	// eslint-disable-next-line no-unused-vars	1✔
397	getObjectToUpdateForAttachedLayers(obj) {	1✔
398	return null;	×
399	}	×
400		1✔
401	/**	1✔
402	* Executes a callback for each tile of this layer tileset.	1✔
403	*	1✔
404	* @param {Function} callback The callback to execute for each tile. Has the following two parameters:	1✔
405	* 1. tile (Object) - the JSON tile	1✔
406	* 2. scene (THREE.Object3D \| null) - The tile content. Contains a `batchTable` property. Can be null if the tile	1✔
407	* has not yet been loaded.	1✔
408	*/	1✔
409	forEachTile(callback) {	1✔
410	this.tilesRenderer.traverse((tile) => {	×
UNCOV 411	callback(tile, tile.cached.scene);	×
UNCOV 412	});	×
UNCOV 413	}	×
414	}	1✔
415		1✔
416	export default OGC3DTilesLayer;	1✔

iTowns / itowns / 11179762037

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