float 装不下地图坐标:一次精度拆分的完整推演

3 阅读26分钟

7.2 位有效数字去装 9 位坐标,丢掉的不是小数位,是米。

把 12900000.1234 存进 float 再打印,得到的是 12900000.0。丢掉的 0.1234 米本身不算致命,致命的是这个数附近所有顶点都被吸附到了同一个 1 米间隔的网格上——相邻两个顶点最多可以相差整整 1 米。按纬度 30° 算,缩放级 22 时一个像素约 0.032 米,1 米就是 31 个像素。一个本该平直的楼顶轮廓,顶点各自跳到你不知道的格点上,放大到街道级就是一条抖动的锯齿。

这不是"float 装不下大数"的故事。1.29e7 离 float 的上限 3.4e38 差了三十个数量级,装得下,装得轻轻松松。问题在位数分配:float 只有 24 位二进制有效位,全部花在整数部分之后,小数点后面一位都不剩。

要把这件事彻底讲清楚,得把"精度预算"当成一笔账来算:先算出差多少米,再算拆成两半能不能补上,再算拼回去的时候会不会又被吃掉,最后算这套方案在带宽上要付多少利息。下面按这个顺序走,每一步都落到具体数字和具体代码。

一、先把账算到小数点后:7.2 位是怎么来的

IEEE 754 的单精度浮点由三部分组成:1 位符号、8 位阶码、23 位尾数。尾数前面还有一个隐含的前导 1,所以有效二进制位是 24 位。这 24 位决定了相对精度:

2^-24 = 5.9605e-8
log10(2^24) = 24 × 0.30103 = 7.2247

也就是说,一个 float 能保证 7.2 位十进制有效数字。这里的"保证"是严格意义上的:任意一个十进制数转成 float,前 7 位一定对,第 8 位开始要看运气。

这里有个常见的混淆要拆掉:C 标准里的 FLT_DECIMAL_DIG 是 9,很多人看到 9 就以为 float 能存 9 位。不是。9 是"往返可还原"所需的最短十进制位数——把 float 打印成 9 位十进制再解析回来,能得到同一个 float;但这 9 位里后面的位是用于唯一标识这个 float 的编码,不代表原始十进制数的这 9 位被保留了下来。12900000.12 实际已经用掉 10 位有效数字,比 float 能保证的多出近 3 位,于是 .12 全丢。

"有效数字"这个词要落到实处,得换算成绝对误差。float 的相邻可表示值之间的间隔(ulp)取决于数量级:数值落在 [2e,2e+1)[2^e, 2^{e+1}) 区间时,ulp = 2^(e-23)。把它按地图上常见的数量级摊开:

坐标量级(米)示例值二进制区间ulp(米)可保证的小数位z18 像素z20 像素z22 像素
1e712,900,000[2^23, 2^24)1.001.97.730.9
1e61,290,000[2^20, 2^21)0.12510.240.973.9
1e5129,000[2^16, 2^17)0.007820.0150.060.24
1e412,900[2^13, 2^14)0.0009830.00190.00760.03
1e31,290[2^10, 2^11)0.0001224———
1e2129[2^7, 2^8)0.00001535———

(像素列按纬度 30°、Web 墨卡托分辨率 156543.03 × cos(30°) / 2^z 换算,z18 约 0.517 米/像素,z20 约 0.129,z22 约 0.0323。)

这张表说明了一件比"会抖"更有用的事:精度不是常量,是坐标量级的函数。同一个 float,在 1e2 量级能保住 5 位小数(微米级),到了 1e7 量级一位小数都保不住。而 Web 墨卡托把全球铺在 ±20037508 米见方里,中国东部的东向坐标落在 12,900,000 到 12,960,000 这一档——正好是最坏的一档。这一档里 float 的网格是 1 米,比 z20 的一个像素还宽 7.7 倍。

拿那个数走一遍:

val x = 12900000.12f   // 存成 float
println(x)              // 12900000.0,小数点后直接没了

差了 0.12 米。单个顶点的误差上界是半个 ulp,也就是 0.5 米;但两个相邻顶点各自独立地舍入,相对位移上界是整整 1 米。前者是整体偏移,看起来还像个正常的地图;后者是几何内部被撕开,这才是"面在呼吸"的真正来源。

