Fix snap picking coordinate scaling

  Use the renderer's effective resolution scale when mapping CSS cursor
  coordinates into WebGL pick/snap buffers and when projecting snapped
  positions back to canvas coordinates.

Author: xeolabs

packages/sdk/src/viewing/webGLRenderer/internal/ViewManager.ts

@@ -14,6 +14,7 @@ import {SceneTransform} from "../../../model/scene/SceneTransform";
 import {type MemoryConfigs} from "../MemoryConfigs";
 import type {DataTextures} from "./gpuMemoryManager/DataTextures";
 import {RenderInspector, ShaderInspector} from "./inspectors";
+import {getEffectiveResolutionScale} from "./resolutionScale";
 
 /**
  * Top-level, internal rendering and pipeline manager within a {@link WebGLRenderer}.
@@ -764,9 +765,7 @@ export class ViewManager {
     const top = Math.round(rect.top);
 
     // Resolution scaling affects only the backing buffer size.
-    const resolutionScale = view.resolutionScale.applied
-      ? Math.max(0.05, view.resolutionScale.resolutionScale)
-      : 1.0;
+    const resolutionScale = getEffectiveResolutionScale(view);
 
     const pixelWidth = Math.max(1, Math.round(cssWidth * resolutionScale));
     const pixelHeight = Math.max(1, Math.round(cssHeight * resolutionScale));

packages/sdk/src/viewing/webGLRenderer/internal/pickManager/PickManager.ts

@@ -20,6 +20,7 @@ import {SceneMesh} from "../../../../model/scene";
 import {RENDER_PASSES} from "../RENDER_PASSES";
 import {createRTCViewMat} from "../../../../base/math/rtc";
 import {GaussianSplatPickTechnique, SPLAT_PICK_SENTINEL} from "../drawOps/techniques/splats/GaussianSplatPickTechnique";
+import {getEffectiveResolutionScale} from "../resolutionScale";
 
 const tempVec3a = createVec3Float64();
 const tempVec3b = createVec3Float64();
@@ -289,7 +290,7 @@ export class PickManager {
 
     const view = rendererView.view;
     const viewIndex = view.viewIndex;
-    const resolutionScale = view.resolutionScale;
+    const effectiveResolutionScale = getEffectiveResolutionScale(view);
     const renderContext = this._renderContext;
     const gl = renderContext.gl;
     const pickBuffer = this._pickBuffer;
@@ -311,8 +312,8 @@ export class PickManager {
     renderContext.pickProjMatrix = pickProjMatrix;
     renderContext.pickInvisible = !!pickInvisible;
     renderContext.pickClipPos = [
-      this._getClipPosX(pickCanvasPos[0] * resolutionScale.resolutionScale, gl.drawingBufferWidth),
-      this._getClipPosY(pickCanvasPos[1] * resolutionScale.resolutionScale, gl.drawingBufferHeight)
+      this._getClipPosX(pickCanvasPos[0] * effectiveResolutionScale, gl.drawingBufferWidth),
+      this._getClipPosY(pickCanvasPos[1] * effectiveResolutionScale, gl.drawingBufferHeight)
     ];
 
     gl.viewport(0, 0, 1, 1);

packages/sdk/src/viewing/webGLRenderer/internal/resolutionScale.ts

@@ -0,0 +1,16 @@
+import type {View} from "../../viewer";
+
+/**
+ * Returns the backing-buffer scale currently applied to a View.
+ *
+ * `ResolutionScale.resolutionScale` is only the configured value. The renderer
+ * applies it only while the View's render mode is included in
+ * `ResolutionScale.renderModes`; otherwise CSS pixels and drawing-buffer pixels
+ * are 1:1.
+ */
+export function getEffectiveResolutionScale(view: Pick<View, "resolutionScale">): number {
+  const resolutionScale = view.resolutionScale;
+  return resolutionScale.applied
+    ? Math.max(0.05, resolutionScale.resolutionScale)
+    : 1.0;
+}

packages/sdk/src/viewing/webGLRenderer/internal/snapManager/SnapManager.ts

@@ -13,6 +13,7 @@ import {MeshManager} from "../meshManager/MeshManager";
 import {GPUMemoryManager} from "../gpuMemoryManager/GPUMemoryManager";
 import {getDrawOps, DrawOps, putDrawOps} from "../drawOps/DrawOps";
 import {RENDER_PASSES} from "../RENDER_PASSES";
+import {getEffectiveResolutionScale} from "../resolutionScale";
 
 const tempVec3a = createVec3Float64();
 const tempVec4a = createVec4Float64();
