Z scaling

common/api/imodeljs-frontend.api.md

@@ -5930,15 +5930,7 @@ export class MeasureAreaTool extends MeasureElementTool {
 // @alpha (undocumented)
 export class MeasureDistanceTool extends PrimitiveTool {
     // (undocumented)
-    protected readonly _acceptedSegments: {
-        distance: number;
-        slope: number;
-        start: Point3d;
-        end: Point3d;
-        delta: Vector3d;
-        refAxes: Matrix3d;
-        marker: MeasureMarker;
-    }[];
+    protected readonly _acceptedSegments: Segment[];
     // (undocumented)
     protected acceptNewSegments(): Promise<void>;
     // (undocumented)
@@ -5952,7 +5944,7 @@ export class MeasureDistanceTool extends PrimitiveTool {
     // (undocumented)
     protected displayDelta(context: DecorateContext, seg: any): void;
     // (undocumented)
-    protected displayDynamicDistance(context: DecorateContext, points: Point3d[]): void;
+    protected displayDynamicDistance(context: DecorateContext, points: Point3d[], adjustedPoints: Point3d[]): void;
     // (undocumented)
     getDecorationGeometry(_hit: HitDetail): GeometryStreamProps | undefined;
     // (undocumented)
@@ -5968,12 +5960,11 @@ export class MeasureDistanceTool extends PrimitiveTool {
     // (undocumented)
     isValidLocation(_ev: BeButtonEvent, _isButtonEvent: boolean): boolean;
     // (undocumented)
+    protected _lastMotionAdjustedPt?: Point3d;
+    // (undocumented)
     protected _lastMotionPt?: Point3d;
     // (undocumented)
-    protected readonly _locationData: {
-        point: Point3d;
-        refAxes: Matrix3d;
-    }[];
+    protected readonly _locationData: Location[];
     // (undocumented)
     onDataButtonDown(ev: BeButtonEvent): Promise<EventHandled>;
     // (undocumented)
@@ -8114,6 +8105,8 @@ export abstract class RenderSystem implements IDisposable {
     get supportsInstancing(): boolean;
     // @internal (undocumented)
     get supportsLogZBuffer(): boolean;
+    // @internal (undocumented)
+    get supportsNonuniformScaledInstancing(): boolean;
 }
 
 // @public
@@ -8509,6 +8502,8 @@ export class ScreenViewport extends Viewport {
         source: DepthPointSource;
         sourceId?: string;
     };
+    // @internal (undocumented)
+    picker: ElementPicker;
     pickNearestVisibleGeometry(pickPoint: Point3d, radius?: number, allowNonLocatable?: boolean, out?: Point3d): Point3d | undefined;
     // @internal
     static removeAllChildren(el: HTMLDivElement): void;
@@ -10199,6 +10194,8 @@ export class TileDrawArgs {
     // @internal (undocumented)
     parentsAndChildrenExclusive: boolean;
     // @internal (undocumented)
+    readonly pixelSizeScaleFactor: number;
+    // @internal (undocumented)
     planarClassifier?: RenderPlanarClassifier;
     // @internal
     processSelectedTiles(_tiles: Tile[]): void;
@@ -12675,6 +12672,10 @@ export abstract class ViewState extends ElementState {
     // (undocumented)
     toJSON(): ViewDefinitionProps;
     toProps(): ViewStateProps;
+    // @internal (undocumented)
+    transformNormalByModelDisplayTransform(modelId: string | undefined, normal: Vector3d): void;
+    // @internal (undocumented)
+    transformPointByModelDisplayTransform(modelId: string | undefined, pnt: Point3d, inverse: boolean): void;
     // (undocumented)
     protected _updateMaxGlobalScopeFactor(): void;
     get viewFlags(): ViewFlags;

common/changes/@bentley/imodeljs-frontend/z-scaling_2021-03-22-21-25.json

@@ -0,0 +1,11 @@
+{
+  "changes": [
+    {
+      "packageName": "@bentley/imodeljs-frontend",
+      "comment": "Added capability to scale the model display transform nonuniformly and have still Accusnap properly.",
+      "type": "none"
+    }
+  ],
+  "packageName": "@bentley/imodeljs-frontend",
+  "email": "36053767+MarcNeely@users.noreply.github.com"
+}

core/frontend/src/AccuSnap.ts

@@ -705,28 +705,39 @@ export class AccuSnap implements Decorator {
     };
 
     // If this hit is from a plan projection model, apply the model's elevation to the snap point for display.
+    // Likewise, if it is a hit on a model with a display transform, apply the model's transform to the snap point.
     let snapPoint = result.snapPoint!;
     const elevation = undefined !== thisHit.modelId ? thisHit.viewport.view.getModelElevation(thisHit.modelId) : 0;
-    if (0 !== elevation) {
+    if (0 !== elevation || undefined !== thisHit.viewport.view.modelDisplayTransformProvider) {
       const adjustedSnapPoint = Point3d.fromJSON(snapPoint);
+      thisHit.viewport.view.transformPointByModelDisplayTransform(thisHit.modelId, adjustedSnapPoint, false);
       adjustedSnapPoint.z += elevation;
       snapPoint = adjustedSnapPoint;
     }
 
     const snap = new SnapDetail(thisHit, result.snapMode, result.heat, snapPoint);
 
-    // Apply model's elevation to curve for display.
+    // Apply model's elevation and display transform to curve for display.
     let transform;
-    if (0 !== elevation)
+    if (undefined !== thisHit.modelId && undefined !== thisHit.viewport.view.modelDisplayTransformProvider) {
+      transform = thisHit.viewport.view.getModelDisplayTransform(thisHit.modelId, Transform.createIdentity());
+      if (0 !== elevation)
+        transform.origin.set(0, 0, elevation);
+    } else if (0 !== elevation) {
       transform = Transform.createTranslationXYZ(0, 0, elevation);
+    }
 
     snap.setCurvePrimitive(parseCurve(result.curve), transform, result.geomType);
     if (undefined !== result.parentGeomType)
       snap.parentGeomType = result.parentGeomType;
-    if (undefined !== result.hitPoint)
+    if (undefined !== result.hitPoint) {
       snap.hitPoint.setFromJSON(result.hitPoint); // Update hitPoint from readPixels with exact point location corrected to surface/edge geometry...
-    if (undefined !== result.normal)
+      thisHit.viewport.view.transformPointByModelDisplayTransform(thisHit.modelId, snap.hitPoint, false);
+    }
+    if (undefined !== result.normal) {
       snap.normal = Vector3d.fromJSON(result.normal);
+      thisHit.viewport.view.transformNormalByModelDisplayTransform(thisHit.modelId, snap.normal);
+    }
 
     if (SnapMode.Intersection !== snap.snapMode)
       return snap;

core/frontend/src/ViewState.ts

@@ -1034,6 +1034,28 @@ export abstract class ViewState extends ElementState {
     return this.modelDisplayTransformProvider ? this.modelDisplayTransformProvider.getModelDisplayTransform(modelId, baseTransform) : baseTransform;
   }
 
+  /** @internal */
+  public transformPointByModelDisplayTransform(modelId: string | undefined, pnt: Point3d, inverse: boolean): void {
+    if (undefined !== modelId && undefined !== this.modelDisplayTransformProvider) {
+      const transform = this.modelDisplayTransformProvider.getModelDisplayTransform(modelId, Transform.createIdentity());
+      const newPnt = inverse ? transform.multiplyInversePoint3d(pnt) : transform.multiplyPoint3d(pnt);
+      if (undefined !== newPnt)
+        pnt.set(newPnt.x, newPnt.y, newPnt.z);
+    }
+  }
+
+  /** @internal */
+  public transformNormalByModelDisplayTransform(modelId: string | undefined, normal: Vector3d): void {
+    if (undefined !== modelId && undefined !== this.modelDisplayTransformProvider) {
+      const transform = this.modelDisplayTransformProvider.getModelDisplayTransform(modelId, Transform.createIdentity());
+      const newVec = transform.matrix.multiplyInverse(normal);
+      if (undefined !== newVec) {
+        newVec.normalizeInPlace();
+        normal.set(newVec.x, newVec.y, newVec.z);
+      }
+    }
+  }
+
   /** Invoked when this view becomes the view displayed by the specified [[Viewport]].
    * A ViewState can be attached to at most **one** Viewport.
    * @note If you override this method you **must** call `super.attachToViewport`.

core/frontend/src/Viewport.ts

@@ -2366,9 +2366,12 @@ export abstract class Viewport implements IDisposable {
       this.npcToWorld(npc, npc);
 
       // If this is a plan projection model, invert the elevation applied to its display transform.
+      // Likewise, if it is a hit on a model with a display transform, reverse the display transform.
       const modelId = pixels.getPixel(x, y).featureTable?.modelId;
-      if (undefined !== modelId)
+      if (undefined !== modelId) {
         npc.z -= this.view.getModelElevation(modelId);
+        this.view.transformPointByModelDisplayTransform(modelId, npc, true);
+      }
     }
 
     return npc;
@@ -2765,6 +2768,9 @@ export class ScreenViewport extends Viewport {
     return result;
   }
 
+  /** @internal */
+  public picker = new ElementPicker(); // Picker used in pickDepthPoint below so it hangs around and can be querried later.
+
   /** Find a point on geometry visible in this Viewport, within a radius of supplied pick point.
    * If no geometry is selected, return the point projected to the most appropriate reference plane.
    * @param pickPoint Point to search about, in world coordinates
@@ -2781,14 +2787,14 @@ export class ScreenViewport extends Viewport {
     if (undefined === radius)
       radius = this.pixelsFromInches(ToolSettings.viewToolPickRadiusInches);
 
-    const picker = new ElementPicker();
+    this.picker.empty();
     const locateOpts = new LocateOptions();
     locateOpts.allowNonLocatable = (undefined === options || !options.excludeNonLocatable);
     locateOpts.allowDecorations = (undefined === options || !options.excludeDecorations);
     locateOpts.allowExternalIModels = (undefined === options || !options.excludeExternalIModels);
 
-    if (0 !== picker.doPick(this, pickPoint, radius, locateOpts)) {
-      const hitDetail = picker.getHit(0)!;
+    if (0 !== this.picker.doPick(this, pickPoint, radius, locateOpts)) {
+      const hitDetail = this.picker.getHit(0)!;
       const hitPoint = hitDetail.getPoint();
       if (hitDetail.isModelHit)
         return { plane: Plane3dByOriginAndUnitNormal.create(hitPoint, this.view.getUpVector(hitPoint))!, source: DepthPointSource.Model, sourceId: hitDetail.sourceId };

core/frontend/src/render/RenderSystem.ts

@@ -191,6 +191,9 @@ export abstract class RenderSystem implements IDisposable {
   /** @internal */
   public get supportsInstancing(): boolean { return true; }
 
+  /** @internal */
+  public get supportsNonuniformScaledInstancing(): boolean { return true; }
+
   /** @internal */
   public get dpiAwareLOD(): boolean { return true === this.options.dpiAwareLOD; }
 

core/frontend/src/render/webgl/BranchUniforms.ts

@@ -61,6 +61,7 @@ export class BranchUniforms {
   private readonly _mvp32 = new Matrix4();
   private readonly _m32 = new Matrix4();
   private readonly _v32 = new Matrix3();
+  private readonly _mvn32 = new Matrix3();
 
   // Working state
   private readonly _scratchTransform = Transform.createIdentity();
@@ -169,6 +170,11 @@ export class BranchUniforms {
       uniform.setMatrix3(this._v32);
   }
 
+  public bindModelViewNTransform(uniform: UniformHandle, geom: CachedGeometry, isViewCoords: boolean) {
+    if (this.update(uniform, geom, isViewCoords))
+      uniform.setMatrix3(this._mvn32);
+  }
+
   private update(uniform: UniformHandle, geometry: CachedGeometry, isViewCoords: boolean): boolean {
     const uniforms = this._target.uniforms[isViewCoords ? "viewRect" : "frustum"];
     if (!sync(uniforms, this))
@@ -230,6 +236,12 @@ export class BranchUniforms {
     Matrix4d.createTransform(mv, this._mv);
     this._mv32.initFromTransform(mv);
 
+    const inv = this._mv.createInverse();
+    if (undefined !== inv) {
+      const invTr = inv.cloneTransposed();
+      this._mvn32.initFromMatrix3d(invTr.matrixPart());
+    }
+
     // Don't bother computing mvp for instanced geometry - it's not used.
     if (!this._isInstanced) {
       uniforms.projectionMatrix.multiplyMatrixMatrix(this._mv, this._mvp);

core/frontend/src/render/webgl/System.ts

@@ -391,6 +391,7 @@ export class System extends RenderSystem implements RenderSystemDebugControl, Re
 
   public get maxTextureSize(): number { return this.capabilities.maxTextureSize; }
   public get supportsInstancing(): boolean { return this.capabilities.supportsInstancing; }
+  public get supportsNonuniformScaledInstancing(): boolean { return this.capabilities.isWebGL2; }
   public get isWebGL2(): boolean { return this.capabilities.isWebGL2; }
   public get isMobile(): boolean { return this.capabilities.isMobile; }
 

core/frontend/src/render/webgl/glsl/Vertex.ts

@@ -12,6 +12,7 @@ import { UniformHandle } from "../UniformHandle";
 import { Matrix4 } from "../Matrix";
 import { RenderPass, TextureUnit } from "../RenderFlags";
 import { VariableType, VertexShaderBuilder } from "../ShaderBuilder";
+import { System } from "../System";
 import { decodeUint16, decodeUint24 } from "./Decode";
 import { addInstanceOverrides } from "./Instancing";
 import { addLookupTable } from "./LookupTable";
@@ -113,7 +114,13 @@ export function addModelViewMatrix(vert: VertexShaderBuilder): void {
 }
 
 const computeNormalMatrix = `
-  g_nmx = mat3(MAT_MV);
+  g_nmx = mat3(u_modelViewN);
+  g_nmx[0][0] *= u_frustumScale.x;
+  g_nmx[1][1] *= u_frustumScale.y;
+`;
+
+const computeNormalMatrix2 = `
+  g_nmx = transpose(inverse(mat3(MAT_MV)));
   g_nmx[0][0] *= u_frustumScale.x;
   g_nmx[1][1] *= u_frustumScale.y;
 `;
@@ -128,7 +135,16 @@ export function addNormalMatrix(vert: VertexShaderBuilder) {
     });
   });
 
-  vert.addInitializer(computeNormalMatrix);
+  if (System.instance.capabilities.isWebGL2)
+    vert.addInitializer(computeNormalMatrix2);
+  else {
+    vert.addUniform("u_modelViewN", VariableType.Mat3, (prog) => {
+      prog.addGraphicUniform("u_modelViewN", (uniform, params) => {
+        params.target.uniforms.branch.bindModelViewNTransform(uniform, params.geometry, false);
+      });
+    });
+    vert.addInitializer(computeNormalMatrix);
+  }
 }
 
 const scratchLutParams = new Float32Array(4);