@playcraft/skills 0.0.2

package/skills/playcraft-3d-flip-sprite/renderer/render.mjs

@@ -0,0 +1,325 @@
+/**
+ * GLB → Flip Sprite Sheet renderer (pure JS, no native deps)
+ *
+ * Architecture: "White model + face texture injection"
+ *   - GLB provides the 3D shape (mesh + UV atlas for body/edges/back)
+ *   - An optional face texture overrides ONLY the front-face triangles
+ *   - Batch: run once per tile image, reuse the same GLB
+ *
+ * Usage:
+ *   node render.mjs [glb] [out.png] [face-texture.png]
+ *
+ * Pipeline:
+ *   1. Parse GLB → extract geometry + body texture (UV atlas)
+ *   2. Classify each triangle as "face" (front) or "body" (edges/back)
+ *      by checking model-space normal Y > FACE_THRESHOLD
+ *   3. For face triangles, derive UV from model-space XZ position
+ *      (maps tile width/height → [0,1] range of the supplied face texture)
+ *   4. Perspective rasterize with Phong shading + Z-buffer + SSAA
+ *   5. Assemble sprite sheet
+ */
+import { NodeIO } from '@gltf-transform/core';
+import sharp from 'sharp';
+import { existsSync } from 'fs';
+
+// ── CLI args ─────────────────────────────────────────────────────────────────
+const GLB_PATH      = process.argv[2] || '/tmp/mahjong-tile/tile_1wan.glb';
+const OUT_PATH      = process.argv[3] || '/tmp/mahjong-tile/tile_flip_sprite.png';
+const FACE_TEX_PATH = process.argv[4] || null;   // optional face override texture
+
+// ── Config ────────────────────────────────────────────────────────────────────
+const FRAMES = 16;
+const COLS   = 8;
+const W = 280, H = 280;
+const SS = 2;                   // SSAA factor (2 = 4× samples)
+const RW = W*SS, RH = H*SS;
+
+// Triangle normal Y > this threshold (model space) = front face
+const FACE_THRESHOLD = 0.7;
+
+// ── Vector math ───────────────────────────────────────────────────────────────
+const v3    = (x,y,z) => ({x,y,z});
+const add   = (a,b)   => v3(a.x+b.x,a.y+b.y,a.z+b.z);
+const sub   = (a,b)   => v3(a.x-b.x,a.y-b.y,a.z-b.z);
+const scale = (v,s)   => v3(v.x*s,v.y*s,v.z*s);
+const dot   = (a,b)   => a.x*b.x+a.y*b.y+a.z*b.z;
+const cross = (a,b)   => v3(a.y*b.z-a.z*b.y,a.z*b.x-a.x*b.z,a.x*b.y-a.y*b.x);
+function normalize(v) { const l=Math.sqrt(dot(v,v))||1e-9; return scale(v,1/l); }
+function rotY(p,ry)   { const c=Math.cos(ry),s=Math.sin(ry); return v3(p.x*c+p.z*s,p.y,-p.x*s+p.z*c); }
+function rotX(p,rx)   { const c=Math.cos(rx),s=Math.sin(rx); return v3(p.x,p.y*c-p.z*s,p.y*s+p.z*c); }
+
+// ── Camera & lighting ─────────────────────────────────────────────────────────
+const FOCAL    = 2.8;
+const CAMERA_Z = 3.2;
+const LIGHT    = normalize(v3(0.3, 0.8, 1.0));
+const VIEW_DIR = v3(0, 0, 1);
+
+// ── Pose: RX_INIT = +1.908 rad (+109.3°)
+//   • At ry=0:  front face toward camera, 一 at screen-top (correct orientation)
+//   • At ry=π:  back face toward camera   (flip START position)
+//   • Flip runs ry: π → 0 (back → front reveal)
+const RX_INIT = 1.908;
+
+// ── Projection ────────────────────────────────────────────────────────────────
+function project(p) {
+  const dz = CAMERA_Z - p.z;
+  return { sx:(p.x/dz)*FOCAL*RW*0.42+RW/2, sy:(-p.y/dz)*FOCAL*RH*0.42+RH/2, wClip:1/dz };
+}
+
+// ── Bilinear texture sample ───────────────────────────────────────────────────
+function sampleBilinear(tex, tw, th, u, v) {
+  const fx = Math.max(0, Math.min(tw-1.001, u*(tw-1)));
+  const fy = Math.max(0, Math.min(th-1.001, v*(th-1)));
+  const x0=Math.floor(fx), y0=Math.floor(fy), sx=fx-x0, sy=fy-y0;
+  const I = (r,c) => (r*tw+c)*4;
+  const out = new Float32Array(4);
+  for (let ch=0; ch<4; ch++)
+    out[ch] = (tex[I(y0,x0)+ch]*(1-sx)+tex[I(y0,x0+1)+ch]*sx)*(1-sy)
+            + (tex[I(y0+1,x0)+ch]*(1-sx)+tex[I(y0+1,x0+1)+ch]*sx)*sy;
+  return out;
+}
+
+// ── Triangle rasterizer ───────────────────────────────────────────────────────
+function rasterizeTri(pixels, zbuf, p0, p1, p2, u0,v0, u1,v1, u2,v2,
+                      n0, n1, n2, tex, tw, th, flipU) {
+  const mnX=Math.max(0,Math.floor(Math.min(p0.sx,p1.sx,p2.sx)));
+  const mxX=Math.min(RW-1,Math.ceil(Math.max(p0.sx,p1.sx,p2.sx)));
+  const mnY=Math.max(0,Math.floor(Math.min(p0.sy,p1.sy,p2.sy)));
+  const mxY=Math.min(RH-1,Math.ceil(Math.max(p0.sy,p1.sy,p2.sy)));
+  const area2 = (p1.sx-p0.sx)*(p0.sy-p2.sy)-(p0.sx-p2.sx)*(p1.sy-p0.sy);
+  if (Math.abs(area2) < 1e-6) return;
+  const isMirrored = area2 < 0;
+  const invArea    = 1/Math.abs(area2);
+  const sign       = isMirrored ? -1 : 1;
+
+  for (let py=mnY; py<=mxY; py++) {
+    for (let px=mnX; px<=mxX; px++) {
+      const w0=sign*((px-p1.sx)*(p2.sy-p1.sy)-(py-p1.sy)*(p2.sx-p1.sx))*invArea;
+      const w1=sign*((px-p2.sx)*(p0.sy-p2.sy)-(py-p2.sy)*(p0.sx-p2.sx))*invArea;
+      const w2=1-w0-w1;
+      if (w0<0||w1<0||w2<0) continue;
+      const wI = w0*p0.wClip+w1*p1.wClip+w2*p2.wClip;
+      const pidx = py*RW+px;
+      if (wI < zbuf[pidx]) continue;
+      zbuf[pidx] = wI;
+
+      const uI = (w0*u0*p0.wClip+w1*u1*p1.wClip+w2*u2*p2.wClip)/wI;
+      const vI = (w0*v0*p0.wClip+w1*v1*p1.wClip+w2*v2*p2.wClip)/wI;
+
+      const nx=(w0*n0.x*p0.wClip+w1*n1.x*p1.wClip+w2*n2.x*p2.wClip)/wI;
+      const ny=(w0*n0.y*p0.wClip+w1*n1.y*p1.wClip+w2*n2.y*p2.wClip)/wI;
+      const nz=(w0*n0.z*p0.wClip+w1*n1.z*p1.wClip+w2*n2.z*p2.wClip)/wI;
+      const nLen=Math.sqrt(nx*nx+ny*ny+nz*nz)||1e-9;
+      const nN={x:nx/nLen,y:ny/nLen,z:nz/nLen};
+
+      const NdL = Math.max(0, dot(nN, LIGHT));
+      const half = normalize(add(LIGHT, VIEW_DIR));
+      const NdH  = Math.max(0, dot(nN, half));
+      const light = 0.32 + 0.60*NdL;
+      const spec  = 0.18*Math.pow(NdH, 48);
+
+      // U flip: body uses isMirrored (UV atlas), face uses explicit flipU flag
+      const uSample = (flipU ?? isMirrored) ? 1-uI : uI;
+      const col = sampleBilinear(tex, tw, th, Math.max(0,Math.min(1,uSample)), Math.max(0,Math.min(1,vI)));
+      if (col[3] < 8) continue;
+
+      const oi = pidx*4;
+      pixels[oi  ] = Math.min(255, col[0]*light+255*spec);
+      pixels[oi+1] = Math.min(255, col[1]*light+255*spec);
+      pixels[oi+2] = Math.min(255, col[2]*light+255*spec);
+      pixels[oi+3] = col[3];
+    }
+  }
+}
+
+// ── Load face override texture (optional) ────────────────────────────────────
+let faceTexData = null, faceTexW = 0, faceTexH = 0;
+if (FACE_TEX_PATH && existsSync(FACE_TEX_PATH)) {
+  const { data, info } = await sharp(FACE_TEX_PATH)
+    .resize(512, 512, { fit: 'fill' }).ensureAlpha().raw()
+    .toBuffer({ resolveWithObject: true });
+  faceTexData = new Uint8ClampedArray(data);
+  faceTexW = info.width; faceTexH = info.height;
+  console.log(`Face texture loaded: ${FACE_TEX_PATH} (${faceTexW}×${faceTexH})`);
+} else {
+  console.log('No face texture — using GLB atlas for all faces');
+}
+
+// ── Parse GLB ─────────────────────────────────────────────────────────────────
+console.log(`Loading GLB: ${GLB_PATH}`);
+const doc  = await (new NodeIO()).read(GLB_PATH);
+const meshData = [];
+
+for (const mesh of doc.getRoot().listMeshes()) {
+  for (const prim of mesh.listPrimitives()) {
+    const posAcc  = prim.getAttribute('POSITION');
+    if (!posAcc) continue;
+    const normAcc = prim.getAttribute('NORMAL');
+    const uvAcc   = prim.getAttribute('TEXCOORD_0');
+    const idxAcc  = prim.getIndices();
+    const positions = posAcc.getArray();
+    const normals   = normAcc?.getArray() ?? null;
+    const uvs       = uvAcc?.getArray()   ?? null;
+    const indices   = idxAcc?.getArray()  ?? null;
+    const triCount  = indices ? indices.length/3 : positions.length/9;
+    const triList   = [];
+    for (let t=0; t<triCount; t++) {
+      const i0 = indices ? indices[t*3]   : t*3;
+      const i1 = indices ? indices[t*3+1] : t*3+1;
+      const i2 = indices ? indices[t*3+2] : t*3+2;
+      triList.push(i0,i1,i2);
+    }
+    const mat = prim.getMaterial();
+    let texData=null, texW=1, texH=1;
+    if (mat) {
+      const baseColorTex = mat.getBaseColorTexture();
+      if (baseColorTex?.getImage()) {
+        const { data, info } = await sharp(Buffer.from(baseColorTex.getImage()))
+          .resize(512, 512, { fit:'fill' }).ensureAlpha().raw()
+          .toBuffer({ resolveWithObject: true });
+        texData = new Uint8ClampedArray(data); texW=info.width; texH=info.height;
+      }
+    }
+    if (!texData) {
+      const f = mat?.getBaseColorFactor() ?? [0.8,0.8,0.8,1];
+      texData = new Uint8ClampedArray([f[0]*255,f[1]*255,f[2]*255,f[3]*255|0]);
+      texW=1; texH=1;
+    }
+    meshData.push({ positions, normals, uvs, triList, texData, texW, texH });
+  }
+}
+console.log(`  Loaded ${meshData.length} primitive(s)`);
+
+// ── Normalize model to unit cube ──────────────────────────────────────────────
+let mnX=Infinity,mnY=Infinity,mnZ=Infinity,mxX=-Infinity,mxY=-Infinity,mxZ=-Infinity;
+for (const m of meshData) {
+  const p=m.positions;
+  for (let i=0; i<p.length; i+=3) {
+    if(p[i  ]<mnX)mnX=p[i  ]; if(p[i  ]>mxX)mxX=p[i  ];
+    if(p[i+1]<mnY)mnY=p[i+1]; if(p[i+1]>mxY)mxY=p[i+1];
+    if(p[i+2]<mnZ)mnZ=p[i+2]; if(p[i+2]>mxZ)mxZ=p[i+2];
+  }
+}
+const cx=(mnX+mxX)/2, cy=(mnY+mxY)/2, cz=(mnZ+mxZ)/2;
+const ext=Math.max(mxX-mnX,mxY-mnY,mxZ-mnZ)/2||1;
+for (const m of meshData) {
+  const p=m.positions;
+  for (let i=0; i<p.length; i+=3) { p[i]=(p[i]-cx)/ext; p[i+1]=(p[i+1]-cy)/ext; p[i+2]=(p[i+2]-cz)/ext; }
+}
+console.log(`  Normalized: extent=${ext.toFixed(3)}`);
+
+// ── Compute face bounding box (model space, after normalization) ───────────────
+// Face triangles: original normal Y > FACE_THRESHOLD (front face of the tile)
+// We use their model-space XZ extent to generate UV coords for the face texture.
+//   faceU = (x - faceXMin) / (faceXMax - faceXMin)   → tile left→right
+//   faceV = (z - faceZMin) / (faceZMax - faceZMin)   → 一(zMin)→万(zMax)
+//
+// Standard tile image (一 at top, 万 at bottom) maps directly onto this space.
+let faceXMin=Infinity,faceXMax=-Infinity,faceZMin=Infinity,faceZMax=-Infinity;
+for (const m of meshData) {
+  const { positions, normals } = m;
+  if (!normals) continue;
+  for (let i=0; i<positions.length/3; i++) {
+    if (normals[i*3+1] > FACE_THRESHOLD) {
+      const x=positions[i*3], z=positions[i*3+2];
+      if(x<faceXMin)faceXMin=x; if(x>faceXMax)faceXMax=x;
+      if(z<faceZMin)faceZMin=z; if(z>faceZMax)faceZMax=z;
+    }
+  }
+}
+const faceXRange = faceXMax-faceXMin || 1;
+const faceZRange = faceZMax-faceZMin || 1;
+console.log(`  Face bbox: X=[${faceXMin.toFixed(3)},${faceXMax.toFixed(3)}]  Z=[${faceZMin.toFixed(3)},${faceZMax.toFixed(3)}]`);
+
+// ── Render frames ─────────────────────────────────────────────────────────────
+async function renderFrame(ry) {
+  const pixels = new Uint8ClampedArray(RW*RH*4);
+  const zbuf   = new Float32Array(RW*RH).fill(-Infinity);
+
+  for (const m of meshData) {
+    const { positions, normals, uvs, triList, texData, texW, texH } = m;
+    const nTris = triList.length/3;
+
+    for (let t=0; t<nTris; t++) {
+      const i0=triList[t*3], i1=triList[t*3+1], i2=triList[t*3+2];
+
+      // Pose: rotX then rotY
+      function pose(i) { return rotY(rotX(v3(positions[i*3],positions[i*3+1],positions[i*3+2]),RX_INIT),ry); }
+      const p0=pose(i0), p1=pose(i1), p2=pose(i2);
+
+      // Backface cull
+      const faceN = normalize(cross(sub(p1,p0),sub(p2,p0)));
+      if (dot(faceN, sub(v3(0,0,CAMERA_Z),p0)) < 0) continue;
+
+      // World normals
+      function rotN(i) { return normals ? rotY(rotX(v3(normals[i*3],normals[i*3+1],normals[i*3+2]),RX_INIT),ry) : faceN; }
+      const n0=rotN(i0), n1=rotN(i1), n2=rotN(i2);
+
+      // ── Face texture injection ──────────────────────────────────────────────
+      // Detect face triangle by avg model-space normal Y
+      const avgNY = normals ? (normals[i0*3+1]+normals[i1*3+1]+normals[i2*3+1])/3 : 0;
+      const isFaceTri = faceTexData && avgNY > FACE_THRESHOLD;
+
+      let tu0,tv0,tu1,tv1,tu2,tv2, activeTex,activeTW,activeTH, flipU;
+
+      if (isFaceTri) {
+        // Model-space XZ → face UV  (一=zMin→faceV=0, 万=zMax→faceV=1)
+        tu0=(positions[i0*3]-faceXMin)/faceXRange; tv0=(positions[i0*3+2]-faceZMin)/faceZRange;
+        tu1=(positions[i1*3]-faceXMin)/faceXRange; tv1=(positions[i1*3+2]-faceZMin)/faceZRange;
+        tu2=(positions[i2*3]-faceXMin)/faceXRange; tv2=(positions[i2*3+2]-faceZMin)/faceZRange;
+        activeTex=faceTexData; activeTW=faceTexW; activeTH=faceTexH;
+        flipU = false;   // face never needs U-flip (only visible at ry≈0, CCW winding)
+      } else {
+        // Body/edges/back: use GLB UV atlas with isMirrored correction
+        tu0=uvs?uvs[i0*2]:0; tv0=uvs?uvs[i0*2+1]:0;
+        tu1=uvs?uvs[i1*2]:0; tv1=uvs?uvs[i1*2+1]:0;
+        tu2=uvs?uvs[i2*2]:0; tv2=uvs?uvs[i2*2+1]:0;
+        activeTex=texData; activeTW=texW; activeTH=texH;
+        flipU = null;    // null = use isMirrored auto-detection in rasterizer
+      }
+
+      rasterizeTri(pixels, zbuf,
+        project(p0), project(p1), project(p2),
+        tu0,tv0, tu1,tv1, tu2,tv2,
+        n0, n1, n2,
+        activeTex, activeTW, activeTH,
+        flipU);
+    }
+  }
+
+  // Downsample SSAA → output resolution
+  const out = new Uint8ClampedArray(W*H*4);
+  for (let y=0; y<H; y++) for (let x=0; x<W; x++) {
+    let r=0,g=0,b=0,a=0;
+    for (let sy=0; sy<SS; sy++) for (let sx=0; sx<SS; sx++) {
+      const i=((y*SS+sy)*RW+(x*SS+sx))*4;
+      r+=pixels[i]; g+=pixels[i+1]; b+=pixels[i+2]; a+=pixels[i+3];
+    }
+    const n2=SS*SS, oi=(y*W+x)*4;
+    out[oi]=r/n2; out[oi+1]=g/n2; out[oi+2]=b/n2; out[oi+3]=a/n2;
+  }
+  return Buffer.from(out.buffer);
+}
+
+// ── Generate frames ───────────────────────────────────────────────────────────
+const ROWS = Math.ceil(FRAMES/COLS);
+const frames = [];
+console.log(`Rendering ${FRAMES} frames (${W}×${H} × ${SS}² AA)...`);
+for (let i=0; i<FRAMES; i++) {
+  // ry: π → 0  (back face first → front face revealed)
+  const ry = Math.PI - (i/(FRAMES-1))*Math.PI;
+  process.stdout.write(`\r  Frame ${i+1}/${FRAMES}`);
+  frames.push(await renderFrame(ry));
+}
+console.log('\n  Compositing...');
+
+const pngFrames = await Promise.all(
+  frames.map(buf => sharp(buf,{raw:{width:W,height:H,channels:4}}).png().toBuffer())
+);
+await sharp({ create:{width:W*COLS,height:H*ROWS,channels:4,background:{r:0,g:0,b:0,alpha:0}} })
+  .composite(pngFrames.map((buf,i)=>({input:buf,left:(i%COLS)*W,top:Math.floor(i/COLS)*H})))
+  .png().toFile(OUT_PATH);
+
+console.log(`\nSaved → ${OUT_PATH}  (${COLS}×${ROWS} frames, ${W}×${H}px each)`);
+await sharp(pngFrames[0]).png().toFile(OUT_PATH.replace('.png','_frame0.png'));
+await sharp(pngFrames[FRAMES-1]).png().toFile(OUT_PATH.replace('.png','_frameN.png'));

