LuciadRIA Release notes

• you pan away from the selected feature over a long distance
• a FeatureLayer.transformer is reset and the original features put into the model had no IDs
• a FeatureLayer.filter is reset and the original features put into the model had no IDs

Fixed a bug where draping on meshes could produce blurry results if the meshes was not set as part of terrain.

HSPC Pack files are now supported on HSPCTilesModel and TileSet3DLayer.

3D Cartesian references, for example the "LUCIAD:XYZ" reference or those created with ReferenceProvider.createCartesianReference, can now be used as the world reference on a WebGLMap. This allows you to visualize non-georeferenced data on a 3D WebGLMap.

The use of a WebGLMap with a 3D Cartesian reference is demonstrated in the 3D icon sample, which now displays a separate panel when you select an icon. The panel uses a 3D Cartesian world reference.

A WebGLMap with a 3D Cartesian reference has certain limitations and conventions to take into account. For more information, please see the article on Cartesian views.

You can now set the property facetCulling on a Icon3DStyle. The facetCulling property defines the polygons that are not visible to the camera and will be discarded.

The precision of WKT references that use an ellipsoidal version of the Lambert azimuthal equal area projection has been improved. This affects the following EPSG codes:

• 3035
• 3571 to 3576
• 5633, 5635, 5636, 5638
• 6931, 6932
• 9039
• 9947

WebGLMap.globeColor has new behaviour.

The globeColor can now be set to null to avoid painting a globe entirely. This also disables 2D vector and raster painting. Only data that does not need to be draped will be rendered on the map.

On top of that, you can now set the alpha value of your globeColor to 0, which will render a fully transparent globe in the absence of raster layers. The fully transparent globe still allows you to drape 2D shapes and images on top of it.

Setting a globeColor with an alpha values between 0 (exclusive) and 1 (inclusive) will render the globe with a fully opaque color.

When loading glTF files they are now also automatically converted from their Y-up axis system to the LuciadRIA axis system, as a result you will in most cases no longer need to apply rotations to have your model oriented correctly.

For compatibility reasons Icon3DStyle.legacyAxis was added. Setting this property to true restores the behavior as it was. In the LuciadRIA 2023.1 release this property defaults to true, so you do not need to update existing code. From LuciadRIA 2024.0 onwards the default will be set to false, it is recommended to already adapt your code for the changes in the axis system.

The versions property in WFSFeatureStoreConstructorOptions, WFSCapabilitiesFromUrlOptions, and WFSFeatureStoreCreateOptions are not anymore of the "string" type but WFSVersion enumerations.

The allowedVersions property passed to WFSCapabilities.fromURL is not anymore of the "string" but WFSVersion enumerations.

The WMS version property in WMSImageModelConstructorOptions, and WMSTileSetModelConstructorOptions is not anymore of the "string" type. Versions are now represented as WMSVersion enumerations.

The allowedVersions property passed to WMSCapabilities.fromURL, WMTSCapabilities.fromURL is not anymore of the "string" but WMSVersion enumerations.

      createFromCapabilities(capabilities, featureTypeName, { versions: ["2.0.0"] });
    

      createFromCapabilities(capabilities, featureTypeName, { versions: [WFSVersion.V200] });
    

• Korean Datum 1985
• Macao 1920

WMTS support is extended to handle Tile Matrix Sets of which the first Tile Matrix has more than 8 columns and 8 rows, only in the case of a WebGL-enabled maps.

RasterTileSetLayer can now display a red hatched rectangle instead of any actual imagery data when zoomed out to a fair distance from the data. More information can be found in the article Why does my imagery layer show a red (hatched) rectangle on a WebGL map?

You can customize the style of the raster outline drawn when zoomed out far from the data. For more information please refer to the article Learn how to visualize and style raster data using a RasterTileSetLayer. and the API documentation of RasterStyle, where you can find the new fillStyle and lineStyle properties.

You can now use complex stroke lines with a width in world units, for example meters. See the ComplexStrokedLineStyle.uom property for details.

You can also scale your icon or text decorations in world size, see the size property on their factory method options.

World-sized complex stroke lines are not supported in a non-WebGL Map.

