Files
XericUIActionVessel/Runtime/XChart/Mesh/ChartToolVectorArrows.cs
T
lrss3 4272406330 XChart P20b:132 个旋钮全部"设了就生效"——122 个自动置脏,10 个走各自的 Sync
外部数据驱动缺的那一半:工具的参数以前是裸自动属性,写进去值在、画面不动,
必须再记得叫一次 MarkDirty()(他 2026-10-26 的原话:"设置的同时,属性就会自动完成脏标记")。
现在 9 个工具里每一个可写属性的 setter 都自己送变化:

    public float Radius { get => m_Radius; set { m_Radius = value; MarkDirty(); } }

覆盖不是"改了我记得的那几个",是源码门数的(.ximage-gate/dirty_gate.py):
knobs=132 takesEffect=132 —— 122 支经 MarkDirty、10 支(散点外观)经 SyncShapeParams。
那 10 支是本轮门**查出来的**,不是我原本知道的:它们早已自带生效路径,
所以判据从"必须调 MarkDirty"改成"必须调到本文件里定义的 MarkDirty 或 Sync*/Push*/Apply*/Rebuild*"。
门另两条顺手立的判据:
- E 支:setter 靠 Sync 生效的,OnInitialize 里也必须有那一句——否则
  "if (IsInitialized) Sync()" 会把初始化之前的写全丢;
- D 支:工具自己不许在 setter 之外给自己的旋钮赋值——那会在渲染过程中把自己重新置脏、每帧重建。
  这一支第一轮报了 26 处"自赋值",全是渲染器属性的 { get; private set; }:那是只读投影不是旋钮,
  归进 views(14 个)后 0 处——真违规的一处没有(写了这条判据才知道有没有)。
  同轮另一处假红是判据把标识符里的字母当成了关键字:Offset 拼出来含 "set",
  于是只读的 Offset 被读成"有个从不调用置脏的 setter"⇒ 访问器判定改成词边界 \bset\b。
七支变异全红:M1 抹掉一个 setter 的 MarkDirty、M2 把 override 拿掉(CS0108 只是警告,
通过基类的调用从此静默失效)、M3 新增一个裸自动属性、M4 工具自赋值、M5 把一个工具从磁盘上挪走
(清单两侧都数)、M6 Sync 调用改成不存在的名字、M7 从 OnInitialize 里删掉那句 Sync。

自己的批量改写脚本先写错了一处,被门和编译门各抓一次:生成的字段行漏了等号
(private float m_Radius 0.22f;),121 个字段全中。修法是逐字节再走一遍
(.ximage-gate/knob_dirty_fix.py:判据是"这种形状的行了 0"而不是"看着差不多了")。
教训记进规范:批量改写后**先比"我说改了几处"与"实际几处合规"**,两侧都数。

ChartToolSpace 的 Rotation 初始化式跨两行,脚本按"同一行没闭合就拒绝整份"跳过了整个文件,
那 4 个旋钮手改——拒绝写比写一半好。

离线编译门(runtime + player + editor + 3 支对照):GATE PASSED,chain_p20b.txt rc=0。
mono 数学探针本轮不重跑:改的全是 MonoBehaviour 侧工具的 setter,纯算文件一个没动。
2026-10-26 09:02:13 +08:00

