Andee lives on your phone or Mac and uses any app like you do—no integrations, no root, any model; memory and passwords never leave your device | Andee 住进你的手机或 Mac,像你一样操作任何 App——无需集成、无需 Root、支持任意模型,记忆和密码绝不离开设备。
<!DOCTYPE html>
<html lang="zh-CN" data-page-node-id="hJTC176C2uAF7p7h5xRD5q">
<head data-page-node-id="4slCRHHEGMdHcTHsXmZUbE">
<meta charset="utf-8" data-page-node-id="O9HpAC3UFFxWLUftFe5zFn">
<meta name="viewport" content="width=device-width, initial-scale=1" data-page-node-id="ExHcPBiuwcXrHgpok4jDyD">
<title>球球可爱度实验室 · andee</title>
<style>
:root{
--bg:#f6f7f9; --panel:#ffffff; --line:#e3e6ec; --ink:#1b1f27;
--ink2:#5b6472; --ink3:#8b95a5; --accent:#3b6ef5;
--card:#0f172a;
--app:#eef1f6;
}
*{box-sizing:border-box}
body{
margin:0; background:var(--bg); color:var(--ink);
font:14px/1.6 -apple-system,BlinkMacSystemFont,"PingFang SC","Helvetica Neue",Arial,sans-serif;
-webkit-font-smoothing:antialiased;
}
header{padding:20px 24px 8px;max-width:1180px;margin:0 auto}
h1{margin:0 0 4px;font-size:19px;letter-spacing:-.01em}
.sub{color:var(--ink2);font-size:13px}
code{background:#eef0f4;padding:1px 5px;border-radius:4px;font-size:11.5px}
.wrap{max-width:1180px;margin:0 auto;padding:0 24px 48px;display:grid;
grid-template-columns:250px 1fr;gap:20px;align-items:start}
@media(max-width:900px){.wrap{grid-template-columns:1fr}}
.panel{background:var(--panel);border:1px solid var(--line);border-radius:12px;padding:14px}
.panel h2{margin:0 0 10px;font-size:12px;letter-spacing:.08em;text-transform:uppercase;color:var(--ink3);font-weight:600}
.sticky{position:sticky;top:16px}
.presets{display:flex;flex-direction:column;gap:6px;margin-bottom:16px}
.presets button{
text-align:left;padding:9px 11px;border:1px solid var(--line);background:#fff;
border-radius:9px;cursor:pointer;font:inherit;color:var(--ink);transition:.13s;
}
.presets button:hover{border-color:#c6cdd9}
.presets button[aria-pressed=true]{border-color:var(--accent);background:#eef3ff;box-shadow:inset 3px 0 0 var(--accent)}
.presets .tag{display:block;font-size:11px;color:var(--ink3);margin-top:1px}
label.row{display:flex;justify-content:space-between;align-items:center;gap:8px;margin:11px 0 3px;font-size:12px;color:var(--ink2)}
label.row b{font-weight:600;color:var(--ink);font-variant-numeric:tabular-nums}
input[type=range]{width:100%;accent-color:var(--accent)}
select{width:100%;padding:7px 9px;border:1px solid var(--line);border-radius:8px;background:#fff;font:inherit;color:var(--ink)}
.grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(168px,1fr));gap:14px}
.cell{background:var(--panel);border:1px solid var(--line);border-radius:12px;overflow:hidden;cursor:pointer;
transition:border-color .13s, box-shadow .13s}
.cell:hover{border-color:#c6cdd9}
.cell[aria-pressed=true]{border-color:var(--accent);box-shadow:0 0 0 1px var(--accent)}
.cell .stage{position:relative;aspect-ratio:1;display:flex;align-items:center;justify-content:center}
.cell .stage.dark{background:var(--card)}
.cell .stage.app{background:var(--app)}
.cell .stage.app::before{
content:"";position:absolute;inset:0;pointer-events:none;
background:
radial-gradient(circle at 24% 30%, #ffffff 0 28px, transparent 29px),
radial-gradient(circle at 78% 70%, #ffffff 0 40px, transparent 41px),
linear-gradient(transparent 0 44px, #ffffff 44px 46px, transparent 46px);
opacity:.9;
}
.cell canvas{position:relative;display:block;width:100%;height:100%}
.cell .cap{padding:9px 12px 11px;border-top:1px solid var(--line)}
.cell .cap b{font-size:13px}
.cell .cap span{display:block;font-size:11.5px;color:var(--ink3);margin-top:1px}
.badge{position:absolute;top:8px;left:8px;font-size:10.5px;letter-spacing:.04em;
padding:2px 7px;border-radius:20px;background:rgba(255,255,255,.14);color:#cfd6e4;
border:1px solid rgba(255,255,255,.16);z-index:2}
.stage.app .badge{background:rgba(15,23,42,.06);color:#5b6472;border-color:rgba(15,23,42,.1)}
.hero{background:var(--panel);border:1px solid var(--line);border-radius:12px;padding:14px;display:grid;
grid-template-columns:1fr 250px;gap:16px;align-items:center}
@media(max-width:1000px){.hero{grid-template-columns:1fr}}
.hpair{display:grid;grid-template-columns:1fr 1fr;gap:12px}
.hstage{position:relative;border-radius:10px;display:flex;align-items:center;justify-content:center;
padding:10px;overflow:hidden}
.hstage.dark{background:var(--card)}
.hstage.app{background:var(--app)}
.hstage.app::before{content:"";position:absolute;inset:0;pointer-events:none;
background:radial-gradient(circle at 24% 30%, #fff 0 30px, transparent 31px),
radial-gradient(circle at 78% 72%, #fff 0 44px, transparent 45px);opacity:.9}
.hstage canvas{position:relative;width:100%;aspect-ratio:1;display:block}
.hbadge{position:absolute;top:8px;left:8px;font-size:10.5px;letter-spacing:.04em;z-index:2;
padding:2px 7px;border-radius:20px;background:rgba(255,255,255,.14);color:#cfd6e4;
border:1px solid rgba(255,255,255,.16)}
.hstage.app .hbadge{background:rgba(15,23,42,.06);color:#5b6472;border-color:rgba(15,23,42,.1)}
.seg{display:inline-flex;gap:0;margin-left:10px;vertical-align:middle;border:1px solid var(--line);
border-radius:8px;overflow:hidden}
.seg button{border:0;background:#fff;font:inherit;font-size:12px;padding:3px 11px;cursor:pointer;color:var(--ink2)}
.seg button[aria-pressed=true]{background:var(--accent);color:#fff}
.hero .notes{font-size:12.5px;color:var(--ink2)}
.hero .notes h3{margin:0 0 7px;font-size:12px;letter-spacing:.08em;text-transform:uppercase;color:var(--ink3)}
.hero .notes ul{margin:0;padding-left:16px}
.hero .notes li{margin-bottom:5px}
.sec{margin:22px 0 10px;font-size:13px;font-weight:600;color:var(--ink)}
.sec em{font-style:normal;font-weight:400;color:var(--ink3);font-size:12px;margin-left:6px}
.legend{margin-top:14px;font-size:12.5px;color:var(--ink2);border-top:1px solid var(--line);padding-top:10px}
#err{margin:14px 0;padding:12px;border-radius:10px;background:#fff1f1;border:1px solid #f5c2c2;
color:#a02020;font:12px/1.5 ui-monospace,SFMono-Regular,Menlo,monospace;white-space:pre-wrap;display:none}
</style>
</head>
<body data-page-node-id="SPoEpCghNXJ2BBcVKouME5">
<header data-page-node-id="C3dS7imDfzSrXCYs3EGg8D">
<h1 data-page-node-id="LsEdSfvFA8mQT1DMHaHzSu">球球可爱度实验室</h1>
<div class="sub" data-page-node-id="ArBs6ap0weFHb8cUrkZFZi">
画的就是 <code data-page-node-id="mDIEh3CoaxhsYWEXrntO86">EmotionBallRenderer</code> 每一帧在画的那批三角形,不是手绘示意图。
左边选预设,右边是同一个球在不同底子上的样子。每个滑块都对应代码里一个常量。
</div>
<div class="sub" style="margin-top:10px;padding:10px 13px;background:#eef3ff;border:1px solid #cfdcff;border-radius:9px;color:#2a3a5e">
<b>奶油球</b>和<b>小恶魔</b>是落地的两套 —— <code>BallLook.kt</code> 里的 <code>CREAM</code> 与 <code>IMP</code>,
表情表、几何、材质与这个页面逐字一致。果冻球也原样保留成 <code>JELLY</code>,留作对照。
<b>现在</b>是改动前的原样,同样留作对照。
</div>
<div class="sub" style="margin-top:10px;padding:10px 13px;background:#fff7ed;border:1px solid #fed7aa;border-radius:9px;color:#7c3d0a">
⚠️ 这一页<b>还没画得出</b>小恶魔的角、獠牙、尾巴,也没画过八戒的猪鼻。选中那两颗球时,
<b>脸</b>是真机上那套,<b>轮廓不是</b> —— 别照着这个圆球去判断它们的边界形状。
</div>
</header>
<div class="wrap" data-page-node-id="9HLcd6JUUvl59L0PSgyFBq">
<div class="panel sticky" data-page-node-id="HABepjNBIjQbY5mIlxUVr6">
<h2 data-page-node-id="C0jVPSKXrONWIuAjoSJG4Z">预设</h2>
<div class="presets" id="presets" data-page-node-id="upEDhOFwpJRq7Mo8cyRBIX"></div>
<h2 data-page-node-id="sEwhmEbvpEySRQWa4uBsCD">表情</h2>
<select id="mood" data-page-node-id="TZKO9dDFXI0Dq3kLQTfNRo"></select>
<label class="row" data-page-node-id="Dglty4qiK3L8HDmEezOsxR"><span data-page-node-id="UN9G4sHG0Bj8UOjfC0WL1F">眼睛大小</span><b id="v-eyeR" data-page-node-id="DYYLAOZzF6vimgx2W8FeL1"></b></label>
<input type="range" id="s-eyeR" min="0.06" max="0.17" step="0.004" data-page-node-id="KIz5AOYP03RgasdHpxm6Kx">
<label class="row" data-page-node-id="PukAk0fccJffQg6XoNWxAd"><span data-page-node-id="wdCOS4nl7TbGQFtfSlXwaB">眼睛间距</span><b id="v-eyeX" data-page-node-id="wz2ETthFuyKnu8oCAJXOCA"></b></label>
<input type="range" id="s-eyeX" min="0.16" max="0.36" step="0.004" data-page-node-id="l9Py8pmsQ6bOWullzaj5I5">
<label class="row" data-page-node-id="xgUeCusNQrGCXnChzeGh8h"><span data-page-node-id="TE1FMTFvdliJzcrCcU5n7N">眼睛高低</span><b id="v-eyeY" data-page-node-id="AKWbvoulvHQUsNM50PnTFy"></b></label>
<input type="range" id="s-eyeY" min="0.06" max="0.34" step="0.004" data-page-node-id="RTBkRUjpXdFZ5Zlw2fipfN">
<label class="row" data-page-node-id="wVfI6BzFBHrutMvuSuZXXb"><span data-page-node-id="UfS7UOXhtP6OKE1vHOz4vM">身体上色量</span><b id="v-tint" data-page-node-id="IsBZ3f64VsrgC1ajn7Aokz"></b></label>
<input type="range" id="s-tint" min="0" max="1" step="0.02" data-page-node-id="L60TKqLya1hloUPtVYyalx">
<label class="row" data-page-node-id="0G1NGHz2IBzHg5BWEoiVSW"><span data-page-node-id="xiIhwCG1jYQjA9sA3SW7Ge">身体明度</span><b id="v-mul" data-page-node-id="T8EjUg3i9AMkYbwgoHGH83"></b></label>
<input type="range" id="s-mul" min="0.4" max="1.15" step="0.02" data-page-node-id="GTnQGUpdtU7uAsOFG6wM0y">
<label class="row" data-page-node-id="iPBIDqhsHP63yTqaraCJee"><span data-page-node-id="grbkX5XBhzUEIXWHDckyml">镜面光泽</span><b id="v-gloss" data-page-node-id="NPMwWGefUK0sDS8HoVTCN5"></b></label>
<input type="range" id="s-gloss" min="0" max="1.6" step="0.05" data-page-node-id="T1XQfesEwg8JzF2xzR9hWB">
<label class="row" data-page-node-id="sSdrRiTlMSAfbQBsHCZ0ok"><span data-page-node-id="v98mmPaA8BH7wiQUUWMKtz">腮红</span><b id="v-blush" data-page-node-id="dSfidlMTI8HEJhKoa1CuOs"></b></label>
<input type="range" id="s-blush" min="0" max="2.4" step="0.05" data-page-node-id="Mh0jNmmGfbyp3PUVb5fopW">
<label class="row" data-page-node-id="EeTUqBAxMWNFe2FHi4RxOe"><span data-page-node-id="2h4F5Ra1j3mS3aCypOk2gG">嘴角上扬加成</span><b id="v-smile" data-page-node-id="hQwmt0CQZdkb33gFHrksXw"></b></label>
<input type="range" id="s-smile" min="-0.2" max="0.45" step="0.01" data-page-node-id="xolz6DWREygBhlVGXA7f6Y">
<label class="row"><span>鼻涕泡大小</span><b id="v-bubR"></b></label>
<input type="range" id="s-bubR" min="0.03" max="0.16" step="0.005">
<label class="row"><span>鼻涕泡高低</span><b id="v-bubY"></b></label>
<input type="range" id="s-bubY" min="-0.20" max="0.05" step="0.005">
<label class="row"><span>泡的厚度</span><b id="v-bubIn"></b></label>
<input type="range" id="s-bubIn" min="0" max="0.5" step="0.01">
<h2 style="margin-top:18px">耳朵</h2>
<label class="row"><span>耳朵大小</span><b id="v-earH"></b></label>
<input type="range" id="s-earH" min="0" max="0.55" step="0.01">
<label class="row"><span>耳朵高低</span><b id="v-earY"></b></label>
<input type="range" id="s-earY" min="0.40" max="0.90" step="0.01">
<label class="row"><span>耳朵左右</span><b id="v-earX"></b></label>
<input type="range" id="s-earX" min="0.10" max="0.55" step="0.01">
<label class="row"><span>耳朵撇开(度)</span><b id="v-earTilt"></b></label>
<input type="range" id="s-earTilt" min="-30" max="60" step="1">
<label class="row"><span>耳朵暗一档</span><b id="v-earShade"></b></label>
<input type="range" id="s-earShade" min="0.30" max="1" step="0.02">
<h2 style="margin-top:18px">眉毛</h2>
<label class="row"><span>眉毛长度</span><b id="v-browW"></b></label>
<input type="range" id="s-browW" min="0" max="0.30" step="0.005">
<label class="row"><span>眉毛高低</span><b id="v-browY"></b></label>
<input type="range" id="s-browY" min="0.03" max="0.32" step="0.005">
<label class="row"><span>眉毛倾角(度)</span><b id="v-browTilt"></b></label>
<input type="range" id="s-browTilt" min="-30" max="30" step="1">
<h2 style="margin-top:18px">眼神</h2>
<label class="row"><span>眼睛上沿切平</span><b id="v-eyeCut"></b></label>
<input type="range" id="s-eyeCut" min="0" max="0.85" step="0.01">
<label class="row"><span>眼睛倾角(度)</span><b id="v-eyeTilt"></b></label>
<input type="range" id="s-eyeTilt" min="-24" max="24" step="1">
<label class="row"><span>瞳孔竖缝</span><b id="v-pupilAspect"></b></label>
<input type="range" id="s-pupilAspect" min="0.25" max="1" step="0.01">
<button id="reset" style="margin-top:14px;width:100%;padding:8px;border:1px solid var(--line);background:#fff;border-radius:9px;font:inherit;cursor:pointer;color:var(--ink2)" data-page-node-id="MsiIXrvrt2aqAPJ2AEw1OU">
还原此预设
</button>
<div class="legend" data-page-node-id="YJVBjoZyCoFB3Q0bfWn9JZ">
瞳孔大小 / 高光由预设决定,不给滑块 —— 那是造型选择,不是调参。
<b>瞳孔竖缝</b>例外:那是"换物种"那一档,值得单独试。
</div>
</div>
<div data-page-node-id="xHcP9fBoFkC2vu3VH59FJR">
<div id="err" data-page-node-id="iSvxKDZoG2BMcUjEaWOwfP"></div>
<div class="sec">放大细节 <em>选中的预设 · 两种底子并排看</em></div>
<div class="hero">
<div class="hpair">
<div class="hstage dark"><div class="hbadge">深色卡片</div><canvas class="heroCv"></canvas></div>
<div class="hstage app"><div class="hbadge">亮色 App</div><canvas class="heroCv"></canvas></div>
</div>
<div class="notes">
<h3>在改什么</h3>
<ul>
<li><b>眼睛</b>:改前半径 0.075、间距 ±0.30、位置 y=0.30 —— 又小又高又分家,那是一张机器人的脸。</li>
<li><b>幼态三件套</b>:放大、往中间收、往下降,额头留大。</li>
<li><b>身体</b>:改前是纯平近黑色。顶光渐变 + 高光点,球才有体积。</li>
<li><b>眼睛内容</b>:白眼球加瞳孔,或深色豆豆眼加一点白高光。</li>
<li><b>腮红</b>:改前只有 HAPPY/SUCCESS 有 —— 静止那张脸一整天没有脸颊。</li>
<li><b>嘴</b>:改前是条发丝细的弧,80dp 的球上读不出表情。</li>
</ul>
<h3 style="margin-top:12px">量出来的数(占球径)</h3>
<ul>
<li>奶油球(当前落地):眼宽 <b>0.17</b> · 长宽比 <b>1.25</b> · 内距 <b>0.20</b> · 嘴宽 <b>0.29</b></li>
<li>果冻球(备选):眼宽 0.18 · 内距 0.17 · 眼心高 0.22</li>
<li>改前对应是 0.10 / 2.25 / 0.30 / 0.37。</li>
<li>眼心从球心上方 40% 降到 <b>22%</b> —— 额头留大,这是幼态脸的算法。</li>
<li>腮红:脸颊像素从 <code>(57,66,95)</code> 抬到 <code>(138,100,140)</code>。</li>
</ul>
</div>
</div>
<div class="sec">
七套方案 <em>168dp 窗口的 1:1 真实尺寸 · 点一个看大图</em>
<span class="seg" id="bgToggle">
<button type="button" data-bg="dark" aria-pressed="true">深色卡片</button>
<button type="button" data-bg="app" aria-pressed="false">亮色 App</button>
</span>
</div>
<div class="grid" id="grid"></div>
</div>
</div>
<script>
"use strict";
/* =========================================================================
1. mat4 —— 列主序,跟 android.opengl.Matrix 同一套约定
========================================================================= */
const M4 = {
id(){ return new Float32Array([1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1]); },
perspective(fovyDeg, aspect, near, far){
const f = 1/Math.tan(fovyDeg*Math.PI/180/2), m = new Float32Array(16);
m[0]=f/aspect; m[5]=f; m[10]=(far+near)/(near-far); m[11]=-1;
m[14]=2*far*near/(near-far); return m;
},
lookAt(ex,ey,ez, cx,cy,cz, ux,uy,uz){
let zx=ex-cx, zy=ey-cy, zz=ez-cz, l=Math.hypot(zx,zy,zz);
zx/=l; zy/=l; zz/=l;
let xx=uy*zz-uz*zy, xy=uz*zx-ux*zz, xz=ux*zy-uy*zx;
l=Math.hypot(xx,xy,xz)||1; xx/=l; xy/=l; xz/=l;
const yx=zy*xz-zz*xy, yy=zz*xx-zx*xz, yz=zx*xy-zy*xx;
const m=new Float32Array(16);
m[0]=xx; m[4]=xy; m[8]=xz; m[12]=-(xx*ex+xy*ey+xz*ez);
m[1]=yx; m[5]=yy; m[9]=yz; m[13]=-(yx*ex+yy*ey+yz*ez);
m[2]=zx; m[6]=zy; m[10]=zz; m[14]=-(zx*ex+zy*ey+zz*ez);
m[15]=1; return m;
},
mul(a,b){
const o=new Float32Array(16);
for(let c=0;c<4;c++)for(let r=0;r<4;r++){
let s=0; for(let k=0;k<4;k++) s+=a[k*4+r]*b[c*4+k];
o[c*4+r]=s;
} return o;
},
translate(m,x,y,z){ const t=M4.id(); t[12]=x;t[13]=y;t[14]=z; return M4.mul(m,t); },
scale(m,x,y,z){ const t=M4.id(); t[0]=x;t[5]=y;t[10]=z; return M4.mul(m,t); },
rotate(m,deg,ax,ay,az){
let l=Math.hypot(ax,ay,az); ax/=l; ay/=l; az/=l;
const a=deg*Math.PI/180, s=Math.sin(a), c=Math.cos(a), t=1-c, r=M4.id();
r[0]=t*ax*ax+c; r[1]=t*ax*ay+s*az; r[2]=t*ax*az-s*ay;
r[4]=t*ax*ay-s*az; r[5]=t*ay*ay+c; r[6]=t*ay*az+s*ax;
r[8]=t*ax*az+s*ay; r[9]=t*ay*az-s*ax; r[10]=t*az*az+c;
return M4.mul(m,r);
},
};
/* =========================================================================
2. 几何体 —— IcoSphere / UvSphere / Capsule / Torus 的逐行移植
========================================================================= */
function icoSphere(subdivisions){
const t=(1+Math.sqrt(5))/2;
const base=[-1,t,0, 1,t,0, -1,-t,0, 1,-t,0,
0,-1,t, 0,1,t, 0,-1,-t, 0,1,-t,
t,0,-1, t,0,1, -t,0,-1, -t,0,1];
const pos=[];
for(let i=0;i<12;i++){
const x=base[i*3],y=base[i*3+1],z=base[i*3+2], inv=1/Math.hypot(x,y,z);
pos.push(x*inv,y*inv,z*inv);
}
let faces=[0,11,5, 0,5,1, 0,1,7, 0,7,10, 0,10,11,
1,5,9, 5,11,4, 11,10,2, 10,7,6, 7,1,8,
3,9,4, 3,4,2, 3,2,6, 3,6,8, 3,8,9,
4,9,5, 2,4,11, 6,2,10, 8,6,7, 9,8,1];
const cache=new Map();
function mid(a,b){
const lo=Math.min(a,b), hi=Math.max(a,b), key=lo*100000+hi;
if(cache.has(key)) return cache.get(key);
let mx=(pos[a*3]+pos[b*3])/2, my=(pos[a*3+1]+pos[b*3+1])/2, mz=(pos[a*3+2]+pos[b*3+2])/2;
const inv=1/Math.hypot(mx,my,mz); mx*=inv; my*=inv; mz*=inv;
const idx=pos.length/3; pos.push(mx,my,mz); cache.set(key,idx); return idx;
}
for(let s=0;s<subdivisions;s++){
const next=[];
for(let r=0;r<faces.length;r+=3){
const a=faces[r],b=faces[r+1],c=faces[r+2];
const ab=mid(a,b), bc=mid(b,c), ca=mid(c,a);
next.push(a,ab,ca, b,bc,ab, c,ca,bc, ab,bc,ca);
}
faces=next; cache.clear();
}
const n=pos.length/3;
return {pos:new Float32Array(pos), nrm:new Float32Array(pos),
uv:new Float32Array(n*2), idx:new Uint16Array(faces)};
}
function uvSphere(wSeg,hSeg,radius=1){
const n=(wSeg+1)*(hSeg+1);
const pos=new Float32Array(n*3), nrm=new Float32Array(n*3), uv=new Float32Array(n*2);
let p=0,u=0;
for(let iy=0;iy<=hSeg;iy++){
const v=iy/hSeg, phi=v*Math.PI, sPhi=Math.sin(phi), cPhi=Math.cos(phi);
for(let ix=0;ix<=wSeg;ix++){
const th=(ix/wSeg)*2*Math.PI;
const x=-radius*Math.cos(th)*sPhi, y=radius*cPhi, z=radius*Math.sin(th)*sPhi;
pos[p]=x; pos[p+1]=y; pos[p+2]=z;
nrm[p]=x/radius; nrm[p+1]=y/radius; nrm[p+2]=z/radius;
uv[u]=ix/wSeg; uv[u+1]=1-v; p+=3; u+=2;
}
}
const raw=[], stride=wSeg+1;
for(let iy=0;iy<hSeg;iy++)for(let ix=0;ix<wSeg;ix++){
const a=iy*stride+ix+1, b=iy*stride+ix, c=(iy+1)*stride+ix, d=(iy+1)*stride+ix+1;
if(iy!==0) raw.push(a,b,d);
if(iy!==hSeg-1) raw.push(b,c,d);
}
return {pos,nrm,uv,idx:new Uint16Array(raw)};
}
function capsule(radius, cylH, capSegs=4, radialSegs=12){
const half=cylH/2, totalRings=2*(capSegs+1), verts=totalRings*(radialSegs+1);
const pos=new Float32Array(verts*3), nrm=new Float32Array(verts*3), uv=new Float32Array(verts*2);
let p=0,u=0,ring=0;
for(const sign of [1,-1]){
for(let i=0;i<=capSegs;i++){
const phi=sign>0 ? (i/capSegs)*(Math.PI/2) : Math.PI/2+(i/capSegs)*(Math.PI/2);
const sP=Math.sin(phi), cP=Math.cos(phi);
for(let j=0;j<=radialSegs;j++){
const th=(j/radialSegs)*2*Math.PI;
const nx=-Math.cos(th)*sP, ny=cP, nz=Math.sin(th)*sP;
pos[p]=radius*nx; pos[p+1]=radius*ny+sign*half; pos[p+2]=radius*nz;
nrm[p]=nx; nrm[p+1]=ny; nrm[p+2]=nz;
uv[u]=j/radialSegs; uv[u+1]=1-ring/(totalRings-1); p+=3; u+=2;
}
ring++;
}
}
const idx=[], stride=radialSegs+1;
for(let r=0;r<totalRings-1;r++)for(let s=0;s<radialSegs;s++){
const a=r*stride+s, b=r*stride+s+1, c=(r+1)*stride+s+1, d=(r+1)*stride+s;
idx.push(a,b,c, a,c,d);
}
return {pos,nrm,uv,idx:new Uint16Array(idx)};
}
/**
* 眼睛的**上沿切平**版 —— gl/Eye.kt 的逐行移植。
*
* 切出来的那条平边**就是眉毛**。这一页最要紧的一句是:白色眼球压在近黑的
* 身上本来就是屏幕能给出的最大对比,所以"凶"根本不需要在眼睛旁边再画一笔,
* 把眼睛自己的上沿切平、再歪一点,那条边就读成压下来的眉。那个画法还顺手
* 拆掉了另一个陷阱:**盖在眼睛上的东西必须同时"对身体不可见"和"对眼睛可见"**
* ——身体是打过光的、平涂不是,两件事不在同一个尺度上(`browShade` 第一步错
* 就错在这里)。切几何没有颜色可以错。
*
* 和 [capsule] 结构相同(沿 Y 一摞环,北极在下、中间一段圆柱),只多两件事:
* 扫到切口就停,然后用自己的一个环加圆心**补一片平盖**。
*
* ⚠️ **切的角度不在这里**。一道水平的平边是一双**困**眼睛;让它成为眉的是
* 那条线**歪着**,而歪是调用方把整颗眼睛转出来的(`p.eyeTilt` 加表情自己的
* brow)。角度留在绘制那一步,这个函数就还是一颗**形状**,而形状能被动画改。
*
* @param {number} radius 半宽
* @param {number} cylH 圆柱段长度,同 [capsule]
* @param {number} topCut 上半个眼睛切掉多少,占半高的比例:0 = 不切,
* 0.5 = 平边落在圆心与天然顶端的中点上。夹到 0..MAX_CUT。
* @param {number} capSegs 每个半球跨几环
* @param {number} radialSegs 每环几个点
*/
function eyeMesh(radius, cylH, topCut, capSegs=4, radialSegs=12){
// 和 gl/Eye.kt 的 MAX_TOP_CUT 同值。这是**造型**上限不是几何上限:到 0.85
// 切口仍在圆心之上,再往下就降到圆心以下,那已经不是"一只被压住的眼睛"了。
// 真正的天花板比它早得多,而且不在这个网格里 —— 瞳孔是画在眼球**前面**的
// 另一片,切口只切眼球自己,切到瞳孔顶上就会有一颗黑豆从平盖上立出来。
// 那条线由 pupilR 决定,所以在 BallLook.eyeCut 那边算。见 P_IMP 的注释。
const MAX_CUT=0.85;
const half=cylH/2, halfHeight=radius+half;
const cut=Math.min(MAX_CUT,Math.max(0,topCut));
const yCut=halfHeight*(1-cut);
// 环按 (y, r) 收进数组而不是先数好再声明类型化数组:环数取决于切口落在
// 上半球上还是落在圆柱段上,数错了是**静默**的 —— 类型化数组越界写入直接
// 丢弃,症状是"网格建出来了、不报错、上面有个洞"。
const ys=[], rs=[];
// 下半球:phi π → π/2,北极在前,正好收在下赤道上。
for(let i=0;i<=capSegs;i++){
const phi=Math.PI-(i/capSegs)*(Math.PI/2);
ys.push(radius*Math.cos(phi)-half);
rs.push(radius*Math.sin(phi));
}
if(yCut>half){
// 切在上半球里。下赤道就是刚加进去的那一环,所以补上上赤道、让两者之间的
// 四边形当圆柱壁([capsule] 就是这么干的),然后扫到切口。
ys.push(half); rs.push(radius);
const phiCut=Math.acos(Math.min(1,Math.max(-1,(yCut-half)/radius)));
for(let i=1;i<=capSegs;i++){
const phi=Math.PI/2-(i/capSegs)*(Math.PI/2-phiCut);
ys.push(radius*Math.cos(phi)+half);
rs.push(radius*Math.sin(phi));
}
} else {
// 切口落在上赤道或更低:圆柱段直接顶到切口,没有半球可扫。
//
// 上赤道这一环是**跳过**的,不是"加完再补切口"。加了就会让某一环排在
// 它后面那一环之上,条带自己折回去 —— 而折回去不是报错,是一颗渲染出来
// 里外翻转的网格。这一支在真实数值下**是够得到的**:小恶魔的眼睛半高
// 0.1755、half 0.0275,任何大于 ~0.84 的切口都落在这里。
ys.push(yCut); rs.push(radius);
}
const ringCount=ys.length, stride=radialSegs+1;
const vertCount=ringCount*stride+stride+1;
const pos=new Float32Array(vertCount*3), nrm=new Float32Array(vertCount*3), uv=new Float32Array(vertCount*2);
let p=0,u=0;
for(let i=0;i<ringCount;i++){
const y=ys[i], r=rs[i];
// 这一环属于哪个球决定了法线。两个赤道环落在边界上,公式在两边都退化成
// 径向,所以跨过去是连续的。
const cy = y<=-half ? -half : (y>=half ? half : 0);
const onCyl = y>-half && y<half;
for(let j=0;j<=radialSegs;j++){
const th=(j/radialSegs)*2*Math.PI;
const nx=-Math.cos(th), nz=Math.sin(th);
pos[p]=r*nx; pos[p+1]=y; pos[p+2]=r*nz;
if(onCyl){ nrm[p]=nx; nrm[p+1]=0; nrm[p+2]=nz; }
else { nrm[p]=nx*r/radius; nrm[p+1]=(y-cy)/radius; nrm[p+2]=nz*r/radius; }
uv[u]=j/radialSegs; uv[u+1]=1-i/Math.max(1,ringCount-1);
p+=3; u+=2;
}
}
// 切口那片盖子,用**自己的**一环而不是复用扫出来的最后一环:最后一环带的是
// 半球法线,继承过来的盖子会是一片"还被当成曲面在打光"的平盘 —— 眼睛顶上
// 一道亮糊。今天眼睛走的是平涂、根本不读法线,这正是它值得现在做对的原因。
const capRing=ringCount*stride, capCenter=capRing+stride, rCut=rs[ringCount-1];
pos[capCenter*3]=0; pos[capCenter*3+1]=yCut; pos[capCenter*3+2]=0;
nrm[capCenter*3+1]=1; uv[capCenter*2]=0.5; uv[capCenter*2+1]=1;
for(let j=0;j<=radialSegs;j++){
const th=(j/radialSegs)*2*Math.PI;
const nx=-Math.cos(th), nz=Math.sin(th);
const v=capRing+j;
pos[v*3]=rCut*nx; pos[v*3+1]=yCut; pos[v*3+2]=rCut*nz;
nrm[v*3+1]=1; uv[v*2]=j/radialSegs; uv[v*2+1]=0;
}
const idx=new Uint16Array((ringCount-1)*radialSegs*6+radialSegs*3);
let w=0;
for(let ring=0;ring<ringCount-1;ring++)for(let s=0;s<radialSegs;s++){
const a=ring*stride+s, b=ring*stride+s+1, c=(ring+1)*stride+s+1, d=(ring+1)*stride+s;
idx[w++]=a; idx[w++]=b; idx[w++]=c;
idx[w++]=a; idx[w++]=c; idx[w++]=d;
}
for(let s=0;s<radialSegs;s++){
idx[w++]=capCenter; idx[w++]=capRing+s; idx[w++]=capRing+s+1;
}
return {pos,nrm,uv,idx};
}
function torus(radius, tube, radialSegs, tubularSegs, arc=2*Math.PI){
const verts=(radialSegs+1)*(tubularSegs+1);
const pos=new Float32Array(verts*3), nrm=new Float32Array(verts*3), uv=new Float32Array(verts*2);
let p=0,u=0;
for(let j=0;j<=radialSegs;j++){
const v=(j/radialSegs)*2*Math.PI, cV=Math.cos(v), sV=Math.sin(v);
for(let i=0;i<=tubularSegs;i++){
const uu=(i/tubularSegs)*arc, cU=Math.cos(uu), sU=Math.sin(uu);
const rr=radius+tube*cV;
const px=rr*cU, py=rr*sU, pz=tube*sV;
pos[p]=px; pos[p+1]=py; pos[p+2]=pz;
let nx=px-radius*cU, ny=py-radius*sU, nz=pz;
const inv=1/Math.hypot(nx,ny,nz);
nrm[p]=nx*inv; nrm[p+1]=ny*inv; nrm[p+2]=nz*inv;
uv[u]=i/tubularSegs; uv[u+1]=j/radialSegs; p+=3; u+=2;
}
}
const idx=[], stride=tubularSegs+1;
for(let j=0;j<radialSegs;j++)for(let i=0;i<tubularSegs;i++){
const a=j*stride+i, b=j*stride+i+1, c=(j+1)*stride+i+1, d=(j+1)*stride+i;
idx.push(a,b,c, a,c,d);
}
return {pos,nrm,uv,idx:new Uint16Array(idx)};
}
/**
* 一只耳 —— **gl/Ear.kt 的逐行移植**,不是另画一个形状。
*
* 这个函数原来是 `cone()`:一根正圆锥(椭圆截面,尖顶)。真机上的耳朵早就不是它了
* ——`Ear.build` 是一摞沿曲线轴走的椭圆环,截面扁、**尖端是圆的**,参数也完全不同
* (width/height/thickness/bend,而不是 rx/rz/height)。两边形状不一致的代价是:
* 用户在实验室里把耳朵调到自己满意,装到机器上是另一个东西,而且两边都"看起来对"。
* 所以这里按 Kotlin 原文抄一遍,参数名也对齐。
*
* 三件让它成为"耳"而不是"角"的事,都在下面看得见:
* * 截面是**椭圆**(宽 w、薄 th),所以是一片扁的,不是一根锥;
* * 轮廓按 **1/4 椭圆收口**(`k = √(1-t²)`,且下限 0.08),所以尖端是一个
* 小圆头而不是一个点 —— 尖的读作角;
* * 它自己不长,靠调用方把它**转出去**([-earTilt] 那一步)才是耳朵的姿态。
*
* @param {number} width 根部半宽(在弯曲平面内)
* @param {number} height 沿弯曲轴的长度
* @param {number} thickness z 方向的半厚(远小于 width,扁平就是"片"的来源)
* @param {number} bend 从根到尖的总转角,**弧度**(调用方负责从度转过来)
*/
function earMesh(width, height, thickness, bend=0, segs=6, radialSegs=10){
// 顶点数 = 环数 × (每环点数)。写环这类网格先把数数一遍再声明数组:
// 类型化数组越界写入是**静默丢弃**的,症状是"网格建出来了、不报错、就是画不出来"。
const rings=segs+1, vertCount=rings*(radialSegs+1);
const pos=new Float32Array(vertCount*3), nrm=new Float32Array(vertCount*3), uv=new Float32Array(vertCount*2);
const step=height/segs;
let cx=0, cy=0, pi=0, ui=0;
for(let i=0;i<rings;i++){
const t=i/segs;
// 尖端保留 8% 的宽度:既是一颗圆头,也保证下面法线不会除以 0。
const k=Math.max(Math.sqrt(1-t*t),0.08);
const w=width*k, th=thickness*k;
const ang=bend*t;
const ax=Math.sin(ang), ay=Math.cos(ang);
// u ⊥ a,都在 XY 平面内;第三个方向就是 Z。
const ux=ay, uy=-ax;
for(let j=0;j<=radialSegs;j++){
const tht=j/radialSegs*2*Math.PI, ct=Math.cos(tht), st=Math.sin(tht);
pos[pi++]=cx+w*ct*ux;
pos[pi++]=cy+w*ct*uy;
pos[pi++]=th*st;
// 椭圆 (w,th) 的表面法线 ∝ (ct/w, st/th)。
const nu=ct/w, nz=st/th;
const inv=1/Math.sqrt(nu*nu+nz*nz);
nrm[pi-3]=nu*inv*ux;
nrm[pi-2]=nu*inv*uy;
nrm[pi-1]=nz*inv;
uv[ui++]=j/radialSegs;
uv[ui++]=t;
}
cx+=ax*step;
cy+=ay*step;
}
const idx=new Uint16Array(segs*radialSegs*6);
let m=0;
for(let i=0;i<segs;i++)for(let j=0;j<radialSegs;j++){
const a=i*(radialSegs+1)+j, b=a+1, c=(i+1)*(radialSegs+1)+j, d=c+1;
idx[m++]=a; idx[m++]=c; idx[m++]=b;
idx[m++]=b; idx[m++]=c; idx[m++]=d;
}
return {pos,nrm,uv,idx};
}
/* =========================================================================
3. GL 小工具
========================================================================= */
function compile(gl,type,src){
const s=gl.createShader(type);
gl.shaderSource(s,src); gl.compileShader(s);
if(!gl.getShaderParameter(s,gl.COMPILE_STATUS))
throw new Error(gl.getShaderInfoLog(s)+"\n---\n"+src);
return s;
}
class Prog{
constructor(gl,vs,fs){
this.gl=gl;
const p=gl.createProgram();
gl.attachShader(p,compile(gl,gl.VERTEX_SHADER,vs));
gl.attachShader(p,compile(gl,gl.FRAGMENT_SHADER,fs));
gl.linkProgram(p);
if(!gl.getProgramParameter(p,gl.LINK_STATUS))
throw new Error(gl.getProgramInfoLog(p));
this.p=p; this.cache=new Map();
}
use(){ this.gl.useProgram(this.p); }
u(n){ const k="u:"+n; if(!this.cache.has(k)) this.cache.set(k,this.gl.getUniformLocation(this.p,n)); return this.cache.get(k); }
a(n){ const k="a:"+n; if(!this.cache.has(k)) this.cache.set(k,this.gl.getAttribLocation(this.p,n)); return this.cache.get(k); }
}
class GMesh{
constructor(gl,data){
this.gl=gl;
const n=data.pos.length/3, stride=8;
const inter=new Float32Array(n*stride);
for(let i=0;i<n;i++){
const j=i*stride;
inter[j]=data.pos[i*3]; inter[j+1]=data.pos[i*3+1]; inter[j+2]=data.pos[i*3+2];
inter[j+3]=data.nrm[i*3]; inter[j+4]=data.nrm[i*3+1]; inter[j+5]=data.nrm[i*3+2];
inter[j+6]=data.uv[i*2]; inter[j+7]=data.uv[i*2+1];
}
this.vbo=gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER,this.vbo);
gl.bufferData(gl.ARRAY_BUFFER,inter,gl.STATIC_DRAW);
this.ibo=gl.createBuffer();
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER,this.ibo);
gl.bufferData(gl.ELEMENT_ARRAY_BUFFER,data.idx,gl.STATIC_DRAW);
this.count=data.idx.length;
}
bind(aPos,aNrm=-1,aUV=-1){
const gl=this.gl, S=8*4;
gl.bindBuffer(gl.ARRAY_BUFFER,this.vbo);
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER,this.ibo);
if(aPos>=0){ gl.enableVertexAttribArray(aPos); gl.vertexAttribPointer(aPos,3,gl.FLOAT,false,S,0); }
if(aNrm>=0){ gl.enableVertexAttribArray(aNrm); gl.vertexAttribPointer(aNrm,3,gl.FLOAT,false,S,12); }
if(aUV>=0){ gl.enableVertexAttribArray(aUV); gl.vertexAttribPointer(aUV,2,gl.FLOAT,false,S,24); }
}
draw(){ this.gl.drawElements(this.gl.TRIANGLES,this.count,this.gl.UNSIGNED_SHORT,0); }
}
class GPoints{
constructor(gl,capacity){
this.gl=gl; this.capacity=capacity;
this.data=new Float32Array(capacity*6);
this.vbo=gl.createBuffer();
gl.bindBuffer(gl.ARRAY_BUFFER,this.vbo);
gl.bufferData(gl.ARRAY_BUFFER,capacity*6*4,gl.DYNAMIC_DRAW);
}
upload(){
const gl=this.gl;
gl.bindBuffer(gl.ARRAY_BUFFER,this.vbo);
gl.bufferSubData(gl.ARRAY_BUFFER,0,this.data);
}
bind(aPos,aCol){
const gl=this.gl, S=6*4;
gl.bindBuffer(gl.ARRAY_BUFFER,this.vbo);
gl.enableVertexAttribArray(aPos); gl.vertexAttribPointer(aPos,3,gl.FLOAT,false,S,0);
gl.enableVertexAttribArray(aCol); gl.vertexAttribPointer(aCol,3,gl.FLOAT,false,S,12);
}
draw(){ this.gl.drawArrays(this.gl.POINTS,0,this.capacity); }
}
/* =========================================================================
4. 表情表 —— 与 Mood.kt 的 FACE 表一一对应
========================================================================= */
function F(o){ return Object.assign({eyeArc:0,blush:0,spread:1,breath:0.022,gape:0,bubble:0},o); }
/* 改动前的表 —— "现在"这个预设专用,做诚实的基线。 */
const FACE_OLD = {
CALM: F({c:0x9db4ff, eye:1.00, brow:0.00, smile:0.10, pulse:1.00, tilt:0.00, skew:0.00, jitter:0.00}),
HAPPY: F({c:0x5eead4, eye:0.72, brow:-0.16,smile:0.62, pulse:1.25, tilt:0.04, skew:0.00, jitter:0.00, eyeArc:0.90, blush:0.70}),
CURIOUS: F({c:0xf0abfc, eye:1.22, brow:-0.06,smile:0.14, pulse:1.15, tilt:0.17, skew:0.055,jitter:0.00}),
TENSE: F({c:0xfb923c, eye:0.88, brow:0.30, smile:-0.20,pulse:1.95, tilt:0.00, skew:0.02, jitter:0.55}),
ANXIOUS: F({c:0xfb7185, eye:1.26, brow:0.42, smile:-0.44,pulse:2.50, tilt:0.00, skew:0.03, jitter:1.00}),
CONCERNED: F({c:0xfbbf24, eye:1.10, brow:0.34, smile:-0.34,pulse:1.15, tilt:-0.05,skew:0.00, jitter:0.12}),
LISTENING: F({c:0x7dd3fc, eye:1.60, brow:-0.14,smile:0.16, pulse:1.70, tilt:-0.13,skew:0.00, jitter:0.00, breath:0.055, gape:0.12}),
HOLDING: F({c:0xfacc15, eye:0.92, brow:0.48, smile:-0.18,pulse:0.72, tilt:0.00, skew:0.00, jitter:0.00, breath:0.018}),
THINKING: F({c:0xc084fc, eye:0.40, brow:0.32, smile:-0.06,pulse:1.15, tilt:0.15, skew:0.08, jitter:0.00, breath:0.042}),
SPEAKING: F({c:0x9db4ff, eye:1.05, brow:0.00, smile:0.20, pulse:1.50, tilt:0.00, skew:0.00, jitter:0.00}),
SEARCHING: F({c:0x7dd3fc, eye:0.84, brow:0.10, smile:0.06, pulse:1.60, tilt:0.13, skew:0.05, jitter:0.00, spread:1.16, breath:0.036}),
SUCCESS: F({c:0x5eead4, eye:0.50, brow:-0.22,smile:0.80, pulse:1.30, tilt:0.00, skew:0.00, jitter:0.00, eyeArc:1.00, blush:0.95, spread:1.10}),
FAILED: F({c:0xfb7185, eye:0.68, brow:0.45, smile:-0.50,pulse:1.10, tilt:-0.07,skew:0.02, jitter:0.22}),
SLEEPING: F({c:0x64748b, eye:0.10, brow:0.06, smile:0.08, pulse:0.45, tilt:0.11, skew:0.00, jitter:0.00, eyeArc:0.85, spread:0.90}),
};
/* 改动后的表 —— 与 Mood.kt 的 FACE 逐字对齐,这样这里看到的就是装机后的样子。
smile 与 blush 已经把"基线"烘进表里了,不再有额外的全局加成。 */
const FACE_NEW = {
CALM: F({c:0x9db4ff, eye:1.00, brow:0.00, smile:0.26, pulse:1.00, tilt:0.00, skew:0.00, jitter:0.00, blush:0.38}),
HAPPY: F({c:0x5eead4, eye:0.72, brow:-0.16,smile:0.68, pulse:1.25, tilt:0.04, skew:0.00, jitter:0.00, eyeArc:0.90, blush:0.85}),
CURIOUS: F({c:0xf0abfc, eye:1.22, brow:-0.06,smile:0.28, pulse:1.15, tilt:0.17, skew:0.055,jitter:0.00, blush:0.72}),
TENSE: F({c:0xfb923c, eye:0.88, brow:0.30, smile:-0.20,pulse:1.95, tilt:0.00, skew:0.02, jitter:0.55, blush:0.26}),
ANXIOUS: F({c:0xfb7185, eye:1.26, brow:0.42, smile:-0.44,pulse:2.50, tilt:0.00, skew:0.03, jitter:1.00, blush:0.24}),
CONCERNED: F({c:0xfbbf24, eye:1.10, brow:0.34, smile:-0.34,pulse:1.15, tilt:-0.05,skew:0.00, jitter:0.12, blush:0.32}),
LISTENING: F({c:0x7dd3fc, eye:1.60, brow:-0.14,smile:0.28, pulse:1.70, tilt:-0.13,skew:0.00, jitter:0.00, blush:0.46, breath:0.055, gape:0.12}),
HOLDING: F({c:0xfacc15, eye:0.92, brow:0.48, smile:-0.18,pulse:0.72, tilt:0.00, skew:0.00, jitter:0.00, blush:0.3, breath:0.018}),
THINKING: F({c:0xc084fc, eye:0.40, brow:0.32, smile:0.04, pulse:1.15, tilt:0.15, skew:0.08, jitter:0.00, blush:0.3, breath:0.042}),
SPEAKING: F({c:0x9db4ff, eye:1.05, brow:0.00, smile:0.32, pulse:1.50, tilt:0.00, skew:0.00, jitter:0.00, blush:0.44}),
SEARCHING: F({c:0x7dd3fc, eye:0.84, brow:0.10, smile:0.16, pulse:1.60, tilt:0.13, skew:0.05, jitter:0.00, blush:0.34, spread:1.16, breath:0.036}),
SUCCESS: F({c:0x5eead4, eye:0.50, brow:-0.22,smile:0.86, pulse:1.30, tilt:0.00, skew:0.00, jitter:0.00, eyeArc:1.00, blush:1.0, spread:1.10}),
FAILED: F({c:0xfb7185, eye:0.68, brow:0.45, smile:-0.50,pulse:1.10, tilt:-0.07,skew:0.02, jitter:0.22, blush:0.42}),
SLEEPING: F({c:0x9db4ff, eye:0.10, brow:0.06, smile:0.16, pulse:0.45, tilt:0.11, skew:0.00, jitter:0.00, eyeArc:0.85, blush:0.16, spread:0.90, bubble:1}),
};
const MOODS = Object.keys(FACE_NEW);
for(const T of [FACE_OLD, FACE_NEW]) for(const k in T) T[k].color = hex2rgb(T[k].c);
function hex2rgb(h){ return [((h>>16)&255)/255, ((h>>8)&255)/255, (h&255)/255]; }
/* =========================================================================
5. 预设 —— 每个数都对应 Kotlin 里一个常量
========================================================================= */
const P_NOW = {
key:'now', label:'现在', tag:'近黑球 + 白胶囊眼 + 发光描边',
bodyBase:[0.102,0.137,0.220], tint:0.20, albedoMul:1.00, grad:0.00,
amb:1.00, diff:0.00, gloss:0.00, bodyScale:0.885,
eyeStyle:'plain', eyeColor:[1,1,1], pupilR:0, specR:0,
eyeR:0.075, eyeH:0.100, eyeX:0.300, eyeY:0.300,
eyeCut:0, eyeTilt:0, pupilAspect:1,
faceZ:0.860, mouthR:0.240, mouthTube:0.036, mouthY:-0.340, mouthThick:0.00,
mouthMode:'mood', smileBoost:0.00, faces:FACE_OLD,
blushColor:[1,0.42,0.55],
blushMul:1.00, restBlush:0.00, blushAlpha:0.55, blushBlend:'add', blushSize:0.34, blushX:0.440, blushY:-0.120,
mouthStyle:'arc',
earH:0, earX:0.360, earY:0.700, earZ:0.360, earW:0.155, earThick:0.056, earTilt:24, earBend:0, earShade:0.86,
browW:0, browH:0.032, browY:0.150, browTilt:0, browShade:0,
bubbleX:0.085, bubbleY:-0.030, bubbleR:0.085,
bubbleColor:[0.105,0.135,0.205], bubblePow:3.0, bubbleShine:26, bubbleInner:0.10,
outline:0.000, outlineColor:[0.085,0.085,0.115],
rimMode:'glow', rimGain:1.00, rimPow:2.6,
};
const P_JELLY = {
key:'jelly', label:'果冻球', tag:'糖果色光泽身体 + 大眼带瞳孔 + 腮红',
bodyBase:[0.055,0.072,0.130], tint:0.62, albedoMul:0.88, grad:0.60,
amb:0.66, diff:0.55, gloss:0.70, bodyScale:0.885,
eyeStyle:'pupil', eyeColor:[1,1,1], pupilR:0.070, specR:0.024,
eyeR:0.135, eyeH:0.050, eyeX:0.262, eyeY:0.175,
eyeCut:0, eyeTilt:0, pupilAspect:1,
faceZ:0.876, mouthR:0.175, mouthTube:0.040, mouthY:-0.235, mouthThick:0.06,
mouthMode:'mood', smileBoost:0.00, faces:FACE_NEW,
blushColor:[1,0.42,0.55],
blushMul:1.00, restBlush:0.00, blushAlpha:0.85, blushBlend:'add', blushSize:0.44, blushX:0.400, blushY:-0.145,
mouthStyle:'arc',
earH:0, earX:0.360, earY:0.700, earZ:0.360, earW:0.155, earThick:0.056, earTilt:24, earBend:0, earShade:0.86,
browW:0, browH:0.032, browY:0.150, browTilt:0, browShade:0,
bubbleX:0.085, bubbleY:-0.030, bubbleR:0.085,
bubbleColor:[0.920,0.950,1.000], bubblePow:3.0, bubbleShine:26, bubbleInner:0.10,
outline:0.000, outlineColor:[0.085,0.085,0.115],
rimMode:'glow', rimGain:1.15, rimPow:2.6,
};
/* --- 奶油球(已落地的那套)---
2026-09-30:长了一对**立耳**;同一天把**眉毛去掉了**。
"机灵"不是一种颜色,是形状 —— 圆球加一对立耳,读出来的立刻是动物,动物才
谈得上机敏。原先还有一对画上去的眉毛(browW 0.145 / browH 0.032 / browY
0.185 / browTilt 5),**已按用户要求删除**,剩下耳朵单独扛这个读法。
删得掉是有算术支撑的:当初选 browY 的注释说眉下沿离眼上沿留了 0.031,
但那是**把眼睛当成一颗球算的**(只算了 eyeRadius 0.122),漏了它的圆柱段。
眼睛真正的半高是 eyeRadius + eyeCyl/2 = 0.1445,顶端到 **0.3845** 而不是
0.362 —— 光这一项就把间隙砍到 0.0085;再算上 5° 倾角把内端压低,**真实
间隙只有 0.0062**。也就是说那根眉几乎贴在眼睛上,正是"厚眼皮"的读法。
⚠️ 复算这类间隙时注意:眉盘是 dotMesh 缩放出来的**椭圆**(半轴 browW ×
browH)再整体旋转,最低点是 `cy − √((w·sinθ)² + (h·cosθ)²)`,**不是**
`cy − h`。同一个公式下 BAJIE 的眉内端是**压进眼睛 0.0291** 的(那是它故意的,
猪的"内端下压"= 凶相),两者不是一回事。
一条留下的坑:**耳朵得比身体暗一档**(earShade)。它伸在身体那条深描边之外,
同色的话就是一块没有边的浅色糊在亮色 App 上 —— 而这颗球在亮色 App 上
全靠那条深边活着。 */
const P_CREAM = {
key:'cream', label:'奶油球', tag:'奶油身体 + 深色豆豆眼 + 深色描边 + 立耳(无眉)',
bodyBase:[0.955,0.965,0.985], tint:0.55, albedoMul:0.93, grad:0.42,
amb:0.66, diff:0.38, gloss:0.45, bodyScale:0.845,
eyeStyle:'spec', eyeColor:[0.105,0.135,0.205], pupilR:0, specR:0.040,
eyeR:0.122, eyeH:0.045, eyeX:0.262, eyeY:0.240,
eyeCut:0, eyeTilt:0, pupilAspect:1,
faceZ:0.876, mouthR:0.170, mouthTube:0.038, mouthY:-0.230, mouthThick:0.05,
mouthMode:'deep', smileBoost:0.00, faces:FACE_NEW,
blushColor:[1,0.60,0.66],
blushMul:1.00, restBlush:0.00, blushAlpha:0.62, blushBlend:'alpha', blushSize:0.48, blushX:0.400, blushY:-0.142,
mouthStyle:'arc',
earH:0.380, earW:0.170, earThick:0.050, earX:0.315, earY:0.645, earZ:0.290, earTilt:24, earBend:12, earShade:0.62,
browW:0, browH:0, browY:0, browTilt:0, browShade:0,
bubbleX:0.085, bubbleY:-0.030, bubbleR:0.085,
bubbleColor:[0.105,0.135,0.205], bubblePow:3.0, bubbleShine:26, bubbleInner:0.10,
outline:0.000, outlineColor:[0.085,0.085,0.115],
rimMode:'dark', rimGain:1.00, rimPow:5.6,
};
/* --- 小恶魔:**部分**可画 ---
这颗球是 BallLook.IMP 落地的参数,但这一页**画不出它的角、獠牙和尾巴** ——
三种几何都没移植。所以这个预设只在"脸平面"上可信:眼睛(含切平的顶和
竖缝瞳孔)、嘴弧、腮红、边光、身体颜色,这些是真机上那套。
轮廓不是 —— 别看着这里的圆球去调 bodyScale 或 hornY,那些数真机上是另一颗球。
(check_look_sync.py 会把这件事印出来,不让它看起来"已经核对过"。)
它存在的理由很具体:三个形象里小恶魔是唯一**完全没有实验室覆盖**的,而上一
个 bug(眉毛和脸同色、看不见)正因为它不在这一页才只能在真机上被发现。
eyeCut 0.48 / eyeTilt 12 —— 那道平边就是眉,两个数怎么来的写在 BallLook.IMP
的注释里,这里只记这一页看得见的那部分(下面这几个数都在 Node 里跑过一遍,
见 tools/eye_mesh_check.py):
* 0.48 把平边放在半高 0.1755 的 +0.0913 处,离瞳孔顶(0.8×0.082 = 0.0656)
还剩 0.0257 的白。眼睛少了 24% 的高度,从 0.296×0.351 变成 0.296×0.267,
平边自己有 0.267 宽(眼宽的 90%)。
**天花板不是 0.85**:瞳孔是画在眼球前面的一片,切口只切眼球自己,切到瞳孔
顶上就有一颗黑豆从平盖上立出来。这个形象的那条线是
1 − 0.8×pupilR/(eyeR+eyeH/2),算出来 0.626,再往下就没有白眼仁了。
* 12° 让平边沿自身长度降下 0.267×sin12° ≈ 0.056,约眼高的五分之一 ——
这一步才是"困眼"和"斜眼"的分界,也是它比原来那根眉条的 24° 小的原因:
这里转的是整颗眼睛,连瞳孔一起。 */
const P_IMP = {
key:'imp', label:'小恶魔', tag:'墨色 + 獠牙 + 切平的眼睛 · 本页画不出角/獠牙/尾巴',
bodyBase:[0.052,0.042,0.072], tint:0.14, albedoMul:0.92, grad:0.40,
amb:0.62, diff:0.60, gloss:0.26, bodyScale:0.868,
eyeStyle:'pupil', eyeColor:[1,1,1], pupilR:0.082, specR:0.022,
eyeR:0.148, eyeH:0.055, eyeX:0.255, eyeY:0.190,
eyeCut:0.48, eyeTilt:12, pupilAspect:0.42,
faceZ:0.876, mouthR:0.330, mouthTube:0.026, mouthY:-0.215, mouthThick:0.03,
mouthMode:'deep', smileBoost:0.00, faces:FACE_NEW,
blushColor:[1,0.30,0.52],
blushMul:1.00, restBlush:0.00, blushAlpha:0.78, blushBlend:'add', blushSize:0.32, blushX:0.430, blushY:-0.075,
mouthStyle:'arc',
/* 没开的那几条**照抄 Kotlin 的默认值**,不是从邻居预设复制过来凑格式。
两边都是关着的、看起来无所谓,但核对脚本按"继承来的值"比:earH=0 时
earW 是 0.155 还是 0 都不影响这一页,可它一旦和 Kotlin 的默认值不同,
下一颗球加耳朵时就会拿一串没人认领的数去开工。第一版这里正是复制的,
脚本一次报出 9 处 —— 那 9 处就是这条规则存在的原因。 */
earH:0, earW:0, earThick:0, earX:0, earY:0, earZ:0, earTilt:0, earBend:0, earShade:1,
browW:0, browH:0, browY:0, browTilt:0, browShade:0,
bubbleX:0.085, bubbleY:-0.030, bubbleR:0.085,
bubbleColor:[0.920,0.950,1.000], bubblePow:3.0, bubbleShine:26, bubbleInner:0.10,
outline:0.000, outlineColor:[0.085,0.085,0.115],
rimMode:'glow', rimGain:0.85, rimPow:3.6,
};
/* --- 猫耳球:同一颗果冻球,加一对耳朵和 ω 嘴 ---
耳朵是这张表里唯一"长出来"的几何,也是可爱的最大单笔加成:
圆的东西加一对尖角,读出来的立刻是动物而不是物件。 */
const P_KITTY = {
key:'kitty', label:'猫耳球', tag:'果冻球 + 一对耳朵 + ω 嘴',
bodyBase:[0.055,0.072,0.130], tint:0.62, albedoMul:0.88, grad:0.60,
amb:0.66, diff:0.55, gloss:0.70, bodyScale:0.885,
eyeStyle:'pupil', eyeColor:[1,1,1], pupilR:0.070, specR:0.024,
eyeR:0.135, eyeH:0.050, eyeX:0.262, eyeY:0.175,
eyeCut:0, eyeTilt:0, pupilAspect:1,
faceZ:0.876, mouthR:0.120, mouthTube:0.038, mouthY:-0.232, mouthThick:0.10,
mouthMode:'mood', smileBoost:0.00, faces:FACE_NEW,
blushColor:[1,0.42,0.55],
blushMul:1.00, restBlush:0.00, blushAlpha:0.85, blushBlend:'add',
blushSize:0.44, blushX:0.400, blushY:-0.145,
mouthStyle:'cat',
earH:0.340, earW:0.165, earThick:0.056, earX:0.345, earY:0.690, earZ:0.300, earTilt:15, earBend:0, earShade:0.84,
browW:0, browH:0.032, browY:0.150, browTilt:0, browShade:0,
bubbleX:0.085, bubbleY:-0.030, bubbleR:0.085,
bubbleColor:[0.105,0.135,0.205], bubblePow:3.0, bubbleShine:26, bubbleInner:0.10,
outline:0.000, outlineColor:[0.085,0.085,0.115],
rimMode:'glow', rimGain:1.15, rimPow:2.6,
};
/* --- 麻薯球:哑光白团子。可爱来自"软",不来自"亮" ---
高光降到 0.08 —— 有高光就变成塑料球,没有才像糯米。眼睛是这批里最大的,
瞳孔吃掉眼宽 68%,两颗眼几乎贴在一起,嘴巴缩成一个小弧。 */
const P_MOCHI = {
key:'mochi', label:'麻薯球', tag:'哑光糯米团 · 最大的一双眼睛 · 一块大软腮红',
bodyBase:[0.985,0.968,0.940], tint:0.38, albedoMul:0.90, grad:0.32,
amb:0.76, diff:0.26, gloss:0.08, bodyScale:0.885,
eyeStyle:'spec', eyeColor:[0.125,0.140,0.195], pupilR:0.000, specR:0.052,
eyeR:0.148, eyeH:0.040, eyeX:0.246, eyeY:0.186,
eyeCut:0, eyeTilt:0, pupilAspect:1,
faceZ:0.876, mouthR:0.065, mouthTube:0.026, mouthY:-0.205, mouthThick:0.00,
mouthMode:'deep', smileBoost:0.00, faces:FACE_NEW,
blushColor:[1,0.60,0.66],
blushMul:1.00, restBlush:0.00, blushAlpha:0.55, blushBlend:'alpha',
blushSize:0.62, blushX:0.360, blushY:-0.150,
mouthStyle:'arc',
earH:0, earX:0.360, earY:0.700, earZ:0.360, earW:0.155, earThick:0.056, earTilt:24, earBend:0, earShade:0.86,
browW:0, browH:0.032, browY:0.150, browTilt:0, browShade:0,
bubbleX:0.085, bubbleY:-0.030, bubbleR:0.085,
bubbleColor:[0.105,0.135,0.205], bubblePow:3.0, bubbleShine:26, bubbleInner:0.10,
outline:0.000, outlineColor:[0.085,0.085,0.115],
rimMode:'dark', rimGain:0.55, rimPow:4.5,
};
/* --- 贴纸球:品牌吉祥物的做法 ---
没有渐变、没有高光、没有瞳孔高光点,只有一块饱和的平色加一条脆的深描边。
描边不是菲涅尔光晕,是"先画一圈放大的实心暗球、再把身体压上去"——
光晕是软的,贴纸要的是硬的。 */
const P_STICKER = {
key:'sticker', label:'贴纸球', tag:'纯平色 + 一条脆的硬描边 · 吉祥物路线',
bodyBase:[0.175,0.140,0.320], tint:0.78, albedoMul:1.00, grad:0.18,
amb:0.94, diff:0.10, gloss:0.00, bodyScale:0.845,
eyeStyle:'pupil', eyeColor:[1,1,1], pupilR:0.062, specR:0.024,
eyeR:0.132, eyeH:0.046, eyeX:0.258, eyeY:0.176,
eyeCut:0, eyeTilt:0, pupilAspect:1,
faceZ:0.876, mouthR:0.150, mouthTube:0.038, mouthY:-0.232, mouthThick:0.08,
mouthMode:'deep', smileBoost:0.00, faces:FACE_NEW,
blushColor:[1,0.42,0.55],
blushMul:1.00, restBlush:0.00, blushAlpha:0.52, blushBlend:'alpha',
blushSize:0.46, blushX:0.395, blushY:-0.150,
mouthStyle:'arc',
earH:0, earX:0.360, earY:0.700, earZ:0.360, earW:0.155, earThick:0.056, earTilt:24, earBend:0, earShade:0.86,
browW:0, browH:0.032, browY:0.150, browTilt:0, browShade:0,
bubbleX:0.085, bubbleY:-0.030, bubbleR:0.085,
bubbleColor:[0.105,0.135,0.205], bubblePow:3.0, bubbleShine:26, bubbleInner:0.10,
outline:0.055, outlineColor:[0.070,0.070,0.095],
rimMode:'dark', rimGain:0.00, rimPow:6.0,
};
/* --- 角落球:可爱来自"不闹" ---
它大部分时间就蹲在屏幕角上,所以给它一个最不起眼的脸:哑光、小一圈的眼、
淡到几乎没有的描边、几乎没有光。参考的是角落生物那一类——
不靠大和亮,靠"缩着"。 */
const P_SUMIKKO = {
key:'sumikko', label:'角落球', tag:'哑光 · 小一圈的眼 · 几乎不发光',
bodyBase:[0.135,0.130,0.155], tint:0.30, albedoMul:0.86, grad:0.50,
amb:0.68, diff:0.45, gloss:0.10, bodyScale:0.885,
eyeStyle:'pupil', eyeColor:[0.860,0.850,0.815], pupilR:0.048, specR:0.017,
eyeR:0.098, eyeH:0.048, eyeX:0.196, eyeY:0.168,
eyeCut:0, eyeTilt:0, pupilAspect:1,
faceZ:0.876, mouthR:0.062, mouthTube:0.026, mouthY:-0.198, mouthThick:0.00,
mouthMode:'mood', smileBoost:0.00, faces:FACE_NEW,
blushColor:[1,0.42,0.55],
blushMul:1.00, restBlush:0.00, blushAlpha:0.45, blushBlend:'add',
blushSize:0.42, blushX:0.330, blushY:-0.132,
mouthStyle:'arc',
earH:0, earX:0.360, earY:0.700, earZ:0.360, earW:0.155, earThick:0.056, earTilt:24, earBend:0, earShade:0.86,
browW:0, browH:0.032, browY:0.150, browTilt:0, browShade:0,
bubbleX:0.085, bubbleY:-0.030, bubbleR:0.085,
bubbleColor:[0.105,0.135,0.205], bubblePow:3.0, bubbleShine:26, bubbleInner:0.10,
outline:0.000, outlineColor:[0.085,0.085,0.115],
rimMode:'dark', rimGain:0.45, rimPow:6.0,
};
/* 顺序:先"现在"对照,再几个没落地的草稿,最后两个是 BallLook.kt 里真有的。
cream 和 imp 是**有 Kotlin 对应**的两个 —— 核对脚本只查它们,其余五个是
这一页自己的草稿,改了不会影响真机。 */
const PRESETS = [P_NOW, P_JELLY, P_KITTY, P_MOCHI, P_STICKER, P_SUMIKKO, P_CREAM, P_IMP];
const clone = o => JSON.parse(JSON.stringify(o));
/* =========================================================================
6. Shader
========================================================================= */
const VS_SOLID = `
uniform mat4 uMVP;
attribute vec3 aPos;
void main(){ gl_Position = uMVP * vec4(aPos,1.0); }
`;
const FS_SOLID = `
precision mediump float;
uniform vec3 uColor;
uniform float uAlpha;
void main(){ gl_FragColor = vec4(uColor, uAlpha); }
`;
/* 身体:顶光渐变 + 主光 + 镜面高光。这是"果冻感"的全部来源。 */
const VS_BODY = `
uniform mat4 uMVP; uniform mat4 uMV;
attribute vec3 aPos; attribute vec3 aNormal;
varying vec3 vN; varying vec3 vP;
void main(){
vN = normalize(mat3(uMV) * aNormal);
vec4 p = uMV * vec4(aPos,1.0);
vP = p.xyz;
gl_Position = uMVP * vec4(aPos,1.0);
}
`;
const FS_BODY = `
precision mediump float;
uniform vec3 uColor;
uniform float uAlpha;
uniform float uGrad;
uniform float uAmb;
uniform float uDiff;
uniform float uGloss;
varying vec3 vN; varying vec3 vP;
void main(){
vec3 n = normalize(vN);
vec3 V = normalize(-vP);
float vert = n.y * 0.5 + 0.5;
vec3 base = uColor * mix(1.0, mix(0.70, 1.14, vert), uGrad);
// 主光偏正上方。高光点落在额头 —— 压在眼睛上等于把眼睛的对比度
// 吃掉一半,而且 0.95 的强度会在 80dp 的球上糊出一块 30px 的白斑。
vec3 L = normalize(vec3(-0.48, 0.85, 0.20));
float diff = max(0.0, dot(n, L));
vec3 lit = base * (uAmb + uDiff * diff);
vec3 H = normalize(L + V);
float spec = pow(max(0.0, dot(n, H)), 90.0) * uGloss;
float edge = pow(1.0 - max(0.0, dot(n, V)), 3.0) * uGloss * 0.26;
gl_FragColor = vec4(lit + vec3(spec) + uColor * edge, uAlpha);
}
`;
/* 描边 / 光晕。uPow 小 → 柔和发光;大 → 紧的深色轮廓。
这一段必须与 EmotionBallRenderer.RIM_FS **逐字相同** ——
上一版这里少写了一条扫描光带,结果真机上出现了一条实验室永远看不见的
滚动色带,用户先发现。实验室的价值全在于它和真机一样。 */
const VS_RIM = `
uniform mat4 uMVP; uniform mat4 uMV;
attribute vec3 aPos; attribute vec3 aNormal;
varying vec3 vN; varying vec3 vP; varying float vY;
void main(){
vN = normalize(mat3(uMV) * aNormal);
vec4 p = uMV * vec4(aPos,1.0);
vP = p.xyz; vY = aPos.y;
gl_Position = uMVP * vec4(aPos,1.0);
}
`;
const FS_RIM = `
precision mediump float;
uniform vec3 uColor;
uniform float uIntensity;
uniform float uScan;
uniform float uScanY;
uniform float uPow;
uniform float uCap;
varying vec3 vN; varying vec3 vP; varying float vY;
void main(){
float f = pow(1.0 - abs(dot(normalize(vN), normalize(-vP))), uPow);
float d = vY - uScanY;
float slope = d > 0.0 ? 7.5 : 4.2;
float band = pow(max(0.0, 1.0 - abs(d) * slope), 3.0);
gl_FragColor = vec4(uColor, min(f * uIntensity + band * uScan, uCap));
}
`;
const VS_PTS = `
uniform mat4 uMVP; uniform mat4 uMV;
uniform float uSize; uniform float uPointFactor;
attribute vec3 aPos; attribute vec3 aColor;
varying vec3 vColor;
void main(){
vec4 mvpos = uMV * vec4(aPos,1.0);
gl_Position = uMVP * vec4(aPos,1.0);
gl_PointSize = uSize * uPointFactor / -mvpos.z;
vColor = aColor;
}
`;
const FS_PTS = `
precision mediump float;
uniform float uAlpha;
varying vec3 vColor;
void main(){
vec2 c = gl_PointCoord - 0.5;
float d = length(c);
float a = smoothstep(0.5, 0.0, d);
gl_FragColor = vec4(vColor, a * uAlpha);
}
`;
/* =========================================================================
7. EmotionState 移植
========================================================================= */
const ACTION_SECONDS = {NONE:0, HOP:0.52, NOD:0.42, SHAKE:0.5, POP:0.46, RECOIL:0.55,
STRETCH:1.6, LOOK_AROUND:1.9, WIGGLE:1.1, BOUNCE:0.9};
class State{
constructor(){
this.nowColor = FACE_OLD.CALM.color.slice();
this.eye=1; this.brow=0; this.smile=0.1; this.tilt=0; this.skew=0; this.jitter=0;
this.open=0; this.eyeArc=0; this.blush=0; this.spread=1; this.lid=1;
// 鼻涕泡:amount 是随表情淡入淡出,scale 是它自己的一呼一吸
this.bubble=0; this.bubbleScale=1; this.bubblePhase=0;
this.think=0; this.busy=0;
this.rotX=0; this.rotY=0; this.rotZ=0; this.breathe=1;
this.breatheDepth=0.022; this.scaleX=1; this.scaleY=1; this.hopY=0;
this.eyeOffX=0; this.eyeOffY=0; this.eyeLRotZ=0; this.eyeRRotZ=0; this.eyeYScale=1;
this.mouthY=-0.34; this.mouthScaleY=0.16; this.mouthRotZ=Math.PI;
this.blinkNext=2.4; this.blinkLeft=0;
// 扫描光带:一条横线从下往上扫,一轮约 5.3 秒。think/listen 会让它变明显。
this.scanAngle=0; this.scanY=-2; this.scan=0; this.listen=0;
this.action='NONE'; this.actionT=0; this.actionDur=0;
}
trigger(a){ if(!a||a==='NONE') return; this.action=a; this.actionT=0; this.actionDur=ACTION_SECONDS[a]; }
tick(dt,t,mood,p){
const want=p.faces[mood], k=Math.min(1,dt*7);
this.eye+=(want.eye-this.eye)*k;
this.brow+=(want.brow-this.brow)*k;
this.smile+=(want.smile-this.smile)*k;
this.tilt+=(want.tilt-this.tilt)*k;
this.skew+=(want.skew-this.skew)*k;
this.jitter+=(want.jitter-this.jitter)*Math.min(1,dt*2.4);
this.eyeArc+=(want.eyeArc-this.eyeArc)*k;
this.blush+=(want.blush-this.blush)*k;
this.spread+=(want.spread-this.spread)*Math.min(1,dt*3.5);
for(let i=0;i<3;i++) this.nowColor[i]+=(want.color[i]-this.nowColor[i])*k;
this.think+=(((mood==='THINKING'||mood==='SEARCHING')?1:0)-this.think)*Math.min(1,dt*2.2);
const th=this.think;
this.busy=th;
// listen 在真机上是语音管线给的;这里用 LISTENING 表情近似
this.listen += (((mood==='LISTENING')?1:0)-this.listen)*Math.min(1,dt*3.4);
this.scanAngle += dt*(0.19 + th*0.55);
this.scanY = -1.35 + (this.scanAngle - Math.floor(this.scanAngle))*2.7;
this.scan = 0.08 + th*0.5 + this.listen*0.42 + this.open*0.12;
const gaze = th*(Math.sin(t*0.9)+Math.sin(t*1.31)*0.5);
const gazeY= th*(Math.sin(t*0.73)*0.6+Math.sin(t*1.07)*0.35);
const jx=(Math.sin(t*23.7)+Math.sin(t*37.1)*0.6)*this.jitter;
const jy=(Math.sin(t*29.3)+Math.sin(t*41.7)*0.6)*this.jitter;
const talk = (mood==='SPEAKING') ? 0.34+Math.sin(t*17)*0.16+Math.sin(t*29)*0.09 : want.gape;
this.open+=(Math.max(0,talk)-this.open)*Math.min(1,dt*22);
// 眨眼是"给睁着的眼睛合上眼皮"。屏幕上那只眼睛已经是 `^ ^` 弧的时候
// (eyeArc ≥ ARC_EYE_AT)没有眼皮可合,眨一下只是把弧抽动一下 ——
// 睡着的球每三秒抖一次就是这么来的。
const eyeShut=this.eyeArc>=ARC_EYE_AT;
this.blinkNext-=dt;
if(this.blinkNext<=0){
if(eyeShut){
// 顺带取消正在进行的那一次,并稍后重试:醒来后第一次眨眼
// 不用等满一整轮
this.blinkLeft=0; this.blinkNext=0.35;
} else {
this.blinkLeft=0.12;
const base=(this.listen>0.5?1.8:3.2)+Math.random()*2.6;
this.blinkNext=(base*(1+th*0.9))/(1+this.jitter*1.6);
}
}
let lid=1;
if(this.blinkLeft>0){ this.blinkLeft-=dt; lid=Math.abs(this.blinkLeft/0.06-1); }
this.lid=lid;
let sqx=0,sqy=0,hop=0,actRX=0,actRY=0;
if(this.action!=='NONE'){
this.actionT+=dt;
const pp=Math.min(1,this.actionT/this.actionDur);
const arch=Math.sin(pp*Math.PI);
switch(this.action){
case 'HOP':{ hop=arch*0.22;
const c=Math.max(0,1-pp/0.2)+Math.max(0,(pp-0.8)/0.2);
sqx=c*0.13; sqy=c*-0.17; break; }
case 'NOD': actRX=Math.sin(pp*2*Math.PI)*0.26; break;
case 'SHAKE': actRY=Math.sin(pp*3*Math.PI)*0.20; break;
case 'POP': sqx=arch*0.15; sqy=arch*0.15; hop=arch*0.06; break;
case 'RECOIL': sqx=arch*0.17; sqy=arch*-0.20; actRX=-arch*0.14; break;
case 'STRETCH':{ const e=Math.sin(pp*Math.PI);
sqx=-e*0.12; sqy=e*0.20; actRX=-e*0.08; break; }
case 'LOOK_AROUND': actRY=Math.sin(pp*2.5*Math.PI)*0.30; actRX=Math.sin(pp*1.25*Math.PI)*0.05; break;
case 'WIGGLE': actRY=Math.sin(pp*3*Math.PI)*0.14; break;
case 'BOUNCE':{ hop=Math.abs(Math.sin(pp*2*Math.PI))*0.09;
const c=Math.max(0,1-pp/0.15)+Math.max(0,(pp-0.85)/0.15);
sqx=c*0.07; sqy=c*-0.09; break; }
}
if(pp>=1) this.action='NONE';
}
this.breatheDepth+=(want.breath-this.breatheDepth)*Math.min(1,dt*3);
this.breathe=1+Math.sin(t*want.pulse)*this.breatheDepth+this.open*0.03;
this.scaleX=this.breathe*(1+sqx);
this.scaleY=this.breathe*(1+sqy);
this.hopY=hop;
this.rotY=Math.sin(t*0.22)*0.12+jx*0.012+gaze*0.09+actRY;
this.rotX=Math.sin(t*0.17)*0.06+jy*0.009-gazeY*0.05+actRX;
this.rotZ=this.tilt+th*Math.sin(t*0.51)*0.09;
const browR=this.brow+this.skew, browL=this.brow;
this.eyeOffX=jx*0.014+gaze*0.075;
this.eyeOffY=-browL*0.06+gazeY*0.05;
// 眼睛的滚动,两项同轴:
// * 造型自己的静止倾角,左右分别取反 —— 这是"凶"的形状,写在同一颗球上
// 而不是某一刻的表情。见 BallLook.eyeTilt(切平的眼睛歪多少度就是
// "压低的一根眉",而水平的切边只是一双困眼睛)。
// * 表情的 brow,满值是 ±0.4rad,符号约定跟原来那根眉条一样,所以
// "生来就皱着"的造型还能被表情拉得更凶,而不是被换掉。
this.eyeLRotZ=-p.eyeTilt/DEG-browL*0.40;
this.eyeRRotZ=p.eyeTilt/DEG+browR*0.40;
const sm=this.smile+p.smileBoost;
this.eyeYScale=Math.max(0.06,this.eye*this.lid-sm*0.34);
// 鼻涕泡。相位**故意不挂在呼吸上**:SLEEPING 的 pulse 是 0.45,
// 挂上去一轮 14 秒 —— 一个 14 秒不动的泡等于没有在动。
// 速率仍然跟着 pulse 走,"睡得越沉、泡越慢"这层关系还在。
this.bubble+=((want.bubble||0)-this.bubble)*Math.min(1,dt*2.2);
this.bubblePhase+=dt*(0.9+want.pulse*1.6);
this.bubbleScale=0.30+0.70*(0.5+0.5*Math.sin(this.bubblePhase));
this.mouthScaleY=0.16+this.open*1.5+Math.abs(sm)*0.5+p.mouthThick;
this.mouthY=p.mouthY+sm*0.06;
this.mouthRotZ=Math.PI+sm*0.9+this.skew*2.2;
}
}
/* =========================================================================
8. Ball
========================================================================= */
const CAM_Z=4.9, RIM=0.9;
const EYE_LID_PIVOT=-0.125;
/* 眉毛的倾角可以随表情摆动多少(弧度),与 EmotionBallRenderer.BROW_MOOD_TILT 同值。
+1 的表情值 = 内端往下 17.2°。 */
const BROW_MOOD_TILT=0.30;
/* 面片元素的 z 厚度(压扁的单位球 = 一片)。同 DISC_THICKNESS。 */
const DISC_THICKNESS=0.08;
/* 度 → 弧度。BallLook 里的角度(earTilt / browTilt / eyeTilt)是**度**,表情
给的是弧度,这一页两处相减,用一个常量比散落 57.29578 安全。 */
const DEG=57.29578;
const EYE_ARC_SPAN=0.8*Math.PI, EYE_ARC_ROT_Z=Math.PI/2-EYE_ARC_SPAN/2, EYE_ARC_DROP=0.06;
/* 超过这个值,屏幕上的眼睛就是那条 `^ ^` 弧,圆眼不是主角了。
两处共用:还要不要画瞳孔、还要不要眨眼。 */
const ARC_EYE_AT=0.5;
class Ball{
constructor(canvas,params){
this.cv=canvas;
this.gl=canvas.getContext('webgl',{alpha:true,antialias:true,premultipliedAlpha:true,depth:true});
if(!this.gl) throw new Error('这台机器没有 WebGL');
const gl=this.gl;
// 默认就停在 SLEEPING:这一页现在的主题是睡着那颗球
this.mood='SLEEPING';
this.st=new State();
this.autoFidget=true;
this.pSolid=new Prog(gl,VS_SOLID,FS_SOLID);
/* 鼻涕泡。一个透明的水滴,不是一颗白球:
* 背面 discard —— 只留朝向相机的那半,否则前后面叠在一起,边缘会变成两倍厚;
* edge 是菲涅尔,在轮廓上收紧成一圈(水滴的边是折射,浅色球上用暗色边);
* spec 是一个小高光点,落在左上,和球的主光同一个方向;
* uInner 是内部那层很薄的雾 —— 0 就完全透明。
uColor 按 look 给:浅色球用深色边,深色球用亮边。 */
const VS_BUBBLE = `
uniform mat4 uMVP; uniform mat4 uMV;
attribute vec3 aPos; attribute vec3 aNormal;
varying vec3 vN; varying vec3 vP;
void main(){
vN = normalize(mat3(uMV) * aNormal);
vec4 mvpos = uMV * vec4(aPos,1.0);
vP = mvpos.xyz;
gl_Position = uMVP * vec4(aPos,1.0);
}
`;
const FS_BUBBLE = `
precision mediump float;
uniform vec3 uColor;
uniform float uAlpha;
uniform float uPow;
uniform float uShine;
uniform float uInner;
varying vec3 vN; varying vec3 vP;
void main(){
vec3 n = normalize(vN);
vec3 V = normalize(-vP);
float facing = dot(n, V);
if (facing <= 0.0) discard;
float edge = pow(1.0 - facing, uPow);
vec3 L = normalize(vec3(-0.45, 0.80, 0.60));
vec3 H = normalize(L + V);
float spec = pow(max(0.0, dot(n, H)), uShine);
float a = clamp(edge + uInner + spec, 0.0, 1.0);
vec3 c = mix(uColor, vec3(1.0), clamp(spec * 2.5, 0.0, 1.0));
gl_FragColor = vec4(c, a * uAlpha);
}
`;
this.pBody =new Prog(gl,VS_BODY ,FS_BODY);
this.pRim =new Prog(gl,VS_RIM ,FS_RIM);
this.pBubble=new Prog(gl,VS_BUBBLE,FS_BUBBLE);
this.pPts =new Prog(gl,VS_PTS ,FS_PTS);
this.mBody=new GMesh(gl,icoSphere(4));
this.mRim =new GMesh(gl,uvSphere(40,28));
this.mDot =new GMesh(gl,icoSphere(2));
this.mArc =new GMesh(gl,torus(0.1,0.03,6,20,EYE_ARC_SPAN));
this.mBlush=new GPoints(gl,2);
this.proj=M4.id(); this.view=M4.lookAt(0,0,CAM_Z,0,0,0,0,1,0);
this.pointFactor=400;
this.setParams(params);
this.fidNext=9+Math.random()*8;
this.resize();
}
setParams(params){
// 网格的尺寸跟着参数走,所以耳朵和眼角形状也必须进这个判据:只改一条
// earH / eyeCut 滑杆而不重建,屏幕上还是旧的几何,而滑杆数字已经变了
// —— 用户会以为"这个参数没用"。眼睛的尺寸参数是 eyeR / eyeH / eyeCut 三个。
const changedSame = this.p && this.p.eyeR===params.eyeR &&
this.p.eyeH===params.eyeH && this.p.eyeCut===params.eyeCut &&
this.p.mouthR===params.mouthR &&
this.p.mouthTube===params.mouthTube &&
this.p.earW===params.earW && this.p.earH===params.earH &&
this.p.earThick===params.earThick && this.p.earBend===params.earBend;
this.p=clone(params);
if(!changedSame || !this.mEye){
// eyeCut > 0 就换一颗切了顶的眼睛。判据和真机 LookMeshes 一样是 `>0`
// 而不是 `!==0`:负数切出来的是"往反方向切",没有意义,而 0 是默认值
// ——预设表里每个形象都得写出这一行,否则 `undefined > 0` 是假、
// `undefined !== 0` 是真,两边会各自安静地走上不同的分支。
this.mEye = this.p.eyeCut>0
? new GMesh(this.gl, eyeMesh(this.p.eyeR,this.p.eyeH,this.p.eyeCut,4,12))
: new GMesh(this.gl, capsule(this.p.eyeR,this.p.eyeH,4,12));
this.mMouth=new GMesh(this.gl,torus(this.p.mouthR,this.p.mouthTube,8,24,Math.PI));
// 耳朵按预设的真实比例建,比例变了就重建 —— 这样绘制时只做旋转平移,
// 法线不会被非等比缩放搞坏(法线要的是逆转置,普通缩放是错的)。
// 参数顺序就是 gl/Ear.build 的;earBend 在 BallLook 里是**度**,这里转弧度。
// earH = 0 就是不画耳朵 —— 和真机 LookMeshes 一样给 null,而不是建一个
// 退化成纸片的网格(height=0 的环会让法线变成 0/0)。绘制处另有 earH>0
// 的判据,两道都留着:滑杆拖到 0 时两边同时安静。
this.mEar = this.p.earH>0
? new GMesh(this.gl,
earMesh(this.p.earW, this.p.earH, this.p.earThick,
this.p.earBend*Math.PI/180, 6, 10))
: null;
}
}
/**
* 瞳孔 / 高光 / 眉毛所在的 z(相对面平面)。眼球是**胶囊**,在 z 上也有半径
* ([eyeR]),把瞳孔按面片画在面平面上会被它自己的眼球挡掉。
*
* 这条公式是 **eyeR + 0.025**,跟真机的 `EmotionBallRenderer.eyeFrontZ` 一样。
* 从前这里是一个死数 0.16 —— 那是照果冻球(eyeR 0.135)凑出来的,换到眼睛
* 更小的奶油球(0.122)上就偏前了 0.013。这种"两边都对、但不一样"的偏移
* 正是这个页面最怕的:用户照着它调完,装到机器上又是另一个东西。
*/
get eyeFront(){ return this.p.eyeR + 0.025; }
resize(){
const dpr=Math.min(2,window.devicePixelRatio||1);
const w=Math.max(1,Math.round(this.cv.clientWidth*dpr));
const h=Math.max(1,Math.round(this.cv.clientHeight*dpr));
if(this.cv.width!==w||this.cv.height!==h){ this.cv.width=w; this.cv.height=h; }
const gl=this.gl;
gl.viewport(0,0,this.cv.width,this.cv.height);
this.proj=M4.perspective(42,this.cv.width/this.cv.height,0.1,100);
this.pointFactor=this.cv.height/(2*Math.tan(42*Math.PI/180/2));
}
frame(dt,t){
const gl=this.gl, p=this.p;
this.st.tick(dt,t,this.mood,p);
if(this.autoFidget && this.st.action==='NONE'){
this.fidNext-=dt;
if(this.fidNext<=0){
const pool=['STRETCH','LOOK_AROUND','WIGGLE','BOUNCE','HOP'];
this.st.trigger(pool[Math.floor(Math.random()*pool.length)]);
this.fidNext=14+Math.random()*22;
}
}
gl.clearColor(0,0,0,0);
gl.clear(gl.COLOR_BUFFER_BIT|gl.DEPTH_BUFFER_BIT);
gl.enable(gl.DEPTH_TEST);
gl.enable(gl.BLEND);
let root=M4.id();
root=M4.translate(root,0,this.st.hopY,0);
root=M4.rotate(root,this.st.rotX*57.29578,1,0,0);
root=M4.rotate(root,this.st.rotY*57.29578,0,1,0);
root=M4.rotate(root,this.st.rotZ*57.29578,0,0,1);
root=M4.scale(root,this.st.scaleX,this.st.scaleY,this.st.scaleX);
this.root=root;
this.face=M4.translate(root,0,0,p.faceZ);
const c=this.st.nowColor;
/* ---- 1. 身体 ---- */
const albedo=[0,0,0];
for(let i=0;i<3;i++) albedo[i]=(p.bodyBase[i]+(c[i]-p.bodyBase[i])*p.tint)*p.albedoMul;
this.albedo=albedo;
// 硬描边:先画一圈放大的实心暗球,再让身体压上去,中间留一条边。
// 关键在 depthMask(false) —— 描边球比身体大,整个包在身体外面,
// 如果它写了深度,后面画的身体深度更大,会被它自己那圈描边挡掉,
// 结果是一颗纯黑的球。不写深度,它就成了身体后面的一层衬底。
if(p.outline>0.001){
gl.blendFunc(gl.SRC_ALPHA,gl.ONE_MINUS_SRC_ALPHA);
gl.depthMask(false);
const os=p.bodyScale+p.outline;
const om=M4.scale(root,os,os,os);
const omv=M4.mul(this.view,om), omvp=M4.mul(this.proj,omv);
this.pSolid.use();
gl.uniform1f(this.pSolid.u('uAlpha'),1);
gl.uniform3fv(this.pSolid.u('uColor'),p.outlineColor);
gl.uniformMatrix4fv(this.pSolid.u('uMVP'),false,omvp);
this.mBody.bind(this.pSolid.a('aPos'));
this.mBody.draw();
// 描边层里的耳朵。注意这是**硬描边这一套(p.outline)**独有的,真机的
// drawEars 里没有对应的一笔 —— 真机给耳朵的边靠 earShade(比身体暗一档)
// 换来的,不靠再画一层放大的壳。目前没有任何预设同时开 outline 和耳朵,
// 所以这一步在屏幕上永远走不到;打开之前先想好在 Kotlin 那边怎么补。
if(p.earH>0) this.drawEars(1+p.outline/p.earW, p.outlineColor);
}
let m=M4.scale(root,p.bodyScale,p.bodyScale,p.bodyScale);
let mv=M4.mul(this.view,m), mvp=M4.mul(this.proj,mv);
gl.blendFunc(gl.SRC_ALPHA,gl.ONE_MINUS_SRC_ALPHA);
gl.depthMask(true);
this.pBody.use();
gl.uniformMatrix4fv(this.pBody.u('uMVP'),false,mvp);
gl.uniformMatrix4fv(this.pBody.u('uMV'),false,mv);
gl.uniform3fv(this.pBody.u('uColor'),albedo);
gl.uniform1f(this.pBody.u('uGrad'),p.grad);
gl.uniform1f(this.pBody.u('uAmb'),p.amb);
gl.uniform1f(this.pBody.u('uDiff'),p.diff);
gl.uniform1f(this.pBody.u('uGloss'),p.gloss);
gl.uniform1f(this.pBody.u('uAlpha'),1);
this.mBody.bind(this.pBody.a('aPos'),this.pBody.a('aNormal'));
this.mBody.draw();
if(p.earH>0) this.drawEars(1, null);
/* ---- 2. 五官 ---- */
gl.blendFunc(gl.SRC_ALPHA,gl.ONE_MINUS_SRC_ALPHA);
gl.depthMask(true);
this.pSolid.use();
const aPos=this.pSolid.a('aPos');
// uAlpha 必须显式给 —— 片元是 vec4(uColor, uAlpha),漏设就是 0,
// 混合后贡献为零,整条五官管线会静默地什么都不画。
gl.uniform1f(this.pSolid.u('uAlpha'),1);
const round=this.st.eyeYScale*(1-this.st.eyeArc);
const arc=this.st.eyeArc;
const eX=p.eyeX+this.st.eyeOffX, eY=p.eyeY+this.st.eyeOffY;
const pivotScale=round;
if(round>0.01){
for(const side of [-1,1]){
const rz = side<0 ? this.st.eyeLRotZ : this.st.eyeRRotZ;
this.faceElem(side*eX, eY, rz, round, 1, EYE_LID_PIVOT);
gl.uniformMatrix4fv(this.pSolid.u('uMVP'),false,this.mvp);
gl.uniform3fv(this.pSolid.u('uColor'),p.eyeColor);
this.mEye.bind(aPos); this.mEye.draw();
}
}
// 瞳孔 + 高光:跟着眼睛一起眨
// arc < 0.5:`^ ^` 眯眼时眼球已经塌成一条线,再挂个瞳孔就是脸上一个孤点。
if(p.eyeStyle!=='plain' && round>0.05 && arc<ARC_EYE_AT){
const pupilCol=[c[0]*0.20+0.045, c[1]*0.20+0.050, c[2]*0.20+0.075];
for(const side of [-1,1]){
const ex=side*eX, ey=eY;
const rz = side<0 ? this.st.eyeLRotZ : this.st.eyeRRotZ;
if(p.eyeStyle==='pupil'){
const pr=p.pupilR;
// 三个坑一起来:pivotY 必须传 0(sy 是自己的半径,套眼睑铰链
// 补偿会把瞳孔推到脸颊上);z 要压扁成片;z 还要抬到眼球前面
// —— 胶囊眼球在 z 上有半径,不抬就整颗瞳孔沉在眼球背面。
// sx 上乘 pupilAspect:竖缝是最便宜的一次"换物种",一个乘法的事。
// 漏掉它,小恶魔在实验室里就是一双圆瞳孔 —— 而真机上不是。
this.faceElem(ex-pr*0.12, ey-pr*0.20, rz, pr*round, pr*p.pupilAspect,
0, pr*0.06, this.eyeFront);
gl.uniformMatrix4fv(this.pSolid.u('uMVP'),false,this.mvp);
gl.uniform3fv(this.pSolid.u('uColor'),pupilCol);
this.mDot.bind(aPos); this.mDot.draw();
// 瞳孔里的白点。贴纸风不要它:有高光就有立体,扁平是它的全部意思。
const sr=p.specR;
if(sr>0.001){
this.faceElem(ex-pr*0.34, ey+pr*0.26, rz, sr*round, sr, 0, sr*0.06, this.eyeFront+0.02);
gl.uniformMatrix4fv(this.pSolid.u('uMVP'),false,this.mvp);
gl.uniform3fv(this.pSolid.u('uColor'),[1,1,1]);
this.mDot.bind(aPos); this.mDot.draw();
}
} else if(p.specR>0.001) {
// 深色豆豆眼 + 一点白高光,落在眼睛的左上
const sr=p.specR;
this.faceElem(ex-p.eyeR*0.36, ey+p.eyeR*0.40, rz, sr*round, sr, 0, sr*0.06, this.eyeFront);
gl.uniformMatrix4fv(this.pSolid.u('uMVP'),false,this.mvp);
gl.uniform3fv(this.pSolid.u('uColor'),[1,1,1]);
this.mDot.bind(aPos); this.mDot.draw();
}
}
}
// 弧形眼 ^ ^
if(arc>0.01){
const h=arc*this.st.lid;
for(const side of [-1,1]){
const rz = side<0 ? this.st.eyeLRotZ : this.st.eyeRRotZ;
this.faceElem(side*eX, eY-EYE_ARC_DROP, EYE_ARC_ROT_Z+rz, h, arc);
gl.uniformMatrix4fv(this.pSolid.u('uMVP'),false,this.mvp);
gl.uniform3fv(this.pSolid.u('uColor'),p.eyeColor);
this.mArc.bind(aPos); this.mArc.draw();
}
}
// 嘴。cat 就是同一条半环画两次、各缩到一半宽、并排拼起来 —— 两条弧在
// 中间相接,读出来就是 ω。比再造一个网格省事,也省得为它单独配参数。
const mouthCol = p.mouthMode==='deep' ? [c[0]*0.40,c[1]*0.40,c[2]*0.40] : c;
gl.uniform3fv(this.pSolid.u('uColor'),mouthCol);
if(p.mouthStyle==='cat'){
const mo=(p.mouthR+p.mouthTube)*0.5; // 半个弧宽,两条正好在 x=0 相接
for(const side of [-1,1]){
this.faceElem(side*mo, this.st.mouthY, this.st.mouthRotZ, this.st.mouthScaleY, 0.5);
gl.uniformMatrix4fv(this.pSolid.u('uMVP'),false,this.mvp);
this.mMouth.bind(aPos); this.mMouth.draw();
}
} else {
this.faceElem(0, this.st.mouthY, this.st.mouthRotZ, this.st.mouthScaleY);
gl.uniformMatrix4fv(this.pSolid.u('uMVP'),false,this.mvp);
this.mMouth.bind(aPos); this.mMouth.draw();
}
this.drawBrows(aPos);
// 鼻涕泡:一个透明的水滴。不是实心圆片 —— 中间是透的,球体自己透出来,
// 只有轮廓一圈(折射边)和左上一个小高光。用整颗球而不是压扁的片,
// 因为菲涅尔要的就是"球面朝向",压扁之后轮廓就没了。
if(this.st.bubble>0.01){
const br=p.bubbleR*this.st.bubbleScale*this.st.bubble;
let bm=M4.id();
bm=M4.translate(bm,p.bubbleX,p.bubbleY,0);
bm=M4.scale(bm,br,br,br);
const bmodel=M4.mul(this.face,bm);
const bmv=M4.mul(this.view,bmodel), bmvp=M4.mul(this.proj,bmv);
gl.blendFunc(gl.SRC_ALPHA,gl.ONE_MINUS_SRC_ALPHA);
gl.depthMask(false);
this.pBubble.use();
gl.uniformMatrix4fv(this.pBubble.u('uMVP'),false,bmvp);
gl.uniformMatrix4fv(this.pBubble.u('uMV'),false,bmv);
gl.uniform3fv(this.pBubble.u('uColor'),p.bubbleColor);
gl.uniform1f(this.pBubble.u('uAlpha'),this.st.bubble);
gl.uniform1f(this.pBubble.u('uPow'),p.bubblePow);
gl.uniform1f(this.pBubble.u('uShine'),p.bubbleShine);
gl.uniform1f(this.pBubble.u('uInner'),p.bubbleInner);
this.mBody.bind(this.pBubble.a('aPos'),this.pBubble.a('aNormal'));
this.mBody.draw();
gl.depthMask(true);
}
/* ---- 3. 腮红 ---- */
// restBlush —— 静止脸也带一点血色。球一天里绝大多数时间是 CALM,
// 而"只有开心才有腮红"等于默认那张脸永远没有脸颊。
const bl=Math.min(1,(this.st.blush+p.restBlush)*p.blushMul);
if(bl>0.01){
const light = p.blushBlend==='alpha';
const d=this.mBlush.data;
for(let n=0;n<2;n++){
const j=n*6;
d[j]=n===0?-p.blushX:p.blushX;
d[j+1]=p.blushY; d[j+2]=-0.02;
d[j+3]=p.blushColor[0]; d[j+4]=p.blushColor[1]; d[j+5]=p.blushColor[2];
}
this.mBlush.upload();
mv=M4.mul(this.view,this.face); mvp=M4.mul(this.proj,mv);
gl.blendFunc(gl.SRC_ALPHA, light?gl.ONE_MINUS_SRC_ALPHA:gl.ONE);
gl.depthMask(false);
this.pPts.use();
gl.uniformMatrix4fv(this.pPts.u('uMVP'),false,mvp);
gl.uniformMatrix4fv(this.pPts.u('uMV'),false,mv);
gl.uniform1f(this.pPts.u('uPointFactor'),this.pointFactor);
gl.uniform1f(this.pPts.u('uSize'),p.blushSize);
gl.uniform1f(this.pPts.u('uAlpha'),bl*p.blushAlpha);
this.mBlush.bind(this.pPts.a('aPos'),this.pPts.a('aColor'));
this.mBlush.draw();
}
/* ---- 4. 描边 / 光晕 ---- */
m=M4.scale(root,RIM,RIM,RIM);
mv=M4.mul(this.view,m); mvp=M4.mul(this.proj,mv);
gl.depthMask(false);
this.pRim.use();
gl.uniformMatrix4fv(this.pRim.u('uMVP'),false,mvp);
gl.uniformMatrix4fv(this.pRim.u('uMV'),false,mv);
gl.uniform1f(this.pRim.u('uPow'),p.rimPow);
// 扫描是"光"在扫:只有发光描边那一路的 uColor 是亮色。深色描边那一路
// uColor 是暗部色,扫过去就是在球上滚一条黑带,看着像渲染坏了。
gl.uniform1f(this.pRim.u('uScanY'),this.st.scanY);
gl.uniform1f(this.pRim.u('uScan'), p.rimMode==='dark' ? 0 : this.st.scan);
if(p.rimMode==='dark'){
gl.blendFunc(gl.SRC_ALPHA,gl.ONE_MINUS_SRC_ALPHA);
gl.uniform3fv(this.pRim.u('uColor'),[c[0]*0.34,c[1]*0.34,c[2]*0.42]);
gl.uniform1f(this.pRim.u('uIntensity'),p.rimGain*1.15);
gl.uniform1f(this.pRim.u('uCap'),0.82);
} else {
gl.blendFunc(gl.SRC_ALPHA,gl.ONE);
const thinkBeat=this.st.think*(0.5+Math.sin(t*1.9)*0.5);
const rimI=0.85+this.st.open*0.7+thinkBeat*0.55
+Math.sin(t*p.faces[this.mood].pulse*2)*0.05;
gl.uniform3fv(this.pRim.u('uColor'),c);
gl.uniform1f(this.pRim.u('uIntensity'),rimI*p.rimGain);
gl.uniform1f(this.pRim.u('uCap'),1.0);
}
this.mRim.bind(this.pRim.a('aPos'),this.pRim.a('aNormal'));
this.mRim.draw();
gl.depthMask(true);
}
/**
* 一对眉毛 —— `EmotionBallRenderer.drawBrows` 的同一套做法。
*
* 为什么是"压扁的球"而不是一根条:一颗缩放过的球就是一个**透镜**形状,
* 两端自然收细,那正是一根眉毛的样子;用长方体出来的是两片方角。
*
* [p.browShade] > 0 时它是**用身体色系挖掉眼睛上内角的一块**
* ——底下幸存的白眼仁变成一个斜的杏仁,那才是"眼神"。
* 取的是**当前实时的身体色**而不是一个常量,因为身体带着表情的颜色,
* 写死的近黑色在 CALM 下对、在 TENSE 下就是一块脏。
*
* ⚠️ **现在没有任何一个形象用它,这是故意的。** 小恶魔原来走这一路
* (browShade 2.5),现在改成 [eyeMesh] 把眼睛自己的上沿切平 —— 同样
* 一道斜的杏仁,但从几何里来。理由就在下面这张表:那是一个**区间**,
* 而且是一个要同时满足两头的区间,表情一动两头都在动。切几何没有颜色可挑。
* 这一路留着给"以后某个深色形象想要一根真的眉"。见 BallLook.browShade。
*
* ⚠️ **browShade 是在 albedo 上乘,可眉毛底下的脸是打过光的。**
* 这一笔走 pSolid(平涂),值就是 `albedo × browShade`;而身体走 pBody,
* 在眉毛那个纬度大约是 `0.82 × albedo`(垂直渐变 ≈1.0,光从头顶来)。
* 于是 1.0 实际上是"比脸暗",1.05 只比脸亮 1.28 倍 —— 在近黑的球上
* 是 7/255 的差,等于看不见。**取值的判据不是"比身体亮一点",而是
* 落在"身体"和"眼睛"的正中间**:既要比身体亮(不然两端糊掉),
* 又比眼睛暗(不然挖不出楔形)。眼睛是纯白,所以目标是两者的几何中点。
* 小恶魔那颗球(albedo 亮度 0.105)的中点是 ≈0.32,就是 **2.5 × albedo**。
* 细节和整张对照表在 BallLook.browShade 与 EmotionBallRenderer.drawBrows。
*
* 倾角 = 造型自己的 [p.browTilt](**度**)+ 表情的 st.brow × 0.30rad,
* 所以一个"天生就皱着眉"的造型还能被表情拉得更凶、或者被拉平。
* 左右**分别取反**:内端朝下在左右两边是相反的旋转方向,
* 这一个符号搞错,凶脸就变成愁脸。
*
* 它们骑在**当前的眼睛高度**上(不是造型里的静止值),所以眨眼、瞟一眼
* 都会把它们一起带走,而不是把它们钉在脑门上。
*/
drawBrows(aPos){
const gl=this.gl, p=this.p;
if(!(p.browW>0)) return;
const col = p.browShade>0
? [this.albedo[0]*p.browShade, this.albedo[1]*p.browShade, this.albedo[2]*p.browShade]
: p.eyeColor;
gl.uniform3fv(this.pSolid.u('uColor'), col);
gl.uniform1f(this.pSolid.u('uAlpha'),1);
const eX=p.eyeX+this.st.eyeOffX, eY=p.eyeY+this.st.eyeOffY;
// 和 Kotlin 一样先算弧度:browTilt 是度 → /DEG;表情那项本身就是弧度。
const tilt=p.browTilt/57.29578 + this.st.brow*BROW_MOOD_TILT;
for(const side of [-1,1]){
// pivotY = 0:眉毛的 sy 就是自己的半高,眼睑那套铰链补偿会把整根眉推走
// (和瞳孔同一个坑)。z 抬到眼球前面,否则被自己的眼球吃掉。
this.faceElem(side*eX, eY+p.browY, tilt*side, p.browH, p.browW,
0, p.browH*DISC_THICKNESS, this.eyeFront);
gl.uniformMatrix4fv(this.pSolid.u('uMVP'),false,this.mvp);
this.mDot.bind(aPos); this.mDot.draw();
}
}
/**
* 一对耳朵。挂在 [root] 上,所以身体压扁、跳起来、歪头它都跟着 ——
* 长在头上的东西不该有自己的动作。
*
* [scaleMul] !== 1 时用纯色画(硬描边那一层):描边不需要法线,
* 也就不必为放大后的比例再建一个网格。
*/
drawEars(scaleMul, flatColor){
const gl=this.gl, p=this.p;
if(!this.mEar) return;
const flat = flatColor != null;
if(flat){
this.pSolid.use();
gl.uniform1f(this.pSolid.u('uAlpha'),1);
gl.uniform3fv(this.pSolid.u('uColor'),flatColor);
} else {
this.pBody.use();
gl.uniform1f(this.pBody.u('uAlpha'),1);
gl.uniform1f(this.pBody.u('uGrad'),p.grad);
gl.uniform1f(this.pBody.u('uAmb'),p.amb);
gl.uniform1f(this.pBody.u('uDiff'),p.diff);
gl.uniform1f(this.pBody.u('uGloss'),p.gloss);
// 耳朵比身体暗一档(earShade)。一条**浅色**球上这是必需的:耳朵伸在
// 身体那条深描边之外,自己没有边,在亮色 App 上会糊进背景。
// 同一个乘数在真机 drawEars 里也有(BallLook.earShade)。
const e=this.albedo||[0.5,0.5,0.5];
gl.uniform3f(this.pBody.u('uColor'),
e[0]*p.earShade, e[1]*p.earShade, e[2]*p.earShade);
}
for(const side of [-1,1]){
let l=M4.id();
l=M4.translate(l, side*p.earX, p.earY, p.earZ);
// 往两边撇开:顶点从 +Y 转向 ∓x,所以左耳(+x 转角)往外。
// earTilt 是**度**(跟 BallLook.earTilt 一致),M4.rotate 收的就是度。
l=M4.rotate(l, -side*p.earTilt, 0,0,1);
if(scaleMul!==1) l=M4.scale(l,scaleMul,scaleMul,scaleMul);
const model=M4.mul(this.root,l);
const mv=M4.mul(this.view,model), mvp=M4.mul(this.proj,mv);
if(flat){
gl.uniformMatrix4fv(this.pSolid.u('uMVP'),false,mvp);
this.mEar.bind(this.pSolid.a('aPos'));
} else {
gl.uniformMatrix4fv(this.pBody.u('uMVP'),false,mvp);
gl.uniformMatrix4fv(this.pBody.u('uMV'),false,mv);
this.mEar.bind(this.pBody.a('aPos'),this.pBody.a('aNormal'));
}
this.mEar.draw();
}
}
/* face 空间里的一个元素:T * R * S,跟 setLocalFromFace 同序。
sz 默认跟随 sx —— 点状元素(瞳孔、高光)是各向同性的小球,
漏掉 z 会把单位球沿视线拉成一根柱,糊掉整颗球。 */
faceElem(x,y,rotZ,sy,sx=1,pivotY=0,sz=null,zOff=0){
let l=M4.id();
l=M4.translate(l,x,y+pivotY*(1-sy),zOff);
l=M4.rotate(l,rotZ*57.29578,0,0,1);
l=M4.scale(l,sx,sy,sz===null?1:sz);
const model=M4.mul(this.face,l);
const mv=M4.mul(this.view,model);
this.mvp=M4.mul(this.proj,mv);
}
}
/* =========================================================================
9. UI
========================================================================= */
let curPreset=P_CREAM.key;
const edited={};
PRESETS.forEach(p=>edited[p.key]=clone(p));
let stages=[];
let heroes=[];
function showErr(e){
const box=document.getElementById('err');
box.style.display='block';
box.textContent=String(e && e.stack || e);
console.error(e);
}
function buildStage(presetKey){
const p=PRESETS.find(q=>q.key===presetKey);
const cell=document.createElement('div');
cell.className='cell'; cell.dataset.k=presetKey;
cell.setAttribute('aria-pressed', presetKey===curPreset ? 'true':'false');
cell.innerHTML=`
<div class="stage dark">
<div class="badge">1:1</div>
<canvas></canvas>
</div>
<div class="cap"><b>${p.label}${p.key==='cream'||p.key==='imp'?' · 已落地':''}</b><span>${p.tag}</span></div>`;
cell.onclick=()=>{ curPreset=presetKey; syncUI(); };
return {el:cell, cv:cell.querySelector('canvas'), key:presetKey, ball:null};
}
/** 网格的底子只是 CSS —— 画布本来就是透明的,切换不用重画。 */
function setBg(bg){
stages.forEach(s=>{ s.el.querySelector('.stage').className='stage '+bg; });
document.querySelectorAll('#bgToggle button').forEach(b=>{
b.setAttribute('aria-pressed', b.dataset.bg===bg ? 'true':'false');
});
}
function build(){
const ci=document.getElementById('presets');
PRESETS.forEach(p=>{
const b=document.createElement('button');
b.type='button'; b.dataset.k=p.key;
b.innerHTML=`${p.label}<span class="tag">${p.tag}</span>`;
b.onclick=()=>{ curPreset=p.key; syncUI(); };
ci.appendChild(b);
});
const ms=document.getElementById('mood');
MOODS.forEach(m=>{
const o=document.createElement('option'); o.value=m; o.textContent=m; ms.appendChild(o);
});
ms.value='SLEEPING';
ms.onchange=()=>{
stages.forEach(s=>s.ball.mood=ms.value);
heroes.forEach(h=>h.mood=ms.value);
};
// 网格:每个预设一个 1:1 画布。Ball 必须在挂进 DOM 之后建,
// 它要读 clientWidth 才知道画多大。
const grid=document.getElementById('grid');
PRESETS.forEach(p=>{
const st=buildStage(p.key);
grid.appendChild(st.el);
st.ball=new Ball(st.cv, edited[p.key]);
st.ball.mood='SLEEPING';
stages.push(st);
});
// 放大区:同一个预设、两种底子,各一个画布。
heroes=[...document.querySelectorAll('.heroCv')].map(cv=>{
const b=new Ball(cv, edited[curPreset]);
b.mood='SLEEPING';
return b;
});
document.querySelectorAll('#bgToggle button').forEach(b=>{
b.onclick=()=>setBg(b.dataset.bg);
});
bindSliders();
syncUI();
requestAnimationFrame(loop);
}
const SLIDERS=[
['s-eyeR','eyeR','v-eyeR',v=>v.toFixed(3)],
['s-eyeX','eyeX','v-eyeX',v=>v.toFixed(3)],
['s-eyeY','eyeY','v-eyeY',v=>v.toFixed(3)],
['s-tint','tint','v-tint',v=>v.toFixed(2)],
['s-mul','albedoMul','v-mul',v=>v.toFixed(2)],
['s-gloss','gloss','v-gloss',v=>v.toFixed(2)],
['s-blush','blushMul','v-blush',v=>v.toFixed(2)],
['s-smile','smileBoost','v-smile',v=>v.toFixed(2)],
['s-bubR','bubbleR','v-bubR',v=>v.toFixed(3)],
['s-bubY','bubbleY','v-bubY',v=>v.toFixed(3)],
['s-bubIn','bubbleInner','v-bubIn',v=>v.toFixed(2)],
// 耳朵 / 眉毛。earTilt、browTilt 在 BallLook 里都是**度**,所以显示也带度数,
// 不然 24 和 0.42 摆在一起,用户没法判断哪个是"撇了 24 度"。
['s-earH','earH','v-earH',v=>v.toFixed(2)],
['s-earY','earY','v-earY',v=>v.toFixed(3)],
['s-earX','earX','v-earX',v=>v.toFixed(3)],
['s-earTilt','earTilt','v-earTilt',v=>v.toFixed(0)+'°'],
['s-earShade','earShade','v-earShade',v=>v.toFixed(2)],
['s-browW','browW','v-browW',v=>v.toFixed(3)],
['s-browY','browY','v-browY',v=>v.toFixed(3)],
['s-browTilt','browTilt','v-browTilt',v=>v.toFixed(0)+'°'],
// 眼神。eyeCut 是**比例**(上半个眼睛切掉多少),eyeTilt 是度 —— 和 BallLook
// 里的字段同名同单位。eyeCut 拖动能重建网格,见 setParams 的 changedSame。
['s-eyeCut','eyeCut','v-eyeCut',v=>v.toFixed(2)],
['s-eyeTilt','eyeTilt','v-eyeTilt',v=>v.toFixed(0)+'°'],
['s-pupilAspect','pupilAspect','v-pupilAspect',v=>v.toFixed(2)],
];
function bindSliders(){
SLIDERS.forEach(([sid,key,vid,fmt])=>{
const s=document.getElementById(sid);
s.oninput=()=>{
const v=parseFloat(s.value);
edited[curPreset][key]=v;
document.getElementById(vid).textContent=fmt(v);
applyAll();
};
});
document.getElementById('reset').onclick=()=>{
edited[curPreset]=clone(PRESETS.find(p=>p.key===curPreset));
applyAll(); syncUI();
};
}
function syncUI(){
document.querySelectorAll('#presets button').forEach(b=>{
b.setAttribute('aria-pressed', b.dataset.k===curPreset ? 'true':'false');
});
stages.forEach(s=>s.el.setAttribute('aria-pressed', s.key===curPreset ? 'true':'false'));
const p=edited[curPreset];
SLIDERS.forEach(([sid,key,vid,fmt])=>{
document.getElementById(sid).value=p[key];
document.getElementById(vid).textContent=fmt(p[key]);
});
applyAll();
}
function applyAll(){
stages.forEach(s=>s.ball.setParams(edited[s.key]));
heroes.forEach(h=>h.setParams(edited[curPreset]));
}
let last=performance.now(), t0=last;
function loop(now){
const dt=Math.min(0.05,(now-last)/1000); last=now;
const t=(now-t0)/1000;
try{
stages.forEach(s=>s.ball.frame(dt,t));
heroes.forEach(h=>h.frame(dt,t));
}catch(e){ showErr(e); return; }
requestAnimationFrame(loop);
}
try{
build();
window.addEventListener('resize',()=>{ stages.forEach(s=>s.ball.resize()); heroes.forEach(h=>h.resize()); });
// 给测量脚本用:把渲染器和矩阵栈暴露出去,好从画布上量实际像素。
window.LAB={Ball,M4,FACE_OLD,FACE_NEW,PRESETS,edited,version:'v31',
get stages(){return stages}, get heroes(){return heroes}};
window.__ready=true;
}catch(e){ showErr(e); }
</script>
</body>
</html>