• A sample's package.json now mentions "type": "module".
• A sample's tsconfig.json now sets "moduleResolution": "nodenext".
• Imports in samples now also contain the file extension (.js or .jsx)

The creation of WMTSTileSetModel now can create a RasterTileSetModel that does not have a quad-tree tile set structure.

Users of a WebGL enabled map are not affected by this change as the rendering supports this type of tile set structures.

Users of a Canvas map are affected as this map only supports raster tile sets that have a quad-tree structure. You need to update the call for the WMTS model creation to restrict use to Tile Matrix Sets that have a quad-tree. You can do this by adding the option useQuadTreeOnly: true in the WMTSTileSetModelCreateOptions when calling the method createFromURL or createFromCapabilities.

The RasterTileSetModel can now represent tile sets that are not a quad-tree. It allows to create tile sets where the bounds on different levels are not exactly the same and for which the number of rows and columns is not a power of two with respect to the top level. The bounds for each level in the tile set must be aligned in the top-left corner.

The constructor options for the following raster models are affected by this change. They now use a new way to express the tile set structure.

• RasterTileSetModelConstructorOptions
• URLTileSetModelConstructorOptions
• WMTSTileSetModelConstructorOptions
• FusionTileSetModelConstructorOptions

To maintain backward compatibility these constructor options have an equivalent with Deprecated in their name, i.e., RasterTileSetModelConstructorDeprecatedOptions for RasterTileSetModelConstructorOptions. When using TypeScript type declarations you may need to update your code to use the deprecated options type.

You can now use world-sized lines for non-draped 3D lines. Before, these were always draped on terrain.

The behavior is now in line with other shape painting: the line will be draped if you explicitly enable draping in your style, or if the line is 2D (Z=0 and depth=0). Otherwise, the line is not draped.

If you have 3D lines with a world size, these were always draped before, so if you want to keep that behavior, specify draped: true in your ShapeStyle.

You can now use complex stroke lines for non-draped 3D lines. Before, these were always draped on terrain.

The behavior is now in line with other shape painting: the line will be draped if you explicitly enable draping in your style, or if the line is 2D (Z=0 and depth=0). Otherwise, the line is not draped.

If you have 3D lines with complex strokes, these were always draped before, so if you want to keep that behavior, specify draped: true in your ShapeStyle.

In addition, the width of draped complex strokes is now much more stable, also when looking at the horizon.

Non-draped pixel-sized 3D lines with complex strokes are oriented towards the viewer. Draped strokes, or world-sizes strokes are never screen-oriented.

Keep in mind that certain deformations of your pattern is expected, particularly when looking along the line.

Example of complex strokes on 3D lines.

The default hierarchy icon line color for Sea Mine symbols is now always black #000000 instead of the symbology style's color (MilSymStyle.color).

This improves consistency with the other symbols where the symbology style's color is only used to color offset lines, direction of movement arrows and other icon decorations.

The rendering of APP-6B Sea Mine symbols has been improved. The outline of their icon is now painted in the MilSymStyle.color, where it used to be painted in the affiliation color. If you want the effect as in the image below, you need to add color: "#000000", in your MilSymStyle. The default color of the outline is white ("#FFFFFF").

APP-6B Sea Mines before the change.

APP-6B Sea Mines after the change.

The rendering of Sea Mine symbols has been improved when their fill is disabled for various standards. When their symbol fill is disabled, the hierarchy representation is no longer filled, revealing additional details such as the 'N' icon inside the "Ground (Bottom) Non-Mine Mine-Like Contact" MIL-STD-2525c symbol. This makes the Sea Mine symbols more recognisable. This change affects the Sea Mine symbols in the following standards: APP-6D, MIL-STD-2525c, MIL-STD-2525d.

Unfilled MIL-STD-2525c Sea Mines before the change.

Unfilled MIL-STD-2525c Sea Mines after the change.

LuciadRIA now contains a sample that illustrates how to handle IFC datasets. The geometry is loaded as OGC 3D Tiles, the metadata information is loaded via a GeoJSON dataset. The sample shows how to combine geometry and metadata into a single application.

Screenshot of the IFC sample application.

