diff --git a/Editor/XChart/XChartBaseEditor.cs b/Editor/XChart/XChartBaseEditor.cs index 8292aaa..534768c 100644 --- a/Editor/XChart/XChartBaseEditor.cs +++ b/Editor/XChart/XChartBaseEditor.cs @@ -1,34 +1,1105 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Reflection; +using System.Text; using UnityEditor; +using UnityEditor.UIElements; using UnityEngine; +using UnityEngine.UIElements; using XericUI.XChart; +using XericUI.XChart.Axis; +using XericUI.XChart.Mesh; +using XericUI.XChart.Space; namespace XericUI.XChart.Editor { + /// + /// 图表的层级式面板(实施依据见 Documentation/XChart-RenderFramework.md 的 §0/§4)。 + /// + /// 两个板块,顺序固定:「基础」= 基本变换 / 颜色 / 数据 / 调试;「工具」= 图上每个渲染元素。 + /// 工具只呈现,数据归属 chart,所以维度下标、显示范围这些东西不该散落在工具里。 + /// + /// 层级怎么来的:不新增元数据——字段上的 [Header] 就是分组标题, + /// [Tooltip] 是浮上去看的说明。标题里不放括号补充语(标题定下来就不改,解释归 Tooltip)。 + /// + /// 层级别由调用方报数:chart 自己和每个元素都只走同一对入口 + /// ( / ),块与块的父子关系由"挂在谁的 Body 里"决定。 + /// 灌完整棵树后 现算深度,并把互斥标记只打在叶子块 + /// (下面再无折叠块、真正装字段的那一层)上:展开任意一个叶子块 ⇒ 收起其余叶子块, + /// 任何时候只开一个详细面板。中间层(基础 / 工具 / 某个元素 / 数据)是导航,不受这条管。 + /// 所有块默认折叠;工具栏「Expand」是互斥的显式例外(要横向比对时一次全开), + /// 之后点任意叶子块就回到"只开一个"。 + /// + /// 两处踩过的坑,这里按机制避开: + /// + /// 值变化的监听挂在每个字段自己身上,不挂在面板根上。 本身是 + /// INotifyValueChanged<bool>,挂在根上冒泡监听会把"点标题展开"当成一次数据修改, + /// 于是一边触发重灌/重建、一边把序列化对象 Apply 一次。 + /// 展开状态不靠 ChangeEvent 回写:元素挂上面板时 Unity 会补发一次默认值通知 + /// (bool 的默认值是 false),那一下会把所有分组的状态打回折叠。状态改为在重建前 + /// 从现存 Foldout 身上抄一次,控件自己就是唯一真相。 + /// + /// [CustomEditor(typeof(XChartBase), true)] internal sealed class XChartBaseEditor : UnityEditor.Editor { - private bool m_ShowData = true; - private bool m_ShowAdvanced; + private string m_ElementSignature; + private int m_LastPanelRows = -1; + private int m_LastPanelTableSize = -1; + private int m_LastMaxDepth = -1; + private string m_HierarchyVerdict = "NO-BUILD"; + private Label m_HierarchyLabel; + private float m_NextWitnessWrite; - public override void OnInspectorGUI() + private VisualElement m_Root; + private readonly Dictionary m_LiveFoldouts = new Dictionary(); + private readonly Dictionary> m_GroupsByHost + = new Dictionary>(); + + /// 本轮流程造出来的每个折叠块,按创建顺序。层级不在这里传——灌完树从树上现算。 + private readonly List m_Groups = new List(); + + /// 元素标题行上的 R/D 文本(值变了要就地重写,见 ) + private readonly List m_OrderReadouts = new List(); + + /// 互斥显示的字段登记(勾了某个开关,另外几个要消失;见 ) + private readonly List m_ExclusiveFields = new List(); + + /// 和 一一对应的纯数据视图,交给 判层级。 + private readonly List> m_Nodes + = new List>(); + + /// 最深块的 key:它们共用一个互斥标记,展开一个就收起其余。 + private readonly List m_ExclusiveKeys = new List(); + + /// 批量开合中(见 ):这段时间互斥让路。 + private bool m_BulkFold; + + /// + /// 元素表的句柄。每次都现取:`serializedObject.Update()` 之后旧句柄会作废, + /// 而作废的 SerializedProperty 不报错——它安静地报 arraySize == 0, + /// 于是"元素行整批不见了"(同一时刻表里其实还有 2~4 条,报表拍的到)。 + /// + private SerializedProperty ElementsProp() + { + return serializedObject.FindProperty("m_Elements"); + } + + public override VisualElement CreateInspectorGUI() + { + m_ElementSignature = ComputeSignature(ElementsProp()); + + m_Root = new VisualElement(); + m_Root.Add(BuildToolbar()); + RebuildTree(); + return m_Root; + } + + private VisualElement BuildToolbar() + { + var toolbar = new Toolbar(); + // 这三个按钮的汉字(添加/元素/展/开/折/叠…)不在默认字体的图集里 ⇒ 文本测量要走"新增字形"那条路, +// 于是撞上那个坏掉的动态图集槽(§8.6)⇒ 只有它们抛 MissingReferenceException。 +// 改成 ASCII 就不再需要新字形,而这仨本来就很短,英文也装得下。 + toolbar.Add(MakeButton("Add", ShowAddElementMenu)); + toolbar.Add(MakeButton("Expand", () => SetAllExpanded(true))); + toolbar.Add(MakeButton("Collapse", () => SetAllExpanded(false))); + return toolbar; + } + + // ── 树装配 ──────────────────────────────────────────────── + + private void RebuildTree() + { + if (m_Root == null) return; + + // 重建前把当前展开状态从活的控件上抄下来(唯一真相;不接受事件回写) + foreach (var pair in m_LiveFoldouts) m_LastExpanded[pair.Key] = pair.Value.value; + m_LiveFoldouts.Clear(); + + serializedObject.Update(); + + var body = m_Root.Q("panel-body"); + if (body == null) + { + body = new VisualElement { name = "panel-body" }; + m_Root.Add(body); + } + body.Clear(); + // 树要重建了:同一父级下的同名合并表也必须清掉,否则第二遍会把字段塞进上一棵树的盒子里 + m_GroupsByHost.Clear(); + m_Groups.Clear(); + m_Nodes.Clear(); + m_OrderReadouts.Clear(); + m_ExclusiveFields.Clear(); + + var chart = target as XChartBase; + body.Add(BuildBasicsBox(chart)); + body.Add(BuildToolsBox(chart)); + FinalizeHierarchy(); + WritePanelWitness(); + } + + private readonly Dictionary m_LastExpanded = new Dictionary(); + + /// 基础板块:图表自己的字段(按 [Header] 分组)+ 数据窗口入口 + 调试。 + private VisualElement BuildBasicsBox(XChartBase chart) + { + var basics = MakeGroup("chart-basics", "基础"); + + // 数据这件事在面板上只留一个入口:浏览/增删行列/导入导出/每列的统计与范围覆盖 + // 全在数据窗口里(2026-10-25 他明确要求"所有信息整合到这个窗口里",面板不要再摊一层)。 + if (chart != null) + { + basics.Body.Add(MakeButton("打开数据窗口", () => XChartDataWindow.OpenFor(chart))); + basics.Body.Add(MakeReadonly("数据的增删行列、导入导出、每列统计与范围覆盖都在这个窗口里")); + } + + AppendHeaderGroups(basics.Body, null, "chart"); + + // 同名合并:基类 [Header("调试")] 的两只开关会落进这一块,别再自己 AddField 一遍 + // (验收时问"调试与工具管理是同一份字段、分两个板块的意义何在"就是这么来的) + var debug = GroupFor(basics.Body, "chart-debug", "调试"); + var buttons = new VisualElement { style = { flexDirection = FlexDirection.Row } }; + buttons.Add(MakeButton("重新生成全部节点", () => { chart?.RebuildAll(); RebuildTree(); })); + buttons.Add(MakeButton("显示生成节点", () => chart?.SetDebugVisibility(true))); + buttons.Add(MakeButton("隐藏生成节点", () => chart?.SetDebugVisibility(false))); + debug.Body.Add(buttons); + var second = new VisualElement { style = { flexDirection = FlexDirection.Row } }; + second.Add(MakeButton("自述报表 开", () => SetDumpFlag(true))); + second.Add(MakeButton("自述报表 关", () => SetDumpFlag(false))); + second.Add(MakeButton("打开报表文件", OpenDumpFile)); + debug.Body.Add(second); + debug.Body.Add(MakeReadonly(DumpFlagSummary())); + // 层级读数:互斥标记到底打在几块上、有没有认输(离线探针看不见真控件那一层,所以这里必须自己印) + m_HierarchyLabel = MakeReadonly(HierarchySummary()); + debug.Body.Add(m_HierarchyLabel); + + return basics.Root; + } + + /// 工具板块:配置注册的每个元素一个可折叠块;脚本注册的只报数量。 + private VisualElement BuildToolsBox(XChartBase chart) + { + var tools = MakeGroup("chart-tools", "工具"); + + var list = ElementsProp(); + int rows = 0; + if (list != null) + { + for (int i = 0; i < list.arraySize; i++) + { + var elementProp = list.GetArrayElementAtIndex(i); + var config = elementProp.managedReferenceValue as XChartElementConfig; + if (config == null) continue; + + int index = i; + // 标题用登记名(同类第二个会带序号):两条轴都叫 "Axis" 的话,行和工具对不上号 + string title = chart != null ? chart.ElementNameFor(index) : config.ElementName; + var block = MakeGroup(elementProp.propertyPath, title); + block.Root.tooltip = ObjectNames.NicifyVariableName(config.GetType().Name); + + // **一行装下状态**(他 2026-10-25 给的格式:`▼ √ Cylinder (R1, D4) [↑][↓][-]`): + // 元素块默认折叠着,这些控件放在 Body 里就等于看不见——他报"注册序/绘制序的字段 + // 我在界面上没看到"正是这个原因(控件在,只是那块是收起来的)。 + var head = MakeHeaderRow(block); + var enabled = elementProp.FindPropertyRelative("m_Enabled"); + if (enabled != null) head.Add(MakeEnabledToggle(enabled)); + var order = elementProp.FindPropertyRelative("m_OrderIndex"); + var drawOrder = elementProp.FindPropertyRelative("m_DrawOrder"); + // 标题行里是**文本**(他 2026-10-25 第二轮:"做成文本,格式就是 R 几 D 几"): + // 这里放过输入框会露出拖拽光标,而且标签把宽度吃掉之后数字根本看不见 + var orderText = new Label(OrderText(order, drawOrder)) + { + tooltip = "R=注册序(谁先建、谁先算) D=绘制序(谁盖谁;只在同一分组内比较)", + style = { marginLeft = 8, flexShrink = 1 }, + }; + head.Add(orderText); + m_OrderReadouts.Add(new OrderReadout { Order = order, Draw = drawOrder, Text = orderText }); + head.Add(MakeTinyButton("↑", () => MoveElement(index, -1), "上移(与上一项交换注册位置)")); + head.Add(MakeTinyButton("↓", () => MoveElement(index, 1), "下移(与下一项交换注册位置)")); + head.Add(MakeTinyButton("-", () => RemoveElement(index), + "删除这个元素。默认元素(空间 / BG Cube Wire / BG Cube Grid)**也能删**——" + + "删了就是不要它;预设不会在之后又把它补回来(只在第一次读到这张表时补齐缺的那几件)")); + + // 序号的**写入口**在 Body 里(标题行只读):改完标题那一行就地跟着变(见 OnValueChanged) + var orderRow = new VisualElement { style = { flexDirection = FlexDirection.Row } }; + if (order != null) orderRow.Add(MakeField(order, "注册序")); + if (drawOrder != null) orderRow.Add(MakeField(drawOrder, "绘制序")); + block.Body.Add(orderRow); + + // 这个元素要几个数值维、表里现在有几个——两个数一起印(§25)。 + // "加了工具但什么都没显示"最常见的原因就是这一对不上,而画面上两者长得一模一样。 + if (config.RequiredNumericDimensions > 0) + { + int have = chart != null && chart.DataModel != null + ? chart.DataModel.NumericDimensionCount + : 0; + int need = config.RequiredNumericDimensions; + block.Body.Add(MakeReadonly(have < need + ? "需要 " + need + " 个数值维,表现在有 " + have + " 个 ⇒ 一条都不画(报表里 dims=" + + have + "/" + need + ")" + : "需要 " + need + " 个数值维,表现在有 " + have + " 个")); + } + + AppendHeaderGroups(block.Body, elementProp, elementProp.propertyPath); + + // 宿主面:从**当前板上真有的插槽**里挑(外加手填),不让人去猜 `mesh.face.3` 这种字符串 + if (config is XChartAxisConfig) + { + AddSlotPicker(block.Body, elementProp.FindPropertyRelative("m_SlotId"), chart); + } + + // 刻度与网格分格的对齐提示:两套口径(nice-step 铺刻度 / GridDivisions 铺分格线) + // 不派生,而是把算式和当前数字印出来——他要的是"能对上",先得知道差在哪 + if (config is XChartAxisConfig) + { + var major = elementProp.FindPropertyRelative("m_TargetMajorCount"); + int ticks = major != null ? major.intValue : 0; + int cells = Mathf.Max(ticks - 1, 1); + + // 按方向给建议:轴沿 S 走,刻度就应该落在"沿 T 的格线"上,而那组格线由 S 方向的分格数决定 + var direction = elementProp.FindPropertyRelative("m_Direction"); + string along = direction != null && direction.intValue != 0 ? "T" : "S"; + // 光说"设成 K-1"还得让人满面板找那两个旋钮——把当前值和位置一并印出来。 + // 值住在**网格元素**那份配置里(以前是图上的字段,所以旧提示语指着"基础 → 立方体外观") + string gridNow = GridKnobsHint(chart, list); + + block.Body.Add(MakeReadonly("与网格对齐:主刻度 " + ticks + " 条 = " + cells + " 段" + gridNow)); + LogDetailOnce("grid-align", + "XChart 面板:与网格对齐——主刻度 " + ticks + " 条 = " + cells + " 段,这条轴沿 " + along + + " 走,把立方体网格的 " + along + " 方向分格数设成 " + cells + " 就逐线对上" + + "(0 表示跟随统一值);前提是轴铺满整面、且范围能被步长整除。"); + + // 两头对不上最可能的原因就是这条轴只铺了面宽的一部分(默认内缩过)。 + // 网格线铺的是整面 0..1,轴铺 8%..95% 的话怎么调分格数都对不上。 + var start = elementProp.FindPropertyRelative("m_StartRatio"); + var end = elementProp.FindPropertyRelative("m_EndRatio"); + if (start != null && end != null && (start.floatValue > 0f || end.floatValue < 1f)) + { + var warn = MakeReadonly("这条轴只铺了 " + (start.floatValue * 100f).ToString("0.#") + + "% .. " + (end.floatValue * 100f).ToString("0.#") + "%"); + block.Body.Add(warn); + LogDetailOnce("axis-span", + "XChart 面板:这条轴只铺了 " + (start.floatValue * 100f).ToString("0.#") + + "% .. " + (end.floatValue * 100f).ToString("0.#") + + "% 的面宽,两头都对不上格线(网格线铺的是整面 0..1)。按“铺满整面”一步到位。"); + block.Body.Add(MakeButton("铺满整面", () => SetAxisSpan(index, warn))); + } + } + + tools.Body.Add(block.Root); + rows++; + } + } + + if (chart != null) + { + // 脚本注册的工具也要逐个点名(他 2026-10-25:"你并没有显示出来这几个工具是什么东西? + // 既然是工具就要放在工具下面")。只报数量的话,"图里到底有谁"还得去翻报表或代码。 + var elementTools = chart.ElementTools; + var live = chart.ToolManager != null ? chart.ToolManager.Tools : null; + int listed = 0; + var scriptBox = GroupFor(tools.Body, "chart-tools-script", "脚本注册的工具"); + if (live != null) + { + for (int i = 0; i < live.Count; i++) + { + var tool = live[i]; + if (tool == null || IsElementTool(elementTools, tool)) continue; + if (++listed == 1) + scriptBox.Body.Add(MakeReadonly("这些由派生类 RegisterTools 登记;" + + "字段在脚本/各自元素配置里,不在这里改")); + scriptBox.Body.Add(MakeReadonly(ToolSummary(tool))); + } + } + // 一行都没有也要说明为什么:分不清"没有脚本工具"和"管理器还没建"就等于没报 + if (listed == 0) + scriptBox.Body.Add(MakeReadonly("脚本注册的工具 0 个" + + (chart.ToolManager == null ? "(工具管理器还没建)" : string.Empty))); + } + + // 证人:面板渲染出来的行数要和表长一起印进同一份报表。 + // "行整批不见了"那一次,表里其实还有 2~4 条——只有两边同印才分得清是数据没了还是读数没了。 + m_LastPanelRows = rows; + m_LastPanelTableSize = list != null ? list.arraySize : -1; + return tools.Root; + } + + /// 这个工具是不是元素表建出来的(按引用比,不按名字:名字可以撞,引用不会) + private static bool IsElementTool(System.Collections.Generic.IReadOnlyList elementTools, + XChartToolBase tool) + { + if (elementTools == null) return false; + for (int i = 0; i < elementTools.Count; i++) + if (ReferenceEquals(elementTools[i], tool)) return true; + return false; + } + + /// + /// 一个脚本注册工具的自述行:名字 + 类型 + 分组 + 注册序 + 绘制序。 + /// 名字与序必须一起印:「上移下移」只管元素表,脚本工具的先后由注册顺序决定, + /// 不印出来就成了"面板上有两排同名的东西,谁是权威看不出来"。 + /// + private static string ToolSummary(XChartToolBase tool) + { + return tool.ToolName + " · " + tool.GetType().Name + + " 组=" + tool.Category + " 注册=" + tool.OrderIndex + " 绘制=" + tool.DrawOrder; + } + + /// + /// S / T 分格数现在的住址与现值。 + /// + /// 提示语必须当场找这两个数,不能凭印象写死:"这两个旋钮在哪"这件事刚刚搬过家 + /// (图上的「基础 → 立方体外观」→ 工具里的那份网格配置)。写死的提示语不会报错,只会把人引到 + /// 一个已经不存在的块上——比没有提示更坏。 + /// + private static string GridKnobsHint(XChartBase chart, SerializedProperty elements) + { + if (elements == null) return "(图里没有网格元素 ⇒ 没有格线可对:在 工具 里 Add 一个 BG Cube Grid)"; + + for (int i = 0; i < elements.arraySize; i++) + { + var prop = elements.GetArrayElementAtIndex(i); + if (!(prop.managedReferenceValue is XChartMeshBgConfig)) continue; + + var divisionsS = prop.FindPropertyRelative("m_GridDivisionsS"); + var divisionsT = prop.FindPropertyRelative("m_GridDivisionsT"); + if (divisionsS == null || divisionsT == null) return string.Empty; + + // 两块网格时印的是第一块的名字——那才是刻度这条轴实际对上的那一块 + string name = chart != null ? chart.ElementNameFor(i) : "BG Cube Grid"; + return "(现在 S=" + divisionsS.intValue + " T=" + divisionsT.intValue + + ",这两个旋钮在 工具 → " + name + " 里,紧挨着「网格分格数」;0=跟随统一值)"; + } + return "(图里没有网格元素 ⇒ 没有格线可对:在 工具 里 Add 一个 BG Cube Grid)"; + } + + /// 把 owner 的直接子字段按 [Header] 切成嵌套 box;没有 Header 的进"其它"。 + private void AppendHeaderGroups(VisualElement host, SerializedProperty owner, string keyPrefix) + { + Type type = owner != null + ? (owner.managedReferenceValue == null ? null : owner.managedReferenceValue.GetType()) + : target.GetType(); + if (type == null) return; + + var bodyContent = new VisualElement(); + string groupTitle = null; + + // 互斥显示的判据在配置自己身上(§25):面板只负责"照着藏/放"。 + // 只有"元素"这一层才有配置——chart 自己那份(owner == null)是没有的,所以这里**不写** + // `target as XChartElementConfig`:target 是 UnityEngine.Object,配置是纯托管类,那样写编不过 + var config = owner != null ? owner.managedReferenceValue as XChartElementConfig : null; + + foreach (SerializedProperty prop in DirectChildren(owner)) + { + if (prop.name == "m_Script" || prop.name == "m_DataModel" || prop.name == "m_Elements") continue; + // 轴线的宿主面在轴那一块有专用控件("已发布插槽"下拉 + 手填框), + // 这里再出一个裸文本框就是同一件事两个入口 + if (prop.name == "m_SlotId" && type == typeof(XChartAxisConfig)) continue; + // 启用 / 注册序 / 绘制序 归**元素标题那一行**(√ R D)管了(§24.1):基类那三个字段 + // 没有 [Header],不跳过去它们就会整组落进"其它",同一个写入口出现两次 + if (owner != null && (prop.name == "m_Enabled" + || prop.name == "m_OrderIndex" || prop.name == "m_DrawOrder")) continue; + + string header = HeaderFor(type, prop.name); + if (header != null && header != groupTitle) + { + FlushGroupBox(host, bodyContent, groupTitle ?? "其它", keyPrefix); + bodyContent = new VisualElement(); + groupTitle = header; + } + var field = MakeField(prop); + bodyContent.Add(field); + if (config != null) RegisterExclusiveField(config, prop.name, field); + } + FlushGroupBox(host, bodyContent, groupTitle ?? "其它", keyPrefix); + } + + private void FlushGroupBox(VisualElement host, VisualElement content, string title, string keyPrefix) + { + if (content.childCount == 0) return; + // 同名合并:面板手建的"数据 / 调试"与派生类的 [Header] 同名时落进同一块 + GroupFor(host, keyPrefix + "/" + title, title).Body.Add(content); + } + + /// + /// 一个 box = 边框 + 可折叠标题 + Body 容器。折叠切换的就是 Body 的显示, + /// 所以所有内容必须加进 ;加到 上 + /// 会变成"标题折叠了、内容还在"(上一版的大分类打不开就是这个原因)。 + /// + /// 默认折叠:面板一打开只露顶层两行(基础 / 工具),要看的东西一层点进去。 + /// 展开状态从 取(没有记录就是关着),当前实例登记进 + /// 供下次重建抄回。 + /// + /// 这里不接受调用方传层级: 在树灌完后从 + /// "这块挂在谁的 Body 里"现算深度,并把互斥标记只打在最深那一层上。 + /// + private Group MakeGroup(string key, string title) + { + var box = new VisualElement(); + ApplyBoxStyle(box); + box.style.marginLeft = 2; + box.style.marginRight = 4; + box.style.marginTop = 4; + // 左侧留够内边距:折叠小三角是 Foldout 自带 toggle,默认样式带负缩进, + // 留白不够它就压在左描边上(就是"box 和折叠按钮冲突"那个现象) + box.style.paddingLeft = 16; + box.style.paddingRight = 6; + box.style.paddingTop = 2; + box.style.paddingBottom = 3; + + bool expanded; + if (!m_LastExpanded.TryGetValue(key, out expanded)) expanded = false; + + var header = new Foldout { text = title, value = expanded }; + header.style.unityFontStyleAndWeight = FontStyle.Bold; + header.style.marginLeft = 0; + header.style.marginTop = 0; + header.style.marginBottom = 0; + // key 钉在盒子根上(不是标题上):算层级时沿 parent 往上走,撞到的第一个带 key 的 + // 祖先就是父块;标题是盒子的孩子、永远不会成为谁的祖先。 + box.userData = key; + m_LiveFoldouts[key] = header; + box.Add(header); + + var body = new VisualElement { name = "box-body" }; + body.style.marginLeft = 4; + body.style.display = expanded ? DisplayStyle.Flex : DisplayStyle.None; + // 折叠只改显示,不碰序列化对象:点标题不是一次数据修改 + header.RegisterValueChangedCallback(evt => body.style.display = evt.newValue ? DisplayStyle.Flex : DisplayStyle.None); + box.Add(body); + + var group = new Group { Root = box, Body = body, Header = header }; + group.Mark = new XChartPanelHierarchy.Node { Key = key, Box = box }; + m_Groups.Add(group); + m_Nodes.Add(group.Mark); + return group; + } + + /// + /// 把某个块的标题改装进一行横排:折叠箭头与名字仍是最左那一段,右边留给状态控件。 + /// 折叠机件( 里那条"开合只改 Body 显示"的回调、层级互斥)都还挂在 + /// 同一个 Foldout 上,搬动位置不改它的身份。 + /// + private static VisualElement MakeHeaderRow(Group group) + { + var row = new VisualElement + { + style = { flexDirection = FlexDirection.Row, alignItems = Align.Center }, + }; + int at = group.Root.IndexOf(group.Header); + group.Root.Remove(group.Header); + group.Header.style.flexShrink = 0; + row.Add(group.Header); + group.Root.Insert(at < 0 ? 0 : at, row); + return row; + } + + /// + /// 标题行上的"启用"勾选:写的就是 m_Enabled,Body 里不再留第二个入口。 + /// 签名()里含 Enabled ⇒ 改它走的是 RebuildElements, + /// 停用之后工具真的会没,而不是"勾了但还在画"。 + /// + private Toggle MakeEnabledToggle(SerializedProperty enabled) + { + var toggle = new Toggle + { + value = enabled.boolValue, + tooltip = "启用/停用这个元素(停用=不创建它,配置留在表里)", + style = { marginLeft = 4, flexShrink = 0 }, + }; + toggle.RegisterValueChangedCallback(evt => + { + serializedObject.Update(); + enabled.boolValue = evt.newValue; + OnValueChanged(); + }); + return toggle; + } + + /// + /// 标题行上的一段读数:R1 D4。用文本而不是输入框—— + /// 输入框的标签区会露出拖拽光标("露馅"),而且窄到连数字都看不见(他 2026-10-25 两轮反馈)。 + /// 写入口在 Body 里;这里只显示,值一变就地改文本()。 + /// + private static string OrderText(SerializedProperty order, SerializedProperty drawOrder) + { + return "R" + (order != null ? order.intValue : 0) + + " D" + (drawOrder != null ? drawOrder.intValue : 0); + } + + /// 标题行的 R/D 读数:面板树在值变化时**不重建**(会换掉正在拖的输入框), + /// 所以静态文本要自己去改,否则它就停在旧值上("改了没反应"的又一种形状) + private sealed class OrderReadout + { + public SerializedProperty Order; + public SerializedProperty Draw; + public Label Text; + } + + /// 把标题行上的 R/D 文本按序列化对象现值重写一遍(OnValueChanged 末尾调) + private void RefreshOrderReadouts() + { + for (int i = 0; i < m_OrderReadouts.Count; i++) + { + OrderReadout readout = m_OrderReadouts[i]; + if (readout == null || readout.Text == null) continue; + readout.Text.text = OrderText(readout.Order, readout.Draw); + } + } + + /// 互斥显示登记的一条:哪个配置的哪个字段、对应面板上哪个控件 + private sealed class ExclusiveField + { + public XChartElementConfig Config; + public string FieldName; + public VisualElement Element; + } + + /// + /// 登记一个字段的"该不该藏",并立刻按现况定初值。 + /// 藏而不是不建:勾掉那个开关时要能立刻回来,而面板树在值变化时是不重建的—— + /// 建好再切显示,才有"勾一下它回来"这种即时手感。 + /// + private void RegisterExclusiveField(XChartElementConfig config, string fieldName, VisualElement element) + { + m_ExclusiveFields.Add(new ExclusiveField { Config = config, FieldName = fieldName, Element = element }); + element.style.display = config.IsFieldHidden(fieldName) ? DisplayStyle.None : DisplayStyle.Flex; + } + + /// 按各配置现况重算"该藏的藏起来"(值变化时调;判据在配置自己身上) + private void RefreshExclusiveFields() + { + for (int i = 0; i < m_ExclusiveFields.Count; i++) + { + ExclusiveField item = m_ExclusiveFields[i]; + if (item == null || item.Element == null) continue; + item.Element.style.display = item.Config != null && item.Config.IsFieldHidden(item.FieldName) + ? DisplayStyle.None + : DisplayStyle.Flex; + } + } + + /// 一行里的单个动作键(↑ ↓ -):一个字符 + 一句 tooltip,中文按钮名留给浮看 + private static Button MakeTinyButton(string text, Action clicked, string tooltip) + { + return new Button(clicked) + { + text = text, + tooltip = tooltip, + style = + { + width = 22f, minWidth = 22f, flexShrink = 0, + marginLeft = 1, marginRight = 0, paddingLeft = 0, paddingRight = 0, + }, + }; + } + + /// + /// 取(没有就建)一个 box,按同一父级下的标题认同一块:派生类自己写的 [Header("数据")] + /// 与面板手建的"数据"曾经各起一个同名 box(验收时问"分两个板块的意义何在"),现在同名合并进同一块。 + /// + /// 合并必须限定在同一父级内:两条轴元素的内部标题是同名的("值域与刻度"/"外观"/…), + /// 跨父级按标题合并会把第二条轴的字段全灌进第一条的盒子里,第二条看起来就是空的 + /// (P4 验收现场:"只有第一个 axis 有内容,另一个 axis 的内容是空的",就是这一条)。 + /// 本方法自己把 Root 挂到 host 上,调用方不要再 Add 一次。 + /// + private Group GroupFor(VisualElement host, string key, string title) + { + if (host == null) return MakeGroup(key, title); + + Dictionary siblings; + if (!m_GroupsByHost.TryGetValue(host, out siblings)) + { + siblings = new Dictionary(); + m_GroupsByHost[host] = siblings; + } + + Group existing; + if (siblings.TryGetValue(title, out existing)) return existing; + + var group = MakeGroup(key, title); + siblings[title] = group; + host.Add(group.Root); + return group; + } + + /// 一个可折叠块:Root 挂到父 Body 上,内容一律进 Body。 + private sealed class Group + { + public VisualElement Root; + public VisualElement Body; + public Foldout Header; + + /// 这块的 key 与层级判定结果(父级/深度/是否最深都由 填)。 + public XChartPanelHierarchy.Node Mark; + } + + /// + /// 树灌完后统一收口:把这一轮的块交给 判层级, + /// 再把互斥标记只打在最深那一层(叶子块)上。 + /// + /// 为什么在这儿算而不是装配时传参:调用方知道自己第几层,但"挂在谁的 Body 里" + /// 是 的合并规则决定的(同名合并、跨父级不合并)。传进来的层级会和 + /// 实际挂接位置分叉,而"最深那一层"必须按真实的树判——所以流程只登记块,层级事后从树上读。 + /// + /// 互斥只有一条:整个面板共用一组标记,展开任意一个叶子块就收起其余叶子块, + /// 于是任何时候最多只有一个"详细面板"开着。中间层(基础 / 工具 / 某个元素 / 数据)不受管, + /// 它们只是导航,想同时开几个开几个。 + /// + private void FinalizeHierarchy() + { + m_ExclusiveKeys.Clear(); + + XChartPanelHierarchy.Compute(m_Nodes, v => v.parent, v => v.userData as string); + + int deepest = 0; + bool anyParent = false; + m_LastMaxDepth = 0; + foreach (var group in m_Groups) + { + if (group.Mark.Depth > m_LastMaxDepth) m_LastMaxDepth = group.Mark.Depth; + if (group.Mark.ParentKey != null) anyParent = true; + if (!group.Mark.IsLeaf) continue; + + deepest++; + m_ExclusiveKeys.Add(group.Mark.Key); + string self = group.Mark.Key; + // 只接"开"这一下:开一个就把别的最深块收掉。Body 的显示不归这里管—— + // MakeGroup 里那条回调本来就是唯一的显示开关,两条各管各的。 + group.Header.RegisterValueChangedCallback(evt => + { + if (evt.newValue) CollapseOtherDetails(self); + }); + } + + m_HierarchyVerdict = HierarchyVerdict(m_Groups.Count, deepest, anyParent); + if (m_HierarchyLabel != null) m_HierarchyLabel.text = HierarchySummary(); + } + + private string HierarchySummary() + { + return "层级:块 " + m_Groups.Count + " 最深 " + m_ExclusiveKeys.Count + + " 深 " + m_LastMaxDepth + " " + m_HierarchyVerdict; + } + + /// + /// 层级判决行。这两条不是装饰,是"离线探针看不见的这一层"的读数: + /// 纯数据那侧算得再对,parent/userData 没接上时它收到的就是一串顶层节点。 + /// + private static string HierarchyVerdict(int groups, int deepest, bool anyParent) + { + if (groups == 0) return "NO-GROUPS"; + if (deepest == 0) return "HIERARCHY-NO-LEAF"; + // 多于一个块却没人有父级 ⇒ 往上爬那一格没爬到东西:互斥会把导航层也一起管了 + if (groups > 1 && !anyParent) return "HIERARCHY-NO-PARENT"; + return "OK"; + } + + /// 收起除 之外所有开着的最深块。 + private void CollapseOtherDetails(string openKey) + { + if (m_BulkFold) return; + + for (int i = 0; i < m_ExclusiveKeys.Count; i++) + { + string key = m_ExclusiveKeys[i]; + if (key == openKey) continue; + + Foldout header; + if (!m_LiveFoldouts.TryGetValue(key, out header)) continue; + // 已经关着的别补发事件:Foldout 的 value setter 无条件发 ChangeEvent, + // 白发给下去只是多跑一遍回调 + if (!header.value) continue; + + header.value = false; + } + } + + /// + /// 2022.1 的 IStyle 没有 borderWidth/borderColor/borderRadius 这组简写(那是以后才加的), + /// 只有分边的属性,所以 box 的描边一条条写。 + /// + private static void ApplyBoxStyle(VisualElement box) + { + var line = new StyleColor(new Color(1f, 1f, 1f, 0.14f)); + box.style.borderLeftWidth = 1; + box.style.borderRightWidth = 1; + box.style.borderTopWidth = 1; + box.style.borderBottomWidth = 1; + box.style.borderLeftColor = line; + box.style.borderRightColor = line; + box.style.borderTopColor = line; + box.style.borderBottomColor = line; + box.style.borderTopLeftRadius = 3; + box.style.borderTopRightRadius = 3; + box.style.borderBottomLeftRadius = 3; + box.style.borderBottomRightRadius = 3; + } + + /// + /// 批量开合。这一趟要屏蔽互斥:不屏蔽的话,"全部展开"逐个把最深块置 true, + /// 每置一个就收掉前面刚开的那个 ⇒ 按钮按下去只剩最后一个开着(等于没展开)。 + /// 所以 Expand 是这条规则的显式例外出口(要横向比对时用它), + /// 而只要再点任意一个最深块,规则立刻恢复成"只开一个"。 + /// + private void SetAllExpanded(bool expanded) + { + m_BulkFold = true; + foreach (var pair in m_LiveFoldouts) + { + pair.Value.value = expanded; + m_LastExpanded[pair.Key] = expanded; + } + m_BulkFold = false; + } + + // ── 字段 ────────────────────────────────────────────────── + + private PropertyField MakeField(SerializedProperty prop, string label = null) + { + var field = label == null ? new PropertyField(prop) : new PropertyField(prop, label); + // 监听挂在这个字段自己身上(只收它内部控件冒泡上来的事件),不挂面板根: + // 挂根上会把 Foldout 的开合也当成"值变了" + field.RegisterCallback>(evt => OnValueChanged()); + field.RegisterCallback>(evt => OnValueChanged()); + field.RegisterCallback>(evt => OnValueChanged()); + field.RegisterCallback>(evt => OnValueChanged()); + field.RegisterCallback>(evt => OnValueChanged()); + field.RegisterCallback>(evt => OnValueChanged()); + field.RegisterCallback>(evt => OnValueChanged()); + field.RegisterCallback>(evt => OnValueChanged()); + field.RegisterCallback>(evt => OnValueChanged()); + field.RegisterCallback>(evt => OnValueChanged()); + field.RegisterCallback>(evt => OnValueChanged()); + field.RegisterCallback>(evt => OnValueChanged()); + return field; + } + + /// 下拉里表示"不用清单里的 id,我自己填"的那一项 + private const string kManualSlot = "(手填)"; + + /// + /// 宿主面 = "已发布插槽"下拉 + 手填框。列的是**当前板上真有的** id + /// (由定义网格的那个元素发布,见规范 §11.2),所以不用去猜 mesh.face.3 这种字符串; + /// 手填保留,因为发布可能晚于面板构建(面板重开一次就到齐)。 + /// + private void AddSlotPicker(VisualElement host, SerializedProperty slotProp, XChartBase chart) + { + if (slotProp == null) return; + + var available = new List(); + var board = chart != null && chart.ToolManager != null && chart.ToolManager.Context != null + ? chart.ToolManager.Context.Slots + : null; + if (board != null) + { + for (int i = 0; i < board.SlotCount; i++) + { + string id; + XChartSlotMode mode; + if (!board.TryGetSlotAt(i, out id, out mode)) continue; + if (!available.Contains(id)) available.Add(id); + } + } + + var choices = new List { kManualSlot }; + choices.AddRange(available); + int current = available.IndexOf(slotProp.stringValue); + + var dropdown = new DropdownField("已发布插槽", choices, current < 0 ? 0 : current + 1); + dropdown.RegisterValueChangedCallback(evt => + { + if (evt.newValue == kManualSlot) return; // 手填:不动现值 + serializedObject.Update(); + slotProp.stringValue = evt.newValue; + serializedObject.ApplyModifiedProperties(); + OnValueChanged(); + }); + + host.Add(dropdown); + host.Add(MakeField(slotProp, "宿主面(可手填)")); + host.Add(MakeReadonly("已发布插槽 " + available.Count + " 个")); + LogDetailOnce("slots", "XChart 面板:板上已发布的插槽 id —— " + (available.Count == 0 + ? "(一个都没有:定义网格的元素还没跑,或本图没有网格元素)" + : string.Join(", ", available.ToArray()))); + } + + /// + /// 把某条轴铺满整面(起点 0、终点 1)。网格线铺的是整面 0..1, + /// 轴内缩着就不可能和格线对齐——这是"两头都对不上"最常见的原因, + /// 所以给一键而不是让人去猜两个比例该填多少。 + /// + private void SetAxisSpan(int elementIndex, Label warn) { serializedObject.Update(); - DrawPropertiesExcluding(serializedObject, "m_Script", "m_DataModel", "m_ShowDebug", "m_HideAllTools"); - m_ShowData = EditorGUILayout.Foldout(m_ShowData, "数据", true); - if (m_ShowData) - { - var model = ((XChartBase)target).DataModel; - EditorGUILayout.LabelField("维度", model.Dimensions.Count.ToString()); - EditorGUILayout.LabelField("记录", model.Records.Count.ToString()); - EditorGUILayout.LabelField("版本", model.Version.ToString()); - } - m_ShowAdvanced = EditorGUILayout.Foldout(m_ShowAdvanced, "高级", true); - if (m_ShowAdvanced) - { - EditorGUILayout.PropertyField(serializedObject.FindProperty("m_ShowDebug")); - EditorGUILayout.PropertyField(serializedObject.FindProperty("m_HideAllTools")); - } + var table = ElementsProp(); + if (table == null || elementIndex < 0 || elementIndex >= table.arraySize) return; + + var element = table.GetArrayElementAtIndex(elementIndex); + var start = element.FindPropertyRelative("m_StartRatio"); + var end = element.FindPropertyRelative("m_EndRatio"); + if (start == null || end == null) return; + + start.floatValue = 0f; + end.floatValue = 1f; serializedObject.ApplyModifiedProperties(); + if (warn != null) warn.text = "已铺满整面(0% .. 100%):刻度现在能落在格线上了"; + OnValueChanged(); + } + + /// + /// 值变了:重灌元素 + 无条件刷一次。不重建面板——只有结构真的变了(增删/移动/启停/换类型) + /// 才重建工具,且面板树保持不动,用户正在拖的输入框才不会半路被换掉。 + /// + private void OnValueChanged() + { + serializedObject.ApplyModifiedProperties(); + // 面板树不重建(重建会换掉用户正在拖的输入框)⇒ 标题行的 R/D 文本与"互斥该藏谁" + // 都要就地重算,否则它们停在旧状态上("改了没反应"的又一种形状) + RefreshOrderReadouts(); + RefreshExclusiveFields(); + + var chart = target as XChartBase; + if (chart == null) return; + + string signature = ComputeSignature(ElementsProp()); + if (signature != m_ElementSignature) + { + m_ElementSignature = signature; + chart.RebuildElements(); + } + else + { + chart.ReapplyElements(); + chart.ForceRefresh(); + } + Repaint(); + } + + private static Label MakeReadonly(string text) => new Label(text); + + private static Button MakeButton(string text, Action clicked) + => new Button(clicked) { text = text }; + + // ── 自述报表(与 chart 那边共用同一对文件名)──────────────── + + private static void SetDumpFlag(bool on) + { + var root = XChartBase.ProjectRoot(); + if (root == null) return; + var path = Path.Combine(root, XChartBase.DumpFlagName); + if (on) File.WriteAllText(path, DateTime.Now.ToString("u")); + else if (File.Exists(path)) File.Delete(path); + Debug.Log(DumpFlagDetail()); // 完整状态走日志:面板塞不下、也复制不了 + } + + private static void OpenDumpFile() + { + var root = XChartBase.ProjectRoot(); + if (root == null) return; + var path = Path.Combine(root, XChartBase.DumpFileName); + if (!File.Exists(path)) + { + Debug.LogWarning("XChart 报表还没生成:先按“自述报表 开”,再让图表跑几帧。"); + return; + } + EditorUtility.OpenWithDefaultApp(path); + } + + /// + /// 面板只留一句话,**完整说明进 Console**;每个 key 只打一次——面板会随数据重建, + /// 不按 key 去重就会刷屏(这也是"说明太长、面板塞不下、又没法复制"的统一出口)。 + /// + private static readonly HashSet s_LoggedOnce = new HashSet(); + + private static void LogDetailOnce(string key, string detail) + { + if (!s_LoggedOnce.Add(key)) return; + Debug.Log(detail); + } + + private static string DumpFlagSummary() + { + // 面板上只留一句话;**路径、字节数这类长文本走日志**(面板里看不全、也没法复制) + var root = XChartBase.ProjectRoot(); + if (root == null) return "报表:拿不到工程根"; + return "报表:" + (File.Exists(Path.Combine(root, XChartBase.DumpFlagName)) ? "开" : "关"); + } + + /// 完整状态(含输出路径与文件大小):抱怨不进面板,直接进 Console 让人能读能复制 + private static string DumpFlagDetail() + { + var root = XChartBase.ProjectRoot(); + if (root == null) return "XChart 报表:拿不到工程根"; + var on = File.Exists(Path.Combine(root, XChartBase.DumpFlagName)); + var file = Path.Combine(root, XChartBase.DumpFileName); + return "XChart 报表:" + (on ? "开" : "关") + ";输出 " + file + + (File.Exists(file) ? "(" + new FileInfo(file).Length + " 字节)" : "(还没生成)"); + } + + /// + /// 把"面板渲染了几行 / 表里有几条"追加进同一份报表:这两个数不等就说明行不是被数据拿走、 + /// 而是面板自己读不到(验收时"元素行整批不见"正是这一类)。按 0.4 秒节流,别在重绘里刷盘。 + /// + private void WritePanelWitness() + { + var root = XChartBase.ProjectRoot(); + if (root == null) return; + if (!File.Exists(Path.Combine(root, XChartBase.DumpFlagName))) return; + if ((float)EditorApplication.timeSinceStartup < m_NextWitnessWrite) return; + m_NextWitnessWrite = (float)EditorApplication.timeSinceStartup + 0.4f; + + try + { + File.AppendAllText(Path.Combine(root, XChartBase.DumpFileName), + " panel: rows=" + m_LastPanelRows + " table=" + m_LastPanelTableSize + + (m_LastPanelRows == m_LastPanelTableSize ? "" : " ROWS-DISAGREE") + + " groups=" + m_Groups.Count + " deepest=" + m_ExclusiveKeys.Count + + " depth=" + m_LastMaxDepth + " hierarchy=" + m_HierarchyVerdict + "\n"); + } + catch (Exception error) + { + m_NextWitnessWrite = float.MaxValue; + Debug.LogWarning("XChart 面板证人写入失败,已停止:" + error.Message); + } + } + + /// owner 的直接子字段;owner 为 null 时取顶层字段。 + private IEnumerable DirectChildren(SerializedProperty owner) + { + var result = new List(); + if (owner != null) + { + SerializedProperty it = owner.Copy(); + int depth = it.depth; + if (!it.Next(true)) return result; + do + { + if (it.depth <= depth) break; + if (it.depth == depth + 1) result.Add(it.Copy()); + } + while (it.Next(false)); + return result; + } + + SerializedProperty top = serializedObject.GetIterator(); + bool enterFirst = true; + while (top.NextVisible(enterFirst)) + { + enterFirst = false; + if (top.depth != 0) continue; + result.Add(top.Copy()); + } + return result; + } + + // ── [Header] 反射 ───────────────────────────────────────── + + private static string HeaderFor(Type type, string fieldName) + { + FieldInfo field = FindField(type, fieldName); + if (field == null) return null; + var attribute = field.GetCustomAttribute(); + return attribute == null ? null : attribute.header; + } + + private static FieldInfo FindField(Type type, string name) + { + for (Type t = type; t != null; t = t.BaseType) + { + var field = t.GetField(name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public); + if (field != null) return field; + } + return null; + } + + // ── 元素增删移(结构性操作才重建面板) ──────────────────── + + private void ShowAddElementMenu() + { + if (target as XChartBase == null) return; + + var entries = XChartElementRegistry.GetEntries(); + var menu = new GenericMenu(); + if (entries.Count == 0) + { + menu.AddDisabledItem(new GUIContent("没有带 [XChartElement] 的配置类型")); + } + else + { + for (int i = 0; i < entries.Count; i++) + { + var entry = entries[i]; + menu.AddItem(new GUIContent(entry.Meta.DisplayName), false, () => AddElement(entry.ConfigType)); + } + } + menu.DropDown(new Rect(m_Root.worldBound.position, Vector2.zero)); + } + + private void AddElement(Type configType) + { + var config = XChartElementRegistry.Create(configType); + if (config == null) return; + + Undo.RecordObject(target, "添加图表元素"); + serializedObject.Update(); + var list = ElementsProp(); + int index = list.arraySize; + list.InsertArrayElementAtIndex(index); + list.GetArrayElementAtIndex(index).managedReferenceValue = config; + serializedObject.ApplyModifiedProperties(); + + AfterStructureChange(); + } + + private void RemoveElement(int index) + { + Undo.RecordObject(target, "删除图表元素"); + serializedObject.Update(); + ElementsProp().DeleteArrayElementAtIndex(index); + serializedObject.ApplyModifiedProperties(); + AfterStructureChange(); + } + + private void MoveElement(int index, int delta) + { + serializedObject.Update(); + var list = ElementsProp(); + int to = index + delta; + if (to < 0 || to >= list.arraySize) return; + + Undo.RecordObject(target, "调整图表元素顺序"); + list.MoveArrayElement(index, to); + serializedObject.ApplyModifiedProperties(); + AfterStructureChange(); + } + + private void AfterStructureChange() + { + m_ElementSignature = ComputeSignature(ElementsProp()); + var chart = target as XChartBase; + if (chart != null) chart.RebuildElements(); + RebuildTree(); + Repaint(); + } + + private static string ComputeSignature(SerializedProperty list) + { + if (list == null) return string.Empty; + var builder = new StringBuilder(); + for (int i = 0; i < list.arraySize; i++) + { + var config = list.GetArrayElementAtIndex(i).managedReferenceValue as XChartElementConfig; + if (config == null) { builder.Append("|"); continue; } + builder.Append(config.GetType().Name).Append(':') + .Append(config.Enabled ? '1' : '0').Append(':') + .Append(config.OrderIndex).Append(':') + .Append(config.ElementName).Append('|'); + } + return builder.ToString(); } } } diff --git a/Editor/XChart/XChartCreateMenu.cs b/Editor/XChart/XChartCreateMenu.cs index ca037f9..1bbc3e6 100644 --- a/Editor/XChart/XChartCreateMenu.cs +++ b/Editor/XChart/XChartCreateMenu.cs @@ -1,7 +1,10 @@ using UnityEditor; +using UnityEditor.SceneManagement; using UnityEngine; using UnityEngine.UI; +using XericUI.Core; using XericUI.XChart.Line; +using XericUI.XChart.Products; using XericUI.XChart.Pseudo3D; using XericUI.XChart.Radar; @@ -9,33 +12,73 @@ namespace XericUI.XChart.Editor { internal static class XChartCreateMenu { - [MenuItem("GameObject/Xeric/XChart/Line Chart", false, 10)] + [MenuItem(XericRegistrationPaths.ChartCreate + "/Line Chart", false, 10)] private static void CreateLineChart() => Create("XLineChart"); - [MenuItem("GameObject/Xeric/XChart/Radar Chart", false, 11)] + [MenuItem(XericRegistrationPaths.ChartCreate + "/Radar Chart", false, 11)] private static void CreateRadarChart() => Create("XRadarChart"); - [MenuItem("GameObject/Xeric/XChart/Pseudo3D Scatter Chart", false, 12)] + [MenuItem(XericRegistrationPaths.ChartCreate + "/Pseudo3D Scatter Chart", false, 12)] private static void CreateScatterChart() => Create("XPseudo3DScatterChart"); + [MenuItem(XericRegistrationPaths.ChartCreate + "/网格渲染预览图", false, 13)] + private static void CreateMeshPreview() => Create("XMeshPreviewChart"); + + /// + /// 建一个图表对象。 + /// + /// 不替用户决定宿主结构:只在当前位置放不下时给出警告,绝不自动创建 Canvas—— + /// 自动建出来的 Canvas 会多出一个用户没要求的根物体,预制体里尤其碍事。 + /// 没有 Canvas 祖先时的现象是"什么都画不出来",所以 + /// 必须把这句话说出口。 + /// + /// 预制体编辑模式要特殊处理:此时对象必须挂进预制体根,否则它建在了预制体外面, + /// 退出预制体时会被直接丢掉("组件完全不存在"就是这么来的)。 + /// private static void Create(string name) where T : Component { - Canvas canvas = Selection.activeTransform == null ? null : Selection.activeTransform.GetComponentInParent(); - if (canvas == null) - { - var canvasObject = new GameObject("Canvas", typeof(RectTransform), typeof(Canvas), typeof(CanvasScaler), typeof(GraphicRaycaster)); - canvas = canvasObject.GetComponent(); - canvas.renderMode = RenderMode.ScreenSpaceOverlay; - Undo.RegisterCreatedObjectUndo(canvasObject, "Create Canvas"); - } + PrefabStage stage = PrefabStageUtility.GetCurrentPrefabStage(); + Transform parent = stage != null + ? stage.prefabContentsRoot.transform + : FindParentForScene(); + var chart = new GameObject(name, typeof(RectTransform), typeof(T)); var rect = chart.GetComponent(); - rect.SetParent(canvas.transform, false); + if (parent != null) rect.SetParent(parent, false); rect.anchorMin = rect.anchorMax = new Vector2(0.5f, 0.5f); rect.pivot = new Vector2(0.5f, 0.5f); rect.sizeDelta = new Vector2(600f, 360f); + Undo.RegisterCreatedObjectUndo(chart, "Create XChart"); Selection.activeGameObject = chart; + + if (stage != null) + { + EditorSceneManager.MarkSceneDirty(stage.scene); + } + + ValidateRenderingContext(chart); + } + + /// 选中项所在 Canvas 优先,其次直接挂在选中物体下;都没选中就建在场景根 + private static Transform FindParentForScene() + { + Transform selection = Selection.activeTransform; + if (selection == null) return null; + + Canvas canvas = selection.GetComponentInParent(); + if (canvas != null) return canvas.transform; + + return selection is RectTransform ? selection : null; + } + + /// 没有 Canvas 祖先时给出明确提示——否则现象是"什么都看不见",很难查 + private static void ValidateRenderingContext(GameObject chart) + { + if (chart.GetComponentInParent() != null) return; + Debug.LogWarning( + "XChart:这个图表没有 Canvas 祖先,UGUI 图元不会渲染(现象就是什么都看不到)。" + + "把它放到某个 Canvas 下,或在它上面挂一个 Canvas 组件。", chart); } } -} +} \ No newline at end of file diff --git a/Editor/XChart/XChartDataGenerators.cs b/Editor/XChart/XChartDataGenerators.cs new file mode 100644 index 0000000..1475ab7 --- /dev/null +++ b/Editor/XChart/XChartDataGenerators.cs @@ -0,0 +1,148 @@ +using System; +using System.Collections.Generic; + +namespace XericUI.XChart.Editor +{ + /// + /// 编辑器侧的测试数据生成器:面板与数据窗口共用同一套口径 + /// (原来"生成 32 条示例"写死在面板里,数据窗口要同一份形状就得抄一遍——抄一遍就会分叉)。 + /// + /// 一律走 TryAddRecord:时间戳按上一条 +1(记录表要求时间非递减), + /// 值个数必须等于数值维数量(否则模型直接拒收),所以先补齐/截断再提交。 + /// + public static class XChartDataGenerators + { + /// 螺旋矢量场一条记录占的数值维:起点 3 + 第二点 3 + 颜色 3(色相/饱和/明度) + public const int VectorFieldDimensions = 9; + + /// 螺旋上参数 t∈[0,1] 的那个点(一圈正弦/余弦配线性 x) + private static void Spiral(float t, out float x, out float y, out float z) + { + x = Lerp(-100f, 100f, t); + y = (float)Math.Sin(t * Math.PI * 2.0) * 50f; + z = (float)Math.Cos(t * Math.PI * 2.0) * 50f; + } + + /// 螺旋:一圈正弦/余弦配线性 x——现有"生成 32 条示例"就是它。 + public static int AppendSpiral(XChartDataModel model, int count) + { + if (model == null || count <= 0) return 0; + + int accepted = 0; + for (int i = 0; i < count; i++) + { + float t = count > 1 ? i / (float)(count - 1) : 0f; + float x, y, z; + Spiral(t, out x, out y, out z); + if (!TryAppend3(model, x, y, z)) break; + accepted++; + } + return accepted; + } + + /// + /// 螺旋矢量场:一条记录 9 个数值维 [x, y, z, nx, ny, nz, h, s, v]—— + /// 前三维是这一条的点,中三维是下一个点,后三维是颜色(色相 0..256 走色环,饱和/明度都是 1)。 + /// + /// 为什么中三维取"下一个点":两种读法都能一眼分出来(他 2026-10-25 的描述)—— + /// 相对:箭头由本点指向下一点 ⇒ 一串首尾相接、顺着螺旋转; + /// 绝对:后三维当方向矢量用 ⇒ 每根朝"下一点的坐标方向"散开,看起来像一片刺猬。 + /// + /// 维数不够会先把列补出来(测试数据的判据是"点一下就能看到东西", + /// 而不是"提示他先去加六列");表里原有的记录会被清掉——它就是一份示例数据。 + /// + public static int AppendSpiralVectorField(XChartDataModel model, int count) + { + if (model == null || count <= 0) return 0; + + EnsureNumericDimensions(model, VectorFieldDimensions); + if (model.NumericDimensionCount < VectorFieldDimensions) return 0; + + model.Clear(); + int accepted = 0; + var values = new float[VectorFieldDimensions]; + for (int i = 0; i < count; i++) + { + float t = count > 1 ? i / (float)(count - 1) : 0f; + float tNext = count > 1 ? (i + 1) / (float)(count - 1) : 0f; + Spiral(t, out values[0], out values[1], out values[2]); + Spiral(tNext, out values[3], out values[4], out values[5]); + values[6] = 256f * t; // 色相:0..256 正好走完一圈色环 + values[7] = 1f; // 饱和度 + values[8] = 1f; // 明度 + if (!TryAppend(model, values)) break; + accepted++; + } + return accepted; + } + + /// 把数值维补到至少 个(按"数值维个数"补,不按表行数)。 + private static void EnsureNumericDimensions(XChartDataModel model, int wanted) + { + if (model.NumericDimensionCount >= wanted) return; + + var dimensions = new List(model.Dimensions); + int numeric = model.NumericDimensionCount; + for (int i = numeric; i < wanted; i++) + { + dimensions.Add(new XChartDimensionDefinition("v" + i, "V" + i, XChartDimensionKind.Number)); + } + model.SetDimensions(dimensions); + } + + /// + /// 平方和金字塔:第 k 层是 k×k 个顶点(1、4、9、16 ⇒ 30 个), + /// 层内 x/y 铺满 [-(k-1)/2, +(k-1)/2],z = k 逐层升高 + /// ⇒ 层数越高、点越多、位置越高的阶梯金字塔。 + /// + public static int AppendSquarePyramid(XChartDataModel model, int layers) + { + if (model == null || layers <= 0) return 0; + + int accepted = 0; + for (int k = 1; k <= layers; k++) + { + float half = (k - 1) * 0.5f; + for (int i = 0; i < k; i++) + { + for (int j = 0; j < k; j++) + { + float x = i - half; + float y = j - half; + if (!TryAppend3(model, x, y, k)) return accepted; + accepted++; + } + } + } + return accepted; + } + + /// 追加一条:前三个数值维按顺序喂 x / y / z(其余补 0)。 + public static bool TryAppend3(XChartDataModel model, float x, float y, float z) + { + if (model == null) return false; + + int dimensions = model.NumericDimensionCount; + if (dimensions <= 0) return false; + + var values = new float[dimensions]; + if (dimensions > 0) values[0] = x; + if (dimensions > 1) values[1] = y; + if (dimensions > 2) values[2] = z; + return TryAppend(model, values); + } + + /// 追加一条:时间戳 = 上一条 +1(空表从 0 开始),其余交给模型校验。 + public static bool TryAppend(XChartDataModel model, float[] values) + { + if (model == null || values == null) return false; + + double timestamp = model.RecordCount > 0 + ? model.GetTimeAt(model.RecordCount - 1) + 1.0 + : 0.0; + return model.TryAddRecord(timestamp, values); + } + + private static float Lerp(float from, float to, float t) => from + (to - from) * t; + } +} \ No newline at end of file diff --git a/Editor/XChart/XChartDataGenerators.cs.meta b/Editor/XChart/XChartDataGenerators.cs.meta new file mode 100644 index 0000000..f9387d5 --- /dev/null +++ b/Editor/XChart/XChartDataGenerators.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 44cc42a4675d3ad489defb98a68854c0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/XChart/XChartDataWindow.cs b/Editor/XChart/XChartDataWindow.cs new file mode 100644 index 0000000..234e273 --- /dev/null +++ b/Editor/XChart/XChartDataWindow.cs @@ -0,0 +1,1161 @@ +using System; +using System.Collections.Generic; +using System.IO; +using UnityEditor; +using UnityEditor.UIElements; +using UnityEngine; +using UnityEngine.UIElements; + +namespace XericUI.XChart.Editor +{ + /// + /// 数据窗口:浏览 / 导入 / 导出 / 复制粘贴图表数据(UI Toolkit + 行虚拟化)。 + /// + /// 虚拟化落在 UI 层:数据本身仍是 里那张内存记录表 + /// (没有分页、没有懒加载)。这里的虚拟化指"只有滚到可见范围的那几行才被绑定"—— + /// 窗口顶部会自报"已绑定次数 / 总行数",一万条数据下这个次数应该停在几十,而不是一万。 + /// + /// 格式只有一份:导出、导入、复制、粘贴全都走 , + /// 所以"复制出来的文本"和"导出的文件"逐字节同源(规范 §3)。 + /// + public sealed class XChartDataWindow : EditorWindow + { + private XChartBase m_Chart; + private ObjectField m_ChartField; + private VisualElement m_TablePane; + private ScrollView m_RangePane; + private VisualElement m_RangeRows; + private ToolbarToggle m_TableTab; + private ToolbarToggle m_RangeTab; + private VisualElement m_Header; + private ListView m_List; + private Label m_Stats; + private TextField m_CapacityField; + private Label m_BindReadout; + private Label m_Message; + private int m_BindCount; + private int m_LastBoundIndex = -1; + private int m_DimensionCount = -1; + + /// 每一列对应的值下标(-1=这一列不占值格);表头与格子共用,规则来自 + private int[] m_ColumnValueSlots = new int[0]; + + /// 上面那组的签名:换一张同列数但种类不同的图时,旧行里的格子必须重造 + private string m_ColumnValueSignature = string.Empty; + + /// 范围页是在哪一份值格分布上建的:对不上就整页重建(一列一行不能指错列) + private string m_RangeSignature = string.Empty; + private bool m_Applying; + private bool m_ShowRangeTab; + + /// 维度范围页里每个维度一行控件(重建只在列数变化时发生,改数只刷读数) + private readonly List m_DimensionRows = new List(); + + // 列宽:表头与行里的格子共用同一组常量,否则表头和内容会错位 + private const float kIndexWidth = 60f; + private const float kTimeWidth = 110f; + private const float kCellWidth = 100f; + private const float kAddColumnWidth = 26f; + private const float kDeleteWidth = 26f; + private const float kOverrideFieldWidth = 90f; + + /// 表页的操作帮助:只作 tooltip,不占界面(他 2026-10-25:"描述性信息太多、语法不简洁") + private const string kListHint = + "时间与数值列可直接改(回车或点开别处提交,改不动会说明原因并回填原值);标签列只读。" + + "末行「+ 添加一行」加记录;行末「-」删这一行;表头「+」加一列、「×」删一列" + + "(删列连同整列的值一起删,动手前整表已复制到剪贴板)。" + + "整表改法走「导出到剪贴板 → 改文本 → 从剪贴板替换」,导出的文件与剪贴板是同一份格式。"; + + /// 范围页的操作帮助:同样只作 tooltip + private const string kRangeHint = + "一列两行:标题是名字与值下标 [n],第二行是这一列的真实统计;两端各一个开关带一个格子。" + + "勾上才生效,没勾的那端跟着数据跑;钉住的那端会盖住自动值域。"; + + [MenuItem("Tools/XChart/数据窗口")] + private static void OpenFromMenu() + { + var window = GetWindow("XChart 数据"); + window.TryAdoptSelection(); + window.RebuildList(); + } + + /// 供面板按钮调用:"打开这张图的数据窗口" + public static void OpenFor(XChartBase chart) + { + var window = GetWindow("XChart 数据"); + window.m_Chart = chart; + window.BindChartField(); + window.RebuildList(); + window.Repaint(); + } + + private void TryAdoptSelection() + { + if (m_Chart != null) return; + m_Chart = Selection.activeGameObject != null + ? Selection.activeGameObject.GetComponent() + : null; + } + + private void OnEnable() + { + BuildUI(); + } + + private void OnFocus() + { + // 别处(面板/脚本)改了数据以后回到这个窗口要看到新的 + RebuildList(); + } + + private void BuildUI() + { + rootVisualElement.Clear(); + m_DimensionRows.Clear(); + + // ── 顶部:动作(导出 / 导入 / 清空 / 测试 / 强制刷新)──────────────── + // 工具栏控件一律用 Toolbar* 那一族(ToolbarMenu / ToolbarButton / ToolbarToggle), + // 它们自带工具栏的尺寸与配色,和窗口里其它按钮混用会显得是两种界面。 + // "图表"这个引用字段不在这里——它属于"我现在看的是哪张图",归底部状态栏右侧。 + var toolbar = new Toolbar(); + toolbar.Add(MakeMenu("导出", + ("到剪贴板", (Action)ExportToClipboard), + ("到文件…", (Action)ExportToFile))); + toolbar.Add(MakeMenu("导入", + ("从剪贴板替换", () => ImportFromClipboard(true)), + ("从剪贴板追加", () => ImportFromClipboard(false)), + ("从文件替换…", () => ImportFromFile(true)), + ("从文件追加…", () => ImportFromFile(false)))); + toolbar.Add(MakeMenu("清空", ("清空全部记录", (Action)ClearData))); + toolbar.Add(MakeMenu("测试", + ("螺旋 32(一圈正弦/余弦)", AppendTestSpiral), + ("螺旋矢量场 32(9 维:起点+第二点+色相/饱和/明度)", AppendTestVectorField), + ("平方和金字塔 30(1+4+9+16)", AppendTestPyramid))); + toolbar.Add(new ToolbarButton(ForceRefreshNow) { text = "强制刷新", tooltip = "改完数据直接重画一次图,不用回界面乱点" }); + + var bindToggle = new ToolbarToggle { text = "绑定读数", value = false }; + bindToggle.RegisterValueChangedCallback(evt => m_BindReadout.style.display = + evt.newValue ? DisplayStyle.Flex : DisplayStyle.None); + toolbar.Add(bindToggle); + rootVisualElement.Add(toolbar); + + m_BindReadout = new Label { style = { display = DisplayStyle.None } }; + rootVisualElement.Add(m_BindReadout); + + // ── 中部:两页(数据表 / 维度范围),同一时刻只显示一页 ────────────── + var panes = new VisualElement { style = { flexGrow = 1 } }; + + m_TablePane = new VisualElement { style = { flexGrow = 1 } }; + // 表头:#(记录下标,只读)/ 时间 / 各维度(就地改名 + 删列)/ +加一列 / 标签 / 删位 + m_Header = new VisualElement { style = { flexDirection = FlexDirection.Row, flexShrink = 0 } }; + m_TablePane.Add(m_Header); + + m_List = new ListView + { + fixedItemHeight = 20, + selectionType = SelectionType.Single, + showAlternatingRowBackgrounds = AlternatingRowBackground.ContentOnly, + }; + m_List.style.flexGrow = 1; + m_List.makeItem = MakeRow; + m_List.bindItem = BindRow; + m_List.tooltip = kListHint; + m_TablePane.Add(m_List); + + m_RangePane = new ScrollView { style = { flexGrow = 1, display = DisplayStyle.None } }; + // 滚动内容一律 flexShrink=0:窗口矮了要能滚,而不是把最上面那一行压扁成"两行叠着画" + // (他 2026-10-25 现场:第一列的统计行与开关行重叠,后面几列却正常——就是被挤掉高度的那一行) + var rangeBody = new VisualElement { style = { flexShrink = 0 } }; + m_RangeRows = new VisualElement { style = { flexShrink = 0 }, tooltip = kRangeHint }; + rangeBody.Add(m_RangeRows); + m_RangePane.Add(rangeBody); + // 滚动容器自己的内容也要不许收缩:收缩会发生在"这一整页"上,压扁的就是最上面那一行 + m_RangePane.contentContainer.style.flexShrink = 0; + panes.Add(m_TablePane); + panes.Add(m_RangePane); + rootVisualElement.Add(panes); + + // ── 标签条(在窗口下面,不在上面:表是主视图,切下去才看到范围页)────── + var tabs = new Toolbar(); + m_TableTab = new ToolbarToggle { text = "数据表", value = true }; + m_RangeTab = new ToolbarToggle { text = "维度范围", value = false }; + m_TableTab.RegisterValueChangedCallback(evt => SelectTab(evt.newValue ? 0 : 1)); + m_RangeTab.RegisterValueChangedCallback(evt => SelectTab(evt.newValue ? 1 : 0)); + tabs.Add(m_TableTab); + tabs.Add(m_RangeTab); + rootVisualElement.Add(tabs); + + // ── 底部状态栏:计数 + 缓冲上限(就地可改)+ 图表引用(右侧)────────── + var status = new Toolbar(); + m_Stats = new Label(); + status.Add(m_Stats); + status.Add(new ToolbarSpacer { style = { flexGrow = 1 } }); + status.Add(new Label("缓冲")); + m_CapacityField = new TextField { style = { width = 70 }, tooltip = + "数据模型的缓冲上限:写入超过它才从最旧的记录开始丢;改小不会立刻裁剪,改大也找不回已经丢掉的" }; + HookCommit(m_CapacityField, CommitCapacity); // 与单元格同一套提交时机(回车 / 失焦) + status.Add(m_CapacityField); + status.Add(new ToolbarSpacer { style = { width = 10f } }); + m_ChartField = new ObjectField("图表") + { + objectType = typeof(XChartBase), + allowSceneObjects = true, + style = { width = 240, flexShrink = 0 }, + tooltip = "这个窗表现在作用在哪张图上(改它等于换一个表)", + }; + m_ChartField.RegisterValueChangedCallback(evt => + { + m_Chart = evt.newValue as XChartBase; + RebuildColumns(); + RebuildList(); + }); + status.Add(m_ChartField); + rootVisualElement.Add(status); + + m_Message = new Label(); + rootVisualElement.Add(m_Message); + + BindChartField(); + RebuildColumns(); + RebuildList(); + SelectTab(m_ShowRangeTab ? 1 : 0); + } + + /// + /// 切页:两个 当一个互斥标签条用(点哪个看哪个, + /// 点当前这个就翻到另一页——两页的标签条不需要第三个状态)。 + /// + private void SelectTab(int index) + { + bool range = index == 1; + m_ShowRangeTab = range; + m_TableTab.SetValueWithoutNotify(!range); + m_RangeTab.SetValueWithoutNotify(range); + m_TablePane.style.display = range ? DisplayStyle.None : DisplayStyle.Flex; + m_RangePane.style.display = range ? DisplayStyle.Flex : DisplayStyle.None; + if (range) RefreshDimensionRows(); + } + + /// + /// 算出"每一列对应的值下标"与它的签名。表头、行里的格子、范围页都读这一份, + /// 于是"这一列有没有值"这件事全窗口只有一个答案(口径来自 )。 + /// 签名而不是个数:两张表可以同样 3 列但"哪一列有值格"完全不同(换图时旧格子必须重造)。 + /// + private void ComputeColumnSlots(XChartDataModel model) + { + int dimensions = model != null ? model.Dimensions.Count : 0; + m_ColumnValueSlots = new int[dimensions]; + for (int i = 0; i < dimensions; i++) + m_ColumnValueSlots[i] = XChartColumnMath.ValueSlot(model.Dimensions, i); + + var signature = new System.Text.StringBuilder(); + for (int i = 0; i < dimensions; i++) signature.Append(m_ColumnValueSlots[i]).Append('|'); + m_ColumnValueSignature = signature.ToString(); + } + + /// 工具栏上的一个下拉:条目按顺序排,点哪个跑哪个 + private static ToolbarMenu MakeMenu(string text, params (string label, Action action)[] items) + { + var menu = new ToolbarMenu { text = text }; + for (int i = 0; i < items.Length; i++) + { + var item = items[i]; + menu.menu.AppendAction(item.label, _ => item.action()); + } + return menu; + } + + private void BindChartField() + { + if (m_ChartField != null) m_ChartField.SetValueWithoutNotify(m_Chart); + } + + /// + /// 表头:#(记录下标,只读)/ 时间 / 每个维度(就地改名)/ +(加一列)/ 标签。 + /// 列宽与行里的格子共用同一组常量,否则表头和内容会错位。 + /// + private void RebuildColumns() + { + if (m_Header == null) return; + m_Header.Clear(); + + // 每一列对应的**值下标**先算好(表头、格子、范围页都读这一份) + var model = m_Chart != null ? m_Chart.DataModel : null; + ComputeColumnSlots(model); + int dimensions = model != null ? model.Dimensions.Count : 0; + m_DimensionCount = dimensions; + + m_Header.Add(new Label("#") + { + style = { width = kIndexWidth }, + tooltip = "记录下标:0 = 最早,n-1 = 最新。所有工具都按这个顺序取数" + + "(圆柱就是按它两两分组:0-1、2-3…)。它不是数据,不可改。", + }); + m_Header.Add(new Label("时间") { style = { width = kTimeWidth } }); + + for (int i = 0; i < dimensions; i++) + { + int index = i; + int valueSlot = m_ColumnValueSlots[i]; + var cell = new VisualElement { style = { flexDirection = FlexDirection.Row, width = kCellWidth } }; + + var name = new TextField { style = { flexGrow = 1 } }; + name.SetValueWithoutNotify(ColumnName(model, index)); + name.tooltip = "列标题=这一维的显示名;改它只改显示名,维度序号不动" + + (valueSlot < 0 ? "(这一列不占值格:种类不是 Number)" : string.Empty); + name.RegisterCallback(evt => + { + if (evt.keyCode != KeyCode.Return && evt.keyCode != KeyCode.KeypadEnter) return; + RenameColumn(index, name.value); + evt.StopPropagation(); + }); + name.RegisterCallback(_ => RenameColumn(index, name.value)); + cell.Add(name); + + cell.Add(new ToolbarButton(() => DeleteColumn(index)) + { + text = "×", + style = { width = 20 }, + tooltip = "删掉这一列(连同它每一行的值):后面的列号整体前移," + + "绑在这些列上的工具要重新对一遍序号", + }); + m_Header.Add(cell); + } + + m_Header.Add(new ToolbarButton(AddColumn) + { + text = "+", + style = { width = kAddColumnWidth }, + tooltip = "加一列(新增一个数值维,默认名 D,随后可在这里改名)", + }); + m_Header.Add(new Label("标签") { style = { flexGrow = 1 }, tooltip = "记录自带的标签(只读)" }); + // 行末"删"那一格的位置:表头留同样的宽度,否则标签列和删列对不齐 + m_Header.Add(new Label { style = { width = kDeleteWidth } }); + } + + private static string ColumnName(XChartDataModel model, int index) + { + if (model == null || index < 0 || index >= model.Dimensions.Count) return "-"; + var definition = model.Dimensions[index]; + if (definition == null) return "D" + index; + return string.IsNullOrEmpty(definition.DisplayName) ? "D" + index : definition.DisplayName; + } + + /// 改一维的显示名(只动显示名,序号/键都不动) + private void RenameColumn(int index, string displayName) + { + var model = m_Chart != null ? m_Chart.DataModel : null; + if (model == null) return; + + if (!model.TryRenameDimension(index, displayName)) + { + SetMessage("第 " + index + " 列改不了名(不能是空名,或下标越界)"); + RebuildColumns(); // 回填现况,别让控件显示一个没生效的名字 + return; + } + + EditorUtility.SetDirty(m_Chart); + m_Chart.ForceRefresh(); + RebuildColumns(); + SetMessage("第 " + index + " 列改名为「" + displayName.Trim() + "」"); + } + + /// 加一列=新增一个数值维;老记录的这一维会补 0(SetDimensions 会重排每行的值数组) + private void AddColumn() + { + var model = m_Chart != null ? m_Chart.DataModel : null; + if (model == null) { SetMessage("先指定一个图表"); return; } + + var dimensions = new List(model.Dimensions); + string key = "d" + dimensions.Count; + dimensions.Add(new XChartDimensionDefinition(key, "D" + dimensions.Count, XChartDimensionKind.Number)); + model.SetDimensions(dimensions); + EditorUtility.SetDirty(m_Chart); + m_Chart.ForceRefresh(); + + RebuildColumns(); + RebuildList(); + SetMessage("已加一列(" + key + "):老记录这一维补 0"); + } + + /// + /// 删一列=删掉一个维度定义,连同每一行的那一格。 + /// 破坏性动作要看得见代价:先把整表留在剪贴板(和"清空"同一个安全网),再要一次确认—— + /// 删掉的列不能从"改大缓冲上限"那种操作里找回来。 + /// + private void DeleteColumn(int index) + { + var model = m_Chart != null ? m_Chart.DataModel : null; + if (model == null) { SetMessage("先指定一个图表"); return; } + if (index < 0 || index >= model.Dimensions.Count) + { + SetMessage("第 " + index + " 列已经不在表里了(先刷新一次)"); + RebuildColumns(); + return; + } + + string name = ColumnName(model, index); + EditorGUIUtility.systemCopyBuffer = XChartDataText.Export(model); + if (!EditorUtility.DisplayDialog("删除第 " + index + " 列?", + "「" + name + "」连同它在 " + model.RecordCount + " 行里的值一起删掉。\n" + + "后面的列号整体前移:绑在这些列上的工具(轴的维度、圆柱的 X/Y/Z)要重新对一遍。\n" + + "整表已先复制到剪贴板,误删可以导回来。", "删除", "取消")) + { + SetMessage("已取消删列"); + return; + } + + string reason; + if (!model.TryRemoveDimension(index, out reason)) + { + SetMessage("删不掉第 " + index + " 列:" + reason); + return; + } + + EditorUtility.SetDirty(m_Chart); + m_Chart.ForceRefresh(); + RebuildColumns(); + RebuildList(); + SetMessage("已删掉第 " + index + " 列(" + name + "):现在 " + model.Dimensions.Count + + " 列,每行 " + model.NumericDimensionCount + " 个值"); + } + + /// 强制重画一次图(改完数据不用回界面乱点) + private void ForceRefreshNow() + { + if (!EnsureChart()) return; + m_Chart.ForceRefresh(); + RebuildList(); + SetMessage("已强制刷新"); + } + + private void AppendTestSpiral() => AppendTest("螺旋", XChartDataGenerators.AppendSpiral, 32); + + private void AppendTestVectorField() + => AppendTest("螺旋矢量场", XChartDataGenerators.AppendSpiralVectorField, 32, false); + + private void AppendTestPyramid() => AppendTest("平方和金字塔", XChartDataGenerators.AppendSquarePyramid, 4); + + /// 生成器是否要求表里**已经**有数值维。 + /// 矢量场那份自己会把列补出来("点一下就能看到东西"才是测试数据的用处),所以传 false。 + private void AppendTest(string label, Func generator, int argument, + bool needsDimensions = true) + { + if (!EnsureChart()) return; + + var model = m_Chart.DataModel; + int dimensions = model.NumericDimensionCount; + if (needsDimensions && dimensions <= 0) + { + SetMessage("这个数据模型没有数值维,先加一列"); + return; + } + + int before = model.RecordCount; + int accepted = generator(model, argument); + m_Chart.ForceRefresh(); + RebuildList(); + SetMessage("已生成" + label + ":" + accepted + " 条(行数 " + before + " → " + model.RecordCount + + ",时间戳接在最后一条之后)"); + } + + /// 末行那个按钮:加一条记录(值全 0,时间戳 = 上一条 +1) + private void AddRecord() + { + var model = m_Chart != null ? m_Chart.DataModel : null; + if (model == null) { SetMessage("先指定一个图表"); return; } + if (model.NumericDimensionCount <= 0) { SetMessage("这个数据模型没有数值维,先加一列"); return; } + + var values = new float[model.NumericDimensionCount]; + if (!XChartDataGenerators.TryAppend(model, values)) + { + SetMessage("加不了这一行(时间戳必须非递减,或值不是有限数)"); + return; + } + + EditorUtility.SetDirty(m_Chart); + m_Chart.ForceRefresh(); + RebuildList(); + SetMessage("已添加一行(时间戳 = 上一条 +1,值全 0,可直接在行里改)"); + } + + private VisualElement MakeRow() + { + var row = new VisualElement { style = { flexDirection = FlexDirection.Row, alignItems = Align.Center } }; + + // 格子装在自己的容器里:末行的"+ 添加一行"要和格子互斥显示,两种布局不能挤在同一层。 + // 格子的引用统一装在 RowWidgets 上(cells.userData):按位置数格子会随列数错位, + // 上一版就是这么数的,加一列之后"标签"那一格会去吃数值格。 + var cells = new VisualElement { name = "row-cells", style = { flexDirection = FlexDirection.Row, flexGrow = 1 } }; + var widgets = new RowWidgets(); + cells.userData = widgets; + + widgets.Index = new Label { style = { width = kIndexWidth } }; + cells.Add(widgets.Index); + + // 单元格就地编辑:时间与数值列是 TextField(回车或失焦提交),标签列只读。 + // userData 记"这一格是哪个槽":-1=时间列,>=0=数值维下标。 + // 时间列的格子没有值下标:CommitCell 用"是不是 widgets.Time 这一格"来分派, + // 不靠给 userData 塞 -1 这种两个含义撞在一个数上的写法(-1 已经被"不占值格"占了) + widgets.Time = new TextField { style = { width = kTimeWidth } }; + HookCommit(widgets.Time, () => CommitCell(widgets.Time)); + cells.Add(widgets.Time); + + int dimensions = Mathf.Max(m_DimensionCount, 0); + widgets.Values = new TextField[dimensions]; + widgets.Slots = m_ColumnValueSignature; + for (int i = 0; i < dimensions; i++) + { + int valueSlot = i < m_ColumnValueSlots.Length ? m_ColumnValueSlots[i] : -1; + var cell = new TextField { userData = valueSlot, style = { width = kCellWidth } }; + if (valueSlot < 0) + { + // 非数值列:没有对应的值格。留一个禁用的格子而不是让人填进去再被拒—— + // 他填过却存不进去,比一眼看出"这一格不归我改"更坏。 + cell.SetEnabled(false); + cell.tooltip = "这一列的种类不是 Number ⇒ 它不占值格(值数组里没有它的位置)"; + } + else HookCommit(cell, () => CommitCell(cell)); + widgets.Values[i] = cell; + cells.Add(cell); + } + + widgets.Labels = new Label { style = { flexGrow = 1 } }; + cells.Add(widgets.Labels); + + widgets.Delete = new ToolbarButton(() => DeleteRecord(widgets)) + { + text = "-", // 一个符号就够(他 2026-10-25:"删除按钮应该改为 -,而不是一个'删'") + style = { width = kDeleteWidth }, + tooltip = "删掉这一行=删掉这一条记录(后面的行号整体前移;记录表本来就按时间排,删一条不会打乱顺序)", + }; + cells.Add(widgets.Delete); + + row.Add(cells); + + var add = new ToolbarButton(AddRecord) + { + name = "row-add", + text = "+ 添加一行", + style = { display = DisplayStyle.None }, + }; + row.Add(add); + return row; + } + + /// + /// 拿到这条行控件的引用集;列数和当前不一致就整条重造—— + /// 列表回收的是行控件本身,回收来的旧行还带着上一轮的格子数,直接用会少画一列。 + /// + private RowWidgets EnsureWidgets(VisualElement element) + { + var existing = element.Q("row-cells"); + var widgets = existing != null ? existing.userData as RowWidgets : null; + int want = Mathf.Max(m_DimensionCount, 0); + // 列数一样但"哪一列有值格"变了(换了一张同列数、种类不同的图):格子的可编辑性与 + // 值下标都记在格子上,只看列数会把这一列当成能改的,于是往错的列写数 + if (widgets != null && widgets.Values != null && widgets.Values.Length == want + && widgets.Slots == m_ColumnValueSignature) return widgets; + + element.Clear(); + var fresh = MakeRow(); + for (int i = fresh.childCount - 1; i >= 0; i--) + { + var child = fresh[i]; + fresh.Remove(child); + element.Insert(0, child); + } + + var cells = element.Q("row-cells"); + return cells != null ? cells.userData as RowWidgets : null; + } + + private void HookCommit(TextField field, Action commit) + { + field.RegisterCallback(evt => + { + if (evt.keyCode != KeyCode.Return && evt.keyCode != KeyCode.KeypadEnter) return; + commit(); + evt.StopPropagation(); + }); + field.RegisterCallback(_ => commit()); + } + + private void BindRow(VisualElement element, int index) + { + m_BindCount++; + m_LastBoundIndex = index; + // 绑定期间控件会失焦/改值:这一段不许被当成用户编辑(否则回填会被写回数据) + m_Applying = true; + + var model = m_Chart != null ? m_Chart.DataModel : null; + int total = model != null ? model.RecordCount : 0; + + var widgets = EnsureWidgets(element); + var add = element.Q("row-add"); + bool isAddRow = model != null && index >= total; + + var cells = element.Q("row-cells"); + if (cells != null) cells.style.display = isAddRow ? DisplayStyle.None : DisplayStyle.Flex; + if (add != null) add.style.display = isAddRow ? DisplayStyle.Flex : DisplayStyle.None; + + if (widgets != null) widgets.RecordIndex = isAddRow || model == null ? -1 : index; + if (widgets != null && !isAddRow) BindRowCore(widgets, index); + + m_Applying = false; + UpdateStats(); + } + + /// + /// 提交一格:解析失败/越界/时间倒序都明确报因并把该行按模型现况回填—— + /// 控件显示与数据不一致比改不动更坏。 + /// + private void CommitCell(TextField field) + { + if (m_Applying || m_Chart == null) return; + + var cells = field.parent; + var widgets = cells != null ? cells.userData as RowWidgets : null; + if (widgets == null || widgets.RecordIndex < 0) return; + int recordIndex = widgets.RecordIndex; + bool isTime = ReferenceEquals(field, widgets.Time); + int slot = field.userData is int value ? value : -1; + if (!isTime && slot < 0) return; // 非数值列的格子是禁用的,压根不该走到这里 + + var model = m_Chart.DataModel; + if (model == null || recordIndex < 0 || recordIndex >= model.RecordCount) return; + + double parsed; + if (!double.TryParse(field.value, System.Globalization.NumberStyles.Float, + System.Globalization.CultureInfo.InvariantCulture, out parsed)) + { + SetMessage("\"" + field.value + "\" 不是数字,已回填原值"); + RefreshRow(widgets, recordIndex); + return; + } + + string reason = null; + bool ok = isTime + ? model.TrySetTime(recordIndex, parsed, out reason) + : model.TrySetValue(recordIndex, slot, parsed); + + if (!ok) + { + SetMessage("第 " + recordIndex + " 行改不动:" + (reason ?? "数值维下标越界,或值不是有限数")); + RefreshRow(widgets, recordIndex); + return; + } + + m_Chart.ForceRefresh(); + SetMessage("第 " + recordIndex + " 行已改(" + (isTime ? "时间戳" : "第 " + slot + " 个数值维") + ")"); + RefreshDimensionRows(); + } + + private void RefreshRow(RowWidgets widgets, int recordIndex) + { + m_Applying = true; + BindRowCore(widgets, recordIndex); + m_Applying = false; + } + + /// 只按模型现况重填一行的格子(不计数、不动统计:回填用) + private void BindRowCore(RowWidgets widgets, int index) + { + var model = m_Chart != null ? m_Chart.DataModel : null; + if (model == null || widgets == null) return; + if (index < 0 || index >= model.RecordCount) return; + widgets.RecordIndex = index; + + widgets.Index.text = "#" + index; + widgets.Time.SetValueWithoutNotify(model.GetTimeAt(index).ToString("0.###")); + + for (int d = 0; d < widgets.Values.Length; d++) + { + if (widgets.Values[d] == null) continue; + // 格子的下标是**表里的列号**,值数组的下标是**第几个数值列**:中间夹一个非数值列时 + // 两者就差开了,所以这里问的是行控件建好时记下的那一对(widgets.Slots)。 + int slot = d < m_ColumnValueSlots.Length ? m_ColumnValueSlots[d] : -1; + string text = slot >= 0 ? model.GetValueAt(index, slot).ToString("0.####") : "-"; + widgets.Values[d].SetValueWithoutNotify(text); + } + + var record = model.Records[index]; + widgets.Labels.text = record.Labels.Count > 0 ? string.Join(", ", record.Labels) : string.Empty; + } + + /// 删一行=删一条记录。删完立刻重排行号(列表多/少一行都要跟着改) + private void DeleteRecord(RowWidgets widgets) + { + var model = m_Chart != null ? m_Chart.DataModel : null; + if (model == null) { SetMessage("先指定一个图表"); return; } + + int index = widgets != null ? widgets.RecordIndex : -1; + string reason; + if (!model.TryRemoveRecord(index, out reason)) + { + SetMessage("删不掉第 " + index + " 行:" + reason); + RebuildList(); // 行号是从上一次绑定抄来的:先让它跟现况对齐 + return; + } + + EditorUtility.SetDirty(m_Chart); + m_Chart.ForceRefresh(); + RebuildList(); + SetMessage("已删掉第 " + index + " 行:现在 " + model.RecordCount + " 行" + + "(后面每行的行号 −1;时间顺序不会因此变乱)"); + } + + private void UpdateStats() + { + var model = m_Chart != null ? m_Chart.DataModel : null; + int total = model != null ? model.RecordCount : 0; + int dimensions = model != null ? model.Dimensions.Count : 0; + int capacity = model != null ? model.Capacity : 0; + + if (m_Stats != null) + { + m_Stats.text = "总行 " + total + " 维度 " + dimensions + + " 已丢弃 " + (model != null ? model.DroppedCount : 0); + } + + // 缓冲上限的读数就在状态栏里(可改):别处再放一份就会两处各说各话 + if (m_CapacityField != null && !m_Applying) + m_CapacityField.SetValueWithoutNotify(capacity.ToString()); + + if (m_BindReadout != null) + { + m_BindReadout.text = "已绑定次数 " + m_BindCount + " 最近绑定行 #" + m_LastBoundIndex + + "(虚拟化:这个次数应远小于总行数)"; + } + } + + /// 改缓冲上限(状态栏里的那个格子) + private void CommitCapacity() + { + if (m_Applying || m_Chart == null) return; + var model = m_Chart.DataModel; + if (model == null) { UpdateStats(); return; } + + int parsed; + if (!int.TryParse(m_CapacityField.value, out parsed) || parsed < 1) + { + UpdateStats(); // 回填现况 + SetMessage("缓冲上限要是个 ≥1 的整数,已回填原值"); + return; + } + + if (parsed == model.Capacity) return; + model.Capacity = parsed; + EditorUtility.SetDirty(m_Chart); + UpdateStats(); + SetMessage("缓冲上限 = " + model.Capacity + "(只影响之后的写入:到顶才从最旧的开始丢;" + + "改小不会立刻裁剪,改大也找不回已经丢掉的)"); + } + + private void RebuildList() + { + if (m_List == null) return; + + var model = m_Chart != null ? m_Chart.DataModel : null; + int dimensions = model != null ? model.Dimensions.Count : 0; + string previousSlots = m_ColumnValueSignature; + ComputeColumnSlots(model); + if (dimensions != m_DimensionCount || m_ColumnValueSignature != previousSlots) + { + m_DimensionCount = dimensions; + m_List.makeItem = MakeRow; // 列数变了:下一轮的可见行按新列数建 + RebuildColumns(); // 表头与格子共用列宽,必须一起重建 + } + + // 范围页一列一行:判"行数和列数/值格分布对不对得上"而不是判"列数变没变"—— + // 第一次打开(列数从来没变过)和换一张同列数但种类不同的图都走得到这里, + // 只盯"变化"的话这两处的范围页会是空的或指错列,而表看着完全正常。 + if (m_DimensionRows.Count != dimensions || m_RangeSignature != m_ColumnValueSignature) + RebuildDimensionRows(); + + // 行数 = 记录数 + 1:最后那一行专门放"+ 添加一行" + var items = new List(); + int total = model != null ? model.RecordCount : 0; + for (int i = 0; i <= total; i++) items.Add(i); + m_List.itemsSource = items; + m_List.Rebuild(); + + m_BindCount = 0; + m_LastBoundIndex = -1; + UpdateStats(); + RefreshDimensionRows(); // 统计与生效范围是数据的函数:行数变了它们也变 + SetMessage("已加载 " + total + " 行"); + } + + private void ExportToClipboard() + { + if (!EnsureChart()) return; + EditorGUIUtility.systemCopyBuffer = XChartDataText.Export(m_Chart.DataModel); + SetMessage("已复制到剪贴板:" + m_Chart.DataModel.RecordCount + " 条记录"); + } + + private void ImportFromClipboard(bool replace) + { + if (!EnsureChart()) return; + ApplyText(EditorGUIUtility.systemCopyBuffer, replace, "剪贴板"); + } + + private void ExportToFile() + { + if (!EnsureChart()) return; + string path = EditorUtility.SaveFilePanel("导出图表数据", string.Empty, "xchart-data.txt", "txt"); + if (string.IsNullOrEmpty(path)) return; + + File.WriteAllText(path, XChartDataText.Export(m_Chart.DataModel)); + SetMessage("已导出到 " + path); + } + + private void ImportFromFile(bool replace) + { + if (!EnsureChart()) return; + string path = EditorUtility.OpenFilePanel("导入图表数据", string.Empty, "txt"); + if (string.IsNullOrEmpty(path)) return; + + ApplyText(File.ReadAllText(path), replace, path); + } + + private void ApplyText(string text, bool replace, string source) + { + if (string.IsNullOrEmpty(text)) + { + SetMessage(source + " 里没有文本(先复制一份导出的数据?)"); + return; + } + + if (replace) + { + // 替换是破坏性的:先把原文留一份在剪贴板,误操作还能捞回来 + EditorGUIUtility.systemCopyBuffer = XChartDataText.Export(m_Chart.DataModel); + bool confirmed = EditorUtility.DisplayDialog("替换全部数据?", + "这会用 " + source + " 里的内容替换掉当前全部记录。\n" + + "当前数据已先复制到剪贴板(误操作可粘贴回来)。", "替换", "取消"); + if (!confirmed) + { + SetMessage("已取消替换"); + return; + } + } + + string error; + if (!XChartDataText.TryImport(text, m_Chart.DataModel, replace, out error)) + { + SetMessage("导入失败(没有改动任何数据):" + error); + return; + } + + m_Chart.ForceRefresh(); + RebuildList(); + SetMessage("导入成功(" + (replace ? "替换" : "追加") + "):现在 " + m_Chart.DataModel.RecordCount + " 条"); + } + + private void ClearData() + { + if (!EnsureChart()) return; + if (m_Chart.DataModel.RecordCount == 0) + { + SetMessage("本来就没有数据"); + return; + } + + EditorGUIUtility.systemCopyBuffer = XChartDataText.Export(m_Chart.DataModel); + if (!EditorUtility.DisplayDialog("清空数据?", "清空 " + m_Chart.DataModel.RecordCount + + " 条记录。\n当前数据已先复制到剪贴板。", "清空", "取消")) + { + SetMessage("已取消清空"); + return; + } + + m_Chart.ResetData(); + m_Chart.ForceRefresh(); + RebuildList(); + SetMessage("已清空"); + } + + // ── 维度范围页:一列一行(统计只读 + 两端各自可钉)────────────────────── + + /// + /// 建范围页的控件。只在列数变化时重建:格子/勾选框每敲一下都会发 change, + /// 重建会把正在输入的控件换掉(面板那边踩过同一次坑)。 + /// + private void RebuildDimensionRows() + { + if (m_RangeRows == null) return; + m_RangeRows.Clear(); + m_DimensionRows.Clear(); + + var model = m_Chart != null ? m_Chart.DataModel : null; + int dimensions = model != null ? model.Dimensions.Count : 0; + if (dimensions == 0) + { + m_RangeRows.Add(new Label("这个数据模型还没有列:回到「数据表」页,点表头的+加一列") + { + style = { marginLeft = 6, marginTop = 4 }, + }); + return; + } + + for (int i = 0; i < dimensions; i++) m_RangeRows.Add(MakeDimensionRowBox(model, i)); + m_RangeSignature = m_ColumnValueSignature; + RefreshDimensionRows(); + } + + private VisualElement MakeDimensionRowBox(XChartDataModel model, int index) + { + // Index=表里的列号(标题、删列用它),Slot=值数组里的那一格(统计、范围、覆盖用它) + var row = new DimensionRow + { + Index = index, + Slot = model != null ? XChartColumnMath.ValueSlot(model.Dimensions, index) : -1, + }; + + var box = new VisualElement + { + style = + { + flexShrink = 0, + marginLeft = 4, marginRight = 4, marginTop = 4, marginBottom = 4, + paddingLeft = 6, paddingRight = 6, paddingTop = 4, paddingBottom = 4, + borderTopWidth = 1, borderBottomWidth = 1, borderLeftWidth = 1, borderRightWidth = 1, + borderTopColor = new StyleColor(new Color(0.32f, 0.32f, 0.32f, 1f)), + borderBottomColor = new StyleColor(new Color(0.32f, 0.32f, 0.32f, 1f)), + borderLeftColor = new StyleColor(new Color(0.32f, 0.32f, 0.32f, 1f)), + borderRightColor = new StyleColor(new Color(0.32f, 0.32f, 0.32f, 1f)), + }, + }; + + // 三行各自 flexShrink=0 + 不许换行:一行装不下就宁可截断,也不许和邻行叠在一起 + var head = new VisualElement + { + style = { flexDirection = FlexDirection.Row, alignItems = Align.Center, flexShrink = 0 }, + }; + row.Title = new Label("维度 " + index) { style = { width = 120f, flexShrink = 0 } }; + row.Effective = new Label { style = { flexGrow = 1, whiteSpace = WhiteSpace.NoWrap } }; + head.Add(row.Title); + head.Add(row.Effective); + box.Add(head); + + row.Stats = new Label { style = { whiteSpace = WhiteSpace.NoWrap, flexShrink = 0 } }; + box.Add(row.Stats); + + var edit = new VisualElement + { + style = { flexDirection = FlexDirection.Row, alignItems = Align.Center, flexShrink = 0 }, + }; + row.PinMin = new Toggle("钉住最小") { tooltip = "勾上:这一维的最小端就用格子里的数,不再跟着数据跑" }; + row.Min = new TextField + { + style = { width = kOverrideFieldWidth }, + tooltip = "最小端的覆盖值(默认 0)。没勾时这个数留着但不参与解析;勾上立刻生效", + }; + row.PinMax = new Toggle("钉住最大") { tooltip = "勾上:这一维的最大端就用格子里的数,不再跟着数据跑" }; + row.Max = new TextField + { + style = { width = kOverrideFieldWidth }, + tooltip = "最大端的覆盖值(默认 0)。没勾时这个数留着但不参与解析;勾上立刻生效", + }; + HookCommit(row.Min, () => CommitOverride(row)); + HookCommit(row.Max, () => CommitOverride(row)); + row.PinMin.RegisterValueChangedCallback(_ => CommitOverride(row)); + row.PinMax.RegisterValueChangedCallback(_ => CommitOverride(row)); + edit.Add(row.PinMin); + edit.Add(row.Min); + edit.Add(row.PinMax); + edit.Add(row.Max); + box.Add(edit); + + m_DimensionRows.Add(row); + return box; + } + + /// + /// 按模型现况刷一遍范围页的读数。 + /// 只在范围页真的露出来时算:统计要扫全表(中位数还要排一次), + /// 在「数据表」页敲格子时算它,等于每敲一下都为一页看不见的东西扫一遍数据。 + /// + private void RefreshDimensionRows() + { + if (!m_ShowRangeTab || m_DimensionRows.Count == 0) return; + + var model = m_Chart != null ? m_Chart.DataModel : null; + const XChartAggregateMask mask = XChartAggregateMask.Count | XChartAggregateMask.Range + | XChartAggregateMask.Mean | XChartAggregateMask.Median | XChartAggregateMask.Rms; + + m_Applying = true; // 回填不许被当成用户编辑(与表里同一套护栏) + for (int i = 0; i < m_DimensionRows.Count; i++) + { + DimensionRow row = m_DimensionRows[i]; + string column = model != null ? ColumnName(model, row.Index) : "已经不在这张表里了"; + + if (model == null || row.Slot < 0) + { + // 表里的一行可以是 Label/Time:它有自己的键与显示名,但值数组里没有它的格子, + // 所以它既没有可统计的样本,也没有可以钉住的范围(工具根本不会按数值读它)。 + row.Title.text = column + " [-]"; + row.Stats.text = "不占值格"; + row.Effective.text = "种类不是 Number,工具不按数值读它"; + SetOverrideControlsEnabled(row, false); + continue; + } + SetOverrideControlsEnabled(row, true); + + XChartDimensionDefinition definition; + if (!model.TryGetDimension(row.Slot, out definition) || definition == null) + { + row.Title.text = "已经不在这张表里了"; + row.Stats.text = "-"; + row.Effective.text = "-"; + continue; + } + + // [n] 就是值下标(行的**位置**已经是表里的列号):两个号在全数值表上相同, + // 夹一个非数值列才错开,所以只印一个真正被工具使用的那个数 + row.Title.text = column + " [" + row.Slot + "]"; + + XChartAggregates aggregates = default; + bool computed = model.TryGetAggregates(row.Slot, mask, out aggregates); + row.Stats.text = computed ? StatsSummary(aggregates) : "统计:这一列还没有可统计的数值"; + + var over = definition.DomainOverride; + row.PinMin.SetValueWithoutNotify(over.HasMin); + row.PinMax.SetValueWithoutNotify(over.HasMax); + row.Min.SetValueWithoutNotify(definition.ManualRange.x.ToString("0.####")); + row.Max.SetValueWithoutNotify(definition.ManualRange.y.ToString("0.####")); + + double min, max; + bool drawable = XChartDomainMath.TryResolve(model, row.Slot, out min, out max); + // 哪一端被钉住由下面那两个勾直接看得见,这里不再复述一遍(同一件事只说一次) + row.Effective.text = drawable + ? "生效 " + Number(min) + " .. " + Number(max) + : "没有生效范围(没钉、没数据)"; + } + m_Applying = false; + } + + private static void SetOverrideControlsEnabled(DimensionRow row, bool enabled) + { + row.PinMin.SetEnabled(enabled); + row.Min.SetEnabled(enabled); + row.PinMax.SetEnabled(enabled); + row.Max.SetEnabled(enabled); + } + + /// + /// 提交一行的覆盖:两个勾 + 两个数一起交(改任一个都交一次全套, + /// 于是"勾了但格子还没填"这种半状态不会留在模型里)。 + /// + private void CommitOverride(DimensionRow row) + { + if (m_Applying || m_Chart == null) return; + var model = m_Chart.DataModel; + if (model == null) return; + if (row.Slot < 0) return; // 不占值的列:控件本来就是禁用的,走到这里也只当没发生 + + double min, max; + if (!TryFinite(row.Min.value, out min)) + { + SetMessage(ColumnName(model, row.Index) + " [" + row.Slot + "] 最小端「" + row.Min.value + "」不是有限数字,已回填"); + RefreshDimensionRows(); + return; + } + if (!TryFinite(row.Max.value, out max)) + { + SetMessage(ColumnName(model, row.Index) + " [" + row.Slot + "] 最大端「" + row.Max.value + "」不是有限数字,已回填"); + RefreshDimensionRows(); + return; + } + + if (!model.TrySetDomainOverride(row.Slot, row.PinMin.value, min, row.PinMax.value, max)) + { + SetMessage(ColumnName(model, row.Index) + " [" + row.Slot + "] 写不进去:已经不在这张表里了"); + RebuildColumns(); + RebuildDimensionRows(); + return; + } + + EditorUtility.SetDirty(m_Chart); + m_Chart.ForceRefresh(); + RefreshDimensionRows(); + // 回执报的是**结果**(这一维现在按哪个范围画),不是"我改了什么" + double appliedMin, appliedMax; + SetMessage(ColumnName(model, row.Index) + " [" + row.Slot + "] " + + (XChartDomainMath.TryResolve(model, row.Slot, out appliedMin, out appliedMax) + ? "生效 " + Number(appliedMin) + " .. " + Number(appliedMax) + : "没有生效范围")); + } + + /// 覆盖值的门口检查:非有限数一律不收(它会变成一个"画不出东西"的范围) + private static bool TryFinite(string text, out double value) + { + if (!double.TryParse(text, System.Globalization.NumberStyles.Float, + System.Globalization.CultureInfo.InvariantCulture, out value)) return false; + if (double.IsNaN(value) || double.IsInfinity(value)) { value = 0.0; return false; } + return true; + } + + /// 统计那一行:只列数,不写"统计:"这类前缀(界面串要短,他 2026-10-25) + private static string StatsSummary(XChartAggregates aggregates) + { + if (aggregates.Count == 0) return "样本 0"; + return "样本 " + aggregates.Count + " 最小 " + Number(aggregates.Minimum) + + " 最大 " + Number(aggregates.Maximum) + " 平均 " + Number(aggregates.Mean) + + " 中位 " + Number(aggregates.Median) + " RMS " + Number(aggregates.Rms); + } + + private static string Number(double value) + { + if (double.IsNaN(value)) return "—"; + if (double.IsInfinity(value)) return value > 0 ? "+∞" : "-∞"; + return value.ToString("0.####", System.Globalization.CultureInfo.InvariantCulture); + } + + private bool EnsureChart() + { + if (m_Chart != null) return true; + SetMessage("先指定一个图表(底部状态栏右侧的“图表”字段,或选中场景里的图表再打开窗口)"); + return false; + } + + private void SetMessage(string text) + { + if (m_Message != null) m_Message.text = text; + } + + /// + /// 一条表行的控件引用。按引用取而不是按下标取:行的格子数随列数变, + /// 用 `cells[childCount - 1]` 那种算法在加一列之后会把"标签"格当成数值格去填。 + /// + private sealed class RowWidgets + { + public int RecordIndex = -1; + public Label Index; + public TextField Time; + public TextField[] Values; + + /// 建这一行时"哪一列有值格"的签名;对不上就整条重造(格子是禁用的还是可编辑的都记在格子上) + public string Slots; + public Label Labels; + public ToolbarButton Delete; + } + + /// 范围页里一列的那一行控件 + private sealed class DimensionRow + { + public int Index; + + /// 这一列在值数组里的那一格;-1=这一列不占值(种类不是 Number),没有统计也没有范围可钉 + public int Slot = -1; + public Label Title; + public Label Effective; + public Label Stats; + public Toggle PinMin; + public TextField Min; + public Toggle PinMax; + public TextField Max; + } + } +} \ No newline at end of file diff --git a/Editor/XChart/XChartDataWindow.cs.meta b/Editor/XChart/XChartDataWindow.cs.meta new file mode 100644 index 0000000..01206be --- /dev/null +++ b/Editor/XChart/XChartDataWindow.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c994b40d97f481e44b3c097fce84b574 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/XChart/XChartElementRegistry.cs b/Editor/XChart/XChartElementRegistry.cs new file mode 100644 index 0000000..ac6788f --- /dev/null +++ b/Editor/XChart/XChartElementRegistry.cs @@ -0,0 +1,82 @@ +using System; +using System.Collections.Generic; +using UnityEditor; +using UnityEngine; +using XericUI.XChart; + +namespace XericUI.XChart.Editor +{ + /// + /// 元素类型登记表(编辑器专用)。 + /// + /// 反射扫描所有带 的 派生类, + /// 供 Inspector 的"添加元素"菜单列出。放在编辑器程序集里是刻意的:运行时不需要枚举全程序集, + /// 也避免 IL2CPP 裁剪把只在菜单里用到的类型剪掉。 + /// + internal static class XChartElementRegistry + { + internal struct Entry + { + public Type ConfigType; + public XChartElementAttribute Meta; + } + + private static List s_Entries; + + /// 所有已注册元素(按菜单序) + internal static IReadOnlyList GetEntries() + { + if (s_Entries != null) return s_Entries; + + s_Entries = new List(); + var assemblies = AppDomain.CurrentDomain.GetAssemblies(); + for (int a = 0; a < assemblies.Length; a++) + { + Type[] types; + try + { + types = assemblies[a].GetTypes(); + } + catch (Exception) + { + // 动态程序集/加载失败的程序集直接跳过,不能让一个坏程序集挡住菜单 + continue; + } + + for (int i = 0; i < types.Length; i++) + { + var type = types[i]; + if (type == null || type.IsAbstract || !typeof(XChartElementConfig).IsAssignableFrom(type)) + continue; + + var meta = (XChartElementAttribute)Attribute.GetCustomAttribute( + type, typeof(XChartElementAttribute), false); + if (meta == null) continue; + + s_Entries.Add(new Entry { ConfigType = type, Meta = meta }); + } + } + + s_Entries.Sort((x, y) => + { + int byOrder = x.Meta.MenuOrder.CompareTo(y.Meta.MenuOrder); + return byOrder != 0 ? byOrder : string.CompareOrdinal(x.Meta.DisplayName, y.Meta.DisplayName); + }); + return s_Entries; + } + + /// 按类型造一个默认配置 + internal static XChartElementConfig Create(Type configType) + { + try + { + return (XChartElementConfig)Activator.CreateInstance(configType); + } + catch (Exception exception) + { + Debug.LogError("Failed to create a chart element config: " + configType + " / " + exception.Message); + return null; + } + } + } +} \ No newline at end of file diff --git a/Editor/XChart/XChartElementRegistry.cs.meta b/Editor/XChart/XChartElementRegistry.cs.meta new file mode 100644 index 0000000..c4c703b --- /dev/null +++ b/Editor/XChart/XChartElementRegistry.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 67697d7796f1432d8701b36d7d9fa4d0 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Editor/XChart/XChartPanelHierarchy.cs b/Editor/XChart/XChartPanelHierarchy.cs new file mode 100644 index 0000000..fc27f6e --- /dev/null +++ b/Editor/XChart/XChartPanelHierarchy.cs @@ -0,0 +1,89 @@ +using System; +using System.Collections.Generic; + +namespace XericUI.XChart.Editor +{ + /// + /// 折叠层级的判定:纯数据,不碰 UIElements。 + /// + /// 为什么单独一支:面板要"互斥标记只打在最深那一层",而"谁是谁的父级"是装配完才定的 + /// (GroupFor 的同名合并、跨父级不合并都会改挂接位置)。这段规则要是散在控件代码里, + /// 就只能靠眼睛验收;抽出来之后它能离线跑(引擎的 mono 造不出真 VisualElement—— + /// 它的静态构造要撞 UIElementsRuntimeUtilityNative,所以这里对树一无所知, + /// 只接两条注入的访问器:parentOf 往上一格、keyOf 读一个格子带的 key)。 + /// + /// 离线能看见的与看不见的:能看见父级识别、深度、叶子判定这三步算术; + /// 看不见真控件的 parent/userData 到底填没填——那一层由面板自己在报表里印 + /// groups/deepest/depth 三个读数作证(数错了会在 HIERARCHY-NO-PARENT 这类 + /// 判决行里点名,不是"没打印所以没事")。 + /// + public static class XChartPanelHierarchy + { + /// 一块折叠板。Box 是它的盒子根(key 钉在盒子根上,不是钉在标题上)。 + public sealed class Node where T : class + { + public string Key; + public T Box; + + public string ParentKey; + public int Depth; + public bool IsLeaf; + } + + /// + /// 就地算出每个节点的 / / + /// 。 + /// + /// 父级 = 沿 parent 往上走,第一个 key 在本轮清单里的格子。中途那些没有 key 的 + /// 容器(Body、装字段的临时壳)直接跳过——所以深度按"折叠块"数,不按控件层数。 + /// + /// 最深的一层 = 不是任何块的父级的那些块(叶子)。注意这不是"全局最大深度": + /// 一条分支只有一层(基础 → 调试),另一条有两条(基础 → 数据 → 维度 0),两边的叶子都算 + /// "它那条分支里最深的一层",都要打标记;按全局最大深度挑就会把"调试"漏成自由块。 + /// + public static void Compute(IList> nodes, Func parentOf, Func keyOf) + where T : class + { + var byKey = new Dictionary>(); + foreach (var node in nodes) byKey[node.Key] = node; + + var parents = new HashSet(); + foreach (var node in nodes) + { + node.ParentKey = NearestAncestorKey(node.Box, parentOf, keyOf, byKey); + if (node.ParentKey != null) parents.Add(node.ParentKey); + } + + foreach (var node in nodes) + { + node.Depth = DepthOf(node, byKey); + node.IsLeaf = !parents.Contains(node.Key); + } + } + + private static string NearestAncestorKey(T box, Func parentOf, + Func keyOf, Dictionary> byKey) where T : class + { + for (T node = box == null ? null : parentOf(box); node != null; node = parentOf(node)) + { + string key = keyOf(node); + if (key != null && byKey.ContainsKey(key)) return key; + } + return null; + } + + private static int DepthOf(Node node, Dictionary> byKey) where T : class + { + int depth = 0; + string key = node.ParentKey; + Node parent; + // 父级先全部算完才走到这里,所以沿 ParentKey 往上爬是有限步(挂接是棵树,不会绕圈) + while (key != null && byKey.TryGetValue(key, out parent)) + { + depth++; + key = parent.ParentKey; + } + return depth; + } + } +} diff --git a/Editor/XChart/XChartPanelHierarchy.cs.meta b/Editor/XChart/XChartPanelHierarchy.cs.meta new file mode 100644 index 0000000..b25ce46 --- /dev/null +++ b/Editor/XChart/XChartPanelHierarchy.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b25122dd07509f34bac3f94fb019e2c9 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/Core/XericRegistrationPaths.cs b/Runtime/Core/XericRegistrationPaths.cs new file mode 100644 index 0000000..96c0503 --- /dev/null +++ b/Runtime/Core/XericRegistrationPaths.cs @@ -0,0 +1,63 @@ +namespace XericUI.Core +{ + /// + /// 注册路径总表:本插件里所有菜单 / 组件注册路径的唯一出处。 + /// + /// 为什么要有它:路径以前散落在各文件的字面量里("Xeric UI Vessel/…"、 + /// "Xeric/XChart/…"、"XericLibrary/…" 三套风格并存),改名要满地找。 + /// 现在统一成"{根}/{产品族}/{产品名}",注册时只用 族常量 + 自己的名字。 + /// + /// 用法(属性参数必须是编译期常量,所以这里全是 const,靠拼接成串) + /// + /// // 组件菜单(Component 菜单下,不需要 "Component/" 前缀) + /// [AddComponentMenu(XericRegistrationPaths.Chart + "/Mesh/Cube Mesh Background Tool")] + /// + /// // 菜单栏 + /// [MenuItem(XericRegistrationPaths.Chart + "/重新投影")] + /// + /// // GameObject > … 创建菜单 + /// [MenuItem(XericRegistrationPaths.ChartCreate + "/Scatter Chart", false, 12)] + /// + /// // 组件上下文菜单(CONTEXT/<组件类型>/… 的前缀是绑定键,不能加根) + /// [MenuItem(XericRegistrationPaths.ContextPrefix + "Image/Replace To/Xeric Image", true)] + /// + /// + /// 新加产品时:先用 + 你自己的族名拼一个族常量放在这里, + /// 再去调用点用"族常量 + 产品名"。不要在任何别的地方写死路径字面量。 + /// + public static class XericRegistrationPaths + { + /// 总根:所有注册路径的公共前缀 + public const string Root = "Xeric Library"; + + // ── 产品族(菜单栏与组件菜单共用同一套前缀) ────────────── + + /// 图表族(Chart / Line / Radar / Mesh / Pseudo3D …) + public const string Chart = Root + "/Chart"; + /// 表格族 + public const string Table = Root + "/Table"; + /// 通用 UI 组件族(Image / Button / Toggle / Style* / Values …) + public const string UI = Root + "/UI"; + /// 布局族 + public const string Layout = Root + "/Layout"; + /// 窗口(Form)族 + public const string Form = Root + "/Form"; + /// 翻页族 + public const string FlipPage = Root + "/FlipPage"; + /// 锚点窗口族 + public const string AnchorWindow = Root + "/AnchorWindow"; + + // ── 其它菜单前缀 ────────────────────────────────────────── + + /// GameObject 菜单前缀:创建类菜单必须从这里开始 + public const string CreatePrefix = "GameObject/"; + + /// GameObject 菜单下的族路径 + public const string ChartCreate = CreatePrefix + Chart; + public const string TableCreate = CreatePrefix + Table; + public const string UICreate = CreatePrefix + UI; + + /// 组件上下文菜单前缀(后接 组件类型/叶子,例如 "Image/Replace To/Xeric Image") + public const string ContextPrefix = "CONTEXT/"; + } +} \ No newline at end of file diff --git a/Runtime/Core/XericRegistrationPaths.cs.meta b/Runtime/Core/XericRegistrationPaths.cs.meta new file mode 100644 index 0000000..76921bc --- /dev/null +++ b/Runtime/Core/XericRegistrationPaths.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9dfafbe06d614797935bf1c4c7e20c7a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Axis.meta b/Runtime/XChart/Axis.meta new file mode 100644 index 0000000..bf4e563 --- /dev/null +++ b/Runtime/XChart/Axis.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 952f13859b77d0448ad01457c86815f0 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Axis/ChartToolAxis.cs b/Runtime/XChart/Axis/ChartToolAxis.cs new file mode 100644 index 0000000..c36f503 --- /dev/null +++ b/Runtime/XChart/Axis/ChartToolAxis.cs @@ -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 +{ + /// 轴在宿主面上沿哪个面参数方向走 + public enum XChartAxisDirection { AlongS = 0, AlongT = 1 } + + /// 刻度标签的内容来源 + public enum XChartAxisLabelSource + { + /// 数据直驱:每个主刻度写它的数值(格式串可覆盖,留空走自适应) + TickValue = 0, + /// 维度标签:只写一次该维的显示名,挂在轴末端 + DimensionLabel = 1, + /// 自定义:用 按刻度顺序填 + Custom = 2, + } + + /// + /// 轴线元素:在立方体某个面的参数域里画一条轴 + 主/次刻度 + TMP 标签。 + /// + /// 它完全住在面帧里:宿主面()+ 面内方向() + /// + 该方向上的起止比例(.. + /// )+ 垂直方向上的位置()。 + /// 这些参数经 变成像素,所以轴和背景/散点天然共形变—— + /// 转立方体、换视角都不用重新对坐标。 + /// + /// 空间类型: 决定"值 ↔ 轴上参数"的映射(线性 / 对数 / 指数), + /// 刻度值由 生成(对数按数量级铺 1/2/5,线性/指数按 nice-step 铺)。 + /// 次刻度在参数域里等分,所以在对数/指数轴上分出来的是几何级数。 + /// + /// 标签三源: —— 数值直驱(带格式串入口)、 + /// 维度显示名、自定义字符串数组。 + /// + [AddComponentMenu(XericRegistrationPaths.Chart + "/Axis/Axis Tool")] + public sealed class ChartToolAxis : XChartToolBase + { + // ── 宿主与走向 ──────────────────────────────────────────── + + /// + /// 宿主面用**插槽 id** 指定(规范 §11.2):默认取定义网格发布的 mesh.face.<面号>。 + /// 不再认"第几个面"——拿到的是点,所以异形网格只要发布同 id 的插槽就能用。 + /// + public string SlotId { get; set; } = XChartCubeGeometry.FaceSlotId(XChartCubeGeometry.CubeFace.Bottom); + + /// + /// 对齐格线(P9):开启后每条主刻度的位置会吸附到网格发布的那组线上 + /// (轴沿 S 走读 grid.T、沿 T 走读 grid.S),偏移超过"相邻两条线间距的一半" + /// 就不吸。网格是定义方,这里只是跟随。 + /// + 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; + + // ── 值域与刻度 ──────────────────────────────────────────── + + /// + /// 轴读哪一维——这是绑定(这条轴画的是哪一路数据),不是范围。 + /// 范围与"这一维现在有没有数据"归 chart 的数据板块(每个维度一行), + /// 工具只呈现(规范 §1)。 + /// + 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; + /// 刻度朝哪边:+1 朝面参数增大方向,-1 朝减小方向 + public float TickSide { get; set; } = -1f; + + // ── 标签 ────────────────────────────────────────────────── + + public XChartAxisLabelSource LabelSource { get; set; } = XChartAxisLabelSource.TickValue; + /// 数值格式化串(如 "0.00" 或 "0.#");留空走自适应 + 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); + /// 标签跟着轴的方向转(斜面上读起来才不拧着) + public bool RotateLabelsWithAxis { get; set; } = true; + + // ── 内部 ────────────────────────────────────────────────── + + public UILineRendererV2 LineRenderer { get; private set; } + private readonly List m_Majors = new List(); + private readonly List m_Minors = new List(); + private readonly XChartFaceFrame[] m_FaceFrames = new XChartFaceFrame[XChartCubeGeometry.FaceCount]; + + private Matrix4x4 m_Composed = Matrix4x4.identity; + private int m_LastSpaceVersion = -1; + /// 这一帧的面帧是从插槽拿的还是自己从立方几何推的(报表用) + private string m_FrameSource = "cube"; + + /// 对齐格线的读数(报表用):off / grid(n/m, snapMax=…) / no-slot / unknown-face + private string m_AlignNote = "off"; + private int m_AlignSnapped; + private int m_AlignTotal; + private float m_AlignMaxSnap; + private float[] m_GridRatios = new float[64]; + + /// + /// 把刻度吸附到网格发布的线上(P9 的"跟随"那一半):网格是定义方,这里只读它的线。 + /// 轴沿 S 走 ⇒ 刻度落在等 s 线上,而等 s 线发布在 grid.T;沿 T 走读 grid.S。 + /// 取不到槽(没网格元素 / 网格没发布 / 手填的 id 不是 mesh.face.<n>)就不吸, + /// 并把原因记进 ——"没吸上"和"没开对齐"在画面上一样,只有读数分得清。 + /// + 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("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; + } + + /// + /// 数据侧:算范围、铺刻度、申请这一帧要的标签数(申请只置脏,件在随后的池调度里发落)。 + /// 放在这里而不是 OnRender,是为了让"申请→发落→落笔"在同一片帧内闭合。 + /// + 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); + } + + /// + /// 面帧从**定义网格发布的插槽**里取(规范 §11.2):网格是定义者,其余工具跟随—— + /// 消费者拿到的是四个点,不是"第几个面",所以换成异形网格也不用改这里。 + /// 取不到就回落到老路径(自己从立方几何推),并把**走的是哪条**印进报表(`frame=`): + /// 两条路画出来一样时更要印,否则"跟随网格"这句话没有生产者。 + /// + 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); + } + + /// 回落用:从 mesh.face.<n> 里读面号;不是这个形状就返回 -1 + 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; + } + + /// 几何侧:面帧、线、刻度、标签。空间版本变了必须重画(转立方体时标签要跟着走) + 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); + } + + /// + /// 轴的范围只问上下文要(手动优先、否则该维聚合,规则在 )。 + /// 对数轴不能跨 0:贴 0 取一个下界,其余照手动/聚合优先级。 + /// + 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; + } + + /// 把"沿轴比例"换成像素点;垂直位置固定在 + 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 + /// + /// 这一帧的范围是从哪来的:override=chart 那一维的维度行填了覆盖、aggregate= + /// 用该维聚合、none=两边都没有(于是整条轴不画)。报表靠它证明"范围归数据行"。 + /// 判据取本帧的结果(),不重新问一遍聚合——空模型下 + /// "聚合存在"是真的、值是 NaN,照那样问会印出 aggregate,那是在骗读报表的人。 + /// + 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(); + } + } +} diff --git a/Runtime/XChart/Axis/ChartToolAxis.cs.meta b/Runtime/XChart/Axis/ChartToolAxis.cs.meta new file mode 100644 index 0000000..ad4bd10 --- /dev/null +++ b/Runtime/XChart/Axis/ChartToolAxis.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8ae98c37a332aee4abdf1e2e7a11da67 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Axis/XChartAxisConfig.cs b/Runtime/XChart/Axis/XChartAxisConfig.cs new file mode 100644 index 0000000..cb4b115 --- /dev/null +++ b/Runtime/XChart/Axis/XChartAxisConfig.cs @@ -0,0 +1,137 @@ +using System; +using UnityEngine; +using XericUI.XChart.Mesh; +using XericUI.XChart.Space; + +namespace XericUI.XChart.Axis +{ + /// + /// 轴线元素的配置。一条轴 = 宿主面 + 面内方向 + 子区间 + 空间类型 + 刻度 + 标签来源, + /// 全部走同一套面帧协议,所以它和背景/散点必然共形变(口径见 )。 + /// + /// 要三条轴就在面板里加三个这个元素,各自选自己的面和维度—— + /// 图表不必为"X 轴 / Y 轴 / Z 轴"写任何专用字段。 + /// + [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(); + } + } +} diff --git a/Runtime/XChart/Axis/XChartAxisConfig.cs.meta b/Runtime/XChart/Axis/XChartAxisConfig.cs.meta new file mode 100644 index 0000000..2365678 --- /dev/null +++ b/Runtime/XChart/Axis/XChartAxisConfig.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 7e8a7544d20c7104cb74c554878e791f +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Axis/XChartAxisMath.cs b/Runtime/XChart/Axis/XChartAxisMath.cs new file mode 100644 index 0000000..059fcb5 --- /dev/null +++ b/Runtime/XChart/Axis/XChartAxisMath.cs @@ -0,0 +1,200 @@ +using System; +using System.Collections.Generic; + +namespace XericUI.XChart.Axis +{ + /// 轴的空间类型:值 ↔ 轴上参数(0..1)的映射方式。 + public enum XChartAxisScale + { + /// 线性:参数与值成正比 + Linear = 0, + /// 对数空间:等参数间距对应等数量级间距(要求范围两端同号且不为 0) + Logarithmic = 1, + /// 指数空间:值按 exp(k·参数) 增长( 控制弯的程度) + Exponential = 2, + } + + /// + /// 轴线的纯数学:值域 ↔ 参数、刻度取值。不碰 Unity 类型, + /// 所以编译门里的 mono 探针能直接把这几条互逆关系和 nice-step 当断言跑。 + /// + public static class XChartAxisMath + { + private const double k_Epsilon = 1e-9; + + /// 指数空间强度太小时 exp(k)-1 会掉到 0,除法炸掉;这是下限。 + public const double MinStrength = 1e-3; + + // ── 值 ↔ 参数 ───────────────────────────────────────────── + + /// 值 → 轴上参数 [0,1]。范围退化(max≈min)时一律给 0.5,不炸也不乱跳。 + 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; + } + } + + /// 轴上参数 [0,1] → 值。与 互为逆。 + 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; + } + } + + // ── 刻度 ────────────────────────────────────────────────── + + /// + /// "好看"的步长:把目标条数折算成步长后,收拢到 1 / 2 / 5 × 10^n。 + /// 这样刻度值读起来是 0.5、1、2、5、10,而不是 1.37、2.74。 + /// + 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; + } + + /// + /// 生成主刻度值(升序)。线性/指数:从 ceil(min/step)*step 起按步长铺; + /// 对数:按数量级铺 1/2/5 × 10^n(步长参数此时不用,因为等步长在数量级轴上没意义)。 + /// + public static void BuildTicks(double min, double max, XChartAxisScale scale, double step, + int targetCount, bool autoStep, List 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)); + } + } + + /// 对数轴:每个数量级上的 1/2/5 + private static void BuildDecadeTicks(double min, double max, List 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); + } + } + } + + /// 把 -1e-17 这类"本该是 0"的刻度收正,否则标签会出现 -0。 + private static double SnapToZero(double value, double delta) + { + return Math.Abs(value) < delta * 1e-6 ? 0.0 : value; + } + + /// + /// 次刻度:在主刻度之间按参数等分。对数/指数空间里这样分出来的是几何级数, + /// 视觉上才均匀(按值等分会在小值那头挤成一坨)。 + /// + public static void BuildMinorTicks(double majorFrom, double majorTo, int minorCount, + double min, double max, XChartAxisScale scale, double strength, List 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)); + } + } + + /// + /// 数值 → 标签文本。格式化串为空时用"按量级自适应"的默认写法: + /// 步长 ≥1 走整数,否则按步长的小数位数给(避免出现 0.30000001)。 + /// + 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); + } + } +} diff --git a/Runtime/XChart/Axis/XChartAxisMath.cs.meta b/Runtime/XChart/Axis/XChartAxisMath.cs.meta new file mode 100644 index 0000000..b7ed3f8 --- /dev/null +++ b/Runtime/XChart/Axis/XChartAxisMath.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ae22b8f1e7d36b54d93e7b7c78f0e0b5 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Line/XLineChart.cs b/Runtime/XChart/Line/XLineChart.cs index 148170d..062bb34 100644 --- a/Runtime/XChart/Line/XLineChart.cs +++ b/Runtime/XChart/Line/XLineChart.cs @@ -2,10 +2,11 @@ using System; using System.Collections.Generic; using UnityEngine; using XericLibrary.Runtime.UIGraph; +using XericUI.Core; namespace XericUI.XChart.Line { - [AddComponentMenu("Xeric/XChart/Line/Line Chart")] + [AddComponentMenu(XericRegistrationPaths.Chart + "/Line/Line Chart")] [ExecuteAlways] public sealed class XLineChart : XChartBase { diff --git a/Runtime/XChart/Mesh.meta b/Runtime/XChart/Mesh.meta new file mode 100644 index 0000000..8f2fa47 --- /dev/null +++ b/Runtime/XChart/Mesh.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 73911d48057b40a29d9c8f773db9f455 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Mesh/ChartToolCylinder.cs b/Runtime/XChart/Mesh/ChartToolCylinder.cs new file mode 100644 index 0000000..7ba5cd7 --- /dev/null +++ b/Runtime/XChart/Mesh/ChartToolCylinder.cs @@ -0,0 +1,722 @@ +using System; +using System.Collections.Generic; +using UnityEngine; +using XericLibrary.Runtime.UIGraph; +using XericUI.Core; +using XericUI.XChart.Space; + +namespace XericUI.XChart.Mesh +{ + /// + /// 圆柱元素:两端圆盘(各自圆心/法线)+ 半径 → 视角下的外轮廓包边 + 轮廓填充 + /// + 可选端面十字 + 可选内部母线。 + /// + /// 为什么不再"把两端顶点都连起来":扫掠体在人眼里的样子是它的外轮廓—— + /// 圆在正交投影下压成椭圆,"过圆心的长轴方向"那两条桥接线才是侧面的可见边界; + /// 把相邻端面点一片片连成四边形,画出来的是"所有母线都可见"的线框,不是包边。 + /// 现在轮廓=两片椭圆点集的凸包(对凸截面是精确解,平行/斜置/两端不同法线同一套代码), + /// 填充就是同一个多边形。几何在 (纯数学、离线可验)。 + /// + /// 投影只做三次:每片端面只投影"圆心 + 两根基",椭圆在 2D 上按参数式展开—— + /// 不再对盘上每点做 3D 投影(这是他要的"从 2D 上算,最大限度复用结果")。 + /// + /// 弧走曲线渲染器、直线走折线渲染器:库里 Generation/Curve 那套内部就是贝塞尔细分 + /// (所以放大也不会露出折点),轮廓的弧段与两个端面圆环都交给它,控制点由 + /// 算(我不自己切段);十字与母线是直线, + /// 留在折线渲染器上——他一 2026-10-23 的原话是"折线渲染器适合用来显示直线"。 + /// + [AddComponentMenu(XericRegistrationPaths.Chart + "/Mesh/Cylinder Tool")] + public sealed class ChartToolCylinder : XChartToolBase + { + // ── 几何(立方体单位,±1 就是盒子边界) ─────────────────── + + public Vector3 Start { get; set; } = new Vector3(-0.6f, -0.6f, -0.6f); + public Vector3 End { get; set; } = new Vector3(0.6f, 0.6f, 0.6f); + public float Radius { get; set; } = 0.22f; + public int SegmentCount { get; set; } = 48; + + /// 起点端面的法线。零向量=沿两端连线(与旧行为一致) + public Vector3 StartNormal { get; set; } + /// 终点端面的法线。零向量=沿两端连线 + public Vector3 EndNormal { get; set; } + + /// 圆柱自己的变换(叠在图的空间之上) + public XChartToolTransform Transform { get; set; } = XChartToolTransform.Identity; + + // ── 几何来源:常量 / 数据(一组记录一根圆柱) ── + + /// 关=用 / 的常量坐标;开=从数据源取 + public bool DriveByData { get; set; } + public int DimensionX { get; set; } + public int DimensionY { get; set; } = 1; + public int DimensionZ { get; set; } = 2; + /// 几条记录凑一根圆柱;2=两两一组(记录 0-1、2-3…,不重叠也不并入上一组) + public int GroupSize { get; set; } = 2; + /// 最多画几根 + public int MaxCylinders { get; set; } = 64; + + // ── 呈现(各有开关) ────────────────────────────────────── + + /// 外轮廓包边 + public bool ShowOutline { get; set; } = true; + public Color OutlineColor { get; set; } = new Color(0.75f, 0.85f, 1f, 0.9f); + public float OutlineThickness { get; set; } = 2f; + + /// 轮廓填充(同一个凸包多边形) + public bool ShowFill { get; set; } = true; + public Color FillColor { get; set; } = new Color(0.34f, 0.55f, 0.85f, 0.35f); + + /// 端面十字:用端面自己的采样顶点连,所以它**永远与实际端面对得上**,能看出滚转 + public bool ShowCapCross { get; set; } + public Color CrossColor { get; set; } = new Color(0.9f, 0.95f, 1f, 0.85f); + public float CrossThickness { get; set; } = 1.5f; + + /// 起点端面的闭合圆环(画满一整圈端面椭圆,=端面自己的边界) + public bool ShowStartRing { get; set; } + /// 终点端面的闭合圆环 + public bool ShowEndRing { get; set; } + + /// 内部母线数量(把两端对应点连起来;0=不画)。默认 0:轮廓之外的东西要显式要 + public int GeneratrixCount { get; set; } + public Color GeneratrixColor { get; set; } = new Color(0.75f, 0.85f, 1f, 0.35f); + + // ── 内部 ────────────────────────────────────────────────── + + public XChartMeshFillRenderer FillRenderer { get; private set; } + /// 曲线渲染器(贝塞尔细分):弧段走它。折线渲染器只留给直线(十字/母线) + public UICurveRenderer CurveRenderer { get; private set; } + public UILineRendererV2 WireRenderer { get; private set; } + + private Matrix4x4 m_Composed = Matrix4x4.identity; + private int m_LastSpaceVersion = -1; + private bool m_Dirty = true; + + private Vector2[] m_Scratch = new Vector2[0]; + private Vector2[] m_Outline = new Vector2[0]; + private byte[] m_Tags = new byte[0]; + private int[] m_RunStarts = new int[0]; + private int[] m_RunEnds = new int[0]; + private byte[] m_RunTags = new byte[0]; + private int m_RunCount; + private readonly Vector2[] m_Bezier = new Vector2[4]; + private readonly float[] m_BezierWidths = new float[4]; + private readonly Vector2[] m_Cross = new Vector2[3]; + private int m_CurveEntries; + private int m_RingArcs; + private int m_RingFullCaps; + private XChartCylinderDisc2D m_DiscStart; + private XChartCylinderDisc2D m_DiscEnd; + private int m_OutlineCount; + + // ── 多根圆柱:一组记录一根,组与组不重叠(尾巴凑不满一组就不画) ── + private Vector3[] m_CylinderStart = new Vector3[0]; + private Vector3[] m_CylinderEnd = new Vector3[0]; + private float[] m_CylinderDepth = new float[0]; + private int[] m_CylinderOrder = new int[0]; + private int m_CylinderCount; + private int m_GroupSkipped; + private bool m_GroupCapped; + + /// 数据版本:数据模式下几何随数据变,脏判定要把它算进来 + private long m_LastDataVersion = long.MinValue; + /// 本帧几何是怎么来的(报表用):literal / data(groups …) / data-skipped(原因) + private string m_GeometryNote = "literal"; + + public void MarkDirty() => m_Dirty = true; + + protected override void OnInitialize() + { + FillRenderer = CreateChildComponent("CylinderFill"); + if (FillRenderer != null) Stretch(FillRenderer.rectTransform); + + // 弧段走曲线渲染器:它内部就是贝塞尔细分,所以椭圆弧不会像折线那样在接缝上露断口 + CurveRenderer = CreateChildComponent("CylinderCurve"); + if (CurveRenderer != null) + { + CurveRenderer.autoRebuild = false; // 控制点由本工具每帧喂,别让它自己重建默认那条 + Stretch(CurveRenderer.rectTransform); + } + + WireRenderer = CreateChildComponent("CylinderWire"); + if (WireRenderer != null) + { + WireRenderer.defaultColor = OutlineColor; + WireRenderer.defaultThickness = OutlineThickness; + Stretch(WireRenderer.rectTransform); + } + SetVisible(true); + } + + private static void Stretch(RectTransform rect) + { + rect.anchorMin = Vector2.zero; + rect.anchorMax = Vector2.one; + rect.offsetMin = Vector2.zero; + rect.offsetMax = Vector2.zero; + } + + public override void OnRender() + { + base.OnRender(); + if (FillRenderer == null) return; + + var space = Context?.Space; + if (space == null) return; + + var data = Context?.Data; + long dataVersion = data != null ? data.Version : 0L; + if (!m_Dirty && space.ProjectionVersion == m_LastSpaceVersion + && (!DriveByData || dataVersion == m_LastDataVersion)) return; + m_Dirty = false; + m_LastSpaceVersion = space.ProjectionVersion; + m_LastDataVersion = dataVersion; + m_Composed = space.Compose(Transform); + + int segments = Mathf.Clamp(SegmentCount, 8, 256); + EnsureBuffers(segments); + + string note; + if (!TryCollectCylinders(data, out note)) + { + // 这一帧给不出几何:把上一帧收干净。留着旧几何是最坏的结果——那几根圆柱 + // 会被读成"当前值"。(不能走绘制路径:端面圆环吃的是上一帧的圆盘。) + m_GeometryNote = note; + ClearGeometry(); + return; + } + m_GeometryNote = note; + + SortCylindersByDepth(space); // DepthOf 越大越近 ⇒ 先画远的 + BeginGeometry(); + for (int i = 0; i < m_CylinderCount; i++) + DrawCylinder(space, segments, m_CylinderOrder[i]); + EndGeometry(); + } + + private void BeginGeometry() + { + FillRenderer.ClearFaces(); + if (CurveRenderer != null) CurveRenderer.ClearAll(); + if (WireRenderer != null) WireRenderer.ClearAll(); + m_CurveEntries = 0; + m_RingArcs = 0; + m_RingFullCaps = 0; + } + + private void EndGeometry() + { + FillRenderer.Apply(); + if (CurveRenderer != null) CurveRenderer.RebuildAll(); + } + + /// 一根圆柱的全部落笔:两片端面 → 轮廓 → 填充 → 弧(轮廓/圆环)→ 直线(十字/母线)。 + /// 三个渲染器都是"先清一次、循环里追加、最后统一提交",所以这里只追加、不提交。 + private void DrawCylinder(ChartToolSpace space, int segments, int index) + { + Vector3 start = m_CylinderStart[index]; + Vector3 end = m_CylinderEnd[index]; + float radius = Mathf.Max(1e-4f, Radius); + + XChartCylinderGeometry.ResolveNormals(StartNormal, EndNormal, start, end, + out Vector3 startNormal, out Vector3 endNormal); + bool built = BuildDisc(space, start, startNormal, radius, segments, out m_DiscStart) + && BuildDisc(space, end, endNormal, radius, segments, out m_DiscEnd); + + m_OutlineCount = built + ? XChartCylinderGeometry.BuildOutline(m_DiscStart, m_DiscEnd, segments, m_Scratch, m_Outline) + : 0; + + AppendFill(); + AppendCurves(segments); + AppendStraightWires(); + } + + /// + /// 把三个渲染器清空到"什么都没画",并且不动圆盘缓冲——给"这一帧拿不到几何"用。 + /// + private void ClearGeometry() + { + m_OutlineCount = 0; + m_CurveEntries = 0; + m_RingArcs = 0; + m_RingFullCaps = 0; + + FillRenderer.ClearFaces(); + FillRenderer.Apply(); + if (CurveRenderer != null) + { + CurveRenderer.ClearAll(); + CurveRenderer.RebuildAll(); + } + if (WireRenderer != null) WireRenderer.ClearAll(); + } + + /// + /// 这一帧要画哪几根圆柱。常量模式=一根(配置里那两个坐标);数据模式=按组: + /// 组 g 覆盖记录 [g*GroupSize, g*GroupSize + GroupSize - 1],两端取组首与组尾, + /// 组与组严格不重叠、也不把上一组并进来;凑不满一组的尾巴不画(记进 )。 + /// + /// 下标只有一个权威(他 2026-10-24 的要求):记录下标 0 = 最早、n-1 = 最新, + /// 与数据窗口的行号同一套下标,所以这里只按绝对下标取记录——"往回数第几条"那种 + /// 相对量会让同一份数据在窗口里是第 1 条、在工具里却成了第 n-2 条(现场就是它)。 + /// + /// 数据值必须先用该维值域归一化到立方体单位才进几何(不归一化的话数据值可能上千, + /// 直接飞出盒子)。每一步失败都给出可点名的原因,报表里印出来。 + /// + private bool TryCollectCylinders(IXChartDataSource data, out string note) + { + m_CylinderCount = 0; + m_GroupSkipped = 0; + m_GroupCapped = false; + + if (!DriveByData) + { + EnsureCylinderCapacity(1); + Store(0, Start, End); + note = "literal"; + return true; + } + + if (data == null) { note = "data-skipped(no-source)"; return false; } + + int groupSize = Mathf.Max(2, GroupSize); + int available = XChartBindingMath.CompleteGroupCount(data.RecordCount, groupSize); + if (available == 0) + { + note = "data-skipped(need " + groupSize + " records per group, have " + data.RecordCount + ")"; + return false; + } + + int groups = Mathf.Min(available, Mathf.Max(1, MaxCylinders)); + m_GroupCapped = groups < available; + + double minX, maxX, minY, maxY, minZ, maxZ; + if (!TryResolveDomains(out minX, out maxX, out minY, out maxY, out minZ, out maxZ)) + { + note = "data-skipped(no-domain)"; + return false; + } + + EnsureCylinderCapacity(groups); + for (int g = 0; g < groups; g++) + { + int first, last; + if (!XChartBindingMath.TryResolveGroup(data.RecordCount, g, groupSize, out first, out last)) + { + m_GroupSkipped++; + continue; + } + + Vector3 head, tail; + if (!TryResolveNormalized(data, first, minX, maxX, minY, maxY, minZ, maxZ, out head) + || !TryResolveNormalized(data, last, minX, maxX, minY, maxY, minZ, maxZ, out tail)) + { + m_GroupSkipped++; + continue; + } + + Store(m_CylinderCount, head, tail); + } + + if (m_CylinderCount == 0) { note = "data-skipped(all-groups-rejected)"; return false; } + + int drawnRecords = m_CylinderCount * groupSize; + note = "data(groups " + m_CylinderCount + "/" + available + ", size " + groupSize + + ", rec 0->" + (drawnRecords - 1) + + (m_GroupCapped ? ", capped" : string.Empty) + + (m_GroupSkipped > 0 ? ", skip " + m_GroupSkipped : string.Empty) + ")"; + return true; + } + + private void Store(int index, Vector3 start, Vector3 end) + { + m_CylinderStart[index] = start; + m_CylinderEnd[index] = end; + m_CylinderCount = index + 1; + } + + private void EnsureCylinderCapacity(int count) + { + if (m_CylinderStart.Length >= count) return; + m_CylinderStart = new Vector3[count]; + m_CylinderEnd = new Vector3[count]; + m_CylinderDepth = new float[count]; + m_CylinderOrder = new int[count]; + } + + private bool TryResolveNormalized(IXChartDataSource data, int record, + double minX, double maxX, double minY, double maxY, double minZ, double maxZ, out Vector3 unit) + { + unit = Vector3.zero; + Vector3 raw; + if (!XChartBindingMath.TryResolvePosition(data, record, DimensionX, DimensionY, DimensionZ, out raw)) + return false; + + float x, y, z; + if (!XChartBindingMath.TryNormalize(raw.x, minX, maxX, out x) + || !XChartBindingMath.TryNormalize(raw.y, minY, maxY, out y) + || !XChartBindingMath.TryNormalize(raw.z, minZ, maxZ, out z)) return false; + + unit = new Vector3(x, y, z); + return true; + } + + /// + /// 按深度从远到近排序( 越大越靠近观察者): + /// 同一个工具内的多根圆柱靠提交顺序决定画家序(三个渲染器都不按深度自己排), + /// 不排就会让近的被远的盖住。 + /// + private void SortCylindersByDepth(ChartToolSpace space) + { + for (int i = 0; i < m_CylinderCount; i++) + { + m_CylinderDepth[i] = (space.DepthOf(m_CylinderStart[i], m_Composed) + + space.DepthOf(m_CylinderEnd[i], m_Composed)) * 0.5f; + m_CylinderOrder[i] = i; + } + + // 插入排序:根数有上限(MaxCylinders),且渲染路径里不分配 + for (int i = 1; i < m_CylinderCount; i++) + { + int key = m_CylinderOrder[i]; + float depth = m_CylinderDepth[key]; + int j = i - 1; + while (j >= 0 && m_CylinderDepth[m_CylinderOrder[j]] > depth) + { + m_CylinderOrder[j + 1] = m_CylinderOrder[j]; + j--; + } + m_CylinderOrder[j + 1] = key; + } + } + + private bool TryResolveDomains(out double minX, out double maxX, + out double minY, out double maxY, out double minZ, out double maxZ) + { + minX = maxX = minY = maxY = minZ = maxZ = 0d; + var context = Context; + if (context == null) return false; + return context.TryResolveDomain(DimensionX, out minX, out maxX) + && context.TryResolveDomain(DimensionY, out minY, out maxY) + && context.TryResolveDomain(DimensionZ, out minZ, out maxZ); + } + + /// + /// 一片端面 → 2D 椭圆:只投影圆心与两根基。基向量的像素像就是椭圆的半轴, + /// 半径并进半轴里,之后所有采样都在 2D 上做。 + /// + private bool BuildDisc(ChartToolSpace space, Vector3 center, Vector3 normal, float radius, + int segments, out XChartCylinderDisc2D disc) + { + disc = default(XChartCylinderDisc2D); + Vector3 u, v; + if (!XChartCylinderGeometry.TryOrthogonalBasis(normal, out u, out v)) return false; + + Vector2 centerPixels = space.Project(center, m_Composed); + Vector2 uPixels = space.Project(center + u, m_Composed) - centerPixels; + Vector2 vPixels = space.Project(center + v, m_Composed) - centerPixels; + + return XChartCylinderGeometry.TryProjectDisc(centerPixels, uPixels, vPixels, radius, out disc); + } + + /// + /// 填充=轮廓多边形本身,用"扇形"喂进去(库里只有四边形图元):每片是 + /// (中心, 第 i 点, 第 i+1 点, 第 i+1 点) 的退化三角形。整片轮廓在一处连续提交, + /// 所以它相对其它元素是整块参与画家序,内部不再分片排序。 + /// + private void AppendFill() + { + if (!ShowFill || m_OutlineCount < 3) return; + + Vector2 centroid = Vector2.zero; + for (int i = 0; i < m_OutlineCount; i++) centroid += m_Outline[i]; + centroid /= m_OutlineCount; + + for (int i = 0; i < m_OutlineCount; i++) + { + Vector2 a = m_Outline[i]; + Vector2 b = m_Outline[(i + 1) % m_OutlineCount]; + FillRenderer.AddFace(centroid, a, b, b, FillColor, FillColor); + } + } + + /// 弧线交给曲线渲染器(贝塞尔细分),直线留在折线渲染器上——他 2026-10-23 的原话: + /// "你现在用的折线渲染器就是分段的,适合用来显示直线"。 + private void AppendCurves(int segments) + { + if (CurveRenderer == null) return; + + ComputeRuns(); + if (ShowOutline && m_OutlineCount >= 3) AddOutlineCurves(); + if (ShowStartRing) AddRingCurves(1, segments); + if (ShowEndRing) AddRingCurves(2, segments); + } + + /// 提交一节三次贝塞尔(4 个控制点)。控制点会被库拷进它自己的扁平缓存,所以复用 scratch 安全。 + private void AddCurveEntry(Color color) + { + for (int i = 0; i < m_BezierWidths.Length; i++) m_BezierWidths[i] = OutlineThickness; + var entry = new CurveCacheEntry + { + startColor = color, + endColor = color, + tessellationSegments = Mathf.Clamp(SegmentCount / 6, 4, 32), + }; + CurveRenderer.AddCurve(entry, m_Bezier, m_BezierWidths); + m_CurveEntries++; + } + + /// 端面圆环=把端面圆补成整圈:包边已经画了那一片的外侧弧, + /// 环就补剩下的内侧弧(同两个端点、反方向走)——他 2026-10-23 的要求: + /// "关闭 start/end ring 时消失的应该是内部圆环那部分",而且"画整圈会和包边重复出两条线框"。 + /// 包边没在画(或这一片在轮廓上只占一个点)时,环自己补整圈。 + private void AddRingCurves(byte tag, int segments) + { + XChartCylinderDisc2D disc = tag == 1 ? m_DiscStart : m_DiscEnd; + int index = FindRun(tag); + if (!ShowOutline || index < 0) + { + // 包边没在画,或这一片整个躲在外轮廓里(凸包上连一段可见弧都没有)⇒ 只能画整圈 + m_RingFullCaps++; + AddFullRing(disc, segments); + return; + } + + if (m_RunStarts[index] == m_RunEnds[index]) + { + m_RingFullCaps++; + AddFullRing(disc, segments); + return; + } + + // 补弧:起点接在可见弧的终点、扫过 2π-|可见|(显式走长路,不能用"反向短路"表达) + if (!XChartCylinderGeometry.TryParameterOf(disc, m_Outline[m_RunStarts[index]], out float fromAngle)) + return; + if (!XChartCylinderGeometry.TryParameterOf(disc, m_Outline[m_RunEnds[index]], out float toAngle)) + return; + float visible = XChartCylinderGeometry.SweepToDirection(toAngle - fromAngle, DirectionOfRun(index)); + XChartCylinderGeometry.RingArc(fromAngle, visible, out float ringStart, out float ringSweep); + AddArcPieces(disc, ringStart, ringSweep); + m_RingArcs++; + } + + /// 整圈(每节 ≤90°;与采样段数解耦,所以放大也不会露出折点) + private void AddFullRing(in XChartCylinderDisc2D disc, int segments) + { + int pieces = Mathf.Max(1, segments / 4); + for (int p = 0; p < pieces; p++) + { + XChartCylinderGeometry.BuildArcPiece(disc, 0f, 6.2831855f, pieces, p, m_Bezier); + AddCurveEntry(OutlineColor); + } + } + + /// + /// 轮廓=弧段 + 桥接段。凸包点先按"落在哪片端面的椭圆上"打标记,同标记的连续段是椭圆弧 + /// (走贝塞尔),跨标记那条就是"过圆心的长轴方向连外框"的桥接线(走直线)。 + /// + private void AddOutlineCurves() + { + for (int r = 0; r < m_RunCount; r++) + { + int start = m_RunStarts[r]; + int end = m_RunEnds[r]; + if (m_RunTags[r] != 0 && start != end) + { + AddArcBetween(DiscOfRun(r), m_Outline[start], m_Outline[end], + DirectionOfRun(r), m_Outline[start]); + } + + int nextStart = m_RunStarts[(r + 1) % m_RunCount]; + AddStraightCurve(m_Outline[end], m_Outline[nextStart]); // 段与段之间(含首尾相接那条桥接) + } + } + + /// + /// 把凸包切成"同端面的连续段"。切分本身在纯几何里(`SplitOutlineRuns`),因为 + /// "哪半边在轮廓里"这种判定必须能离线验。 + /// + private void ComputeRuns() + { + m_RunCount = 0; + if (m_OutlineCount < 3) return; + + EnsureRunBuffers(m_OutlineCount); + m_RunCount = XChartCylinderGeometry.SplitOutlineRuns(m_Outline, m_OutlineCount, m_DiscStart, m_DiscEnd, + m_Tags, m_RunStarts, m_RunEnds, m_RunTags); + } + + private void EnsureRunBuffers(int count) + { + if (m_Tags.Length < count) + { + m_Tags = new byte[count]; + m_RunStarts = new int[count]; + m_RunEnds = new int[count]; + m_RunTags = new byte[count]; + } + } + + private int FindRun(byte tag) + { + for (int r = 0; r < m_RunCount; r++) + { + if (m_RunTags[r] == tag) return r; + } + return -1; + } + + private XChartCylinderDisc2D DiscOfRun(int index) => m_RunTags[index] == 1 ? m_DiscStart : m_DiscEnd; + + /// 这一段弧的转向:看段内第二个点(凸包是逆时针,弧必须顺着它走) + private int DirectionOfRun(int index) + { + if (m_RunStarts[index] == m_RunEnds[index]) return 1; + XChartCylinderDisc2D disc = DiscOfRun(index); + int second = (m_RunStarts[index] + 1) % m_OutlineCount; + if (!XChartCylinderGeometry.TryParameterOf(disc, m_Outline[m_RunStarts[index]], out float fromAngle)) + return 1; + if (!XChartCylinderGeometry.TryParameterOf(disc, m_Outline[second], out float secondAngle)) + return 1; + return XChartCylinderGeometry.ShortestDirection(secondAngle - fromAngle); + } + + /// 提交一段椭圆弧; 非 0 时强制转向,为 0 时按 定 + private void AddArcBetween(in XChartCylinderDisc2D disc, Vector2 fromPoint, Vector2 toPoint, + int direction, Vector2 hintPoint) + { + if (!XChartCylinderGeometry.TryParameterOf(disc, fromPoint, out float fromAngle)) return; + if (!XChartCylinderGeometry.TryParameterOf(disc, toPoint, out float toAngle)) return; + + if (direction == 0 && XChartCylinderGeometry.TryParameterOf(disc, hintPoint, out float hintAngle)) + direction = XChartCylinderGeometry.ShortestDirection(hintAngle - fromAngle); + + AddArcPieces(disc, fromAngle, XChartCylinderGeometry.SweepToDirection(toAngle - fromAngle, direction)); + } + + /// 把"起点角 + 扫过角"切成 ≤90° 的贝塞尔节提交 + private void AddArcPieces(in XChartCylinderDisc2D disc, float fromAngle, float sweep) + { + int pieces = XChartCylinderGeometry.ArcPieceCount(sweep); + for (int p = 0; p < pieces; p++) + { + XChartCylinderGeometry.BuildArcPiece(disc, fromAngle, sweep, pieces, p, m_Bezier); + AddCurveEntry(OutlineColor); + } + } + + private void AddStraightCurve(Vector2 from, Vector2 to) + { + if ((from - to).sqrMagnitude < 1e-8f) return; + XChartCylinderGeometry.BuildLineBezier(from, to, m_Bezier); + AddCurveEntry(OutlineColor); + } + + private void AppendStraightWires() + { + if (WireRenderer == null) return; + + if (ShowCapCross) + { + DrawCross(m_DiscStart); + DrawCross(m_DiscEnd); + } + + if (GeneratrixCount > 0 && m_OutlineCount > 0) DrawGeneratrices(); + } + + /// + /// 一整条折线一次提交(不要一段一段 DrawLine):库里网格生成器的"转角连接三角形"只在 + /// 同一根线内的相邻子段之间补,所以逐段画会在**每个转角留下断口**——他 2026-10-23 放大看到的 + /// "拉近了有断口"就是这么来的。闭合的多边形靠把首点补到末尾来实现。 + /// + private void DrawPolyline(Vector2[] points, int count, bool close, Color color, float thickness) + { + int length = count + (close ? 1 : 0); + if (length < 2) return; + var buffer = new Vector2[length]; + for (int i = 0; i < count; i++) buffer[i] = points[i]; + if (close) buffer[count] = points[0]; + WireRenderer.DrawPolyline(buffer, color, thickness); + } + + private void DrawCross(in XChartCylinderDisc2D disc) + { + Vector2 left, top, right, bottom; + XChartCylinderGeometry.CrossPoints(disc, SegmentCount, out left, out top, out right, out bottom); + // 过圆心的三段折线(左-心-右 / 上-心-下):转角连接由同一条线内的接缝补齐 + m_Cross[0] = left; + m_Cross[1] = disc.Center; + m_Cross[2] = right; + DrawPolyline(m_Cross, 3, false, CrossColor, CrossThickness); + m_Cross[0] = top; + m_Cross[1] = disc.Center; + m_Cross[2] = bottom; + DrawPolyline(m_Cross, 3, false, CrossColor, CrossThickness); + } + + /// + /// 内部母线:两端对应采样点连线(不是随便连)——对应关系由同一个采样角保证, + /// 所以它和端面十字是同一套顶点,转起来不会互相错位。 + /// + private void DrawGeneratrices() + { + int segments = Mathf.Clamp(SegmentCount, 8, 256); + int stride = Mathf.Max(1, segments / Mathf.Max(1, GeneratrixCount)); + for (int i = 0; i < segments; i += stride) + { + Vector2 from = m_DiscStart.PointAtStep(i, segments); + Vector2 to = m_DiscEnd.PointAtStep(i, segments); + WireRenderer.DrawLine(from, to, GeneratrixColor, OutlineThickness); + } + } + + private void EnsureBuffers(int segments) + { + // scratch 装两片椭圆的采样点;包点缓冲按凸包容量口径要 2×采样数 + int samples = segments * 2; + if (m_Scratch.Length < samples) + { + m_Scratch = new Vector2[samples]; + m_Outline = new Vector2[samples * 2]; + } + } + + protected override void OnDispose() + { + FillRenderer = null; + CurveRenderer = null; + WireRenderer = null; + m_Scratch = null; + m_Outline = null; + m_Tags = null; + } + +#if UNITY_EDITOR + /// 报表里点名轮廓点数与各开关:0 要能分清"没算"还是"算出来是空"(轮廓点数=0 时 m_Dirty 也停了) + internal override void AppendDebugLine(System.Text.StringBuilder sb) + { + base.AppendDebugLine(sb); + sb.Append(" outlinePoints=").Append(m_OutlineCount) + .Append(" curveEntries=").Append(m_CurveEntries) + .Append(" fill=").Append(ShowFill) + .Append(" fillChunks=").Append(FillRenderer != null ? FillRenderer.ChunkCount : 0) + .Append(" fillMaxVerts=").Append(FillRenderer != null ? FillRenderer.MaxChunkVertices : 0) + .Append(" curveVerts=").Append(CurveRenderer != null ? CurveRenderer.LiveVertexCount : 0) + .Append(" wireVerts=").Append(WireRenderer != null ? WireRenderer.LiveVertexCount : 0) + .Append(" ringStart=").Append(ShowStartRing) + .Append(" ringEnd=").Append(ShowEndRing) + .Append(" ringArcs=").Append(m_RingArcs) + .Append(" ringFullCaps=").Append(m_RingFullCaps) + .Append(" cross=").Append(ShowCapCross) + .Append(" generatrices=").Append(GeneratrixCount) + .Append(" normals=").Append(StartNormal.sqrMagnitude > 1e-8f ? "explicit" : "alongAxis") + .Append("/").Append(EndNormal.sqrMagnitude > 1e-8f ? "explicit" : "alongAxis") + // 几何来源:数据模式下必须能看出"这一帧画了几根、取的是哪几组记录", + // 否则 skipped 与 literal、以及"截断了多少"都分不清 + .Append(" geometry=").Append(m_GeometryNote) + .Append(" cylinders=").Append(m_CylinderCount); + } +#endif + } +} \ No newline at end of file diff --git a/Runtime/XChart/Mesh/ChartToolCylinder.cs.meta b/Runtime/XChart/Mesh/ChartToolCylinder.cs.meta new file mode 100644 index 0000000..e65d0cb --- /dev/null +++ b/Runtime/XChart/Mesh/ChartToolCylinder.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 75b05406ca016db469518a7bff37d1a4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Mesh/ChartToolMeshBg.cs b/Runtime/XChart/Mesh/ChartToolMeshBg.cs new file mode 100644 index 0000000..e1cd817 --- /dev/null +++ b/Runtime/XChart/Mesh/ChartToolMeshBg.cs @@ -0,0 +1,510 @@ +using System; +using System.Collections.Generic; +using UnityEngine; +using XericLibrary.Runtime.UIGraph; +using XericUI.Core; +using XericUI.XChart.Axis; +using XericUI.XChart.Space; + +namespace XericUI.XChart.Mesh +{ + /// + /// 伪立方体背景元素:填充面 + 面内网格(线框棱由 ChartToolCubeBg 负责,两者可同用)。 + /// + /// 画哪些面由掩码决定,不看可见性:图表里的背景网格常画在背朝观察者的那几面 + /// (后墙 / 底面),所以 与 是两份独立的 + /// ,字母契约见该类型(a=前 b=后 c=上 d=下 e=左 f=右)。 + /// + /// 深度顺序:填充按面心深度从远到近提交(画家算法),半透明叠色才正确; + /// 网格线跟在填充之后(子节点顺序 = 绘制顺序)。 + /// + /// 空间来源:本元素不再自己算投影,而是问图里的 + /// 要矩阵和面帧(投影 = 基变换 ∘ 工具变换)。 + /// 散点/轴线问的是同一个空间,所以点必然落在背景里——这是结构保证,不是两边凑数值。 + /// + [AddComponentMenu(XericRegistrationPaths.Chart + "/Mesh/Cube Mesh Background Tool")] + public class ChartToolMeshBg : XChartToolBase + { + // ── 工具变换(在图的空间之上再叠一层) ──────────────────── + + /// + /// 背景自己的变换(立方体局部单位)。默认恒等——背景通常就占满图的空间。 + /// 想画一个"小一号/偏一角"的背景格子时才用它。 + /// + public XChartToolTransform Transform { get; set; } = XChartToolTransform.Identity; + + // ── 填充 ────────────────────────────────────────────────── + + /// 要填充哪些面 + public XChartCubeFaceMask FillFaces { get; set; } = XChartCubeFaceMask.None; + + /// 填充色(面边缘) + public Color FillColor { get; set; } = new Color(0.16f, 0.19f, 0.24f, 0.85f); + + /// 填充面中心色;与 不同时走径向渐变 + public Color FillCenterColor { get; set; } = new Color(0.16f, 0.19f, 0.24f, 0.85f); + + // ── 面内网格 ────────────────────────────────────────────── + + /// 要画网格的面 + public XChartCubeFaceMask GridFaces { get; set; } = XChartCubeFaceMask.None; + + /// 网格线颜色 + public Color GridColor { get; set; } = new Color(0.55f, 0.6f, 0.7f, 0.35f); + + /// 网格线宽 + public float GridThickness { get; set; } = 1f; + + /// 每个方向的网格分割数(统一值;S/T 各自给了正数时按各自的来) + public int GridDivisions { get; set; } = 5; + + /// S 方向分格数。0=跟随 。 + /// 等分时"沿 S 的线由 T 的分格数决定"(算式在 ,探针钉着); + /// 绑了维度时这个数是那一族线的目标刻度条数(不是分格数,规范 §22)。 + public int GridDivisionsS { get; set; } + + /// T 方向分格数。0=跟随 + public int GridDivisionsT { get; set; } + + /// 是否同时描出面轮廓(没有线框元素时也能看清面的边界) + public bool ShowFaceOutline { get; set; } = true; + + /// + /// 只画朝向观察者的面。默认 false——背景网格本就常画在背朝观察者的那几面(后墙/底面); + /// 想要"实体盒子"的观感时打开它。 + /// + public bool OnlyVisibleFaces { get; set; } + + /// 网格与轮廓的颜色与线宽(轮廓更实一点) + public Color OutlineColor { get; set; } = new Color(0.7f, 0.75f, 0.85f, 0.6f); + + // ── 内部组件 ────────────────────────────────────────────── + + /// 面填充渲染器 + public XChartMeshFillRenderer FillRenderer { get; private set; } + + /// 面内网格渲染器 + public UILineRendererV2 GridRenderer { get; private set; } + + // ── 投影状态(权威在 ChartToolSpace,这里只缓存复合结果) ── + + private readonly XChartFaceFrame[] m_FaceFrames = new XChartFaceFrame[XChartCubeGeometry.FaceCount]; + private readonly List m_SortedFaces = new List(XChartCubeGeometry.FaceCount); + + private struct FaceSortEntry + { + public int Face; + public float Depth; + } + + private static readonly Comparison s_FarToNear = + (left, right) => left.Depth.CompareTo(right.Depth); + + private ChartToolSpace m_Space; + private Matrix4x4 m_Composed = Matrix4x4.identity; + private int m_LastSpaceVersion = -1; + /// 上一次发布格线时数据模型的版本号:绑了维度的格线要跟着数据走, + /// 而数据变化不会动空间的投影版本,所以这个号要单独判(否则"数据变了格线还停在老位置") + private long m_LastDataVersion = -1; + private bool m_Dirty = true; + /// 发布插槽用的复用缓冲(一个面的四角 = 12 个值) + private readonly float[] m_SlotValues = new float[12]; + + // 本帧的自述读数:画了几条线 / 发了几条线 / 提交了几块几面 / 面帧有效几个 + private int m_LinesS; + private int m_LinesT; + private int m_GridLinesPublished; + private int m_GridFacesPublished; + private int m_GridSlotsRetracted; + private int m_GridLinesDrawn; + private int m_GridFacesDrawn; + private int m_FacesOutlined; + private int m_FacesFilled; + + /// 格线插槽的值暂存:两个方向各一个,长度按各自的条数精确相等(板子按数组长度算组数) + private float[] m_GridValuesS; + private float[] m_GridValuesT; + + /// 这一方向各条线的面参数比例(等分或数据刻度),复用不分配 + private float[] m_RatioScratchS; + private float[] m_RatioScratchT; + private readonly List m_TickScratch = new List(); + + /// 沿 S 的线绑哪一维(<0 = 不绑,等分) + public int GridDimensionS { get; set; } = -1; + + /// 沿 T 的线绑哪一维(<0 = 不绑,等分) + public int GridDimensionT { get; set; } = -1; + + /// 本元素的变换变了(或想强制重取空间)时调用 + public void MarkDirty() => m_Dirty = true; + + /// 本工具定义网格(发布面/格线插槽、算范围)⇒ 归定义组、最先跑(规范 §11.4); + /// 它"画在底下"这件事由绘制序(默认最小)表达,与分组无关 + public override XChartToolCategory Category => XChartToolCategory.Definition; + + /// 取某个面的面帧(图表局部像素) + public XChartFaceFrame GetFaceFrame(XChartCubeGeometry.CubeFace face) + { + UpdateProjection(); + return m_FaceFrames[(int)face]; + } + + /// + /// 空间版本没变、自己的变换也没变,就一次矩阵乘法都不做。 + /// 空间是渲染时现找的(不是初始化时塞的),所以注册先后顺序不影响正确性。 + /// + private void UpdateProjection() + { + m_Space = Context?.Space; + if (m_Space == null) return; + + // 数据版本也要判:格线绑了维度时"线在哪"是数据的函数,而写数据不会动空间的投影版本 + var data = Context != null ? Context.Data : null; + long dataVersion = data != null ? data.Version : -1; + if (!m_Dirty && m_Space.ProjectionVersion == m_LastSpaceVersion && dataVersion == m_LastDataVersion) return; + m_Dirty = false; + m_LastSpaceVersion = m_Space.ProjectionVersion; + m_LastDataVersion = dataVersion; + + m_Composed = m_Space.Compose(Transform); + m_Space.BuildFaceFrames(m_FaceFrames, m_Composed); + SortFacesByDepth(); + PublishFaceSlots(); + } + + /// + /// 把六个面发布成 `Quad3D` 插槽(规范 §11.2):本工具是定义网格的那一个,其余工具按 id 取用。 + /// 发布的是**单位立方体的四角**(不是像素):消费者用自己的矩阵投影,于是 + /// "谁投影"仍只有一条路,而"哪个面在哪儿"由定义者说了算——换成异形网格只需改这里。 + /// + private void PublishFaceSlots() + { + IXChartSlotBoard board = Context?.Slots; + if (board == null) return; + + for (int i = 0; i < XChartCubeGeometry.FaceCount; i++) + { + var face = (XChartCubeGeometry.CubeFace)i; + Vector3 c00, c01, c11, c10; + XChartCubeGeometry.GetFaceCorners(face, out c00, out c01, out c11, out c10); + + m_SlotValues[0] = c00.x; m_SlotValues[1] = c00.y; m_SlotValues[2] = c00.z; + m_SlotValues[3] = c01.x; m_SlotValues[4] = c01.y; m_SlotValues[5] = c01.z; + m_SlotValues[6] = c11.x; m_SlotValues[7] = c11.y; m_SlotValues[8] = c11.z; + m_SlotValues[9] = c10.x; m_SlotValues[10] = c10.y; m_SlotValues[11] = c10.z; + + board.Publish(XChartCubeGeometry.FaceSlotId(face), XChartSlotMode.Quad3D, + XChartSlotAccess.ReadOnly, m_SlotValues, out string _); + } + + PublishGridSlots(board); + } + + /// + /// 把每个面的**格线**发布成 Line3D 插槽(规范 §11.2 / P9):沿 S 的一组与 + /// 沿 T 的一组。发布的是单位立方体端点,与 mesh.face.<n> 的四角同一口径 + /// ⇒ 谁投影仍只有一条路。 + /// + /// 线位置由谁定:绑了维度(/ ≥ 0) + /// 就用该维的数据范围算刻度位置(,与轴线刻度同一套 nice step); + /// 没绑就等分(比例 i/(count-1),与旧行为逐位相同)——"网格线的定义权在网格、 + /// 轴线按发布的线跟随"这句话就落在这里。 + /// + /// 缓冲必须长度精确:插槽板按数组长度算组数,开大了会把残留当成额外的线发出去。 + /// + private void PublishGridSlots(IXChartSlotBoard board) + { + // 条数只算一次(两个方向各一份),缓冲按两者最大值开;比例数组算完就留着给绘制侧用, + // 于是"画上哪几条线"与"发布给轴线哪几条线"不可能各说各话(规范 §22) + m_LinesS = XChartGridDivisions.LinesAlongS(GridDivisionsS, GridDivisionsT, GridDivisions); + m_LinesT = XChartGridDivisions.LinesAlongT(GridDivisionsS, GridDivisionsT, GridDivisions); + EnsureRatioBuffers(Mathf.Max(m_LinesS, m_LinesT)); + m_LinesS = BuildGridRatios(true, m_RatioScratchS); + m_LinesT = BuildGridRatios(false, m_RatioScratchT); + + m_GridLinesPublished = 0; + m_GridFacesPublished = 0; + m_GridSlotsRetracted = 0; + for (int i = 0; i < XChartCubeGeometry.FaceCount; i++) + { + var face = (XChartCubeGeometry.CubeFace)i; + if (DrawsGridOnFace(face)) + { + m_GridFacesPublished++; + m_GridLinesPublished += PublishGridSlot(board, face, true, m_RatioScratchS, m_LinesS); + m_GridLinesPublished += PublishGridSlot(board, face, false, m_RatioScratchT, m_LinesT); + continue; + } + + // 不画的那个面得把上一轮发出去的那批线**撤下来**:插槽说的是"这里有线可吸", + // 只发不收就等于留一批画面上并不存在的线给轴线去吸(规范 §22) + m_GridSlotsRetracted += RetractGridSlot(board, face, true); + m_GridSlotsRetracted += RetractGridSlot(board, face, false); + } + } + + private static int RetractGridSlot(IXChartSlotBoard board, XChartCubeGeometry.CubeFace face, bool alongS) + => board.Unpublish(XChartCubeGeometry.GridSlotId(face, alongS)) ? 1 : 0; + + /// + /// 这个面的格线这一帧到底会不会被画出来——发布侧与绘制侧共用这同一个判据。 + /// + /// 插槽的语义是"这里有格线,可以吸附"。把掩码筛掉的面、背朝观察者的面(开了"只画可见面"时)、 + /// 面帧退化的面也发出去,轴线就会去吸一条画面上一条都不存在的线——那正是本轮要消灭的 + /// "关掉一边、另一边还跟着"的形状,只是换到了插槽这一层(规范 §22)。 + /// 两侧各写一遍过滤迟早会飘,所以只写一次。 + /// + private bool DrawsGridOnFace(XChartCubeGeometry.CubeFace face) + { + if (!XChartCubeFaceMaskUtility.HasFace(GridFaces, face)) return false; + if (!m_FaceFrames[(int)face].IsValid) return false; + if (OnlyVisibleFaces && m_Space != null && !m_Space.IsFaceVisible(face, m_Composed)) return false; + return true; + } + + private int PublishGridSlot(IXChartSlotBoard board, XChartCubeGeometry.CubeFace face, + bool alongS, float[] ratios, int lines) + { + int needed = XChartCubeGeometry.GridSlotValueCount(lines); + if (needed <= 0) return 0; + + float[] buffer = alongS ? m_GridValuesS : m_GridValuesT; + if (buffer == null || buffer.Length != needed) + { + buffer = new float[needed]; + if (alongS) m_GridValuesS = buffer; + else m_GridValuesT = buffer; + } + + if (XChartCubeGeometry.FillGridLineValues(face, alongS, ratios, lines, buffer) <= 0) return 0; + board.Publish(XChartCubeGeometry.GridSlotId(face, alongS), XChartSlotMode.Line3D, + XChartSlotAccess.ReadOnly, buffer, out string _); + return lines; + } + + /// + /// 这一方向的线位置:绑了维度就用数据范围算刻度(与轴线同源),否则等分。 + /// 那一维没有数据时退回等分而不是不画——网格整片消失比"线回到等分"难查得多。 + /// + private int BuildGridRatios(bool alongS, float[] ratios) + { + // 等分那一档的条数:算式只在 XChartGridDivisions 里("沿 S 的线由 T 的分格数决定",探针钉着) + int lines = alongS + ? XChartGridDivisions.LinesAlongS(GridDivisionsS, GridDivisionsT, GridDivisions) + : XChartGridDivisions.LinesAlongT(GridDivisionsS, GridDivisionsT, GridDivisions); + int dimension = alongS ? GridDimensionS : GridDimensionT; + var context = Context; + + if (dimension < 0 || context == null) + return XChartGridLines.BuildUniformRatios(lines, ratios); + + double min, max; + if (!context.TryResolveDomain(dimension, out min, out max)) + return XChartGridLines.BuildUniformRatios(lines, ratios); + + // 绑了维度:条数目标=该方向自己那个分格数(0=统一值),刻度由数据范围定 + int target = Mathf.Max(2, alongS + ? XChartGridDivisions.Resolve(GridDivisionsS, GridDivisions) + : XChartGridDivisions.Resolve(GridDivisionsT, GridDivisions)); + return XChartGridLines.BuildRatios(min, max, XChartAxisScale.Linear, 0.0, + target, 0.0, true, ratios, m_TickScratch); + } + + private void EnsureRatioBuffers(int capacity) + { + if (m_RatioScratchS == null || m_RatioScratchS.Length < capacity) m_RatioScratchS = new float[capacity]; + if (m_RatioScratchT == null || m_RatioScratchT.Length < capacity) m_RatioScratchT = new float[capacity]; + } + + // ── 初始化 ──────────────────────────────────────────────── + + protected override void OnInitialize() + { + // 先建填充、后建网格:兄弟顺序就是绘制顺序,网格要在填充之上 + FillRenderer = CreateChildComponent("CubeFaceFill"); + if (FillRenderer != null) Stretch(FillRenderer.rectTransform); + + GridRenderer = CreateChildComponent("CubeFaceGrid"); + if (GridRenderer != null) + { + GridRenderer.defaultColor = GridColor; + GridRenderer.defaultThickness = GridThickness; + Stretch(GridRenderer.rectTransform); + } + + SetVisible(true); + } + + private static void Stretch(RectTransform rect) + { + rect.anchorMin = Vector2.zero; + rect.anchorMax = Vector2.one; + rect.offsetMin = Vector2.zero; + rect.offsetMax = Vector2.zero; + } + + // ── 画家序 ──────────────────────────────────────────────── + + /// 按面心深度从远到近排序(画家算法:远的先提交) + private void SortFacesByDepth() + { + m_SortedFaces.Clear(); + for (int i = 0; i < XChartCubeGeometry.FaceCount; i++) + { + m_SortedFaces.Add(new FaceSortEntry + { + Face = i, + Depth = XChartCubeGeometry.GetFaceDepth(m_Composed, (XChartCubeGeometry.CubeFace)i), + }); + } + m_SortedFaces.Sort(s_FarToNear); + } + + // ── 渲染 ────────────────────────────────────────────────── + + public override void OnRender() + { + base.OnRender(); + + UpdateProjection(); + + DrawFill(); + DrawGrid(); + } + + private void DrawFill() + { + m_FacesFilled = 0; + if (FillRenderer == null) return; + + FillRenderer.ClearFaces(); + if (FillFaces != XChartCubeFaceMask.None) + { + for (int i = 0; i < m_SortedFaces.Count; i++) + { + var face = (XChartCubeGeometry.CubeFace)m_SortedFaces[i].Face; + if (!XChartCubeFaceMaskUtility.HasFace(FillFaces, face)) continue; + if (OnlyVisibleFaces && !m_Space.IsFaceVisible(face, m_Composed)) continue; + + XChartFaceFrame frame = m_FaceFrames[(int)face]; + if (!frame.IsValid) continue; + + FillRenderer.AddFace(frame.CornerST00, frame.CornerST01, frame.CornerST11, frame.CornerST10, + FillColor, FillCenterColor); + m_FacesFilled++; + } + } + FillRenderer.Apply(); + } + + private void DrawGrid() + { + m_GridLinesDrawn = 0; + m_GridFacesDrawn = 0; + m_FacesOutlined = 0; + if (GridRenderer == null) return; + + GridRenderer.ClearAll(); + if (GridFaces == XChartCubeFaceMask.None) return; + + // 格线的位置**不在这里再算一遍**:用发布那一侧留下的同一份比例数组(PublishGridSlots 里填的), + // 于是"画上的线"与"轴线能吸附到的线"永远是同一批。旧版这里自己按 divisions 等分, + // 发布侧按刻度算,两条路各画一套(规范 §22) + for (int i = 0; i < m_SortedFaces.Count; i++) + { + var face = (XChartCubeGeometry.CubeFace)m_SortedFaces[i].Face; + // 与发布侧同一个判据:哪些面有格线,只许有一处说了算(DrawsGridOnFace) + if (!DrawsGridOnFace(face)) continue; + + XChartFaceFrame frame = m_FaceFrames[(int)face]; + m_GridFacesDrawn++; + + if (ShowFaceOutline) + { + frame.GetLineAlongS(0f, out Vector2 bottomFrom, out Vector2 bottomTo); + frame.GetLineAlongS(1f, out Vector2 topFrom, out Vector2 topTo); + frame.GetLineAlongT(0f, out Vector2 leftFrom, out Vector2 leftTo); + frame.GetLineAlongT(1f, out Vector2 rightFrom, out Vector2 rightTo); + + GridRenderer.DrawLine(bottomFrom, bottomTo, OutlineColor, GridThickness); + GridRenderer.DrawLine(topFrom, topTo, OutlineColor, GridThickness); + GridRenderer.DrawLine(leftFrom, leftTo, OutlineColor, GridThickness); + GridRenderer.DrawLine(rightFrom, rightTo, OutlineColor, GridThickness); + m_GridLinesDrawn += 4; + m_FacesOutlined++; + } + + for (int d = 0; d < m_LinesS; d++) + { + frame.GetLineAlongS(m_RatioScratchS[d], out Vector2 from, out Vector2 to); + GridRenderer.DrawLine(from, to, GridColor, GridThickness); + m_GridLinesDrawn++; + } + + for (int d = 0; d < m_LinesT; d++) + { + frame.GetLineAlongT(m_RatioScratchT[d], out Vector2 from, out Vector2 to); + GridRenderer.DrawLine(from, to, GridColor, GridThickness); + m_GridLinesDrawn++; + } + } + } + +#if UNITY_EDITOR + /// + /// 这一帧的自述:fillFaces/gridFaces 是掩码字母(面板上改的数有没有真落到工具上), + /// filled= 提交了几面填充,faces=画上/发出 与 linesCheck= 是本元素的**自证**: + /// "画上哪几条线"和"发布给轴线哪几条线"必须同一批(差值只许来自描轮廓的 4 条/面)。 + /// 判决由被测进程自己印——"应当相等"写在文档里没人查就等于没写(规范 §22)。 + /// 他报的"填充面改了没反应"这类症状,也只有这几个数能分清是"没提交"还是"提交了看不见"。 + /// + internal override void AppendDebugLine(System.Text.StringBuilder sb) + { + base.AppendDebugLine(sb); + int valid = 0; + for (int i = 0; i < m_FaceFrames.Length; i++) + if (m_FaceFrames[i].IsValid) valid++; + // 轮廓那 4 条只画不发(插槽里发的是格线,不含边框),所以期望值要把它加回去 + int want = m_GridLinesPublished + m_FacesOutlined * 4; + sb.Append(" fillFaces=").Append(XChartCubeFaceMaskUtility.Describe(FillFaces)) + .Append(" gridFaces=").Append(XChartCubeFaceMaskUtility.Describe(GridFaces)) + .Append(" filled=").Append(m_FacesFilled) + .Append(" gridDrawn=").Append(m_GridLinesDrawn) + .Append(" gridPublished=").Append(m_GridLinesPublished) + .Append(" faces=").Append(m_GridFacesDrawn).Append('/').Append(m_GridFacesPublished) + .Append(" retracted=").Append(m_GridSlotsRetracted) + .Append(" linesCheck=").Append(m_GridLinesDrawn == want ? "ok" + : "DIFF drawn=" + m_GridLinesDrawn + " want=" + want) + .Append(" lines=").Append(m_LinesS).Append('/').Append(m_LinesT) + .Append(" frames=").Append(valid).Append('/').Append(m_FaceFrames.Length) + .Append(" chunks=").Append(FillRenderer != null ? FillRenderer.ChunkCount : -1) + .Append(" renderers=").Append(FillRenderer == null ? "fill-NULL" : "ok") + .Append('/').Append(GridRenderer == null ? "grid-NULL" : "ok"); + } +#endif + + // ── 清理 ────────────────────────────────────────────────── + + protected override void OnDispose() + { + // 元素是格线的唯一作者 ⇒ 元素没了,它发过的格线插槽必须跟着没(否则轴线还在吸一批 + // 已经没有任何东西在画的线,规范 §22)。这里**只撤自己发的**:`mesh.face.` 那批四角 + // 是立方体本身的几何,线框元素也在发,动它就是拆别人定义的东西。 + var board = Context?.Slots; + if (board != null) + { + for (int i = 0; i < XChartCubeGeometry.FaceCount; i++) + { + var face = (XChartCubeGeometry.CubeFace)i; + board.Unpublish(XChartCubeGeometry.GridSlotId(face, true)); + board.Unpublish(XChartCubeGeometry.GridSlotId(face, false)); + } + } + + FillRenderer = null; + GridRenderer = null; + m_SortedFaces.Clear(); + } + } +} \ No newline at end of file diff --git a/Runtime/XChart/Mesh/ChartToolMeshBg.cs.meta b/Runtime/XChart/Mesh/ChartToolMeshBg.cs.meta new file mode 100644 index 0000000..342ad54 --- /dev/null +++ b/Runtime/XChart/Mesh/ChartToolMeshBg.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4bc06795ba034015814db2d0981a74a7 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Mesh/ChartToolVectorArrows.cs b/Runtime/XChart/Mesh/ChartToolVectorArrows.cs new file mode 100644 index 0000000..232262d --- /dev/null +++ b/Runtime/XChart/Mesh/ChartToolVectorArrows.cs @@ -0,0 +1,296 @@ +using System; +using System.Collections.Generic; +using UnityEngine; +using XericLibrary.Runtime.UIGraph; +using XericUI.Core; +using XericUI.XChart.Space; + +namespace XericUI.XChart.Mesh +{ + /// + /// 向量场 / 流形箭头元素:一条记录占 6 个数值维——两组三维, + /// 按 解释成一支箭头(绝对=方向矢量 / 相对=第二个点)。 + /// 后面可以再接 3~4 维颜色(色相/饱和度/明度 [+不透明度]),见 。 + /// + /// 两种读法(他 2026-10-25 口述): + /// 绝对 ⇒ 后三维是方向本身,起点加方向乘倍率就是末端(螺旋点画出来是一片"刺猬"); + /// 相对 ⇒ 后三维是第二个点,箭头是第一点指向第二点(一串首尾相接的点读起来就是"连着头转")。 + /// + /// 连续绘制:把所有记录的第一组三维按顺序连成折线(只有最后一段带箭头)。 + /// 这时"相对/绝对"不适用 ⇒ 配置里那一项隐藏(互斥显示)。 + /// + /// 箭头是自己拼的,没有用库里的 ArrowShape:那套箭头是给曲线的屏幕空间 + /// 图元用的,而这里的箭头必须跟着立方体姿态走(投影后长短和方向都在变)。做法是 + /// 只让空间负责两端的投影,杆和头都在像素空间里量出来:杆是一段等宽四边形, + /// 头是一个退化四边形(三角形),宽度恒定所以任何姿态下都不会塌成一条线。 + /// + /// 数据只经过中转接口:按维度下标 逐条取, + /// 不碰记录数组;条数由 兜住,免得十万条记录一口气投影。 + /// + [AddComponentMenu(XericRegistrationPaths.Chart + "/Mesh/Vector Arrow Tool")] + public sealed class ChartToolVectorArrows : XChartToolBase + { + /// 起点的维度下标(矢量再占三维,颜色再往后) + public int OriginDimension { get; set; } + /// 两组三维怎么读成一支箭头 + public XChartArrowVectorMode VectorMode { get; set; } = XChartArrowVectorMode.Absolute; + /// 把每条记录的第一个点按顺序连成折线(此时相对/绝对不适用) + public bool Continuous { get; set; } + /// 方向向量的长度倍率(立方体单位);相对模式下作用在差向量上 + public float DirectionScale { get; set; } = 0.25f; + /// 最多画多少条(数据再多也只取前 N 条,避免一次性铺满) + public int MaxArrowCount { get; set; } = 512; + + /// 箭头自己的变换(叠在图的空间之上) + public XChartToolTransform Transform { get; set; } = XChartToolTransform.Identity; + + // ── 颜色:可选的三到四个数值维 ──────────────────────────── + + /// 是否用额外的数值维给每支箭头上色 + public bool UseColorDimensions { get; set; } + /// 颜色维的起点(色相、饱和度、明度 [+不透明度]) + public int ColorDimension { get; set; } = 6; + /// 是否多读一维不透明度 + public bool HasAlphaDimension { get; set; } + + public Color ArrowColor { get; set; } = new Color(0.95f, 0.6f, 0.25f, 0.9f); + public float ShaftWidth { get; set; } = 2f; + public float HeadLength { get; set; } = 10f; + public float HeadWidth { get; set; } = 7f; + /// 方向为零向量时什么都不画;给个数就画成一个点 + public bool ShowZeroVectorsAsDots { get; set; } + + public XChartMeshFillRenderer FillRenderer { get; private set; } + + private Matrix4x4 m_Composed = Matrix4x4.identity; + private int m_LastSpaceVersion = -1; + private long m_LastDataVersion = -1; + private bool m_Dirty = true; + + private readonly List m_Faces = new List(256); + + // 本帧的自述读数:算了几支 / 表里几个数值维 / 够不够 + private int m_ArrowsBuilt; + private int m_DimensionsHave; + private int m_DimensionsNeed; + + private struct ArrowFace + { + public Vector2 A; + public Vector2 B; + public Vector2 C; + public Vector2 D; + public float Depth; + public Color Color; + } + + private static readonly Comparison s_FarToNear = + (left, right) => left.Depth.CompareTo(right.Depth); + + public void MarkDirty() => m_Dirty = true; + + /// + /// 这个元素要几个数值维:矢量 6 +(可选)颜色 3。 + /// 不透明度那一维不算硬需求:它多给就多读、没给就退回单色的 alpha—— + /// 把它算进门槛的话,勾一下"有不透明度"会让整个元素突然一条都不画(维数不够), + /// 那是把这一个开关变成了总闸。 + /// + public int RequiredDimensionCount + => XChartArrowConfig.VectorDimensionCount + (UseColorDimensions ? 3 : 0); + + protected override void OnInitialize() + { + FillRenderer = CreateChildComponent("ArrowFill"); + if (FillRenderer != null) + { + var rect = FillRenderer.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); + + BuildFaces(space); + + FillRenderer.ClearFaces(); + for (int i = 0; i < m_Faces.Count; i++) + { + ArrowFace face = m_Faces[i]; + FillRenderer.AddFace(face.A, face.B, face.C, face.D, face.Color, face.Color); + } + FillRenderer.Apply(); + } + + private void BuildFaces(ChartToolSpace space) + { + m_Faces.Clear(); + m_ArrowsBuilt = 0; + m_DimensionsHave = 0; + m_DimensionsNeed = RequiredDimensionCount; + + var source = Data; + if (source == null || !source.HasData) return; + + m_DimensionsHave = source.NumericDimensionCount; + // 维数不够就一条都不画(现象是"加了工具但什么都没显示")——需求与实际两个数都留在报表里, + // 面板也会印同一对(规范 §25) + if (m_DimensionsHave < OriginDimension + RequiredDimensionCount) return; + + int records = source.RecordCount; + int limit = records; + if (MaxArrowCount > 0 && MaxArrowCount < limit) limit = 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, OriginDimension); + Vector3 second = ReadPoint(source, i, OriginDimension + 3); + // 两种读法的算式在纯算术里(离线钉着):绝对=后三维就是方向;相对=后三维是第二个点 + Vector3 tip = XChartVectorFieldMath.Tip(VectorMode, first, second, DirectionScale); + + if (AddArrow(space, first, tip, ColorAt(source, i))) m_ArrowsBuilt++; + } + + m_Faces.Sort(s_FarToNear); + } + + /// + /// 连续绘制:把所有记录的第一个点按顺序连成一条折线,只有最后一段带箭头。 + /// 读的是每组的第一组三维(坐标),后面那几维(方向/第二点/颜色维)在这种模式下不参与—— + /// 连起来的本来就是空间里的一条路径。 + /// + private void BuildContinuous(IXChartDataSource source, ChartToolSpace space, int limit) + { + if (limit < 2) return; + + Vector3 previous = ReadPoint(source, 0, OriginDimension); + for (int i = 1; i < limit; i++) + { + Vector3 current = ReadPoint(source, i, OriginDimension); + bool last = i == limit - 1; + // 段用"到达点"的颜色(最后一段的箭头也用它):一串颜色维读下来就是沿路径渐变 + AddArrow(space, previous, current, ColorAt(source, i), last); + m_ArrowsBuilt++; + previous = current; + } + } + + /// 一支箭头 = 杆 +(可选)头。退化(零长度)时按开关画成一个小方块 + private bool AddArrow(ChartToolSpace space, Vector3 origin, Vector3 tip, Color color, 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 = color, + }); + return true; + } + + m_Faces.Add(new ArrowFace + { + A = shaftA, B = shaftB, C = shaftC, D = shaftD, Depth = depth, Color = color, + }); + if (!withHead) return true; + + m_Faces.Add(new ArrowFace + { + A = headA, B = headB, C = headC, D = headD, Depth = depth, Color = color, + }); + return true; + } + + private static Vector3 ReadPoint(IXChartDataSource source, int record, int dimension) + { + return new Vector3( + (float)source.GetValueAt(record, dimension), + (float)source.GetValueAt(record, dimension + 1), + (float)source.GetValueAt(record, dimension + 2)); + } + + /// + /// 这一条记录的颜色:没开颜色维就是单色;开了就按 + /// [色相(0..256 色环), 饱和度(0..1), 明度(0..1), (不透明度 0..1)] 读。 + /// 读不成(维不够或值不是有限数)就退回单色——不是画成黑:黑在深色背景上等于没画, + /// 而"退回了单色"这件事在报表的 colors= 读数里看得见。 + /// + private Color ColorAt(IXChartDataSource source, int record) + { + if (!UseColorDimensions) return ArrowColor; + if (source.NumericDimensionCount < ColorDimension + 3) 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; + m_Faces.Clear(); + } + +#if UNITY_EDITOR + /// + /// 报表里点名这一帧:维数(现有/需要)+算了几支+读法+面数/块数。 + /// "加了工具什么都没显示"这件事只有这一行分得清是"维数不够"还是"算了但没提交" + /// (他 2026-10-25 现场;规范 §25)。 + /// + internal override void AppendDebugLine(System.Text.StringBuilder sb) + { + base.AppendDebugLine(sb); + sb.Append(" dims=").Append(m_DimensionsHave).Append('/').Append(m_DimensionsNeed) + .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(" arrowFaces=").Append(FillRenderer != null ? FillRenderer.FaceCount : 0) + .Append(" fillChunks=").Append(FillRenderer != null ? FillRenderer.ChunkCount : 0) + .Append(" fillMaxVerts=").Append(FillRenderer != null ? FillRenderer.MaxChunkVertices : 0); + } +#endif + } +} \ No newline at end of file diff --git a/Runtime/XChart/Mesh/ChartToolVectorArrows.cs.meta b/Runtime/XChart/Mesh/ChartToolVectorArrows.cs.meta new file mode 100644 index 0000000..1124c5f --- /dev/null +++ b/Runtime/XChart/Mesh/ChartToolVectorArrows.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: bde26796110e5ae4b9a4f3d79fe688c2 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Mesh/XChartArrowGeometry.cs b/Runtime/XChart/Mesh/XChartArrowGeometry.cs new file mode 100644 index 0000000..c9e5e5d --- /dev/null +++ b/Runtime/XChart/Mesh/XChartArrowGeometry.cs @@ -0,0 +1,70 @@ +using System; +using UnityEngine; + +namespace XericUI.XChart.Mesh +{ + /// + /// 箭头的像素空间几何:杆 + 头两组四边形。 + /// + /// 放在像素空间算是有意的:箭头的宽度要恒定(不管视角怎么转、向量投得多短, + /// 头都得是个看得见的头),而长度和方向已经由 投影给出来了。 + /// 所以这里只做"沿单位方向量长度、按垂直方向量宽度"这一件事,纯数学、离线可验。 + /// + /// 会被钳到向量屏幕长度的 60%,因此短箭头的杆不会被头穿过去; + /// 屏幕长度接近 0 时返回 false,由调用方决定是画个点还是什么都不画。 + /// + public static class XChartArrowGeometry + { + /// 杆最长能占屏幕长度的比例上限之外,头也不得超过这个比例 + public const float HeadLengthRatioCap = 0.6f; + + /// 屏幕长度小于这个值就当"没有方向",交给调用方的退化分支。 + public const float MinScreenLength = 1e-3f; + + /// 杆的四角(沿箭头方向绕一圈) + 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; + } + + /// 头的四角:两个底角 + 尖点(尖点重复一次,四边形即三角形) + 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; + } + + /// + /// 一条箭头的完整拆分。 是屏幕上的尖点。 + /// 返回 false 表示屏幕长度退化。 + /// + 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; + } + } +} diff --git a/Runtime/XChart/Mesh/XChartArrowGeometry.cs.meta b/Runtime/XChart/Mesh/XChartArrowGeometry.cs.meta new file mode 100644 index 0000000..2fe73ec --- /dev/null +++ b/Runtime/XChart/Mesh/XChartArrowGeometry.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8e7522065536fdf438d0e378d47ca462 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Mesh/XChartCubeFaceMask.cs b/Runtime/XChart/Mesh/XChartCubeFaceMask.cs new file mode 100644 index 0000000..ec8f515 --- /dev/null +++ b/Runtime/XChart/Mesh/XChartCubeFaceMask.cs @@ -0,0 +1,113 @@ +using System; + +namespace XericUI.XChart.Mesh +{ + /// + /// 立方体六面的选择掩码。用它可以精确控制"渲染哪些面"(填充与网格各自独立一份掩码)。 + /// + /// 面编号契约(固定不变) + /// + /// a = 前 Front (法线 +Z) d = 下 Down (法线 -Y) + /// b = 后 Back (法线 -Z) e = 左 Left (法线 -X) + /// c = 上 Up (法线 +Y) f = 右 Right (法线 +X) + /// + /// 字母按语义绑定,与内部遍历顺序无关: 的枚举值 + /// 顺序将来即使调整,字母也不会跟着漂。 + /// + /// 注意:掩码是"画哪些面"的唯一依据,不看可见性——图表里的背景网格 + /// 恰恰常画在背朝观察者的那几面(后墙 / 底面)。要只画朝向观察者的面请自行用 + /// 过滤。 + /// + [Flags] + public enum XChartCubeFaceMask + { + None = 0, + /// a 前 + Front = 1 << 0, + /// b 后 + Back = 1 << 1, + /// c 上 + Up = 1 << 2, + /// d 下 + Down = 1 << 3, + /// e 左 + Left = 1 << 4, + /// f 右 + Right = 1 << 5, + + All = Front | Back | Up | Down | Left | Right, + + /// 三面(后 + 下 + 左):常见的"背景墙"一组 + BackWalls = Back | Down | Left, + } + + /// 面掩码与面之间的换算(与 的字母契约配套) + public static class XChartCubeFaceMaskUtility + { + /// 面的稳定字母(a=前 b=后 c=上 d=下 e=左 f=右) + public static char GetLetter(XChartCubeGeometry.CubeFace face) + { + switch (face) + { + case XChartCubeGeometry.CubeFace.Front: return 'a'; + case XChartCubeGeometry.CubeFace.Back: return 'b'; + case XChartCubeGeometry.CubeFace.Top: return 'c'; + case XChartCubeGeometry.CubeFace.Bottom: return 'd'; + case XChartCubeGeometry.CubeFace.Left: return 'e'; + default: return 'f'; + } + } + + /// 字母反查面 + public static bool TryParseLetter(char letter, out XChartCubeGeometry.CubeFace face) + { + switch (char.ToLowerInvariant(letter)) + { + case 'a': face = XChartCubeGeometry.CubeFace.Front; return true; + case 'b': face = XChartCubeGeometry.CubeFace.Back; return true; + case 'c': face = XChartCubeGeometry.CubeFace.Top; return true; + case 'd': face = XChartCubeGeometry.CubeFace.Bottom; return true; + case 'e': face = XChartCubeGeometry.CubeFace.Left; return true; + case 'f': face = XChartCubeGeometry.CubeFace.Right; return true; + default: face = XChartCubeGeometry.CubeFace.Front; return false; + } + } + + /// 单个面对应的掩码位 + public static XChartCubeFaceMask GetMask(XChartCubeGeometry.CubeFace face) + { + switch (face) + { + case XChartCubeGeometry.CubeFace.Front: return XChartCubeFaceMask.Front; + case XChartCubeGeometry.CubeFace.Back: return XChartCubeFaceMask.Back; + case XChartCubeGeometry.CubeFace.Top: return XChartCubeFaceMask.Up; + case XChartCubeGeometry.CubeFace.Bottom: return XChartCubeFaceMask.Down; + case XChartCubeGeometry.CubeFace.Left: return XChartCubeFaceMask.Left; + default: return XChartCubeFaceMask.Right; + } + } + + /// 掩码里是否包含某个面 + public static bool HasFace(XChartCubeFaceMask mask, XChartCubeGeometry.CubeFace face) + => (mask & GetMask(face)) != 0; + + /// + /// 掩码的字母写法(a=前 b=后 c=上 d=下 e=左 f=右,按面号升序),空掩码写作 -。 + /// + /// 报表与调试行要说"这一帧工具手上到底是哪几面",直接印枚举的数字没用—— + /// 面板上的掩码下拉显示的是字母组合,数字对不上眼睛;而印枚举名(Back | Down | Left) + /// 又会随枚举定义漂移。字母是这份契约里唯一钉住的语义(见类型注释),所以读数用它。 + /// + public static string Describe(XChartCubeFaceMask mask) + { + var builder = new System.Text.StringBuilder(); + for (int i = 0; i < 6; i++) + { + var face = (XChartCubeGeometry.CubeFace)i; + if (!HasFace(mask, face)) continue; + builder.Append(GetLetter(face)); + } + return builder.Length > 0 ? builder.ToString() : "-"; + } + } +} \ No newline at end of file diff --git a/Runtime/XChart/Mesh/XChartCubeFaceMask.cs.meta b/Runtime/XChart/Mesh/XChartCubeFaceMask.cs.meta new file mode 100644 index 0000000..c905d9d --- /dev/null +++ b/Runtime/XChart/Mesh/XChartCubeFaceMask.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 95a4a48449654bb4b8d72924f5e50632 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Mesh/XChartCubeGeometry.cs b/Runtime/XChart/Mesh/XChartCubeGeometry.cs new file mode 100644 index 0000000..e97e766 --- /dev/null +++ b/Runtime/XChart/Mesh/XChartCubeGeometry.cs @@ -0,0 +1,395 @@ +using UnityEngine; +using XericUI.XChart.Space; + +namespace XericUI.XChart.Mesh +{ + /// + /// 伪立方体的几何来源:8 顶点 / 12 棱 / 6 面,以及"把面算成屏幕四边形"的推导方法。 + /// + /// 为什么它决定协议 + /// 我们要的不是"立方体",而是"任意一个面在屏幕上是哪四个点"。把它写出来就能看清协议该长什么样: + /// + /// 面局部 3D : p3(s,t) = O3 + s * S3 + t * T3 (s,t ∈ [0,1]) + /// 投影 : screen = (R * p3).xy * scale + offset ← 正交投影,丢 Z + /// 合成 : screen = O2 + s * S2 + t * T2 ← 关于 (s,t) 是仿射的 + /// + /// 也就是说:正交投影下,每个面的屏幕映射必定是仿射(平行四边形),只需要"原点 + 两个基向量"; + /// 一旦换成透视投影(除以 w),它升级成一般四边形/单应。协议因此只需四个角点, + /// 不需要知道立方体、pitch/yaw、透视——详见 。 + /// + /// 坐标与单位:立方体中心在原点、半边长 1(顶点在 [-1,1]³);S3/T3 是整条边 + /// 向量(长度 2),所以 s,t 直接就是 [0,1] 的面参数。因为顶点就在 ±1,投影缩放 + /// scale 在"半边长口径"下就等于半边长(像素)——见 + /// ,旋转与尺寸都收在那里,本类只负责顶点和可见性判定。 + /// + /// 与 ChartToolCubeBg / ChartToolMeshBg 的关系:面顺序与本类的枚举一致 + /// (Front/Back/Right/Left/Top/Bottom),两个工具都消费本类的顶点/面/棱表, + /// 不再各自带一份私有副本。 + /// + public static class XChartCubeGeometry + { + /// 面的枚举,顺序与 个面帧的输出顺序一致 + public enum CubeFace + { + /// 法线 (0,0,1),面参数 (s,t) = (X,Y) + Front = 0, + /// 法线 (0,0,-1),面参数 (s,t) = (-X,Y) + Back = 1, + /// 法线 (1,0,0),面参数 (s,t) = (-Z,Y) + Right = 2, + /// 法线 (-1,0,0),面参数 (s,t) = (Z,Y) + Left = 3, + /// 法线 (0,1,0),面参数 (s,t) = (X,Z)(当作地板用) + Top = 4, + /// 法线 (0,-1,0),面参数 (s,t) = (X,Z) + Bottom = 5, + } + + public const int FaceCount = 6; + public const int EdgeCount = 12; + + // ── 顶点与棱 ────────────────────────────────────────────── + + /// 8 个顶点(中心原点、半边长 1) + public static readonly Vector3[] Vertices = + { + new Vector3(-1, -1, -1), // 0 后下左 + new Vector3( 1, -1, -1), // 1 后下右 + new Vector3( 1, 1, -1), // 2 后上右 + new Vector3(-1, 1, -1), // 3 后上左 + new Vector3(-1, -1, 1), // 4 前下左 + new Vector3( 1, -1, 1), // 5 前下右 + new Vector3( 1, 1, 1), // 6 前上右 + new Vector3(-1, 1, 1), // 7 前上左 + }; + + /// 12 条棱(顶点索引对):0-3 后面,4-7 前面,8-11 连接棱 + public static readonly int[,] Edges = + { + {0,1}, {1,2}, {2,3}, {3,0}, + {4,5}, {5,6}, {6,7}, {7,4}, + {0,4}, {1,5}, {2,6}, {3,7}, + }; + + // ── 面帧(3D) ──────────────────────────────────────────── + + private static readonly Vector3[] s_FaceNormal = new Vector3[FaceCount]; + private static readonly Vector3[] s_FaceOrigin = new Vector3[FaceCount]; // (s,t)=(0,0) + private static readonly Vector3[] s_FaceAxisS = new Vector3[FaceCount]; // 整条边,长度 2 + private static readonly Vector3[] s_FaceAxisT = new Vector3[FaceCount]; // 整条边,长度 2 + + // 每个面的四个角点对应的顶点索引,顺序与 (s,t) 角点一致: (0,0) (0,1) (1,1) (1,0) + // 不手写这张表:由 3D 角点与 Vertices 比对得出(探针里有"每面四角恰落在顶点上"的断言兜底) + private static readonly int[,] s_FaceVertexIndices = new int[FaceCount, 4]; + + /// 棱 -> 相邻面(每面两条). 由面顶点索引反查得出,供"棱是否朝向观察者"判定 + private static readonly int[,] s_EdgeAdjacentFaces = new int[EdgeCount, 2]; + + static XChartCubeGeometry() + { + for (int i = 0; i < FaceCount; i++) + BuildFace3D((CubeFace)i, out s_FaceNormal[i], out s_FaceOrigin[i], out s_FaceAxisS[i], out s_FaceAxisT[i]); + + for (int f = 0; f < FaceCount; f++) + { + for (int k = 0; k < 4; k++) + { + float s = (k == 2 || k == 3) ? 1f : 0f; + float t = (k == 1 || k == 2) ? 1f : 0f; + s_FaceVertexIndices[f, k] = FindVertexIndex(GetFacePoint3D((CubeFace)f, s, t)); + } + } + + for (int e = 0; e < EdgeCount; e++) + { + s_EdgeAdjacentFaces[e, 0] = -1; + s_EdgeAdjacentFaces[e, 1] = -1; + int slot = 0; + for (int f = 0; f < FaceCount && slot < 2; f++) + { + if (!FaceContainsEdge(f, Edges[e, 0], Edges[e, 1])) continue; + s_EdgeAdjacentFaces[e, slot++] = f; + } + } + } + + private static int FindVertexIndex(Vector3 point) + { + int best = -1; + float bestDistance = 1e-6f; + for (int i = 0; i < Vertices.Length; i++) + { + float d = (point - Vertices[i]).sqrMagnitude; + if (d <= bestDistance) { bestDistance = d; best = i; } + } + return best; + } + + private static bool FaceContainsEdge(int face, int v0, int v1) + { + return FaceContainsVertex(face, v0) && FaceContainsVertex(face, v1); + } + + private static bool FaceContainsVertex(int face, int vertex) + { + for (int k = 0; k < 4; k++) + if (s_FaceVertexIndices[face, k] == vertex) return true; + return false; + } + + /// + /// 由"外法线 + 参考上方向"导出面的 3D 帧。 + /// 一致的右手规则:right = up x n,t = n x right,原点取该面的 (0,0) 角点。 + /// 侧面用世界 Y 当参考上方向,顶/底面用 Z(这样顶面天然是 (X,Z) 地板参数化)。 + /// + private static void BuildFace3D(CubeFace face, out Vector3 normal, out Vector3 origin, + out Vector3 axisS, out Vector3 axisT) + { + normal = GetFaceNormalVector(face); + Vector3 upReference = (face == CubeFace.Top || face == CubeFace.Bottom) + ? new Vector3(0f, 0f, 1f) + : new Vector3(0f, 1f, 0f); + + Vector3 right = Vector3.Cross(upReference, normal).normalized; + Vector3 up = Vector3.Cross(normal, right).normalized; + + // 面在 ±1 的立方体上,所以 (0,0) 角点 = 法线方向的面 + 反向的两个轴 + origin = normal - right - up; + axisS = right * 2f; + axisT = up * 2f; + } + + private static Vector3 GetFaceNormalVector(CubeFace face) + { + switch (face) + { + case CubeFace.Front: return new Vector3(0f, 0f, 1f); + case CubeFace.Back: return new Vector3(0f, 0f, -1f); + case CubeFace.Right: return new Vector3(1f, 0f, 0f); + case CubeFace.Left: return new Vector3(-1f, 0f, 0f); + case CubeFace.Top: return new Vector3(0f, 1f, 0f); + default: return new Vector3(0f, -1f, 0f); + } + } + + /// 面的外法线(立方体局部空间) + public static Vector3 GetFaceNormal(CubeFace face) => s_FaceNormal[(int)face]; + + /// 面参数 (0,0) 对应的 3D 点 + public static Vector3 GetFaceOrigin(CubeFace face) => s_FaceOrigin[(int)face]; + + /// 面参数 s 方向的 3D 边向量(长度 2) + public static Vector3 GetFaceAxisS(CubeFace face) => s_FaceAxisS[(int)face]; + + /// 面参数 t 方向的 3D 边向量(长度 2) + public static Vector3 GetFaceAxisT(CubeFace face) => s_FaceAxisT[(int)face]; + + /// + /// 面片四个角(单位立方体,±1 就是边界),角序与面帧完全一致 + /// (ST00→(s0,t0)、ST01→(s0,t1)、ST11→(s1,t1)、ST10→(s1,t0))。 + /// 定义网格的工具把这四个点发布成 `Quad3D` 插槽,消费者用自己的矩阵投影它们即可—— + /// 这条与 的角序必须一直一致(探针把两者对拍)。 + /// + public static void GetFaceCorners(CubeFace face, out Vector3 cornerST00, out Vector3 cornerST01, + out Vector3 cornerST11, out Vector3 cornerST10) + { + Vector3 origin = s_FaceOrigin[(int)face]; + Vector3 axisS = s_FaceAxisS[(int)face]; + Vector3 axisT = s_FaceAxisT[(int)face]; + cornerST00 = origin; + cornerST01 = origin + axisT; + cornerST11 = origin + axisT + axisS; + cornerST10 = origin + axisS; + } + + /// 插槽 id 约定:定义网格的工具把每个面发布成 mesh.face.<面号> + public const string FaceSlotPrefix = "mesh.face."; + + /// 某个面的插槽 id + public static string FaceSlotId(CubeFace face) => FaceSlotPrefix + (int)face; + + /// + /// 格线插槽 id:mesh.face.<面号>.grid.S(沿 S 的等 t 线)/ + /// .grid.T(沿 T 的等 s 线)。格线由定义网格的那个工具发布,轴线按 id 取用—— + /// 于是"刻度落在格线上"这件事有一个共同的来源,而不是两边各自算一遍。 + /// + public static string GridSlotId(CubeFace face, bool alongS) + => FaceSlotPrefix + (int)face + (alongS ? ".grid.S" : ".grid.T"); + + /// + /// 一组格线要占多少个 float( 组 × 每组两个端点 × 3 个分量): + /// 两个背景都按它开缓冲,"值布局"只有这一个来源。 + /// + public static int GridSlotValueCount(int lineCount) + { + if (lineCount <= 0) return 0; + return lineCount * XChartSlotModes.PointsPerGroup(XChartSlotMode.Line3D) * 3; + } + + /// + /// 按给定的一组面参数比例把格线写进 : + /// 每组 6 个 float(两个单位立方体端点),共 组。 + /// + /// 比例来自 (等分,或按数据范围算出来的刻度位置)—— + /// 这里只管"比例 → 端点",于是"格线在哪儿"只有一个实现、两个背景共用,离线探针钉得住 + /// (轴线对齐格线的判据也靠它同源)。 + /// + /// 沿 S 的线 = 等 t 线(从 (0,t) 到 (1,t)),沿 T 的线 = 等 s 线—— + /// 与面帧 GetLineAlongS/GetLineAlongT 同一条约定(写反了就是整片网格转 90°)。 + /// + public static int FillGridLineValues(CubeFace face, bool alongS, float[] ratios, int lineCount, float[] values) + { + if (values == null || ratios == null || lineCount <= 0) return 0; + if (values.Length < GridSlotValueCount(lineCount)) return 0; + + int written = 0; + for (int i = 0; i < lineCount; i++) + { + float ratio = ratios[i]; + Vector3 from = alongS ? GetFacePoint3D(face, 0f, ratio) : GetFacePoint3D(face, ratio, 0f); + Vector3 to = alongS ? GetFacePoint3D(face, 1f, ratio) : GetFacePoint3D(face, ratio, 1f); + + int at = i * 6; + values[at + 0] = from.x; values[at + 1] = from.y; values[at + 2] = from.z; + values[at + 3] = to.x; values[at + 4] = to.y; values[at + 5] = to.z; + written++; + } + return written; + } + + /// + /// 面参数 (s,t) -> 立方体局部 3D 点 + /// + public static Vector3 GetFacePoint3D(CubeFace face, float s, float t) + => s_FaceOrigin[(int)face] + s_FaceAxisS[(int)face] * s + s_FaceAxisT[(int)face] * t; + + /// + /// 立方体局部 3D 点 → 面参数 (s,t):与 互为逆。 + /// 面基是单位正交的(角的定义就是 origin / +axisT / +axisT+axisS / +axisS),所以直接点积即可。 + /// + /// 谁需要它:轴线要按网格发布的线(单位立方体端点)反解出"这条线在面参数的哪儿", + /// 才能把刻度吸附上去——于是"网格定义、轴线跟随"落地,而两边不各算一遍。 + /// + public static void GetFaceParameter(CubeFace face, Vector3 point, out float s, out float t) + { + Vector3 axisS = s_FaceAxisS[(int)face]; + Vector3 axisT = s_FaceAxisT[(int)face]; + Vector3 relative = point - s_FaceOrigin[(int)face]; + + // 面轴是"整条边",长度 2(±1 的立方体)⇒ 点积后要**除以 |轴|²** 才是参数。 + // 少了这一步,参数会整整齐齐地放大 4 倍(看着像对的,其实全偏了)。 + float lengthS = axisS.sqrMagnitude; + float lengthT = axisT.sqrMagnitude; + s = lengthS > 1e-8f ? Vector3.Dot(relative, axisS) / lengthS : 0f; + t = lengthT > 1e-8f ? Vector3.Dot(relative, axisT) / lengthT : 0f; + } + + /// 面的第 corner 个角点(0=(0,0) 1=(0,1) 2=(1,1) 3=(1,0))对应的顶点索引 + public static int GetFaceVertexIndex(CubeFace face, int corner) + => s_FaceVertexIndices[(int)face, Mathf.Clamp(corner, 0, 3)]; + + // ── 投影 ────────────────────────────────────────────────── + + /// 立方体局部 3D 点 -> 图表局部像素(旋转 -> 正交投影丢 Z -> 缩放平移) + public static Vector2 Project(Matrix4x4 rotation, float scale, Vector2 offset, Vector3 point) + { + Vector3 rotated = rotation.MultiplyPoint3x4(point); + return new Vector2(rotated.x * scale + offset.x, rotated.y * scale + offset.y); + } + + /// 投影后的包围盒(旋转 + 正交投影丢 Z 后的 XY 范围)。半边长为 1 时范围在 ±√2 内 + public static void ComputeProjectedBounds(Matrix4x4 rotation, out Vector2 min, out Vector2 max) + { + min = new Vector2(float.MaxValue, float.MaxValue); + max = new Vector2(float.MinValue, float.MinValue); + for (int i = 0; i < Vertices.Length; i++) + { + Vector3 rotated = rotation.MultiplyPoint3x4(Vertices[i]); + if (rotated.x < min.x) min.x = rotated.x; + if (rotated.x > max.x) max.x = rotated.x; + if (rotated.y < min.y) min.y = rotated.y; + if (rotated.y > max.y) max.y = rotated.y; + } + } + + /// + /// 用四元数投影:先换成旋转矩阵,再走 。 + /// 缩放/平移的算法(半边长口径 vs 视口适配口径)不在这里,见 + /// 。 + /// + public static Vector2 Project(Quaternion rotation, float scale, Vector2 offset, Vector3 point) + => Project(XChartCubeView.ToMatrix(rotation), scale, offset, point); + + // ── 面帧(屏幕) ────────────────────────────────────────── + + /// + /// 算出六个面在图表局部像素空间的四边形——这就是"协议"的来源。 + /// 输出顺序与 一致。 + /// + public static void BuildFaceFrames(Matrix4x4 rotation, float scale, Vector2 offset, + XChartFaceFrame[] output) + { + if (output == null || output.Length < FaceCount) + return; + + for (int i = 0; i < FaceCount; i++) + { + var face = (CubeFace)i; + Vector3 o3 = s_FaceOrigin[i]; + Vector3 s3 = s_FaceAxisS[i]; + Vector3 t3 = s_FaceAxisT[i]; + + Vector2 c00 = Project(rotation, scale, offset, o3); + Vector2 c01 = Project(rotation, scale, offset, o3 + t3); + Vector2 c11 = Project(rotation, scale, offset, o3 + t3 + s3); + Vector2 c10 = Project(rotation, scale, offset, o3 + s3); + + XChartFaceFrame frame = XChartFaceFrame.FromCorners(c00, c01, c11, c10); + frame.FaceId = i; + output[i] = frame; + } + } + + /// + /// 一次把"四元数 + 半边长 + 口径"算成完整的投影状态与六个面帧。 + /// scale/offset 一并吐出来,数据类元素(散点等)要和背景共用同一份,不能各算一次。 + /// + public static XChartFaceFrame[] BuildFaceFrames(Quaternion rotation, float halfEdge, + Vector2 centerOffset, XChartCubeSizeMode mode, out float scale, out Vector2 offset) + { + Matrix4x4 matrix = XChartCubeView.ToMatrix(rotation); + XChartCubeView.ComputeProjection(matrix, halfEdge, centerOffset, mode, out scale, out offset); + var frames = new XChartFaceFrame[FaceCount]; + BuildFaceFrames(matrix, scale, offset, frames); + return frames; + } + + /// 面的朝向是否对着观察者(旋转后法线 Z > 0)——填充面必须用它判可见性 + public static bool IsFaceVisible(Matrix4x4 rotation, CubeFace face) + => rotation.MultiplyVector(s_FaceNormal[(int)face]).z > 0f; + + /// + /// 棱是否朝向观察者:它相邻的两个面里只要有一个可见就算。 + /// 这样棱和面用同一套口径(旧实现里棱按平均 Z 判、网格线按法线判,两套口径)。 + /// + public static bool IsEdgeVisible(Matrix4x4 rotation, int edgeIndex) + { + for (int slot = 0; slot < 2; slot++) + { + int face = s_EdgeAdjacentFaces[edgeIndex, slot]; + if (face < 0) continue; + if (IsFaceVisible(rotation, (CubeFace)face)) return true; + } + return false; + } + + /// 面的旋转后 Z(面心深度),供"先画远的再画近的"排序 + public static float GetFaceDepth(Matrix4x4 rotation, CubeFace face) + { + Vector3 center = s_FaceOrigin[(int)face] + + s_FaceAxisS[(int)face] * 0.5f + + s_FaceAxisT[(int)face] * 0.5f; + return rotation.MultiplyPoint3x4(center).z; + } + } +} \ No newline at end of file diff --git a/Runtime/XChart/Mesh/XChartCubeGeometry.cs.meta b/Runtime/XChart/Mesh/XChartCubeGeometry.cs.meta new file mode 100644 index 0000000..ed552c7 --- /dev/null +++ b/Runtime/XChart/Mesh/XChartCubeGeometry.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 894f93de698f45ae8c22edc26599b938 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Mesh/XChartCubeView.cs b/Runtime/XChart/Mesh/XChartCubeView.cs new file mode 100644 index 0000000..017cc38 --- /dev/null +++ b/Runtime/XChart/Mesh/XChartCubeView.cs @@ -0,0 +1,304 @@ +using UnityEngine; + +namespace XericUI.XChart.Mesh +{ + /// + /// 立方体尺寸的两种口径。两者的差别正是"旋转时立方体会不会变小"。 + /// + public enum XChartCubeSizeMode + { + /// + /// 半边长口径(默认):给定值是立方体真实边长的一半(也等于面心到中心的距离, + /// 即内切球半径)。投影缩放与旋转无关:怎么转,边长都是 2 * halfEdge 像素。 + /// + HalfEdgeLength, + + /// + /// 视口适配口径:把投影包围盒的最长边缩放到 2 * halfEdge 像素, + /// 于是立方体永远刚好铺满那块矩形。代价是尺寸随旋转变化:包围盒在某屏幕轴上的半长是 + /// h * (|ux| + |uy| + |uz|)(u 是该屏幕轴在立方体局部空间的像, + /// 即 R^T 的那一行),正对时为 h,某条体对角线对着该轴时最大、为 √3 h。 + /// 同一份配置下的实际尺度因此只有设定值的 1/√3 ≈ 0.577(等距预设下垂直方向半长 + /// √(8/3) h,即 ≈ 0.612 倍)——这就是"越转越小"。 + /// 需要"填满指定的矩形"时才用它。 + /// + FitToViewport, + } + + /// + /// 视角预设:每个值都对应一个四元数(见 ),不是角度分量。 + /// 表示不做预设覆盖,直接用配置里序列化好的那个四元数。 + /// + public enum XChartCubeViewPreset + { + Manual = 0, + /// 45° 正交(体对角线对着观察者),轮廓是正六边形,Front/Right/Top 三面可见 + Isometric = 1, + /// 等距视角的镜像(Front/Left/Top 可见) + IsometricMirrored = 2, + Front = 3, + Back = 4, + Right = 5, + Left = 6, + Top = 7, + Bottom = 8, + } + + /// + /// 立方体视图:旋转只有一个权威量——四元数,尺寸只有一个权威量——半边长。 + /// + /// 为什么不再拆 pitch/yaw:两轴拆分本身不算错,但它把"视角"表达成了 + /// "绕世界 X 转一下、再绕世界 Y 转一下",于是任何第三个轴的姿态都拿不到(roll 被钉死为 0), + /// 而且默认值 (25, -30) 只是随手取的,既不是正交等距也不是正视,所以画面里的"矩形"总是歪的。 + /// 本类把姿态收成一个四元数:预设、拖拽、代码 API 都直接给四元数,需要由角度合成时用 + /// (它按 Rx * Ry * Rz 合成,与 Quaternion.Euler 同一约定)。 + /// + /// 为什么尺寸要收成半边长:见 。 + /// 旧实现按"投影包围盒最长边"来 fit,而包围盒半长随旋转从 h 一路长大到 √3 h, + /// 立方体就必须缩小,调一次俯仰小一档、再调一次偏航又小一档,最后远小于设定的尺寸。 + /// 默认口径改成与旋转无关的半边长后,尺寸这件事和视角这件事彻底解耦。 + /// + /// 几种半径的关系(半边长记作 h,立方体顶点在 ±h): + /// + /// 面心到中心(内切球半径) = h + /// 顶点到中心(外接球半径) = √3 h ≈ 1.7321 h + /// 等距轮廓正六边形的外接圆半径 = √(8/3) h ≈ 1.6330 h + /// 等距轮廓正六边形的内切圆半径 = √2 h ≈ 1.4142 h + /// 沿某屏幕轴的包围盒半长 = h * (|ux| + |uy| + |uz|),取值 h … √3 h + /// + /// 所以"要画进一个 R 半径的圆里"时,半边长取 R / √(8/3); + /// 换算函数在下面这几个 *FromHalfEdge / HalfEdgeFrom* 里。 + /// + /// 离线可跑:这里不做任何引擎内部调用(Quaternion.Euler、 + /// Quaternion.FromToRotation、Matrix4x4.TRS 出不了 Unity), + /// 四元数由 axis-angle + Hamilton 积纯托管合成,矩阵由字段逐个拼出来。 + /// 编译门里的 mono 探针会把 与 Matrix4x4.Rotate 对拍, + /// 把 与三次 的连乘对拍, + /// 并把"等距视角轮廓是正六边形""半边长口径下尺度不随旋转变化"当断言钉住。 + /// + public static class XChartCubeView + { + /// atan(1/√2) 的度数:体对角线对着观察者时,对角线与水平面的夹角 + public const float IsometricPitchDegrees = 35.2643897f; + + /// 等距视角的偏航量(绝对值),符号由 决定 + public const float IsometricYawDegrees = 45f; + + private const float k_Sqrt3 = 1.7320508f; + private const float k_Sqrt2 = 1.41421356f; + private const float k_Sqrt8Over3 = 1.6329932f; + private const float k_MinLength = 1e-8f; + + // ── 四元数合成(纯托管) ────────────────────────────────── + + /// 归一化后的四元数。长度过短返回单位四元数(不做除法放大噪声) + public static Quaternion Normalized(float x, float y, float z, float w) + { + float length = Mathf.Sqrt(x * x + y * y + z * z + w * w); + if (length < k_MinLength) return new Quaternion(0f, 0f, 0f, 1f); + float inv = 1f / length; + return new Quaternion(x * inv, y * inv, z * inv, w * inv); + } + + /// + /// 绕任意轴的旋转(右手定则,角度制)。轴不必预先归一化。 + /// q = (axis * sin(θ/2), cos(θ/2)) + /// + public static Quaternion AxisAngle(Vector3 axis, float angleDegrees) + { + float length = Mathf.Sqrt(axis.x * axis.x + axis.y * axis.y + axis.z * axis.z); + if (length < k_MinLength) return new Quaternion(0f, 0f, 0f, 1f); + + float inv = 1f / length; + float half = angleDegrees * 0.5f * Mathf.Deg2Rad; + float s = Mathf.Sin(half); + return new Quaternion( + axis.x * inv * s, + axis.y * inv * s, + axis.z * inv * s, + Mathf.Cos(half)); + } + + /// + /// Hamilton 积 a ⊗ b,按 Unity 的约定即"先施加 、再施加 " + /// (矩阵视角就是 Ra * Rb)。 + /// 手写展开而不用引擎的 operator*,好让整条合成链在离线探针里也走得通。 + /// + public static Quaternion Multiply(Quaternion a, Quaternion b) + { + return new Quaternion( + a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y, + a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x, + a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w, + a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z); + } + + /// + /// 按 Rx(xDeg) * Ry(yDeg) * Rz(zDeg) 合成——与 Quaternion.Euler 的约定一致 + /// (先绕 Z、再绕 Y、最后绕 X,都是绕世界轴)。 + /// + public static Quaternion Euler(float xDegrees, float yDegrees, float zDegrees) + { + Quaternion rx = AxisAngle(Vector3.right, xDegrees); + Quaternion ry = AxisAngle(Vector3.up, yDegrees); + Quaternion rz = AxisAngle(Vector3.forward, zDegrees); + return Multiply(Multiply(rx, ry), rz); + } + + /// 把配置里的四元数收正:归一化 + 长度失效时退回单位旋转 + public static Quaternion Sanitize(Quaternion q) => Normalized(q.x, q.y, q.z, q.w); + + // ── 预设 ────────────────────────────────────────────────── + + /// + /// 预设对应的旋转。"某面正对观察者"= 把该面的外法线转到 +Z(投影保留 X/Y、丢弃 Z, + /// 所以 (R n).z == 1 时该面正对观察者)。 + /// + public static Quaternion RotationOf(XChartCubeViewPreset preset) + { + switch (preset) + { + case XChartCubeViewPreset.Isometric: + return Euler(IsometricPitchDegrees, -IsometricYawDegrees, 0f); + case XChartCubeViewPreset.IsometricMirrored: + return Euler(IsometricPitchDegrees, IsometricYawDegrees, 0f); + case XChartCubeViewPreset.Front: + return new Quaternion(0f, 0f, 0f, 1f); + case XChartCubeViewPreset.Back: + return AxisAngle(Vector3.up, 180f); + case XChartCubeViewPreset.Right: + return AxisAngle(Vector3.up, -90f); + case XChartCubeViewPreset.Left: + return AxisAngle(Vector3.up, 90f); + case XChartCubeViewPreset.Top: + return AxisAngle(Vector3.right, 90f); + case XChartCubeViewPreset.Bottom: + return AxisAngle(Vector3.right, -90f); + default: + return new Quaternion(0f, 0f, 0f, 1f); + } + } + + // ── 旋转 -> 矩阵 ────────────────────────────────────────── + + /// + /// 四元数 -> 3D 旋转矩阵(齐次形式,m33 = 1)。 + /// 这里逐字段拼装,和 Matrix4x4.Rotate 是两条独立实现,探针要求它们一致。 + /// 输入必须是单位四元数,所以先过一遍 。 + /// + public static Matrix4x4 ToMatrix(Quaternion q) + { + Quaternion u = Sanitize(q); + + float xx = u.x * u.x, yy = u.y * u.y, zz = u.z * u.z; + float xy = u.x * u.y, xz = u.x * u.z, yz = u.y * u.z; + float wx = u.w * u.x, wy = u.w * u.y, wz = u.w * u.z; + + var m = new Matrix4x4 + { + m00 = 1f - 2f * (yy + zz), + m01 = 2f * (xy - wz), + m02 = 2f * (xz + wy), + m03 = 0f, + + m10 = 2f * (xy + wz), + m11 = 1f - 2f * (xx + zz), + m12 = 2f * (yz - wx), + m13 = 0f, + + m20 = 2f * (xz - wy), + m21 = 2f * (yz + wx), + m22 = 1f - 2f * (xx + yy), + m23 = 0f, + + m30 = 0f, + m31 = 0f, + m32 = 0f, + m33 = 1f, + }; + return m; + } + + /// + /// 仿射复合 a ∘ b(矩阵意义下的 a * b:先施加 ,再施加 + /// )。只支持"线性 + 平移"这一族(最后一行恒为 0,0,0,1), + /// 所以 12 个元素就够,不用写全 4x4 乘。 + /// 为什么不用 Matrix4x4.operator*:它底层是引擎内部调用,出不了 Unity, + /// 离线探针就跑不了这条链;空间层的"基变换 × 工具变换"必须能离线验。 + /// + public static Matrix4x4 Compose(Matrix4x4 a, Matrix4x4 b) + { + var m = new Matrix4x4 + { + m00 = a.m00 * b.m00 + a.m01 * b.m10 + a.m02 * b.m20, + m01 = a.m00 * b.m01 + a.m01 * b.m11 + a.m02 * b.m21, + m02 = a.m00 * b.m02 + a.m01 * b.m12 + a.m02 * b.m22, + m03 = a.m00 * b.m03 + a.m01 * b.m13 + a.m02 * b.m23 + a.m03, + + m10 = a.m10 * b.m00 + a.m11 * b.m10 + a.m12 * b.m20, + m11 = a.m10 * b.m01 + a.m11 * b.m11 + a.m12 * b.m21, + m12 = a.m10 * b.m02 + a.m11 * b.m12 + a.m12 * b.m22, + m13 = a.m10 * b.m03 + a.m11 * b.m13 + a.m12 * b.m23 + a.m13, + + m20 = a.m20 * b.m00 + a.m21 * b.m10 + a.m22 * b.m20, + m21 = a.m20 * b.m01 + a.m21 * b.m11 + a.m22 * b.m21, + m22 = a.m20 * b.m02 + a.m21 * b.m12 + a.m22 * b.m22, + m23 = a.m20 * b.m03 + a.m21 * b.m13 + a.m22 * b.m23 + a.m23, + + m30 = 0f, m31 = 0f, m32 = 0f, m33 = 1f, + }; + return m; + } + + // ── 尺寸口径 ────────────────────────────────────────────── + + /// 半边长 -> 外接球半径(顶点到中心)= √3 h + public static float CircumradiusFromHalfEdge(float halfEdge) => halfEdge * k_Sqrt3; + + /// 外接球半径 -> 半边长 + public static float HalfEdgeFromCircumradius(float circumradius) => circumradius / k_Sqrt3; + + /// 半边长 -> 等距轮廓正六边形的外接圆半径 = √(8/3) h + public static float IsometricHexagonCircumradius(float halfEdge) => halfEdge * k_Sqrt8Over3; + + /// 想让轮廓正六边形内接于半径 r 的圆,半边长该给多少 + public static float HalfEdgeFromHexagonCircumradius(float radius) => radius / k_Sqrt8Over3; + + /// 半边长 -> 等距轮廓正六边形的内切圆半径 = √2 h + public static float IsometricHexagonInradius(float halfEdge) => halfEdge * k_Sqrt2; + + /// + /// 按口径算投影缩放与平移。 + /// :scale = halfEdge—— + /// 立方体顶点在 ±1,所以 scale 就是半边长,与旋转无关;包围盒中心仍然对齐到 + /// ,于是转起来只是转、不会漂。 + /// :scale 让包围盒最长边等于 + /// 2 * halfEdge,铺满固定矩形但尺寸随旋转变化。 + /// + public static void ComputeProjection(Matrix4x4 rotation, float halfEdge, Vector2 centerOffset, + XChartCubeSizeMode mode, out float scale, out Vector2 offset) + { + XChartCubeGeometry.ComputeProjectedBounds(rotation, out Vector2 min, out Vector2 max); + Vector2 center = new Vector2((min.x + max.x) * 0.5f, (min.y + max.y) * 0.5f); + + if (mode == XChartCubeSizeMode.HalfEdgeLength) + { + scale = Mathf.Max(0.001f, halfEdge); + } + else + { + float maxRange = Mathf.Max(max.x - min.x, max.y - min.y); + scale = maxRange > 0.001f ? halfEdge * 2f / maxRange : 1f; + } + + offset = new Vector2(centerOffset.x - center.x * scale, centerOffset.y - center.y * scale); + } + + /// 四元数版入口:内部先转矩阵,调用方不必自己拿 + public static void ComputeProjection(Quaternion rotation, float halfEdge, Vector2 centerOffset, + XChartCubeSizeMode mode, out float scale, out Vector2 offset) + { + ComputeProjection(ToMatrix(rotation), halfEdge, centerOffset, mode, out scale, out offset); + } + } +} diff --git a/Runtime/XChart/Mesh/XChartCubeView.cs.meta b/Runtime/XChart/Mesh/XChartCubeView.cs.meta new file mode 100644 index 0000000..60e26a9 --- /dev/null +++ b/Runtime/XChart/Mesh/XChartCubeView.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1cd7950bf06cfc34b9beecec773cce9b +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Mesh/XChartCylinderGeometry.cs b/Runtime/XChart/Mesh/XChartCylinderGeometry.cs new file mode 100644 index 0000000..2acbe0a --- /dev/null +++ b/Runtime/XChart/Mesh/XChartCylinderGeometry.cs @@ -0,0 +1,388 @@ +using System; +using UnityEngine; + +namespace XericUI.XChart.Mesh +{ + /// + /// 一片端面在 2D 上的像:中心 + 盘内一对基向量(已投影、已乘半径)。 + /// + /// 正交投影是仿射的,所以 3D 圆盘的像正好是"把盘内基向量的像当半轴"的椭圆: + /// p(θ) = 中心 + U·cosθ + V·sinθ。只需投影中心与两个基各一次, + /// 不必对盘上每点做 3D 投影——这就是"投影从 2D 算起"(2026-10-23 他的要求)。 + /// + public struct XChartCylinderDisc2D + { + public Vector2 Center; + /// 盘内第一根半轴(已投影、已乘半径) + public Vector2 U; + /// 盘内第二根半轴(已投影、已乘半径) + public Vector2 V; + + public Vector2 PointAt(float angle) + { + return Center + U * Mathf.Cos(angle) + V * Mathf.Sin(angle); + } + + /// 第 个采样点(角度均匀一圈) + public Vector2 PointAtStep(int index, int count) + { + if (count <= 0) return Center; + return PointAt(6.2831855f * index / count); + } + + /// 椭圆参数式的导数 p'(θ) = -U·sinθ + V·cosθ(贝塞尔控制点要用) + public Vector2 TangentAt(float angle) + { + float c = Mathf.Cos(angle); + float s = Mathf.Sin(angle); + return new Vector2(-U.x * s + V.x * c, -U.y * s + V.y * c); + } + } + + /// + /// 圆柱的纯几何:不碰 Unity 对象,所以离线 mono 探针能直接验"外轮廓是不是两片椭圆的凸包" + /// "桥接点是否落在垂直于桥接方向的极值点上"这类断言。 + /// + /// 为什么外轮廓=凸包:扫掠体的可见轮廓就是两个端面点集的凸包—— + /// 对凸截面这是精确解,而且平行、斜置、两端不同法线、两端不同心都是同一套代码, + /// 不需要为"斜圆柱"再写一条切线公式。他要的那两条"过圆心的长轴方向连着外边框"的桥接线 + /// 就是凸包自动给出的那两段。 + /// + /// 母线只在显式要求时才画:轮廓只画包边;"把两端顶点全连起来"那种透视线框 + /// 是可选元素(GeneratrixCount),不再是侧面填充的实现方式。 + /// + public static class XChartCylinderGeometry + { + /// + /// 取与 垂直的一对单位向量。辅助轴按"离轴最远的那根世界轴"选, + /// 这样叉积不会退化(法线与某世界轴平行时那个叉积接近 0)。 + /// + public static bool TryOrthogonalBasis(Vector3 normal, out Vector3 u, out Vector3 v) + { + u = Vector3.zero; + v = Vector3.zero; + float length = normal.magnitude; + if (length < 1e-6f) return false; + + Vector3 n = normal / length; + Vector3 auxiliary = Mathf.Abs(n.y) < 0.9f ? Vector3.up : Vector3.right; + + u = Vector3.Cross(n, auxiliary); + float uLength = u.magnitude; + if (uLength < 1e-6f) return false; + u = u / uLength; + v = Vector3.Cross(n, u); + return true; + } + + /// + /// 端面盘 → 2D。只投影中心与两根基(基向量按 缩放, + /// 半径并进基向量里),所以调用方拿到的是"椭圆的半轴"而不是 3D 点集。 + /// + public static bool TryProjectDisc(Vector2 centerPixels, Vector2 uPixels, Vector2 vPixels, + float radius, out XChartCylinderDisc2D disc) + { + disc = default(XChartCylinderDisc2D); + if (radius <= 0f) return false; + + disc.Center = centerPixels; + disc.U = uPixels * radius; + disc.V = vPixels * radius; + return disc.U.sqrMagnitude > 1e-12f || disc.V.sqrMagnitude > 1e-12f; + } + + /// + /// 凸包(Andrew monotone chain),返回包上点数并写进 。 + /// 会被就地排序(它同时充当 scratch,避免每帧分配)。 + /// 容量:两条链各自最多 push 一次每个输入点 ⇒ 写入下标最大到 2×count−3, + /// 所以 要能装下 2×count 个点。这不是留白:写成"≥count" + /// 在"输入点几乎全在包上"时会越界(我写的一支变异臂就是这么把它照出来的)。 + /// + public static int ConvexHull(Vector2[] points, int count, Vector2[] output) + { + if (points == null || output == null) throw new ArgumentNullException(nameof(points)); + if (output.Length < count * 2) throw new ArgumentException("output 至少要能装下 2×count 个点"); + if (count <= 0) return 0; + if (count < 3) + { + int copy = Math.Min(count, output.Length); + for (int i = 0; i < copy; i++) output[i] = points[i]; + return copy; + } + + SortByXThenY(points, count); + + int total = 0; + // 下凸链:从左到右;上凸链:从右到左。两链拼起来就是凸包(逆时针) + for (int i = 0; i < count; i++) + { + while (total >= 2 && Cross(output[total - 2], output[total - 1], points[i]) <= 0f) total--; + output[total++] = points[i]; + } + + int lower = total + 1; + for (int i = count - 2; i >= 0; i--) + { + while (total >= lower && Cross(output[total - 2], output[total - 1], points[i]) <= 0f) total--; + output[total++] = points[i]; + } + + return total - 1; // 首点重复了一次 + } + + /// + /// 外轮廓=两片端面椭圆点集的凸包。scratch 装采样点(长度 ≥ 2×), + /// output 按 的容量口径要能装下 2×采样数(长度 ≥ 4×)。 + /// + public static int BuildOutline(in XChartCylinderDisc2D first, in XChartCylinderDisc2D second, + int segmentCount, Vector2[] scratch, Vector2[] output) + { + if (scratch == null || output == null) throw new ArgumentNullException(nameof(scratch)); + int samples = segmentCount * 2; + if (scratch.Length < samples || output.Length < samples * 2) + throw new ArgumentException("scratch 要装下两片椭圆的采样点,output 要装下 2×采样数"); + + float step = 6.2831855f / segmentCount; + for (int i = 0; i < segmentCount; i++) + { + float angle = i * step; + scratch[i] = first.PointAt(angle); + scratch[segmentCount + i] = second.PointAt(angle); + } + + return ConvexHull(scratch, segmentCount * 2, output); + } + + /// + /// 两片端面的法线:显式给了就用显式;没给则两端都用同一条轴、同向。 + /// + /// 为什么不是"各自朝另一端":`TryOrthogonalBasis(-n)` 会给出 u' = -u + /// (叉积对第一个参数反号),于是两片的采样角是镜像的——同一个采样下标落在两片上的 + /// 方向不一致,可选元素里"两端对应点相连"的母线就会拧成 X 形,端面十字两端也是镜像的 + /// (他 2026-10-23 现场看出来的"两个端面是旋转了吗,它的连接顺序错了")。 + /// 同向法线让两片参数化完全一致,采样下标 i 在两片上就是同一个 3D 方向。 + /// + public static void ResolveNormals(Vector3 explicitStart, Vector3 explicitEnd, + Vector3 start, Vector3 end, out Vector3 startNormal, out Vector3 endNormal) + { + Vector3 axis = end - start; + if (axis.sqrMagnitude < 1e-8f) axis = Vector3.forward; + startNormal = explicitStart.sqrMagnitude > 1e-8f ? explicitStart : axis; + endNormal = explicitEnd.sqrMagnitude > 1e-8f ? explicitEnd : axis; + } + + /// 多边形有向面积(逆时针为正)。探针用它比"凸包面积 ≥ 单个椭圆面积"。 + public static float SignedArea(Vector2[] polygon, int count) + { + if (polygon == null || count < 3) return 0f; + float twice = 0f; + for (int i = 0; i < count; i++) + { + Vector2 a = polygon[i]; + Vector2 b = polygon[(i + 1) % count]; + twice += a.x * b.y - b.x * a.y; + } + return twice * 0.5f; + } + + /// + /// 椭圆上"带滚转信息"的四个点:+U 方向是 right、+V 是 top、-U 是 left、-V 是 bottom + /// (right - left = 2U、top - bottom = 2V,这样十字的两臂方向就是盘自己的两根基)。 + /// 端面十字用它而不是用椭圆的长短轴:长短轴会随观察方向自己转、把滚转吃掉, + /// 而这四个点就是实际渲染用的那几个顶点,所以十字永远与实际端面对得上。 + /// + public static void CrossPoints(in XChartCylinderDisc2D disc, int segmentCount, + out Vector2 left, out Vector2 top, out Vector2 right, out Vector2 bottom) + { + int quarter = Math.Max(1, segmentCount / 4); + right = disc.PointAtStep(0, segmentCount); + top = disc.PointAtStep(quarter, segmentCount); + left = disc.PointAtStep(quarter * 2, segmentCount); + bottom = disc.PointAtStep(quarter * 3, segmentCount); + } + + private static float Cross(Vector2 origin, Vector2 a, Vector2 b) + { + return (a.x - origin.x) * (b.y - origin.y) - (a.y - origin.y) * (b.x - origin.x); + } + + /// + /// 反解椭圆参数:p = C + U·cosθ + V·sinθ ⇒ 解 2×2 线性方程得 (cosθ, sinθ), + /// 再按 cos²+sin² ≈ 1 判这点是否真的落在这片椭圆上。凸包分组(弧段 vs 桥接段)靠它。 + /// + public static bool TryParameterOf(in XChartCylinderDisc2D disc, Vector2 point, out float angle) + { + angle = 0f; + float det = disc.U.x * disc.V.y - disc.U.y * disc.V.x; + if (Mathf.Abs(det) < 1e-9f) return false; // 半轴退化(端面看到侧刃)⇒ 参数不唯一 + + Vector2 d = point - disc.Center; + float cos = (d.x * disc.V.y - d.y * disc.V.x) / det; + float sin = (disc.U.x * d.y - disc.U.y * d.x) / det; + if (Mathf.Abs(cos * cos + sin * sin - 1f) > 1e-3f) return false; + angle = Mathf.Atan2(sin, cos); + return true; + } + + /// 把一段扫过的角整理成"朝指定方向"的弧长:先折到 (-π, π],再按方向补一圈。 + public static float SweepToDirection(float sweep, int direction) + { + const float twoPi = 6.2831855f; + sweep = Mathf.Repeat(sweep + 3.1415927f, twoPi) - 3.1415927f; + if (direction > 0 && sweep < 0f) sweep += twoPi; + if (direction < 0 && sweep > 0f) sweep -= twoPi; + return sweep; + } + + /// 按"最短路"定转向:折到 (-π, π] 后为正就 +1,否则 -1(弧段的转向靠它推断)。 + public static int ShortestDirection(float sweep) + { + float wrapped = Mathf.Repeat(sweep + 3.1415927f, 6.2831855f) - 3.1415927f; + return wrapped > 0f ? 1 : -1; + } + + /// + /// 一段弧的补弧:起点接在它的终点、同方向走完剩下的那一圈(扫过 2π-|sweep|)。 + /// 不是"反过来走"——这是它最容易写错的地方:反向走会原路覆盖同一段弧(半圆时尤其明显, + /// 反着走一遍正好还是那半个圆),于是端面环又画回包边那条线上(他 2026-10-23 报的"补成外半环")。 + /// 补弧与可见弧合起来才是整圈,所以两者同号、绝对值和 = 2π。 + /// + public static float ComplementSweep(float sweep) + { + const float twoPi = 6.2831855f; + if (sweep > 0f) return twoPi - sweep; + if (sweep < 0f) return -twoPi - sweep; + return twoPi; + } + + /// 一段椭圆弧要拆成几节三次贝塞尔(每节 ≤ 90°,与圆的贝塞尔逼近同口径) + public static int ArcPieceCount(float sweep) + { + float magnitude = Mathf.Abs(sweep); + if (magnitude < 1e-6f) return 0; + return Mathf.Max(1, Mathf.CeilToInt(magnitude / 1.5707964f)); + } + + /// + /// 写出一节椭圆弧的三次贝塞尔控制点(4 个,顺序 P0/P1/P2/P3)。 + /// 系数 k = 4/3·tan(Δ/4) 是"圆弧 → 三次贝塞尔"的经典值。椭圆是圆的仿射像, + /// 而贝塞尔控制点随仿射变换同样变换,所以同一个 k 对椭圆弧一样成立—— + /// 我只算控制点,细分交给曲线渲染器(他 2026-10-23 点名的 + /// Generation/Curve 那套,它的结构里就是贝塞尔细分)。 + /// + public static void BuildArcPiece(in XChartCylinderDisc2D disc, float fromAngle, float sweep, + int pieceCount, int index, Vector2[] output) + { + if (output == null || output.Length < 4) throw new ArgumentException("控制点数组至少要 4 个点"); + if (pieceCount <= 0) pieceCount = 1; + float delta = sweep / pieceCount; + float a = fromAngle + delta * index; + float b = a + delta; + float k = 1.3333333f * Mathf.Tan(delta * 0.25f); + + Vector2 pa = disc.PointAt(a); + Vector2 pb = disc.PointAt(b); + output[0] = pa; + output[1] = pa + disc.TangentAt(a) * k; + output[2] = pb - disc.TangentAt(b) * k; + output[3] = pb; + } + + /// 直线段 → 一次三次贝塞尔(控制点在 1/3、2/3,形状就是这条直线) + public static void BuildLineBezier(Vector2 a, Vector2 b, Vector2[] output) + { + if (output == null || output.Length < 4) throw new ArgumentException("控制点数组至少要 4 个点"); + Vector2 third = (b - a) / 3f; + output[0] = a; + output[1] = a + third; + output[2] = a + third * 2f; + output[3] = b; + } + + /// + /// 给轮廓每个点打"落在哪片端面上"的标记(1=第一片 / 2=第二片 / 0=都认不出)。 + /// 凸包按端面分组,才能把弧段当曲线、把跨端面那两段当直线("过圆心的长轴方向连外框"那两条桥接线)。 + /// + public static void ClassifyOutline(Vector2[] outline, int count, in XChartCylinderDisc2D first, + in XChartCylinderDisc2D second, byte[] tags) + { + if (outline == null || tags == null) throw new ArgumentNullException(nameof(outline)); + if (tags.Length < count) throw new ArgumentException("tags 长度不足"); + for (int i = 0; i < count; i++) + { + tags[i] = TryParameterOf(first, outline[i], out float _) ? (byte)1 + : TryParameterOf(second, outline[i], out float _) ? (byte)2 + : (byte)0; + } + } + + /// + /// 把凸包切成"同一片端面"的连续段(每段是那片的可见弧)。从"标记变化处"起步走一圈, + /// 跨末尾的那一段才不会被劈成两半。各段写进 / / + /// ,返回段数(数组要能装下 count 段)。 + /// 凸包上每片凸集只贡献一段弧,所以正常就是"2 弧 + 2 桥接";远侧端面可能一段都没有 + /// (它整个躲在外轮廓里),这时它没有"可见弧"可补——环只能自己画整圈。 + /// + public static int SplitOutlineRuns(Vector2[] outline, int count, in XChartCylinderDisc2D first, + in XChartCylinderDisc2D second, byte[] tags, int[] runStarts, int[] runEnds, byte[] runTags) + { + if (outline == null || tags == null || runStarts == null || runEnds == null || runTags == null) + throw new ArgumentNullException(nameof(outline)); + if (tags.Length < count || runStarts.Length < count || runEnds.Length < count || runTags.Length < count) + throw new ArgumentException("缓冲长度不足"); + if (count < 3) return 0; + + ClassifyOutline(outline, count, first, second, tags); + + int start = 0; + for (int i = 0; i < count; i++) + { + if (tags[i] != tags[(i + count - 1) % count]) { start = i; break; } + } + + int runs = 0; + int runStart = start; + int runTag = tags[start]; + for (int step = 1; step <= count; step++) + { + int index = (start + step) % count; + if (step < count && tags[index] == runTag) continue; + + runTags[runs] = (byte)runTag; + runStarts[runs] = runStart; + runEnds[runs] = (start + step - 1) % count; + runs++; + + runStart = index; + if (step < count) runTag = tags[index]; + } + return runs; + } + + /// + /// 端面环=包边那段可见弧的补弧:起点接在可见弧的终点、扫过 2π-|可见|(方向相反), + /// 也就是端面圆上躲在外轮廓里面的那一半。外侧由包边画、内侧由环画,两边都不重复。 + /// + public static void RingArc(float fromAngle, float visibleSweep, out float ringStartAngle, out float ringSweep) + { + ringStartAngle = fromAngle + visibleSweep; + ringSweep = ComplementSweep(visibleSweep); + } + + /// 按 x 再按 y 排序(就地)。凸包要它,且顺序稳定才能让"包点顺序"可复现。 + private static void SortByXThenY(Vector2[] points, int count) + { + for (int i = 1; i < count; i++) + { + Vector2 key = points[i]; + int j = i - 1; + while (j >= 0 && (points[j].x > key.x || (points[j].x == key.x && points[j].y > key.y))) + { + points[j + 1] = points[j]; + j--; + } + points[j + 1] = key; + } + } + } +} \ No newline at end of file diff --git a/Runtime/XChart/Mesh/XChartCylinderGeometry.cs.meta b/Runtime/XChart/Mesh/XChartCylinderGeometry.cs.meta new file mode 100644 index 0000000..49d064a --- /dev/null +++ b/Runtime/XChart/Mesh/XChartCylinderGeometry.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1141350d0fe65dc41847751ed92b2aa1 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Mesh/XChartFaceFrame.cs b/Runtime/XChart/Mesh/XChartFaceFrame.cs new file mode 100644 index 0000000..affd617 --- /dev/null +++ b/Runtime/XChart/Mesh/XChartFaceFrame.cs @@ -0,0 +1,174 @@ +using UnityEngine; +using XericUI.OverrideUI; + +namespace XericUI.XChart.Mesh +{ + /// + /// 面帧:把一个平面面片自己的参数域 (s,t) 映射到图表局部像素空间的变换协议。 + /// + /// 它从哪来的(推导链) + /// 以伪立方体为例,要画它任意一个面,我们必须回答"这个面在屏幕上是哪四个点": + /// + /// 1) 面在立方体局部空间里是一个四边形 + /// 面原点 O3 + s * S3 + t * T3 (s,t ∈ [0,1],S3/T3 是面的两个边向量) + /// 2) 把 3D 点投到屏幕局部像素 + /// 正交投影(旋转后丢 Z): P(p) = (R*p).xy * scale + offset → 线性 + /// 透视投影(除以 w) : 一般四边形(梯形) + /// 3) 于是 "面参数 -> 屏幕" 只剩两种可能: + /// 仿射(S/T 的投影像仍是平面上的两个固定向量) —— 正交投影下恒成立 + /// 一般四边形 / 单应(投影后不再保持平行) —— 透视投影 + /// + /// 所以协议不需要知道立方体、pitch/yaw、透视——它只需要四个角点,剩下的都由此推出。 + /// + /// 两档表示 + /// 同一个类型承担两档,不做两个类型: + /// + /// 仿射档:四角构成平行四边形,(1,0)-(0,0) 与 (0,1)-(0,0) 就是两个基向量,映射可解析求逆,零开销。 + /// 一般四边形档:任意四角,用单应(透视)映射,退化时会失败。 + /// + /// 映射实现直接复用 (同一个"单位正方形 -> 四边形"的投影,已被 + /// 数值验证),本类型只负责角点约定与语义,不再另写一份映射。 + /// + /// 角点约定(与 Image 顶点顺序同源): + /// + /// CornerST00 = Map(0,0) 左下 CornerST01 = Map(0,1) 左上 + /// CornerST11 = Map(1,1) 右上 CornerST10 = Map(1,0) 右下 + /// + /// + /// 谁用它:网格绘制器(填充面)、面内网格线、轴线组件(在面上取 + /// 值 -> 比例 -> 面参数 -> 像素)、数据图元(把点投到面上)。 + /// + public struct XChartFaceFrame + { + /// (s,t)=(0,0) 角点(左下),局部像素 + public Vector2 CornerST00; + /// (s,t)=(0,1) 角点(左上) + public Vector2 CornerST01; + /// (s,t)=(1,1) 角点(右上) + public Vector2 CornerST11; + /// (s,t)=(1,0) 角点(右下) + public Vector2 CornerST10; + + /// 面语义(哪个面 / 哪条轴用它做宿主),仅作标识,不参与映射 + public int FaceId; + + private XericQuadProjection m_Projection; + private bool m_Valid; + + /// 面参数到像素的映射是否可用(四角退化时不可用) + public bool IsValid => m_Valid; + + /// + /// 是否平行四边形。成立时映射退化为仿射,可解析求逆;正交投影下恒成立, + /// 透视投影下一般不成立。 + /// + public bool IsAffine + { + get + { + Vector2 d = CornerST00 + CornerST11 - CornerST01 - CornerST10; + return d.sqrMagnitude <= 1e-6f; + } + } + + // ── 构造 ────────────────────────────────────────────────── + + /// 由四个角点构造(左下 / 左上 / 右上 / 右下) + public static XChartFaceFrame FromCorners(Vector2 cornerST00, Vector2 cornerST01, + Vector2 cornerST11, Vector2 cornerST10) + { + var frame = new XChartFaceFrame + { + CornerST00 = cornerST00, + CornerST01 = cornerST01, + CornerST11 = cornerST11, + CornerST10 = cornerST10, + }; + // 单位正方形顺序:p00 -> p10 -> p11 -> p01 + frame.m_Valid = XericQuadProjection.TryCreate( + cornerST00, cornerST10, cornerST11, cornerST01, out frame.m_Projection); + return frame; + } + + /// 由仿射基构造:原点 + s 方向 + t 方向(正交投影下最省的一条路) + public static XChartFaceFrame FromAffine(Vector2 origin, Vector2 axisS, Vector2 axisT) + { + return FromCorners( + origin, + origin + axisT, + origin + axisT + axisS, + origin + axisS); + } + + /// 把面参数域里的一个矩形子区间映射成新的面帧(留白 / 内缩用) + public XChartFaceFrame Slice(float s0, float t0, float s1, float t1) + { + return FromCorners( + Map(s0, t0), + Map(s0, t1), + Map(s1, t1), + Map(s1, t0)); + } + + // ── 映射 ────────────────────────────────────────────────── + + /// 面参数 (s,t) -> 图表局部像素 + public Vector2 Map(float s, float t) + { + if (!m_Valid) + return CornerST00; + return m_Projection.Transform(s, t); + } + + /// + /// 子区间内插:把 (u,v) ∈ [0,1]^2 映射到面参数域里 [s0,s1] x [t0,t1] 的位置。 + /// 轴线的留白、图例区、数据区都靠它表达,避免各处自己乘偏移。 + /// + public Vector2 MapRange(float s0, float t0, float s1, float t1, float u, float v) + { + return Map(s0 + (s1 - s0) * u, t0 + (t1 - t0) * v); + } + + /// 局部像素 -> 面参数(反查,命中测试/拖拽用) + public bool TryInverse(Vector2 local, out Vector2 st) + { + st = Vector2.zero; + if (!m_Valid) + return false; + if (!m_Projection.TryInvert(out var inverse)) + return false; + st = inverse.Transform(local.x, local.y); + return true; + } + + /// 取一条等 t 线(沿 s 方向)的两端 + public void GetLineAlongS(float t, out Vector2 from, out Vector2 to) + { + from = Map(0f, t); + to = Map(1f, t); + } + + /// 取一条等 s 线(沿 t 方向)的两端 + public void GetLineAlongT(float s, out Vector2 from, out Vector2 to) + { + from = Map(s, 0f); + to = Map(s, 1f); + } + + /// 四个角点(顺序:左下 / 左上 / 右上 / 右下) + public Vector2[] GetCorners() => new[] + { + CornerST00, CornerST01, CornerST11, CornerST10, + }; + + /// 包围盒(局部像素) + public Rect GetBounds() + { + float minX = Mathf.Min(Mathf.Min(CornerST00.x, CornerST01.x), Mathf.Min(CornerST11.x, CornerST10.x)); + float maxX = Mathf.Max(Mathf.Max(CornerST00.x, CornerST01.x), Mathf.Max(CornerST11.x, CornerST10.x)); + float minY = Mathf.Min(Mathf.Min(CornerST00.y, CornerST01.y), Mathf.Min(CornerST11.y, CornerST10.y)); + float maxY = Mathf.Max(Mathf.Max(CornerST00.y, CornerST01.y), Mathf.Max(CornerST11.y, CornerST10.y)); + return new Rect(minX, minY, maxX - minX, maxY - minY); + } + } +} \ No newline at end of file diff --git a/Runtime/XChart/Mesh/XChartFaceFrame.cs.meta b/Runtime/XChart/Mesh/XChartFaceFrame.cs.meta new file mode 100644 index 0000000..637b345 --- /dev/null +++ b/Runtime/XChart/Mesh/XChartFaceFrame.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 451d6866f0204c85b7ecee44c7d6ab92 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Mesh/XChartGridDivisions.cs b/Runtime/XChart/Mesh/XChartGridDivisions.cs new file mode 100644 index 0000000..2310854 --- /dev/null +++ b/Runtime/XChart/Mesh/XChartGridDivisions.cs @@ -0,0 +1,42 @@ +using System; + +namespace XericUI.XChart.Mesh +{ + /// + /// 网格分格数的唯一算法(规范 §8.2)。 + /// + /// 立方体的线框要能和轴刻度逐线对上,分格数就不能只有一份——两条轴的范围不同, + /// 需要的格数也不同(验收现场:-100..100 要 4 格、-40..40 要 8 格, + /// 而网格当时只有一份"5")。所以按方向给:S 一份、T 一份,不给(0 或负)表示跟随统一值。 + /// + /// 沿 S 的格线数由 T 方向的分格数决定("沿 S 走"的线就是"每个 T 分格边界一条"), + /// 反过来也一样——这一句最容易写反,所以从绘制代码里抽出来,让离线探针钉住它。 + /// + public static class XChartGridDivisions + { + /// 某个方向的分格数:给了正数就用它,否则回落到统一值(统一值也不正就取 1) + public static int Resolve(int perDirection, int uniform) + { + if (perDirection >= 1) return perDirection; + return uniform >= 1 ? uniform : 1; + } + + /// 沿 S 方向的格线数 = T 方向分格数 + 1(含两条边) + public static int LinesAlongS(int divisionsS, int divisionsT, int uniform) + { + return Resolve(divisionsT, uniform) + 1; + } + + /// 沿 T 方向的格线数 = S 方向分格数 + 1(含两条边) + public static int LinesAlongT(int divisionsS, int divisionsT, int uniform) + { + return Resolve(divisionsS, uniform) + 1; + } + + /// 统一值(不拆方向)时两个方向的格线数——留给"只有一份分格数"的旧配置用 + public static int UniformLineCount(int uniform) + { + return Resolve(0, uniform) + 1; + } + } +} \ No newline at end of file diff --git a/Runtime/XChart/Mesh/XChartGridDivisions.cs.meta b/Runtime/XChart/Mesh/XChartGridDivisions.cs.meta new file mode 100644 index 0000000..2710f97 --- /dev/null +++ b/Runtime/XChart/Mesh/XChartGridDivisions.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4aff13f79207a164c889411dea6b9839 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Mesh/XChartGridLines.cs b/Runtime/XChart/Mesh/XChartGridLines.cs new file mode 100644 index 0000000..17eec29 --- /dev/null +++ b/Runtime/XChart/Mesh/XChartGridLines.cs @@ -0,0 +1,79 @@ +using System.Collections.Generic; +using UnityEngine; +using XericUI.XChart.Axis; + +namespace XericUI.XChart.Mesh +{ + /// + /// 网格线的位置从哪儿来(P9):网格是定义方——按绑定的那一维的数据范围与目标条数 + /// 算出一组"好看"的刻度值,再折成面参数比例发布出去;轴线以后按这些发布的线吸附, + /// 不再两边各算一遍(他 2026-10-23 的原话:"立方体网格上的分割线也都统一通过 chart 上的 + /// 数据范围控制")。 + /// + /// 不绑数据(维度 < 0)时退回等分:比例 = i/(count-1),与旧行为逐位相同—— + /// 所以"没配维度"这件事不会改变任何画面。 + /// + /// 刻度值那一套(nice step + 升序铺 + 指数/对数换算)直接复用 + /// :**网格与刻度同源**,"逐条坐标相等"才有基础。 + /// + public static class XChartGridLines + { + /// 等分(不绑数据): 条线,含两条边,比例 i/(count-1)。 + public static int BuildUniformRatios(int count, float[] ratios) + { + if (ratios == null || count <= 0) return 0; + count = Mathf.Min(count, ratios.Length); + for (int i = 0; i < count; i++) + ratios[i] = count > 1 ? (float)i / (count - 1) : 0f; + return count; + } + + /// + /// 按数据范围算线位置:用 求出刻度值, + /// 每个值经 折成面参数比例并夹到 [0,1] + /// (范围外的刻度值不该画到面外去)。 + /// + public static int BuildRatios(double min, double max, XChartAxisScale scale, double strength, + int targetCount, double manualStep, bool autoStep, float[] ratios, List scratch) + { + if (ratios == null || scratch == null) return 0; + + XChartAxisMath.BuildTicks(min, max, scale, manualStep, targetCount, autoStep, scratch); + + int count = 0; + for (int i = 0; i < scratch.Count && count < ratios.Length; i++) + { + double ratio = XChartAxisMath.ToParameter(scratch[i], min, max, scale, strength); + if (double.IsNaN(ratio) || double.IsInfinity(ratio)) continue; + ratios[count++] = Mathf.Clamp01((float)ratio); + } + return count; + } + /// + /// 把 吸附到最近的一条格线比例上(P9 的"轴线跟随"那一步)。 + /// 最近那条的距离超过 就不吸——宁可不对齐,也不要把刻度 + /// 扭到老远的地方(那会让人以为数据变了)。吸不上时 原样回填,返回 false。 + /// + public static bool TrySnapToGrid(float[] ratios, int count, float ratio, float maxDistance, out float snapped) + { + snapped = ratio; + if (ratios == null || count <= 0) return false; + + int best = -1; + float bestDistance = float.MaxValue; + for (int i = 0; i < count; i++) + { + float distance = Mathf.Abs(ratios[i] - ratio); + if (distance < bestDistance) + { + bestDistance = distance; + best = i; + } + } + + if (best < 0 || bestDistance > maxDistance) return false; + snapped = ratios[best]; + return true; + } + } +} \ No newline at end of file diff --git a/Runtime/XChart/Mesh/XChartGridLines.cs.meta b/Runtime/XChart/Mesh/XChartGridLines.cs.meta new file mode 100644 index 0000000..85df353 --- /dev/null +++ b/Runtime/XChart/Mesh/XChartGridLines.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: eef8dae19b1d78648ac23a0bd8e50170 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Mesh/XChartMeshBgConfig.cs b/Runtime/XChart/Mesh/XChartMeshBgConfig.cs new file mode 100644 index 0000000..827a813 --- /dev/null +++ b/Runtime/XChart/Mesh/XChartMeshBgConfig.cs @@ -0,0 +1,153 @@ +using System; +using UnityEngine; +using XericUI.XChart.Space; + +namespace XericUI.XChart.Mesh +{ + /// + /// 立方体网格背景元素(面板上叫 BG Cube Grid)的配置——Inspector 上看到的就是这一份。 + /// + /// 它是格线的唯一作者:画面内格线、也按同一套条数发布 + /// mesh.face.<面号>.grid.S/.T 插槽给轴线跟随(规范 §22)。线框元素 + /// ()只画棱、只发四角,两边不再抢同一批 id。 + /// + /// 它通过 协议接进图表:图表用 [SerializeReference] + /// 持有一张配置表,Unity 会按实际类型展开这里的字段,所以新增元素不需要写自定义 Editor。 + /// + /// 两份面掩码各自独立: 管填充, 管面内网格。 + /// 掩码不看可见性——背景网格本来就常画在背朝观察者的那几面(后墙 / 底面)。 + /// 字母契约:a=前 b=后 c=上 d=下 e=左 f=右。 + /// + /// 它不再持有坐标系:姿态(四元数)/半边长/尺寸口径/中心偏移都归 + /// (空间元素)管,本配置只报出自己的工具变换。 + /// 投影是 基变换 ∘ 工具变换,所以背景、线框、散点、轴线必然落在同一个空间里。 + /// + /// 名字为什么不叫 MeshBg 了:后面还要有平面坐标系网格、雷达图网格、神经图谱网格, + /// "Mesh/背景"分不开它们;名字按画的是什么几何取(BG Cube Grid), + /// 与 BG Cube Wire(线框)、将来的 BG Plane Grid 一类并列(他 2026-10-25 点名要求)。 + /// + [Serializable] + [XChartElement("cube-grid", "BG Cube Grid", 10)] + public sealed class XChartMeshBgConfig : XChartElementConfig + { + [Header("工具变换")] + [SerializeField, Tooltip("背景自己的缩放/旋转/平移。默认恒等——背景就占满图的空间")] + private XChartToolTransform m_Transform = XChartToolTransform.Identity; + + [Header("填充面")] + [SerializeField, Tooltip("要填充哪些面;None = 不填充")] + private XChartCubeFaceMask m_FillFaces = XChartCubeFaceMask.BackWalls; + + [SerializeField, Tooltip("填充色(面边缘)")] + private Color m_FillColor = new Color(0.16f, 0.19f, 0.24f, 0.85f); + + [SerializeField, Tooltip("填充中心色;与边缘色不同则走径向渐变")] + private Color m_FillCenterColor = new Color(0.16f, 0.19f, 0.24f, 0.85f); + + [Header("网格面")] + [SerializeField, Tooltip("要在哪些面上画网格;None = 不画")] + private XChartCubeFaceMask m_GridFaces = XChartCubeFaceMask.BackWalls; + + [SerializeField, Tooltip("网格线颜色")] + private Color m_GridColor = new Color(0.55f, 0.6f, 0.7f, 0.35f); + + [SerializeField, Min(0.1f), Tooltip("网格线宽")] + private float m_GridThickness = 1f; + + [SerializeField, Range(1, 50), Tooltip("每方向的网格分格数(统一值;下面 S/T 给了正数就按各自的来)。" + + "绑了维度时它当\"目标刻度条数\"")] + private int m_GridDivisions = 5; + + [SerializeField, Min(0), Tooltip("S 方向分格数(0=跟随上面的统一值)。等分时\"沿 S 的线由 T 的分格数决定\"" + + "(两条边都算,所以 N 段出 N+1 条);绑了维度时这个数是那一族线的目标刻度条数")] + private int m_GridDivisionsS; + + [SerializeField, Min(0), Tooltip("T 方向分格数(0=跟随统一值)")] + private int m_GridDivisionsT; + + [SerializeField, Tooltip("沿 S 的格线绑哪一维(-1=不绑、等分):绑了就用该维数据范围算线位置,轴线可按发布的线跟随")] + private int m_GridDimensionS = -1; + + [SerializeField, Tooltip("沿 T 的格线绑哪一维(-1=不绑、等分)")] + private int m_GridDimensionT = -1; + + [SerializeField, Tooltip("是否同时描出面轮廓")] + private bool m_ShowFaceOutline = true; + + [SerializeField, Tooltip("只画朝向观察者的面(关掉才会画后墙/底面这类背朝观察者的面)")] + private bool m_OnlyVisibleFaces; + + /// 元素在 ToolsRoot 下的名字 + public override string ElementName => "BG Cube Grid"; + + // ── 给脚本用的入口(默认长什么样由预设说,不在图上再存一份字段)────────── + // 这些就是上面序列化字段的读写口,不是第二份状态:配置本身是权威,工具在 ApplyTo 时读它。 + + /// 填哪些面(None=不填) + public XChartCubeFaceMask FillFaces { get => m_FillFaces; set => m_FillFaces = value; } + + /// 在哪些面上画格线(None=不画) + public XChartCubeFaceMask GridFaces { get => m_GridFaces; set => m_GridFaces = value; } + + /// 只画朝向观察者的面 + public bool OnlyVisibleFaces { get => m_OnlyVisibleFaces; set => m_OnlyVisibleFaces = value; } + + /// 描面轮廓:图里已经有 BG Cube Wire 时应当关掉,否则同一条边被描两遍 + public bool ShowFaceOutline { get => m_ShowFaceOutline; set => m_ShowFaceOutline = value; } + + /// 每方向分格数(统一值) + public int GridDivisions { get => m_GridDivisions; set => m_GridDivisions = Mathf.Max(1, value); } + + /// S 方向分格数(0=跟随统一值) + public int GridDivisionsS { get => m_GridDivisionsS; set => m_GridDivisionsS = Mathf.Max(0, value); } + + /// T 方向分格数(0=跟随统一值) + public int GridDivisionsT { get => m_GridDivisionsT; set => m_GridDivisionsT = Mathf.Max(0, value); } + + /// 格线颜色 + public Color GridColor { get => m_GridColor; set => m_GridColor = value; } + + /// 格线线宽 + public float GridThickness { get => m_GridThickness; set => m_GridThickness = Mathf.Max(0.1f, value); } + + /// 沿 S 的格线绑哪一维(<0=不绑、等分) + public int GridDimensionS { get => m_GridDimensionS; set => m_GridDimensionS = value; } + + /// 沿 T 的格线绑哪一维(<0=不绑、等分) + public int GridDimensionT { get => m_GridDimensionT; set => m_GridDimensionT = value; } + + public override XChartToolBase CreateTool() => new ChartToolMeshBg(); + + public override void ApplyTo(XChartToolBase tool) + { + if (!(tool is ChartToolMeshBg meshBg)) return; + + // 投影不在这里:背景只报出自己的工具变换,基变换在空间元素那份配置里 + meshBg.Transform = m_Transform; + + meshBg.FillFaces = m_FillFaces; + meshBg.FillColor = m_FillColor; + meshBg.FillCenterColor = m_FillCenterColor; + + meshBg.GridFaces = m_GridFaces; + meshBg.GridColor = m_GridColor; + meshBg.GridThickness = m_GridThickness; + meshBg.GridDivisions = m_GridDivisions; + meshBg.GridDivisionsS = m_GridDivisionsS; + meshBg.GridDivisionsT = m_GridDivisionsT; + meshBg.GridDimensionS = m_GridDimensionS; + meshBg.GridDimensionT = m_GridDimensionT; + meshBg.ShowFaceOutline = m_ShowFaceOutline; + meshBg.OnlyVisibleFaces = m_OnlyVisibleFaces; + + meshBg.MarkDirty(); + } + + public override void CaptureFrom(XChartToolBase tool) + { + if (!(tool is ChartToolMeshBg meshBg)) return; + + m_Transform = meshBg.Transform; + } + } +} \ No newline at end of file diff --git a/Runtime/XChart/Mesh/XChartMeshBgConfig.cs.meta b/Runtime/XChart/Mesh/XChartMeshBgConfig.cs.meta new file mode 100644 index 0000000..0f1fb03 --- /dev/null +++ b/Runtime/XChart/Mesh/XChartMeshBgConfig.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e071b542959f4fce9abe272bea055082 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Mesh/XChartMeshFillRenderer.cs b/Runtime/XChart/Mesh/XChartMeshFillRenderer.cs new file mode 100644 index 0000000..ac68320 --- /dev/null +++ b/Runtime/XChart/Mesh/XChartMeshFillRenderer.cs @@ -0,0 +1,254 @@ +using System; +using System.Collections.Generic; +using UnityEngine; +using UnityEngine.UI; +using XericUI.Core; + +namespace XericUI.XChart.Mesh +{ + /// + /// 顶点预算分块(纯算,离线可验)。 + /// + /// 为什么要有它:UGUI 的 65535 顶点上限是每个 Graphic 各自的,而有些元素是 + /// 按记录数长网格的(箭头一条记录 2 个四边形、散点一个点 1 个四边形)⇒ 记录一多必然撞上 + /// (他 2026-10-23 灌 10000 条时现场抛 `Mesh can not have more than 65000 vertices`)。 + /// 所以提交前先按预算把面切成若干块,每块一个 Graphic。 + /// + public static class XChartMeshBudget + { + /// 每块顶点上限。65535 是硬上限,这里留足余量(还要给别的顶点与实现细节留空间)。 + public const int ChunkVertexBudget = 16000; + + /// + /// 切块:把 个面按"每面顶点数"切成若干块, + /// 各块起始面下标写进 ,返回块数。 + /// 块 k 覆盖面 [starts[k], starts[k+1]),最后一块到 。 + /// 顺序不变、不重不漏;单面就超过预算时它自成一块(无解,只能交给渲染器)。 + /// + public static int Split(int[] faceVertexCounts, int faceCount, int budget, int[] starts) + { + if (faceVertexCounts == null) throw new ArgumentNullException(nameof(faceVertexCounts)); + if (starts == null) throw new ArgumentNullException(nameof(starts)); + if (starts.Length < 1) throw new ArgumentException("starts 至少要有 1 个位置"); + if (faceCount <= 0) + { + starts[0] = 0; + return 0; + } + if (budget < 1) budget = 1; + + int chunks = 0; + int start = 0; + int used = 0; + for (int i = 0; i < faceCount; i++) + { + int vertices = Mathf.Max(1, faceVertexCounts[i]); + if (used > 0 && used + vertices > budget) + { + starts[chunks++] = start; + start = i; + used = 0; + } + used += vertices; + } + starts[chunks++] = start; + return chunks; + } + + /// 各块顶点数的最大值(报表用:报告"最大的那个 Graphic 有多少顶点") + public static int MaxChunkVertices(int[] faceVertexCounts, int faceCount, int[] starts, int chunkCount) + { + int max = 0; + for (int c = 0; c < chunkCount; c++) + { + int end = (c + 1 < chunkCount) ? starts[c + 1] : faceCount; + int sum = 0; + for (int i = starts[c]; i < end; i++) sum += Mathf.Max(1, faceVertexCounts[i]); + if (sum > max) max = sum; + } + return max; + } + } + + /// + /// 面填充渲染器:提交若干四边形,按顶点预算自动分块,每块一个子 Graphic。 + /// + /// 每面可以纯色填充,也可以"四角色 + 中心色"径向渐变(背景做浅淡的立体感很需要这个)。 + /// 面的提交顺序就是绘制顺序,所以调用方要按深度从远到近喂(画家算法)—— + /// 半透明面叠在一起时,顺序错了颜色就错了。分块不改这个顺序:块按提交顺序排,块内也按顺序。 + /// + /// 不参与射线检测(背景不该挡住交互)。 + /// + [AddComponentMenu(XericRegistrationPaths.Chart + "/Mesh/Cube Face Fill Renderer")] + public sealed class XChartMeshFillRenderer : MaskableGraphic + { + private struct FaceQuad + { + public Vector2 Corner00; + public Vector2 Corner01; + public Vector2 Corner11; + public Vector2 Corner10; + public Color32 EdgeColor; + public Color32 CenterColor; + } + + /// 一块:只画 [Start, End) 之间的面。顶点数受预算限制,所以不会撞 65535 上限。 + private sealed class FaceChunk : MaskableGraphic + { + public XChartMeshFillRenderer Owner; + public int FirstFace; + public int LastFace; + + protected override void OnEnable() + { + base.OnEnable(); + raycastTarget = false; + } + + protected override void OnPopulateMesh(VertexHelper vh) + { + vh.Clear(); + if (Owner != null) Owner.PopulateSlice(vh, FirstFace, LastFace); + } + } + + private readonly List m_Faces = new List(8); + private readonly List m_Chunks = new List(); + private int[] m_FaceVertexCounts = new int[0]; + private int[] m_ChunkStarts = new int[8]; + + /// 报表用:这一帧提交了几个面 / 切成几块 / 最大的那块有多少顶点 + public int FaceCount => m_Faces.Count; + public int ChunkCount => m_Chunks.Count; + public int MaxChunkVertices { get; private set; } + + protected override void OnEnable() + { + base.OnEnable(); + raycastTarget = false; + } + + /// 清空已提交的面(每次重建网格前调用) + public void ClearFaces() => m_Faces.Clear(); + + /// + /// 追加一个面。 与 不同时 + /// 走径向渐变(多一个中心顶点 + 4 个三角),相同则平坦填充(4 顶点 2 三角)。 + /// + public void AddFace(Vector2 corner00, Vector2 corner01, Vector2 corner11, Vector2 corner10, + Color edgeColor, Color centerColor) + { + m_Faces.Add(new FaceQuad + { + Corner00 = corner00, + Corner01 = corner01, + Corner11 = corner11, + Corner10 = corner10, + EdgeColor = edgeColor, + CenterColor = centerColor, + }); + } + + /// 提交:按预算分块,然后各块重画 + public void Apply() + { + RebuildChunks(); + SetVerticesDirty(); // 本体不画东西,但仍刷一次,保证子块的顺序紧跟其后 + for (int i = 0; i < m_Chunks.Count; i++) m_Chunks[i].SetVerticesDirty(); + } + + private void RebuildChunks() + { + if (m_FaceVertexCounts.Length < m_Faces.Count) m_FaceVertexCounts = new int[m_Faces.Count]; + for (int i = 0; i < m_Faces.Count; i++) + m_FaceVertexCounts[i] = IsGradient(m_Faces[i]) ? 5 : 4; + + if (m_ChunkStarts.Length < m_Faces.Count + 1) m_ChunkStarts = new int[m_Faces.Count + 1]; + int chunks = XChartMeshBudget.Split(m_FaceVertexCounts, m_Faces.Count, + XChartMeshBudget.ChunkVertexBudget, m_ChunkStarts); + MaxChunkVertices = XChartMeshBudget.MaxChunkVertices(m_FaceVertexCounts, m_Faces.Count, + m_ChunkStarts, chunks); + + EnsureChunkCount(chunks); + for (int c = 0; c < chunks; c++) + { + m_Chunks[c].FirstFace = m_ChunkStarts[c]; + m_Chunks[c].LastFace = (c + 1 < chunks) ? m_ChunkStarts[c + 1] : m_Faces.Count; + m_Chunks[c].enabled = true; + } + for (int c = chunks; c < m_Chunks.Count; c++) m_Chunks[c].enabled = false; // 多余的块停掉,不画空网格 + } + + private void EnsureChunkCount(int count) + { + while (m_Chunks.Count < count) + { + var chunk = new GameObject("FillChunk" + m_Chunks.Count, typeof(RectTransform)).AddComponent(); + chunk.Owner = this; + var rect = (RectTransform)chunk.transform; + rect.SetParent(transform, false); + rect.anchorMin = Vector2.zero; + rect.anchorMax = Vector2.one; + rect.offsetMin = Vector2.zero; + rect.offsetMax = Vector2.zero; + chunk.raycastTarget = false; + m_Chunks.Add(chunk); + } + } + + /// 本体不画东西:所有面都交给受预算约束的子块 + protected override void OnPopulateMesh(VertexHelper vh) => vh.Clear(); + + private static bool IsGradient(FaceQuad face) + { + // Color32 是逐字节比较:"两色不同"就说明这次要做渐变 + return face.CenterColor.r != face.EdgeColor.r + || face.CenterColor.g != face.EdgeColor.g + || face.CenterColor.b != face.EdgeColor.b + || face.CenterColor.a != face.EdgeColor.a; + } + + internal void PopulateSlice(VertexHelper vh, int start, int end) + { + if (start < 0) start = 0; + if (end > m_Faces.Count) end = m_Faces.Count; + + for (int i = start; i < end; i++) + { + FaceQuad face = m_Faces[i]; + int first = vh.currentVertCount; + + vh.AddVert(face.Corner00, face.EdgeColor, new Vector2(0f, 0f)); + vh.AddVert(face.Corner01, face.EdgeColor, new Vector2(0f, 1f)); + vh.AddVert(face.Corner11, face.EdgeColor, new Vector2(1f, 1f)); + vh.AddVert(face.Corner10, face.EdgeColor, new Vector2(1f, 0f)); + + if (IsGradient(face)) + { + Vector2 center = (face.Corner00 + face.Corner01 + face.Corner11 + face.Corner10) * 0.25f; + vh.AddVert(center, face.CenterColor, new Vector2(0.5f, 0.5f)); + + vh.AddTriangle(first + 0, first + 1, first + 4); + vh.AddTriangle(first + 1, first + 2, first + 4); + vh.AddTriangle(first + 2, first + 3, first + 4); + vh.AddTriangle(first + 3, first + 0, first + 4); + } + else + { + vh.AddTriangle(first + 0, first + 1, first + 2); + vh.AddTriangle(first + 2, first + 3, first + 0); + } + } + } + + protected override void OnDisable() + { + base.OnDisable(); + // 图形停用时子块也得停,否则会留下"看不见但还在"的空网格 + for (int i = 0; i < m_Chunks.Count; i++) + { + if (m_Chunks[i] != null) m_Chunks[i].enabled = false; + } + } + } +} \ No newline at end of file diff --git a/Runtime/XChart/Mesh/XChartMeshFillRenderer.cs.meta b/Runtime/XChart/Mesh/XChartMeshFillRenderer.cs.meta new file mode 100644 index 0000000..cf29b36 --- /dev/null +++ b/Runtime/XChart/Mesh/XChartMeshFillRenderer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 75d18a4a019d4d50842820a2bdf026ab +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Mesh/XChartVectorFieldMath.cs b/Runtime/XChart/Mesh/XChartVectorFieldMath.cs new file mode 100644 index 0000000..ad2831a --- /dev/null +++ b/Runtime/XChart/Mesh/XChartVectorFieldMath.cs @@ -0,0 +1,75 @@ +using UnityEngine; + +namespace XericUI.XChart.Mesh +{ + /// + /// 矢量场(箭头)的纯算术:一条记录的两组三维怎么变成一支箭头,以及一组颜色维怎么变成颜色。 + /// 单独拎出来是因为这两条是"看图看不出来"的判据—— + /// 他 2026-10-25 现场:"我把它添加进来了,之后它并没有显示出来",以及"相对和绝对就是这两种区别"。 + /// 读数与算式放在一起,离线探针才能逐条钉住(规范 §25)。 + /// + public static class XChartVectorFieldMath + { + /// + /// 末端位置。= 时 + /// 是方向矢量本身(起点 + 方向×倍率); + /// = 时它是第二个点(起点 + 差向量×倍率)。 + /// 两种读法在同一个数据上画出来是两幅不同的图:前者"刺猬",后者"首尾相接"。 + /// + public static Vector3 Tip(XChartArrowVectorMode mode, Vector3 first, Vector3 second, float scale) + { + Vector3 direction = mode == XChartArrowVectorMode.Relative ? second - first : second; + return first + direction * scale; + } + + /// + /// 读一组颜色维: 按 0..256 的色环(256 与 0 是同一个颜色, + /// 取模,所以 300 也读得动),饱和度/明度/不透明度按 0..1 夹住。 + /// + /// 任何一个不是有限数就拒绝(返回 false,调用方退回单色): + /// NaN 经取模与 HSV 换算会得到一个看着像"黑色块"的东西——那不是数据的意思, + /// 是我们在替它编一个颜色(同 §14.1 的"宁可这一帧不画")。 + /// + public static bool TryColor(float hue, float saturation, float value, float alpha, out Color color) + { + color = Color.white; + if (!IsFinite(hue) || !IsFinite(saturation) || !IsFinite(value) || !IsFinite(alpha)) return false; + + color = HsvToRgb(Mathf.Repeat(hue / 256f, 1f), Mathf.Clamp01(saturation), Mathf.Clamp01(value)); + color.a = Mathf.Clamp01(alpha); + return true; + } + + private static bool IsFinite(float value) + => !float.IsNaN(value) && !float.IsInfinity(value); + + /// + /// HSV → RGB(h∈[0,1),s/v∈[0,1])。 + /// 自己写而不是调 Color.HSVToRGB:后者是引擎侧的静态调用, + /// 离线探针(mono + CoreModule)里跑不起来,而这条换算恰恰是要离线钉住的(规范 §25)。 + /// + private static Color HsvToRgb(float h, float s, float v) + { + if (s <= 0f) return new Color(v, v, v, 1f); + + float sector = h * 6f; + int index = Mathf.FloorToInt(sector) % 6; + if (index < 0) index += 6; + float f = sector - Mathf.Floor(sector); + + float p = v * (1f - s); + float q = v * (1f - s * f); + float t = v * (1f - s * (1f - f)); + + switch (index) + { + case 0: return new Color(v, t, p, 1f); + case 1: return new Color(q, v, p, 1f); + case 2: return new Color(p, v, t, 1f); + case 3: return new Color(p, q, v, 1f); + case 4: return new Color(t, p, v, 1f); + default: return new Color(v, p, q, 1f); + } + } + } +} \ No newline at end of file diff --git a/Runtime/XChart/Mesh/XChartVectorFieldMath.cs.meta b/Runtime/XChart/Mesh/XChartVectorFieldMath.cs.meta new file mode 100644 index 0000000..d016ecc --- /dev/null +++ b/Runtime/XChart/Mesh/XChartVectorFieldMath.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 2bd6270bc110b8f4e992616c92d55453 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Mesh/XChartVolumeConfigs.cs b/Runtime/XChart/Mesh/XChartVolumeConfigs.cs new file mode 100644 index 0000000..ba03791 --- /dev/null +++ b/Runtime/XChart/Mesh/XChartVolumeConfigs.cs @@ -0,0 +1,244 @@ +using System; +using UnityEngine; +using XericUI.XChart.Space; + +namespace XericUI.XChart.Mesh +{ + /// + /// 一条记录里的两个点怎么变成一支箭头。 + /// + /// 绝对:后三点是方向矢量本身(起点 + 方向×倍率=末端)。螺旋点这样画出来是"刺猬"。 + /// 相对:后三点是第二个点,箭头=第一点指向第二点(差向量×倍率)。 + /// 连续绘制模式下两者都不适用(连起来的是一条空间路径)。 + /// + public enum XChartArrowVectorMode + { + /// 后三维=方向矢量 + Absolute = 0, + /// 后三维=第二个点(箭头由第一点指向它) + Relative = 1, + } + + /// 圆柱元素的配置(几何单位都是立方体局部:±1 就是盒子边界)。 + [Serializable] + [XChartElement("cylinder", "圆柱", 40)] + public sealed class XChartCylinderConfig : XChartElementConfig + { + [Header("几何")] + [SerializeField, Tooltip("起点圆心(立方体单位)")] + private Vector3 m_Start = new Vector3(-0.6f, -0.6f, -0.6f); + [SerializeField, Tooltip("终点圆心(立方体单位);两端不重合就是斜圆柱")] + private Vector3 m_End = new Vector3(0.6f, 0.6f, 0.6f); + + [SerializeField, Tooltip("几何来源:关=用上面的常量坐标;开=从数据取(每组的首尾两条记录=这条圆柱的两端)")] + private bool m_DriveByData; + [SerializeField, Tooltip("数据模式下 X 取哪一维")] + private int m_DimensionX; + [SerializeField, Tooltip("数据模式下 Y 取哪一维")] + private int m_DimensionY = 1; + [SerializeField, Tooltip("数据模式下 Z 取哪一维")] + private int m_DimensionZ = 2; + [SerializeField, Min(2), Tooltip("几条记录凑一根圆柱(2=两两一组:记录 0-1、2-3…,不重叠也不并入上一组)")] + private int m_GroupSize = 2; + [SerializeField, Min(1), Tooltip("最多画几根(记录多时按组数上限截断,报表会点名截了多少)")] + private int m_MaxCylinders = 64; + + [SerializeField, Min(0.001f), Tooltip("半径(立方体单位)")] + private float m_Radius = 0.22f; + [SerializeField, Range(8, 256), Tooltip("一圈分多少段(轮廓与十字的采样精度)")] + private int m_SegmentCount = 48; + + [SerializeField, Tooltip("起点端面的法线。零=沿两端连线(与旧行为一致)")] + private Vector3 m_StartNormal = Vector3.zero; + [SerializeField, Tooltip("终点端面的法线。零=沿两端连线。两端各给各的,就能做出端面不平行的那种")] + private Vector3 m_EndNormal = Vector3.zero; + + [SerializeField, Tooltip("圆柱自己的变换(叠在图的空间之上)")] + private XChartToolTransform m_Transform = XChartToolTransform.Identity; + + [Header("呈现(各有开关)")] + [SerializeField, Tooltip("外轮廓包边(视角下的轮廓,不是把所有母线都连起来)")] + private bool m_ShowOutline = true; + [SerializeField] private Color m_OutlineColor = new Color(0.75f, 0.85f, 1f, 0.9f); + [SerializeField, Min(0.1f)] private float m_OutlineThickness = 2f; + + [SerializeField, Tooltip("轮廓填充(与包边同一个凸包多边形)")] + private bool m_ShowFill = true; + [SerializeField] private Color m_FillColor = new Color(0.34f, 0.55f, 0.85f, 0.35f); + + [SerializeField, Tooltip("端面十字:用端面自己的采样顶点连成,所以永远与实际端面对得上,能看出滚转")] + private bool m_ShowCapCross; + [SerializeField] private Color m_CrossColor = new Color(0.9f, 0.95f, 1f, 0.85f); + [SerializeField, Min(0.1f)] private float m_CrossThickness = 1.5f; + + [SerializeField, Tooltip("起点端面的闭合圆环(端面自己的边界,整圈闭合)")] + private bool m_ShowStartRing; + [SerializeField, Tooltip("终点端面的闭合圆环")] + private bool m_ShowEndRing; + + [SerializeField, Range(0, 64), Tooltip("内部母线数量(两端对应点相连;0=不画)")] + private int m_GeneratrixCount; + [SerializeField] private Color m_GeneratrixColor = new Color(0.75f, 0.85f, 1f, 0.35f); + + public override string ElementName => "Cylinder"; + + public override XChartToolBase CreateTool() => new ChartToolCylinder(); + + public override void ApplyTo(XChartToolBase tool) + { + if (!(tool is ChartToolCylinder cylinder)) return; + + cylinder.Start = m_Start; + cylinder.End = m_End; + cylinder.DriveByData = m_DriveByData; + cylinder.DimensionX = m_DimensionX; + cylinder.DimensionY = m_DimensionY; + cylinder.DimensionZ = m_DimensionZ; + cylinder.GroupSize = m_GroupSize; + cylinder.MaxCylinders = m_MaxCylinders; + cylinder.Radius = m_Radius; + cylinder.SegmentCount = m_SegmentCount; + cylinder.StartNormal = m_StartNormal; + cylinder.EndNormal = m_EndNormal; + cylinder.Transform = m_Transform; + + cylinder.ShowOutline = m_ShowOutline; + cylinder.OutlineColor = m_OutlineColor; + cylinder.OutlineThickness = m_OutlineThickness; + + cylinder.ShowFill = m_ShowFill; + cylinder.FillColor = m_FillColor; + + cylinder.ShowCapCross = m_ShowCapCross; + cylinder.CrossColor = m_CrossColor; + cylinder.CrossThickness = m_CrossThickness; + + cylinder.ShowStartRing = m_ShowStartRing; + cylinder.ShowEndRing = m_ShowEndRing; + + cylinder.GeneratrixCount = m_GeneratrixCount; + cylinder.GeneratrixColor = m_GeneratrixColor; + + cylinder.MarkDirty(); + } + } + + /// + /// 向量箭头(矢量场)元素的配置。 + /// + /// 一条记录怎么读:前 3 维是"一个点",后 3 维是"另一个点", + /// 按 解释成一支箭头—— + /// + /// (绝对):后 3 维是方向矢量本身, + /// 起点 + 方向×倍率 = 箭头末端。螺旋点在这种读法下画出来是一片"刺猬"(每根朝外)。 + /// (相对):后 3 维是第二个点, + /// 箭头 = 第一点指向第二点(差向量×倍率)。一串首尾相接的点在这种读法下就是"连着头往下转"。 + /// + /// + /// 连续绘制():把所有记录的点按顺序连成一条折线—— + /// 这时"相对/绝对"没有意义(连起来的本来就是空间里的一条路径)⇒ 面板上那两个选项**隐藏** + /// (互斥显示,见 )。 + /// + /// 颜色是可选的额外维度:[h, s, v](可选 +a)接在矢量后面读, + /// 于是"给每个点标颜色"不需要往表里塞非数值列——色相走 0..256 的色环,其余三个按 0..1。 + /// + [Serializable] + [XChartElement("arrows", "向量箭头", 50)] + public sealed class XChartArrowConfig : XChartElementConfig + { + /// 3 维起点 + 3 维方向/第二点 + public const int VectorDimensionCount = 6; + + [Header("数据")] + [SerializeField, Tooltip("起点从第几个数值维开始(一条记录要占 6 维:起点 3 + 方向或第二点 3)")] + private int m_OriginDimension; + + [SerializeField, Tooltip("绝对:后三维是方向矢量(起点→末端)。相对:后三维是第二个点," + + "箭头=第一点指向第二点。**连续绘制打开时这一项不适用**")] + private XChartArrowVectorMode m_VectorMode = XChartArrowVectorMode.Absolute; + + [SerializeField, Tooltip("把每条记录的点按顺序连成一条折线(只有最后一段带箭头)。" + + "打开之后「相对/绝对」被隐藏——连起来的是一条空间路径,谈不到这两者")] + private bool m_Continuous; + + [SerializeField, Tooltip("方向向量长度倍率(立方体单位);相对模式下作用在差向量上")] + private float m_DirectionScale = 0.25f; + + [SerializeField, Range(0, 100000), Tooltip("最多画多少条(0=不限);防止十万条记录一口气铺满")] + private int m_MaxArrowCount = 512; + + [SerializeField, Tooltip("箭头自己的变换(叠在图的空间之上)")] + private XChartToolTransform m_Transform = XChartToolTransform.Identity; + + [Header("颜色(可选维度)")] + [SerializeField, Tooltip("用额外的数值维给每支箭头上色。三个维依次是 色相(0..256 色环) / 饱和度(0..1) / 明度(0..1)")] + private bool m_UseColorDimensions; + + [SerializeField, Tooltip("颜色三维从第几维开始(默认 6=紧跟在矢量后面)。" + + "这些维**不进**前面的数据语义,只是被读走做颜色")] + private int m_ColorDimension = VectorDimensionCount; + + [SerializeField, Tooltip("再加一维不透明度(0..1),读颜色起点维 +3")] + private bool m_HasAlphaDimension; + + [Header("外观")] + [SerializeField, Tooltip("没有给颜色维度时用的单色")] + private Color m_ArrowColor = new Color(0.95f, 0.6f, 0.25f, 0.9f); + [SerializeField, Min(0.1f), Tooltip("杆宽(像素)")] + private float m_ShaftWidth = 2f; + [SerializeField, Min(0.1f), Tooltip("箭头长(像素)")] + private float m_HeadLength = 10f; + [SerializeField, Min(0.1f), Tooltip("箭头宽(像素)")] + private float m_HeadWidth = 7f; + [SerializeField, Tooltip("零向量也画成一个极小四边形(不画的话它会整条消失)")] + private bool m_ShowZeroVectorsAsDots; + + public override string ElementName => "Arrows"; + + /// + /// 这个元素要几个数值维才画得出来(面板据此报"表里只有几个",不再"什么都不显示")。 + /// 不透明度那一维**不算硬需求**(多给就多读、没给退回单色 alpha)——算进去就成了 + /// "勾一个开关,整个元素消失"。 + /// + public override int RequiredNumericDimensions + => VectorDimensionCount + (m_UseColorDimensions ? 3 : 0); + + /// + /// 互斥显示:连续绘制打开时「相对/绝对」没有意义(他 2026-10-25:勾一个就把排斥的那几个藏起来)。 + /// 判据只有一处,面板照着问,不在面板里写特例。 + /// + public override bool IsFieldHidden(string fieldName) + { + if (fieldName == nameof(m_VectorMode)) return m_Continuous; + if (fieldName == nameof(m_ColorDimension) || fieldName == nameof(m_HasAlphaDimension)) + return !m_UseColorDimensions; + return false; + } + + public override XChartToolBase CreateTool() => new ChartToolVectorArrows(); + + public override void ApplyTo(XChartToolBase tool) + { + if (!(tool is ChartToolVectorArrows arrows)) return; + + arrows.OriginDimension = m_OriginDimension; + arrows.VectorMode = m_VectorMode; + arrows.Continuous = m_Continuous; + arrows.DirectionScale = m_DirectionScale; + arrows.MaxArrowCount = m_MaxArrowCount; + arrows.Transform = m_Transform; + + arrows.UseColorDimensions = m_UseColorDimensions; + arrows.ColorDimension = m_ColorDimension; + arrows.HasAlphaDimension = m_HasAlphaDimension; + + arrows.ArrowColor = m_ArrowColor; + arrows.ShaftWidth = m_ShaftWidth; + arrows.HeadLength = m_HeadLength; + arrows.HeadWidth = m_HeadWidth; + arrows.ShowZeroVectorsAsDots = m_ShowZeroVectorsAsDots; + + arrows.MarkDirty(); + } + } +} diff --git a/Runtime/XChart/Mesh/XChartVolumeConfigs.cs.meta b/Runtime/XChart/Mesh/XChartVolumeConfigs.cs.meta new file mode 100644 index 0000000..f8702d1 --- /dev/null +++ b/Runtime/XChart/Mesh/XChartVolumeConfigs.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 453779c1de4515048aa67a2ac98cac43 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Pools.meta b/Runtime/XChart/Pools.meta new file mode 100644 index 0000000..0e3ad59 --- /dev/null +++ b/Runtime/XChart/Pools.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 50b159b177a7708419cfff955d65dba8 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Pools/IXChartSlotFactory.cs b/Runtime/XChart/Pools/IXChartSlotFactory.cs new file mode 100644 index 0000000..523c9ef --- /dev/null +++ b/Runtime/XChart/Pools/IXChartSlotFactory.cs @@ -0,0 +1,38 @@ +namespace XericUI.XChart.Pools +{ + /// + /// 槽位工厂。池的调度器只认这一个接口,所以调度算法是纯托管的,能在离线探针里 + /// 用假工厂跑(规范 Documentation/XChart-RenderFramework.md §5.3)。 + /// + /// host 对调度器是透明引用,只有实现认识它(运行时里是标签宿主 RectTransform)。 + /// 把 host 交给 与 ,是为了让"挂在哪"成为有效性判据 + /// 的一部分:父节点不对就是被人挪走了(或者宿主节点随域重载没了),必须丢弃重补, + /// 而不是继续画在一个来历不明的位置。 + /// + public interface IXChartSlotFactory + { + /// + /// 取一个可用槽位:工厂自己的空闲表里有就复用,没有就新建(新建件的 hideFlags 由实现负责)。 + /// 给不出来就返回 null——调度器会保持该 owner 为脏,下一帧再试,不会静默少画。 + /// + TSlot Acquire(); + + /// + /// 真正归还:停用并放回工厂的空闲表。 + /// 只在顺位复用之后还有剩余时调用——抽出来的槽位默认先在本帧回收队列里等别人认领。 + /// + void Release(TSlot slot); + + /// 发落给某个 owner:挂到 host 下并置为激活 + void Assign(TSlot slot, object host); + + /// §5.3 的合取判据:任一条件不满足就返回 false(调度器随即丢弃它并补新的) + bool IsUsable(TSlot slot, object host); + + /// + /// 硬销毁池的一切(chart.RebuildAll() 与调试菜单走这一条)。 + /// 调度器只管列表,只有实现知道"件"是什么、池根挂在哪——所以销毁也归它。 + /// + void DestroyAll(); + } +} diff --git a/Runtime/XChart/Pools/IXChartSlotFactory.cs.meta b/Runtime/XChart/Pools/IXChartSlotFactory.cs.meta new file mode 100644 index 0000000..b0d506c --- /dev/null +++ b/Runtime/XChart/Pools/IXChartSlotFactory.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3deb2549fc4a3a34c82df3712c373398 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Pools/XChartSlotPool.cs b/Runtime/XChart/Pools/XChartSlotPool.cs new file mode 100644 index 0000000..75ab502 --- /dev/null +++ b/Runtime/XChart/Pools/XChartSlotPool.cs @@ -0,0 +1,247 @@ +using System.Collections.Generic; + +namespace XericUI.XChart.Pools +{ + /// + /// 槽位池调度器(规范 §5.1/§5.2/§5.3)。 + /// + /// 纯托管、不引用 UnityEngine:调度是唯一一份实现,判据靠假工厂在离线探针里跑, + /// 不需要编辑器在场也能证明"先释放、顺位优先、池兜底"这套顺序真的在生效。 + /// + /// 申请单位是一批: 只把 owner 标脏,分配一律推迟到 + /// 。每个 owner 的列表被整份换回(换新列表实例,不原地改长度), + /// 所以调用方拿到的旧引用不会被人悄悄改短。 + /// + public sealed class XChartSlotPool + { + private sealed class OwnerRecord + { + public int Index; + public object Host; + public int Requested; + public bool Dirty; + public List Slots = new List(); + } + + private readonly IXChartSlotFactory m_Factory; + + /// 注册顺序就是次级排序键:申请数相同时先注册者顺位在前,调度可重放 + private readonly List m_Order = new List(); + private readonly Dictionary m_Lookup = new Dictionary(); + private readonly List m_Round = new List(); + private readonly List m_Recycle = new List(); + private static readonly IReadOnlyList k_Empty = new TSlot[0]; + + private int m_DirtyCount; + + // ── 计数器:都是累计值,探针取两次快照的差来判决 ────────────── + public int DispatchCount { get; private set; } + /// 从本帧回收队列里顺位取用的次数(不是向工厂要的) + public int ReuseCount { get; private set; } + /// 向工厂 Acquire 的次数(池兜底 + 新建) + public int AcquireCount { get; private set; } + /// 真正归还工厂的次数(只等于回收队列的剩余) + public int ReleaseCount { get; private set; } + /// §5.3 校验丢弃的槽位数(域重载、宿主重建都会在这里露头) + public int DroppedCount { get; private set; } + + public int OwnerCount => m_Order.Count; + + /// 调度收敛了没有:为 false 说明还有 owner 在等件(工厂给不出或宿主没就绪) + public bool IsIdle => m_DirtyCount == 0; + + public XChartSlotPool(IXChartSlotFactory factory) + { + m_Factory = factory; + } + + /// + /// 登记一批需求( 是本帧要用的总数,不是增量)。只置脏,不分配。 + /// 变了也要重排——域重载后宿主是新实例,旧槽位的父节点就对不上了。 + /// + public void Request(object owner, object host, int count) + { + if (owner == null) return; + if (count < 0) count = 0; + + OwnerRecord record; + if (!m_Lookup.TryGetValue(owner, out record)) + { + record = new OwnerRecord { Index = m_Order.Count }; + m_Lookup[owner] = record; + m_Order.Add(record); + } + + if (record.Requested == count && ReferenceEquals(record.Host, host) && !record.Dirty) return; + record.Requested = count; + record.Host = host; + MarkDirty(record); + } + + public void Forget(object owner) + { + if (owner == null) return; + OwnerRecord record; + if (!m_Lookup.TryGetValue(owner, out record)) return; + m_Lookup.Remove(owner); + m_Order.Remove(record); + // 它手上的件全数归还池,不然这些实例就没人认领了 + for (int i = 0; i < record.Slots.Count; i++) + { + m_Factory.Release(record.Slots[i]); + ReleaseCount++; + } + record.Slots.Clear(); + if (record.Dirty) + { + record.Dirty = false; + m_DirtyCount--; + } + } + + /// owner 当前持有的槽位(长度就是已发落的数量,申请数看 ) + public IReadOnlyList SlotsOf(object owner) + { + OwnerRecord record; + return m_Lookup.TryGetValue(owner, out record) ? record.Slots : k_Empty; + } + + public int RequestedCount(object owner) + { + OwnerRecord record; + return m_Lookup.TryGetValue(owner, out record) ? record.Requested : 0; + } + + public int HeldCount(object owner) + { + OwnerRecord record; + return m_Lookup.TryGetValue(owner, out record) ? record.Slots.Count : 0; + } + + /// + /// 一次调度:校验 → 排序 → 先释放 → 再补充(顺位优先,池兜底)→ 盈余才归还 → 换回列表。 + /// 返回本次是否真的动过(没脏也没丢弃时是 O(槽位总数) 的一次校验而已)。 + /// + public bool Dispatch() + { + DispatchCount++; + + // 0) 有效性校验:每次调度都做,不只对脏 owner(§5.3) + for (int i = 0; i < m_Order.Count; i++) + { + OwnerRecord record = m_Order[i]; + int held = record.Slots.Count; + if (held == 0) continue; + + int kept = 0; + for (int s = 0; s < held; s++) + { + TSlot slot = record.Slots[s]; + if (m_Factory.IsUsable(slot, record.Host)) record.Slots[kept++] = slot; + else DroppedCount++; + } + + if (kept == held) continue; + record.Slots.RemoveRange(kept, held - kept); + MarkDirty(record); + } + + // 1) 脏 owner 按申请数从大到小排序,让先申请者顺位拿到回收件 + m_Round.Clear(); + for (int i = 0; i < m_Order.Count; i++) + { + OwnerRecord record = m_Order[i]; + if (!record.Dirty) continue; + // 宿主还没就绪又要点件:这轮整个跳过,脏着下一帧再试(不然会反复造出无主的件) + if (record.Host == null && record.Requested > 0) continue; + m_Round.Add(record); + } + if (m_Round.Count == 0) return false; + m_Round.Sort(CompareByRequestDescending); + + // 2) 先处理释放:多出来的抽进本帧回收队列——这一步还不还池 + m_Recycle.Clear(); + for (int i = 0; i < m_Round.Count; i++) + { + OwnerRecord record = m_Round[i]; + int keep = record.Requested; + if (record.Slots.Count <= keep) continue; + for (int s = keep; s < record.Slots.Count; s++) m_Recycle.Add(record.Slots[s]); + record.Slots.RemoveRange(keep, record.Slots.Count - keep); + } + + // 3) 再补充:先吃回收队列(顺位复用),队列空了才向工厂要 + for (int i = 0; i < m_Round.Count; i++) + { + OwnerRecord record = m_Round[i]; + var next = new List(record.Slots); + while (next.Count < record.Requested) + { + TSlot slot; + if (m_Recycle.Count > 0) + { + slot = m_Recycle[m_Recycle.Count - 1]; + m_Recycle.RemoveAt(m_Recycle.Count - 1); + ReuseCount++; + } + else + { + slot = m_Factory.Acquire(); + AcquireCount++; + } + if (slot == null) break; + m_Factory.Assign(slot, record.Host); + next.Add(slot); + } + + record.Slots = next; + ClearDirty(record); + // 工厂给不出(宿主没了、创建被挡)就保持脏,下一帧重试——不静默少画 + if (next.Count < record.Requested) MarkDirty(record); + } + + // 4) 回收队列的剩余才是真正归还 + for (int i = 0; i < m_Recycle.Count; i++) + { + m_Factory.Release(m_Recycle[i]); + ReleaseCount++; + } + m_Recycle.Clear(); + return true; + } + + /// + /// 拆池:清空全部 owner 记录,再把"件"的销毁交给工厂。 + /// 列表在这里没意义——件是别人(GameObject)造的,只有实现知道怎么硬销毁。 + /// + public void Dispose() + { + m_Lookup.Clear(); + m_Order.Clear(); + m_Round.Clear(); + m_Recycle.Clear(); + m_DirtyCount = 0; + m_Factory.DestroyAll(); + } + + private int CompareByRequestDescending(OwnerRecord a, OwnerRecord b) + { + if (a.Requested != b.Requested) return b.Requested.CompareTo(a.Requested); + return a.Index.CompareTo(b.Index); + } + + private void MarkDirty(OwnerRecord record) + { + if (record.Dirty) return; + record.Dirty = true; + m_DirtyCount++; + } + + private void ClearDirty(OwnerRecord record) + { + if (!record.Dirty) return; + record.Dirty = false; + m_DirtyCount--; + } + } +} diff --git a/Runtime/XChart/Pools/XChartSlotPool.cs.meta b/Runtime/XChart/Pools/XChartSlotPool.cs.meta new file mode 100644 index 0000000..0ac8074 --- /dev/null +++ b/Runtime/XChart/Pools/XChartSlotPool.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c7aa7a7cc2823a149a9778eb4f0b07ae +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Pools/XChartTextSlotFactory.cs b/Runtime/XChart/Pools/XChartTextSlotFactory.cs new file mode 100644 index 0000000..de96340 --- /dev/null +++ b/Runtime/XChart/Pools/XChartTextSlotFactory.cs @@ -0,0 +1,136 @@ +using System.Collections.Generic; +using TMPro; +using UnityEngine; + +namespace XericUI.XChart.Pools +{ + /// + /// 文本槽位工厂:运行时里唯一造 TMP 标签的地方(规范 §5)。 + /// + /// 空闲的槽位停在池根(chart 根下的 GeneratedTextPool 节点)上并停用; + /// 发落出去时挂到该 owner 自己的宿主节点。"父节点必须等于宿主"是有效性判据的一部分—— + /// 域重载后宿主是新实例,旧标签还挂在旧父节点上,这种必须丢弃重补, + /// 不能让它带着上一轮的父子关系继续画。 + /// + /// 池根整块没了(chart 被销毁又重建)不抛异常: 直接重建。 + /// + public sealed class XChartTextSlotFactory : IXChartSlotFactory + { + /// 池根节点名。chart 的回收校验和调试报表都按这个名字找它,所以只此一份。 + public const string PoolRootName = "GeneratedTextPool"; + + private readonly RectTransform m_ChartRoot; + private readonly Stack m_Free = new Stack(); + private RectTransform m_PoolRoot; + private int m_SlotIndex; + + public XChartTextSlotFactory(RectTransform chartRoot) + { + m_ChartRoot = chartRoot; + } + + /// 池里闲置的槽位数(调试判据用:调度收敛后应当等于"曾经发落过又还回来的") + public int FreeCount => m_Free.Count; + + public TMP_Text Acquire() + { + var poolRoot = EnsurePoolRoot(); + if (poolRoot == null) return null; + + while (m_Free.Count > 0) + { + TMP_Text slot = m_Free.Pop(); + // 空闲表里也可能有域重载留下的僵尸件:验不过就当场销毁,别发出去 + if (!IsAlive(slot)) { DestroySlot(slot); continue; } + slot.gameObject.SetActive(true); + return slot; + } + + var go = new GameObject("TextSlot_" + m_SlotIndex, typeof(RectTransform)); + m_SlotIndex++; + go.transform.SetParent(poolRoot, false); + go.hideFlags = XChartBase.CurrentFlags; + + var tmp = go.AddComponent(); + tmp.text = string.Empty; + tmp.enableWordWrapping = false; + tmp.alignment = TextAlignmentOptions.Center; + var rect = tmp.rectTransform; + rect.anchorMin = new Vector2(0.5f, 0.5f); + rect.anchorMax = new Vector2(0.5f, 0.5f); + rect.pivot = new Vector2(0.5f, 0.5f); + return tmp; + } + + public void Release(TMP_Text slot) + { + if (!IsAlive(slot)) return; + slot.text = string.Empty; + slot.gameObject.SetActive(false); + var poolRoot = EnsurePoolRoot(); + if (poolRoot != null) slot.transform.SetParent(poolRoot, false); + m_Free.Push(slot); + } + + public void Assign(TMP_Text slot, object host) + { + if (!IsAlive(slot)) return; + var parent = host as RectTransform; + if (parent == null) return; + slot.transform.SetParent(parent, false); + slot.gameObject.SetActive(true); + } + + public bool IsUsable(TMP_Text slot, object host) + { + var parent = host as RectTransform; + if (parent == null) return false; + if (!IsAlive(slot)) return false; + return slot.transform.parent == parent && slot.gameObject.activeSelf; + } + + /// + /// 存在性合取判据(§5.3 的前半):件还在、GameObject 还在、保存位仍然带 DontSave。 + /// 父节点与激活状态因 owner 而异,交给 。 + /// + private static bool IsAlive(TMP_Text slot) + { + if (slot == null) return false; + if (slot.gameObject == null) return false; + return (slot.hideFlags & HideFlags.DontSave) != 0; + } + + private static void DestroySlot(TMP_Text slot) + { + if (slot == null) return; + if (slot.gameObject == null) return; + UnityEngine.Object.DestroyImmediate(slot.gameObject); + } + + /// + /// 拆池:把池根连同池内件一起硬销毁。必须有这一步——池根挂在 chart 自己下面而 + /// 工具清理只拆 [XChartTools],不拆它就等于每回收重建一次漏一个池根在场景里。 + /// 已经发落出去的件不归这里:它们在各工具的宿主下,随工具根一起销毁。 + /// + public void DestroyAll() + { + m_Free.Clear(); + if (m_PoolRoot == null) return; + var rootObject = m_PoolRoot.gameObject; + m_PoolRoot = null; + if (rootObject != null) UnityEngine.Object.DestroyImmediate(rootObject); + } + + private RectTransform EnsurePoolRoot() + { + if (m_PoolRoot != null) return m_PoolRoot; + if (m_ChartRoot == null) return null; + + var go = new GameObject(PoolRootName, typeof(RectTransform)); + go.transform.SetParent(m_ChartRoot, false); + go.hideFlags = XChartBase.CurrentFlags; + m_PoolRoot = go.GetComponent(); + return m_PoolRoot; + } + } +} diff --git a/Runtime/XChart/Pools/XChartTextSlotFactory.cs.meta b/Runtime/XChart/Pools/XChartTextSlotFactory.cs.meta new file mode 100644 index 0000000..ea6316c --- /dev/null +++ b/Runtime/XChart/Pools/XChartTextSlotFactory.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 0dcf25011e8767243943bb98474d15b6 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Products.meta b/Runtime/XChart/Products.meta new file mode 100644 index 0000000..7a0a633 --- /dev/null +++ b/Runtime/XChart/Products.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 1efd46adfe404bba8a57a6d6c12352a2 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Products/XMeshPreviewChart.cs b/Runtime/XChart/Products/XMeshPreviewChart.cs new file mode 100644 index 0000000..5acb72c --- /dev/null +++ b/Runtime/XChart/Products/XMeshPreviewChart.cs @@ -0,0 +1,398 @@ +using UnityEngine; +using XericUI.Core; +using XericUI.XChart.Axis; +using XericUI.XChart.Mesh; +using XericUI.XChart.Pseudo3D; + +namespace XericUI.XChart.Products +{ + /// + /// 网格渲染预览图:用来验证立方体网格背景(填充 / 面内网格 / 面控制 / 3D 旋转) + /// 以及后续同类网格渲染器(圆柱等)的观感。 + /// + /// 它示范的是"脚本注册"这条路:三个工具全部在 里登记, + /// 没有用 Inspector 的元素表——固定的调试组合用这种写法最省事。生产用的成品图应当走 + /// 元素配置(),那样才可在 Inspector 里增删改。 + /// + /// 验证要点 + /// + /// 面掩码:a=前 b=后 c=上 d=下 e=左 f=右,填充与网格各一份(互不影响)。 + /// 默认画的是背朝观察者的后墙/底面(背景墙观感);勾 + /// 切成"实体盒子"观感,可来回对照。 + /// 半透明填充按面心深度从远到近提交,改 alpha 能看出叠色顺序对不对。 + /// 散点走的是线框工具的投影,两者的四元数姿态/半边长/尺寸口径由本组件统一推下去, + /// 所以点会落在盒子里。默认视角是 + /// (45° 正交,整个立方体的轮廓是一个正六边形)。 + /// + /// + /// 编辑器里就要能看到效果:基类是 [ExecuteAlways],改本组件的旋钮会延迟一拍 + /// 直接生效。注意编辑器静止时 Unity 不重绘 SceneView,LateUpdate 不一定跑——动一下鼠标/平移视图 + /// 就会刷新,这不是坏了。 + /// + [AddComponentMenu(XericRegistrationPaths.Chart + "/Products/网格渲染预览图")] + [ExecuteAlways] + public class XMeshPreviewChart : XChartBase + { + // ── 空间(3D 旋转 + 投影) ──────────────────────────────── + + [Header("空间")] + [SerializeField, Min(1f), Tooltip("立方体半边长(UI 像素):真实边长的一半。" + + "外接球半径(顶点到中心)= √3 倍,等距轮廓正六边形的外接圆 = √(8/3) 倍")] + private float m_HalfSize = 100f; + + [SerializeField, Tooltip("视角预设:一次性动作。选它就把预设四元数写进 Rotation,然后回到\"手动\";渲染只读 Rotation")] + private XChartCubeViewPreset m_ViewPreset = XChartCubeViewPreset.Manual; + + [SerializeField, Tooltip("姿态四元数(x,y,z,w)——唯一的旋转权威量,没有相机位置可调")] + private Quaternion m_Rotation = XChartCubeView.RotationOf(XChartCubeViewPreset.Isometric); + + [SerializeField, Tooltip("尺寸口径:半边长(尺度与旋转无关,默认)/ 视口适配(铺满固定矩形,转起来会变小)")] + private XChartCubeSizeMode m_SizeMode = XChartCubeSizeMode.HalfEdgeLength; + + // ── 填充 ────────────────────────────────────────────────── + + [Header("填充面")] + [SerializeField, Tooltip("要填充哪些面;None = 不填充")] + private XChartCubeFaceMask m_FillFaces = XChartCubeFaceMask.BackWalls; + + [SerializeField, Tooltip("填充色(面边缘)")] + private Color m_FillColor = new Color(0.16f, 0.19f, 0.24f, 0.85f); + + [SerializeField, Tooltip("填充中心色;与边缘色不同则走径向渐变")] + private Color m_FillCenterColor = new Color(0.28f, 0.34f, 0.42f, 0.85f); + + [SerializeField, Tooltip("只画朝向观察者的面(关掉才会画后墙/底面这类背朝观察者的面)")] + private bool m_OnlyVisibleFaces; + + // ── 面内网格 ────────────────────────────────────────────── + + [Header("网格面")] + [SerializeField, Tooltip("要在哪些面上画网格;None = 不画")] + private XChartCubeFaceMask m_GridFaces = XChartCubeFaceMask.BackWalls; + + [SerializeField, Tooltip("网格线颜色")] + private Color m_GridColor = new Color(0.55f, 0.6f, 0.7f, 0.4f); + + [SerializeField, Min(0.1f), Tooltip("网格线宽")] + private float m_GridThickness = 1f; + + [SerializeField, Range(1, 50), Tooltip("每个方向的网格分割数")] + private int m_GridDivisions = 5; + + [SerializeField, Tooltip("是否同时描出面轮廓")] + private bool m_ShowFaceOutline = true; + + // ── 线框 ────────────────────────────────────────────────── + + [Header("线框")] + [SerializeField, Tooltip("是否显示立方体 12 棱线框")] + private bool m_ShowWireframe = true; + + [SerializeField, Tooltip("前向棱颜色")] + private Color m_FrontEdgeColor = new Color(0.75f, 0.8f, 0.9f, 0.9f); + + [SerializeField, Tooltip("后向棱颜色")] + private Color m_BackEdgeColor = new Color(0.5f, 0.55f, 0.65f, 0.35f); + + [SerializeField, Min(0.1f), Tooltip("棱线宽")] + private float m_EdgeThickness = 2f; + + // ── 示例散点 ────────────────────────────────────────────── + + [Header("示例散点")] + [SerializeField, Tooltip("是否显示示例散点")] + private bool m_ShowSamplePoints = true; + + [SerializeField, Range(0, 2000), Tooltip("示例点数量")] + private int m_SamplePointCount = 240; + + [SerializeField, Min(0.5f), Tooltip("点大小(像素)")] + private float m_PointSize = 6f; + + [SerializeField, Tooltip("点颜色")] + private Color m_PointColor = new Color(0.34f, 0.72f, 1f, 1f); + + [SerializeField, Tooltip("点边框颜色")] + private Color m_PointBorderColor = new Color(0.08f, 0.12f, 0.2f, 1f); + + // ── 轴线 / 体积元素(同一空间的其它消费者) ─────────────── + + [Header("轴线")] + [SerializeField, Tooltip("显示 X / Y / Z 三条轴线元素")] + private bool m_ShowAxes = true; + + [SerializeField, Tooltip("刻度标签用数值直驱时的格式化串;留空=自适应")] + private string m_AxisLabelFormat; + + [Header("圆柱 / 箭头")] + [SerializeField, Tooltip("显示一根斜圆柱(两端不重合,验斜圆柱也走同一套环几何)")] + private bool m_ShowCylinder; + + [SerializeField, Range(3, 128), Tooltip("圆柱分段数")] + private int m_CylinderSegments = 24; + + [SerializeField, Min(0.01f), Tooltip("圆柱半径(立方体单位)")] + private float m_CylinderRadius = 0.22f; + + [SerializeField, Tooltip("显示向量箭头(数据里每条记录的后三维当方向)")] + private bool m_ShowArrows; + + // ── 工具引用 ────────────────────────────────────────────── + + private ChartToolMeshBg m_MeshBg; + private ChartToolCubeBg m_Wireframe; + private ChartToolScatterPoints m_Points; + private ChartToolAxis m_AxisX; + private ChartToolAxis m_AxisY; + private ChartToolAxis m_AxisZ; + private ChartToolCylinder m_Cylinder; + private ChartToolVectorArrows m_Arrows; + + private Vector3[] m_SamplePoints; + + /// + /// 当前姿态(渲染唯一权威)。预设选择器是一次性的:非"手动"时把预设四元数写进 + /// 并复位选择器,之后 Rotation 想怎么拧就怎么拧。 + /// + public Quaternion Rotation + { + get => m_Rotation; + set { m_Rotation = value; m_ViewPreset = XChartCubeViewPreset.Manual; ApplySpace(); } + } + + private Quaternion ConsumeViewPreset() + { + if (m_ViewPreset == XChartCubeViewPreset.Manual) return m_Rotation; + m_Rotation = XChartCubeView.RotationOf(m_ViewPreset); + m_ViewPreset = XChartCubeViewPreset.Manual; + return m_Rotation; + } + + /// ★ 脚本注册:本图要用哪些工具都在这里登记(唯一的集中注册点) + protected override void RegisterTools() + { + // 空间工具(投影权威)由基类保证存在,这里不重复登记 + // 背景最先画(负序号),线框、轴线、体积元素、散点依次压上去 + // 工具名=元素显示名(BG Cube Grid / BG Cube Wire):面板的「脚本注册的工具」 + // 就是照这个名字点名的,两边一个名字才认得出是同一个东西 + m_MeshBg = RegisterTool("BG Cube Grid", -10); + m_Wireframe = RegisterTool("BG Cube Wire", 0); + + m_AxisX = RegisterTool("AxisX", 5); + m_AxisY = RegisterTool("AxisY", 6); + m_AxisZ = RegisterTool("AxisZ", 7); + ConfigureAxes(); + + m_Cylinder = RegisterTool("Cylinder", 8); + m_Points = RegisterTool("SamplePoints", 10); + m_Arrows = RegisterTool("Arrows", 11); + } + + /// 三条轴各挑自己的面 / 方向 / 维度;它们共用同一个空间,所以不必彼此协调 + private void ConfigureAxes() + { + if (m_AxisX != null) + { + m_AxisX.SlotId = XChartCubeGeometry.FaceSlotId(XChartCubeGeometry.CubeFace.Bottom); + m_AxisX.Direction = XChartAxisDirection.AlongS; + m_AxisX.Dimension = 0; + } + if (m_AxisY != null) + { + m_AxisY.SlotId = XChartCubeGeometry.FaceSlotId(XChartCubeGeometry.CubeFace.Bottom); + m_AxisY.Direction = XChartAxisDirection.AlongT; + m_AxisY.Dimension = 1; + } + if (m_AxisZ != null) + { + m_AxisZ.SlotId = XChartCubeGeometry.FaceSlotId(XChartCubeGeometry.CubeFace.Left); + m_AxisZ.Direction = XChartAxisDirection.AlongT; + m_AxisZ.Dimension = 2; + } + } + + protected override void OnChartInitialized() => ApplySettings(); + + /// 刷新时把本组件的旋钮推给工具(正常刷新与强制刷新共用这一条) + protected override void OnChartRefresh(bool force) => ApplySettings(); + + protected override void OnResetRender() + { + // 渲染重置:让示例点重新生成一遍(验证重排) + m_SamplePoints = null; + } + + protected override void OnChartValidated() => ApplySettings(); + + private void ApplySettings() + { + ApplySpace(); + ApplyMeshBg(); + ApplyWireframe(); + ApplyAxes(); + ApplyVolume(); + ApplyPoints(); + } + + private void ApplyAxes() + { + ApplyOneAxis(m_AxisX, m_AxisLabelFormat); + ApplyOneAxis(m_AxisY, m_AxisLabelFormat); + ApplyOneAxis(m_AxisZ, m_AxisLabelFormat); + } + + private void ApplyOneAxis(ChartToolAxis axis, string format) + { + if (axis == null) return; + axis.SetVisible(m_ShowAxes); + axis.LabelFormat = format; + axis.MarkDirty(); + } + + private void ApplyVolume() + { + if (m_Cylinder != null) + { + m_Cylinder.SetVisible(m_ShowCylinder); + m_Cylinder.SegmentCount = m_CylinderSegments; + m_Cylinder.Radius = m_CylinderRadius; + m_Cylinder.MarkDirty(); + } + if (m_Arrows != null) + { + m_Arrows.SetVisible(m_ShowArrows); + m_Arrows.MarkDirty(); + } + } + + private void ApplySpace() + { + var space = Space; + if (space != null) + { + space.Rotation = ConsumeViewPreset(); + space.HalfEdge = m_HalfSize; + space.SizeMode = m_SizeMode; + space.MarkProjectionDirty(); + } + + // 背景和线框默认恒等变换,和空间严丝合缝;散点自己也没额外偏移 + if (m_MeshBg != null) m_MeshBg.MarkDirty(); + if (m_Wireframe != null) m_Wireframe.MarkDirty(); + if (m_Points != null) m_Points.MarkDataDirty(); + } + + private void ApplyMeshBg() + { + if (m_MeshBg == null) return; + + m_MeshBg.FillFaces = m_FillFaces; + m_MeshBg.FillColor = m_FillColor; + m_MeshBg.FillCenterColor = m_FillCenterColor; + m_MeshBg.OnlyVisibleFaces = m_OnlyVisibleFaces; + + m_MeshBg.GridFaces = m_GridFaces; + m_MeshBg.GridColor = m_GridColor; + m_MeshBg.GridThickness = m_GridThickness; + m_MeshBg.GridDivisions = m_GridDivisions; + m_MeshBg.ShowFaceOutline = m_ShowFaceOutline; + } + + private void ApplyWireframe() + { + if (m_Wireframe == null) return; + + m_Wireframe.SetVisible(m_ShowWireframe); + m_Wireframe.FrontEdgeColor = m_FrontEdgeColor; + m_Wireframe.BackEdgeColor = m_BackEdgeColor; + m_Wireframe.EdgeThickness = m_EdgeThickness; + // 这里以前还写一句 m_Wireframe.ShowGridLines = false:"面内网格归 MeshBg"这件事 + // 现在由结构保证(线框工具根本没有格线这条代码路径),不需要每个调用方再声明一遍 + } + + private void ApplyPoints() + { + if (m_Points == null) return; + + m_Points.SetVisible(m_ShowSamplePoints); + m_Points.PointSize = m_PointSize; + m_Points.PointColor = m_PointColor; + m_Points.BorderColor = m_PointBorderColor; + m_Points.PointType = XericLibrary.Runtime.UIGraph.PrimitiveType.Polygon; + m_Points.PointSizeMode = XericLibrary.Runtime.UIGraph.SizeMode.InscribedCircle; + m_Points.SideCount = 8; + + if (!m_ShowSamplePoints) return; + + if (m_SamplePoints == null || m_SamplePoints.Length != m_SamplePointCount) + { + m_SamplePoints = BuildSamplePoints(m_SamplePointCount); + PublishSamples(m_SamplePoints); + } + + // 走数据源那条路:点和轴线读的是同一份记录,不再各拿一份数组 + m_Points.AutoFromData = true; + m_Points.MarkDataDirty(); + } + + /// + /// 把示例数据登记到图共享的序列化数据模型里:每条记录 6 个数值维 + /// [x, y, z, dx, dy, dz]——前三维给散点和轴线,后三维给箭头。 + /// 存进数据模型(而不是只留在内存)才能让"重开预制体数据还在"这件事成立。 + /// + private void PublishSamples(Vector3[] positions) + { + EnsureDataDimensions(); + DataModel.Clear(); + + var values = new float[6]; + for (int i = 0; i < positions.Length; i++) + { + Vector3 p = positions[i]; + values[0] = p.x; + values[1] = p.y; + values[2] = p.z; + // 方向取"绕 Y 轴切向 + 一点上抬",看起来就是一个旋涡场 + values[3] = -p.y; + values[4] = p.x; + values[5] = 0.25f; + DataModel.TryAddRecord(i, values); + } + } + + private void EnsureDataDimensions() + { + if (DataModel.NumericDimensionCount == 6) return; + DataModel.SetDimensions(new System.Collections.Generic.List + { + new XChartDimensionDefinition("x", "X", XChartDimensionKind.Number), + new XChartDimensionDefinition("y", "Y", XChartDimensionKind.Number), + new XChartDimensionDefinition("z", "Z", XChartDimensionKind.Number), + new XChartDimensionDefinition("dx", "dX", XChartDimensionKind.Number), + new XChartDimensionDefinition("dy", "dY", XChartDimensionKind.Number), + new XChartDimensionDefinition("dz", "dZ", XChartDimensionKind.Number), + }); + } + + /// + /// 生成 [-1,1]³ 里的一批示例点。用固定种子的 LCG,不用 UnityEngine.Random—— + /// 编辑期每次重算必须得到同一批点,否则一改旋钮点就乱跳,没法验证。 + /// + private static Vector3[] BuildSamplePoints(int count) + { + var points = new Vector3[Mathf.Max(0, count)]; + uint state = 20261021u; + for (int i = 0; i < points.Length; i++) + { + points[i] = new Vector3(NextUnit(ref state), NextUnit(ref state), NextUnit(ref state)); + } + return points; + } + + private static float NextUnit(ref uint state) + { + state = state * 1664525u + 1013904223u; + return (state >> 8) / (float)(1 << 24) * 2f - 1f; + } + } +} \ No newline at end of file diff --git a/Runtime/XChart/Products/XMeshPreviewChart.cs.meta b/Runtime/XChart/Products/XMeshPreviewChart.cs.meta new file mode 100644 index 0000000..f271cfc --- /dev/null +++ b/Runtime/XChart/Products/XMeshPreviewChart.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 86de4ff965df49a29180f72c3b4c1b8c +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Pseudo3D/ChartToolCubeBg.cs b/Runtime/XChart/Pseudo3D/ChartToolCubeBg.cs index 1f0a536..72a3243 100644 --- a/Runtime/XChart/Pseudo3D/ChartToolCubeBg.cs +++ b/Runtime/XChart/Pseudo3D/ChartToolCubeBg.cs @@ -1,38 +1,39 @@ using System.Collections.Generic; using UnityEngine; using XericLibrary.Runtime.UIGraph; +using XericUI.XChart.Mesh; +using XericUI.XChart.Space; +using XericUI.Core; namespace XericUI.XChart.Pseudo3D { /// - /// 伪 3D 立方体背景工具。 + /// 伪 3D 立方体线框工具(元素显示名 BG Cube Wire)。 /// - /// 使用 UILineRendererV2 绘制: - /// 1. 立方体 12 条棱的线框(前向棱使用实色,后向棱可选半透明) - /// 2. 三个可见面上的轴标线网格 + /// 它只做两件事:12 条棱(相邻面里只要有一个朝向观察者就算前向棱,与面用同一套 + /// 可见性口径)+ 把六个面发布成 mesh.face.<n> 插槽(供轴线/散点取几何)。 + /// 它不画面内格线、也不发布格线插槽——那是 BG Cube Grid + /// ()作为唯一作者的活(规范 §22)。上一版两边都画格线、还都往 + /// 同一批插槽 id 上发布,于是"关掉一边、另一边又把线显示回来",看起来就像开关反了 + /// (他 2026-10-25 现场报的两条症状是同一个结构问题的两个面)。 /// - /// 3D 坐标系统: - /// 立方体中心在原点,半边长 1(即 [-1, 1] 范围)。 - /// 通过 pitch/yaw 旋转后进行正交投影(丢弃 Z 轴)得到 2D UI 坐标。 - /// 最终通过 scale + offset 映射到 RectTransform 的像素空间。 + /// 几何与投影全部来自 与 , + /// 投影权威来自 (本类不自带顶点/面/棱表,也不自己算投影): + /// / 是对外的投影出口, + /// 数据类工具靠它对齐到同一空间。 /// - /// 子节点结构: - /// [ChartTool_CubeBg] - /// └─ CubeRenderer (UILineRendererV2) + /// 旋转是一个四元数,不是两轴角度;尺寸是半边长,默认口径下它不随旋转变化 + /// (旧版按投影包围盒 fit,转起来会越转越小)。理由与换算见 。 + /// + /// 子节点结构:[BG Cube Wire] → CubeEdgeRenderer (UILineRendererV2) /// - [AddComponentMenu("Xeric/XChart/Pseudo3D/Cube Background Tool")] + [AddComponentMenu(XericRegistrationPaths.Chart + "/Pseudo3D/Cube Wire Background Tool")] public class ChartToolCubeBg : XChartToolBase { // ── 外观配置 ────────────────────────────────────────────── - /// 立方体半边长(UI 像素) - public float CubeHalfSize { get; set; } = 150f; - - /// 俯仰角(绕 X 轴旋转,度数) - public float Pitch { get; set; } = 25f; - - /// 偏航角(绕 Y 轴旋转,度数) - public float Yaw { get; set; } = -30f; + /// 线框自己的变换(立方体局部单位);默认恒等,即和图的空间重合 + public XChartToolTransform Transform { get; set; } = XChartToolTransform.Identity; /// 前向棱颜色 public Color FrontEdgeColor { get; set; } = new Color(0.7f, 0.7f, 0.7f, 1f); @@ -43,220 +44,129 @@ namespace XericUI.XChart.Pseudo3D /// 棱线宽度 public float EdgeThickness { get; set; } = 2f; - /// 网格线颜色 - public Color GridLineColor { get; set; } = new Color(0.5f, 0.5f, 0.5f, 0.3f); - - /// 网格线宽度 - public float GridLineThickness { get; set; } = 1f; - - /// 每轴网格分割数 - public int GridDivisions { get; set; } = 5; - /// 是否显示后向棱 public bool ShowBackEdges { get; set; } = true; - /// 是否显示网格标线 - public bool ShowGridLines { get; set; } = true; - - /// 立方体中心偏移 - public Vector2 CenterOffset { get; set; } = Vector2.zero; - // ── 内部组件 ────────────────────────────────────────────── /// 棱线渲染器 public UILineRendererV2 EdgeRenderer { get; private set; } - /// 网格线渲染器 - public UILineRendererV2 GridRenderer { get; private set; } - - // ── 3D 管线状态 ────────────────────────────────────────── - - // 8 个立方体顶点(中心在原点,半边长 1) - private static readonly Vector3[] s_CubeVertices = new Vector3[] - { - new Vector3(-1, -1, -1), // 0: 后下左 - new Vector3( 1, -1, -1), // 1: 后下右 - new Vector3( 1, 1, -1), // 2: 后上右 - new Vector3(-1, 1, -1), // 3: 后上左 - new Vector3(-1, -1, 1), // 4: 前下左 - new Vector3( 1, -1, 1), // 5: 前下右 - new Vector3( 1, 1, 1), // 6: 前上右 - new Vector3(-1, 1, 1), // 7: 前上左 - }; - - // 12 条棱(顶点索引对) - private static readonly int[,] s_CubeEdges = new int[12, 2] - { - {0,1}, {1,2}, {2,3}, {3,0}, // 后面 - {4,5}, {5,6}, {6,7}, {7,4}, // 前面 - {0,4}, {1,5}, {2,6}, {3,7}, // 连接棱 - }; - - // 6 个面的顶点索引 + 法线 - private struct FaceDef { public int[] verts; public Vector3 normal; } - private static readonly FaceDef[] s_Faces = new FaceDef[] - { - new FaceDef { verts = new int[] {4,5,6,7}, normal = new Vector3(0, 0, 1) }, // 前 - new FaceDef { verts = new int[] {0,1,2,3}, normal = new Vector3(0, 0,-1) }, // 后 - new FaceDef { verts = new int[] {1,5,6,2}, normal = new Vector3(1, 0, 0) }, // 右 - new FaceDef { verts = new int[] {0,4,7,3}, normal = new Vector3(-1,0, 0) }, // 左 - new FaceDef { verts = new int[] {2,6,7,3}, normal = new Vector3(0, 1, 0) }, // 上 - new FaceDef { verts = new int[] {0,1,5,4}, normal = new Vector3(0,-1, 0) }, // 下 - }; - - // 每个面由两个轴定义(用于网格线方向) - private static readonly Vector3[] s_FaceAxisA = new Vector3[] - { - new Vector3(1,0,0), new Vector3(1,0,0), // 前/后: X 轴 - new Vector3(0,1,0), new Vector3(0,1,0), // 右/左: Y 轴 - new Vector3(1,0,0), new Vector3(1,0,0), // 上/下: X 轴 - }; - private static readonly Vector3[] s_FaceAxisB = new Vector3[] - { - new Vector3(0,1,0), new Vector3(0,1,0), // 前/后: Y 轴 - new Vector3(0,0,1), new Vector3(0,0,1), // 右/左: Z 轴 - new Vector3(0,0,1), new Vector3(0,0,1), // 上/下: Z 轴 - }; - // ── 投影状态 ────────────────────────────────────────────── - private Vector3[] m_RotatedVerts = new Vector3[8]; // 旋转后的 3D 顶点 - private Vector2[] m_ProjectedVerts = new Vector2[8]; // 投影后的 2D 顶点 - private bool m_ProjectionDirty = true; + private readonly XChartFaceFrame[] m_FaceFrames = new XChartFaceFrame[XChartCubeGeometry.FaceCount]; + private readonly List m_FrontEdges = new List(24); + private readonly List m_BackEdges = new List(24); - /// 投影版本号(每次投影矩阵变化时递增,供外部检测变化) - public int ProjectionVersion { get; private set; } = 0; + private ChartToolSpace m_Space; + private Matrix4x4 m_Composed = Matrix4x4.identity; + private int m_LastSpaceVersion = -1; + private bool m_Dirty = true; - private Matrix4x4 m_RotationMatrix; - private float m_Scale; - private Vector2 m_Offset; + /// 发布插槽用的复用缓冲(一个面的四角 = 12 个值) + private readonly float[] m_SlotValues = new float[12]; + + // 本帧提交了多少:线框"整块不见了"要能分清是没空间、没提交还是提交了 0 条 + private int m_EdgesDrawn; + private int m_FacesPublished; + + // ── 对外出口 ────────────────────────────────────────────── + + /// 六个可见性判定共用的面帧(图表局部像素) + public XChartFaceFrame GetFaceFrame(XChartCubeGeometry.CubeFace face) + { + UpdateProjection(); + return m_FaceFrames[(int)face]; + } + + /// 本元素的变换变了(或想强制重取空间)时调用 + public void MarkDirty() => m_Dirty = true; + + /// 线框定义立方体的面(发布 mesh.face.* 四角)⇒ 归定义组、最先跑(规范 §11.4) + public override XChartToolCategory Category => XChartToolCategory.Definition; + + /// 线框用的复合矩阵。数据元素要落到同一个空间就问它要,别自己再算一遍 + public Matrix4x4 ComposedMatrix { get { UpdateProjection(); return m_Composed; } } + + /// 空间工具(投影权威)。渲染时现找,所以注册先后顺序不影响正确性 + public ChartToolSpace Space + { + get + { + m_Space = Context?.Space; + return m_Space; + } + } + + // ── 插槽发布 ────────────────────────────────────────────── + + /// + /// 把六个面发布成 Quad3D 插槽:用哪个网格元素都得能供面给轴线, + /// 否则"轴线跟随网格"会因为图里只放了线框而静默回落(报表里 frame=cube 就是那个信号)。 + /// 只发四角、不发格线:格线由画它的那个元素发布(两个发布者会抢同一批 id,见规范 §22)。 + /// + private void PublishFaceSlots() + { + IXChartSlotBoard board = Context?.Slots; + m_FacesPublished = 0; + if (board == null) return; + + for (int i = 0; i < XChartCubeGeometry.FaceCount; i++) + { + var face = (XChartCubeGeometry.CubeFace)i; + Vector3 c00, c01, c11, c10; + XChartCubeGeometry.GetFaceCorners(face, out c00, out c01, out c11, out c10); + + m_SlotValues[0] = c00.x; m_SlotValues[1] = c00.y; m_SlotValues[2] = c00.z; + m_SlotValues[3] = c01.x; m_SlotValues[4] = c01.y; m_SlotValues[5] = c01.z; + m_SlotValues[6] = c11.x; m_SlotValues[7] = c11.y; m_SlotValues[8] = c11.z; + m_SlotValues[9] = c10.x; m_SlotValues[10] = c10.y; m_SlotValues[11] = c10.z; + + board.Publish(XChartCubeGeometry.FaceSlotId(face), XChartSlotMode.Quad3D, + XChartSlotAccess.ReadOnly, m_SlotValues, out string _); + m_FacesPublished++; + } + } // ── 初始化 ──────────────────────────────────────────────── protected override void OnInitialize() { - // 创建棱线渲染器 EdgeRenderer = CreateChildComponent("CubeEdgeRenderer"); if (EdgeRenderer != null) { EdgeRenderer.defaultColor = FrontEdgeColor; EdgeRenderer.defaultThickness = EdgeThickness; - var rt = EdgeRenderer.rectTransform; - rt.anchorMin = Vector2.zero; - rt.anchorMax = Vector2.one; - rt.offsetMin = Vector2.zero; - rt.offsetMax = Vector2.zero; - } - - // 创建网格线渲染器 - GridRenderer = CreateChildComponent("CubeGridRenderer"); - if (GridRenderer != null) - { - GridRenderer.defaultColor = GridLineColor; - GridRenderer.defaultThickness = GridLineThickness; - var rt = GridRenderer.rectTransform; - rt.anchorMin = Vector2.zero; - rt.anchorMax = Vector2.one; - rt.offsetMin = Vector2.zero; - rt.offsetMax = Vector2.zero; + StretchToRoot(EdgeRenderer); } SetVisible(true); } - // ── 更新投影矩阵 ────────────────────────────────────────── + private static void StretchToRoot(UILineRendererV2 renderer) + { + var rt = renderer.rectTransform; + rt.anchorMin = Vector2.zero; + rt.anchorMax = Vector2.one; + rt.offsetMin = Vector2.zero; + rt.offsetMax = Vector2.zero; + } + + // ── 投影 ────────────────────────────────────────────────── private void UpdateProjection() { - if (!m_ProjectionDirty) return; - m_ProjectionDirty = false; + var space = Space; + if (space == null) return; + if (!m_Dirty && space.ProjectionVersion == m_LastSpaceVersion) return; + m_Dirty = false; + m_LastSpaceVersion = space.ProjectionVersion; - // 1. 构建旋转矩阵:先绕 X 轴(pitch),再绕 Y 轴(yaw) - float pitchRad = Pitch * Mathf.Deg2Rad; - float yawRad = Yaw * Mathf.Deg2Rad; - m_RotationMatrix = Matrix4x4.Rotate( - Quaternion.Euler(pitchRad * Mathf.Rad2Deg, yawRad * Mathf.Rad2Deg, 0)); - - // 2. 旋转所有顶点 - for (int i = 0; i < 8; i++) - m_RotatedVerts[i] = m_RotationMatrix.MultiplyPoint3x4(s_CubeVertices[i]); - - // 3. 计算投影后的 2D 范围(丢弃 Z) - float minX = float.MaxValue, maxX = float.MinValue; - float minY = float.MaxValue, maxY = float.MinValue; - for (int i = 0; i < 8; i++) - { - float px = m_RotatedVerts[i].x; - float py = m_RotatedVerts[i].y; - if (px < minX) minX = px; - if (px > maxX) maxX = px; - if (py < minY) minY = py; - if (py > maxY) maxY = py; - } - - // 4. 计算缩放和偏移,使立方体适配 CubeHalfSize - float rangeX = maxX - minX; - float rangeY = maxY - minY; - float maxRange = Mathf.Max(rangeX, rangeY); - m_Scale = (maxRange > 0.001f) ? (CubeHalfSize * 2f / maxRange) : 1f; - - // 中心对齐到 CenterOffset - float centerX = (minX + maxX) * 0.5f; - float centerY = (minY + maxY) * 0.5f; - m_Offset = new Vector2( - CenterOffset.x - centerX * m_Scale, - CenterOffset.y - centerY * m_Scale); - - // 5. 计算最终投影坐标 - for (int i = 0; i < 8; i++) - { - m_ProjectedVerts[i] = new Vector2( - m_RotatedVerts[i].x * m_Scale + m_Offset.x, - m_RotatedVerts[i].y * m_Scale + m_Offset.y); - } + m_Composed = space.Compose(Transform); + space.BuildFaceFrames(m_FaceFrames, m_Composed); + PublishFaceSlots(); } - /// 标记投影需要重新计算 - public void MarkProjectionDirty() - { - m_ProjectionDirty = true; - ProjectionVersion++; - } - - // ── 3D 投影辅助 ────────────────────────────────────────── - - /// 将 3D 点投影到 2D - public Vector2 ProjectPoint3D(Vector3 point3d) - { - UpdateProjection(); - Vector3 rotated = m_RotationMatrix.MultiplyPoint3x4(point3d); - return new Vector2(rotated.x * m_Scale + m_Offset.x, - rotated.y * m_Scale + m_Offset.y); - } - - /// 批量投影 3D 点到 2D - public Vector2[] ProjectPoints3D(Vector3[] points3d) - { - UpdateProjection(); - var result = new Vector2[points3d.Length]; - for (int i = 0; i < points3d.Length; i++) - { - Vector3 rotated = m_RotationMatrix.MultiplyPoint3x4(points3d[i]); - result[i] = new Vector2(rotated.x * m_Scale + m_Offset.x, - rotated.y * m_Scale + m_Offset.y); - } - return result; - } - - /// 获取当前旋转矩阵 - public Matrix4x4 RotationMatrix => m_RotationMatrix; - - /// 获取当前缩放 - public float Scale => m_Scale; - - /// 获取当前偏移 - public Vector2 Offset => m_Offset; - // ── 渲染 ────────────────────────────────────────────────── public override void OnRender() @@ -265,196 +175,87 @@ namespace XericUI.XChart.Pseudo3D if (EdgeRenderer == null) return; UpdateProjection(); - - // 绘制棱线 DrawEdges(); - - // 绘制网格标线 - if (GridRenderer != null) - { - if (ShowGridLines) - { - DrawGridLines(); - } - else - { - GridRenderer.ClearAll(); - } - } } - // ── 棱线绘制 ────────────────────────────────────────────── - private void DrawEdges() { EdgeRenderer.ClearAll(); + m_FrontEdges.Clear(); + m_BackEdges.Clear(); + m_EdgesDrawn = 0; - // 确定前向棱:棱的两个顶点中,Z 值较大的为前向 - // 更准确:棱所属的面中,法线 Z > 0 的面为可见面 - // 简单方法:棱的两个顶点的 rotated Z 平均值 > 0 为前向 - var frontVerts = new List(); - var backVerts = new List(); - - for (int e = 0; e < 12; e++) + for (int e = 0; e < XChartCubeGeometry.EdgeCount; e++) { - int v0 = s_CubeEdges[e, 0]; - int v1 = s_CubeEdges[e, 1]; - float avgZ = (m_RotatedVerts[v0].z + m_RotatedVerts[v1].z) * 0.5f; - bool isFront = avgZ >= 0; - - var list = isFront ? frontVerts : backVerts; - int startIdx = list.Count; + bool isFront = XChartCubeGeometry.IsEdgeVisible(m_Composed, e); + var list = isFront ? m_FrontEdges : m_BackEdges; + Color color = isFront ? FrontEdgeColor : BackEdgeColor; list.Add(new LineVertexData { - position = m_ProjectedVerts[v0], - color = isFront ? FrontEdgeColor : BackEdgeColor, + position = Space.Project(XChartCubeGeometry.Vertices[XChartCubeGeometry.Edges[e, 0]], m_Composed), + color = color, thickness = EdgeThickness, userData = Vector4.zero, }); list.Add(new LineVertexData { - position = m_ProjectedVerts[v1], - color = isFront ? FrontEdgeColor : BackEdgeColor, + position = Space.Project(XChartCubeGeometry.Vertices[XChartCubeGeometry.Edges[e, 1]], m_Composed), + color = color, thickness = EdgeThickness, userData = Vector4.zero, }); } - // 先画后向棱(在底层),再画前向棱(在上层) - if (ShowBackEdges && backVerts.Count > 0) - { - // 每两个顶点构成一条线段 - for (int i = 0; i < backVerts.Count; i += 2) - { - EdgeRenderer.DrawLine( - backVerts[i].position, - backVerts[i + 1].position, - backVerts[i].color, - backVerts[i].thickness); - } - } + // 先画后向棱(在底层),再画前向棱 + if (ShowBackEdges) + DrawSegments(m_BackEdges); + DrawSegments(m_FrontEdges); + } - for (int i = 0; i < frontVerts.Count; i += 2) + private void DrawSegments(List segments) + { + for (int i = 0; i + 1 < segments.Count; i += 2) { EdgeRenderer.DrawLine( - frontVerts[i].position, - frontVerts[i + 1].position, - frontVerts[i].color, - frontVerts[i].thickness); + segments[i].position, + segments[i + 1].position, + segments[i].color, + segments[i].thickness); + m_EdgesDrawn++; } } - // ── 网格标线绘制 ────────────────────────────────────────── + // ── 自述读数 ────────────────────────────────────────────── - private void DrawGridLines() +#if UNITY_EDITOR + /// + /// 线框这一帧做了什么,全写在报表这一行里:edges= 提交了几条棱、 + /// faces= 发布了几个面、space= 有没有投影权威、renderer= 渲染器在不在位。 + /// "线框整个不见了"这四件事在画面上长得一样,只有这一行分得清(规范 §22)。 + /// + internal override void AppendDebugLine(System.Text.StringBuilder sb) { - GridRenderer.ClearAll(); - - // 获取 3 个可见面(法线 Z 值最大的 3 个面) - var visibleFaces = GetVisibleFaces(); - if (visibleFaces.Count == 0) return; - - foreach (int faceIdx in visibleFaces) - { - DrawGridLinesOnFace(faceIdx); - } - } - - /// 获取可见面索引列表(按可见度排序,最多 3 个) - private List GetVisibleFaces() - { - var result = new List(3); - var faceScores = new (int index, float score)[6]; - - for (int i = 0; i < 6; i++) - { - // 将面法线旋转到当前视角 - Vector3 rotatedNormal = m_RotationMatrix.MultiplyVector(s_Faces[i].normal); - // Z 分量越大,越面向用户 - faceScores[i] = (i, rotatedNormal.z); - } - - // 按 Z 值降序排列(Z 越大越面向用户) - System.Array.Sort(faceScores, (a, b) => b.score.CompareTo(a.score)); - - // 取前 3 个且 Z > 0 的面 - for (int i = 0; i < 3 && faceScores[i].score > 0; i++) - result.Add(faceScores[i].index); - - return result; - } - - /// 在指定面上绘制网格线 - private void DrawGridLinesOnFace(int faceIdx) - { - var face = s_Faces[faceIdx]; - Vector3 axisA = s_FaceAxisA[faceIdx]; - Vector3 axisB = s_FaceAxisB[faceIdx]; - - // 面的四个顶点(在立方体局部坐标中) - Vector3 v0 = s_CubeVertices[face.verts[0]]; - Vector3 v1 = s_CubeVertices[face.verts[1]]; - Vector3 v2 = s_CubeVertices[face.verts[2]]; - Vector3 v3 = s_CubeVertices[face.verts[3]]; - - // 面的范围 - float minA = float.MaxValue, maxA = float.MinValue; - float minB = float.MaxValue, maxB = float.MinValue; - - // 计算顶点在轴上的投影 - float GetAxisValue(Vector3 v, Vector3 axis) => Vector3.Dot(v, axis); - - for (int i = 0; i < 4; i++) - { - var v = s_CubeVertices[face.verts[i]]; - float va = GetAxisValue(v, axisA); - float vb = GetAxisValue(v, axisB); - if (va < minA) minA = va; - if (va > maxA) maxA = va; - if (vb < minB) minB = vb; - if (vb > maxB) maxB = vb; - } - - // 沿 A 轴画线(平行于 B 轴) - float stepA = (maxA - minA) / GridDivisions; - float stepB = (maxB - minB) / GridDivisions; - - // 沿 A 轴方向的网格线 - for (int i = 0; i <= GridDivisions; i++) - { - float aVal = minA + i * stepA; - // 线的两个端点 - Vector3 p1 = face.normal + axisA * aVal + axisB * minB; - Vector3 p2 = face.normal + axisA * aVal + axisB * maxB; - - Vector2 pp1 = ProjectPoint3D(p1); - Vector2 pp2 = ProjectPoint3D(p2); - - // 只绘制落在面范围内的线 - GridRenderer.DrawLine(pp1, pp2, GridLineColor, GridLineThickness); - } - - // 沿 B 轴方向的网格线 - for (int i = 0; i <= GridDivisions; i++) - { - float bVal = minB + i * stepB; - Vector3 p1 = face.normal + axisA * minA + axisB * bVal; - Vector3 p2 = face.normal + axisA * maxA + axisB * bVal; - - Vector2 pp1 = ProjectPoint3D(p1); - Vector2 pp2 = ProjectPoint3D(p2); - - GridRenderer.DrawLine(pp1, pp2, GridLineColor, GridLineThickness); - } + base.AppendDebugLine(sb); + int valid = 0; + for (int i = 0; i < m_FaceFrames.Length; i++) + if (m_FaceFrames[i].IsValid) valid++; + sb.Append(" edges=").Append(m_EdgesDrawn) + .Append(" faces=").Append(m_FacesPublished) + .Append(" frames=").Append(valid).Append('/').Append(m_FaceFrames.Length) + .Append(" backEdges=").Append(ShowBackEdges ? "on" : "off") + .Append(" space=").Append(Context != null && Context.Space != null ? "ok" : "NULL") + .Append(" renderer=").Append(EdgeRenderer == null ? "NULL" : "ok"); } +#endif // ── 清理 ────────────────────────────────────────────────── protected override void OnDispose() { EdgeRenderer = null; - GridRenderer = null; + m_FrontEdges.Clear(); + m_BackEdges.Clear(); } } } diff --git a/Runtime/XChart/Pseudo3D/ChartToolScatterPoints.cs b/Runtime/XChart/Pseudo3D/ChartToolScatterPoints.cs index a5a7250..4411c8d 100644 --- a/Runtime/XChart/Pseudo3D/ChartToolScatterPoints.cs +++ b/Runtime/XChart/Pseudo3D/ChartToolScatterPoints.cs @@ -1,132 +1,115 @@ using UnityEngine; using XericLibrary.Runtime.UIGraph; using PrimitiveType = XericLibrary.Runtime.UIGraph.PrimitiveType; +using XericUI.Core; +using XericUI.XChart.Mesh; +using XericUI.XChart.Space; namespace XericUI.XChart.Pseudo3D { /// - /// 散点渲染工具。 + /// 散点元素:把 3D 数据点画进图的空间里。 /// - /// 使用 XScatterPointRenderer 渲染 3D 散点数据在 2D 平面上的投影。 - /// 数据点从 3D 立方体空间投影到 UI 坐标,每个点用一个图元表示。 + /// 数据从哪儿来:只认图表给的中转接口 + /// ( 为真时按维度下标逐条取,范围用聚合量的 min/max)。 + /// 元素不直接摸记录数组,所以以后要换桶/环形缓冲也不用改这里。 + /// 为假时用脚本喂进来的 (立方体单位)。 + /// + /// 投影从哪儿来:图里的 ,和背景/线框/轴线同一个。 + /// 所以"点落在盒子里"是结构保证——数据归一化到 [0,1] 再映到立方体局部 [-1,1], + /// 然后走和背景一样的 基变换 ∘ 工具变换。 + /// + /// 什么时候重算:数据版本号或空间版本号变了才重投影,其余帧什么都不做。 /// /// 子节点结构: - /// [ChartTool_ScatterPoints] + /// [ScatterPoints] /// └─ PointRenderer (XScatterPointRenderer) /// - [AddComponentMenu("Xeric/XChart/Pseudo3D/Scatter Points Tool")] + [AddComponentMenu(XericRegistrationPaths.Chart + "/Pseudo3D/Scatter Points Tool")] public class ChartToolScatterPoints : XChartToolBase { - // ── 配置 ────────────────────────────────────────────────── + // ── 数据装配 ────────────────────────────────────────────── - /// 点的大小(像素) - public float PointSize - { - get => m_PointSize; - set { m_PointSize = Mathf.Max(0.5f, value); if (IsInitialized) SyncShapeParams(); } - } + /// 真=从图的数据源按维度下标读;假=用 喂的点 + public bool AutoFromData { get; set; } = true; + + /// 三个维度在数据源里的下标(绑定:点云画哪三路数据;范围归 chart 的维度行) + public int DimensionX { get; set; } + public int DimensionY { get; set; } = 1; + public int DimensionZ { get; set; } = 2; + + /// 点云自己的变换(立方体单位),用来把点整体缩进盒子里或挪一角 + public XChartToolTransform Transform { get; set; } = XChartToolTransform.Identity; + + /// + /// 桶采样目标点数:0 或 ≥ 记录数=不聚合;否则把记录按桶归约成这么多个点。 + /// 目的是"几万条记录也只画 N 个点",同时让每个点代表它那一段时间。 + /// + public int BucketTargetPoints { get; set; } + + /// 桶内取哪个统计量当这个点(抽稀 First/Last 不造新值;趋势 Mean/Median;包络 Minimum/Maximum) + public XChartAggregateKind BucketReduce { get; set; } = XChartAggregateKind.Last; + + // ── 外观 ────────────────────────────────────────────────── + + public float PointSize { get => m_PointSize; set { m_PointSize = Mathf.Max(0.5f, value); if (IsInitialized) SyncShapeParams(); } } private float m_PointSize = 8f; - /// 图元类型 - public PrimitiveType PointType - { - get => m_PointType; - set { m_PointType = value; if (IsInitialized) SyncShapeParams(); } - } + public PrimitiveType PointType { get => m_PointType; set { m_PointType = value; if (IsInitialized) SyncShapeParams(); } } private PrimitiveType m_PointType = PrimitiveType.Polygon; - /// 尺寸模式 - public SizeMode SizeMode - { - get => m_SizeMode; - set { m_SizeMode = value; if (IsInitialized) SyncShapeParams(); } - } - private SizeMode m_SizeMode = SizeMode.InscribedCircle; + public SizeMode PointSizeMode { get => m_PointSizeMode; set { m_PointSizeMode = value; if (IsInitialized) SyncShapeParams(); } } + private SizeMode m_PointSizeMode = SizeMode.InscribedCircle; - /// 填充颜色 - public Color PointColor - { - get => m_PointColor; - set { m_PointColor = value; if (IsInitialized) SyncShapeParams(); } - } + public Color PointColor { get => m_PointColor; set { m_PointColor = value; if (IsInitialized) SyncShapeParams(); } } private Color m_PointColor = new Color(0.33f, 0.67f, 1f, 1f); - /// 中心渐变颜色 - public Color CenterColor - { - get => m_CenterColor; - set { m_CenterColor = value; if (IsInitialized) SyncShapeParams(); } - } + public Color CenterColor { get => m_CenterColor; set { m_CenterColor = value; if (IsInitialized) SyncShapeParams(); } } private Color m_CenterColor = Color.white; - /// 边框颜色 - public Color BorderColor - { - get => m_BorderColor; - set { m_BorderColor = value; if (IsInitialized) SyncShapeParams(); } - } + public Color BorderColor { get => m_BorderColor; set { m_BorderColor = value; if (IsInitialized) SyncShapeParams(); } } private Color m_BorderColor = new Color(0.2f, 0.2f, 0.2f, 1f); - /// 边框宽度 - public float BorderThickness - { - get => m_BorderThickness; - set { m_BorderThickness = Mathf.Max(0f, value); if (IsInitialized) SyncShapeParams(); } - } + public float BorderThickness { get => m_BorderThickness; set { m_BorderThickness = Mathf.Max(0f, value); if (IsInitialized) SyncShapeParams(); } } private float m_BorderThickness = 1f; - /// 多边形边数 - public int SideCount - { - get => m_SideCount; - set { m_SideCount = Mathf.Max(3, value); if (IsInitialized) SyncShapeParams(); } - } + public int SideCount { get => m_SideCount; set { m_SideCount = Mathf.Max(3, value); if (IsInitialized) SyncShapeParams(); } } private int m_SideCount = 8; - /// 倒角大小 - public float ChamferSize - { - get => m_ChamferSize; - set { m_ChamferSize = Mathf.Clamp01(value); if (IsInitialized) SyncShapeParams(); } - } - private float m_ChamferSize = 0f; + public float ChamferSize { get => m_ChamferSize; set { m_ChamferSize = Mathf.Clamp01(value); if (IsInitialized) SyncShapeParams(); } } + private float m_ChamferSize; - /// 图元旋转角度 - public float PointAngle - { - get => m_PointAngle; - set { m_PointAngle = value; if (IsInitialized) SyncShapeParams(); } - } - private float m_PointAngle = 0f; + public float PointAngle { get => m_PointAngle; set { m_PointAngle = value; if (IsInitialized) SyncShapeParams(); } } + private float m_PointAngle; - /// 是否使用颜色渐变(按数据范围) - public bool EnableColorMapping { get; set; } = false; + /// 按某一维的数值做颜色渐变 + public bool EnableColorMapping { get; set; } - /// 颜色映射渐变起始色 public Color ColorMapMin { get; set; } = Color.blue; - - /// 颜色映射渐变结束色 public Color ColorMapMax { get; set; } = Color.red; - /// 颜色映射轴(0=X, 1=Y, 2=Z) - public int ColorMapAxis { get; set; } = 2; + /// 拿哪一维的数值做映射 + public int ColorMapDimension { get; set; } = 2; - // ── 内部组件 ────────────────────────────────────────────── + // ── 内部 ────────────────────────────────────────────────── - /// 散点渲染器 public XScatterPointRenderer PointRenderer { get; private set; } - /// 对 CubeBg 工具的引用(用于投影) - public ChartToolCubeBg CubeBg { get; set; } + private Matrix4x4 m_Composed = Matrix4x4.identity; - // ── 数据缓存 ────────────────────────────────────────────── + private Vector3[] m_CubePoints = new Vector3[0]; + /// 中位数归约用的暂存:长度按记录数上限,渲染路径里不分配 + private double[] m_BucketScratch; + /// 本帧桶数(=-1 表示还没算过);与源记录数一起进报表——"少画了多少"要能看到 + private int m_BucketCount = -1; + private int m_SourceRecords; + private Vector2[] m_Projected = new Vector2[0]; + private Color[] m_PointColors; + private float[] m_ColorValues; - private Vector3[] m_NormalizedPoints = new Vector3[0]; - private Vector2[] m_ProjectedPoints = new Vector2[0]; - private bool m_DataDirty = true; - private int m_LastProjectionVersion = -1; - - // ── 初始化 ──────────────────────────────────────────────── + private bool m_PointsDirty = true; + private long m_LastDataVersion = -1; + private int m_LastSpaceVersion = -1; protected override void OnInitialize() { @@ -139,17 +122,14 @@ namespace XericUI.XChart.Pseudo3D rt.offsetMin = Vector2.zero; rt.offsetMax = Vector2.zero; } - SyncShapeParams(); } - // ── 形状参数同步 ────────────────────────────────────────── - private void SyncShapeParams() { if (PointRenderer == null) return; PointRenderer.pointType = m_PointType; - PointRenderer.sizeMode = m_SizeMode; + PointRenderer.sizeMode = m_PointSizeMode; PointRenderer.pointSize = m_PointSize; PointRenderer.fillColor = m_PointColor; PointRenderer.centerColor = m_CenterColor; @@ -160,101 +140,212 @@ namespace XericUI.XChart.Pseudo3D PointRenderer.chamferSegments = 4; PointRenderer.angle = m_PointAngle; - // 如果已有数据,触发形状重建 - if (m_NormalizedPoints.Length > 0) - { - PointRenderer.UpdateShapeParams(); - } + if (m_CubePoints.Length > 0) PointRenderer.UpdateShapeParams(); } - // ── 数据更新 ────────────────────────────────────────────── - - /// - /// 设置要渲染的 3D 点(归一化到 [-1, 1] 立方体空间)。 - /// - public void SetNormalizedPoints(Vector3[] normalizedPoints) + /// 脚本喂点(立方体单位,[-1,1] 就是盒子内部)。配合 =false 用 + public void SetCubePoints(Vector3[] cubePoints) { - m_NormalizedPoints = normalizedPoints ?? new Vector3[0]; - m_ProjectedPoints = new Vector2[m_NormalizedPoints.Length]; - m_DataDirty = true; + m_CubePoints = cubePoints ?? new Vector3[0]; + m_Projected = new Vector2[m_CubePoints.Length]; + m_PointColors = null; + m_ColorValues = null; + m_BucketCount = 0; // 脚本喂点这条路没有桶 + m_SourceRecords = m_CubePoints.Length; + m_PointsDirty = true; } - /// 标记数据需要重新投影 - public void MarkDataDirty() - { - m_DataDirty = true; - } + /// 数据或变换变了(版本号比对才是真判据,这里只负责"再算一次") + public void MarkDataDirty() => m_PointsDirty = true; // ── 渲染 ────────────────────────────────────────────────── public override void OnRender() { base.OnRender(); - if (PointRenderer == null || CubeBg == null) return; - if (m_NormalizedPoints.Length == 0) return; + if (PointRenderer == null) return; - bool projectionChanged = CubeBg.ProjectionVersion != m_LastProjectionVersion; + var space = Context?.Space; + if (space == null) return; - // 如果数据脏了或立方体投影发生了变化,重新投影所有点 - if (m_DataDirty || projectionChanged) + bool spaceChanged = space.ProjectionVersion != m_LastSpaceVersion; + bool dataChanged = Data != null && Data.Version != m_LastDataVersion; + if (!m_PointsDirty && !spaceChanged && !dataChanged) return; + + if (spaceChanged || dataChanged) m_PointsDirty = true; + m_LastSpaceVersion = space.ProjectionVersion; + m_LastDataVersion = Data != null ? Data.Version : -1; + m_Composed = space.Compose(Transform); + + if (m_PointsDirty) { - m_LastProjectionVersion = CubeBg.ProjectionVersion; - - // 使用 CubeBg 的投影能力将 3D 点投影到 2D - for (int i = 0; i < m_NormalizedPoints.Length; i++) - { - m_ProjectedPoints[i] = CubeBg.ProjectPoint3D(m_NormalizedPoints[i]); - } - - // 颜色映射 - if (EnableColorMapping) - { - ApplyColorMapping(); - } - - // 批量更新到渲染器 - if (EnableColorMapping && m_PointColors != null) - { - PointRenderer.SetPoints(m_ProjectedPoints, m_PointColors); - } - else - { - PointRenderer.SetPoints(m_ProjectedPoints); - } - - m_DataDirty = false; + if (AutoFromData) BuildPointsFromDataSource(space); + RebuildProjection(space); + m_PointsDirty = false; } + + if (m_Projected.Length == 0) + { + PointRenderer.ClearAll(); + return; + } + + if (EnableColorMapping && m_PointColors != null) PointRenderer.SetPoints(m_Projected, m_PointColors); + else PointRenderer.SetPoints(m_Projected); } - // ── 颜色映射 ────────────────────────────────────────────── + /// 立方体单位点 → 图表局部像素 + private void RebuildProjection(ChartToolSpace space) + { + if (m_Projected == null || m_Projected.Length != m_CubePoints.Length) + m_Projected = new Vector2[m_CubePoints.Length]; - private Color[] m_PointColors; + for (int i = 0; i < m_CubePoints.Length; i++) + m_Projected[i] = space.Project(m_CubePoints[i], m_Composed); + + if (EnableColorMapping) ApplyColorMapping(); + } + + /// + /// 从数据源逐条取值,按每维范围归一化到 [0,1],再映到立方体局部 [-1,1]。 + /// 范围优先用配置里给的手动范围,没给就用该维的聚合 min/max。 + /// + private void BuildPointsFromDataSource(ChartToolSpace space) + { + var source = Data; + if (source == null || !source.HasData) + { + ClearPoints(); + return; + } + + int count = source.RecordCount; + + // 桶采样:0 或 ≥ 记录数=不聚合(桶数就是记录数,行为与以前完全一致) + int buckets = XChartBucketMath.BucketCount(count, BucketTargetPoints); + m_BucketCount = buckets; + m_SourceRecords = count; + + if (m_CubePoints.Length < buckets) + { + m_CubePoints = new Vector3[buckets]; + m_Projected = new Vector2[buckets]; + } + if (EnableColorMapping && (m_PointColors == null || m_PointColors.Length < buckets)) + m_PointColors = new Color[buckets]; + if (EnableColorMapping && (m_ColorValues == null || m_ColorValues.Length < buckets)) + m_ColorValues = new float[buckets]; + if (BucketReduce == XChartAggregateKind.Median && (m_BucketScratch == null || m_BucketScratch.Length < count)) + m_BucketScratch = new double[count]; + + double minX, maxX, minY, maxY, minZ, maxZ; + ResolveRange(DimensionX, out minX, out maxX); + ResolveRange(DimensionY, out minY, out maxY); + ResolveRange(DimensionZ, out minZ, out maxZ); + double colorMin, colorMax; + ResolveRange(ColorMapDimension, out colorMin, out colorMax); + + int written = 0; + for (int b = 0; b < buckets; b++) + { + int first, end; + if (!XChartBucketMath.TryBucketRange(count, b, buckets, out first, out end)) continue; + + double x, y, z; + if (!XChartBucketMath.TryReduce(source, DimensionX, first, end, BucketReduce, m_BucketScratch, out x) + || !XChartBucketMath.TryReduce(source, DimensionY, first, end, BucketReduce, m_BucketScratch, out y) + || !XChartBucketMath.TryReduce(source, DimensionZ, first, end, BucketReduce, m_BucketScratch, out z)) + { + // 整桶坏值:这个桶不画,也不拿别的桶的值顶替(那会造出一个不在数据里的点) + continue; + } + + m_CubePoints[written] = ChartToolSpace.NormalizedToCube(new Vector3( + Normalize(x, minX, maxX), Normalize(y, minY, maxY), Normalize(z, minZ, maxZ))); + + if (EnableColorMapping) + { + double color; + if (!XChartBucketMath.TryReduce(source, ColorMapDimension, first, end, BucketReduce, m_BucketScratch, out color)) + continue; + m_ColorValues[written] = Normalize(color, colorMin, colorMax); + } + written++; + } + + if (written != m_CubePoints.Length) TrimPoints(written); + } + + private void ClearPoints() + { + m_CubePoints = new Vector3[0]; + m_Projected = new Vector2[0]; + m_PointColors = null; + m_ColorValues = null; + m_BucketCount = 0; + m_SourceRecords = 0; + } + + /// + /// 只保留前 个点:渲染器按数组长度提交, + /// 不裁掉尾巴就会画出一批"上一轮的旧点"。 + /// + private void TrimPoints(int count) + { + System.Array.Resize(ref m_CubePoints, count); + System.Array.Resize(ref m_Projected, count); + if (m_PointColors != null) System.Array.Resize(ref m_PointColors, count); + if (m_ColorValues != null) System.Array.Resize(ref m_ColorValues, count); + } + + /// + /// 显示范围只问上下文要(覆盖优先、否则该维聚合;规则在 )。 + /// 范围本身归 chart 的维度行(数据板块),元素只说要哪一维—— + /// 元素自己再存一份范围就是"点和轴对不上"的来路。 + /// + private void ResolveRange(int dimension, out double min, out double max) + { + var context = Context; + if (context != null && context.TryResolveDomain(dimension, out min, out max)) return; + min = 0.0; + max = 1.0; + } + + private static float Normalize(double value, double min, double max) + { + double span = max - min; + if (span <= 0.0) return 0.5f; + return Mathf.Clamp01((float)((value - min) / span)); + } private void ApplyColorMapping() { - if (m_NormalizedPoints.Length == 0) return; - - if (m_PointColors == null || m_PointColors.Length != m_NormalizedPoints.Length) - m_PointColors = new Color[m_NormalizedPoints.Length]; - - for (int i = 0; i < m_NormalizedPoints.Length; i++) - { - float value = m_NormalizedPoints[i][ColorMapAxis]; - // 从 [-1, 1] 映射到 [0, 1] - float t = Mathf.Clamp01((value + 1f) * 0.5f); - m_PointColors[i] = Color.Lerp(ColorMapMin, ColorMapMax, t); - } + if (m_ColorValues == null || m_PointColors == null) return; + for (int i = 0; i < m_PointColors.Length && i < m_ColorValues.Length; i++) + m_PointColors[i] = Color.Lerp(ColorMapMin, ColorMapMax, m_ColorValues[i]); } - // ── 清理 ────────────────────────────────────────────────── - protected override void OnDispose() { PointRenderer = null; - CubeBg = null; - m_NormalizedPoints = null; - m_ProjectedPoints = null; + m_CubePoints = null; + m_Projected = null; m_PointColors = null; + m_ColorValues = null; } + +#if UNITY_EDITOR + /// 报表里点名这个组件这一帧提交了多少顶点——按点数长网格的元素靠它自证没撞 65535 + internal override void AppendDebugLine(System.Text.StringBuilder sb) + { + base.AppendDebugLine(sb); + sb.Append(" points=").Append(m_CubePoints != null ? m_CubePoints.Length : 0) + .Append(" pointVerts=").Append(PointRenderer != null ? PointRenderer.LiveVertexCount : 0) + // 桶采样读数:画了几个点、源有多少条、取的是哪个统计量——"少画了多少"必须能看到 + .Append(" buckets=").Append(m_BucketCount) + .Append(" records=").Append(m_SourceRecords) + .Append(" reduce=").Append(BucketReduce); + } +#endif } } diff --git a/Runtime/XChart/Pseudo3D/XChartCubeWireConfig.cs b/Runtime/XChart/Pseudo3D/XChartCubeWireConfig.cs new file mode 100644 index 0000000..cef1408 --- /dev/null +++ b/Runtime/XChart/Pseudo3D/XChartCubeWireConfig.cs @@ -0,0 +1,89 @@ +using System; +using UnityEngine; +using XericUI.XChart.Mesh; +using XericUI.XChart.Space; + +namespace XericUI.XChart.Pseudo3D +{ + /// + /// 立方体线框元素的配置(面板上叫 BG Cube Wire)。 + /// + /// 它只管 12 条棱:前向一套色、后向一套色,后向棱可整体关掉。 + /// 面内格线不在这里——那是 (BG Cube Grid)的活。 + /// 上一版两边都能画格线、还都往 mesh.face.*.grid.S/.T 同一批插槽上发布, + /// 于是"关掉一边另一边又亮回来"+"改完别的再刷新一下这边的状态又反了" + /// (他 2026-10-25 现场报的两条症状,同一个结构问题的两个面,规范 §22)。 + /// + /// 姿态/半边长/中心偏移仍归 :投影是 + /// 基变换 ∘ 工具变换,这里只出自己的工具变换。 + /// + /// 为什么单独立一个元素配置:这些旋钮原先是 XPseudo3DScatterChart 的 + /// 图级字段(面板「基础 → 立方体外观」)。渲染参数挂在图上,就有两个后果—— + /// 面板里它不在「工具」下("既然是工具就要放在工具下面"),以及换一张图/加第二个背景时 + /// 那份旋钮并不能复用。搬进元素表后,参数随元素走、脚本注册与配置注册同一条路(规范 §22)。 + /// + [Serializable] + [XChartElement("cube-wire", "BG Cube Wire", 9)] + public sealed class XChartCubeWireConfig : XChartElementConfig + { + [Header("工具变换")] + [SerializeField, Tooltip("线框自己的缩放/旋转/平移。默认恒等——线框就占满图的空间")] + private XChartToolTransform m_Transform = XChartToolTransform.Identity; + + [Header("棱线")] + [SerializeField, Tooltip("前向棱颜色(至少有一端面朝向观察者)")] + private Color m_FrontEdgeColor = new Color(0.7f, 0.7f, 0.7f, 1f); + + [SerializeField, Tooltip("后向棱颜色(两面都背朝观察者的棱);透明度低一点就是\"透过去看到的淡线\"")] + private Color m_BackEdgeColor = new Color(0.4f, 0.4f, 0.4f, 0.4f); + + [SerializeField, Min(0.1f), Tooltip("棱线宽度(像素)")] + private float m_EdgeThickness = 2f; + + [SerializeField, Tooltip("显示后向棱:关掉就只剩看得见的那一面外壳")] + private bool m_ShowBackEdges = true; + + /// 元素在 ToolsRoot 下的名字 + public override string ElementName => "BG Cube Wire"; + + // 脚本入口:写的就是下面这些序列化字段(配置是权威,工具在 ApplyTo 里读它), + // 所以不存在"脚本改了一份、面板显示另一份" + /// 前向棱颜色 + public Color FrontEdgeColor { get => m_FrontEdgeColor; set => m_FrontEdgeColor = value; } + + /// 后向棱颜色 + public Color BackEdgeColor { get => m_BackEdgeColor; set => m_BackEdgeColor = value; } + + /// 棱线宽度 + public float EdgeThickness { get => m_EdgeThickness; set => m_EdgeThickness = Mathf.Max(0.1f, value); } + + /// 是否显示后向棱 + public bool ShowBackEdges { get => m_ShowBackEdges; set => m_ShowBackEdges = value; } + + public override XChartToolBase CreateTool() => new ChartToolCubeBg(); + + public override void ApplyTo(XChartToolBase tool) + { + if (!(tool is ChartToolCubeBg wire)) return; + + wire.Transform = m_Transform; + wire.FrontEdgeColor = m_FrontEdgeColor; + wire.BackEdgeColor = m_BackEdgeColor; + wire.EdgeThickness = m_EdgeThickness; + wire.ShowBackEdges = m_ShowBackEdges; + + wire.MarkDirty(); + } + + public override void CaptureFrom(XChartToolBase tool) + { + if (!(tool is ChartToolCubeBg wire)) return; + + m_Transform = wire.Transform; + m_FrontEdgeColor = wire.FrontEdgeColor; + m_BackEdgeColor = wire.BackEdgeColor; + m_EdgeThickness = wire.EdgeThickness; + m_ShowBackEdges = wire.ShowBackEdges; + } + } +} diff --git a/Runtime/XChart/Pseudo3D/XChartCubeWireConfig.cs.meta b/Runtime/XChart/Pseudo3D/XChartCubeWireConfig.cs.meta new file mode 100644 index 0000000..62f4c02 --- /dev/null +++ b/Runtime/XChart/Pseudo3D/XChartCubeWireConfig.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ef9b3c372cf02f44b9a32242b420cbef +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Pseudo3D/XPseudo3DScatterChart.cs b/Runtime/XChart/Pseudo3D/XPseudo3DScatterChart.cs index 4ce8ffa..4bee13a 100644 --- a/Runtime/XChart/Pseudo3D/XPseudo3DScatterChart.cs +++ b/Runtime/XChart/Pseudo3D/XPseudo3DScatterChart.cs @@ -1,48 +1,44 @@ using UnityEngine; using XericLibrary.Runtime.UIGraph; using PrimitiveType = XericLibrary.Runtime.UIGraph.PrimitiveType; +using XericUI.Core; +using XericUI.XChart.Mesh; +using XericUI.XChart.Space; namespace XericUI.XChart.Pseudo3D { /// /// 伪 3D 散点图主组件。 /// - /// 在 UI 平面上绘制一个带有透视效果的 3D 散点图: - /// - 立方体线框代表三维空间边界 - /// - 三个可见面上的标线网格帮助定位 - /// - 数据点以图元(多边形/矩形)形式渲染在立方体内部 + /// 这张图自己不画任何东西(规范 §22):立方体线框、面内格线、散点都是「工具」, + /// 参数在面板「工具」下的那一块块里。立方体三件(空间 / 线框 / 网格)在元素表空时由 + /// 补成默认元素——所以新挂一张图就是能用的样子, + /// 而每一块都能被单独删掉、复制、改序。 /// /// 使用方式: /// 1. 在场景中创建空 GameObject,挂载本组件 /// 2. 设置数据:chart.SetData(xs, ys, zs) - /// 3. 调整外观参数 + /// 3. 外观参数在面板「工具」下改(旧版这里是「基础 → 立方体外观」,那份字段已删) /// - /// 子节点结构: - /// [XPseudo3DScatterChart] - /// └─ [XChartTools] - /// ├─ [ChartTool_CubeBg] ← 立方体线框 + 网格 - /// │ ├─ CubeEdgeRenderer (UILineRendererV2) - /// │ └─ CubeGridRenderer (UILineRendererV2) - /// └─ [ChartTool_ScatterPoints] - /// └─ PointRenderer (XScatterPointRenderer) + /// 子节点结构(工具根节点下,名字=元素名): + /// [XChartTools] + /// ├─ Space ← 基变换(四元数 + 半边长) + /// ├─ BG Cube Wire ← 12 条棱;发布 mesh.face.* 四角 + /// ├─ BG Cube Grid ← 面填充 + 面内格线;格线的唯一作者(也发布 .grid.S/.T) + /// └─ ChartTool_ScatterPoints + /// └─ PointRenderer (XScatterPointRenderer) /// - [AddComponentMenu("Xeric/XChart/Pseudo3D/Pseudo3D Scatter Chart")] + [AddComponentMenu(XericRegistrationPaths.Chart + "/Pseudo3D/Pseudo3D Scatter Chart")] [ExecuteAlways] public class XPseudo3DScatterChart : XChartBase { // ── 串行化字段(Inspector 可编辑) ──────────────────────── - - [Header("立方体外观")] - [SerializeField] private float m_CubeHalfSize = 150f; - [SerializeField] private float m_Pitch = 25f; - [SerializeField] private float m_Yaw = -30f; - [SerializeField] private Color m_FrontEdgeColor = new Color(0.7f, 0.7f, 0.7f, 1f); - [SerializeField] private Color m_BackEdgeColor = new Color(0.4f, 0.4f, 0.4f, 0.3f); - [SerializeField] private float m_EdgeThickness = 2f; - [SerializeField] private Color m_GridLineColor = new Color(0.5f, 0.5f, 0.5f, 0.25f); - [SerializeField] private int m_GridDivisions = 5; - [SerializeField] private bool m_ShowBackEdges = true; - [SerializeField] private bool m_ShowGridLines = true; + // + // 「立方体外观」那组字段以前住在这里(半边长 / 四元数 / 尺寸口径 / 前后棱颜色 / 格线颜色 / + // 分格数 S,T / 两个显示开关)。它们是**渲染参数**,挂在图上就有两个毛病:面板里它不在 + // 「工具」下、换一张图不能复用。现在它们各自是元素表里的一条配置 + // ( / / + // ),默认值由 给。 [Header("散点外观")] [SerializeField] private PrimitiveType m_PointType = PrimitiveType.Polygon; @@ -67,7 +63,6 @@ namespace XericUI.XChart.Pseudo3D // ── 工具引用 ────────────────────────────────────────────── - private ChartToolCubeBg m_CubeBg; private ChartToolScatterPoints m_ScatterPoints; // ── 数据模型 ────────────────────────────────────────────── @@ -77,12 +72,51 @@ namespace XericUI.XChart.Pseudo3D /// 3D 数据模型(只读) public XChartDataModel3D DataModel3D => m_DataModel; + // ── 默认元素 ────────────────────────────────────────────── + + /// + /// 立方体这三件(坐标系 / 线框 / 网格)默认就是图的一部分:元素表空着时补上, + /// 补完之后它们就在面板「工具」下,可以单独删、单独调、可以复制一份变成两个背景。 + /// + /// 网格那份的默认值=旧版「立方体外观」那组字段的默认行为:不填面(填充是网格元素 + /// 自己的可选项,旧图没有)、六面都画格线但只画朝向观察者的那几面(=旧线框工具的画法)、 + /// 不描面轮廓(轮廓由线框那 12 条棱管,描两遍只会让边变粗)。 + /// 其余参数取各类配置自己的默认值,所以新挂一张图的样子和以前一致。 + /// + protected override void DeclareDefaultElements() + { + AddDefaultElement(new XChartSpaceConfig { OrderIndex = -1000 }); + AddDefaultElement(new XChartCubeWireConfig { OrderIndex = 0, DrawOrder = 0 }); + AddDefaultElement(new XChartMeshBgConfig + { + OrderIndex = 1, + DrawOrder = 1, + FillFaces = XChartCubeFaceMask.None, + GridFaces = XChartCubeFaceMask.All, + OnlyVisibleFaces = true, + ShowFaceOutline = false, + }); + } + + /// + /// 元素表里某一类配置的第一个实例(脚本要改外观参数就走它,不再自带一份字段—— + /// 两处存同一件事就是"改了没反应"的来路)。没有就返回 null,调用方不当没发生也不崩。 + /// + private T ElementOf() where T : XChartElementConfig + { + return XChartElementTable.FirstOfKind(Elements, typeof(T)) as T; + } + // ── 初始化 ──────────────────────────────────────────────── protected override void OnEnable() { base.OnEnable(); EnsureToolsCreated(); + // 维度定义要在没有数据的时候就存在:面板的"数据"板块是按维度逐行给的, + // 只在第一次喂点时定义维度,就会出现"图里还没数据 ⇒ 一行都没有、无处填范围" + // (P4 验收现场:"没有看到维度数据行"就是这一条) + EnsureSharedDimensions(); } private void Start() @@ -94,55 +128,25 @@ namespace XericUI.XChart.Pseudo3D private void EnsureToolsCreated() { - if (m_CubeBg != null && m_ScatterPoints != null) return; + if (m_ScatterPoints != null) return; - // 创建立方体背景工具(OrderIndex 0,先渲染) - if (m_CubeBg == null) - { - m_CubeBg = AddTool("ChartTool_CubeBg", 0); - } - - // 创建散点工具(OrderIndex 10,后渲染,在上层) - if (m_ScatterPoints == null) - { - m_ScatterPoints = AddTool("ChartTool_ScatterPoints", 10); - m_ScatterPoints.CubeBg = m_CubeBg; - } + // 散点是"这张图必需的那个读数据的工具",所以走脚本注册(OrderIndex 10,画在背景之上)。 + // 立方体的三件(空间/线框/网格)不在这里:它们是元素表里的配置,面板上看得见能改。 + m_ScatterPoints = AddTool("ChartTool_ScatterPoints", 10); } // ── 参数同步 ────────────────────────────────────────────── private void SyncAllParams() { - SyncCubeParams(); SyncPointParams(); } - private void SyncCubeParams() - { - if (m_CubeBg == null) return; - m_CubeBg.CubeHalfSize = m_CubeHalfSize; - m_CubeBg.Pitch = m_Pitch; - m_CubeBg.Yaw = m_Yaw; - m_CubeBg.FrontEdgeColor = m_FrontEdgeColor; - m_CubeBg.BackEdgeColor = m_BackEdgeColor; - m_CubeBg.EdgeThickness = m_EdgeThickness; - m_CubeBg.GridLineColor = m_GridLineColor; - m_CubeBg.GridDivisions = m_GridDivisions; - m_CubeBg.ShowBackEdges = m_ShowBackEdges; - m_CubeBg.ShowGridLines = m_ShowGridLines; - m_CubeBg.MarkProjectionDirty(); - - // 投影变化时,散点需要重新投影 - if (m_ScatterPoints != null) - m_ScatterPoints.MarkDataDirty(); - } - private void SyncPointParams() { if (m_ScatterPoints == null) return; m_ScatterPoints.PointType = m_PointType; - m_ScatterPoints.SizeMode = m_PointSizeMode; + m_ScatterPoints.PointSizeMode = m_PointSizeMode; m_ScatterPoints.PointSize = m_PointSize; m_ScatterPoints.PointColor = m_PointColor; m_ScatterPoints.CenterColor = m_PointCenterColor; @@ -154,7 +158,7 @@ namespace XericUI.XChart.Pseudo3D m_ScatterPoints.EnableColorMapping = m_EnableColorMapping; m_ScatterPoints.ColorMapMin = m_ColorMapMin; m_ScatterPoints.ColorMapMax = m_ColorMapMax; - m_ScatterPoints.ColorMapAxis = m_ColorMapAxis; + m_ScatterPoints.ColorMapDimension = m_ColorMapAxis; } // ── 每帧更新 ────────────────────────────────────────────── @@ -174,26 +178,23 @@ namespace XericUI.XChart.Pseudo3D #region 公共 API - /// 刷新图表(重新投影所有数据点) + /// + /// 刷新图表:让散点重读数据源、让空间重投影。 + /// 点现在是从图共享的序列化数据源里读的(散点元素自己按维度下标 + 聚合范围归一化), + /// 所以存进预制体的数据重开预制体后还在——以前读的是本组件那份非序列化的 3D 模型,一重载就空。 + /// public void RefreshChart() { EnsureToolsCreated(); - // 标记立方体投影需要重新计算 - if (m_CubeBg != null) - m_CubeBg.MarkProjectionDirty(); + var space = Space; + if (space != null) space.MarkProjectionDirty(); - // 获取归一化数据点并传递给散点工具 - if (m_ScatterPoints != null && m_DataModel.HasData) + if (m_ScatterPoints != null) { - var normalized = m_DataModel.GetNormalizedPoints(); - m_ScatterPoints.SetNormalizedPoints(normalized); + m_ScatterPoints.AutoFromData = true; m_ScatterPoints.MarkDataDirty(); } - else if (m_ScatterPoints != null) - { - m_ScatterPoints.SetNormalizedPoints(null); - } } /// 设置散点数据 @@ -255,73 +256,140 @@ namespace XericUI.XChart.Pseudo3D public void ClearData() { m_DataModel.ClearAll(); + DataModel.Clear(); RefreshChart(); } #endregion - // ── 外观属性(运行时属性) ───────────────────────────────── + // ── 外观属性(转发到元素表) ─────────────────────────────── #region 运行时属性 + /// + /// 这一组属性以前各配一个序列化字段,再由 SyncCubeParams 灌进工具: + /// 于是"面板上改元素"与"脚本改属性"写的是两处状态,谁后跑谁赢——他报的"勾选了反而消失" + /// 就是这类结构的一个面(规范 §22)。现在读写的是元素表里那份配置本身: + /// 脚本、面板、预制体看到的是同一个数,没有第二份需要同步。 + /// + private void PushCubeLook() + { + ReapplyElements(); + ForceRefresh(); + } + + /// + /// 坐标系元素(姿态 / 半边长 / 尺寸口径的权威)。基类保证图里有一个 + /// 工具,但配置可以整条删掉——删了这里就是 null:getter 给中性值、setter 什么都不做, + /// 既不抛也不背着他造一个元素回来。 + /// + public XChartSpaceConfig SpaceElement => ElementOf(); + + /// 线框元素(前后棱颜色 / 棱宽 / 后向棱开关的权威) + public XChartCubeWireConfig WireElement => ElementOf(); + + /// 网格元素(格线颜色 / 分格数 / 画哪些面的权威) + public XChartMeshBgConfig GridElement => ElementOf(); + public float CubeHalfSize { - get => m_CubeHalfSize; - set { m_CubeHalfSize = value; SyncCubeParams(); } + get { var e = SpaceElement; return e != null ? e.HalfEdge : 0f; } + set { var e = SpaceElement; if (e == null) return; e.HalfEdge = value; PushCubeLook(); } } - public float Pitch + /// 姿态四元数——唯一的旋转权威量(没有相机位置可调) + public Quaternion Rotation { - get => m_Pitch; - set { m_Pitch = value; SyncCubeParams(); } + get { var e = SpaceElement; return e != null ? e.Rotation : Quaternion.identity; } + set { var e = SpaceElement; if (e == null) return; e.Rotation = value; PushCubeLook(); } } - public float Yaw + /// 一步跳到某个预设视角,等价于把那个四元数写进 + public void ApplyViewPreset(XChartCubeViewPreset preset) { - get => m_Yaw; - set { m_Yaw = value; SyncCubeParams(); } + var e = SpaceElement; + if (e == null) return; + e.ApplyViewPreset(preset); + PushCubeLook(); + } + + /// + /// 立方体尺寸口径(默认半边长:立方体大小不随旋转变化)。 + /// 名字必须带 Cube 前缀:本类还有散点用的 SizeMode(UIGraph 那个类型), + /// 同名会让散点那份字段的初始化器把类型名解成这个属性(CS0236)。 + /// + public XChartCubeSizeMode CubeSizeMode + { + get { var e = SpaceElement; return e != null ? e.SizeMode : XChartCubeSizeMode.HalfEdgeLength; } + set { var e = SpaceElement; if (e == null) return; e.SizeMode = value; PushCubeLook(); } } public Color FrontEdgeColor { - get => m_FrontEdgeColor; - set { m_FrontEdgeColor = value; SyncCubeParams(); } + get { var e = WireElement; return e != null ? e.FrontEdgeColor : Color.clear; } + set { var e = WireElement; if (e == null) return; e.FrontEdgeColor = value; PushCubeLook(); } } public Color BackEdgeColor { - get => m_BackEdgeColor; - set { m_BackEdgeColor = value; SyncCubeParams(); } + get { var e = WireElement; return e != null ? e.BackEdgeColor : Color.clear; } + set { var e = WireElement; if (e == null) return; e.BackEdgeColor = value; PushCubeLook(); } } public float EdgeThickness { - get => m_EdgeThickness; - set { m_EdgeThickness = value; SyncCubeParams(); } - } - - public Color GridLineColor - { - get => m_GridLineColor; - set { m_GridLineColor = value; SyncCubeParams(); } - } - - public int GridDivisions - { - get => m_GridDivisions; - set { m_GridDivisions = Mathf.Max(1, value); SyncCubeParams(); } + get { var e = WireElement; return e != null ? e.EdgeThickness : 0f; } + set { var e = WireElement; if (e == null) return; e.EdgeThickness = value; PushCubeLook(); } } public bool ShowBackEdges { - get => m_ShowBackEdges; - set { m_ShowBackEdges = value; SyncCubeParams(); } + get { var e = WireElement; return e != null && e.ShowBackEdges; } + set { var e = WireElement; if (e == null) return; e.ShowBackEdges = value; PushCubeLook(); } } + /// 格线颜色(旧名 GridLineColor,现归网格元素) + public Color GridLineColor + { + get { var e = GridElement; return e != null ? e.GridColor : Color.clear; } + set { var e = GridElement; if (e == null) return; e.GridColor = value; PushCubeLook(); } + } + + public int GridDivisions + { + get { var e = GridElement; return e != null ? e.GridDivisions : 0; } + set { var e = GridElement; if (e == null) return; e.GridDivisions = value; PushCubeLook(); } + } + + /// S 方向分格数(0=跟随统一值)。按方向分是为了让两条轴各自都能和格线对齐 + public int GridDivisionsS + { + get { var e = GridElement; return e != null ? e.GridDivisionsS : 0; } + set { var e = GridElement; if (e == null) return; e.GridDivisionsS = value; PushCubeLook(); } + } + + public int GridDivisionsT + { + get { var e = GridElement; return e != null ? e.GridDivisionsT : 0; } + set { var e = GridElement; if (e == null) return; e.GridDivisionsT = value; PushCubeLook(); } + } + + /// + /// 格线开关的旧写法。它现在的真身是网格元素的 掩码: + /// 开=六面都画,关=一面都不画。以前图上这个 bool 和线框里的另一套开关并存, + /// 两边都往同一批格线插槽上发布,才有"关掉一边另一边又亮回来"(规范 §22)。 + /// 只画后墙那类"部分面"请直接改掩码。 + /// public bool ShowGridLines { - get => m_ShowGridLines; - set { m_ShowGridLines = value; SyncCubeParams(); } + get { var e = GridElement; return e != null && e.GridFaces != XChartCubeFaceMask.None; } + set + { + var e = GridElement; + if (e == null) return; + e.GridFaces = value ? XChartCubeFaceMask.All : XChartCubeFaceMask.None; + PushCubeLook(); + } } public float PointSize @@ -382,18 +450,24 @@ namespace XericUI.XChart.Pseudo3D // ── 编辑器 ──────────────────────────────────────────────── -#if UNITY_EDITOR - private void OnValidate() + /// + /// 必须 override 基类的 OnValidate 并调 base——以前这里写的是 private void OnValidate(), + /// 它把基类那份遮掉了,导致基类的"重灌元素 + 强制刷新"对这个组件从未执行。 + /// 本图还没迁到 OnChartRefresh,所以自己那套参数同步仍在自己的 delayCall 里推。 + /// + protected override void OnValidate() { - if (m_GridDivisions < 1) m_GridDivisions = 1; if (m_PointSideCount < 3) m_PointSideCount = 3; if (m_PointSize < 0.5f) m_PointSize = 0.5f; - if (m_CubeHalfSize < 10f) m_CubeHalfSize = 10f; if (m_ColorMapAxis < 0) m_ColorMapAxis = 0; if (m_ColorMapAxis > 2) m_ColorMapAxis = 2; - // 编辑器下延迟同步,确保 Awake/Start 已执行 - if (isActiveAndEnabled && m_CubeBg != null) + base.OnValidate(); + +#if UNITY_EDITOR + // 编辑器下延迟一拍再同步,确保 Awake/OnEnable 已执行 + // (立方体那几件不归这里管了:基类的 base.OnValidate 已经"重灌元素 + 强制刷新"过) + if (isActiveAndEnabled) { UnityEditor.EditorApplication.delayCall += () => { @@ -404,7 +478,7 @@ namespace XericUI.XChart.Pseudo3D } }; } - } #endif + } } } diff --git a/Runtime/XChart/Pseudo3D/XScatterPointRenderer.cs b/Runtime/XChart/Pseudo3D/XScatterPointRenderer.cs index e484aa6..b7e7080 100644 --- a/Runtime/XChart/Pseudo3D/XScatterPointRenderer.cs +++ b/Runtime/XChart/Pseudo3D/XScatterPointRenderer.cs @@ -1,6 +1,7 @@ using UnityEngine; using XericLibrary.Runtime.UIGraph; using UIPrimitiveType = XericLibrary.Runtime.UIGraph.PrimitiveType; +using XericUI.Core; namespace XericUI.XChart.Pseudo3D { @@ -12,7 +13,7 @@ namespace XericUI.XChart.Pseudo3D /// /// 相比为每个点创建独立的 UIPrimitiveRenderer,本组件大幅减少 GameObject 数量和 Draw Call。 /// - [AddComponentMenu("Xeric/XChart/Pseudo3D/Scatter Point Renderer")] + [AddComponentMenu(XericRegistrationPaths.Chart + "/Pseudo3D/Scatter Point Renderer")] public class XScatterPointRenderer : PrimitiveCacheRendererBase { // ── 全局形状参数 ────────────────────────────────────────── @@ -64,6 +65,14 @@ namespace XericUI.XChart.Pseudo3D /// 可选:每个点的颜色(null 则使用 fillColor) public void SetPoints(Vector2[] positions, Color[] colors = null) { + // null 的意思是"没有点了,清空"。当成数据去读 .Length 就是一条 NRE, + // 而这条 NRE 会把管理器渲染循环里后面的所有工具一起带走(现象:加一个元素,全图不显示)。 + if (positions == null) + { + ClearAll(); + return; + } + ClearAll(); for (int i = 0; i < positions.Length; i++) diff --git a/Runtime/XChart/Radar/ChartToolRadarBg.cs b/Runtime/XChart/Radar/ChartToolRadarBg.cs index 8d617b7..8c91437 100644 --- a/Runtime/XChart/Radar/ChartToolRadarBg.cs +++ b/Runtime/XChart/Radar/ChartToolRadarBg.cs @@ -1,6 +1,7 @@ using UnityEngine; using XericLibrary.Runtime.UIGraph; using TMPro; +using XericUI.Core; namespace XericUI.XChart.Radar { @@ -21,7 +22,7 @@ namespace XericUI.XChart.Radar /// ├─ Label_1 (TMP_Text) /// └─ ... /// - [AddComponentMenu("Xeric/XChart/Radar/Radar Background Tool")] + [AddComponentMenu(XericRegistrationPaths.Chart + "/Radar/Radar Background Tool")] public class ChartToolRadarBg : XChartToolBase { // ── 配置 ────────────────────────────────────────────────── @@ -79,11 +80,12 @@ namespace XericUI.XChart.Radar /// 轴线渲染器 public UILineRendererV2 AxisRenderer { get; private set; } - /// 标签的父变换 - public Transform LabelsRoot { get; private set; } - - /// 所有标签文本组件 - public TMP_Text[] LabelTexts { get; private set; } + /// + /// 维度标签的数量口径:要几个就申请几个,件本身由 chart 的文本槽位池发落 + /// (规范 §5.4:隐藏靠少申请,不靠把发落到的槽位 SetActive(false)——那会被校验当无效丢弃)。 + /// + private int DesiredLabelCount + => ShowLabels && DimensionCount >= 3 ? DimensionCount : 0; // ── 内部状态 ────────────────────────────────────────────── @@ -114,11 +116,13 @@ namespace XericUI.XChart.Radar rt.offsetMin = Vector2.zero; rt.offsetMax = Vector2.zero; } + } - // 创建标签父节点 - var labelsObj = CreateChild("Labels"); - LabelsRoot = labelsObj; - + /// 申请维度标签(只登记需求,件在 chart 的池调度里发落) + public override void OnUpdate() + { + base.OnUpdate(); + RequestTextSlots(DesiredLabelCount); } // ── 标记脏 ──────────────────────────────────────────────── @@ -139,6 +143,8 @@ namespace XericUI.XChart.Radar DrawGrid(); DrawAxis(); UpdateLabels(); + // 槽位是下一轮调度才补齐的:还欠着件就保持脏,补齐后重画一次 + if (TextSlotsPending) m_DataDirty = true; } // ── 网格绘制 ────────────────────────────────────────────── @@ -197,25 +203,18 @@ namespace XericUI.XChart.Radar private void UpdateLabels() { - if (LabelsRoot == null) return; - int dims = DimensionCount; var dirs = XChartRadarDataModel.GetDimensionDirections(dims); + var labels = Texts; - // 确保标签数量匹配 - EnsureLabelCount(dims); + // 件要下一轮调度才补齐:这一帧先画已有的那些,欠着的由 OnRender 保持脏后再画一遍 + int usable = Mathf.Min(dims, labels.Count); - bool show = ShowLabels && dims >= 3; - - for (int i = 0; i < dims; i++) + for (int i = 0; i < usable; i++) { - var label = LabelTexts[i]; + var label = labels[i]; if (label == null) continue; - label.gameObject.SetActive(show); - - if (!show) continue; - // 设置文本 string name = (i < DimensionNames.Length && DimensionNames[i] != null) ? DimensionNames[i] @@ -239,65 +238,18 @@ namespace XericUI.XChart.Radar else label.alignment = TextAlignmentOptions.Top; - // 应用位置 + // 应用位置(尺寸也要在这里设:槽位来自池,创建时不知道要给哪个图表用) var rt = label.rectTransform; rt.anchoredPosition = labelPos; rt.anchorMin = new Vector2(0.5f, 0.5f); rt.anchorMax = new Vector2(0.5f, 0.5f); rt.pivot = new Vector2(0.5f, 0.5f); - } - - // 隐藏多余的标签 - for (int i = dims; i < LabelTexts.Length; i++) - { - if (LabelTexts[i] != null) - LabelTexts[i].gameObject.SetActive(false); - } - } - - /// 确保标签数组长度匹配维度数量 - private void EnsureLabelCount(int count) - { - if (LabelTexts != null && LabelTexts.Length == count) - return; - - // 清理旧的标签 - if (LabelTexts != null) - { - foreach (var label in LabelTexts) - { - if (label != null && label.gameObject != null) - { - if (Application.isPlaying) - Object.Destroy(label.gameObject); - else - Object.DestroyImmediate(label.gameObject); - } - } - } - - LabelTexts = new TMP_Text[count]; - - for (int i = 0; i < count; i++) - { - var labelObj = new GameObject($"Label_{i}", typeof(RectTransform)); - labelObj.transform.SetParent(LabelsRoot, false); - labelObj.hideFlags = CurrentFlags; - - var tmp = labelObj.AddComponent(); - tmp.text = ""; - tmp.fontSize = LabelFontSize; - tmp.color = LabelColor; - tmp.alignment = TextAlignmentOptions.Center; - - var rt = tmp.rectTransform; - rt.anchorMin = new Vector2(0.5f, 0.5f); - rt.anchorMax = new Vector2(0.5f, 0.5f); - rt.pivot = new Vector2(0.5f, 0.5f); rt.sizeDelta = new Vector2(100f, 24f); - - LabelTexts[i] = tmp; } + + // 没点亮的槽位必须擦空:池件是跨维度数复用的,留着上一轮的字就是残影 + for (int i = usable; i < labels.Count; i++) + if (labels[i] != null) labels[i].text = string.Empty; } // ── 清理 ────────────────────────────────────────────────── @@ -306,8 +258,6 @@ namespace XericUI.XChart.Radar { GridRenderer = null; AxisRenderer = null; - LabelsRoot = null; - LabelTexts = null; } } } diff --git a/Runtime/XChart/Radar/ChartToolRadarData.cs b/Runtime/XChart/Radar/ChartToolRadarData.cs index f671fc8..4fb3b5e 100644 --- a/Runtime/XChart/Radar/ChartToolRadarData.cs +++ b/Runtime/XChart/Radar/ChartToolRadarData.cs @@ -1,5 +1,6 @@ using UnityEngine; using XericLibrary.Runtime.UIGraph; +using XericUI.Core; namespace XericUI.XChart.Radar { @@ -14,7 +15,7 @@ namespace XericUI.XChart.Radar /// [ChartTool_RadarData] /// └─ DataRenderer (UILineRendererV2) — 所有数据系列的线框 /// - [AddComponentMenu("Xeric/XChart/Radar/Radar Data Tool")] + [AddComponentMenu(XericRegistrationPaths.Chart + "/Radar/Radar Data Tool")] public class ChartToolRadarData : XChartToolBase { // ── 配置 ────────────────────────────────────────────────── diff --git a/Runtime/XChart/Radar/XRadarChart.cs b/Runtime/XChart/Radar/XRadarChart.cs index 7017139..7b3acd3 100644 --- a/Runtime/XChart/Radar/XRadarChart.cs +++ b/Runtime/XChart/Radar/XRadarChart.cs @@ -1,4 +1,5 @@ using UnityEngine; +using XericUI.Core; namespace XericUI.XChart.Radar { @@ -27,7 +28,7 @@ namespace XericUI.XChart.Radar /// └─ [ChartTool_RadarData] (OrderIndex=10) ← 数据线框 /// └─ DataRenderer (UILineRendererV2) /// - [AddComponentMenu("Xeric/XChart/Radar/Radar Chart")] + [AddComponentMenu(XericRegistrationPaths.Chart + "/Radar/Radar Chart")] [ExecuteAlways] public class XRadarChart : XChartBase { @@ -345,13 +346,19 @@ namespace XericUI.XChart.Radar // ── 编辑器 ──────────────────────────────────────────────── -#if UNITY_EDITOR - private void OnValidate() + /// + /// override 基类并调 base:写成 private void OnValidate() 会遮掉基类那份, + /// "重灌元素 + 强制刷新"就再也不会为这个组件执行(和散点图同一个坑)。 + /// + protected override void OnValidate() { if (m_Radius < 10f) m_Radius = 10f; if (m_RingCount < 1) m_RingCount = 1; if (m_LabelFontSize < 4f) m_LabelFontSize = 4f; + base.OnValidate(); + +#if UNITY_EDITOR if (isActiveAndEnabled && m_RadarBg != null) { UnityEditor.EditorApplication.delayCall += () => @@ -363,7 +370,7 @@ namespace XericUI.XChart.Radar } }; } - } #endif + } } } diff --git a/Runtime/XChart/Space.meta b/Runtime/XChart/Space.meta new file mode 100644 index 0000000..3b59c06 --- /dev/null +++ b/Runtime/XChart/Space.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: a02b6ee38ba074b458a804d750e774d5 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Space/ChartToolSpace.cs b/Runtime/XChart/Space/ChartToolSpace.cs new file mode 100644 index 0000000..ffa031a --- /dev/null +++ b/Runtime/XChart/Space/ChartToolSpace.cs @@ -0,0 +1,156 @@ +using UnityEngine; +using XericUI.Core; +using XericUI.XChart.Mesh; + +namespace XericUI.XChart.Space +{ + /// + /// 空间工具(数据源工具):一张图里唯一的"立方体局部空间 → 图表局部像素"权威。 + /// + /// 为什么要有它:背景网格、线框、散点、轴线以前各算各的投影——同一份 pitch/yaw + /// 在两个类里各存一份、各推一遍,点就落不进盒子里。本工具把基变换收在一处, + /// 所有元素只问它要矩阵和面帧:投影 = 基变换 ∘ 工具变换, + /// 于是"点落在背景里"是结构保证,不是靠两边数值凑巧一致。 + /// + /// 两档出口: + /// + /// :基矩阵 × 工具矩阵,得到该工具用的仿射矩阵, + /// 交给 / + /// 复用同一套投影与面帧推导。 + /// / :需要自己换算长度或偏移的元素(轴线的 + /// 刻度长度、标签的让位距离)用它们,不要各自再算一遍 scale。 + /// + /// + /// 版本号: 在标记脏的那一刻递增, + /// 消费者拿它比对"要不要重新投影",不需要谁去清脏标记。 + /// + [AddComponentMenu(XericRegistrationPaths.Chart + "/Space/Space Tool")] + public sealed class ChartToolSpace : XChartToolBase + { + /// 图表自带的空间工具在管理器里的名字 + public const string DefaultToolName = "Space"; + + /// 空间是"投影权威":投影矩阵没算出来,谁也算不了 ⇒ 归定义组,最先跑(规范 §11.4) + public override XChartToolCategory Category => XChartToolCategory.Definition; + + // ── 基变换 ──────────────────────────────────────────────── + + /// 图表级姿态(四元数,唯一的旋转权威量) + public Quaternion Rotation { get; set; } = + XChartCubeView.RotationOf(XChartCubeViewPreset.Isometric); + + /// 半边长(UI 像素) + public float HalfEdge { get; set; } = 120f; + + /// 尺寸口径(默认半边长:尺度不随旋转变化) + public XChartCubeSizeMode SizeMode { get; set; } = XChartCubeSizeMode.HalfEdgeLength; + + /// 立方体中心在图表局部像素里的偏移 + public Vector2 CenterOffset { get; set; } + + // ── 派生状态 ────────────────────────────────────────────── + + private Matrix4x4 m_Base; + private float m_Scale = 1f; + private Vector2 m_Offset; + private bool m_ProjectionDirty = true; + + /// 投影版本号(标记脏时递增) + public int ProjectionVersion { get; private set; } + + /// 基变换矩阵(纯旋转) + public Matrix4x4 BaseMatrix { get { EnsureProjection(); return m_Base; } } + + /// 立方体单位 → 像素的缩放(半边长口径下就等于 ) + public float CubeToPixel { get { EnsureProjection(); return m_Scale; } } + + /// 投影后的平移(图表局部像素) + public Vector2 Offset { get { EnsureProjection(); return m_Offset; } } + + public void MarkProjectionDirty() + { + m_ProjectionDirty = true; + ProjectionVersion++; + } + + private void EnsureProjection() + { + if (!m_ProjectionDirty) return; + m_ProjectionDirty = false; + m_Base = XChartCubeView.ToMatrix(Rotation); + XChartCubeView.ComputeProjection(m_Base, HalfEdge, CenterOffset, SizeMode, out m_Scale, out m_Offset); + } + + // ── 出口 ────────────────────────────────────────────────── + + /// 基变换 ∘ 工具变换( 为恒等时就只剩基矩阵) + public Matrix4x4 Compose(XChartToolTransform tool) + { + EnsureProjection(); + return tool.IsIdentity ? m_Base : XChartCubeView.Compose(m_Base, tool.Build()); + } + + /// 立方体局部点 → 图表局部像素(带工具变换) + public Vector2 Project(Vector3 cubePoint, Matrix4x4 composed) + { + EnsureProjection(); + return XChartCubeGeometry.Project(composed, m_Scale, m_Offset, cubePoint); + } + + /// 立方体局部点 → 图表局部像素(只用基变换) + public Vector2 Project(Vector3 cubePoint) + { + EnsureProjection(); + return XChartCubeGeometry.Project(m_Base, m_Scale, m_Offset, cubePoint); + } + + /// 深度(越大越靠近观察者),用来做画家序 + public float DepthOf(Vector3 cubePoint, Matrix4x4 composed) + { + EnsureProjection(); + return composed.MultiplyPoint3x4(cubePoint).z; + } + + /// 六个面帧( 长度至少 6;顺序同 ) + public void BuildFaceFrames(XChartFaceFrame[] output, Matrix4x4 composed) + { + EnsureProjection(); + XChartCubeGeometry.BuildFaceFrames(composed, m_Scale, m_Offset, output); + } + + /// 六个面帧(只用基变换) + public void BuildFaceFrames(XChartFaceFrame[] output) + { + EnsureProjection(); + XChartCubeGeometry.BuildFaceFrames(m_Base, m_Scale, m_Offset, output); + } + + /// 某个面是否朝向观察者。注意:法线是按矩阵的线性部分转的, + /// 工具带非等比缩放时这只是近似(立方体场景里够用,别拿它判曲面)。 + public bool IsFaceVisible(XChartCubeGeometry.CubeFace face, Matrix4x4 composed) + => XChartCubeGeometry.IsFaceVisible(composed, face); + + public bool IsFaceVisible(XChartCubeGeometry.CubeFace face) + { + EnsureProjection(); + return XChartCubeGeometry.IsFaceVisible(m_Base, face); + } + + // ── 数据域 → 立方体域 ───────────────────────────────────── + + /// + /// 归一化数据(每维 [0,1])→ 立方体局部点([-1,1])。 + /// 数据元素统一走这一条,保证"0.5 就是立方体中间"这件事只有一处定义。 + /// + public static Vector3 NormalizedToCube(Vector3 zeroOne) + => new Vector3(zeroOne.x * 2f - 1f, zeroOne.y * 2f - 1f, zeroOne.z * 2f - 1f); + + protected override void OnInitialize() + { + // 空间本身不画东西:它只是别的元素的坐标系。节点仍然要建, + // 因为元素的兄弟序(= 绘制序)里得有它占的那一格 + SetVisible(true); + MarkProjectionDirty(); + } + } +} diff --git a/Runtime/XChart/Space/ChartToolSpace.cs.meta b/Runtime/XChart/Space/ChartToolSpace.cs.meta new file mode 100644 index 0000000..c151ba6 --- /dev/null +++ b/Runtime/XChart/Space/ChartToolSpace.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 4d9c1534a81b1ed4883cbc4eebcc9581 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Space/XChartScatterConfig.cs b/Runtime/XChart/Space/XChartScatterConfig.cs new file mode 100644 index 0000000..ba21f39 --- /dev/null +++ b/Runtime/XChart/Space/XChartScatterConfig.cs @@ -0,0 +1,116 @@ +using System; +using UnityEngine; +using XericLibrary.Runtime.UIGraph; +using PrimitiveType = XericLibrary.Runtime.UIGraph.PrimitiveType; +using XericUI.XChart.Pseudo3D; +using XericUI.XChart.Space; + +namespace XericUI.XChart.Space +{ + /// + /// 散点元素的配置。数据默认直接读图的数据源(按维度下标 + 聚合范围归一化), + /// 所以配好三个维度下标就能出图,不需要在图表上为散点再写一遍数据。 + /// + /// 关掉 就变成"脚本喂点"模式:由调用方 + /// SetCubePoints 给立方体单位的点([-1,1] 就是盒子内部)。 + /// + [Serializable] + [XChartElement("scatter", "散点", 30)] + public sealed class XChartScatterConfig : XChartElementConfig + { + [Header("数据来源")] + [SerializeField, Tooltip("真=按下面的维度下标读图的数据源;假=脚本用 SetCubePoints 喂")] + private bool m_AutoFromData = true; + + [SerializeField, Tooltip("X / Y / Z 轴取哪几个维度下标(绑定;显示范围在 chart 的数据板块逐维给)")] + private int m_DimensionX; + [SerializeField] private int m_DimensionY = 1; + [SerializeField] private int m_DimensionZ = 2; + + [SerializeField, Tooltip("点云自己的变换(叠在图的空间之上)")] + private XChartToolTransform m_Transform = XChartToolTransform.Identity; + + [SerializeField, Min(0), Tooltip("桶采样目标点数:0 或 ≥ 记录数=不聚合;填了数就把记录按桶归约成这么多个点")] + private int m_BucketTargetPoints; + + [SerializeField, Tooltip("桶内取哪个统计量当这个点:抽稀用 First/Last(不造新值),看趋势用 Mean/Median,看包络用 Minimum/Maximum")] + private XChartAggregateKind m_BucketReduce = XChartAggregateKind.Last; + + [Header("外观")] + [SerializeField, Min(0.5f), Tooltip("点的大小(像素)")] + private float m_PointSize = 8f; + + [SerializeField, Tooltip("图元类型")] + private PrimitiveType m_PointType = PrimitiveType.Polygon; + + [SerializeField, Tooltip("图元边数(多边形时有效)")] + private int m_SideCount = 8; + + [SerializeField, Tooltip("填充色")] + private Color m_PointColor = new Color(0.33f, 0.67f, 1f, 1f); + + [SerializeField, Tooltip("中心色;与填充色不同就走径向渐变")] + private Color m_CenterColor = Color.white; + + [SerializeField, Tooltip("边框色")] + private Color m_BorderColor = new Color(0.2f, 0.2f, 0.2f, 1f); + + [SerializeField, Min(0f), Tooltip("边框宽度")] + private float m_BorderThickness = 1f; + + [Header("按数值上色")] + [SerializeField, Tooltip("用某一维的数值做颜色渐变")] + private bool m_EnableColorMapping; + + [SerializeField, Tooltip("拿哪一维的数值")] + private int m_ColorMapDimension = 2; + + [SerializeField, Tooltip("范围下限对应颜色")] + private Color m_ColorMapMin = Color.blue; + + [SerializeField, Tooltip("范围上限对应颜色")] + private Color m_ColorMapMax = Color.red; + + public override string ElementName => "Scatter"; + + public override XChartToolBase CreateTool() => new ChartToolScatterPoints(); + + public override void ApplyTo(XChartToolBase tool) + { + if (!(tool is ChartToolScatterPoints scatter)) return; + + scatter.AutoFromData = m_AutoFromData; + scatter.DimensionX = m_DimensionX; + scatter.DimensionY = m_DimensionY; + scatter.DimensionZ = m_DimensionZ; + scatter.Transform = m_Transform; + scatter.BucketTargetPoints = m_BucketTargetPoints; + scatter.BucketReduce = m_BucketReduce; + + scatter.PointSize = m_PointSize; + scatter.PointType = m_PointType; + scatter.SideCount = m_SideCount; + scatter.PointColor = m_PointColor; + scatter.CenterColor = m_CenterColor; + scatter.BorderColor = m_BorderColor; + scatter.BorderThickness = m_BorderThickness; + + scatter.EnableColorMapping = m_EnableColorMapping; + scatter.ColorMapDimension = m_ColorMapDimension; + scatter.ColorMapMin = m_ColorMapMin; + scatter.ColorMapMax = m_ColorMapMax; + + scatter.MarkDataDirty(); + } + + public override void CaptureFrom(XChartToolBase tool) + { + if (!(tool is ChartToolScatterPoints scatter)) return; + + m_AutoFromData = scatter.AutoFromData; + m_PointSize = scatter.PointSize; + m_PointColor = scatter.PointColor; + m_Transform = scatter.Transform; + } + } +} diff --git a/Runtime/XChart/Space/XChartScatterConfig.cs.meta b/Runtime/XChart/Space/XChartScatterConfig.cs.meta new file mode 100644 index 0000000..c0b238a --- /dev/null +++ b/Runtime/XChart/Space/XChartScatterConfig.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f4e9ce2094df4084ca17a83c04839e07 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Space/XChartSlotBoard.cs b/Runtime/XChart/Space/XChartSlotBoard.cs new file mode 100644 index 0000000..d0ca395 --- /dev/null +++ b/Runtime/XChart/Space/XChartSlotBoard.cs @@ -0,0 +1,350 @@ +using System; +using System.Collections.Generic; +using UnityEngine; + +namespace XericUI.XChart.Space +{ + /// + /// 插槽的数据模式:决定"怎么切值 + 每个参数怎么解释"。**纯数据描述** —— 切值与解释都能离线断言。 + /// + public enum XChartSlotMode + { + /// 2 值/点,2 点一组:起点 → 终点(面内坐标) + Line2D = 0, + /// 3 值/点,2 点一组:起点 → 终点(立方体单位) + Line3D = 1, + /// 2 值=圆心,1 值=半径(面内圆) + Circle2D = 2, + /// 3 值=圆心,3 值=法向,1 值=半径(空间圆,法向定斜切面) + Circle3D = 3, + /// 3 值/点,4 点一组(ST00→ST01→ST11→ST10):空间四边形面片 + Quad3D = 4, + } + + /// 读写权限:只读槽被写要拒(可写用于"拖手柄写回去让网格跟随")。 + public enum XChartSlotAccess + { + ReadOnly = 0, + ReadWrite = 1, + } + + /// 模式的切值规则(各一条判据:一组几个值、个数不对就拒、越界就拒)。 + public static class XChartSlotModes + { + /// 空间面片固定四个角(ST00→ST01→ST11→ST10) + public const int QuadCorners = 4; + + /// 这种模式一组要几个值;未知模式返回 0 + public static int ValuesPerGroup(XChartSlotMode mode) + { + switch (mode) + { + case XChartSlotMode.Line2D: return 4; // 2 值 × 2 点 + case XChartSlotMode.Line3D: return 6; // 3 值 × 2 点 + case XChartSlotMode.Circle2D: return 3; // 圆心 2 + 半径 1 + case XChartSlotMode.Circle3D: return 7; // 圆心 3 + 法向 3 + 半径 1 + case XChartSlotMode.Quad3D: return 12; // 3 值 × 4 点 + default: return 0; + } + } + + /// 一组里的点数(圆算 0,它的"点"是圆心 + 半径、另有法向) + public static int PointsPerGroup(XChartSlotMode mode) + { + switch (mode) + { + case XChartSlotMode.Line2D: + case XChartSlotMode.Line3D: return 2; + case XChartSlotMode.Quad3D: return QuadCorners; + default: return 0; + } + } + + /// 按模式切组:值个数必须正好装下整数个组,否则拒收(越界/个数不对是一类错) + public static bool TryGroupCount(XChartSlotMode mode, int valueCount, out int groups) + { + groups = 0; + int perGroup = ValuesPerGroup(mode); + if (perGroup <= 0 || valueCount <= 0 || valueCount % perGroup != 0) return false; + groups = valueCount / perGroup; + return true; + } + + /// 值必须是有限数:NaN/Inf 会让几何静默画歪,所以发布时就拒(零要说清零在哪一层) + public static bool AllFinite(float[] values, int count) + { + if (values == null) return false; + for (int i = 0; i < count; i++) + { + if (float.IsNaN(values[i]) || float.IsInfinity(values[i])) return false; + } + return true; + } + } + + /// + /// 一个插槽的视图:值留在板子里(不复制),视图只带模式/权限/版本 + 该模式的取点方法。 + /// 过期视图不许写:板子版本前进过就说明它已经不是最新的那份。 + /// + public struct XChartSlotView + { + private float[] m_Values; + private XChartSlotBoard m_Board; + private int m_BoardVersion; + + public string Id { get; internal set; } + public XChartSlotMode Mode { get; internal set; } + public XChartSlotAccess Access { get; internal set; } + public int Version { get; internal set; } + public int GroupCount { get; internal set; } + + internal void Bind(float[] values, XChartSlotBoard board, int boardVersion) + { + m_Values = values; + m_Board = board; + m_BoardVersion = boardVersion; + } + + private bool InRange(int group, int point, int pointCount) + { + return m_Values != null && group >= 0 && group < GroupCount + && point >= 0 && point < pointCount; + } + + /// 取第 group 组第 point 个点(2D 模式 z 补 0) + public bool TryGetPoint(int group, int point, out Vector3 result) + { + result = Vector3.zero; + int points = XChartSlotModes.PointsPerGroup(Mode); + if (!InRange(group, point, points)) return false; + int stride = 3; + if (Mode == XChartSlotMode.Line2D) stride = 2; + int baseIndex = group * XChartSlotModes.ValuesPerGroup(Mode) + point * stride; + result = new Vector3(m_Values[baseIndex], m_Values[baseIndex + 1], + stride == 3 ? m_Values[baseIndex + 2] : 0f); + return true; + } + + /// 取一条线(Line2D / Line3D) + public bool TryGetLine(int group, out Vector3 from, out Vector3 to) + { + from = Vector3.zero; + to = Vector3.zero; + if (Mode != XChartSlotMode.Line2D && Mode != XChartSlotMode.Line3D) return false; + return TryGetPoint(group, 0, out from) && TryGetPoint(group, 1, out to); + } + + /// 取一个圆(Circle2D 的法向固定 +Z;Circle3D 用法向定斜切面) + public bool TryGetCircle(int group, out Vector3 center, out Vector3 normal, out float radius) + { + center = Vector3.zero; + normal = Vector3.forward; + radius = 0f; + if (group < 0 || group >= GroupCount || m_Values == null) return false; + + if (Mode == XChartSlotMode.Circle2D) + { + int i = group * 3; + center = new Vector3(m_Values[i], m_Values[i + 1], 0f); + radius = m_Values[i + 2]; + return true; + } + if (Mode == XChartSlotMode.Circle3D) + { + int i = group * 7; + center = new Vector3(m_Values[i], m_Values[i + 1], m_Values[i + 2]); + normal = new Vector3(m_Values[i + 3], m_Values[i + 4], m_Values[i + 5]); + radius = m_Values[i + 6]; + return true; + } + return false; + } + + /// 取一个面片(Quad3D),角序固定 ST00→ST01→ST11→ST10 + public bool TryGetQuad(int group, out Vector3 cornerST00, out Vector3 cornerST01, + out Vector3 cornerST11, out Vector3 cornerST10) + { + cornerST00 = Vector3.zero; + cornerST01 = Vector3.zero; + cornerST11 = Vector3.zero; + cornerST10 = Vector3.zero; + if (Mode != XChartSlotMode.Quad3D) return false; + return TryGetPoint(group, 0, out cornerST00) + && TryGetPoint(group, 1, out cornerST01) + && TryGetPoint(group, 2, out cornerST11) + && TryGetPoint(group, 3, out cornerST10); + } + + /// 能不能写:只读槽、或视图已经过期(板子版本前进过)都不行 + public bool CanWrite => m_Board != null && Access == XChartSlotAccess.ReadWrite + && m_BoardVersion == m_Board.Version && m_Values != null; + + /// 把一条线写回去(可拖动的手柄就是靠它反写网格);写成功会推板子版本,别的消费者据此重建 + public bool TryWriteLine(int group, Vector3 from, Vector3 to) + { + if (!CanWrite) return false; + if (Mode != XChartSlotMode.Line2D && Mode != XChartSlotMode.Line3D) return false; + if (group < 0 || group >= GroupCount) return false; + + int stride = Mode == XChartSlotMode.Line2D ? 2 : 3; + int baseIndex = group * XChartSlotModes.ValuesPerGroup(Mode); + WritePoint(baseIndex, from, stride); + WritePoint(baseIndex + stride, to, stride); + m_Board.BumpVersionForWrite(); + m_BoardVersion = m_Board.Version; // 写成功之后自己也跟着前进 + return true; + } + + private void WritePoint(int index, Vector3 point, int stride) + { + m_Values[index] = point.x; + m_Values[index + 1] = point.y; + if (stride == 3) m_Values[index + 2] = point.z; + } + } + + /// + /// 插槽板:定义网格的工具把自己的一组组标定顶点放上来,其余工具按 id 取用。 + /// 几何的通路,不碰数据(数据仍走 IXChartDataSource)。 + /// + public interface IXChartSlotBoard + { + /// 板子版本:任何一次成功发布/写回都会前进;消费者据此判断要不要重建 + int Version { get; } + + /// 发布的槽数(报表用) + int SlotCount { get; } + + bool Publish(string id, XChartSlotMode mode, XChartSlotAccess access, float[] values, out string reason); + bool TryRead(string id, out XChartSlotView view); + + /// + /// 第 个已发布槽的 id 与模式。按索引取、不给集合: + /// 这份清单只给面板做"已发布插槽"下拉用(每帧取一次不能分配)。 + /// + bool TryGetSlotAt(int index, out string id, out XChartSlotMode mode); + + /// + /// 撤下一个插槽:从这一刻起这里没有几何可吸附。真撤掉了返回 true,不在板上返回 false。 + /// + bool Unpublish(string id); + + void Clear(); + } + + /// + public sealed class XChartSlotBoard : IXChartSlotBoard + { + private sealed class Entry + { + public string Id; + public XChartSlotMode Mode; + public XChartSlotAccess Access; + public float[] Values; + public int Version; + } + + private readonly List m_Entries = new List(8); + + public int Version { get; private set; } + public int SlotCount => m_Entries.Count; + + /// 发布(同 id 覆盖)。拒收:空值、个数不是整数组、含 NaN/Inf、未知模式。 + public bool Publish(string id, XChartSlotMode mode, XChartSlotAccess access, float[] values, out string reason) + { + reason = null; + if (string.IsNullOrEmpty(id)) { reason = "插槽 id 为空"; return false; } + + int groups; + if (!XChartSlotModes.TryGroupCount(mode, values == null ? 0 : values.Length, out groups)) + { + reason = "值个数不是这种模式的整数组:" + (values == null ? 0 : values.Length); + return false; + } + if (!XChartSlotModes.AllFinite(values, values.Length)) { reason = "值里有 NaN/Inf"; return false; } + + var entry = Find(id); + if (entry == null) + { + entry = new Entry { Id = id }; + m_Entries.Add(entry); + } + entry.Mode = mode; + entry.Access = access; + if (entry.Values == null || entry.Values.Length != values.Length) entry.Values = new float[values.Length]; + Array.Copy(values, entry.Values, values.Length); + Version++; + entry.Version = Version; + return true; + } + + public bool TryRead(string id, out XChartSlotView view) + { + view = default(XChartSlotView); + var entry = Find(id); + if (entry == null) return false; + + view.Id = entry.Id; + view.Mode = entry.Mode; + view.Access = entry.Access; + view.Version = entry.Version; + XChartSlotModes.TryGroupCount(entry.Mode, entry.Values.Length, out int groups); + view.GroupCount = groups; + view.Bind(entry.Values, this, Version); + return true; + } + + public void Clear() + { + if (m_Entries.Count == 0) return; + m_Entries.Clear(); + Version++; + } + + /// + /// 撤下一个插槽(不在板上就没什么可撤 ⇒ false,并且不推版本)。 + /// + /// 为什么板子必须有这一面:只有 (同 id 覆盖)的话, + /// 定义者说得出"这里的线变成这一批",却说不出"这里不再有线"——上一轮那批值会一直留在板上, + /// 消费者照吸不误。本轮把格线收成一个作者之后,这件事必须有出口:网格掩码筛掉某个面、 + /// 或者整个网格元素被删掉,那些面的格线插槽就得撤下来,否则"关掉一边、另一边还跟着" + /// 只是换到插槽那一层复发(规范 §22)。空数组发布是拒的(组数必须是正数, + /// 见 ),所以"撤下"只能是一个显式动作。 + /// + public bool Unpublish(string id) + { + if (string.IsNullOrEmpty(id)) return false; + for (int i = 0; i < m_Entries.Count; i++) + { + if (m_Entries[i].Id != id) continue; + m_Entries.RemoveAt(i); + Version++; + return true; + } + return false; + } + + public bool TryGetSlotAt(int index, out string id, out XChartSlotMode mode) + { + id = null; + mode = default(XChartSlotMode); + if (index < 0 || index >= m_Entries.Count) return false; + + id = m_Entries[index].Id; + mode = m_Entries[index].Mode; + return true; + } + + private Entry Find(string id) + { + for (int i = 0; i < m_Entries.Count; i++) + { + if (string.Equals(m_Entries[i].Id, id, StringComparison.Ordinal)) return m_Entries[i]; + } + return null; + } + + /// 写回也算"内容变了":推版本号,别的消费者下一帧会重建 + internal void BumpVersionForWrite() => Version++; + } +} \ No newline at end of file diff --git a/Runtime/XChart/Space/XChartSlotBoard.cs.meta b/Runtime/XChart/Space/XChartSlotBoard.cs.meta new file mode 100644 index 0000000..710ba83 --- /dev/null +++ b/Runtime/XChart/Space/XChartSlotBoard.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b091fa6c38d0c364ab68723d2e25c761 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Space/XChartSpaceConfig.cs b/Runtime/XChart/Space/XChartSpaceConfig.cs new file mode 100644 index 0000000..661d876 --- /dev/null +++ b/Runtime/XChart/Space/XChartSpaceConfig.cs @@ -0,0 +1,106 @@ +using System; +using UnityEngine; +using XericUI.XChart.Mesh; + +namespace XericUI.XChart.Space +{ + /// + /// 空间(基变换)元素的配置——整张图的坐标系就是这一份。 + /// + /// 图表在初始化时会保证图里一定有一个 :两条注册路径 + /// 都没登记时自动补一个默认的。想调它就在层级面板里加这个元素(加出来的是同一个名字 + /// "Space",所以不会和默认的那个并存),或者在脚本里直接改 chart.Space。 + /// + /// 渲染只看一个量:四元数 。没有相机、没有焦距、没有第二处 + /// 输入;尺寸也只有一个量(半边长)。理由与换算见 。 + /// + /// 预设是按钮不是模式:选一次预设 = 把那个四元数写进 , + /// 选择器随即回到"手动"。所以不存在"选了预设,Rotation 字段就失效"这种事—— + /// 想在等距基础上再拧一点,直接改 Rotation 就行。 + /// + [Serializable] + [XChartElement("space", "空间(基变换)", -1000)] + public sealed class XChartSpaceConfig : XChartElementConfig + { + [Header("基变换")] + [SerializeField, Tooltip("立方体半边长(UI 像素):真实边长的一半,也等于面心到中心的距离")] + private float m_HalfEdge = 120f; + + [SerializeField, Tooltip("视角预设:一次性动作,不是模式。选它在写入的那一刻把预设四元数灌进下面的 Rotation," + + "然后自己回到\"手动\"。渲染永远只读 Rotation。")] + private XChartCubeViewPreset m_ViewPreset = XChartCubeViewPreset.Manual; + + [SerializeField, Tooltip("姿态四元数(x,y,z,w)——唯一的旋转权威量:没有相机、没有第二处输入")] + private Quaternion m_Rotation = XChartCubeView.RotationOf(XChartCubeViewPreset.Isometric); + + [SerializeField, Tooltip("尺寸口径:半边长(尺度与旋转无关)/ 视口适配(铺满固定矩形,转起来会变小)")] + private XChartCubeSizeMode m_SizeMode = XChartCubeSizeMode.HalfEdgeLength; + + [SerializeField, Tooltip("立方体中心在图表局部像素里的偏移")] + private Vector2 m_CenterOffset = Vector2.zero; + + /// 元素在 ToolsRoot 下的名字(和图表自动补的那个是同一个,所以不会并存) + public override string ElementName => ChartToolSpace.DefaultToolName; + + /// 当前姿态(渲染唯一权威)。写它=放弃预设、手动定角度(与面板上直接改四元数同一条路) + public Quaternion Rotation + { + get => m_Rotation; + set { m_Rotation = value; m_ViewPreset = XChartCubeViewPreset.Manual; } + } + + /// 半边长(UI 像素) + public float HalfEdge { get => m_HalfEdge; set => m_HalfEdge = Mathf.Max(0.01f, value); } + + /// 尺寸口径(半边长 / 视口适配) + public XChartCubeSizeMode SizeMode { get => m_SizeMode; set => m_SizeMode = value; } + + /// 中心偏移(图表局部像素) + public Vector2 CenterOffset { get => m_CenterOffset; set => m_CenterOffset = value; } + + /// 一步跳到某个预设视角:等价于把那个四元数写进 + public void ApplyViewPreset(XChartCubeViewPreset preset) + { + if (preset == XChartCubeViewPreset.Manual) return; + m_Rotation = XChartCubeView.RotationOf(preset); + m_ViewPreset = XChartCubeViewPreset.Manual; + } + + /// + /// 把预设当按钮用:非"手动"时把预设四元数写进 ,随即把选择器复位。 + /// 这样"改一下当前视角"和"从某个预设起步"用的是同一个字段,不存在"预设挡着 Rotation 让它失效"。 + /// + private void ConsumeViewPreset() + { + if (m_ViewPreset == XChartCubeViewPreset.Manual) return; + m_Rotation = XChartCubeView.RotationOf(m_ViewPreset); + m_ViewPreset = XChartCubeViewPreset.Manual; + } + + public override XChartToolBase CreateTool() => new ChartToolSpace(); + + public override void ApplyTo(XChartToolBase tool) + { + ConsumeViewPreset(); + if (!(tool is ChartToolSpace space)) return; + + space.Rotation = m_Rotation; + space.HalfEdge = m_HalfEdge; + space.SizeMode = m_SizeMode; + space.CenterOffset = m_CenterOffset; + + // 基变换变了要立刻让版本号走,下游元素下次渲染就会重投影 + space.MarkProjectionDirty(); + } + + public override void CaptureFrom(XChartToolBase tool) + { + if (!(tool is ChartToolSpace space)) return; + + m_HalfEdge = space.HalfEdge; + m_SizeMode = space.SizeMode; + m_CenterOffset = space.CenterOffset; + m_Rotation = space.Rotation; + } + } +} diff --git a/Runtime/XChart/Space/XChartSpaceConfig.cs.meta b/Runtime/XChart/Space/XChartSpaceConfig.cs.meta new file mode 100644 index 0000000..84caba9 --- /dev/null +++ b/Runtime/XChart/Space/XChartSpaceConfig.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e912716caa7c82c4ea9407b9b9aa6620 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/Space/XChartToolTransform.cs b/Runtime/XChart/Space/XChartToolTransform.cs new file mode 100644 index 0000000..73fd6e4 --- /dev/null +++ b/Runtime/XChart/Space/XChartToolTransform.cs @@ -0,0 +1,68 @@ +using UnityEngine; +using XericUI.XChart.Mesh; + +namespace XericUI.XChart.Space +{ + /// + /// 工具级变换:作用在立方体局部空间里的一个仿射(缩放 → 旋转 → 平移)。 + /// + /// 单位:立方体局部空间是"半边长 1"的归一化域(顶点在 ±1),所以 + /// 的 1 就是立方体边界、 的 1 就是原尺寸。 + /// 这样工具自己不用关心像素,也不用关心图表当前多大。 + /// + /// 和基变换的关系:投影时算的是 Base ∘ Tool(先工具、后基), + /// 由 复合, + /// 结果仍然是一个仿射矩阵,所以面帧依旧落在平行四边形那一档(协议见 + /// )。 + /// + [System.Serializable] + public struct XChartToolTransform + { + [SerializeField] private Vector3 m_Position; + [SerializeField] private Quaternion m_Rotation; + [SerializeField] private Vector3 m_Scale; + + /// + /// 结构体不能有字段初始化器,所以单位变换只能由 或这个构造给。 + /// 直接 new XChartToolTransform() 会得到 scale=0(整个塌成一个点), + /// 现象很扎眼但不是语义——所有配置字段都写成 = XChartToolTransform.Identity。 + /// + public XChartToolTransform(Vector3 position, Quaternion rotation, Vector3 scale) + { + m_Position = position; + m_Rotation = rotation; + m_Scale = scale; + } + + /// 立方体局部空间里的平移(1 = 到立方体边界) + public Vector3 Position { get => m_Position; set => m_Position = value; } + + /// 工具自身的旋转(四元数,和基变换同样不拆角度) + public Quaternion Rotation { get => m_Rotation; set => m_Rotation = value; } + + /// 各轴缩放(1 = 原尺寸) + public Vector3 Scale { get => m_Scale; set => m_Scale = value; } + + public static XChartToolTransform Identity + => new XChartToolTransform { Scale = Vector3.one }; + + /// 是否等于不做任何事(用来走"省掉复合"的快速路径) + public bool IsIdentity => m_Position == Vector3.zero + && m_Rotation == new Quaternion(0f, 0f, 0f, 1f) + && m_Scale == Vector3.one; + + /// T * R * S(线性 + 平移,最后一行恒 0,0,0,1) + public Matrix4x4 Build() + { + Matrix4x4 r = XChartCubeView.ToMatrix(m_Rotation); + var m = new Matrix4x4 + { + m00 = r.m00 * m_Scale.x, m01 = r.m01 * m_Scale.y, m02 = r.m02 * m_Scale.z, m03 = m_Position.x, + m10 = r.m10 * m_Scale.x, m11 = r.m11 * m_Scale.y, m12 = r.m12 * m_Scale.z, m13 = m_Position.y, + m20 = r.m20 * m_Scale.x, m21 = r.m21 * m_Scale.y, m22 = r.m22 * m_Scale.z, m23 = m_Position.z, + m30 = 0f, m31 = 0f, m32 = 0f, m33 = 1f, + }; + return m; + } + } +} diff --git a/Runtime/XChart/Space/XChartToolTransform.cs.meta b/Runtime/XChart/Space/XChartToolTransform.cs.meta new file mode 100644 index 0000000..9a45765 --- /dev/null +++ b/Runtime/XChart/Space/XChartToolTransform.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a9334f8228fdda948b8ae3a9533d0060 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/XChartBase.DebugDump.cs b/Runtime/XChart/XChartBase.DebugDump.cs new file mode 100644 index 0000000..7f72409 --- /dev/null +++ b/Runtime/XChart/XChartBase.DebugDump.cs @@ -0,0 +1,239 @@ +#if UNITY_EDITOR +using System; +using System.IO; +using System.Text; +using UnityEditor; +using UnityEngine; +using XericUI.XChart.Pools; +using XericUI.XChart.Space; + +namespace XericUI.XChart +{ + /// + /// 编辑器期的自述报表(规范 §6 的调试入口,整份文件包在 #if UNITY_EDITOR 里, + /// 运行时构建看不到它——作用域纪律见 §3)。 + /// + /// 开关是工程根下一个文件 xchart.dump.on:它存在时每 0.4 秒把这张图的关键内部状态 + /// 追加进 xchart.dump.txt;删掉就不再写。LateUpdate 里只按节流做一次 File.Exists, + /// 不在绘制路径上反复做 IO。 + /// + /// 为什么走文件而不是 Console:面板(元素行)与渲染(图形)同时出问题时,需要同一个时刻 + /// 两边的读数,而 Console 会滚掉、也看不见"这一帧到底有没有算出范围"。 + /// + public abstract partial class XChartBase + { + private const float k_DumpInterval = 0.4f; + private const int k_DumpCap = 300; + + /// 开关文件名(面板的"自述报表 开/关"按钮和这边必须同一份口径) + public const string DumpFlagName = "xchart.dump.on"; + /// 输出文件名(追加) + public const string DumpFileName = "xchart.dump.txt"; + + /// 工程根(报表开关与输出都放这里);拿不到就返回 null。 + public static string ProjectRoot() + { + try + { + return Directory.GetParent(Application.dataPath).FullName; + } + catch (Exception) + { + return null; + } + } + + private float m_NextDumpCheck; + private int m_DumpCount; + + private void EditorDumpTick() + { + if (Time.realtimeSinceStartup < m_NextDumpCheck) return; + m_NextDumpCheck = Time.realtimeSinceStartup + k_DumpInterval; + + var root = ProjectRoot(); + if (root == null) return; + + var flag = Path.Combine(root, DumpFlagName); + if (!File.Exists(flag)) return; + if (m_DumpCount >= k_DumpCap) return; + + m_DumpCount++; + try + { + var sb = new StringBuilder(); + BuildDump(sb); + File.AppendAllText(Path.Combine(root, DumpFileName), sb.ToString()); + } + catch (Exception error) + { + // 报表自己炸了就说清楚,并停止再来(别每帧抛) + m_NextDumpCheck = float.MaxValue; + Debug.LogWarning("XChart 调试报表写入失败,已停止:" + error.Message); + } + } + + private void BuildDump(StringBuilder sb) + { + sb.Append("==== dump #").Append(m_DumpCount) + .Append(" ").Append(DateTime.Now.ToString("HH:mm:ss.fff")) + .Append(" chart=\"").Append(name).Append("\" id=").Append(GetInstanceID()) + .Append(" type=").Append(GetType().Name).Append('\n'); + + sb.Append(" chart: activeSelf=").Append(gameObject.activeSelf) + .Append(" activeInHierarchy=").Append(gameObject.activeInHierarchy) + .Append(" hideFlags=").Append(hideFlags) + .Append(" enabled=").Append(enabled).Append('\n'); + + var rect = transform as RectTransform; + if (rect == null) sb.Append(" rect: NOT-A-RECTTRANSFORM\n"); + else + { + sb.Append(" rect: size=").Append(rect.rect.width.ToString("0.#")).Append('x') + .Append(rect.rect.height.ToString("0.#")) + .Append(" anchored=").Append(rect.anchoredPosition.x.ToString("0.#")).Append(',') + .Append(rect.anchoredPosition.y.ToString("0.#")) + .Append(" lossy=").Append(rect.lossyScale.x.ToString("0.###")).Append('\n'); + sb.Append(" ancestry: ").Append(Chain(rect)).Append('\n'); + } + + var canvas = GetComponentInParent(); + if (canvas == null) sb.Append(" canvas: NO-CANVAS(这条子树里任何 Graphic 都不可能出图)\n"); + else + { + sb.Append(" canvas: \"").Append(canvas.name).Append("\" mode=").Append(canvas.renderMode) + .Append(" scale=").Append(canvas.scaleFactor.ToString("0.###")) + .Append(" rootChildCount=").Append(canvas.transform.childCount).Append('\n'); + } + + var tools = ToolsRoot; + if (tools == null) sb.Append(" toolsRoot: NULL\n"); + else + { + var toolsRect = tools as RectTransform; + sb.Append(" toolsRoot: children=").Append(tools.childCount) + .Append(" active=").Append(tools.gameObject.activeSelf) + .Append(" sibling=").Append(toolsRect != null ? toolsRect.GetSiblingIndex() : -1) + .Append(" hideFlags=").Append(tools.gameObject.hideFlags).Append('\n'); + } + + var space = Space; + if (space == null) sb.Append(" space: NULL(工具会全部判空跳过,画面就是空的)\n"); + else + { + var offset = space.Offset; + sb.Append(" space: version=").Append(space.ProjectionVersion) + .Append(" halfEdge=").Append(space.HalfEdge.ToString("0.###")) + .Append(" sizeMode=").Append(space.SizeMode) + .Append(" cubeToPixel=").Append(space.CubeToPixel.ToString("0.###")) + .Append(" offset=").Append(offset.x.ToString("0.#")).Append(',').Append(offset.y.ToString("0.#")) + .Append(" euler=").Append(space.Rotation.eulerAngles.x.ToString("0.#")).Append(',') + .Append(space.Rotation.eulerAngles.y.ToString("0.#")).Append(',') + .Append(space.Rotation.eulerAngles.z.ToString("0.#")).Append('\n'); + } + + sb.Append(" elements: count=").Append(Elements.Count).Append('\n'); + for (int i = 0; i < Elements.Count; i++) + { + var config = Elements[i]; + if (config == null) + { + sb.Append(" [").Append(i).Append("] NULL-CONFIG\n"); + continue; + } + sb.Append(" [").Append(i).Append("] ").Append(config.GetType().Name) + .Append(" enabled=").Append(config.Enabled) + .Append(" name=\"").Append(config.ElementName).Append("\"") + .Append(" order=").Append(config.OrderIndex).Append('\n'); + } + + var pool = ToolManager != null ? ToolManager.TextPool : null; + if (pool == null) sb.Append(" pool: NULL(申请会被静默丢掉,标签永远不出现)\n"); + else + { + sb.Append(" pool: owners=").Append(pool.OwnerCount) + .Append(" dispatches=").Append(pool.DispatchCount) + .Append(" acquire=").Append(pool.AcquireCount) + .Append(" reuse=").Append(pool.ReuseCount) + .Append(" release=").Append(pool.ReleaseCount) + .Append(" dropped=").Append(pool.DroppedCount) + .Append(" idle=").Append(pool.IsIdle).Append('\n'); + } + + if (ToolManager == null) { sb.Append(" tools: manager NULL\n"); return; } + + // 池根是"回收干净"的判据对象:RebuildAll 之后它要么不在,要么只剩空闲件,不该越重建越多 + var poolRoot = transform.Find(XChartTextSlotFactory.PoolRootName); + sb.Append(" poolRoot: ").Append(poolRoot == null ? "absent" + : "present children=" + poolRoot.childCount + " active=" + poolRoot.gameObject.activeSelf).Append('\n'); + int poolRoots = 0; + for (int i = 0; i < transform.childCount; i++) + if (transform.GetChild(i).name == XChartTextSlotFactory.PoolRootName) poolRoots++; + if (poolRoots > 1) sb.Append(" POOL-ROOTS-LEAKED: ").Append(poolRoots).Append(" 个池根\n"); + + // 显隐开关的判据读数:隐藏位是"要不要在 Hierarchy 里露脸",与保存位是两件事, + // 所以这里既印隐藏位分布,也印有没有人把 DontSave 弄丢(那才会写进资产) + int hiddenNodes = 0, visibleNodes = 0, noDontSave = 0; + CountHideFlags(ToolsRoot != null ? ToolsRoot.gameObject : null, ref hiddenNodes, ref visibleNodes, ref noDontSave); + CountHideFlags(poolRoot != null ? poolRoot.gameObject : null, ref hiddenNodes, ref visibleNodes, ref noDontSave); + sb.Append(" hideFlags: hidden=").Append(hiddenNodes) + .Append(" shown=").Append(visibleNodes) + .Append(" missing-DontSave=").Append(noDontSave).Append('\n'); + + sb.Append(" tools: count=").Append(ToolManager.ToolCount).Append('\n'); + var list = ToolManager.Tools; + for (int i = 0; i < list.Count; i++) + { + var tool = list[i]; + if (tool == null) { sb.Append(" [").Append(i).Append("] NULL-TOOL\n"); continue; } + + sb.Append(" [").Append(i).Append("] \"").Append(tool.ToolName).Append("\" "); + tool.AppendDebugLine(sb); + sb.Append('\n'); + + var root = tool.RootTransform; + if (root == null) sb.Append(" rootRect: NULL\n"); + else + { + sb.Append(" rootRect: size=").Append(root.rect.width.ToString("0.#")).Append('x') + .Append(root.rect.height.ToString("0.#")) + .Append(" sibling=").Append(root.GetSiblingIndex()) + .Append(" parent=\"").Append(root.parent != null ? root.parent.name : "NULL").Append("\"") + .Append(" children=").Append(root.childCount).Append('\n'); + } + + string failure = ToolManager.LastFailureOf(tool.ToolName); + if (!string.IsNullOrEmpty(failure)) sb.Append(" LAST-FAILURE: ").Append(failure).Append('\n'); + } + + var dispatchFailure = ToolManager.LastDispatchFailure; + if (!string.IsNullOrEmpty(dispatchFailure)) sb.Append(" pool-dispatch-failure: ").Append(dispatchFailure).Append('\n'); + } + + private static void CountHideFlags(GameObject node, ref int hidden, ref int shown, ref int noDontSave) + { + if (node == null) return; + if ((node.hideFlags & HideFlags.HideInHierarchy) != 0) hidden++; + else shown++; + if ((node.hideFlags & HideFlags.DontSaveInEditor) == 0) noDontSave++; + var t = node.transform; + for (int i = 0; i < t.childCount; i++) + CountHideFlags(t.GetChild(i).gameObject, ref hidden, ref shown, ref noDontSave); + } + + private static string Chain(RectTransform node) + { + var sb = new StringBuilder(); + var current = node; + for (int depth = 0; current != null && depth < 6; depth++) + { + if (depth > 0) sb.Append(" < "); + sb.Append(current.name); + if (current.GetComponent() != null) { sb.Append("[CANVAS]"); break; } + current = current.parent as RectTransform; + } + return sb.ToString(); + } + } +} +#endif diff --git a/Runtime/XChart/XChartBase.DebugDump.cs.meta b/Runtime/XChart/XChartBase.DebugDump.cs.meta new file mode 100644 index 0000000..d7c44b9 --- /dev/null +++ b/Runtime/XChart/XChartBase.DebugDump.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 7d20714ffa463c54887f5e99f5b1315a +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/XChartBase.cs b/Runtime/XChart/XChartBase.cs index d35fc7a..b5c2115 100644 --- a/Runtime/XChart/XChartBase.cs +++ b/Runtime/XChart/XChartBase.cs @@ -1,55 +1,143 @@ +using System.Collections.Generic; +using TMPro; using UnityEngine; +using XericUI.Core; +using XericUI.XChart.Pools; +using XericUI.XChart.Space; namespace XericUI.XChart { /// /// 图表主行为组件基类。 /// - /// 标记 [ExecuteAlways] 确保编辑器下生命周期正常执行。 - /// 派生类在 Start() 中创建工具并配置数据模型。 + /// 两条注册路径,同一个管理器: + /// + /// 脚本路径:派生类重写 ,在里面 + /// 登记工具。写死在代码里、不进序列化,适合固定组合。 + /// 配置路径:Inspector 的"元素"表(), + /// 每个元素自带配置、可增删、可改字段。 + /// + /// 两条路最终都落到 上,靠 OrderIndex 决定绘制顺序。 + /// + /// 生命周期(严格分段,钩子见下) + /// + /// ── 初始化(Awake / OnEnable,[ExecuteAlways] 下编辑期同样执行)── + /// BuildToolsRoot 建 [XChartTools] + 管理器(并把数据中转口交给它) + /// RegisterTools() ★ 脚本注册工具(唯一的集中注册点) + /// RebuildElements() 配置路径加载元素 + /// EnsureSpace() 两条路都没登记空间工具就补一个默认的 + /// OnChartInitialized() 通用收尾 + /// OnRuntimeInitialized() / OnEditorInitialized() 按 Application.isPlaying 二选一 + /// ForceRefresh() 首帧全量刷一次 + /// + /// ── 每帧 ── + /// Update() ToolManager.UpdateAll() + NeedsRefresh() 时走正常刷新 + /// LateUpdate() ToolManager.RenderAll() (渲染只在 LateUpdate 里做) + /// + /// ── 刷新 ── + /// Refresh() 脏标记驱动的正常刷新(数据版本变了,或有人 RequestRefresh()) + /// ForceRefresh() 无条件刷新(编辑期改旋钮、重置之后都走它) + /// 两者都汇到 OnChartRefresh(bool force),派生类只需实现这一个 + /// + /// ── 重置 ── + /// ResetRender() 渲染层重建(不碰数据) + /// ResetData() 清数据 + 数据缓存,再刷新 + /// RebuildAll() 回收重建:拆掉全部生成物再走一遍完整初始化(含每个工具) + /// + /// + /// 脏是怎么判的:用数据版本号()与 + /// "本图已消费的版本"比对,而不是共用脏标记再协调清理——版本号不需要谁来清, + /// 所以"某个消费者清了脏、另一个消费者还没看到"这类互相污染不可能发生。 /// - [AddComponentMenu("Xeric/XChart/Chart Base")] + [AddComponentMenu(XericRegistrationPaths.Chart + "/Chart Base")] [ExecuteAlways] - public abstract class XChartBase : MonoBehaviour + public abstract partial class XChartBase : MonoBehaviour { - [Header("工具管理")] + [Header("调试")] [SerializeField] private bool m_ShowDebug; [SerializeField] private bool m_HideAllTools; [SerializeField] private XChartDataModel m_DataModel = new XChartDataModel(); + [Header("元素")] + // 元素配置:所有元素(网格背景 / 轴线 / 数据图元…)共用这一张表, + // [SerializeReference] 让每个元素按自己的实际类型序列化并在 Inspector 里展开。 + [SerializeReference] private List m_Elements = new List(); + + /// + /// 这张表的元素被填过没有。它存在的唯一理由是:默认元素只在"从来没有元素"的图上补 + /// (老场景里靠脚本注册的那批),他手工把表清空之后不该又被塞回来。 + /// + [SerializeField, HideInInspector] private bool m_ElementsSeen; + public XChartToolsManager ToolManager { get; private set; } public Transform ToolsRoot { get; private set; } public XChartDataModel DataModel => m_DataModel; - private bool m_IsInitialized; + /// + /// 数据访问中转口:元素(网格背景 / 轴线 / 数据图元)只认这个接口, + /// 不直接摸记录数组。默认就是 的直通实现。 + /// + public IXChartDataSource DataSource => m_DataModel; + + private long m_ConsumedDataVersion = -1; + private bool m_RefreshRequested = true; // ── hideFlags ───────────────────────────────────────────── - private const HideFlags k_EditorFlags = HideFlags.DontSaveInEditor; + /// + /// 编辑期生成物:既不进资产(DontSaveInEditor),也不出现在 Hierarchy。 + /// 图是脚本画出来的,节点列表里混一堆临时物体只会让人误操作;要看就按调试按钮临时显示。 + /// + private const HideFlags k_EditorFlags = HideFlags.DontSaveInEditor | HideFlags.HideInHierarchy; private const HideFlags k_PlayFlags = HideFlags.HideAndDontSave; internal static HideFlags CurrentFlags => Application.isPlaying ? k_PlayFlags : k_EditorFlags; - // ── 生命周期 ────────────────────────────────────────────── + // ══ 阶段一:初始化 ═══════════════════════════════════════ - private void Awake() - { - Initialize(); - } + private void Awake() => EnsureInitialized(); - protected virtual void OnEnable() - { - if (!m_IsInitialized) Initialize(); - } + protected virtual void OnEnable() => EnsureInitialized(); - private void Initialize() + /// + /// “初始化过了没有”只由 是否在位来判,不自立一个 bool 标记。 + /// + /// 脚本重载时 Unity 会把托管字段备份再还原:普通 bool 原样回来, + /// 而 这种纯托管引用回不来(变 null)。先前那种 + /// if (m_IsInitialized) return; 的写法在这个时刻就成了"自称初始化完、其实什么都没有"的 + /// 僵尸态——工具建不出来,后续 ReapplyElements/ForceRefresh 又都在 + /// ToolManager == null 上静默 return,Inspector 里怎么改都不响应,只能拆了重挂。 + /// 引用本身判空就不会和它保护的东西失联。 + /// + private void EnsureInitialized() { - if (m_IsInitialized) return; if (ToolManager != null) return; + BuildToolsRoot(); - var flags = CurrentFlags; + RegisterTools(); + DeclareMissingElements(); + RebuildElements(); + EnsureSpace(); + OnChartInitialized(); + if (Application.isPlaying) + { + OnRuntimeInitialized(); + } + else + { + OnEditorInitialized(); + } + + // 重建出来的都是新节点:调试开关(显示生成物 / 隐藏全部工具)必须再过一遍, + // 否则界面上勾着、实际却没有任何效果 + ApplyDebugVerbs(); + ForceRefresh(); + } + + private void BuildToolsRoot() + { var toolsRoot = transform.Find("[XChartTools]") as RectTransform; if (toolsRoot == null) { @@ -57,41 +145,308 @@ namespace XericUI.XChart toolsRoot = toolsObj.GetComponent(); toolsRoot.SetParent(transform, false); } + else + { + // 复用到旧根就说明上一个域的生成物还挂着:那些工具的 POCO 主人已经没了, + // 再也没人更新或清理它们,留着只会变成画不出东西的幽灵节点 + PurgeLeftoverChildren(toolsRoot); + } toolsRoot.anchorMin = Vector2.zero; toolsRoot.anchorMax = Vector2.one; toolsRoot.offsetMin = Vector2.zero; toolsRoot.offsetMax = Vector2.zero; toolsRoot.pivot = new Vector2(0.5f, 0.5f); - toolsRoot.gameObject.hideFlags = flags; + toolsRoot.gameObject.hideFlags = CurrentFlags; ToolsRoot = toolsRoot; + PurgeLeftoverPoolRoots(); + ToolManager = new XChartToolsManager { ToolsRoot = ToolsRoot, }; - - m_IsInitialized = true; + // 上下文的委托读的是这个字段:重建后旧上下文不会拽着旧空间不放 + ToolManager.Context = new XChartRenderContext(m_DataModel, + () => ToolManager != null ? ToolManager.FindTool() : null); + // 文本槽位池归 chart 所有:工具只申请,分配与回收在这里统一调度(规范 §5) + ToolManager.TextPool = new XChartSlotPool( + new XChartTextSlotFactory((RectTransform)transform)); } + private static void PurgeLeftoverChildren(RectTransform root) + { + for (int i = root.childCount - 1; i >= 0; i--) + { + var child = root.GetChild(i).gameObject; + if (Application.isPlaying) Object.Destroy(child); + else Object.DestroyImmediate(child); + } + } + + /// + /// 清掉上个域遗留的池根。池根挂在 chart 自己下面(不在 [XChartTools] 里), + /// 所以复用旧 [XChartTools] 的那套孤儿清理带不走它:域重载后旧池根还在, + /// 新池再建一个,每次重载攒一个(验收现场报表打到 66 次 POOL-ROOTS-LEAKED, + /// 他重启 Unity 正好把这件事放大)。 + /// + private void PurgeLeftoverPoolRoots() + { + for (int i = transform.childCount - 1; i >= 0; i--) + { + var child = transform.GetChild(i); + if (child.name != XChartTextSlotFactory.PoolRootName) continue; + if (Application.isPlaying) Destroy(child.gameObject); + else DestroyImmediate(child.gameObject); + } + } + + /// + /// 图里的空间工具(唯一的投影权威)。两条注册路径都没有登记它时, + /// 这里补一个默认的——立方体空间的元素(背景 / 线框 / 散点 / 轴线)都靠它对齐, + /// 少了它就变成"各算各的投影"。 + /// + public ChartToolSpace Space => ToolManager?.FindTool(); + + private void EnsureSpace() + { + if (ToolManager == null || ToolManager.FindTool() != null) return; + ToolManager.AddTool(ChartToolSpace.DefaultToolName, -1000); + } + + /// + /// ★ 派生类在这里声明"这张图默认带哪些元素"(规范 §22)。 + /// + /// 渲染参数挂在图上(旧版 XPseudo3DScatterChart 的「立方体外观」那组字段)有两个毛病: + /// 面板里它不在「工具」下,看不见是哪个东西在用;以及换一张图、加第二个背景时那份旋钮不能复用。 + /// 搬进元素表之后,参数随元素走,脚本注册与配置注册是同一条路。 + /// + /// 只在这张表"第一次被读到"时调用一次(见 ), + /// 而且 按类型去重:表里已经有这一类就不再塞第二份。 + /// 于是两种历史形态都照顾到了——表是空的(新图)补出整套默认元素;表里只有轴线/散点 + /// (老场景:立方体那几件当时还是图上的字段、不在表里)只把缺的那几件补上, + /// 而不是"升级之后背景整块没了"。 + /// 他之后把某个元素删掉,标记已置,不会再自动补回来——那是对着意愿干架。 + /// + protected virtual void DeclareDefaultElements() { } + + /// 把一份元素配置加进表(面板上的 Add 走序列化属性,不从这里走) + protected T AddElement(T config) where T : XChartElementConfig + { + if (config == null || m_Elements.Contains(config)) return config; + m_Elements.Add(config); + return config; + } + + /// + /// 补一份默认元素:这一类配置在表里已经存在时就沿用现有那条、不加第二份 + /// (语义与判据见 )。 + /// 真要"两个背景"是主动的事:面板 Add,或 。 + /// + protected T AddDefaultElement(T config) where T : XChartElementConfig + { + int at = XChartElementTable.IndexOfKind(m_Elements, typeof(T)); + if (at >= 0) return m_Elements[at] as T; + return AddElement(config); + } + + /// + /// 第一次见到这张表 ⇒ 让派生类把这张图默认该有的元素补齐,并把"见过这张表"记下来。 + /// 编辑器里额外打一次脏:默认元素要能存进场景、能在面板上被编辑,否则下次进来又是一张生表。 + /// + private void DeclareMissingElements() + { + if (m_ElementsSeen) return; + m_ElementsSeen = true; + + int before = m_Elements.Count; + DeclareDefaultElements(); +#if UNITY_EDITOR + if (m_Elements.Count > before && !Application.isPlaying) UnityEditor.EditorUtility.SetDirty(this); +#endif + } + + /// + /// ★ 脚本注册工具的唯一集中点:派生类在这里登记自己要用的渲染工具。 + /// 只在初始化时调用一次;配置路径(Inspector 元素表)走 , + /// 两条路互不冲突,都会进同一个管理器。 + /// + /// 新的预设请优先走 (元素表里的一条配置): + /// 那样面板上看得见、能改、能存。脚本路径留给"这张图必需的托管组件"(例如散点渲染器)。 + /// + protected virtual void RegisterTools() { } + + /// 登记一个工具(脚本路径的便捷写法,返回实例便于后续配置) + protected T RegisterTool(string toolName, int orderIndex = 0) + where T : XChartToolBase, new() + => ToolManager.AddTool(toolName, orderIndex); + + /// 登记一个已经造好的工具实例 + protected void RegisterTool(XChartToolBase tool, string toolName, int orderIndex = 0) + => ToolManager?.AddTool(tool, toolName, orderIndex); + + /// 初始化全部完成(两条注册路径都已落地)后的通用钩子 + protected virtual void OnChartInitialized() { } + + /// 仅运行时(Application.isPlaying)初始化后调用 + protected virtual void OnRuntimeInitialized() { } + + /// 仅编辑器(编辑期,[ExecuteAlways] 下)初始化后调用 + protected virtual void OnEditorInitialized() { } + + // ══ 阶段二:每帧 ════════════════════════════════════════ + protected virtual void Update() { - if (!m_IsInitialized || ToolManager == null) return; + if (ToolManager == null) return; + // 工具在这里算出"这帧要几个标签"并申请(只置脏) ToolManager.UpdateAll(); + if (NeedsRefresh()) Refresh(); } protected virtual void LateUpdate() { - if (!m_IsInitialized || ToolManager == null) return; + if (ToolManager == null) return; + // 申请都收齐了才统一发落,然后才轮到渲染:顺序反了就会出现"这帧申请、下帧才有件" + ToolManager.DispatchTextPools(); ToolManager.RenderAll(); +#if UNITY_EDITOR + EditorDumpTick(); +#endif } - // ── 工具管理 ────────────────────────────────────────────── + // ══ 阶段三:刷新 ════════════════════════════════════════ + + /// 是否需要刷新:数据版本变了,或有人显式请求过 + public bool NeedsRefresh() + => m_RefreshRequested || m_ConsumedDataVersion != DataSource.Version; + + /// 请求一次刷新(脏标记):下一帧走正常刷新流程 + public void RequestRefresh() => m_RefreshRequested = true; + + /// 正常刷新(版本比对不过就跳过,除非有人请求过) + public void Refresh() + { + if (!NeedsRefresh()) return; + m_RefreshRequested = false; + m_ConsumedDataVersion = DataSource.Version; + OnChartRefresh(false); + } + + /// 无条件刷新:编辑期改旋钮、重置之后都走这条 + public void ForceRefresh() + { + m_RefreshRequested = false; + m_ConsumedDataVersion = DataSource.Version; + OnChartRefresh(true); + } + + /// + /// 刷新钩子。 为 true 表示无条件刷新。 + /// 派生类只需要实现这一个,正常刷新与强制刷新的差别由它自己决定。 + /// + protected virtual void OnChartRefresh(bool force) { } + + // ══ 阶段四:重置 ════════════════════════════════════════ + + /// 渲染层重置:不碰数据,只让渲染重新来过 + public void ResetRender() + { + OnResetRender(); + ForceRefresh(); + } + + /// 数据重置:清空数据与数据缓存,再刷新 + public void ResetData() + { + m_DataModel?.Clear(); + OnResetData(); + ForceRefresh(); + } + + /// 渲染层重置钩子 + protected virtual void OnResetRender() { } + + /// 数据重置钩子(数据本身已由 清空) + protected virtual void OnResetData() { } + + /// + /// 回收重建:把自己生成的全部节点拆掉,再走一遍完整初始化流程——chart 的初始化流程 + /// 和每个工具的初始化流程依次重来(拆目录是 chart 的活,不下放给某个工具)。 + /// 脚本重载、配置结构大改、或调试菜单里手动触发时用。 + /// + public void RebuildAll() + { + Teardown(); + EnsureInitialized(); + } + + /// + /// 调试开关:临时显示/隐藏生成节点。只改可见位,不动保存位—— + /// 关掉隐藏是为了让人能选中它们看参数,绝不是让它们被存进资产或场景。 + /// + /// 遍历的是"chart 的整条生成子树":池根挂在 chart 自己下面(不在 [XChartTools] 里), + /// 件又在工具的宿主之下([XChartTools]/工具/GeneratedTexts/TextSlot_n), + /// 所以按名字认根 + 递归到底,不按层数猜——按层数猜就是"按了没反应"。 + /// + public void SetGeneratedVisible(bool visible) + { + if (Application.isPlaying) return; // 运行期是 HideAndDontSave,没有临时显示这件事 + + if (ToolsRoot != null) ApplyHideFlagsDeep(ToolsRoot.gameObject, visible); + var poolRoot = transform.Find(XChartTextSlotFactory.PoolRootName); + if (poolRoot != null) ApplyHideFlagsDeep(poolRoot.gameObject, visible); + } + + private static void ApplyHideFlagsDeep(GameObject target, bool visible) + { + ApplyHideFlags(target, visible); + var node = target.transform; + for (int i = 0; i < node.childCount; i++) + ApplyHideFlagsDeep(node.GetChild(i).gameObject, visible); + } + + /// + /// 面板按钮的入口:同时把状态写回 m_ShowDebug,免得按钮和字段各说各话 + /// (两个地方记同一件事,总有一个会先烂)。 + /// + public void SetDebugVisibility(bool visible) + { + m_ShowDebug = visible; + SetGeneratedVisible(visible); + } + + /// + /// 两个调试开关的实际效果。这两个字段原先没有任何读者——"开了没反应"就是这么来的: + /// m_ShowDebug 接到"显示生成节点",m_HideAllTools 接到"隐藏所有工具"。 + /// 每次初始化与每次 Inspector 改值都过一遍,重建后也不会掉。 + /// + public void ApplyDebugVerbs() + { + SetGeneratedVisible(m_ShowDebug); + + if (ToolManager == null) return; + var tools = ToolManager.Tools; + for (int i = 0; i < tools.Count; i++) + { + if (tools[i] != null) tools[i].SetVisible(!m_HideAllTools); + } + } + + private static void ApplyHideFlags(GameObject target, bool visible) + { + if (Application.isPlaying) return; // 运行期是 HideAndDontSave,没有临时显示这件事 + target.hideFlags = visible + ? HideFlags.DontSaveInEditor + : HideFlags.DontSaveInEditor | HideFlags.HideInHierarchy; + } + + // ── 工具管理(公开 API) ────────────────────────────────── public T AddTool(string toolName, int orderIndex = 0) where T : XChartToolBase, new() { - if (ToolManager == null) Initialize(); + EnsureInitialized(); return ToolManager.AddTool(toolName, orderIndex); } @@ -103,30 +458,202 @@ namespace XericUI.XChart public void RemoveAllTools() => ToolManager?.RemoveAllTools(); - // ── 清理 ────────────────────────────────────────────────── + // ── 元素(配置路径) ────────────────────────────────────── + + /// 元素配置表([SerializeReference],Inspector 里逐项展开自己类型的字段) + public IReadOnlyList Elements => m_Elements; + + /// 当前已加载的元素实例(与配置表同序、只含启用的项) + public IReadOnlyList ElementTools => m_ElementTools; + + private readonly List m_ElementTools = new List(); + + /// + /// 元素在表里的登记名:默认名按类型给,同类加第二个就会撞(现场拍到 Axis, Axis), + /// 而按名字配对就会把第二条轴的字段灌进第一条。所以同名按表内出现次序补序号—— + /// 它只由位置决定,不入库,重建后同名元素还是同一个名字。 + /// + public string ElementNameFor(int index) + { + if (index < 0 || index >= m_Elements.Count) return string.Empty; + var config = m_Elements[index]; + if (config == null) return string.Empty; + + string baseName = config.ElementName; + for (int earlier = 0; earlier < index; earlier++) + { + var other = m_Elements[earlier]; + if (other != null && other.ElementName == baseName) return baseName + " " + (index + 1); + } + return baseName; + } + + /// + /// 按配置表重建全部元素:清掉旧的 → 逐个 CreateTool/AddTool/ApplyTo。 + /// 轴线、网格背景、数据图元都走这一条,图表不需要为每个元素各写一段 Sync。 + /// + public void RebuildElements() + { + // 管理器不在就走完整初始化(它内部会灌一遍元素表),别在这里再建第二次 + if (ToolManager == null) + { + EnsureInitialized(); + return; + } + + for (int i = 0; i < m_ElementTools.Count; i++) + { + if (m_ElementTools[i] != null) ToolManager.RemoveTool(m_ElementTools[i]); + } + m_ElementTools.Clear(); + + for (int i = 0; i < m_Elements.Count; i++) + { + var config = m_Elements[i]; + if (config == null || !config.Enabled) continue; + + var tool = config.CreateTool(); + if (tool == null) continue; + + ToolManager.AddTool(tool, ElementNameFor(i), config.OrderIndex, config.DrawOrder); + config.ApplyTo(tool); + m_ElementTools.Add(tool); + } + + // "图里一定有一个空间工具"这条不变量要在**每次重建后**都成立,不只是初始化那一次: + // 面板上把「空间(基变换)」这一条删掉或停用是合法动作,而投影权威一没,线框/网格/散点 + // 会一起不画(现象是"整张图突然空了")。补一个默认的就是为了让"删掉它"不等于"图没了"。 + EnsureSpace(); + + OnElementsRebuilt(); + } + + /// + /// 配置里改了字段:不重建实例,只把配置重灌进已存在的元素(按名字配对)。 + /// 配对不上(结构变了)就退回整体重建。 + /// + public void ReapplyElements() + { + // 管理器不在就直接重新初始化,不要静默 return——静默 return 正是 + // "改了字段什么反应都没有"的那种死法 + if (ToolManager == null) + { + EnsureInitialized(); + return; + } + + for (int i = 0; i < m_Elements.Count; i++) + { + var config = m_Elements[i]; + if (config == null || !config.Enabled) continue; + + var tool = ToolManager.FindTool(ElementNameFor(i)); + if (tool == null) + { + RebuildElements(); + return; + } + config.ApplyTo(tool); + } + } + + /// 元素重建完成后的钩子(派生类可在此做自己的收尾) + protected virtual void OnElementsRebuilt() { } + + // ══ 阶段五:销毁 ════════════════════════════════════════ + + /// + /// 整条层级正在被 Unity 递归销毁——Undo 删 GameObject 走的也是这条路。 + /// + /// 这个窗口里对子孙调 DestroyImmediate 会撞进 Unity 自己的销毁遍历, + /// 实测 SIGSEGV(2026-10-24,他的 Editor.log):栈是 + /// Object_CUSTOM_DestroyImmediate ← XChartToolBase.Dispose ← XChartToolsManager.RemoveAllTools + /// ← Teardown ← OnDestroy ← GameObject::WillDestroyGameObject/PreDestroyRecursive + /// ← ObjectUndo::ApplyUndo;崩溃前 Unity 还连报两次 + /// Child GameObject 'LineChunk0' was not registered into undo system and became dangling。 + /// + /// 生成物(工具根 / 池根 / 分块子节点)全是本对象的子孙 ⇒ 跟着一起没。 + /// 所以这窗口只做记账(清列表、丢引用、从池里注销),一个 Destroy* 都不调。 + /// + private bool m_HierarchyBeingDestroyed; protected virtual void OnDestroy() + { + m_HierarchyBeingDestroyed = true; + Teardown(); + } + + private void Teardown() { m_DataModel?.DisposeRuntime(); + m_ElementTools.Clear(); if (ToolManager != null) { - ToolManager.Dispose(); + if (m_HierarchyBeingDestroyed) + { + ToolManager.ReleaseBookkeeping(); + } + else + { + // 池根挂在 chart 自己下面,[XChartTools] 的清理带不走它:不先拆池, + // 每回收重建一次就在场景里漏一个 GeneratedTextPool + ToolManager.DestroyTextPool(); + ToolManager.Dispose(); + } ToolManager = null; } if (ToolsRoot != null) { - if (Application.isPlaying) - Destroy(ToolsRoot.gameObject); - else - DestroyImmediate(ToolsRoot.gameObject); + if (!m_HierarchyBeingDestroyed) + { + if (Application.isPlaying) + Destroy(ToolsRoot.gameObject); + else + DestroyImmediate(ToolsRoot.gameObject); + } ToolsRoot = null; } - m_IsInitialized = false; + // "回收干净"是判据不是意图:池根要现拆现验,别留一个看不见的节点自称已清。 + // 销毁窗口里这条不适用——整棵子树都在被销毁,没有"漏一个"可言。 + if (!m_HierarchyBeingDestroyed) + { + var leftoverPoolRoot = transform.Find(XChartTextSlotFactory.PoolRootName); + if (leftoverPoolRoot != null) + { + if (Application.isPlaying) Destroy(leftoverPoolRoot.gameObject); + else DestroyImmediate(leftoverPoolRoot.gameObject); + } + } + m_ConsumedDataVersion = -1; + m_RefreshRequested = true; } - private void OnValidate() + // ── 编辑器 ──────────────────────────────────────────────── + + /// + /// Inspector 里的值变了。派生类要扩展它请写 protected override void OnValidate() + /// 并记得 base.OnValidate();——Unity 按名字只调最派生的那一个, + /// 在派生类里另写一个 private void OnValidate() 会把基类这份遮掉, + /// 于是"改字段不刷新"(先前 XPseudo3DScatterChart 就是这么把自己的刷新弄丢的)。 + /// + protected virtual void OnValidate() { - // 由派生类按需扩展 +#if UNITY_EDITOR + // Inspector 里改了配置就重灌元素,再无条件刷一次(这样编辑期就能看到实际效果)。 + // 延迟一拍:避开反序列化中途(工具还没建),也避免拖数值框时同步重建。 + if (!isActiveAndEnabled) return; + UnityEditor.EditorApplication.delayCall += () => + { + if (this == null || !isActiveAndEnabled) return; + ApplyDebugVerbs(); + ReapplyElements(); + ForceRefresh(); + }; +#endif + OnChartValidated(); } + + /// 编辑器里参数变化后的钩子(给派生类把自己那些非元素旋钮推进工具用) + protected virtual void OnChartValidated() { } } -} +} \ No newline at end of file diff --git a/Runtime/XChart/XChartBindingMath.cs b/Runtime/XChart/XChartBindingMath.cs new file mode 100644 index 0000000..7167de8 --- /dev/null +++ b/Runtime/XChart/XChartBindingMath.cs @@ -0,0 +1,89 @@ +using UnityEngine; + +namespace XericUI.XChart +{ + /// + /// 元素参数"从数据哪来"的翻译:记录下标 + 维度下标 → 一个几何通道的值。 + /// + /// 顺序只有一个权威(他 2026-10-24 的要求:"所有工具访问数据时,顺序、方向、索引、 + /// 尺寸、内容都是一样的"):记录下标 0 就是表里最早的、n-1 是最新的, + /// 和数据窗口显示的行号同一套下标。这里不提供"往回数第几条"这种相对量—— + /// 它让同一份数据在窗口里是第 1 条、在工具里变成第 n-2 条(那次现场就是它: + /// 圆柱默认取"上一条→最新",于是他改第 1 条时圆柱不动,而末两条相等时两端合并)。 + /// + /// 多记录一图元走"编组":组 g 覆盖 [g*size, g*size+size-1], + /// 组与组严格不重叠、也不把上一组并进来;凑不满一组的尾巴不画 + /// (宁可少画一个,也不要画一个用错记录的)。这样 32 条记录、组大小 2 ⇒ 16 个图元。 + /// + public static class XChartBindingMath + { + /// 能凑出几个完整组:记录数 / 组大小(向下取整,尾巴不算)。 + public static int CompleteGroupCount(int recordCount, int groupSize) + { + if (groupSize < 2 || recordCount < groupSize) return 0; + return recordCount / groupSize; + } + + /// + /// 组 的首尾记录下标(绝对下标,组内 = 首…尾)。 + /// 尾巴凑不满一组时返回 false。 + /// + public static bool TryResolveGroup(int recordCount, int groupIndex, int groupSize, + out int firstRecord, out int lastRecord) + { + firstRecord = lastRecord = -1; + if (groupSize < 2 || groupIndex < 0) return false; + + int first = groupIndex * groupSize; + int last = first + groupSize - 1; + if (last >= recordCount) return false; + + firstRecord = first; + lastRecord = last; + return true; + } + + /// + /// 三个维度 + 一条指定的记录 → 一个位置(原始数值,还在数据口径里)。 + /// 下标越界、维度越界、值不是有限数一律 false:宁可这一帧不画,也不往几何里塞 NaN + /// ——NaN 进去以后是静默毁掉整条管线,不是画歪。 + /// + public static bool TryResolvePosition(IXChartDataSource data, int recordIndex, + int dimensionX, int dimensionY, int dimensionZ, out Vector3 position) + { + position = Vector3.zero; + if (data == null) return false; + if (recordIndex < 0 || recordIndex >= data.RecordCount) return false; + if (dimensionX < 0 || dimensionY < 0 || dimensionZ < 0) return false; + + int dimensions = data.NumericDimensionCount; + if (dimensionX >= dimensions || dimensionY >= dimensions || dimensionZ >= dimensions) return false; + + double x = data.GetValueAt(recordIndex, dimensionX); + double y = data.GetValueAt(recordIndex, dimensionY); + double z = data.GetValueAt(recordIndex, dimensionZ); + if (!IsFinite(x) || !IsFinite(y) || !IsFinite(z)) return false; + + position = new Vector3((float)x, (float)y, (float)z); + return true; + } + + /// + /// 数据值 → 立方体单位(±1 就是盒子边界)。值域退化(两个端点相等或非有限)时返回 false: + /// 那一刻没有"数据在哪儿"可言,硬画出来是一个假位置,不如让调用方这一帧不画。 + /// 不裁剪到 ±1——超出盒子的值是数据的事实,裁了就看不出来了。 + /// + public static bool TryNormalize(double value, double minimum, double maximum, out float unit) + { + unit = 0f; + if (!IsFinite(value) || !IsFinite(minimum) || !IsFinite(maximum)) return false; + double span = maximum - minimum; + if (span <= 0d) return false; + + unit = (float)((value - minimum) / span * 2d - 1d); + return true; + } + + private static bool IsFinite(double value) => !double.IsNaN(value) && !double.IsInfinity(value); + } +} \ No newline at end of file diff --git a/Runtime/XChart/XChartBindingMath.cs.meta b/Runtime/XChart/XChartBindingMath.cs.meta new file mode 100644 index 0000000..abeebd0 --- /dev/null +++ b/Runtime/XChart/XChartBindingMath.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: aaa2cc725d59cd5488d9c77f65c85048 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/XChartBucketMath.cs b/Runtime/XChart/XChartBucketMath.cs new file mode 100644 index 0000000..34a2018 --- /dev/null +++ b/Runtime/XChart/XChartBucketMath.cs @@ -0,0 +1,104 @@ +using System; + +namespace XericUI.XChart +{ + /// + /// 桶采样:把一段记录简化成 N 个点,每点取桶内一个"最有意义"的统计量。 + /// + /// 为什么要有它:元素按记录数长几何(散点一个点一条记录、箭头一条记录两个四边形), + /// 几万条记录就会把顶点预算和帧率一起吃掉。桶采样把"这一段时间里发生了什么"压成一个点—— + /// 折线要最新值就取 Last、要看包络就取 Minimum/Maximum、要看趋势就取 Mean。 + /// + /// 分桶的硬要求:整数均分,不留缝、不重叠、每条记录恰好属于一个桶 + /// (用 recordCount * i / bucketCount 的整数算术,不是浮点即兴切); + /// 目标点数 ≥ 记录数或 ≤ 0 就是"不聚合",一个桶都不多。 + /// + /// 纯算术 + 只读数据源 ⇒ 离线可判(见 math_probe.cs 的 bucket 断言与 p4 的对照臂): + /// "少一条记录""桶边界错一格"这类错误在画面上只是"点少了一个",眼睛看不出来。 + /// + public static class XChartBucketMath + { + /// + /// 要分几个桶。 ≤ 0 或 ≥ 记录数=不聚合(桶数 = 记录数), + /// 记录数为 0 时返回 0。 + /// + public static int BucketCount(int recordCount, int targetPoints) + { + if (recordCount <= 0) return 0; + if (targetPoints <= 0 || targetPoints >= recordCount) return recordCount; + return targetPoints; + } + + /// + /// 第 个桶覆盖 [firstRecord, endExclusive)。 + /// 整数均分:桶与桶严丝合缝(前一个的 end == 后一个的 first),全部桶并起来正好是 [0, recordCount)。 + /// + public static bool TryBucketRange(int recordCount, int bucketIndex, int bucketCount, + out int firstRecord, out int endExclusive) + { + firstRecord = endExclusive = 0; + if (recordCount <= 0 || bucketCount <= 0 || bucketCount > recordCount) return false; + if (bucketIndex < 0 || bucketIndex >= bucketCount) return false; + + firstRecord = (int)((long)recordCount * bucketIndex / bucketCount); + endExclusive = (int)((long)recordCount * (bucketIndex + 1) / bucketCount); + return endExclusive > firstRecord; + } + + /// + /// 桶内归约:取该维在 [firstRecord, endExclusive) 上的一个统计量。 + /// NaN/Inf 一律跳过(它们不是数据点);整桶都是坏值返回 false——**宁可少画一个点, + /// 也不要往几何里塞一个假位置**。 只给中位数用(要么给够长度、 + /// 要么别选中位数),长度不够就拒收而不是内部悄悄分配。 + /// + public static bool TryReduce(IXChartDataSource data, int dimension, int firstRecord, int endExclusive, + XChartAggregateKind reduce, double[] scratch, out double value) + { + value = double.NaN; + if (data == null || dimension < 0) return false; + if (firstRecord < 0 || endExclusive > data.RecordCount || endExclusive <= firstRecord) return false; + if (reduce == XChartAggregateKind.Median && scratch == null) return false; + + double sum = 0d, squareSum = 0d, first = 0d, last = 0d, minimum = 0d, maximum = 0d; + int valid = 0; + + for (int i = firstRecord; i < endExclusive; i++) + { + double v = data.GetValueAt(i, dimension); + if (double.IsNaN(v) || double.IsInfinity(v)) continue; + + if (valid == 0) { first = minimum = maximum = v; } + last = v; + sum += v; + squareSum += v * v; + if (v < minimum) minimum = v; + if (v > maximum) maximum = v; + if (scratch != null && valid < scratch.Length) scratch[valid] = v; + valid++; + } + + if (valid == 0) return false; + + switch (reduce) + { + case XChartAggregateKind.Count: value = valid; return true; + case XChartAggregateKind.First: value = first; return true; + case XChartAggregateKind.Last: value = last; return true; + case XChartAggregateKind.Minimum: value = minimum; return true; + case XChartAggregateKind.Maximum: value = maximum; return true; + case XChartAggregateKind.Sum: value = sum; return true; + case XChartAggregateKind.Mean: value = sum / valid; return true; + case XChartAggregateKind.Rms: value = Math.Sqrt(squareSum / valid); return true; + case XChartAggregateKind.Median: + if (scratch.Length < valid) return false; + Array.Sort(scratch, 0, valid); + value = (valid & 1) == 1 + ? scratch[valid / 2] + : (scratch[valid / 2 - 1] + scratch[valid / 2]) * 0.5; + return true; + default: + return false; + } + } + } +} \ No newline at end of file diff --git a/Runtime/XChart/XChartBucketMath.cs.meta b/Runtime/XChart/XChartBucketMath.cs.meta new file mode 100644 index 0000000..43b3214 --- /dev/null +++ b/Runtime/XChart/XChartBucketMath.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8cf8de233df91a3458166d6d0ec820f4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/XChartColumnMath.cs b/Runtime/XChart/XChartColumnMath.cs new file mode 100644 index 0000000..8b047c4 --- /dev/null +++ b/Runtime/XChart/XChartColumnMath.cs @@ -0,0 +1,64 @@ +using System.Collections.Generic; + +namespace XericUI.XChart +{ + /// + /// 维度表的下标口径:表里一行是"一列"(键、种类、显示名、范围覆盖),而每条记录的 + /// 值数组只装数值列——中间夹一个 Label/Time 列时,"表里第几行"和"值是第几格"会错开。 + /// + /// 这条映射以前在数据模型里数一遍、在数据窗口里再数一遍,两处各数各的就会出现 + /// "窗口把刚填过数的格子显示成 -,导出里那两个数却还在"。规则收在这里, + /// 模型与界面都调它,判据也只需要盯这一处(见规范 §21.7)。 + /// + public static class XChartColumnMath + { + /// 数值列的个数=每条记录值数组的长度(非数值列不占格) + public static int ValueCount(IReadOnlyList dimensions) + { + if (dimensions == null) return 0; + int count = 0; + for (int i = 0; i < dimensions.Count; i++) + if (dimensions[i] != null && dimensions[i].Kind == XChartDimensionKind.Number) count++; + return count; + } + + /// + /// 表里第 行对应的值下标; + /// 那一列不占值(种类不是 Number)或行号越界时返回 -1(调用方据此显示"没有数值"而不是猜)。 + /// + public static int ValueSlot(IReadOnlyList dimensions, int tableIndex) + { + if (dimensions == null || tableIndex < 0 || tableIndex >= dimensions.Count) return -1; + var target = dimensions[tableIndex]; + if (target == null || target.Kind != XChartDimensionKind.Number) return -1; + + int slot = 0; + for (int i = 0; i < tableIndex; i++) + if (dimensions[i] != null && dimensions[i].Kind == XChartDimensionKind.Number) slot++; + return slot; + } + + /// + /// 反方向:值下标 属于表里哪一列(拿到那一列的定义)。 + /// + /// 工具绑的"第几维"是值下标(它按 GetValueAt(record, dimension) 取数), + /// 而范围覆盖存在表里那一列上。两边都按下标直接查就会在混合种类的表上错位: + /// 表是 x, tag, y 时,工具的"第 1 维"是 y,而表里第 1 行是 tag。 + /// 这条函数把那一次换算固定下来(规范 §21.7)。 + /// + public static XChartDimensionDefinition DefinitionOfValueSlot( + IReadOnlyList dimensions, int valueSlot) + { + if (dimensions == null || valueSlot < 0) return null; + int slot = 0; + for (int i = 0; i < dimensions.Count; i++) + { + var candidate = dimensions[i]; + if (candidate == null || candidate.Kind != XChartDimensionKind.Number) continue; + if (slot == valueSlot) return candidate; + slot++; + } + return null; + } + } +} diff --git a/Runtime/XChart/XChartColumnMath.cs.meta b/Runtime/XChart/XChartColumnMath.cs.meta new file mode 100644 index 0000000..0c8984c --- /dev/null +++ b/Runtime/XChart/XChartColumnMath.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 810f5b65df5742f4da0c46663136a5f4 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/XChartDataModel.cs b/Runtime/XChart/XChartDataModel.cs index 0e429a5..4e151d6 100644 --- a/Runtime/XChart/XChartDataModel.cs +++ b/Runtime/XChart/XChartDataModel.cs @@ -21,12 +21,86 @@ namespace XericUI.XChart [SerializeField] private string m_Format = "0.##"; [SerializeField] private bool m_Visible = true; + // ── 显示范围(归 chart 的数据维度行:工具只呈现,不自己声明范围)──────── + // 两端各自可以钉住:"最小值必须是 0、最大值跟着数据跑"是常态, + // 而一个总的"覆盖范围"开关只表达得出"两端都钉住"或"两端都自由"。 + [SerializeField] private bool m_OverrideRange; // 旧:两端一起覆盖(分侧开关一旦写过就清掉它) + [SerializeField] private bool m_OverrideMin; + [SerializeField] private bool m_OverrideMax; + [SerializeField] private Vector2 m_ManualRange = Vector2.zero; + public string Key => m_Key; - public string DisplayName => m_DisplayName; + /// + /// 显示名。可写是为了"改列标题":改的只是显示名,维度序号与 key 都不动 + /// (序号是数据的事实——工具的维度绑定按序号走)。 + /// + public string DisplayName + { + get => m_DisplayName; + set => m_DisplayName = value; + } public XChartDimensionKind Kind => m_Kind; - public string Format => m_Format; + + /// 数值格式串(可写:文本导入要能把格式一起带回来) + public string Format + { + get => m_Format; + set => m_Format = value; + } + public bool Visible => m_Visible; + /// 旧口径:两端一起覆盖。留着是因为已有场景里带这个字段,而且它=两个分侧开关同时为真 + public bool OverrideRange + { + get => m_OverrideRange; + set => m_OverrideRange = value; + } + + /// 覆盖范围的两个端点(x=最小、y=最大)。没钉住的那一端这里的值不参与解析, + /// 但要保持可读——数据窗口里两个格子随时显示这里存的数,勾上就立刻生效。 + public Vector2 ManualRange + { + get => m_ManualRange; + set => m_ManualRange = value; + } + + /// 旧主开关的生效条件:勾上了而且两端确实填了不同的值("勾了但没填"不算覆盖, + /// 这条规则从 P4 起就在,它保住了"默认 0/0 状态不会凭空造出一段范围") + private bool LegacyBothPinned => m_OverrideRange && m_ManualRange.x != m_ManualRange.y; + + /// 这一端现在是不是被钉住了(旧的主开关两端一起算) + public bool OverrideMin => LegacyBothPinned || m_OverrideMin; + + /// 同上:最大端 + public bool OverrideMax => LegacyBothPinned || m_OverrideMax; + + /// + /// 交给域解析的覆盖请求(唯一出口):没钉住的端由 回落到该维聚合。 + /// + public XChartDomainOverride DomainOverride + => new XChartDomainOverride(OverrideMin, m_ManualRange.x, OverrideMax, m_ManualRange.y); + + /// + /// 分侧设覆盖: / 总是留着(哪怕这一端没钉), + /// 所以"先填好数、再勾选"和"先勾选、再改数"两条路都不会把另一端的数字抹掉。 + /// + public void SetDomainOverride(bool overrideMin, double min, bool overrideMax, double max) + { + m_OverrideRange = false; // 分侧开关写过之后,"两端一起"这个旧状态就不再参与 + m_OverrideMin = overrideMin; + m_OverrideMax = overrideMax; + m_ManualRange = new Vector2((float)min, (float)max); + } + + /// 脚本侧一次设完两端( == 表示不覆盖) + public void SetRangeOverride(double min, double max) + { + bool over = min != max; + m_OverrideRange = over; + m_ManualRange = new Vector2((float)min, (float)max); + } + public XChartDimensionDefinition(string key, string displayName, XChartDimensionKind kind) { m_Key = key; @@ -93,31 +167,61 @@ namespace XericUI.XChart } } + /// + /// 图表的默认数据模型:维度定义 + 记录表 + 版本号,并作为 的 + /// 直通实现(不做任何映射,范围游标就是下标遍历,聚合现算)。 + /// + /// 记录表按时间非递减( 强制),所以时间窗可以直接二分定位。 + /// [Serializable] - public sealed class XChartDataModel + public sealed class XChartDataModel : IXChartDataSource { [SerializeField] private int m_Capacity = 4096; [SerializeField] private List m_Dimensions = new List(); [SerializeField] private List m_Records = new List(); [NonSerialized] private XChartDataSnapshot m_Snapshot; + [NonSerialized] private long m_SnapshotVersion = -1; [NonSerialized] private long m_Version; [NonSerialized] private long m_NextRecordId = 1; + [NonSerialized] private long m_DroppedCount; + + // 聚合缓存:写一次改版本,同一版本内重复查询(同一帧里多个元素问同一个维度)不重算 + [NonSerialized] private long m_AggregateVersion = -1; + [NonSerialized] private int m_AggregateDimension = -1; + [NonSerialized] private XChartAggregates m_AggregateCache; + [NonSerialized] private double[] m_MedianScratch; public IReadOnlyList Dimensions => m_Dimensions; public IReadOnlyList Records => m_Records; - public XChartDataSnapshot Snapshot => m_Snapshot; - public long Version => m_Version; - public int Capacity { get => m_Capacity; set => m_Capacity = Mathf.Max(1, value); } - public int NumericDimensionCount + + /// + /// 只读快照(NativeArray)。惰性构建:写入时只标脏,谁先要谁触发一次重建。 + /// 旧快照在新快照建好之后才释放,避免把手里的 NativeArray 提前释放掉。 + /// + public XChartDataSnapshot Snapshot { get { - int count = 0; - for (int i = 0; i < m_Dimensions.Count; i++) if (m_Dimensions[i].Kind == XChartDimensionKind.Number) count++; - return count; + EnsureSnapshot(); + return m_Snapshot; } } + public long Version => m_Version; + public int Capacity { get => m_Capacity; set => m_Capacity = Mathf.Max(1, value); } + + /// + /// 因为触顶被丢掉的记录条数(累计事实,不会因为改大 Capacity 而减少——那些记录已经不在表里了)。 + /// 现场就是靠它解释"我改了容量怎么还是 4096 条":丢掉的找不回来,得重新灌。 + /// + public long DroppedCount => m_DroppedCount; + + /// + /// 数值维个数=每条记录值数组的长度。口径只有一份(), + /// 数据窗口按同一个函数决定"哪一列有值格",于是这里的数和表上的列不会各说各话。 + /// + public int NumericDimensionCount => XChartColumnMath.ValueCount(m_Dimensions); + public void SetDimensions(IList dimensions) { m_Dimensions.Clear(); @@ -133,12 +237,92 @@ namespace XericUI.XChart Publish(); } + /// + /// 给某一维改显示名(列标题)。序号与 key 都不动——序号是数据的事实, + /// 工具的维度绑定按序号走;空名拒收(列标题空了就认不出是哪一列)。 + /// + public bool TryRenameDimension(int index, string displayName) + { + if (index < 0 || index >= m_Dimensions.Count) return false; + if (string.IsNullOrEmpty(displayName) || string.IsNullOrEmpty(displayName.Trim())) return false; + + m_Dimensions[index].DisplayName = displayName.Trim(); + Publish(); + return true; + } + + /// + /// 给某一维设分侧覆盖(数据窗口的两个勾选框走这里)。下标是值下标 + /// (与 一致);非有限数一律拒绝:覆盖值会被当成坐标算, + /// NaN 进去就是整条轴安静地什么都不画。 + /// + public bool TrySetDomainOverride(int dimension, bool overrideMin, double min, bool overrideMax, double max) + { + var definition = XChartColumnMath.DefinitionOfValueSlot(m_Dimensions, dimension); + if (definition == null) return false; + if (double.IsNaN(min) || double.IsInfinity(min) || double.IsNaN(max) || double.IsInfinity(max)) return false; + + definition.SetDomainOverride(overrideMin, min, overrideMax, max); + Publish(); // 范围变了:按版本缓存聚合/快照的工具要重读 + return true; + } + + /// + /// 删掉一列(=一个维度定义)。数值列里对应的那一格会跟着从每条记录上摘掉, + /// 所以删完之后每一行的值个数还是等于数值维个数。 + /// + /// 序号会整体前移:删第 0 列,原来的第 1 列就成了第 0 列——而工具的维度绑定按序号走 + /// (轴的 Dimension、圆柱的 X/Y/Z)。这里不回改绑定,只把事实做对;绑定要不要跟着挪是决定层的事。 + /// + public bool TryRemoveDimension(int index, out string reason) + { + reason = null; + if (index < 0 || index >= m_Dimensions.Count) + { + reason = "列号越界(现在一共 " + m_Dimensions.Count + " 列)"; + return false; + } + + var definition = m_Dimensions[index]; + if (definition == null) + { + reason = "第 " + index + " 列的定义是空的,删不动"; + return false; + } + + // 值数组按"数值维中的序号"排,不是按维度表下标排:中间夹一个非数值维时两者会错开 + // 值下标由那一条规则给(非数值列返回 -1:本来就没有格要摘) + int column = XChartColumnMath.ValueSlot(m_Dimensions, index); + + m_Dimensions.RemoveAt(index); + + if (column >= 0) + { + for (int i = 0; i < m_Records.Count; i++) + { + var record = m_Records[i]; + if (column >= record.Values.Count) continue; // 这一行短了一截:本就没有这一格 + var values = new float[record.Values.Count - 1]; + for (int j = 0, k = 0; j < record.Values.Count; j++) + if (j != column) values[k++] = record.Values[j]; + m_Records[i] = new XChartRecord(record.RecordId, record.Timestamp, values, CopyLabels(record.Labels)); + } + } + + Publish(); + return true; + } + public bool TryAddRecord(double timestamp, float[] values, string[] labels = null) { if (double.IsNaN(timestamp) || double.IsInfinity(timestamp) || values == null || values.Length != NumericDimensionCount) return false; for (int i = 0; i < values.Length; i++) if (float.IsNaN(values[i]) || float.IsInfinity(values[i])) return false; if (m_Records.Count > 0 && timestamp < m_Records[m_Records.Count - 1].Timestamp) return false; - if (m_Records.Count == Capacity) m_Records.RemoveAt(0); + if (m_Records.Count == Capacity) + { + m_Records.RemoveAt(0); + m_DroppedCount++; + } var copy = new float[values.Length]; Array.Copy(values, copy, values.Length); m_Records.Add(new XChartRecord(m_NextRecordId++, timestamp, copy, labels ?? Array.Empty())); @@ -152,11 +336,104 @@ namespace XericUI.XChart Publish(); } + // ── 就地编辑(数据窗口用;改完就 Publish,让工具按新版本重读)────── + + /// 改某条记录的某个数值维。越界或 NaN/Infinity 一律拒绝,不半改。 + public bool TrySetValue(int recordIndex, int numericDimension, double value) + { + if (recordIndex < 0 || recordIndex >= m_Records.Count) return false; + var record = m_Records[recordIndex]; + if (numericDimension < 0 || numericDimension >= record.Values.Count) return false; + if (double.IsNaN(value) || double.IsInfinity(value)) return false; + + var values = CopyValues(record.Values); + values[numericDimension] = (float)value; + m_Records[recordIndex] = new XChartRecord(record.RecordId, record.Timestamp, values, CopyLabels(record.Labels)); + Publish(); + return true; + } + + /// + /// 改时间戳。记录表必须时间非递减:新值要落在左右邻居之间(含端点)才接受, + /// 否则拒绝并把原因说清——把它放宽会让"时间窗二分定位"整个失效。 + /// + public bool TrySetTime(int recordIndex, double time, out string reason) + { + reason = null; + if (recordIndex < 0 || recordIndex >= m_Records.Count) { reason = "行号越界"; return false; } + if (double.IsNaN(time) || double.IsInfinity(time)) { reason = "不是有限数"; return false; } + + double lower = recordIndex > 0 ? m_Records[recordIndex - 1].Timestamp : double.NegativeInfinity; + double upper = recordIndex + 1 < m_Records.Count ? m_Records[recordIndex + 1].Timestamp : double.PositiveInfinity; + if (time < lower || time > upper) + { + reason = "要让时间保持非递减:得落在 " + lower.ToString("0.###") + " 与 " + upper.ToString("0.###") + " 之间"; + return false; + } + + var record = m_Records[recordIndex]; + m_Records[recordIndex] = new XChartRecord(record.RecordId, time, CopyValues(record.Values), CopyLabels(record.Labels)); + Publish(); + return true; + } + + /// 改某条记录的某个标签(下标越界或空串一律拒绝) + public bool TrySetLabel(int recordIndex, int labelIndex, string text) + { + if (recordIndex < 0 || recordIndex >= m_Records.Count) return false; + var record = m_Records[recordIndex]; + if (labelIndex < 0 || labelIndex >= record.Labels.Count) return false; + + var labels = CopyLabels(record.Labels); + labels[labelIndex] = text ?? string.Empty; + m_Records[recordIndex] = new XChartRecord(record.RecordId, record.Timestamp, CopyValues(record.Values), labels); + Publish(); + return true; + } + + /// + /// 删一条记录。时间非递减不会被破坏:有序序列去掉一个元素还是有序的, + /// 所以时间窗的二分定位照旧成立(这也是为什么这里不需要重排)。 + /// + public bool TryRemoveRecord(int recordIndex, out string reason) + { + reason = null; + if (recordIndex < 0 || recordIndex >= m_Records.Count) + { + reason = "行号越界(现在一共 " + m_Records.Count + " 行)"; + return false; + } + + m_Records.RemoveAt(recordIndex); + Publish(); + return true; + } + + private static float[] CopyValues(IReadOnlyList values) + { + var copy = new float[values.Count]; + for (int i = 0; i < values.Count; i++) copy[i] = values[i]; + return copy; + } + + /// + /// 标记数据已变更:只递增版本号并失效缓存。 + /// 以前这里每次写入都会重建一次 NativeArray 快照(O(n) 分配),流式写入下开销随条数线性增长; + /// 现在改成惰性,谁读 谁触发一次重建。 + /// public void Publish() { - var oldSnapshot = m_Snapshot; m_Version++; + m_SnapshotVersion = -1; + m_AggregateVersion = -1; + } + + private void EnsureSnapshot() + { + if (m_Snapshot != null && m_SnapshotVersion == m_Version) return; + var oldSnapshot = m_Snapshot; m_Snapshot = new XChartDataSnapshot(m_Records, NumericDimensionCount, m_Version); + m_SnapshotVersion = m_Version; oldSnapshot?.Dispose(); } @@ -164,6 +441,183 @@ namespace XericUI.XChart { m_Snapshot?.Dispose(); m_Snapshot = null; + m_SnapshotVersion = -1; + m_AggregateVersion = -1; + } + + // ── IXChartDataSource(直通实现) ───────────────────────── + + /// 直通实现:记录表本身就是存储,不需要任何映射层 + public int RecordCount => m_Records.Count; + + /// 直通实现:无映射,任何条数都能取 + public bool HasData => m_Records.Count > 0; + + /// 直通实现能当场给出全部聚合(含中位数,按需求算) + public XChartAggregateMask SupportedAggregates => XChartAggregateMask.All; + + /// 取某条记录的时间戳 + public double GetTimeAt(int recordIndex) + { + if (recordIndex < 0 || recordIndex >= m_Records.Count) return double.NaN; + return m_Records[recordIndex].Timestamp; + } + + /// 取某条记录某维的数值 + public double GetValueAt(int recordIndex, int dimension) + { + if (recordIndex < 0 || recordIndex >= m_Records.Count) return double.NaN; + var values = m_Records[recordIndex].Values; + if (dimension < 0 || dimension >= values.Count) return double.NaN; + return values[dimension]; + } + + /// + /// 取某一维的作者元数据。这里的下标是值下标(与 / + /// 同一个口径:工具绑的就是这一个数),所以表里夹着 + /// Label/Time 列时,它给的是"第 N 个数值列"那一行,而不是维度表第 N 行 + /// (换算只有一处:)。 + /// + public bool TryGetDimension(int dimension, out XChartDimensionDefinition definition) + { + definition = XChartColumnMath.DefinitionOfValueSlot(m_Dimensions, dimension); + return definition != null; + } + + /// + /// 一次扫描算 Count/First/Last/Min/Max/Sum/Mean/Rms;中位数单独排序一次。 + /// 结果按(版本, 维度)缓存,请求的是缓存子集时直接复用。 + /// + public bool TryGetAggregates(int dimension, XChartAggregateMask mask, out XChartAggregates aggregates) + { + aggregates = default; + if (mask == XChartAggregateMask.None) return false; + if (dimension < 0 || dimension >= NumericDimensionCount) return false; + + if (m_AggregateVersion == m_Version && m_AggregateDimension == dimension + && (mask & ~m_AggregateCache.Computed) == XChartAggregateMask.None) + { + aggregates = m_AggregateCache; + return true; + } + + int count = m_Records.Count; + double minimum = double.MaxValue, maximum = double.MinValue; + double sum = 0d, squareSum = 0d; + double first = double.NaN, last = double.NaN; + int valid = 0; + + for (int i = 0; i < count; i++) + { + double value = GetValueAt(i, dimension); + if (double.IsNaN(value) || double.IsInfinity(value)) continue; + if (valid == 0) first = value; + last = value; + if (value < minimum) minimum = value; + if (value > maximum) maximum = value; + sum += value; + squareSum += value * value; + valid++; + } + + var result = default(XChartAggregates); + if (valid == 0) + { + result.Set(XChartAggregateKind.Count, 0); + if ((mask & XChartAggregateMask.First) != 0) result.Set(XChartAggregateKind.First, double.NaN); + if ((mask & XChartAggregateMask.Last) != 0) result.Set(XChartAggregateKind.Last, double.NaN); + if ((mask & XChartAggregateMask.Minimum) != 0) result.Set(XChartAggregateKind.Minimum, double.NaN); + if ((mask & XChartAggregateMask.Maximum) != 0) result.Set(XChartAggregateKind.Maximum, double.NaN); + if ((mask & XChartAggregateMask.Sum) != 0) result.Set(XChartAggregateKind.Sum, 0d); + if ((mask & XChartAggregateMask.Mean) != 0) result.Set(XChartAggregateKind.Mean, double.NaN); + if ((mask & XChartAggregateMask.Rms) != 0) result.Set(XChartAggregateKind.Rms, double.NaN); + if ((mask & XChartAggregateMask.Median) != 0) result.Set(XChartAggregateKind.Median, double.NaN); + } + else + { + if ((mask & XChartAggregateMask.Count) != 0) result.Set(XChartAggregateKind.Count, valid); + if ((mask & XChartAggregateMask.First) != 0) result.Set(XChartAggregateKind.First, first); + if ((mask & XChartAggregateMask.Last) != 0) result.Set(XChartAggregateKind.Last, last); + if ((mask & XChartAggregateMask.Minimum) != 0) result.Set(XChartAggregateKind.Minimum, minimum); + if ((mask & XChartAggregateMask.Maximum) != 0) result.Set(XChartAggregateKind.Maximum, maximum); + if ((mask & XChartAggregateMask.Sum) != 0) result.Set(XChartAggregateKind.Sum, sum); + if ((mask & XChartAggregateMask.Mean) != 0) result.Set(XChartAggregateKind.Mean, sum / valid); + if ((mask & XChartAggregateMask.Rms) != 0) result.Set(XChartAggregateKind.Rms, Math.Sqrt(squareSum / valid)); + if ((mask & XChartAggregateMask.Median) != 0) result.Set(XChartAggregateKind.Median, ComputeMedian(dimension)); + } + + m_AggregateVersion = m_Version; + m_AggregateDimension = dimension; + m_AggregateCache = result; + aggregates = result; + return true; + } + + /// + /// 中位数:把该维的有效样本拷进复用的 scratch 数组排序后取中位。 + /// 桶/窗口级样本量小,排序足够;真要全量流式中位数再考虑 P² / t-digest。 + /// + private double ComputeMedian(int dimension) + { + int count = m_Records.Count; + int valid = 0; + if (m_MedianScratch == null || m_MedianScratch.Length < count) + m_MedianScratch = new double[Mathf.Max(count, 16)]; + + for (int i = 0; i < count; i++) + { + double value = GetValueAt(i, dimension); + if (double.IsNaN(value) || double.IsInfinity(value)) continue; + m_MedianScratch[valid++] = value; + } + if (valid == 0) return double.NaN; + + Array.Sort(m_MedianScratch, 0, valid); + int middle = valid / 2; + if ((valid & 1) == 1) return m_MedianScratch[middle]; + return (m_MedianScratch[middle - 1] + m_MedianScratch[middle]) * 0.5d; + } + + /// + /// 直通的范围游标:时间非递减(写入时强制),二分定位窗口。 + /// 以后换成桶/环形缓冲实现时,外面这一层调用方式不变。 + /// + public XChartRangeCursor OpenRange(int dimension, double fromTime, double toTime) + { + var cursor = new XChartRangeCursor + { + Source = this, + Dimension = dimension, + Index = LowerBound(fromTime), + EndExclusive = UpperBound(toTime), + }; + return cursor; + } + + /// 第一个时间戳 >= time 的下标 + private int LowerBound(double time) + { + int low = 0, high = m_Records.Count; + while (low < high) + { + int mid = (low + high) / 2; + if (m_Records[mid].Timestamp < time) low = mid + 1; + else high = mid; + } + return low; + } + + /// 第一个时间戳 > time 的下标 + private int UpperBound(double time) + { + int low = 0, high = m_Records.Count; + while (low < high) + { + int mid = (low + high) / 2; + if (m_Records[mid].Timestamp <= time) low = mid + 1; + else high = mid; + } + return low; } private static string[] CopyLabels(IReadOnlyList labels) diff --git a/Runtime/XChart/XChartDataSource.cs b/Runtime/XChart/XChartDataSource.cs new file mode 100644 index 0000000..8755523 --- /dev/null +++ b/Runtime/XChart/XChartDataSource.cs @@ -0,0 +1,188 @@ +using System; + +namespace XericUI.XChart +{ + /// 可向数据源索取的聚合量 + public enum XChartAggregateKind + { + Count, + First, + Last, + Minimum, + Maximum, + Sum, + Mean, + Rms, + Median, + } + + /// 聚合量集合(可按位组合,一次扫描一并算出) + [Flags] + public enum XChartAggregateMask + { + None = 0, + Count = 1 << 0, + First = 1 << 1, + Last = 1 << 2, + Minimum = 1 << 3, + Maximum = 1 << 4, + Sum = 1 << 5, + Mean = 1 << 6, + Rms = 1 << 7, + Median = 1 << 8, + + /// 数据范围(轴线自动缩放最常用的两个) + Range = Minimum | Maximum, + /// 默认集合 + Default = Count | Minimum | Maximum, + All = Count | First | Last | Minimum | Maximum | Sum | Mean | Rms | Median, + } + + /// + /// 聚合结果。 标明哪些字段真的被算过(其余字段无意义)。 + /// + public struct XChartAggregates + { + public XChartAggregateMask Computed; + + public int Count; + public double First; + public double Last; + public double Minimum; + public double Maximum; + public double Sum; + public double Mean; + public double Rms; + public double Median; + + /// 是否算过某项 + public bool Has(XChartAggregateKind kind) => (Computed & ToMask(kind)) != 0; + + /// 数据范围(需算过 Minimum/Maximum) + public double Range => Maximum - Minimum; + + /// 取某项,没算过则返回 fallback + public double Get(XChartAggregateKind kind, double fallback) + { + switch (kind) + { + case XChartAggregateKind.Count: return Has(kind) ? Count : fallback; + case XChartAggregateKind.First: return Has(kind) ? First : fallback; + case XChartAggregateKind.Last: return Has(kind) ? Last : fallback; + case XChartAggregateKind.Minimum: return Has(kind) ? Minimum : fallback; + case XChartAggregateKind.Maximum: return Has(kind) ? Maximum : fallback; + case XChartAggregateKind.Sum: return Has(kind) ? Sum : fallback; + case XChartAggregateKind.Mean: return Has(kind) ? Mean : fallback; + case XChartAggregateKind.Rms: return Has(kind) ? Rms : fallback; + case XChartAggregateKind.Median: return Has(kind) ? Median : fallback; + default: return fallback; + } + } + + public static XChartAggregateMask ToMask(XChartAggregateKind kind) => (XChartAggregateMask)(1 << (int)kind); + + /// 把单项结果并进结果集 + public void Set(XChartAggregateKind kind, double value) + { + switch (kind) + { + case XChartAggregateKind.Count: Count = (int)value; break; + case XChartAggregateKind.First: First = value; break; + case XChartAggregateKind.Last: Last = value; break; + case XChartAggregateKind.Minimum: Minimum = value; break; + case XChartAggregateKind.Maximum: Maximum = value; break; + case XChartAggregateKind.Sum: Sum = value; break; + case XChartAggregateKind.Mean: Mean = value; break; + case XChartAggregateKind.Rms: Rms = value; break; + case XChartAggregateKind.Median: Median = value; break; + } + Computed |= ToMask(kind); + } + } + + /// + /// 范围游标(虚拟指针):按时间窗在某一维上顺序读取,不暴露底层存储。 + /// + /// 它是为"以后换成桶结构 / 环形缓冲 / 分层预聚合"预留的把手:调用方只认 + /// "打开一个范围、逐个 MoveNext",底层是数组直通、桶、还是 ring,都换得来。 + /// 默认实现( 直通)就是按下标走记录表。 + /// + public struct XChartRangeCursor + { + internal IXChartDataSource Source; + internal int Dimension; + internal int EndExclusive; + + /// 当前记录下标;开始时等于范围的起点 + public int Index; + + /// 游标是否还有当前位置 + public bool IsValid => Source != null && Index >= 0 && Index < EndExclusive; + + /// 当前记录的时间戳 + public double Time => Source != null ? Source.GetTimeAt(Index) : double.NaN; + + /// 当前记录的数值(打开游标时指定的维度) + public double Value => Source != null ? Source.GetValueAt(Index, Dimension) : double.NaN; + + /// 前进一格;返回新位置是否有效 + public bool MoveNext() + { + Index++; + return IsValid; + } + + /// 范围内剩余记录数(含当前) + public int Remaining => Source == null ? 0 : Math.Max(0, EndExclusive - Index); + } + + /// + /// 图表数据访问的唯一中转口。 + /// + /// 为什么要有它:元素(网格背景 / 轴线 / 数据图元)不该直接摸记录数组。 + /// 一旦它们只认这个接口,"数据怎么存"就变成可替换的实现细节——今天是数组直通, + /// 明天可以是一个包着环形缓冲 + 桶统计的实现( 已经 + /// 具备那套能力),元素一行都不用改。 + /// + /// 版本号是脏判定的统一依据:任何写入都会让 递增, + /// 需要缓存的元素只需比对这个号,不要再自己发明"成员变了吗"这类判据。 + /// + public interface IXChartDataSource + { + /// 数据版本号:每次写入递增 + long Version { get; } + + /// 数值维度数量 + int NumericDimensionCount { get; } + + /// 是否有数据 + bool HasData { get; } + + /// 记录条数 + int RecordCount { get; } + + /// 本实现能直接给出的聚合集合(其余可现算,或声明不支持) + XChartAggregateMask SupportedAggregates { get; } + + /// + /// 取某一维的聚合量。默认实现一次扫描算出 Count/First/Last/Min/Max/Sum/Rms, + /// 中位数另需排序(桶内样本数小,直接排序即可)。 + /// + bool TryGetAggregates(int dimension, XChartAggregateMask mask, out XChartAggregates aggregates); + + /// 取某条记录的时间戳(直通实现不需要映射,直接读) + double GetTimeAt(int recordIndex); + + /// 取某条记录某维的数值 + double GetValueAt(int recordIndex, int dimension); + + /// + /// 取某一维的作者元数据(显示名 / 格式化串 / 维度类型)。轴线的"数据直驱标签" + /// 用它拿默认格式,标签模式用它拿显示名。下标越界返回 false(不抛,渲染路径里调用)。 + /// + bool TryGetDimension(int dimension, out XChartDimensionDefinition definition); + + /// 按时间窗打开一个范围游标(虚拟指针) + XChartRangeCursor OpenRange(int dimension, double fromTime, double toTime); + } +} \ No newline at end of file diff --git a/Runtime/XChart/XChartDataSource.cs.meta b/Runtime/XChart/XChartDataSource.cs.meta new file mode 100644 index 0000000..0606f23 --- /dev/null +++ b/Runtime/XChart/XChartDataSource.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 94b99e7f4512429487d6c674ce3b1061 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/XChartDataText.cs b/Runtime/XChart/XChartDataText.cs new file mode 100644 index 0000000..b2fc970 --- /dev/null +++ b/Runtime/XChart/XChartDataText.cs @@ -0,0 +1,338 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.Text; + +namespace XericUI.XChart +{ + /// + /// 图表数据的文本序列化:导出 / 导入 / 复制粘贴共用这一份格式定义 + /// (规范 §3 的作用域纪律:不许导出写一套、粘贴再写一套)。 + /// + /// 为什么是"行文本"而不是 JSON:运行时程序集现在没有可依赖的 JSON 库, + /// 手写一个 JSON 解析器等于自己造一个容易错的轮子;而行文本(制表符分隔)能直接丢进表格软件看、 + /// 在编辑器里逐行 diff、粘贴替换也不需要转义嵌套。字段名与顺序就是格式的一部分,见下。 + /// + /// + /// XCHART-DATA 2 + /// DIM <key> <displayName> <kind> <format> <ovMin:0/1> <ovMax:0/1> <manualMin> <manualMax> ← 每个维度一行,顺序即维度下标 + /// REC <timestamp> <v0> <v1> … ← 每条记录一行;数值个数=数值维个数 + /// + /// + /// 为什么是 2:第 1 版只带得出"两端一起覆盖"(两个数相等=没覆盖), + /// 而分侧覆盖(钉住最小、最大自由)是常态——两个标记位必须各自落进文件,否则导出再导回来 + /// 会把"只钉一端"读成"两端都钉"。旧文件()仍按第 1 版口径读, + /// 两种表头的字段布局不同,所以版本必须来自表头本身,不能靠数字猜。 + /// + /// 精度:数值一律按往返精度("R")写、按不变文化读——0.00 那种写法会在 + /// 导出→导入之间静默丢精度,而这类丢精度在图上只表现为"点挪了一点点",最难查。 + /// + /// 失败语义:导入是全有或全无——任何一行不合法就整份拒绝并指出行号, + /// 不半途替换掉一半数据(半份数据比没数据更坏)。 + /// + public static class XChartDataText + { + public const string HeaderLine = "XCHART-DATA 2"; + /// 第 1 版表头:只带"两端一起"的覆盖(<min> <max> 直接跟在格式串后面),仍读得动 + public const string LegacyHeaderLine = "XCHART-DATA 1"; + public const string DimensionPrefix = "DIM"; + public const string RecordPrefix = "REC"; + + private const char Tab = (char)9; + private const char NewLine = (char)10; + + /// 导出成文本(维度定义 + 全部记录) + public static string Export(XChartDataModel model) + { + if (model == null) return HeaderLine + NewLine; + + var builder = new StringBuilder(); + builder.Append(HeaderLine).Append(NewLine); + + for (int i = 0; i < model.Dimensions.Count; i++) + { + var dimension = model.Dimensions[i]; + if (dimension == null) continue; + var over = dimension.DomainOverride; + builder.Append(DimensionPrefix).Append(Tab) + .Append(Escape(dimension.Key)).Append(Tab) + .Append(Escape(dimension.DisplayName)).Append(Tab) + .Append(dimension.Kind.ToString()).Append(Tab) + .Append(Escape(dimension.Format)).Append(Tab) + // 标记位与两端值各写各的:没钉住的那一端也要把数留着, + // 否则导回来就变成"从没填过",下一次勾上时格子是空的 + .Append(over.HasMin ? "1" : "0").Append(Tab) + .Append(over.HasMax ? "1" : "0").Append(Tab) + .Append(dimension.ManualRange.x.ToString("R", CultureInfo.InvariantCulture)).Append(Tab) + .Append(dimension.ManualRange.y.ToString("R", CultureInfo.InvariantCulture)) + .Append(NewLine); + } + + int numericCount = model.NumericDimensionCount; + for (int r = 0; r < model.RecordCount; r++) + { + builder.Append(RecordPrefix).Append(Tab) + .Append(model.GetTimeAt(r).ToString("R", CultureInfo.InvariantCulture)); + for (int d = 0; d < numericCount; d++) + { + builder.Append(Tab) + .Append(model.GetValueAt(r, d).ToString("R", CultureInfo.InvariantCulture)); + } + + var record = model.Records[r]; + for (int l = 0; l < record.Labels.Count; l++) + builder.Append(Tab).Append(Escape(record.Labels[l])); + + builder.Append(NewLine); + } + + return builder.ToString(); + } + + /// 把一行拆成字段(制表符分隔;不做引号语法——制表符与换行在写入时已被转义) + public static string[] SplitFields(string line) + { + if (string.IsNullOrEmpty(line)) return new string[0]; + var fields = new List(); + int start = 0; + for (int i = 0; i < line.Length; i++) + { + if (line[i] != Tab) continue; + fields.Add(Unescape(line.Substring(start, i - start))); + start = i + 1; + } + fields.Add(Unescape(line.Substring(start))); + return fields.ToArray(); + } + + /// + /// 导入: 为真=整表替换,为假=追加。 + /// 先解析成临时结果、全部合法才落到目标上——失败时不留下半份数据。 + /// + public static bool TryImport(string text, XChartDataModel target, bool replace, out string error) + { + error = null; + if (target == null) { error = "没有目标数据模型"; return false; } + if (text == null) { error = "文本为空"; return false; } + + var lines = text.Replace("\r\n", "\n").Replace('\r', '\n').Split('\n'); + var dimensions = new List(); + var timestamps = new List(); + var recordValues = new List(); + var recordLabels = new List(); + bool sawHeader = false; + bool legacyLayout = false; // 字段布局由表头定,不由"像不像数字"定 + + for (int i = 0; i < lines.Length; i++) + { + string line = lines[i]; + if (line.Length == 0) continue; + if (!sawHeader) + { + if (line == HeaderLine) legacyLayout = false; + else if (line == LegacyHeaderLine) legacyLayout = true; + else + { + error = "第 " + (i + 1) + " 行不是表头(应以 " + HeaderLine + " 或 " + LegacyHeaderLine + " 开头)"; + return false; + } + sawHeader = true; + continue; + } + + string[] fields = SplitFields(line); + if (fields.Length == 0) continue; + + if (fields[0] == DimensionPrefix) + { + if (fields.Length < 4) + { + error = "第 " + (i + 1) + " 行的维度定义少了字段(需要 key / 显示名 / 种类)"; + return false; + } + + XChartDimensionKind kind; + if (!TryParseKind(fields[3], out kind)) + { + error = "第 " + (i + 1) + " 行的维度种类无法识别:" + fields[3]; + return false; + } + + var dimension = new XChartDimensionDefinition(fields[1], fields[2], kind); + if (fields.Length >= 5 && !string.IsNullOrEmpty(fields[4])) dimension.Format = fields[4]; + + // 覆盖段的长度由版本定:v1 是 ` `(两端一起),v2 是 ` `。 + // 只给"少一截"的行报错,不静默丢掉半个覆盖——字段数对不上就是这份文本被改坏了。 + int full = legacyLayout ? 7 : 9; + if (fields.Length != 4 && fields.Length != 5 && fields.Length != full) + { + error = "第 " + (i + 1) + " 行的维度定义字段数不对(要 4、5 或 " + full + " 个,现在 " + + fields.Length + " 个)"; + return false; + } + + if (fields.Length == full) + { + double manualMin, manualMax; + if (legacyLayout) + { + // 第 1 版没有分侧标记:两个数相等=没覆盖(那正是当时的"一起覆盖"口径) + if (!TryParseFinite(fields[5], out manualMin) || !TryParseFinite(fields[6], out manualMax)) + { + error = "第 " + (i + 1) + " 行的覆盖范围不是有限数字(" + fields[5] + " / " + fields[6] + ")"; + return false; + } + dimension.SetRangeOverride(manualMin, manualMax); + } + else + { + bool pinMin, pinMax; + if (!TryParseFlag(fields[5], out pinMin) || !TryParseFlag(fields[6], out pinMax)) + { + error = "第 " + (i + 1) + " 行的覆盖标记只能是 0 或 1(" + fields[5] + " / " + fields[6] + ")"; + return false; + } + if (!TryParseFinite(fields[7], out manualMin) || !TryParseFinite(fields[8], out manualMax)) + { + error = "第 " + (i + 1) + " 行的覆盖端点不是有限数字(" + fields[7] + " / " + fields[8] + ")"; + return false; + } + dimension.SetDomainOverride(pinMin, manualMin, pinMax, manualMax); + } + } + + dimensions.Add(dimension); + continue; + } + + if (fields[0] == RecordPrefix) + { + if (dimensions.Count == 0) + { + error = "第 " + (i + 1) + " 行是记录,但前面没有任何 DIM 行(先声明维度)"; + return false; + } + + double timestamp; + if (!TryParseDouble(fields[1], out timestamp)) + { + error = "第 " + (i + 1) + " 行的时间戳不是数字"; + return false; + } + + int numericCount = 0; + for (int d = 0; d < dimensions.Count; d++) + if (dimensions[d].Kind == XChartDimensionKind.Number) numericCount++; + + if (fields.Length - 2 < numericCount) + { + error = "第 " + (i + 1) + " 行的数值个数(" + (fields.Length - 2) + ")少于数值维个数(" + numericCount + ")"; + return false; + } + + var values = new float[numericCount]; + for (int d = 0; d < numericCount; d++) + { + double value; + if (!TryParseDouble(fields[2 + d], out value)) + { + error = "第 " + (i + 1) + " 行第 " + (d + 1) + " 个数值不是数字:" + fields[2 + d]; + return false; + } + if (double.IsNaN(value) || double.IsInfinity(value)) + { + error = "第 " + (i + 1) + " 行第 " + (d + 1) + " 个数值是 NaN/Infinity,记录表不收这种值"; + return false; + } + values[d] = (float)value; + } + + var labels = new string[Math.Max(fields.Length - 2 - numericCount, 0)]; + for (int l = 0; l < labels.Length; l++) labels[l] = fields[2 + numericCount + l]; + + timestamps.Add(timestamp); + recordValues.Add(values); + recordLabels.Add(labels); + continue; + } + + error = "第 " + (i + 1) + " 行无法识别(应以 " + DimensionPrefix + " 或 " + RecordPrefix + " 开头)"; + return false; + } + + if (!sawHeader) { error = "文本只有空白(缺少表头)"; return false; } + if (dimensions.Count == 0) { error = "没有任何 DIM 行"; return false; } + + // 到这里才动目标:先定义维度(会重排既有记录的数值个数),再灌记录 + target.SetDimensions(dimensions); + if (replace) target.Clear(); + + for (int i = 0; i < timestamps.Count; i++) + { + if (!target.TryAddRecord(timestamps[i], recordValues[i], recordLabels[i])) + { + error = "第 " + (i + 1) + " 条记录没能写进模型(时间必须非递减、数值个数要对得上)"; + return false; + } + } + + return true; + } + + private static bool TryParseKind(string text, out XChartDimensionKind kind) + { + kind = XChartDimensionKind.Number; + if (string.IsNullOrEmpty(text)) return false; + switch (text) + { + case "Number": kind = XChartDimensionKind.Number; return true; + case "Time": kind = XChartDimensionKind.Time; return true; + case "Label": kind = XChartDimensionKind.Label; return true; + default: + int raw; + if (int.TryParse(text, out raw) && raw >= 0 && raw <= 2) + { + kind = (XChartDimensionKind)raw; + return true; + } + return false; + } + } + + private static bool TryParseDouble(string text, out double value) + { + return double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out value); + } + + /// + /// 覆盖端点:必须是有限数。文本里写得出 NaN / Infinity,而这两个数一旦当成 + /// 范围端点,整条轴会安静地什么都不画——那是"导入成功但图空了"最难查的一条路,所以在门口就拒。 + /// + private static bool TryParseFinite(string text, out double value) + { + if (!TryParseDouble(text, out value)) return false; + if (double.IsNaN(value) || double.IsInfinity(value)) { value = 0.0; return false; } + return true; + } + + /// 分侧覆盖的标记位:只认 0 / 1(别的写法一律算这份文本被改坏了) + private static bool TryParseFlag(string text, out bool value) + { + value = false; + if (text == "0") return true; + if (text == "1") { value = true; return true; } + return false; + } + + private static string Escape(string text) + { + if (string.IsNullOrEmpty(text)) return string.Empty; + return text.Replace(Tab, ' ').Replace('\n', ' ').Replace('\r', ' '); + } + + private static string Unescape(string text) + { + return text ?? string.Empty; + } + } +} \ No newline at end of file diff --git a/Runtime/XChart/XChartDataText.cs.meta b/Runtime/XChart/XChartDataText.cs.meta new file mode 100644 index 0000000..2f54419 --- /dev/null +++ b/Runtime/XChart/XChartDataText.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 9be2b3c5a1fa7e34b9102c49ac7abb38 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/XChartDomainMath.cs b/Runtime/XChart/XChartDomainMath.cs new file mode 100644 index 0000000..b13a085 --- /dev/null +++ b/Runtime/XChart/XChartDomainMath.cs @@ -0,0 +1,139 @@ +using UnityEngine; + +namespace XericUI.XChart +{ + /// + /// 一维的覆盖请求:哪几端被钉住、钉成多少。 + /// + /// 为什么要分侧( / 各一个):验收时他要的是 + /// "最小值必须得是 0,最大值让它自由发挥"——一个总的开关只能表达"两端都钉住"或"两端都自由", + /// 而"钉一端"是常见形态(把轴的原点按住,让另一端跟数据走)。 + /// + public readonly struct XChartDomainOverride + { + public readonly bool HasMin; + public readonly double Min; + public readonly bool HasMax; + public readonly double Max; + + public XChartDomainOverride(bool hasMin, double min, bool hasMax, double max) + { + HasMin = hasMin; + Min = min; + HasMax = hasMax; + Max = max; + } + + /// 两端都没钉(=完全跟着该维聚合走) + public static XChartDomainOverride None => new XChartDomainOverride(false, 0.0, false, 0.0); + } + + /// + /// 显示范围(domain)解析的纯函数:只吃标量,不碰 Unity 对象, + /// 所以编译门里的 mono 探针能把这几条规则逐条当断言跑(含反向变异对照)。 + /// + /// 规则(顺序就是优先级): + /// + /// 钉住的端优先:每一端各问各的——钉了就用填的值,没钉就用该维聚合。 + /// 只钉了一端、而另一端连聚合都没有时,以钉住的那端为中心展开 ±: + /// 这跟"两端都钉住但填成同一个值"同一处理,都是为了避开零宽域上的除零。 + /// 钉住的一端比自由端的聚合还靠外(或写反了)⇒ 自动排序。手滑填反不该让整条轴什么都不画, + /// 也不该画出一段反向的轴。 + /// 什么都没钉、聚合也没有 → false,调用者这帧什么都不画(不是画在 0 上)。 + /// + /// + /// 入口只有一个:拿数据源问范围请走 + /// (它读维度行的覆盖 + 该维聚合,再调下面这条纯规则)。渲染上下文、面板、数据窗口都从这里问, + /// 于是"这条轴现在画哪一段"这件事全图只有一份算法。 + /// + public static class XChartDomainMath + { + /// 退化范围的中心展开半径(数据全是同一个值、或只钉了一端又没有聚合时用) + public const double DegeneratePad = 0.5; + + /// 这一维现在要钉住什么:覆盖请求就存在 chart 的维度行里("范围归数据、工具只呈现") + public static XChartDomainOverride OverrideOf(IXChartDataSource data, int dimension) + { + XChartDimensionDefinition definition; + if (data == null || !data.TryGetDimension(dimension, out definition) || definition == null) + return XChartDomainOverride.None; + return definition.DomainOverride; + } + + /// + /// 解析某维的显示范围(所有人问范围的同一扇门):覆盖来自维度行, + /// 自由端来自该维的聚合。规则明细见类型注释。 + /// + public static bool TryResolve(IXChartDataSource data, int dimension, out double min, out double max) + { + min = 0.0; + max = 1.0; + if (data == null) return false; + + XChartAggregates aggregates = default; + bool has = data.TryGetAggregates(dimension, XChartAggregateMask.Range, out aggregates) + && aggregates.Has(XChartAggregateKind.Minimum) + && aggregates.Has(XChartAggregateKind.Maximum); + + return TryResolve(OverrideOf(data, dimension), has, + has ? aggregates.Minimum : 0.0, has ? aggregates.Maximum : 0.0, out min, out max); + } + + public static bool TryResolve(XChartDomainOverride over, bool hasAggregates, double aggregateMin, + double aggregateMax, out double min, out double max) + { + min = 0.0; + max = 0.0; + + bool aggregatesUsable = hasAggregates + && !double.IsNaN(aggregateMin) && !double.IsNaN(aggregateMax) + && !double.IsInfinity(aggregateMin) && !double.IsInfinity(aggregateMax); + + // 两端都没钉:纯聚合口径 + if (!over.HasMin && !over.HasMax) + { + if (!aggregatesUsable) return false; + if (aggregateMax > aggregateMin) + { + min = aggregateMin; + max = aggregateMax; + return true; + } + min = aggregateMin - DegeneratePad; + max = aggregateMin + DegeneratePad; + return true; + } + + // 钉住的一端用填的值,自由的一端用聚合(聚合没有就是 NaN,下面按"没有依据"处理) + double lower = over.HasMin ? over.Min : (aggregatesUsable ? aggregateMin : double.NaN); + double upper = over.HasMax ? over.Max : (aggregatesUsable ? aggregateMax : double.NaN); + + if (double.IsNaN(lower) || double.IsNaN(upper)) + { + // 只钉了一端,另一端没有任何依据 ⇒ 以钉住的这端为中心展开(零宽的域画不出东西) + double anchor = over.HasMin ? over.Min : over.Max; + min = anchor - DegeneratePad; + max = anchor + DegeneratePad; + return true; + } + + if (upper < lower) + { + double swap = lower; + lower = upper; + upper = swap; + } + + if (upper == lower) + { + min = lower - DegeneratePad; + max = lower + DegeneratePad; + return true; + } + + min = lower; + max = upper; + return true; + } + } +} diff --git a/Runtime/XChart/XChartDomainMath.cs.meta b/Runtime/XChart/XChartDomainMath.cs.meta new file mode 100644 index 0000000..153c3c8 --- /dev/null +++ b/Runtime/XChart/XChartDomainMath.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f718fdc679333664595bd647cc6f8e21 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/XChartElementConfig.cs b/Runtime/XChart/XChartElementConfig.cs new file mode 100644 index 0000000..f864dbd --- /dev/null +++ b/Runtime/XChart/XChartElementConfig.cs @@ -0,0 +1,161 @@ +using System; +using System.Collections.Generic; +using UnityEngine; + +namespace XericUI.XChart +{ + /// + /// 元素注册标记:凡是带它的 派生类,都会被编辑器的 + /// "添加元素"菜单列出来( 是稳定标识,改名不改 id)。 + /// + [AttributeUsage(AttributeTargets.Class, Inherited = false)] + public sealed class XChartElementAttribute : Attribute + { + /// 稳定标识(序列化无关,供菜单/查找用) + public string Id { get; } + + /// Inspector 菜单里显示的名字 + public string DisplayName { get; } + + /// 菜单排序 + public int MenuOrder { get; } + + public XChartElementAttribute(string id, string displayName, int menuOrder = 0) + { + Id = id; + DisplayName = string.IsNullOrEmpty(displayName) ? id : displayName; + MenuOrder = menuOrder; + } + } + + /// + /// 元素配置基类——元素的作者数据。 + /// + /// 它同时是三样东西: + /// + /// 图表的序列化内容:由图表用 [SerializeReference] 列表持有,所以每个元素 + /// 自带自己的配置,图表组件不必再为每个元素声明一堆字段并逐个 Sync。 + /// Inspector 上的界面:Unity 对 [SerializeReference] 的支持本身就是"接口协议"—— + /// 列表里每个元素按实际类型展开、显示它自己的字段,派生类不需要写自定义 Editor。 + /// 元素的工厂与装配点: 造元素实例, + /// 把配置灌进去。轴线、网格背景、以后任何东西都走这一条路。 + /// + /// + /// 方向是单向的:配置是作者数据,元素是运行时实例。所以主流程只走 + /// 配置 -> 元素(); 只给编辑器做 + /// "把当前元素状态收回配置"的可选操作,运行时不需要。 + /// + [Serializable] + public abstract class XChartElementConfig + { + [SerializeField] private bool m_Enabled = true; + + /// + /// 注册序:谁先建、谁先更新(§11.4 的"注册 order")。它不再是绘制序—— + /// 想让某个元素"先算但后画"(比如轴线的线画在点上面)用 。 + /// + [SerializeField] private int m_OrderIndex; + + /// 绘制序(画家序):小者先画、大者盖在上面;只在同一分组内比较(分组见 XChartToolCategory) + [SerializeField] private int m_DrawOrder; + + /// 是否参与加载(关掉后元素不创建,但配置留在图表上) + public bool Enabled + { + get => m_Enabled; + set => m_Enabled = value; + } + + /// 注册序(越小越先建、越先更新;与绘制序分开) + public int OrderIndex + { + get => m_OrderIndex; + set => m_OrderIndex = value; + } + + /// 绘制序(越小越先画;同分组内比较) + public int DrawOrder + { + get => m_DrawOrder; + set => m_DrawOrder = value; + } + + /// 元素在 ToolsRoot 下的名字,默认取类型名 + public virtual string ElementName => GetType().Name; + + /// + /// 造一个元素实例。基类拿不到具体类型,所以由每个配置自己 new 出对应的元素; + /// 这里不接触 ToolsManager,也不做初始化(初始化由图表按统一流程完成)。 + /// + public abstract XChartToolBase CreateTool(); + + /// + /// 把配置灌进元素。调用时机:元素已 AddTool 完成(子节点/渲染器都已建好)。 + /// + public abstract void ApplyTo(XChartToolBase tool); + + /// 从元素回读当前状态(编辑器里的"拾取",可选实现) + public virtual void CaptureFrom(XChartToolBase tool) { } + + /// + /// 这个元素要几个数值维才画得出来(0=无所谓,比如几何是常量的元素)。 + /// + /// 面板拿它跟表里现有的数值维数对一下印出来:向量箭头要 6 维,而表里只有 x/y/z 三列时它 + /// 一条都不画——那时画面上什么都没有,报表里也只是几个 0,人只能猜 + /// (他 2026-10-25:"我把它添加进来了,之后它并没有显示出来,我现在是有默认数据在里面的")。 + /// 需求是多少、现有是多少,两个数一起印才分得清"没数据"和"数据形状不对"。 + /// + public virtual int RequiredNumericDimensions => 0; + + /// + /// 互斥显示: 这个字段在当前配置下要不要从面板上藏掉。 + /// + /// 他 2026-10-25 要的用法:"我勾选'连续绘制',配置里就失去'相对还是绝对'那个选项; + /// 取消勾选,那个选项又回来"。判据写在配置自己身上(它读的是自己的字段), + /// 面板只负责照着藏——不在面板里给某个元素写特例,也不做两套开关防止互相矛盾。 + /// + public virtual bool IsFieldHidden(string fieldName) => false; + } + + /// + /// 元素表的纯算部分(离线可验,不碰 Unity 对象)。 + /// + public static class XChartElementTable + { + /// + /// 表里第一份这一类(含派生)配置的下标,没有则 -1。 + /// + /// 为什么单独拎出来:默认元素按类型去重就靠它。图表初始化会跑很多遍 + /// (域重载、预制体开合、进 Play),DeclareDefaultElements 每遍都被问一次; + /// 不去重的结果是"每重载一次多一个背景"——同一批格线画两遍、边越描越粗, + /// 而他看到的只是"图好像越来越糊"。这类"多出来的那一份"必须在能算的地方算清, + /// 而不是留在 MonoBehaviour 里等现场撞见。 + /// + public static int IndexOfKind(IReadOnlyList elements, Type kind) + { + if (elements == null || kind == null) return -1; + for (int i = 0; i < elements.Count; i++) + { + // 空槽(被清掉的那一条)跳过,不算命中:它既不是这一类,也不该把这一类挡在外面 + var element = elements[i]; + if (element != null && kind.IsInstanceOfType(element)) return i; + } + return -1; + } + + /// 表里已经有这一类了吗( 的是/否写法) + public static bool HasKind(IReadOnlyList elements, Type kind) + => IndexOfKind(elements, kind) >= 0; + + /// + /// 这一类配置的第一条,没有则 null。 + /// "哪一条是这一类"只许有这一个答法:判重用下标、脚本入口用实例,两条查找各写一遍 + /// 迟早答得不同(本轮拆掉的正是"两处存同一件事"这一族)。 + /// + public static XChartElementConfig FirstOfKind(IReadOnlyList elements, Type kind) + { + int at = IndexOfKind(elements, kind); + return at >= 0 ? elements[at] : null; + } + } +} \ No newline at end of file diff --git a/Runtime/XChart/XChartElementConfig.cs.meta b/Runtime/XChart/XChartElementConfig.cs.meta new file mode 100644 index 0000000..826f57f --- /dev/null +++ b/Runtime/XChart/XChartElementConfig.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a6fb5d1c512f48c389de12b5bfa224f9 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/XChartRenderContext.cs b/Runtime/XChart/XChartRenderContext.cs new file mode 100644 index 0000000..ad7ac0c --- /dev/null +++ b/Runtime/XChart/XChartRenderContext.cs @@ -0,0 +1,74 @@ +using System; +using UnityEngine; +using XericUI.XChart.Mesh; +using XericUI.XChart.Space; + +namespace XericUI.XChart +{ + /// + /// 渲染上下文:由 chart 建立并持有,工具只读(规范 §2)。 + /// + /// 它替代"工具自己去 FindTool 找邻居"的写法:空间、数据、显示范围都从这里拿。 + /// 于是"谁给谁投影"这件事在图这一层就定了,工具里没有第二条查找路径, + /// 也不会出现两个工具各自算一遍投影、点落不进盒子那种事。 + /// + /// 可以返回 null: 在初始化早期或重建过程中可能还没有, + /// 工具必须判空并跳过这一帧(不抛、也不拿旧的空间凑数)。 + /// + public interface IXChartRenderContext + { + /// 投影权威(图的空间工具)。没有就返回 null,调用方跳过本帧。 + ChartToolSpace Space { get; } + + /// + /// 插槽板(规范 §11.2):定义网格的工具**发布**标定顶点,其余工具按 id **读取**—— + /// 消费者认的是点,不是"第几个面",所以换成异形网格也不用改消费者。 + /// 空板也一定非 null(没有网格时读到 false),调用方不必判 null。 + /// + IXChartSlotBoard Slots { get; } + + /// 数据中转口。默认实现是图表自己那份直通实现。 + IXChartDataSource Data { get; } + + /// + /// 解析某维的显示范围。手动范围不从这里传——它归 chart 的维度行(数据板块, + /// 见 ),工具只说要哪一维。 + /// 规则明细见 :覆盖优先、没覆盖回落该维聚合、 + /// 聚合也没有就返回 false(调用者应清空自己的绘制,而不是画在 0 上)。 + /// + bool TryResolveDomain(int dimension, out double min, out double max); + } + + /// + /// 的默认实现:空间靠一个由 chart 提供的解析委托现找, + /// 数据直通图表的 XChartDataModel。 + /// + /// 为什么每次现找而不缓存空间实例:重建(RebuildAll、增删元素)会换掉空间工具, + /// 缓存下来的引用不会报错、只会安静地画到旧空间上——那比 null 难查得多。每帧一次线性查找 + /// 只在渲染前做一次,代价远小于查错对象。 + /// + public sealed class XChartRenderContext : IXChartRenderContext + { + private readonly IXChartDataSource m_Data; + private readonly Func m_SpaceResolver; + + public XChartRenderContext(IXChartDataSource data, Func spaceResolver) + { + m_Data = data; + m_SpaceResolver = spaceResolver; + } + + public ChartToolSpace Space => m_SpaceResolver != null ? m_SpaceResolver() : null; + + public IXChartSlotBoard Slots { get; } = new XChartSlotBoard(); + + public IXChartDataSource Data => m_Data; + + public bool TryResolveDomain(int dimension, out double min, out double max) + { + // 范围的算法只有一份(XChartDomainMath 的那扇门):这里就是转发, + // 覆盖来自 chart 的维度行、自由端来自该维聚合——工具不再各存一份范围 + return XChartDomainMath.TryResolve(m_Data, dimension, out min, out max); + } + } +} diff --git a/Runtime/XChart/XChartRenderContext.cs.meta b/Runtime/XChart/XChartRenderContext.cs.meta new file mode 100644 index 0000000..cc2d318 --- /dev/null +++ b/Runtime/XChart/XChartRenderContext.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c37bc812b4604d140ac6173e9fa6c616 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/XChartToolBase.cs b/Runtime/XChart/XChartToolBase.cs index 3c9d36e..1d986f9 100644 --- a/Runtime/XChart/XChartToolBase.cs +++ b/Runtime/XChart/XChartToolBase.cs @@ -1,4 +1,6 @@ using System; +using System.Collections.Generic; +using TMPro; using UnityEngine; namespace XericUI.XChart @@ -20,7 +22,7 @@ namespace XericUI.XChart { // ── 编辑器/运行时统一 hideFlags ──────────────────────────── - private const HideFlags k_EditorFlags = HideFlags.DontSaveInEditor; + private const HideFlags k_EditorFlags = HideFlags.DontSaveInEditor | HideFlags.HideInHierarchy; private const HideFlags k_PlayFlags = HideFlags.HideAndDontSave; protected static HideFlags CurrentFlags => @@ -29,13 +31,44 @@ namespace XericUI.XChart // ── 基础属性 ────────────────────────────────────────────── protected XChartToolsManager Manager { get; private set; } + + /// + /// 注册序(越小越先建、越先更新)。它不是绘制序——绘制序看 : + /// 以前一个值同时管两件事,于是"想让轴先算但后画"根本表达不出来(§11.4)。 + /// public int OrderIndex { get; set; } + + /// + /// 绘制序(画家序):小者先画、大者盖在上面。只在同一分组内比较—— + /// 定义/背景/前景三组之间永远按分组先后画(否则前景的散点会被背景的网格盖住)。 + /// + public int DrawOrder { get; set; } + + /// + /// 生命周期分组:类型标记(由工具自己声明),不入序列化。 + /// 定义几何/范围/插槽的工具报 ,它们先跑, + /// 别的工具当帧就能取到插槽(§11.4)。 + /// + public virtual XChartToolCategory Category => XChartToolCategory.Foreground; + public GameObject RootObject { get; private set; } public RectTransform RootTransform { get; private set; } public string ToolName { get; private set; } public bool IsEnabled { get; set; } = true; public bool IsInitialized { get; protected set; } + /// + /// 渲染上下文(chart 提供)。空间、数据、显示范围都只从这里拿: + /// Context?.Space / Context?.Data / Context.TryResolveDomain(...)。 + /// + /// 可能为 null(初始化早期),工具必须判空跳过这一帧——不去找邻居、也不拿旧引用凑数。 + /// 规范见 Documentation/XChart-RenderFramework.md §2。 + /// + protected IXChartRenderContext Context => Manager?.Context; + + /// 数据中转口的简写(Context.Data)。可能为 null,用之前判。 + protected IXChartDataSource Data => Manager?.Context?.Data; + // ── 构造 ────────────────────────────────────────────────── protected XChartToolBase() { } @@ -64,17 +97,81 @@ namespace XericUI.XChart public virtual void OnRender() { } protected virtual void OnDispose() { } - public void Dispose() + public void Dispose() => Dispose(true); + + /// + /// =false:整条层级正在被 Unity 销毁(Undo 删 GameObject 也走这条路), + /// 自己的根会跟着一起没——而那个窗口里调 DestroyImmediate 会撞进 Unity 的销毁遍历 + /// (实测 SIGSEGV,见 XChartBase.Teardown)。该记的账照记,只是不拆对象。 + /// + public void Dispose(bool destroyRoot) { + // 先从池里注销,再拆自己的根:顺序反了就会把随根一起销毁的标签当成"可归还"塞回空闲表 + Manager?.ForgetTextOwner(this); OnDispose(); - if (RootObject != null) + if (destroyRoot && RootObject != null) { UnityEngine.Object.DestroyImmediate(RootObject); - RootObject = null; } + RootObject = null; IsInitialized = false; } + // ── 文本槽位(申请与读取;发落在 chart 的池调度里)──────────── + + private static readonly IReadOnlyList k_NoTexts = new TMP_Text[0]; + + private RectTransform m_TextHost; + private int m_RequestedTexts; + + /// + /// 标签的宿主节点(第一次申请时惰性建,挂在工具自己的根下)。 + /// 工具根随立方体走,所以标签天然跟着转。 + /// + protected RectTransform TextHost => m_TextHost ?? (m_TextHost = CreateStretchChild("GeneratedTexts")); + + /// + /// 已发落的文本槽位。长度可以短于申请数(申请到发落之间隔一次调度), + /// 所以取值一律 i < Texts.Count 并跳过 null——不 NRE,也不静默画错。 + /// 每次现问池要:池换回列表时旧引用就作废了,缓存它等于读一份没人维护的副本。 + /// + protected IReadOnlyList Texts + { + get + { + var pool = Manager != null ? Manager.TextPool : null; + return pool != null ? pool.SlotsOf(this) : k_NoTexts; + } + } + + /// 还欠着件(手上的数量不等于申请数量) + protected bool TextSlotsPending + { + get + { + var pool = Manager != null ? Manager.TextPool : null; + return pool == null ? m_RequestedTexts > 0 : pool.HeldCount(this) != m_RequestedTexts; + } + } + + /// 本工具申请到的数量(报表用:want 与 have 的差就是欠的件) + protected int RequestedTextCount => m_RequestedTexts; + + /// + /// 申请一批文本槽位: 是总数而不是增量,而且只登记需求(置脏), + /// 不当场给件(规范 §5.1)。没变且已经发落到位时直接跳过,不重复打扰池。 + /// + protected void RequestTextSlots(int count) + { + if (count < 0) count = 0; + // 宿主一旦建起来就一直带着:否则 count 归 0 时池会读到 host==null, + // 把手上的件当"无效"丢弃而不是回收归还。 + var host = count > 0 ? TextHost : m_TextHost; + if (count == m_RequestedTexts && ReferenceEquals(host, m_TextHost) && !TextSlotsPending) return; + m_RequestedTexts = count; + Manager?.RequestTextSlots(this, host, count); + } + // ── 子组件管理 ──────────────────────────────────────────── protected RectTransform CreateChild(string childName) @@ -110,5 +207,26 @@ namespace XericUI.XChart { if (RootObject != null) RootObject.SetActive(visible); } + +#if UNITY_EDITOR + /// + /// 调试报表里本工具的一行:只写"这一帧到底有没有画、没画的话卡在哪"的关键状态(规范 §6)。 + /// 派生类接上去补自己的判据;基类这份只报通用的可见性。 + /// + internal virtual void AppendDebugLine(System.Text.StringBuilder sb) + { + sb.Append("enabled=").Append(IsEnabled) + .Append(" init=").Append(IsInitialized) + .Append(" root="); + if (RootObject == null) sb.Append("NULL"); + else sb.Append(RootObject.activeSelf ? "active" : "inactive"); + + // 顺序的三个读数必须分开印:"谁先算"(分组+注册序)、"谁盖谁"(分组+绘制序+兄弟序) + sb.Append(" category=").Append(Category) + .Append(" reg=").Append(OrderIndex) + .Append(" draw=").Append(DrawOrder) + .Append(" sibling=").Append(RootTransform != null ? RootTransform.GetSiblingIndex().ToString() : "NULL"); + } +#endif } } diff --git a/Runtime/XChart/XChartToolOrder.cs b/Runtime/XChart/XChartToolOrder.cs new file mode 100644 index 0000000..d1606ff --- /dev/null +++ b/Runtime/XChart/XChartToolOrder.cs @@ -0,0 +1,71 @@ +namespace XericUI.XChart +{ + /// + /// 工具的生命周期分组(他 2026-10-23 的口径:"背景(背景网格)/ 前景(参数点位、轴线标尺、 + /// tooltip、其他可互动元素)")。定义 → 背景 → 前景 依次跑更新:定义网格的那个工具先算出 + /// 各维范围、把插槽发布出去,同一帧里轴线和数据图元就能取到——这是"注册先后不影响正确性"的前提。 + /// + /// 分组不是绘制序:画家序由 决定(§11.4: + /// "轴线的线可以绘制在点的上面")。两者分开,是因为"谁先算"和"谁盖住谁"是两件事。 + /// + /// 分组是类型标记(工具自己声明),不入序列化——省得又多一个要调的旋钮。 + /// + public enum XChartToolCategory + { + /// 定义几何/范围/插槽的工具(空间、网格背景、立方体背景):最先跑 + Definition = 0, + + /// 只画背景、不定义几何的工具(今天还没有工具落在这里,位置先留着) + Background = 1, + + /// 数据图元与可交互元素(散点、箭头、圆柱、轴线、tooltip 之类):最后跑 + Foreground = 2, + } + + /// + /// 工具顺序的唯一规则:先按分组(定义→背景→前景),再按各自的值,值相等时按注册序 + /// (先注册的在前)——最后这一条是稳定性的来源,缺了它"值相同"的两个工具的相对次序就看运气, + /// 而"看运气"的次序在画面上就是"有时点在上面、有时轴在上面"。 + /// + /// 抽成纯算术是为了离线判:次序错了不会报错,只是有人被别人盖住。 + /// + public static class XChartToolOrder + { + /// 是否应该排在 前面(−1 前,0 同序,1 后) + public static int Compare(XChartToolCategory aCategory, int aOrder, int aRegistration, + XChartToolCategory bCategory, int bOrder, int bRegistration) + { + if (aCategory != bCategory) return (int)aCategory < (int)bCategory ? -1 : 1; + if (aOrder != bOrder) return aOrder < bOrder ? -1 : 1; + if (aRegistration != bRegistration) return aRegistration < bRegistration ? -1 : 1; + return 0; + } + + /// + /// 按 做稳定插入排序(就地,不分配):条目数有上限(工具几十个), + /// 且它跑在渲染/初始化路径上。返回是否真的动过(报表读数用:动没动能看出旋钮生效没)。 + /// + public static bool Sort(int count, XChartToolCategory[] categories, int[] orders, int[] registrations, + int[] output) + { + if (count <= 0) return false; + for (int i = 0; i < count; i++) output[i] = i; + + bool moved = false; + for (int i = 1; i < count; i++) + { + int key = output[i]; + int j = i - 1; + while (j >= 0 && Compare(categories[output[j]], orders[output[j]], registrations[output[j]], + categories[key], orders[key], registrations[key]) > 0) + { + output[j + 1] = output[j]; + moved = true; + j--; + } + output[j + 1] = key; + } + return moved; + } + } +} \ No newline at end of file diff --git a/Runtime/XChart/XChartToolOrder.cs.meta b/Runtime/XChart/XChartToolOrder.cs.meta new file mode 100644 index 0000000..8b7f6bd --- /dev/null +++ b/Runtime/XChart/XChartToolOrder.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: bfda5e2c13fa5574886e2233d33f4265 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Runtime/XChart/XChartToolsManager.cs b/Runtime/XChart/XChartToolsManager.cs index ee39f0f..55f7775 100644 --- a/Runtime/XChart/XChartToolsManager.cs +++ b/Runtime/XChart/XChartToolsManager.cs @@ -1,6 +1,8 @@ using System; using System.Collections.Generic; +using TMPro; using UnityEngine; +using XericUI.XChart.Pools; namespace XericUI.XChart { @@ -16,6 +18,18 @@ namespace XericUI.XChart private List m_Tools = new List(8); + /// + /// 更新用的调度序(分组 → 注册序)。与 分开: + /// 那个是"注册顺序",这个是"谁先算"。绘制不走这个表——画家序由兄弟序决定(见 )。 + /// + private readonly List m_Dispatch = new List(8); + + private XChartToolCategory[] m_SortCategories = new XChartToolCategory[0]; + private int[] m_SortOrders = new int[0]; + private int[] m_SortRegistrations = new int[0]; + private int[] m_SortIndex = new int[0]; + private bool m_OrderApplied; + /// 只读工具列表(用于外部遍历) public IReadOnlyList Tools => m_Tools; @@ -27,6 +41,51 @@ namespace XericUI.XChart /// 所有工具的根父节点(由 XChartBase 指定) public Transform ToolsRoot { get; set; } + /// + /// 渲染上下文(由 chart 建好塞进来)。元素要的空间、数据、显示范围都只从这一个门拿, + /// 不再自己 FindTool 找邻居——查找路径有第二条,就会长出第二套投影。 + /// + public IXChartRenderContext Context { get; set; } + + /// + /// 文本槽位池(由 chart 建好塞进来)。工具不自己 new 标签、也不自己维护实例列表: + /// 申请走 ,发落在 (规范 §5)。 + /// + public XChartSlotPool TextPool { get; set; } + + internal void RequestTextSlots(XChartToolBase owner, RectTransform host, int count) + => TextPool?.Request(owner, host, count); + + internal void ForgetTextOwner(XChartToolBase owner) => TextPool?.Forget(owner); + + /// 拆池(chart 回收重建 / 销毁时调用):件由工厂硬销毁,管理器这边把引用清干净 + public void DestroyTextPool() + { + if (TextPool == null) return; + TextPool.Dispose(); + TextPool = null; + } + + /// + /// 一次池调度:先释放、顺位复用、池兜底、盈余归还(chart 在渲染前调用)。 + /// 这里必须隔离:它跑在 RenderAll 之前,抛出去就等于整张图这一帧不画 + /// ("加了一个元素后所有元素都不显示"的老形状会因此复活)。 + /// + public void DispatchTextPools() + { + if (TextPool == null) return; + try + { + TextPool.Dispatch(); + } + catch (System.Exception error) + { + m_DispatchFailure = error.GetType().Name + ": " + error.Message; + if (m_ReportedFailures.Add("Dispatch|" + error.Message)) + Debug.LogWarning("XChart 文本槽位调度抛异常,本轮跳过(其余渲染照常):\n" + error); + } + } + // ── 版本控制(防溢出) ──────────────────────────────────── private int m_Version; @@ -34,18 +93,34 @@ namespace XericUI.XChart // ── 添加工具 ────────────────────────────────────────────── /// - /// 添加一个图表工具。 - /// 自动在 ToolsRoot 下创建同名子 GameObject,挂载并初始化工具。 + /// 添加一个图表工具(泛型版:自己 new)。 /// public T AddTool(string toolName, int orderIndex = 0) where T : XChartToolBase, new() { + var tool = new T(); + AddTool(tool, toolName, orderIndex); + return tool; + } + + /// + /// 添加一个已经造好的图表工具实例。 + /// 元素框架走这一条:由 决定造什么, + /// 管理器只负责建同名子 GameObject、初始化、按 OrderIndex 插入。 + /// + public void AddTool(XChartToolBase tool, string toolName, int orderIndex = 0, int drawOrder = 0) + { + if (tool == null) + throw new ArgumentNullException(nameof(tool)); if (ToolsRoot == null) throw new InvalidOperationException("ToolsRoot 未设置,无法添加工具"); + if (string.IsNullOrEmpty(toolName)) + toolName = tool.GetType().Name; + var flags = Application.isPlaying ? HideFlags.HideAndDontSave - : HideFlags.DontSaveInEditor; + : HideFlags.DontSaveInEditor | HideFlags.HideInHierarchy; var rootObject = new GameObject(toolName, typeof(RectTransform)); var rootTransform = rootObject.GetComponent(); @@ -56,10 +131,10 @@ namespace XericUI.XChart rootTransform.offsetMax = Vector2.zero; rootObject.hideFlags = flags; - var tool = new T(); tool.InternalInitialize(this, toolName, rootObject, orderIndex); + tool.DrawOrder = drawOrder; - // 按 OrderIndex 插入到有序位置 + // 按注册序(OrderIndex)插入:它就是"谁先建、谁先更新" int insertIdx = m_Tools.Count; for (int i = 0; i < m_Tools.Count; i++) { @@ -71,19 +146,68 @@ namespace XericUI.XChart } m_Tools.Insert(insertIdx, tool); - rootObject.transform.SetSiblingIndex(insertIdx); + // 兄弟序与更新序都由 ApplyOrder 统一落(不再在这里按注册序设兄弟序—— + // 那正是"注册序被迫等于绘制序"的老毛病) + ApplyOrder(); + } + + /// + /// 把"谁先跑、谁先画"一次落清(§11.4): + /// + /// 更新序 = 分组(定义→背景→前景)→ 注册序:定义网格的工具先算范围/发插槽,别的当帧就能取; + /// 绘制序(= 兄弟序)= 分组 → :所以"轴先算、但画在点上面"表达得出来。 + /// + /// 注册/删除工具时自动调一次,不必手工维护。 + /// + public void ApplyOrder() + { + int count = m_Tools.Count; + if (m_SortCategories.Length < count) + { + m_SortCategories = new XChartToolCategory[count]; + m_SortOrders = new int[count]; + m_SortRegistrations = new int[count]; + m_SortIndex = new int[count]; + } + + for (int i = 0; i < count; i++) + { + m_SortCategories[i] = m_Tools[i].Category; + m_SortOrders[i] = m_Tools[i].OrderIndex; + m_SortRegistrations[i] = i; + } + + // 更新序:分组 → 注册序 + XChartToolOrder.Sort(count, m_SortCategories, m_SortOrders, m_SortRegistrations, m_SortIndex); + m_Dispatch.Clear(); + for (int i = 0; i < count; i++) m_Dispatch.Add(m_Tools[m_SortIndex[i]]); + + // 绘制序(兄弟序):分组 → 绘制序 + for (int i = 0; i < count; i++) m_SortOrders[i] = m_Tools[i].DrawOrder; + XChartToolOrder.Sort(count, m_SortCategories, m_SortOrders, m_SortRegistrations, m_SortIndex); + for (int i = 0; i < count; i++) + { + var tool = m_Tools[m_SortIndex[i]]; + if (tool != null && tool.RootTransform != null) tool.RootTransform.SetSiblingIndex(i); + } + + m_OrderApplied = true; m_Version++; - return tool; } // ── 移除工具 ────────────────────────────────────────────── - public void RemoveTool(XChartToolBase tool) + public void RemoveTool(XChartToolBase tool) => RemoveTool(tool, true); + + public void RemoveTool(XChartToolBase tool, bool destroyRoot) { if (tool == null || !m_Tools.Contains(tool)) return; - tool.Dispose(); + tool.Dispose(destroyRoot); m_Tools.Remove(tool); m_Version++; + // destroyRoot=false ="整条层级正在被销毁"(见 XChartBase.Teardown):那个窗口里 + // 不许再动兄弟序(会走进 Unity 的销毁遍历,与 DestroyImmediate 同族的重入) + if (destroyRoot) ApplyOrder(); } public bool RemoveToolByName(string toolName) @@ -99,12 +223,33 @@ namespace XericUI.XChart return false; } - public void RemoveAllTools() + public void RemoveAllTools() => RemoveAllTools(true); + + /// + /// =false:整条层级正在被 Unity 销毁(见 XChartBase.Teardown)。 + /// 工具的根都是那一层的子孙 ⇒ 跟着一起没;那个窗口里再调 DestroyImmediate 会撞进 + /// Unity 的销毁遍历(实测 SIGSEGV)。 + /// + public void RemoveAllTools(bool destroyRoots) { for (int i = m_Tools.Count - 1; i >= 0; i--) - m_Tools[i].Dispose(); + m_Tools[i].Dispose(destroyRoots); m_Tools.Clear(); m_Version++; + if (destroyRoots) ApplyOrder(); + } + + /// + /// 只记清楚账、一个对象都不拆:给"整条层级正在被销毁"那个窗口用。 + /// 池根同样是 chart 的子孙,所以这里只丢引用,不 Dispose 一遍;调度表也一并清掉—— + /// 那个窗口里不许动兄弟序(那与 DestroyImmediate 是同族的重入)。 + /// + public void ReleaseBookkeeping() + { + RemoveAllTools(false); + TextPool = null; + m_Dispatch.Clear(); + m_OrderApplied = false; } // ── 查找工具 ────────────────────────────────────────────── @@ -124,16 +269,56 @@ namespace XericUI.XChart // ── 生命周期驱动 ────────────────────────────────────────── + /// + /// 已经报过异常的工具:隔离但要出声。一个工具炸掉不该让后面的工具全不画 + /// ("加了个圆柱,所有元素都不显示"就是这么来的),但悄悄吞掉更难查, + /// 所以每种"工具 + 异常"组合只报一次。 + /// + private readonly HashSet m_ReportedFailures = new HashSet(); + + /// + /// 每个工具最近一次炸在哪:日志滚过去就没了,但调试报表要能点名"这个工具这一帧没画是因为抛了"。 + /// + private readonly Dictionary m_LastFailures = new Dictionary(); + + public string LastFailureOf(string toolName) + { + string text; + return m_LastFailures.TryGetValue(toolName, out text) ? text : null; + } + + /// 调度阶段的异常见证(报表用;null 表示没炸过) + public string LastDispatchFailure => m_DispatchFailure; + private string m_DispatchFailure; + + private void ReportFailure(XChartToolBase tool, string phase, System.Exception error) + { + string name = tool != null ? tool.ToolName : ""; + m_LastFailures[name] = phase + ": " + error.Message; + if (!m_ReportedFailures.Add(phase + '|' + name + '|' + error.GetType().Name + '|' + error.Message)) return; + Debug.LogWarning("XChart 工具 \"" + name + "\" 在 " + phase + " 中抛异常,已跳过它,其余工具继续:\n" + error); + } + public void UpdateAll() { - for (int i = 0; i < m_Tools.Count; i++) + // 按调度序跑(分组 → 注册序):定义几何/插槽的工具先算,轴线和数据图元当帧就能取到。 + // 列表为空(还没排过)就退回注册序,免得早期调用什么都跑不到。 + var order = m_OrderApplied ? (IReadOnlyList)m_Dispatch : m_Tools; + for (int i = 0; i < order.Count; i++) { - var tool = m_Tools[i]; - if (!tool.IsEnabled || !tool.IsInitialized) continue; + var tool = order[i]; + if (tool == null || !tool.IsEnabled || !tool.IsInitialized) continue; int snap = m_Version; - tool.OnUpdate(); - if (snap != m_Version && (i >= m_Tools.Count || m_Tools[i] != tool)) + try + { + tool.OnUpdate(); + } + catch (System.Exception error) + { + ReportFailure(tool, "OnUpdate", error); + } + if (snap != m_Version && (i >= order.Count || order[i] != tool)) i--; } } @@ -146,7 +331,14 @@ namespace XericUI.XChart if (!tool.IsEnabled || !tool.IsInitialized) continue; int snap = m_Version; - tool.OnRender(); + try + { + tool.OnRender(); + } + catch (System.Exception error) + { + ReportFailure(tool, "OnRender", error); + } if (snap != m_Version && (i >= m_Tools.Count || m_Tools[i] != tool)) i--; } @@ -154,9 +346,15 @@ namespace XericUI.XChart // ── 清理 ────────────────────────────────────────────────── - public void Dispose() + public void Dispose() => Dispose(true); + + /// + /// =false 时不拆任何对象(见 ): + /// 那是 Undo/删除驱动的整层销毁窗口。 + /// + public void Dispose(bool destroyRoots) { - RemoveAllTools(); + RemoveAllTools(destroyRoots); m_Tools.Clear(); } }