package/skills/playcraft-3d-flip-sprite/renderer/render_single.mjs

@@ -0,0 +1,138 @@
+/**
+ * Single-frame 3D renderer: GLB + face texture → one PNG
+ * Usage: node render_single.mjs <face-texture.png> <output.png> [ry=0]
+ * Optimised for batch: SS=1, smaller canvas, preloaded GLB data
+ */
+import { NodeIO } from '@gltf-transform/core';
+import sharp from 'sharp';
+import { existsSync } from 'fs';
+
+// ── Config ─────────────────────────────────────────────────────────────────
+const FACE_TEX  = process.argv[2];
+const OUT_PATH  = process.argv[3];
+const RY        = parseFloat(process.argv[4] ?? '0');
+const GLB_PATH  = process.env.GLB ?? '/tmp/mahjong-tile/tile_1wan.glb';
+const W = 180, H = 180;
+const FACE_THRESHOLD = 0.7;
+const RX_INIT = 1.908;
+const FOCAL = 2.8, CAMERA_Z = 3.2;
+
+if (!FACE_TEX || !OUT_PATH) {
+  console.error('Usage: node render_single.mjs <face.png> <out.png> [ry]');
+  process.exit(1);
+}
+
+// ── Math ───────────────────────────────────────────────────────────────────
+const v3=(x,y,z)=>({x,y,z}),add=(a,b)=>v3(a.x+b.x,a.y+b.y,a.z+b.z),
+  sub=(a,b)=>v3(a.x-b.x,a.y-b.y,a.z-b.z),scl=(v,s)=>v3(v.x*s,v.y*s,v.z*s),
+  dot=(a,b)=>a.x*b.x+a.y*b.y+a.z*b.z,
+  cross=(a,b)=>v3(a.y*b.z-a.z*b.y,a.z*b.x-a.x*b.z,a.x*b.y-a.y*b.x);
+function nm(v){const l=Math.sqrt(dot(v,v))||1e-9;return scl(v,1/l);}
+function rotX(p,rx){const c=Math.cos(rx),s=Math.sin(rx);return v3(p.x,p.y*c-p.z*s,p.y*s+p.z*c);}
+function rotY(p,ry){const c=Math.cos(ry),s=Math.sin(ry);return v3(p.x*c+p.z*s,p.y,-p.x*s+p.z*c);}
+const LIGHT=nm(v3(0.3,0.8,1)),VIEW=v3(0,0,1);
+function proj(p){const dz=CAMERA_Z-p.z;return{sx:(p.x/dz)*FOCAL*W*0.42+W/2,sy:(-p.y/dz)*FOCAL*H*0.42+H/2,wClip:1/dz};}
+
+function bilin(tex,tw,th,u,v){
+  const fx=Math.max(0,Math.min(tw-1.001,u*(tw-1))),fy=Math.max(0,Math.min(th-1.001,v*(th-1)));
+  const x0=Math.floor(fx),y0=Math.floor(fy),sx=fx-x0,sy=fy-y0;
+  const I=(r,c)=>(r*tw+c)*4,o=new Float32Array(4);
+  for(let ch=0;ch<4;ch++)o[ch]=(tex[I(y0,x0)+ch]*(1-sx)+tex[I(y0,x0+1)+ch]*sx)*(1-sy)+(tex[I(y0+1,x0)+ch]*(1-sx)+tex[I(y0+1,x0+1)+ch]*sx)*sy;
+  return o;
+}
+
+function rasterize(px,zb,p0,p1,p2,u0,v0,u1,v1,u2,v2,n0,n1,n2,tex,tw,th,flipU){
+  const mxX=Math.min(W-1,Math.ceil(Math.max(p0.sx,p1.sx,p2.sx))),mnX=Math.max(0,Math.floor(Math.min(p0.sx,p1.sx,p2.sx)));
+  const mxY=Math.min(H-1,Math.ceil(Math.max(p0.sy,p1.sy,p2.sy))),mnY=Math.max(0,Math.floor(Math.min(p0.sy,p1.sy,p2.sy)));
+  const a2=(p1.sx-p0.sx)*(p0.sy-p2.sy)-(p0.sx-p2.sx)*(p1.sy-p0.sy);
+  if(Math.abs(a2)<1e-6)return;
+  const iM=a2<0,ia=1/Math.abs(a2),sg=iM?-1:1;
+  for(let py=mnY;py<=mxY;py++)for(let ppx=mnX;ppx<=mxX;ppx++){
+    const w0=sg*((ppx-p1.sx)*(p2.sy-p1.sy)-(py-p1.sy)*(p2.sx-p1.sx))*ia;
+    const w1=sg*((ppx-p2.sx)*(p0.sy-p2.sy)-(py-p2.sy)*(p0.sx-p2.sx))*ia;
+    const w2=1-w0-w1;
+    if(w0<0||w1<0||w2<0)continue;
+    const wI=w0*p0.wClip+w1*p1.wClip+w2*p2.wClip,pi=py*W+ppx;
+    if(wI<zb[pi])continue;zb[pi]=wI;
+    const uI=(w0*u0*p0.wClip+w1*u1*p1.wClip+w2*u2*p2.wClip)/wI;
+    const vI=(w0*v0*p0.wClip+w1*v1*p1.wClip+w2*v2*p2.wClip)/wI;
+    const nx=(w0*n0.x*p0.wClip+w1*n1.x*p1.wClip+w2*n2.x*p2.wClip)/wI;
+    const ny=(w0*n0.y*p0.wClip+w1*n1.y*p1.wClip+w2*n2.y*p2.wClip)/wI;
+    const nz=(w0*n0.z*p0.wClip+w1*n1.z*p1.wClip+w2*n2.z*p2.wClip)/wI;
+    const nL=Math.sqrt(nx*nx+ny*ny+nz*nz)||1e-9;
+    const nN={x:nx/nL,y:ny/nL,z:nz/nL};
+    const NdL=Math.max(0,dot(nN,LIGHT)),half=nm(add(LIGHT,VIEW)),NdH=Math.max(0,dot(nN,half));
+    const light=0.32+0.60*NdL,spec=0.18*Math.pow(NdH,48);
+    const uS=(flipU??iM)?1-uI:uI;
+    const col=bilin(tex,tw,th,Math.max(0,Math.min(1,uS)),Math.max(0,Math.min(1,vI)));
+    if(col[3]<8)continue;
+    const oi=pi*4;
+    px[oi]=Math.min(255,col[0]*light+255*spec);px[oi+1]=Math.min(255,col[1]*light+255*spec);
+    px[oi+2]=Math.min(255,col[2]*light+255*spec);px[oi+3]=col[3];
+  }
+}
+
+// ── Load GLB (cached via env GLB_CACHE_SKIP or read fresh) ─────────────────
+const doc = await (new NodeIO()).read(GLB_PATH);
+const meshData=[];
+for(const mesh of doc.getRoot().listMeshes()){
+  for(const prim of mesh.listPrimitives()){
+    const posA=prim.getAttribute('POSITION');if(!posA)continue;
+    const normA=prim.getAttribute('NORMAL'),uvA=prim.getAttribute('TEXCOORD_0'),idxA=prim.getIndices();
+    const pos=posA.getArray(),norms=normA?.getArray()??null,uvs=uvA?.getArray()??null,idx=idxA?.getArray()??null;
+    const tc=idx?idx.length/3:pos.length/9,tl=[];
+    for(let t=0;t<tc;t++){tl.push(idx?idx[t*3]:t*3,idx?idx[t*3+1]:t*3+1,idx?idx[t*3+2]:t*3+2);}
+    const mat=prim.getMaterial();let texData=null,texW=1,texH=1;
+    if(mat?.getBaseColorTexture()?.getImage()){
+      const{data,info}=await sharp(Buffer.from(mat.getBaseColorTexture().getImage()))
+        .resize(256,256,{fit:'fill'}).ensureAlpha().raw().toBuffer({resolveWithObject:true});
+      texData=new Uint8ClampedArray(data);texW=info.width;texH=info.height;
+    }
+    if(!texData){const f=mat?.getBaseColorFactor()??[0.8,0.8,0.8,1];texData=new Uint8ClampedArray([f[0]*255|0,f[1]*255|0,f[2]*255|0,f[3]*255|0]);texW=1;texH=1;}
+    meshData.push({pos,norms,uvs,tl,texData,texW,texH});
+  }
+}
+// Normalize
+let mnX=1e9,mnY=1e9,mnZ=1e9,mxX=-1e9,mxY=-1e9,mxZ=-1e9;
+for(const m of meshData){const p=m.pos;for(let i=0;i<p.length;i+=3){if(p[i]<mnX)mnX=p[i];if(p[i]>mxX)mxX=p[i];if(p[i+1]<mnY)mnY=p[i+1];if(p[i+1]>mxY)mxY=p[i+1];if(p[i+2]<mnZ)mnZ=p[i+2];if(p[i+2]>mxZ)mxZ=p[i+2];}}
+const cx=(mnX+mxX)/2,cy=(mnY+mxY)/2,cz=(mnZ+mxZ)/2,ext=Math.max(mxX-mnX,mxY-mnY,mxZ-mnZ)/2||1;
+for(const m of meshData){const p=m.pos;for(let i=0;i<p.length;i+=3){p[i]=(p[i]-cx)/ext;p[i+1]=(p[i+1]-cy)/ext;p[i+2]=(p[i+2]-cz)/ext;}}
+// Face bbox
+let fxMn=1e9,fxMx=-1e9,fzMn=1e9,fzMx=-1e9;
+for(const m of meshData){if(!m.norms)continue;for(let i=0;i<m.pos.length/3;i++){if(m.norms[i*3+1]>FACE_THRESHOLD){const x=m.pos[i*3],z=m.pos[i*3+2];if(x<fxMn)fxMn=x;if(x>fxMx)fxMx=x;if(z<fzMn)fzMn=z;if(z>fzMx)fzMx=z;}}}
+const fxR=fxMx-fxMn||1,fzR=fzMx-fzMn||1;
+
+// ── Load face texture ───────────────────────────────────────────────────────
+const{data:fData,info:fInfo}=await sharp(FACE_TEX).resize(256,256,{fit:'fill'}).ensureAlpha().raw().toBuffer({resolveWithObject:true});
+const faceTexData=new Uint8ClampedArray(fData),faceW=fInfo.width,faceH=fInfo.height;
+
+// ── Render ─────────────────────────────────────────────────────────────────
+const pixels=new Uint8ClampedArray(W*H*4),zbuf=new Float32Array(W*H).fill(-Infinity);
+const ry=RY;
+for(const m of meshData){
+  const{pos,norms,uvs,tl,texData,texW,texH}=m;
+  for(let t=0;t<tl.length/3;t++){
+    const i0=tl[t*3],i1=tl[t*3+1],i2=tl[t*3+2];
+    const pp=i=>rotY(rotX(v3(pos[i*3],pos[i*3+1],pos[i*3+2]),RX_INIT),ry);
+    const[p0,p1,p2]=[pp(i0),pp(i1),pp(i2)];
+    const fN=nm(cross(sub(p1,p0),sub(p2,p0)));
+    if(dot(fN,sub(v3(0,0,CAMERA_Z),p0))<0)continue;
+    const rn=i=>norms?rotY(rotX(v3(norms[i*3],norms[i*3+1],norms[i*3+2]),RX_INIT),ry):fN;
+    const avgNY=norms?(norms[i0*3+1]+norms[i1*3+1]+norms[i2*3+1])/3:0;
+    const isFace=avgNY>FACE_THRESHOLD;
+    let u0,v0,u1,v1,u2,v2,tex,tw,th,flipU;
+    if(isFace){
+      u0=(pos[i0*3]-fxMn)/fxR;v0=(pos[i0*3+2]-fzMn)/fzR;
+      u1=(pos[i1*3]-fxMn)/fxR;v1=(pos[i1*3+2]-fzMn)/fzR;
+      u2=(pos[i2*3]-fxMn)/fxR;v2=(pos[i2*3+2]-fzMn)/fzR;
+      tex=faceTexData;tw=faceW;th=faceH;flipU=false;
+    }else{
+      u0=uvs?uvs[i0*2]:0;v0=uvs?uvs[i0*2+1]:0;
+      u1=uvs?uvs[i1*2]:0;v1=uvs?uvs[i1*2+1]:0;
+      u2=uvs?uvs[i2*2]:0;v2=uvs?uvs[i2*2+1]:0;
+      tex=texData;tw=texW;th=texH;flipU=null;
+    }
+    rasterize(pixels,zbuf,proj(p0),proj(p1),proj(p2),u0,v0,u1,v1,u2,v2,rn(i0),rn(i1),rn(i2),tex,tw,th,flipU);
+  }
+}
+await sharp(Buffer.from(pixels.buffer),{raw:{width:W,height:H,channels:4}}).png().toFile(OUT_PATH);

