⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

v0.3.0

cesiumjs-3d-tiles

cesiumgs@cesiumgs⭐ 198 stars· last commit 2mo ago· 4 open issues

CesiumJS 3D Tiles - Cesium3DTileset, compressed and CAD-style glTF content, MVTDataProvider, UrlTemplate3DTilesDataProvider, styling, metadata, feature picking, voxels, point clouds, I3S, Gaussian splats, clipping. Use when a task involves loading 3D Tiles or Mapbox Vector Tiles, draping vector tiles on terrain, rendering KHR meshopt/CAD content, styling or querying features, working with voxels or point clouds, or clipping spatial data.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐ 198 on GitHubGitHub ↗

Popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

CesiumJS Agent Skills

Curated agent skills for CesiumJS development — 14 domain skills covering ~551 public symbols across the CesiumJS v1.143 API surface.

See the July 2026 / CesiumJS 1.143 coverage matrix for the exact skill owner of every release addition, runtime fix, and announced workflow surface.

Quick Start

Claude Code

One-Liner from the terminal (recommended):

claude plugin marketplace add CesiumGS/cesiumjs-skills

From inside Claude Code:

  1. Type /plugin and press Enter
  2. Select Add Marketplace
  3. Enter CesiumGS/cesiumjs-skills
  4. Once the marketplace is added, type /plugin again
  5. Select Install Plugin
  6. Choose cesiumjs-skills from the list

After installing, run /reload-plugins to activate the skills in your current session.

Any Agent Skills-Compatible Tool

These skills follow the Agent Skills open standard. Copy or symlink the skills/ directory into your workspace — skills are discovered automatically from skills/<name>/SKILL.md.


Table of Contents

Skills Catalog

SkillActivates when...
cesiumjs-viewer-setupInitializing a CesiumJS app, configuring widgets, setting Ion tokens, bootstrapping a globe
cesiumjs-cameraPositioning the camera, flyTo animations, constraining navigation, entity tracking
cesiumjs-entitiesAdding graphics and time-segmented paths; loading GeoJSON/KML/CZML/GPX through DataSources
cesiumjs-3d-tilesLoading tilesets, compressed/CAD glTF, or MVT; styling, metadata, voxels, clipping
cesiumjs-imageryAdding/swapping base map layers, configuring imagery providers, split-screen comparisons
cesiumjs-terrain-environmentConfiguring terrain, querying heights, atmosphere/sky/fog/lighting/shadows, panoramas
cesiumjs-primitivesPerformance-critical static/vector geometry, GeoJsonPrimitive, BufferPrimitive collections
cesiumjs-materials-shadersFabric materials, ImageBasedLighting, post-processing effects, bloom, tonemapping
cesiumjs-custom-shaderWriting GLSL shader bodies for Model/Cesium3DTileset/VoxelPrimitive; feature IDs, EXT_structural_metadata
cesiumjs-time-propertiesDynamic properties, simulation clock, interpolation, and interval/sampled path materials
cesiumjs-spatial-mathCoordinate conversions, ellipsoid geometry, model matrices, intersection tests, projections
cesiumjs-interactionUser clicks on the globe, multi-modifier shortcuts, entity/feature selection, hover, drag
cesiumjs-models-particlesCompressed/CAD glTF/GLB loading, edge display, animations, and particle effects
cesiumjs-core-utilitiesHTTP requests via Resource, Color, Event, error handling, helper functions

Domain Mapping

Every public class, function, and enum in CesiumJS is assigned to exactly one skill. Cross-domain ownership rules and the full symbol map are documented in docs/DOMAINS.md.

Compatibility

The Agent Skills format is an open standard originally developed by Anthropic and adopted by leading AI development tools including Claude Code, GitHub Copilot, and many others.

By popular demand, this repository also ships as a Claude Code plugin with a SessionStart hook and Chrome DevTools MCP integration for browser-based verification.

Repository Layout

cesiumjs-skills/
├── skills/                          # The product
│   ├── cesiumjs-*/SKILL.md          # 14 domain skills (CesiumJS v1.143)
│   └── using-cesiumjs-skills/       # Bootstrap orientation skill
├── docs/
│   ├── DOMAINS.md                   # Symbol ownership map
│   └── skills-catalog.md            # Skills catalog
├── .claude-plugin/
│   ├── plugin.json                  # Claude Code plugin manifest
│   └── marketplace.json             # Plugin marketplace catalog
├── .mcp.json                        # Chrome DevTools MCP server
├── hooks/                           # SessionStart hook + runner
└── LICENSE

License

