Skip to content

armgit / andee

Public Imported from GitHub
0

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、支持任意模型,记忆和密码绝不离开设备。

20.9 KB
Raw Blame
#!/usr/bin/env python3
"""实验室与真机是否还对得上。

`reports/ball-cutie-lab.html` 是这套球球的规格说明书:用户在那个页面上看效果、
拖参数、做决定,然后把结论落到 Kotlin。所以两边一旦漂移,用户就是拿一个假的样机
在做决策 —— 而这是发生过的:

  * 实验室的 RIM_FS 少写了一条扫描光带,真机上多出一条从下往上滚的色带。
    参数核对脚本查不出这个,因为参数全对,错的是着色器。
  * 我手改 RIM_FS 时把 `abs(d)` 写成了 `d`,band 从 [0,1] 变成最大 140,
    被 clamp 到满强度 —— 整颗球从下往上染色。实验室里依然看不见。

这个脚本查两件事:**参数逐位**、**着色器语义**(忽略空白与注释)。
只做检查,不改任何文件;不一致就退出码 1。

    python3 tools/check_look_sync.py
"""
import re
import sys
from pathlib import Path

# 仓库根目录按脚本自身位置推断。别写死绝对路径 —— 写死过一次,别人 clone 下来
# 脚本第一行就指向一个不存在的目录,且报错是"文件读不到",看不出是路径问题。
ROOT = Path(__file__).resolve().parent.parent
KT_LOOK = ROOT / "app/src/main/java/net/kuafuai/andee/ui/ball/BallLook.kt"
KT_RENDERER = ROOT / "app/src/main/java/net/kuafuai/andee/ui/ball/EmotionBallRenderer.kt"
KT_MOOD = ROOT / "app/src/main/java/net/kuafuai/andee/ui/ball/Mood.kt"
LAB = ROOT / "reports/ball-cutie-lab.html"

# 参数名对应:实验室里叫什么 → Kotlin 里叫什么
PARAMS = [
    ("bodyBase", "bodyBase"), ("tint", "bodyTint"), ("albedoMul", "bodyAlbedo"),
    ("grad", "bodyGrad"), ("amb", "bodyAmb"), ("diff", "bodyDiff"),
    ("gloss", "bodyGloss"), ("bodyScale", "bodyScale"),
    ("faceZ", "faceZ"), ("eyeX", "eyeX"), ("eyeY", "eyeY"),
    ("eyeR", "eyeRadius"), ("eyeH", "eyeCyl"),
    ("mouthR", "mouthR"), ("mouthTube", "mouthTube"),
    ("mouthY", "mouthY"), ("mouthThick", "mouthThick"),
    ("eyeColor", "eyeColor"), ("pupilR", "pupilR"), ("specR", "glintR"),
    ("blushColor", "blushColor"), ("blushAlpha", "blushAlpha"),
    ("blushSize", "blushSize"), ("blushX", "blushX"), ("blushY", "blushY"),
    ("rimGain", "rimGain"), ("rimPow", "rimPow"),
    ("bubbleX", "bubbleX"), ("bubbleY", "bubbleY"), ("bubbleR", "bubbleR"),
    ("bubbleColor", "bubbleColor"), ("bubblePow", "bubblePow"),
    ("bubbleShine", "bubbleShine"), ("bubbleInner", "bubbleInner"),
    # 耳朵与眉毛。奶油球 2026-09-30 长出来的那一对耳朵,加在这里是因为它们**进
    # 了屏幕上的轮廓**:earH/earX/earY/earTilt 一起决定耳朵出不出球的边。
    # (眉毛曾经的理由也是"压不压到眼睛上" —— 但奶油球那对同一天删掉了,
    # 现在只有 BAJIE 还在用,而它在实验室里根本没有预设。字段仍然留着核对,
    # 因为它给"以后某个形象想要一根真的眉"留了路。)
    #
    # ⚠️ 想验"眉压没压到眼睛"不能只看 browY:眉盘是 dotMesh 缩放的**椭圆**再旋转,
    # 最低点是 `cy − √((w·sinθ)² + (h·cosθ)²)`,不是 `cy − browH`;眼睛的顶也不是
    # `eyeY + eyeRadius`(那只是球,漏了圆柱段 eyeCyl/2)—— 奶油球当初就是在这两个
    # 地方都算错,才把一根眉放到了几乎贴着眼球的位置(见 BallLook.CREAM 的注释)。
    # browShade 故意**不在**这个表里:它是"零即关",Kotlin 侧没有任何形象写这一行,
    # 而实验室的 preset 表为了格式整齐每个形象都把它列出来。核对一个恒为默认值的
    # 字段没有意义。
    ("earH", "earH"), ("earW", "earW"), ("earThick", "earThick"),
    ("earX", "earX"), ("earY", "earY"), ("earZ", "earZ"),
    ("earTilt", "earTilt"), ("earBend", "earBend"), ("earShade", "earShade"),
    ("browW", "browW"), ("browH", "browH"),
    ("browY", "browY"), ("browTilt", "browTilt"),
    # 眼神。eyeCut 是**进屏幕轮廓的那一类**:0.48 把眼睛上沿切掉 23% 的高度,
    # 眼睛从竖椭圆变成横的;eyeTilt 把整颗眼睛连瞳孔一起转。这两条在实验室里
    # 调完不落回 Kotlin,用户看到的就是另一双眼睛。
    ("eyeCut", "eyeCut"), ("eyeTilt", "eyeTilt"),
    ("pupilAspect", "pupilAspect"),
]