那为什么不直接上 double?OpenGL ES 3.0 的 glVertexAttribPointer 确实接受 GL_DOUBLE,规范层面没拦你。问题在实现层面:移动 GPU 的顶点取数单元对 64 位属性的支持极不整齐,中低端芯片上常见两种降级——直接按 float 处理(精度白给),或者走一条慢路径(带宽翻倍、吞吐腰斩)。把渲染正确性押在"这颗芯片的驱动老实实现了 double 属性"上,是拿产品赌供应链。双精度在移动 GPU 上不可靠,这是一切拆分方案的前提假设。

三种存法的账摊开是这样的:

方案每顶点字节100 万顶点占用有效精度移动 GPU 可用性主要代价
纯 float(2×float)8 B8 MB7.2 位,1e7 处 ulp = 1 米完全可靠z18 以上必抖
double 属性(2×double)16 B16 MB15~17 位不可靠,可能被降级带宽翻倍且精度可能白给
float + ushort 拆分12 B12 MB优于 9 位,格点 1e-4 米完全可靠着色器重组 + 域对齐

第三行就是这篇要一层层剥开的东西。它用 12 字节换到了比 double 只差一点点的精度,代价全部转移到了代码复杂度上——而复杂度才是真正会出事的地方。

二、拆:floor、回退一个 ulp、四舍五入的边界

拆分的目标很朴素:把 12900000.1234 切成 12900000 和 0.1234 两块,前者用 float 存(整数,1e7 量级正好在 float 的整数精确范围内),后者乘 10000 变成 1234,用 ushort 存(0~65535 的整数,绰绰有余)。

/** 取整数部分:向下取整再转 float(避免负数截断) */
private fun toStoredFloat(d: Double): Float {
    val floor = Math.floor(d)
    var f = floor.toFloat()
    // float 可能因精度不足向上舍入,破坏 floor 语义,需回退一个 ulp
    if (f.toDouble() > floor) {
        f = Float.fromBits(f.toRawBits() - 1)
    }
    return f
}

/** 取小数部分:乘 10000 后四舍五入到 0~65535,存 unsigned short */
fun fourDecimal(d: Double): Short {
    val stored = toStoredFloat(d)
    val remainder = d - stored
    val raw = Math.round(remainder * 10000.0).toLong()
    return raw.toShort()   // 转成 short,交给 GL_UNSIGNED_SHORT 读取
}

十几行代码,三个边界。每一个都能单独让地图错位。

边界一:floor 不是截断。

Kotlin 的 d.toInt() 是向零截断,不是向下取整。对正数两者一样,对负数就分家了:

val d = -1.3
Math.floor(d)        // -2.0  → 余数 0.7  → 存 7000
d.toInt()            // -1    → 余数 -0.3 → 存 -3000 → 位模式 62536

一旦余数是负的,toShort() 得到的 -3000 在按 GL_UNSIGNED_SHORT 读取时会被解释成 62536,还原出来是 -1 + 6.2536 = 5.2536,符号和量级同时错,误差 6.55 米。这种错误在正数样本上永远测不出来,上线跑到西半球或者南半球才炸。

负数坐标在地图里不是边角情况:西经、南纬、以及某些地方坐标系的图层直接以 0 为原点,一半数据在负半轴。Math.floor 付出一次函数调用的代价换来的正确性,不能省。

边界二:float 向上舍入会破坏 floor 的语义。

floor(d) 是一个 double 整数,最多 17 位十进制。把它转成 float 时,如果这个整数超过 2^24,就要按"就近舍入、平局取偶"的规则落格。落格可能往上,于是 f > floor,d - f 变成负数——和边界一是同一个后果,但触发条件隐蔽得多。

具体反例。2^24 = 16,777,216,超过这个值之后 float 的相邻间隔变成 2:

val d = 16777219.25
val floor = Math.floor(d)                  // 16777219.0
val f = floor.toFloat()                    // 16777220.0 —— 平局取偶,往上落了
val raw = Math.round((d - f) * 10000.0)    // (16777219.25 - 16777220) × 1e4 = -7500
val stored = raw.toShort()                 // -7500,按无符号读是 58036
// 着色器还原:16777220.0 + 58036 / 10000.0 = 16777225.8036
// 期望 16777219.25,实际 16777225.8036,误差 6.55 米且方向反了

16,777,219 正好落在 16,777,218 和 16,777,220 中间,平局取偶选后者(尾数 8388610 是偶数)。回退一个 ulp 之后就变成 16,777,218,余数变成 1.25,存 12500,还原 16,777,219.25,分毫不差。

