XChart 图表框架落地(P0–P17):格线单一作者、面板一行状态、矢量场

此前整个 XChart 特性一直没有提交(分期 P0–P12 的代码与素材都还在工作区里)。这一批一并入库,
并含本轮 P13–P17 的改动(规范 Documentation/XChart-RenderFramework.md 新增 §22–§25):

- P13:格线只剩一个作者——线框工具不再有"画格线 / 发布格线插槽"的代码路径;BG Cube Grid(原 MeshBg)
  是唯一作者,且"画上去的线=发布给轴线的那份比例数组";插槽板新增 Unpublish(说得出"这里不再有线",
  否则掩码筛掉的面会把上一轮的值留着被消费者吸走);渲染参数搬进元素表
  (DeclareDefaultElements / AddDefaultElement + XChartElementTable 按类型去重,只在第一次读到表时补);
  图上「立方体外观」那组字段删除、公共属性转发到元素表;面板逐行点名脚本注册的工具。
- P14 / P15:数据窗口文案收敛(行末 `-`、标题 `X [0]`、长说明退回 tooltip、范围页三行不再被压扁);
  元素块收成一行状态 `▼ 名称 √ R… D… [↑][↓][-]`;**注册序由类型定死、只显示不给输入控件,
  绘制序与元素在表里的位置绑定**(§24.5,他 2026-10-25 澄清);默认元素让删也让关;
  EnsureSpace 改成每次重建后都跑(删掉"空间"不再等于整张图空掉)。
- P17:矢量场——维数不够时不再静默不画(元素配置报需求,面板与报表同时印"需求/现有");
  相对/绝对两种读法收进纯算术 XChartVectorFieldMath;连续绘制(互斥显示把"相对/绝对"藏起来);
  颜色维(色相走 0..256 色环,饱和/明度/不透明 0..1,不透明度不算硬需求);新增螺旋矢量场测试数据。
  数据口径按他澄清修正为:前三维=坐标、一支箭头=相邻两条记录、第 4~7 维是颜色(§25、CHANGELOG 修正行)。

