@bloomengine/engine 0.3.1

package/src/scene/index.ts

@@ -0,0 +1,570 @@
+/**
+ * Bloom Scene Graph — Retained-mode 3D scene management.
+ *
+ * Unlike immediate-mode drawing (drawCube, drawModel), the scene graph holds
+ * persistent meshes that survive across frames. Systems update geometry and
+ * transforms; the renderer draws all visible nodes each frame automatically.
+ *
+ * Designed for architecture/CAD editors compiled natively via Perry.
+ */
+
+// ============================================================
+// FFI declarations (match package.json nativeLibrary.functions)
+// ============================================================
+
+declare function bloom_scene_create_node(): number;
+declare function bloom_scene_destroy_node(handle: number): void;
+declare function bloom_scene_set_visible(handle: number, visible: number): void;
+declare function bloom_scene_set_cast_shadow(handle: number, cast: number): void;
+declare function bloom_scene_set_receive_shadow(handle: number, receive: number): void;
+declare function bloom_scene_set_parent(handle: number, parent: number): void;
+declare function bloom_scene_set_transform(handle: number, matrix: number): void;
+declare function bloom_scene_update_geometry(
+  handle: number,
+  vertices: number,
+  vertexCount: number,
+  indices: number,
+  indexCount: number,
+): void;
+declare function bloom_scene_set_material_color(handle: number, r: number, g: number, b: number, a: number): void;
+declare function bloom_scene_set_material_pbr(handle: number, roughness: number, metalness: number): void;
+declare function bloom_scene_set_material_texture(handle: number, textureIdx: number): void;
+declare function bloom_scene_node_count(): number;
+
+// Frame callbacks
+declare function bloom_register_frame_callback(priority: number, callback: number): number;
+declare function bloom_unregister_frame_callback(id: number): void;
+
+// Multiple lights
+declare function bloom_add_directional_light(
+  dx: number, dy: number, dz: number,
+  r: number, g: number, b: number,
+  intensity: number,
+): void;
+declare function bloom_add_point_light(
+  x: number, y: number, z: number, range: number,
+  r: number, g: number, b: number,
+  intensity: number,
+): void;
+
+// Shadows
+declare function bloom_enable_shadows(): void;
+declare function bloom_disable_shadows(): void;
+declare function bloom_dump_shadow_map(path: number): void;
+
+// Post-processing
+declare function bloom_enable_postfx(): void;
+declare function bloom_disable_postfx(): void;
+declare function bloom_postfx_set_selected(handle: number): void;
+declare function bloom_postfx_set_hovered(handle: number): void;
+declare function bloom_postfx_set_outline_color(r: number, g: number, b: number, a: number): void;
+declare function bloom_postfx_set_outline_thickness(thickness: number): void;
+
+// Model attachment
+declare function bloom_scene_attach_model(nodeHandle: number, modelHandle: number, meshIndex: number): void;
+
+// 3D→2D Projection
+declare function bloom_project_to_screen(wx: number, wy: number, wz: number): number;
+declare function bloom_project_screen_y(): number;
+
+// Scene picking
+declare function bloom_scene_pick(screenX: number, screenY: number): number;
+declare function bloom_pick_hit_handle(): number;
+declare function bloom_pick_hit_distance(): number;
+declare function bloom_pick_hit_x(): number;
+declare function bloom_pick_hit_y(): number;
+declare function bloom_pick_hit_z(): number;
+declare function bloom_pick_hit_normal_x(): number;
+declare function bloom_pick_hit_normal_y(): number;
+declare function bloom_pick_hit_normal_z(): number;
+
+// Geometry generation
+// Q6: multi-hit picking
+declare function bloom_scene_pick_all(screenX: number, screenY: number, maxResults: number): number;
+declare function bloom_pick_all_handle(index: number): number;
+declare function bloom_pick_all_distance(index: number): number;
+
+// Q8: water material
+declare function bloom_scene_set_material_water(handle: number, waveAmp: number, waveSpeed: number, r: number, g: number, b: number, a: number): void;
+
+// Q4: transform read-back
+declare function bloom_scene_get_transform(handle: number, index: number): number;
+// Q5: node bounds
+declare function bloom_scene_get_bounds_min_x(handle: number): number;
+declare function bloom_scene_get_bounds_min_y(handle: number): number;
+declare function bloom_scene_get_bounds_min_z(handle: number): number;
+declare function bloom_scene_get_bounds_max_x(handle: number): number;
+declare function bloom_scene_get_bounds_max_y(handle: number): number;
+declare function bloom_scene_get_bounds_max_z(handle: number): number;
+// Q7: user data
+declare function bloom_scene_set_user_data(handle: number, data: number): void;
+declare function bloom_scene_get_user_data(handle: number): number;
+
+declare function bloom_scene_extrude_polygon(
+  handle: number,
+  polygon: number,
+  pointCount: number,
+  depth: number,
+): void;
+declare function bloom_scene_subtract_box(
+  handle: number,
+  minX: number, minY: number, minZ: number,
+  maxX: number, maxY: number, maxZ: number,
+): void;
+
+// ============================================================
+// Types
+// ============================================================
+
+export type SceneNodeHandle = number;
+
+export interface PbrMaterial {
+  color?: [number, number, number];
+  roughness?: number;
+  metalness?: number;
+  opacity?: number;
+  textureIdx?: number;
+}
+
+// ============================================================
+// Public API
+// ============================================================
+
+/**
+ * Create a new empty scene node. Returns a handle.
+ * The node is visible by default but has no geometry.
+ */
+export function createSceneNode(): SceneNodeHandle {
+  return bloom_scene_create_node();
+}
+
+/**
+ * Destroy a scene node, freeing its GPU resources.
+ */
+export function destroySceneNode(handle: SceneNodeHandle): void {
+  bloom_scene_destroy_node(handle);
+}
+
+/**
+ * Set visibility of a scene node.
+ */
+export function setSceneNodeVisible(handle: SceneNodeHandle, visible: boolean): void {
+  bloom_scene_set_visible(handle, visible ? 1 : 0);
+}
+
+/**
+ * Set whether this node casts shadows.
+ */
+export function setSceneNodeCastShadow(handle: SceneNodeHandle, cast: boolean): void {
+  bloom_scene_set_cast_shadow(handle, cast ? 1 : 0);
+}
+
+/**
+ * Set whether this node receives shadows.
+ */
+export function setSceneNodeReceiveShadow(handle: SceneNodeHandle, receive: boolean): void {
+  bloom_scene_set_receive_shadow(handle, receive ? 1 : 0);
+}
+
+/**
+ * Set the parent of a scene node. Pass 0 for no parent (root node).
+ */
+export function setSceneNodeParent(handle: SceneNodeHandle, parent: SceneNodeHandle): void {
+  bloom_scene_set_parent(handle, parent);
+}
+
+/**
+ * Set the 4x4 transform matrix for a scene node.
+ * Matrix is in column-major order (same as Three.js/glm).
+ */
+export function setSceneNodeTransform(handle: SceneNodeHandle, matrix: number[]): void {
+  bloom_scene_set_transform(handle, matrix as any);
+}
+
+/**
+ * Update the geometry of a scene node.
+ *
+ * @param vertices — Flat array of vertex data. Each vertex has 12 floats:
+ *   [x, y, z, nx, ny, nz, r, g, b, a, u, v]
+ * @param indices — Flat array of triangle indices (3 per triangle).
+ */
+export function updateSceneNodeGeometry(
+  handle: SceneNodeHandle,
+  vertices: number[],
+  indices: number[],
+): void {
+  bloom_scene_update_geometry(
+    handle,
+    vertices as any,
+    vertices.length / 12,
+    indices as any,
+    indices.length,
+  );
+}
+
+/**
+ * Set the material color and opacity of a scene node.
+ * Color components are 0-1 (not 0-255).
+ */
+export function setSceneNodeColor(handle: SceneNodeHandle, r: number, g: number, b: number, a: number = 1): void {
+  bloom_scene_set_material_color(handle, r, g, b, a);
+}
+
+/**
+ * Set PBR material properties (roughness and metalness).
+ */
+export function setSceneNodePbr(handle: SceneNodeHandle, roughness: number, metalness: number): void {
+  bloom_scene_set_material_pbr(handle, roughness, metalness);
+}
+
+/**
+ * Set the texture for a scene node's material.
+ * Pass 0 for the default white texture.
+ */
+export function setSceneNodeTexture(handle: SceneNodeHandle, textureIdx: number): void {
+  bloom_scene_set_material_texture(handle, textureIdx);
+}
+
+/**
+ * Get the number of live scene nodes.
+ */
+export function getSceneNodeCount(): number {
+  return bloom_scene_node_count();
+}
+
+// ============================================================
+// Frame Callbacks (replaces R3F's useFrame)
+// ============================================================
+
+/**
+ * Register a callback that runs every frame, ordered by priority.
+ * Lower priority numbers run first (matching R3F convention:
+ * SlabSystem=1, ItemSystem=2, DoorSystem=3, WallSystem=4, RoofSystem=5).
+ *
+ * Returns an ID that can be used to unregister the callback.
+ */
+export function registerFrameCallback(priority: number, callback: (deltaTime: number) => void): number {
+  return bloom_register_frame_callback(priority, callback as any);
+}
+
+/**
+ * Unregister a frame callback by ID.
+ */
+export function unregisterFrameCallback(id: number): void {
+  bloom_unregister_frame_callback(id);
+}
+
+// ============================================================
+// Multiple Lights
+// ============================================================
+
+/**
+ * Add a directional light. Color is 0-1 range. Up to 4 additional directional lights.
+ * Called each frame (lights are cleared at frame start).
+ */
+export function addDirectionalLight(
+  dx: number, dy: number, dz: number,
+  r: number, g: number, b: number,
+  intensity: number,
+): void {
+  bloom_add_directional_light(dx, dy, dz, r, g, b, intensity);
+}
+
+/**
+ * Add a point light. Color is 0-1 range. Up to 16 point lights.
+ * Called each frame (lights are cleared at frame start).
+ */
+// ============================================================
+// Shadow Mapping
+// ============================================================
+
+/**
+ * Enable shadow mapping (single directional light).
+ * Shadows are rendered from the primary directional light's perspective.
+ */
+export function enableShadows(): void {
+  bloom_enable_shadows();
+}
+
+/**
+ * Disable shadow mapping.
+ */
+export function disableShadows(): void {
+  bloom_disable_shadows();
+}
+
+/**
+ * Dump the shadow map depth texture to a grayscale PNG for debugging.
+ */
+export function dumpShadowMap(path: string): void {
+  bloom_dump_shadow_map(path as any);
+}
+
+// ============================================================
+// Post-Processing (Outlines, SSAO)
+// ============================================================
+
+/**
+ * Enable the post-processing pipeline (outlines, SSAO).
+ * Must be called after initWindow.
+ */
+export function enablePostFx(): void {
+  bloom_enable_postfx();
+}
+
+/**
+ * Disable post-processing (render directly to screen).
+ */
+export function disablePostFx(): void {
+  bloom_disable_postfx();
+}
+
+/**
+ * Set the selected scene node for outline rendering.
+ * Pass 0 to clear selection. Matching Pascal Editor's outliner.selectedObjects.
+ */
+export function setPostFxSelected(handle: SceneNodeHandle): void {
+  bloom_postfx_set_selected(handle);
+}
+
+/**
+ * Set the hovered scene node for outline rendering.
+ * Pass 0 to clear hover.
+ */
+export function setPostFxHovered(handle: SceneNodeHandle): void {
+  bloom_postfx_set_hovered(handle);
+}
+
+/**
+ * Set the outline color for selected objects (0-1 range).
+ */
+export function setOutlineColor(r: number, g: number, b: number, a: number = 1): void {
+  bloom_postfx_set_outline_color(r, g, b, a);
+}
+
+/**
+ * Set the outline thickness in pixels.
+ */
+export function setOutlineThickness(thickness: number): void {
+  bloom_postfx_set_outline_thickness(thickness);
+}
+
+// ============================================================
+// Model Attachment (GLTF → Scene Node)
+// ============================================================
+
+/**
+ * Attach a loaded GLTF model's mesh to a scene node.
+ * Copies vertex/index data from the model into the scene node's geometry.
+ * This is the native equivalent of R3F's useGLTF + Clone.
+ *
+ * @param nodeHandle — scene node to receive the geometry
+ * @param modelHandle — loaded model handle (from loadModel())
+ * @param meshIndex — which mesh in the model (0 for single-mesh models)
+ */
+export function attachModelToNode(
+  nodeHandle: SceneNodeHandle,
+  modelHandle: number,
+  meshIndex: number = 0,
+): void {
+  bloom_scene_attach_model(nodeHandle, modelHandle, meshIndex);
+}
+
+// ============================================================
+// 3D → 2D Projection (for UI overlays in 3D space)
+// ============================================================
+
+/**
+ * Project a world-space 3D point to screen coordinates.
+ * Returns { x, y, visible }. If the point is behind the camera, visible is false.
+ *
+ * This is the native equivalent of R3F's drei Html component positioning.
+ * Used for zone labels, dimension references, interactive controls.
+ */
+export function projectToScreen(
+  worldX: number, worldY: number, worldZ: number,
+): { x: number; y: number; visible: boolean } {
+  const sx = bloom_project_to_screen(worldX, worldY, worldZ);
+  const sy = bloom_project_screen_y();
+  return {
+    x: sx,
+    y: sy,
+    visible: sx > -9000,
+  };
+}
+
+// ============================================================
+// Scene Picking (raycasting from screen)
+// ============================================================
+
+export interface PickHit {
+  hit: boolean;
+  handle: SceneNodeHandle;
+  distance: number;
+  point: { x: number; y: number; z: number };
+  normal: { x: number; y: number; z: number };
+}
+
+/**
+ * Raycast from screen coordinates against all visible scene nodes.
+ * Returns the closest hit with world-space point and normal.
+ *
+ * Must be called after beginMode3D() so the camera matrices are set.
+ */
+export function pickScene(screenX: number, screenY: number): PickHit {
+  const hit = bloom_scene_pick(screenX, screenY) !== 0;
+  if (!hit) {
+    return {
+      hit: false,
+      handle: 0,
+      distance: 0,
+      point: { x: 0, y: 0, z: 0 },
+      normal: { x: 0, y: 0, z: 0 },
+    };
+  }
+  return {
+    hit: true,
+    handle: bloom_pick_hit_handle(),
+    distance: bloom_pick_hit_distance(),
+    point: {
+      x: bloom_pick_hit_x(),
+      y: bloom_pick_hit_y(),
+      z: bloom_pick_hit_z(),
+    },
+    normal: {
+      x: bloom_pick_hit_normal_x(),
+      y: bloom_pick_hit_normal_y(),
+      z: bloom_pick_hit_normal_z(),
+    },
+  };
+}
+
+// ============================================================
+// Geometry Generation
+// ============================================================
+
+/**
+ * Extrude a 2D polygon along Y axis and set as the node's geometry.
+ * The polygon is a flat array of 2D points: [x0, z0, x1, z1, ...].
+ * Extrusion goes from Y=0 to Y=depth.
+ */
+export function extrudePolygon(
+  handle: SceneNodeHandle,
+  polygon: number[],
+  depth: number,
+): void {
+  bloom_scene_extrude_polygon(handle, polygon as any, polygon.length / 2, depth);
+}
+
+/**
+ * Subtract an axis-aligned box from a scene node's geometry.
+ * Removes triangles fully inside the box (simplified CSG for door cutouts).
+ */
+export function subtractBox(
+  handle: SceneNodeHandle,
+  minX: number, minY: number, minZ: number,
+  maxX: number, maxY: number, maxZ: number,
+): void {
+  bloom_scene_subtract_box(handle, minX, minY, minZ, maxX, maxY, maxZ);
+}
+
+// ============================================================
+// Q4: Transform Read-back
+// ============================================================
+
+/**
+ * Read back the 4x4 transform matrix of a scene node as a flat 16-element
+ * array in column-major order (same layout as setSceneNodeTransform).
+ */
+export function getSceneNodeTransform(handle: SceneNodeHandle): number[] {
+  const m: number[] = new Array(16);
+  for (let i = 0; i < 16; i++) {
+    m[i] = bloom_scene_get_transform(handle, i);
+  }
+  return m;
+}
+
+// ============================================================
+// Q5: Scene Node Bounds
+// ============================================================
+
+/**
+ * Return the cached AABB of a scene node's geometry in local space.
+ * Recomputed automatically when geometry is updated via updateSceneNodeGeometry.
+ */
+export function getSceneNodeBounds(handle: SceneNodeHandle): { min: { x: number; y: number; z: number }; max: { x: number; y: number; z: number } } {
+  return {
+    min: {
+      x: bloom_scene_get_bounds_min_x(handle),
+      y: bloom_scene_get_bounds_min_y(handle),
+      z: bloom_scene_get_bounds_min_z(handle),
+    },
+    max: {
+      x: bloom_scene_get_bounds_max_x(handle),
+      y: bloom_scene_get_bounds_max_y(handle),
+      z: bloom_scene_get_bounds_max_z(handle),
+    },
+  };
+}
+
+// ============================================================
+// Q7: Scene Node User Data
+// ============================================================
+
+/**
+ * Attach an arbitrary integer to a scene node. Used by editors to associate
+ * entity ids with scene nodes so picking can return the entity id directly.
+ */
+export function setSceneNodeUserData(handle: SceneNodeHandle, data: number): void {
+  bloom_scene_set_user_data(handle, data);
+}
+
+export function getSceneNodeUserData(handle: SceneNodeHandle): number {
+  return bloom_scene_get_user_data(handle);
+}
+
+// ============================================================
+// Q6: Multi-Hit Picking
+// ============================================================
+
+/**
+ * Raycast against all visible scene nodes and return all hits sorted by
+ * distance (closest first). Used by editors for Alt-click cycling through
+ * occluded objects. Returns an array of { handle, distance }.
+ */
+export function pickSceneAll(screenX: number, screenY: number, maxResults: number = 8): { handle: number; distance: number }[] {
+  const count = bloom_scene_pick_all(screenX, screenY, maxResults);
+  const results: { handle: number; distance: number }[] = [];
+  for (let i = 0; i < count; i++) {
+    results.push({
+      handle: bloom_pick_all_handle(i),
+      distance: bloom_pick_all_distance(i),
+    });
+  }
+  return results;
+}
+
+// ============================================================
+// Q8: Water Material
+// ============================================================
+
+/**
+ * Set a water-like material on a scene node with translucent tint and
+ * low roughness. The wave parameters are stored for a future animated
+ * water shader; currently they're visual-only placeholders.
+ */
+export function setSceneNodeWaterMaterial(
+  handle: SceneNodeHandle,
+  waveAmplitude: number, waveSpeed: number,
+  r: number, g: number, b: number, a: number,
+): void {
+  bloom_scene_set_material_water(handle, waveAmplitude, waveSpeed, r, g, b, a);
+}
+
+export function addPointLight(
+  x: number, y: number, z: number, range: number,
+  r: number, g: number, b: number,
+  intensity: number,
+): void {
+  bloom_add_point_light(x, y, z, range, r, g, b, intensity);
+}