这个守卫在 Web 墨卡托的绝大部分范围里根本不会触发——因为 |x| < 2^24 时所有整数都能精确表示。但墨卡托的边界是 20,037,508,比 2^24 多出 3,260,292 米,也就是说投影边缘那一圈确实会踩到。回退之后余数上界从"小于 1 米"放宽到"1 个 ulp 加 1 米内的零头",在投影边缘是 3 米左右、存不到 30000,离 65535 仍有近一倍余量,编码不会溢出。

这里还有一处容易忽略的方向问题:f.toRawBits() - 1 只在正数侧成立。IEEE 754 的位模式对同号数是单调的,但负数一侧方向是反的——-1.0f 是 0xBF800000,-2.0f 是 0xC0000000,量级越大位模式越大。所以负数要往更负走,位模式得 +1:

if (f.toDouble() > floor) {
    f = Float.fromBits(
        if (f > 0f) f.toRawBits() - 1 else f.toRawBits() + 1
    )
}

在投影范围内,负数侧要 |x| > 16,777,216 才会触发,也就是西南角那一小块;但真踩上就是整块图形朝反方向平移 6 米多,排查起来比正数侧难十倍。

边界三:乘 10000 之后,Math.round 会把 1.0 交出来。

余数的名义范围是 [0, 1),乘 10000 得 [0, 10000),看起来 ushort 的 65535 只用到了 15%。但 Math.round 是四舍五入,余数一旦 ≥ 0.99995,乘完就是 9999.5 以上,取整直接得到 10000:

val d = 12900000.99999
val s = toStoredFloat(d)                       // 12900000.0
val raw = Math.round((d - s) * 10000.0)        // 0.99999 × 1e4 = 9999.9 → 10000
// 还原:12900000.0 + 10000 / 10000.0 = 12900001.0 —— 数值是对的

数值是对的(本来也该进位到 12900001.0),所以这不是精度 bug,是不变量被破坏:所有下游代码如果假设 X2 ≤ 9999,就会在这里翻车。比如把 X2、Y2 打进 13 位做紧凑存储(8191 放不下 10000),或者在断言里写死 X2 < 10000。安全的写法是把上界记成"10000,且在投影边缘可逼近 30000",也就是永远别假设它小于 65535。

另外两个小坑一起记在这里:Math.round 的平局方向是向 +∞(round(0.5) == 1),余数非负时没问题,但一旦边界二漏了、余数为负,round(-0.5) 会给 0 而不是 -1,误差被悄悄吃掉一半,反而更难查。以及 raw.toShort() 在 raw > 32767 时会得到负数——这是正常的,16 位位模式没变,GL_UNSIGNED_SHORT 读的就是这 16 位。前提是 glVertexAttribPointer 的 normalized 参数必须是 GL_FALSE,一旦传 GL_TRUE,驱动会把它除以 65535 归一化到 [0,1],整套编码直接失效。

三个边界合起来,构成了这张排查表:

现场现象直接原因根因
整块图形固定偏移数米,形状完好小数分量整体错位uniform 与顶点不在同一缩放域
个别顶点被拉到远处,几何"长刺"该点小数分量为负,按无符号读成大数用了截断而非 floor,或漏了 ulp 回退
图形沿中心点镜像符号翻转负数侧位模式方向搞反
高缩放级下顶点抖动,低缩放级正常顶点落在 1 米网格上没减中心点,绝对坐标直接进 float
图形整体缩放比例不对小数分量被归一化了normalized 传了 GL_TRUE
只有靠近投影边缘的数据错触发 2^24 以上的舍入漏了 ulp 回退守卫

三、拼:一行着色器里的三个域

拆开存只是把精度搬了个家,真正的难点在于拼回去的时候不能又被大数吃掉。顶点着色器里这一行是整套方案的核心:

float x = a_Position_X1 - u_Centre.x
        + (a_Position_X2 * 10000.0 - u_Centre.y) / 100000000.0;

它看起来像随手写的,其实每个常数的来历都能追溯。先把四个量按"域"分开:

项所在域12,900,000.1234 时的值该域相邻间隔
a_Position_X1米,整数129000001 米
u_Centre.x米,整数视口中心,量级相同1 米
a_Position_X21e-4 米格点的整数12341e-4 米
a_Position_X2 * 10000.01e8 域123400001e-8 米
u_Centre.y1e8 域中心点小数 × 1e81e-8 米
/ 100000000.0回到米0.1234—

