XChart P24:方向来源四档、头的尺寸吃投影、锚点字段(规范 §30)

他这轮给了三条,我先只回答"是不是真的",再动手。

1) "矢量被归一化到屏幕空间再算了"——是真的,而且成因在库那一行:
   CurveMeshGenerator.cs:150   pos += tangent * arrow.width * 0.5f * arrow.depthCompensation
   标记的**方向**跟曲线切线走(对),**尺寸是固定像素**(不是投影结果)。杆随姿态缩短、头不缩 ⇒
   整支读起来就是"屏幕空间里等长的箭头"。修法:新增纯算术 ProjectedScale(投影像素, 立方体长度, CubeToPixel)
   =这条矢量自己的投影比例(平行于屏幕=1、指向屏幕里→0),头的两个尺寸都乘它;连续绘制那一档取
   **这一节自己**的比例,所以弯到背面去的那一节头跟着缩;除不出来(NaN、零长、零比例)就答 0——
   宁可头缩成没有,也不要一个凭空的固定像素尺寸。
2) Absolute 下"方向从哪来"要可选,支数跟着变(他的算术:32 个点两两一组 ⇒ 16 支,而不是现在的 32 支)。
   新增 XChartArrowDirectionSource 四档:NextRecordAsVector(旧 Absolute,N−1)/NextRecordAsPoint
   (旧 Relative,N−1,点到点不用再算一次投影,所以 Tip 只在这一档作差)/ThisRecordCarriesVector
   (同一条记录 0~2 是点、3~5 是方向,N 支、要 6 维)/AlternatingRecords(偶数是点、奇数是方向,N÷2 支)。
   **支数与维数只有 ArrowCount(source,…) 和 RequiredCoordinateDimensions(source) 这一个实现**:
   四档算法在工具里各写一遍,画面上只是"少几支",那是最难查的一类错。
3) 锚点:MarkerAnchor [0,1] → 库的 depthCompensation(anchor×2−1;0=尾部落点、0.5=中心、1=头尖落点=默认),
   非有限退回 1——"头该贴在哪"不该因为一次写坏的值变成位置未知。

另外两条顺手立的规矩:
- **方向是原始矢量,绝不按位置的显示范围折**(TryReadRaw):折一次就把"朝哪"变成"在哪"
  ((0,1,0) 会被折成一个偏移量,整场箭头一起跑偏);尺度交给 DirectionScale。
  顺带:XMeshPreviewChart 那份"一条记录 6 维、方向存 3~5"的旧示例数据在 ThisRecordCarriesVector 下
  正好合法(§28.5 说的"死数据"有了读法)——默认值我没替他改。
- **颜色维撞上方向维**(自带方向那档吃 0~5 六列,颜色起点默认仍是 3):撞了就退回单色并印 colors=overlap,
  不静默把方向当色相读。
- **序列化兼容**:新枚举的 0/1 就是旧 XChartArrowVectorMode 的 Absolute/Relative,字段再加
  [FormerlySerializedAs("m_VectorMode")] ⇒ 他场景里存过的值不用重设("换类型不换序号"是"改字段名静默丢值"的反面)。

判据:探针 462 项 0 失败(新增 10 条:四档各自支数、维数需求只有自带方向那档要 6、锚点 0/0.5/1→−1/0/+1、
越界夹取与非有限回退、投影比例 1/0.5/指向屏幕=0、坏输入答 0);p4_control 66 支
(新增 3 支:分档按条数算/头无视投影比例/锚点映射写死 0;**删 1 支**——"空表被挡在算术外"那支的守卫
在新算术下已经到不了,**没有靶子的臂不当证据用**);编译门三臂 + 3 对照绿(chain_p24.txt)。

**门自己这轮现了一次瞎,这是本轮最值钱的自证**:`public T X` 与 `{` 分成两行的属性写法**根本没被数到**,
所以总数是 132 而不是 133——而"132/132 VERDICT: PASS"是绿的、却已经不等于"每个旋钮都看得见"
(我这次把 DirectionSource 写成了多行形状,正好撞上)。补 match_head(认得大括号在下一行的声明),
并加 **M9_nextline** 专测这种失明:把某个旋钮改写成多行形状**并抽掉它的 MarkDirty()**,门必须红——
看不见形状的门会放行一个不置脏的旋钮。补完后 knobs=133 takesEffect=133、九支变异全红。

两次 harness 正常工作也记在这里(都是它拒绝,而不是假判):CJK 第三次进了声明 coding: ascii 的脚本
(⇒ 中文只进仓内文档);一支臂的单行锚被我新写的孪生函数撞成 2 命中 ⇒ SETUP FAILED 整轮作废
(锚点加宽成两行块)。

