LuciadRIA Release notes

We now expose the Editor used in EditController and CreateController using a getter. This new functionality is used SampleCreateController inside ria-toolbox-core, to correctly initialize the parent controller when a delegate controller is provided.

It is now possible to load GLTF files that reference data stored in external files or embedded as base64‑encoded content.

Fixed an issue where the environment map was not displayed correctly on maps with a large field-of-view.

Fixed an issue where 3D tiles could sometimes be painted twice if the dataset contained a mix of meshes and point clouds.

Fixed an issue where enabling GraphicsEffects.antiAliasing would result in the map having a black background rather than a transparent one.

Fixed an issue where picking on OGC 3D Tiles caused a WebGPU error when Physics-Based Rendering was enabled.

You can now use OGCFilterEncoder.createOGCFilterEncoder to create an encoder for your OGCExpression based on the correct WFSVersion. The encoder will use the proper OGC XML filter format.

The new TileSet3DLayerConstructorOptions#attributeFilter property allows filtering attributes of HSPC datasets. See Tuning performance and visual quality of point clouds.

WFSFeatureStoreCreateOptions#splitBBOX allows you to choose whether the BBOX filter should be split when it contains the antimeridian. When set to true, two BBOX filters will be created and combined with an OR operator. When set to false, a single BBOX filter crossing the antimeridian will be created.

Partial support for the military standard APP-6E has been added. It is now possible to create and visualize MilitarySymbol instances for the APP-6E military standard.

APP-6E support is currently limited to the Cyberspace icon symbols. All supported symbol sets are listed in the supported military standards article .

To visualize the supported symbols, you can run the "Military Symbology Overview" sample, located in samples/symbology/allsymbols within the release directory.

You can now implement custom a custom Editor that not only edits the shape of a feature, but also its properties. EditHandle and EditController can now emit EditProperty events. By default, these events are not emitted. You need to implement this behavior in your custom editor. You can use this event to create "edit property" undoables in your application. For more information, check the API documentation of EditHandle, EditController, and their new "EditProperty" events.

UndoManager now emits "Undo" and "Redo" events when an undo or redo operation is performed. Previously, only change events for the undo and redo stack were emitted. You can use these events to perform custom actions in your application when an undo or redo operation occurs.

You can now visualize icons and parameterized points with enhanced transparency by enabling the IconStyle.transparency and ParameterizedPointPainterConstructorOptions.transparency flags respectively.

Added ImageCaptureUtil to ria-toolbox-core to support reliable map image capture using GPU rendering.

Added the Infinite-Grid tool to the LuciadRIA Toolbox. It renders a GPU-accelerated, infinite reference grid to 3D maps. See toolbox/ria/infinite-grid/README.md for more information.

PickController, and its subclasses SelectController and HoverController, now support asynchronous picking. You can enable asynchronous picking by setting the new async option on the controller to true. For more information, check the API documentation of PickController, SelectController and HoverController.

Added Camera.viewProjectionMatrix to retrieve the camera’s view–projection matrix.

Complex Strokes can now load concurrently in the background, which typically results in significantly faster loading times overall in Chromium-based browsers.

Added support for other HTTP methods (like POST) in UrlStore queries.

RIAMap now offers asynchronous versions of its picking methods. The methods take the same arguments as their synchronous counterparts and return a Promise. Here is a list of the new methods:

• RIAMap.pickClosestObjectAsync
• RIAMap.pickClosestObjectRectangleAsync
• RIAMap.pickAtAsync
• RIAMap.pickAtRectangleAsync

The KMLCodec now decodes ExtendedData into KMLFeature.properties.extendedData. Supported sources: Data, SchemaData and foreign-namespace elements.

GoogleLayer has been removed from the API. It's recommended to use GoogleMapsTileSetModel instead. Check the Differences between GoogleMapsTileSetModel, GoogleImageModel and GoogleLayer article for more information.

LuciadRIA no longer performs its license check at module evaluation time, but rather when a map is first instantiated. This makes it easier to configure the license in your application. Before, you had to ensure the license was correctly configured before any LuciadRIA module was loaded. This could be difficult in some project setups, especially those where you have little to no control over the order in which modules are loaded. Now, you no longer need to worry about module loading order. You just have to make sure the license is configured before you instantiate a map, using the existing\ @luciad/ria/util/License.js API. Existing applications that already configured a LuciadRIA license will continue to work as before. For the optional modules, the license check is performed also at the following API entry points:

• Constructive Geometry
  • ConstructiveGeometryFactory.createEllipsoidal()
  • ConstructiveGeometryFactory.createSpherical()
  • ConstructiveGeometryFactory.createCartesian()
• Panoramics:
  • GeoCanvas.drawPanorama()
• Military Symbology
  • SymbologyProvider.getSymbology()

The loading time for tactical graphics on a LuciadRIA WebGPU map has been significantly improved due to the possibility of concurrent loading (shader compilation) in the background in Chromium-based browsers. This removes the need to initially render tactical graphics using a fast “skeleton” style, and replacing them with the full style once loaded.

Fixed an issue where saveState() and restoreState() calls were not properly delegated in ComposedShapeEditor.

Fix a bug where selected labels didn't get a higher priority than unselected labels.

Fix a bug where trajectories would disappear when switching reference while an animation is playing.

User-configured RIAMap.maxMemoryUsageHint is now correctly applied after a RIAMap.reboot triggered by GPU device loss. Previously, default settings were applied.

In some cases, no terrain was painted in a 1-pixel wide zone around the meridian.

