查看: 491|回复: 3

鸿蒙PC ArkUI氛围应用文字对比度治理与CI断言实践

[复制链接]
发表于 7 小时前 | 显示全部楼层 |阅读模式
做沉浸式界面的人都有同一套肌肉记忆:看到不好看就去调渐变、调模糊、调透明度。但氛围类应用上线后收到的第一条反馈,往往不是不够梦幻,而是看久了眼睛累、这个数字看不清。本文以鸿蒙PC(2in1 桌面形态)上运行的「光屿 LumenAura」为样本,把好看这件主观的事拆成一串可以断言的数字:颜色从 .ets 搬进设计令牌表、用 alpha 合成模型还原屏幕上的真实像素、把 WCAG 的相对亮度与对比度公式搬进 ArkTS 端侧、用时间轴最坏帧取代截一帧看看,最后用二分法反解出某块面板最薄能做多薄。

全文最有价值的不是某个漂亮的结果,而是一处打脸:原以为会出事的导航玻璃面板,最坏帧 9.43:1,余量 2.1 倍;原以为最安全的渐变画布,二级文字对比度只有 1.04:1,扫完 360 个色相全程不达标。

一、氛围应用的真实失败点不在美不美

普通界面的对比度是静态的:白底黑字,量一次,一辈子。氛围界面的对比度是一个函数,输入是你的参数(色相、光强、交融度),外加一个隐藏输入——时间。光团在漂、画布在变色、玻璃面板后面是别人的像素,文字的背景是一个随时间变化的量。只截一帧去量,等于只在函数图像上取了一个点,然后宣布这条曲线安全。本文要做的事,就是把这个函数真正算出来。

平台口径需要先交代清楚:讨论的是 ArkUI 跨平台框架最原始的含义——同一份 .ets 声明式代码,靠 deviceTypes: ['2in1', 'tablet', 'phone'] 在手机、平板、2in1 桌面三种形态上复用。配套工程是纯原生 ArkTS + ArkUI 的 Stage 模型工程,dependencies: {},零第三方依赖,没有 ArkUI-X,也没有任何跨平台运行时。

需要强调的是:桌面形态把对比度从审美问题升级成了工程问题。手机上一屏只显示一页,PC 上用户可能把窗口拉满 2560 宽盯着看一小时。

二、第一步不是写公式,是把颜色从 .ets 里赶出去

在最早版本里,颜色是散落的:#0A0E1A 写在 AuroraBackground.ets,#10162B99 写在 Index.ets,#B8C2DE 写在 SpectrumLab.ets 的胶囊里,光球的三个 alpha 写在 LightOrb.ets 的三个私有方法里。直接后果不是难维护,而是没法被断言——你连这个界面上有几种文字色都答不出来,谈什么逐个校验。

所以第一件事是分层,而且是三层,不是一层。很多人做设计令牌只做第一层,然后发现还是没法校验。

第一层是原始值,只有色号,没有语义:
  1. // entry/src/main/ets/tokens/Palette.ets —— 第一层:原始值
  2. export class Primitive {
  3.   static readonly INK_900: string = '#0A0E1A';
  4.   static readonly INK_800: string = '#101636';
  5.   static readonly INK_700: string = '#10162B';
  6.   static readonly AURA_CYAN: string = '#38E8D2';
  7.   static readonly AURA_VIOLET: string = '#8A6CFF';
  8.   static readonly AURA_AMBER: string = '#FF9A4D';
  9.   static readonly TEXT_200: string = '#B8C2DE';
  10.   static readonly WHITE: string = '#FFFFFF';
  11. }
复制代码