除数 1e8 的来源。 它不是精度需要,是域对齐需要。ushort 里存的是"小数 × 1e4"的整数(1234);着色器里乘 10000 把它抬到"小数 × 1e8"(12,340,000)。中心点的小数分量要参与相减,就必须处在同一个 1e8 域,所以它也按 ×1e8 打包进 uniform。两个 1e8 域的数相减,结果再除 1e8 才回到米。写成 1e8 = 1e4 × 1e4 就一目了然:一个 1e4 来自 ushort 的存储缩放,另一个 1e4 来自 uniform 侧的提升。

这意味着打包侧有一条硬契约,必须和着色器成对维护:

// uniform 侧:小数分量必须落在 1e8 域,与 a_Position_X2 * 10000 对齐
return mvp to floatArrayOf(
    toStoredFloat(cx), fourDecimal(cx) * 10000f,
    toStoredFloat(cy), fourDecimal(cy) * 10000f
)

少了那个 * 10000f,中心点的小数分量最多有 6.55 米没被抵消掉,等于白拆一场;误差量级和拆分前完全一样,但代码看上去一切正常。这类错误最难的地方在于它不崩、不报错,只是"精度没提升"。

为什么要先减再加。 浮点加减法不是结合律成立的运算,运算顺序决定了谁被吃掉。如果写成 X1 + X2/1e4 - Cx,第一步 12900000.0 + 0.1234 就把 0.1234 咽了(1e7 量级 ulp = 1),后面再怎么减都救不回来。写成 (X1 - Cx) + frac,第一步是两个 1e7 量级的 float 相减——按 Sterbenz 引理,当 y/2 ≤ x ≤ 2y 时 x - y 是精确的,不需要舍入。两个整数部分都是精确的 float 整数,差值也是整数,落到视口范围的几百到几千米量级;这个量级的 ulp 在 1e-6 到 1e-3 之间,再加 0.1234 就一点不丢。只要相对坐标压在 1e3 以内,1e-4 米的小数格点就始终保得住。

这就是"大数减大数"的威力:两个相近的大数相减,结果是精确的小数,而不是很多人直觉里的"减法也会丢精度"。丢精度的从来不是减法本身,是相减之前各自已经被量化过。

属性类型的那点事。 a_Position_X2 在 GLSL 里声明成 float,但顶点数据是 GL_UNSIGNED_SHORT。GLES 的规则是:着色器输入为浮点、顶点数据为整型且 normalized = GL_FALSE 时,整数被直接转换成浮点数。所以 1234 的位模式进去,1234.0 出来,正是我们要的。换成 normalized = GL_TRUE 会得到 0.0188,整条链路作废。

完整版本长这样,y 走的是完全对称的一条路径:

// 顶点着色器核心:X1 + X2/10000 还原出原始坐标
val vertexShader = """
    precision highp float;
    attribute float a_Position_X1;   // 整数部分
    attribute float a_Position_X2;   // 小数部分(已乘 10000)
    attribute float a_Position_Y1;
    attribute float a_Position_Y2;
    uniform vec4  u_Centre;          // 中心点偏移
    uniform mat4  u_mvpMatrix;
    void main() {
        float x = a_Position_X1 - u_Centre.x
                + (a_Position_X2 * 10000.0 - u_Centre.y) / 100000000.0;
        float y = a_Position_Y1 - u_Centre.z
                + (a_Position_Y2 * 10000.0 - u_Centre.w) / 100000000.0;
        gl_Position = u_mvpMatrix * vec4(x, y, 0.0, 1.0);
    }
"""

注意 u_Centre 是个 vec4 被当成四个独立的标量用:.x .y 是中心点的 X 整数和小数,.z .w 是 Y 的。用 vec4 而不是两个 vec2,纯粹是为了少一次 uniform 查询——每帧都要更新的东西,能省一次是一次。

把量级变化画出来更直观:

