# Door robot arm: status ## Red look and bake: DONE on the work copy (2026-10-19 01:14-01:50; not yet in the user's open files) The user, with `reference/ref8_red_metallic_paint.png`: "examine this image and texture the arms accoding to picture yes red color and that mettallic paint and everything bake it". Both of the user's files were open with unsaved changes, so everything ran headless on `DoorRobotArm_look_work.blend` (a copy of DoorRobotArm.blend, 22:15); the coordinator applies it in the open sessions with `build/dra_live_look.py`. Backup first: `versions/v22_before_red_look/` (textures/ = the 1.0x atlas maps, dra_surf, dra_build, dra_lib, dra_cycles, reports, README, STATUS). - Recipes (`build/dra_surf.py`, header and RECIPES): PaintWhite -> **PaintRed** (red metallic, flakes, clear coat 0.10, slight orange peel on the coat), Orange -> **Marking** (white labels; kit copy -> M_DoorArmKit_Marking where it exists), Gunmetal and BlackMetal black (low specular), Steel brighter and cleaner, Rubber black, Cable a braided sleeve. `painted()` gained coat_rough, peel_on_coat, flake, flake_col, flake_scale, smudge, spec; `steel()` shade, aniso, scratch, prints; new `braided()`. Material slots unchanged; dra_lib MAT_NAMES and dra_build MAT_COLORS renamed too. Tuning: a first try read pinkish red and grey blacks (0.50/0.020/0.018, metallic black 0.25 at specular 0.5). - Braid: the curves' UV is U along, V round (`build/dra_look_sig.py`). An Object attribute (bevel_depth or data.bevel_depth) reads 0 at render time, so the weave is set for the elbow cables (22 carriers, 5.9 mm, 2.38 m). - Atlas bake (`--stage bake`, all meshes in one call per map now, margin 3 px): T_DoorArm_Masks + T_DoorArm_BevelNormal, 4096, 16 samples, HIP, 221 s. The atlas is back on in the materials (no DRA_NO_ATLAS). - Final look bake (`--stage bake_look`, `build/look_bake_report.json`): T_DoorArm_BaseColor (sRGB), T_DoorArm_ORM (R AO, G roughness, B metallic, A coat), T_DoorArm_Normal (OpenGL), 4096, 1 sample each, HIP, 341 s (about 110 s a pass, whatever the samples). Covered 52.7 % of the atlas; roughness 0.28 / 0.35 / 0.64 (5/50/95 %), coat on 52 % of it. - Signature check against the user's open ship (`live_sig_18464.json`, `build/look_sig_report.json`): all 11 arm meshes in the ship (version B) match the work copy exactly (vertices + UVMap); the 9 version-A-only meshes are not in the ship. - `build/dra_live_look.py` tested on a copy of the ship (deleted after): 0.46 s; renamed the two materials, rebuilt 12 node trees, added only the two atlas images (//door-robot-arm/textures/...); 0 slot, object, mesh or matrix changes; no missing image. - Pictures: `previews/red_look/red_ref2_both.png`, `red_close_elbow.png`, `red_close_wrist.png` (128 samples) and a small braid probe `red_probe_cable_braid.png`. - Not done: FBX re-export (fbx/ still has the old material names), the layout json's material table, the other preview sets. DoorRobotArm.blend and the ship are untouched by this work. ## Scale-up and door-centre attach: BUILT, CHECKED, INSTALLED (2026-10-18 22:24; no bake, no export) The user: "make it bigger so those can withstand the pressure to open that door under the water" and "attach the main plate to the doors center and make it bigger" (screenshots: B's pad and plate). The coordinator's list: A attach point at the door's centre (both versions), B plate about 1.0-1.2 m, C the whole machine scaled uniformly (about 1.5x, or what the fit needs), D re-fit and check (pocket + the well: carousel, Tenders), E rebuild through the stages, F reinstall B in the ship (backup first, work copy, swap after the check). Power rule: every Blender through the capped runner (scratchpad run_blender.py, -t 16, below-normal), one at a time, Workbench for checks, at most 6 Cycles stills. Backup: `versions/v21_before_scale_up/` (file, layout, design.json, README, STATUS, build/, textures/); `design_base.json` = design.json before the scale-up (the fit script reads it). - Door centres (`build/dra_door_centre.py` -> `build/door_centre.json`): each door is 5.82 m long (local x) with a curved section 7.95 m long (arc); the centre on the inner face is local (-/+0.0858, -0.7053, -0.6179), normal (0, 0.7422, 0.6701): at the closed door that is 4.1 m below the rail and 1.0 m outboard of it. The inner face is hollow toward the arm: under a flat plate it rises 16.7 mm (1.0 m plate) / 23.8 mm (1.2 m) at the edges. - Door paths sampled (`build/dra_door_path.py` -> `build/door_path.json`). - The fit, in plain Python (`build/dra_fit.py`: the scaled design and the rig's own IK; `build/dra_fit_map.py`: rough clearances of the lower arm and forearm as boxes against the door's real inner face and the pocket's end wall, and a search for a continuous carriage schedule). Checked against the old design first: at 1.0x with the old attach point it gives the end wall 0.247 m where rig_check measured 0.2436 m. - RESULT (2026-10-18 18:40): **the door's centre cannot be held by this arm at any scale.** - At 1.0-1.2x the centre is out of reach (the arm cannot stretch 4 m down to it). - From 1.3x up it reaches, but while the door is pulled in and sliding, its inner face comes under the rail: the lower arm (0.92 S wide) hangs into the door (1.5x: 0.4-0.6 m deep, frames 13-108), and with the door open the elbow, which leans back from the wrist, meets the pocket's end wall or the door again. No carriage schedule avoids both (searched: any continuous schedule, either direction, up to 1.5x the door's speed); the other IK branches break the J2 / J3 limits (the lower arm would fold into the turret). A longer tool does not help. - Bigger arms also stop working at the old, high attach point: from about 1.2x the elbow runs out of travel (J3). - What fits (`build/fit_map.json`): up to 1.3x, with the plate 0.7 m from the door's middle toward the pocket's end and 1.6 m above the middle of the curved section (1.3x is tight: joints 5 deg from their limits; 1.2x with the plate 1.5 m along and 1.6 m up has 10 deg, 1.0 m door clearance). 1.4x and 1.5x fit nowhere near the centre. - Picture: `previews/scale_up/fit_section.png` (the door's section mid-slide, the arm as now and at 1.5x). - NOTHING REBUILT: DoorRobotArm.blend is still the fix-round file (16:41), design.json unchanged (`design_base.json` is its copy), the ship untouched. Waiting for the user's choice (sent to the coordinator). - 2026-10-18 evening, the coordinator: the exact centre, no menu; solve with the rail's position, the scale (1.4-1.5x preferred), the IK branch / turret zero / limits, the link lengths, in that order. - Surroundings from the ship itself, read only (`build/dra_obstacles.py` -> `build/obstacles_ship.npz`, 1.46 M surface points of 120 objects, instances and linked objects included; the Tender carousel and the Tenders sit above the deck, out of the arms' reach) and the arm's links as points (`build/dra_arm_points.py` -> `build/arm_points.npz`). The 3D fit `build/dra_fit3d.py` (5 cm distance grid, the doors moved with their animation, the rig's IK, a carriage-schedule search); checked on the old design (end wall 0.25 m, rig_check 0.244). - LAYOUT (DESIGN.md addendum "2026-10-18 scale-up and door-centre attach"): rail line y -3.80 (2.0 m inboard), scale 1.6x, upper arm and forearm +20 %, the J3 cylinder's knob 13 % closer to J3 (J3 window -29.75..63.25), J1 +-185, the carriage c -3.83 -> -5.50 (AFT), B's plate 1.2 m on a 1.3 m pad, both versions at the door centre. - PROOF (`build/fit3d_proof.json`, every half frame, both doors, both versions): ship surfaces >= 0.45 m, doors >= 0.32 m, joints >= 5.2 deg inside their limits, the piston in its bore. - Next: build it (design numbers, geo with the scale and lengths, rig, checks, surf, bake, export), then the ship. - 2026-10-18 evening (the coordinator: the layout accepted, "finish this"). Building: - Final numbers (`build/dra_scaleup.py` -> design.json, from design_base.json): the inner stop needed room under the deck, so the rail ends at x -3.12 (30 mm short of the deck's edge at the beam's outer side), the carriage's travel is c -3.871 -> -5.50 (AFT); the knob 0.86x toward J3, turned -2 deg (J3 window -30.25..+65.5); the upper arm's J4 moves 0.2312 along x (its housing's top stays level; J3 -> wrist centre +20 %, as proved). Proof re-run for these (`build/fit3d_proof.json`): ship >= level 9 (0.45 m), doors >= 0.316 m, joints >= 5.65 deg inside the limits. - Code: dra_rigdata (build units + bands + scale), the part builders (knob, cylinder axis, a second channel floor for the cylinder's wider swing, tool B 1.2 m with 12 bolts), dra_parts_scene (own rail beam, stops at the travel ends, 15-link chain, tray, fixtures, showroom x1.6), rig, ik, sweep, rig_check, export, surf, cycles, preview, ship install (beam appended; check with depsgraph instances; beam-under-deck test). - Work file: `DoorRobotArm_work.blend` in the model folder; DoorRobotArm.blend stays the fix-round file until all passes. - geo (32 s) and geo_audit: 0 open edges, n-gons, duplicates, crossings (ship fit too). geo_sweep found three things the fit proof could not see (a link against its own parent), all fixed and swept again (0 crossings): - J2: version A pitches the lower arm back to 37.3 deg when the door is open (the wrist centre close under the rail); the root straps' back end met the turret's back at 33 deg. The straps end 13 deg sooner (95..215 deg); free to 44.0 now. - J5: version A's wrist bends to -85.5 deg (the door's centre needs it); the finger motors met the wrist block's core and, 10 deg off the path, the cheeks. The core sits 0.065 under the cheeks' top line (was 0.035), and version A grips the round knob turned 10 deg (AFT +10, FORE -10): J6 75-84 at the deepest bends. Margin 5.5-6.5. - J3: version B's elbow (59.4 deg at the shut door) brought the truss onto the lower arm's crotch at 61.5. The knob is 0.84x toward J3 and turned -4.5 deg (the proof had 0.86 / -2): free to 70; the cylinder's stroke sets the low end (-28.75). - Limits set where nothing touches: J2 -72..+43, J3 -28.75..+66, J5 -90.5..(+120 unused); J1 +-185. - rig: 430 drivers, all simple and valid. - 2026-10-18 22:00, the user's choice (via the coordinator): "only build, check and install. No renders or extras." - rig_check (`build/rig_report_A.json`, `rig_report_B.json`; every frame 1-120, both doors): pose 0.0024 mm / 0.020 deg, 0 limit breaks, 0 crossings (arm, cables, hoses), piston in its bore (end -0.360..+0.674 m, bore -0.432..+0.800), carriage inside its travel, pads 7.4 mm off the buffers, chain 0 crossings, grip 0.90 mm, the version switch OK. One fix on the way: the piston rod's ring sat 1 mm into the barrel at B's shortest cylinder (moved against the collar). Joint margins: A J3 5.2 deg (-23.6 / -28.75), A J2 5.7 (37.3 / 43), A J5 5.0 (-85.5 / -90.5), B J3 6.6 (59.4 / 66). geo_audit 0 everywhere. - Swapped in: DoorRobotArm.blend is the new file (22:15); the old one is `versions/v21_before_scale_up/`. - TEXTURES, NOT BAKED (the user: no bake): the UV0 atlas was repacked, so the arm's materials are dressed without the baked mask and bevel maps (`DRA_NO_ATLAS=1` at the surf stage; no material uses T_DoorArm_Masks / BevelNormal). The edge wear and baked bevels are missing until a bake is run (surf without the variable, then bake). - Ship: reinstalled 22:24 (README "In the ship"); backup `models/M_Ship_v2_interior_season2_before-robot-arm-scale-up_2026-10-18.blend`; the real file was unchanged before the swap (md5). Report `build/ship_install_report.json`. - Not done (the user skipped them): FBX, LODs, layout JSON, renders, README rewrite. DESIGN.md's addendum still has the proof's knob (0.86, -2 deg) and schedule; the built ones are in design.json `scale_up` and above. ## Installed in the ship: version B (2026-10-18, the coordinator) The user: "ok now install this version of the arm to the ship, you can change the rail system with this try to fit it accordingly how I described you before" (screenshot of version B). `build/dra_ship_install.py` + `build/run_ship_install.py`, run headless (8 threads, below-normal priority) on a work copy beside the ship, swapped in after the check. Backup: `models/M_Ship_v2_interior_season2_before-robot-arm-install_2026-10-18.blend`. Report `build/ship_install_report.json`: 152 objects, 346 drivers all simple, door copies remapped; every frame 1-120 plate to pad 0.02 mm / 0.0 deg, 0 crossings against 122 ship objects. Rail boxes hidden, the arm's rail beams in their place; flush-hinge arms excluded (kept). Pictures `previews/ship_install/`. Details in README.md, "In the ship". Standalone project (the user: "this will be standalone project dont add on the ship yet"). The ship file is not touched. ## Final fix round (CRITIQUE_2): DONE (2026-10-16 21:40 - 2026-10-18 16:48) Backup of the file, every build script, STATUS and README: `versions/v20_before_fix_round/`. Order (the coordinator's): must 1 wrist wedge; should 2 lower arm core and stepped shells, 3 cable bundle route, 4 dark metal where the references show it, 5 knee caps, 6 forearm housing and dial, 7 hooks onto the knob, 8 README (appending: remap the door copies; the flush-hinge arms on the same rails); nice 10 coarser grain, 11 rail kit UCX and a convex Turret_02 hull, 12 fewer material sections in the FBX, 13 solver empties hidden (eye), a Ship fit camera. Item 9 (deeper sculpt of turret and upper arm) is left for later. Then the whole chain on the final file. ### Progress (DoorRobotArm.blend on disk stays the stage-3 file until the whole chain has passed on the new build; work files in the scratchpad.) - must 1 (2026-10-16 22:06, resumed 2026-10-18): where the tool passes over the wrist block measured with `build/dra_wrist_envelope.py` (rig path every quarter frame -> `wrist_envelope.json`, `wrist_envelope_grid.json`; the geo_sweep's own poses -> `wrist_envelope_sweep.json`). Lowest finger-motor point over the cheeks: 0.129 above the forearm axis on the path, 0.124 in the sweep poses, at x 0.88-0.96 (WC at 1.034). New wrist block in `dra_parts_wrist.py`: two cheek slabs rising 22 deg from the J5 lobe to the motor cylinder (top 0.0725 over WC, 0.243 at the back), raised panels, fin bar F10 (left) / slot plate F10r (right) on the panels, triangles on the left panel, a lower core between the cheeks, the web from x 0.855; F15 (the white cylinder on top) removed; no pocket needed (>= 10 mm to the path, >= 4 mm to the sweep poses). Side view checked (Workbench). geo_audit 0, geo_sweep 0; J5 margin at the deepest bend now 4.0 deg (was 3.0). rig_check comes with the final chain. - should 2 + 5 (2026-10-18, `dra_parts_arm.py`): the dark stack runs along the arm's front from the knee (0.02 above its centre) to below the J3 cap: the white layers are cut back 65 mm from the front edge there and three dark plates (|y| 0.42 / 0.30 / 0.19, fronts 16 / 8 / 0 mm behind the front edge) fill the strip, one plate on each cheek above the crotch; nothing stands proud. Side faces in steps with 45 deg chamfers: the knee block 14 mm over the panels, the panel between the diagonal and the back strip 12 mm under them (the front seam line is gone). The rim's inner outline now comes from the SDF (no miter spikes). Knee caps: a dark floor under the notched disc (ten notches 0.045 long, dark), toothed ring 0.165, a dark hub ring with the orange ring (no bright nut). geo_audit 0, geo_sweep 0. - should 3 (`dra_parts_turret._cables`): the band now leaves the top collar (moved to y -0.08), runs forward and down the turret's end close to it, through the white clamp T10 on the drive bracket's -y face beside the pulley, and down behind the pulley into a new gland T08g on the lower block's front; no loop out and back. >= 10 mm from the bracket, clear of belt and pulley. The old clamp over the motor is gone. audit 0, sweep 0 (J1 included). - should 4: dark metal (gunmetal; dark glass on the J3 caps' discs) on U03h, L15's disc, U11 knob + U11d dome, F04c, A03 motors, A04 / A06 caps, C03c buckle (the carriage's gunmetal renders as BlackMetal); L07h has no steel now. - should 6 (`dra_parts_wrist.build_forearm`): housing with a flat top, an R 0.11 round over the dial into a front face at x 0.52 (the motor cylinder shows between it and the wrist slab, as ref1), the belly step forward to x 0.60; the dial's groove runs up and down (two half discs), notches left and right, dark hub. - should 7: the knob's neck sized to the closed hooks: the hooks' faces reach 0.0608 from the knob axis (rig = sweep, measured), neck R 0.0603, head R 0.085 (hooks 23 mm inside its rim). rig_check gets `grip_contact` (surface gap per hook per frame, crossing test) and the four hook/knob pairs as mounts. geo_sweep grip 0. - rig_check on the scratch build (all of the above, both doors, both versions, frames 1-120): pose 0.0558 / 0.0546 mm, 0.014 deg; 0 crossings on all four arms; chains 0; fixtures follow 0.001 mm; hooks on the knob 0.45-0.54 mm at every frame, no crossing; switch OK; 604 drivers simple and valid; arm to end wall 0.2435 m (A) / 0.3209 m (B). - should 8: README's appending steps rewritten (remap the door copies, delete them, rerun rig_check; the choice between this arm and the flush-hinge arms on the same rails; the close names; the fixtures collection added). - nice 10 (`dra_surf`): the white powder coat's bump grain coarser and stronger (noise 140/m, strength 0.22, 1.1 mm). - nice 11 (`dra_export`): every hull triangulated and checked convex (rebuilt from jittered points if the hull op slips; worst error in ucx_report); the rail kits get box hulls (flanges, tray, rack, buffers). - nice 12 (`dra_export`): Cable -> Rubber and Lamp -> Glass sections in the FBX (7 sections). - nice 13 (`dra_surf.ship_view`, called by surf): the solver collection's eye off in the Ship fit scene; a camera 'Cam | Ship fit (AFT arm and door)' (studio collection) is that scene's camera; the pocket cameras stay. - Final chain (2026-10-18): the stage-3 textures, FBX files and layout are also backed up in `versions/v20_before_fix_round/`. The chain runs on `DoorRobotArm_work.blend` (beside the real file, so relative texture paths hold); DoorRobotArm.blend is replaced only when everything has passed. NOTE: the bake writes textures/ in place, so if this stops between the bake and the swap, copy the textures back from v20 for the old file. - 16:10-16:41 on the work file: build (atlas 351.8 px/m), bake (HIP, 199 s), ucx (41 hulls, worst convex error 0.058 mm), geo_audit 0 (69 meshes, A 189,931 / B 164,503 game tris), geo_sweep 0 (all joints + grip), rig_check (as on the scratch build: poses 0.0558 / 0.0546 mm, 0.014 deg, 0 crossings, hooks 0.45-0.54 mm, switch OK, 604 drivers simple), export 21 files (LOD A 191,771 / 96,802 / 39,788, B 166,343 / 84,088 / 34,714; 7 material sections; rail kit 53 box hulls), verify_fbx ALL OK. - 16:41 DONE: DoorRobotArm.blend is now the new, checked file (showroom active, relative textures). The work file went to the scratchpad. Next: Cycles renders (show, close, ship + switch sheets), compare sheets, README numbers. - 16:42-16:48 Cycles renders on the final file: all 37 in `previews/cycles/` (showroom ref1-3 both / A / B, close-ups ref4-7 and ref6A/B, ship fit frames 1/12/30/48/90 both versions both doors, the two switch sheets) and `cycles_compare_sheet.png`. About 16:52 the PC was restarted (the Coder's headless Blender runs had held the CPU at 100 %; the user: "finish this ... stop using 100% CPU use 99%"). The coordinator finished the README's numbers (FBX triangles, atlas density, the hooks' contact, the date) and added the CPU rule to its Rebuild section: run Blender with `-t 30` at below-normal priority, one run at a time. Item 9 (a deeper sculpt of turret and upper arm) is left for later. **Fix round DONE.** ## Coder stage 3: DONE (2026-10-16, 19:55-21:05) Summary (details under Progress below): - PART 1, the shape pass: the dark core as one mass, the drum shown as ref7 shows it, the turret / upper arm / wrist block rounded and layered, version A's beak fingers with ribbed sections. Real file rebuilt (backup v16). All checks 0, pose 0.056 mm / 0.014 deg. - PART 2: surfaces from real texture data with a baked 4096 atlas (AO / edges / crevices + bevel normal); 41 UCX hulls; 21 FBX files (skeletal per version with LOD1 50.5 % and LOD2 20.8 %, 4 door animations, statics with UCX, rail kits, fixtures, the chains with their animations), all re-imported and verified (ALL OK); `DoorRobotArm_layout.json`; Cycles renders in `previews/cycles/` (showroom at ref1-3 both and alone, close-ups like ref4-7, ship fit frames 1/12/30/48/90 both versions both doors, switch sheets, a comparison sheet); the light rig '90 STUDIO | lights (not part of the asset)' in the file; the file saved with the showroom active; `README.md`. - Final checks on the final file: rig_check pose 0.0558 mm (A) / 0.0549 mm (B), 0.014 deg, 0 crossings (arm parts, context, kit, chains, fixtures, curves), 0 limit breaks, pads 3.5 mm from the buffers, arm to the end wall 0.242 m (A) / 0.324 m (B), switch correct, 604 drivers simple and valid; geo_audit 0 n-gons / open edges / non-manifold / crossings (69 meshes with the hulls); geo_sweep 0 hits; verify_fbx ALL OK (21 files). - Triangles LOD0 A 187,707 / B 162,279 in the file (FBX with the cables: 189,547 / 164,119); LOD1 95,690 / 82,976; LOD2 39,342 / 34,268. - Not done: nothing tried in Unreal (import, root placement, Physics Asset, materials rebuilt there); the materials are Blender-only (table in `build/surf_report.json` and the layout json); the shells are still simpler than the sculpted reference model; the arm is not in the ship (the user's word). The coordinator's order (stage 2 accepted): PART 1 a shape pass before the bake, only these four: (1) the lower arm's dark core as one dark mass (ref5, ref1); (2) the shoulder drum shown as ref7 does (barrel and ribbed strip clearly between the side caps); (3) turret, upper arm and wrist block layered and sculpted like ref1-ref5; (4) version A's finger tips as ref6's curved beaks with ribbed sections. Then audit, sweep, rig_check, previews/geo, compare sheet. Triangle budget (the coordinator's decision): keep LOD0 as is; LOD1 about 50 %, LOD2 about 20 % at export (small parts dropped first, then reduced; the silhouette must hold). PART 2 stage 3: surf (real texture sets, UV in metres, baked AO/edge/crevice atlas), UCX hulls (hidden in the viewport), export (FBX per version with LODs, a verify script, DoorRobotArm_layout.json), Cycles renders (showroom at ref1-3 both and each alone, close-ups like ref4-7, ship fit frames 1/12/30/48/90 both versions), a light rig saved in a collection outside the asset, the file saved with the showroom active, README.md. Back up the .blend into versions/ before each rebuild. ### Progress - PART 1 scripts changed (20:00-20:25), checked in scratch files (audit 0, sweep 0, rig_check 0 crossings, pose 0.056 mm / 0.014 deg, 604 drivers simple and valid): 1. dark core: one dark mass (`CORE_MASS` 72 mm proud, half width 0.285, rounds 16 mm) with one raised face (`CORE_FACE`) carrying the bosses, in place of three thin plates (`dra_parts_arm.py`); 2. drum: the white inner shells start 0.315 m from J2 (`ROOT_CLEAR`), so the barrel with its hole rows and the ribbed strip shows between the side caps from behind; the side housings' rear ends are now an arc round the J2 cap (R 0.185, top Z 0.70 as ref1 measures), the drum stands 0.06 above them (ref7) (`dra_parts_turret.py`); 3. shells: turret housing rounds 26 mm (was 10), its panels set inside them, a lid on each cheek's top, a skirt ledge at its foot; upper arm rounds 32 mm (was 18) with a raised lid along the top under the spine; wrist block rounds 14-20 mm (was 4-10) and a stepped side panel kept out of the finger motors' sweep (`dra_parts_wrist.py`); 4. fingers (A): the distal links are curved beaks (centre line bowed outward, tapered 40 -> 14 mm, an oval slot, bored for their pin, the hook unchanged); the proximal's ribbed section is nine flat rib plates (ref6). Previews: ref5 now uses the critique's matched camera (front-left, from below). Triangles: A 187,707, B 162,279. - 20:05 the real file rebuilt (`versions/v16_before_stage3_shape/` holds the one before). Checks on it, all pass: rig_check (both doors, both versions, frames 1-120): pose 0.056 mm (A) / 0.055 mm (B), 0.014 deg; 0 crossings, 0 curve crossings, 0 limit breaks; pads 3.5 mm from the buffers; arm to end wall 0.242 (A) / 0.324 m (B); chains 0 crossings; switch correct; 604 drivers simple and valid; fixtures 0.001 mm. geo_audit 0 (n-gons, open edges, non-manifold, crossings); geo_sweep 0 hits. previews/geo re-rendered, `geo_compare_sheet.png` remade (now built by the preview stage itself). **PART 1 DONE.** - Next: PART 2 (surf, UCX, export with LODs, verify, layout json, Cycles renders, light rig, README). - 20:15-20:30 PART 2 step 1, surfaces (`build/dra_surf.py`, stages `surf` and `bake`). Fetched with curl into `source_polyhaven/` (manifest there; CC0): `blue_metal_plate` (2K, 4 maps, 4.2 MB) and the studio HDRI `studio_small_09` (2K, 6.3 MB, renders only). On the real file (backup `versions/v17_before_surf/`): one UV0 atlas for the 20 arm meshes of both versions (one texel density, 357 px/m, concave pack), materials dressed (white powder coat, orange, gunmetal, black metal for the carriage, bright steel, rubber, glass, lamp; kit and cable variants), the ship context's missing images given stand-in colours, the light rig '90 STUDIO | lights (not part of the asset)' saved in the ship-fit scene; the file saved with the showroom active. Bake (HIP GPU, 128 s): `textures/T_DoorArm_Masks.png` and `textures/T_DoorArm_BevelNormal.png` (4096). After any rebuild run `surf` then `bake` again. - 20:30 step 2, UCX (`build/dra_export.py`, stage `ucx`; backup `versions/v18_before_ucx/`): 41 convex hulls for the 20 links (k-means clusters of each link's vertices, at most 96 extreme points each, 23-93 vertices), parented to the showroom's link objects, collection `DoorArm | collision` with its eye off and hidden in renders. - 20:35 step 3, export (stage `export`, nothing saved) into `fbx/`, 21 files: SK_DoorRobotArm_A/B with _LOD1/_LOD2 (A 189,547 / 95,690 / 39,342 tris = 100 / 50.5 / 20.8 %; B 164,119 / 82,976 / 34,268), the door animations A_DoorRobotArm___OpenClose (frames 1-120), SM_DoorRobotArm_Links (20 statics + 41 UCX), the rail kits, fixtures (with UCX), and the energy chains (SK_DoorArm_Chain_ + their animations, 45 bones). `DoorRobotArm_layout.json` written. Verify (stage `verify_fbx`, `build/fbx_report.json`): ALL OK (bones, meshes, triangles, materials, UCX, bounds within 0.1 mm, skeletal files in cm with no scale on any node, animations 1-120 with the bones moving 5.1-6.3 m). - 20:40 the re-import showed the skeletal files' default pose was not their bind pose (the exporter read the pose before Blender re-evaluated the turned and scaled rest, so the mesh folded up on import). Fixed (`settle()` before writing); the verifier now checks the deformed mesh and the default pose too: ALL OK, default pose = bind pose (0.0). `previews/lods_A.png`, `lods_B.png`: LOD0 / LOD1 / LOD2 side by side from the re-imported files; the silhouette holds. - 20:45 `README.md` written (what it is in the user's words, opening and switching, scale and pivots, the rig, the rail, checks, textures and licences, FBX and LODs, what is not done, appending it to the ship later). - 20:50 step 4, Cycles renders (`build/dra_cycles.py`, stage `render`) into `previews/cycles/`. The first set showed the whites too clean and smooth (plastic) beside ref2/ref3 and the studio flat: a look pass in `dra_surf.py` (grey-white with the scan's scuffs, stronger relief and orange peel, a fine grain, satin roughness, more shade in crevices, a few more edge chips; the studio's fill and HDRI lower, the backdrop mid grey, `studio_look()`), then surf + bake again and the renders again. The atlas is now packed once per build (`atlas_packed`), so a later surf keeps the bake valid. - 21:00 look pass applied to the real file (backup `versions/v19_before_look_pass/`): surf (atlas packed again, flagged), bake again (134 s), then a visible powder-coat grain and faint smudges (surf again, the atlas kept). The close-up next to ref2 now reads as a satin grey-white powder coat with grain, not plastic. Final Cycles set rendering. - 21:00 final Cycles set done (37 pictures incl. sheets); the ref2 view showed the studio HDRI past the backdrop's edge: the world now lights with the HDRI and shows the camera a plain grey (`studio_look`, saved in the file), the showroom views rendered again. Final rig_check, geo_audit, export and verify_fbx on the final file (numbers in the summary above). `previews/cycles/cycles_compare_sheet.png`. **Stage 3 DONE.** - 21:05 the surf stage now stores every texture path relative to the file (checked: the scan, the HDRI and the baked maps load from `//source_polyhaven/...` and `//textures/...`); the file opens in the showroom, the collision collection has its eye off, the light rig is in the ship-fit scene, CONTROLS version 0 (A) and grip 1. ## Coder stage 2 (fixes, rig and fit): DONE (2026-10-16, 17:50-19:50, two power cuts on the way) Backup of the file and every build script before any change: `versions/v14_before_stage2/` (DoorRobotArm.blend, build/*.py, STATUS.md). The stage-1 file before the final build: `versions/v15_stage2_rig/`. ### What the file holds now (`DoorRobotArm.blend`, 19:33, made by `--stage build`) - Scene `DoorArm | Ship fit` (opens there, frame 1, version A shown): four arms `DoorArm_AFT_A`, `DoorArm_AFT_B`, `DoorArm_FORE_A`, `DoorArm_FORE_B` (root empties under the rails, turned 180 deg about x), in the collections `DoorArm | version A` / `DoorArm | version B` with their door fixtures and cable/hose curves; solver empties in `DoorArm | solver (hidden)`; `DoorArm | controls` holds `DoorArm | CONTROLS` with `version` (0 = A gripper, 1 = B plate) and `grip` (0 open .. 1 closed on the knob, default 1). Rail kits and the two 44-link energy chains in `DoorArm | rail kit`. Nothing is keyed: 604 drivers, every one a simple expression, all reading only the doors' location (the doors keep their own actions, frames 1-120). - Scene `DoorArm | Showroom`: both versions upright side by side on the floor rail, at rest (no drivers). - To switch versions: select `DoorArm | CONTROLS` and set its `version` property (Object properties, Custom Properties) to 0 or 1. A hidden version is not evaluated, so its objects keep old transforms until it is shown again; the export stage must switch `version` before it exports each version. ### Checks (all pass) - `build/rig_report.json` (frames 1-120 step 1, both doors, both versions; rig_check, 131 s): - pose of the end against the door: position 0.056 mm (A) / 0.055 mm (B), angle 0.014 deg (single precision); - 0 crossings: every arm object against every other one, against the context (deck, both rails, both end walls, hull lining, basin channel, aperture rim, both lamps and housings, both doors), the rail kit, the chain links and the fixtures; each arm's 4 curves (two elbow cables, two cylinder hoses) against the arm (except at their glands) and the context; - joints inside their limits (0 breaks). A: J1 32.7..82.4 (FORE 97.6..147.3), J2 -52.9..9.8, J3 -24.4..29.1, J4 -52.5..-10.8, J5 -74.4..-40.0, J6 11.5..52.3. B: J1 41.5..84.5 (FORE 95.6..138.5), J2 -60.4..-3.4, J3 -13.6..42.2, J4 -47.9..-7.6, J5 -66.4..-42.0, J6 8.0..49.1 deg (FORE mirrors J1, J4, J6); - J3 cylinder length A 0.716..1.245, B 0.591..1.147 m; piston end in the bore (-0.270..0.500): A -0.084..0.445, B -0.209..0.347; - carriage inside its travel (AFT -8.116..-3.014, FORE 9.114..14.216); strike pads 3.5-3.6 mm short of the buffers at both ends; carriage body 40 mm short of the rail's inner end; the arm to the pocket's end wall at least 0.243 m (A) / 0.324 m (B), the elbow cap at frame 48; - lowest clearances that are not a joint's own gap: chain bracket to the deck 6.5 mm, elbow cable to the looped hose 8.6 mm, J3 hose to the channel rungs 9.3 mm, A's hooks to the knob 12.5 mm, B's plate to the door 14.5 mm (the pad between, plate on pad by design), A to the door 110 mm; lining, basin channel, rim, lamps, end walls > 0.20 m; - joint gaps (running clearances by design): rollers on the rail 0.5-0.7 mm, trunnion stubs 0.5 mm, pins in eyes 1.2 mm, pinion in the rack 1.2 mm, rod in the barrel 1.4 mm, slewing ring 2 mm, wrist head in the cheeks 4.4 mm; faces in contact by design: tool on flange, plate on pad; - energy chains: 0 crossings (links with their neighbours, links with the tray), spacing 0.78 mm off the pitch on the bend (the chord), lowest to the tray 3.6 mm; door fixtures follow the doors to 0.001 mm, 0 deg; - version switch: 84 objects, A shown / B hidden, then B, then back to A, viewport and render: correct; - drivers in the saved file: 604, all `is_simple_expression` and `is_valid`. - `build/geo_report.json`: 0 n-gons, 0 open edges (markings apart), 0 zero-area, 0 duplicate faces, 0 non-manifold edges; 0 crossings within links, between the showroom objects, in the ship fit (rail kits, chains, fixtures, per version) and for the curves. Triangles (LOD0): arm A 184,311, arm B 161,139 (design budget 151,500 / 137,500: over by 22 % / 17 %, the critique's added detail); 85.7 % of arm A's faces are quads. Per mesh: lower arm 48,242, turret 37,870, carriage 24,980, upper arm 19,112, forearm 17,515, tool A hub 9,296, fingers 4 x (2,572 + 1,648), J3 cylinder 4,176, tool B 3,004, flange 2,112, piston 2,016, wrist head 1,440, pinion 672; rail kit 11,500 each, chain link 352 (x 44 per rail), fixture A 2,172 / B 672. - `build/geo_sweep.json`: 0 hits for both versions. Ranges = each version's door path +-3 deg (from `dra_ik.py`), J1 the whole circle, J3 with the cylinder and piston, J5 with J6 as the rig moves them, the grip closed on the knob. Information: J5 with J6 at 0 bends freely to -72.5 (A) / -77.5 (B); at the deepest bend (-74.4, A) J5 has 3 deg to spare with J6 on the path, about 0 if J6 were also 10 deg off it. ### Pictures - `previews/rig/` (Cycles, 96 samples, 1280 x 720, quick look; lights and cameras in the collection `DoorArm | render lights (not exported)`, made in the render session only; the ship's door material, whose images were already missing in the ship, gets a plain stand-in colour): `rig___f<001|012|030|048|090>.png` (one camera per frame for both versions, inboard under the deck), strips `rig___strip.png`, the switch `rig_switch_AFT.png` / `rig_switch_FORE.png` (A row over B row, same cameras), close-ups `rig_gripA_closed_on_knob.png`, `rig_plateB_on_pad.png`. - `previews/geo/` re-rendered from the final file: ref1 (and the overlay), ref2-ref5, ref6A/ref6B with ref6's camera, ref7 with the lower arm stood upright as in ref7, both, the ship views (now with the arms), the grip closed on the knob from the real meshes (CRITIQUE_1 item 11), and `geo_compare_sheet.png` (each reference beside its view). ### Compared with the references (honestly) - Done as CRITIQUE_1 asked: version B's short cone neck and plate (as the red sketch, ref6); the turret's long side housings with the J2 caps set in their rear ends, caps at |Y| 0.40, lower block in three tiers 0.60 wide; the perforated drum showing behind the caps (ref3) with the ribbed strip between the root straps; the forearm's rounded housing round the dial and the one-slope wrist wedge, J5 caps 0.19; curved, layered shells with raised rims and panels; the knee cap's size and notches; truss pockets, dark rod with collars, knurled knob with a dome; the sprocket and lug belt; the flat cable band; two cable loops and the looped hose; the flat-plate buckle; 0 non-manifold edges. - Still different: the lower arm's dark core reads as three stacked thin plates, not ref5's black mass; from behind, the turret cheeks hide more of the drum than ref7 shows; the turret, upper arm and wrist block are boxier than the sculpted references; the finger tips are not ref6's curved beaks (CRITIQUE_1 item 12, a "nice", not done). ref2 and ref3 turn the turret on a fixed rail, the previews move the camera instead. ### Not done (stage 3, the next Coder) Stages `surf` (real texture sets, bake), `export` (UCX hulls, FBX, layout json), `render` (Cycles beauty renders) and the README: `dra_build.py` has the stage table ready for them (`main()`). The triangle budget is a decision for the Designer/Critique (accept 184k / 161k or cut). ### History of this stage Plan: (1) fix CRITIQUE_1 must + should items in the geometry, (2) rig stage in `dra_build.py`, (3) version switch, (4) rig check -> `build/rig_report.json`, (5) renders -> `previews/rig/`. Decision on version B (critique item 1): neck 0.13 m (cone dia 0.154 -> 0.26), plate 0.55 x 0.55 x 0.044; its wrist centre is 0.326 m off the door face (A stays 0.63). So B has its own pose: B's IK ranges (closed form over the door path, AFT): J1 41.8..84.5, J2 -60.6..-3.8, J3 -13.2..42.7, J4 -47.8..-7.5, J5 -66.2..-42.0, J6 7.9..49.0 deg (A: J2 -52.9..9.8, J3 -24.4..29.1). Each door gets one arm per version (four arms), one control switches them. ### Power cut at about 18:47; a new Coder carries on (19:00) - What the cut left: `build/rig_drivers.json` was empty (zero bytes); the scratch files of the last minutes are not trusted and are made again. All `build/*.py` compile; the scripts changed last (render, sweep, arm, turret, wrist, base, audit) were read through and are complete. `DoorRobotArm.blend` is still the stage-1 file (16:56). - Plan from here: build geo + rig in a scratch file, rerun geo_audit, geo_sweep and rig_check, fix what fails, then back up and build the real file, check it, render. - 19:00-19:45, in scratch files: geo, audit (clean), rig (604 drivers, all simple and valid), rig_check (A and B, both doors, every frame: 0 crossings, pose 0.056 mm / 0.014 deg). The sweep with each version's real ranges (+3 deg) failed in two places, both fixed: - J3 at +45 deg (version B needs 42.2): the J3 barrel's gland (r 0.047) reached the truss plates (inner faces at |y| 0.040). The plates' inner faces moved out to |y| 0.052 (spacers on the knob pin longer); the truss looks the same from outside. (`dra_parts_arm._truss`) - J5 with J6 held at 0: the top finger's motor meets the wrist wedge at -73 deg (A needs -74.4, but the door path has J6 at 45-52 deg there; the wedge is shaped for that). The sweep now turns the wrist as the rig does: J5 past the path's ends at the path's J6, and J6 +-10 deg along the path (one margin at a time). Both pass. Reported as information: J5 alone is free to -72.5 (A) / -77.5 (B); at the deepest bend J5 has 3 deg to spare at the path's J6, about 0 if J6 were also 10 deg off the path. New: `build/dra_ik.py` (the closed-form IK in plain Python, for the sweep). The rig check now also measures the carriage's end gaps, the arm to the end wall, the energy chains, the fixtures following the doors, the version switch and recounts every driver in the saved file; clearances are split into joint gaps and all others. The ship-fit renders frame each shot on both versions' arms and the door round the hold (camera inboard under the deck); ref6 previews use the critique's ref6 camera; ref7 stands the lower arm upright as ref7 shows it. - 19:33 the real file: `--stage build --name stage2_rig` backed up the stage-1 file to `versions/v15_stage2_rig/` and built geo + rig into `DoorRobotArm.blend` (604 drivers, all simple and valid, `build/rig_drivers.json`). - 19:35 checks on the real file, all pass: `build/rig_report.json` (both doors, both versions, frames 1-120 step 1), `build/geo_report.json`, `build/geo_sweep.json`. The audit's ship-fit part now skips the rigged arms (the rig check's job) and checks each version's fixtures with that version switched on: a hidden version is not evaluated, so its objects keep stale transforms until it is switched on (the export stage must switch versions too). - 19:36 a second power cut; after it all scripts and reports were read back and are complete. The stray empty file `ship` (18:57, made while this session read the files) was moved out to the scratchpad. - 19:41-19:50 renders into `previews/rig/` and `previews/geo/` (see Pictures above); this note marked DONE. ### Progress (17:50 -> 18:47, before the cut) - Geometry fixes written (scripts only; the real .blend is not rebuilt yet, iterations go to the scratchpad): item 2 turret rebuilt in a new module `build/dra_parts_turret.py` (long side housings X -0.50..+0.515, Z 0.345..0.742, cheeks |Y| 0.215..0.30 round the drum, J2 caps faces at |Y| 0.398, three-tier lower block 0.60 wide); item 3 drum 0.40 long with a bulge, 2 x 32 barrel holes + 2 x 32 side holes, root straps + ribbed strip on the lower arm (`_root_band`); item 5 lower arm S-curved front edge, raised rim, 16 mm panel steps, three stacked dark core plates; upper arm convex top, dark lower strip, raised panels; item 6 knee cap 0.41/0.30 with round-ended notches and a castellated ring; item 7 truss with rim and five pockets, dark rod dia 0.058 with collars, knurled knob with a dome, bore deepened to -0.270 (B's shortest cylinder length 0.591); item 8 belt drive (sprocket + wide lug belt inboard of the white motor) and a flat seven-cable band with clips; item 9 two different cable loops + the looped hose on the gland; item 10 buckle of flat plates with pin bosses; item 4 forearm housing round the dial, keyhole dark plate, wrist block silhouette one 20 deg slope (central wedge |y| <= 0.085; cheeks stay low because the side fingers' motors sweep there at q5 -68..-74), J5 caps dia 0.19; item 1 tool B neck 0.13 m cone. - Rig written: `build/dra_rig.py` (stage `rig`, or `build` = geo + rig), check `build/dra_rigcheck.py` (stage `rig_check`). First full checks (scratch file): 604 drivers, all simple and valid; A and B, both doors, every frame: 0 crossings, pose error 0.056 mm / 0.014 deg, joints inside limits, carriage inside its travel, piston in the bore. - Audit (scratch): 0 n-gons, 0 open edges, 0 non-manifold (now in the summary), 0 crossings within links, between objects, ship fit, curves. Triangles A 184,311 / B 161,139 (design budget 151,500 / 137,500: over by 22 %, the critique's added detail). - Next: geo_sweep with the new ranges, the render stage (`build/dra_render.py`), the final build into DoorRobotArm.blend, the final rig_check into build/rig_report.json, previews. ## Design stage: DONE (Designer, 2026-10-16) `DESIGN.md`, `design.json` (made by `build/design_make_json.py`), proof scripts `build/design_*.py`, `build/check_*.json`, `build/proto_*.json`, posed proxy pictures `previews/design_pose_AFT_A_*.png`. ## Coder stage 1, geometry: DONE (2026-10-16) Entry point `build/dra_build.py`, one stage per headless call (each takes seconds): "E:\Steam\steamapps\common\Blender\blender.exe" -b --factory-startup --python build/dra_build.py -- --stage geo ... -- --stage geo_audit -> build/geo_report.json ... -- --stage geo_sweep -> build/geo_sweep.json ... -- --stage geo_preview -> previews/geo/geo_*.png (Workbench; --views ref1,ref2,... to pick) `--stage geo` backs up `DoorRobotArm.blend` to `versions/vNN_/` first (`--name` names it). `versions/v01..v13` are this stage's intermediate states (the file is rebuilt by script; they can go when the user wishes). Stage 2 added `rig`, `build`, `rig_check`, `rig_render`; `surf`, `export`, `render` are still to come (stage 3). ### Modules (`build/`) - `dra_lib.py` primitives (lathe, rbox with real bevels and recessed/raised panels, slab with quad caps, tube, knurl, star_slab, holed_surface with real blind holes, outlines from signed distances by marching squares), the `Link` builder (every piece has a part id and the parts it may sit in), `finish()` (mesh, origin on the joint), `uv_tile()`. - `dra_shapes.py` small shapes (screws, hex bolts, domes, holed plates, gears, notched discs, slotted heads, boots...). - `dra_rigdata.py` the links table (name, parent, joint point in arm frame A, builder, tool A/B), finger joint points, and `instantiate(collection, prefix, root_matrix, meshes, tools)` which makes one arm's object hierarchy at rest. **Stage 2 should use it for the AFT/FORE arms** (root matrix = translation (c, -5.795, -4.182) @ rotation 180 deg X). - `dra_parts_base.py` carriage, carriage pinion (its old turret is unused: stage 2 moved the turret to `dra_parts_turret.py`). `dra_parts_arm.py` lower arm, J3 cylinder, J3 piston, upper arm, and `add_curves()` (cable pair over the elbow, two cylinder hoses: Bezier curves parented to the lower arm). `dra_parts_wrist.py` forearm, wrist head, flange, tool A hub, 8 finger links, tool B. `dra_parts_scene.py` showroom, rail kits, chain links (placed with the design's chain driver expressions at frame 1), door fixtures (conformal pads ray-cast onto the door). `dra_audit.py`, `dra_sweep.py`, `dra_preview.py`. ### The file `DoorRobotArm.blend` - Scene `DoorArm | Showroom`: `Showroom | arm A` (gripper, fingers open) at x -1.9 and `Showroom | arm B` (plate) at x +1.8946 (151 rack teeth from A, so both pinions mesh), turntable face at z 1.012, on `Showroom | floor rail` (the ship rail turned over with flanges and rack, on posts); cyclorama, three area lights, world grey. Collections `Showroom | arms` (`... | arm A`, `... | arm B`) and `Showroom | studio`. Objects `Showroom | arm A | `, all at rest: rotation 0, scale 1, origins on the joints (custom property `link`, `version`). - Scene `DoorArm | Ship fit` (frames 1-120, 30 fps, markers CLOSED / RETRACTED INBOARD / OPEN / CLOSE): `00 CONTEXT | from the ship (reference, not part of the asset)` (19 objects copied from `source/ship_context_2026-10-16.blend` with the doors' actions; the user's placeholder carriages hidden; every object has `reference_only`), `DoorArm | rail kit` (`DoorArm_AFT | rail kit`, `DoorArm_FORE | rail kit`, chain trays and 2 x 44 `chain link NN` at frame 1, linked duplicates of `DoorArm | chain link`), `DoorArm | door fixtures` (`DoorArm_ | door fixture ` at the closed doors, origin on the attach point, rotation 0, property `version` and `attach_local`). No arms in the ship and no drivers yet (stage 2 added them, see above). - Meshes `DoorArm | ` (one per moving link, several material slots), shared by both showroom arms. Every mesh stores `parts`, `seats`, `decals` (per part id) and `joint_A`; the upper arm and lower arm store `gland_U08` / `gland_L17` (cable ends, link coordinates). - Materials `M_DoorArm_PaintWhite, _Gunmetal, _Steel, _Rubber, _Orange, _Glass, _Lamp`: plain colours now (stage 3 dresses them). Markings are thin floating geometry (0.4 mm proud) in `M_DoorArm_Orange`, no text anywhere, so no decal atlas is needed (the design's `M_DoorArm_Decals` is not used). - UVs on every mesh: UV0 `UVMap` (smart project per mesh; the bake repacks them into one atlas), UV1 `UV_Tile` (box projection in metres). ### Checks (all pass) - `build/geo_report.json`: 0 n-gons, 0 open edges (except on the floating markings, counted apart), 0 zero-area faces, 0 duplicate faces, 0 non-manifold edges; crossings in the rest pose: 0 between parts inside a link (a part may sit 1-2 mm in its declared seat), 0 between the objects of each showroom arm and the floor rail, 0 for the cable/hose curves (ends in their glands), 0 in the ship scene (rail kits, chains, fixtures against each other and the ship context). - `build/geo_sweep.json`: each joint turned through more than the door animation's range, others at rest, real meshes: J1 -180..180, J2 -58..+15 (needs -53..+10), J3 -30..+35 (with the cylinder turned and the piston slid as the rig will), J4 -60..60, J5 -80..+5 (needs -74.4..-40), J6 -60..60, and the grip closed 0..1 with the door's knob fixture on the tool axis: 0 crossings for both versions. Closed, the hooks wrap behind the knob's head 13 mm clear (`previews/geo/geo_gripA_closed_on_knob.png`). This is not the rig's check: stage 2 still runs all joints together along the real IK path. ### Triangles (LOD0, stage 1; stage 2's numbers are in its section above) Arm A (gripper) 159,075, arm B (plate) 136,479 (design budget 151,500 / 137,500). Arm A: 73,395 quads and 12,285 triangle faces (86 % of the faces are quads, 0 n-gons). | mesh | tris | quads | tri faces | |---|---|---|---| | lower arm | 35,586 | 16,477 | 2,632 | | turret | 31,890 | 14,814 | 2,262 | | carriage | 23,324 | 10,782 | 1,760 | | forearm | 16,499 | 7,502 | 1,495 | | upper arm | 16,144 | 7,300 | 1,544 | | tool A hub | 9,296 | 4,160 | 976 | | J3 cylinder / piston | 4,176 / 1,056 | | | | tool B | 3,580 | 1,562 | 456 | | each finger proximal / distal (x4) | 2,572 / 1,648 | | | | flange / wrist head / pinion | 2,112 / 1,440 / 672 | | | | rail kit (each) | 11,500 | | | | chain link (x 44 per rail) | 352 | | | | door fixture A / B (each door) | 2,172 / 672 | | | Triangle faces come from fans at the poles of turned parts, the two ends of column-filled caps, non-convex flat caps (triangle fill joined back into quads where possible) and where a loop cut meets a bevel. ### Changes to the design made in the geometry (and why) - Shoulder: drum dia 0.49 (design 0.594): a 0.594 drum on J2 cuts 22 mm into the turret's front housing (its back face is 0.253 from J2). The white ring round the drum in ref1 is a fixed collar on the turret (r 0.252..0.302); the ears are motor pods within 0.27 m of J2 (ref1's pods are that size), caps scaled to ref1 (bezel 0.24, design 0.363); the housing's back moved 8 mm forward. - Lower arm in layers: a narrow beam (inner shells |y| 0.075..0.175 round a dark core and the cylinder's channel) from the drum to the crotch; wide outer shells (|y| 0.17..0.451; cheeks 0.275..0.451 above the crotch) only beyond 0.40 m from J2, so the arm can lean 58 deg forward past the housing and the pods (the door needs 53). - J3 cylinder: middle trunnion = collar with two stub pins in bosses on the channel walls (no pin through the barrel); the barrel has a blind bore the rod slides in. Knob pin 0.046 (the design's 0.11 is larger than the eye's 0.05 bore). Channel floor drops from 0.095 to 0.150 under the rod axis beyond the knee (the cylinder turns 5.2 deg toward it). - Carriage: channel ceiling at the top plate (z -0.044) so the pinion fits over the rack; motor along y beside the pinion (the design's dia-0.12 motor did not fit); side guide rollers run on the rail's side faces; strike pads 5 mm proud (5 mm short of the buffers). The pinion (module 8, 10 teeth, one tooth pointing at the rack at rest) is its own object `DoorArm | carriage pinion`: **stage 2 must turn it with the carriage** (rotation about its axis = carriage travel from frame 1 / 0.040 m, sign so the teeth roll along the rack) to keep it in mesh. The ship racks are phased so it meshes at frame 1 (c = -3.0143 AFT, 9.1143 FORE). - Wrist: head drum r 0.090 (design 0.1045, it reached the flange's knurl); knurl x' 0.0925..0.121, flange face 0.121..0.132. Wrist block body stops 0.198 behind WC (the design's proof proxy); its middle slice (|y| < 0.046) is cut back at the front top where the top finger's motor passes at q5 -62..-80 deg. Fork cheeks (lobes R 0.120) and two wedge blocks (|y| 0.088..0.163) carry ref1/ref6's sloping top; their top line keeps clear of the hub to q5 -80. Finger drive motors dia 0.052, 0.08 long, on the design's line 0.051 from the knuckle (clear of the finger's eye). - Fixture A: stem dia 0.06 (the finger proof used 0.06; the parts list said 0.08). Pads sit 0.5 mm off the door face. - Showroom rail at z 0.505..0.840 (the design's 0.25..0.585 put it under the carriage; the carriage wraps the rail's top 0.255 m as it does in the ship). - Energy chain links are joggled (outer plates on one half, inner plates on the other) so neighbours overlap without touching on the bend; the fixed-end bracket sits past the last link at frame 1. ### Compared with the references (`previews/geo/geo_compare_sheet.png`, ref1 also as `geo_ref1_overlay.png`) In the ref1 overlay (same scale and origin) the joints lie on the reference's joints; the shells did not (CRITIQUE_1 items 2-6 and 9, reworked in stage 2). ref2-ref7 matched in parts and layout. What I could not match, honestly: - The references are dense subdivided render models with layered, sculpted panels; mine are bevelled quad shells with real grooves and raised panels, closer to a game asset. The turret's lower block, the upper arm's hump and the forearm's dial housing are simpler and boxier than in the pictures. - Kinematics win over looks in three places: the drum is smaller and the shoulder ring is a fixed collar; the lower arm's wide shells start 0.40 m from J2 (ref1 shows the white shells nearer the drum); the wrist block is a narrow body with cheeks and side wedges, not ref6's full-width wedge (a full wedge would be hit by the top finger's motor at the door's wrist bend). - The rail of ref1-3 is a thin square tube; the showroom rail is the ship's rail (0.458 x 0.335) with the added running flanges and rack, because that is what the carriage rides in the ship. - Fine reference glyph text is replaced by abstract chevrons, dots and stripes (no text by rule). ## Next (stage 2, rig): done in stage 2 (section above) - Make `DoorArm_AFT` / `DoorArm_FORE` with `dra_rigdata.instantiate()` in the Ship fit scene; solver empties and drivers from `design.json` "drivers"; pinion driver; fixture location drivers (the fixtures already carry `attach_local`); chain link drivers (objects exist, named as in the design); version switch (`DoorArm | CONTROLS`); hooks on the curves made by `dra_parts_arm.add_curves()`; the rig check (all joints along the IK path, every frame). ## Critique 1 of the geometry stage: DONE (Critique, 2026-10-16) `CRITIQUE_1.md`: 5 must, 6 should, 1 nice. Extra views, side-by-side crops and the read-only check scripts are in `previews/critique1/` (the .blend was not saved). Must: (1) version B's neck is 0.434 m, ref6's sketch shows about 0.10-0.15 m (B then needs its own IK offset); (2) turret front housing is a box and the J2 caps sit on pill-shaped pods, ref1-4 show one long side housing ending round each cap, and the shoulder is about 40 % wider than ref7; (3) the perforated drum and its ribbed strip are hidden; (4) forearm and wrist block are boxes, ref1/ref6 show a rounded housing and one sloped wedge; (5) upper and lower arm are straight-edged plates with groove lines, the pictures show curved, layered shells. Also: the forearm has 14 non-manifold edges (F09), not 0. Next: fix the must items (the Designer for item 1's IK offset), rerun geo_audit and geo_sweep, then stage 2. (Done in stage 2: every must and should item; the nice item 12 is not done.)