# 真正核对的形象。**这个元组是唯一的定义处** —— 下面的循环、末尾的报告都读它,
# 免得"核对了哪些"和"报告说核对了哪些"各写一遍然后对不上。
#
# imp 加进来的理由很具体:它是唯一一个曾经完全没覆盖的落地形象,而"眉毛和脸
# 同色看不见"那个 bug 正因为它不在这里,只能在真机上被发现。它现在在,但只是
# **部分**在 —— 角/獠牙/尾巴这一页画不出来,见 LAB_BLIND_SPOTS。
CHECKS = ("cream", "imp")

# 实验室**画不出来**的几何,按形象列。这和"参数没核对"是两件事,报告里必须分开:
# 前者是实验室会画出一颗形状不对的球(可见的谎),后者只是漏检(没覆盖)。
# 混在一起说,用户就会以为预设里的球等于真机上的球。
LAB_BLIND_SPOTS = {
    "imp": "角、獠牙、尾巴",
    "bajie": "猪鼻、鼻孔",
}
# 枚举型:实验室用的是字符串
ENUMS = [
    ("mouthDeep", lambda L: L.get("mouthMode") == "deep"),
    ("blushBlendNormal", lambda L: L.get("blushBlend") == "alpha"),
    ("rimDark", lambda L: L.get("rimMode") == "dark"),
]
# 着色器别名:实验室里叫 BODY/PTS,Kotlin 里叫 SHELL/POINTS
SHADER_ALIAS = {
    "SHELL_VS": "BODY_VS", "SHELL_FS": "BODY_FS",
    "POINTS_VS": "PTS_VS", "POINTS_FS": "PTS_FS",
}
SHADERS_IN_USE = ["SOLID_VS", "SOLID_FS", "SHELL_VS", "SHELL_FS",
                  "RIM_VS", "RIM_FS", "POINTS_VS", "POINTS_FS",
                  "BUBBLE_VS", "BUBBLE_FS"]

# 表情表的字段与默认值。两边的默认值必须一致 —— Face 的具名参数和实验室
# F() 的 Object.assign 都从这里取,改一边不改另一边就是一次静默漂移。
FACE_DEFAULTS = {
    "eyeArc": 0.0, "blush": 0.0, "spread": 1.0,
    "breath": 0.022, "gape": 0.0, "bubble": 0.0,
}
FACE_FIELDS = ["c", "eye", "brow", "smile", "pulse", "tilt", "skew", "jitter",
               "eyeArc", "blush", "spread", "breath", "gape", "bubble"]


