@maptiler/3d
Advanced tools
With this MapTiler SDK module, you can add 3D objects to your basemap with plenty of customizations from glTF/glb files! Those can be meshes, groups of meshes, point clouds and a mix of all these.
📖 Documentation 📦 NPM Package 🌐 Website 🔑 Get API Key
From NPM and using the ES module, in a terminal, in your project:
npm install @maptiler/3d
Then to import:
import { Layer3D } from "@maptiler/3d";
// or
import * as maptiler3d from "@maptiler/3d";
From CDN and using the UMD bundle, in the <head></head> section of your HTML file:
<script src="https://cdn.maptiler.com/maptiler-3d/<VERSION>/maptiler-3d.umd.js"></script>
To generate the typedoc documentation and serve them locally:
npm run doc && npx http-server docs
With the UMD bundle (on CDN), the namespace for this project is maptiler3d. So the layer3D class is available at maptiler3d.Layer3D.
An instance of Layer3D is a custom type of layer that contain a 3D scene, where multiple 3D meshes and lights can be added. Like any other layer in MapTiler SDK/Maplibre GL JS, it must have an ID and then be added to a Map instance:
// Create a map;
const map = new Map({
container: "map",
// ...
});
// Waiting that the map is ready. You can also wait for the "load" event.
map.on("ready", () => {
// Create a Layer3D and add it
const layer3D = new maptiler3d.Layer3D("custom-3D-layer");
map.addLayer(layer3D);
});
Once created and added, a mesh can be added. In this version any glTF and their binary counterpart glb files can be added.
To add a mesh:
// The call can be awaited for the whole download of the mesh to complete
const item3D = await layer3D.addMeshFromURL(
// ID to give to this mesh, unique within this Layer3D instance
"flatiron",
// The URL of the mesh
"https://example.com/meshes/flatiron_building.glb",
// A set of options, these can be modified later
{
lngLat: { lat: 40.74072950731568, lng: -73.98918779556983 }, // can also be an array [lng, lat]
heading: 91.1,
scale: 39.5,
visible: true,
altitude: 74.38,
altitudeReference: maptiler3d.AltitudeReference.GROUND,
}
);
// do stuff with the item 3D...
Add an airplane 3D model to your map using the MapTiler 3D JS Module
Add multiple 3D models to the map with the MapTiler 3D JS Module
Display a building model based on point cloud data on a map with the MapTiler 3D JS Module
Display a 3D building model generated with photogrammetry software with the MapTiler 3D JS Module
Display a 3D building model generated with photogrammetry software with the MapTiler 3D JS Module
Display a point cloud 3D building model on a map with the MapTiler 3D JS Module
Import and play GLTF animations from GLTF files
Listen for mouse events on 3D objects
Apply declarative UI 'states' to 3D objects
Change the pitch and roll of 3d items
For detailed guides, API reference, and advanced examples, visit our comprehensive documentation:
Here are all the options for meshes:
lngLat location of the center of the 3D object, as longitude and latitudealtitude the altitude in meters above the reference point (to the origin of the mesh, that is not always the bottom)altitudeReference reference point of altitude (ground or mean sea level)visible whether the mesh is visiblesourceOrientation applies a correction from the original orientation of the meshscale scaling factor applied to the mesh. Can be a single number for uniform scaling, or an array of three numbers [x, y, z] for non-uniform scaling.heading orientation in degrees (0-360), where 0 and 360 are true north and 90 is eastopacity opacity of the mesh. If the mesh is a group of meshes, this is applied to all the child nodes that can deal with transparencypointSize applicable only to point clouds, set the size of the pointswireframe applicable only to non-point cloud, applies a wireframe rendering to all the child nodes of the mesh that are compatible with the optionstates a set of properties that will be applied on different UI states (hover, active/click). For instance, a mesh could be scaled up on hover.userData a place to store arbitrary data, that can be retrieved at a later stage.transform (only for addMeshFromURL and cloneMesh) a set of props allowing for tweaking of the mesh before it's added to the map. This can be useful if a model internally points in the incorrect direction or if it needs a world space offset without having to tweak LngLat. { rotation: { x, y, z }, offset: { x, y, z } }. These can also be applied when cloning a mesh. Please Note: The offset when cloning a mesh is additive not absolute, it will be added to the world position of the mesh you are cloning.The constructor of the Layer3D class takes two arguments:
Layer3DOptionsHere are more details about the Layer3DOptions type:
type Layer3DOptions = {
/**
* Bellow this zoom level, the meshes are not visible
* Default: 0
*/
minZoom?: number;
/**
* Beyond this zoom level, the meshes are not visible.
* Default: 22
*/
maxZoom?: number;
/**
* Default: true
*/
antialias?: boolean;
/**
* Ambient light color.
* Default: `0xffffff` (white)
*/
ambientLightColor?: ColorRepresentation;
/**
* Ambient light intensity.
* Default: `1`
*/
ambientLightIntensity?: number;
};
Other important types that are exported:
enum AltitudeReference {
/**
* Use the ground as a reference point to compute the altitude
*/
GROUND = 1,
/**
* Uses mean sea level as a reference point to compute the altitude
*/
MEAN_SEA_LEVEL = 2,
}
Example: A mesh that is add with the option altitudeReference being AltitudeReference.GROUND and an altitude of 10 will always "fly" 10 meters above the ground, regardless the terrain or the terrain exaggeration. If the provided altitude were to be a negative number, then it would always be beneath the ground surface by this amount (in meters). This mode is convenient for any item that needs to be positions relatively to the ground: cars, buildings, lap post, etc.
On the other hand, mesh that is add with the option altitudeReference being AltitudeReference.MEAN_SEA_LEVEL and the altitude of 1000 means the item will be at an absolute altitude of 1000 meters (3280 feet) above the mean sea level. If located in a place where the terrain shows mountains higher than 1000 meters, then the mesh will be underneath the ground surface and as such not visible. This mode is more convenient for flying objects such as planes, paraglydings, etc. as those thend to measure altitude with an absolute reference.
enum SourceOrientation {
/**
* The mesh was originaly created in a 3D space that uses the x axis as the up direction
*/
X_UP = 1,
/**
* The mesh was originaly created in a 3D space that uses the Y axis as the up direction
*/
Y_UP = 2,
/**
* The mesh was originaly created in a 3D space that uses the Z axis as the up direction
*/
Z_UP = 3,
}
Note that regardless of the original up axis, this module as well as MapTiler SDK/Maplibre GL JS only deal with 3D spaces that follow the right-hand rule.
type GenericObject3DOptions = {
/**
* Position.
* Default: `[0, 0]` (Null Island)
*/
lngLat?: LngLatLike;
/**
* Altitude above the reference (in meters).
* Default: `0` for meshes, or `2000000` for point lights.
*/
altitude?: number;
/**
* Reference to compute and adjust the altitude.
* Default: `AltitudeReference.GROUND` for meshes and `AltitudeReference.MEAN_SEA_LEVEL` for point lights.
*/
altitudeReference?: AltitudeReference;
/**
* Make the object visible or not.
* Default: `true`
*/
visible?: boolean;
};
export type MeshOptions = GenericObject3DOptions & {
/**
* Rotation to apply to the model to add, as a Quaternion.
* Default: a rotation of PI/2 around the x axis, to adjust from the default ThreeJS space (right-hand, Y up) to the Maplibre space (right-hand, Z up)
*/
sourceOrientation?: SourceOrientation;
/**
* Scale the mesh by a factor. Can be a single number for uniform scaling, or an array of three numbers `[x, y, z]` for non-uniform scaling.
* Default: no scaling added
*/
scale?: number | [number, number, number];
/**
* Heading measured in degrees clockwise from true north.
*/
heading?: number;
/**
* Opacity of the mesh
*/
opacity?: number;
/**
* Point size, applicable only to point clouds.
* Default: 1
*/
pointSize?: number;
/**
* Displays a mesh as wireframe if true (does not apply to point cloud)
* Default: `false`
*/
wireframe?: boolean;
/**
* Animation mode. How the animation should update.
* "manual" puts the responsibility on an external render loop to update.
* "continuous" automatically advances the animation with it's on internal animation loop.
* Default: `continuous`
*/
animationMode?: AnimationMode;
/**
* A set of properties that will be applied on different UI states (`hover`, `active`/`click`).
* For instance, a mesh could be scaled up on hover.
*/
states?: Item3DMeshUIStates;
/**
* A place to store arbitrary data, that can be retrieved at a later stage.
*/
userData?: Record<string, any>;
};
// The name of the state. `hover` is triggered on mouse enter/leave, `active` is triggered on mouse down/up.
export type Item3DMeshUIStateName = "default" | "hover" | "active";
// The properties that can be modified for a given state
export type Item3DMeshUIStateProperties = {
opacity?: number;
scale?: number | [number, number, number]; // note: this is _relative scale_ not absolute scale. Eg the scale in comparison to the items current size.
transform?: Item3DTransform;
heading?: number;
altitude?: number;
lngLat?: LngLatLike;
wireframe?: boolean;
pointSize?: number;
elevation?: number;
};
// The object to provide to the `states` option
export type Item3DMeshUIStates = {
[key in Item3DMeshUIStateName]?: Item3DMeshUIStateProperties;
};
// example
const item = layer3D.addMesh("mesh-id", mesh, {
opacity: 0.5,
states: {
hover: { opacity: 1 },
active: { scale: [2, 2, 2] },
},
});
addMeshFromURL **export type AddMeshFromURLOptions = MeshOptions & {
// wraps the object and transforms it accordingly.
// useful if your model does not point "north" or is not in the position you need it to be.
transform?: {
rotation?: {
x?: number;
y?: number;
z?: number;
};
offset?: {
x?: number;
y?: number;
z?: number;
};
};
};
type PointLightOptions = GenericObject3DOptions & {
/**
* Light color.
* Default: `0xffffff` (white)
*/
color?: ColorRepresentation;
/**
* Intensity of the light.
* Default: `75`
*/
intensity?: number;
/**
* Decay of the light relative to the distance to the subject.
* Default: `0.5`
*/
decay?: number;
};
Here is the list of instance methods of the Layer3D class:
.setAmbientLight(options: {color?: ColorRepresentation, intensity?: number} = {})
To adjust the settings of the ambient light. The type ColorRepresentation means the color can be a number (such as a hex notation 0xff0000, for red), a hex string (such as "#FF0000", for red), or a ThreeJS color (read more about these here).
ℹ️ By default, the ambiant light is white (0xffffff) with an intensity of 0.5.
.addMeshFromURL(id: string, url: string, options: AddMeshFromURLOptions = {}) async
Adds a mesh from a URL to a glTF of glb file, given a mesh ID (will throw if not unique) and a set of options. This method returns an Item3D object that can be modified later on.
.addMesh(id: string, mesh: Mesh | Group | Object3D, options: MeshOptions = {})
Adds a ThreeJS mesh/Group/Object3D, given a mesh ID (will throw if not unique) and a set of options. This method returns a Promise<Item3D> object that can be modified later on.
ℹ️ By default, the mesh will have some settings (if not overwritten by the options):
SourceOrientation.Y_UP0[0, 0]0true.getItem3D(id: string): Item3D | null
Returns the Item3D instance for a given ID. This object can be used to modify the mesh's properties and control animations. See the section bellow for the methods of the Item3D object.
.cloneMesh(sourceId: string, id: string, options: CloneMeshOptions)
Clones a mesh that has a given ID (sourceId) and create another one with a new ID (id). The provided options will overwrite the settings of the source mesh.
.addPointLight(id: string, options: PointLightOptions = {})
Adds a point light with a unique ID (will throw if not unique) and some options.
ℹ️ By default, the light will have some settings (if not overwritten by the options):
[0, 0] (null island)2_000_000 metersAltitudeReference.MEAN_SEA_LEVEL0xffffff (white)750.2.modifyPointLight(id: string, options: PointLightOptions)
Modify a point light given its ID.
ℹ️ Only the settings provided in the option object will be updated, the others will be left as they already are.
.removeMesh(id: string)
Remove a mesh or point light from the scene and frees the GPU memory associated to it
.clear()
Removes all the meshes and point lights from the scene and frees the GPU memory associated with them
Item3D objectThe addMesh, addMeshFromURL and cloneMesh methods return an Item3D object. You can also retrieve it later using layer.getItem3D(id). This object has its own set of methods to modify its properties and control animations.
All methods that update visual state accept an optional cueRepaint (default true). When true, a repaint is requested; when false, the map will repaint on its next update.
.clone(newId?: string, options?: CloneMeshOptions)
Clone this item and add it to the layer. The clone shares geometry and animations but has its own materials and transform. Returns the new Item3D. If newId is omitted, defaults to ${this.id}-clone.
.remove()
Remove the item from the scene and free GPU memory (materials, geometries). Also removes it from the layer index.
.on(event: Item3DEventTypes, callback: (event: any) => void)
Register an event listener. Event types: "click", "mouseenter", "mouseleave", "mousedown", "mouseup", "dblclick".
.off(event: Item3DEventTypes, callback: (event: any) => void)
Unregister an event listener.
.modify(options: Partial<MeshOptions>)
Update multiple settings at once (e.g. scale, lngLat, altitude, heading, opacity, visible). Only the options provided are updated; others are left unchanged.
.setTransform(transform?: Partial<Item3DTransform>)
Set the item’s transform (rotation, translate). Pass nothing to reset to the default transform.
.setStates(stateUpdate: Item3DMeshUIStates | (currentState) => Item3DMeshUIStates)
Set the UI state config (e.g. hover, active, selected). Can be an object or a function that receives current state and returns the new state.
.addState(name: Item3DMeshUIStateName, state: Item3DMeshUIStateProperties)
Add a named state (e.g. "hover", "active", "selected") with the given properties.
.removeState(name: Item3DMeshUIStateName)
Remove a state and run its cleanup.
.setLngLat(lngLat: LngLat, cueRepaint?)
Set the item’s longitude/latitude.
.setAltitude(altitude: number, cueRepaint?)
Set the item’s altitude (height above ground or sea, depending on altitudeReference).
.setPositionRelativeTo(item: Item3D | Position3D, offset: { x, y, z }, units?, cueRepaint?)
Set position relative to another item or a 3D position, then apply offset. offset.x = longitude direction, offset.y = altitude, offset.z = latitude. units: "meters" (default), "feet", "km", "miles".
.moveBy(offset: { x, y, z }, units?, cueRepaint?)
Move the item by the given offset. Same axis and units as setPositionRelativeTo.
.setElevation(elevation: number, cueRepaint?)
Set the ground elevation at the item’s location (used for transform/altitude calculation).
.setScale(scale: number | [number, number, number], cueRepaint?)
Set the absolute scale of the item (relative to the map).
.setRelativeScale(scale: number | [number, number, number], cueRepaint?)
Set scale relative to the item’s base scale (e.g. for states; 1.5 = 150%).
.setHeading(heading: number, cueRepaint?)
Set heading in degrees.
.setPitch(pitchInDegrees: number, cueRepaint?)
Set pitch in degrees.
.setRoll(rollInDegrees: number, cueRepaint?)
Set roll in degrees.
.setSourceOrientation(sourceOrientation: SourceOrientation, cueRepaint?)
Set source orientation ("y-up" or "z-up").
.setAltitudeReference(altitudeReference: AltitudeReference, cueRepaint?)
Set whether altitude is relative to ground or sea level.
.setOpacity(opacity: number, cueRepaint?)
Set opacity (0–1). Materials are set transparent as needed.
.setWireframe(wireframe?: boolean, cueRepaint?)
Toggle wireframe rendering for meshes.
.setPointSize(size: number, cueRepaint?)
Set point size for point clouds.
.getAnimationNames()
Returns the names of all animations loaded with the model.
.getAnimation(animationName: string)
Returns the Three.js AnimationAction for animationName, or null.
.playAnimation(animationName: string, loop?: AnimationLoopOptions)
Start playing animationName. loop: "loop" (infinite), "once", or "pingPong" (forward then reverse).
.pauseAnimation(animationName: string)
Pause the given animation.
.stopAnimation(animationName: string)
Stop the animation and remove it from the renderer’s animation loop.
.updateAnimation(delta = 0.02)
Advance animations by delta seconds. Only needed when animationMode is "manual".
.setAnimationTime(time: number)
Set the mixer time to time seconds (affects all animations on this item).
.intersects(item3D: Item3D, precision?: "low" | "medium")
Test whether this item intersects another. precision: "low" (bounding sphere/AABB, fast) or "medium" (default; broad pass then per-mesh OBB). Returns true if they intersect.
NOTE: The intersections are not exact at present and only use bounding boxes, hence "low" and "medium" are the only options available at present.
.debug (property)
When true, renders bounding boxes and bounding spheres for each internal mesh. Set item.debug = true to enable.
We love contributions from the community! Whether it's bug reports, feature requests, or pull requests, all contributions are welcome:
mainThis project uses a combination of Vite for building and serving fixtures and Playwright for browser automation to perform end-to-end testing.
Currently we are unable to use Vitest as a test runner at present due to this issue with Playwright.
The testing setup consists of:
Configuration files:
vite.config-e2e.ts: Vite configuration for e2e testingplaywright.config.ts: Playwright browser configurationTest files are organized under the e2e directory:
public/: HTML files that run the test fixturessrc/: Test fixture implementation filesmocks/: Mock data and objects for testingsnapshots/: image snapshots for comparisontsconfig.json that extends the base project configTo add new test fixtures, add entry points to the rollup options in vite-config-e2e.ts.
Two npm scripts are available for testing; they must be run simultaneously:
# Start the test server that serves test fixtures
npm run e2e:serve
# Run the e2e tests against local test server
npm run e2e:local
# to update the snapshots pass the appropriate flag
npm run e2e:local -- --update-snapshots
# to run in ui mode...
npm run e2e:local -- --ui
Note: GitHub Actions integration for automated testing will be implemented in upcoming versions.
To generate the typedoc documentation and serve them locally:
npm run doc && npx http-server docs
This project is licensed under the MapTiler JS Module – see the LICENSE file for details.
This project is built on the shoulders of giants:
💜 Made with love by the MapTiler team
FAQs
Add 3D things to your map, plugin for MapTiler SDK
The npm package @maptiler/3d receives a total of 171 weekly downloads. As such, @maptiler/3d popularity was classified as not popular.
We found that @maptiler/3d demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 10 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Research
/Security News
A mini Shai-Hulud campaign compromised Red Hat Cloud Services npm packages to steal developer and CI/CD secrets during installation.
Research
/Security News
The North Korean malware loader hides in a Packagist-listed package and its GitHub branch to fetch and execute remote code in a likely Contagious Interview-style lure.
Security News
The Rust project is moving toward formal rules on LLM use in contributions after months of internal debate over maintainer burden, code quality, and contributor experience.