samcan 0.0.2 → 0.1.0

package/dist/shared/chunk-hewznwbd.js

@@ -0,0 +1,305 @@
+// camera/camera.ts
+function create_camera(x = 0, y = 0, zoom = 1, rotation = 0) {
+  return [x, y, zoom, rotation];
+}
+function clone_camera(c) {
+  return [c[0], c[1], c[2], c[3]];
+}
+function copy_camera(c, out) {
+  out[0] = c[0];
+  out[1] = c[1];
+  out[2] = c[2];
+  out[3] = c[3];
+  return out;
+}
+function set_camera(x, y, zoom, rotation, out) {
+  out[0] = x;
+  out[1] = y;
+  out[2] = zoom;
+  out[3] = rotation;
+  return out;
+}
+function x_of_camera(c) {
+  return c[0];
+}
+function y_of_camera(c) {
+  return c[1];
+}
+function zoom_of_camera(c) {
+  return c[2];
+}
+function rotation_of_camera(c) {
+  return c[3];
+}
+function position_of_camera(c, out) {
+  out[0] = c[0];
+  out[1] = c[1];
+  return out;
+}
+function pan_camera(c, dx, dy, out) {
+  out[0] = c[0] + dx;
+  out[1] = c[1] + dy;
+  out[2] = c[2];
+  out[3] = c[3];
+  return out;
+}
+function zoom_camera(c, factor, out) {
+  out[0] = c[0];
+  out[1] = c[1];
+  out[2] = c[2] * factor;
+  out[3] = c[3];
+  return out;
+}
+function zoom_at_camera(c, factor, anchor, out) {
+  const world_dx = anchor.world_x - c[0];
+  const world_dy = anchor.world_y - c[1];
+  const new_zoom = c[2] * factor;
+  const new_world_x = anchor.world_x - world_dx / factor;
+  const new_world_y = anchor.world_y - world_dy / factor;
+  out[0] = new_world_x;
+  out[1] = new_world_y;
+  out[2] = new_zoom;
+  out[3] = c[3];
+  return out;
+}
+function rotate_camera(c, angle, out) {
+  out[0] = c[0];
+  out[1] = c[1];
+  out[2] = c[2];
+  out[3] = c[3] + angle;
+  return out;
+}
+function clamp_camera(c, limits, out) {
+  const clamped_zoom = Math.max(limits.min_zoom, Math.min(limits.max_zoom, c[2]));
+  const clamped_x = Math.max(limits.min_x, Math.min(limits.max_x, c[0]));
+  const clamped_y = Math.max(limits.min_y, Math.min(limits.max_y, c[1]));
+  out[0] = clamped_x;
+  out[1] = clamped_y;
+  out[2] = clamped_zoom;
+  out[3] = c[3];
+  return out;
+}
+function lerp_camera(a, b, t, out) {
+  const clamped_t = Math.max(0, Math.min(1, t));
+  out[0] = a[0] + clamped_t * (b[0] - a[0]);
+  out[1] = a[1] + clamped_t * (b[1] - a[1]);
+  out[2] = a[2] + clamped_t * (b[2] - a[2]);
+  let rotation_diff = b[3] - a[3];
+  while (rotation_diff > Math.PI) {
+    rotation_diff = rotation_diff - 2 * Math.PI;
+  }
+  while (rotation_diff < -Math.PI) {
+    rotation_diff = rotation_diff + 2 * Math.PI;
+  }
+  out[3] = a[3] + clamped_t * rotation_diff;
+  return out;
+}
+function smooth_damp_camera(current, target, velocity, smooth_time, delta_time, out) {
+  const omega = 2 / Math.max(0.0001, smooth_time);
+  const x = omega * delta_time;
+  const exp = 1 / (1 + x + 0.48 * x * x + 0.235 * x * x * x);
+  const delta_x = current[0] - target[0];
+  const delta_y = current[1] - target[1];
+  const delta_zoom = current[2] - target[2];
+  let rotation_diff = target[3] - current[3];
+  while (rotation_diff > Math.PI) {
+    rotation_diff = rotation_diff - 2 * Math.PI;
+  }
+  while (rotation_diff < -Math.PI) {
+    rotation_diff = rotation_diff + 2 * Math.PI;
+  }
+  const delta_rotation = -rotation_diff;
+  const temp_x = (velocity[0] + omega * delta_x) * delta_time;
+  const temp_y = (velocity[1] + omega * delta_y) * delta_time;
+  const temp_zoom = (velocity[2] + omega * delta_zoom) * delta_time;
+  const temp_rotation = (velocity[3] + omega * delta_rotation) * delta_time;
+  const new_velocity_x = (velocity[0] - omega * temp_x) * exp;
+  const new_velocity_y = (velocity[1] - omega * temp_y) * exp;
+  const new_velocity_zoom = (velocity[2] - omega * temp_zoom) * exp;
+  const new_velocity_rotation = (velocity[3] - omega * temp_rotation) * exp;
+  velocity[0] = new_velocity_x;
+  velocity[1] = new_velocity_y;
+  velocity[2] = new_velocity_zoom;
+  velocity[3] = new_velocity_rotation;
+  const result_x = target[0] + (delta_x + temp_x) * exp;
+  const result_y = target[1] + (delta_y + temp_y) * exp;
+  const result_zoom = target[2] + (delta_zoom + temp_zoom) * exp;
+  const result_rotation = target[3] + (delta_rotation + temp_rotation) * exp;
+  out[0] = result_x;
+  out[1] = result_y;
+  out[2] = result_zoom;
+  out[3] = result_rotation;
+  return out;
+}
+function equals_camera(c1, c2, epsilon = 0.0001) {
+  return Math.abs(c1[0] - c2[0]) < epsilon && Math.abs(c1[1] - c2[1]) < epsilon && Math.abs(c1[2] - c2[2]) < epsilon && Math.abs(c1[3] - c2[3]) < epsilon;
+}
+function is_identity_camera(c) {
+  return c[0] === 0 && c[1] === 0 && c[2] === 1 && c[3] === 0;
+}
+
+// camera/projection.ts
+function world_to_screen_camera(c, v, world_pos, out) {
+  const dx = world_pos[0] - c[0];
+  const dy = world_pos[1] - c[1];
+  const cos_r = Math.cos(c[3]);
+  const sin_r = Math.sin(c[3]);
+  const rotated_x = dx * cos_r - dy * sin_r;
+  const rotated_y = dx * sin_r + dy * cos_r;
+  const screen_x = rotated_x * c[2] + v[0] / 2;
+  const screen_y = rotated_y * c[2] + v[1] / 2;
+  out[0] = screen_x;
+  out[1] = screen_y;
+  return out;
+}
+function screen_to_world_camera(c, v, screen_pos, out) {
+  if (c[2] <= 0) {
+    out[0] = c[0];
+    out[1] = c[1];
+    return out;
+  }
+  const dx = screen_pos[0] - v[0] / 2;
+  const dy = screen_pos[1] - v[1] / 2;
+  const cos_r = Math.cos(-c[3]);
+  const sin_r = Math.sin(-c[3]);
+  const scaled_x = dx / c[2];
+  const scaled_y = dy / c[2];
+  const rotated_x = scaled_x * cos_r - scaled_y * sin_r;
+  const rotated_y = scaled_x * sin_r + scaled_y * cos_r;
+  out[0] = rotated_x + c[0];
+  out[1] = rotated_y + c[1];
+  return out;
+}
+function view_transform_camera(c, out) {
+  const cos_r = Math.cos(c[3]);
+  const sin_r = Math.sin(c[3]);
+  out[0] = cos_r * c[2];
+  out[1] = sin_r * c[2];
+  out[2] = -sin_r * c[2];
+  out[3] = cos_r * c[2];
+  out[4] = -c[0] * cos_r * c[2] + c[1] * sin_r * c[2];
+  out[5] = -c[0] * sin_r * c[2] - c[1] * cos_r * c[2];
+  return out;
+}
+function inverse_view_transform_camera(c, out) {
+  const cos_r = Math.cos(c[3]);
+  const sin_r = Math.sin(c[3]);
+  const safe_zoom = c[2] <= 0 ? 0.0001 : c[2];
+  const inverse_zoom = 1 / safe_zoom;
+  out[0] = cos_r * inverse_zoom;
+  out[1] = -sin_r * inverse_zoom;
+  out[2] = sin_r * inverse_zoom;
+  out[3] = cos_r * inverse_zoom;
+  out[4] = c[0];
+  out[5] = c[1];
+  return out;
+}
+function camera_frustum(c, v, out) {
+  if (c[2] <= 0) {
+    out[0] = c[0];
+    out[1] = c[0];
+    out[2] = c[1];
+    out[3] = c[1];
+    out[4] = 0;
+    out[5] = Number.MAX_VALUE;
+    return out;
+  }
+  const half_width = v[0] / (2 * c[2]);
+  const half_height = v[1] / (2 * c[2]);
+  if (c[3] === 0) {
+    out[0] = c[0] - half_width;
+    out[1] = c[0] + half_width;
+    out[2] = c[1] + half_height;
+    out[3] = c[1] - half_height;
+    out[4] = 0;
+    out[5] = Number.MAX_VALUE;
+    return out;
+  }
+  const cos_r = Math.abs(Math.cos(c[3]));
+  const sin_r = Math.abs(Math.sin(c[3]));
+  const x_extent = half_width * cos_r + half_height * sin_r;
+  const y_extent = half_width * sin_r + half_height * cos_r;
+  out[0] = c[0] - x_extent;
+  out[1] = c[0] + x_extent;
+  out[2] = c[1] + y_extent;
+  out[3] = c[1] - y_extent;
+  out[4] = 0;
+  out[5] = Number.MAX_VALUE;
+  return out;
+}
+function fit_camera_to_bounds(bounds, v, margin = 0.1, out) {
+  const bounds_width = bounds[2];
+  const bounds_height = bounds[3];
+  if (bounds_width <= 0 || bounds_height <= 0) {
+    out[0] = bounds[0];
+    out[1] = bounds[1];
+    out[2] = 1;
+    out[3] = 0;
+    return out;
+  }
+  const viewport_width = v[0] * (1 - margin * 2);
+  const viewport_height = v[1] * (1 - margin * 2);
+  if (viewport_width <= 0 || viewport_height <= 0) {
+    out[0] = bounds[0] + bounds_width / 2;
+    out[1] = bounds[1] + bounds_height / 2;
+    out[2] = 1;
+    out[3] = 0;
+    return out;
+  }
+  const zoom_x = viewport_width / bounds_width;
+  const zoom_y = viewport_height / bounds_height;
+  const zoom = Math.min(zoom_x, zoom_y);
+  const center_x = bounds[0] + bounds_width / 2;
+  const center_y = bounds[1] + bounds_height / 2;
+  out[0] = center_x;
+  out[1] = center_y;
+  out[2] = zoom;
+  out[3] = 0;
+  return out;
+}
+function contains_point_camera_frustum(c, v, world_x, world_y) {
+  const dx = world_x - c[0];
+  const dy = world_y - c[1];
+  const cos_r = Math.cos(-c[3]);
+  const sin_r = Math.sin(-c[3]);
+  const rotated_x = dx * cos_r - dy * sin_r;
+  const rotated_y = dx * sin_r + dy * cos_r;
+  const scaled_x = rotated_x * c[2];
+  const scaled_y = rotated_y * c[2];
+  const half_width = v[0] / 2;
+  const half_height = v[1] / 2;
+  return scaled_x >= -half_width && scaled_x <= half_width && scaled_y >= -half_height && scaled_y <= half_height;
+}
+function width_of_camera_world(c, v) {
+  const safe_zoom = c[2] <= 0 ? 0.0001 : c[2];
+  return v[0] / safe_zoom;
+}
+function height_of_camera_world(c, v) {
+  const safe_zoom = c[2] <= 0 ? 0.0001 : c[2];
+  return v[1] / safe_zoom;
+}
+function pixel_size_of_camera(c) {
+  const safe_zoom = c[2] <= 0 ? 0.0001 : c[2];
+  return 1 / safe_zoom;
+}
+function pixel_ratio_of_viewport(v) {
+  return v[2];
+}
+function device_width_of_viewport(v) {
+  return v[0] * v[2];
+}
+function device_height_of_viewport(v) {
+  return v[1] * v[2];
+}
+function world_to_device_camera(c, v, world_pos, out) {
+  world_to_screen_camera(c, v, world_pos, out);
+  out[0] = out[0] * v[2];
+  out[1] = out[1] * v[2];
+  return out;
+}
+function device_to_world_camera(c, v, device_pos, out) {
+  const screen_pos = [device_pos[0] / v[2], device_pos[1] / v[2]];
+  return screen_to_world_camera(c, v, screen_pos, out);
+}
+
+export { create_camera, clone_camera, copy_camera, set_camera, x_of_camera, y_of_camera, zoom_of_camera, rotation_of_camera, position_of_camera, pan_camera, zoom_camera, zoom_at_camera, rotate_camera, clamp_camera, lerp_camera, smooth_damp_camera, equals_camera, is_identity_camera, world_to_screen_camera, screen_to_world_camera, view_transform_camera, inverse_view_transform_camera, camera_frustum, fit_camera_to_bounds, contains_point_camera_frustum, width_of_camera_world, height_of_camera_world, pixel_size_of_camera, pixel_ratio_of_viewport, device_width_of_viewport, device_height_of_viewport, world_to_device_camera, device_to_world_camera };