CommunityImagegithub.com

lamina

Expliquez le fonctionnement d'une machine ou d'un mécanisme sous la forme d'une page web sombre avec des figures 3D animées (« láminas ») : un court texte, puis des cartes encadrées montrant le même modèle entier, ouvert, son mécanisme seul, son mouvement et sa vue éclatée, chacune avec une ou deux commandes et des pièces nommées que vous pouvez sélectionner tandis que le reste s'estompe. Le modèle est construit dans Blender à partir de code sous forme de pièces fermées réelles et audité pour que rien ne traverse rien. À utiliser quand quelqu'un demande comment fonctionne quelque chose, veut une page expliquée, une « lámina », un explicateur 3D interactif, une coupe ou une vue éclatée d'une machine, d'un robot, d'un outil, d'un instrument ou d'un mécanisme.

Qu'est-ce que lamina ?

Lamina est une compétence avancée pour Claude Code, conçue pour créer des pages web explicatives interactives en 3D. Elle permet de modéliser fidèlement le fonctionnement d'une machine, d'un mécanisme ou d'un instrument en partant de données réelles (tailles, masses, vitesses) et en générant un modèle Blender à partir de code Python. Le résultat est une page web sombre et élégante affichant le modèle sous plusieurs angles : entier, ouvert, mécanisme seul, en mouvement, et en vue éclatée, avec des commandes minimalistes et la possibilité de sélectionner des pièces nommées. L'audit intégré vérifie qu'aucune pièce ne s'interpénètre, que les engrenages respectent leurs rapports, et que toutes les pièces sont fermées. Lamina est idéale pour des explications techniques détaillées, des démonstrations de produits ou des documentations interactives, prenant en charge Blender 4.2+, Node.js 20+ et Chromium.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/zeuscabanas/lamina/tree/HEAD

Installed? Explore more Image skills: steipete/songsee, affaan-m/frontend-design, mattpocock/improve-codebase-architecture · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Que fait lamina ?

Une machine, un modèle, une page. La lectrice ou le lecteur défile sur une courte explication et rencontre la machine plusieurs fois : entière, ouverte, son mécanisme seul, en mouvement, éclatée. Chaque figure est le même modèle audité, donc rien sur la page ne peut contredire quoi que ce soit d'autre sur la page.

SKILL_DIR est le dossier où se trouve ce fichier. examples/colibri/ est une page complète (un colibri robotique de 12 g, 44 pièces, six figures) : lisez-la avant de commencer et copiez sa structure.

cd "$SKILL_DIR" && npm install && npx playwright install chromium     # une fois
python examples/colibri/model.py --audit                              # modèle → colibri.glb, doit afficher `audit passed`
node build.mjs examples/colibri                                       # → out/colibri.html, un fichier hors ligne
node scripts/shots.mjs out/colibri.html                               # captures de chaque figure + vérifications des contrôles

Avec Blender au lieu du module bpy : blender -b -P examples/colibri/model.py -- --audit.

Flux de travail

Travaillez dans cet ordre. La majeure partie de la qualité se décide lors des étapes 1 à 3, avant tout maillage.

  1. Les faits d'abord. Collectez les nombres réels : tailles, masses, vitesses, nombres de dents, rapports, limites. Cherchez-les. Placez-les dans un petit module pur (kin.js) et indiquez dans la page d'où ils viennent. Les pièces inventées reçoivent des noms inventés : un produit fictif avec un code modèle, jamais une vraie marque.
  2. Une seule entrée. Nommez la variable unique qui anime la machine (un angle de manivelle, une course, une position de soupape). Chaque pose et chaque affichage est une fonction de celle-ci.
  3. Liste des pièces et disposition, sur papier. 40+ pièces regroupées par assemblage, chacune avec ce sur quoi elle repose. Disposez le mécanisme avec des nombres avant de modéliser : centres d'engrenages à (z1 + z2)·m / 2, positions des arbres, ce qui doit dégager quoi, où chaque arbre traverse une coque. Écrivez la liste en haut de model.py.
  4. Modélisez dans Blender avec blender/tdb.py (voir « Modélisation »).
  5. Auditez à zéro. python model.py --audit jusqu'à ce qu'il affiche audit passed.
  6. Écrivez la page avec kit/page.js (voir « La page ») : 4 à 7 figures, chacune répondant à une question.
  7. Regardez-la. node scripts/shots.mjs out/<nom>.html doit afficher checks passed. Ensuite, lisez chaque PNG qu'il a écrit. Corrigez et répétez jusqu'à ce qu'un passage complet ne trouve rien.