package/skills/playcraft-asset-management/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: playcraft-asset-management
+description: PlayCraft 项目素材管理。查看项目资产列表、生成或处理图片/音频素材、替换现有资产文件。
+compatibility: agent
+---
+
+## Skill Definition
+tools:
+  - bash
+  - read
+  - write
+prompt_extension: |
+  你负责 PlayCraft 项目的素材（资产）查询与管理。
+  通过 bash 工具运行 `playcraft tools` CLI 命令完成素材生成与处理。
+
+  ## 能力清单
+
+  ### 查询项目资产
+  通过 bash 运行 `playcraft tools list-assets --project-id <projectId>` 获取指定项目中的所有资产。
+  - 输入：projectId（数字，如 10000013）；可选过滤：`--types texture,audio,script`、`--search <名称>`
+  - 输出：按类型分组的资产列表，含 id、name、type、fileSize
+
+  ### 读取资产文件内容
+  资产文件存储在 sandbox 中。用 read 工具读取指定路径的文件，路径通常为 `/assets/<assetId>/asset.json` 或 `/files/<name>`。
+
+  ### 生成新素材
+  - 图片：`playcraft tools generate-image --prompt "<描述>" --output <路径> [--aspect-ratio ...] [--image-model ...]`（文生图/图生图）
+  - 音效：`playcraft tools generate-sfx --prompt "<英文描述>" --output <路径>`
+  - BGM：`playcraft tools generate-bgm --prompt "<描述>" --output <路径>`
+  - 精灵图合并：`playcraft image sprite-sheet --inputs <图1,图2,...> --output <基路径>`（本地生成 PNG + JSON 元数据，见 playcraft-sprite-sheet）
+
+  ### 处理/替换现有素材
+  - 图片：`playcraft image <子命令>`（如 `resize` / `crop` / `convert` / `remove-background` / `overlay` 等），见 playcraft-image-processing；**不存在** `playcraft tools process-image`
+  - write：将新文件内容写入 sandbox 中的资产路径，完成替换
+
+  ## 工作流示例
+
+  ### 查看项目中所有图片
+  1. `playcraft tools list-assets --project-id <ID> --types texture`
+  2. terminate — 汇报图片列表
+
+  ### 替换某张背景图
+  1. `playcraft tools list-assets --search "background"` 定位资产 ID
+  2. `playcraft tools generate-image --prompt "..." --output <路径>` 生成新图片
+  3. `playcraft image resize --input <路径> --output <路径> --width <W> --height <H> --fit contain`（或其它 `playcraft image` 子命令）调整至目标规格
+  4. write 写入资产路径
+  5. terminate — 汇报完成
+
+  ## 注意事项
+  - projectId 是数字型 ID，可从 list_remixes 或编辑器 URL 获取
+  - 资产 ID 是数字（numericId），不是 UUID
+  - 替换文件后，变体需要重新构建才会反映到发布版本
+
+## 我做什么
+
+- 列出项目中所有资产，支持按类型、名称筛选
+- 生成新的图片、音频、精灵图素材
+- 处理现有图片（缩放、裁剪、格式转换）
+- 将生成的素材写入项目，完成替换
+
+## 何时用我
+
+- "项目 X 里有哪些图片素材？"
+- "帮我为项目 X 生成一张新的背景图"
+- "把项目 X 的 logo 替换成一个圆角版本"
+- "列出项目 X 中所有音频文件"
+
+## 工作流
+
+1. **`playcraft tools list-assets`** — 通过 bash 获取资产列表，定位目标资产
+2. **`playcraft tools generate-image` / `generate-sfx` / `generate-bgm`** 与 **`playcraft image …`**（本地处理）— 通过 bash 生成或处理素材（如需）
+3. **write** — 将新素材写入 sandbox 资产路径（如需替换）
+4. **terminate** — 汇报结果（资产清单 / 生成文件路径 / 替换状态）