LuciadRIA now supports draping of 2D raster and vector data on OGC 3D Tiles data. You can use the new DrapeTarget enumeration on objects such as a ShapeStyle, IconStyle and RasterStyle to indicate whether the data needs to be draped on 3D Tiles and/or on terrain. You can also choose which 3D Tiles layers need to be taken into account for draping by means of a new isDrapeTarget flag on TileSet3DLayer. The use of this API is demonstrated in the "OGC 3D Tiles" sample, which has been extended with a walking tour draped on top of the Marseille 3D tiles mesh data. For more information, see the Draping on 3D Tiles article.

An area of interest that is draped on an OGC 3D Tiles layer with a city model.

• For point symbolizers:
  • The use of SVG images through the icon provider.
  • The use of UOM-aware stroke widths for marks.
• For line symbolizers:
  • The use of line joins (mitre, round or bevel) and line caps (butt, round or square) in strokes.
  • The combination of a stroke with a graphic stroke (dash-array, graphic rotation).
  • The use of displacement and anchor points for the graphics in a graphic stroke.
  • The use of perpendicular offset without gaps or overlaps at the line joins.
  • The use of UOM-aware graphic fill for strokes.
• For polygon symbolizers:
  • The use of the same improved stroke support as for line symbolizers.
  • The use of UOM-aware graphic fills.
  • The use of UOM-aware displacement.
  • The use of UOM-aware perpendicular offset.

For a complete overview of the supported SLD styling capabilities, see the SLD styling - Supported versions and capabilities article.

A park area from the OGC Symbology Encoding sample, combining several of the line and polygon styling improvements. A first polygon symbolizer uses a black fill with a displacement to apply a shadow effect. A second polygon symbolizer defines the park area’s fill and outer stroke, which is a combination of a dashed stroke and an icon with a shifted anchor point. A third polygon symbolizer with a negative perpendicular offset is used to draw the smaller green area on top.

• SelectController
• ContextMenuController
• PanController
• RotateController
• ZoomController
• HoverController

You can now add bloom to shapes. Bloom is a glow effect that you can use to make shapes appear very bright, and draw focus to them.

Airspaces in the Trajectory sample with Bloom enabled (left) and bloom disabled (right).

For more information, see BloomStyle and BloomEffect. You can also read the "Bloom effect" section in Configuring WebGL Map effects.

      // Let TS compiler know that feature's shape is a point and its properties can contain the population field.
      interface CityProperties { name: string; population?: number};
      const cityFeature = new Feature<Point, CityProperties>(point, { name: 'Leuven'});
      // Let TS compiler know that the store can accept features with a polyline or a polygon shape and any properties.
      const store = new MemoryStore<Feature<Polyline | Polygon, FeatureProperties>>(data: [polylineFeature]);
    

• libcurl: updated to version 7.86.0
• openssl: updated to version 1.1.1s
• zlib: updated to version 1.2.13

• Use the search bar to easily find a certain symbol by name or code.
• Use the "Anchor Points" layer to see the anchor points and their order used to create the symbol.

• We introduced two new MilSymStyle properties that define the appearance of tactical graphics: skeleton to indicate that you want a simplified style without decorations for your tactical graphics (false by default), and body to indicate that you prefer the full, correct styling for your tactical graphic (true by default).
• We offer the possibility to make your MilitarySymbologyPainterConstructorOptions. stylePaintState -dependent.

You can now enable GPU texture compression on TileSet3DLayer for OGC 3D Tiles mesh data. This can greatly reduce the amount of GPU memory needed, improve performance and stability.

Enable when displaying meshes with large textures, such as reality capture reconstructions. By default, texture compression is enabled.
Disable when displaying meshes with lookup textures, such as CAD models.

If your environment does not support GPU texture compression, setting the flag has no effect. Use the "Device Support" sample to verify if texture compression is supported on your device.

You can now set WebGLMap.maxMemoryUsageHint.cpuMB and WebGLMap.maxMemoryUsageHint.gpuMBto values higher than 4000MB. Previously, this would be capped at 4000MB. This allows you to use more memory in your application. It is intended for software that is run on high-end clients.

It is intended for use on high-end devices with enough available memory. Setting this number too high can cause instability.