Montrez une figure tôt (la machine entière, construite et photographiée) avant d'écrire le reste de la page.

Modélisation

Tout ce qui a un corps courbe, une coque sur un mécanisme, ou des pièces qui se déplacent les unes à côté des autres est modélisé dans Blender, pas tapé comme des primitives three.js. Les primitives placées à l'œil sont la façon dont les pièces finissent par se traverser.

  • Un corps est une surface analytique, jamais une sphère ou un tour qui en tient lieu. Définissez des sections de contrôle, joignez-les avec spline, et découpez la surface en panneaux avec patch(surf, u0, u1, v0, v1, thick=0.7) : épaisseur réelle, espaces réels là où vous laissez des plages de paramètres, un chanfrein sur chaque bord.
  • part(name, bmesh, mat, asm, bevel, cut, explode, open, mats) enregistre une pièce fermée dans le repère de son parent. cut=[…] soustrait avec des booléens exacts : un trou pour chaque arbre, patte, œil ou câble qui traverse une coque. carve() découpe un morceau avant qu'il ne soit soudé dans une pièce.
  • Une structure soudée est une pièce (join) : quille, cadres annulaires, plaques, poteaux, bossages. Boulons, trappes et évents sont fusionnés sur le panneau auquel ils appartiennent. L'audit se fait entre les pièces, donc décidez délibérément ce qu'est une pièce.
  • Mouvement : joint(part, 'rev' | 'slide', axis, law, input) avec value = k·q + a·sin(h·q + p) + c + b·tanh(g·cos q). rig_input(name, lo, hi, samples, rest) déclare ce que l'audit parcourt. mate(a, b, depth) déclare des dents en prise ; gear_info(...) déclare des engrenages et des crémaillères ; frame(...) est un vide qui porte une articulation ; anchor(name, at) est un point nommé.
  • Les contacts sont affleurants (jeu de 0,05 mm), tangents, ou jante sur surface. Rien n'est enfoncé dans rien. Une pièce qui flotte est un bogue : donnez-lui un support.
  • Les matériaux sont des noms (shell, orange = l'accent, ink, dark, steel, brass, carbon, lens, membrane, pcb) ; la page leur donne leur apparence. mats={'orange': predicate} peint une région d'une pièce.

L'audit

blender/audit.py pose le modèle pour chaque entrée avec les mêmes lois d'articulation que la page utilise et prouve sur les maillages réels :

VérificationSignification
interferenceAucune pièce ne traverse une autre au repos, à chaque pose échantillonnée, ou éclatée. Un accouplement déclaré peut se chevaucher jusqu'à sa profondeur.
supportChaque pièce en touche une autre et toutes sont reliées ensemble comme un seul assemblage.
gearsDistance entre centres (z1 + z2)·m / 2, rapport de vitesse inverse, course de la crémaillère = angle du pignon × rayon primitif.
closedChaque pièce est un volume fermé ; une tôle a une épaisseur.

Chaque échec nomme la paire, la pose, la profondeur et le point. Corrigez la géométrie : déplacez-la, réduisez-la, coupez un trou, changez la disposition, réduisez une course. N'élargissez jamais un accouplement, ne supprimez jamais une pièce, et ne sautez jamais une pose pour le faire taire. Si l'audit montre que les nombres réels ne correspondent pas, les nombres sur la page changent aussi. Si vous ne pouvez pas l'exécuter (pas de Blender, pas de bpy), dites-le et ne considérez pas le modèle comme terminé.

La page

kit/rig.js charge le GLB et le pose : rig.pose(inputs, {explode, focus, open}). kit/page.js est la page :

import {createPage} from 'lamina-kit/page.js';
const P = await createPage({title, model});          // model : {root, meshes, update(state)}
P.header({code, kicker, name, sub}); P.lead('…'); P.h2('01 — El conjunto', '…'); P.text('…');
P.figure({n: 1, title, cam: {az, el, d, ty, tz}, controls, step: (fig, dt) => state, readout: (fig, state) => html});
P.caption('<b>Fig 1.</b> …'); P.chain([...]); P.table([...]); P.footer(left, right); P.start();
  • Un moteur de rendu pour chaque figure. Chaque carte visible est posée, rendue et copiée dans son propre canevas. Jamais un seul contexte WebGL par figure.
  • Le step d'une figure renvoie l'état pour model.update. state.look(part, asm) renvoie 'solid', 'ghost' ou 'hide' pour chaque maillage : c'est ainsi qu'un modèle devient la machine entière, la machine ouverte et le mécanisme seul.
  • Les contrôles sont peu nombreux et réels : au maximum une pause, trois vitesses et un curseur par figure (P.range, P.speeds, data-pp). Entrées natives uniquement. Pas de consoles, tableaux de bord, timelines ou panneaux d'état.
  • Pièces nommées : ...P.partsPanel(PARTS) ajoute un bouton par pièce avec une ligne à son sujet ; en sélectionner une (ou cliquer dessus dans la figure) estompe le reste et amène la caméra vers elle. PARTS est [name, /regex/, line].
  • Les figures à considérer, dans cet ordre : la machine entière en fonctionnement · l'intérieur (un curseur soulève la coque) · le mécanisme seul, lent, avec une phase que l'on peut parcourir · le mouvement qui compte, tracé · une compensation ou une limite · la vue éclatée avec les pièces nommées. Ensuite un tableau des nombres.

Rédaction

En espagnol par défaut (adaptez-vous à la langue de l'utilisateur). Court. Un chapô de deux phrases, puis par figure : un titre, deux ou trois phrases qui disent quoi regarder et pourquoi c'est ainsi, la figure, et une légende avec un fait. Chaque nombre dans le texte provient du modèle. Dites ce qui est fictif et d'où viennent les chiffres réels.

Apparence

Sombre, toujours. Page #0e0f11, texte #ece8df, un accent : or #d4a94e. Chaque carte a un doux halo de lumière derrière le modèle afin que les parties sombres conservent un contour. Le modèle est blanc et or : coques blanches brillantes, or pour ce que marque le matériau orange, graphite et acier en dessous. Inter pour le texte, JetBrains Mono en petites capitales pour les étiquettes, les nombres et les boutons.

Les parties sombres sur une page sombre perdent leurs bords. Gardez le noir pour quelques pièces ; faites les mécanismes internes en acier, aluminium ou laiton, et vérifiez chaque pièce sélectionnée par rapport à l'arrière-plan dans fig*-part.png.

Révision

Vous ne pouvez pas regarder la page ; vous pouvez lire les images. scripts/shots.mjs écrit top.png, figN.png, figN-part.png et phone.png, appuie sur chaque pause, déplace chaque curseur, sélectionne une pièce et rapporte les erreurs de console. Ensuite, regardez :

  • Le modèle. audit passed sur le fichier actuel. Il se lit comme la vraie chose à première vue ; pas de face nue à 4×.
  • Chaque figure. Un sujet, remplissant la moitié de la carte, non coupé ; son ombre à l'intérieur de la carte ; l'affichage fidèle.
  • Chaque contrôle. Il change ce que la légende dit qu'il change.
  • Le texte. Chaque nombre correspond aux affichages et au tableau.
  • Téléphone. Une colonne à 390 px, rien qui ne défile latéralement.

Dites ce que vous n'avez pas pu vérifier (le taux d'images d'un vrai GPU, par exemple).

Crédits

lamina unifie des idées de teardown (elvarofficial), anatomy (Ryan) et claude-motion (whaleyxbt), tous MIT. Voir CREDITS.md.

Skills associés