package/skills/playcraft-audio-generation/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: playcraft-audio-generation
+description: 为可玩广告生成、处理和优化音频资产（BGM + SFX）。通过 playcraft CLI 调用平台 AI 生成与本地 ffmpeg 处理，支持体积预算管理。
+compatibility: agent,opencode
+---
+
+## CLI 与 Atom skill（`*.aiaudio`）
+
+- **AI 音频入口**：`playcraft tools generate-sfx`（音效）、`playcraft tools generate-bgm`（BGM）。当前 CLI **不提供** `playcraft audio gen`；后处理用 `playcraft audio <子命令>`（见下表 `## Skill Definition` → tools）。
+- **参数来源**：某音频 Atom 的提示词、时长等以该目录 **`manifest.json` → `generation`** 为准，再映射到上述命令行选项。
+
+## Skill Definition
+tools:
+  - bash
+  - read
+  - write
+  - generate_sfx
+  - generate_bgm
+  - audio_info
+  - audio_compress
+  - audio_trim
+  - audio_convert
+  - audio_fade
+  - audio_concat
+  - audio_normalize
+  - audio_loop
+  - audio_mix
+prompt_extension: |
+  你是可玩广告的专业音频设计师。核心原则：
+  - **仅 CLI**：AI 生成只用 `playcraft tools generate-sfx` / `generate-bgm`，后处理只用 `playcraft audio *`；不要索取、配置或讨论任何第三方 API 密钥，不要用 curl/SDK 直连云厂商
+  1. 体积优先：可玩广告有严格体积限制（Facebook 2MB / ironSource 5MB），音频要尽可能小
+  2. 先生成再优化：AI 生成高质量音频 → 本地压缩/裁剪到目标体积
+  3. BGM 必须可循环：用 `playcraft audio loop --crossfade 0.5` 处理无缝循环
+  4. SFX 要短促有力：通常 0.1-3s
+  5. 风格一致：用 `playcraft audio normalize` 统一全套音效音量
+  6. **SFX 的 `--prompt` 必须英文**：`generate-sfx` 不支持有效中文/多语种描述；用户给中文时要译成简洁英文再调用。提示词风格与基础技能 `sound-effects` 一致——具体场景、材质、风格、情绪；避免对白式长句，减少类 TTS 听感
+
+  典型工作流程：
+  1. 用 `playcraft audio info` 评估已有音频，计算体积预算
+  2. 用 `playcraft tools generate-bgm` 生成 BGM，`playcraft tools generate-sfx` 生成各音效
+  3. 用 `playcraft audio loop` 处理 BGM 无缝循环
+  4. 用 `playcraft audio normalize` 统一所有音频音量
+  5. 用 `playcraft audio info` 检查总体积
+  6. 体积超标时，用 `playcraft audio compress --target-size 30KB` 逐个压缩
+  7. 必要时用 `playcraft audio trim` 裁剪、`playcraft audio fade` 加淡入淡出
+
+## 我做什么
+
+- 为可玩广告生成 BGM（20-30s 循环）和 SFX（点击、爆炸、胜利等）
+- 本地处理：压缩、裁剪、循环化、归一化、混音
+- 管理音频体积预算，确保满足平台限制
+
+## 何时用我
+
+在可玩广告项目中，需要为游戏添加背景音乐或音效时。
+
+## AI 生成命令（仅用 CLI）
+
+凭当前 Agent 会话身份调用平台；**不要**配置或讨论任何第三方 API 密钥。
+
+```bash
+# 生成音效（SFX，--prompt 仅英文）
+playcraft tools generate-sfx \
+  --prompt "Crisp UI button click, short tail, no voice" \
+  --duration 0.5 \
+  --output ./assets/audio/click.mp3
+
+# 生成 BGM（Google Lyria 3，固定 30s）
+playcraft tools generate-bgm \
+  --prompt "轻快的休闲游戏背景音乐" \
+  --style casual \
+  --bpm 100 \
+  --output ./assets/audio/bgm.mp3
+```
+
+## 本地音频处理命令（不调 API，纯本地 ffmpeg）
+
+```bash
+# 获取音频信息（体积、时长、比特率）
+playcraft audio info --input bgm.mp3
+# 输出: { "duration": 30.0, "fileSize": 52000, "bitrate": 128, ... }
+
+# 压缩（指定比特率）
+playcraft audio compress --input bgm.mp3 --output bgm.mp3 --bitrate 64 --mono
+
+# 压缩（指定目标体积，自动计算比特率）
+playcraft audio compress --input bgm.mp3 --output bgm_small.mp3 --target-size 30KB
+
+# 裁剪
+playcraft audio trim --input bgm.mp3 --output intro.mp3 --start 0 --end 10
+
+# 格式转换
+playcraft audio convert --input sound.wav --output sound.mp3 --bitrate 128
+
+# 淡入淡出
+playcraft audio fade --input bgm.mp3 --output bgm.mp3 --fade-in 0.5 --fade-out 1.0
+
+# 无缝循环处理（BGM 必做）
+playcraft audio loop --input bgm.mp3 --output bgm.mp3 --crossfade 0.5
+
+# 音量归一化（统一所有音效的音量）
+playcraft audio normalize --input bgm.mp3 --output bgm.mp3 --target-loudness -16
+
+# 拼接多个音频
+playcraft audio concat --inputs intro.mp3 loop.mp3 outro.mp3 --output full.mp3
+
+# 多轨混音（指定音量/时间偏移）
+playcraft audio mix \
+  --inputs bgm.mp3 click.mp3 \
+  --volumes 0.8 1.0 \
+  --offsets 0 2.5 \
+  --output preview.mp3
+```
+
+## 体积预算参考
+
+| 平台 | 总限制 | 音频建议预算 | BGM 目标大小 | SFX 目标大小 |
+|------|--------|------------|------------|------------|
+| Facebook | 2MB | 200-300KB | 30-60KB | 5-15KB |
+| ironSource | 5MB | 500KB | 60-100KB | 10-20KB |
+| Google | 5MB | 500KB | 60-100KB | 10-20KB |
+
+## 输出
+
+- 通常为 MP3 格式
+- 每次完成后输出体积报告（各文件大小 + 总计）