def parse_kotlin_defaults(text):
    """`BallLook` 类声明里的默认值 —— 某个 look 没写某一行时,用的就是它们。

    为什么非要知道默认值:三个形象里只有 cream 把参数写齐了,另外两个大量省略。
    如果只比对"写出来的行",省略的那些就既没核对、又和实验室的预设对不上 ——
    而 earH 恰恰是**零即关**那一类:Kotlin 省略 = 默认 0f,实验室预设写了 0.155,
    两边画的就不是同一颗球。**省略不等于"随便"**,它是一项被继承的值。

    只取**声明区**(`class BallLook(` 到 `) {` 之前)并丢掉注释行,所以 KDoc 里
    的示例文字不会被当成声明;`companion object` 里的 `private val EMPTY` 也不在
    这个区间内。
    """
    head = text[text.index("class BallLook("):]
    head = head[:head.index("\n) {")]
    lines = [ln for ln in head.split("\n")
             if not re.match(r"\s*(?:\*|/\*|//)", ln)]
    out = {}
    for m in re.finditer(
        r"\bval (\w+):\s*(\w+)\s*=\s*(floatArrayOf\([^)]*\)|[^,\n]+),",
        "\n".join(lines),
    ):
        name, kind, raw = m.group(1), m.group(2), m.group(3).strip()
        try:
            if kind == "Float":
                out[name] = float(raw.rstrip("f"))
            elif kind == "Boolean":
                out[name] = raw == "true"
            elif kind == "Int":
                out[name] = int(raw)
            elif kind == "FloatArray" and raw.startswith("floatArrayOf"):
                out[name] = [float(x.strip().rstrip("f"))
                             for x in raw[len("floatArrayOf("):-1].split(",")]
        except ValueError:
            # 值的形态不认识(比如 `EMPTY`)—— 跳过。跳过的后果是这一项被当成
            # "没有默认值",会在下面报成 Kotlin=None,是**大声**的失败,不是静默。
            pass
    return out


def parse_kotlin_look(text, name):
    body = text[text.index(f"val {name} = BallLook("):]
    body = body[:body.index("\n)")]
    out = {}
    for m in re.finditer(
        r"(\w+)\s*=\s*(floatArrayOf\([^)]*\)|[-\d.]+f|true|false)", body
    ):
        k, v = m.group(1), m.group(2)
        if v.endswith("f"):
            out[k] = float(v[:-1])
        elif v.startswith("floatArrayOf"):
            out[k] = [float(x.strip().rstrip("f"))
                      for x in v[len("floatArrayOf("):-1].split(",")]
        else:
            out[k] = v == "true"
    return out


def parse_lab_preset(text, key):
    i = text.index(f"key:'{key}'")
    i = text.rindex("const P_", 0, i)
    j = text.index("\n};", i)
    out = {}
    for m in re.finditer(
        r"(\w+)\s*:\s*(\[[^\]]*\]|'[^']*'|[-\d.]+|true|false)", text[i:j]
    ):
        k, v = m.group(1), m.group(2)
        if v.startswith("["):
            out[k] = [float(x) for x in v[1:-1].split(",")]
        elif v.startswith("'"):
            out[k] = v[1:-1]
        elif v in ("true", "false"):
            out[k] = v == "true"
        else:
            out[k] = float(v)
    return out


def strip_glsl(src):
    """归一化成可比的语义文本:去注释,声明按集合比,其余按去空白文本比。

    三件事都归一化过,因为它们在 GLSL 里都没有意义、但会让天真的文本比对
    报出一堆假警报,检查很快就没人看了:

      * 空白与换行 —— 两边排版风格不同
      * 声明顺序 —— 各自按可读性排的
      * 一行几条声明 —— 一边一行一条,另一边图省事写成一行两条

    所以声明是**按声明粒度**提取(不是按行),再排序。
    """
    src = re.sub(r"//[^\n]*", "", src)
    src = re.sub(r"/\*.*?\*/", "", src, flags=re.S)

    decl_pat = re.compile(r"\b(?:uniform|varying|attribute)\s+[^;]+;")
    decls = sorted(re.sub(r"\s+", "", d) for d in decl_pat.findall(src))
    body = decl_pat.sub("", src)
    body = re.sub(r"precision\s+\w+\s+\w+;", "", body)
    return ";".join(decls) + "||" + re.sub(r"\s+", "", body)


