SDK JS
    Preparing search index...

    Interface Tiles3DPointCloudLayerOptions

    Options for Tiles3DPointCloudLayer. Only id and url (the tileset.json) are required — the default decoder reads uncompressed and Draco .pnts plus glTF POINTS in a worker pool, the cloud is grounded on the basemap, and points colour by 'rgb'. What changes the look most: colorMode (with classColors / colorRamp / hiddenClasses for LAS classification work), the point-size set (pointRadiusM / fixedPx / minPx / maxPx, or attenuation), and eyeDomeLighting, which makes a sparse cloud read as a solid surface.

    interface Tiles3DPointCloudLayerOptions {
        anchor?: { altitude?: number; lat?: number; lng?: number };
        attenuation?: boolean;
        attribution?: string;
        auth?: RequestAuthorizer;
        baseUrl?: string;
        budget?: { maxBytes?: number; maxPoints?: number };
        classColors?: Readonly<Record<number, Rgb>>;
        clippingPlanes?: ClippingPlanesOptions;
        colorMode?: PointColorMode;
        colorRamp?: ColorRamp;
        datum?: VerticalDatum;
        debugBounds?: boolean;
        decoder?: "bvc" | CesiumPointDecoder;
        edlRadius?: number;
        edlStrength?: number;
        eyeDomeLighting?: boolean;
        fixedPx?: number;
        flyTo?: boolean | { duration?: number; pitch?: number; zoom?: number };
        geoidN?: number;
        geometricErrorScale?: number;
        grid?: number;
        ground?: boolean;
        hiddenClasses?: readonly number[];
        id: string;
        intensityBias?: number;
        intensityScale?: number;
        json?: TilesetJson;
        lodFalloffPow?: number;
        maximumAttenuation?: number;
        maxPx?: number;
        maxScreenSpaceError?: number;
        minPx?: number;
        onClassifications?: (classes: ClassificationInfo[]) => void;
        onError?: (error: unknown) => void;
        onLoaded?: () => void;
        onProgress?: (fraction: number) => void;
        opacity?: number;
        pointRadiusM?: number;
        queryParams?: Record<string, string>;
        requestInit?: RequestInit;
        roundPoints?: boolean;
        shadows?: boolean;
        url: string;
        visible?: boolean;
        workers?: boolean;
    }
    Index

    Properties

    anchor? attenuation? attribution? auth? baseUrl? budget? classColors? clippingPlanes? colorMode? colorRamp? datum? debugBounds? decoder? edlRadius? edlStrength? eyeDomeLighting? fixedPx? flyTo? geoidN? geometricErrorScale? grid? ground? hiddenClasses? id intensityBias? intensityScale? json? lodFalloffPow? maximumAttenuation? maxPx? maxScreenSpaceError? minPx? onClassifications? onError? onLoaded? onProgress? opacity? pointRadiusM? queryParams? requestInit? roundPoints? shadows? url visible? workers?

    Properties

    anchor?: { altitude?: number; lat?: number; lng?: number }

    Scene anchor. By default lng/lat come from the tileset root center and the floor is auto-grounded onto the basemap (z=0) — correct for a localized dataset. For a GLOBAL tileset, the root box spans the planet, so pass an explicit lng/lat for the area you're viewing — the ENU frame is anchored there (f32-safe) and the engine frustum-culls the rest. altitude (m, WGS84) overrides the auto-ground.

    attenuation?: boolean

    Geometric-error point attenuation (Cesium PointCloudShading): size points by their node's geometric error so coarse/far points draw bigger and the cloud stays dense at distance instead of going sparse. Default false. Toggle live with Tiles3DPointCloudLayer.setAttenuation.

    attribution?: string

    Dataset attribution (shown in MapLibre's attribution control).

    auth?: RequestAuthorizer

    Request authorizer for tile + tileset fetches (secured ArcGIS 3D-Tiles). For public tilesets, Cesium ion, or Google, leave unset and use requestInit/ queryParams. Superseded by a global configureEsriAuth().

    baseUrl?: string

    Base URL for resolving relative tile URIs (with json). Defaults to url's dir.

    budget?: { maxBytes?: number; maxPoints?: number }

    Resident-memory budget (maxPoints / maxBytes). Default maxBytes 2.4 GB.

    classColors?: Readonly<Record<number, Rgb>>

    Per-code LAS colour overrides applied over the ASPRS palette. Change live with setClassColor; restore one code by passing undefined. Default: the stock palette.

    clippingPlanes?: ClippingPlanesOptions

    Clipping planes (geographic; see ClippingPlanesOptions) applied to this layer's points (whole-point cull in the color, pick, and shadow-cast passes). Change at runtime via Tiles3DPointCloudLayer.setClippingPlanes. Default none.

    colorMode?: PointColorMode

    Initial color mode (default 'rgb'). RGB requires an RGB attribute; falls back per-point.

    colorRamp?: ColorRamp

    Colour ramp for intensity and height modes. Change live with setColorRamp. Default: the built-in Turbo ramp.

    datum?: VerticalDatum

    Vertical datum for auto-placement: 'basemap' (default) drops the ground on the map; 'ellipsoid'/'orthometric' place it at its absolute height. 3D-Tiles point heights are ellipsoidal, so 'orthometric' subtracts geoidN. Switch live with Tiles3DPointCloudLayer.setDatum.

    debugBounds?: boolean
    decoder?: "bvc" | CesiumPointDecoder

    Tile decoder: default (createPointDecoder) reads uncompressed / Draco .pnts + glТF POINTS. 'bvc' reads BVC-transcoded tiles (BITRUVIUS_pointcloud_bvc, from bvc-3dtiles). Or pass a custom CesiumPointDecoder instance to override entirely.

    edlRadius?: number
    edlStrength?: number

    EDL darkening strength (default 80) + neighbour ring radius in px (default 1.4).

    eyeDomeLighting?: boolean

    Eye-dome lighting: a screen-space pass that shades depth gaps so a sparse cloud reads as a solid surface (Cesium/Potree EDL). Default false. Toggle live with Tiles3DPointCloudLayer.setEyeDomeLighting.

    fixedPx?: number
    flyTo?: boolean | { duration?: number; pitch?: number; zoom?: number }

    Fly to the dataset once its location is known (default off).

    geoidN?: number

    Optional — you should not normally need this.* The geoid undulation N (m) at the dataset, used to place absolutely-georeferenced data on mean-sea-level terrain. The SDK resolves it automatically (it fetches the EGM96 grid on demand and samples it at the dataset), so pass this only to override that — e.g. for a dataset referenced to a local vertical datum EGM96 does not model.

    An override shifts placement by the DIFFERENCE between your value and the EGM96 undulation at the dataset — so passing the conventional EGM96 value for your area is a no-op rather than a ~30 m jump.

    geometricErrorScale?: number

    Scale on the geometric error before projection (Cesium geometricErrorScale). Default 1.

    grid?: number

    Requantization grid (m) for the i32 position buffer. Default 0.001 (1 mm).

    ground?: boolean

    Measure + ground the dataset onto the chosen datum (default true).

    hiddenClasses?: readonly number[]

    LAS class ids to hide initially. Toggle live with Tiles3DPointCloudLayer.setHiddenClasses / Tiles3DPointCloudLayer.setClassVisible; discover which codes a scene contains with Tiles3DPointCloudLayer.getClassifications.

    id: string

    Layer id.

    intensityBias?: number
    intensityScale?: number
    json?: TilesetJson

    Pre-fetched tileset JSON — pass ResolvedSource.json to skip a redundant root request. REQUIRED for Google-style hosts where the root must be fetched key-only to establish a session, so re-fetching it with the session appended 400s.

    lodFalloffPow?: number

    LOD distance-falloff exponent for the refine cusp. <1 keeps higher LOD further out (more far detail, more data); 1 = standard SSE — the cusp matches Cesium at the same maxScreenSpaceError. Default: the engine value. Tune live with Tiles3DPointCloudLayer.setLodFalloffPow.

    maximumAttenuation?: number

    Attenuation point-size ceiling, CSS px (Cesium maximumAttenuation). Default 16.

    maxPx?: number
    maxScreenSpaceError?: number

    Target screen-space error (px). Lower = more detail / more tiles. Default 16.

    minPx?: number
    onClassifications?: (classes: ClassificationInfo[]) => void

    Fired (with the current code/label/count list) when the set of LAS classification codes present in the streamed scene changes — wire it to (re)populate a class show/hide checklist without polling Tiles3DPointCloudLayer.getClassifications.

    onError?: (error: unknown) => void

    Fired if the tileset fails to load/initialize.

    onLoaded?: () => void

    Fired once the working set first fully resolves.

    onProgress?: (fraction: number) => void

    Fired with the working-set load fraction (0–1) as it streams.

    opacity?: number
    pointRadiusM?: number
    queryParams?: Record<string, string>

    Query params appended to every tile + external-tileset request (e.g. Google Photorealistic's key + session). Pass ResolvedSource.queryParams through.

    requestInit?: RequestInit

    Static auth/headers for tile + tileset fetches (e.g. a Cesium ion / Google key).

    roundPoints?: boolean
    shadows?: boolean

    Cast + receive cascaded sun shadows (default false). When on, the cloud casts depth footprints into the shared ShadowCoordinator atlas (so it shadows meshes/terrain) and self-shadows by sampling it. Requires an active geo-sun (a setSunState with the sun above the horizon). Toggle live with Tiles3DPointCloudLayer.setShadows.

    url: string

    URL of the 3D-Tiles tileset.json.

    visible?: boolean
    workers?: boolean

    Decode tiles off the main thread in a worker pool (default true).

    Settings

    Member Visibility

    On This Page

    Properties