Files
isokit/docs/ROADMAP.md
T
grabowski e4017ce2a8
Deploy web Studio / deploy (push) Successful in 3m52s
Fences join like walls, fence designs, draw runs corner by corner
Joints: line_joint (util.rhai) applies the house-wall rules to fences and
site walls, so pieces never overlap and the depth sort stays clean.
- A corner is closed: the thicker piece (or, if equal, the one along
  world x) runs through, and the other stops at its face.
- On a straight run, two pieces share one post.
- At a T, the stem stops at the other piece's face without a post of its
  own.
- A fence that ends at a site or house wall stops at the wall's face.

Fence designs (prop style): mesh, wooden boards, steel bars, mesh on a
stone base, cobble wall, and brick wall with pillars. Board, stone and
brick joints are drawn on the face turned to the viewer. Brick pillars
are separate sprites.

Studio: line prefabs (walls, fences, hedges, roads) can be drawn as a
run by clicking corner after corner. Double-click or Enter ends the run,
clicking the first corner closes it, and Backspace drops the last
corner. A run is one undo step. A drag still draws one piece. Corners
and ends snap onto the ends and lines of the pieces they meet, and a
marker shows where the next corner will snap.

The house demo gets a brick front wall with gate pillars and wooden side
fences in place of the old east fence, which ran over the road. Tests
cover every design's corners, Ts, straight runs and wall stops, with no
depth-sort cycles in any rotation, plus site walls. check_studio draws
and closes a fence run, undoes it in one step, snaps a dragged spur,
and picks a design.
2026-10-24 18:07:40 +07:00

117 lines
7.2 KiB
Markdown

