) then itowns' size is
// the container's size. Otherwise we use window' size.
- const newSize = new Vector2(viewerDiv.clientWidth, viewerDiv.clientHeight);
+ const newSize = new THREE.Vector2(viewerDiv.clientWidth, viewerDiv.clientHeight);
this.mainLoop.gfxEngine.onWindowResize(newSize.x, newSize.y);
this.notifyChange(this.camera.camera3D);
}, false);
@@ -101,9 +104,25 @@ function View(crs, viewerDiv, options = {}) {
};
}
-View.prototype = Object.create(EventDispatcher.prototype);
+View.prototype = Object.create(THREE.EventDispatcher.prototype);
View.prototype.constructor = View;
+function _createLayerFromConfig(config) {
+ switch (config.type) {
+ case 'color':
+ return new ColorLayer(config.id, config);
+ case 'elevation':
+ return new ElevationLayer(config.id, config);
+ case 'geometry':
+ return new GeometryLayer(config.id, new THREE.Group(), config);
+ case 'debug':
+ return new Layer(config.id, 'debug', config);
+ default:
+ throw new Error(`Unknown layer type ${config.type}: please
+ specify a valid one`);
+ }
+}
+
const _syncGeometryLayerVisibility = function _syncGeometryLayerVisibility(layer, view) {
if (layer.object3d) {
layer.object3d.visible = layer.visible;
@@ -119,46 +138,21 @@ const _syncGeometryLayerVisibility = function _syncGeometryLayerVisibility(layer
};
function _preprocessLayer(view, layer, provider, parentLayer) {
- if (!(layer instanceof Layer) && !(layer instanceof GeometryLayer)) {
- const nlayer = new Layer(layer.id);
- // nlayer.id is read-only so delete it from layer before Object.assign
- const tmp = layer;
- delete tmp.id;
- layer = Object.assign(nlayer, layer);
- // restore layer.id in user provider layer object
- tmp.id = layer.id;
- }
-
- layer.options = layer.options || {};
- // TODO remove this warning and fallback after the release following v2.3.0
- if (!layer.format && layer.options.mimetype) {
- console.warn('layer.options.mimetype is deprecated, please use layer.format');
- layer.format = layer.options.mimetype;
- }
-
- if (!layer.updateStrategy) {
- layer.updateStrategy = {
- type: STRATEGY_MIN_NETWORK_TRAFFIC,
- };
+ if (!(layer instanceof Layer)) {
+ layer = _createLayerFromConfig(layer);
}
if (provider) {
if (provider.tileInsideLimit) {
layer.tileInsideLimit = provider.tileInsideLimit.bind(provider);
}
-
- if (provider.tileTextureCount) {
- layer.tileTextureCount = provider.tileTextureCount.bind(provider);
- }
}
if (!layer.whenReady) {
- if (layer.type == 'geometry' || layer.type == 'debug') {
- if (!layer.object3d) {
- // layer.threejsLayer *must* be assigned before preprocessing,
- // because TileProvider.preprocessDataLayer function uses it.
- layer.threejsLayer = view.mainLoop.gfxEngine.getUniqueThreejsLayer();
- }
+ if (parentLayer || layer.type == 'debug') {
+ // layer.threejsLayer *must* be assigned before preprocessing,
+ // because TileProvider.preprocessDataLayer function uses it.
+ layer.threejsLayer = view.mainLoop.gfxEngine.getUniqueThreejsLayer();
}
let providerPreprocessing = Promise.resolve();
if (provider && provider.preprocessDataLayer) {
@@ -175,47 +169,11 @@ function _preprocessLayer(view, layer, provider, parentLayer) {
});
}
- // probably not the best place to do this
- if (layer.type == 'color') {
- defineLayerProperty(layer, 'frozen', false);
- defineLayerProperty(layer, 'visible', true);
- defineLayerProperty(layer, 'opacity', 1.0);
- defineLayerProperty(layer, 'sequence', 0);
- } else if (layer.type == 'elevation') {
- defineLayerProperty(layer, 'frozen', false);
- } else if (layer.type == 'geometry' || layer.type == 'debug') {
- defineLayerProperty(layer, 'visible', true, () => _syncGeometryLayerVisibility(layer, view));
- defineLayerProperty(layer, 'frozen', false);
+ if (layer.type == 'geometry' || layer.type == 'debug') {
+ layer.defineLayerProperty('visible', true, () => _syncGeometryLayerVisibility(layer, view));
_syncGeometryLayerVisibility(layer, view);
-
- const changeOpacity = (o) => {
- if (o.material) {
- // != undefined: we want the test to pass if opacity is 0
- if (o.material.opacity != undefined) {
- o.material.transparent = layer.opacity < 1.0;
- o.material.opacity = layer.opacity;
- }
- if (o.material.uniforms && o.material.uniforms.opacity != undefined) {
- o.material.transparent = layer.opacity < 1.0;
- o.material.uniforms.opacity.value = layer.opacity;
- }
- }
- };
- defineLayerProperty(layer, 'opacity', 1.0, () => {
- if (layer.object3d) {
- layer.object3d.traverse((o) => {
- if (o.layer !== layer) {
- return;
- }
- changeOpacity(o);
- // 3dtiles layers store scenes in children's content property
- if (o.content) {
- o.content.traverse(changeOpacity);
- }
- });
- }
- });
}
+
return layer;
}
@@ -313,11 +271,6 @@ function _preprocessLayer(view, layer, provider, parentLayer) {
* @return {Promise} a promise resolved with the new layer object when it is fully initialized or rejected if any error occurred.
*/
View.prototype.addLayer = function addLayer(layer, parentLayer) {
- if (layer.type == 'color') {
- layer.update = layer.update || updateLayeredMaterialNodeImagery;
- } else if (layer.type == 'elevation') {
- layer.update = layer.update || updateLayeredMaterialNodeElevation;
- }
return new Promise((resolve, reject) => {
if (!layer) {
reject(new Error('layer is undefined'));
@@ -404,12 +357,12 @@ View.prototype.notifyChange = function notifyChange(changeSource = undefined, ne
*/
View.prototype.getLayers = function getLayers(filter) {
const result = [];
- for (const geometryLayer of this._layers) {
- if (!filter || filter(geometryLayer)) {
- result.push(geometryLayer);
+ for (const layer of this._layers) {
+ if (!filter || filter(layer)) {
+ result.push(layer);
}
- for (const attached of geometryLayer._attachedLayers) {
- if (!filter || filter(attached, geometryLayer)) {
+ for (const attached of layer.attachedLayers) {
+ if (!filter || filter(attached, layer)) {
result.push(attached);
}
}
@@ -423,7 +376,7 @@ View.prototype.getLayers = function getLayers(filter) {
*/
View.prototype.getParentLayer = function getParentLayer(layer) {
for (const geometryLayer of this._layers) {
- for (const attached of geometryLayer._attachedLayers) {
+ for (const attached of geometryLayer.attachedLayers) {
if (attached === layer) {
return geometryLayer;
}
@@ -545,7 +498,7 @@ View.prototype.execFrameRequesters = function execFrameRequesters(when, dt, upda
}
};
-const _eventCoords = new Vector2();
+const _eventCoords = new THREE.Vector2();
/**
* Extract view coordinates from a mouse-event / touch-event
* @param {event} event - event can be a MouseEvent or a TouchEvent
@@ -575,7 +528,7 @@ View.prototype.eventToNormalizedCoords = function eventToNormalizedCoords(event,
/**
* Convert view coordinates to normalized coordinates (NDC)
- * @param {Vector2} viewCoords (in pixels, 0-0 = top-left of the View)
+ * @param {THREE.Vector2} viewCoords (in pixels, 0-0 = top-left of the View)
* @return {THREE.Vector2} - NDC coordinates (x and y are [-1, 1])
*/
View.prototype.viewToNormalizedCoords = function viewToNormalizedCoords(viewCoords) {
@@ -586,7 +539,7 @@ View.prototype.viewToNormalizedCoords = function viewToNormalizedCoords(viewCoor
/**
* Convert NDC coordinates to view coordinates
- * @param {Vector2} ndcCoords
+ * @param {THREE.Vector2} ndcCoords
* @return {THREE.Vector2} - view coordinates (in pixels, 0-0 = top-left of the View)
*/
View.prototype.normalizedToViewCoords = function normalizedToViewCoords(ndcCoords) {
@@ -632,15 +585,14 @@ View.prototype.pickObjectsAt = function pickObjectsAt(mouseOrEvt, radius, ...whe
radius = radius || 0;
for (const source of sources) {
- if (source instanceof GeometryLayer ||
- source instanceof Layer ||
+ if (source instanceof Layer ||
typeof (source) === 'string') {
const layer = (typeof (source) === 'string') ?
layerIdToLayer(this, source) :
source;
- // does this layer have a custom picking function?
- if (layer.pickObjectsAt) {
+ const parentLayer = this.getParentLayer(layer);
+ if (!parentLayer) {
const sp = layer.pickObjectsAt(this, mouse, radius);
// warning: sp might be very large, so we can't use '...sp' (we'll hit
// 'javascript maximum call stack size exceeded' error) nor
@@ -649,14 +601,6 @@ View.prototype.pickObjectsAt = function pickObjectsAt(mouseOrEvt, radius, ...whe
results.push(sp[i]);
}
} else {
- // - it hasn't: this layer is attached to another one
- let parentLayer;
- this.getLayers((l, p) => {
- if (l.id == layer.id) {
- parentLayer = p;
- }
- });
-
// raycast using parent layer object3d
const obj = Picking.pickObjectsAt(
this,
@@ -671,7 +615,7 @@ View.prototype.pickObjectsAt = function pickObjectsAt(mouseOrEvt, radius, ...whe
}
}
}
- } else if (source instanceof Object3D) {
+ } else if (source instanceof THREE.Object3D) {
Picking.pickObjectsAt(
this,
mouse,
diff --git a/src/Layer/ColorLayer.js b/src/Layer/ColorLayer.js
new file mode 100644
index 0000000000..a2ace32bb6
--- /dev/null
+++ b/src/Layer/ColorLayer.js
@@ -0,0 +1,72 @@
+import Layer from './Layer';
+import { updateLayeredMaterialNodeImagery } from '../Process/LayeredMaterialNodeProcessing';
+
+/**
+ * Fires when the visiblity of the layer has changed.
+ * @event ColorLayer#visible-property-changed
+ */
+/**
+ * Fires when the opacity of the layer has changed.
+ * @event ColorLayer#opacity-property-changed
+ */
+/**
+ * Fires when the sequence of the layer has changed, meaning that the order of
+ * the layer changed in the view it is attached to.
+ * @event ColorLayer#sequence-property-changed
+ */
+
+class ColorLayer extends Layer {
+ /**
+ * A simple layer, usually managing a texture to display on a view. For example,
+ * it can be an aerial view of the ground or a simple transparent layer with the
+ * roads displayed.
+ *
+ * @constructor
+ * @extends Layer
+ *
+ * @param {string} id - The id of the layer, that should be unique. It is
+ * not mandatory, but an error will be emitted if this layer is added a
+ * {@link View} that already has a layer going by that id.
+ * @param {Object} [config] - Optional configuration, all elements in it
+ * will be merged as is in the layer. For example, if the configuration
+ * contains three elements
name, protocol, extent, these
+ * elements will be available using
layer.name or something
+ * else depending on the property name.
+ *
+ * @example
+ * // Create a ColorLayer
+ * const color = new ColorLayer('roads', {
+ * url: 'http://server.geo/wmts/SERVICE=WMTS&TILEMATRIX=%TILEMATRIX&TILEROW=%ROW&TILECOL=%COL',
+ * protocol: 'wmts',
+ * format: 'image/png',
+ * transparent: true
+ * });
+ *
+ * // Add the layer
+ * view.addLayer(color);
+ *
+ * @example
+ * // Add and create a ColorLayer
+ * view.addLayer({
+ * id: 'roads',
+ * type: 'color',
+ * url: 'http://server.geo/wmts/SERVICE=WMTS&TILEMATRIX=%TILEMATRIX&TILEROW=%ROW&TILECOL=%COL',
+ * protocol: 'wmts',
+ * format: 'image/png',
+ * transparent: true
+ * });
+ */
+ constructor(id, config = {}) {
+ super(id, 'color', config);
+
+ this.defineLayerProperty('visible', true);
+ this.defineLayerProperty('opacity', 1.0);
+ this.defineLayerProperty('sequence', 0);
+ }
+
+ update(context, layer, node, parent) {
+ return updateLayeredMaterialNodeImagery(context, this, node, parent);
+ }
+}
+
+export default ColorLayer;
diff --git a/src/Layer/ElevationLayer.js b/src/Layer/ElevationLayer.js
new file mode 100644
index 0000000000..06e9b4eb2c
--- /dev/null
+++ b/src/Layer/ElevationLayer.js
@@ -0,0 +1,51 @@
+import Layer from './Layer';
+import { updateLayeredMaterialNodeElevation } from '../Process/LayeredMaterialNodeProcessing';
+
+class ElevationLayer extends Layer {
+ /**
+ * A simple layer, managing an elevation texture to add some reliefs on the
+ * plane or globe view for example.
+ *
+ * @constructor
+ * @extends Layer
+ *
+ * @param {string} id - The id of the layer, that should be unique. It is
+ * not mandatory, but an error will be emitted if this layer is added a
+ * {@link View} that already has a layer going by that id.
+ * @param {Object} [config] - Optional configuration, all elements in it
+ * will be merged as is in the layer. For example, if the configuration
+ * contains three elements
name, protocol, extent, these
+ * elements will be available using
layer.name or something
+ * else depending on the property name.
+ *
+ * @example
+ * // Create an ElevationLayer
+ * const elevation = new ElevationLayer('IGN_MNT', {
+ * url: 'http://server.geo/wmts/SERVICE=WMTS&TILEMATRIX=%TILEMATRIX&TILEROW=%ROW&TILECOL=%COL',
+ * protocol: 'wmts',
+ * format: 'image/x-bil;bits=32',
+ * });
+ *
+ * // Add the layer
+ * view.addLayer(elevation);
+ *
+ * @example
+ * // Add and create an ElevationLayer
+ * view.addLayer({
+ * id: 'IGN_MNT',
+ * type: 'elevation',
+ * url: 'http://server.geo/wmts/SERVICE=WMTS&TILEMATRIX=%TILEMATRIX&TILEROW=%ROW&TILECOL=%COL',
+ * protocol: 'wmts',
+ * format: 'image/x-bil;bits=32',
+ * });
+ */
+ constructor(id, config = {}) {
+ super(id, 'elevation', config);
+ }
+
+ update(context, layer, node, parent) {
+ return updateLayeredMaterialNodeElevation(context, this, node, parent);
+ }
+}
+
+export default ElevationLayer;
diff --git a/src/Layer/GeometryLayer.js b/src/Layer/GeometryLayer.js
new file mode 100644
index 0000000000..485f971385
--- /dev/null
+++ b/src/Layer/GeometryLayer.js
@@ -0,0 +1,172 @@
+import Layer from './Layer';
+import Picking from '../Core/Picking';
+
+/**
+ * Fires when the opacity of the layer has changed.
+ * @event GeometryLayer#opacity-property-changed
+ */
+
+class GeometryLayer extends Layer {
+ /**
+ * A layer usually managing a geometry to display on a view. For example, it
+ * can be a layer of buildings extruded from a a WFS stream.
+ *
+ * @constructor
+ * @extends Layer
+ *
+ * @param {string} id - The id of the layer, that should be unique. It is
+ * not mandatory, but an error will be emitted if this layer is added a
+ * {@link View} that already has a layer going by that id.
+ * @param {THREE.Object3d} object3d - The object3d used to contain the
+ * geometry of the GeometryLayer. It is usually a
THREE.Group,
+ * but it can be anything inheriting from a
THREE.Object3d.
+ * @param {Object} [config] - Optional configuration, all elements in it
+ * will be merged as is in the layer. For example, if the configuration
+ * contains three elements
name, protocol, extent, these
+ * elements will be available using
layer.name or something
+ * else depending on the property name.
+ *
+ * @throws {Error}
object3d must be a valid
+ *
THREE.Object3d.
+ *
+ * @example
+ * // Create a GeometryLayer
+ * const geometry = new GeometryLayer('buildings', {
+ * url: 'http://server.geo/wfs?',
+ * protocol: 'wfs',
+ * format: 'application/json'
+ * });
+ *
+ * // Add the layer
+ * view.addLayer(geometry);
+ *
+ * @example
+ * // Add and create a GeometryLayer
+ * view.addLayer({
+ * id: 'buildings',
+ * type: 'geometry',
+ * url: 'http://server.geo/wfs?',
+ * protocol: 'wfs',
+ * format: 'application/json'
+ * });
+ */
+ constructor(id, object3d, config = {}) {
+ super(id, 'geometry', config);
+
+ if (!object3d || !object3d.isObject3D) {
+ throw new Error(`Missing/Invalid object3d parameter (must be a
+ three.js Object3D instance)`);
+ }
+
+ if (object3d.type === 'Group' && object3d.name === '') {
+ object3d.name = id;
+ }
+
+ Object.defineProperty(this, 'object3d', {
+ value: object3d,
+ writable: false,
+ });
+
+ this.defineLayerProperty('opacity', 1.0, () => {
+ this.object3d.traverse((object) => {
+ if (object.layer !== this) {
+ return;
+ }
+ this.changeOpacity(object);
+ // 3dtiles layers store scenes in children's content property
+ if (object.content) {
+ object.content.traverse(this.changeOpacity);
+ }
+ });
+ });
+
+ this.attachedLayers = [];
+ this.visible = true;
+
+ // Attached layers expect to receive the visual representation of a
+ // layer (= THREE object with a material). So if a layer's update
+ // function don't process this kind of object, the layer must provide a
+ // getObjectToUpdateForAttachedLayers function that returns the correct
+ // object to update for attached layer.
+ // See 3dtilesProvider or PointCloudProvider for examples.
+ // eslint-disable-next-line arrow-body-style
+ this.getObjectToUpdateForAttachedLayers = (obj) => {
+ if (obj.parent && obj.material) {
+ return {
+ element: obj,
+ parent: obj.parent,
+ };
+ }
+ };
+
+ this.postUpdate = () => {};
+ }
+
+ /**
+ * Attach another layer to this one. Layers attached to a GeometryLayer will
+ * be available in
geometryLayer.attachedLayers.
+ *
+ * @param {Layer} layer - The layer to attach, that must have an
+ *
update method.
+ */
+ attach(layer) {
+ if (!layer.update) {
+ throw new Error(`Missing 'update' function -> can't attach layer
+ ${layer.id}`);
+ }
+ this.attachedLayers.push(layer);
+ }
+
+ /**
+ * Detach a layer attached to this one. See {@link attach} to learn how to
+ * attach a layer.
+ *
+ * @param {Layer} layer - The layer to detach.
+ *
+ * @return {boolean} Confirmation of the detachment of the layer.
+ */
+ detach(layer) {
+ const count = this.attachedLayers.length;
+ this.attachedLayers = this.attachedLayers.filter(attached => attached.id != layer.id);
+ return this.attachedLayers.length < count;
+ }
+
+ /**
+ * Picking method for this layer. It uses the {@link Picking#pickObjectsAt}
+ * method.
+ *
+ * @param {View} view - The view instance.
+ * @param {Object} coordinates - The coordinates to pick in the view. It
+ * should have at least
x and
y properties.
+ * @param {number} radius - Radius of the picking circle.
+ *
+ * @return {Array} An array containing all targets picked under the
+ * specified coordinates.
+ */
+ pickObjectsAt(view, coordinates, radius = this.options.defaultPickingRadius) {
+ return Picking.pickObjectsAt(view, coordinates, radius, this.object3d);
+ }
+
+ /**
+ * Change the opacity of an object, according to the value of the
+ *
opacity property of this layer.
+ *
+ * @param {Object} object - The object to change the opacity from. It is
+ * usually a
THREE.Object3d or an implementation of it.
+ */
+ changeOpacity(object) {
+ if (object.material) {
+ // != undefined: we want the test to pass if opacity is 0
+ if (object.material.opacity != undefined) {
+ object.material.transparent = this.opacity < 1.0;
+ object.material.opacity = this.opacity;
+ }
+ if (object.material.uniforms && object.material.uniforms.opacity != undefined) {
+ object.material.transparent = this.opacity < 1.0;
+ object.material.uniforms.opacity.value = this.opacity;
+ }
+ }
+ }
+}
+
+export default GeometryLayer;
diff --git a/src/Layer/Layer.js b/src/Layer/Layer.js
new file mode 100644
index 0000000000..5453866876
--- /dev/null
+++ b/src/Layer/Layer.js
@@ -0,0 +1,188 @@
+import * as THREE from 'three';
+import { STRATEGY_MIN_NETWORK_TRAFFIC } from './LayerUpdateStrategy';
+
+class Layer extends THREE.EventDispatcher {
+ /**
+ * Don't use directly constructor to instance a new Layer. Instead, use
+ * another available type of Layer, implement a new one inheriting from this
+ * one or use {@link View#addLayer}.
+ *
+ * @constructor
+ * @protected
+ *
+ * @param {string} id - The id of the layer, that should be unique. It is
+ * not mandatory, but an error will be emitted if this layer is added a
+ * {@link View} that already has a layer going by that id.
+ * @param {string} type - The type of the layer, used to determine
+ * operations to do on a layer later in the rendering loop. There are three
+ * type of layers in itowns:
+ *
+ * color, used for simple layer containing a textureelevation, used for adding an elevation to the globe or
+ * plane the layer is attached togeometry, used for complex layer containing meshes,
+ * like a WFS layer with extruded buildings
+ * @param {Object} [config] - Optional configuration, all elements in it
+ * will be merged as is in the layer. For example, if the configuration
+ * contains three elements name, protocol, extent, these
+ * elements will be available using layer.name or something
+ * else depending on the property name.
+ *
+ * @example
+ * // Add and create a new Layer
+ * const newLayer = view.addLayer({options});
+ *
+ * // Change layer's visibilty
+ * const layerToChange = view.getLayers(layer => layer.id == 'idLayerToChange')[0];
+ * layerToChange.visible = false;
+ * view.notifyChange(); // update viewer
+ *
+ * // Change layer's opacity
+ * const layerToChange = view.getLayers(layer => layer.id == 'idLayerToChange')[0];
+ * layerToChange.opacity = 0.5;
+ * view.notifyChange(); // update viewer
+ *
+ * // Listen properties
+ * const layerToListen = view.getLayers(layer => layer.id == 'idLayerToListen')[0];
+ * layerToListen.addEventListener('visible-property-changed', (event) => console.log(event));
+ * layerToListen.addEventListener('opacity-property-changed', (event) => console.log(event));
+ */
+ constructor(id, type, config = {}) {
+ super();
+
+ Object.assign(this, config);
+
+ Object.defineProperty(this, 'id', {
+ value: id,
+ writable: false,
+ });
+
+ Object.defineProperty(this, 'type', {
+ value: type,
+ writable: false,
+ });
+
+ // Default properties
+ this.options = config.options || {};
+
+ if (!this.updateStrategy) {
+ this.updateStrategy = {
+ type: STRATEGY_MIN_NETWORK_TRAFFIC,
+ };
+ }
+
+ // TODO remove this warning and fallback after the release following v2.3.0
+ if (!this.format && this.options.mimetype) {
+ console.warn('layer.options.mimetype is deprecated, please use layer.format');
+ this.format = this.options.mimetype;
+ }
+
+ this.defineLayerProperty('frozen', false);
+ }
+
+ /**
+ * Defines a property for this layer, with a default value and a callback
+ * executed when the property changes.
+ *
+ * When changing the property, it also emits an event, named following this
+ * convention: ${propertyName}-property-changed, with
+ * ${propertyName} being replaced by the name of the property.
+ * For example, if the added property name is frozen, it will
+ * emit a frozen-property-changed.
+ *
+ * The emitted event has some properties assigned to it:
+ *
+ * event = {
+ * new: {
+ * ${propertyName}: * // the new value of the property
+ * },
+ * previous: {
+ * ${propertyName}: * // the previous value of the property
+ * },
+ * target: Layer // the layer it has been dispatched from
+ * type: string // the name of the emitted event
+ * }
+ *
+ *
+ * @param {string} propertyName - The name of the property, also used in
+ * the emitted event name.
+ * @param {*} defaultValue - The default set value.
+ * @param {function} [onChange] - The function executed when the property is
+ * changed. Parameters are the layer the property is defined on, and the
+ * name of the property.
+ */
+ defineLayerProperty(propertyName, defaultValue, onChange) {
+ const existing = Object.getOwnPropertyDescriptor(this, propertyName);
+ if (!existing || !existing.set) {
+ let property = this[propertyName] == undefined ? defaultValue : this[propertyName];
+
+ Object.defineProperty(
+ this,
+ propertyName,
+ {
+ get: () => property,
+ set: (newValue) => {
+ if (property !== newValue) {
+ const event = { type: `${propertyName}-property-changed`, previous: {}, new: {} };
+ event.previous[propertyName] = property;
+ event.new[propertyName] = newValue;
+ property = newValue;
+ if (onChange) {
+ onChange(this, propertyName);
+ }
+ this.dispatchEvent(event);
+ }
+ },
+ });
+ }
+ }
+}
+
+export default Layer;
+
+export const ImageryLayers = {
+ // move this to new index
+ // After the modification :
+ // * the minimum sequence will always be 0
+ // * the maximum sequence will always be layers.lenght - 1
+ // the ordering of all layers (Except that specified) doesn't change
+ moveLayerToIndex: function moveLayerToIndex(layer, newIndex, imageryLayers) {
+ newIndex = Math.min(newIndex, imageryLayers.length - 1);
+ newIndex = Math.max(newIndex, 0);
+ const oldIndex = layer.sequence;
+
+ for (const imagery of imageryLayers) {
+ if (imagery.id === layer.id) {
+ // change index of specified layer
+ imagery.sequence = newIndex;
+ } else if (imagery.sequence > oldIndex && imagery.sequence <= newIndex) {
+ // down all layers between the old index and new index (to compensate the deletion of the old index)
+ imagery.sequence--;
+ } else if (imagery.sequence >= newIndex && imagery.sequence < oldIndex) {
+ // up all layers between the new index and old index (to compensate the insertion of the new index)
+ imagery.sequence++;
+ }
+ }
+ },
+
+ moveLayerDown: function moveLayerDown(layer, imageryLayers) {
+ if (layer.sequence > 0) {
+ this.moveLayerToIndex(layer, layer.sequence - 1, imageryLayers);
+ }
+ },
+
+ moveLayerUp: function moveLayerUp(layer, imageryLayers) {
+ const m = imageryLayers.length - 1;
+ if (layer.sequence < m) {
+ this.moveLayerToIndex(layer, layer.sequence + 1, imageryLayers);
+ }
+ },
+
+ getColorLayersIdOrderedBySequence: function getColorLayersIdOrderedBySequence(imageryLayers) {
+ const copy = Array.from(imageryLayers);
+ copy.sort((a, b) => a.sequence - b.sequence);
+ return copy.map(l => l.id);
+ },
+};
+
diff --git a/src/Core/Layer/LayerUpdateState.js b/src/Layer/LayerUpdateState.js
similarity index 100%
rename from src/Core/Layer/LayerUpdateState.js
rename to src/Layer/LayerUpdateState.js
diff --git a/src/Core/Layer/LayerUpdateStrategy.js b/src/Layer/LayerUpdateStrategy.js
similarity index 97%
rename from src/Core/Layer/LayerUpdateStrategy.js
rename to src/Layer/LayerUpdateStrategy.js
index c4a5b43e04..32c77291d9 100644
--- a/src/Core/Layer/LayerUpdateStrategy.js
+++ b/src/Layer/LayerUpdateStrategy.js
@@ -1,4 +1,4 @@
-import { EMPTY_TEXTURE_ZOOM } from '../../Renderer/LayeredMaterialConstants';
+import { EMPTY_TEXTURE_ZOOM } from '../Renderer/LayeredMaterialConstants';
/**
* This modules implements various layer update strategies.
*
diff --git a/src/Layer/TiledGeometryLayer.js b/src/Layer/TiledGeometryLayer.js
new file mode 100644
index 0000000000..ec7ee72764
--- /dev/null
+++ b/src/Layer/TiledGeometryLayer.js
@@ -0,0 +1,168 @@
+import GeometryLayer from './GeometryLayer';
+import Picking from '../Core/Picking';
+import { processTiledGeometryNode } from '../Process/TiledNodeProcessing';
+
+class TiledGeometryLayer extends GeometryLayer {
+ /**
+ * A layer extending the {@link GeometryLayer}, but with a tiling notion.
+ *
+ * @constructor
+ * @extends GeometryLayer
+ *
+ * @param {string} id - The id of the layer, that should be unique. It is
+ * not mandatory, but an error will be emitted if this layer is added a
+ * {@link View} that already has a layer going by that id.
+ * @param {THREE.Object3d} object3d - The object3d used to contain the
+ * geometry of the TiledGeometryLayer. It is usually a
+ *
THREE.Group, but it can be anything inheriting from a
+ *
THREE.Object3d.
+ * @param {Object} [config] - Optional configuration, all elements in it
+ * will be merged as is in the layer. For example, if the configuration
+ * contains three elements
name, protocol, extent, these
+ * elements will be available using
layer.name or something
+ * else depending on the property name.
+ *
+ * @throws {Error}
object3d must be a valid
+ *
THREE.Object3d.
+ */
+ constructor(id, object3d, config) {
+ super(id, object3d, config);
+
+ this.protocol = 'tile';
+ this.lighting = {
+ enable: false,
+ position: { x: -0.5, y: 0.0, z: 1.0 },
+ };
+ }
+
+ /**
+ * Picking method for this layer. It uses the {@link Picking#pickTilesAt}
+ * method.
+ *
+ * @param {View} view - The view instance.
+ * @param {Object} coordinates - The coordinates to pick in the view. It
+ * should have at least
x and
y properties.
+ * @param {number} radius - Radius of the picking circle.
+ *
+ * @return {Array} An array containing all targets picked under the
+ * specified coordinates.
+ */
+ pickObjectsAt(view, coordinates, radius = this.options.defaultPickingRadius) {
+ return Picking.pickTilesAt(view, coordinates, radius, this);
+ }
+
+ preUpdate(context, changeSources) {
+ if (changeSources.has(undefined) || changeSources.size == 0) {
+ return this.level0Nodes;
+ }
+
+ if (__DEBUG__) {
+ this._latestUpdateStartingLevel = 0;
+ }
+
+ context.colorLayers = context.view.getLayers(
+ (l, a) => a && a.id == this.id && l.type == 'color');
+ context.elevationLayers = context.view.getLayers(
+ (l, a) => a && a.id == this.id && l.type == 'elevation');
+
+ context.maxElevationLevel = -1;
+ for (const e of context.elevationLayers) {
+ context.maxElevationLevel = Math.max(e.options.zoom.max, context.maxElevationLevel);
+ }
+ if (context.maxElevationLevel == -1) {
+ context.maxElevationLevel = Infinity;
+ }
+
+ let commonAncestor;
+ for (const source of changeSources.values()) {
+ if (source.isCamera) {
+ // if the change is caused by a camera move, no need to bother
+ // to find common ancestor: we need to update the whole tree:
+ // some invisible tiles may now be visible
+ return this.level0Nodes;
+ }
+ if (source.this === this) {
+ if (!commonAncestor) {
+ commonAncestor = source;
+ } else {
+ commonAncestor = source.findCommonAncestor(commonAncestor);
+ if (!commonAncestor) {
+ return this.level0Nodes;
+ }
+ }
+ if (commonAncestor.material == null) {
+ commonAncestor = undefined;
+ }
+ }
+ }
+ if (commonAncestor) {
+ if (__DEBUG__) {
+ this._latestUpdateStartingLevel = commonAncestor.level;
+ }
+ return [commonAncestor];
+ } else {
+ return this.level0Nodes;
+ }
+ }
+
+ update(context, layer, node) {
+ return processTiledGeometryNode(this.culling, this.subdivision)(context, this, node);
+ }
+
+ onTileCreated(node) {
+ node.material.setLightingOn(this.lighting.enable);
+ node.material.uniforms.lightPosition.value = this.lighting.position;
+
+ if (this.noTextureColor) {
+ node.material.uniforms.noTextureColor.value.copy(this.noTextureColor);
+ }
+
+ if (__DEBUG__) {
+ node.material.uniforms.showOutline = { value: this.showOutline || false };
+ node.material.wireframe = this.wireframe || false;
+ }
+ }
+
+ /**
+ * Tell if a node has enough elevation or color textures to subdivide.
+ * Subdivision is prevented if:
+ *
+ * - the node is covered by at least one elevation layer and if the node
+ * doesn't have an elevation texture yet
+ * - a color texture is missing
+ *
+ *
+ * @param {Object} context
+ * @param {TileMesh} node - The node to subdivide.
+ *
+ * @returns {boolean} False if the node can not be subdivided, true
+ * otherwise.
+ */
+ static hasEnoughTexturesToSubdivide(context, node) {
+ for (const e of context.elevationLayers) {
+ if (!e.frozen && e.ready && e.tileInsideLimit(node, e) && !node.material.isElevationLayerLoaded()) {
+ // no stop subdivision in the case of a loading error
+ if (node.layerUpdateState[e.id] && node.layerUpdateState[e.id].inError()) {
+ continue;
+ }
+ return false;
+ }
+ }
+
+ for (const c of context.colorLayers) {
+ if (c.frozen || !c.visible || !c.ready) {
+ continue;
+ }
+ // no stop subdivision in the case of a loading error
+ if (node.layerUpdateState[c.id] && node.layerUpdateState[c.id].inError()) {
+ continue;
+ }
+ if (c.tileInsideLimit(node, c) && !node.material.isColorLayerLoaded(c)) {
+ return false;
+ }
+ }
+ return true;
+ }
+}
+
+export default TiledGeometryLayer;
diff --git a/src/Main.js b/src/Main.js
index c95a00627e..a68bcab255 100644
--- a/src/Main.js
+++ b/src/Main.js
@@ -1,7 +1,8 @@
export { default as Coordinates, UNIT } from './Core/Geographic/Coordinates';
export { default as Extent } from './Core/Geographic/Extent';
-export { GeometryLayer, ImageryLayers } from './Core/Layer/Layer';
-export { STRATEGY_MIN_NETWORK_TRAFFIC, STRATEGY_GROUP, STRATEGY_PROGRESSIVE, STRATEGY_DICHOTOMY } from './Core/Layer/LayerUpdateStrategy';
+export { ImageryLayers } from './Layer/Layer';
+export { default as GeometryLayer } from './Layer/GeometryLayer';
+export { STRATEGY_MIN_NETWORK_TRAFFIC, STRATEGY_GROUP, STRATEGY_PROGRESSIVE, STRATEGY_DICHOTOMY } from './Layer/LayerUpdateStrategy';
export { default as GlobeView, GLOBE_VIEW_EVENTS, createGlobeLayer } from './Core/Prefab/GlobeView';
export { default as PlanarView, createPlanarLayer } from './Core/Prefab/PlanarView';
export { default as PanoramaView, createPanoramaLayer } from './Core/Prefab/PanoramaView';
diff --git a/src/Process/3dTilesProcessing.js b/src/Process/3dTilesProcessing.js
index 7c80250a4e..fac2c00b80 100644
--- a/src/Process/3dTilesProcessing.js
+++ b/src/Process/3dTilesProcessing.js
@@ -222,8 +222,9 @@ function _cleanupObject3D(n) {
n.remove(...n.children);
}
-export function pre3dTilesUpdate(context, layer) {
- if (!layer.visible) {
+// this is a layer
+export function pre3dTilesUpdate(context) {
+ if (!this.visible) {
return [];
}
@@ -240,26 +241,26 @@ export function pre3dTilesUpdate(context, layer) {
// Since we simply push in this array, the first item is always
// the oldest one.
const now = Date.now();
- if (layer._cleanableTiles.length
- && (now - layer._cleanableTiles[0].cleanableSince) > layer.cleanupDelay) {
+ if (this._cleanableTiles.length
+ && (now - this._cleanableTiles[0].cleanableSince) > this.cleanupDelay) {
// Make sure we don't clean root tile
- layer.root.cleanableSince = undefined;
+ this.root.cleanableSince = undefined;
let i = 0;
- for (; i < layer._cleanableTiles.length; i++) {
- const elt = layer._cleanableTiles[i];
- if ((now - elt.cleanableSince) > layer.cleanupDelay) {
- cleanup3dTileset(layer, elt);
+ for (; i < this._cleanableTiles.length; i++) {
+ const elt = this._cleanableTiles[i];
+ if ((now - elt.cleanableSince) > this.cleanupDelay) {
+ cleanup3dTileset(this, elt);
} else {
// later entries are younger
break;
}
}
// remove deleted elements from _cleanableTiles
- layer._cleanableTiles.splice(0, i);
+ this._cleanableTiles.splice(0, i);
}
- return [layer.root];
+ return [this.root];
}
const boundingVolumeBox = new THREE.Box3();
diff --git a/src/Process/FeatureProcessing.js b/src/Process/FeatureProcessing.js
index d9f9f05d5b..ebe2a5b1fa 100644
--- a/src/Process/FeatureProcessing.js
+++ b/src/Process/FeatureProcessing.js
@@ -1,5 +1,5 @@
import * as THREE from 'three';
-import LayerUpdateState from '../Core/Layer/LayerUpdateState';
+import LayerUpdateState from '../Layer/LayerUpdateState';
import CancelledCommandException from '../Core/Scheduler/CancelledCommandException';
import ObjectRemovalHelper from './ObjectRemovalHelper';
diff --git a/src/Process/GlobeTileProcessing.js b/src/Process/GlobeTileProcessing.js
index 9b6fa6c8ba..c134f45fdb 100644
--- a/src/Process/GlobeTileProcessing.js
+++ b/src/Process/GlobeTileProcessing.js
@@ -42,15 +42,6 @@ export function preGlobeUpdate(context, layer) {
// pre-sse
context.camera.preSSE = _preSSE(context.view);
-
- const elevationLayers = context.view.getLayers((l, a) => a && a.id == layer.id && l.type == 'elevation');
- context.maxElevationLevel = -1;
- for (const e of elevationLayers) {
- context.maxElevationLevel = Math.max(e.options.zoom.max, context.maxElevationLevel);
- }
- if (context.maxElevationLevel == -1) {
- context.maxElevationLevel = Infinity;
- }
}
const vT = new THREE.Vector3();
diff --git a/src/Process/LayeredMaterialNodeProcessing.js b/src/Process/LayeredMaterialNodeProcessing.js
index 6f586ca266..4a2f927e09 100644
--- a/src/Process/LayeredMaterialNodeProcessing.js
+++ b/src/Process/LayeredMaterialNodeProcessing.js
@@ -1,7 +1,7 @@
import { l_ELEVATION, l_COLOR, EMPTY_TEXTURE_ZOOM } from '../Renderer/LayeredMaterialConstants';
-import { chooseNextLevelToFetch } from '../Core/Layer/LayerUpdateStrategy';
-import LayerUpdateState from '../Core/Layer/LayerUpdateState';
-import { ImageryLayers } from '../Core/Layer/Layer';
+import { chooseNextLevelToFetch } from '../Layer/LayerUpdateStrategy';
+import LayerUpdateState from '../Layer/LayerUpdateState';
+import { ImageryLayers } from '../Layer/Layer';
import CancelledCommandException from '../Core/Scheduler/CancelledCommandException';
import { SIZE_TEXTURE_TILE } from '../Provider/OGCWebServiceHelper';
import { computeMinMaxElevation } from '../Parser/XbilParser';
diff --git a/src/Process/PanoramaTileProcessing.js b/src/Process/PanoramaTileProcessing.js
index 418378b9c6..db6d9fd37c 100644
--- a/src/Process/PanoramaTileProcessing.js
+++ b/src/Process/PanoramaTileProcessing.js
@@ -38,6 +38,6 @@ export function panoramaSubdivisionControl(maxLevel, textureSize) {
return false;
}
- return _isTileBiggerThanTexture(context.camera, textureSize, layer.quality || 1.0, node);
+ return _isTileBiggerThanTexture(context.camera, textureSize, layer.options.quality || 1.0, node);
};
}
diff --git a/src/Process/PlanarTileProcessing.js b/src/Process/PlanarTileProcessing.js
index 4e25ddf292..7e35c7bb34 100644
--- a/src/Process/PlanarTileProcessing.js
+++ b/src/Process/PlanarTileProcessing.js
@@ -24,17 +24,6 @@ function _isTileBigOnScreen(camera, node) {
return (dim.x >= 256 && dim.y >= 256);
}
-export function prePlanarUpdate(context, layer) {
- const elevationLayers = context.view.getLayers((l, a) => a && a.id == layer.id && l.type == 'elevation');
- context.maxElevationLevel = -1;
- for (const e of elevationLayers) {
- context.maxElevationLevel = Math.max(e.options.zoom.max, context.maxElevationLevel);
- }
- if (context.maxElevationLevel == -1) {
- context.maxElevationLevel = Infinity;
- }
-}
-
export function planarSubdivisionControl(maxLevel, maxDeltaElevationLevel) {
return function _planarSubdivisionControl(context, layer, node) {
if (maxLevel <= node.level) {
diff --git a/src/Process/PointCloudProcessing.js b/src/Process/PointCloudProcessing.js
index 53df6562d1..465ac015b4 100644
--- a/src/Process/PointCloudProcessing.js
+++ b/src/Process/PointCloudProcessing.js
@@ -87,9 +87,9 @@ function markForDeletion(elt) {
}
export default {
- preUpdate(context, layer, changeSources) {
+ preUpdate(context, changeSources) {
// Bail-out if not ready
- if (!layer.root) {
+ if (!this.root) {
return [];
}
@@ -99,27 +99,27 @@ export default {
context.camera.height /
(2 * Math.tan(THREE.Math.degToRad(context.camera.camera3D.fov) * 0.5));
- if (layer.material) {
- layer.material.visible = layer.visible;
- layer.material.opacity = layer.opacity;
- layer.material.transparent = layer.opacity < 1;
- layer.material.size = layer.pointSize;
+ if (this.material) {
+ this.material.visible = this.visible;
+ this.material.opacity = this.opacity;
+ this.material.transparent = this.opacity < 1;
+ this.material.size = this.pointSize;
}
// lookup lowest common ancestor of changeSources
let commonAncestorName;
for (const source of changeSources.values()) {
- if (source.isCamera || source == layer) {
+ if (source.isCamera || source == this) {
// if the change is caused by a camera move, no need to bother
// to find common ancestor: we need to update the whole tree:
// some invisible tiles may now be visible
- return [layer.root];
+ return [this.root];
}
if (source.obj === undefined) {
continue;
}
// filter sources that belong to our layer
- if (source.obj.isPoints && source.obj.layer == layer) {
+ if (source.obj.isPoints && source.obj.layer == this) {
if (!commonAncestorName) {
commonAncestorName = source.name;
} else {
@@ -137,11 +137,11 @@ export default {
}
}
if (commonAncestorName) {
- return [layer.root.findChildrenByName(commonAncestorName)];
+ return [this.root.findChildrenByName(commonAncestorName)];
}
// Start updating from hierarchy root
- return [layer.root];
+ return [this.root];
},
update(context, layer, elt) {
diff --git a/src/Process/SubdivisionControl.js b/src/Process/SubdivisionControl.js
deleted file mode 100644
index ea223cfedf..0000000000
--- a/src/Process/SubdivisionControl.js
+++ /dev/null
@@ -1,37 +0,0 @@
-export default {
- preUpdate: (context, layer) => {
- context.colorLayers = context.view.getLayers(
- (l, a) => a && a.id == layer.id && l.type == 'color');
- context.elevationLayers = context.view.getLayers(
- (l, a) => a && a.id == layer.id && l.type == 'elevation');
- },
-
- hasEnoughTexturesToSubdivide: (context, layer, node) => {
- // Prevent subdivision if node is covered by at least one elevation layer
- // and if node doesn't have a elevation texture yet.
- for (const e of context.elevationLayers) {
- if (!e.frozen && e.ready && e.tileInsideLimit(node, e) && !node.material.isElevationLayerLoaded()) {
- // no stop subdivision in the case of a loading error
- if (node.layerUpdateState[e.id] && node.layerUpdateState[e.id].inError()) {
- continue;
- }
- return false;
- }
- }
-
- // Prevent subdivision if missing color texture
- for (const c of context.colorLayers) {
- if (c.frozen || !c.visible || !c.ready) {
- continue;
- }
- // no stop subdivision in the case of a loading error
- if (node.layerUpdateState[c.id] && node.layerUpdateState[c.id].inError()) {
- continue;
- }
- if (c.tileInsideLimit(node, c) && !node.material.isColorLayerLoaded(c)) {
- return false;
- }
- }
- return true;
- },
-};
diff --git a/src/Process/TiledNodeProcessing.js b/src/Process/TiledNodeProcessing.js
index d3817bac7b..3fe0ab30be 100644
--- a/src/Process/TiledNodeProcessing.js
+++ b/src/Process/TiledNodeProcessing.js
@@ -2,6 +2,7 @@ import Extent from '../Core/Geographic/Extent';
import Coordinates from '../Core/Geographic/Coordinates';
import CancelledCommandException from '../Core/Scheduler/CancelledCommandException';
import ObjectRemovalHelper from './ObjectRemovalHelper';
+import TiledGeometryLayer from '../Layer/TiledGeometryLayer';
const center = new Coordinates('EPSG:4326', 0, 0, 0);
@@ -40,7 +41,7 @@ export function requestNewTile(view, scheduler, geometryLayer, extent, parent, l
return scheduler.execute(command).then((node) => {
node.add(node.OBB());
- geometryLayer.onTileCreated(geometryLayer, parent, node);
+ geometryLayer.onTileCreated(node);
return node;
});
}
@@ -110,7 +111,7 @@ export function processTiledGeometryNode(cullingTest, subdivisionTest) {
if (isVisible) {
let requestChildrenUpdate = false;
- if (node.pendingSubdivision || subdivisionTest(context, layer, node)) {
+ if (node.pendingSubdivision || (TiledGeometryLayer.hasEnoughTexturesToSubdivide(context, node) && subdivisionTest(context, layer, node))) {
subdivideNode(context, layer, node);
// display iff children aren't ready
node.setDisplayed(node.pendingSubdivision);
diff --git a/src/Provider/TileProvider.js b/src/Provider/TileProvider.js
index 88114c1f2c..320be8e05a 100644
--- a/src/Provider/TileProvider.js
+++ b/src/Provider/TileProvider.js
@@ -47,7 +47,7 @@ function executeCommand(command) {
const { sharableExtent, quaternion, position } = builder.computeSharableExtent(extent);
const south = sharableExtent.south().toFixed(6);
- const segment = layer.segments || 16;
+ const segment = layer.options.segments || 16;
const key = `${builder.type}_${layer.disableSkirt ? 0 : 1}_${segment}_${level}_${south}`;
let geometry = Cache.get(key);
diff --git a/src/Renderer/ColorLayersOrdering.js b/src/Renderer/ColorLayersOrdering.js
index bca62979fa..0df3348fff 100644
--- a/src/Renderer/ColorLayersOrdering.js
+++ b/src/Renderer/ColorLayersOrdering.js
@@ -1,4 +1,4 @@
-import { ImageryLayers } from '../Core/Layer/Layer';
+import { ImageryLayers } from '../Layer/Layer';
function updateLayersOrdering(geometryLayer, imageryLayers) {
var sequence = ImageryLayers.getColorLayersIdOrderedBySequence(imageryLayers);
diff --git a/src/Renderer/ThreeExtended/PlanarControls.js b/src/Renderer/ThreeExtended/PlanarControls.js
index 844ec8c49d..32a38336f3 100644
--- a/src/Renderer/ThreeExtended/PlanarControls.js
+++ b/src/Renderer/ThreeExtended/PlanarControls.js
@@ -210,7 +210,7 @@ function PlanarControls(view, options = {}) {
this.update = function update(dt, updateLoopRestarted) {
// We test if camera collide to geometry layer or too close to ground and ajust it's altitude in case
if (this.handleCollision) { // We check distance to the ground/surface geometry. (Could be another geometry layer)
- this.view.camera.adjustAltitudeToAvoidCollisionWithLayer(this.view, view.getLayers(layer => layer.type === 'geometry')[0], this.minDistanceCollision);
+ this.view.camera.adjustAltitudeToAvoidCollisionWithLayer(this.view, this.view.tileLayer, this.minDistanceCollision);
}
// dt will not be relevant when we just started rendering, we consider a 1-frame move in this case
if (updateLoopRestarted) {
diff --git a/test/unit/geometrylayer.js b/test/unit/geometrylayer.js
new file mode 100644
index 0000000000..9662284b3e
--- /dev/null
+++ b/test/unit/geometrylayer.js
@@ -0,0 +1,19 @@
+import assert from 'assert';
+import * as THREE from 'three';
+import GeometryLayer from '../../src/Layer/GeometryLayer';
+import ColorLayer from '../../src/Layer/ColorLayer';
+
+describe('GeometryLayer', function () {
+ const geometry = new GeometryLayer('geometry', new THREE.Group());
+ const color = new ColorLayer('color');
+
+ it('should attached a color layer', function () {
+ geometry.attach(color);
+ assert.equal(geometry.attachedLayers.length, 1);
+ });
+
+ it('should detached a color layer', function () {
+ geometry.detach(color);
+ assert.equal(geometry.attachedLayers.length, 0);
+ });
+});
diff --git a/test/unit/layer.js b/test/unit/layer.js
new file mode 100644
index 0000000000..fc12ecbc7c
--- /dev/null
+++ b/test/unit/layer.js
@@ -0,0 +1,65 @@
+import assert from 'assert';
+import Layer, { ImageryLayers } from '../../src/Layer/Layer';
+import ColorLayer from '../../src/Layer/ColorLayer';
+
+describe('Layer', function () {
+ it('should emit an event on property changed', function () {
+ const layer = new Layer('testId', 'testType');
+ layer.defineLayerProperty('test', 0);
+ layer.addEventListener('test-property-changed', (e) => {
+ assert.equal(e.type, 'test-property-changed');
+ assert.equal(e.previous.test, 0);
+ assert.equal(e.new.test, 1);
+ });
+ layer.test = 1;
+ });
+});
+
+describe('ImageryLayers', function () {
+ const layers = [
+ new ColorLayer('l0'),
+ new ColorLayer('l1'),
+ new ColorLayer('l2'),
+ new ColorLayer('l3'),
+ ];
+
+ layers[0].sequence = 0;
+ layers[1].sequence = 1;
+ layers[2].sequence = 2;
+ layers[3].sequence = 3;
+
+ it('should return all layers id in order', function () {
+ const res = ImageryLayers.getColorLayersIdOrderedBySequence(layers);
+ assert.equal(res[0], 'l0');
+ assert.equal(res[1], 'l1');
+ assert.equal(res[2], 'l2');
+ assert.equal(res[3], 'l3');
+ });
+
+ it('should move the layer l3 to the first index', function () {
+ ImageryLayers.moveLayerToIndex(layers[3], 0, layers);
+ const res = ImageryLayers.getColorLayersIdOrderedBySequence(layers);
+ assert.equal(res[0], 'l3');
+ assert.equal(res[1], 'l0');
+ assert.equal(res[2], 'l1');
+ assert.equal(res[3], 'l2');
+ });
+
+ it('should move the layer l1 to the second index', function () {
+ ImageryLayers.moveLayerDown(layers[1], layers);
+ const res = ImageryLayers.getColorLayersIdOrderedBySequence(layers);
+ assert.equal(res[0], 'l3');
+ assert.equal(res[1], 'l1');
+ assert.equal(res[2], 'l0');
+ assert.equal(res[3], 'l2');
+ });
+
+ it('should move the layer l0 to the last index', function () {
+ ImageryLayers.moveLayerUp(layers[0], layers);
+ const res = ImageryLayers.getColorLayersIdOrderedBySequence(layers);
+ assert.equal(res[0], 'l3');
+ assert.equal(res[1], 'l1');
+ assert.equal(res[2], 'l2');
+ assert.equal(res[3], 'l0');
+ });
+});
diff --git a/test/unit/layeredmaterial.js b/test/unit/layeredmaterial.js
index 93d21563db..aea7077074 100644
--- a/test/unit/layeredmaterial.js
+++ b/test/unit/layeredmaterial.js
@@ -1,5 +1,5 @@
import assert from 'assert';
-import LayerUpdateState from '../../src/Core/Layer/LayerUpdateState';
+import LayerUpdateState from '../../src/Layer/LayerUpdateState';
import { updateLayeredMaterialNodeImagery } from '../../src/Process/LayeredMaterialNodeProcessing';
describe('material state vs layer state', function () {
diff --git a/test/unit/layeredmaterialnodeprocessing.js b/test/unit/layeredmaterialnodeprocessing.js
index fd7e16e151..03cd525b4c 100644
--- a/test/unit/layeredmaterialnodeprocessing.js
+++ b/test/unit/layeredmaterialnodeprocessing.js
@@ -5,7 +5,7 @@ import TileMesh from '../../src/Core/TileMesh';
import Extent from '../../src/Core/Geographic/Extent';
import OBB from '../../src/Renderer/ThreeExtended/OBB';
import LayeredMaterial from '../../src/Renderer/LayeredMaterial';
-import { STRATEGY_MIN_NETWORK_TRAFFIC } from '../../src/Core/Layer/LayerUpdateStrategy';
+import { STRATEGY_MIN_NETWORK_TRAFFIC } from '../../src/Layer/LayerUpdateStrategy';
describe('updateLayeredMaterialNodeImagery', function () {
// Misc var to initialize a TileMesh instance
diff --git a/test/unit/pointcloudprocessing.js b/test/unit/pointcloudprocessing.js
index aeb4516900..bd05ba94ce 100644
--- a/test/unit/pointcloudprocessing.js
+++ b/test/unit/pointcloudprocessing.js
@@ -9,7 +9,7 @@ describe('preUpdate', function () {
const sources = new Set();
assert.equal(
layer.root,
- PointCloudProcessing.preUpdate(context, layer, sources)[0]);
+ PointCloudProcessing.preUpdate.call(layer, context, sources)[0]);
});
it('should return root if no common ancestors', () => {
@@ -21,7 +21,7 @@ describe('preUpdate', function () {
sources.add(elt2);
assert.equal(
layer.root,
- PointCloudProcessing.preUpdate(context, layer, sources)[0]);
+ PointCloudProcessing.preUpdate.call(layer, context, sources)[0]);
});
it('should return common ancestor', () => {