@genart-dev/projection 0.1.0

package/dist/index.cjs

@@ -0,0 +1,670 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  add: () => add,
+  aerialCamera: () => aerialCamera,
+  createCamera: () => createCamera,
+  cross: () => cross,
+  depthSort: () => depthSort,
+  depthSortIndices: () => depthSortIndices,
+  deriveVanishingPoints: () => deriveVanishingPoints,
+  distance: () => distance,
+  distanceSq: () => distanceSq,
+  distanceTo: () => distanceTo,
+  dollyCamera: () => dollyCamera,
+  dot: () => dot,
+  frustumContainsBox: () => frustumContainsBox,
+  frustumContainsPoint: () => frustumContainsPoint,
+  horizonScreenY: () => horizonScreenY,
+  identity: () => identity,
+  invert: () => invert,
+  isBackFace: () => isBackFace,
+  isometricCamera: () => isometricCamera,
+  landscapeCamera: () => landscapeCamera,
+  length: () => length,
+  lengthSq: () => lengthSq,
+  lerpCamera: () => lerpCamera,
+  lerpVec3: () => lerp,
+  lookAt: () => lookAt,
+  multiply: () => multiply,
+  negate: () => negate,
+  normalize: () => normalize,
+  normalizedDepth: () => normalizedDepth,
+  orbitCamera: () => orbitCamera,
+  orthographicMatrix: () => orthographicMatrix,
+  panCamera: () => panCamera,
+  perspectiveMatrix: () => perspectiveMatrix,
+  project: () => project,
+  projectMany: () => projectMany,
+  projectWithMatrix: () => projectWithMatrix,
+  scaleAtDepth: () => scaleAtDepth,
+  scaleVec3: () => scale,
+  streetCamera: () => streetCamera,
+  sub: () => sub,
+  transformDirection: () => transformDirection,
+  transformPoint: () => transformPoint,
+  transformPointRaw: () => transformPointRaw,
+  unproject: () => unproject,
+  updateCamera: () => updateCamera,
+  vec3: () => vec3,
+  viewProjectionMatrix: () => viewProjectionMatrix,
+  wormEyeCamera: () => wormEyeCamera
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/vec3.ts
+function vec3(x, y, z) {
+  return { x, y, z };
+}
+function add(a, b) {
+  return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
+}
+function sub(a, b) {
+  return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
+}
+function scale(v, s) {
+  return { x: v.x * s, y: v.y * s, z: v.z * s };
+}
+function dot(a, b) {
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+function cross(a, b) {
+  return {
+    x: a.y * b.z - a.z * b.y,
+    y: a.z * b.x - a.x * b.z,
+    z: a.x * b.y - a.y * b.x
+  };
+}
+function length(v) {
+  return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+}
+function lengthSq(v) {
+  return v.x * v.x + v.y * v.y + v.z * v.z;
+}
+function normalize(v) {
+  const len = length(v);
+  if (len === 0) return { x: 0, y: 0, z: 0 };
+  return { x: v.x / len, y: v.y / len, z: v.z / len };
+}
+function negate(v) {
+  return { x: -v.x, y: -v.y, z: -v.z };
+}
+function lerp(a, b, t) {
+  return {
+    x: a.x + (b.x - a.x) * t,
+    y: a.y + (b.y - a.y) * t,
+    z: a.z + (b.z - a.z) * t
+  };
+}
+function distance(a, b) {
+  return length(sub(a, b));
+}
+function distanceSq(a, b) {
+  return lengthSq(sub(a, b));
+}
+
+// src/mat4.ts
+function identity() {
+  const m = new Float64Array(16);
+  m[0] = 1;
+  m[5] = 1;
+  m[10] = 1;
+  m[15] = 1;
+  return m;
+}
+function lookAt(eye, target, up) {
+  const f = normalize(sub(target, eye));
+  const s = normalize(cross(up, f));
+  const u = cross(f, s);
+  const m = new Float64Array(16);
+  m[0] = s.x;
+  m[1] = u.x;
+  m[2] = -f.x;
+  m[3] = 0;
+  m[4] = s.y;
+  m[5] = u.y;
+  m[6] = -f.y;
+  m[7] = 0;
+  m[8] = s.z;
+  m[9] = u.z;
+  m[10] = -f.z;
+  m[11] = 0;
+  m[12] = -dot(s, eye);
+  m[13] = -dot(u, eye);
+  m[14] = dot(f, eye);
+  m[15] = 1;
+  return m;
+}
+function perspectiveMatrix(fovDegrees, aspect, near, far) {
+  const fovRad = fovDegrees * Math.PI / 180;
+  const f = 1 / Math.tan(fovRad / 2);
+  const rangeInv = 1 / (near - far);
+  const m = new Float64Array(16);
+  m[0] = f / aspect;
+  m[5] = f;
+  m[10] = (far + near) * rangeInv;
+  m[11] = -1;
+  m[14] = 2 * far * near * rangeInv;
+  return m;
+}
+function orthographicMatrix(left, right, bottom, top, near, far) {
+  const m = new Float64Array(16);
+  m[0] = 2 / (right - left);
+  m[5] = 2 / (top - bottom);
+  m[10] = -2 / (far - near);
+  m[12] = -(right + left) / (right - left);
+  m[13] = -(top + bottom) / (top - bottom);
+  m[14] = -(far + near) / (far - near);
+  m[15] = 1;
+  return m;
+}
+function multiply(a, b) {
+  const r = new Float64Array(16);
+  for (let col = 0; col < 4; col++) {
+    const c0 = b[col * 4];
+    const c1 = b[col * 4 + 1];
+    const c2 = b[col * 4 + 2];
+    const c3 = b[col * 4 + 3];
+    for (let row = 0; row < 4; row++) {
+      r[col * 4 + row] = a[row] * c0 + a[4 + row] * c1 + a[8 + row] * c2 + a[12 + row] * c3;
+    }
+  }
+  return r;
+}
+function invert(m) {
+  const a00 = m[0], a01 = m[1], a02 = m[2], a03 = m[3];
+  const a10 = m[4], a11 = m[5], a12 = m[6], a13 = m[7];
+  const a20 = m[8], a21 = m[9], a22 = m[10], a23 = m[11];
+  const a30 = m[12], a31 = m[13], a32 = m[14], a33 = m[15];
+  const b00 = a00 * a11 - a01 * a10;
+  const b01 = a00 * a12 - a02 * a10;
+  const b02 = a00 * a13 - a03 * a10;
+  const b03 = a01 * a12 - a02 * a11;
+  const b04 = a01 * a13 - a03 * a11;
+  const b05 = a02 * a13 - a03 * a12;
+  const b06 = a20 * a31 - a21 * a30;
+  const b07 = a20 * a32 - a22 * a30;
+  const b08 = a20 * a33 - a23 * a30;
+  const b09 = a21 * a32 - a22 * a31;
+  const b10 = a21 * a33 - a23 * a31;
+  const b11 = a22 * a33 - a23 * a32;
+  const det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+  if (Math.abs(det) < 1e-12) return null;
+  const invDet = 1 / det;
+  const r = new Float64Array(16);
+  r[0] = (a11 * b11 - a12 * b10 + a13 * b09) * invDet;
+  r[1] = (a02 * b10 - a01 * b11 - a03 * b09) * invDet;
+  r[2] = (a31 * b05 - a32 * b04 + a33 * b03) * invDet;
+  r[3] = (a22 * b04 - a21 * b05 - a23 * b03) * invDet;
+  r[4] = (a12 * b08 - a10 * b11 - a13 * b07) * invDet;
+  r[5] = (a00 * b11 - a02 * b08 + a03 * b07) * invDet;
+  r[6] = (a32 * b02 - a30 * b05 - a33 * b01) * invDet;
+  r[7] = (a20 * b05 - a22 * b02 + a23 * b01) * invDet;
+  r[8] = (a10 * b10 - a11 * b08 + a13 * b06) * invDet;
+  r[9] = (a01 * b08 - a00 * b10 - a03 * b06) * invDet;
+  r[10] = (a30 * b04 - a31 * b02 + a33 * b00) * invDet;
+  r[11] = (a21 * b02 - a20 * b04 - a23 * b00) * invDet;
+  r[12] = (a11 * b07 - a10 * b09 - a12 * b06) * invDet;
+  r[13] = (a00 * b09 - a01 * b07 + a02 * b06) * invDet;
+  r[14] = (a31 * b01 - a30 * b03 - a32 * b00) * invDet;
+  r[15] = (a20 * b03 - a21 * b01 + a22 * b00) * invDet;
+  return r;
+}
+function transformPoint(m, v) {
+  const w = m[3] * v.x + m[7] * v.y + m[11] * v.z + m[15];
+  return {
+    x: (m[0] * v.x + m[4] * v.y + m[8] * v.z + m[12]) / w,
+    y: (m[1] * v.x + m[5] * v.y + m[9] * v.z + m[13]) / w,
+    z: (m[2] * v.x + m[6] * v.y + m[10] * v.z + m[14]) / w
+  };
+}
+function transformDirection(m, v) {
+  return {
+    x: m[0] * v.x + m[4] * v.y + m[8] * v.z,
+    y: m[1] * v.x + m[5] * v.y + m[9] * v.z,
+    z: m[2] * v.x + m[6] * v.y + m[10] * v.z
+  };
+}
+function transformPointRaw(m, v) {
+  return {
+    x: m[0] * v.x + m[4] * v.y + m[8] * v.z + m[12],
+    y: m[1] * v.x + m[5] * v.y + m[9] * v.z + m[13],
+    z: m[2] * v.x + m[6] * v.y + m[10] * v.z + m[14],
+    w: m[3] * v.x + m[7] * v.y + m[11] * v.z + m[15]
+  };
+}
+
+// src/camera.ts
+var DEFAULT_UP = { x: 0, y: 1, z: 0 };
+function createCamera(options) {
+  return {
+    position: options?.position ?? { x: 0, y: 1.7, z: 0 },
+    target: options?.target ?? { x: 0, y: 0.5, z: 100 },
+    up: options?.up ?? DEFAULT_UP,
+    fov: options?.fov ?? 60,
+    near: options?.near ?? 0.1,
+    far: options?.far ?? 1e4,
+    projection: options?.projection ?? "perspective",
+    orthoScale: options?.orthoScale
+  };
+}
+function updateCamera(camera, updates) {
+  return { ...camera, ...updates };
+}
+function viewProjectionMatrix(camera, viewport) {
+  const view = lookAt(camera.position, camera.target, camera.up);
+  const aspect = viewport.width / viewport.height;
+  let proj;
+  if (camera.projection === "orthographic") {
+    const scale2 = camera.orthoScale ?? 10;
+    const halfH = scale2 / 2;
+    const halfW = halfH * aspect;
+    proj = orthographicMatrix(-halfW, halfW, -halfH, halfH, camera.near, camera.far);
+  } else {
+    proj = perspectiveMatrix(camera.fov, aspect, camera.near, camera.far);
+  }
+  return multiply(proj, view);
+}
+
+// src/project.ts
+function project(point, camera, viewport) {
+  const vp = viewProjectionMatrix(camera, viewport);
+  return projectWithMatrix(point, vp, camera, viewport);
+}
+function projectWithMatrix(point, vpMatrix, camera, viewport) {
+  const clip = transformPointRaw(vpMatrix, point);
+  if (clip.w <= 0) {
+    return {
+      x: 0,
+      y: 0,
+      depth: -1,
+      scale: 0,
+      visible: false,
+      distance: distance(point, camera.position)
+    };
+  }
+  const ndcX = clip.x / clip.w;
+  const ndcY = clip.y / clip.w;
+  const ndcZ = clip.z / clip.w;
+  const screenX = viewport.x + (ndcX + 1) / 2 * viewport.width;
+  const screenY = viewport.y + (1 - ndcY) / 2 * viewport.height;
+  const depth = (ndcZ + 1) / 2;
+  const visible = ndcX >= -1 && ndcX <= 1 && ndcY >= -1 && ndcY <= 1 && ndcZ >= -1 && ndcZ <= 1;
+  const fovRad = camera.fov * Math.PI / 180;
+  const projScale = camera.projection === "perspective" ? viewport.height / 2 * (1 / Math.tan(fovRad / 2)) / clip.w : viewport.height / (camera.orthoScale ?? 10);
+  return {
+    x: screenX,
+    y: screenY,
+    depth,
+    scale: projScale,
+    visible,
+    distance: distance(point, camera.position)
+  };
+}
+function projectMany(points, camera, viewport) {
+  const vp = viewProjectionMatrix(camera, viewport);
+  return points.map((p) => projectWithMatrix(p, vp, camera, viewport));
+}
+function unproject(screenX, screenY, depth, camera, viewport) {
+  const vp = viewProjectionMatrix(camera, viewport);
+  const inv = invert(vp);
+  if (!inv) return null;
+  const ndcX = (screenX - viewport.x) / viewport.width * 2 - 1;
+  const ndcY = 1 - (screenY - viewport.y) / viewport.height * 2;
+  const ndcZ = depth * 2 - 1;
+  const clip = transformPointRaw(inv, { x: ndcX, y: ndcY, z: ndcZ });
+  if (Math.abs(clip.w) < 1e-12) return null;
+  return {
+    x: clip.x / clip.w,
+    y: clip.y / clip.w,
+    z: clip.z / clip.w
+  };
+}
+
+// src/spatial.ts
+function frustumContainsPoint(point, camera, viewport) {
+  const vp = viewProjectionMatrix(camera, viewport);
+  const clip = transformPointRaw(vp, point);
+  if (clip.w <= 0) return false;
+  const ndcX = clip.x / clip.w;
+  const ndcY = clip.y / clip.w;
+  const ndcZ = clip.z / clip.w;
+  return ndcX >= -1 && ndcX <= 1 && ndcY >= -1 && ndcY <= 1 && ndcZ >= -1 && ndcZ <= 1;
+}
+function frustumContainsBox(box, camera, viewport) {
+  const vp = viewProjectionMatrix(camera, viewport);
+  const corners = [
+    { x: box.min.x, y: box.min.y, z: box.min.z },
+    { x: box.max.x, y: box.min.y, z: box.min.z },
+    { x: box.min.x, y: box.max.y, z: box.min.z },
+    { x: box.max.x, y: box.max.y, z: box.min.z },
+    { x: box.min.x, y: box.min.y, z: box.max.z },
+    { x: box.max.x, y: box.min.y, z: box.max.z },
+    { x: box.min.x, y: box.max.y, z: box.max.z },
+    { x: box.max.x, y: box.max.y, z: box.max.z }
+  ];
+  let allInside = true;
+  let anyInside = false;
+  for (const corner of corners) {
+    const clip = transformPointRaw(vp, corner);
+    if (clip.w <= 0) {
+      allInside = false;
+      continue;
+    }
+    const ndcX = clip.x / clip.w;
+    const ndcY = clip.y / clip.w;
+    const ndcZ = clip.z / clip.w;
+    const inside = ndcX >= -1 && ndcX <= 1 && ndcY >= -1 && ndcY <= 1 && ndcZ >= -1 && ndcZ <= 1;
+    if (inside) {
+      anyInside = true;
+    } else {
+      allInside = false;
+    }
+  }
+  if (allInside) return "inside";
+  if (anyInside) return "intersect";
+  let minNdcX = Infinity, maxNdcX = -Infinity;
+  let minNdcY = Infinity, maxNdcY = -Infinity;
+  let behindCount = 0;
+  for (const corner of corners) {
+    const clip = transformPointRaw(vp, corner);
+    if (clip.w <= 0) {
+      behindCount++;
+      continue;
+    }
+    const ndcX = clip.x / clip.w;
+    const ndcY = clip.y / clip.w;
+    minNdcX = Math.min(minNdcX, ndcX);
+    maxNdcX = Math.max(maxNdcX, ndcX);
+    minNdcY = Math.min(minNdcY, ndcY);
+    maxNdcY = Math.max(maxNdcY, ndcY);
+  }
+  if (behindCount > 0 && behindCount < 8) return "intersect";
+  if (behindCount === 8) return "outside";
+  if (maxNdcX < -1 || minNdcX > 1 || maxNdcY < -1 || minNdcY > 1) return "outside";
+  return "intersect";
+}
+function isBackFace(faceNormal, faceCenter, camera) {
+  const toCamera = sub(camera.position, faceCenter);
+  return dot(faceNormal, toCamera) <= 0;
+}
+function scaleAtDepth(worldPoint, camera, viewport) {
+  const vp = viewProjectionMatrix(camera, viewport);
+  const clip = transformPointRaw(vp, worldPoint);
+  if (clip.w <= 0) return 0;
+  if (camera.projection === "perspective") {
+    const fovRad = camera.fov * Math.PI / 180;
+    return viewport.height / 2 * (1 / Math.tan(fovRad / 2)) / clip.w;
+  }
+  return viewport.height / (camera.orthoScale ?? 10);
+}
+function normalizedDepth(point, camera, viewport) {
+  const vp = viewProjectionMatrix(camera, viewport);
+  const clip = transformPointRaw(vp, point);
+  if (clip.w <= 0) return -1;
+  const ndcZ = clip.z / clip.w;
+  return (ndcZ + 1) / 2;
+}
+function distanceTo(point, camera) {
+  return distance(point, camera.position);
+}
+function horizonScreenY(camera, viewport) {
+  const lookDir = normalize(sub(camera.target, camera.position));
+  const horizDir = normalize({ x: lookDir.x, y: 0, z: lookDir.z });
+  if (horizDir.x === 0 && horizDir.z === 0) {
+    return viewport.y + viewport.height / 2;
+  }
+  const farPoint = {
+    x: camera.position.x + horizDir.x * camera.far * 0.99,
+    y: camera.position.y,
+    z: camera.position.z + horizDir.z * camera.far * 0.99
+  };
+  const vp = viewProjectionMatrix(camera, viewport);
+  const clip = transformPointRaw(vp, farPoint);
+  if (clip.w <= 0) return viewport.y + viewport.height / 2;
+  const ndcY = clip.y / clip.w;
+  return viewport.y + (1 - ndcY) / 2 * viewport.height;
+}
+function deriveVanishingPoints(camera, viewport) {
+  const vp = viewProjectionMatrix(camera, viewport);
+  const far = camera.far * 0.99;
+  const projectDir = (dir) => {
+    const point = {
+      x: camera.position.x + dir.x * far,
+      y: camera.position.y + dir.y * far,
+      z: camera.position.z + dir.z * far
+    };
+    const clip = transformPointRaw(vp, point);
+    if (clip.w <= 0) return void 0;
+    const ndcX = clip.x / clip.w;
+    const ndcY = clip.y / clip.w;
+    return {
+      x: viewport.x + (ndcX + 1) / 2 * viewport.width,
+      y: viewport.y + (1 - ndcY) / 2 * viewport.height
+    };
+  };
+  return {
+    left: projectDir({ x: 1, y: 0, z: 0 }),
+    right: projectDir({ x: -1, y: 0, z: 0 }),
+    vertical: projectDir({ x: 0, y: 1, z: 0 })
+  };
+}
+
+// src/sorting.ts
+function depthSort(items, positionFn, camera) {
+  const camPos = camera.position;
+  return [...items].sort((a, b) => {
+    const da = distanceSq(positionFn(a), camPos);
+    const db = distanceSq(positionFn(b), camPos);
+    return db - da;
+  });
+}
+function depthSortIndices(positions, camera) {
+  const camPos = camera.position;
+  const indices = positions.map((_, i) => i);
+  indices.sort((a, b) => {
+    const pa = positions[a];
+    const pb = positions[b];
+    return distanceSq(pb, camPos) - distanceSq(pa, camPos);
+  });
+  return indices;
+}
+
+// src/presets.ts
+function landscapeCamera(options) {
+  const eyeHeight = options?.eyeHeight ?? 1.7;
+  const lookDistance = options?.lookDistance ?? 100;
+  const lookElevation = options?.lookElevation ?? 0.3;
+  return createCamera({
+    position: { x: 0, y: eyeHeight, z: 0 },
+    target: { x: 0, y: lookElevation, z: lookDistance },
+    fov: options?.fov ?? 60
+  });
+}
+function aerialCamera(options) {
+  const altitude = options?.altitude ?? 200;
+  const angleDeg = options?.lookAngle ?? 45;
+  const angleRad = angleDeg * Math.PI / 180;
+  const lookDistance = altitude / Math.tan(angleRad);
+  return createCamera({
+    position: { x: 0, y: altitude, z: 0 },
+    target: { x: 0, y: 0, z: lookDistance },
+    fov: options?.fov ?? 50
+  });
+}
+function streetCamera(options) {
+  const eyeHeight = options?.eyeHeight ?? 1.7;
+  const angleDeg = options?.lookDirection ?? 0;
+  const angleRad = angleDeg * Math.PI / 180;
+  const lookDist = 50;
+  return createCamera({
+    position: { x: 0, y: eyeHeight, z: 0 },
+    target: {
+      x: Math.sin(angleRad) * lookDist,
+      y: eyeHeight * 0.8,
+      z: Math.cos(angleRad) * lookDist
+    },
+    fov: options?.fov ?? 55
+  });
+}
+function wormEyeCamera(options) {
+  const groundLevel = options?.groundLevel ?? 0.3;
+  const tiltDeg = options?.tiltAngle ?? 60;
+  const tiltRad = tiltDeg * Math.PI / 180;
+  const lookDist = 30;
+  return createCamera({
+    position: { x: 0, y: groundLevel, z: 0 },
+    target: {
+      x: 0,
+      y: groundLevel + Math.sin(tiltRad) * lookDist,
+      z: Math.cos(tiltRad) * lookDist
+    },
+    fov: options?.fov ?? 75
+  });
+}
+function isometricCamera(options) {
+  const angleDeg = options?.angle ?? 30;
+  const angleRad = angleDeg * Math.PI / 180;
+  const dist = options?.distance ?? 200;
+  return createCamera({
+    position: {
+      x: -Math.cos(angleRad) * dist,
+      y: Math.sin(angleRad) * dist + dist * 0.5,
+      z: -Math.cos(angleRad) * dist
+    },
+    target: { x: 0, y: 0, z: 0 },
+    projection: "orthographic",
+    orthoScale: options?.orthoScale ?? 100
+  });
+}
+
+// src/interpolation.ts
+function lerpCamera(a, b, t) {
+  return {
+    position: lerp(a.position, b.position, t),
+    target: lerp(a.target, b.target, t),
+    up: normalize(lerp(a.up, b.up, t)),
+    fov: a.fov + (b.fov - a.fov) * t,
+    near: a.near + (b.near - a.near) * t,
+    far: a.far + (b.far - a.far) * t,
+    projection: t < 0.5 ? a.projection : b.projection,
+    orthoScale: a.orthoScale != null && b.orthoScale != null ? a.orthoScale + (b.orthoScale - a.orthoScale) * t : t < 0.5 ? a.orthoScale : b.orthoScale
+  };
+}
+function orbitCamera(camera, angleX, angleY, center) {
+  const pivot = center ?? camera.target;
+  const offset = sub(camera.position, pivot);
+  const cosX = Math.cos(angleX);
+  const sinX = Math.sin(angleX);
+  let rotated = {
+    x: offset.x * cosX + offset.z * sinX,
+    y: offset.y,
+    z: -offset.x * sinX + offset.z * cosX
+  };
+  const forward = normalize(sub(pivot, add(pivot, rotated)));
+  const right = normalize(cross(camera.up, forward));
+  const cosY = Math.cos(angleY);
+  const sinY = Math.sin(angleY);
+  const dotRR = right.x * rotated.x + right.y * rotated.y + right.z * rotated.z;
+  const crossRR = cross(right, rotated);
+  rotated = {
+    x: rotated.x * cosY + crossRR.x * sinY + right.x * dotRR * (1 - cosY),
+    y: rotated.y * cosY + crossRR.y * sinY + right.y * dotRR * (1 - cosY),
+    z: rotated.z * cosY + crossRR.z * sinY + right.z * dotRR * (1 - cosY)
+  };
+  return {
+    ...camera,
+    position: add(pivot, rotated)
+  };
+}
+function dollyCamera(camera, distance2) {
+  const dir = normalize(sub(camera.target, camera.position));
+  const move = scale(dir, distance2);
+  return {
+    ...camera,
+    position: add(camera.position, move),
+    target: add(camera.target, move)
+  };
+}
+function panCamera(camera, dx, dy) {
+  const forward = normalize(sub(camera.target, camera.position));
+  const right = normalize(cross(camera.up, forward));
+  const up = cross(forward, right);
+  const offset = add(scale(right, dx), scale(up, dy));
+  return {
+    ...camera,
+    position: add(camera.position, offset),
+    target: add(camera.target, offset)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  add,
+  aerialCamera,
+  createCamera,
+  cross,
+  depthSort,
+  depthSortIndices,
+  deriveVanishingPoints,
+  distance,
+  distanceSq,
+  distanceTo,
+  dollyCamera,
+  dot,
+  frustumContainsBox,
+  frustumContainsPoint,
+  horizonScreenY,
+  identity,
+  invert,
+  isBackFace,
+  isometricCamera,
+  landscapeCamera,
+  length,
+  lengthSq,
+  lerpCamera,
+  lerpVec3,
+  lookAt,
+  multiply,
+  negate,
+  normalize,
+  normalizedDepth,
+  orbitCamera,
+  orthographicMatrix,
+  panCamera,
+  perspectiveMatrix,
+  project,
+  projectMany,
+  projectWithMatrix,
+  scaleAtDepth,
+  scaleVec3,
+  streetCamera,
+  sub,
+  transformDirection,
+  transformPoint,
+  transformPointRaw,
+  unproject,
+  updateCamera,
+  vec3,
+  viewProjectionMatrix,
+  wormEyeCamera
+});
+//# sourceMappingURL=index.cjs.map