覆盖不到的照旧:头的绝对大小好不好看归他现场判(§30.6 五条:换 AlternatingRecords 应见 16 支、
换 ThisRecordCarriesVector 应见 32 支且 colors=overlap 时把颜色起点调到 6、转立方体时长短不一且
headScale 读数跟着变、拖 MarkerAnchor 头尾互换、以及报表 src= anchor= headScale= 三个新读数)。
P25(自己写简单填充、替掉 chunk 式填充渲染器,顺带解掉 P23)按他的指示排在下一轮。
This commit is contained in:
2026-10-26 17:44:13 +08:00
parent 5f4c1adf0a
commit d60d204ec1
5 changed files with 325 additions and 74 deletions
+1
View File
@@ -98,6 +98,7 @@ P18 矢量场收尾:两端各自的颜色 + 连续绘制走曲线渲染器 +
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。
P24 箭头:方向来源四档 + 头的尺寸吃投影 + 锚点(规范 §30,2026-10-26 他三条要求):① **他指出的"矢量被归一化到屏幕空间再算了"是真的**,成因在库那一行 `CurveMeshGenerator.cs:150 pos += tangent * arrow.width * 0.5f * arrow.depthCompensation`——标记的**方向**跟曲线切线走(对)、**尺寸是固定像素**(不是投影结果):杆会随姿态缩短而头不缩,整支读起来就是"屏幕空间里等长的箭头"。修法:新增纯算术 `ProjectedScale(投影像素, 立方体长度, CubeToPixel)`=这条矢量自己的投影比例(平行于屏幕=1、指向屏幕里→0),头的两个尺寸都乘它;连续绘制那一档取**这一节自己**的比例,所以弯到背面去的那一节头跟着一起缩;**除不出来(NaN、零长、零比例)就答 0**——宁可头缩成没有,也不要一个凭空的固定像素尺寸。② **`XChartArrowDirectionSource` 四档**(他的"一个箭头对应两组数据 ⇒ 32 个点只该 16 支"):`NextRecordAsVector`(旧 Absolute,N−1)/`NextRecordAsPoint`(旧 Relative,N−1,**点到点不用再算一次投影**,所以 `Tip` 只在这一档作差)/`ThisRecordCarriesVector`(同一条的 3~5 维是方向,N 支、要 6 维)/`AlternatingRecords`(偶数条是点、奇数条是方向,N÷2 支);**支数与维数只有 `ArrowCount(source,…)`/`RequiredCoordinateDimensions(source)` 这一个实现**——四档算法在工具里各写一遍,画面上只是"少几支",最难查。③ **方向是原始矢量、绝不按位置的显示范围折**(`TryReadRaw`):折一次就把"朝哪"变成"在哪"(`(0,1,0)` 会被折成一个偏移量,整场箭头一起跑偏),尺度交给 `DirectionScale`;顺带 `XMeshPreviewChart` 那份"一条记录 6 维、方向存 3~5"的旧示例数据在新档 `ThisRecordCarriesVector` 下**正好合法**(§28.5 说的"死数据"有了读法,默认值我没替他改)。④ **序列化兼容**:新枚举 0/1 就是旧 `XChartArrowVectorMode` 的 Absolute/Relative,字段再加 `[FormerlySerializedAs("m_VectorMode")]` ⇒ 他场景里存过的值不用重设("换类型不换序号"是"改字段名静默丢值"的反面)。⑤ **`MarkerAnchor` [0,1]** → 库的 `depthCompensation`(`anchor×2−1`;0=尾部落点、0.5=中心、1=头尖落点=默认),非有限退回 1。⑥ **颜色维撞上方向维**:自带方向那档吃 0~5 六列而颜色起点默认仍是 3 ⇒ 会把方向当色相读;判据是撞了就退回单色并印 `colors=overlap`("颜色没生效"与"配置撞了"分得开)。判据:探针 **462** 项 0 失败(新增 10 条:四档各自支数(含 33÷2=16、1 条=0)、维数需求只有自带方向那档要 6、锚点 0/0.5/1→−1/0/+1、越界夹取与非有限回退、投影比例 1/0.5/指向屏幕=0、坏输入答 0)+ `p4_control` **66** 支(新增 3 支:分档按条数算/头无视投影比例/锚点映射写死 0;**删 1 支**——"空表被挡在算术外"那支的守卫在新算术下已经到不了,**没有靶子的臂不当证据用**)+ `dirty_gate` 正本 `knobs=133 takesEffect=133 findings=0`、**九支变异全红** + 编译门三臂 + 3 对照绿(`chain_p24.txt`)。**门自己也现了一次瞎**(本轮最重要的自证):`public T X` 与 `{` 分成两行的属性写法**根本没被数到**,于是总数是 132 而不是 133,而"132/132 PASS"是绿的、却不再等于"每个旋钮都看得见"——补 `match_head`(认得大括号在下一行的声明)并加 **M9_nextline** 专测这种失明:把某个旋钮改写成多行形状**并抽掉它的 `MarkDirty()`**,门必须红(看不见形状的门会放行一个不置脏的旋钮)。另记两次 harness 正常工作:CJK 又进了一次声明 `coding: ascii` 的脚本(第三次),以及一支臂的锚点被我新写的孪生函数撞成 2 命中 ⇒ `SETUP FAILED` 整轮作废(锚点加宽成两行块;规矩已进记忆)。
## [0.1.6] - 2026-07-01
+69
View File
@@ -3,6 +3,9 @@
本文是**实施依据**:先约定职责与流程,再按分期落地。每节末尾的"判据"是必须能机器验证或能明确观察的条目,
不写"应该会更好"这种无法证伪的话。
> **要接图表,不用读本文**:面向使用者(从外部喂数据、改元素参数)的速查在
> [`XChart-ExternalAPI.md`](XChart-ExternalAPI.md);本文管的是"为什么这样设计、每条判据靠什么红"。
---
## 0. 现状问题(P0,先修)
@@ -1998,3 +2001,69 @@ P18 那次我读不到库那个包(被拦过一次),就照着自己代码
3. 打开颜色维:杆沿程渐变(起点色 → 终点色),头是终点色。
4. 若画面仍然什么都没有 ⇒ 读报表那一行的 `path= / arrows= / markers= / curveVerts=`。
现在箭头这条路上没有"填充"那一层了,读数能给的解释比上一版窄——这正是这次改动的目的。
## 30. P24:方向来源四档、头的尺寸吃投影、锚点字段(2026-10-26 他三条要求)
### 30.1 他指出的两件事
1. **"矢量被归一化到屏幕空间再算了"**:圆周方向的一圈矢量,投到 2D 上不可能一样长,而他看到的一样长。
成因在库那一行——`CurveMeshGenerator.cs:150 pos += tangent * arrow.width * 0.5f * arrow.depthCompensation`:
标记的**方向**跟着曲线切线走(对),**尺寸是固定像素**(≠投影结果)。杆是两端点投影画的,所以会缩短;
头不缩 ⇒ 整支读起来就是"屏幕空间里等长的箭头"。
2. **`Absolute` 下"方向的来源"应该是可选的**,而且支数要跟着一起来:
他说"要让一个箭头对应两组数据,32 个点上就只该有 16 个箭头,而现在有 32 个"。
### 30.2 四档方向来源(`XChartArrowDirectionSource`,算式全在 `XChartVectorFieldMath`)
| 档 | 起点 | 方向/第二量 | 支数 | 要几个数值维 |
| --- | --- | --- | --- | --- |
| `NextRecordAsVector`(旧 Absolute) | 第 i 条 0~2 | 第 i+1 条 0~2(折进盒子后的坐标当方向) | N−1 | 3 |
| `NextRecordAsPoint`(旧 Relative) | 第 i 条 0~2 | 第 i+1 条 0~2(**第二个点**,作差) | N−1 | 3 |
| `ThisRecordCarriesVector` | 第 i 条 0~2 | **同一条**的 3~5(原始矢量) | N | 6 |
| `AlternatingRecords`(分段) | **偶数**条 0~2 | **奇数**条 0~2(原始矢量) | N÷2 | 3 |
- **支数与维数只有这一个实现**:`ArrowCount(source,…)` / `RequiredCoordinateDimensions(source)`。
四档的算法(`N−1 / N / N÷2`、`3 / 6`)一旦在工具里各写一遍,画面上只是"少几支",最难查。
- **方向是原始矢量,绝不按位置的显示范围折**(`TryReadRaw`):折一次就把"朝哪"变成"在哪"——
一个 `(0,1,0)` 会被折成一个偏移量,于是整场箭头一起跑偏。它的尺度由 `DirectionScale`(每数据单位给多少立方体单位)说话。
- **兼容**:新枚举的 0/1 就是旧 `XChartArrowVectorMode` 的 Absolute/Relative,字段另加了
`[FormerlySerializedAs("m_VectorMode")]` ⇒ 他场景里存过的值不用重设("换类型不换序号"是"改名静默丢值"的反面做法)。
- 他说"相对模式是一个点到另一个点,不用再算一次投影":这条本来就成立(两端都是投影点),
所以 `Tip` 只在 `NextRecordAsPoint` 那一档作差,其余三档第二量直接就是方向。
### 30.3 头的尺寸吃投影 + 锚点
- `ProjectedScale(投影像素, 立方体长度, CubeToPixel)`=这条矢量的**投影比例**:平行于屏幕=1、指向屏幕里→0;
头的两个尺寸都乘它(连续绘制那一档取**这一节自己**的比例,所以弯到背面去的那一节头也跟着缩)。
除不出来(NaN、零长、零比例)就答 **0**:宁可头缩成没有,也不要一个凭空的固定尺寸。
- `MarkerAnchor` [0,1] → 库的 `depthCompensation`(`anchor×2−1`):**0=尾部落在点上(向前伸)、0.5=中心、1=头尖落在点上**(默认 1)。
非有限数退回 1——"头该贴在哪"不该因为一次写坏的值变成位置未知。
- `XMeshPreviewChart` 那份"一条记录 6 维、方向存 3~5 维"的旧示例数据,在 `ThisRecordCarriesVector` 这一档下
**正好是合法的**(§28.5 里我说的"死数据"从此有了读法)——我没有替他把默认值改掉。
### 30.4 颜色维撞上方向维:当场说,不静默画错
`ThisRecordCarriesVector` 要吃 0~5 六列,而颜色起点默认还是 3 ⇒ 会把**方向**当色相读。
判据:`ColorDimension < RequiredCoordinateDimensions(source)` 时退回单色,报表印 `colors=overlap`
("颜色没生效"与"配置撞了"是分开的两件事)。
### 30.5 判据
- 探针 **462** 项 0 失败:新增 10 条——四档各自的支数(含 33 条÷2=16、1 条=0)、维数需求(只有自带方向那档要 6)、
锚点 0/0.5/1 → −1/0/+1、越界夹取与非有限回退、头的投影比例(1/0.5/指向屏幕=0)、坏输入答 0。
- `p4_control` **66** 支各红在点名断言上(新增 3 支:分段那档按条数算/头无视投影比例/锚点映射写死 0;
删 1 支——"空表被挡在算术外"那支的守卫在新算术下已经到不了,**没有靶子的臂不当证据用**)。
- `dirty_gate` 正本 `knobs=133 takesEffect=133 findings=0`、**九支变异全红**。
这轮它自己也现了一次瞎:`public T X` 与 `{` 分成两行的写法**根本没被数到**(所以是 132 而不是 133),
那时"132/132 PASS"是绿的、却不再等于"每个旋钮都看得见"。补了 `match_head`(认得大括号在下一行的声明),
并加 **M9_nextline** 专测这种失明:把某个旋钮改写成多行形状**并抽掉它的 `MarkDirty()`**,门必须红——
看不见形状的门会放行一个不置脏的旋钮。
- 编译门 runtime + player + editor + 3 支对照 `GATE PASSED`(`chain_p24.txt`)。
### 30.6 覆盖不到什么 / 他侧验收(Ctrl+R 后)
1. 换成 `AlternatingRecords`:32 条记录 ⇒ **16 支**(报表 `arrows=16 src=alternatingrecords`)。
2. 换成 `ThisRecordCarriesVector`(他那份 demo 数据的形状)⇒ 32 支;若 `colors=overlap` 就把颜色起点调到 6。
3. 转立方体:一圈"圆周方向"的矢量投到 2D 上**长短不一**(`headScale` 读数跟着变;指向屏幕里的那支会缩到几乎看不见)。
4. 拖 `MarkerAnchor`:0 时尾巴钉在点上、1 时头尖钉在点上(默认)。
5. 头的绝对大小他满意与否归他判——机器只保证"它是投影算出来的,不是写死的"。
+141 -31
View File
@@ -10,7 +10,7 @@ namespace XericUI.XChart.Mesh
/// 向量场 / 流形箭头元素。<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"/> 解释成"第二个点"或"方向矢量"),
/// (第 i 条是起点,第 i+1 条按 <see cref="DirectionSource"/> 解释成"第二个点"或"方向矢量"),
/// <b>第 4~7 维是颜色</b>(色相 0..256 色环 / 饱和度 / 明度 / 不透明度,可选)。
///
/// <para><b>两种读法</b>:绝对 ⇒ 第二条记录的坐标就是方向(起点 + 方向×倍率),螺旋点画出来是一片"刺猬";
@@ -34,9 +34,13 @@ namespace XericUI.XChart.Mesh
private int m_CoordinateDimension;
/// <summary>坐标的维度下标(x/y/z 三维)</summary>
public int CoordinateDimension { get => m_CoordinateDimension; set { m_CoordinateDimension = value; MarkDirty(); } }
private XChartArrowVectorMode m_VectorMode = XChartArrowVectorMode.Absolute;
/// <summary>第二条记录怎么读成方向</summary>
public XChartArrowVectorMode VectorMode { get => m_VectorMode; set { m_VectorMode = value; MarkDirty(); } }
private XChartArrowDirectionSource m_DirectionSource = XChartArrowDirectionSource.NextRecordAsVector;
/// <summary>方向从哪来(四档,箭数与维数需求都跟着它变;算式在 XChartVectorFieldMath 里)</summary>
public XChartArrowDirectionSource DirectionSource
{
get => m_DirectionSource;
set { m_DirectionSource = value; MarkDirty(); }
}
private bool m_Continuous;
/// <summary>把每条记录的坐标按顺序连成路径(此时相对/绝对不适用)</summary>
public bool Continuous { get => m_Continuous; set { m_Continuous = value; MarkDirty(); } }
@@ -94,11 +98,20 @@ namespace XericUI.XChart.Mesh
/// </summary>
public float HeadPosition { get => m_HeadPosition; set { m_HeadPosition = value; MarkDirty(); } }
private float m_MarkerAnchor = 1f;
/// <summary>
/// 头贴在矢量端点的哪一处:0=尾部落在点上(向前伸)、0.5=中心对点、1=<b>头尖落在点上</b>(默认)。
/// 它就是库那个标记的 <c>depthCompensation</c>(映射=anchor×2−1,在纯算术里)。
/// </summary>
public float MarkerAnchor { get => m_MarkerAnchor; set { m_MarkerAnchor = value; MarkDirty(); } }
private int m_PathSegments = 12;
/// <summary>连续绘制时每段路径细分成几节(曲线渲染器的 tessellation)</summary>
public int PathSegments { get => m_PathSegments; set { m_PathSegments = value; MarkDirty(); } }
private readonly List<Vector2> m_Pixels = new List<Vector2>(64);
// 路径还要留着<b>立方体单位</b>的那一份:头的投影比例要用"这一节在 3D 里多长"作分母
private readonly List<Vector3> m_Cubes = new List<Vector3>(64);
private readonly Vector2[] m_Bezier = new Vector2[XChartArrowPathMath.ControlPointsPerSegment];
private readonly float[] m_Widths = new float[XChartArrowPathMath.ControlPointsPerSegment];
// 一支箭头一个标记,所以一条曲线最多挂一个:数组长度 1 是刻意的(AddCurve 吃的是数组)
@@ -106,6 +119,7 @@ namespace XericUI.XChart.Mesh
private string m_PathRenderer = "-";
private int m_CurveEntries;
private int m_Markers;
private float m_HeadScale = 1f;
private Matrix4x4 m_Composed = Matrix4x4.identity;
private int m_LastSpaceVersion = -1;
@@ -127,16 +141,20 @@ namespace XericUI.XChart.Mesh
public override void MarkDirty() => m_Dirty = true;
/// <summary>
/// 这个元素要几个数值维:坐标 3 +(可选)颜色 3。
/// <b>不透明度那一维不算硬需求</b>:多给就多读、没给退回单色 alpha——
/// 把它算进门槛的话,勾一下"有不透明度"会让整个元素突然一条都不画,
/// 那是把这一个开关变成了总闸。
/// 这个元素要几个数值维:坐标那一半<b>随方向来源变</b>(本条自带方向那档要 6:0~2 点、3~5 方向),
/// 再加(可选)颜色 3。<b>不透明度那一维不算硬需求</b>:多给就多读、没给退回单色 alpha——
/// 把它算进门槛的话,勾一下"有不透明度"会让整个元素突然一条都不画,那是把开关变成了总闸。
/// </summary>
public int RequiredDimensionCount
=> XChartArrowConfig.CoordinateDimensionCount + (UseColorDimensions ? XChartArrowConfig.ColorDimensionCount : 0);
=> XChartVectorFieldMath.RequiredCoordinateDimensions(DirectionSource)
+ (UseColorDimensions ? XChartArrowConfig.ColorDimensionCount : 0);
/// <summary>一支箭头要两条记录</summary>
public int RequiredRecordCount => 2;
/// <summary>几条记录凑一支:本条自带方向那档一条就够,其余要两条</summary>
public int RequiredRecordCount
=> DirectionSource == XChartArrowDirectionSource.ThisRecordCarriesVector ? 1 : 2;
/// <summary>这一支箭头在屏幕上的"像素/立方体单位"比例(头的尺寸吃它,§30)</summary>
public float LastHeadScale => m_HeadScale;
protected override void OnInitialize()
{
@@ -218,7 +236,7 @@ namespace XericUI.XChart.Mesh
if (!m_HasDomains) return;
// 一支箭头=相邻两条记录 ⇒ 支数由纯算术算(离线钉着:记录不够 vs 维数不够要分得清)
int limit = XChartVectorFieldMath.ArrowCount(m_RecordsHave, MaxArrowCount);
int limit = XChartVectorFieldMath.ArrowCount(DirectionSource, m_RecordsHave, MaxArrowCount);
if (Continuous)
{
@@ -228,20 +246,63 @@ namespace XericUI.XChart.Mesh
for (int i = 0; i < limit; i++)
{
Vector3 first, second;
if (!TryReadPoint(source, i, out first) || !TryReadPoint(source, i + 1, out second))
Vector3 origin, second;
if (!TryReadArrow(source, i, out origin, out second))
{
m_PointsSkipped++;
continue;
}
// 两种读法的算式在纯算术里(离线钉着):绝对=第二条的坐标就是方向;相对=它是第二个点
Vector3 tip = XChartVectorFieldMath.Tip(VectorMode, first, second, DirectionScale);
AddShaft(space.Project(first, m_Composed), space.Project(tip, m_Composed),
ColorAt(source, i), ColorAt(source, i + 1));
// 读法在纯算术里:相邻两条·下一条是第二个点 ⇒ 作差;其余三档 ⇒ 第二量本身就是方向
Vector3 tip = XChartVectorFieldMath.Tip(DirectionSource, origin, second, DirectionScale);
AddShaft(space, origin, tip, ColorAt(source, FirstRecordOf(i)), ColorAt(source, SecondRecordOf(i)));
m_ArrowsBuilt++;
}
}
/// <summary>这支箭头的<b>第一条</b>记录号(起点、起点色都读它)</summary>
private int FirstRecordOf(int arrow)
=> DirectionSource == XChartArrowDirectionSource.AlternatingRecords ? arrow * 2 : arrow;
/// <summary>
/// 这支箭头的<b>第二条</b>记录号(终点色读它)。"本条自带方向"那档没有第二条,就是它自己——
/// 那一档两端同色是数据的说法,不是画错了。
/// </summary>
private int SecondRecordOf(int arrow)
{
switch (DirectionSource)
{
case XChartArrowDirectionSource.AlternatingRecords: return arrow * 2 + 1;
case XChartArrowDirectionSource.ThisRecordCarriesVector: return arrow;
default: return arrow + 1;
}
}
/// <summary>
/// 按"方向从哪来"读出一支箭头需要的两个量。相邻两条那两档读两条记录的坐标(都折进盒子);
/// 自带方向那档读同一条的 3~5 维、分段那档读奇数号记录的 0~2 维——
/// <b>这两档的方向是原始矢量,绝不按位置的显示范围折</b>:折一次就把"朝哪"变成"在哪"
/// (一个 (0,1,0) 的方向会被折成一个偏移量,于是所有箭头一起跑偏)。它的尺度由 DirectionScale 说话。
/// </summary>
private bool TryReadArrow(IXChartDataSource source, int arrow, out Vector3 origin, out Vector3 second)
{
origin = Vector3.zero;
second = Vector3.zero;
int firstRecord = FirstRecordOf(arrow);
int secondRecord = SecondRecordOf(arrow);
if (firstRecord < 0 || secondRecord >= m_RecordsHave) return false;
if (!TryReadFolded(source, firstRecord, 0, out origin)) return false;
switch (DirectionSource)
{
case XChartArrowDirectionSource.ThisRecordCarriesVector:
return TryReadRaw(source, firstRecord, XChartArrowConfig.CoordinateDimensionCount, out second);
case XChartArrowDirectionSource.AlternatingRecords:
return TryReadRaw(source, secondRecord, 0, out second);
default:
return TryReadFolded(source, secondRecord, 0, out second);
}
}
/// <summary>
/// 连续绘制:途经点 → Catmull-Rom 贝塞尔链(曲线<b>真的经过每个数据点</b>——矢量场的点是数据本身,
/// 用不经过控制点的自由贝塞尔等于把数据挪了位置),逐节提交成一条路径;
@@ -251,12 +312,14 @@ namespace XericUI.XChart.Mesh
private void BuildContinuous(IXChartDataSource source, ChartToolSpace space, int limit)
{
m_Pixels.Clear();
m_Cubes.Clear();
for (int i = 0; i <= limit; i++)
{
Vector3 cube;
// 跳过的点要报出来:路径按"活下来的点"连,颜色仍按记录号取——数据里有非有限值时
// 这两者会错开,不印出来的话就只能靠猜(skipped= 那一读数的全部意义)
if (!TryReadPoint(source, i, out cube)) { m_PointsSkipped++; continue; }
if (!TryReadFolded(source, i, 0, out cube)) { m_PointsSkipped++; continue; }
m_Cubes.Add(cube);
m_Pixels.Add(space.Project(cube, m_Composed));
}
@@ -271,7 +334,13 @@ namespace XericUI.XChart.Mesh
bool withHead = s == headSegment;
if (withHead)
{
m_Heads[0] = ToHeadData(XChartVectorFieldMath.Head(HeadLength, HeadWidth, headT,
// 连续绘制没有"一支矢量"那个长度可折,就用<b>这一节自己</b>的投影比例
// (画了多少像素 ÷ 它在立方体单位里该有多少像素):弯到背面去的那一节,头跟着一起缩
m_HeadScale = XChartVectorFieldMath.ProjectedScale(
Vector2.Distance(m_Pixels[s], m_Pixels[s + 1]),
Vector3.Distance(m_Cubes[s], m_Cubes[s + 1]), space.CubeToPixel);
m_Heads[0] = ToHeadData(XChartVectorFieldMath.Head(
HeadLength * m_HeadScale, HeadWidth * m_HeadScale, headT, MarkerAnchor,
ColorAt(source, Mathf.Min(s + 1, m_RecordsHave - 1))));
m_Markers++;
m_ArrowsBuilt = 1; // 连续绘制是"一条路径 + 一支箭头"
@@ -294,22 +363,33 @@ namespace XericUI.XChart.Mesh
/// 零向量不投一条零长曲线(库在零长输入上的细分没有承诺),改画一个圆点标记;
/// 开关关掉就整条不画——<c>arrows=/skipped=</c> 说得出为什么少了一支。
/// </summary>
private void AddShaft(Vector2 from, Vector2 to, Color startColor, Color endColor)
private void AddShaft(ChartToolSpace space, Vector3 originCube, Vector3 tipCube,
Color startColor, Color endColor)
{
Vector2 from = space.Project(originCube, m_Composed);
Vector2 to = space.Project(tipCube, m_Composed);
// 头的尺寸吃"这条矢量自己的投影比例":库的标记是<b>固定像素</b>的(库里那行
// pos += tangent * arrow.width * 0.5f * depthCompensation),不乘它就等于
// "转个身所有箭头还是同样长"(他 2026-10-26 的判决:圆周方向投到 2D 不可能都等长)
m_HeadScale = XChartVectorFieldMath.ProjectedScale(Vector2.Distance(from, to),
Vector3.Distance(originCube, tipCube), space.CubeToPixel);
if ((to - from).sqrMagnitude < 1e-4f)
{
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));
Mathf.Max(ShaftWidth, 1f), Mathf.Max(HeadWidth * m_HeadScale, 1f), endColor));
AddEntry(m_Bezier, endColor, endColor, true);
m_Markers++;
return;
}
XChartArrowPathMath.Straight(from, to, m_Bezier);
m_Heads[0] = ToHeadData(XChartVectorFieldMath.Head(HeadLength, HeadWidth, 1f, endColor));
m_Heads[0] = ToHeadData(XChartVectorFieldMath.Head(
HeadLength * m_HeadScale, HeadWidth * m_HeadScale, 1f, MarkerAnchor, endColor));
AddEntry(m_Bezier, startColor, endColor, true);
m_Markers++;
}
@@ -364,22 +444,42 @@ namespace XericUI.XChart.Mesh
}
/// <summary>
/// 一条记录 → <b>立方体单位</b>的点。原始值先按各维范围折进 [-1,1] 再投影
/// (折法在纯算术里,离线钉着:<see cref="XChartVectorFieldMath.TryCubePoint"/>)。
/// 一条记录的第 <c>offset~offset+2</c> 维(相对坐标起点)→ <b>立方体单位</b>的点:原始值先按各维
/// 范围折进 [-1,1] 再投影(折法在纯算术里,离线钉着:<see cref="XChartVectorFieldMath.TryCubePoint"/>)。
/// 折不出来(值非有限、或那一维跨度为 0)就返回 false,调用方计入 <c>skipped=</c>——
/// <b>不是"静默少一支",是"少几支当场说"</b>。
/// </summary>
private bool TryReadPoint(IXChartDataSource source, int record, out Vector3 cube)
private bool TryReadFolded(IXChartDataSource source, int record, int offset, out Vector3 cube)
{
cube = Vector3.zero;
if (record < 0 || record >= m_RecordsHave) return false;
int dim = CoordinateDimension + offset;
return XChartVectorFieldMath.TryCubePoint(
source.GetValueAt(record, CoordinateDimension),
source.GetValueAt(record, CoordinateDimension + 1),
source.GetValueAt(record, CoordinateDimension + 2),
source.GetValueAt(record, dim),
source.GetValueAt(record, dim + 1),
source.GetValueAt(record, dim + 2),
m_MinX, m_MaxX, m_MinY, m_MaxY, m_MinZ, m_MaxZ, out cube);
}
/// <summary>
/// 一条记录的三个<b>原始</b>值(方向用):<b>不折进盒子、不位移</b>——方向是矢量,
/// 拿位置的显示范围去折它就是把"朝哪"变成"在哪"。这里只保证三个数都是有限数,
/// 尺度交给 <see cref="DirectionScale"/>(每数据单位给多少立方体单位)。
/// </summary>
private bool TryReadRaw(IXChartDataSource source, int record, int offset, out Vector3 vector)
{
vector = Vector3.zero;
if (record < 0 || record >= m_RecordsHave) return false;
int dim = CoordinateDimension + offset;
double x = source.GetValueAt(record, dim);
double y = source.GetValueAt(record, dim + 1);
double z = source.GetValueAt(record, dim + 2);
if (double.IsNaN(x) || double.IsNaN(y) || double.IsNaN(z)
|| double.IsInfinity(x) || double.IsInfinity(y) || double.IsInfinity(z)) return false;
vector = new Vector3((float)x, (float)y, (float)z);
return true;
}
/// <summary>
/// 这一条记录的颜色:没开颜色维就是单色;开了就按
/// <c>[色相(0..256 色环), 饱和度(0..1), 明度(0..1), (不透明度 0..1)]</c> 读。
@@ -390,6 +490,10 @@ namespace XericUI.XChart.Mesh
{
if (!UseColorDimensions) return ArrowColor;
if (source.NumericDimensionCount < ColorDimension + XChartArrowConfig.ColorDimensionCount) return ArrowColor;
// 颜色维压到了坐标/方向那几列上(自带方向那档要 6 列,颜色起点默认还是 3):
// 那不是"一种颜色",那是把方向当色相读——退回单色,并让 colors=overlap 说出来
if (ColorDimension < XChartVectorFieldMath.RequiredCoordinateDimensions(DirectionSource))
return ArrowColor;
float hue = (float)source.GetValueAt(record, ColorDimension);
float saturation = (float)source.GetValueAt(record, ColorDimension + 1);
@@ -406,6 +510,7 @@ namespace XericUI.XChart.Mesh
{
CurveRenderer = null;
m_Pixels.Clear();
m_Cubes.Clear();
}
#if UNITY_EDITOR
@@ -428,8 +533,13 @@ namespace XericUI.XChart.Mesh
: "-")
.Append(" arrows=").Append(m_ArrowsBuilt)
.Append(" skipped=").Append(m_PointsSkipped)
.Append(" mode=").Append(Continuous ? "continuous" : (VectorMode == XChartArrowVectorMode.Relative ? "relative" : "absolute"))
.Append(" colors=").Append(UseColorDimensions ? (HasAlphaDimension ? "hsv+a" : "hsv") : "single")
.Append(" src=").Append(Continuous ? "continuous" : DirectionSource.ToString().ToLower())
.Append(" anchor=").Append(MarkerAnchor.ToString("0.###"))
.Append(" headScale=").Append(m_HeadScale.ToString("0.###"))
// colors=overlap:颜色维的起点压到了坐标/方向那几列上 ⇒ 实际画的是单色(不是"颜色没生效",是配置撞了)
.Append(" colors=").Append(!UseColorDimensions ? "single"
: (ColorDimension < XChartVectorFieldMath.RequiredCoordinateDimensions(DirectionSource) ? "overlap"
: (HasAlphaDimension ? "hsv+a" : "hsv")))
.Append(" path=").Append(m_PathRenderer)
.Append(" at=").Append(HeadPosition.ToString("0.###"))
.Append(" curves=").Append(m_CurveEntries)
+83 -16
View File
@@ -4,7 +4,27 @@ using XericUI.XChart;
namespace XericUI.XChart.Mesh
{
/// <summary>
/// 曲线渲染器的箭头标记长什么样(离线侧的形状,接线时一对一映射到库的 <c>ArrowShape</c>)。
/// 一支箭头的<b>方向从哪来</b>(他 2026-10-26 补的口径:光有"相对/绝对"两个词表达不出
/// "一条记录自带方向"和"偶数点是点、奇数点是方向"这两种存法)。
///
/// <para><b>编号是有意接旧的</b>:0/1 就是原来 <c>XChartArrowVectorMode</c> 的 Absolute/Relative,
/// 所以场景里存过的 <c>m_VectorMode</c> 值不用动就还是同一个意思(枚举换类型而序号不改=静默丢值的反面)。
/// 2/3 是新增的两档"方向是矢量"的存法。</para>
/// </summary>
public enum XChartArrowDirectionSource
{
/// <summary>相邻两条、重叠:本条=起点,下一条的<b>坐标</b>就是方向矢量(旧 Absolute)。箭数=N−1</summary>
NextRecordAsVector = 0,
/// <summary>相邻两条、重叠:本条=起点,下一条=<b>第二个点</b>(旧 Relative,首尾相接)。箭数=N−1</summary>
NextRecordAsPoint = 1,
/// <summary>一条记录自带:0~2 维是点、3~5 维是方向矢量。箭数=N(要 6 个数值维)</summary>
ThisRecordCarriesVector = 2,
/// <summary>分段:偶数记录是点、奇数记录是方向(不重叠)。箭数=N/2</summary>
AlternatingRecords = 3,
}
/// <summary>
/// 曲线渲染器的箭头标记长什么样(接线时一对一映射到库的 <c>ArrowShape</c>)。
/// 只列我们真用的两档:三角形=有方向的箭头,圆形=零向量那种"就是一个点"。
/// </summary>
public enum XChartMarkerShape
@@ -70,11 +90,13 @@ namespace XericUI.XChart.Mesh
}
/// <summary>
/// 三角形头。<paramref name="progress"/> 夹进 [0,1];<b>不是有限数就落在末端</b>(1)——
/// 三角形头。<paramref name="progress"/> 与 <paramref name="anchorOnPoint"/> 都夹进 [0,1];
/// <b>不是有限数就退回默认</b>(位置=末端、锚=头尖对点)——
/// NaN 一路传进库里会得到一个位置未知、也报不出错的东西,那正是"画面和读数对不上"的来路。
/// 两个尺寸都兜住最小值:0 长的头等于没画,而"没画"该由开关说话,不该由算术偷偷决定。
/// </summary>
public static XChartArrowMarker Head(float length, float width, float progress, Color color)
public static XChartArrowMarker Head(float length, float width, float progress, float anchorOnPoint,
Color color)
{
return new XChartArrowMarker
{
@@ -82,7 +104,7 @@ namespace XericUI.XChart.Mesh
Progress = IsFinite(progress) ? Mathf.Clamp01(progress) : 1f,
AlongTangent = Mathf.Max(0.1f, length),
AcrossTangent = Mathf.Max(0.1f, width),
TipAtPoint = 1f,
TipAtPoint = AnchorToCompensation(anchorOnPoint),
Color = color,
};
}
@@ -102,31 +124,76 @@ namespace XericUI.XChart.Mesh
}
/// <summary>
/// 末端位置。<paramref name="mode"/>=<see cref="XChartArrowVectorMode.Absolute"/> 时
/// <paramref name="second"/> 是<b>方向矢量</b>本身(起点 + 方向×倍率);
/// =<see cref="XChartArrowVectorMode.Relative"/> 时它是<b>第二个点</b>(起点 + 差向量×倍率)。
/// 两种读法在同一个数据上画出来是两幅不同的图:前者"刺猬",后者"首尾相接"。
/// 末端位置。<paramref name="source"/>=<see cref="XChartArrowDirectionSource.NextRecordAsPoint"/> 时
/// <paramref name="second"/> 是<b>第二个点</b>(起点 + 差向量×倍率,首尾相接);
/// 其余三档它就是<b>方向矢量</b>本身(起点 + 方向×倍率)。
/// 相邻两条的两档在同一个数据上画出来是两幅图:一片"刺猬"对一串首尾相接。
/// </summary>
public static Vector3 Tip(XChartArrowVectorMode mode, Vector3 first, Vector3 second, float scale)
public static Vector3 Tip(XChartArrowDirectionSource source, Vector3 first, Vector3 second, float scale)
{
Vector3 direction = mode == XChartArrowVectorMode.Relative ? second - first : second;
// 只有"下一条记录是第二个点"这一档要作差;其余档里 second 本身就是方向矢量。
// 点到点这一档的两端都是投影点,所以它的 2D 长度天然是投影结果,不需要再多算一次(他 2026-10-26)
Vector3 direction = source == XChartArrowDirectionSource.NextRecordAsPoint ? second - first : second;
return first + direction * scale;
}
/// <summary>
/// 一支箭头=相邻两条记录 ⇒ 给定记录数与上限,能画出几支(上限 ≤0 =不限)。
/// 这一档方向来源<b>每个箭头自己要吃几个数值维</b>:自带方向那档要 6 个(0~2 点、3~5 方向),
/// 其余三档只要 3 个(方向从别的记录来)。
///
/// <para>单列出来是因为<b>"记录不够"与"维数不够"在画面上完全同形</b>(都是一条都不画),
/// 而 N−1 与 0 这两个数是唯一分得清它们的读数(规范 §25.1)。</para>
/// <para>面板拿它和表里现有的维数对印(§25.1):维数不够时元素一支都不画,
/// 报出来必须是"需要几个、现有几个"两个数,不能只说"没显示"。</para>
/// </summary>
public static int ArrowCount(int recordCount, int maxArrows)
public static int RequiredCoordinateDimensions(XChartArrowDirectionSource source)
=> source == XChartArrowDirectionSource.ThisRecordCarriesVector
? XChartArrowConfig.CoordinateDimensionCount * 2
: XChartArrowConfig.CoordinateDimensionCount;
/// <summary>
/// 给定记录数与上限,这一档来源能画几支。四种算法各不同,所以都得在这里,
/// 由调用方现问而不是在工具里各写一遍("N−1/N/N÷2"三个数写错一个,画面上只是少几支,最难查)。
/// </summary>
public static int ArrowCount(XChartArrowDirectionSource source, int recordCount, int maxArrows)
{
if (recordCount < 2) return 0;
int pairs = recordCount - 1;
// 没有"记录数 ≤0 就先返回 0"那道闸:四档算法各自都把 0/1 条算成 0(0−1、0/2、<2 那一支),
// 加一道到不了的守卫只会多一个"看起来判过、其实永远不响"的地方(§29.4 那条教训)
int pairs;
switch (source)
{
case XChartArrowDirectionSource.ThisRecordCarriesVector: pairs = recordCount; break;
case XChartArrowDirectionSource.AlternatingRecords: pairs = recordCount / 2; break;
default: pairs = recordCount < 2 ? 0 : recordCount - 1; break; // 相邻两条那两档
}
if (maxArrows > 0 && maxArrows < pairs) return maxArrows;
return pairs;
}
/// <summary>
/// 锚点 → 库的 <c>depthCompensation</c>:<b>0=尾部落在数据点上、0.5=中心、1=头尖落在点上</b>
/// (映射就是 anchor×2−1)。默认 1:矢量场的箭头指的就是那一点。
/// 非有限数按 1 处理——"头该贴在哪"这件事不该因为一次写坏的值变成位置未知。
/// </summary>
public static float AnchorToCompensation(float anchorOnPoint)
=> IsFinite(anchorOnPoint) ? Mathf.Clamp01(anchorOnPoint) * 2f - 1f : 1f;
/// <summary>
/// <b>这条矢量的投影比例</b>:投影后画了多少像素 ÷ 它在立方体单位里该有多少像素
/// (<paramref name="projectedPixels"/>=|to−from|,<paramref name="cubeLength"/>=|tip−origin|(立方体单位),
/// <paramref name="pixelsPerCubeUnit"/>=<c>space.CubeToPixel</c>)。
/// 平行于屏幕=1,指向屏幕里→0。库的标记吃的是<b>固定像素</b>(库里那行
/// <c>pos += tangent * arrow.width * 0.5f * depthCompensation</c>),所以头的尺寸必须乘上这个比例,
/// 否则所有姿态下头一样长——他 2026-10-26 看到的就是这个:"圆周方向的长度在 2D 上的投影不可能完全一样长"。
/// 除不出来(长度为 0 或不是有限数)就答 0:宁可头缩成没有,也不要一个凭空的固定尺寸。
/// </summary>
public static float ProjectedScale(float projectedPixels, float cubeLength, float pixelsPerCubeUnit)
{
if (!IsFinite(projectedPixels) || !IsFinite(cubeLength) || !IsFinite(pixelsPerCubeUnit)) return 0f;
float reference = cubeLength * pixelsPerCubeUnit;
if (reference <= 1e-6f) return 0f;
float scale = projectedPixels / reference;
return scale > 0f ? scale : 0f;
}
/// <summary>
/// 读一组颜色维:<paramref name="hue"/> 按 <b>0..256 的色环</b>(256 与 0 是同一个颜色,
/// 取模,所以 300 也读得动),饱和度/明度/不透明度按 0..1 夹住。
+31 -27
View File
@@ -1,23 +1,12 @@
using System;
using UnityEngine;
using UnityEngine.Serialization;
using XericUI.XChart.Space;
namespace XericUI.XChart.Mesh
{
/// <summary>
/// 一条记录里的两个点怎么变成一支箭头。
///
/// <para><b>绝对</b>:后三点是方向矢量本身(起点 + 方向×倍率=末端)。螺旋点这样画出来是"刺猬"。
/// <b>相对</b>:后三点是第二个点,箭头=第一点指向第二点(差向量×倍率)。
/// 连续绘制模式下两者都不适用(连起来的是一条空间路径)。</para>
/// </summary>
public enum XChartArrowVectorMode
{
/// <summary>后三维=方向矢量</summary>
Absolute = 0,
/// <summary>后三维=第二个点(箭头由第一点指向它)</summary>
Relative = 1,
}
// 方向来源的枚举在 XChartVectorFieldMath.cs 里(XChartArrowDirectionSource):
// 算箭数的四种算法也在那里,配置只存"选哪一种"——两边各写一遍就会答得不一样(§25.1 那一族)。
/// <summary>圆柱元素的配置(几何单位都是立方体局部:±1 就是盒子边界)。</summary>
[Serializable]
@@ -129,8 +118,9 @@ namespace XericUI.XChart.Mesh
/// <para><b>数据口径(2026-10-25 他澄清后定稿,规范 §25.2)</b>:</para>
/// <list type="bullet">
/// <item><b>前三维=坐标 x/y/z</b>(立方体单位,与圆柱、散点同一套归一化)——不是"两组三维"。</item>
/// <item><b>一支箭头=相邻两条记录</b>:第 i 条是起点,第 i+1 条按 <see cref="VectorMode"/> 解释成
/// "第二个点"或"方向矢量"(他原话:"我们是 0 和 1,一个代表坐标,一个代表它的矢量的方向")。</item>
/// <item><b>一支箭头=相邻两条记录</b>:第 i 条是起点,第 i+1 条按 <see cref="m_DirectionSource"/> 解释成
/// "第二个点"或"方向矢量"(他原话:"我们是 0 和 1,一个代表坐标,一个代表它的矢量的方向")。
/// 2026-10-26 又补了两档来源:本条记录自带方向(0~2 点、3~5 方向)、以及"偶数是点、奇数是方向"的分段存法。</item>
/// <item><b>第 4~7 维是颜色</b>:色相(0..256 色环)/ 饱和度 / 明度 / 不透明度,全部可选。
/// 颜色随记录自带 ⇒ 一支箭头的起点色与终点色可以不同(七维信息的那个用法)。</item>
/// </list>
@@ -152,9 +142,11 @@ namespace XericUI.XChart.Mesh
[SerializeField, Tooltip("坐标从第几个数值维开始(一条记录 3 维:x/y/z);一支箭头由**相邻两条记录**构成")]
private int m_CoordinateDimension;
[SerializeField, Tooltip("绝对:第二条记录的坐标当作方向矢量(起点→末端)。" +
"相对:它是第二个点,箭头=第一点指向第二点。**连续绘制打开时这一项不适用**")]
private XChartArrowVectorMode m_VectorMode = XChartArrowVectorMode.Absolute;
[SerializeField, Tooltip("方向从哪来(旧「相对/绝对」就是这里的前两项,存的值不用重设):" +
"相邻两条·下一条的坐标当方向 / 相邻两条·下一条是第二个点(首尾相接) / " +
"本条记录自带方向(0~2 是点、3~5 是方向) / 分段(偶数记录是点、奇数是方向)")]
[FormerlySerializedAs("m_VectorMode")]
private XChartArrowDirectionSource m_DirectionSource = XChartArrowDirectionSource.NextRecordAsVector;
[SerializeField, Tooltip("把每条记录的坐标按顺序连成一条路径(贝塞尔细分,接缝不断口)。" +
"打开之后「相对/绝对」被隐藏——连起来的是一条空间路径,谈不到这两者")]
@@ -165,6 +157,11 @@ namespace XericUI.XChart.Mesh
"只有连续绘制用得上")]
private float m_HeadPosition = 1f;
[SerializeField, Range(0f, 1f), Tooltip("头贴在矢量端点的哪一处:0=尾部落在点上(向前伸)、" +
"0.5=中心对点、1=头尖落在点上(默认)。" +
"头的长短还会按这条矢量的投影比例缩放,指向屏幕里就会缩没")]
private float m_MarkerAnchor = 1f;
[SerializeField, Range(2, 64), Tooltip("连续绘制时每段路径细分成几节(曲线渲染器的 tessellation)。" +
"越大越圆也越贵。只有连续绘制用得上")]
private int m_PathSegments = 12;
@@ -205,22 +202,28 @@ namespace XericUI.XChart.Mesh
/// <summary>
/// 这个元素要几个数值维才画得出来(面板据此报"表里只有几个",不再"什么都不显示")。
/// 坐标 3 +(可选)颜色 3;**不透明度那一维不算硬需求**(多给就多读、没给退回单色 alpha)——
/// <b>坐标那一半随方向来源变</b>:本条自带方向那档要 6 个(0~2 点、3~5 方向),其余三档 3 个;
/// 再加(可选)颜色 3。<b>不透明度那一维不算硬需求</b>(多给就多读、没给退回单色 alpha)——
/// 算进门槛的话,勾一下"有不透明度"会让整个元素因维数不够突然消失。
/// </summary>
public override int RequiredNumericDimensions
=> CoordinateDimensionCount + (m_UseColorDimensions ? ColorDimensionCount : 0);
/// <summary>一支箭头要两条记录 ⇒ 记录少于 2 条时一支都画不出来(面板/报表同样要印出来)</summary>
public override int RequiredRecordCount => 2;
=> XChartVectorFieldMath.RequiredCoordinateDimensions(m_DirectionSource)
+ (m_UseColorDimensions ? ColorDimensionCount : 0);
/// <summary>
/// 互斥显示:连续绘制打开时「相对/绝对」没有意义(他 2026-10-25:勾一个就把排斥的那几个藏起来)。
/// 一支箭头要几条记录:本条自带方向那档<b>一条就够</b>;
/// 相邻两条与"偶点奇向"那两档要两条(后者是同一支的两半,前者是重叠取)。
/// </summary>
public override int RequiredRecordCount
=> m_DirectionSource == XChartArrowDirectionSource.ThisRecordCarriesVector ? 1 : 2;
/// <summary>
/// 互斥显示:连续绘制打开时"方向从哪来"没有意义(他 2026-10-25:勾一个就把排斥的那几个藏起来)。
/// 判据只有一处,面板照着问,不在面板里写特例。
/// </summary>
public override bool IsFieldHidden(string fieldName)
{
if (fieldName == nameof(m_VectorMode)) return m_Continuous;
if (fieldName == nameof(m_DirectionSource)) return m_Continuous;
// 这两项是"路径上的箭头"才有的概念:一支一支画的时候头永远在末端
if (fieldName == nameof(m_HeadPosition) || fieldName == nameof(m_PathSegments)) return !m_Continuous;
if (fieldName == nameof(m_ColorDimension) || fieldName == nameof(m_HasAlphaDimension))
@@ -235,9 +238,10 @@ namespace XericUI.XChart.Mesh
if (!(tool is ChartToolVectorArrows arrows)) return;
arrows.CoordinateDimension = m_CoordinateDimension;
arrows.VectorMode = m_VectorMode;
arrows.DirectionSource = m_DirectionSource;
arrows.Continuous = m_Continuous;
arrows.HeadPosition = m_HeadPosition;
arrows.MarkerAnchor = m_MarkerAnchor;
arrows.PathSegments = m_PathSegments;
arrows.DirectionScale = m_DirectionScale;
arrows.MaxArrowCount = m_MaxArrowCount;