@netless/app-presentation 0.1.10 → 0.1.11

package/src/camera-options.ts

@@ -0,0 +1,19 @@
+export interface CameraTransformOptions {
+  disableCameraTransform?: boolean;
+  disableDeviceCameraTransform?: boolean;
+}
+
+export function getCameraScaleRange(
+  fitScale: number,
+  maxCameraScale: number,
+  disableCameraTransform?: boolean
+): { minScale: number; maxScale: number } {
+  return {
+    minScale: fitScale,
+    maxScale: fitScale * (disableCameraTransform ? 1 : maxCameraScale),
+  }
+}
+
+export function shouldDisableDeviceCameraTransform(options: CameraTransformOptions): boolean {
+  return Boolean(options.disableCameraTransform || options.disableDeviceCameraTransform)
+}

package/src/camera-reference.ts

@@ -0,0 +1,81 @@
+import type { Camera, Rectangle, Size } from "@netless/window-manager"
+
+export function isValidSize(size: Size | null | undefined): size is Size {
+  return Boolean(
+    size &&
+    Number.isFinite(size.width) &&
+    Number.isFinite(size.height) &&
+    size.width > 0 &&
+    size.height > 0
+  )
+}
+
+export function isValidSharedViewport(
+  viewport: Rectangle | null | undefined
+): viewport is Rectangle {
+  return Boolean(
+    viewport &&
+    Number.isFinite(viewport.originX) &&
+    Number.isFinite(viewport.originY) &&
+    isValidSize(viewport)
+  )
+}
+
+export function getCameraReferenceSize(
+  originSize: Size | null | undefined,
+  pageSize: Size
+): Size {
+  return isValidSize(originSize) ? originSize : pageSize
+}
+
+export function fitPageSizeToOrigin(
+  pageSize: Size,
+  originSize: Size | null | undefined
+): Size {
+  if (!isValidSize(pageSize) || !isValidSize(originSize)) return { ...pageSize }
+  const ratio = Math.min(
+    originSize.width / pageSize.width,
+    originSize.height / pageSize.height
+  )
+  if (!(Number.isFinite(ratio) && ratio > 0)) return { ...pageSize }
+  return {
+    width: pageSize.width * ratio,
+    height: pageSize.height * ratio,
+  }
+}
+
+export function getFitScale(viewSize: Size, referenceSize: Size): number | undefined {
+  if (!isValidSize(viewSize) || !isValidSize(referenceSize)) return
+  const scale = Math.min(
+    viewSize.width / referenceSize.width,
+    viewSize.height / referenceSize.height
+  )
+  return Number.isFinite(scale) && scale > 0 ? scale : undefined
+}
+
+export function cameraToSharedViewport(
+  camera: Camera,
+  viewSize: Size,
+  referenceSize: Size
+): Rectangle | undefined {
+  const fitScale = getFitScale(viewSize, referenceSize)
+  if (
+    fitScale === undefined ||
+    !Number.isFinite(camera.centerX) ||
+    !Number.isFinite(camera.centerY) ||
+    !Number.isFinite(camera.scale) ||
+    camera.scale <= 0
+  ) {
+    return
+  }
+
+  const normalizedScale = camera.scale / fitScale
+  const width = referenceSize.width / normalizedScale
+  const height = referenceSize.height / normalizedScale
+  return {
+    originX: camera.centerX - width / 2,
+    originY: camera.centerY - height / 2,
+    width,
+    height,
+  }
+}