第二层是语义值,界面只准用这一层:
  1. // entry/src/main/ets/tokens/Semantic.ets —— 第二层:语义值
  2. import { Primitive } from './Palette';
  3. export class Surface {
  4.   /** 窗口底色,必须与 start_window_background 完全一致 */
  5.   static readonly CANVAS: string = Primitive.INK_900;
  6.   /** 玻璃面板底:alpha 153/255,压在深空底上合成后约 #0B1022 */
  7.   static readonly GLASS: string = '#10162B99';
  8.   /** 玻璃亮边:alpha 18/255 的 1vp 白 */
  9.   static readonly GLASS_EDGE: string = '#12FFFFFF';
  10. }
  11. export class Content {
  12.   /** 正文/次要文字,唯一允许出现在玻璃面板上的文字色 */
  13.   static readonly BODY: string = Primitive.TEXT_200;
  14.   /** 主标题 */
  15.   static readonly TITLE: string = '#E7ECFA';
  16. }
  17. export class Aura {
  18.   static readonly CYAN: string = Primitive.AURA_CYAN + '0D';
  19.   static readonly VIOLET: string = Primitive.AURA_VIOLET + '0D';
  20.   static readonly AMBER: string = Primitive.AURA_AMBER + '0D';
  21. }
复制代码

第三层是状态层:能被交互改写的量,它们不是颜色,而是颜色的输入。
  1. // entry/src/main/ets/tokens/Live.ets —— 第三层:状态,运行时可变,每次变更都要过契约
  2. export interface AuraParams {
  3.   hueA: number;      // 0..360
  4.   hueB: number;      // 0..360
  5.   mix: number;       // 10..90
  6.   intensity: number; // 0..100
  7. }
  8. export const DEFAULT_PARAMS: AuraParams = { hueA: 190, hueB: 320, mix: 50, intensity: 70 };
  9. export interface ParamsRange {
  10.   hueMin: number; hueMax: number; mixMin: number; mixMax: number; intMin: number; intMax: number;
  11. }
  12. export const PARAM_RANGE: ParamsRange = {
  13.   hueMin: 0, hueMax: 360, mixMin: 10, mixMax: 90, intMin: 0, intMax: 100
  14. };
复制代码

三层分完,收益立刻出现:GLASS_EDGE 这个令牌暴露出一个第一版写错、而且编译器永远不会告诉你的东西。它原来是 '#FFFFFF12'——看着像白色加 alpha 18,因为 CSS 的八位写法是 #RRGGBBAA,很多人下意识按那个读。但 ArkUI 的八位顺序是 #AARRGGBB,#FFFFFF12 的真实含义是 alpha 255、RGB = FF FF 12,一个不透明的亮黄色。同一串字符两种读法,一种是一条 7% 的白边,一种是界面上一条解释不了的黄线。改成 '#12FFFFFF' 之后两者才一致。

这件事的意义不在于这一个字符,而在于:当一个颜色有名字,它就能被检查;当它是一串散落的字面量,它只能被眼睛偶然发现。后面所有契约,都建立在这个有名字的前提之上。顺带一个硬性约定:./tokens 与 ./core 目录下不允许出现任何 ArkUI 导入(不许 import { ... } from '@kit.ArkUI'),这样它才能被 Node 脚本直接跑,CI 断言就靠这条纪律。

三、合成模型:你写的颜色和屏幕上的颜色是两个东西

#B8C2DE 是那行字的颜色,但对比度算的不是它,算的是它和它背后的最终像素。而背后那个像素,是至少五层材料叠出来的结果。
  1. // entry/src/main/ets/core/Color.ets
  2. export interface Rgba { a: number; r: number; g: number; b: number; }
  3. /** ArkUI 八位十六进制:AARRGGBB;六位视为 A=255 */
  4. export function parseColor(hex: string): Rgba {
  5.   let s: string = hex.charAt(0) === '#' ? hex.substring(1) : hex;
  6.   if (s.length === 6) { s = 'FF' + s; }
  7.   return {
  8.     a: parseInt(s.substring(0, 2), 16),
  9.     r: parseInt(s.substring(2, 4), 16),
  10.     g: parseInt(s.substring(4, 6), 16),
  11.     b: parseInt(s.substring(6, 8), 16)
  12.   };
  13. }
  14. /** source-over:src 压在 dst 上,产出不透明结果 */
  15. export function over(src: Rgba, dst: Rgba): Rgba {
  16.   const sa: number = src.a / 255;
  17.   const mix = (s: number, d: number): number => Math.round(s * sa + d * (1 - sa));
  18.   return { a: 255, r: mix(src.r, dst.r), g: mix(src.g, dst.g), b: mix(src.b, dst.b) };
  19. }