# Roadmap
Each phase ends with tests, a Studio/viewer check in Edge, commit and push.
## Phase 1: engine, Studio, MCP (done)
- [x] Core: projection with 4 rotations, primitives (box, prism, cylinder, frustum, face, poly, flat,
openings, lines, disc, circle, stem, figures, puffs, fan, raw, groups, sequences), sprites with
90° object frames, depth sort ported from the JS views, SVG writer, tags, tooltips
- [x] Theme: built-in palette, materials and rules converted from the Mooban/CNX CSS; TOML overrides
- [x] Rhai runtime: drawing API, module imports from memory, errors with file:line, safety limits
- [x] Prefab library: site, area, road, parking, wall, fence, lamp, marker, tree, tree row, hedge,
building (storeys, windows, door, flat/gable roof, solar, AC, cut-open levels), carport, shed,
car (driving), truck, motorbike, person, crowd, tank, container, generator, solar field, chimney
- [x] Scene document + prefab catalog with property schemas
- [x] Project folder, ops (add/update/remove/duplicate/reorder/set_cfg/replace), Workspace (save, undo,
reload on outside changes), check, static HTML page, SVG export
- [x] Viewer JS: port of the views' mount() (pan, pinch, wheel, declutter, tooltips, full screen) for
prerendered, server and future WASM sources
- [x] Studio GUI: palette, object list, placing, drag-to-move with snap, keyboard, forms from schemas,
levels, undo/redo, live follow of agent edits, MCP connection panel
- [x] MCP: 15 tools over stdio and HTTP (`/mcp`), validation messages for agents
- [x] Demo project, 52 Rust tests, Playwright Studio + MCP test
## Web Studio (done)
- [x] `isokit-wasm`: the engine in the browser (wasm-bindgen, 2.8 MB / 0.75 MB gzipped); `Store`
trait (folder or memory) under the `Workspace`; Studio JSON API shared with `isokit studio`
- [x] `studio.js` runs on a pluggable backend; the web shell answers it from WASM
- [x] Projects in IndexedDB; new, demo copy, delete; export / import `.zip` (stored or deflated) and
folders (drop or pick); two tabs on one project stay in step
- [x] Folder projects (File System Access, Chrome / Edge): edits written to disk, outside changes
followed live and undoable, Build page writes `dist/index.html`
- [x] Code editor for scripts, prefabs, theme and manifest, with script errors by file and line
- [x] MCP tools inside the page (`isokit.mcp`), WebMCP registration when the browser offers it
- [x] `tools/build_web.py` (static output), `tools/check_web.py` (44 checks, Edge)
- [ ] Deploy a hosted copy; render in a Web Worker for very large scenes
## Agent window (done)
- [x] ✦ Agent in the Studio: chat with a model on an OpenAI-compatible endpoint (default: B4L's
inference server) that edits the scene with the MCP tools + page tools (select, view);
streamed answers and reasoning, tool calls with results, clickable object ids, Stop, Undo
- [x] `isokit studio` relays the calls (`/api/agent/*`, key stays on the machine, no CORS);
settings from `ISOKIT_LLM_*` or `agent.json` in the user's config folder
- [x] Web Studio calls the endpoint from the page; isokit.buildfor.life relays `/llm/` to the
inference server (Caddy) so the page needs no CORS from it
- [x] `tools/mock_llm.py` + `tools/agent_checks.py` in both Studio checks
- [ ] Keep the conversation per project across reloads; attach a rendered view (PNG, Phase 4)
for vision models
## Build your own house (done)
- [x] House parts: `house_wall` (drawn along a line, ends adapt at corners, T-junctions and
straight runs), `window` and `door` that sit on a wall and cut its opening (door styles:
panel, glass, double, sliding, opening; open / closed, hinge and swing by rotation),
`floor` (boards / tiles / carpet / stone), `roof` (hip, gable, flat, solar), `stairs`
- [x] Furniture: chair, sofa / armchair, table with chairs, desk with monitor and chair, TV,
bed with nightstands, cupboard, bookshelf, kitchen run (sink, hob, wall cabinets, fridge),
bathtub, shower, toilet, washbasin, plant, rug, floor lamp
- [x] Cut-open levels for houses: walls in front of rooms cut low (rooms found by their floors),
roof as an outline, storeys from z (`storey_h`), upper storeys left out
- [x] Scripting: `objects_of`, `objects_at`, `objects_on`, `mount_of`, `mounted`, `frame`,
`to_world`, `to_local`, `local_of`; prefab meta `shape` (line / rect), `mount`, `storey`
- [x] Studio: drag to draw lines and rectangles (walls, roads, fences, floors, areas, buildings),
Room tool (floor + walls, shared walls not doubled), windows and doors snap onto walls
(hover preview) and move, turn, copy and delete with them, new parts land on the storey
shown, collapsible palette that scrolls on its own
- [x] `examples/house` (a furnished house built from parts), House demo in the web Studio
- [ ] Openings across two walls; diagonal walls; floor openings for stairs
## Backlog (2026-10)
1. Web performance: the web build runs smoothly on low-power machines
2. Conveyors: placeable conveyors
3. Producers with adjustable production speed
4. Robotic arms
5. Rounded streets: curved road segments
6. Sidewalks along streets
7. Roundabouts
8. Waypoint animation: a person or car moving along a path of waypoints
9. ~~Build your own house~~ (done, see above)
Done since: the middle mouse button only moves the camera; fences and site walls join like house
walls (`line_joint`); fence designs (mesh, wood, bars, half stone, cobble, brick with pillars);
runs of walls and fences drawn corner by corner, ends snapping onto the pieces they meet.
## Phase 2: richer editing
- [x] Interior prefabs (see Build your own house); a building `rooms` prop is still open
- [ ] Path objects in the Studio: click points for areas, roads (polyline with width), fences, walls,
pipe runs; vertex handles
- [ ] Multi-select (box select, Shift-click), group move, align/distribute
- [ ] Copy/paste between projects; prefab thumbnails in the palette (rendered icons)
- [ ] Measure tool and grid overlay; numeric resize handles on the selection
- [ ] Studio editor for `theme.toml` (colour pickers) and for project parameters
## Phase 3: embedding in the other projects
- [ ] Host pages on the WASM build (`isokit-wasm` exists, see Web Studio): the same scene
recomputes in the browser when a host page's calculator changes the parameters (cnx_vinyl
fleet calculator)
- [ ] `isokit build --fragment`: `<style>` + `<script>` blocks for the Python build scripts of the
host pages (replace `inline.py`)
- [ ] Host API parity with CNXIso (`mount`, `update(cfg)`, `setLevel`, `focus`, `info`, `onPick`)
- [ ] Port the existing scenes: mooban estate, CNX Scuba centre (section cut), CNX Vinyl plant;
check each against its old view with the QA checklist from the skill
## Phase 4: output and QA
- [ ] Section cut layer (underground scenes) from iso-scuba: cut plane, clip-path per cavity
- [ ] PNG export (static style resolution + resvg) so agents get an image from `render_view`
- [ ] `isokit check` rules from the QA checklist: props on paved areas, runs ending in the air,
covers drawn over their contents, tag overlaps
- [ ] Performance budget test (render ms per view, 60 fps pan) on a 3,500-node scene
- [ ] Packaged desktop app (Tauri); shared projects for the hosted web Studio (behind login)