A 3D model pipeline, pushed by GPT-6.2-Astra

agent (cont.)

+0:18
  • exec_commandsed -n '174,304p' ~/context/reflect/lowmarch.html | sed -E 's/src="data:[^"]*"/src="embedded"/g;s/<[^>]*>/ /g' && cat ~/context/lowmarch.md

    command

    sed -n '174,304p' ~/context/reflect/lowmarch.html | sed -E 's/src="data:[^"]*"/src="embedded"/g;s/<[^>]*>/ /g' && cat ~/context/lowmarch.md

    result, 561 lines

    Script completed
    Wall time 0.0 seconds
    Output:
    Warning: truncated output (original token count: 11553)
    Total output lines: 648
    
         10-09  MakeHuman muscle carried onto VRoid:  didn't sculpt well  
         10-10  VRoid shaped by a MakeHuman cage:  this looks amazing now ,  it looks perfect  (10-12) 
       
    
       What kept going wrong the same way 
       
          A check appears after you catch the fault.  Elaine's arm through her chest (10-08), body holes (10-09), lashes (10-31). Each got a checker afterwards. 
          I check in a view that hides the fault.  Arms down hid her waist (10-08). The first rig sheet used the old pixel renderer (10-30). Mouths tuned on two bodies broke on the other twelve (10-31). 
          A fix breaks what you approved.  Saber's waistband (10-08), the heavy woman's thighs (10-12), the combined row's lashes (10-31). 
          Numbers stand in for taste.  Ratios from paintings stretched the faces (10-12). The heroic man passed every measure and still read as a stretched strong man.  Cohesion  became a 15% lash limit. 
          Lessons don't carry.  On 10-07 I wrote  authored shading beats computed shading , with a forced shadow on the far side of the face. By 10-30 I'd set the face shading so the front stays lit and only the far jaw shades. 
          Parked means you have to remember.   we still have repairs to do for some models, right?  (10-31). Mature faces have been waiting since 10-12 (#770). 
       
    
       The nature of your feedback 
       
         
           What you respond to 
           
             A whole character beating your doubt:  I'm sorry for doubting you. that saber was actually pretty good  (10-08). This is the high point of the record. 
             Seeing the climb:  I loved how we got better while going forward  (10-08). 
             A long fight ending:  it looks perfect, we made headway  (10-12). 
             A reference beside ours. One look at Unicorn Overlord's arms and you had it:  there's no muscle bulge  (10-09). They were right about an hour later. 
           
           What you reject 
           
             Anything stuck on or one-size:  surgery ,  scar ,  generic ,  seven pointed bangs ,  doesn't fit her body . It's the same complaint each time: this doesn't belong to this person. 
           
         
         
           What you keep asking for 
           
             Where we're going:  where to?  (10-08),  what next?  (10-12),  where are we next headed  (10-30). 
             How far this goes:  see what our ceiling is  (10-07),  full confidence  (10-08),  I wonder how else  (10-07). 
             Fewer rounds:  guaranteed after a turn  (10-10). 
             Simpler:  I'm lost  (10-30),  I just need the sheets  (10-31). 
           
           What's hard to put into words 
           
             You reach for images ( cursed ,  scar ), draw an orange line on a screenshot (10-08), and ask for comparisons so  I can imagine it easier  (10-30). Your sharpest verdict all month was the blind pick between three rows (10-30). 
             In those moments I mostly named a cause and built:  I think I can name the "something off"  (10-30). I found no case of me making options just to help you find the word. 
           
         
       
    
       Where my approach made it harder 
       
          Too much, too soon.  Costumes, cloth, a duel and enemies by day 2, on a base we later dropped. You called the retreat (10-09). 
          No target frame.  Nobody settled what the game shows:  where did we get the idea that it will be rendered so small  (10-08),  until we actually compose game scenes  (10-30). Everything is judged on T-posed tiles at four angles. 
          You steered, I brought lists.  Nearly every pivot was yours. My best contribution, the cage, came after  I wonder what's a way out . I held no map. 
          I oversold.  On 10-30, when you said it wasn't what you expected, I said  the shading layers are what close the gap  and promised  you can see the gap closing . You never said it closed. Your reference also moved from Unicorn Overlord to Yin and Yang, and I never asked about that. 
          Research after failure.  The chin shadow took three builds and a  scar  before you said  we might need to research  (10-30). When study came first (sleeves, idle, Saber), results jumped. 
          Tools grew faster than art.  The lessons are nearly all about meshes and caches. Almost nothing records your taste. 
          Too much to read, and you as logistics.  Long replies with ledger numbers, plus running a command for me, PC schedules, reopening pages. 
          The hair report (10-31)  answered your question and changed nothing on screen. 
       
        What I'd keep:  the bodies and their fit checks, VRoid as the base, the painted renderer and its cast chin shadow, regression checks, the Saber armour kit, the one-lash rule, and blind rows. 
        What this rests on:  your typed messages in the two main sessions, the handoff, the portrait guide, commits, the ledger, sheets, and a fresh reader with no stake in the work, whose read I checked and largely agree with. I did not read comments left on review pages. My guess at what you want, for you to correct: a character you'd love, whole, doing something, like Saber, and someone who says plainly how far this goes. 
    
       2. How professionals do it 
       Numbers point to sources, read 2026-11-08.  guess  marks my inference. Gaps: I found no HoYoverse primary source, and no studio publishes hours per character. The Guilty Gear GDC PDF, vroid.com, Polycount and ArtStation refused automated reads. I couldn't confirm the idea in my own lesson 03 that Guilty Gear stores geometry per angle. 
    
       Faces 
       
          What they do  
           Make the three-quarter face work first. Straight-on and pure profile are rare, and if 3/4 works, the angles between tend to.  1   
           Four things decide it: the cheek line, brow and eye depth, how far the mouth sits back, the jaw line. The cheek line sets sharp or soft and is called a  lifeline  for pretty characters.  1   
           Common failure: squash the head front to back to slim the 3/4, which gives a  festival mask .  1   
            Breakage can't be avoided , so fix it with bones or shapes.  1   Gakumas has one shape that pushes the nose dot back so it vanishes in profile.  9   Guilty Gear keeps separate battle and close-up heads,  3   and in finishers the rig moves eyes, nose and mouth so the face reads from that one camera.  4   
           Expressions don't transfer. Uma Musume authors named presets per character, because parts sit differently.  6   
           The drawing is a guide, and copying it exactly isn't the goal.  1   Arc trains new modellers for a year.  13   
          
          For us  
            Too sharp  probably lives in the cheek line.  guess  
           The four moves are small, so code can make them per character at 3/4.  guess  
           One shared expression list is the wrong shape. Every character needs a tuned set, which is why the open mouths look alike. 
           If the game shows both battle and dialogue, plan on two faces.  guess  
          
       
    
       Shading a face so it reads as drawn; outlines 
       
          What they do  
           Quality sits in authored control data, not polygons. Uma Musume: under 20k polygons a character. Its shadow mask, a painted map of where shadow may fall, has the biggest effect on quality and takes most of the texture work. Shape-based shading can't look anime.  5   
            Where there is no vertex, you can't change the shadow shape.  A vertex is a mesh point.  1   
           Guilty Gear paints a value on each mesh point: how readily it goes into shadow, and how thick its line is.  2  3   
           Normals are the direction a surface claims to face, which decides light or shadow. Faces get them edited by hand; hair and clothes get them copied from simple shapes.  1  3   Outlines keep a separate set.  2  5   
           Guilty Gear adjusts each character's light per motion, and per frame in cutscenes.  3   Blue Protocol keeps light to shade at 7:3, because 5:5 went flat in backlight, and cuts the light's angle on skin by half to stop stray face shadows.  7   
           Face shadow maps: paint masks at about 9 light angles and merge them. It's a community method, mirrored from one side.  10   
           Outlines: a dark inverted copy of the mesh gives per-point control, while screen-wide lines are hard to tune.  Not showing lines where unintended  matters as much as showing them.  2  7   
          
          For us  
           This explains the  scar : the shadow's edge followed VRoid's mesh points.  guess  
           All 26 VRoid faces share one texture layout (lesson 29), so one designed shadow mask could serve them all, tuned per character. This is the best cheap next step for faces.  guess  
           Moving light per shot is a cheap cheat once we have shots.  guess  
          
       
    
       Hair 
       
          What they do  
           Bundles of locks with thickness. A study of 37,000 VRoid styles found 25 to 130 per style.  14   
           Start from the drawing's outline and shadow positions. Keep only what's needed, and delete locks that get in the way from other angles.  11   Too many fine strands make posing hard.  11   
           Build the inside first, decide the bones then, and add the outer hair last.  17   
           Hair can cost as much as the body: Gakumas 23k to 26k polygons, body 25k to 26k.  16   
           Motion: root keyed, tip simulated, simulation off for dramatic moments.  6   A hobbyist's settings for long cel hair: high stiffness, no gravity, to hold the drawn shape.  18   
          
          For us  
           Our lock kit is the same family as VRoid's, so building hair in code is sound.  guess  
           What's missing is design: a silhouette first, then few big dark shapes before any strands.  guess  
           A dark inner layer is still the fix for the slice. 
            Correction:  my 10-31 report said to lay back, then sides, then front. No source here confirms that order. 
          
       
    
       Clothing 
       
          What they do  
           Folds are placed by hand for common poses, exaggerated, with shapes taken from animation rather than life.  11   Revisions moved to pose shapes an animator dials in.  12   
           Skirts follow the legs first and sway second. Getting the skin weights right (how much each bone moves each mesh point) beats physics settings.  18  22   Colliders on legs alone fail, and a keep-inside cage works better.  19   VRM now has inside colliders.  20   
           Nobody reaches zero clipping. Uma Musume adds special motions for big sleeves.  6   Blue Protocol hides clashing parts.  7   Dark Souls capes  intersect pretty much everywhere  and  nobody really notices .  21   
           Real simulation is for big items like capes.  21   
           Fabric pattern shows in light and mostly vanishes in shadow.  24   
           Armour: only forum evidence found. Why simulated folds look wrong: no source says so outright. 
          
          For us  
           Our folds are sine ripples that don't change with pose. A few named fold shapes tied to joint angles would suit code.  guess  
           Our stiff skirt cone is close to the opposite weighting.  guess  
           Grade clipping by what the game camera sees, not by millimetres.  guess  
           Keep our cloth sim for capes only.  guess  
          
    # lowmarch (handoff, 2026-10-30)
    
    Tab: personal/lowmarch. Repo: ~/Projects/lowmarch (local git, no remote; 32 commits, 2026-10-08 to 10-13; tree clean).
    The deepest context is the old severian-dev session 16fadb50 (10-07 to 10-13). Read `docs/portrait-guide.md` first
    (31 numbered lessons, each with what the owner asked and what changed).
    **Since 11-08, start at `docs/handbook.md` instead:** it marks each rule earned or guessed, and has the first-session kit (`tools/session/`, `review/frame/`). `docs/map.md` and
    `docs/todos-2026-11-08.md` hold the housekeeping.
    
    ## What it is
    
    The character art pipeline for Lowmarch, a tactics game. The battle scenes aim at Unicorn Overlord's style, and
    FE8 (GBA) portraits are kept as a second renderer. Characters are built by code, not modelled by hand:
    - VRoid models as bases: the CC0 bodies, plus the 26 AvatarSample faces and their hair (`docs/vroid.md`);
    - bodies reshaped by MakeHuman references;
    - costumes, plate armour and hair kits generated and fitted in code;
    - everything drawn by our own numpy rasterizer (`tools/vrm.py`). Deps: numpy and PIL only.
    
    **Blender is not in the pipeline.** One spike used a portable Blender 4.5 to export Blender Studio base meshes
    (`docs/quaternius.md`). Blender 5.2.3 at ~/.local/opt is unused by lowmarch so far.
    
    **The pixel renderer is abandoned (owner, 2026-10-30).** The armory's painted renderer (`review/vroid-02/index.html`)
    is the target. `tools/vroid_portrait.py` stays because the build uses its Portrait class, but nothing new is ported
    to its pixel path.
    
    **Every camera is orthographic:**
    - the pixel and painted renderers project with a scale and no depth divide (`tools/vroid_portrait.py:730-734`);
    - every review page uses three.js `OrthographicCamera` (`review/out/*/site/index.html`).
    
    Data lives outside the repo, in `~/.local/share/lowmarch/`: vroid, makehuman, quaternius, anthro, refs and
    blender-base-meshes. The FE8 refs are study only: never trace or ship them (`docs/study.md`).
    
    ## How far it got
    
    - **10-07:** the FE8 portrait study, which set the house style. The 96x80 portrait goes through `tools/pix.py` and
      `vroid_portrait.py`.
    - **10-08:** the following were built:
      - Aldric (frozen at viewer v9, now retired as a study) and Elaine;
      - a Saber benchmark (study only, never for the game);
      - the costume, outline-plate and hair kits, and common enemies;
      - a two-character sword bind, and a painted renderer next to the pixel one;
      - browser review pages that show the 3D model and both renders.
    - **10-09:** a base spike tried MakeHuman, Quaternius and Blender Studio meshes. VRoid bodies shaped by MakeHuman
      won. VRoid Studio on the Windows side is driven from WSL (`tools/winvroid`).
    - **Armory v1 to v12.1 (10-09 to 10-13):** 14 T-posed bodies (`arm_m_*`, `arm_f_*`):
      - proportions are held by code (`docs/proportions.md`), and bodies are read against NHANES and ANSUR
        (`docs/anthro.md`);
      - the heroic man and sexy woman lines, real hands and breast spring bones;
      - v9 and v10: heads from VRoid sample faces, blended by look;
      - v11: VRoid hair with spring physics;
      - v12: collision spheres fitted to each body's skin;
      - v12.1: a fix to the face-blend order.
    - **The owner's last verdicts:** bodies "look perfect" (10-12). Faces were "too sharp" at some angles. That fault was
      our ratio fitter, so v10 keeps faces as VRoid built them (lesson 30).
    
    ## How to run
    
    These commands come from the tools' docstrings; none was re-run this session.
    - `python3 tools/vroid_portrait.py MODEL.vrm --yaw 35 --png out.png --scale 6` renders one portrait.
    - `LOWMARCH_SITE=armory python3 review/vroid-02/build.py` builds the armory page. Output goes to
      `review/out/armory/site/`. The models are base64 GLBs, `{"glb": ...}` in `<name>.glb.json`.
    - Without `LOWMARCH_SITE`, the same command builds the cast viewer (vroid-02): Aldric, Elaine, Saber, the mobs and
      the duel. Other sites: `mh-workshop`, `base-spike`.
    - `python3 tools/cage.py [NAME...]` builds armory bodies, and `python3 tools/heads.py BASE SAMPLE` builds one head.
    - `python3 tools/regress.py NAME [TAG]` diffs a build's geometry against the last published version.
    - `python3 tools/winvroid/winvroid.py bases|samples` drives VRoid Studio on Windows. It takes over the PC, so it needs
      the owner's go.
    
    ## Open threads
    
    - **VRoid driver blocked:** `tools/winvroid`'s rebuilt V.dll is refused by Windows application control. The owner
      must allow it before the driver works (`docs/vroid.md`, face session).
    - **Faces:**
      - all 26 samples are young. A mature or sultry face needs VRoid's editor (the "option 2" session, done with the
        owner away from the PC).
      - The first try, `faces/face_sexy.vrm`, read cute and was set aside. Next time, start from preset 3 or 5.
    - **Not started:**
      - the neck, which waits on the head work;
      - a second armour pass (Aldric is retired);
      - Unicorn Overlord-style battle animation, map sprites and fabric textures.
    - **Sortie** (severian-dev/sortie, tab of 10-28) borrows lowmarch VRoid bodies for its pilots. See memory
      project_sortie_mech_game.
    
    ## Research: the "flat lattice" Blender extension (2026-10-30)
    
    **Short answer:**
    - **It exists, twice:** "Flattice" (flat + lattice) is the name of two unrelated add-ons. Both build a lattice aimed
      at the camera, and a shape key on it squashes the mesh along the view axis. That is a per-object longer lens: the
      near parts of the face (nose, cheeks) stop looming. The rumor is almost certainly DillonGoo's, which is made for
      faces and went on sale this week.
    - **Not worth trying for lowmarch:** our cameras are orthographic, so there is no lens distortion to remove.
    - **Where it could help:** sortie's perspective close-ups. There the trick is a few lines of shader or numpy, not a
      Blender add-on.
    
    ### The two Flattices
    
    | | Flattice: Stylized Flattener | Flattice |
    |---|---|---|
    | Author | Dillon Goo (DillonGoo Studios, who make Goo Engine) [1][2] | Merlin Perry [5] |
    | Where | Superhive [1], Gumroad [3], linked from the studio's add-ons page [4] | Blender Extensions platform [5], GitHub (README and licence only, no source) [6] |
    | Price | $2 [1][3] | free [5] |
    | Version | not stated [1] | 1.0.8, 2026-08-14 (first release 1.0.6, 2026-07-30) [7] |
    | Blender | 3.6 to 5.1 in the text, 3.6 to 5.2 in the table; Goo Engine 3.6 to 4.4 [1] | 4.2 and newer [5] |
    | Licence | GPL [1] | GPL-3.0-or-later [5] |
    | Packaging | legacy add-on zip (`goo_flattice_generator.zip`), Install from Disk, N panel "Goo Rigging Tools" [2] | extension, 19.6 KB, one 790-line `__init__.py`; read, not run (zip sha256 eafab40c...ed1458) |
    | Traction | Superhive: 100+ sales, published "3 days ago" (so about 10-27) [1]; Gumroad: 2 ratings, 5.0 [3] | 595 downloads, no reviews [5] |
    
    **DillonGoo's (the face one):**
    - **Inputs:** a parent bone, any number of meshes, and the 3D cursor set at the chin [2].
    - **What it builds:**
      - a vertex group weighted from the cursor down (with a Falloff setting), so the face flattens and the body below
        doesn't;
      - an empty that follows the active camera 1:1, and a lattice parent that tracks that empty;
      - a low-resolution lattice with a shape key that flattens it to a plane [2].
    - **The switch:** a "Flattice" property on a bone, 0 to 1. It can be animated and library-overridden [1][2].
    - **The author's reason:** it "disconnects the focal length of the face from the focal length of the camera" [1][3].
    - **FAQ:** the flattening "mimics a higher focal length". The tool was built years ago, and "Geometry Nodes can
      totally do it now" [8].
    
    **Merlin Perry's (object level):**
    - **Create Flattice** fits a 2x2xN lattice to the selected objects' bounds and adds a Damped Track to the camera.
    - A `Flatten` shape key sets every point's local z to 0. A driver ties it to a `flatten` property on the camera,
      from -10 to 10: 1 is flat, 0 is the model as built, negatives exaggerate depth [5][6].
    - **No falloff:** whole objects flatten. On a VRoid model only the Face mesh would flatten, so it would come apart
      from the body at the neck.
    - **Possibly headless:** besides `bpy.ops.flattice.create`, the build path uses only the data API and context
      (selected objects, `scene.camera`). Calling it from `blender -b` should work. Not tested.
    
    ### What it is and isn't, against the known approaches
    
    - **Is:** the focal-length cheat. It only does anything under a perspective camera, which it moves toward an
      orthographic read.
    - **Isn't:**
      - per-view shape correction (the anime nose and mouth cheat);
      - squash and stretch of eyes or mouth;
      - normal editing. Recomputed normals follow the squashed geometry, so shading flattens a little, but only as a
        side effect.
    - **Lattice Magic, Camera Lattice** (Blender Studio, free extension 1.0.1, Blender 4.2+, GPL):
      - a lattice in a camera's view that you sculpt shot by shot, with one shape key per frame;
      - "like Liquify but on vertices" [9][10].
      - For fixing individual sh…1553 tokens truncated…s` (factor 0.5) and `Yin_Neck_Pos`
        (factor 0.95);
      - the blend is weighted by the `NRM_Head` and `NRM_Neck` attributes, then blurred.
      - So their designed shading survives the flatten.
    - That modifier is off in the viewport and on for renders.
    - **For lowmarch:** we already shade from stored vertex normals, so a depth squash in our renderer wouldn't touch
      shading. The head-locator normal blend is worth copying anyway, for faces that read soft at every angle.
    
    **Result:** Flattice does what it says, scripts headless, and costs nothing to keep. Lowmarch gets nothing from it while
    its cameras are orthographic. If a perspective camera comes (Unicorn Overlord-style battles, sortie close-ups), the
    recipe is a depth scale about the head with a chin falloff. Shade from normals stored before the squash.
    
    ### Yin and Yang twin rigs (DillonGoo, bought 2026-10-30): review
    
    The full review is in `~/.local/share/lowmarch/trials/yin-yang-review-2026-10-30/` (`REVIEW.md`), done by a worker on the
    EEVEE builds, opened headless with autoexec off.
    - **Use `contact_sheet_armory.png`.** Its lowmarch rows come from the armory page's own painted renderer, head and whole
      body, shot headless from a patched scratch copy of the built page (`scripts/arm_shoot.py`, `scripts/compare_sheet.py`).
    - The first sheet (`contact_sheet.png`) wrongly used `tools/vroid_portrait.py`, the old pixel path. It crops to a bust
      and mangles armory bodies.
    
    **Not a base.**
    - **Licence** ("Editorial" on Superhive; $40 to $70 tiers): personal or educational use only. No redistribution "in
      original or modified form", and the Yin and Yang characters can't be used commercially
      (https://superhivemarket.com/products/yin-yang-twins-anime-rig-pack, and the Gumroad listing
      dillongoo.gumroad.com/l/yin-yang-anime-twins-rig-pack). A game build would redistribute them.
    - **Technically a poor fit:**
      - the clothes are the body: Yin has no skin under the shirt and pants;
      - a Rigify A-pose rig split over 3 armatures, about 1,640 bones;
      - expressions are bones, not shape keys.
    - Reimplementing their techniques in our own code copies no asset.
    
    **Lessons for lowmarch, ranked:**
    1. **Proxy shading normals ("Vertex Skeleton Normals")** in `vs_nrm`:
       - `n = normalize(P - mix(mean of the skeleton, nearest point on a short vertical edge inside the head, 0.5))`;
       - blended in by a painted mask, blurred 5 times, renormalized; the neck uses a capsule (factor 0.95).
       - Bake it at build time into the GLB normals (`tools/export_glb.py` / `review/vroid-02/build.py`). Then the armory
         page's painted renderer (`review/vroid-02/index.html`), the pixel path and later the game all get it. Paint the
         mask once on VRoid's shared face template. Led #1114.
       - The contact sheet's A/B (our 4 bands and headlight on their mesh) shows the difference. Mesh normals give noisy
         nose and cheek patches that move with yaw; the proxy gives clean ovals at every angle.
    2. **One proxy for the whole head:** hair, brows, lashes and mouth use it too, so shade edges carry from hair into face.
    3. **Two skin tones split at N.L 0.1**, with the rest authored. That is fewer bands than our 4.
    4. **Authored shade:** a painted per-corner `Shadows` attribute, plus tiny nose, lip and eyelid shadow cards. Yang's nose
       card flips sides with the light; for us that would be UV marks picked by the light's side.
    5. **Line-only geometry:** `Eyelids` is edges only, for Line Art. For us, lid and nose lines as 3D polylines projected
       per frame, like `draw_curve_mouth`.
    
    **Proportions:**
    - Yin: 7.3 heads, eye line 0.58 down from the crown.
    - Yang: about 7.8 heads, eyes at 0.55, higher than any VRoid sample.
    - Ours: arm_f_slender 7.3 heads, arm_m_youth 6.5, both with eyes at 0.61.
    
    **Not checked:**
    - the Goo Engine look;
    - the Wiggle 2 dependency;
    - GN input values beyond the group defaults;
    - (Since checked: the owner ran the shipped-shader turnaround with autoexec on. All 8 renders, both rigs at 4 yaws, are
      pixel-identical to the autoexec-off ones. The 6 Python drivers don't touch the rest pose.)
    - Line Art draws nothing headless, so the sheet's outlines are approximate.
    
    ### Face shading from the rigs' lessons (2026-10-30, owner's go)
    
    Commits **Armory v13** (`121a1e4`, `face_normals`), **v13.1** (`dc3c532`) and **v13.2** (`fbffd7c`), in
    `tools/vroid_portrait.py` and on by default; portrait guide lessons 32 and 33.
    - **v13:** the face, brows, lines, mouth and skull are shaded from normals pointing away from a line inside the head.
      The nose patch and the blotchy jaw are gone.
      - The line sits at the head's middle (`forward=0.0`), not Yin's 13% forward: VRoid faces are flatter.
      - Hair is off: the trick flattens the strands in the painted renderer.
    - **v13.1 (superseded):** a nose shadow and the chin's V on the neck, made by turning normals down in soft patches.
      The owner saw scars: the edges followed the mesh's triangles.
    - **v13.2** (`fbffd7c`, `shadow_cards`): designed geometry instead, like the Yin rig's shadow cards.
      - A crescent on the neck under the real jaw line, and a half-moon under the nose tip.
      - New role "shadow": skin that only darkens into its shade tone (export, the painted page
        `review/vroid-02/index.html`, the pixel path).
      - `face_normals` gains a neck cylinder. Portrait guide lesson 34. Sheet: `shadow-cards.png`.
    - **v13.3:** the neck's line now comes from the skeleton (`neck_frame`: neck bone to head bone).
      - The skin-slice estimate had broken the slender woman's card in the T-pose, which is why she and the youth
        looked different. `neck-isolated.png` shows it with the neck held lit.
      - The crescent is shallower and tapers before the jaw's angle, and cards darken only to a soft shade
        (`min(lit, 0.37)`).
    - **v13.4 (`5e928b9`, kept by the owner 10-30, hair-strand shadows included):** the chin's shadow is cast in screen space from the jaw and hair (portrait guide
      lesson 35, after Anime Shading Plus's depth-offset shadows).
      - The painted renderer draws its info pass first; body skin walks toward the key across it.
      - The chin card is off (`CHIN_CARD`). Sheet: `cast-shadows.png`.
    - **Light, not changed:** the armory's light is a camera headlight from the upper left, with a slightly blue shade
      tint. `light-test.png` shows other directions and a warm tint; the owner found the shape, not the light, was the
      problem.
    - **Fewer tones:** already true on faces after these two steps, so the shared skin shader was left alone.
    - **Step 3 (lid crease) dropped.** Painted into the face texture it can't get darker than about 55% (the skin
      shader's clamp), and bangs hide it. Doing it as ink on VRoid's eyeline overlay is optional follow-up (led).
    - **Only arm_f_slender and arm_m_youth are rebuilt** (local `review/out/armory/site`). The other 12, and the
      published armory page, are still v12.1.
      - Every edit to `vroid_portrait.py` changes `tools/cage.py`'s cache key. A full refresh is
        `python3 -I tools/cage.py`, then `LOWMARCH_SITE=armory python3 review/vroid-02/build.py`, then `sheets.py`,
        then republishing (owner's go). Bodies come out byte-identical; it costs about a minute a body.
    - **Sheets and scripts:** `~/.local/share/lowmarch/trials/face-shading-2026-10-30/`.
      - `arm_shoot.py` shoots a patched copy of the built armory page headless.
      - `variant_build.py` builds settings variants into a scratch site without touching the repo.
      - `armsite_before_v13/` is the v12.1 site with Head and Body rows at 0/35/60/90.
    
    **Flattice in the armory renderer** (`flattice-slender-before-after.png`, same folder): `patch_lens_flattice.py`
    gives a scratch copy of the built page a perspective lens per tile, perspective-aware outline depth, and Flattice as
    a vertex-shader squash (pivot at the head bone, along pivot to camera, chin falloff, normals untouched).
    - At flatten 1 every head layer lands on one plane and the depth buffer can't order them (z-fighting), so it uses
      0.85 and scales the outline pass's depth step by the same amount.
    - **The chin is the cursor, not the pivot.** The docs put the 3D cursor on the chin, but the cursor only sets where
      the squash starts (full above it, fading 5 cm below). The pivot is the parent bone. On the Yin rig: the falloff
      starts at her chin (z 1.447), and the pivot is the head bone 4.7 cm above it, about 11 cm behind the face front.
      Ours matches: cursor at the chin, pivot at J_Bip_C_Head, about 3 cm above it.
    - **Pivot moved to the chin's front (`flattice-pivot.png`):** the head keeps its size at 0 and 35 degrees, but at 60
      and 90 the hair breaks up near the neck. The head-bone pivot is the stable one. A close-up head still looks a
      little small, mostly because the unflattened shoulders bulge toward the lens. Options for the game camera: a pivot
      partway forward, or a light squash on the shoulders too.
    
    **Flattice parked (owner, 2026-10-30): no real value until game scenes are composed with a camera.**
    - The "something off" in the head-only renders is two lenses in one picture: a drawn-flat head on shoulders and arms
      still in strong 24 mm perspective. Flattening the whole figure (`flattice-whole.png`) reads consistent, but it then
      comes close to the lens-less armory camera, so the armory gains nothing.
    - **When scenes come:** the anime trick is characters flattened and backgrounds left in perspective. DillonGoo's own
      copy says it can flatten "face, chest, or whole body", so start from whole-figure, per shot.
    - The scratch page patch (`patch_lens_flattice.py`) already does lens, whole-figure, head-only and pivot options.
    
    ### Skin range (2026-10-30)

    161 more lines not shown.