We replaced the PointCloudStyle.scalingMode option with PointCloudStyle.pointSize, which gives you more control over the point cloud dot size.

You can still use the existing scalingMode option for backwards compatibility.

LuciadRIA now supports Hexagon Smart Point Clouds (HSPC) in 2D EPSG references.

Before, we supported only HSPC datasets in 3D geocentric (EPSG:4978) coordinates, and non-referenced datasets.

Note that we still recommend to process your HSPC data in 3D geocentric coordinates, for optimal streaming performance. When relying on Hexagon's HSPC conversion functionality available in myVR, you can do this for example with these conversion parameters: mHSPCConverter --source_projection EPSG:7415 --output_projection EPSG:4978.

We did various improvements to our point cloud rendering visual quality and performance, in particular for Hexagon Smart Point Cloud (HSPC). For details, see the documentation of PointCloudStyle and the documentation articles Tuning performance and visual quality of point clouds and Visualize Hexagon Smart Point Cloud (HSPC) data.

Performance
We improved raw painting performance of all point clouds. Your map will be more interactive and fluent when loading lots of points.
We added a new option PointCloudStyle.pointShape which influences how points are drawn, and how overlap between points is handled. When using SPHERE, overlap result in a high quality visual coverage of your data, but at the cost of performance. We propose to use DISC when you have a small point size as it improves performance. The default is DISC for HSPC, SPHERE for OGC 3D Tiles.

World-sized dots
Next to the existing PIXEL_SIZE and ADAPTIVE_WORLD_SIZE, there is a new scaling mode WORLD_SIZE. This mode is particularly useful for HSPC. It allows points to grow larger when you get close to them, based on a physical size in meters. This helps creating a visually closed surface up-close instead of having interspersed small dots. For details see the pointSize property on PointCloudStyle.

Incremental and partial tile painting
We now display HSPC point cloud tiles partially, based on their level-of-detail. This avoids highly visible transitions between tiles of different level-of-detail. This is automatically enabled for HSPC.

Gap-filling post-processing effect
We added an optional point cloud post-processing effect that intelligently fills up small gaps between points. This helps creating a visually closed surface by in-painting gaps of 1 or 2 pixels. You can enable it using the gapFill property on PointCloudStyle.

Additionally, the GARSFormatPrecision, MGRSFormatPrecision and MGRSFormatType enums have been moved into their own modules: @luciad/ria-milsym/text/gars/GARSFormatPrecision, @luciad/ria-milsym/text/mgrs/MGRSFormatPrecision and @luciad/ria-milsym/text/mgrs/MGRSFormatType

      [webpack-cli] TypeError: cli.isMultipleCompiler is not a function
    

• an incorrect prime meridian shift
• a prime meridian shift that was applied twice
• incorrect projection parameters

• EPSG:2065
• EPSG:5513
• EPSG:8352

• MIL-STD-2525D: 01 - Air
• MIL-STD-2525D: 02 - Air Missile
• MIL-STD-2525D: 05 - Space
• MIL-STD-2525D: 06 - Space Missile
• MIL-STD-2525D: 30 - Sea Surface
• MIL-STD-2525D: 35 - Sea Subsurface
• APP-6C: 01 - Air
• APP-6C: 02 - Air Missile
• APP-6C: 05 - Space
• APP-6C: 06 - Space Missile
• APP-6C: 30 - Sea Surface
• APP-6C: 35 - Sea Subsurface

• MIL-STD-2525D: 35 - Sea Subsurface
• APP-6C: 01 - Air
• APP-6C: 02 - Air Missile
• APP-6C: 05 - Space
• APP-6C: 06 - Space Missile
• APP-6C: 30 - Sea Surface
• APP-6C: 35 - Sea Subsurface

• MIL-STD-2525D: 20 - Land Installations
• APP-6C: 20 - Land Installations
• APP-6D: 11 - Land Civilian Organization
• APP-6D: 20 - Land Installation
• APP-6D: 25 - Control Measure

• MIL-STD-2525D: 20 - Land Installations
• APP-6C: 20 - Land Installations
• APP-6D: 11 - Land Civilian Organization