def kotlin_shaders(text):
    return {
        m.group(1): strip_glsl(m.group(2))
        for m in re.finditer(
            r'private const val (\w+_(?:VS|FS)) = """\n(.*?)\n\s*"""', text, re.S
        )
    }


def lab_shaders(text):
    out = {}
    for m in re.finditer(r"const (VS|FS)_(\w+) = `\n(.*?)\n`;", text, re.S):
        # 实验室里变量名不一致(mv vs mvpos)不影响语义,统一一下再比
        src = m.group(3)
        out[f"{m.group(2)}_{m.group(1)}"] = strip_glsl(src)
    return out


def slice_region(text, start_pat, end_pat):
    """截取 [start_pat, 之后第一次出现的 end_pat) 之间的源码,带行号返回。"""
    i = text.index(start_pat)
    start_line = text.count("\n", 0, i) + 1
    j = i + len(start_pat) + text[i + len(start_pat):].index(end_pat)
    return [(start_line + n, ln)
            for n, ln in enumerate(text[i:j].split("\n"))]


def check_color_ownership(label, rows, set_pat, draw_pat):
    """每一笔都必须在自己所在的分支里设过颜色。

    这是踩过两次的坑:`uColor` 是没有 attribute 的 uniform,**它会跨 draw call
    保持上次的值**。所以少设一次不会报错,只会静默地继承上一笔的颜色。

    为什么不能靠"上一条 draw 之后有没有 set"来判断:圆眼那一路是**条件分支**,
    源码里写着 `eyeMesh.draw()`、运行时却可能因为尺寸阈值不执行,
    静态看行序永远是对齐的。所以要给颜色算**作用域**:

      * 一次 set 从它自己开始生效;
      * 出现缩进比它更小的行(也就是退出了它所处的块)就失效;
      * 没有生效颜色的 draw 就是漏洞。

    这样"同色画很多笔"不会误报,而"某个分支忘了设色"会被精确抓住。

    颜色的判据是**两个 program 都算**(五官段用 SOLID,鼻涕泡用自己的 BUBBLE)。
    更严的做法是给每一笔记住它属于哪个 program,但五官段里只有水滴这一笔换了
    program,为它建一套映射不划算;代价是"用了 A 却只设了 B 的颜色"这种错会漏掉,
    而那种错在屏幕上是一眼能看出来的。
    """
    problems = []
    active = None          # 当前生效颜色所在行的缩进
    for line_no, raw in rows:
        code = raw.split("//")[0].rstrip()
        if not code.strip():
            continue
        indent = len(code) - len(code.lstrip())
        if active is not None and indent < active:
            active = None
        if re.search(set_pat, code):
            active = indent
        if re.search(draw_pat, code) and active is None:
            problems.append(
                f"{label}:{line_no} 这一笔没有在自身分支内设颜色,"
                f"会继承上一笔的遗留色"
            )
            print(f"  ✗ 第 {line_no} 行:{code.strip()[:70]}")
    return problems


def parse_kotlin_face(text):
    """Mood.kt 的 FACE 表 → {mood: {字段: 值}},默认值补齐。"""
    out = {}
    for m in re.finditer(r"Mood\.(\w+) to Face\(", text):
        i, depth, j = m.end(), 1, m.end()
        while depth:
            if text[j] == "(":
                depth += 1
            elif text[j] == ")":
                depth -= 1
            j += 1
        # 顶层逗号切分(rgb(...) 里的逗号不算)
        parts, buf, d = [], "", 0
        for ch in text[i:j - 1]:
            if ch == "(":
                d += 1
            elif ch == ")":
                d -= 1
            if ch == "," and d == 0:
                parts.append(buf)
                buf = ""
            else:
                buf += ch
        parts = [p.strip() for p in parts if p.strip()]

        # Face 的位置参数顺序:color, eye, brow, smile, pulse, tilt, skew, jitter
        ORDER = ["c", "eye", "brow", "smile", "pulse", "tilt", "skew", "jitter"]
        vals = dict(FACE_DEFAULTS)
        for k, raw in zip(ORDER, parts):
            hexm = re.search(r"0x([0-9a-fA-F]+)", raw)
            vals[k] = int(hexm.group(1), 16) if k == "c" else float(raw.rstrip("f"))
        for raw in parts[len(ORDER):]:
            name, _, val = raw.partition("=")
            vals[name.strip()] = float(val.strip().rstrip("f"))
        out[m.group(1)] = vals
    return out