package/src/shapes/index.ts

@@ -0,0 +1,120 @@
+import { Color, Rect, Vec2 } from '../core/types';
+
+// FFI declarations
+declare function bloom_draw_line(x1: number, y1: number, x2: number, y2: number, thickness: number, r: number, g: number, b: number, a: number): void;
+declare function bloom_draw_rect(x: number, y: number, w: number, h: number, r: number, g: number, b: number, a: number): void;
+declare function bloom_draw_rect_lines(x: number, y: number, w: number, h: number, thickness: number, r: number, g: number, b: number, a: number): void;
+declare function bloom_draw_circle(cx: number, cy: number, radius: number, r: number, g: number, b: number, a: number): void;
+declare function bloom_draw_circle_lines(cx: number, cy: number, radius: number, r: number, g: number, b: number, a: number): void;
+declare function bloom_draw_triangle(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, r: number, g: number, b: number, a: number): void;
+declare function bloom_draw_poly(cx: number, cy: number, sides: number, radius: number, rotation: number, r: number, g: number, b: number, a: number): void;
+
+// Drawing functions
+
+export function drawLine(startX: number, startY: number, endX: number, endY: number, thickness: number, color: Color): void {
+  bloom_draw_line(startX, startY, endX, endY, thickness, color.r, color.g, color.b, color.a);
+}
+
+export function drawRect(x: number, y: number, width: number, height: number, color: Color): void {
+  bloom_draw_rect(x, y, width, height, color.r, color.g, color.b, color.a);
+}
+
+export function drawRectRec(rec: Rect, color: Color): void {
+  bloom_draw_rect(rec.x, rec.y, rec.width, rec.height, color.r, color.g, color.b, color.a);
+}
+
+export function drawRectLines(x: number, y: number, width: number, height: number, thickness: number, color: Color): void {
+  bloom_draw_rect_lines(x, y, width, height, thickness, color.r, color.g, color.b, color.a);
+}
+
+export function drawCircle(centerX: number, centerY: number, radius: number, color: Color): void {
+  bloom_draw_circle(centerX, centerY, radius, color.r, color.g, color.b, color.a);
+}
+
+export function drawCircleLines(centerX: number, centerY: number, radius: number, color: Color): void {
+  bloom_draw_circle_lines(centerX, centerY, radius, color.r, color.g, color.b, color.a);
+}
+
+export function drawTriangle(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, color: Color): void {
+  bloom_draw_triangle(x1, y1, x2, y2, x3, y3, color.r, color.g, color.b, color.a);
+}
+
+export function drawPoly(centerX: number, centerY: number, sides: number, radius: number, rotation: number, color: Color): void {
+  bloom_draw_poly(centerX, centerY, sides, radius, rotation, color.r, color.g, color.b, color.a);
+}
+
+// Bezier curve drawing (pure TS — subdivides cubic bezier into line segments)
+
+export function drawBezier(
+  startX: number, startY: number,
+  cp1X: number, cp1Y: number,
+  cp2X: number, cp2Y: number,
+  endX: number, endY: number,
+  thickness: number, color: Color,
+): void {
+  const segments = 24;
+  let prevX = startX;
+  let prevY = startY;
+  for (let i = 1; i <= segments; i++) {
+    const t = i / segments;
+    const u = 1 - t;
+    const x = u * u * u * startX + 3 * u * u * t * cp1X + 3 * u * t * t * cp2X + t * t * t * endX;
+    const y = u * u * u * startY + 3 * u * u * t * cp1Y + 3 * u * t * t * cp2Y + t * t * t * endY;
+    bloom_draw_line(prevX, prevY, x, y, thickness, color.r, color.g, color.b, color.a);
+    prevX = x;
+    prevY = y;
+  }
+}
+
+// Pure TypeScript collision detection
+
+export function checkCollisionRecs(rec1: Rect, rec2: Rect): boolean {
+  return (
+    rec1.x < rec2.x + rec2.width &&
+    rec1.x + rec1.width > rec2.x &&
+    rec1.y < rec2.y + rec2.height &&
+    rec1.y + rec1.height > rec2.y
+  );
+}
+
+export function checkCollisionCircles(center1: Vec2, radius1: number, center2: Vec2, radius2: number): boolean {
+  const dx = center2.x - center1.x;
+  const dy = center2.y - center1.y;
+  const distSq = dx * dx + dy * dy;
+  const radiusSum = radius1 + radius2;
+  return distSq <= radiusSum * radiusSum;
+}
+
+export function checkCollisionCircleRec(center: Vec2, radius: number, rec: Rect): boolean {
+  const closestX = Math.max(rec.x, Math.min(center.x, rec.x + rec.width));
+  const closestY = Math.max(rec.y, Math.min(center.y, rec.y + rec.height));
+  const dx = center.x - closestX;
+  const dy = center.y - closestY;
+  return (dx * dx + dy * dy) <= radius * radius;
+}
+
+export function checkCollisionPointRec(point: Vec2, rec: Rect): boolean {
+  return (
+    point.x >= rec.x &&
+    point.x <= rec.x + rec.width &&
+    point.y >= rec.y &&
+    point.y <= rec.y + rec.height
+  );
+}
+
+export function checkCollisionPointCircle(point: Vec2, center: Vec2, radius: number): boolean {
+  const dx = point.x - center.x;
+  const dy = point.y - center.y;
+  return (dx * dx + dy * dy) <= radius * radius;
+}
+
+export function getCollisionRec(rec1: Rect, rec2: Rect): Rect {
+  const x = Math.max(rec1.x, rec2.x);
+  const y = Math.max(rec1.y, rec2.y);
+  const right = Math.min(rec1.x + rec1.width, rec2.x + rec2.width);
+  const bottom = Math.min(rec1.y + rec1.height, rec2.y + rec2.height);
+  if (right <= x || bottom <= y) {
+    return { x: 0, y: 0, width: 0, height: 0 };
+  }
+  return { x, y, width: right - x, height: bottom - y };
+}