Fixed issue where shadows would sometimes cause artifacts on the map on Mac OS.

KMLUtil.createGroundOverlayLayer now returns a promise for FeatureLayer (previously a promise for Layer).

The non-hardware-accelerated Map implementation has been removed from the API. Both Map and WebGLMap have been deprecated in favor of RIAMap, which leverages WebGPU for hardware-accelerated rendering. It is no longer possible to create non-hardware-accelerated maps or WebGL-based maps. To ease the transition, WebGLMap and Map are now both aliases for the new RIAMap. Any maps created with new Map() or new WebGLMap() will automatically instantiate WebGPU-powered RIAMap instances. We recommend updating your code to use RIAMap directly.

Because of the switch to WebGPU, LuciadRIA now requires a secure context (HTTPS or localhost) to run in web browsers. This is a requirement imposed by the WebGPU specification and enforced by all major web browsers. If your application is currently served over HTTP, you will need to migrate it to HTTPS to continue using LuciadRIA. For more information, check the Set up a secure context for LuciadRIA article.

The constructor options for EditController and CreateController have been aligned with the EditSettings type. To this end, the styles that were previously configured on the options object have been moved to a styles property. For example, the following code:

          const editController = new EditController(layer, feature, {
            handleIconStyle: {
              image: createSquare({
                width: 8,
                height: 8,
                fill: "white",
                stroke: "black",
                strokeWidth: 1
              })
            }
          });
        

should be updated to:

        const editController = new EditController(layer, feature, {
          styles: {
            handleIconStyle: {
              image: createSquare({
                width: 8,
                height: 8,
                fill: "white",
                stroke: "black",
                strokeWidth: 1
              })
            }
          }
        });
      

None of the RIAMap.pick methods report features from TileSet3DLayer anymore. The new asynchronous picking methods do report these features and are the recommended approach. To restore synchronous picking support for TileSet3DLayer, enable the synchronousPicking flag in TileSet3DLayerConstructorOptions. For more information, see Picking on 3D Tiles.

The deprecated MapNavigator methods have been removed from the API. Use the newer pan(), zoom(), rotate() and fit() methods instead.

The built-in LuciadRIA API for creating map borders, axes, and custom drawings on borders has been discontinued. This functionality is now provided by the @luciad/ria-toolbox-map-borders component in the LuciadRIA Toolbox. It offers enhanced support for bordered maps, axis rendering, and custom border drawings.
For more information about this LuciadRIA toolbox component, refer to the How to draw a map with borders article.
For guidance with the migration from the previous API to the LuciadRIA Toolbox, refer to the Migrating to the map-borders component in the LuciadRIA Toolbox article.

The transition from using WebGL for graphics rendering to WebGPU introduced some visual differences compared to the previous versions of LuciadRIA:

• Blending of (semi-)transparent colors now happens in linear color space. In previous LuciadRIA versions, it happened in gamma color space (sRGB). This move solves blending artifacts, but it can make blended colors slightly brighter. This is especially noticeable when rendering thin lines or thin text.
  
• Texture sampling now happens in linear color space. In previous LuciadRIA versions, it happened in gamma color space (sRGB). Like for blending, this move solves minor artifacts, but the texture sampling might look slightly differently than before.
  
• Lighting now happens in linear color space. In previous versions, it happened in gamma color space (sRGB). This move results in a harder but more correct lighting gradient. It can make parts of the lit objects brighter or darker than before.
  
• Image-based lighting now correctly interprets the colors when using a PNG or JPEG as reflection map. In previous versions it interpreted these colors as linear colors, which made the lighting brighter than it should.

It is no longer possible to set a map-wide luminance threshold in BloomEffect. Instead, you can now configure a luminance threshold on each individual BloomStyle. This means that bloom is now only applied to features for which a BloomStyle has been set. Merely configuring a BloomEffect on a RIAMap will no longer have any effect.

The following third party libraries have been updated:

• expected-lite: updated to version 0.9.0
• glu: updated to version 1.3+7
• libjpeg: updated to version 9f
• libwebp: updated to version 1.5.0

The following third party libraries have been dropped:

• glad
• protobuf
• rapidxml-ns

With the switch from WebGL to WebGPU, the following API changes were made:

• The RIAMap.webGLContext property has been removed. Has been removed in favor of RIAMap.webGPUDevice, which means listening for WebGL context lost events is no longer supported. Instead, listen to WebGPU device loss events. See Dealing with WebGPU device losses for more information.
• A new event, "WebGPUDeviceChanged", has been added to the RIAMap API.
• The RIAMap's "PostRender" event now uses GPUTexture.

A framework dedicated to the editing of military symbology has been added to LuciadRIA. The LuciadRIA API now includes:

• The MilitarySymbologyCreateController, to improve user experience and correctness when creating multi-point MilitarySymbol tactical graphic instances.
• A MilitarySymbologyEditController to improve user experience and correctness when editing multi-point MilitarySymbol tactical graphic instances.
• A MilitarySymbologyEditor. It is used under the hood of the new controllers, and ensures correct editing behaviour enforcing the necessary constraints for the different tactical graphics.

With the introduction of this dedicated military symbology editing framework, the previous default editing mechanism using the ShapeEditor will break. All tactical graphics will be editable as if they were plain Polyline shapes, without any behavior specific to military symbology.

For more information about using this new editing framework, see the migration guide. For more information about the behavior of this new editor for different types of tactical graphics, see the creation and editing article.