QRF support for model source.

stephanheigl · github-actions[bot] · commit c28b11be3dfc · 2025-10-10T12:56:49.000Z
GitOrigin-RevId: 393e3ebd5db57ad21f429d2e413102c98cf83a76
diff --git a/3d-style/data/model.ts b/3d-style/data/model.ts
@@ -297,8 +297,11 @@ export default class Model {
     nodeOverrideNames: string[] = [];
     featureProperties: Record<string, unknown> = {};
 
-    constructor(id: string, position: [number, number] | null | undefined, orientation: [number, number, number] | null | undefined, nodes: Array<ModelNode>) {
+    uri: string;
+
+    constructor(id: string, uri: string, position: [number, number] | null | undefined, orientation: [number, number, number] | null | undefined, nodes: Array<ModelNode>) {
         this.id = id;
+        this.uri = uri;
         this.position = position != null ? new LngLat(position[0], position[1]) : new LngLat(0, 0);
 
         this.orientation = orientation != null ? orientation : [0, 0, 0];
diff --git a/3d-style/render/model_manager.ts b/3d-style/render/model_manager.ts
@@ -49,7 +49,7 @@ class ModelManager extends Evented {
                 if (!gltf) return;
 
                 const nodes = convertModel(gltf);
-                const model = new Model(id, undefined, undefined, nodes);
+                const model = new Model(id, url, undefined, undefined, nodes);
                 model.computeBoundsAndApplyParent();
                 return model;
             })
diff --git a/3d-style/source/model_source.ts b/3d-style/source/model_source.ts
@@ -113,7 +113,7 @@ class ModelSource extends Evented<SourceEvents> implements ISource {
                 const modelPromise = loadGLTF(this.map._requestManager.transformRequest(modelSpec.uri, ResourceType.Model).url).then(gltf => {
                     if (!gltf) return;
                     const nodes = convertModel(gltf);
-                    const model = new Model(modelId, modelSpec.position, modelSpec.orientation, nodes);
+                    const model = new Model(modelId, modelSpec.uri, modelSpec.position, modelSpec.orientation, nodes);
                     ModelSource.applyModelSpecification(model, modelSpec);
                     model.computeBoundsAndApplyParent();
                     this.models.push(model);
diff --git a/3d-style/style/style_layer/model_style_layer.ts b/3d-style/style/style_layer/model_style_layer.ts
@@ -9,14 +9,16 @@ import {latFromMercatorY, lngFromMercatorX} from '../../../src/geo/mercator_coor
 import EXTENT from '../../../src/style-spec/data/extent';
 import {convertModelMatrixForGlobe, queryGeometryIntersectsProjectedAabb} from '../../util/model_util';
 import Tiled3dModelBucket from '../../data/bucket/tiled_3d_model_bucket';
+import Feature from '../../../src/util/vectortile_to_geojson';
+import {type Feature as ExpressionEvalFeature, type FeatureState} from '../../../src/style-spec/expression/index';
+import ModelSource from '../../source/model_source';
 
 import type {Layout, Transitionable, Transitioning, PossiblyEvaluated, PropertyValue, ConfigOptions} from '../../../src/style/properties';
 import type Point from '@mapbox/point-geometry';
-import type {LayerSpecification} from '../../../src/style-spec/types';
+import type {LayerSpecification, ModelLayerSpecification} from '../../../src/style-spec/types';
 import type {PaintProps, LayoutProps} from './model_style_layer_properties';
 import type {BucketParameters, Bucket} from '../../../src/data/bucket';
-import type {TilespaceQueryGeometry} from '../../../src/style/query_geometry';
-import type {FeatureState} from '../../../src/style-spec/expression/index';
+import type {QueryGeometry, TilespaceQueryGeometry} from '../../../src/style/query_geometry';
 import type Transform from '../../../src/geo/transform';
 import type ModelManager from '../../render/model_manager';
 import type {ModelNode} from '../../data/model';
@@ -25,6 +27,8 @@ import type {CanonicalTileID} from '../../../src/source/tile_id';
 import type {LUT} from "../../../src/util/lut";
 import type {EvaluationFeature} from '../../../src/data/evaluation_feature';
 import type {ProgramName} from '../../../src/render/program';
+import type {QueryResult} from '../../../src/source/query_features';
+import type SourceCache from '../../../src/source/source_cache';
 
 class ModelStyleLayer extends StyleLayer {
     override type: 'model';
@@ -37,13 +41,15 @@ class ModelStyleLayer extends StyleLayer {
     override paint: PossiblyEvaluated<PaintProps>;
 
     modelManager: ModelManager;
+    layer: ModelLayerSpecification;
 
     constructor(layer: LayerSpecification, scope: string, lut: LUT | null, options?: ConfigOptions | null) {
         const properties = {
             layout: getLayoutProperties(),
             paint: getPaintProperties()
         };
         super(layer, properties, scope, lut, options);
+        this.layer = layer as ModelLayerSpecification;
         this._stats = {numRenderedVerticesInShadowPass: 0, numRenderedVerticesInTransparentPass: 0};
     }
 
@@ -79,6 +85,81 @@ class ModelStyleLayer extends StyleLayer {
         return (bucket instanceof Tiled3dModelBucket) ? EXTENT - 1 : 0;
     }
 
+    override queryRenderedFeatures(
+        queryGeometry: QueryGeometry,
+        sourceCache: SourceCache,
+        transform: Transform
+    ): QueryResult {
+        const source = sourceCache.getSource<ModelSource>();
+        if (!source || !(source instanceof ModelSource)) return {};
+        const modelSource: ModelSource = source;
+
+        const result: QueryResult = {};
+        result[this.id] = [];
+        const layerResult = result[this.id];
+
+        let modelFeatureIndex = 0;
+        for (const model of modelSource.models) {
+            const modelFeatureState = sourceCache.getFeatureState(this.sourceLayer, model.id);
+
+            const modelFeatureForEval: ExpressionEvalFeature = {
+                type: 'Unknown',
+                id: model.id,
+                properties: model.featureProperties
+            };
+            const rotation = this.paint.get('model-rotation').evaluate(modelFeatureForEval, modelFeatureState);
+            const scale = this.paint.get('model-scale').evaluate(modelFeatureForEval, modelFeatureState);
+            const translation = this.paint.get('model-translation').evaluate(modelFeatureForEval, modelFeatureState);
+            const elevationReference = this.paint.get('model-elevation-reference');
+            const shouldFollowTerrainSlope = elevationReference === 'ground';
+            const shouldApplyElevation = elevationReference === 'ground';
+
+            let matrix: mat4 = [];
+            calculateModelMatrix(matrix,
+                                         model,
+                                         transform,
+                                         model.position,
+                                         rotation,
+                                         scale,
+                                         translation,
+                                         shouldApplyElevation,
+                                         shouldFollowTerrainSlope,
+                                         false);
+
+            if (transform.projection.name === 'globe') {
+                matrix = convertModelMatrixForGlobe(matrix, transform);
+            }
+            const worldViewProjection = mat4.multiply([], transform.projMatrix, matrix);
+
+            const projectedQueryGeometry = queryGeometry.isPointQuery() ? queryGeometry.screenBounds : queryGeometry.screenGeometry;
+
+            const depth = queryGeometryIntersectsProjectedAabb(projectedQueryGeometry, transform, worldViewProjection, model.aabb);
+            if (depth != null) {
+                const modelFeature: Feature = new Feature(undefined, 0, 0, 0, model.id);
+                modelFeature.layer = this.layer;
+                // Use unsafe assignment for now, due to restriction of GeoJSON/Feature properties to number, string and boolean.
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
+                modelFeature.properties = structuredClone(model.featureProperties) as any;
+                modelFeature.properties['layer'] = this.id;
+                modelFeature.properties['uri'] = model.uri;
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
+                modelFeature.properties['orientation'] = model.orientation as any;
+                modelFeature.sourceLayer = this.sourceLayer;
+                modelFeature.geometry = {
+                    type: 'Point',
+                    coordinates: [model.position.lng, model.position.lat]
+                };
+                modelFeature.state = modelFeatureState;
+                modelFeature.source = this.source;
+                layerResult.push({featureIndex: modelFeatureIndex, feature: modelFeature, intersectionZ: depth});
+            }
+
+            ++modelFeatureIndex;
+        }
+
+        return result;
+    }
+
     override queryIntersectsFeature(
         queryGeometry: TilespaceQueryGeometry,
         feature: VectorTileFeature,
diff --git a/src/source/query_features.ts b/src/source/query_features.ts
@@ -117,6 +117,16 @@ export function queryRenderedFeatures(
         }
     }
 
+    for (const layerId in query.layers) {
+        const layer = query.layers[layerId];
+        if (layer.styleLayer) {
+            const queryResults = layer.styleLayer.queryRenderedFeatures(queryGeometry, query.sourceCache, transform);
+            if (Object.keys(queryResults).length) {
+                renderedFeatureLayers.push({wrappedTileID: 0, queryResults});
+            }
+        }
+    }
+
     if (renderedFeatureLayers.length === 0) {
         return {};
     }
diff --git a/src/style/style_layer.ts b/src/style/style_layer.ts
@@ -26,7 +26,7 @@ import type {
 } from '../style-spec/types';
 import type {CustomLayerInterface} from './style_layer/custom_style_layer';
 import type {Map as MapboxMap} from '../ui/map';
-import type {TilespaceQueryGeometry} from './query_geometry';
+import type {QueryGeometry, TilespaceQueryGeometry} from './query_geometry';
 import type {DEMSampler} from '../terrain/elevation';
 import type {VectorTileFeature} from '@mapbox/vector-tile';
 import type {CreateProgramParams} from '../render/painter';
@@ -36,6 +36,7 @@ import type {LUT} from '../util/lut';
 import type {ImageId} from '../style-spec/expression/types/image_id';
 import type {ProgramName} from '../render/program';
 import type {AppearanceProps} from './appearance_properties';
+import type {QueryResult} from '../source/query_features';
 
 const TRANSITION_SUFFIX = '-transition';
 
@@ -462,6 +463,12 @@ class StyleLayer extends Evented {
         return this.appearances;
     }
 
+    queryRenderedFeatures(
+        queryGeometry: QueryGeometry,
+        sourceCache: SourceCache,
+        transform: Transform
+    ) : QueryResult { return {}; }
+
     // @ts-expect-error - TS2355 - A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
     queryRadius(_bucket: Bucket): number {}
 
diff --git a/src/util/vectortile_to_geojson.ts b/src/util/vectortile_to_geojson.ts
@@ -20,7 +20,7 @@ class Feature implements GeoJSONFeature {
     properties: Record<string, string | number | boolean>;
     tile?: {z: number; x: number; y: number};
     _geometry?: GeoJSON.Geometry;
-    _vectorTileFeature: VectorTileFeature;
+    _vectorTileFeature: VectorTileFeature | null | undefined;
     _x: number;
     _y: number;
     _z: number;
@@ -31,15 +31,15 @@ class Feature implements GeoJSONFeature {
     state?: FeatureState;
     variants?: Record<string, FeatureVariant[]>;
 
-    constructor(vectorTileFeature: VectorTileFeature, z: number, x: number, y: number, id?: string | number) {
+    constructor(vectorTileFeature: VectorTileFeature | null | undefined, z: number, x: number, y: number, id?: string | number) {
         this.type = 'Feature';
 
         this._vectorTileFeature = vectorTileFeature;
         this._z = z;
         this._x = x;
         this._y = y;
 
-        this.properties = vectorTileFeature.properties;
+        this.properties = vectorTileFeature ? vectorTileFeature.properties : {};
         this.id = id;
     }
 
@@ -53,7 +53,7 @@ class Feature implements GeoJSONFeature {
     }
 
     get geometry(): GeoJSON.Geometry {
-        if (this._geometry === undefined) {
+        if (this._geometry === undefined && this._vectorTileFeature) {
             this._geometry = this._vectorTileFeature.toGeoJSON(this._x, this._y, this._z).geometry;
         }
         return this._geometry;
diff --git a/test/integration/query-tests/model/model-source-globe/expected.json b/test/integration/query-tests/model/model-source-globe/expected.json
@@ -0,0 +1,24 @@
+[
+  {
+    "type": "Feature",
+    "state": {},
+    "geometry": {
+      "type": "Point",
+      "coordinates": [
+        20,
+        20
+      ]
+    },
+    "properties": {
+      "layer": "model",
+      "uri": "local://models/low-poly-car.gltf",
+      "orientation": [
+        -45,
+        0,
+        45
+      ]
+    },
+    "id": "model-on-side2",
+    "source": "model"
+  }
+]
diff --git a/test/integration/query-tests/model/model-source-globe/style.json b/test/integration/query-tests/model/model-source-globe/style.json
@@ -0,0 +1,88 @@
+{
+  "version": 8,
+  "metadata": {
+    "test": {
+      "width": 512,
+      "height": 512,
+      "operations": [
+        ["setProjection", "globe"],
+        ["wait"]
+      ],
+       "queryGeometry": [
+        [
+          426,
+          203
+        ],
+        [
+          430,
+          230
+        ]
+      ]
+    }
+  },
+  "center": [ 0, 0 ],
+  "zoom": 3.00,
+  "pitch": 60,
+  "fog": {
+    "star-intensity": 0.0
+  },
+  "sources": {
+    "model": {
+      "type": "model",
+      "models": {
+        "model-1" : {
+          "uri": "local://models/low-poly-car.gltf",
+          "position": [0, 0],
+          "orientation": [0, 0, 45]
+        },
+        "model-on-bumper-1" : {
+          "uri": "local://models/low-poly-car.gltf",
+          "position": [-20, 20],
+          "orientation": [0, 110, 180]
+        },
+        "model-on-roof-resting" : {
+          "uri": "local://models/low-poly-car.gltf",
+          "position": [-20, -20],
+          "orientation": [0, 180, 180]
+        },
+        "model-on-bumper-resting" : {
+          "uri": "local://models/low-poly-car.gltf",
+          "position": [0, -20],
+          "orientation": [0, 90, 180]
+        },
+        "model-on-side1" : {
+          "uri": "local://models/low-poly-car.gltf",
+          "position": [20, 0],
+          "orientation": [-90, 0, 45]
+        },
+        "model-on-side2" : {
+          "uri": "local://models/low-poly-car.gltf",
+          "position": [20, 20],
+          "orientation": [-45, 0, 45]
+        },
+        "model-on-side3" : {
+          "uri": "local://models/low-poly-car.gltf",
+          "position": [0.00000, 20],
+          "orientation": [0, 45, 45]
+        }
+      }
+    }
+  },
+  "layers": [
+    {
+      "id": "background",
+      "type": "background",
+      "paint": {
+          "background-color": "white"
+      }
+    },
+    {
+      "id": "model",
+      "type": "model",
+      "source": "model",
+      "paint": {
+        "model-scale" : [200000, 200000, 200000]
+      }
+    }
+  ]
+}
diff --git a/test/integration/query-tests/model/model-source-mercator-terrain/expected.json b/test/integration/query-tests/model/model-source-mercator-terrain/expected.json
@@ -0,0 +1,24 @@
+[
+  {
+    "type": "Feature",
+    "state": {},
+    "geometry": {
+      "type": "Point",
+      "coordinates": [
+        -122.394457,
+        37.794784
+      ]
+    },
+    "properties": {
+      "layer": "model",
+      "uri": "local://models/low-poly-car.gltf",
+      "orientation": [
+        0,
+        0,
+        0
+      ]
+    },
+    "id": "model-1",
+    "source": "model"
+  }
+]
diff --git a/test/integration/query-tests/model/model-source-mercator-terrain/style.json b/test/integration/query-tests/model/model-source-mercator-terrain/style.json
diff --git a/test/integration/query-tests/model/model-source-mercator/expected.json b/test/integration/query-tests/model/model-source-mercator/expected.json
diff --git a/test/integration/query-tests/model/model-source-mercator/style.json b/test/integration/query-tests/model/model-source-mercator/style.json
diff --git a/test/integration/query-tests/model/sf-trees-duplicate-layer/expected.json b/test/integration/query-tests/model/sf-trees-duplicate-layer/expected.json
diff --git a/test/integration/query-tests/model/sf-trees-puck-landmarks/expected.json b/test/integration/query-tests/model/sf-trees-puck-landmarks/expected.json

Original file line number	Diff line number	Diff line change
`@@ -117,6 +117,16 @@ export function queryRenderedFeatures(`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`
	`120`	`+ for (const layerId in query.layers) {`
	`121`	`+ const layer = query.layers[layerId];`
	`122`	`+ if (layer.styleLayer) {`
	`123`	`+ const queryResults = layer.styleLayer.queryRenderedFeatures(queryGeometry, query.sourceCache, transform);`
	`124`	`+ if (Object.keys(queryResults).length) {`
	`125`	`+ renderedFeatureLayers.push({wrappedTileID: 0, queryResults});`
	`126`	`+ }`
	`127`	`+ }`
	`128`	`+ }`
	`129`	`+`
`120`	`130`	`if (renderedFeatureLayers.length === 0) {`
`121`	`131`	`return {};`
`122`	`132`	`}`