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
+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)。" +