| import { FLY_AREA_CONFIG } from "./env"; | |
| /** | |
| * Axis-aligned bounding box in mm, world (three.js) XZ coordinates. | |
| * `topY` is optional and doubles this same shape as "floor height" data: | |
| * undefined means flies never stand on it (e.g. a wall), a number means a | |
| * walkable/landable surface at that height (e.g. a tabletop). | |
| */ | |
| export interface AabbMm { | |
| minX: number; | |
| maxX: number; | |
| minZ: number; | |
| maxZ: number; | |
| topY?: number; | |
| } | |
| export interface FurniturePlacement { | |
| id: string; | |
| /** path under public/, served by Vite at the same path. */ | |
| modelUrl: string; | |
| position: [number, number, number]; | |
| rotationY: number; | |
| /** uniform scale converting the source glTF's meter units to this app's mm world. */ | |
| scale: number; | |
| /** collision footprint(s) this placement contributes -- empty for purely decorative props. */ | |
| colliders: AabbMm[]; | |
| } | |
| // Room interior derives from FLY_AREA_CONFIG (not its own copy) so the two | |
| // can never drift apart -- FLY_AREA_CONFIG already drives camera/grid | |
| // framing math elsewhere, this just reuses it for wall placement. | |
| // wallHeightMm/wallThicknessMm/TILE_MM match the authored size of | |
| // public/models/room/wall.glb and floor.glb (Kenney "Furniture Kit", CC0): | |
| // each is a 1m x ~1.29m x 0.05m segment meant to be tiled edge-to-edge. | |
| export const ROOM_CONFIG = { | |
| widthMm: FLY_AREA_CONFIG.widthMm, | |
| depthMm: FLY_AREA_CONFIG.depthMm, | |
| wallHeightMm: 1289.5, | |
| wallThicknessMm: 50, | |
| }; | |
| export const TILE_MM = 1000; | |
| // CC0 tileable textures (Poly Haven), applied as diffuse maps onto the | |
| // floor/wall meshes in RoomScene.tsx -- see CREDITS.md. | |
| export const FLOOR_TEXTURE_URL = "/textures/floor_diff.jpg"; | |
| export const WALL_TEXTURE_URL = "/textures/wall_diff.jpg"; | |
| const HALF_WIDTH = ROOM_CONFIG.widthMm / 2; | |
| const HALF_DEPTH = ROOM_CONFIG.depthMm / 2; | |
| // Four thin boxes ringing the interior, computed from ROOM_CONFIG rather | |
| // than hand-authored, since wall placement is mechanical. | |
| export const WALL_COLLIDERS: AabbMm[] = [ | |
| { minX: -HALF_WIDTH, maxX: HALF_WIDTH, minZ: -HALF_DEPTH, maxZ: -HALF_DEPTH + ROOM_CONFIG.wallThicknessMm }, // south | |
| { minX: -HALF_WIDTH, maxX: HALF_WIDTH, minZ: HALF_DEPTH - ROOM_CONFIG.wallThicknessMm, maxZ: HALF_DEPTH }, // north | |
| { minX: -HALF_WIDTH, maxX: -HALF_WIDTH + ROOM_CONFIG.wallThicknessMm, minZ: -HALF_DEPTH, maxZ: HALF_DEPTH }, // west | |
| { minX: HALF_WIDTH - ROOM_CONFIG.wallThicknessMm, maxX: HALF_WIDTH, minZ: -HALF_DEPTH, maxZ: HALF_DEPTH }, // east | |
| ]; | |
| // Furniture layout -- positions/colliders measured directly from each | |
| // downloaded glTF's accessor bounding box (see tools/inspect done during | |
| // execution), not guessed: every piece's local origin sits at a known | |
| // corner or center, and `position` is that corner/center's world-space | |
| // placement minus the piece's own local min/center, so these numbers | |
| // already account for each model's authored origin offset. | |
| // | |
| // Sources (all CC0, see CREDITS.md): | |
| // - table/chair/sofa/plant/rug/floor/wall: Kenney "Furniture Kit" | |
| // - bowl/apple/lemon: Poly Haven "Food & Kitchen" collection | |
| export const FURNITURE: FurniturePlacement[] = [ | |
| // tableCross.glb: local bbox X[0,852.1] Z[-447.4,0] Y[0,347.4] (mm) -- | |
| // verified with `gltf-transform inspect` (scene-graph-aware; an earlier | |
| // raw-accessor read of this specific file ignored a node-level scale and | |
| // was ~2.4x too large, which is why the fruit/chairs looked stranded off | |
| // the table before). Placed against the north wall. | |
| { | |
| id: "table", | |
| modelUrl: "/models/room/table.glb", | |
| position: [-426.06, 0, 1400], | |
| rotationY: 0, | |
| scale: 1000, | |
| colliders: [{ minX: -426.06, maxX: 426.06, minZ: 952.63, maxZ: 1400, topY: 347.41 }], | |
| }, | |
| // chair.glb: local bbox X[0,200] Z[-200,0] Y[0,470] (mm), pulled up snug | |
| // against the table's near edge (952.63mm, ~22.6mm clearance). topY makes | |
| // the seat/back landable, same as the table (see resolvePosition's | |
| // altitude-aware obstacle check in collision.ts). | |
| { | |
| id: "chair-1", | |
| modelUrl: "/models/room/chair.glb", | |
| position: [-350, 0, 930], | |
| rotationY: 0, | |
| scale: 1000, | |
| colliders: [{ minX: -350, maxX: -150, minZ: 730, maxZ: 930, topY: 470 }], | |
| }, | |
| { | |
| id: "chair-2", | |
| modelUrl: "/models/room/chair.glb", | |
| position: [150, 0, 930], | |
| rotationY: 0, | |
| scale: 1000, | |
| colliders: [{ minX: 150, maxX: 350, minZ: 730, maxZ: 930, topY: 470 }], | |
| }, | |
| // loungeSofa.glb: local bbox X[0,980] Z[-410,0] Y[0,460] (mm), placed | |
| // along the west wall. Landable (topY), same reasoning as the chairs. | |
| { | |
| id: "sofa", | |
| modelUrl: "/models/room/sofa.glb", | |
| position: [-1900, 0, -190], | |
| rotationY: 0, | |
| scale: 1000, | |
| colliders: [{ minX: -1900, maxX: -920, minZ: -600, maxZ: -190, topY: 460 }], | |
| }, | |
| // pottedPlant.glb: local bbox X[-106.03,106.03] Z[-120.73,120.73] | |
| // Y[0,654.02] (mm), origin centered in X/Z (verified with `gltf-transform | |
| // inspect`) -- tucked in the corner opposite the sofa. Deliberately no | |
| // topY: a potted plant's foliage isn't a landable surface, so it stays a | |
| // full-height obstacle at every altitude, unlike the table/chairs/sofa/shelf. | |
| { | |
| id: "plant", | |
| modelUrl: "/models/room/plant.glb", | |
| position: [1800, 0, -1300], | |
| rotationY: 0, | |
| scale: 1000, | |
| colliders: [{ minX: 1693.97, maxX: 1906.03, minZ: -1420.73, maxZ: -1179.27 }], | |
| }, | |
| // rugRectangle.glb: purely decorative (no collider) -- laid under the | |
| // free-floor area so the flies have somewhere visually distinct to walk. | |
| { | |
| id: "rug", | |
| modelUrl: "/models/room/rug.glb", | |
| position: [-160, 0.5, -265], | |
| rotationY: 0, | |
| scale: 1000, | |
| colliders: [], | |
| }, | |
| // Fruit bowl + fruit, sitting on the table's topY (347.41mm, centered | |
| // over its Z[952.63,1400] footprint) -- colliders stay [] (a grounded | |
| // fly's XZ collision already keeps it out of the table's whole footprint | |
| // via ALL_OBSTACLES, so nothing here needs to independently block | |
| // horizontal movement), but each still gets its own small landable | |
| // footprint in FRUIT_FLOOR_SURFACES below so a fly can land specifically | |
| // on top of a piece of fruit, not just anywhere on the table. bowl/apple | |
| // have bottom-centered local origins (position.y == topY places them | |
| // flush); lemon's origin sits mid-body, so its position.y adds back its | |
| // local min-Y offset (52.29mm) to rest flush. | |
| { | |
| id: "bowl", | |
| modelUrl: "/models/room/bowl.glb", | |
| position: [0, 347.41, 1176.3], | |
| rotationY: 0, | |
| scale: 1000, | |
| colliders: [], | |
| }, | |
| { | |
| id: "apple", | |
| modelUrl: "/models/room/apple.glb", | |
| position: [-120, 347.41, 1176.3], | |
| rotationY: 0, | |
| scale: 1000, | |
| colliders: [], | |
| }, | |
| { | |
| id: "lemon", | |
| modelUrl: "/models/room/lemon.glb", | |
| position: [100, 399.7, 1186.3], | |
| rotationY: 0, | |
| scale: 1000, | |
| colliders: [], | |
| }, | |
| // bookcaseOpen.glb: local bbox X[0,400] Z[-250,0] Y[0,880] (mm), rotated | |
| // -90deg so its depth (250mm) faces the east wall and stands flush | |
| // against it, in the room's north half (clear of the plant/sofa corners). | |
| // topY makes its top landable (reachable around altitude level 8+). | |
| { | |
| id: "shelf", | |
| modelUrl: "/models/room/shelf.glb", | |
| position: [1700, 0, 700], | |
| rotationY: -Math.PI / 2, | |
| scale: 1000, | |
| colliders: [{ minX: 1700, maxX: 1950, minZ: 700, maxZ: 1100, topY: 880 }], | |
| }, | |
| ]; | |
| /** Everything collision.ts checks fly positions against (horizontal blocking). */ | |
| export const ALL_OBSTACLES: AabbMm[] = [...WALL_COLLIDERS, ...FURNITURE.flatMap((f) => f.colliders)]; | |
| /** | |
| * Raised walkable surfaces for floorHeightAt's height lookup only -- NOT | |
| * horizontal obstacles (a fly can freely walk onto these footprints, it | |
| * just stands slightly higher while over them). Includes every | |
| * topY-bearing FURNITURE collider (e.g. the table) plus the rug, which | |
| * isn't a FURNITURE collider at all (flies must be able to walk across it, | |
| * unlike the table) but still has real thickness -- rugRectangle.glb: local | |
| * bbox X[0,1570] Z[-920,0] Y[0,10] (mm), at its placed position or a | |
| * grounded fly would render with its body clipped partway into the rug | |
| * mesh instead of standing on top of it. | |
| */ | |
| // Each fruit prop's own small landable surface, ON TOP of the table | |
| // (topY = table's 347.41 + this prop's own authored height) -- kept | |
| // separate from FURNITURE's colliders (which stay [] so these never | |
| // independently block horizontal movement, same reasoning as the rug | |
| // below). bowl: 130.7x73.1x124.5mm @ (0,347.41,1176.3), bottom-centered. | |
| // apple: 97.6x85.4x95.9mm @ (-120,347.41,1176.3), bottom-centered. lemon: | |
| // 68.7x95.4x68.3mm @ (100,399.7,1186.3) -- its topY uses its full authored | |
| // height (95.4mm) added to the table's topY, not position.y (399.7mm), | |
| // since position.y already has its own local-origin offset baked in just | |
| // to sit the mesh flush on the table. | |
| export const FRUIT_FLOOR_SURFACES: AabbMm[] = [ | |
| { minX: -65.35, maxX: 65.35, minZ: 1114.05, maxZ: 1238.55, topY: 420.51 }, // bowl | |
| { minX: -168.8, maxX: -71.2, minZ: 1128.35, maxZ: 1224.25, topY: 432.81 }, // apple | |
| { minX: 65.65, maxX: 134.35, minZ: 1152.15, maxZ: 1220.45, topY: 442.81 }, // lemon | |
| ]; | |
| export const FLOOR_SURFACES: AabbMm[] = [ | |
| ...ALL_OBSTACLES.filter((box) => box.topY !== undefined), | |
| { minX: -160, maxX: 1410, minZ: -1185, maxZ: -265, topY: 10.5 }, // rug | |
| ...FRUIT_FLOOR_SURFACES, | |
| ]; | |
| /** | |
| * Free-floor spawn rectangle(s) -- hand-picked to clear every obstacle | |
| * above (with margin), not derived by automatic rectangle subtraction | |
| * (deliberately out of scope: a human picking 1-2 clear rectangles once is | |
| * simpler and just as correct here). | |
| */ | |
| export const FREE_FLOOR_RECTS: AabbMm[] = [{ minX: -350, maxX: 1600, minZ: -1450, maxZ: 0 }]; | |