The platform
Everything one engine does, in depth.
Each part below is the same native core and the same API. Each section says what it does, the specifics behind it, and where to read more.
Rendering
Generally availableOne engine draws all three dimensions.
MapCore renders raster imagery, elevation and vector features as a flat 2D map, a 2.5D map with terrain relief, or full 3D. There is no second engine and no second data path. Your application creates the native window and hands MapCore the handle; from there the viewport is the interface to everything on screen.
- Viewport types: 2D — 2.5D once a DTM is loaded — 3D, and a 1D vertical projection of a route.
- Many cameras per viewport, one active. Yaw, pitch, roll, scale and visible area; in 3D also look-at point, field of view, height limits and clip distances.
- Render one viewport, a list, or all of them. Render to a bitmap instead of the screen for print and capture; terrain-only or terrain-plus-objects.
- Built for heavy scenes: a bounded amount of change per frame to stay fluid, a pending-changes report with flush-on-demand, and an overload mode that drops flagged items when the scene gets too heavy.
More from the reference application
Elevation
Generally availableFrom one height query to full terrain analysis.
Load a DTM layer and the same scene becomes terrain. The elevation data is not only for looks: it backs a query engine built as a pyramidal quad-tree, so a query can trade accuracy for speed by choosing a level of detail. Ask for a single ground height, or ask what a sensor on that hill can actually see.
- Height at a coordinate returned with the terrain normal; heights sampled along a polyline; route length that accounts for surface relief.
- Lowest and highest points inside an area; camera footprint on the ground, or camera parameters recovered from a known footprint.
- DTM formats: DTED, DEM, Arc ASCII Grid, XYZ — converted to MapCore’s native format for performance, or read directly as raw layers.
- Ellipsoid-to-orthometric height conversion and magnetic declination are built in.
- A terrain groups any number of layers and exactly one DTM at a time, with per-layer draw priority, visibility scale range and transparency.
More from the reference application
Data
Generally availableYour data, read where it lives.
MapCore reads raster, elevation, vector, 3D model, material and traversability layers. Each kind can be read in place with no conversion, converted to a pre-tiled native format with a resolution pyramid, streamed from the Map Layer Server, or — for raster and elevation — fetched from an OGC web service. The styling you already have travels with the data.
- Raster through GDAL, with missing levels of detail built as overviews; raw layers can span folders of tiles and grow at runtime.
- OGC web services: WMS, WMTS, WCS, and CSW catalogue discovery, with HTTP authentication.
- Vector from GDAL/OGR sources such as shapefiles, and from PostGIS; SQL WHERE-clause filtering on any layer.
- Styles from SLD, ArcGIS LYRX, MapLibre and KML/KMZ, and built-in S-52 styling for S-57 nautical charts.
- A persistent disk cache for remote layers: usable on a slow link, and usable at all once the link is gone.
3D models
Generally availableBuildings and meshes as part of the scene.
MapCore loads 3D model layers into the same terrain your maps live in: native model layers, server-hosted model layers, and raw formats. It also builds 3D buildings by extruding vector footprints. Where a model layer covers ground, it can suppress the DTM and raster beneath it so there is no double surface.
- A 3D model layer family — native, native-server and raw — plus a 3D extrusion family that lifts buildings out of vector data.
- 3D Tiles and glTF2 support, without Draco compression and with JPEG textures only. Raw 3D Tiles based on glTF2 is not supported on Android.
- Model layers can resolve conflicts with the DTM and raster layers underneath them.
Imagery
Generally availableFrom raw imagery to measured ground.
Imagery is processed at display time, for a whole viewport or a single layer, so the operator tunes what they see without reprocessing a file. Beyond display, the SDK carries the photogrammetry that turns sensor images into measured ground, and the production tools that turn raw collections into map layers.
- Filters — smoothing and sharpening presets or a custom kernel — plus brightness, contrast, gamma, white balance and negative.
- Histogram equalisation, fit and normalisation, including a histogram of the visible area that follows the user as they pan and zoom.
- Multispectral band remapping on raw raster layers.
- Camera models for affine, frame and LOROP imagery, plus user-defined models and RPC.
- Production: orthophoto from LOROP imagery, mosaics from orthophotos, DTM from point clouds, and image-to-image correlation.
Object world
Generally availableEverything that moves, over everything that doesn't.
The map underneath is static. What your operators care about is not: tracks, markers, annotations, military symbols, sensor footprints, 3D models. In MapCore those are graphical objects, each composed from items governed by a scheme. Change a shared scheme once and every object using it updates.
- Symbolic items — polylines, arcs, polygons, ellipses, rectangles, arrows, pictures, text and line-of-sight presentations, with styles, colours, top-most drawing and terrain attachment.
- Physical items — meshes, projectors, and directional, point and spot lights, rendered as part of the 3D scene.
- APP-6(D) and MIL-STD-2525(C) symbology are built in; the application initialises support for each standard it needs.
- An object is defined by its overlay, its scheme, and one or more locations — in world coordinates, screen coordinates, or a mix — each carrying user data, a draw priority, and visible, detectable and selected states.
- Overlays save to a file or a memory buffer and reload. Collections group objects across overlays so show, hide or move applies to the whole group at once.
Overlay manager
Generally availableOne object database. Every window.
The overlay manager is the top container, and it synchronizes objects across viewports. One manager can be rendered by many viewports at once, in different dimensions and different projections, and a change to an object is reflected in all of them. You maintain a single object database and let each window present it — at its own scale, its own projection, its own dimensionality, or hidden entirely.
- One overlay manager, many viewports. Move a track once and every window agrees.
- Windows do not have to match: a 2D UTM plan view and a 3D geographic view render the same objects.
- Any viewport can act as the global map; other viewports register as local maps and have their footprints drawn on it.
- Conditional selectors control what appears where — by scale, location, viewport, object state, or a boolean combination.
Calculations
Generally availableGeospatial maths that runs with no map on screen.
The calculation component is server-oriented. It works without any of MapCore’s viewing capabilities, so you can run conversions, geometry and terrain queries with no map window open at all. This is not a claim on a slide: MapCore ships a calculations-only WebAssembly build with no rendering in it.
- Terrain queries: line of sight between points, area of sight from a point, area-to-area sight, ray intersection, heights along a polyline, and route length over relief.
- Traversability map layers, plus queries that return traversability along a line and line and arrow items that colour themselves by the result.
- A geometric module on 2D and 3D primitives: intersection, distance, spatial relations, point-in-figure, lengths and areas, triangulation, convex hull, and polygon booleans.
- A geographic module on the ellipsoid: great-arc distance and bearing, a point at a given distance and azimuth, and shortest distance to a line or arc.
- Conversions across datums, projections and grids using a seven-parameter Helmert transformation, plus any EPSG/SRID.
More from the reference application
Edit mode
Generally availableThe interaction layer you would otherwise write twice.
MapCore is an API with no GUI of its own, and that is deliberate: your product owns its look. But somebody still has to write pan, rotate, dynamic zoom, a measuring tool, a sight-line tool, and vertex-by-vertex editing for every shape your operators can draw — then write them again for the 3D window. Edit Mode is that module, already built. Everything it does can also be built directly on the base MapCore APIs. It exists so you don’t have to spend the quarter doing it.
- Map tools out of the box: distance and direction measurement including magnetic azimuth, map rotation, dynamic zoom, panning, and sight-line evaluation — in both 2D and 3D viewports.
- Vertex operations in three modes: initialize to create, re-initialize to append, edit to modify.
- Per-item editing that knows what the shape is — polylines and polygons break segments and move vertices, rectangles stay rectangular, ellipses and arcs edit radii and opening angle, text moves and rotates.
- Your rules stay in your code: an event callback on any operation, permission to allow or deny any operation, and constraints declared in advance such as an ellipse’s maximum radius or a polygon’s maximum point count.
- It reads window mouse and keyboard events and also exposes an API your own toolbar can call, so it fits behind your UI instead of replacing it.
Where it runs
| Language | Runs on |
|---|---|
| C# | Windows · WPF · WinForms |
| TypeScript | Browser · Node.js · WebAssembly |
| Java | Android · arm64-v8a |
| C++ | Windows · Linux x86_64 + aarch64 · Android |
Put a map inside your application.
Read the guides and the full API reference — everything you need to start building.