• MilSymStyle.symbolIcon defaults to true.
• MilSymStyle.symbolFrameEnabled defaults to true.
• MilSymStyle.symbolFill defaults to true.
• MilSymStyle.symbolFillPercentage defaults to 1,0.
• MilSymStyle.affiliationColorEnabled defaults to true.

Image showing the effect of the new style properties on an icon.

Introduced the PBRSettings property on Icon3DStyle and MeshStyle. This allows the use of the PBR material information in glTF files to visualize objects in a more realistic, physically based way.

• it can now handle glTF files with multiple textures; previously, only the first encountered texture was used for visualization,
• the texture wrapping is now also parsed and used for visualization.

Added new API to allow facet culling of meshes in OGC 3D Tiles. The new API is available in MeshStyle.facetCulling. By default, nothing changes and all meshes are painted without culling. This means both the back and the front of each triangle is painted. This is the most robust, but also at a slight cost of rendering performance.

Backface culling can result in performance improvements. It only renders the front of each triangle. This also allows you to visualize the interior of a room while observing it from the outside, which can be useful in some applications.

Front-face culling can be used in cases where the orientation of the triangles of the dataset are inverted. This depends on the dataset itself.

If you have a read-only store (without an add, put or remove), FeatureLayer.editable now defaults to false. You'll also get an error if you set editable to true if the layer is backed by a readonly store.

On top of that, EditController and CreateController now respect FeatureLayer.editable. These controllers will now deactivate if you try to use them with a layer that is not editable. They will also deactivate if the layer is not visible in the layer tree (LayerTreeNode.visibleInTree).

• "HoverChanged" event: Event hook that is called when the set of objects that is being hovered over changes.
• Map.hoveredObjects: set of objects which are currently displayed as "hovered".
• Map.hoverObjects(): Updates the set of objects which are displayed as "hovered".
• Map.isHovered(): Determine whether a particular object on a layer is displayed as "hovered".
• Map.clearHovered(): Clear the current set of hovered objects.

You can now draw "world-sized" icons in LuciadRIA. The size of these icons is expressed in a length unit, such as meters or feet, instead of in pixels. The icons don't have a fixed size on the screen, but grow or shrink when you zoom in and out on the map.

In the illustration, the red icon has a size in pixels. It always has the same size on the screen. The green icon has a size in meters. It grows and shrinks when you zoom in and out.

You can draw world-sized icons with IconStyle.uom. When you set it to a specific unit of measure, the values of IconStyle.width, IconStyle.height, IconStyle.offsetX and IconStyle.offsetY will be interpreted in that unit of measure.

Alternatively, you can specify a length unit inside a string value for IconStyle.width, IconStyle.height, IconStyle.offsetX and IconStyle.offsetY. For example:

const worldSizedIconStyle = {
  url: "http://example.com/icon.png",
  width: "50m",
  height: "50m"
};

You can now visually compare multiple layer sets by swiping or flickering using SwipeController and FlickerController.

Swiping is done by dragging a swipe line horizontally or vertically, hiding the right/bottom part of the first layer set and the left/top part of the other layer set.

Flickering is done by (quickly) clicking the mouse button and toggling visibility of two or more layer sets. You can customize these controllers or use them to implement actions that swipe or flicker programmatically. These visual change detection tools work in 2D WebGL and 3D WebGL. As an illustration, you can enable the swipe or flicker controller in many of our samples with a button in the upper left corner.

Because WebAssembly instances are instantiated asynchronously, the following API was changed:

• MapNavigator.fit/pan/zoom/rotate: You now always have to wait for the returned promise to resolve, if you want to be sure that the navigation action completed.
• ExpressionFactory expressions created by this factory are now validated when they are visualized, instead of when they are created.
• Expressions set on TileSet3DLayer.meshStyle and TileSet3DLayer.pointCloudStyle are now validated once the layer is added to the map, instead of when the layer is created.

WebAssembly is supported on all browsers supported by LuciadRIA.

        const abortController = new AbortController();
        const animationPromise = AnimationManager.putAnimation(map.cameraAnimationKey, myAnimation, false,
        abortController.signal);
        // abort the animation after 0.5 seconds
        setTimeout(() => {
        abortController.abort(); // this will abort the animation, instead of animationPromise.cancel()
        }, 500);
      

