LuciadCPillar Release notes

• PbrShadingModelPbrShadingModelPbrShadingModel: physically based rendering (PBR), using the map's light and its reflection map. This is the default, so glTF assets and OGC 3D Tiles are shaded physically without extra configuration.
• SimpleShadingModelSimpleShadingModelSimpleShadingModel: simple diffuse lighting from the map's light, without PBR materials or reflections.
• No shading model: the object keeps its plain albedo and is not affected by the map's light.

Set the shading model through MeshStyleMeshStyleMeshStyle for OGC 3D Tiles and through FeatureCanvas::drawIcon3DFeatureCanvas::drawIcon3DFeatureCanvas::drawIcon3D for 3D icons.

See the Configure shading models article for more information.

The same asset with (1) no shading model, (2) a simple shading model and (3) a physically based one.

• Light: configurable scene lighting using a headlight, a fixed directional light, or sunlight at a given time.
• Atmosphere: this effect offers a physically-based Rayleigh/Mie scattering sky (ScatteringAtmosphereModelScatteringAtmosphereModelScatteringAtmosphereModel) alongside the existing gradient sky (GradientAtmosphereModelGradientAtmosphereModelGradientAtmosphereModel).
• Depth of Field: an effect that blurs the scene outside a focus plane.
• Fog: an effect that fades geometry into a fog color with distance and altitude, with an optional sun-glow tint.
• Bloom: an effect that makes shapes and objects carry a BloomStyleBloomStyleBloomStyle glow, controlled by a map-wide strength and softness.
• Environment map: an effect that supports a skybox and image-based reflections that physically-based rendering (PBR) objects, such as 3D icons and OGC 3D Tiles, reflect and are lit by.

A mesh of Marseille, visualized with the new graphics effects.

How effects are configured has also changed: each effect is now set through an immutable model created with a fluent builder, instead of individual property setters. For the effects that already existed before version 2026.1, this is a source-incompatible change.

See the Configure Map Effects guide for the full API and per-effect guidance.

LuciadCPillar can now decode and visualize Gaussian splats. Gaussian splatting is a novel scene-representation and 3D rendering technique that uses a large amount of tiny 3D Gaussian primitives ("splats") to create photorealistic views of real-world scenes.

A Gaussian splatting dataset of a restaurant.

LuciadCPillar can consume Gaussian splats as OGC 3D Tiles with glTF payloads that make use of the KHR_gaussian_splatting or KHR_gaussian_splatting_compression_spz_2 extension of the glTF specification.

You can visualize a Gaussian splatting dataset by decoding it with Ogc3DTilesModelDecoderOgc3DTilesModelDecoderOgc3DTilesModelDecoder and passing the resulting model to a TileSet3DLayerTileSet3DLayerTileSet3DLayer. Use TileSet3DLayer::Builder::gaussianSplatsStyleTileSet3DLayer::Builder::gaussianSplatsStyleTileSet3DLayer::Builder::gaussianSplatsStyle (or TileSet3DLayer::setGaussianSplatsStyleTileSet3DLayer::setGaussianSplatsStyleTileSet3DLayer::setGaussianSplatsStyle) with a GaussianSplatsStyleGaussianSplatsStyleGaussianSplatsStyle to customize the styling of the Gaussian splats, using expressions for example, and to tweak other performance-related settings.

LuciadCPillar can now project a static image, a continuous stream of video frames, or 360-degree panoramas onto the map. To show such projections, you create a ProjectedImageryLayerProjectedImageryLayerProjectedImageryLayer backed by an IProjectedImageryModelIProjectedImageryModelIProjectedImageryModel, such as the ready-made ProjectedVideoModelProjectedVideoModelProjectedVideoModel for a live video source, or PanoramaModelPanoramaModelPanoramaModel for 360-degree panoramas, and add it to the LayerListLayerListLayerList of the map. For more details about using this feature, see this guide.

A drone video projected onto a map.

