v3.8.0

3d-style/data/bucket/tiled_3d_model_bucket.ts

@@ -25,6 +25,7 @@ import type {Terrain} from '../../../src/terrain/terrain';
 import type FeatureIndex from '../../../src/data/feature_index';
 import type {GridIndex} from '../../../src/types/grid-index';
 import type {TileFootprint} from '../../../3d-style/util/conflation';
+import type {FeatureStates} from '../../../src/source/source_state';
 
 const lookup = new Float32Array(512 * 512);
 const passLookup = new Uint8Array(512 * 512);
@@ -48,7 +49,8 @@ function addAABBsToGridIndex(node: Node, key: number, grid: GridIndex) {
     if (node.meshes) {
         for (const mesh of node.meshes) {
             if (mesh.aabb.min[0] === Infinity) continue;
-            grid.insert(key, mesh.aabb.min[0], mesh.aabb.min[1], mesh.aabb.max[0], mesh.aabb.max[1]);
+            const meshAabb = Aabb.applyTransform(mesh.aabb, node.matrix);
+            grid.insert(key, meshAabb.min[0], meshAabb.min[1], meshAabb.max[0], meshAabb.max[1]);
         }
     }
     if (node.children) {
@@ -138,6 +140,7 @@ class Tiled3dModelBucket implements Bucket {
     brightness: number | null | undefined;
     needsUpload: boolean;
     constructor(
+        layers: Array<ModelStyleLayer>,
         nodes: Array<Node>,
         id: OverscaledTileID,
         hasMbxMeshFeatures: boolean,
@@ -146,6 +149,9 @@ class Tiled3dModelBucket implements Bucket {
         featureIndex: FeatureIndex,
     ) {
         this.id = id;
+        this.layers = layers;
+        this.layerIds = this.layers.map(layer => layer.fqid);
+        this.stateDependentLayerIds = this.layers.filter((l) => l.isStateDependent()).map((l) => l.id);
         this.modelTraits |= ModelTraits.CoordinateSpaceTile;
         this.uploaded = false;
         this.hasPattern = false;
@@ -185,12 +191,20 @@ class Tiled3dModelBucket implements Bucket {
         }
     }
 
-    update() {
-        console.log("Update 3D model bucket");
+    update(states: FeatureStates) {
+        const withStateUpdates = Object.keys(states).length !== 0;
+        if (withStateUpdates && !this.stateDependentLayers.length) return;
+        const layers = withStateUpdates ? this.stateDependentLayers : this.layers;
+
+        for (const layer of layers) {
+            this.evaluate(layer, states);
+        }
     }
+
     populate() {
         console.log("populate 3D model bucket");
     }
+
     uploadPending(): boolean {
         return !this.uploaded || this.needsUpload;
     }
@@ -260,11 +274,12 @@ class Tiled3dModelBucket implements Bucket {
         }
     }
 
-    evaluate(layer: ModelStyleLayer) {
+    evaluate(layer: ModelStyleLayer, states?: FeatureStates) {
         const nodesInfo = this.getNodesInfo();
         for (const nodeInfo of nodesInfo) {
             if (!nodeInfo.node.meshes) continue;
             const evaluationFeature = nodeInfo.feature;
+            const state = states && states[evaluationFeature.id];
             const hasFeatures = nodeInfo.node.meshes && nodeInfo.node.meshes[0].featureData;
             const previousDoorColor = nodeInfo.evaluatedColor[PartIndices.door];
             const previousDoorRMEA = nodeInfo.evaluatedRMEA[PartIndices.door];
@@ -278,18 +293,18 @@ class Tiled3dModelBucket implements Bucket {
                         evaluationFeature.properties['part'] = part;
                     }
 
-                    const color = layer.paint.get('model-color').evaluate(evaluationFeature, {}, canonical).toRenderColor(null);
+                    const color = layer.paint.get('model-color').evaluate(evaluationFeature, state, canonical).toRenderColor(null);
 
-                    const colorMixIntensity = layer.paint.get('model-color-mix-intensity').evaluate(evaluationFeature, {}, canonical);
+                    const colorMixIntensity = layer.paint.get('model-color-mix-intensity').evaluate(evaluationFeature, state, canonical);
                     nodeInfo.evaluatedColor[i] = [color.r, color.g, color.b, colorMixIntensity];
 
-                    nodeInfo.evaluatedRMEA[i][0] = layer.paint.get('model-roughness').evaluate(evaluationFeature, {}, canonical);
+                    nodeInfo.evaluatedRMEA[i][0] = layer.paint.get('model-roughness').evaluate(evaluationFeature, state, canonical);
                     // For the first version metallic is not styled
 
-                    nodeInfo.evaluatedRMEA[i][2] = layer.paint.get('model-emissive-strength').evaluate(evaluationFeature, {}, canonical);
+                    nodeInfo.evaluatedRMEA[i][2] = layer.paint.get('model-emissive-strength').evaluate(evaluationFeature, state, canonical);
                     nodeInfo.evaluatedRMEA[i][3] = color.a;
 
-                    nodeInfo.emissionHeightBasedParams[i] = layer.paint.get('model-height-based-emissive-strength-multiplier').evaluate(evaluationFeature, {}, canonical);
+                    nodeInfo.emissionHeightBasedParams[i] = layer.paint.get('model-height-based-emissive-strength-multiplier').evaluate(evaluationFeature, state, canonical);
 
                     if (!nodeInfo.hasTranslucentParts && color.a < 1.0) {
                         nodeInfo.hasTranslucentParts = true;
@@ -301,10 +316,10 @@ class Tiled3dModelBucket implements Bucket {
                 updateNodeFeatureVertices(nodeInfo, doorLightChanged, this.modelTraits);
             } else {
 
-                nodeInfo.evaluatedRMEA[0][2] = layer.paint.get('model-emissive-strength').evaluate(evaluationFeature, {}, canonical);
+                nodeInfo.evaluatedRMEA[0][2] = layer.paint.get('model-emissive-strength').evaluate(evaluationFeature, state, canonical);
             }
 
-            nodeInfo.evaluatedScale = layer.paint.get('model-scale').evaluate(evaluationFeature, {}, canonical);
+            nodeInfo.evaluatedScale = layer.paint.get('model-scale').evaluate(evaluationFeature, state, canonical);
             if (!this.updatePbrBuffer(nodeInfo.node)) {
                 this.needsUpload = true;
             }

3d-style/render/draw_model.ts

@@ -146,6 +146,14 @@ function setupMeshDraw(definesValues: Array<string>, dynamicBuffers: Array<Verte
     }
 
     definesValues.push('USE_STANDARD_DERIVATIVES');
+
+    const shadowRenderer = painter.shadowRenderer;
+    if (shadowRenderer) {
+        definesValues.push('RENDER_SHADOWS', 'DEPTH_TEXTURE');
+        if (shadowRenderer.useNormalOffset) {
+            definesValues.push('NORMAL_OFFSET');
+        }
+    }
 }
 
 function drawMesh(sortedMesh: SortedMesh, painter: Painter, layer: ModelStyleLayer, modelParameters: ModelParameters, stencilMode: StencilMode, colorMode: ColorMode) {
@@ -195,10 +203,11 @@ function drawMesh(sortedMesh: SortedMesh, painter: Painter, layer: ModelStyleLay
     // Extra buffers (colors, normals, texCoords)
     const dynamicBuffers = [];
 
-    setupMeshDraw((programOptions.defines as Array<string>), dynamicBuffers, mesh, painter, layer.lut);
     const shadowRenderer = painter.shadowRenderer;
     if (shadowRenderer) { shadowRenderer.useNormalOffset = false; }
 
+    setupMeshDraw((programOptions.defines as Array<string>), dynamicBuffers, mesh, painter, layer.lut);
+
     let fogMatrixArray = null;
     if (fog) {
         const fogMatrix = fogMatrixForModel(sortedMesh.nodeModelMatrix, painter.transform);
@@ -970,6 +979,11 @@ function drawBatchedModels(painter: Painter, source: SourceCache, layer: ModelSt
                         defines: []
                     };
                     const dynamicBuffers = [];
+
+                    if (!isShadowPass && shadowRenderer) {
+                        shadowRenderer.useNormalOffset = !!mesh.normalBuffer;
+                    }
+
                     setupMeshDraw((programOptions.defines as Array<string>), dynamicBuffers, mesh, painter, layer.lut);
                     if (!hasMapboxFeatures) {
                         programOptions.defines.push('DIFFUSE_SHADED');
@@ -1013,11 +1027,6 @@ function drawBatchedModels(painter: Painter, source: SourceCache, layer: ModelSt
                         programOptions.defines.push('OCCLUSION_TEXTURE_TRANSFORM');
                     }
 
-                    if (!isShadowPass && shadowRenderer) {
-                        // Set normal offset before program creation, as it adds/remove necessary defines under the hood
-                        shadowRenderer.useNormalOffset = !!mesh.normalBuffer;
-                    }
-
                     const program = painter.getOrCreateProgram('model', programOptions);
 
                     if (!isShadowPass && shadowRenderer) {

3d-style/render/shadow_renderer.ts

@@ -382,6 +382,10 @@ export class ShadowRenderer {
         if (cutoffParams.shouldRenderCutoff) {
             baseDefines.push('RENDER_CUTOFF');
         }
+        baseDefines.push('RENDER_SHADOWS', 'DEPTH_TEXTURE');
+        if (this.useNormalOffset) {
+            baseDefines.push('NORMAL_OFFSET');
+        }
 
         const shadowColor = calculateGroundShadowFactor(style, directionalLight, ambientLight);
 

3d-style/source/model_source.ts

@@ -31,6 +31,10 @@ class ModelSource extends Evented<SourceEvents> implements ISource {
     attribution: string | undefined;
     // eslint-disable-next-line camelcase
     mapbox_logo: boolean | undefined;
+    vectorLayers?: never;
+    vectorLayerIds?: never;
+    rasterLayers?: never;
+    rasterLayerIds?: never;
     map: Map;
     uri: string;
     models: Array<Model>;

3d-style/source/tiled_3d_model_source.ts

@@ -18,6 +18,7 @@ import type {Cancelable} from '../../src/types/cancelable';
 import type {OverscaledTileID} from '../../src/source/tile_id';
 import type {ISource, SourceEvents} from '../../src/source/source';
 import type {ModelSourceSpecification} from '../../src/style-spec/types';
+import type {RequestedTileParameters, WorkerTileResult} from '../../src/source/worker_source';
 
 class Tiled3DModelSource extends Evented<SourceEvents> implements ISource {
     type: 'batched-model';
@@ -35,6 +36,10 @@ class Tiled3DModelSource extends Evented<SourceEvents> implements ISource {
     attribution: string | undefined;
     // eslint-disable-next-line camelcase
     mapbox_logo: boolean | undefined;
+    vectorLayers?: never;
+    vectorLayerIds?: never;
+    rasterLayers?: never;
+    rasterLayerIds?: never;
     tiles: Array<string>;
     dispatcher: Dispatcher;
     scheme: string;
@@ -81,7 +86,7 @@ class Tiled3DModelSource extends Evented<SourceEvents> implements ISource {
         this._loaded = false;
         this.fire(new Event('dataloading', {dataType: 'source'}));
         const language = Array.isArray(this.map._language) ? this.map._language.join() : this.map._language;
-        const worldview = this.map._worldview;
+        const worldview = this.map.getWorldview();
         this._tileJSONRequest = loadTileJSON(this._options, this.map._requestManager, language, worldview, (err, tileJSON) => {
             this._tileJSONRequest = null;
             this._loaded = true;
@@ -121,7 +126,7 @@ class Tiled3DModelSource extends Evented<SourceEvents> implements ISource {
     loadTile(tile: Tile, callback: Callback<undefined>) {
         const url = this.map._requestManager.normalizeTileURL(tile.tileID.canonical.url((this.tiles as any), this.scheme));
         const request = this.map._requestManager.transformRequest(url, ResourceType.Tile);
-        const params = {
+        const params: RequestedTileParameters = {
             request,
             data: undefined,
             uid: tile.uid,
@@ -134,8 +139,15 @@ class Tiled3DModelSource extends Evented<SourceEvents> implements ISource {
             scope: this.scope,
             showCollisionBoxes: this.map.showCollisionBoxes,
             isSymbolTile: tile.isSymbolTile,
-            brightness: this.map.style ? (this.map.style.getBrightness() || 0.0) : 0.0
+            brightness: this.map.style ? (this.map.style.getBrightness() || 0.0) : 0.0,
+            // Not supported in 3D models
+            lut: null,
+            maxZoom: null,
+            promoteId: null,
+            pixelRatio: null,
+            scaleFactor: null,
         };
+
         if (!tile.actor || tile.state === 'expired') {
             tile.actor = this.dispatcher.getActor();
             tile.request = tile.actor.send('loadTile', params, done.bind(this), undefined, true);
@@ -155,22 +167,16 @@ class Tiled3DModelSource extends Evented<SourceEvents> implements ISource {
             tile.request = tile.actor.send('reloadTile', params, done.bind(this));
         }
 
-        function done(err: Error | null | undefined, data: any) {
+        function done(err?: Error | null, data?: WorkerTileResult | null) {
             if (tile.aborted) return callback(null);
 
             // @ts-expect-error - TS2339 - Property 'status' does not exist on type 'Error'.
             if (err && err.status !== 404) {
                 return callback(err);
             }
 
-            if (data) {
-                if (data.resourceTiming) tile.resourceTiming = data.resourceTiming;
-                if (this.map._refreshExpiredTiles) tile.setExpiryData(data);
-                tile.buckets = {...tile.buckets, ...data.buckets};
-                if (data.featureIndex) {
-                    tile.latestFeatureIndex = data.featureIndex;
-                }
-            }
+            if (this.map._refreshExpiredTiles && data) tile.setExpiryData(data);
+            tile.loadModelData(data, this.map.painter);
 
             tile.state = 'loaded';
             callback(null);

3d-style/source/tiled_3d_model_worker_source.ts

@@ -18,9 +18,9 @@ import type {
     TileParameters,
     WorkerTileResult
 } from '../../src/source/worker_source';
-import type {Bucket} from '../../src/data/bucket';
 import type {LoadVectorData} from '../../src/source/load_vector_tile';
 import type Projection from '../../src/geo/projection/projection';
+import type ModelStyleLayer from '../style/style_layer/model_style_layer';
 
 class Tiled3dWorkerTile {
     tileID: OverscaledTileID;
@@ -59,9 +59,7 @@ class Tiled3dWorkerTile {
     ): Promise<void> {
         this.status = 'parsing';
         const tileID = new OverscaledTileID(params.tileID.overscaledZ, params.tileID.wrap, params.tileID.canonical.z, params.tileID.canonical.x, params.tileID.canonical.y);
-        const buckets: {
-            [_: string]: Bucket;
-        } = {};
+        const buckets: Tiled3dModelBucket[] = [];
         const layerFamilies = layerIndex.familiesBySource[params.source];
         const featureIndex = new FeatureIndex(tileID, params.promoteId);
         featureIndex.bucketLayerIDs = [];
@@ -78,31 +76,38 @@ class Tiled3dWorkerTile {
                 const parameters = new EvaluationParameters(this.zoom, {brightness: this.brightness});
                 for (const sourceLayerId in layerFamilies) {
                     for (const family of layerFamilies[sourceLayerId]) {
-                        const layer = family[0];
+                        const layer = family[0] as ModelStyleLayer;
                         featureIndex.bucketLayerIDs.push(family.map((l) => makeFQID(l.id, l.scope)));
                         layer.recalculate(parameters, []);
-                        const bucket = new Tiled3dModelBucket(nodes, tileID, hasMapboxMeshFeatures, hasMeshoptCompression, this.brightness, featureIndex);
+                        const bucket = new Tiled3dModelBucket(family as Array<ModelStyleLayer>, nodes, tileID, hasMapboxMeshFeatures, hasMeshoptCompression, this.brightness, featureIndex);
                         // Upload to GPU without waiting for evaluation if we are in diffuse path
                         if (!hasMapboxMeshFeatures) bucket.needsUpload = true;
-                        buckets[layer.fqid] = bucket;
+                        buckets.push(bucket);
                         // do the first evaluation in the worker to avoid stuttering
-                        // @ts-expect-error - TS2345 - Argument of type 'TypedStyleLayer' is not assignable to parameter of type 'ModelStyleLayer'.
                         bucket.evaluate(layer);
                     }
                 }
+
                 this.status = 'done';
-                // @ts-expect-error - TS2740 - Type '{ [_: string]: Bucket; }' is missing the following properties from type 'Bucket[]': length, pop, push, concat, and 35 more.
-                callback(null, {buckets, featureIndex});
+
+                callback(null, {
+                    buckets,
+                    featureIndex,
+                    collisionBoxArray: null,
+                    glyphAtlasImage: null,
+                    lineAtlas: null,
+                    imageAtlas: null,
+                    brightness: null,
+                });
             })
             .catch((err) => callback(new Error(err.message)));
     }
 }
 
-// @ts-expect-error - TS2420 - Class 'Tiled3dModelWorkerSource' incorrectly implements interface 'WorkerSource'.
 class Tiled3dModelWorkerSource implements WorkerSource {
     actor: Actor;
     layerIndex: StyleLayerIndex;
-
+    availableImages: Array<string>;
     loading: {
         [_: number]: Tiled3dWorkerTile;
     };
@@ -113,6 +118,7 @@ class Tiled3dModelWorkerSource implements WorkerSource {
     constructor(actor: Actor, layerIndex: StyleLayerIndex, availableImages: Array<string>, isSpriteLoaded: boolean, loadVectorData?: LoadVectorData, brightness?: number) {
         this.actor = actor;
         this.layerIndex = layerIndex;
+        this.availableImages = availableImages;
         this.brightness = brightness;
         this.loading = {};
         this.loaded = {};