XChart P22:箭头的杆与头改走曲线渲染器的原生标记(规范 §29,他纠正"箭头为何用的是填充")

他这句纠正指向一件我一直不知道存在的东西:

> 我不是给你提供了曲线,曲线渲染器里面带标记就可以直接显示箭头,你还可以调节箭头在曲线上的位置。

P18 那次我读不到库那个包(被拦过一次)就照自己代码里的调用点猜 API——`AddCurve`/`CurveCacheEntry` 猜对了,
于是**没有回头把那个包读一遍**,它旁边的 `ArrowHeadData` 我一直不知道,就用填充四边形自己拼了杆和头。
包其实就在工作区隔壁(com.lrss3.deconstruction),API 一直写在
Release/Runtime/Generation/Curve/CurveRenderDataTypes.cs。教训写进 §29.1:
**照着调用点猜出来能跑之后,要把那个来源补读一遍**——"我猜对了"证明不了"我看见全了"。

画法(一套几何,没有第二条路):
- 杆=一条**共线**三次贝塞尔(新纯算术 XChartArrowPathMath.Straight:内控制点落在 1/3、2/3),
  宽度=ShaftWidth,startColor/endColor 就是沿杆渐变——P18 我要的那个效果原来是条目的原生能力。
- 头=原生标记 ArrowHeadData:width=头长(沿切线)、height=头宽(垂直切线)、
  depthCompensation=+1 ⇒ **头尖对准那个数据点**。尺寸与位置先走我们自己的纯算术 XChartArrowMarker
  (离线探针引不到库那个 assembly,判据打在纯算术上,工具里只做对号入座)。
- 连续绘制的头挂在 ResolvePosition 算出的那一节上、progress=节内参数;**路径不再剪断**——
  "必须剪否则线穿箭头"是我上一版自己加的机制,Split 因此没有调用方,随四角绕序一起删。
- 零向量=一个 Circle 标记(开关关掉则整条不画,计入 skipped=)。
- **曲线渲染器不在位 ⇒ path=none、一支都不画**。不再有"退回填充画法"那第二条路:两套画法就是两套口径,
  而这次的 bug 恰恰长在第二条路上。

撤掉:XChartArrowGeometry(BuildShaft/BuildHead/TryBuild)整个类删、XChartArrowPathMath.Split 删。
留着:XChartMeshFillRenderer.AddFaceLinear 与 XChartFaceFillKind.Linear——那是填充渲染器自己的上色模式
(预算 VerticesPerFace(Linear)==4 与判据都在),只是箭头不再用它;别的元素要渐变填充时不必再写第二套。
配置里 HeadPosition 的 tooltip 一起改(原文写着"路径在这一处剪断",§29 之后不剪,留着就是面板说谎)。

**为什么这一改仍然不算把 bug 修好**(§29.3 写清):P13 遗留的"填充面改了没作用"与今天"杆与头都不画"
是同一坏点的两种症状,都走 XChartMeshFillRenderer。硬证据是他工程里那份报表(我打开开关后跑出来的):
`arrows=31 arrowFaces=62 fillChunks=1 fillMaxVerts=248`(=62×4 顶点一个不多)且
`dom=x[-100..100] y[-49.936..49.936] z[-49.743..50]` ⇒ 坐标已折进盒子、面提交了、子块建了、网格真填了顶点,
画面上却没有 ⇒ 坏点在填充渲染器到 Canvas 的那一跳。箭头不再经过那一跳,所以箭头上屏了,
而那一跳本身没修(P23 专门查;绕过去不等于修好)。同一行还抓到一条会撒谎的读数:
curves=0 却 curveVerts=66,而圆柱那一行也印 66 ⇒ UICurveRenderer.LiveVertexCount 不是本实例的数,
不能当"我这条曲线画了多少顶点"读(一并立进 P23)。

判据:探针 **452** 项 0 失败(删 13 条判"四边形角点/剪开再接回"的——**被测对象已不存在,留着就是假绿**;
新增 7 条:标记两尺寸对号入座、头尖对点 vs 圆点居中、progress 夹进 [0,1]、NaN 位置落到末端、0 尺寸兜底、
Straight 每个采样都落在那条直线上、切线方向与矢量平行);p4_control **65** 支 CONTROL PASSED
(删 2 支靶子随代码没了、新增 3 支:两尺寸互换 / progress 不夹 / 头尖不对点,各红 1/2/1 条点名断言);
dirty_gate 正本 knobs=132 takesEffect=132 findings=0、八支变异全红(claim F 判"坐标必须经 TryCubePoint",
改写后仍判得住);编译门 runtime+player+editor+3 对照 GATE PASSED(chain_p22.txt,
tooltip 那次改动之后重跑一次 chain_p22b.txt 同样绿)。

本轮我自己两次把臂写坏,两次都是 harness 拒绝而不是假判,记进规范:
① 单行锚 `AcrossTangent = Mathf.Max(0.1f, width),` 被我新写的孪生函数 Head/Dot 撞成 2 命中 ⇒ SETUP FAILED,
整轮作废 ⇒ 锚要加宽到"只有那一处才有的形状"(这次用两行块);
② 替换值给对象初始化器里那一行写了分号(`Progress = progress;`)⇒ 变异体 CS1513,又是 SETUP FAILED
⇒ 替换值要保持它所在语法位置的标点。
另外 run_gate 学到一件事(同轮改动):rsp 是项目取的快照,删掉一个源文件后那份快照还列着它 ⇒ CS2001,
整道门红得像"产品编译不过"。现在它跳过"工作区里已不存在的包内源文件"并**逐个点名印出来**
(判决要说出它判的是哪棵树)——这不是吞错:CS2001 说的是快照过期,Unity 重导入会自己重生成 rsp。