To perform a WMS GetFeatureInfo request, you need a WmsGetFeatureInfoContextWmsGetFeatureInfoContextWmsGetFeatureInfoContext, obtained from a WmsRasterLayerWmsRasterLayerWmsRasterLayer.

To perform a WMTS GetFeatureInfo request, you need a WmtsGetFeatureInfoContextWmtsGetFeatureInfoContextWmtsGetFeatureInfoContext, obtained from a WmtsRasterLayerWmtsRasterLayerWmtsRasterLayer.

• Map::setReferenceMap::setReferenceMap::setReference: to change the Map's reference
• Map::propertyReferenceMap::propertyReferenceMap::propertyReference: to detect changes to the Map's reference

You can now ask the map to repaint with Map::invalidateMap::invalidateMap::invalidate.

An example where this would help is a Map::IRendererCallbackMap::IRendererCallbackMap::IRendererCallback that updates the camera on every paint. Such a callback can leave the camera alone once the view is at rest, which lets the map stop painting, and call Map::invalidateMap::invalidateMap::invalidate on new user input to get it painting again.

addGeometryProperty(name, mainGeometry) additionally attaches the GeometryDataAnnotationGeometryDataAnnotationGeometryDataAnnotation when mainGeometry is true, which removes the need for an IDataAnnotationFactoryIDataAnnotationFactoryIDataAnnotationFactory in the common case of a feature type with a single geometry. Pass false for the additional geometry properties of a type that has several geometries. A data type has at most one main geometry.

The shortcuts add scalar properties of a primitive type. Keep using DataType::Builder::addPropertyDataType::Builder::addPropertyDataType::Builder::addProperty for anything else, such as list-valued properties, properties carrying their own annotations, or properties of which the value type is another data type.

See Describing the feature structure in a data model for more details.

Turning the samples into NuGet packages does not need one either. The generateNugetPackagesOfSamples.bat script and the per sample command in the installation instructions now use dotnet pack, so the .NET SDK that builds the samples is all you need. The script also reports a failed package instead of skipping it silently.

This makes it possible to combine LuciadCPillar with graphics produced by another renderer in the same textures, so the map and that content occlude each other correctly where they overlap.

Fixed an issue where Map::getCameraMap::getCameraMap::getCamera and the view transformation returned by Map::getViewMapTransformationMap::getViewMapTransformationMap::getViewMapTransformation used slightly different camera positions while the map was being navigated. Combining their results could then be inconsistent. Map::getMapScaleMap::getMapScaleMap::getMapScale, Map::getMapBoundsMap::getMapBoundsMap::getMapBounds, Map::getVisibleAreaMap::getVisibleAreaMap::getVisibleArea and Map::queryFeaturesMap::queryFeaturesMap::queryFeatures could momentarily disagree with the camera in the same way.

Map::getCameraMap::getCameraMap::getCamera, the view transformation and these queries now consistently reflect the same view of the map, so their results can be safely combined, also while the map is being navigated.

A number of control measure Line symbols in APP-6D and MIL-STD 2525D no longer display the generic PL ("phase line") label. Previously these symbols were labeled twice: once with PL followed by the first uniqueDesignation modifier, and once with the abbreviation specific to the symbol followed by the second uniqueDesignation modifier. They are now labeled only with their own abbreviation, followed by the first uniqueDesignation modifier.

The change affects the following symbols. All of them belong to symbol set 25 (Control Measure); the symbol code is given for each symbol.

• APP-6D
  • Light Line: 110200
  • Final Coordination Line: 140700
  • Limit Of Advance: 140900
  • Line Of Departure: 141100
  • Line Of Contact: 140200
  • Probable Line Of Deployment: 141200
  • Bridgehead Line (BL): 141400
  • Holding Line: 141500
  • Release Line: 141600