复制代码

over() 只有七行,但藏着一个必须显式承认的前提:mix 是在 gamma 编码后的 sRGB 数值上做线性插值,也就是 0.6 × 16 + 0.4 × 10 = 13.6 这种对 0~255 直接乘的算法。这不是物理正确的光混合(物理上应该先转线性光、混合、再编码回去),但它是 UI 合成管线实际做的事,也是你截图之后能在拾色器里量到的值。

这一点极其关键:要复现屏幕上是什么颜色,就必须在 gamma 空间做 over();要判断这个颜色有多亮,就必须先转成线性光再算亮度。两步的顺序不能颠倒,也不能合并。最典型的错法是把亮度也算在 gamma 空间里——用 (r*0.299 + g*0.587 + b*0.114) / 255,或者干脆用 HSL 的 L。这两种算法在深色区域会给出灾难性的高估:工程里 #0A0E1A 的 HSL 明度是 (10+26)/2/255 = 7.1%,而它的真实相对亮度只有 0.45%,差了 15 倍。用 7.1% 去算,你会以为深空底色已经很亮,于是给出一堆过于乐观的结论。

还有一件在截图上一眼能看出、但很多人归错因的事:三层光团的 alpha 只有 0D(13/255,约 5%)。这么低还能看见,是因为它乘上的是一个直径 720 的低对比度大色块。视觉系统对大面积、低空间频率的色偏极其敏感,对小面积高饱和反而不敏感。这也意味着这类光团的对比度贡献极小(只让背景亮度从 0.00950 变到 0.01262),但对视觉氛围的贡献极大。氛围和可读性在参数上几乎不共享同一个量级——这正是它们能被分开治理的原因。

四、把 WCAG 公式搬进端侧:相对亮度与对比度

有了合成后的 RGB,第二步是转线性光。sRGB 的分段函数不能省,那段 0.04045 的线性段是给极暗值准备的,而氛围 UI 里全是极暗值,这一段的误差会被放大到肉眼可见。
  1. // entry/src/main/ets/core/Contrast.ets
  2. import { Rgba } from './Color';
  3. /** sRGB 分量 → 线性光,0..1 */
  4. function toLinear(channel: number): number {
  5.   const c: number = channel / 255;
  6.   return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
  7. }
  8. /** WCAG 2.x 相对亮度,权重来自人眼对 RGB 三原色的敏感度 */
  9. export function luminance(c: Rgba): number {
  10.   return 0.2126 * toLinear(c.r) + 0.7152 * toLinear(c.g) + 0.0722 * toLinear(c.b);
  11. }
  12. /** 对比度,返回 1..21。1 = 完全看不见,21 = 纯黑对纯白 */
  13. export function contrastRatio(a: Rgba, b: Rgba): number {
  14.   const la: number = luminance(a);
  15.   const lb: number = luminance(b);
  16.   const hi: number = Math.max(la, lb);
  17.   const lo: number = Math.min(la, lb);
  18.   return (hi + 0.05) / (lo + 0.05);
  19. }
复制代码

公式本身是教科书内容,真正值得写下来的是它给出的第一批判定。把工程里的基础色两两量一遍,得到的数字后面每一章都会用到。

五、第一次打脸:以为会出事的玻璃面板,其实最安全