def parse_lab_face(text):
    """实验室 FACE_NEW → {mood: {字段: 值}},默认值补齐。"""
    i = text.index("const FACE_NEW")
    body = text[i:text.index("\nconst MOODS", i)]
    out = {}
    for m in re.finditer(r"^\s*(\w+):\s*F\(\{([^}]*)\}\)", body, re.M):
        vals = dict(FACE_DEFAULTS)
        for kv in m.group(2).split(","):
            name, _, val = kv.partition(":")
            name, val = name.strip(), val.strip()
            if not name:
                continue
            vals[name] = int(val, 16) if val.startswith("0x") else float(val)
        out[m.group(1)] = vals
    return out


def main():
    look_src = open(KT_LOOK).read()
    render_src = open(KT_RENDERER).read()
    mood_src = open(KT_MOOD).read()
    lab_src = open(LAB).read()

    problems = []

    print("── 参数 ──")
    # 默认值是**跨形象共用**的,解析一次就够。
    defaults = parse_kotlin_defaults(look_src)
    for look in CHECKS:
        k = dict(defaults)
        k.update(parse_kotlin_look(look_src, look.upper()))
        lab = parse_lab_preset(lab_src, look)
        n = 0
        for labk, ktk in PARAMS:
            a, b = k.get(ktk), lab.get(labk)
            ok = False
            if isinstance(a, list) and isinstance(b, list) and len(a) == len(b):
                ok = all(abs(x - y) < 1e-6 for x, y in zip(a, b))
            elif isinstance(a, float) and isinstance(b, float):
                ok = abs(a - b) < 1e-6
            if ok:
                n += 1
            else:
                problems.append(f"{look}.{ktk}: Kotlin={a} 实验室={b}")
        for ktk, fn in ENUMS:
            if k.get(ktk) == fn(lab):
                n += 1
            else:
                problems.append(f"{look}.{ktk}: Kotlin={k.get(ktk)} 期望={fn(lab)}")
        print(f"  {look:<6} {n} / {len(PARAMS) + len(ENUMS)} 项一致")

    print("── 着色器(忽略注释与空白)──")
    K = kotlin_shaders(render_src)
    L = lab_shaders(lab_src)
    for name in SHADERS_IN_USE:
        lab_name = SHADER_ALIAS.get(name, name)
        a, b = K.get(name), L.get(lab_name)
        if a is None or b is None:
            problems.append(f"{name}: 一边缺失(实验室里叫 {lab_name})")
            print(f"  ✗ {name:<10} 一边缺失")
        elif a == b:
            tag = f"(实验室里叫 {lab_name})" if lab_name != name else ""
            print(f"  ✓ {name:<10} 语义一致{tag}")
        else:
            i = next((j for j in range(min(len(a), len(b))) if a[j] != b[j]),
                     min(len(a), len(b)))
            problems.append(
                f"{name}: 语义不同,首个差异在第 {i} 字符\n"
                f"      Kotlin: ...{a[max(0, i - 40):i + 60]}\n"
                f"      实验室: ...{b[max(0, i - 40):i + 60]}"
            )
            print(f"  ✗ {name:<10} 语义不同")

    print("── 表情表 ──")
    KF, LF = parse_kotlin_face(mood_src), parse_lab_face(lab_src)
    if set(KF) != set(LF):
        problems.append(f"表情表的表情对不上:只在一侧有 "
                        f"{sorted(set(KF) ^ set(LF))}")
    bad_rows = 0
    for mood in sorted(set(KF) & set(LF)):
        diffs = []
        for f in FACE_FIELDS:
            a, b = KF[mood].get(f), LF[mood].get(f)
            if a is None or b is None:
                diffs.append(f"{f}: 一侧缺失 ({a} / {b})")
            elif a != b:
                diffs.append(f"{f}: Mood.kt={a} 实验室={b}")
        if diffs:
            bad_rows += 1
            problems.append(f"{mood}: " + ";".join(diffs))
            print(f"  ✗ {mood}")
    print(f"  {len(KF) - bad_rows} / {len(KF)} 个表情逐字段一致")

    print("── 五官段:每一笔是否自带颜色 ──")
    problems += check_color_ownership(
        "EmotionBallRenderer.drawFace",
        slice_region(render_src, "private fun drawFace()", "\n    private fun "),
        r'(?:solidShader|bubbleShader)\.uniform\("uColor"\)',
        r"\w+\.draw\(\)",
    )
    problems += check_color_ownership(
        "lab 五官段",
        slice_region(lab_src, "/* ---- 2. 五官 ---- */", "/* ---- 3. 腮红 ---- */"),
        r"(?:pSolid|pBubble)\.u\('uColor'\)",
        r"this\.m\w+\.draw\(\)",
    )
    if not any("自身分支内设颜色" in p for p in problems):
        print("  ✓ 两边每一笔都自带颜色")

    # 落地的不再是一个常量,而是一张可切换的表:用户在全屏卡片上左右滑动球球
    # 换形象,没存过就用第一个。这里要说清楚**哪些真的核对过**、哪些没有,以及
    # 有预设但画不全的那种 —— 三种状态混成一句"都查了"就是这篇脚本最该避免的事。
    m = re.search(r"val ALL = listOf\(([^)]*)\)", look_src)
    names = [n.strip().lower() for n in m.group(1).split(",")] if m else []
    lab_default = re.search(r"let curPreset=P_(\w+)", lab_src).group(1).lower()
    print("\n可切换的形象: " + "、".join(names) + "(默认第一个)")
    print("参数逐项核对过: " + ("、".join(CHECKS) if CHECKS else "(无)"))
    print("实验室默认选中: " + lab_default)
    for n in names:
        if n in CHECKS:
            continue
        if f"key:'{n}'" in lab_src:
            print(f"  ⓘ {n} 有预设但没核对(不在 CHECKS 里)")
        else:
            print(f"  ⓘ {n} 实验室里没有预设 —— 它的参数完全没核对")
    for n, blind in LAB_BLIND_SPOTS.items():
        if f"key:'{n}'" in lab_src:
            print(f"  ⚠️ {n} 的预设是**部分**的:实验室画不出 {blind}。"
                  f"脸可信,轮廓不可信")

    # 这份脚本**看不到网格生成器**(Capsule / Ear / Eye 这一族):它比的是参数表、
    # shader 语义、表情表和配色归属。同一个生成器在 Kotlin 与实验室各存一份,漂了
    # 这里一声不响 —— `Eye` 就是新加的那一个。所以先把"它管不到的那部分由谁管"
    # 说出来:跑一条命令得出"全部一致"很容易被读成"什么都查过了"。
    print("\n── 这份脚本看不到的,由谁管 ──")
    for rel, what in (
        ("tools/eye_parity_check.py", "gl/Eye.kt ↔ 实验室 eyeMesh:数字 / 算术 / 轴向逐项"),
        ("tools/eye_mesh_check.py", "Eye 网格本身合法 + 注释里写下的数"),
    ):
        mark = "✓" if (ROOT / rel).exists() else "✗ 缺失"
        print(f"  {mark} {rel} —— {what}")

    if problems:
        print(f"\n❌ {len(problems)} 处不一致:")
        for p in problems:
            print("  ✗ " + p)
        return 1
    print("\n✅ 全部一致")
    return 0


if __name__ == "__main__":
    sys.exit(main())