TypeError: self.cancelTile is not a function

      const polyline = createPolyline(reference, [[0,0], [5,2]]);
      const polygon = createPolygon(reference, [[0,0,1000], [5,2,1000], [0,4,1000]]);
    

• EPSG:2065
• EPSG:5221
• EPSG:5513
• EPSG:5514
• EPSG:8352
• EPSG:8353

• MIL-STD-2525b: G*G*OLAV--****X - Friendly Aviation
• MIL-STD-2525b: G*G*OLAA--****X - Friendly Airborne
• MIL-STD-2525c: G*G*OLAV--****X - Aviation
• MIL-STD-2525c: G*G*OLAA--****X - Airborne
• MIL-STD-2525d: 10002500001514010000 - Friendly Airborne/Aviation
• APP-6A: G*C*MOLAF-***** - Friendly Aviation
• APP-6A: G*C*MOLAA-***** - Friendly Airborne
• APP-6B: G*C*MOLAF-***** - Friendly Aviation
• APP-6B: G*C*MOLAA-***** - Friendly Airborne
• APP-6C: 10002500001513000000 - Airborne/Aviation Axis Of Advance
• APP-6D: 10002500001514010000 - Friendly Airborne/Aviation

• MIL-STD 2525b: 2.X.4.3.1.1 - Rectangular Target
• MIL-STD 2525c: 2.X.4.3.1.1 - Rectangular Target
• APP-6C: 10002500002306000000 - Rectangular Target

1. Indicate the origin point A
2. Indicate a point B on the minor radius of the first sector
3. Indicate a point C on the left side of the first sector
4. Indicate a point D on the right side of the first sector Note: the major radius is defined by the point (C or D) that is furthest away from B.
5. Repeat steps 2, 3 and 4 for the subsequent sectors.

1. MIL-STD-2525d
2. APP-6D

• MIL-STD-2525b: Wind Plot - WAS-WP----P----
• MIL-STD-2525c: Wind Plot - WAS-WP----P----
• APP-6A: Wind Barb - W*A*W-----*****
• APP-6B: Wind Barb - W*A*W-----*****
• APP-6C: Wind Barb - 10004500001126000000

      const editController = new EditController(layer, feature, {
        handleIconStyle: {
          image: IconFactory.rectangle({ // from samples/common (@luciad/ria-sample-common/IconFactory)
            stroke: "rgb(0,0,0)",
            strokeWidth: 1,
            fill: "rgb(255,255,255)",
            width: 10,
            height: 10
          }),
          width: "10px",
          height: "10px",
          zOrder: 10
        }
      });
    

• number - the loading strategy refreshes every n milliseconds.
• Date object - the loading strategy will refresh at that time.
• null - the loading strategy never refreshes.

• Placemark items
• Network links
• Container elements
• Ground overlays
• KMZ data can now be parsed.

You can now have transparent objects in a TileSet3DLayer, for example based on an OGC 3D Tiles mesh dataset. The transparency can originate from transparent pixels in an rgba texture, transparent colors in a vertex attribute, or transparent colors from a color expression.

Since painting with transparency can have a performance impact, it is disabled by default. You can enable it with the new flag transparency on TileSet3DLayer. When disabled, any transparent surfaces will just be opaque.

• PointLabelPosition.SOUTH for labels drawn on the bottom border
• PointLabelPosition.WEST for labels drawn on the left border

Cartesian references which can be created with ReferenceProvider.createCartesianReference can now be used as the world reference on a WebGLMap. This allows you to visualize non-georeferenced data on a WebGLMap, e.g. timeline, image defined in CRS:1, etc.

The use of a WebGLMap with a Cartesian reference is demonstrated in the timeline, vertical view and image viewer sample.

A WebGLMap with a Cartesian reference has the following limitations:

• For raster data the reference of the data and the map must be equal, e.g. both must use CRS:1.
• World sized styling is not supported.

A WebGLMap with a Cartesian reference can be used to create this timeline for example.

      layer.workingSet.on("QueryFinished", () => {
        layer.workingSet.get().forEach(kmlFeature => kmlFeature.properties.visibility = true);
        layer.painter.invalidateAll();
      });
    

      function SubClass() {
        SuperClass.call(this, arg1, arg2);
        this._field = arg1;
      }

      SubClass.prototype = Object.create(SuperClass.prototype);
      SubClass.prototype.constructor = SubClass;
    