在写这套契约之前,脑子里的危险清单排第一的是左侧那块玻璃导航。理由听起来很充分:它是半透明的(#10162B99,alpha 153/255 约 60%),背后是三层无限往返漂移的光团,还挂着 backdropBlur(30)——也就是说它采样的不是某个固定底色,而是每秒都在变的背景。直觉上等于把文字放在一条滚动的胶片上。

要把这件事算清楚,得先有一个背景函数。光团的 alpha 分布是渐变的:中心是 0D(13/255),到 radius 处衰减为 0。工程里极光青的 radius 是 300,容器半径 360,渐变在 300 处就结束,剩下 60vp 完全透明。用线性停止点模型就能近似(忽略 blur(60) 的涂抹效应,这会高估背景亮度,也就是低估对比度,属于保守估计)。
  1. // entry/src/main/ets/core/AuraField.ets
  2. import { Rgba, over, parseColor } from './Color';
  3. /** 单个光团:alpha 从中心 a0 线性衰减到 radius 处为 0 */
  4. export interface Orb { color: Rgba; a0: number; radius: number; cx: number; cy: number; }
  5. export function sampleOrbAlpha(orb: Orb, x: number, y: number): number {
  6.   const d: number = Math.sqrt((x - orb.cx) * (x - orb.cx) + (y - orb.cy) * (y - orb.cy));
  7.   const t: number = 1 - d / orb.radius;
  8.   return t <= 0 ? 0 : orb.a0 * t;
  9. }
  10. /** 把三层光团叠到底色上,返回该点的合成色(不含玻璃面板) */
  11. export function sampleBackdrop(orbs: Orb[], base: Rgba, x: number, y: number): Rgba {
  12.   let out: Rgba = base;
  13.   for (let i = 0; i < orbs.length; i++) {
  14.     const a: number = sampleOrbAlpha(orbs[i], x, y);
  15.     if (a > 0.2) {
  16.       const layer: Rgba = { a: Math.round(a), r: orbs[i].color.r, g: orbs[i].color.g, b: orbs[i].color.b };
  17.       out = over(layer, out);
  18.     }
  19.   }
  20.   return out;
  21. }
复制代码

drift 是一个从 0 跳到 260 的状态量,三层光团分别以 +drift、-drift、+drift × 0.6 消费它。于是背景变成了 drift 的函数,而 drift 又因为 iterations: -1 加 PlayMode.Alternate 在无限往返——这就是前面说的隐藏输入:时间。采样器只要把 drift 当成参数扫一遍:
  1. // entry/src/main/ets/core/WorstFrame.ets
  2. import { Rgba, over, contrastRatio } from './Contrast';
  3. export interface Panel { x0: number; y0: number; x1: number; y1: number; glass: Rgba; }
  4. /** 在整个动画周期内,求面板上最差(最低)的文字对比度 */
  5. export function worstPanelContrast(panel: Panel, text: Rgba, driftMax: number, phases: number,
  6.                                    backdropAt: (x: number, y: number, drift: number) => Rgba): number {
  7.   let worst: number = 21;
  8.   for (let p = 0; p <= phases; p++) {
  9.     const drift: number = driftMax * p / phases;
  10.     for (let x = panel.x0 + 6; x <= panel.x1; x += 10) {
  11.       for (let y = panel.y0 + 6; y <= panel.y1; y += 40) {
  12.         const pixel: Rgba = over(panel.glass, backdropAt(x, y, drift));
  13.         const cr: number = contrastRatio(text, pixel);
  14.         if (cr < worst) { worst = cr; }
  15.       }
  16.     }
  17.   }
  18.   return worst;
  19. }
复制代码

跑 25 个相位乘面板矩形内的网格点,结果是:导航玻璃面板最坏帧 9.43:1,余量 2.1 倍。真正危险的地方,并不是我担心过的那块玻璃。

六、第二次打脸:真正的灾区是从来没担心过的渐变画布

光谱工坊那块渐变画布是这个应用里视觉最强的元素:135° 线性渐变、三个停止点 A(0) → B(mix) → A(1)、borderRadius(28)、外加 shadow({ radius: 50 })。它好看,而且它是由三个数字算出来的:
  1. // entry/src/main/ets/core/Spectrum.ets
  2. import { hslToHex } from './ColorUtil';
  3. export function canvasStops(hueA: number, hueB: number, mix: number): Array<[string, number]> {
  4.   const a: string = hslToHex(hueA, 80, 60);
  5.   const b: string = hslToHex(hueB, 80, 60);
  6.   return [[a, 0], [b, mix / 100], [a, 1]];
  7. }
复制代码

hslToHex(h, 80, 60) 意味着饱和度 80%、明度 60% 恒定。而明度 60% 在 HSL 里是个非常高的值,离发光只有一步。把图里那两个配置算成 RGB 再量对比度,结论是二级文字对比度 1.04:1,扫完 360 个色相全程不达标。视觉上最抢眼的元素,恰恰是最不能让文字停留的地方。

七、反解:不问够不够透,问它最薄能做多薄

导航玻璃余量 2.1 倍,画布不能压字。但真实项目里还有一个中间态的问题会反复出现:我在这块亮背景上必须放字,那层遮罩得多厚?这个问题不能靠试,它有一个确定的答案,因为遮罩越厚 → 背景越暗 → 亮字对比度越高,是单调的。单调就可以二分:
  1. // entry/src/main/ets/core/Solve.ets
  2. import { Rgba, over } from './Color';
  3. import { contrastRatio } from './Contrast';
  4. /** 二分求解:让 fg 在 bg 上达到 target 所需的最小遮罩 alpha(0..255) */
  5. export function minVeilAlpha(fg: Rgba, bg: Rgba, veil: Rgba, target: number): number {
  6.   let lo: number = 0;
  7.   let hi: number = 255;
  8.   for (let i = 0; i < 32; i++) {
  9.     const mid: number = (lo + hi) / 2;
  10.     const layer: Rgba = { a: Math.round(mid), r: veil.r, g: veil.g, b: veil.b };
  11.     if (contrastRatio(fg, over(layer, bg)) >= target) {
  12.       hi = mid;
  13.     } else {
  14.       lo = mid;
  15.     }
  16.   }
  17.   return Math.ceil(hi);
  18. }
复制代码

32 次迭代后精度到 1/255,足够了。拿它去解上一步那两个最坏的色相,就能得到这块面板最薄需要多厚的遮罩。

八、把契约写进代码,让例外可以被复述

单点检查还不够,需要一份可执行的规则表。规则不仅要能跑,还要能管理例外:
  1. // entry/src/main/ets/core/Contract.ets
  2. import { Rgba, parseColor, over } from './Color';
  3. import { contrastRatio } from './Contrast';
  4. import { Surface, Content } from '../tokens/Semantic';
  5. export interface Rule {
  6.   name: string;
  7.   fg: string;
  8.   bg: string;
  9.   min: number;
  10.   /** 允许放行的原因,空字符串表示不许有例外 */
  11.   waiver: string;
  12. }
  13. export const RULES: Rule[] = [
  14.   { name: '正文/玻璃面板', fg: Content.BODY, bg: '#0B1022', min: 4.5, waiver: '' },
  15.   { name: '正文/深空底色', fg: Content.BODY, bg: Surface.CANVAS, min: 4.5, waiver: '' },
  16.   { name: '环形进度环/底色', fg: '#559EE7', bg: Surface.CANVAS, min: 3.0, waiver: '' },
  17.   { name: '白字/渐变画布(190°)', fg: '#FFFFFF', bg: '#47CFEB', min: 4.5,
  18.     waiver: '画布区禁止压字,规则仅作回归护栏' }
  19. ];
  20. export interface Violation { name: string; actual: number; required: number; }
  21. export function audit(): Violation[] {
  22.   const out: Violation[] = [];
  23.   for (let i = 0; i < RULES.length; i++) {
  24.     const r: Rule = RULES[i];
  25.     const cr: number = contrastRatio(parseColor(r.fg), parseColor(r.bg));
  26.     if (cr < r.min) {
  27.       out.push({ name: r.name, actual: Math.round(cr * 100) / 100, required: r.min });
  28.     }
  29.   }
  30.   return out;
  31. }
复制代码

注意最后一条规则上的 waiver 字段。它是实践中唯一可行的例外管理方式:例外必须写理由,理由必须能被人复述。「画布区禁止压字」是一个可以被复述的约定;「这个 1.04 先放过」不是。等哪天有人真的往画布上加了字,这条规则会立刻从护栏变成红线,而那时候改它的人会先读到这行字。

九、从一帧扩到一个参数域,才是真正的难点

到这里,契约还是个点检查工具:去量某一个具体组合,得到一个数字。但界面上有三个滑块,190° × 320° × 50% 只是 360×360×80 这个空间里的一个点。人工抽点必漏,因为危险区域往往不在你顺手拖出来的那几个位置附近。要把「好看」变成 CI 里可以失败的东西,采样必须从一帧扩到「一整个参数域乘一整个动画周期」。这也是这套对比度契约真正的工程价值:不是给出一个安全的配色,而是证明在某一段参数范围内,界面上任何一行文字,在动画的任何一个相位,都不会掉到可读性红线以下。

对 ArkUI 跨平台项目来说,这套做法还有额外收益:因为 ./tokens 与 ./core 不依赖 ArkUI 运行时,同一套令牌、合成、亮度、契约代码可以在 Node CI 里跑,也可以直接复用在不同 deviceTypes 的设备形态上,不需要为手机、平板、2in1 各写一份校验逻辑。

十、给同类氛围应用的几条落地建议

第一,颜色先命名再使用。三层令牌(原始值 / 语义值 / 状态量)是能被断言的最小前提,尤其是 ArkUI 的 #AARRGGBB 顺序,必须用命名 tokend 把「读错的八位色」这类隐形错误挡掉。

第二,合成与亮度分两步走。屏幕上是什么颜色要在 gamma 空间做 over(),这个颜色有多亮要先转线性光再算,两者顺序不可颠倒、也不可合并。用 HSL 的 L 当亮度,在深色区域会高估十几倍,是氛围 UI 最容易踩的坑。

第三,采样要覆盖时间轴。iterations: -1 加 PlayMode.Alternate 的漂移动画,必须被当作对比度函数的隐藏输入扫描,否则截一帧的结论没有意义。

第四,例外必须写 waiver 和理由。能用文字复述的约定才是约定,否则只是一句暂缓。

第五,把不依赖 ArkUI 的核心计算下沉到 ./core 与 ./tokens,让 CI 可以跑、让多设备形态可以复用。氛围应用的第一条线上反馈很少是不够好看,通常是看久了眼睛累——把这件事提前到 CI 里失败,比上线后再改便宜得多。
回复

使用道具 举报

发表于 7 小时前 | 显示全部楼层

Re: 鸿蒙PC ArkUI氛围应用文字对比度治理与CI断言实践

看完最大的感触就是这个“打脸”点太真实了。大家直觉上都会觉得半透明玻璃面板最危险,结果它最坏帧 9.43:1 还留着两倍余量;反而看着干干净净的渐变画布,二级文字只有 1.04:1,扫遍 360 个色相全挂。这说明光凭眼睛看和拍个截图去“感觉”,基本等于没测。把对比度当成随参数和时间变化的函数来算,这个思路比任何单个数值都有价值。 三层令牌那套我也很认同。很多团队做设计令牌只做到语义层就停了,结果状态参数(色相、光强、交融度)一改,颜色就变成运行时算出来的,断言根本落不了地。把状态也单独拎成一层、规定“变更即过契约”,这个约束挺关键。 几个想追问的点:一是最坏帧怎么取样的?是固定步长生扫时间轴,还是先找极值再局部加密?360 个色相全扫一遍在 CI 里跑得动吗,大概耗时多少。二是玻璃面板背后是“别人的像素”,这个 backdrop 在端侧是怎么还原的,是用 alpha 合成模型自己算,还是有办法拿到实际模糊后的色值。三是二分法反解最薄能多薄,这个阈值是按 4.5:1 卡的还是按 3:1 分级卡的,超小字号的会单独放宽或者收紧吗?四是 CI 断言是只拦回归(比上次差就报错)还是绝对阈值,两边都设的话误报会不会很多。 另外贴的代码最后截在 PARAM_RANGE 的 intMin 就断了,后面二分法和 CI 的部分没看到,有点可惜,希望能补全。整体思路很有借鉴意义,尤其是把主观的“好看
回复 支持 反对

使用道具 举报

发表于 7 小时前 | 显示全部楼层

Re: 鸿蒙PC ArkUI氛围应用文字对比度治理与CI断言实践

看完很有共鸣。氛围类应用把对比度当成随时间变化的函数来算,这个视角比单纯调渐变模糊靠谱多了。三层令牌分层也很关键,尤其把 hue、mix、intensity 这些状态量当成颜色的输入,而不是散落在 .ets 里,后面才谈得上断言。那个打脸点很有价值:最该担心的玻璃面板反而余量充足,最安全的渐变画布二级文字却只有 1.04:1,说明凭直觉选风险点很容易漏。用时间轴最坏帧加二分法反解最薄面板,思路很工程化。建议后续把这类失败样本固化成回归用例,失败时直接输出参数组合和时间点,再固定采样步长,避免最坏帧被偶发漏检。
回复 支持 反对

使用道具 举报

发表于 7 小时前 | 显示全部楼层

Re: 鸿蒙PC ArkUI氛围应用文字对比度治理与CI断言实践

楼主这篇把“氛围感”拆成可断言数字的思路很对我胃口,尤其是那句“对比度在氛围应用里是个函数,时间是个隐藏输入”——这个认知差很多做沉浸式界面的人一开始都意识不到,截一帧量一下就下结论,线上翻车是必然的。 三层令牌的分层我也很认同。很多人做设计令牌停在第一层原始值,觉得有了一套色板就算治理了,结果语义和状态混在一起,改动时根本没法追溯某块文字到底该走哪个颜色。第二层语义值强制界面只用这一层,第三层状态单独剥离并且每次变更要过契约,这个结构比较干净。玻璃面板底写成 `#10162B99` 并注明合成后的近似值,这种“把合成结果写进注释”的习惯挺关键,不然半年后没人记得 99 是怎么来的。 那个打脸的发现最有意思:渐变画布二级文字 1.04:1,扫 360 个色相全程不达标,说明背景随时间变化那部分才是重灾区。玻璃面板因为局部区域相对稳定反而余量充足,这个反直觉的结论挺有说服力。想问下最后二分法反解面板最薄能做多薄,代价大概是什么?是玻璃 alpha 下限、边缘亮度补偿,还是得靠调整文字层的位置或加重字重来兜底?另外 CI 里对比度的断言门槛你们是按 WCAG AA 卡的,还是考虑到桌面长时间观看留了额外 buffer?期待后续把渐变画布这块的治理细节也展开讲讲。
回复 支持 反对

使用道具 举报

您需要登录后才可以回帖 登录 | 注册

本版积分规则

指导单位

江苏省公安厅

江苏省通信管理局

浙江省台州刑侦支队

DEFCON GROUP 86025

Hacking Group 021A

旗下站点

态势感知中心

应急响应中心

红盟安全

联系我们

官方QQ群:112851260

官方邮箱:security#ihonker.org(#改成@)

官方核心成员

关注微信公众号

Archiver|手机版|小黑屋| ( 沪ICP备2021026908号 )

GMT+8, 2026-11-16 08:49 , Processed in 0.029806 second(s), 18 queries , Gzip On, Redis On.

Powered by ihonker.com

Copyright © 2015-现在.

  • 返回顶部