• MIL-STD 2525D
  • Light Line: 110200
  • Final Coordination Line: 140700
  • Limit Of Advance: 140900
  • Line Of Departure / Line Of Contact: 141100
  • Line Of Contact: 140200
  • Probable Line Of Deployment: 141200
  • Bridgehead Line (BL): 141400
  • Holding Line (HL): 141500
  • Release Line: 141600

Error messages of the OGC service formats (WMS, WMTS, WFS and LTS) are now prefixed with the format-specific error code, for example CapabilitiesSourceError - Error while connecting to WMTS url '...'.

See the Managing memory usage guide on how to configure LuciadCPillar's memory management.

• Read the current settings with getModel()
• Build a changed copy and apply it with setModel(...)
• Turn the effect on or off with setEnabled(...)

The individual property setters these effects used to expose, such as AmbientOcclusionEffect::setPower(...), have been removed. Those properties are now configured on the model passed to setModel(...), through the matching method on its builder.

The atmosphere changes the most: its sky and horizon colors now live in a GradientAtmosphereModelGradientAtmosphereModelGradientAtmosphereModel, and the effect's model is the polymorphic AtmosphereModelAtmosphereModelAtmosphereModel base type, which also has the new ScatteringAtmosphereModelScatteringAtmosphereModelScatteringAtmosphereModel variant.

Eye dome lighting's window (a pixel count) is now unsigned rather than a signed int: on EyeDomeLightingModelEyeDomeLightingModelEyeDomeLightingModel it is a uint32_t in C++, surfacing as uint in C# and long in Java/Kotlin.

See the Configure map effects guide for the full API and per-effect guidance.

This changes the requirements for the samples: building them now requires the .NET 8 SDK, and running them requires the .NET 8 Desktop Runtime. See the system requirements for details.

The Luciad.CPillar.SDK binding is not affected: it still targets netstandard2.0, so it can be used from both .NET Framework and .NET applications.

The reusable sample libraries (Luciad.CPillar.CSharp.Integration.Wpf, Luciad.CPillar.CSharp.Samples.Common and Luciad.CPillar.CSharp.Samples.Wpf.Common) target both net472 and net8.0-windows. You can therefore still reference the sample integration code (such as the WPF WpfMapControl) from a .NET Framework 4.7.2 project, and the sample source remains compatible with .NET Framework 4.7.2.

The C# language version used to build the samples has been raised from 7.0 to 7.3.

The airspace limitation came from hosting the map in a separate Win32 child window (through a WindowsFormsHost), which Windows composites as an opaque rectangle on top of every WPF pixel in that area. Because of that, no WPF element (a popup, tooltip, adorner, overlay or panel) could appear over the map. The reworked integration composites the map inside WPF's own visual tree, so WPF content can now be drawn on top of the map.

As an illustration, the WPF samples now place components directly on top of the map, such as the coordinate readout (the location control) that previously had to sit in a bar below the map.

The new WpfMapControl is a drop-in replacement for the previous one. It keeps the same public API and the same WpfMapControlViewModel as its DataContext, so application code that uses it does not need to change.

The previous WindowsFormsHost based integration still works and will keep working, but it is no longer included in the shipped samples.

To adopt the new integration, replace your copy of the integration_wpf sample library with the updated version (the one whose WpfMapControl renders through a D3DImage) and rebuild. No changes to your application code are required.

For Qt Quick, QQuickMapItem is a drop-in replacement: application code that uses it does not need to change.

For Qt Widgets, the new QMapWidget replaces the old QMapWindow and works fundamentally differently: it is now a QWidget (a QRhiWidget), whereas QMapWindow was a QVulkanWindow. To upgrade, add the QMapWidget directly to your widget layout, instead of hosting a QMapWindow through QWidget::createWindowContainer. See the updated sample_qt_widget for the new usage.

The previous integration approach keeps working in this release, but it relies on behavior that is no longer guaranteed and may stop working in a future release. We recommend migrating to the reworked sample integration libraries (integration_common, integration_qt_quick and integration_qt_widgets).