Best approach for rendering and interacting with 1000+ tower models on top of Google Photorealistic 3D Tiles

CesiumJS
1

Title: Best approach for rendering and interacting with 1000+ tower models on top of Google Photorealistic 3D Tiles

Hi everyone,

I’m building a web application using CesiumJS + React where users can explore network towers across the globe. Currently the application loads Google Photorealistic 3D Tiles (from Cesium ion) as the base layer, along with a custom cloud layer and some lighting effects.

For a small number of towers (~10–15), the current approach works fine. However, the project requirements have now changed and we may need to support 1000+ towers globally, and I want to ensure the architecture scales properly.

Current Setup

  • Frontend: React + CesiumJS

  • Base Layer: Google Photorealistic 3D Tiles (Cesium ion asset)

  • Additional Layers:

    • Custom skybox

    • Semi-transparent cloud layer (rectangle entity with texture)

  • Tower models: GLB models placed using Cesium.Entity with model.uri

  • Tower metadata: Each tower has longitude, latitude, altitude, and height

  • Interaction:

    • Clicking on meshes inside the model shows information about that tower component

    • Uses viewer.scene.pick() to detect mesh/node names

Current Rendering Strategy

  • Each tower has:

    • a billboard marker

    • a label

    • a 3D model

  • Camera distance determines whether the model is visible or not.

  • Visibility is updated on viewer.camera.changed.

Example simplified logic:

if (distance < threshold) {
  entity.show = true
} else {
  entity.show = false
}

Concerns

The current implementation works for ~10 towers, but I’m concerned about scaling to 1000+ towers, especially since:

  • Google Photorealistic 3D Tiles already consume a lot of GPU resources.

  • Loading hundreds or thousands of GLB models as entities could affect performance.

  • The application needs to remain smooth while navigating the globe.

Questions

I would appreciate advice on the best approach for scaling this system.

  1. What is the recommended strategy for rendering thousands of models globally in Cesium?

    • Should we continue using Entity models?

    • Would ModelInstanceCollection be better if towers share geometry?

    • Should towers be converted into a 3D Tiles dataset instead?

  2. If towers are separate models, is it better to:

    • Load individual tilesets dynamically based on camera distance?

    • Or combine towers into a larger tileset grouped by region?

  3. What is the typical pattern for level-of-detail (LOD)?
    For example:

    • markers at global zoom

    • simplified tower models at medium zoom

    • full detailed models when close

  4. Can feature picking still work with 3D Tiles?
    We currently detect clicks on individual tower components (meshes). If we move to a tileset-based approach, is there a recommended way to preserve this interaction?

  5. Are there any specific performance considerations when combining custom models with Google Photorealistic 3D Tiles?

Goal

The goal is to support hundreds to thousands of towers worldwide, while keeping the viewer smooth and responsive.

Any suggestions about architecture, rendering strategies, or best practices would be greatly appreciated.

Thanks!

2

Hi @Madhu_Paka,

Here are some of my initial thoughts and suggestions:

  1. In general, 1000 models isn’t necessarily a performance concern. It will also depend on the complexity of the model and whether you can instance it. If you can instance it, it will occupy nearly the same GPU memory as a single model. (Though there’s still the cost of the GPU having to draw the object many times).
  2. I wouldn’t rely on application-side code to determine the visibility of these models. I think the best approach (one you suggested yourself) is to convert the towers to a 3D tileset. This is pretty much what 3D Tiles is designed for. Cesium will automatically handle when given towers need to be loaded in and visible. Cesium can also use instancing on your behalf if the tileset indicates that it should be used (for example, through the glTF EXT_mesh_gpu_instancing extension in 3D Tile 1.1).

3D Tilesets also offer the ability to dictate a refinement strategy as you zoom in and LOD increases. So you could use simplified / more complex geometries for your towers at different LODs and have Cesium swap them out as needed.

Can feature picking still work with 3D Tiles

Yes, 3D tiles still supports these workflows. 3D tiles 1.1 uses the EXT_mesh_features extension to assign identifiers to tile components. If your models have feature IDs as outlined in that spec, they will be pickable in Cesium.

Lastly, I’ll call out this repo of tools that may be useful if you pursue this approach: GitHub - CesiumGS/3d-tiles-tools · GitHub

Good luck!

Best,
Matt