判据:编译门三臂 + 3 支对照绿;离线探针 436 项 0 失败;p4_control 55 支臂各红在自己点名的断言上;
p2_control / pool_family / generator_gate / hierarchy_gate 在同一棵交付树上复跑。
(证据脚本与日志在包外的 .ximage-gate/,未入本仓库。)
This commit is contained in:
2026-10-25 20:21:28 +08:00
parent 216d157472
commit c51ab7a3c8
105 changed files with 13062 additions and 812 deletions
+522
View File
@@ -0,0 +1,522 @@
using System.Collections.Generic;
using TMPro;
using UnityEngine;
using XericLibrary.Runtime.UIGraph;
using XericUI.Core;
using XericUI.XChart.Mesh;
using XericUI.XChart.Space;
namespace XericUI.XChart.Axis
{
/// <summary>轴在宿主面上沿哪个面参数方向走</summary>
public enum XChartAxisDirection { AlongS = 0, AlongT = 1 }
/// <summary>刻度标签的内容来源</summary>
public enum XChartAxisLabelSource
{
/// <summary>数据直驱:每个主刻度写它的数值(格式串可覆盖,留空走自适应)</summary>
TickValue = 0,
/// <summary>维度标签:只写一次该维的显示名,挂在轴末端</summary>
DimensionLabel = 1,
/// <summary>自定义:用 <see cref="ChartToolAxis.CustomLabels"/> 按刻度顺序填</summary>
Custom = 2,
}
/// <summary>
/// 轴线元素:在立方体某个面的参数域里画一条轴 + 主/次刻度 + TMP 标签。
///
/// <para><b>它完全住在面帧里</b>:宿主面(<see cref="Face"/>)+ 面内方向(<see cref="Direction"/>)
/// + 该方向上的起止比例(<see cref="StartRatio"/>..
/// <see cref="EndRatio"/>)+ 垂直方向上的位置(<see cref="CrossRatio"/>)。
/// 这些参数经 <see cref="XChartFaceFrame"/> 变成像素,所以轴和背景/散点天然共形变——
/// 转立方体、换视角都不用重新对坐标。</para>
///
/// <para><b>空间类型</b>:<see cref="Scale"/> 决定"值 ↔ 轴上参数"的映射(线性 / 对数 / 指数),
/// 刻度值由 <see cref="XChartAxisMath"/> 生成(对数按数量级铺 1/2/5,线性/指数按 nice-step 铺)。
/// 次刻度在<b>参数</b>域里等分,所以在对数/指数轴上分出来的是几何级数。</para>
///
/// <para><b>标签三源</b>:<see cref="XChartAxisLabelSource"/> —— 数值直驱(带格式串入口)、
/// 维度显示名、自定义字符串数组。</para>
/// </summary>
[AddComponentMenu(XericRegistrationPaths.Chart + "/Axis/Axis Tool")]
public sealed class ChartToolAxis : XChartToolBase
{
// ── 宿主与走向 ────────────────────────────────────────────
/// <summary>
/// 宿主面用**插槽 id** 指定(规范 §11.2):默认取定义网格发布的 <c>mesh.face.&lt;面号&gt;</c>。
/// 不再认"第几个面"——拿到的是点,所以异形网格只要发布同 id 的插槽就能用。
/// </summary>
public string SlotId { get; set; } = XChartCubeGeometry.FaceSlotId(XChartCubeGeometry.CubeFace.Bottom);
/// <summary>
/// 对齐格线(P9):开启后每条主刻度的位置会<b>吸附到网格发布的那组线上</b>
/// (轴沿 S 走读 <c>grid.T</c>、沿 T 走读 <c>grid.S</c>),偏移超过"相邻两条线间距的一半"
/// 就不吸。网格是定义方,这里只是跟随。
/// </summary>
public bool AlignToGrid { get; set; }
public XChartAxisDirection Direction { get; set; } = XChartAxisDirection.AlongS;
public float StartRatio { get; set; }
public float EndRatio { get; set; } = 1f;
public float CrossRatio { get; set; }
public XChartToolTransform Transform { get; set; } = XChartToolTransform.Identity;
// ── 值域与刻度 ────────────────────────────────────────────
/// <summary>
/// 轴读哪一维——这是<b>绑定</b>(这条轴画的是哪一路数据),不是范围。
/// 范围与"这一维现在有没有数据"归 chart 的数据板块(每个维度一行),
/// 工具只呈现(规范 §1)。
/// </summary>
public int Dimension { get; set; }
public XChartAxisScale Scale { get; set; } = XChartAxisScale.Linear;
public double ExponentialStrength { get; set; } = 2.0;
public bool AutoStep { get; set; } = true;
public double ManualStep { get; set; } = 1.0;
public int TargetMajorCount { get; set; } = 5;
public int MinorTickCount { get; set; } = 4;
// ── 外观 ──────────────────────────────────────────────────
public Color LineColor { get; set; } = new Color(0.85f, 0.88f, 0.95f, 0.9f);
public float LineThickness { get; set; } = 2f;
public float MajorTickLength { get; set; } = 8f;
public float MinorTickLength { get; set; } = 4f;
public float TickThickness { get; set; } = 1.5f;
/// <summary>刻度朝哪边:+1 朝面参数增大方向,-1 朝减小方向</summary>
public float TickSide { get; set; } = -1f;
// ── 标签 ──────────────────────────────────────────────────
public XChartAxisLabelSource LabelSource { get; set; } = XChartAxisLabelSource.TickValue;
/// <summary>数值格式化串(如 "0.00" 或 "0.#");留空走自适应</summary>
public string LabelFormat { get; set; }
public string[] CustomLabels { get; set; }
public float LabelGap { get; set; } = 6f;
public float LabelFontSize { get; set; } = 14f;
public Color LabelColor { get; set; } = new Color(0.85f, 0.88f, 0.95f, 0.95f);
public Vector2 LabelSize { get; set; } = new Vector2(90f, 24f);
/// <summary>标签跟着轴的方向转(斜面上读起来才不拧着)</summary>
public bool RotateLabelsWithAxis { get; set; } = true;
// ── 内部 ──────────────────────────────────────────────────
public UILineRendererV2 LineRenderer { get; private set; }
private readonly List<double> m_Majors = new List<double>();
private readonly List<double> m_Minors = new List<double>();
private readonly XChartFaceFrame[] m_FaceFrames = new XChartFaceFrame[XChartCubeGeometry.FaceCount];
private Matrix4x4 m_Composed = Matrix4x4.identity;
private int m_LastSpaceVersion = -1;
/// <summary>这一帧的面帧是从插槽拿的还是自己从立方几何推的(报表用)</summary>
private string m_FrameSource = "cube";
/// <summary>对齐格线的读数(报表用):off / grid(n/m, snapMax=…) / no-slot / unknown-face</summary>
private string m_AlignNote = "off";
private int m_AlignSnapped;
private int m_AlignTotal;
private float m_AlignMaxSnap;
private float[] m_GridRatios = new float[64];
/// <summary>
/// 把刻度<b>吸附到网格发布的线上</b>(P9 的"跟随"那一半):网格是定义方,这里只读它的线。
/// 轴沿 S 走 ⇒ 刻度落在<b>等 s 线</b>上,而等 s 线发布在 <c>grid.T</c>;沿 T 走读 <c>grid.S</c>。
/// 取不到槽(没网格元素 / 网格没发布 / 手填的 id 不是 <c>mesh.face.&lt;n&gt;</c>)就不吸,
/// 并把原因记进 <see cref="m_AlignNote"/>——"没吸上"和"没开对齐"在画面上一样,只有读数分得清。
/// </summary>
private bool TrySnapParameterToGrid(bool alongS, float parameter, out float snapped)
{
snapped = parameter;
var board = Context?.Slots;
if (board == null) { m_AlignNote = "no-board"; return false; }
int faceIndex = FaceIndexFromSlotId(SlotId);
if (faceIndex < 0 || faceIndex >= XChartCubeGeometry.FaceCount) { m_AlignNote = "unknown-face"; return false; }
var face = (XChartCubeGeometry.CubeFace)faceIndex;
XChartSlotView view;
if (!board.TryRead(SlotId + (alongS ? ".grid.T" : ".grid.S"), out view)) { m_AlignNote = "no-slot"; return false; }
int count = Mathf.Min(view.GroupCount, m_GridRatios.Length);
int written = 0;
for (int i = 0; i < count; i++)
{
Vector3 from, to;
if (!view.TryGetLine(i, out from, out to)) continue;
// 线是"等某个参数"的一条:沿 S 走的那组(grid.T)等的是 s,沿线两个端点的 s 相同;
// grid.S 那组等的是 t。取第一个端点反解即可(面基是单位正交的)。
XChartCubeGeometry.GetFaceParameter(face, from, out float lineS, out float lineT);
m_GridRatios[written++] = alongS ? lineS : lineT;
}
if (written == 0) { m_AlignNote = "no-lines"; return false; }
// 吸附上限 = 相邻两条线最小间距的一半:宁可不对齐,也不把刻度扭到老远的地方
float smallest = float.MaxValue;
for (int i = 1; i < written; i++)
{
float gap = Mathf.Abs(m_GridRatios[i] - m_GridRatios[i - 1]);
if (gap > 1e-6f && gap < smallest) smallest = gap;
}
float maxDistance = smallest < float.MaxValue ? smallest * 0.5f : 1f;
bool snappedOk = XChartGridLines.TrySnapToGrid(m_GridRatios, written, parameter, maxDistance, out snapped);
m_AlignTotal++;
if (snappedOk)
{
m_AlignSnapped++;
m_AlignMaxSnap = Mathf.Max(m_AlignMaxSnap, Mathf.Abs(snapped - parameter));
}
m_AlignNote = "grid(" + m_AlignSnapped + "/" + m_AlignTotal + ", snapMax=" + m_AlignMaxSnap.ToString("0.####") + ")";
return snappedOk;
}
private long m_LastDataVersion = -1;
// 两段脏:刻度要等一次池调度才发落到位,所以"算需求"和"落笔"分开判脏
private bool m_RangeDirty = true;
private bool m_GeometryDirty = true;
private bool m_HasRange;
private double m_RangeMin = 0.0;
private double m_RangeMax = 1.0;
private double m_RangeStep = 1.0;
public void MarkDirty()
{
m_RangeDirty = true;
m_GeometryDirty = true;
}
protected override void OnInitialize()
{
LineRenderer = CreateChildComponent<UILineRendererV2>("AxisLines");
if (LineRenderer != null)
{
LineRenderer.defaultColor = LineColor;
LineRenderer.defaultThickness = LineThickness;
Stretch(LineRenderer.rectTransform);
}
MarkDirty();
SetVisible(true);
}
private static void Stretch(RectTransform rect)
{
rect.anchorMin = Vector2.zero;
rect.anchorMax = Vector2.one;
rect.offsetMin = Vector2.zero;
rect.offsetMax = Vector2.zero;
}
/// <summary>
/// 数据侧:算范围、铺刻度、<b>申请这一帧要的标签数</b>(申请只置脏,件在随后的池调度里发落)。
/// 放在这里而不是 OnRender,是为了让"申请→发落→落笔"在同一片帧内闭合。
/// </summary>
public override void OnUpdate()
{
base.OnUpdate();
if (Context == null) return;
long dataVersion = Data != null ? Data.Version : -1;
// 还欠着槽位时也重新走一遍:件是下一轮调度才补齐的,别把补齐的机会等成"数据变了才有"
if (!m_RangeDirty && dataVersion == m_LastDataVersion && !TextSlotsPending) return;
m_RangeDirty = false;
m_LastDataVersion = dataVersion;
m_GeometryDirty = true;
m_Majors.Clear();
double min, max, step;
if (!ResolveRange(out min, out max, out step))
{
m_HasRange = false;
RequestTextSlots(0);
return;
}
m_HasRange = true;
m_RangeMin = min;
m_RangeMax = max;
m_RangeStep = step;
XChartAxisMath.BuildTicks(min, max, Scale, ManualStep, TargetMajorCount, AutoStep, m_Majors);
RequestTextSlots(LabelSource == XChartAxisLabelSource.DimensionLabel ? 1 : m_Majors.Count);
}
/// <summary>
/// 面帧从**定义网格发布的插槽**里取(规范 §11.2):网格是定义者,其余工具跟随——
/// 消费者拿到的是四个点,不是"第几个面",所以换成异形网格也不用改这里。
/// 取不到就回落到老路径(自己从立方几何推),并把**走的是哪条**印进报表(`frame=`):
/// 两条路画出来一样时更要印,否则"跟随网格"这句话没有生产者。
/// </summary>
private XChartFaceFrame ResolveFaceFrame(ChartToolSpace space)
{
m_FrameSource = "cube";
IXChartSlotBoard board = Context?.Slots;
XChartSlotView slot;
if (board != null && board.TryRead(SlotId, out slot)
&& slot.Mode == XChartSlotMode.Quad3D)
{
Vector3 c00, c01, c11, c10;
if (slot.TryGetQuad(0, out c00, out c01, out c11, out c10))
{
XChartFaceFrame fromSlot = XChartFaceFrame.FromCorners(
space.Project(c00, m_Composed), space.Project(c01, m_Composed),
space.Project(c11, m_Composed), space.Project(c10, m_Composed));
if (fromSlot.IsValid)
{
m_FrameSource = "slot";
return fromSlot;
}
}
}
// 回落:把同一个 id 按立方体自己的语义解释成面号("mesh.face.3" -> 第 3 面);
// 解释不出来的 id 就没有回落可用,返回无效帧、由调用方清空并把 frame= 印出来。
int faceIndex = FaceIndexFromSlotId(SlotId);
space.BuildFaceFrames(m_FaceFrames, m_Composed);
return faceIndex >= 0 && faceIndex < XChartCubeGeometry.FaceCount
? m_FaceFrames[faceIndex]
: default(XChartFaceFrame);
}
/// <summary>回落用:从 <c>mesh.face.&lt;n&gt;</c> 里读面号;不是这个形状就返回 -1</summary>
public static int FaceIndexFromSlotId(string slotId)
{
if (string.IsNullOrEmpty(slotId) || !slotId.StartsWith(XChartCubeGeometry.FaceSlotPrefix)) return -1;
int index;
return int.TryParse(slotId.Substring(XChartCubeGeometry.FaceSlotPrefix.Length), out index) ? index : -1;
}
/// <summary>几何侧:面帧、线、刻度、标签。空间版本变了必须重画(转立方体时标签要跟着走)</summary>
public override void OnRender()
{
base.OnRender();
if (LineRenderer == null) return;
var space = Context?.Space;
if (space == null) return;
if (!m_GeometryDirty && space.ProjectionVersion == m_LastSpaceVersion) return;
m_LastSpaceVersion = space.ProjectionVersion;
if (!m_HasRange)
{
LineRenderer.ClearAll();
m_GeometryDirty = false;
return;
}
m_Composed = space.Compose(Transform);
XChartFaceFrame frame = ResolveFaceFrame(space);
if (!frame.IsValid || m_Majors.Count == 0)
{
LineRenderer.ClearAll();
m_GeometryDirty = false;
return;
}
DrawAxis(frame);
}
/// <summary>
/// 轴的范围只问上下文要(手动优先、否则该维聚合,规则在 <see cref="XChartDomainMath"/>)。
/// 对数轴不能跨 0:贴 0 取一个下界,其余照手动/聚合优先级。
/// </summary>
private bool ResolveRange(out double min, out double max, out double step)
{
min = 0.0; max = 1.0; step = 1.0;
var context = Context;
if (context == null || !context.TryResolveDomain(Dimension, out min, out max))
return false;
if (Scale == XChartAxisScale.Logarithmic && min <= 0.0)
min = max > 0.0 ? max * 1e-3 : 1e-6;
step = AutoStep ? XChartAxisMath.NiceStep(max - min, TargetMajorCount) : ManualStep;
return max > min;
}
private void DrawAxis(XChartFaceFrame frame)
{
double min = m_RangeMin;
double max = m_RangeMax;
double step = m_RangeStep;
// 对齐格线的读数每帧重算("吸上几条/最大挪了多少"要跟着这一帧说话)
m_AlignSnapped = 0;
m_AlignTotal = 0;
m_AlignMaxSnap = 0f;
m_AlignNote = AlignToGrid ? "grid(none)" : "off";
LineRenderer.ClearAll();
bool alongS = Direction == XChartAxisDirection.AlongS;
float span = Mathf.Clamp01(EndRatio) - Mathf.Clamp01(StartRatio);
if (span <= 1e-4f) return;
// 轴线上一点 + 面内垂直方向的"每单位像素"向量,刻度长度因此不受面大小影响
Vector2 probe = alongS ? frame.Map(0.5f, CrossRatio) : frame.Map(CrossRatio, 0.5f);
Vector2 probe2 = alongS ? frame.Map(0.5f, CrossRatio + 0.02f) : frame.Map(CrossRatio + 0.02f, 0.5f);
Vector2 cross = probe2 - probe;
float crossLength = cross.magnitude;
if (crossLength <= 1e-4f) return;
Vector2 crossUnit = cross / crossLength * TickSide;
Vector2 axisFrom = PointAt(frame, alongS, Mathf.Clamp01(StartRatio));
Vector2 axisTo = PointAt(frame, alongS, Mathf.Clamp01(StartRatio + span));
// 轴在屏幕上的走向 = 标签该转的角度(绕自身 Z,UI 平面内旋转)
float axisAngle = RotateLabelsWithAxis
? Mathf.Atan2(axisTo.y - axisFrom.y, axisTo.x - axisFrom.x) * Mathf.Rad2Deg
: 0f;
LineRenderer.DrawLine(axisFrom, axisTo, LineColor, LineThickness);
// 标签一律来自池(基类申请、chart 发落):这里只读,不创建、不扩表。
// 件还没补齐时只少画标签,轴线和刻度照旧——不 NRE,也不留上一次的残字。
int needed = LabelSource == XChartAxisLabelSource.DimensionLabel ? 1 : m_Majors.Count;
var labels = Texts;
for (int i = 0; i < m_Majors.Count; i++)
{
double value = m_Majors[i];
float ratio = Mathf.Clamp01((float)XChartAxisMath.ToParameter(value, min, max, Scale, ExponentialStrength));
float s = Mathf.Clamp01(StartRatio) + span * ratio;
// 对齐格线:在**面参数**上吸附(格线发布的就是面参数位置),再折回轴上的比例,
// 这样"刻度落在格线上"是几何意义,不是数值凑上去
if (AlignToGrid && TrySnapParameterToGrid(alongS, s, out float snappedS))
{
s = snappedS;
float begin = Mathf.Clamp01(StartRatio);
if (span > 1e-6f) ratio = Mathf.Clamp01((s - begin) / span);
}
Vector2 anchor = PointAt(frame, alongS, s);
Vector2 tip = anchor + crossUnit * MajorTickLength;
LineRenderer.DrawLine(anchor, tip, LineColor, TickThickness);
if (MinorTickCount > 1 && i + 1 < m_Majors.Count)
{
m_Minors.Clear();
XChartAxisMath.BuildMinorTicks(m_Majors[i], m_Majors[i + 1], MinorTickCount,
min, max, Scale, ExponentialStrength, m_Minors);
for (int m = 0; m < m_Minors.Count; m++)
{
float mr = Mathf.Clamp01((float)XChartAxisMath.ToParameter(m_Minors[m], min, max, Scale, ExponentialStrength));
Vector2 mAnchor = PointAt(frame, alongS, Mathf.Clamp01(StartRatio) + span * mr);
LineRenderer.DrawLine(mAnchor, mAnchor + crossUnit * MinorTickLength, LineColor, TickThickness);
}
}
if (i < labels.Count) WriteLabel(labels[i], anchor + crossUnit * (MajorTickLength + LabelGap),
LabelTextFor(i, value, step, min, max), axisAngle);
}
if (LabelSource == XChartAxisLabelSource.DimensionLabel && labels.Count > 0)
{
Vector2 end = PointAt(frame, alongS, Mathf.Clamp01(StartRatio + span));
WriteLabel(labels[0], end + crossUnit * (MajorTickLength + LabelGap), DimensionLabel(), axisAngle);
}
// 没用上的槽位必须擦干净,否则上一次多出来的刻度标签会留在原地
int used = Mathf.Min(needed, labels.Count);
for (int i = used; i < labels.Count; i++)
if (labels[i] != null) labels[i].text = string.Empty;
// 件没补齐就继续脏着:下一次池调度补齐后重画一遍
m_GeometryDirty = labels.Count < needed;
}
/// <summary>把"沿轴比例"换成像素点;垂直位置固定在 <see cref="CrossRatio"/></summary>
private Vector2 PointAt(XChartFaceFrame frame, bool alongS, float s)
=> alongS ? frame.Map(s, CrossRatio) : frame.Map(CrossRatio, s);
private void WriteLabel(TMP_Text label, Vector2 local, string text, float axisAngleDegrees)
{
if (label == null) return;
label.text = text;
label.fontSize = LabelFontSize;
label.color = LabelColor;
label.rectTransform.sizeDelta = LabelSize;
label.rectTransform.anchoredPosition = local;
label.rectTransform.localEulerAngles = new Vector3(0f, 0f, axisAngleDegrees);
}
private string LabelTextFor(int index, double value, double step, double min, double max)
{
switch (LabelSource)
{
case XChartAxisLabelSource.Custom:
return CustomLabels != null && index < CustomLabels.Length ? CustomLabels[index] : string.Empty;
case XChartAxisLabelSource.DimensionLabel:
return DimensionLabel();
default:
return XChartAxisMath.FormatValue(value, LabelFormat, step);
}
}
private string DimensionLabel()
{
XChartDimensionDefinition definition;
if (Data != null && Data.TryGetDimension(Dimension, out definition))
return definition.DisplayName;
return "dim " + Dimension;
}
#if UNITY_EDITOR
/// <summary>
/// 这一帧的范围是从哪来的:<c>override</c>=chart 那一维的维度行填了覆盖、<c>aggregate</c>=
/// 用该维聚合、<c>none</c>=两边都没有(于是整条轴不画)。报表靠它证明"范围归数据行"。
/// 判据取<b>本帧的结果</b>(<see cref="m_HasRange"/>),不重新问一遍聚合——空模型下
/// "聚合存在"是真的、值是 NaN,照那样问会印出 aggregate,那是在骗读报表的人。
/// </summary>
private string RangeSourceForDebug()
{
if (!m_HasRange) return "none";
var data = Data;
XChartDimensionDefinition definition;
if (data != null && data.TryGetDimension(Dimension, out definition) && definition != null)
{
var over = definition.DomainOverride;
if (over.HasMin || over.HasMax)
return "override[" + (over.HasMin ? over.Min.ToString("0.###") : "auto")
+ ".." + (over.HasMax ? over.Max.ToString("0.###") : "auto") + "]";
}
return "aggregate";
}
internal override void AppendDebugLine(System.Text.StringBuilder sb)
{
base.AppendDebugLine(sb);
sb.Append(" hasRange=").Append(m_HasRange)
.Append(" range=[").Append(m_RangeMin.ToString("0.###")).Append(',').Append(m_RangeMax.ToString("0.###")).Append(']')
.Append(" rangeSource=").Append(RangeSourceForDebug())
// 工具**自己持有的**起止比例:面板写进配置的值有没有真的到工具身上,看这一对就分得清
.Append(" span=").Append(StartRatio.ToString("0.###")).Append("..").Append(EndRatio.ToString("0.###"))
.Append(" majors=").Append(m_Majors.Count)
.Append(" slot=").Append(SlotId).Append(" dir=").Append(Direction).Append(" dim=").Append(Dimension)
.Append(" want=").Append(RequestedTextCount)
.Append(" have=").Append(Texts.Count)
.Append(" pending=").Append(TextSlotsPending)
.Append(" geoDirty=").Append(m_GeometryDirty)
.Append(" lines=").Append(LineRenderer == null ? "NULL" : "ok")
.Append(" wireVerts=").Append(LineRenderer != null ? LineRenderer.LiveVertexCount : 0)
.Append(" frame=").Append(m_FrameSource)
// 对齐格线的读数:"没吸上"和"没开对齐"在画面上一样,只有这一行分得清
.Append(" align=").Append(m_AlignNote);
}
#endif
protected override void OnDispose()
{
LineRenderer = null;
m_Majors.Clear();
m_Minors.Clear();
}
}
}
+11
View File
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 8ae98c37a332aee4abdf1e2e7a11da67
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+137
View File
@@ -0,0 +1,137 @@
using System;
using UnityEngine;
using XericUI.XChart.Mesh;
using XericUI.XChart.Space;
namespace XericUI.XChart.Axis
{
/// <summary>
/// 轴线元素的配置。一条轴 = <b>宿主面 + 面内方向 + 子区间 + 空间类型 + 刻度 + 标签来源</b>,
/// 全部走同一套面帧协议,所以它和背景/散点必然共形变(口径见 <see cref="XChartFaceFrame"/>)。
///
/// <para>要三条轴就在面板里加三个这个元素,各自选自己的面和维度——
/// 图表不必为"X 轴 / Y 轴 / Z 轴"写任何专用字段。</para>
/// </summary>
[Serializable]
[XChartElement("axis", "轴线", 20)]
public sealed class XChartAxisConfig : XChartElementConfig
{
[Header("宿主")]
[SerializeField, Tooltip("轴画在哪个面上:填插槽 id(默认 mesh.face.<面号>,由定义网格的元素发布;面号 = 0前 1后 2右 3左 4上 5下,语义同 XChartCubeFaceMask)")]
private string m_SlotId = "mesh.face.5";
[SerializeField, Tooltip("对齐格线:开启后每条主刻度会吸附到网格发布的那组线上(网格是定义方,轴只跟随);偏移超过相邻两线间距的一半就不吸")]
private bool m_AlignToGrid;
[SerializeField, Tooltip("沿面参数 s 还是 t 走")]
private XChartAxisDirection m_Direction = XChartAxisDirection.AlongS;
[SerializeField, Range(0f, 1f), Tooltip("轴在该方向上的起点比例。默认 0=从面的边开始;要和网格格线对齐就得铺满整面")]
private float m_StartRatio;
[SerializeField, Range(0f, 1f), Tooltip("轴在该方向上的终点比例。默认 1=到对面边;内缩成 0.95 这种值,两头的刻度就再也对不上格线")]
private float m_EndRatio = 1f;
[SerializeField, Range(0f, 1f), Tooltip("轴在垂直方向上的位置(0=贴这条边的起点侧)")]
private float m_CrossRatio;
[SerializeField, Tooltip("轴自己的变换(叠在图的空间之上)")]
private XChartToolTransform m_Transform = XChartToolTransform.Identity;
[Header("值域与刻度")]
[SerializeField, Tooltip("轴读哪一维(绑定)。显示范围在 chart 的数据板块逐维给,这里不再存范围")]
private int m_Dimension;
[SerializeField, Tooltip("空间类型:线性 / 对数 / 指数")]
private XChartAxisScale m_Scale = XChartAxisScale.Linear;
[SerializeField, Tooltip("指数空间的强度(值按 exp(k·参数) 增长)")]
[Min(0.001f)] private float m_ExponentialStrength = 2f;
[SerializeField, Tooltip("真=按目标条数自动取好看步长(1/2/5×10^n);假=用下面的步长")]
private bool m_AutoStep = true;
[SerializeField, Tooltip("手动主刻度步长")]
private double m_ManualStep = 1.0;
[SerializeField, Range(1, 30), Tooltip("自动步长想要的目标主刻度条数")]
private int m_TargetMajorCount = 5;
[SerializeField, Range(0, 20), Tooltip("两个主刻度之间的次刻度份数(0=不画)")]
private int m_MinorTickCount = 4;
[Header("外观")]
[SerializeField] private Color m_LineColor = new Color(0.85f, 0.88f, 0.95f, 0.9f);
[SerializeField, Min(0.1f)] private float m_LineThickness = 2f;
[SerializeField, Min(0f)] private float m_MajorTickLength = 8f;
[SerializeField, Min(0f)] private float m_MinorTickLength = 4f;
[SerializeField, Min(0.1f)] private float m_TickThickness = 1.5f;
[SerializeField, Tooltip("刻度朝哪边:-1 朝面参数减小方向(朝外),+1 朝增大方向")]
private float m_TickSide = -1f;
[Header("标签")]
[SerializeField, Tooltip("内容来源:刻度数值 / 维度显示名 / 自定义字符串")]
private XChartAxisLabelSource m_LabelSource = XChartAxisLabelSource.TickValue;
[SerializeField, Tooltip("数值格式化串(如 0.00 或 0.#);留空=按量级自适应")]
private string m_LabelFormat;
[SerializeField, Tooltip("标签来源选\"自定义\"时,按主刻度顺序填这些文本")]
private string[] m_CustomLabels = new string[0];
[SerializeField, Min(0f), Tooltip("标签离刻度线的间距(像素)")]
private float m_LabelGap = 6f;
[SerializeField, Min(1f), Tooltip("字号")]
private float m_LabelFontSize = 14f;
[SerializeField] private Color m_LabelColor = new Color(0.85f, 0.88f, 0.95f, 0.95f);
[SerializeField] private Vector2 m_LabelSize = new Vector2(90f, 24f);
[SerializeField, Tooltip("标签跟着轴的方向转(斜面上读起来才不拧着)")]
private bool m_RotateLabelsWithAxis = true;
public override string ElementName => "Axis";
public override XChartToolBase CreateTool() => new ChartToolAxis();
public override void ApplyTo(XChartToolBase tool)
{
if (!(tool is ChartToolAxis axis)) return;
axis.SlotId = m_SlotId;
axis.AlignToGrid = m_AlignToGrid;
axis.Direction = m_Direction;
axis.StartRatio = m_StartRatio;
axis.EndRatio = m_EndRatio;
axis.CrossRatio = m_CrossRatio;
axis.Transform = m_Transform;
axis.Dimension = m_Dimension;
axis.Scale = m_Scale;
axis.ExponentialStrength = m_ExponentialStrength;
axis.AutoStep = m_AutoStep;
axis.ManualStep = m_ManualStep;
axis.TargetMajorCount = m_TargetMajorCount;
axis.MinorTickCount = m_MinorTickCount;
axis.LineColor = m_LineColor;
axis.LineThickness = m_LineThickness;
axis.MajorTickLength = m_MajorTickLength;
axis.MinorTickLength = m_MinorTickLength;
axis.TickThickness = m_TickThickness;
axis.TickSide = m_TickSide;
axis.LabelSource = m_LabelSource;
axis.LabelFormat = m_LabelFormat;
axis.CustomLabels = m_CustomLabels;
axis.LabelGap = m_LabelGap;
axis.LabelFontSize = m_LabelFontSize;
axis.LabelColor = m_LabelColor;
axis.LabelSize = m_LabelSize;
axis.RotateLabelsWithAxis = m_RotateLabelsWithAxis;
axis.MarkDirty();
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 7e8a7544d20c7104cb74c554878e791f
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:
+200
View File
@@ -0,0 +1,200 @@
using System;
using System.Collections.Generic;
namespace XericUI.XChart.Axis
{
/// <summary>轴的空间类型:值 ↔ 轴上参数(0..1)的映射方式。</summary>
public enum XChartAxisScale
{
/// <summary>线性:参数与值成正比</summary>
Linear = 0,
/// <summary>对数空间:等参数间距对应等<b>数量级</b>间距(要求范围两端同号且不为 0)</summary>
Logarithmic = 1,
/// <summary>指数空间:值按 <c>exp(k·参数)</c> 增长(<see cref="XChartAxisMath.Strength"/> 控制弯的程度)</summary>
Exponential = 2,
}
/// <summary>
/// 轴线的纯数学:值域 ↔ 参数、刻度取值。<b>不碰 Unity 类型</b>,
/// 所以编译门里的 mono 探针能直接把这几条互逆关系和 nice-step 当断言跑。
/// </summary>
public static class XChartAxisMath
{
private const double k_Epsilon = 1e-9;
/// <summary>指数空间强度太小时 <c>exp(k)-1</c> 会掉到 0,除法炸掉;这是下限。</summary>
public const double MinStrength = 1e-3;
// ── 值 ↔ 参数 ─────────────────────────────────────────────
/// <summary>值 → 轴上参数 [0,1]。范围退化(max≈min)时一律给 0.5,不炸也不乱跳。</summary>
public static double ToParameter(double value, double min, double max, XChartAxisScale scale, double strength)
{
double span = max - min;
if (Math.Abs(span) <= k_Epsilon) return 0.5;
switch (scale)
{
case XChartAxisScale.Logarithmic:
{
// 只在两端同为正(或同为负)时对数空间才有意义;否则退回线性
if (min <= 0.0 || max <= 0.0) return (value - min) / span;
double lo = Math.Log(min), hi = Math.Log(max);
if (Math.Abs(hi - lo) <= k_Epsilon) return 0.5;
return (Math.Log(Math.Max(value, double.Epsilon)) - lo) / (hi - lo);
}
case XChartAxisScale.Exponential:
{
double k = Math.Max(strength, MinStrength);
double denom = Math.Exp(k) - 1.0;
double ratio = (value - min) / span; // [0,1]
return Math.Log(1.0 + ratio * denom) / k;
}
default:
return (value - min) / span;
}
}
/// <summary>轴上参数 [0,1] → 值。与 <see cref="ToParameter"/> 互为逆。</summary>
public static double FromParameter(double parameter, double min, double max, XChartAxisScale scale, double strength)
{
double span = max - min;
switch (scale)
{
case XChartAxisScale.Logarithmic:
{
if (min <= 0.0 || max <= 0.0) return min + span * parameter;
double lo = Math.Log(min), hi = Math.Log(max);
return Math.Exp(lo + (hi - lo) * parameter);
}
case XChartAxisScale.Exponential:
{
double k = Math.Max(strength, MinStrength);
return min + span * (Math.Exp(k * parameter) - 1.0) / (Math.Exp(k) - 1.0);
}
default:
return min + span * parameter;
}
}
// ── 刻度 ──────────────────────────────────────────────────
/// <summary>
/// "好看"的步长:把目标条数折算成步长后,收拢到 <c>1 / 2 / 5 × 10^n</c>。
/// 这样刻度值读起来是 0.5、1、2、5、10,而不是 1.37、2.74。
/// </summary>
public static double NiceStep(double span, int targetCount)
{
if (targetCount < 1) targetCount = 1;
double magnitude = Math.Abs(span);
if (magnitude <= k_Epsilon) return 1.0;
double raw = magnitude / targetCount;
double exponent = Math.Floor(Math.Log10(raw));
double power = Math.Pow(10.0, exponent);
double mantissa = raw / power;
double nice;
if (mantissa < 1.5) nice = 1.0;
else if (mantissa < 3.0) nice = 2.0;
else if (mantissa < 7.0) nice = 5.0;
else nice = 10.0;
return nice * power;
}
/// <summary>
/// 生成主刻度<b>值</b>(升序)。线性/指数:从 <c>ceil(min/step)*step</c> 起按步长铺;
/// 对数:按数量级铺 <c>1/2/5 × 10^n</c>(步长参数此时不用,因为等步长在数量级轴上没意义)。
/// </summary>
public static void BuildTicks(double min, double max, XChartAxisScale scale, double step,
int targetCount, bool autoStep, List<double> output)
{
if (output == null) throw new ArgumentNullException(nameof(output));
output.Clear();
if (max < min) { double t = min; min = max; max = t; }
if (scale == XChartAxisScale.Logarithmic && min > 0.0 && max > 0.0)
{
BuildDecadeTicks(min, max, output);
return;
}
double delta = autoStep ? NiceStep(max - min, targetCount) : Math.Abs(step);
if (delta <= k_Epsilon) return;
// 用整数倍索引而不是累加,累加的浮点误差会在长轴上看得见
double first = Math.Ceiling(min / delta) * delta;
int index = 0;
for (double value = first; value <= max + delta * 1e-6; value = first + (++index) * delta)
{
if (index > 100000) break; // 步长给得离谱时的兜底,不至于挂死编辑器
if (value < min - delta * 1e-6) continue;
output.Add(SnapToZero(value, delta));
}
}
/// <summary>对数轴:每个数量级上的 1/2/5</summary>
private static void BuildDecadeTicks(double min, double max, List<double> output)
{
int start = (int)Math.Floor(Math.Log10(min));
int end = (int)Math.Ceiling(Math.Log10(max));
if (end - start > 12) end = start + 12; // 12 个数级已经超出任何轴的表达范围
double[] mantissas = { 1.0, 2.0, 5.0 };
for (int k = start; k <= end; k++)
{
double power = Math.Pow(10.0, k);
for (int m = 0; m < mantissas.Length; m++)
{
double value = mantissas[m] * power;
if (value >= min * (1.0 - 1e-9) && value <= max * (1.0 + 1e-9)) output.Add(value);
}
}
}
/// <summary>把 -1e-17 这类"本该是 0"的刻度收正,否则标签会出现 <c>-0</c>。</summary>
private static double SnapToZero(double value, double delta)
{
return Math.Abs(value) < delta * 1e-6 ? 0.0 : value;
}
/// <summary>
/// 次刻度:在主刻度之间按<b>参数</b>等分。对数/指数空间里这样分出来的是几何级数,
/// 视觉上才均匀(按值等分会在小值那头挤成一坨)。
/// </summary>
public static void BuildMinorTicks(double majorFrom, double majorTo, int minorCount,
double min, double max, XChartAxisScale scale, double strength, List<double> output)
{
if (output == null || minorCount < 1) return;
double p0 = ToParameter(majorFrom, min, max, scale, strength);
double p1 = ToParameter(majorTo, min, max, scale, strength);
for (int i = 1; i < minorCount; i++)
{
double u = p0 + (p1 - p0) * i / minorCount;
output.Add(FromParameter(u, min, max, scale, strength));
}
}
/// <summary>
/// 数值 → 标签文本。格式化串为空时用"按量级自适应"的默认写法:
/// 步长 ≥1 走整数,否则按步长的小数位数给(避免出现 0.30000001)。
/// </summary>
public static string FormatValue(double value, string format, double step)
{
if (!string.IsNullOrEmpty(format))
{
try { return string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0:" + format + "}", value); }
catch (FormatException) { /* 格式化串写错就退回默认,别让一整条轴什么都标不出来 */ }
}
double magnitude = Math.Abs(step) > k_Epsilon ? Math.Abs(step) : Math.Abs(value);
if (magnitude >= 1.0) return value.ToString("0", System.Globalization.CultureInfo.InvariantCulture);
int decimals = 1;
double probe = magnitude;
while (probe < 1.0 && decimals < 6) { probe *= 10.0; decimals++; }
string pattern = "0." + new string('#', decimals);
return value.ToString(pattern, System.Globalization.CultureInfo.InvariantCulture);
}
}
}
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: ae22b8f1e7d36b54d93e7b7c78f0e0b5
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: