A town simulation in pale isometric line art, implemented with Ritmo ECS and PixiJs 3D
import { Plane, Vector3 } from "@pixi/3d"
import { OrbitCamera } from "@pixi/3d/extras"
import { buildAsset, floorScale } from "../../render/pixi3d/assets/renderer.ts"
import { inkAssets } from "../../render/pixi3d/assets/assets.ts"
import { makePerson } from "../../render/pixi3d/assets/people.ts"
import { testMap, districts } from "./map.ts"
import { drawCounter } from "../../render/pixi3d/scene.ts"
import { triangleCount } from "../../render/pixi3d/mesh/geometry.ts"
import { labViewer } from "../viewer.ts"
import "./style.css"
const root = document.querySelector<HTMLElement>("#map-lab")!
root.innerHTML = `
<div id="viewport"></div>
<header class="card"><div><h1>Inkline harbour</h1><p>${inkAssets.length} models · complete world asset study</p></div><a href="/asset-lab.html">Asset study ↗</a></header>
<section class="review card"><label>Explore <select id="district"></select></label><label>Inspect <select id="inspect"><option value="">Choose an asset…</option></select></label><div><button id="motion" aria-pressed="true">People moving</button><a id="asset-link" href="/asset-lab.html">Compare with original ↗</a></div></section>
<aside class="compass card" aria-label="Camera orientation"><span id="north" aria-hidden="true">↑</span><span id="heading">0°</span></aside>
<div class="hint card"><span class="desktop-hint">Drag to pan · right-drag to rotate · scroll to zoom</span><span class="touch-hint">Drag to pan · pinch to zoom · switch to Rotate to turn</span><span>WASD / arrows pan · Q / E turn · double-click to focus</span></div>
<nav class="card controls" aria-label="Map camera controls">
<div class="group"><button id="pan" aria-pressed="true" title="Left-drag or one finger pans the map">Pan</button><button id="rotate" aria-pressed="false" title="Left-drag or one finger rotates the map">Rotate</button></div>
<div class="group"><button id="zoom-out" aria-label="Zoom out">−</button><output id="zoom">1.0×</output><button id="zoom-in" aria-label="Zoom in">+</button></div>
<div class="group"><button id="turn-left" aria-label="Rotate left 45 degrees">↶</button><button id="turn-right" aria-label="Rotate right 45 degrees">↷</button></div>
<label class="tilt">Tilt <input id="tilt" type="range" min="15" max="65" step="1" value="30" aria-label="Camera elevation"><output id="tilt-value">30°</output></label>
<button id="reset" title="Restore the original view (Home)">Reset view</button>
</nav>
<span class="scene-note">Every model on the island · Original scale</span>
`
const viewport = root.querySelector<HTMLDivElement>("#viewport")!
const viewer = await labViewer(viewport, { width: viewport.clientWidth || 1, height: viewport.clientHeight || 1, background: 0xe2e9e6 })
const canvas = viewer.canvas, scene = viewer.view.root, camera = viewer.camera, counter = drawCounter(viewer.app.renderer)
canvas.tabIndex = 0
canvas.setAttribute("aria-label", "3D island map. Drag to pan, right-drag to rotate, scroll to zoom.")
const map = buildAsset(testMap.asset, { batchFaces: true })
scene.addChild(map.group)
const effects = testMap.effects.map((p) => {
const model = buildAsset(
inkAssets.find((a) => a.id === p.asset)!,
{ batchFaces: true }
)
model.group.position.set(p.x * floorScale, p.height / Math.cos(Math.PI / 6), p.y * floorScale)
scene.addChild(model.group)
return model
})
const degrees = (radians: number) => (radians * 180) / Math.PI, radians = (degrees: number) => (degrees * Math.PI) / 180
const controls = new OrbitCamera({
view: viewer.view,
target: { x: 0, y: 0, z: 0 },
autoUpdate: false,
screenSpacePanning: false,
zoomToCursor: true,
minZoom: 0.65,
maxZoom: 28,
minPolarAngle: radians(25),
maxPolarAngle: radians(75),
panSpeed: 0.85,
rotateSpeed: 0.65,
zoomSpeed: 0.85,
mouseButtons: { left: "pan", middle: "zoom", right: "rotate" },
touches: { one: "pan", two: "zoom-pan" }
})
const tilt = root.querySelector<HTMLInputElement>("#tilt")!
const district = root.querySelector<HTMLSelectElement>("#district")!
const inspect = root.querySelector<HTMLSelectElement>("#inspect")!
for (const [id, d] of Object.entries(districts)) {
const option = document.createElement("option")
option.value = id
option.textContent = d.title
district.append(option)
}
for (const a of [...inkAssets].sort((a, b) => a.title.localeCompare(b.title))) {
const option = document.createElement("option")
option.value = a.id
option.textContent = a.title
inspect.append(option)
}
let moving = true
const actors = inkAssets
.filter((a) => a.category === "people")
.slice(0, 8)
.map((a, i) => {
const r = a.reference!
if (r.type !== "walker") throw new Error("Actor requires walker reference")
const frames = [0, 1].map((phase) => buildAsset(makePerson(a.id, a.title, r.dress, r.load, r.cart, phase), { batchFaces: true }))
frames.forEach((f) => scene.addChild(f.group))
return { frames, offset: i / 8 }
})
let draws = 0
let mode: "pan" | "rotate" = "pan"
function render() {
for (const effect of effects) effect.group.rotation.y = controls.azimuthAngle - Math.PI / 4
counter.calls = counter.triangles = 0
viewer.render()
draws++
const turned = degrees(controls.azimuthAngle) - 45
const heading = ((turned + 540) % 360) - 180
const elevation = 90 - degrees(controls.polarAngle)
root.querySelector("#zoom")!.textContent = `${camera.zoom.toFixed(1)}×`
root.querySelector("#heading")!.textContent = `${Math.round(heading)}°`
root.querySelector<HTMLElement>("#north")!.style.transform = `rotate(${-heading}deg)`
tilt.value = String(Math.round(elevation))
root.querySelector("#tilt-value")!.textContent = `${Math.round(elevation)}°`
}
controls.on("change", render)
function reset() {
district.value = "all"
inspect.value = ""
controls.target.set(0, 0, 0)
camera.position.set(1600, Math.sqrt(2) * 1600 * Math.tan(Math.PI / 6), 1600)
camera.zoom = 1
controls.update()
render()
}
function resize() {
const width = viewport.clientWidth || 1,
height = viewport.clientHeight || 1
viewer.resize(width, height)
const viewHeight = Math.max(1350, (2150 * height) / width)
camera.orthographicSize = (viewHeight * width) / height / 2
render()
}
/** Moves the camera and its target together by `(dx, dy, dz)`. */
function shift(dx: number, dy: number, dz: number) {
controls.target.set(controls.target.x + dx, controls.target.y + dy, controls.target.z + dz)
camera.position.set(camera.position.x + dx, camera.position.y + dy, camera.position.z + dz)
}
function focus(x: number, y: number, zoom: number) {
shift(x * floorScale - controls.target.x, -controls.target.y, y * floorScale - controls.target.z)
camera.zoom = zoom
controls.update()
render()
}
function focusDistrict(id: keyof typeof districts) {
const d = districts[id]
focus(d.x, d.y, d.zoom)
district.value = id
inspect.value = ""
}
district.onchange = () => focusDistrict(district.value as keyof typeof districts)
inspect.onchange = () => {
const p = testMap.buildings.find((p) => p.asset === inspect.value)
if (!p) return
const a = inkAssets.find((a) => a.id === p.asset)!
focus(p.x, p.y, a.category === "people" ? 24 : a.category === "cargo" ? 18 : 6)
district.value = ""
root.querySelector<HTMLAnchorElement>("#asset-link")!.href = `/asset-lab.html?asset=${p.asset}`
}
root.querySelector<HTMLButtonElement>("#motion")!.onclick = () => {
moving = !moving
root.querySelector("#motion")!.textContent = moving ? "People moving" : "People paused"
root.querySelector("#motion")!.setAttribute("aria-pressed", String(moving))
}
function zoomBy(amount: number) {
camera.zoom = Math.min(controls.maxZoom, Math.max(controls.minZoom, camera.zoom * amount))
controls.update()
render()
}
function rotateBy(angle: number) {
const t = controls.target, x = camera.position.x - t.x, z = camera.position.z - t.z, a = radians(angle)
camera.position.set(t.x + x * Math.cos(a) + z * Math.sin(a), camera.position.y, t.z - x * Math.sin(a) + z * Math.cos(a))
controls.update()
}
function setTilt(angle: number) {
const t = controls.target, x = camera.position.x - t.x, y = camera.position.y - t.y, z = camera.position.z - t.z
const r = Math.hypot(x, y, z), theta = Math.atan2(x, z), phi = radians(90 - angle)
camera.position.set(t.x + r * Math.sin(phi) * Math.sin(theta), t.y + r * Math.cos(phi), t.z + r * Math.sin(phi) * Math.cos(theta))
controls.update()
}
function setMode(next: "pan" | "rotate") {
mode = next
controls.mouseButtons.left = mode === "pan" ? "pan" : "rotate"
controls.touches.one = mode === "pan" ? "pan" : "rotate"
controls.touches.two = mode === "pan" ? "zoom-pan" : "zoom-rotate"
root.querySelector("#pan")!.setAttribute("aria-pressed", String(mode === "pan"))
root.querySelector("#rotate")!.setAttribute("aria-pressed", String(mode === "rotate"))
canvas.style.cursor = mode === "pan" ? "grab" : "ew-resize"
}
function panBy(right: number, forward: number) {
// Along the ground: the camera's forward (towards its target) and its right, level.
const fx = controls.target.x - camera.position.x, fz = controls.target.z - camera.position.z, l = Math.hypot(fx, fz) || 1
const dx = fx / l, dz = fz / l
shift(-dz * right + dx * forward, 0, dx * right + dz * forward)
controls.update()
render()
}
root.querySelector<HTMLButtonElement>("#pan")!.onclick = () => setMode("pan")
root.querySelector<HTMLButtonElement>("#rotate")!.onclick = () => setMode("rotate")
root.querySelector<HTMLButtonElement>("#reset")!.onclick = reset
root.querySelector<HTMLButtonElement>("#zoom-in")!.onclick = () => zoomBy(1.25)
root.querySelector<HTMLButtonElement>("#zoom-out")!.onclick = () => zoomBy(0.8)
root.querySelector<HTMLButtonElement>("#turn-left")!.onclick = () => rotateBy(-45)
root.querySelector<HTMLButtonElement>("#turn-right")!.onclick = () => rotateBy(45)
tilt.oninput = () => setTilt(Number(tilt.value))
canvas.addEventListener("pointerdown", () => canvas.focus({ preventScroll: true }))
const onKeyDown = (event: KeyboardEvent) => {
if (event.target instanceof HTMLElement && event.target.closest("input,select,button,a")) return
const amount = 45 / camera.zoom
switch (event.key.toLowerCase()) {
case "a":
case "arrowleft":
panBy(-amount, 0)
break
case "d":
case "arrowright":
panBy(amount, 0)
break
case "w":
case "arrowup":
panBy(0, amount)
break
case "s":
case "arrowdown":
panBy(0, -amount)
break
case "q":
rotateBy(-15)
break
case "e":
rotateBy(15)
break
case "+":
case "=":
zoomBy(1.2)
break
case "-":
zoomBy(1 / 1.2)
break
case "home":
reset()
break
default:
return
}
event.preventDefault()
}
window.addEventListener("keydown", onKeyDown)
const ground = new Plane(new Vector3(0, 1, 0), 0)
canvas.addEventListener("dblclick", (event) => {
const rect = canvas.getBoundingClientRect()
const point = viewer.view.screenToWorld({ x: ((event.clientX - rect.left) / rect.width) * viewer.width, y: ((event.clientY - rect.top) / rect.height) * viewer.height }, ground)
if (point) {
shift(point.x - controls.target.x, point.y - controls.target.y, point.z - controls.target.z)
controls.update()
render()
}
})
let previous = 0,
elapsed = 0
let frameId = 0
const loop = (now: number) => {
frameId = requestAnimationFrame(loop)
if (!previous) previous = now
if (moving) elapsed += Math.min(0.05, (now - previous) / 1000)
previous = now
controls.update()
if (!moving && draws > 0) return
for (const actor of actors) {
const t = (elapsed * 0.035 + actor.offset) % 1,
forward = t < 0.5
const x = -8 + 16 * (forward ? t * 2 : (1 - t) * 2),
phase = Math.floor(elapsed * 5) % 2
actor.frames.forEach((f, i) => {
f.group.visible = i === phase
f.group.position.set(x * floorScale, 0, 4 * floorScale)
f.group.rotation.y = forward ? 0 : Math.PI
})
}
map.updateEffects(elapsed)
effects.forEach(e=>e.updateEffects(elapsed))
render()
}
frameId = requestAnimationFrame(loop)
const resizeObserver = new ResizeObserver(resize)
resizeObserver.observe(viewport)
reset()
resize()
// Reproducible camera/scene checks, without adding diagnostics to the map UI.
Object.assign(window, {
mapLab: {
reset,
focusDistrict,
focus,
capture: () => {
render()
return canvas.toDataURL("image/webp", 0.95)
},
rotateBy,
zoomBy,
setTilt,
panBy,
setMode,
stats: () => ({
buildings: inkAssets.filter((a) => a.category === "buildings").length,
assets: inkAssets.length,
represented: testMap.coverage,
people: inkAssets.filter((a) => a.category === "people").length,
actors: actors.length,
trees: testMap.trees,
roadCells: testMap.roads,
zoom: camera.zoom,
heading: degrees(controls.azimuthAngle),
elevation: 90 - degrees(controls.polarAngle),
target: [controls.target.x, controls.target.y, controls.target.z].map((value) => value / floorScale),
draws,
drawCalls: counter.calls,
triangles: counter.triangles || [map, ...effects].reduce((n, m) => n + m.parts.reduce((k, p) => k + triangleCount(p.part.mesh), 0), 0),
mode
})
}
})
if (import.meta.hot)
import.meta.hot.dispose(() => {
cancelAnimationFrame(frameId)
controls.destroy()
resizeObserver.disconnect()
window.removeEventListener("keydown", onKeyDown)
map.dispose()
effects.forEach((model) => model.dispose())
actors.forEach((actor) => actor.frames.forEach((frame) => frame.dispose()))
viewer.dispose()
})