顺带把 P18 那个还欠着的 .meta(XChartArrowPathMath.cs.meta,Unity 早生成好了、我一直没提交)一起入仓。
覆盖不到的照旧:观感归他现场判(§29.5 四条:成对模式 31 支直线+三角头、连续绘制拖 HeadPosition 头沿线滑动、
颜色维沿程渐变、什么都没有时读 path=/arrows=/markers=/curveVerts=)。
This commit is contained in:
2026-10-26 13:15:55 +08:00
parent cb759fe583
commit 5f4c1adf0a
9 changed files with 273 additions and 297 deletions
+1
View File
@@ -97,6 +97,7 @@ P17 口径修正(同日,听他澄清;规范 §24.5 与 §25 已按正确
P18 矢量场收尾:两端各自的颜色 + 连续绘制走曲线渲染器 + 箭头位置可调(规范 §26,2026-10-26):① 填充四边形多一档**线性渐变**(`AddFaceLinear`:`00/10` 一对边一色、`01/11` 一对边一色),箭头**杆走渐变(起点色→终点色)、头走终点色**——两端颜色来自相邻两条记录各自的颜色维,所以"这条与下条颜色不同"直接看得出来;每面花几个顶点收成**单一定义** `XChartMeshBudget.VerticesPerFace(kind)`(预算侧与写顶点侧同源,否则"预算以为 4 个、实际发 5 个"会在卡线时撞 65535,§10.3 那一族);**杆的四角绕序有判据**(a/d 在起点一侧、b/c 在末端一侧;配错画面上是"杆两侧各一色"而不是"沿杆渐变",最容易看漏)。② 连续绘制改走**曲线渲染器**(库里 `UICurveRenderer`,圆柱弧段同一件):途经点 → **Catmull-Rom 转三次贝塞尔**(张力 1/6,新纯算术 `XChartArrowPathMath`),曲线**真的经过每个数据点**——矢量场的点是数据本身,用不经过控制点的自由贝塞尔等于把数据挪了位置;`entry` 自带起止色 ⇒ 沿程渐变是它本来的能力;不再逐段提交折线(§10.4 的转角断口)。③ **箭头位置可调**(`HeadPosition` 0..1):`ResolvePosition` 给段号+段内参数 ⇒ 该段 `Split` 剪断、只画左半,箭头放在剪口上、方向取该点**切线**(不是两端连线,弯处会歪);**必须剪**,否则路径从箭头底下穿出去、看着像"箭头朝里长"。④ 互斥显示又用一次:`HeadPosition`/`PathSegments` 只在连续绘制下出现,`相对/绝对` 反过来只在非连续下出现。⑤ 读数与退路:报表带 `path=curve|fill|-`、`at=`、`curves=`、`curveVerts=`——曲线渲染器不在位时退回直线段(形状仍读得出来),但**退没退在 `path=` 上一个字说清**,不是悄悄换个画法还报一样的数。判据:编译门三臂 + 3 对照绿;探针 **450** 项 0 失败(新增 `arrow path:` 9 条——全是**性质**判据:过数据点、端点切线=弦的一半、剪开再接回逐点一致、共线仍是直的、位置 0/0.5/1 落在哪一段,不写手算的中间点坐标)+ `arrow shaft:` 配对 1 条 + 顶点数 1 条;`p4_control` **61** 支臂各红在点名断言上(新增 4 支:起点侧角取成末端、所有面按平坦算顶点、控制柄拉成 /3 张力、剪开不共用剪口点);`p2` / `family` / `generator_gate` / `hierarchy_gate` 同树复跑。**没做**:曲线渲染器的"矢量标签"(它自带的那个)还没接——现在箭头方向来自切线,标签要下一轮;观感照例归他现场判。
P20 外部数据驱动访问(规范 §27,2026-10-26 他问"我能不能直接拿到圆柱渲染器,改属性就自动置脏"):**入口本来就有**(`ToolManager.FindTool<T>()`),缺的是第二半——9 个工具的参数全是裸自动属性,**写进去值在、画面不动**,必须再补一句 `MarkDirty()`(`XMeshPreviewChart.ApplyVolume` 手工补的那个样子)。落法:① `XChartToolBase` 新增 **`public abstract void MarkDirty()`**——不给基类空实现,因为空实现通过基类引用调用时**静默什么都不做**(参数改了、画面不动、报表看不出错,"零要说出它零在哪一层"那一族),抽象让编译器逼 9 个工具各自说清"我的脏位是哪个字段";7 个已有 `public void MarkDirty()` 的必须逐个补 `override`(少了就是 **CS0108 隐藏**:编译只出警告、基类调用失效),`ChartToolSpace` 没有独立脏位⇒转发 `MarkProjectionDirty()`(投影就是它唯一要重算的东西),`ChartToolScatterPoints` 只有 `MarkDataDirty()`⇒override 接 `m_PointsDirty`、旧名转发(同一字段两个名字)。② **132 个旋钮全部改成"设了就生效"**:`public float Radius { get => m_Radius; set { m_Radius = value; MarkDirty(); } }`(122 支走 `MarkDirty`,**10 支走 `SyncShapeParams`——这 10 支是门查出来的,不是我原本知道的**:散点外观早就自带生效路径,于是判据从"必须调 MarkDirty"改成"必须调到本文件里定义的 `MarkDirty` 或 `Sync*/Push*/Apply*/Rebuild*`")。③ `XChartBase` 加两个入口:`Tool<T>(toolName)`(`FindTool<T>` 的空安全简写,管理器还没建时答 null 而不是抛 NRE——"图里现在有没有这一类"是现场状态,调用方要问得出"没有")与 `Element<T>()`(走 `XChartElementTable.FirstOfKind`,与默认元素去重同一个答法)。④ **权威只有一处这件事写明**:外部写进工具的值会活到下一次 `ReapplyElements()`/`RebuildElements()`(面板动任一字段、增删/停用元素、脚本重载、进 Play、`ResetRender()`),那一次把配置整份重灌 ⇒ 外部的写被静默覆盖;要活得过重建就得写配置,而配置的公开写入口本轮**没开**(字段仍 private,面板走 `SerializedProperty`),列为下一步。判据:新门 `.ximage-gate/dirty_gate.py`——清单**两侧都数**(`TOOLS` 9 个 vs 磁盘 `ChartTool*.cs` 9 个,多一个少一个都红)、终态 `knobs=132 takesEffect=132 findings=0` 才算绿;另立两条同门判据:**D** 工具不许在 setter 之外给自己的旋钮赋值(那会在自己渲染的过程中把自己重新置脏 ⇒ 每帧重建),**E** 靠 `Sync` 生效的必须 `OnInitialize` 里也有那一句(否则 `if (IsInitialized) Sync()` 把初始化之前的写全丢);**七支变异各红在自己点名的那条**(M1 抹掉一个 setter 的 `MarkDirty()`、M2 拿掉 `override`、M3 新增一个裸自动属性、M4 工具自赋值、M5 把一个工具从路径上挪走、M6 `Sync` 调用改成不存在的名字、M7 从 `OnInitialize` 删掉那句 `Sync`)。**本轮自己的三处错都被门/编译门抓住(不是现场)**:批量改写脚本把字段行的**等号漏了**(`private float m_Radius 0.22f;`,121 处全中);判据把标识符里的字母当关键字(`Offset` 含 "set" ⇒ 只读的 `Offset` 被读成"从不置脏的 setter",改词边界 `\bset\b`);`{ get; private set; }` 没先归类成 views 时 D 支报出 **26 处**"自赋值"全是渲染器属性的初始化写盘(**分类之后真违规 0 处——写了判据才知道有没有**)。`ChartToolSpace.Rotation` 的初始化式跨两行,脚本按"同一行没闭合就拒绝整份文件"跳过整个文件、那 4 个旋钮手改(**拒绝写比写一半好**)。编译门 runtime+player+editor+3 对照 `GATE PASSED`(`chain_p20a.txt`/`chain_p20b.txt` rc=0);mono 数学探针本轮不重跑——改的全是 MonoBehaviour 侧工具的 setter,纯算文件一个没动。**覆盖不到**:画面观感归他现场判。
P21 矢量场没渲染的根因与修法(规范 §28,2026-10-26 他报"矢量场现在没有在渲染"):**读数先从他自己的资产里取**——`SP_盾构机掘进姿态 Variant.prefab` 那份表是 x/y/z 三维、记录值量级 **−100..50**、三条以上记录,箭头元素 `m_Enabled=1 / VectorMode=Absolute / Continuous=0 / UseColorDimensions=0`,所以形状够(需要 3、现有 3,面板那句"一条都不画"不会亮),问题不在 §25.1 那一层而在**尺度**。根因:`ChartToolVectorArrows.ReadPoint` 把 `GetValueAt` 的**原始值直接当立方体单位**(±1=盒子边界)用 ⇒ 每支箭头被投到**一万多像素之外**:支数在算、面在提交、计数全对,画面上什么都没有;而散点与圆柱一直是"按各维显示范围折进盒子"(`TryResolveDomain` + `XChartBindingMath.TryNormalize`)——**只有箭头这一条路径没折**,同一件事两套口径,坏的那套不抛不报错、只是看不见(§22 格线双作者、§24.5 序号双口径的同族)。排除"P20 改坏"用的是 diff 形状:那次提交 33 增 17 删全在属性形状上、编译门绿、他 `Editor.log` 里这次导入只有一条无关的 `CS0414`。落法:① 纯算术新增 `XChartVectorFieldMath.TryCubePoint(x,y,z, minX..maxZ, out cube)`(每维按自己的范围映到 [-1,1];**任何一维折不出来——跨度 ≤0、值或端点非有限——就整体拒答**,因为半归一化的坐标比不归一化的更难查,它会画出"看着像个箭头、方向却不对"的东西;折法进纯算术才离线钉得住);② 工具**每帧现问**三条轴的范围(范围不归元素存,与散点同规矩),读点改 `TryReadPoint`,读不出的点计入 `skipped=` 而不是静默少画;③ 报表加 `dom=x[..] y[..] z[..]` 与 `skipped=`,**折不出来印 `dom=-` 且一支都不画**——"为什么没有"当场说话(他那份表应印 `dom=x[-100..50] …`、`arrows=记录数−1`)。判据:探针 **458** 项 0 失败(新增 8 条 `vector field cube:`:域两端落 ±1、域中落 0、他那种量级的记录折进盒子内、**域外保持成比例而不是被夹住**(夹住=把数据改了)、零跨度拒答、非有限拒答、坏一轴整体拒答——全是性质判据,不写手算中间值)+ `p4_control` 新增 **3** 支臂(不折 / 坏一轴也照答 / 偷偷 `Clamp`)各红在点名断言上 + `dirty_gate` 新增 **claim F**(箭头这条路径的坐标必须经 `TryCubePoint`,原始值直接进 `new Vector3(` 就红;只挂这个文件,因为它判的是"形状对、画面空"这一类)并配变异 **M8_rawcoord**——**八支全红**、正本 `knobs=132 takesEffect=132 findings=0`;编译门三臂 + 3 对照绿(`chain_p21.txt rc=0`)。**两条判据自身的错记档**:① M8 第一版是**绿的**——不是判据弱,是 claim F 用来认文件的参数被 claim C 的 `for name in names` 重新绑定了(`judge(lines, name)` 里 `name` 既是文件名又当旋钮名,循环跑完它就等于最后一个旋钮名 ⇒ F 支永远不执行),**"臂能不能红"第一次是靠它自己抓到的** ⇒ 规矩:给"按文件生效的判据"传参,参数名不许与函数体内循环变量同名(这次改成 `source`);② 门脚本声明 `coding: ascii`,中文写进注释就直接 `SyntaxError`(中文只进仓内文档,不进脚本)。**留给现场/下一轮、没偷改的两条**:他这串姿态点的正确读法是 `Relative`(首尾相接=轨迹方向,`Absolute` 是给"点一行、方向一行"分开存的表用的);`XMeshPreviewChart` 的示例数据仍是**旧的"一条记录 6 维"口径**(方向存第 4~6 维),新口径下那三列是**死数据**,画出来的是"每条记录位置 → 0.25×下一条记录位置"——重造那份 demo 之前要先确认它还想不想同时喂散点元素(一对记录里的第二条也会成为一个点)。
P22 箭头改走"线 + 库的原生标记"(规范 §29,2026-10-26 他纠正:"箭头为何用的是填充?我不是给你提供了曲线,曲线渲染器里面带标记就可以直接显示箭头,你还可以调节箭头在曲线上的位置"):**根因是一次"猜对了来源"没被复盘**——P18 我读不到库那个包(被拦过一次)就照自己代码里的调用点猜 API,`AddCurve`/`CurveCacheEntry` 猜对了,于是没再回头把那个包读一遍,它旁边的 `ArrowHeadData` 我一直不知道存在,就自己用填充四边形拼了杆和头;包其实就在工作区隔壁(`com.lrss3.deconstruction`),API 一直写在 `Release/Runtime/Generation/Curve/CurveRenderDataTypes.cs`。⇒ 规矩:**照着调用点猜出来能跑之后,要把那个来源补读一遍**,"我猜对了"证明不了"我看见全了"。落法:① 杆=一条**共线**三次贝塞尔(新纯算术 `XChartArrowPathMath.Straight`:内控制点落在 1/3、2/3),宽度=`ShaftWidth`、起止色就是沿杆渐变(P18 那个效果原来是条目的原生能力);② 头=曲线渲染器原生标记 `ArrowHeadData`(`width`=头长沿切线、`height`=头宽垂直切线、`depthCompensation=+1`=**头尖对准那个数据点**);③ 连续绘制的头挂在 `ResolvePosition` 算出的那一节上、`progress`=节内参数,**路径不再剪断**——"必须剪否则线穿箭头"是我上一版自己加的,库的标记本来就叠在线上,于是 `Split` 没有调用方、随四角绕序那套(`XChartArrowGeometry` 整个类)一起删;④ 零向量画 `Circle` 标记(开关关掉就整条不画,计入 `skipped=`);⑤ **曲线渲染器不在位 ⇒ `path=none` 一支都不画**,不再有"退回填充画法"那第二条路(两套画法=两套口径,这次的 bug 恰恰长在第二条路上)。`AddFaceLinear`/`XChartFaceFillKind.Linear` **留着**:那是填充渲染器自己的上色模式(预算 `VerticesPerFace(Linear)==4` 与判据都在),别的元素要渐变填充时不必再写第二套。**另一面要说清**:P13 遗留的"填充面改了没作用"与今天"杆与头都不画"是**同一坏点的两种症状**(都走 `XChartMeshFillRenderer`)——他工程里那份报表给出了硬证据:`arrows=31 arrowFaces=62 fillChunks=1 fillMaxVerts=248`(=62×4 顶点一个不多)且 `dom=x[-100..100] y[-49.936..49.936] z[-49.743..50]` ⇒ 坐标已折进盒子、面提交了、子块建了、网格真填了顶点,画面上却没有 ⇒ 坏点在**填充渲染器到 Canvas 的那一跳**,不是数据形状也不是顶点预算。箭头不再经过那一跳,所以箭头上屏了而**网格背景/圆柱填充若也看不见就是同一坏点未除**,那一跳本轮没修(绕过去不等于修好)。**顺手抓到一条会撒谎的读数**:同一行 `curves=0` 却 `curveVerts=66`,而圆柱那一行也印 66 ⇒ `UICurveRenderer.LiveVertexCount` 不是本实例自己的数,只能当"库里一共活着多少顶点"读,看自己那份要读 `curves=`/`markers=`(已立待办)。判据:探针 **452** 项 0 失败(删 13 条判"四边形角点/剪开再接回"的——**被测对象已不存在,留着就是假绿**;新增 7 条:标记两尺寸对号入座、头尖对点 vs 圆点居中、`progress` 夹进 [0,1]、NaN 位置落到末端而不是"位置未知"、0 尺寸兜底、`Straight` 每个采样都落在那条直线上、切线方向与矢量平行)+ `p4_control` **65** 支(删 2 支靶子随代码没了、新增 3 支:两尺寸互换 / `progress` 不夹 / 头尖不对点,各红在点名断言上)+ `dirty_gate` 正本 `knobs=132 takesEffect=132 findings=0`、八支变异全红(claim F 判"坐标必须经 `TryCubePoint`",改写后仍判得住)+ 编译门三臂 + 3 对照绿(`chain_p22.txt`)。**门自己的一次改动**:`run_gate` 原先把 rsp 里列出的每个源文件都喂给 csc,删掉一个源文件后那份快照还列着它 ⇒ `CS2001 找不到源文件`,整道门红得像"产品编译不过";现在它跳过"工作区里已不存在的包内源文件"并**逐个点名印出来**(判决要说清它判的是哪棵树)——这不是吞错:CS2001 说的是"快照过期",Unity 重导入会自己重生成 rsp。
## [0.1.6] - 2026-07-01
+73
View File
@@ -1723,6 +1723,9 @@ UI Toolkit 里 `flexShrink` 默认为 1,窗口矮了,被压扁的就是**最
### 26.1 两端各自的颜色=填充四边形多一档线性渐变
> **本节那一档"箭头用法"已被 §29 撤掉**(2026-10-26 他纠正:杆走线、头用曲线渲染器的原生标记)。
> `AddFaceLinear` 这个能力留着——它是填充渲染器自己的一种上色模式,只是箭头不再经过它。
`XChartMeshFillRenderer` 原来只有两档:四角同色(平坦)与"四角 + 中心"(径向)。这轮加第三档
**线性渐变**(`AddFaceLinear`):`00/10` 一对边一色、`01/11` 一对边一色,渐变方向垂直于这两条边。
@@ -1925,3 +1928,73 @@ UI Toolkit 里 `flexShrink` 默认为 1,窗口矮了,被压扁的就是**最
- `XMeshPreviewChart` 的示例数据仍是**旧的"一条记录 6 维"口径**(方向存第 4~6 维):
新口径下那三列是**死数据**,画出来的是"每条记录位置 → 0.25×下一条记录位置"。
按"相邻两条"重造这份 demo 之前,要先确认它还想不想同时喂散点元素(一对记录里第二条也会成为一个点)。
## 29. P22:箭头的杆与头改走曲线渲染器的原生标记(2026-10-26 他的纠正)
### 29.1 他的原话,以及我为什么会绕远
> 箭头为何用的是填充?我不是给你提供了曲线,曲线渲染器里面带标记就可以直接显示箭头,你还可以调节箭头在曲线上的位置。
P18 那次我读不到库那个包(被拦过一次),就照着自己代码里的调用点猜 API——猜出来的
`AddCurve` / `CurveCacheEntry` 是对的,但**我没有回头把那个包整个读一遍**,于是它旁边的
`ArrowHeadData` 我一直不知道存在,就用填充四边形自己拼了杆和头。包其实就在工作区隔壁
(`com.lrss3.deconstruction`),API 一直写在 `Release/Runtime/Generation/Curve/CurveRenderDataTypes.cs`。
教训不是"下次记得读",是:**照着调用点猜出来能跑之后,要把那个来源补读一遍**——
"我猜对了"证明不了"我看见全了"。
### 29.2 现在的画法(杆=线,头=标记,没有第二套几何)
- **杆**=一条**共线**的三次贝塞尔(`XChartArrowPathMath.Straight`:内控制点落在 1/3、2/3),
宽度=`ShaftWidth`,`startColor`/`endColor` 就是沿杆渐变——P18 我要的那个效果,其实是条目的原生能力。
- **头**=曲线渲染器的原生标记 `ArrowHeadData`:`shape=Triangle`、`width`=头长(沿切线)、
`height`=头宽(垂直切线)、`depthCompensation=+1`=**头尖对准那个数据点**(矢量场的箭头指的就是那一点)。
- **连续绘制**=Catmull-Rom 链逐节提交,头挂在 `ResolvePosition` 算出的那一节上,
`progress`=节内参数。**路径不再剪断**——"必须剪,否则线从箭头底下穿出去"是我上一版自己加的机制,
库的标记本来就设计成叠在线上,不需要它。于是 `XChartArrowPathMath.Split` 没有调用方了,随杆的四角一起删。
- **零向量**=一个 `Circle` 标记(就是个点);开关关掉则整条不画,`skipped=` 里看得见少了几条。
- **曲线渲染器不在位 ⇒ `path=none`,一支都不画**。没有"退回填充画法"那第二条路——两套画法就是两套口径,
而这次的 bug 恰恰长在"第二条路"上。
### 29.3 撤掉了什么,以及还剩什么没修
- 删 `XChartArrowGeometry`(`BuildShaft`/`BuildHead`/`TryBuild`:四角绕序那套)与 `XChartArrowPathMath.Split`;
`XChartMeshFillRenderer.AddFaceLinear` / `XChartFaceFillKind.Linear` **留着**——那是这个填充渲染器自己的一种
上色模式(预算 `VerticesPerFace(Linear)==4` 与判据都在),只是箭头不再用它;别的元素要渐变填充时不必再写第二套。
- **这件事的另一面要说清**:P13 遗留的"填充面改了没作用"和今天"杆与头都不画"是**同一个坏点的两种症状**
(都走 `XChartMeshFillRenderer`)。证据是他工程里那份报表(我打开开关后他自己跑出来的那一行):
```
Arrows … dims=3/3 records=32 dom=x[-100..100] y[-49.936..49.936] z[-49.743..50]
arrows=31 skipped=0 path=- curves=0 arrowFaces=62 fillChunks=1 fillMaxVerts=248
```
`dom=` 有值 ⇒ §28 那一步折进去了、坐标就在盒子里;`arrows=31`、`arrowFaces=62`、`fillChunks=1`、
`fillMaxVerts=248`(=62×4 个顶点,一个不多)⇒ **面提交了、子块建了、网格也真填了顶点**,画面上却没有。
所以不是数据形状、不是开关、不是顶点预算,是**填充渲染器到 Canvas 的那一跳**。(那一跳本轮没修:
箭头不再经过它,所以箭头上屏了,而网格背景/圆柱填充那两类如果也看不见,就是同一个坏点还没除掉。)
- **顺手抓到的一条会撒谎的读数**:同一行里 `curves=0` 但 `curveVerts=66`——`UICurveRenderer.LiveVertexCount`
**不是这个实例自己的数**(同一时刻圆柱那一行也印 66)。所以 `curveVerts=` 只能当"库里现在一共活着多少顶点"读,
不能当"我这条曲线提交了几个顶点"读;要看自己那份,读 `curves=`(条目数)与 `markers=`。已记进 P23 待办。
### 29.4 判据
- 探针 **452** 项 0 失败:删掉 13 条判"四边形角点 / 剪开再接回"的(**被测对象已经不存在**,留着就是假绿),
新增 7 条——标记两个尺寸的对号入座、头尖对点 vs 圆点居中、`progress` 夹进 [0,1]、
NaN 位置落到末端而不是"位置未知"、0 尺寸兜底、`Straight` 每个采样都落在那条直线上、切线方向与矢量平行。
- `p4_control` **65** 支:删掉 2 支(靶子随代码一起没了),新增 3 支(两个尺寸互换 / `progress` 不夹 /
头尖不对点),各红在自己点名的断言上。
- `dirty_gate`:正本 `knobs=132 takesEffect=132 findings=0`,八支变异全红;claim F(坐标必须经 `TryCubePoint`)
在改写后仍然判得住。
- 编译门 runtime + player + editor + 3 支对照 `GATE PASSED`(`chain_p22.txt`)。
- **门自己的一次改动**(同轮):`run_gate` 把 rsp 里列出的每个源文件都喂给 csc;删掉一个源文件之后
那份快照还列着它 ⇒ `CS2001 找不到源文件`,整道门红得像"产品编译不过"。现在它**跳过工作区里已不存在的
包内源文件,并逐个点名印出来**(判决要能说出它判的是哪棵树)。这不是把错误吞掉:CS2001 说的是
"快照过期",不是"代码编译不过",Unity 重导入后会重新生成那份 rsp。
### 29.5 覆盖不到什么 / 他侧验收(Ctrl+R 后)
1. 关掉连续绘制:每支箭头=一段直线 + 末端三角头(32 条记录 ⇒ 31 支),姿态转过去也不会塌成一条线。
2. 打开连续绘制:一条平滑路径 + 一个头;拖 `HeadPosition` ⇒ 头**沿路径滑动**,路径不剪断。
3. 打开颜色维:杆沿程渐变(起点色 → 终点色),头是终点色。
4. 若画面仍然什么都没有 ⇒ 读报表那一行的 `path= / arrows= / markers= / curveVerts=`。
现在箭头这条路上没有"填充"那一层了,读数能给的解释比上一版窄——这正是这次改动的目的。
+120 -189
View File
@@ -1,4 +1,3 @@
using System;
using System.Collections.Generic;
using UnityEngine;
using XericLibrary.Runtime.UIGraph;
@@ -8,24 +7,23 @@ using XericUI.XChart.Space;
namespace XericUI.XChart.Mesh
{
/// <summary>
/// 向量场 / 流形箭头元素。**数据口径(规范 §25.2,2026-10-25 他澄清后定稿)**:
/// <b>前三维=坐标 x/y/z</b>(与圆柱、散点同一套归一化),<b>一支箭头=相邻两条记录</b>
/// 向量场 / 流形箭头元素。<b>数据口径(规范 §25.2,2026-10-25 他澄清后定稿)</b>:
/// <b>前三维=坐标 x/y/z</b>(与圆柱、散点同一套归一化,折法见
/// <see cref="XChartVectorFieldMath.TryCubePoint"/> 与 §28),<b>一支箭头=相邻两条记录</b>
/// (第 i 条是起点,第 i+1 条按 <see cref="VectorMode"/> 解释成"第二个点"或"方向矢量"),
/// <b>第 4~7 维是颜色</b>(色相 0..256 色环 / 饱和度 / 明度 / 不透明度,可选)。
///
/// <para><b>两种读法</b>:绝对 ⇒ 第二条记录的坐标就是方向(起点 + 方向×倍率),螺旋点画出来是一片"刺猬";
/// 相对 ⇒ 它是第二个点(起点 + 差向量×倍率),一串首尾相接的点读起来就是"连着头转"。</para>
///
/// <para><b>连续绘制</b>:把每条记录的坐标按顺序连成折线(只有最后一段带箭头);
/// 这时"相对/绝对"不适用 ⇒ 配置里那一项隐藏(互斥显示)。</para>
/// <para><b>画法=线 + 库自带的箭头标记</b>(他 2026-10-26 的纠正,规范 §29):杆是一条
/// <b>共线</b>的三次贝塞尔条目(细分出来就是直的,宽度=<see cref="ShaftWidth"/>,
/// 起止色就是沿杆渐变),头是曲线渲染器原生的 <see cref="ArrowHeadData"/> 标记,
/// 它在曲线上的位置由 <see cref="HeadPosition"/> 给(就是标记的 <c>progress</c>)。
/// 上一版把杆和头都拼成填充四边形,等于绕开了库已经提供的能力,还多养了一条坏掉的路径。</para>
///
/// <para><b>两端各自的颜色</b>:起点读第 i 条记录、终点读第 i+1 条 ⇒ 两支记录颜色不同时,
/// 杆与头**各显一色**。真正的"沿杆逐顶点渐变"要等渲染器支持逐顶点双色(P18)。</para>
///
/// <para><b>箭头是自己拼的,没有用库里的 ArrowShape</b>:那套箭头是给曲线的屏幕空间图元用的,
/// 而这里的箭头必须跟着立方体姿态走(投影后长短和方向都在变)。做法是只让空间负责两端的投影,
/// 杆和头都在<b>像素空间</b>里量出来:杆是一段等宽四边形,头是一个退化四边形(三角形),
/// 宽度恒定所以任何姿态下都不会塌成一条线。</para>
/// <para><b>连续绘制</b>:把每条记录的坐标按顺序连成 Catmull-Rom 贝塞尔路径(线<b>真的经过每个数据点</b>),
/// 标记挂在那一节上;这时"相对/绝对"不适用 ⇒ 配置里那一项隐藏(互斥显示)。</para>
///
/// <para><b>数据只经过中转接口</b>:按维度下标 <see cref="IXChartDataSource.GetValueAt"/> 逐条取,
/// 不碰记录数组;支数由 <see cref="MaxArrowCount"/> 兜住,免得十万条记录一口气投影。</para>
@@ -40,7 +38,7 @@ namespace XericUI.XChart.Mesh
/// <summary>第二条记录怎么读成方向</summary>
public XChartArrowVectorMode VectorMode { get => m_VectorMode; set { m_VectorMode = value; MarkDirty(); } }
private bool m_Continuous;
/// <summary>把每条记录的坐标按顺序连成折线(此时相对/绝对不适用)</summary>
/// <summary>把每条记录的坐标按顺序连成路径(此时相对/绝对不适用)</summary>
public bool Continuous { get => m_Continuous; set { m_Continuous = value; MarkDirty(); } }
private float m_DirectionScale = 0.25f;
/// <summary>方向向量的长度倍率(立方体单位);相对模式下作用在差向量上</summary>
@@ -68,51 +66,53 @@ namespace XericUI.XChart.Mesh
private Color m_ArrowColor = new Color(0.95f, 0.6f, 0.25f, 0.9f);
public Color ArrowColor { get => m_ArrowColor; set { m_ArrowColor = value; MarkDirty(); } }
private float m_ShaftWidth = 2f;
/// <summary>杆宽(像素)=曲线条目的宽度</summary>
public float ShaftWidth { get => m_ShaftWidth; set { m_ShaftWidth = value; MarkDirty(); } }
private float m_HeadLength = 10f;
/// <summary>头长(像素,<b>沿切线</b>)=标记的 <c>width</c></summary>
public float HeadLength { get => m_HeadLength; set { m_HeadLength = value; MarkDirty(); } }
private float m_HeadWidth = 7f;
/// <summary>头宽(像素,<b>垂直切线</b>)=标记的 <c>height</c></summary>
public float HeadWidth { get => m_HeadWidth; set { m_HeadWidth = value; MarkDirty(); } }
private bool m_ShowZeroVectorsAsDots;
/// <summary>方向为零向量时什么都不画;给个数就画成一个点</summary>
/// <summary>零向量画成一个<b>圆点标记</b>;关掉就什么都不画(那种记录在画面上等于不存在)</summary>
public bool ShowZeroVectorsAsDots { get => m_ShowZeroVectorsAsDots; set { m_ShowZeroVectorsAsDots = value; MarkDirty(); } }
public XChartMeshFillRenderer FillRenderer { get; private set; }
/// <summary>
/// 连续绘制用的曲线渲染器(库里的贝塞尔细分渲染器,圆柱弧段同一件)。
/// <b>折线渲染器只留给直线</b>——他 2026-10-23 的原话,而路径正是"会弯的那种线"(§10.4)。
/// 唯一的绘制出口:库里的贝塞尔细分渲染器(圆柱弧段同一件)。
/// <b>杆与头都从它走</b>——直线是"共线控制点"的特例(§10.4:折线逐段画会在转角留断口,
/// 而这里连直线都不需要它),头是它自带的标记。
/// 它不在位时这个元素什么都画不出来,报表 <c>path=none</c> 当场说清,不退回任何"备用画法"。
/// </summary>
public UICurveRenderer CurveRenderer { get; private set; }
private float m_HeadPosition = 1f;
/// <summary>
/// 连续绘制时<b>画到路径的哪个位置</b>(0=起点、1=整条,默认 1):
/// 箭头就放在这一处,路径在这一点被剪断(剪口之后不画)——
/// 不剪的话路径会从箭头底下穿出去,看着像"箭头朝里长"。
/// 连续绘制时<b>箭头在路径上的哪个位置</b>(0=起点、1=末端,默认 1):
/// 直接交给标记的 <c>progress</c>,路径不剪断——线从标记底下穿过去是矢量场画法的常态,
/// "剪开"是上一版我自己加的额外机制,库的标记本来就不需要它(§29)。
/// </summary>
public float HeadPosition { get => m_HeadPosition; set { m_HeadPosition = value; MarkDirty(); } }
private int m_PathSegments = 12;
/// <summary>连续绘制时每段贝塞尔细分成几节(曲线渲染器的 tessellation)</summary>
/// <summary>连续绘制时每段路径细分成几节(曲线渲染器的 tessellation)</summary>
public int PathSegments { get => m_PathSegments; set { m_PathSegments = value; MarkDirty(); } }
private readonly List<Vector2> m_Pixels = new List<Vector2>(64);
private string m_PathRenderer = "-";
private readonly Vector2[] m_Bezier = new Vector2[XChartArrowPathMath.ControlPointsPerSegment];
private readonly Vector2[] m_Left = new Vector2[XChartArrowPathMath.ControlPointsPerSegment];
private readonly Vector2[] m_Right = new Vector2[XChartArrowPathMath.ControlPointsPerSegment];
private readonly float[] m_Widths = new float[XChartArrowPathMath.ControlPointsPerSegment];
// 一支箭头一个标记,所以一条曲线最多挂一个:数组长度 1 是刻意的(AddCurve 吃的是数组)
private readonly ArrowHeadData[] m_Heads = new ArrowHeadData[1];
private string m_PathRenderer = "-";
private int m_CurveEntries;
private int m_Markers;
private Matrix4x4 m_Composed = Matrix4x4.identity;
private int m_LastSpaceVersion = -1;
private long m_LastDataVersion = -1;
private bool m_Dirty = true;
private readonly List<ArrowFace> m_Faces = new List<ArrowFace>(256);
// 本帧的自述读数:算了几支 / 表里几个数值维 / 需要几个 / 几条记录
// 本帧的自述读数:算了几支 / 表里几个数值维 / 需要几个 / 几条记录 / 跳过几条
private int m_ArrowsBuilt;
private int m_DimensionsHave;
private int m_DimensionsNeed;
@@ -124,25 +124,6 @@ namespace XericUI.XChart.Mesh
private double m_MinX, m_MaxX, m_MinY, m_MaxY, m_MinZ, m_MaxZ;
private bool m_HasDomains;
private struct ArrowFace
{
public Vector2 A;
public Vector2 B;
public Vector2 C;
public Vector2 D;
public float Depth;
/// <summary>00/10 这一对边的颜色(线性时=起点色)</summary>
public Color Color;
/// <summary>01/11 这一对边的颜色(只有线性用;=终点色)</summary>
public Color ColorTo;
/// <summary>true=沿杆渐变(杆),false=单色(头、退化点)。
/// 必须 public:嵌套类型的 private 成员**外层类也读不到**(C# 的这条反直觉,本项目踩过)</summary>
public bool Linear;
}
private static readonly Comparison<ArrowFace> s_FarToNear =
(left, right) => left.Depth.CompareTo(right.Depth);
public override void MarkDirty() => m_Dirty = true;
/// <summary>
@@ -159,20 +140,10 @@ namespace XericUI.XChart.Mesh
protected override void OnInitialize()
{
FillRenderer = CreateChildComponent<XChartMeshFillRenderer>("ArrowFill");
if (FillRenderer != null)
{
var rect = FillRenderer.rectTransform;
rect.anchorMin = Vector2.zero;
rect.anchorMax = Vector2.one;
rect.offsetMin = Vector2.zero;
rect.offsetMax = Vector2.zero;
}
// 连续绘制走曲线渲染器(贝塞尔细分);控制点每帧由本工具喂,别让它自己重建默认那条
CurveRenderer = CreateChildComponent<UICurveRenderer>("ArrowPath");
CurveRenderer = CreateChildComponent<UICurveRenderer>("ArrowCurve");
if (CurveRenderer != null)
{
// 控制点、宽度、标记每帧由本工具喂:别让它自己重建默认那条
CurveRenderer.autoRebuild = false;
var rect = CurveRenderer.rectTransform;
rect.anchorMin = Vector2.zero;
@@ -186,8 +157,6 @@ namespace XericUI.XChart.Mesh
public override void OnRender()
{
base.OnRender();
if (FillRenderer == null) return;
// 曲线渲染器不在位也要出图(退回直线段),所以它不是"能不能画"的前提
var space = Context?.Space;
if (space == null) return;
@@ -196,38 +165,42 @@ namespace XericUI.XChart.Mesh
if (!m_Dirty && space.ProjectionVersion == m_LastSpaceVersion && dataVersion == m_LastDataVersion)
return;
// 渲染器不在位先把"这一帧确实重新算过、但画不出来"记下来:不然读数会停在上一帧
if (CurveRenderer == null)
{
m_Dirty = false;
m_LastSpaceVersion = space.ProjectionVersion;
m_LastDataVersion = dataVersion;
m_PathRenderer = "none";
m_ArrowsBuilt = 0;
m_CurveEntries = 0;
m_Markers = 0;
return;
}
m_Dirty = false;
m_LastSpaceVersion = space.ProjectionVersion;
m_LastDataVersion = dataVersion;
m_Composed = space.Compose(Transform);
if (CurveRenderer != null) CurveRenderer.ClearAll();
BuildFaces(space);
FillRenderer.ClearFaces();
for (int i = 0; i < m_Faces.Count; i++)
{
ArrowFace face = m_Faces[i];
if (face.Linear)
FillRenderer.AddFaceLinear(face.A, face.B, face.C, face.D, face.Color, face.ColorTo);
else
FillRenderer.AddFace(face.A, face.B, face.C, face.D, face.Color, face.Color);
}
FillRenderer.Apply();
if (CurveRenderer != null) CurveRenderer.RebuildAll();
// ClearAll 连标记缓存一起清(库的 CurveCacheRendererBase.ClearAll 里就有 m_Arrows.Clear()),
// 所以每帧重喂不会越攒越多
CurveRenderer.ClearAll();
m_PathRenderer = "curve";
BuildArrows(space);
CurveRenderer.RebuildAll();
}
private void BuildFaces(ChartToolSpace space)
private void BuildArrows(ChartToolSpace space)
{
m_Faces.Clear();
m_ArrowsBuilt = 0;
m_CurveEntries = 0;
m_Markers = 0;
m_DimensionsHave = 0;
m_RecordsHave = 0;
m_PointsSkipped = 0;
m_DimensionsNeed = RequiredDimensionCount;
m_CurveEntries = 0;
m_HasDomains = false;
m_PathRenderer = Continuous ? (CurveRenderer != null ? "curve" : "fill") : "-";
var source = Data;
if (source == null || !source.HasData) return;
@@ -250,7 +223,6 @@ namespace XericUI.XChart.Mesh
if (Continuous)
{
BuildContinuous(source, space, limit);
m_Faces.Sort(s_FarToNear);
return;
}
@@ -264,18 +236,17 @@ namespace XericUI.XChart.Mesh
}
// 两种读法的算式在纯算术里(离线钉着):绝对=第二条的坐标就是方向;相对=它是第二个点
Vector3 tip = XChartVectorFieldMath.Tip(VectorMode, first, second, DirectionScale);
if (AddArrow(space, first, tip, ColorAt(source, i), ColorAt(source, i + 1))) m_ArrowsBuilt++;
AddShaft(space.Project(first, m_Composed), space.Project(tip, m_Composed),
ColorAt(source, i), ColorAt(source, i + 1));
m_ArrowsBuilt++;
}
m_Faces.Sort(s_FarToNear);
}
/// <summary>
/// 连续绘制:一串途经点 → Catmull-Rom 贝塞尔链,交给曲线渲染器(贝塞尔细分,接缝不断口);
/// 路径在 <see cref="HeadPosition"/> 处<b>剪断</b>,箭头放在剪口上、顺着那一点的<b>切线</b>。
/// 不剪的话路径会从箭头底下穿出去,看着像"箭头朝里长"。
/// 段与段之间是同一串坐标,所以"相对/绝对"在这里没有意义(配置里那一项也隐藏了);
/// 曲线渲染器不在位时退回直线段(形状仍读得出来),报表里 <c>path=fill</c> 会说出来。
/// 连续绘制:途经点 → Catmull-Rom 贝塞尔链(曲线<b>真的经过每个数据点</b>——矢量场的点是数据本身,
/// 用不经过控制点的自由贝塞尔等于把数据挪了位置),逐节提交成一条路径;
/// 头挂在 <see cref="HeadPosition"/> 所在的那一节上("位置 → 第几节 + 节内参数"由纯算术给)。
/// 段与段之间是同一串坐标,所以"相对/绝对"在这里没有意义(配置里那一项也隐藏了)。
/// </summary>
private void BuildContinuous(IXChartDataSource source, ChartToolSpace space, int limit)
{
@@ -283,8 +254,8 @@ namespace XericUI.XChart.Mesh
for (int i = 0; i <= limit; i++)
{
Vector3 cube;
// 跳过的点要报出来:曲线的位置按"活下来的点"排,颜色仍按记录号取——数据里
// 有非有限值时这两者会错开,不印出来的话就只能靠猜(skipped= 那一读数的全部意义)
// 跳过的点要报出来:路径按"活下来的点"连,颜色仍按记录号取——数据里有非有限值时
// 这两者会错开,不印出来的话就只能靠猜(skipped= 那一读数的全部意义)
if (!TryReadPoint(source, i, out cube)) { m_PointsSkipped++; continue; }
m_Pixels.Add(space.Project(cube, m_Composed));
}
@@ -294,28 +265,19 @@ namespace XericUI.XChart.Mesh
XChartArrowPathMath.ResolvePosition(segments, HeadPosition, out int headSegment, out float headT);
Vector2 cut = Vector2.zero;
Vector2 cutTangent = Vector2.zero;
for (int s = 0; s <= headSegment; s++)
for (int s = 0; s < segments; s++)
{
BuildSegmentBezier(s);
Vector2[] drawn = m_Bezier;
if (s == headSegment && headT < 1f)
bool withHead = s == headSegment;
if (withHead)
{
XChartArrowPathMath.Split(m_Bezier, headT, m_Left, m_Right);
drawn = m_Left;
m_Heads[0] = ToHeadData(XChartVectorFieldMath.Head(HeadLength, HeadWidth, headT,
ColorAt(source, Mathf.Min(s + 1, m_RecordsHave - 1))));
m_Markers++;
m_ArrowsBuilt = 1; // 连续绘制是"一条路径 + 一支箭头"
}
AddPathSegment(drawn, ColorAt(source, s), ColorAt(source, s + 1));
cut = XChartArrowPathMath.Evaluate(drawn, 1f);
cutTangent = XChartArrowPathMath.Tangent(drawn, 1f);
if (s == headSegment) break;
AddEntry(m_Bezier, ColorAt(source, s), ColorAt(source, s + 1), withHead);
}
AddHeadAt(cut, cutTangent, ColorAt(source, Mathf.Min(headSegment + 1, m_RecordsHave - 1)));
m_ArrowsBuilt = headSegment + 1;
}
/// <summary>段 s(点 s → 点 s+1)的贝塞尔控制点。端点之外重复端点:端点处切线指向段内。</summary>
@@ -327,90 +289,63 @@ namespace XericUI.XChart.Mesh
m_Pixels[s + 2 <= last ? s + 2 : last], m_Bezier);
}
private void AddPathSegment(Vector2[] bezier, Color fromColor, Color toColor)
/// <summary>
/// 一支箭头:一条<b>共线</b>贝塞尔(细分出来就是直线)+末端一个头标记。
/// 零向量不投一条零长曲线(库在零长输入上的细分没有承诺),改画一个圆点标记;
/// 开关关掉就整条不画——<c>arrows=/skipped=</c> 说得出为什么少了一支。
/// </summary>
private void AddShaft(Vector2 from, Vector2 to, Color startColor, Color endColor)
{
if (CurveRenderer != null)
if ((to - from).sqrMagnitude < 1e-4f)
{
for (int i = 0; i < m_Widths.Length; i++) m_Widths[i] = ShaftWidth;
CurveRenderer.AddCurve(new CurveCacheEntry
{
startColor = fromColor,
endColor = toColor,
tessellationSegments = Mathf.Clamp(PathSegments, 2, 64),
}, bezier, m_Widths);
m_CurveEntries++;
if (!ShowZeroVectorsAsDots) return;
// 一像素的极短直线只为让条目存在,真正画出来的东西是这个圆点
XChartArrowPathMath.Straight(from, from + new Vector2(1f, 0f), m_Bezier);
m_Heads[0] = ToHeadData(XChartVectorFieldMath.Dot(
Mathf.Max(ShaftWidth, 1f), Mathf.Max(HeadWidth, 1f), endColor));
AddEntry(m_Bezier, endColor, endColor, true);
m_Markers++;
return;
}
Vector2 a = bezier[0];
Vector2 b = bezier[3];
Vector2 side = new Vector2(-(b.y - a.y), b.x - a.x);
if (side.sqrMagnitude < 1e-6f) return;
side.Normalize();
float half = ShaftWidth * 0.5f;
m_Faces.Add(new ArrowFace
{
A = a + side * half, B = b + side * half, C = b - side * half, D = a - side * half,
Depth = 0f, Color = fromColor, ColorTo = toColor, Linear = true,
});
XChartArrowPathMath.Straight(from, to, m_Bezier);
m_Heads[0] = ToHeadData(XChartVectorFieldMath.Head(HeadLength, HeadWidth, 1f, endColor));
AddEntry(m_Bezier, startColor, endColor, true);
m_Markers++;
}
/// <summary>箭头放在剪口上,方向顺那一点的<b>切线</b>(不是两端连线——弯处会歪)。</summary>
private void AddHeadAt(Vector2 tip, Vector2 tangent, Color color)
private void AddEntry(Vector2[] controlPoints, Color startColor, Color endColor, bool withHead)
{
if (tangent.sqrMagnitude < 1e-6f) return;
Vector2 unit = tangent.normalized;
Vector2 side = new Vector2(-unit.y, unit.x);
Vector2 baseCenter = tip - unit * HeadLength;
Vector2 a, b, c, d;
XChartArrowGeometry.BuildHead(baseCenter, tip, side, HeadWidth, out a, out b, out c, out d);
m_Faces.Add(new ArrowFace { A = a, B = b, C = c, D = d, Depth = 0f, Color = color });
for (int i = 0; i < m_Widths.Length; i++) m_Widths[i] = Mathf.Max(0.1f, ShaftWidth);
var entry = new CurveCacheEntry
{
startColor = startColor,
endColor = endColor,
// 共线的贝塞尔吃多少节都是直的,所以杆只给最小的 4;路径那边走 PathSegments
tessellationSegments = Continuous ? Mathf.Clamp(PathSegments, 2, 64) : 4,
};
CurveRenderer.AddCurve(entry, controlPoints, m_Widths, withHead ? m_Heads : null);
m_CurveEntries++;
}
/// <summary>
/// 一支箭头 = 杆(用起点色)+(可选)头(用终点色)。
/// <b>两端各显一色</b>是颜色维"随记录自带"的直接结果;真正的沿杆渐变要等渲染器支持逐顶点双色(P18)。
/// 纯算术的标记描述 → 库的 <see cref="ArrowHeadData"/>。<b>这一层只做对号入座</b>:
/// 库的 <c>width</c> 是"沿切线"、<c>height</c> 是"垂直切线",而我们那两个名字叫"头长/头宽";
/// <c>depthCompensation = 1</c> 让<b>头尖对准那个数据点</b>(矢量场的箭头指的就是那一点),
/// 圆点用 0(中心对点)。形状、颜色、位置的算法与夹取都在纯算术里(离线钉着),这里不判据。
/// </summary>
private bool AddArrow(ChartToolSpace space, Vector3 origin, Vector3 tip, Color startColor, Color endColor,
bool withHead = true)
private static ArrowHeadData ToHeadData(XChartArrowMarker marker)
{
Vector2 from = space.Project(origin, m_Composed);
Vector2 to = space.Project(tip, m_Composed);
float depth = (space.DepthOf(origin, m_Composed) + space.DepthOf(tip, m_Composed)) * 0.5f;
Vector2 shaftA, shaftB, shaftC, shaftD, headA, headB, headC, headD;
if (!XChartArrowGeometry.TryBuild(from, to, ShaftWidth, HeadLength, HeadWidth,
out shaftA, out shaftB, out shaftC, out shaftD, out headA, out headB, out headC, out headD))
return new ArrowHeadData
{
if (!ShowZeroVectorsAsDots) return false;
// 退化箭头:画一个极小的四边形,宽度至少一个像素,否则整条向量看不见
m_Faces.Add(new ArrowFace
{
A = from + new Vector2(-1f, -1f),
B = from + new Vector2(-1f, 1f),
C = from + new Vector2(1f, 1f),
D = from + new Vector2(1f, -1f),
Depth = depth,
Color = startColor,
});
return true;
}
// 杆:沿杆渐变(起点一侧 ← 终点一侧)。BuildShaft 的绕序把 a/d 放在起点、b/c 放在末端,
// 而 AddFaceLinear 取的是"00/10 一色、01/11 一色"——这条配对由探针钉着,配错会横着染到杆宽上
m_Faces.Add(new ArrowFace
{
A = shaftA, B = shaftB, C = shaftC, D = shaftD,
Depth = depth, Color = startColor, ColorTo = endColor, Linear = true,
});
if (!withHead) return true;
m_Faces.Add(new ArrowFace
{
A = headA, B = headB, C = headC, D = headD,
Depth = depth, Color = endColor,
});
return true;
shape = marker.Shape == XChartMarkerShape.Circle ? ArrowShape.Circle : ArrowShape.Triangle,
reversed = false,
progress = marker.Progress,
width = marker.AlongTangent,
height = marker.AcrossTangent,
depthCompensation = marker.TipAtPoint,
color = marker.Color,
};
}
/// <summary>
@@ -469,25 +404,23 @@ namespace XericUI.XChart.Mesh
protected override void OnDispose()
{
FillRenderer = null;
CurveRenderer = null;
m_Faces.Clear();
m_Pixels.Clear();
}
#if UNITY_EDITOR
/// <summary>
/// 报表里点名这一帧:<b>维数(现有/需要)与记录数</b>+算了几支+读法+颜色来源+面数/块数。
/// "加了工具什么都没显示"这件事只有这一行分得清是"维数不够"还是"记录不够"还是"算了但没提交"
/// (他 2026-10-25 现场;规范 §25.1)。
/// 报表里点名这一帧:<b>维数(现有/需要)、记录数、折进盒子用的范围</b>+算了几支、几个标记、
/// 提交了几条曲线、曲线顶点数。"加了工具什么都没显示"这件事只有这一行分得清是
/// "维数不够"、"记录不够"、"折不进盒子(dom=-)"还是"曲线渲染器不在位(path=none)"
/// (他 2026-10-25 现场;规范 §25.1、§28、§29)。
/// </summary>
internal override void AppendDebugLine(System.Text.StringBuilder sb)
{
base.AppendDebugLine(sb);
sb.Append(" dims=").Append(m_DimensionsHave).Append('/').Append(m_DimensionsNeed)
.Append(" records=").Append(m_RecordsHave)
// 坐标按这三个范围折进盒子;dom=- 就是"折不出来 ⇒ 一支都不画",
// 而 arrows>0 而 dom=- 不可能同时出现(那道门在算支数之前)
// dom=- 就是"折不出来 ⇒ 一支都不画";它和 arrows>0 不可能同时出现(那道门在算支数之前)
.Append(" dom=").Append(m_HasDomains
? "x[" + m_MinX.ToString("0.###") + ".." + m_MaxX.ToString("0.###") + "] y["
+ m_MinY.ToString("0.###") + ".." + m_MaxY.ToString("0.###") + "] z["
@@ -500,11 +433,9 @@ namespace XericUI.XChart.Mesh
.Append(" path=").Append(m_PathRenderer)
.Append(" at=").Append(HeadPosition.ToString("0.###"))
.Append(" curves=").Append(m_CurveEntries)
.Append(" curveVerts=").Append(CurveRenderer != null ? CurveRenderer.LiveVertexCount : 0)
.Append(" arrowFaces=").Append(FillRenderer != null ? FillRenderer.FaceCount : 0)
.Append(" fillChunks=").Append(FillRenderer != null ? FillRenderer.ChunkCount : 0)
.Append(" fillMaxVerts=").Append(FillRenderer != null ? FillRenderer.MaxChunkVertices : 0);
.Append(" markers=").Append(m_Markers)
.Append(" curveVerts=").Append(CurveRenderer != null ? CurveRenderer.LiveVertexCount : 0);
}
#endif
}
}
}
@@ -1,70 +0,0 @@
using System;
using UnityEngine;
namespace XericUI.XChart.Mesh
{
/// <summary>
/// 箭头的像素空间几何:<b>杆 + 头</b>两组四边形。
///
/// <para>放在像素空间算是有意的:箭头的<b>宽度</b>要恒定(不管视角怎么转、向量投得多短,
/// 头都得是个看得见的头),而长度和方向已经由 <see cref="Space.ChartToolSpace"/> 投影给出来了。
/// 所以这里只做"沿单位方向量长度、按垂直方向量宽度"这一件事,纯数学、离线可验。</para>
///
/// <para><see cref="HeadLength"/> 会被钳到向量屏幕长度的 60%,因此短箭头的杆不会被头穿过去;
/// 屏幕长度接近 0 时返回 false,由调用方决定是画个点还是什么都不画。</para>
/// </summary>
public static class XChartArrowGeometry
{
/// <summary>杆最长能占屏幕长度的比例上限之外,头也不得超过这个比例</summary>
public const float HeadLengthRatioCap = 0.6f;
/// <summary>屏幕长度小于这个值就当"没有方向",交给调用方的退化分支。</summary>
public const float MinScreenLength = 1e-3f;
/// <summary>杆的四角(沿箭头方向绕一圈)</summary>
public static void BuildShaft(Vector2 from, Vector2 unit, Vector2 side, float shaftEndDistance,
float width, out Vector2 a, out Vector2 b, out Vector2 c, out Vector2 d)
{
float half = width * 0.5f;
Vector2 end = from + unit * shaftEndDistance;
a = from + side * half;
b = end + side * half;
c = end - side * half;
d = from - side * half;
}
/// <summary>头的四角:两个底角 + 尖点(尖点重复一次,四边形即三角形)</summary>
public static void BuildHead(Vector2 baseCenter, Vector2 tip, Vector2 side, float headWidth,
out Vector2 a, out Vector2 b, out Vector2 c, out Vector2 d)
{
float half = headWidth * 0.5f;
a = baseCenter + side * half;
b = tip;
c = tip;
d = baseCenter - side * half;
}
/// <summary>
/// 一条箭头的完整拆分。<paramref name="to"/> 是屏幕上的尖点。
/// 返回 false 表示屏幕长度退化。
/// </summary>
public static bool TryBuild(Vector2 from, Vector2 to, float shaftWidth, float headLength,
float headWidth, out Vector2 shaftA, out Vector2 shaftB, out Vector2 shaftC, out Vector2 shaftD,
out Vector2 headA, out Vector2 headB, out Vector2 headC, out Vector2 headD)
{
shaftA = shaftB = shaftC = shaftD = headA = headB = headC = headD = Vector2.zero;
Vector2 axis = to - from;
float length = axis.magnitude;
if (length < MinScreenLength) return false;
Vector2 unit = axis / length;
Vector2 side = new Vector2(-unit.y, unit.x);
float head = Mathf.Min(Mathf.Max(0f, headLength), length * HeadLengthRatioCap);
BuildShaft(from, unit, side, length - head, shaftWidth, out shaftA, out shaftB, out shaftC, out shaftD);
BuildHead(from + unit * (length - head), to, side, headWidth, out headA, out headB, out headC, out headD);
return true;
}
}
}
+10 -33
View File
@@ -3,8 +3,8 @@ using UnityEngine;
namespace XericUI.XChart.Mesh
{
/// <summary>
/// 矢量场"连续绘制"那条路径的<b>纯算术</b>:一串点 → 一条平滑折线(三次贝塞尔链),
/// 以及在链上取点/取切线、在某个参数处把链剪成两段。
/// 矢量场"连续绘制"那条路径的<b>纯算术</b>:一串点 → 一条平滑折线(三次贝塞尔链)、
/// 在链上取点/取切线、把"路径上的位置"换成"第几节的哪个参数",以及把两点写成一条直线贝塞尔。
///
/// <para><b>为什么要单独一个文件</b>:这几条是"画出来对不对"唯一能离线判的部分——
/// 曲线渲染器那一层(库里的 <c>UICurveRenderer</c>)吃的是<b>控制点</b>,
@@ -66,39 +66,16 @@ namespace XericUI.XChart.Mesh
}
/// <summary>
/// 在参数 t 处把一段三次贝塞尔<b>剪成两段</b>(de Casteljau 分裂):
/// <paramref name="left"/> 是 [0,t] 那半、<paramref name="right"/> 是 [t,1] 那半,
/// 两者各 4 个控制点。<b>两段接回去必须与原段逐点一致</b>——这条由探针判据钉住
/// (剪错了画面上是"箭头前面那段路挪了位",很不容易看出来)。
/// 两点之间的<b>共线</b>三次贝塞尔控制点(内控制点落在 1/3、2/3)——细分多少节都是那条直线。
/// 一支箭头的杆走这一条:杆和路径用同一个渲染器、同一套宽度与起止色,
/// 就不需要"填充四边形"那第二套画法(他 2026-10-26 的纠正,§29)。
/// </summary>
public static void Split(Vector2[] bezier, float t, Vector2[] left, Vector2[] right)
public static void Straight(Vector2 from, Vector2 to, Vector2[] bezier)
{
if (bezier == null || bezier.Length < ControlPointsPerSegment) return;
if (left != null && left.Length < ControlPointsPerSegment) return;
if (right != null && right.Length < ControlPointsPerSegment) return;
t = Mathf.Clamp01(t);
Vector2 a = Vector2.Lerp(bezier[0], bezier[1], t);
Vector2 b = Vector2.Lerp(bezier[1], bezier[2], t);
Vector2 c = Vector2.Lerp(bezier[2], bezier[3], t);
Vector2 d = Vector2.Lerp(a, b, t);
Vector2 e = Vector2.Lerp(b, c, t);
Vector2 f = Vector2.Lerp(d, e, t); // = 曲线在 t 处的点
if (left != null)
{
left[0] = bezier[0];
left[1] = a;
left[2] = d;
left[3] = f;
}
if (right != null)
{
right[0] = f;
right[1] = e;
right[2] = c;
right[3] = bezier[3];
}
bezier[0] = from;
bezier[1] = Vector2.Lerp(from, to, 1f / 3f);
bezier[2] = Vector2.Lerp(from, to, 2f / 3f);
bezier[3] = to;
}
/// <summary>
@@ -1,5 +1,5 @@
fileFormatVersion: 2
guid: 8e7522065536fdf438d0e378d47ca462
guid: 0538faa59b33bfb45a06f6ff0f1f9552
MonoImporter:
externalObjects: {}
serializedVersion: 2
@@ -186,9 +186,9 @@ namespace XericUI.XChart.Mesh
/// <paramref name="fromColor"/>,<c>corner01</c> 与 <c>corner11</c> 取 <paramref name="toColor"/>
/// ——也就是"一对边一色",渐变方向垂直于那两条边。
///
/// <para>箭头杆用的就是这一档:<see cref="XChartArrowGeometry.BuildShaft"/> 绕出来的四角里
/// <b>a/d 在起点一侧、b/c 在末端一侧</b>(这条配对由探针钉着,配错就会横着染到杆的宽度上,
/// 画面上看是"杆的两侧各一色"而不是"沿杆渐变")。顶点数与平坦一样(4 个、2 三角)。</para>
/// <para>这一档是"一对边一色",渐变方向垂直于那两条边,顶点数与平坦一样(4 个、2 三角)。
/// <b>矢量场的箭头已经不用它了</b>(§29:杆改走曲线渲染器的共线贝塞尔,头用库的标记),
/// 这里留着是因为它是这个渲染器本身的一种上色模式,别的元素要用渐变填充时不必再写第二套。</para>
/// </summary>
public void AddFaceLinear(Vector2 corner00, Vector2 corner01, Vector2 corner11, Vector2 corner10,
Color fromColor, Color toColor)
@@ -3,6 +3,37 @@ using XericUI.XChart;
namespace XericUI.XChart.Mesh
{
/// <summary>
/// 曲线渲染器的箭头标记长什么样(离线侧的形状,接线时一对一映射到库的 <c>ArrowShape</c>)。
/// 只列我们真用的两档:三角形=有方向的箭头,圆形=零向量那种"就是一个点"。
/// </summary>
public enum XChartMarkerShape
{
Triangle,
Circle,
}
/// <summary>
/// 一支箭头的<b>头</b>:位置(在曲线上的参数 0..1)、尺寸(沿切线/垂直切线)、颜色。
///
/// <para>这是<b>我们自己的</b>纯算术写法,不是库的结构体——离线探针引不到库那个 assembly,
/// 所以判据打在这个结构上,工具里只做"对号入座"的映射(§29)。尺寸在 <see cref="XChartVectorFieldMath.Head"/>
/// 里夹住而不是原样传:"头长 0"进库里就是画不出来的东西,而那里的调用方是面板上的数字框。</para>
/// </summary>
public struct XChartArrowMarker
{
public XChartMarkerShape Shape;
/// <summary>在曲线上的位置(0=起点、1=末端),已夹进 [0,1]</summary>
public float Progress;
/// <summary>沿切线方向的尺寸(库里叫 width)</summary>
public float AlongTangent;
/// <summary>垂直切线方向的尺寸(库里叫 height)</summary>
public float AcrossTangent;
/// <summary>+1=头尖对准那个点;0=中心对准(圆点用这个)</summary>
public float TipAtPoint;
public Color32 Color;
}
/// <summary>
/// 矢量场(箭头)的<b>纯算术</b>:一条记录的两组三维怎么变成一支箭头,以及一组颜色维怎么变成颜色。
/// 单独拎出来是因为这两条是"看图看不出来"的判据——
@@ -38,6 +69,38 @@ namespace XericUI.XChart.Mesh
return true;
}
/// <summary>
/// 三角形头。<paramref name="progress"/> 夹进 [0,1];<b>不是有限数就落在末端</b>(1)——
/// NaN 一路传进库里会得到一个位置未知、也报不出错的东西,那正是"画面和读数对不上"的来路。
/// 两个尺寸都兜住最小值:0 长的头等于没画,而"没画"该由开关说话,不该由算术偷偷决定。
/// </summary>
public static XChartArrowMarker Head(float length, float width, float progress, Color color)
{
return new XChartArrowMarker
{
Shape = XChartMarkerShape.Triangle,
Progress = IsFinite(progress) ? Mathf.Clamp01(progress) : 1f,
AlongTangent = Mathf.Max(0.1f, length),
AcrossTangent = Mathf.Max(0.1f, width),
TipAtPoint = 1f,
Color = color,
};
}
/// <summary>零向量的圆点:位置在条目中间(0.5)、中心对准那个点。</summary>
public static XChartArrowMarker Dot(float diameter, float width, Color color)
{
return new XChartArrowMarker
{
Shape = XChartMarkerShape.Circle,
Progress = 0.5f,
AlongTangent = Mathf.Max(0.1f, diameter),
AcrossTangent = Mathf.Max(0.1f, width),
TipAtPoint = 0f,
Color = color,
};
}
/// <summary>
/// 末端位置。<paramref name="mode"/>=<see cref="XChartArrowVectorMode.Absolute"/> 时
/// <paramref name="second"/> 是<b>方向矢量</b>本身(起点 + 方向×倍率);
+2 -1
View File
@@ -161,7 +161,8 @@ namespace XericUI.XChart.Mesh
private bool m_Continuous;
[SerializeField, Range(0f, 1f), Tooltip("连续绘制时箭头放在路径的哪个位置(0=起点、1=末端):" +
"路径在这一处剪断,箭头顺那一点的切线。只有连续绘制用得上")]
"它是曲线渲染器那个标记在曲线上的参数位置,路径不剪断、标记叠在线上。" +
"只有连续绘制用得上")]
private float m_HeadPosition = 1f;
[SerializeField, Range(2, 64), Tooltip("连续绘制时每段路径细分成几节(曲线渲染器的 tessellation)。" +