455 lines
23 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using System;
using System.Collections.Generic;
using UnityEngine;
using XericLibrary.Runtime.UIGraph;
using XericUI.Core;
using XericUI.XChart.Space;
namespace XericUI.XChart.Mesh
{
/// <summary>
/// 向量场 / 流形箭头元素。**数据口径(规范 §25.2,2026-10-25 他澄清后定稿)**:
/// <b>前三维=坐标 x/y/z</b>(与圆柱、散点同一套归一化),<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>:起点读第 i 条记录、终点读第 i+1 条 ⇒ 两支记录颜色不同时,
/// 杆与头**各显一色**。真正的"沿杆逐顶点渐变"要等渲染器支持逐顶点双色(P18)。</para>
///
/// <para><b>箭头是自己拼的,没有用库里的 ArrowShape</b>:那套箭头是给曲线的屏幕空间图元用的,
/// 而这里的箭头必须跟着立方体姿态走(投影后长短和方向都在变)。做法是只让空间负责两端的投影,
/// 杆和头都在<b>像素空间</b>里量出来:杆是一段等宽四边形,头是一个退化四边形(三角形),
/// 宽度恒定所以任何姿态下都不会塌成一条线。</para>
///
/// <para><b>数据只经过中转接口</b>:按维度下标 <see cref="IXChartDataSource.GetValueAt"/> 逐条取,
/// 不碰记录数组;支数由 <see cref="MaxArrowCount"/> 兜住,免得十万条记录一口气投影。</para>
/// </summary>
[AddComponentMenu(XericRegistrationPaths.Chart + "/Mesh/Vector Arrow Tool")]
public sealed class ChartToolVectorArrows : XChartToolBase
{
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 bool m_Continuous;
/// <summary>把每条记录的坐标按顺序连成折线(此时相对/绝对不适用)</summary>
public bool Continuous { get => m_Continuous; set { m_Continuous = value; MarkDirty(); } }
private float m_DirectionScale = 0.25f;
/// <summary>方向向量的长度倍率(立方体单位);相对模式下作用在差向量上</summary>
public float DirectionScale { get => m_DirectionScale; set { m_DirectionScale = value; MarkDirty(); } }
private int m_MaxArrowCount = 512;
/// <summary>最多画多少支(一支=相邻两条记录)</summary>
public int MaxArrowCount { get => m_MaxArrowCount; set { m_MaxArrowCount = value; MarkDirty(); } }
private XChartToolTransform m_Transform = XChartToolTransform.Identity;
/// <summary>箭头自己的变换(叠在图的空间之上)</summary>
public XChartToolTransform Transform { get => m_Transform; set { m_Transform = value; MarkDirty(); } }
// ── 颜色:可选的三到四个数值维 ────────────────────────────
private bool m_UseColorDimensions;
/// <summary>是否用额外的数值维给每支箭头上色</summary>
public bool UseColorDimensions { get => m_UseColorDimensions; set { m_UseColorDimensions = value; MarkDirty(); } }
private int m_ColorDimension = 3;
/// <summary>颜色维的起点(色相、饱和度、明度 [+不透明度])</summary>
public int ColorDimension { get => m_ColorDimension; set { m_ColorDimension = value; MarkDirty(); } }
private bool m_HasAlphaDimension;
/// <summary>是否多读一维不透明度</summary>
public bool HasAlphaDimension { get => m_HasAlphaDimension; set { m_HasAlphaDimension = value; MarkDirty(); } }
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;
public float ShaftWidth { get => m_ShaftWidth; set { m_ShaftWidth = value; MarkDirty(); } }
private float m_HeadLength = 10f;
public float HeadLength { get => m_HeadLength; set { m_HeadLength = value; MarkDirty(); } }
private float m_HeadWidth = 7f;
public float HeadWidth { get => m_HeadWidth; set { m_HeadWidth = value; MarkDirty(); } }
private bool m_ShowZeroVectorsAsDots;
/// <summary>方向为零向量时什么都不画;给个数就画成一个点</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)。
/// </summary>
public UICurveRenderer CurveRenderer { get; private set; }
private float m_HeadPosition = 1f;
/// <summary>
/// 连续绘制时<b>画到路径的哪个位置</b>(0=起点、1=整条,默认 1):
/// 箭头就放在这一处,路径在这一点被剪断(剪口之后不画)——
/// 不剪的话路径会从箭头底下穿出去,看着像"箭头朝里长"。
/// </summary>
public float HeadPosition { get => m_HeadPosition; set { m_HeadPosition = 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);
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];
private int m_CurveEntries;
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;
private int m_RecordsHave;
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>
/// 这个元素要几个数值维:坐标 3 +(可选)颜色 3。
/// <b>不透明度那一维不算硬需求</b>:多给就多读、没给退回单色 alpha——
/// 把它算进门槛的话,勾一下"有不透明度"会让整个元素突然一条都不画,
/// 那是把这一个开关变成了总闸。
/// </summary>
public int RequiredDimensionCount
=> XChartArrowConfig.CoordinateDimensionCount + (UseColorDimensions ? XChartArrowConfig.ColorDimensionCount : 0);
/// <summary>一支箭头要两条记录</summary>
public int RequiredRecordCount => 2;
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");
if (CurveRenderer != null)
{
CurveRenderer.autoRebuild = false;
var rect = CurveRenderer.rectTransform;
rect.anchorMin = Vector2.zero;
rect.anchorMax = Vector2.one;
rect.offsetMin = Vector2.zero;
rect.offsetMax = Vector2.zero;
}
SetVisible(true);
}
public override void OnRender()
{
base.OnRender();
if (FillRenderer == null) return;
// 曲线渲染器不在位也要出图(退回直线段),所以它不是"能不能画"的前提
var space = Context?.Space;
if (space == null) return;
long dataVersion = Data != null ? Data.Version : -1;
if (!m_Dirty && space.ProjectionVersion == m_LastSpaceVersion && dataVersion == m_LastDataVersion)
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();
}
private void BuildFaces(ChartToolSpace space)
{
m_Faces.Clear();
m_ArrowsBuilt = 0;
m_DimensionsHave = 0;
m_RecordsHave = 0;
m_DimensionsNeed = RequiredDimensionCount;
m_CurveEntries = 0;
m_PathRenderer = Continuous ? (CurveRenderer != null ? "curve" : "fill") : "-";
var source = Data;
if (source == null || !source.HasData) return;
m_DimensionsHave = source.NumericDimensionCount;
m_RecordsHave = source.RecordCount;
// 形状不够就一支都不画(现象是"加了工具但什么都没显示")——需求与实际几个数都留在报表里,
// 面板也印同一对(规范 §25.1)
if (m_DimensionsHave < CoordinateDimension + RequiredDimensionCount) return;
if (m_RecordsHave < RequiredRecordCount) return;
// 一支箭头=相邻两条记录 ⇒ 支数由纯算术算(离线钉着:记录不够 vs 维数不够要分得清)
int limit = XChartVectorFieldMath.ArrowCount(m_RecordsHave, MaxArrowCount);
if (Continuous)
{
BuildContinuous(source, space, limit);
m_Faces.Sort(s_FarToNear);
return;
}
for (int i = 0; i < limit; i++)
{
Vector3 first = ReadPoint(source, i);
Vector3 second = ReadPoint(source, i + 1);
// 两种读法的算式在纯算术里(离线钉着):绝对=第二条的坐标就是方向;相对=它是第二个点
Vector3 tip = XChartVectorFieldMath.Tip(VectorMode, first, second, DirectionScale);
if (AddArrow(space, first, tip, 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> 会说出来。
/// </summary>
private void BuildContinuous(IXChartDataSource source, ChartToolSpace space, int limit)
{
m_Pixels.Clear();
for (int i = 0; i <= limit; i++)
m_Pixels.Add(space.Project(ReadPoint(source, i), m_Composed));
int segments = m_Pixels.Count - 1;
if (segments < 1) return;
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++)
{
BuildSegmentBezier(s);
Vector2[] drawn = m_Bezier;
if (s == headSegment && headT < 1f)
{
XChartArrowPathMath.Split(m_Bezier, headT, m_Left, m_Right);
drawn = m_Left;
}
AddPathSegment(drawn, ColorAt(source, s), ColorAt(source, s + 1));
cut = XChartArrowPathMath.Evaluate(drawn, 1f);
cutTangent = XChartArrowPathMath.Tangent(drawn, 1f);
if (s == headSegment) break;
}
AddHeadAt(cut, cutTangent, ColorAt(source, Mathf.Min(headSegment + 1, m_RecordsHave - 1)));
m_ArrowsBuilt = headSegment + 1;
}
/// <summary>段 s(点 s → 点 s+1)的贝塞尔控制点。端点之外重复端点:端点处切线指向段内。</summary>
private void BuildSegmentBezier(int s)
{
int last = m_Pixels.Count - 1;
XChartArrowPathMath.CatmullRomToBezier(
m_Pixels[s > 0 ? s - 1 : 0], m_Pixels[s], m_Pixels[s + 1],
m_Pixels[s + 2 <= last ? s + 2 : last], m_Bezier);
}
private void AddPathSegment(Vector2[] bezier, Color fromColor, Color toColor)
{
if (CurveRenderer != null)
{
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++;
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,
});
}
/// <summary>箭头放在剪口上,方向顺那一点的<b>切线</b>(不是两端连线——弯处会歪)。</summary>
private void AddHeadAt(Vector2 tip, Vector2 tangent, Color color)
{
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 });
}
/// <summary>
/// 一支箭头 = 杆(用起点色)+(可选)头(用终点色)。
/// <b>两端各显一色</b>是颜色维"随记录自带"的直接结果;真正的沿杆渐变要等渲染器支持逐顶点双色(P18)。
/// </summary>
private bool AddArrow(ChartToolSpace space, Vector3 origin, Vector3 tip, Color startColor, Color endColor,
bool withHead = true)
{
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))
{
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;
}
private Vector3 ReadPoint(IXChartDataSource source, int record)
{
return new Vector3(
(float)source.GetValueAt(record, CoordinateDimension),
(float)source.GetValueAt(record, CoordinateDimension + 1),
(float)source.GetValueAt(record, CoordinateDimension + 2));
}
/// <summary>
/// 这一条记录的颜色:没开颜色维就是单色;开了就按
/// <c>[色相(0..256 色环), 饱和度(0..1), 明度(0..1), (不透明度 0..1)]</c> 读。
/// <b>读不成(维不够或值不是有限数)就退回单色</b>——不是画成黑:黑在深色背景上等于没画,
/// 而"退回了单色"这件事在报表的 <c>colors=</c> 读数里看得见。
/// </summary>
private Color ColorAt(IXChartDataSource source, int record)
{
if (!UseColorDimensions) return ArrowColor;
if (source.NumericDimensionCount < ColorDimension + XChartArrowConfig.ColorDimensionCount) return ArrowColor;
float hue = (float)source.GetValueAt(record, ColorDimension);
float saturation = (float)source.GetValueAt(record, ColorDimension + 1);
float value = (float)source.GetValueAt(record, ColorDimension + 2);
float alpha = HasAlphaDimension
? (float)source.GetValueAt(record, ColorDimension + 3)
: ArrowColor.a;
Color color;
return XChartVectorFieldMath.TryColor(hue, saturation, value, alpha, out color) ? color : ArrowColor;
}
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)。
/// </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)
.Append(" arrows=").Append(m_ArrowsBuilt)
.Append(" mode=").Append(Continuous ? "continuous" : (VectorMode == XChartArrowVectorMode.Relative ? "relative" : "absolute"))
.Append(" colors=").Append(UseColorDimensions ? (HasAlphaDimension ? "hsv+a" : "hsv") : "single")
.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);
}
#endif
}
}