You'll have to change the implementation of the constructor, like this:

    function SubClass() {
      var _this = Reflect.construct(SuperClass, [arg1, arg2], this.constructor);
      _this._field = arg1;
      return _this;
    }

    SubClass.prototype = Object.create(SuperClass.prototype);
    SubClass.prototype.constructor = SubClass;
    

Note that Reflect.construct is not available on Internet Explorer. If you're targeting Internet Explorer, you will have to make sure that a polyfill for Reflect.construct is available.

If you're using ES6 classes, no changes are necessary.

`FeatureLayer` now processes a limited amount of model updates before the next frame, rather that after. This reduces visual jitter when you adjust camera based on a changing `Feature`, for example when following a moving airplane.

If you do more changes than can be processed before the next frame, the rest will be done asynchronously and be visible in later frames only. The amount that can be processed is dependent on the changes and your browser performance.

LuciadRIA is now shipped as a set of ES6 modules, packaged as npm packages. You can find the npm packages in the packages/es6 directory of the release.

Once you've installed the packages into an npm registry, you can use install and use them like any other npm package:

Use npm install to install LuciadRIA packages

The packages include Typescript definition files with documentation for all the public API.

• The LuciadRIA API is now distributed as ES6 modules. For backward compatibility, the AMD version of the API is still included. In order to run LuciadRIA on a browser that does not support ES6 module loading, the code has to be bundled. For the LuciadRIA samples this is done using webpack, as demonstrated in samples/common/webpack.config.
• LuciadRIA folder structure has been changed to match npm style. LuciadRIA classes are located under the packages folder. AMD classes can be found in the packages/amd folder and ES6 classes can be found in the packages/es6 folder. LuciadRIA, Defense Symbology and Advanced GIS Engine modules are stored in their own directories separetely.
• The samples have also been converted to the ES6 module structure. A ready-to-run version is already included in the release and can be accessed by running the startSampleServer.[sh|bat] script. If you want to make changes to the samples, you can modify the source code and run the webpack dev server to inspect your changes. See the developer guide for more information the samples.

• Mode OcclusionMode.VISIBLE_ONLY shows only the part of a shape that is not obscured by other 3D data. This is the default.
• Mode OcclusionMode.ALWAYS_VISIBLE shows the entire shape even if behind by other 3D data. The shape will appear in front of other objects.
• Mode OcclusionMode.OCCLUDED_ONLY shows only the part of the shape that is behind other 3D data. You typically use this to display obscured shapes in combination with another style that uses "VISIBLE" mode.

• Draped content will not show up properly when underground.
• Some imagery tiles can be missing underground, near the "horizon".
• When disabling or re-enabling the above terrain constraint, the bottom-most layer will reload its data.

• When zoomed out, the back of the globe may be visible through the front.
• When switching the fully opaque to transparent or back, the layer will reload its data.

• The painter supports the following elements for TextSymbolizer: IsAligned, IsRepeated, Gap, InitialGap, PerpendicularOffset.
• It now supports Rotation, AnchorPoint and Opacity for Graphic elements.
• Support for GraphicStroke elements has been added.
• The painter can handle the uom attribute from LineSymbolizer and PolygonSymbolizer elements to draw lines in world size units.
• It now supports Mark, Size, Rotation and Opacity for Graphic elements used in a GraphicFill element.
• Added support for the SVG format, SVG images can now be used with both InlineContent and OnlineResource elements.

• A createFromCapabilities method accepting the capabilities and the name of the desired data set
• A createFromURL method accepting the service URL and the name of the desired data set

• Loading times have been improved by using tight-fitting oriented bounds for tile selection. This means less tiles will be downloaded.
• Framerate while loading has been improved by removing and optimizing some cpu-intensive operations. This also improves loading latencies.
• Overall memory consumption was significantly reduced.
• TileSet3DLayer follows the map's allowed memory usage (see WebGLMap.maxMemoryUsageHint, and other release note below), resulting in caching that adapts to the dataset, as well as avoiding crashes.