@@ -171,10 +172,10 @@ export class SnapManager {
     // Cursor → clip-space NDC for the snap viewport remap. Same
     // formula PickManager uses for its 1×1 case; the snap viewport
     // gives the cursor a (2r+1)² window of pixels around it.
-    const resolutionScale = view.resolutionScale;
+    const effectiveResolutionScale = getEffectiveResolutionScale(view);
     renderContext.snapClipPos = createVec2Float64([
-      this._clipPosX(params.canvasPos[0] * resolutionScale.resolutionScale, gl.drawingBufferWidth),
-      this._clipPosY(params.canvasPos[1] * resolutionScale.resolutionScale, gl.drawingBufferHeight),
+      this._clipPosX(params.canvasPos[0] * effectiveResolutionScale, gl.drawingBufferWidth),
+      this._clipPosY(params.canvasPos[1] * effectiveResolutionScale, gl.drawingBufferHeight),
     ]);
     renderContext.snapBufferSize = createVec2Float64([dim, dim]);
 
@@ -285,8 +286,8 @@ export class SnapManager {
     const wClip = clipHomog[3] || 1;
     const ndcX = clipHomog[0] / wClip;
     const ndcY = clipHomog[1] / wClip;
-    const cssWidth  = gl.drawingBufferWidth  / resolutionScale.resolutionScale;
-    const cssHeight = gl.drawingBufferHeight / resolutionScale.resolutionScale;
+    const cssWidth  = gl.drawingBufferWidth  / effectiveResolutionScale;
+    const cssHeight = gl.drawingBufferHeight / effectiveResolutionScale;
     snappedCanvasPos[0] = (ndcX + 1) * 0.5 * cssWidth;
     snappedCanvasPos[1] = (1 - ndcY) * 0.5 * cssHeight;
 

packages/sdk/src/viewing/webGLRenderer/internal/tests/RenderContext.initFailure.test.ts

@@ -0,0 +1,27 @@
+/**
+ * @jest-environment jsdom
+ */
+
+jest.mock("../webGL", () => ({
+  WEBGL_INFO: {MAX_TEXTURE_UNITS: 8},
+}));
+
+import {RenderContext} from "../RenderContext";
+
+describe("RenderContext init failure cleanup", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+    document.body.innerHTML = "";
+  });
+
+  test("does not append a canvas when WebGL2 context creation fails", () => {
+    jest.spyOn(HTMLCanvasElement.prototype, "getContext").mockReturnValue(null as any);
+    const context = new RenderContext({} as any);
+
+    const result = context.init({} as any);
+
+    expect(result.ok).toBe(false);
+    expect(document.body.querySelectorAll("canvas")).toHaveLength(0);
+    expect(() => context.destroy()).not.toThrow();
+  });
+});

packages/sdk/src/viewing/webGLRenderer/internal/tests/ViewManager.initFailure.test.ts

@@ -0,0 +1,37 @@
+/**
+ * @jest-environment jsdom
+ */
+
+jest.mock("../webGL", () => ({
+  WEBGL_INFO: {MAX_TEXTURE_UNITS: 8},
+}));
+jest.mock("../../../viewer", () => ({
+  Camera: class {},
+  Effect: class {},
+  View: class {},
+  Viewer: class {},
+  ViewObject: class {},
+}));
+
+import {ViewManager} from "../ViewManager";
+
+function createViewer(numViews: number) {
+  return {
+    numViews,
+    viewList: Array.from({length: numViews}, (_, i) => ({id: `view-${i}`})),
+  };
+}
+
+describe("ViewManager init failure cleanup", () => {
+  test("destroy is safe after init fails before RenderContext creation", () => {
+    const manager = new ViewManager();
+
+    const result = manager.init({
+      viewer: createViewer(4) as any,
+      memoryConfigs: {} as any,
+    });
+
+    expect(result.ok).toBe(false);
+    expect(() => manager.destroy()).not.toThrow();
+  });
+});

packages/sdk/src/viewing/webGLRenderer/internal/tests/resolutionScale.test.ts

@@ -0,0 +1,24 @@
+import {getEffectiveResolutionScale} from "../resolutionScale";
+
+function viewWithResolutionScale(applied: boolean, resolutionScale: number) {
+  return {
+    resolutionScale: {
+      applied,
+      resolutionScale,
+    },
+  } as any;
+}
+
+describe("getEffectiveResolutionScale", () => {
+  test("returns 1 when resolution scaling is not active", () => {
+    expect(getEffectiveResolutionScale(viewWithResolutionScale(false, 0.5))).toBe(1.0);
+  });
+
+  test("returns the configured scale when resolution scaling is active", () => {
+    expect(getEffectiveResolutionScale(viewWithResolutionScale(true, 0.5))).toBe(0.5);
+  });
+
+  test("clamps active resolution scaling to the renderer minimum", () => {
+    expect(getEffectiveResolutionScale(viewWithResolutionScale(true, 0.01))).toBe(0.05);
+  });
+});