flowchart TB
    subgraph BAD[&#34;不平移 直接相加&#34;]
        A1[&#34;X1 = 12900000.0 ulp 1 米&#34;] --> A2[&#34;加 0.1234&#34;]
        A2 --> A3[&#34;结果仍是 12900000.0 小数被吞&#34;]
    end
    subgraph GOOD[&#34;先减中心点&#34;]
        B1[&#34;X1 = 12900000.0&#34;] --> B3[&#34;减去 Cx = 12899900.0 精确无舍入&#34;]
        B2[&#34;u_Centre.x = 12899900.0&#34;] --> B3
        B3 --> B4[&#34;差值 100.0 ulp 约 7.6e-6&#34;]
        B4 --> B5[&#34;再加 0.1234 得 100.1234&#34;]
    end

四、中心点:一个 uniform 换掉整个 VBO 的重传

u_Centre 不只是精度工具,它还是性能设计的一部分。先看它是怎么算出来的:

// 计算平移中心:视口范围的几何中心,并缩放
fun buildMvpAndCentre(viewBounds: Bounds, scale: Double): Pair<FloatArray, FloatArray> {
    val centre = viewBounds.centre()
    val cx = centre.x * scale
    val cy = centre.y * scale

    val mvp = FloatArray(16)
    Matrix.setIdentityM(mvp, 0)
    val width = viewBounds.width()
    val height = viewBounds.height()
    Matrix.scaleM(mvp, 0, (2.0 / width / scale).toFloat(), (2.0 / height / scale).toFloat(), 1f)

    // u_Centre 的四分量分别存:中心X整数、中心X小数、中心Y整数、中心Y小数
    return mvp to floatArrayOf(
        toStoredFloat(cx), fourDecimal(cx).toFloat(),
        toStoredFloat(cy), fourDecimal(cy).toFloat()
    )
}

返回值里 .x .z 是两个整数分量,.y .w 是两个小数分量——后者要按上一节的契约再乘 10000 抬进 1e8 域,才能和 a_Position_X2 * 10000.0 对上。

这里有一个必须区分的概念:代码里的 scale 是图层坐标单位到米的固定换算系数(常量),不是随手指缩放的视图倍率。两者的处理方式完全相反。

固定换算必须在拆分之前乘掉。因为 ushort 的 1e-4 格点是"米"的格点,如果顶点存的是图层原始单位,这个格点的物理含义就变了,精度预算整个错位。

视图缩放必须留在 MVP 里(2.0 / width / scale 那一项),绝不能乘进顶点数据——否则每捏一下手指,整批顶点都要重新拆分、重新上传。这是"顶点数据不动、只换 uniform"的前提。

于是"中心点每帧变,顶点要不要重传"这个问题有了明确答案:不用,一次都不用。顶点存的是绝对坐标(拆成两块),中心点只出现在 uniform 里。屏幕位置的完整表达式是:

p_screen = MVP · (p_abs - C)

C 变了只影响 uniform;MVP 里的缩放变了也只影响 uniform。顶点缓冲从上传那一刻起就是只读的,平移、缩放、旋转全在 GPU 侧完成。对百万级顶点的图层,这一条省下的是每帧一次 CPU 侧重算加一次全量总线上传——按前面那张存法对比表的字节数算,就是每帧 12 MB 的流量和一次完整的顶点重组。

那中心点突变(跳图)会怎样? 分两种情况。

连续动画(惯性滑动、飞行动画)是安全的。中心点每帧移动几十米,相对坐标始终被压在视口范围内,ulp 一直在微米级,视觉上完全连续。

直接跳转(点击定位、搜索跳转、书签切换)危险的地方不在精度,在同步。中心点在瞬间跳了几百万米,如果瓦片数据还没到、旧瓦片仍按新中心渲染,那些几何的相对坐标会瞬间变成几百万,直接飞出视锥被裁掉——用户看到的是闪一下白,然后瓦片一块块弹出来。反过来,如果中心点更新了但 MVP 没跟着更新,整块图形会平移一个"中心点差值"的距离,同样飞出屏幕。精度问题在这里反而不是主角,主角是中心点和 MVP 必须原子更新。

还有一类实现会在跳图时把顶点在 CPU 侧重算到新中心(rebase),换取更小的相对坐标。这个做法的代价是一次全量重传,百万顶点就是一次肉眼可见的掉帧,正好卡在用户最敏感的那一下上。既然着色器里的减法已经免费提供了同样的效果,就没有理由在 CPU 侧再做一遍。

五、顶点布局:12 字节还是 16 字节,取决于属性顺序

坐标从 2 个 float(8 B)变成 2×(float + ushort),逻辑上是 12 B,涨 50%。四个属性的声明是这样:

// 一个顶点的坐标部分:X整数(float) + X小数(ushort) + Y整数(float) + Y小数(ushort)
class PositionLayout {
    val attributes = listOf(
        LayoutAttribute("a_Position_X1", 1, GLES30.GL_FLOAT),
        LayoutAttribute("a_Position_X2", 1, GLES30.GL_UNSIGNED_SHORT),
        LayoutAttribute("a_Position_Y1", 1, GLES30.GL_FLOAT),
        LayoutAttribute("a_Position_Y2", 1, GLES30.GL_UNSIGNED_SHORT)
    )
}

这份声明只描述了"有几个属性、各是什么类型",没规定"在缓冲里怎么排"。而排列方式直接决定 12 B 能不能落地。

GLES 要求 glVertexAttribPointer 的 offset 必须是该属性类型大小的整数倍——float 需要 4 字节对齐,ushort 需要 2 字节。如果按声明的顺序交错排列(X1、X2、Y1、Y2),字节偏移是 0、4、6、8:Y1 落在偏移 6,不是 4 的倍数。部分驱动直接抛 GL_INVALID_OPERATION,另一些驱动默默接受但走慢路径。

把两个 float 放前面、两个 ushort 放后面,问题就没了:

// 分组排列:两个 float 先放,两个 ushort 收尾,stride 12 且全部对齐
val stride = 12
GLES30.glVertexAttribPointer(posX1, 1, GLES30.GL_FLOAT,         false, stride, 0)   // 0
GLES30.glVertexAttribPointer(posY1, 1, GLES30.GL_FLOAT,         false, stride, 4)   // 4
GLES30.glVertexAttribPointer(posX2, 1, GLES30.GL_UNSIGNED_SHORT, false, stride, 8)  // 8
GLES30.glVertexAttribPointer(posY2, 1, GLES30.GL_UNSIGNED_SHORT, false, stride, 10) // 10
排列方式字节偏移stride对齐合法性100 万顶点
纯 float(X、Y)0、48合法8 MB
交错(X1、X2、Y1、Y2)0、4、6、812 → 补到 16Y1 偏移 6 非法16 MB
分组(X1、Y1、X2、Y2)0、4、8、1012全部合法12 MB

一个属性顺序的差别,把 50% 的带宽涨幅变成了 100%。这不是微优化,是把方案从"可以接受"推回"需要论证"的分界线。

带宽账。 10 万顶点:8 B → 12 B,多 400 KB;如果每帧全量重传、跑 60 fps,就是 24 MB/s 的额外总线流量。100 万顶点:多 4 MB/帧,240 MB/s——这个数量级在移动端已经不可接受了,不只是带宽,还有驱动侧的拷贝和 cache flush。所以这套方案的适用边界很清楚:

  • 静态图层(一次上传、永不改动)——代价为零,随便用;
  • 动态图层但只传增量瓦片——单帧增量通常几十 KB,400 KB 的系数摊上去可以忽略;
  • 每帧全量重传且顶点过百万——不要用拆分,先想办法让顶点别每帧重传。

顺便,把两个 ushort 排在一起还有个隐性收益:属性取数单元访问连续的同类型数据,命中同一条 cache line 的概率更高。交错的混合类型布局在部分移动 GPU 上会让顶点取数退化成多次非对齐读取。

六、数值流全貌:从 double 到屏幕

把拆分和重组两侧的每一步连起来,包括位模式的变化:

flowchart TD
    A[&#34;double 12900000.1234&#34;] --> B[&#34;Math.floor 取整&#34;]
    B --> C[&#34;12900000.0 double&#34;]
    C -->|&#34;toFloat 并回退一个 ulp&#34;| D[&#34;X1 float 12900000.0&#34;]
    A -->|&#34;减去 X1&#34;| E[&#34;余数 0.1234&#34;]
    E -->|&#34;乘 10000 后 round&#34;| F[&#34;1234&#34;]
    F -->|&#34;toShort 保留 16 位&#34;| G[&#34;X2 ushort 0x04D2&#34;]
    D --> H[&#34;着色器 X1 减 Cx&#34;]
    G --> I[&#34;X2 乘 1e4 减 Cy 再除 1e8&#34;]
    H --> J[&#34;相加&#34;]
    I --> J
    J --> K[&#34;还原坐标 米&#34;]
    K -->|&#34;乘 u_mvpMatrix&#34;| L[&#34;裁剪空间&#34;]

用具体数字把它跑一遍,确认每一站都对得上:

val x = 12900000.1234

// ① 拆整数部分:向下取整
val x1 = toStoredFloat(x)   // floor(12900000.1234) = 12900000.0,转 float

// ② 拆小数部分:余数 × 10000 取整
val x2 = fourDecimal(x)     // (12900000.1234 - 12900000.0) × 10000 = 1234

// ③ 着色器重组:X1 + X2 / 10000
val restored = x1 + x2 / 10000.0
// = 12900000.0 + 1234 / 10000.0
// = 12900000.0 + 0.1234
// = 12900000.1234   ✓ 分毫不差

ushort 的最大值是 65535,对应小数部分 0.0000~6.5535 米。实际需要的最坏余数是"1 个 ulp 加 1 米内的零头"(回退之后),在 2e7 量级是 3 米上下,用掉不到 30000,还剩近一半余量。这个余量不是浪费——它是留给"整数部分落格失败"的缓冲。

再往外一层是整条渲染链路。四个阶段的更新频率完全不同,这是设计的关键:

flowchart LR
    A[&#34;业务经纬度 BLH&#34;] -->|&#34;投影 低频&#34;| B[&#34;Web 墨卡托 double&#34;]
    B -->|&#34;乘单位换算 常量&#34;| C[&#34;渲染坐标 double&#34;]
    C -->|&#34;floor 加 round&#34;| D[&#34;X1 Y1 float 与 X2 Y2 ushort&#34;]
    D -->|&#34;VBO 上传 一次性&#34;| E[&#34;顶点缓冲&#34;]
    E --> F[&#34;顶点着色器&#34;]
    F -->|&#34;减 u_Centre 每帧&#34;| G[&#34;相对坐标 float&#34;]
    G -->|&#34;乘 u_mvpMatrix 每帧&#34;| H[&#34;裁剪空间&#34;]
    H --> I[&#34;屏幕像素&#34;]

投影是低频的,一个图层的数据坐标系定了就不变,所以它只在数据加载时做一次,并且要批量做。视图缩放是高频的,全部交给 MVP,不碰顶点。拆分是"投影之后、进缓冲之前"的一次性动作。上传是"数据变化时"的动作。四者的频率差了几个数量级,混在一起就是性能灾难。

投影要批量,且一次到位。 每个顶点单独调一次投影变换是不可接受的——不是慢一点,是慢到不可用,因为每次调用都要过一遍 JNI 和坐标转换器的状态机:

fun transFeature(feature: Feature, srcCrs: Crs, threadId: Int): Feature {
    val copy = feature.shallowCopy()
    val geometry = copy.geometry() ?: return copy
    val needTransform = mapCrs != srcCrs || useWebMercator

    if (needTransform) {
        val coordinates = geometry.coordinates
        // 批量坐标转换:一次 native 调用 + 一次锁获取,而非逐点调用
        val failCount = transform.transformBatch(coordinates, coordinates.size)
        if (failCount > 0) {
            // 记录失败点数,便于定位异常数据
        }
    }
    return copy
}

transformBatch 的收益是双份的:一次 native 调用摊掉了 JNI 开销,一次锁获取摊掉了并发争用。整段数组交出去,失败计数回来,失败的通常是超出投影范围的脏数据。

转换器要按线程缓存。 native 转换器对象的构造和初始化都很贵(要装载投影参数、建内部状态),而渲染是多线程的。每个 worker 各自持有一份,键是源 CRS:

// 每个线程持有自己的转换器缓存,key 是源 CRS
private val transformCache = ConcurrentHashMap<Int, MutableMap<Crs, Transform>>()

fun getTransform(crs: Crs, threadId: Int): Transform {
    val threadMap = transformCache.getOrPut(threadId) { ConcurrentHashMap() }
    return threadMap.getOrPut(crs) {
        Transform().apply {
            srcCrs = crs
            dstCrs = webMercator
            applyCoordSystem()
        }
    }
}

两级 Map 的结构值得留意:外层按线程隔离,避免多线程争同一把锁;内层按 CRS 分桶,因为一个工程里往往同时叠加了经纬度图层、地方坐标图层和已经是墨卡托的图层。线程数一般远小于 CRS 数,所以外层开销可以忽略。

顺序固定下来就是:投影(低频)→ 单位换算(常量)→ 拆分存储 → 上传 → 着色器平移还原(每帧)→ MVP 变换(每帧)。 每一环的频率决定了它该待在哪一层,任何一环挪位置都会引出上面某一节里描述过的错误。

七、如果重写:自适应降级与瓦片原点

这套方案有一个明显的浪费:它假设所有图层都需要 9 位有效数字。而一个在几百米范围内铺开的局部数据(一个工地、一个园区、一栋楼的室内图),坐标量级在 1e3 以下,float 的 ulp 是 0.0001 米——单 float 就绰绰有余,拆成两个属性纯属白送 50% 带宽。

所以第一个改动是把拆分做成按图层可配置:

// 按图层数据范围决定布局:对角线小于 128 km 时,单 float 相对中心已足够
val useSplit = layer.extent.diagonal() > 128_000.0

128 km 这个阈值不是拍脑袋的。2^17 = 131,072,相对坐标量级压在 2^17 以下时 ulp 是 0.0078 米,在 z22(0.0323 米/像素)下是 0.24 个像素,肉眼不可见。判断依据必须是图层自身的数据范围,不是当前缩放级别——后者每帧都变,会逼着你不断切换布局、不断重传。

但两套布局的维护成本是实打实的,而且分布在很意想不到的地方:

  • 着色器要出变体(#define SPLIT_POS),两条路径都要测;
  • 顶点构建器要分支,两条路径的 stride、offset、padding 都不同;
  • 屏幕坐标反算世界坐标(点选、编辑、绘制)必须用同一套布局,否则拾取位置偏移几米;
  • 顶点插值、几何裁剪、动画变形,凡是碰坐标的地方都要过一遍分支;
  • 测试矩阵翻倍,而且"某个图层在某次数据更新后范围超过了阈值"这种边界几乎必然被漏测。

第二个改动更彻底,也更值得做:放弃全局坐标,改用瓦片局部原点。

// 每块瓦片一个 double 原点,顶点只存相对原点的 float 偏移
fun encode(vertex: DoublePoint, tileOrigin: DoublePoint): FloatArray =
    floatArrayOf(
        (vertex.x - tileOrigin.x).toFloat(),
        (vertex.y - tileOrigin.y).toFloat()
    )

一块瓦片在 Web 墨卡托 z18 下大约 150 米见方,相对坐标量级 1e2,float 的 ulp 是 1.5e-5 米。一套单 float 布局就覆盖了所有缩放级别,不需要 ushort、不需要拆分、不需要域对齐,前面六节里描述的所有边界问题一次性消失。原点作为两个 float(整数部分 + 小数部分)进 uniform,或者干脆作为 double 留在 CPU 侧参与 MVP 的构造。

代价是每个 draw call 多一次 uniform 更新(可忽略),以及顶点无法跨瓦片复用、瓦片边界处的几何要被切开(这个是真的成本,接缝处理和几何合并的逻辑都要改)。如果从零开始,这笔交易明显划算;如果是给一个已经跑了两年的引擎换布局,改造面积会吓退所有人。

这也解释了为什么现实中这类"拆 float 存 ushort"的方案能活下来:它不是最优解,它是在不改动数据组织方式的前提下能拿到的最优解。全局坐标体系一旦定下来,顶点缓冲、拾取、编辑、空间索引全都建立在"绝对坐标"这个假设上,改动成本远大于在着色器里多写一行除法。

八、小结

  • float 的 24 位有效位只能保证 7.2 位十进制,1e7 量级下 ulp 就是 1 米,z22 下等于 31 个像素——这是精度预算的起点,不是"会不会抖"的猜测。
  • 拆分的三个边界缺一不可:整数部分必须 floor(负数截断会翻符号)、float 向上舍入必须回退一个 ulp(且负数侧方向相反)、round 会让小数分量取到 10000 而不是 9999。
  • 着色器里的 1e8 是 1e4 × 1e4,一个来自 ushort 存储、一个来自 uniform 提升,两侧必须成对维护,差一个就是 6.55 米的静默误差。
  • 先减中心点再相加不是风格问题:两个 1e7 量级的 float 相减是精确的,先加小数则会被 ulp 直接吞掉。
  • 顶点布局的属性顺序决定 12 B 还是 16 B,一个排列差异就是 100% 的带宽差距;超过百万顶点且每帧重传时,这套方案的带宽账算不过来。

如果你手上正跑着一套顶点缓冲,不妨回答一个问题:把中心点瞬间挪到 100 公里外,画面是整体飞出去、还是原地不动?答案能直接告诉你,平移是在着色器里做的,还是在 CPU 上重算的。