Apache 2.0

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • skills/cesiumjs-3d-tiles/SKILL.md7.8 KBupstream ↗
    ---
    name: cesiumjs-3d-tiles
    description: "CesiumJS 3D Tiles - Cesium3DTileset, compressed and CAD-style glTF content, MVTDataProvider, UrlTemplate3DTilesDataProvider, styling, metadata, feature picking, voxels, point clouds, I3S, Gaussian splats, clipping. Use when a task involves loading 3D Tiles or Mapbox Vector Tiles, draping vector tiles on terrain, rendering KHR meshopt/CAD content, styling or querying features, working with voxels or point clouds, or clipping spatial data."
    ---
    # CesiumJS 3D Tiles
    
    Version baseline: CesiumJS v1.144 (ES module imports, async factory methods).
    
    ## Loading a Tileset
    
    Always use async factory methods -- never call the constructor directly.
    For public/no-token examples, prefer URL-backed tilesets such as CesiumGS sample
    tilesets. `fromIonAssetId`, `createOsmBuildingsAsync`, and Google
    Photorealistic 3D Tiles require external entitlements; use them only when the
    caller explicitly asks for those services and the runtime is configured for
    them.
    
    ```js
    import { Cesium3DTileset, HeadingPitchRange, Math as CesiumMath } from "cesium";
    
    // From a URL
    const tileset = await Cesium3DTileset.fromUrl(
      "https://example.com/tileset.json",
      { maximumScreenSpaceError: 16 }, // lower = higher quality
    );
    viewer.scene.primitives.add(tileset);
    await viewer.zoomTo(tileset, new HeadingPitchRange(
      0.0, CesiumMath.toRadians(-25.0), tileset.boundingSphere.radius * 2.0,
    ));
    ```
    
    CesiumJS 1.143 applies standalone model loading to glTF embedded in tilesets.
    Read the [glTF compatibility matrix](../cesiumjs-models-particles/REFERENCE.md)
    for automatic `KHR_meshopt_compression`, CAD extension behavior, and the unsupported planar-fill boundary.
    
    ```js
    // From Cesium ion
    const tileset = await Cesium3DTileset.fromIonAssetId(75343);
    viewer.scene.primitives.add(tileset);
    ```
    
    ```js
    // Google Photorealistic 3D Tiles
    import { createGooglePhotorealistic3DTileset } from "cesium";
    const google3D = await createGooglePhotorealistic3DTileset({
      onlyUsingWithGoogleGeocoder: true,
    });
    viewer.scene.primitives.add(google3D);
    ```
    
    ```js
    // OSM Buildings
    import { createOsmBuildingsAsync } from "cesium";
    const osmBuildings = await createOsmBuildingsAsync();
    viewer.scene.primitives.add(osmBuildings);
    ```
    
    ## Key Constructor Options
    
    | Option | Default | Purpose |
    |--------|---------|---------|
    | `maximumScreenSpaceError` | 16 | LOD quality threshold (pixels) |
    | `cacheBytes` | 536870912 | Tile cache trim target (bytes) |
    | `maximumCacheOverflowBytes` | 536870912 | Extra cache headroom |
    | `shadows` | ShadowMode.ENABLED | Shadow casting/receiving |
    | `modelMatrix` | Matrix4.IDENTITY | Root transform |
    | `clippingPlanes` | undefined | ClippingPlaneCollection |
    | `clippingPolygons` | undefined | ClippingPolygonCollection (WebGL 2) |
    | `enableCollision` | false | Camera collision with tileset surface |
    | `pointCloudShading` | undefined | Point attenuation options object |
    | `classificationType` | undefined | TERRAIN, CESIUM_3D_TILE, or BOTH |
    | `dynamicScreenSpaceError` | true | Horizon LOD optimization |
    | `foveatedScreenSpaceError` | true | Center-screen tile priority |
    | `preloadFlightDestinations` | true | Prefetch tiles at flight target |
    | `featureIdLabel` | "featureId_0" | EXT_mesh_features ID set label |
    | `backFaceCulling` | true | Cull back faces per glTF material |
    | `edgeDisplayMode` | EdgeDisplayMode.SURFACES_ONLY | Render glTF edge-visibility data when present |
    
    ## Mapbox Vector Tiles as Runtime 3D Tiles (Experimental, 1.142+)
    
    `MVTDataProvider` loads `{z}/{x}/{y}` Mapbox Vector Tile `.mvt`/`.pbf`
    templates and converts tile payloads into runtime 3D Tiles. Use it when vector
    data is naturally tiled and you want 3D Tiles styling, metadata picking, and LOD
    instead of a single GeoJSON primitive.
    
    For one in-memory or URL-backed GeoJSON object, prefer `GeoJsonPrimitive` in
    `cesiumjs-primitives`. For Entity/DataSource conveniences, prefer
    `GeoJsonDataSource` in `cesiumjs-entities`.
    
    ```js
    import {
      Cesium3DTileStyle,
      MVTDataProvider,
      Rectangle,
    } from "cesium";
    
    const provider = await MVTDataProvider.fromUrl(
      "https://example.com/tiles/{z}/{x}/{y}.pbf",
      {
        minZoom: 4,
        maxZoom: 14,
        extent: Rectangle.fromDegrees(-125, 24, -66, 50),
        featureIdProperty: "id",
      },
    );
    
    viewer.scene.primitives.add(provider);
    
    // The provider owns a generated Cesium3DTileset.
    provider.tileset.style = new Cesium3DTileStyle({
      color: {
        conditions: [
          ["${kind} === 'park'", "color('seagreen', 0.65)"],
          ["${kind} === 'water'", "color('steelblue', 0.55)"],
          ["true", "color('white', 0.45)"],
        ],
      },
    });
    ```
    
    Feature properties are encoded as `EXT_structural_metadata`, so standard
    3D Tiles styling and picking patterns apply:
    
    ```js
    const picked = viewer.scene.pick(windowPosition);
    if (picked && typeof picked.getProperty === "function") {
      console.log(picked.getProperty("name"));
    }
    ```
    
    Notes:
    - URL templates must contain `{z}`, `{x}`, and `{y}` placeholders; tile URLs are parsed from `/z/x/y`.
    - Empty 204/404 tiles are treated as missing instead of hard failures.
    - `provider.show` proxies visibility to the generated tileset.
    - Runtime vector glTF content uses draft `EXT_mesh_polygon` and `3DTILES_content_gltf_vector` support; treat this path as experimental.
    
    **Terrain draping (1.144+):** clamped vector tile polylines and polygons drape
    onto terrain automatically, with screen-space-constant line width, and
    per-feature styling stays driven by `Cesium3DTileStyle`. There is no opt-in
    flag; clamped vector content follows the terrain surface beneath it.
    
    **Custom vector tile formats (1.144+):** `MVTDataProvider` now extends
    `UrlTemplate3DTilesDataProvider`, a public base class that turns any
    `{z}/{x}/{y}` URL-template vector source into a runtime-generated
    `Cesium3DTileset`. Its `fromUrl`, `tileset`, `show`, `extent`, and
    `minZoom`/`maxZoom` options behave the same as on `MVTDataProvider`; subclass
    it and implement its protected codec hook to support a tiled vector format
    other than MVT.
    
    ## Tileset Events and Render Readiness
    
    `fromUrl` resolves when tileset metadata is usable; it does not mean the tiles
    for the current camera view have rendered. `initialTilesLoaded` fires only for
    the first loaded view, while `allTilesLoaded` and `tilesLoaded` are
    view-dependent. After `zoomTo`, `flyTo`, `setView`, or interactive camera
    movement, check readiness again. Do not substitute a fixed delay for this
    semantic condition.
    
    ```js
    function waitForTilesetView(viewer, tileset, timeoutMs = 30_000) {
      return new Promise((resolve, reject) => {
        const scene = viewer.scene;
        let readyFrames = 0;
        const remove = scene.postRender.addEventListener(() => {
          readyFrames = tileset.tilesLoaded ? readyFrames + 1 : 0;
          if (readyFrames < 2) {
            scene.requestRender();
            return;
          }
          clearTimeout(timeoutId);
          remove();
          resolve(tileset);
        });
        const timeoutId = setTimeout(() => {
          remove();
          reject(new Error(`Tileset did not load within ${timeoutMs} ms`));
        }, timeoutMs);
        scene.requestRender();
      });
    }
    
    await viewer.zoomTo(tileset);
    await waitForTilesetView(viewer, tileset);
    ```
    
    Use `loadProgress` for loading UI, `tileLoad`/`tileUnload` for cache activity,
    and `tileFailed` for diagnostics. Do not treat an individual `tileLoad` event as
    proof that the current view is complete.
    
    ```js
    import { Color } from "cesium";
    
    // Per-frame manual styling
    tileset.tileVisible.addEventListener((tile) => {
      const content = tile.content;
      for (let i = 0; i < content.featuresLength; i++) {
        content.getFeature(i).color = Color.fromRandom();
      }
    });
    ```
    
    ## Runtime Properties
    
    ```js
    import { Matrix4, Cartesian3 } from "cesium";
    
    tileset.show = false;                     // toggle visibility
    tileset.maximumScreenSpaceError = 8;      // increase quality
    const { center, radius } = tileset.boundingSphere;
    tileset.modelMatrix = Matrix4.fromTranslation(new Cartesian3(0, 0, 100));
    ```
    
    ## Declarative Styling
    
    Assign a 
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/cesiumgs-cesiumjs-skills-skills-cesiumjs-3d-tiles.md

// REPO STATS

198 stars
4 open issues
Last commit: 2mo ago