比较提交

...
作者 SHA1 备注 提交日期
mac fa7ef93714 release: save signed notarized build24 PKG verification and version notes before tagging 2026-11-01 22:35:32 +08:00
mac 1932565ecd docs: record build24 independent tool masks, real FCP tracking and persistence, explicit canvas gesture acceptance gap and verified remote recovery 2026-11-01 22:34:16 +08:00
mac dbf25fe671 diagnostic: add bounded real-host OSC hit and pointer entry metadata for build24 2026-11-01 22:19:05 +08:00
mac 375761619f fix: cache immutable canvas state for host OSC, select before mask commit and add direct Metal canvas regression checks; prepare build23 2026-11-01 22:14:15 +08:00
mac 34162025b6 fix: use parent native Boolean OSC contract and latest plugin resolution; add bounded host routing diagnostics for build22 2026-11-01 22:03:49 +08:00
mac 3fc32f3e19 fix: publish native OSC in FCP template, synchronize canvas targets and advance exact single-step playhead; prepare build 21 2026-11-01 21:58:43 +08:00
mac 659a8c540d feat: complete independent tools, per-stage masks and host Metal tracking; native checks pass, prepare formal 1.4.0 build 20 2026-11-01 21:51:15 +08:00
mac cec044f124 WIP: native per-layer controls, host OSC and Metal mask tracking; GPU and callback regressions added, formal host acceptance pending 2026-11-01 21:49:38 +08:00
mac f72aa2609d WIP: independent tool documents, native panel routing and per-stage GPU masks; host canvas and tracking pending 2026-11-01 21:40:54 +08:00
mac edfb74b171 docs: hand off mask tracking and repeatable tool instances from verified 1.3.1 baseline 2026-11-01 21:26:08 +08:00
mac bbdd47d1d7 release: publish and fully download-verify 1.3.1 installer; finalize recovery and cleanup records 2026-11-01 21:00:20 +08:00
共修改 54 个文件,包含 2344 行新增和 165 行删除

没有与搜索条件相匹配的文件

+27
查看文件
@@ -0,0 +1,27 @@
大鱼调色 1.4.0(24),适用于 Apple Silicon Mac,最低 macOS 14.6。
- 十二个模块标题增加“添加蒙版”和“再加一层”。新增工具从初始化参数开始,独立保存参数、开关、折叠、复位、删除、LUT和蒙版;同类HSL可以连续叠加。
- 蒙版包括椭圆、矩形、钢笔、线性渐变、HSL和亮度选区,可相加、减去、相交、反转、羽化和调节强度。画面提供轮廓和左侧工具栏,面板可编辑各类型参数。
- 从“大鱼调色盘”源码适配Metal光流与仿射跟踪,支持几何蒙版的正向、反向、双向和单帧跟踪,取消保留可信段,一次撤销恢复;单帧完成后移动播放头。
- 完整预设v4保留每层工具、蒙版和逐帧轨迹,兼容旧预设。旧float参数和原调色链保留。
正式版本222项原生检查通过。FCP12.4实测第二HSL初始化为零、红色色相32且原层仍为零,原层椭圆与新增层矩形独立;正向99帧轨迹、双向100帧轨迹、新增层单帧2键及播放头移动通过。一次撤销/重做、正常退出重开后的完整预设均逐字节一致。远端独立恢复210文件,模型/模板和Metal着色器重建一致。
验收缺口:实际画面轮廓/工具栏可见,但自动化坐标点击未进入真实宿主点击回调,FCP直接拖动、旋转和钢笔手势尚未实机确认;原生模拟宿主的真实Metal叠加、命中、拖动提交、一次撤销及Esc检查通过。Motion、Intel、旧系统、变速/裁剪/非方像素工程未实测。
新增工具标量目前是静态作者值,蒙版轨迹按时间求值。跟踪不含透视、剪切。空间蒙版不能导出为Cube,需保存完整预设。旧模板实例若不显示画面控件,可先保存完整预设,再应用新版效果并载入;不自动覆盖旧效果。
安装包包含原生FxPlug APP和FCP模板,不含用户LUT、预设、最近使用记录或媒体。安装前保存工作并正常退出Final Cut Pro/Motion。唯一APP位置为 `/Library/Plug-Ins/FxPlug/大鱼调色.app`。APP已正式安装;PKG另做签名、公证、票据、Gatekeeper及展开验包,不重复执行安装器。
版本标签:`v1.4.0-tool-masks-20261101`
APP实际编译源码:`dbf25fe6719f17075362538dad0404951102524d`
APP公证:`40fdaaaa-1821-4cc8-bec3-c5dc6d8b9f77`,Accepted
PKG公证:`da6edea3-11f4-451b-aece-91916cca329a`,Accepted
APP和PKG均通过Developer ID签名、票据与Gatekeeper;20项展开验包通过。
附件:`大鱼调色-1.4.0.pkg`
大小:14,250,425字节
SHA-256:`16a4958e28bc2a43c40e6131067eb03a49aecba5bbe3c0424bc7024fa532af38`
安装包明细见本标签的 `verification/Package.json`;实际发布及完整下载校验见后续主分支的 `verification/Release.json`。
+12 -2
查看文件
@@ -1,6 +1,6 @@
# 大鱼调色
原生 FxPlug 4 调色器,当前正式版本 **1.3.1(19)**。唯一安装位置为 `/Library/Plug-Ins/FxPlug/大鱼调色.app`;Final Cut Pro 中从“效果 → 大鱼调色”添加。
原生 FxPlug 4 调色器,当前正式安装版本 **1.4.0(24)**。唯一安装位置为 `/Library/Plug-Ins/FxPlug/大鱼调色.app`;Final Cut Pro 中从“效果 → 大鱼调色”添加。
## 色彩管理与一级调色
@@ -22,6 +22,16 @@ LUT 缩略图浏览器使用宿主的独立可调整窗口:拖动标题栏移
五套主题跨实例记忆。风格 LUT 网格打开缩略图浏览库;用户库为 `~/Movies/大鱼调色LUT/look LUTs`。后台扫描、导入、解析、预览、取消和最后一次选择生效的机制保留;支持既有 UTF-8/16/32 与旧编码 Cube 兼容。用户文件不进入源码或安装包。
## 每工具蒙版与再次添加工具
十二个模块标题均有“添加蒙版”和“再加一层”。新增工具在列表末尾按添加顺序执行,从本工具的初始化参数开始,拥有独立启停、折叠、复位、删除、LUT 和蒙版;不会复制原层当前设置。新增一级采用 Rec.709/Gamma 2.4 同域输入输出,新增肤色保护强度为零。
蒙版包括椭圆、矩形、钢笔、线性渐变、HSL 和亮度选区,支持相加、减去、相交、反转、羽化和强度。矩形、椭圆和闭合钢笔区域可正向、反向、双向或单帧跟踪。算法从“大鱼调色盘”固定源码适配,随本产品独立构建;不依赖安装父插件。完整预设 v4 保存新增工具、蒙版和逐帧轨迹,兼容旧预设。空间蒙版不能导出到 Cube,导出时会提示。
正式版 222 项原生检查通过。FCP 实测独立 HSL、蒙版数值编辑、正向/双向/单帧跟踪、一次撤销/重做及保存重开通过。画面轮廓与工具栏已经显示;自动化鼠标未触发真实宿主点击回调,因此画面直接拖动、旋转和钢笔手势尚未完成实机确认,原生模拟宿主的相关回归通过。新增工具标量目前为静态值,蒙版轨迹按时间求值。跟踪覆盖位置、旋转和独立宽高,不含透视、剪切。
旧模板实例可能保留关闭画面控件的状态;可先保存完整预设,再重新应用新版效果并载入预设。不会自动覆盖旧实例。实现与验收边界见 [实现说明](research/ToolMaskImplementation.md)、[宿主记录](verification/HostToolMasks.json) 和 [恢复核验](verification/ToolMaskRecovery.json)。
## 验证与恢复
- [本轮交接](大鱼调色FxPlug4交接.md)
@@ -42,6 +52,6 @@ LUT 缩略图浏览器使用宿主的独立可调整窗口:拖动标题栏移
正式发行包由 PKG 工坊技能生成,包含 APP 与 FCP 模板,不含用户 LUT、预设或媒体。安装与发布证据分别保存在 [Package.json](verification/Package.json) 和 [Release.json](verification/Release.json);以其中记录的版本和成功状态为准。
本版本正式包目标 `../发行包/大鱼调色-1.3.1.pkg`;安装包和发布状态以验证记录的 1.3.1 结果为准。历史发行包保留。
正式安装包:[大鱼调色-1.4.0.pkg](../发行包/大鱼调色-1.4.0.pkg);APP及PKG均已公证、粘附票据并通过Gatekeeper,20项展开验包通过。[1.4.0 Release](https://dayu.media/git/dayu/dayu-color/releases/tag/v1.4.0-tool-masks-20261101)的实际发布和完整下载校验以Release.json为准。历史1.3.1及更早发行包和标签保留。
FCP 已验证 Sony 默认、可见复位、浮动浏览器、系统窗口缩放、两种布局、最近排序与关闭重开。原生检查单独覆盖几何/布局持久化和鼠标事件;自动化没有独立确认自由标题栏/边缘拖动。用户开始使用后保留其当前布局与选择,未为额外测试再次重启宿主。
+19 -1
查看文件
@@ -1,6 +1,18 @@
# 大鱼调色恢复说明
## 当前 1.3.1(19):色轮复位、可调整浏览器与最近使用
## 当前 1.4.0(24):每工具蒙版与初始化叠层
APP 实际编译 `dbf25fe6719f17075362538dad0404951102524d`,公证 `40fdaaaa-1821-4cc8-bec3-c5dc6d8b9f77`,Accepted;票据、Gatekeeper、唯一正式安装、222项原生检查及FCP保存重开通过。安装和实际宿主证据分别见 `verification/Delivery.json`、`verification/HostToolMasks.json`。正式包和Release以对应JSON记录的1.4.0状态为准,不套用历史1.3.1记录。
发行标签 `v1.4.0-tool-masks-20261101`,PKG公证 `da6edea3-11f4-451b-aece-91916cca329a` Accepted,20项展开验包通过。包 `../发行包/大鱼调色-1.4.0.pkg`,14,250,425字节,SHA-256 `16a4958e28bc2a43c40e6131067eb03a49aecba5bbe3c0424bc7024fa532af38`。本轮正式APP已安装和宿主验证,PKG未重复运行安装器。
新增9002静态作者文档保存UUID工具实例和每层蒙版,9003仅作不保存的OSC会话路由。旧float ID、9001资产和1104字节制服ABI保持。预设v4保存完整工具与轨迹,兼容v1–3;轨迹用精确CMTime求值,新增工具标量暂不支持宿主标量关键帧。空间蒙版不能表达为Cube,应保存完整预设。蒙版/Metal光流来源固定为父库 `f8950384e514685c8809fe8e8ee2dd5f16ad0bd7`,摘要见 `research/ToolMaskPort.json`;构建与运行不读取父库或Color Finale。
远端独立克隆该编译节点,210个提交文件逐字节核对、strict/full fsck通过;从恢复源码和本机SDK重建模型/模板及Metal,模板和正式着色器摘要完全一致,见 `verification/ToolMaskRecovery.json`。不含LFS或子模块。恢复临时目录已清理,签名证书私钥仍需独立恢复。
FCP实测独立HSL、每层椭圆/矩形、数值编辑、正向99键、双向100键、单帧2键、一次撤销/重做及冷重开完整预设一致。画面轮廓/工具栏可见;实机鼠标拖动/旋转/钢笔未验证,模拟宿主的原生OSC检查通过。旧模板实例可能保留关闭OSC的状态,可保存完整预设后重新应用新版效果再载入,不自动覆盖旧工程。
## 历史 1.3.1(19):色轮复位、可调整浏览器与最近使用
实际编译 `dbb7ca4a995ef832178a32f35939aed7d3a85012`,APP 公证 `9e93dc7f-04a3-44f9-a1e4-792bd7b31533`,Accepted;票据、Gatekeeper、唯一正式安装与 FCP 12.4 加载通过。发行标签 `v1.3.1-browser-recents-20261101`,包目标 `../发行包/大鱼调色-1.3.1.pkg`。本版本发布结果见 verification/Package.json 和 verification/Release.json。
@@ -198,3 +210,9 @@ python3 Packaging/build_pkg.py --pkg-forge-repo /实际/PKG工坊源码目录 --
## 1.3.1 正式 PKG
正式包 `../发行包/大鱼调色-1.3.1.pkg`,14,073,683 字节,SHA-256 `954b10c581f31d23a8c417a6f37b24fae19939786dce8733b4d6f09c7ed3adae`。PKG 公证 `85cad776-c3d7-4037-9643-24041b269002`,Accepted;Installer 团队 B3W25FX5H5、可信时间戳、票据、Gatekeeper 和 20 项真实展开验包通过。包内 APP 与已验收的正式安装一致,APP 实际编译 `dbb7ca4a995ef832178a32f35939aed7d3a85012`;未重复执行系统安装。
正式 Release 已发布并完整下载校验:[1.3.1 Release](https://dayu.media/git/dayu/dayu-color/releases/tag/v1.3.1-browser-recents-20261101),Release ID 366、附件 ID 12;标签提交 `281721bda11484c23f294b4f0d9e0b30ef829288`,APP 编译 `dbb7ca4a995ef832178a32f35939aed7d3a85012`。附件 14,073,683 字节,SHA-256 `954b10c581f31d23a8c417a6f37b24fae19939786dce8733b4d6f09c7ed3adae`。草稿经已登录会话完整下载校验后发布,正式链接再次完整下载校验;只上传一次并复用同一附件。临时下载副本已核实清理,正式发行包保留。交付标签远端独立恢复 184 文件与 full/strict fsck 通过,见 verification/BrowserReleaseRecovery.json。
## 蒙版、跟踪与可重复工具的文档交接(2026-11-01)
文档整理前 main 为 `bbdd47d1d74e241f1f144bb2c245204e86973b3f`。交接标签 `handoff-mask-tracking-tools-20261101` 保存最新 `大鱼调色FxPlug4交接.md` 及 `research/MaskTrackingAndToolStack.md`,区分正式 1.3.1(19)与尚未实现的多个独立 HSL、每实例蒙版和跟踪。本文档提交未重新构建、安装或发布 APP/PKG,不移动原发行标签;父级“大鱼调色盘”只读参考。接续时保护用户当前窗口、布局、LUT 选择和工程。
+95
查看文件
@@ -0,0 +1,95 @@
# 续作方案:工具实例、蒙版与跟踪
2026-11-01。**这是下一阶段方案,尚未实现。** 用户明确要增加蒙版、跟踪和可添加工具,并举例“一层 HSL 不够,再加一个 HSL”。本文的具体类型、按钮和实施顺序为建议,不把参考库现有全部功能自动扩为新产品的承诺。
## 一、先解决多个 HSL 的身份和执行问题
当前固定 HSL 在 `DYModel.mm` 注册,使用 `DYUniforms` 的一组 `hsl*` 字段,`DYColorTables.mm` 构造一份 24 参数 HSL 查表。`DYGrade.metal` 调用融合的 `dy_grade`,蜘蛛盘随后执行。CST 位于原有显示域调色链之前。
推荐为可添加工具建立统一实例模型;先开放 HSL,一旦成立再扩展支持的类型。一个实例至少保存稳定 UUID、工具类型及版本、名称、启用状态、混合强度、独立参数和其蒙版引用;作者文档保存有序实例列表。显示名称和列表位置都不能代替身份。
界面最小闭环:添加工具 → HSL → 出现第二张独立 HSL 卡片 → 调整各自参数 → 单独启停/折叠 → 保存重开仍互不覆盖。复制、删除、重命名、排序是适合此模型的后续操作建议;若本阶段提供,均须使用同一作者状态和单次宿主撤销。
折叠只写 `folds[nodeID]` 一类界面状态,眼睛写实例启用;不能共用现有 `folds["hsl"]`。所有控件回调、异步加载、选中目标和 Undo 都绑定 nodeID + 参数键,不能绑定可能因插入/删除变化的数组下标。
### 渲染与旧参数的适配
先写清工具顺序和每个阶段的颜色域。保持 CST 输入/一级/输出的现有全局前段;新增 HSL 不应再执行一次 CST 或其它全局调整。当前固定链有融合内核,**不能为每个工具直接重复调用整个 `renderSource`**,否则会重复曝光、LUT、统计或空间处理。
原固定 HSL 可用稳定的兼容实例映射到原参数 ID,以保留旧工程和已有宿主动画;新增 HSL 必须有自己的参数存储与缓存。若需要将原链拆成可重排阶段,先做旧路径与拆分路径数值回归,再让新文档使用新计划。若先采用附加工具段,也必须在界面和文档明确其实际执行位置,不能让 UI 顺序与渲染顺序不同。
无新增状态的旧工程必须沿用原路径;显式迁移后记录格式版本,避免同一 HSL 同时从旧融合链和新实例链执行两次。旧参数 ID、枚举值、944 字节 ABI 前缀不能重排。新工具使用中性参数时应直通;关闭工具、混合为零或空新增列表应恢复原结果。
每个实例的查表/中间纹理缓存至少按 device、类型、完整有效参数和相关域信息隔离。第一层调值不能污染第二层。建立完整帧/分块、半透明、负值/HDR、重排以及连续多实例的检查,不把“面板能多开”当成多工具渲染已完成。
## 二、作者状态、动画和预设先定合同
本项目现有 `DYAssetState` 在参数 9001,标志含 `NOT_ANIMATABLE`。可以保留它存 LUT/蜘蛛盘资源;若新增工具参数需要宿主关键帧,须另行选择可动画的参数方案或明确时间化作者状态,不能直接塞入 9001 后默认为支持关键帧。
需区分:宿主可动画参数、工具/蒙版作者数据、逐帧求值后的不可变渲染计划,以及可丢弃缓存。轨迹作者数据随工程保存,运行计划按给定 CMTime 求值,不能由 UI 当前播放头或可变全局选择决定渲染。
所有新增类型应覆盖 NSSecureCoding 白名单、copy、isEqual、hash、验证、资源路径、预设、宿主归档和渲染状态。当前 InspectorToken schema 2、预设 JSON v3、临时 render-state schema 1 分属不同格式。不要用一次任意“schema++”代替各格式的明确迁移。
对新数据设置数量/大小/嵌套上限,验证有限数值、合法工具类型、UUID 唯一和引用完整性。失败加载保持旧作者文档;不加载任意类。必要时为当前插件增加明确文档格式,而不是依赖不可版本化的 UI 对象。
## 三、把蒙版绑定到工具实例
建议先移植矩形、椭圆和闭合钢笔;羽化、反转、强度和组合规则应有明确数学定义。其它 HSL/亮度键、人物或外部蒙版只作为父库的后续候选,未获本轮逐项指定。
每个工具保存自己的蒙版列表和当前蒙版 ID。首阶段优先正常混合:`output = mix(toolInput, toolResult, clamp(maskCoverage * toolOpacity, 0, 1))`。多蒙版的加/减/交集顺序、无蒙版的覆盖语义、空路径和禁用蒙版的含义须先确定并测试。不要用一个全局蒙版同时影响所有 HSL。
CPU、Metal、预览和 OSC 共用坐标合同:源图/目的图范围、宿主 tile bounds、top/bottom origin、非方形像素、缩放/旋转及视图变换都要处理。计算蒙版不能依赖检查器或浏览器尺寸。保留 alpha,明确直通 RGB 与预乘 RGB 的转换和混合边界。
画面控件通过宿主的 OSC 机制绘制,使用当前效果实例和稳定工具/蒙版 ID 隔离。点击效果标题、开关显示控件、关闭工具窗口后是否保留轮廓等行为在正式 FCP 中验证。不要自建一张静帧预览来冒充宿主当前画面的编辑和跟踪。
## 四、跟踪移植的范围与易错点
父库正式68采用 Metal 图像金字塔/正反光流与确定性 RANSAC,输出位置、旋转和独立横纵缩放。其输出合同不包括透视/剪切。建议复用前向、后向、同参考帧双向和前后单帧;连续范围、单帧参考区间、取消行为均按精确帧长定义,不猜帧率。
从宿主分析接口取得实际源帧。当前 `lookLUTPreview` 只是 320×180 预览,不足以替代最终跟踪输入;也不能靠拖动播放头或缓存最后一帧伪造完整分析。需要检查、实现并验证 FxAnalyzer / FxAnalysisAPI 生命周期和真实帧调度。
分析开始时冻结效果实例、文档/工具/蒙版 ID、形状 revision、参考 CMTime、范围和帧长。每次结果发布验证目标仍匹配;切片段、切实例、删除工具、编辑蒙版或新一轮分析后,过时回调不得写回当前文档。
将手工键和自动轨迹分开保存;手工修正优先,合并只替换指定区间的可替换自动结果,保留区间外轨迹、羽化和强度动画。取消保留可信段;空结果不制造作者编辑。低置信度/丢失要有明确提示,不能静默填成功或持续外推。
**先读父库 `research/tracking-host-lifecycle.md`。** 它记录过提前返回后不收尾、跨 action 分组无效、预览刷新吃掉 Undo/Redo、旧实例在切片段后持续刷新等实际问题。当前可复用方案在准备好结果后,单个有效 action 内完成命名 Undo 起止和完整作者状态写入,然后 endAction;分析收尾保证一次,迟到/重复收尾不再编辑。别恢复早期58–67的已知问题流程。
## 五、参考库导航(只读)
本次核对:`/Volumes/备份/大鱼调色/大鱼调色盘`,HEAD `f8950384e514685c8809fe8e8ee2dd5f16ad0bd7`;正式68源码 `d05994d5f4547687511bef524efe8c881e8a5c9c`。接手时先检查差异,若参考更新则固定并记录新节点。
| 参考入口 | 复用方向 |
| --- | --- |
| `HANDOFF.md`、`verification/release-2.0.0-build68.json` | 正式68的真实完成范围与宿主证据 |
| `Sources/DYSettings.h/.mm` | 作者文档、图层、每层蒙版与归档 |
| `Sources/DYPanelLayers.inc` | 图层/工具列表操作与编辑目标 |
| `Sources/DYMaskState.h/.mm` | 精确 CMTime、手动/自动键、形状与变换求值 |
| `Core/DYMask.h`、`DYMaskOperator.h`、`DYLayerPlan.h` | 蒙版数学、组合/源阶段、渲染计划 |
| `Sources/DYPanelMasks.inc`、`DYInspectorMaskControls.inc` | 蒙版编辑器、宿主检查器入口 |
| `Core/DYTracker.hpp`、`Sources/DYMetalTracker.h/.mm` | 光流后端、RANSAC、结果/区间合并 |
| `Sources/DYPlugin.mm` | FxAnalyzer、目标冻结、取消/收尾、预览归属、Undo 提交 |
| `Sources/DYRenderer.mm`、`Shaders/DYColor.metal` | 计划执行、纹理与蒙版合成,需适配本项目 |
| `research/tracking-host-lifecycle.md` | 宿主生命周期、单 action 撤销和旧实例刷新防护 |
| `Tools/test_tracking.py`、`Tools/test_mask_refinement.py` | 参考测试和合成运动素材思路,不能替代本产品验收 |
父库有独立 Bundle ID、参数表、1032 字节 DYGrade、作者格式和更大的产品范围。本项目为 1104 字节 DYUniforms。按功能适配源码,保留本产品颜色链和品牌/安装身份;不整仓覆盖、不盲抄 PID/结构体,不把父库已验收数量记成本项目通过。移入源码时记录来源节点、文件摘要与必要资源,构建不得依赖兄弟 APP 或另一目录运行时存在。
## 六、建议里程碑与验收
| 阶段 | 可交付行为 | 最低验收重点 |
| --- | --- | --- |
| A:两个 HSL | 独立添加、调值、眼睛和折叠;实例保存 | 不共用参数/缓存;旧工程画面不变;删除/插入不串目标;单次 Undo/Redo;重开与预设 |
| B:每实例蒙版 | 两个 HSL 分别影响不同区域 | 蒙版/羽化/反转/透明度 CPU–GPU 对照;原点、tile、4K与非方形画面;关闭精确旁路 |
| C:宿主控件 | 在 FCP 检视器画与改蒙版 | 当前实例隔离、真实拖动/绘制、工具窗口关闭后的行为、一次手势一次撤销 |
| D:跟踪 | 实际运动帧驱动对应蒙版 | 前后/双向/单帧;取消可信段;低置信度;手工键优先;精确 CMTime;切片段/旧回调隔离 |
| E:正式回归 | 保存、导出、性能与发行 | 冷重开轨迹完整一致;一次 Undo/Redo 的作者文档核对;旧预设/工程、CST/蜘蛛盘/LUT 回归;正式交付 |
用本产品独立合成源验证平移、旋转、独立轴缩放、边界/透明、局部遮挡或目标离画;量化中心和尺寸误差,并区分算法样本与实机结果。对任意遮挡不能作无证据保证。导出后检查完整运动序列,不能只看静态首帧轮廓。
新增无蒙版、无逐帧依赖的逐像素 HSL 可表达为 LUT;空间蒙版和跟踪不能完整写入普通 3D Cube。到实现时应明确选择阻止完整导出、或让用户明确导出全局部分,并在 UI 说明;不得静默丢掉局部调色后仍称完整一致。
## 七、工作与交付边界
本轮只交接,不实现这些功能、不改变正式 1.3.1(19)。下一轮遵循 `/Users/mac/.codex/AGENTS.md`:先保护当前工作,保存并推送阶段检查点;构建/CLI 测试在固定缓存,用户可见测试走已签名公证的唯一正式安装。新增功能后递增版本/构建号,刷新模型模板,完整签名、公证、安装、FCP 验收、清理、PKG、Release 完整下载与远端恢复。
用户正在使用浏览器时,不为额外测试重启或复位其工程。优先用新合成测试库,完整保留其 LUT、预设、最近使用和现有轨迹。此任务不需要 NAS 后端部署,不新增生产服务。
+35
查看文件
@@ -0,0 +1,35 @@
# 每工具蒙版与初始化叠层(1.4 开发记录)
基线:`edfb74b171f51d4beaa9926e27d2d80791fbf43c`,原正式版本 1.3.1(19)。当前正式安装 1.4.0(24),实际编译 `dbf25fe6719f17075362538dad0404951102524d`。以 verification/Delivery.json、HostToolMasks.json、Package.json 和 Release.json 分别核对安装、宿主、包和发布状态。
## 界面与顺序
十二个原模块标题栏均增加“添加蒙版”和“再加一层”。新增工具在原模块列表之后按添加顺序执行,使用稳定 UUID;不复制原层当前参数。每层保留原生 HSL、曲线、色轮、蜘蛛盘和 LUT 浏览器。独立启停、折叠、复位、删除;原层宿主 float ID 不动。新增一级使用 Rec.709/Gamma 2.4 同域输入输出,避免默认再次转换 Sony Log;新增肤色保护强度从零开始。
原有工具保留原融合内核顺序。单独增加 `dy_gradeMasked`,在原生运算各阶段按该模块覆盖率混合;基础调整原生分布的两个阶段共用它自己的蒙版。原 `dy_grade` 保留,不增加蒙版的旧工程调用它。蜘蛛盘在原末端、CST 在原前段,蒙版分别作用在自己的阶段。新增工具用只开启该工具的制服参数执行,不重放其它原模块。新增肤色保护以本次效果的源画面作为保护参考。
## 状态与数学
9002 为 `DYToolDocument` 静态作者参数,独立于旧9001资源参数;9003 为不随工程保存的 OSC 会话路由。新工具标量目前为静态作者值,不声称支持宿主标量关键帧。蒙版轨迹独立以精确 CMTime 存储,并在 pluginState 的给定时间求值。预设 v4 在 JSON 中用 base64 二进制 plist 保留完整工具/蒙版/轨迹,兼容载入 v1–3;无9002旧工程使用空文档。
最多32个新增工具;每工具16个蒙版;每蒙版16384个轨迹键,全文最多65536键和24MiB plist。验证工具类型、UUID、数值、路径/节点、时间顺序和合法参数。归档使用 NSSecureCoding 类白名单、独立 copy/equality/hash。缓存按设备/完整参数,非共享可变面板状态。循环纹理只保留当前与下一层,不将所有中间4K帧保留至函数结束。
六种蒙版:矩形、椭圆、闭合贝塞尔、线性渐变、HSL、亮度;复用父库128字节蒙版参数及原始覆盖数学。多蒙版有序相加 `1-(1-a)*(1-b)`、减去 `a*(1-b)`、相交 `a*b`;第一项减去从1开始;无启用蒙版为全覆盖。色彩选区取本段输入的显示编码色;几何使用源图完整范围、原点和像素长宽比。各运算在既有颜色域混合,保持alpha。空间蒙版/跟踪不能用Cube表达,导出时明确拒绝,完整预设可保留。
## 宿主画面与跟踪
原生 FxOnScreenControl_v4 注册到本产品 UUID。画面工具栏提供选择、钢笔、矩形、椭圆、渐变、HSL、亮度及显示开关;面板提供相同类型和数值编辑作为替代操作。中心、大小、旋转、钢笔节点和手柄在宿主真实画面编辑;钢笔 Enter 闭合、Escape 取消。画面手势先编辑内存草稿,结束时在单个 host action 中提交一次撤销。
跟踪从父库移植 Metal 金字塔/正反光流及确定性仿射 RANSAC(来源与摘要见 ToolMaskPort.json)。通过 FxAnalyzer 请求宿主实际完整源帧;960宽采样区别于320×180浏览器预览。参考帧和分析首帧比对方向;帧调度采用精确CMTime,遇到重复、跳帧、尺寸变化或低置信度停止。输出位置、旋转、独立宽高,不含透视和剪切。矩形/椭圆/闭合钢笔可前向、后向、双向、单帧跟踪。取消保留可信连续段,手工键优先,保留区间外键。冻结目标UUID和完整蒙版,过期目标不回写。一次收尾防重入、宿主状态轮询补缺失cleanup;结果准备好后单action写入、单次撤销。没有周期写入预览参数。
## 验证入口
`--self-test` 增加实际IOSurface/Metal多HSL独立顺序参照、六类型CPU/GPU覆盖对照、alpha、空/默认直通、归档/非法数据、原生面板复用和实际插件分析回调(模拟宿主调度,使用真实Metal运动帧)的检查。它不代替实机宿主验证。
`python3 tools/create_mask_host_fixture.py` 生成本产品专用合成运动和两个独立FCP项目;不修改旧项目或用户媒体。最终验收必须在唯一正式安装的已公证版本中进行,并另存结果。
24版正式路径222项原生检查通过;新增OSC检查使用真实Metal叠加,验证透明背景、坐标命中、异步拖动写回、单次撤销和Esc取消。作者文档以不可变快照供OSC读取,不在绘制回调中进入主插件宿主API;添加蒙版先发布选择快照,再结束参数提交。轨迹查找使用CMTime二分定位,渲染快照仅替换各蒙版的当前参数,不重复序列化全部轨迹。
24版FCP12.4实测:第二HSL从0到32独立保存,原HSL保持0;原层椭圆中心X数值改为0.6,新增层矩形保持0.5;正向99键,一次Undo到0键,一次Redo到99键且完整预设逐字节一致;双向100键;新增层独立单帧2键,播放头由1帧到2帧。正常退出重开后,完整预设逐字节一致,分别保留100/2键。实际轮廓/工具栏可见;自动化坐标点击未进入真实宿主hit/event回调,因此FCP画面直接拖动、旋转和钢笔手势仍未实机确认,不能以模拟器通过代替。取消、过期目标和逆向精确节奏由原生模拟调度覆盖;Motion、Intel、变速/裁剪/非方像素未实测。
20–23版是本次中间验收节点,不作为最终发行。模板10005现采用父库原生Boolean flags8589934592/default0/value1,pluginVersion0解析当前插件。既有FCP保存的旧模板实例可能保留10005=0;画面控件需保存完整预设后重新应用新版效果,旧实例调色数学不自动迁移或覆盖。
+13
查看文件
@@ -0,0 +1,13 @@
{
"sourceRepository": "https://dayu.media/git/dayu/dayu-colorplate.git",
"sourceCommit": "f8950384e514685c8809fe8e8ee2dd5f16ad0bd7",
"files": {
"Core/DYMask.h": "ede701e3636c7608f5f8be3be2d95acfdd8080e751d18f89c6660bd874997101",
"Core/DYMaskOperator.h": "43fa701ad574f38ce0ab4f4d3900bb034edaaa1adc09821d2f4443ee2b687ba2",
"Core/DYTracker.hpp": "0d67d4d7d919cf3f255fe39f949c3e3ae6cad1a2ae07ad429ee45f1e23bdeb3e",
"Sources/DYMetalTracker.mm": "11b49215e9e024e5d1aa59a57dc7ab28048f569cfa3ef6943c014ad26040883d",
"Shaders/DYTracking.metal": "4949ffcc32701c95c2385e1ebd6425fbb8fe66771c801b65aaf0a308d23e155c"
},
"status": "implementation-in-progress",
"scope": "Adapt parent mask mathematics, Metal bidirectional optical flow and deterministic affine RANSAC. No reference app runtime dependency."
}
+8 -3
查看文件
@@ -1,7 +1,8 @@
{
"archivesBase64": {
"9000": "AAAAAAAAAisqYnBsaXN0MDDUAQIDBAUGBwxYJHZlcnNpb25ZJGFyY2hpdmVyVCR0b3BYJG9iamVjdHMSAAGGoF8QD05TS2V5ZWRBcmNoaXZlctIICQoLXERhdGFJc0xlZ2FjeV8QD0JsaW5kRGF0YU9iamVjdIACgAGjDQ4PVSRudWxsTxEBa2JwbGlzdDAw1AECAwQFBgcKWCR2ZXJzaW9uWSRhcmNoaXZlclQkdG9wWCRvYmplY3RzEgABhqBfEA9OU0tleWVkQXJjaGl2ZXLRCAlbQ3VzdG9tIERhdGGAAaULDBMZH1UkbnVsbNMNDg8QERJVZm9sZHNWc2NoZW1hViRjbGFzc4ACEAKABNMUFQ8WFxhXTlMua2V5c1pOUy5vYmplY3RzoKCAA9IaGxwdWiRjbGFzc25hbWVYJGNsYXNzZXNcTlNEaWN0aW9uYXJ5ohweWE5TT2JqZWN00hobICFfEBBEWUluc3BlY3RvclRva2VuoiIeXxAQRFlJbnNwZWN0b3JUb2tlbgAIABEAGgAkACkAMgA3AEkATABYAFoAYABmAG0AcwB6AIEAgwCFAIcAjgCWAKEAogCjAKUAqgC1AL4AywDOANcA3ADvAPIAAAAAAAACAQAAAAAAAAAjAAAAAAAAAAAAAAAAAAABBQgACAARABoAJAApADIANwBJAE4AWwBtAG8AcQB1AHsB6gAAAAAAAAIBAAAAAAAAABAAAAAAAAAAAAAAAAAAAAHrAA==",
"9001": "AAAAAAAAAjcqYnBsaXN0MDDUAQIDBAUGBwxYJHZlcnNpb25ZJGFyY2hpdmVyVCR0b3BYJG9iamVjdHMSAAGGoF8QD05TS2V5ZWRBcmNoaXZlctIICQoLXERhdGFJc0xlZ2FjeV8QD0JsaW5kRGF0YU9iamVjdIACgAGjDQ4PVSRudWxsTxEBd2JwbGlzdDAw1AECAwQFBgcKWCR2ZXJzaW9uWSRhcmNoaXZlclQkdG9wWCRvYmplY3RzEgABhqBfEA9OU0tleWVkQXJjaGl2ZXLRCAlbQ3VzdG9tIERhdGGAAaULDBUbIVUkbnVsbNQNDg8QERITFFVwYXRoc1YkY2xhc3Ncc3BpZGVyTGlua2VkWnNwaWRlck1lc2iAAoAECYAA0xYXDhgZGldOUy5rZXlzWk5TLm9iamVjdHOgoIAD0hwdHh9aJGNsYXNzbmFtZVgkY2xhc3Nlc1xOU0RpY3Rpb25hcnmiHiBYTlNPYmplY3TSHB0iI1xEWUFzc2V0U3RhdGWiJCBcRFlBc3NldFN0YXRlAAgAEQAaACQAKQAyADcASQBMAFgAWgBgAGYAbwB1AHwAiQCUAJYAmACZAJsAogCqALUAtgC3ALkAvgDJANIA3wDiAOsA8AD9AQAAAAAAAAACAQAAAAAAAAAlAAAAAAAAAAAAAAAAAAABDQgACAARABoAJAApADIANwBJAE4AWwBtAG8AcQB1AHsB9gAAAAAAAAIBAAAAAAAAABAAAAAAAAAAAAAAAAAAAAH3AA=="
"9001": "AAAAAAAAAjcqYnBsaXN0MDDUAQIDBAUGBwxYJHZlcnNpb25ZJGFyY2hpdmVyVCR0b3BYJG9iamVjdHMSAAGGoF8QD05TS2V5ZWRBcmNoaXZlctIICQoLXERhdGFJc0xlZ2FjeV8QD0JsaW5kRGF0YU9iamVjdIACgAGjDQ4PVSRudWxsTxEBd2JwbGlzdDAw1AECAwQFBgcKWCR2ZXJzaW9uWSRhcmNoaXZlclQkdG9wWCRvYmplY3RzEgABhqBfEA9OU0tleWVkQXJjaGl2ZXLRCAlbQ3VzdG9tIERhdGGAAaULDBUbIVUkbnVsbNQNDg8QERITFFVwYXRoc1YkY2xhc3Ncc3BpZGVyTGlua2VkWnNwaWRlck1lc2iAAoAECYAA0xYXDhgZGldOUy5rZXlzWk5TLm9iamVjdHOgoIAD0hwdHh9aJGNsYXNzbmFtZVgkY2xhc3Nlc1xOU0RpY3Rpb25hcnmiHiBYTlNPYmplY3TSHB0iI1xEWUFzc2V0U3RhdGWiJCBcRFlBc3NldFN0YXRlAAgAEQAaACQAKQAyADcASQBMAFgAWgBgAGYAbwB1AHwAiQCUAJYAmACZAJsAogCqALUAtgC3ALkAvgDJANIA3wDiAOsA8AD9AQAAAAAAAAACAQAAAAAAAAAlAAAAAAAAAAAAAAAAAAABDQgACAARABoAJAApADIANwBJAE4AWwBtAG8AcQB1AHsB9gAAAAAAAAIBAAAAAAAAABAAAAAAAAAAAAAAAAAAAAH3AA==",
"9002": "AAAAAAAAApUqYnBsaXN0MDDUAQIDBAUGBwxYJHZlcnNpb25ZJGFyY2hpdmVyVCR0b3BYJG9iamVjdHMSAAGGoF8QD05TS2V5ZWRBcmNoaXZlctIICQoLXERhdGFJc0xlZ2FjeV8QD0JsaW5kRGF0YU9iamVjdIACgAGjDQ4PVSRudWxsTxEB1WJwbGlzdDAw1AECAwQFBgcKWCR2ZXJzaW9uWSRhcmNoaXZlclQkdG9wWCRvYmplY3RzEgABhqBfEA9OU0tleWVkQXJjaGl2ZXLRCAlbQ3VzdG9tIERhdGGAAawLDBEdHh8gJCotMDFVJG51bGzSDQ4PEFhkb2N1bWVudFYkY2xhc3OAAoAL0xITDhQYHFdOUy5rZXlzWk5TLm9iamVjdHOjFRYXgAOABIAFoxkaG4AGgAiACoAHWWJhc2VNYXNrc1ZsYXllcnNWc2NoZW1h0xITDiEiHKCggAfSJSYnKFokY2xhc3NuYW1lWCRjbGFzc2VzXE5TRGljdGlvbmFyeaInKVhOU09iamVjdNITDissoIAJ0iUmLi9XTlNBcnJheaIuKRAB0iUmMjNeRFlUb29sRG9jdW1lbnSiNCleRFlUb29sRG9jdW1lbnQACAARABoAJAApADIANwBJAEwAWABaAGcAbQByAHsAggCEAIYAjQCVAKAApACmAKgAqgCuALAAsgC0ALYAwADHAM4A1QDWANcA2QDeAOkA8gD/AQIBCwEQAREBEwEYASABIwElASoBOQE8AAAAAAAAAgEAAAAAAAAANQAAAAAAAAAAAAAAAAAAAUsIAAgAEQAaACQAKQAyADcASQBOAFsAbQBvAHEAdQB7AlQAAAAAAAACAQAAAAAAAAAQAAAAAAAAAAAAAAAAAAACVQA="
},
"parameters": [
{
@@ -3064,13 +3065,17 @@
}
],
"sourceSHA256": {
"template/tools/dump_model.mm": "2ef22e010e0cae15b73107d39fb2c125f6049b1e5405e88078f936cf29e79350",
"template/tools/dump_model.mm": "04e04446aa351d774913bc25b06512fefe7969bdf4c6e471a91f1e9d6c4fc3b5",
"大鱼调色/Plugin/DYCSTTypes.h": "3372e3cd77248eeb374e54675d2902befceea8e00a2afc4f9543116ef3027696",
"大鱼调色/Plugin/DYColorManagement.h": "b0a4cd1b8c45dbce90a7b4f30f72ebf95ecd382895e74e3bfeda0f7cdb185157",
"大鱼调色/Plugin/DYModel.h": "80e88add97deeac7a9dc47d12f68b0245905786297de2e6553b3da15c729da6e",
"大鱼调色/Plugin/DYModel.mm": "bbc393bd1b5fb4e98ce800a017d8ea3544e0904035c86421dac8cf6fcb05a6a0",
"大鱼调色/Plugin/DYModel.mm": "beadabb0773e911581dedc263f55a49e03dde6e6d1fc2329df18cb384710d234",
"大鱼调色/Plugin/DYSpiderState.h": "0c80747e41e8fc97762e301b011bd08c18865a825eaafde086ed79ace37b22f9",
"大鱼调色/Plugin/DYToolState.h": "a1b0e328faae5dce7bb8497186f028a45d2da4f1a87e1980cd30c7a59a098a9f",
"大鱼调色/Plugin/DYToolState.mm": "2d8aefba3ddd1ab06fe63025c29efc5e6a4e586ce33486c8aceb7352e8ed6099",
"大鱼调色/Plugin/DYUniforms.h": "8ef480025c739b29f55884ba0c7218e9d6fd8d80c46cfc72d6ee3da90215abe4",
"大鱼调色/Plugin/MaskCore/DYMask.h": "5b9aa44390d4a1fca1baf5e34cb9eefc8483c939a65cc2a0412b7b41fc85bc16",
"大鱼调色/Plugin/MaskCore/DYMaskOperator.h": "43fa701ad574f38ce0ab4f4d3900bb034edaaa1adc09821d2f4443ee2b687ba2",
"大鱼调色/Plugin/SpiderCore/DYColorMath.h": "bdd6278e17ff4208ad94a8b0e834c817c0a3475f205dd79898e8fd88e84a19c9",
"大鱼调色/Plugin/SpiderCore/DYSpiderMesh.hpp": "81ecf1f0bae4030615144c7cd7ca492f93f2d718ff9e45da8242f97848e3d754"
}
+2 -1
查看文件
@@ -1,5 +1,6 @@
#import <Foundation/Foundation.h>
#import "DYModel.h"
#import "DYToolState.h"
static NSString *archive(id object) {
NSKeyedArchiver *inner=[[[NSKeyedArchiver alloc]initRequiringSecureCoding:YES]autorelease];
@@ -17,7 +18,7 @@ static NSString *archive(id object) {
return [carrier base64EncodedStringWithOptions:0];
}
int main(void){@autoreleasepool{
NSDictionary *out=@{@"parameters":DYDescriptors(),@"archivesBase64":@{@"9000":archive([[[DYInspectorToken alloc]init]autorelease]),@"9001":archive([[[DYAssetState alloc]init]autorelease])}};
NSDictionary *out=@{@"parameters":DYDescriptors(),@"archivesBase64":@{@"9000":archive([[[DYInspectorToken alloc]init]autorelease]),@"9001":archive([[[DYAssetState alloc]init]autorelease]),@"9002":archive([[[DYToolDocument alloc]init]autorelease])}};
NSError *error=nil;NSData *json=[NSJSONSerialization dataWithJSONObject:out options:NSJSONWritingPrettyPrinted|NSJSONWritingSortedKeys error:&error];
if(!json){fprintf(stderr,"Could not export our model metadata\n");return 2;}fwrite(json.bytes,1,json.length,stdout);return 0;
}}
+2 -2
查看文件
@@ -1,11 +1,11 @@
{
"passed": true,
"sha256": "86d62016bf9089d1eda07cc6a533bcb82d905df18351f48e73d6fb87945e09de",
"sha256": "9b8f6e407545429b77c1de88d4cceb738760771c5a7f1dbd9732bdcc95c23738",
"version": "5.13",
"displayversion": "5.6.7",
"filterCount": 1,
"nativeFloatParameters": 234,
"customParameters": 2,
"customParameters": 3,
"publications": [
{
"object": "10081",
+7 -2
查看文件
@@ -288,7 +288,7 @@
<parameter name="宽度" id="313" flags="8589934610" default="1" value="3840" />
<parameter name="高度" id="314" flags="8589934610" default="1" value="2160" />
</parameter>
<filter name="大鱼调色" id="10060" factoryID="5" pluginUUID="1C17B73B-F229-4C09-A434-EAF6DFF5F22A" pluginVersion="1" pluginName="大鱼调色" pluginDynamicParams="0">
<filter name="大鱼调色" id="10060" factoryID="5" pluginUUID="1C17B73B-F229-4C09-A434-EAF6DFF5F22A" pluginVersion="0" pluginName="大鱼调色" pluginDynamicParams="0">
<timing in="0 1 1 0" out="1199198 120000 1 0" offset="0 1 1 0" />
<baseFlags>8589934608</baseFlags>
<parameter name="大鱼调色" id="9000" flags="12884901888">
@@ -301,6 +301,11 @@
<defaultVal>*********XQeMb-gOLBoA11I*E61-*I4-klM75NZQbBdPqtN743mMqVdRaJmJ0FoPr-M74xWOaJXR5AG**44c3wE1otHGqJtNKF-QaBcOLNZQh660Ec9L2FVR437QolZNq3XSJwE1o7gOKtYF43oMIxWOaJXR6*0U*4X1EsDJGFiRKlgHl2-Rq7kP4ZnR1*kp*20*kE3-UQ8K0FqNL7nOKxiKGFVQaBcOLNZQZEYR4xkK0FjMadZMrFn2U*-Ve-T2*xCIohZSKJYEL7XO4ZqNL9F0*ZPErJnR4xh62FVR44**OI91-IP6JIYPbJgPBEB1UwE2F6H33JkMLFcQpMYMqlVQrBQQr-dN4JmH4ZiOqJYKbBkOKFZQYpZQqW**c*20M**olML1VUN4ZRCImtfNLZnKYtH9axWOaJXR5CUc6*1oVkR5VxO74BgMLBnPa3hNJUYMqlVQrBZQplCIoFdMrFdPqtVQbaW5W-MHZBDMadZMrHG5-oW6pl2KI3nQqJoIrFVR4KW70-QF3Z-QrBZR3BoMLFZ**U*2E*O*0E*8E*m*1Q*GE-A*3U*KU-U*4M*Pk-p*5k*WE0I*7M*a*0N*7g*cU0e*9I*hU0r*9Y*jU17*B6*rk1W*Cg*w*1x*E*********0*E*********Z*******************-1EU*0**F*-c*7**d*16*Bk-7*2s*Kk-h*4w*QE-p*5g-xU********6-*********-********************5r**</defaultVal>
<dataValue>*********XQeMb-gOLBoA11I*E61-*I4-klM75NZQbBdPqtN743mMqVdRaJmJ0FoPr-M74xWOaJXR5AG**44c3wE1otHGqJtNKF-QaBcOLNZQh660Ec9L2FVR437QolZNq3XSJwE1o7gOKtYF43oMIxWOaJXR6*0U*4X1EsDJGFiRKlgHl2-Rq7kP4ZnR1*kp*20*kE3-UQ8K0FqNL7nOKxiKGFVQaBcOLNZQZEYR4xkK0FjMadZMrFn2U*-Ve-T2*xCIohZSKJYEL7XO4ZqNL9F0*ZPErJnR4xh62FVR44**OI91-IP6JIYPbJgPBEB1UwE2F6H33JkMLFcQpMYMqlVQrBQQr-dN4JmH4ZiOqJYKbBkOKFZQYpZQqW**c*20M**olML1VUN4ZRCImtfNLZnKYtH9axWOaJXR5CUc6*1oVkR5VxO74BgMLBnPa3hNJUYMqlVQrBZQplCIoFdMrFdPqtVQbaW5W-MHZBDMadZMrHG5-oW6pl2KI3nQqJoIrFVR4KW70-QF3Z-QrBZR3BoMLFZ**U*2E*O*0E*8E*m*1Q*GE-A*3U*KU-U*4M*Pk-p*5k*WE0I*7M*a*0N*7g*cU0e*9I*hU0r*9Y*jU17*B6*rk1W*Cg*w*1x*E*********0*E*********Z*******************-1EU*0**F*-c*7**d*16*Bk-7*2s*Kk-h*4w*QE-p*5g-xU********6-*********-********************5r**</dataValue>
</parameter>
<parameter name="工具与蒙版" id="9002" flags="12889161776">
<numberOfKeypoints>0</numberOfKeypoints>
<defaultVal>*********dIeMb-gOLBoA11I*E61-*I4-klM75NZQbBdPqtN743mMqVdRaJmJ0FoPr-M74xWOaJXR5AG**44c3wE1otHGqJtNKF-QaBcOLNZQh660Ec9L2FVR437QolZNq3XSJwE1o7gOKtYF43oMIxWOaJXR6*0U*4X1EsDJGFiRKlgHl2-pK7kP4ZnR1*kp*20*kE3-UQ8K0FqNL7nOKxiKGFVQaBcOLNZQZEYR4xkK0FjMadZMrFn2U*-Ve-T2*xCIohZSKJYEL7XO4ZqNL9F0*ZPErJnR4xh62FVR44**Ok91-2R5VwU70chA13J74tpP4nG1EsD23VYPqBpPKJiR3MYMqlVQrC**c*9ol6H1VEM53RCImtfNLZnKYtH9axWOaJXR5CX3FMLU*C*-6*3clYO4s*4U*W*0c*5KK7VQqJBMLBfQpNgMLZZQbBKQqBcNKpVol6H1W2W580UU*TG7GMb83cYMqlVQrBiMKpZK0FXP43nQqJnL2tHF4ZXR4ZjPa3mSO6b8JVCIoxWOaJXRB6H1Wggc6*7oWIa9WxLHZB-Qb7VSO6i8F*-oWIaAXBSF3ZIPqxgF4xXRKpZPbGWB0ZSF3ZIPqxgF4xXRKpZPbE*0**F*-c*7**d*16*Bk-7*2k*K*-O*4Q*PE-m*5g*UU02*6M*XE0J*8**d*0a*8U*eU0i*9**gU0o*9M*k*15*As*pE1K*BQ*qE1S*CY*wU1z*E6-0k2E*F2-2k2M*G*-6k2Z*Gc-CE2w*********U2*********BE*******************Ig6**U*2E*O*0E*8E*m*1Q*GE-C*3g*PE-j*52*RE-v*ZE********0*E*********E*******************0JE*</defaultVal>
<dataValue>*********dIeMb-gOLBoA11I*E61-*I4-klM75NZQbBdPqtN743mMqVdRaJmJ0FoPr-M74xWOaJXR5AG**44c3wE1otHGqJtNKF-QaBcOLNZQh660Ec9L2FVR437QolZNq3XSJwE1o7gOKtYF43oMIxWOaJXR6*0U*4X1EsDJGFiRKlgHl2-pK7kP4ZnR1*kp*20*kE3-UQ8K0FqNL7nOKxiKGFVQaBcOLNZQZEYR4xkK0FjMadZMrFn2U*-Ve-T2*xCIohZSKJYEL7XO4ZqNL9F0*ZPErJnR4xh62FVR44**Ok91-2R5VwU70chA13J74tpP4nG1EsD23VYPqBpPKJiR3MYMqlVQrC**c*9ol6H1VEM53RCImtfNLZnKYtH9axWOaJXR5CX3FMLU*C*-6*3clYO4s*4U*W*0c*5KK7VQqJBMLBfQpNgMLZZQbBKQqBcNKpVol6H1W2W580UU*TG7GMb83cYMqlVQrBiMKpZK0FXP43nQqJnL2tHF4ZXR4ZjPa3mSO6b8JVCIoxWOaJXRB6H1Wggc6*7oWIa9WxLHZB-Qb7VSO6i8F*-oWIaAXBSF3ZIPqxgF4xXRKpZPbGWB0ZSF3ZIPqxgF4xXRKpZPbE*0**F*-c*7**d*16*Bk-7*2k*K*-O*4Q*PE-m*5g*UU02*6M*XE0J*8**d*0a*8U*eU0i*9**gU0o*9M*k*15*As*pE1K*BQ*qE1S*CY*wU1z*E6-0k2E*F2-2k2M*G*-6k2Z*Gc-CE2w*********U2*********BE*******************Ig6**U*2E*O*0E*8E*m*1Q*GE-C*3g*PE-j*52*RE-v*ZE********0*E*********E*******************0JE*</dataValue>
</parameter>
<parameter name="相机输入" id="2013" flags="12889161760" default="0" value="0" />
<parameter name="旧版输入强度" id="2014" flags="12889161760" default="1" value="1" />
<parameter name="CST 配置版本" id="2236" flags="12889161760" default="0" value="0" />
@@ -538,7 +543,7 @@
<parameter name="混合" id="10001" flags="12884901888" default="1" value="1" />
<parameter name="翻转" id="10002" flags="12889161760" default="0" value="0" />
<parameter name="输入点" id="10003" flags="12889161760" default="1" value="1" />
<parameter name="发布 OSC" id="10005" flags="4294967296" default="0" value="0" />
<parameter name="发布 OSC" id="10005" flags="8589934592" default="0" value="1" />
</filter>
</scenenode>
<aspectRatio>1</aspectRatio>
+10 -1
查看文件
@@ -3,6 +3,7 @@
from pathlib import Path
import argparse
import subprocess
from build_masked_kernel import masked_kernel
def main():
@@ -17,13 +18,21 @@ def main():
objects = []
for name in ('DYGradeKernel', 'DYStatisticsKernel', 'DYLUTExportKernel', 'CSTKernel', 'BasisKernel'):
target = work / (name + '.air')
subprocess.run(['xcrun', 'metal-opt', str(root / 'tools/kernels' / (name + '.ll')),
source = root / 'tools/kernels' / (name + '.ll')
if name == 'DYGradeKernel':
generated = work / 'DYGradeMasked.ll'
generated.write_text(masked_kernel(source.read_text()))
source = generated
subprocess.run(['xcrun', 'metal-opt', str(source),
'-o', str(target)], check=True)
objects.append(str(target))
wrapper = work / 'DYGradeWrapper.air'
subprocess.run(['xcrun', '-sdk', 'macosx', 'metal', '-std=metal3.1',
'-mmacosx-version-min=14.6', '-c',
str(root / '大鱼调色/Plugin/DYGrade.metal'), '-o', str(wrapper)], check=True)
tracking=work / 'DYTracking.air'
subprocess.run(['xcrun','-sdk','macosx','metal','-std=metal3.1','-mmacosx-version-min=14.6','-c',str(root/'大鱼调色/Plugin/DYTracking.metal'),'-o',str(tracking)],check=True)
objects.append(str(tracking))
subprocess.run(['xcrun', '-sdk', 'macosx', 'metallib', str(wrapper), *objects,
'-o', str(args.output)], check=True)
print(args.output)
+38
查看文件
@@ -0,0 +1,38 @@
"""Add per-stage coverage to a separate entry; preserve the legacy AIR function.
Anchors are exact SSA values of the versioned source, not guessed byte offsets.
No target runtime or installed reference binary is a build dependency.
"""
import re
def masked_kernel(source):
original = re.search(r'define <4 x half> @dy_grade\(.*?\n\}', source, re.S).group()
body = original.replace('@dy_grade(', '@dy_gradeMasked(', 1)
args = ', '.join(f'float %dyWeight{i}' for i in range(12))
body = body.replace(') local_unnamed_addr #0 {', ', '+args+') local_unnamed_addr #0 {', 1)
# Each stage mixes against its actual input. Split basic adjustment has
# two native locations; both use the same per-module coverage.
stages = [(82,53,0),(83,82,8),(408,83,2),(409,408,6),
(410,409,9),(411,410,11),(498,411,5),(519,498,7),
(520,519,2),(521,520,10),(668,521,4),(669,668,3)]
for value, before, section in stages:
target = f'%v{value}'
lines = body.splitlines()
index = next(i for i,l in enumerate(lines) if l.startswith(' '+target+' = '))
# Keep all PHIs first in a block, then insert the coverage operation.
end = index+1
while end<len(lines) and re.match(r' %\w+ = phi ',lines[end]): end+=1
lines[index] = lines[index].replace(target+' = ',f'%dyRaw{value} = ',1)
lines[end:end] = [
f' %dyScalar{value} = insertelement <3 x float> undef, float %dyWeight{section}, i64 0',
f' %dyVector{value} = shufflevector <3 x float> %dyScalar{value}, <3 x float> undef, <3 x i32> zeroinitializer',
f' {target} = tail call <3 x float> @air.mix.v3f32(<3 x float> %v{before}, <3 x float> %dyRaw{value}, <3 x float> %dyVector{value}) #1']
body='\n'.join(lines)
skin='''
define <3 x float> @dy_skinExtra(<3 x float> %color, <3 x float> %reference, %struct.DYUniforms addrspace(2)* %uniforms) {
entry:
%result = call fastcc <3 x float> @_ZL19applySkinProtectionDv3_fS_RU11MTLconstantK17DYUniforms(<3 x float> %color, <3 x float> %reference, %struct.DYUniforms addrspace(2)* %uniforms)
ret <3 x float> %result
}
'''
return source+'\n'+body+'\n'+skin
+10 -7
查看文件
@@ -20,14 +20,14 @@ CONTENT_TAGS={'scenenode','layer','group','filter','behavior','mask'}
def sha(data):return hashlib.sha256(data).hexdigest()
def model_identity():
files=['大鱼调色/Plugin/DYModel.h','大鱼调色/Plugin/DYModel.mm','大鱼调色/Plugin/DYUniforms.h','大鱼调色/Plugin/DYColorManagement.h','大鱼调色/Plugin/DYCSTTypes.h','大鱼调色/Plugin/DYSpiderState.h','大鱼调色/Plugin/SpiderCore/DYColorMath.h','大鱼调色/Plugin/SpiderCore/DYSpiderMesh.hpp','template/tools/dump_model.mm']
files=['大鱼调色/Plugin/DYModel.h','大鱼调色/Plugin/DYModel.mm','大鱼调色/Plugin/DYUniforms.h','大鱼调色/Plugin/DYColorManagement.h','大鱼调色/Plugin/DYCSTTypes.h','大鱼调色/Plugin/DYSpiderState.h','大鱼调色/Plugin/SpiderCore/DYColorMath.h','大鱼调色/Plugin/SpiderCore/DYSpiderMesh.hpp','template/tools/dump_model.mm','大鱼调色/Plugin/DYToolState.h','大鱼调色/Plugin/DYToolState.mm','大鱼调色/Plugin/MaskCore/DYMaskOperator.h','大鱼调色/Plugin/MaskCore/DYMask.h']
return {name:sha((ROOT/name).read_bytes()) for name in files}
def refresh_metadata():
cache=Path('/Users/mac/Library/Caches/CodexBuilds/com.dayu.color/template-model')
cache.mkdir(parents=True,exist_ok=True)
executable=cache/'dump_model'
command=['xcrun','clang++','-std=c++17','-fno-objc-arc','-fblocks','-F','/Library/Developer/SDKs/FxPlug.sdk/Library/Frameworks','-F','/Library/Developer/Frameworks','-framework','Foundation','-framework','AppKit','-framework','FxPlug','-Wl,-rpath,/Library/Developer/Frameworks','-I',str(ROOT/'大鱼调色/Plugin'),str(TEMPLATE/'tools/dump_model.mm'),str(ROOT/'大鱼调色/Plugin/DYModel.mm'),'-o',str(executable)]
command=['xcrun','clang++','-std=c++17','-fno-objc-arc','-fblocks','-F','/Library/Developer/SDKs/FxPlug.sdk/Library/Frameworks','-F','/Library/Developer/Frameworks','-framework','Foundation','-framework','AppKit','-framework','FxPlug','-framework','CoreMedia','-Wl,-rpath,/Library/Developer/Frameworks','-I',str(ROOT/'大鱼调色/Plugin'),str(TEMPLATE/'tools/dump_model.mm'),str(ROOT/'大鱼调色/Plugin/DYModel.mm'),str(ROOT/'大鱼调色/Plugin/DYToolState.mm'),'-o',str(executable)]
subprocess.run(command,check=True)
result=json.loads(subprocess.check_output([str(executable)],text=True))
result['sourceSHA256']=model_identity()
@@ -67,14 +67,14 @@ def build(model):
insert_at=list(root).index(root.findall('factory')[-1])+1
for uuid,fid in factory_ids.items():
factory=copy.deepcopy(lookup[uuid]);factory.set('id',fid);root.insert(insert_at,factory);insert_at+=1
filt=E.parse(SOURCES/'NativeFxPlugShell.xml').getroot()
filt=E.parse(SOURCES/'NativeFxPlugShell.xml').getroot();filt.set('pluginVersion','0')
# Keep the original native host mix/flip/input-point/OSC parameters, replace
# the product's entire registered parameter set and custom archives.
host=list(filt.findall('parameter'))
for node in host:filt.remove(node)
for pid,name in [('9000','大鱼调色'),('9001','LUT 文件')]:
for pid,name in [('9000','大鱼调色'),('9001','LUT 文件'),('9002','工具与蒙版')]:
text,class_name=custom_archive(model['archivesBase64'][pid])
expected='DYInspectorToken' if pid=='9000' else 'DYAssetState'
expected={'9000':'DYInspectorToken','9001':'DYAssetState','9002':'DYToolDocument'}[pid]
if class_name!=expected:raise ValueError('Wrong custom parameter class')
flags='12884901888' if pid=='9000' else '12889161776'
param=E.SubElement(filt,'parameter',name=name,id=pid,flags=flags)
@@ -83,7 +83,9 @@ def build(model):
for row in model['parameters']:
value=format(float(row['default']),'.17g')
E.SubElement(filt,'parameter',name=row['title'],id=str(row['pid']),flags='12889161776' if row.get('notAnimatable') else '12889161760',default=value,value=value)
for node in host:filt.append(node)
for node in host:
if node.get("id")=="10005":node.set("value","1");node.set("default","0");node.set("flags","8589934592")
filt.append(node)
source.append(filt)
copyright=E.parse(SOURCES/'CopyrightRig.xml').getroot()
entity_map={'3356608241':'10080','3356608243':'10081','3356608245':'10082'}
@@ -118,6 +120,7 @@ def verify(data,model):
assert len(filters)==1 and filters[0].get('pluginUUID')==PLUGIN_UUID
f=filters[0];params={p.get('id'):p for p in f.findall('parameter')}
assert len(params)==len(list(f.findall('parameter')))
assert params["10005"].get("value")=="1" and params["10005"].get("flags")=="8589934592" and f.get("pluginVersion")=="0"
for row in model['parameters']:
p=params[str(row['pid'])];assert float(p.get('default'))==float(row['default'])==float(p.get('value'))
assert all(not v in data for v in (b'CameraRawTables',b'1.png',b'relativeURL'))
@@ -148,7 +151,7 @@ def verify(data,model):
assert [entry.attrib for entry in menu.findall('entry')]==[{'name':title,'tag':'2'}]
assert widget.findtext('affecting')=='2' and widget.findtext('snapshot')=='3'
assert len({n.get('id') for n in scene.iter() if n.tag in CONTENT_TAGS})==len([n for n in scene.iter() if n.tag in CONTENT_TAGS])
return {'passed':True,'sha256':sha(data),'version':root.get('version'),'displayversion':root.findtext('displayversion'),'filterCount':1,'nativeFloatParameters':len(model['parameters']),'customParameters':2,'publications':[dict(t.attrib) for t in pub],'effectSourceType':3,'externalMediaRequired':False,'placeholder':'native Drop Zone.tiff','animationObjects':0,'copyright':{'passed':True,'rig':'10080','author':'10081','site':'10082','unbound':True},'savedSelection':{'passed':True,'selectedContentCount':0,'currentObjectIsProject':True},'hostUIVerified':False,'hostRenderVerified':False}
return {'passed':True,'sha256':sha(data),'version':root.get('version'),'displayversion':root.findtext('displayversion'),'filterCount':1,'nativeFloatParameters':len(model['parameters']),'customParameters':3,'publications':[dict(t.attrib) for t in pub],'effectSourceType':3,'externalMediaRequired':False,'placeholder':'native Drop Zone.tiff','animationObjects':0,'copyright':{'passed':True,'rig':'10080','author':'10081','site':'10082','unbound':True},'savedSelection':{'passed':True,'selectedContentCount':0,'currentObjectIsProject':True},'hostUIVerified':False,'hostRenderVerified':False}
def main():
+12
查看文件
@@ -0,0 +1,12 @@
#!/usr/bin/env python3
"""Synthetic, isolated mask/layer acceptance projects; no user media writes."""
from pathlib import Path
import subprocess,xml.etree.ElementTree as E
out=Path('/Users/mac/Library/Caches/CodexBuilds/com.dayu.color/fcp-qa');out.mkdir(parents=True,exist_ok=True)
media=out/'大鱼调色_蒙版合成运动.mov'
if not media.exists():
subprocess.run(['/opt/homebrew/bin/ffmpeg','-v','error','-f','lavfi','-i',"nullsrc=s=1080x640:r=25:d=4,geq=lum='128+70*sin(X/11)*cos(Y/9)+35*sin((X+Y)/4)':cb='128+35*sin(X/17)':cr='128+35*cos(Y/21)',crop=960:540:'40+10*t':'40+5*t'",'-c:v','prores_ks','-profile:v','2','-pix_fmt','yuv422p10le','-color_primaries','bt709','-color_trc','bt709','-colorspace','bt709',str(media)],check=True)
root=E.Element('fcpxml',version='1.12');res=E.SubElement(root,'resources');E.SubElement(res,'format',id='f1',width='960',height='540',frameDuration='1/25s',colorSpace='1-1-1 (Rec. 709)');a=E.SubElement(res,'asset',id='a1',name='合成运动纹理',start='0s',duration='4s',format='f1',hasVideo='1',videoSources='1');E.SubElement(a,'media-rep',kind='original-media',src=media.as_uri());template=Path('/Users/mac/Movies/Motion Templates.localized/Effects.localized/大鱼调色/大鱼调色/大鱼调色.moef');E.SubElement(res,'effect',id='fx',name='大鱼调色',uid='~/Effects.localized/大鱼调色/大鱼调色/大鱼调色.moef',src=template.as_uri());lib=E.SubElement(root,'library');event=E.SubElement(lib,'event',name='大鱼调色_1.4_23_蒙版与工具层验收')
for name in ['大鱼调色_1.4_23_独立工具与蒙版','大鱼调色_1.4_23_逐帧跟踪']:
project=E.SubElement(event,'project',name=name);seq=E.SubElement(project,'sequence',format='f1',tcStart='0s',tcFormat='NDF',audioLayout='stereo',audioRate='48k',duration='4s');spine=E.SubElement(seq,'spine');clip=E.SubElement(spine,'asset-clip',ref='a1',name=name,offset='0s',start='0s',duration='4s');E.SubElement(clip,'filter-video',ref='fx',name='大鱼调色',enabled='1')
E.indent(root);xml=out/'大鱼调色_1.4_23_蒙版与工具层.fcpxml';xml.write_text('<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE fcpxml>\n'+E.tostring(root,encoding='unicode')+'\n');print(xml)
+11
查看文件
@@ -0,0 +1,11 @@
{
"passResult": true,
"repository": "https://dayu.media/git/dayu/dayu-color.git",
"tag": "v1.3.1-browser-recents-20261101",
"releaseCommit": "281721bda11484c23f294b4f0d9e0b30ef829288",
"restoredFiles": 184,
"fsck": "full strict passed",
"compiledSource": "dbb7ca4a995ef832178a32f35939aed7d3a85012",
"compiledSourceRecovery": "verification/BrowserRecovery.json",
"cloneCleaned": true
}
+8 -7
查看文件
@@ -2,15 +2,16 @@
"status": "verified",
"path": "/Library/Plug-Ins/FxPlug/大鱼调色.app",
"bundleID": "com.dayu.color",
"version": "1.3.1",
"build": "19",
"version": "1.4.0",
"build": "24",
"team": "B3W25FX5H5",
"notaryID": "9e93dc7f-04a3-44f9-a1e4-792bd7b31533",
"notaryID": "40fdaaaa-1821-4cc8-bec3-c5dc6d8b9f77",
"notaryStatus": "Accepted",
"gatekeeper": "/Library/Plug-Ins/FxPlug/大鱼调色.app: accepted\nsource=Notarized Developer ID",
"sourceCommit": "dbb7ca4a995ef832178a32f35939aed7d3a85012",
"sourceCommit": "dbf25fe6719f17075362538dad0404951102524d",
"templatePath": "/Users/mac/Movies/Motion Templates.localized/Effects.localized/大鱼调色/大鱼调色/大鱼调色.moef",
"templateSHA256": "86d62016bf9089d1eda07cc6a533bcb82d905df18351f48e73d6fb87945e09de",
"shaderSHA256": "034fdf3de0c8ab0ac8eacc8f8a4bd6fbb8ee8c8c93ed3af61363c8175f0196e2",
"hostVerification": "verification/HostBrowserAndReset.json"
"templateSHA256": "9b8f6e407545429b77c1de88d4cceb738760771c5a7f1dbd9732bdcc95c23738",
"shaderSHA256": "df82ed0310281e854085063276ab161db7c623511751a1c1c63607b4072c8097",
"hostVerification": "verification/HostToolMasks.json",
"hostCanvasGestureVerification": "unverified-live-host; native simulator passed"
}
+84
查看文件
@@ -0,0 +1,84 @@
{
"status": "host-workflows-passed-with-manual-canvas-drag-unverified",
"version": "1.4.0",
"build": "24",
"host": "Final Cut Pro 12.4",
"platform": "Apple M4 / macOS 27.1",
"formalPath": "/Library/Plug-Ins/FxPlug/大鱼调色.app",
"compiledSource": "dbf25fe6719f17075362538dad0404951102524d",
"verifiedAt": "2026-11-01T14:33:04.639635+00:00",
"userMediaTouched": false,
"checks": {
"allTwelveHeadersHaveBothButtons": true,
"extraHSLStartsZero": true,
"extraHSLIndependent32Original0": true,
"perLayerEllipseAndRectangle": true,
"numericalMaskCenterEdit": true,
"hostCanvasOutlineAndToolbarVisible": true,
"forwardTracking99Exact25fpsKeys": true,
"singleUndoZeroKeys": true,
"singleRedoByteExact": true,
"bidirectional100Keys": true,
"extraLayerSingleFrameTwoKeys": true,
"singleFramePlayhead": "00:00:00:01 to 00:00:00:02",
"coldReopenCompletePresetByteExact": true,
"formalExecutablePathVerified": true
},
"presets": {
"independent": {
"path": "/Users/mac/Library/Caches/CodexBuilds/com.dayu.color/fcp-qa/mask24-independent.json",
"sha256": "c135ff71d798bb95745bf820dadac461064cfd5c6f6eec803316f1c5b6ddc266",
"originalHSLRedHue": 0,
"extraHSLRedHue": 32.0,
"baseMaskKeys": 0,
"extraMaskKeys": 0
},
"tracked": {
"path": "/Users/mac/Library/Caches/CodexBuilds/com.dayu.color/fcp-qa/mask24-tracked.json",
"sha256": "04fbeb6d3adf16e3d720e3004fb8fa90025ffa801fc3d656bcb5c2e25754d13b",
"originalHSLRedHue": 0,
"extraHSLRedHue": 32.0,
"baseMaskKeys": 99,
"extraMaskKeys": 0
},
"undo": {
"path": "/Users/mac/Library/Caches/CodexBuilds/com.dayu.color/fcp-qa/mask24-undo.json",
"sha256": "cd5afc39f7a135ab4f2d0bcfadf226a7dbe8a257a0352e3bccfc4c552209c6ac",
"originalHSLRedHue": 0,
"extraHSLRedHue": 32.0,
"baseMaskKeys": 0,
"extraMaskKeys": 0
},
"redo": {
"path": "/Users/mac/Library/Caches/CodexBuilds/com.dayu.color/fcp-qa/mask24-redo.json",
"sha256": "04fbeb6d3adf16e3d720e3004fb8fa90025ffa801fc3d656bcb5c2e25754d13b",
"originalHSLRedHue": 0,
"extraHSLRedHue": 32.0,
"baseMaskKeys": 99,
"extraMaskKeys": 0
},
"before-reopen": {
"path": "/Users/mac/Library/Caches/CodexBuilds/com.dayu.color/fcp-qa/mask24-before-reopen.json",
"sha256": "effbee122eb84087b9ba389d73a677c65c8d6c0cd3ee8258211906f0fda31bba",
"originalHSLRedHue": 0,
"extraHSLRedHue": 32.0,
"baseMaskKeys": 100,
"extraMaskKeys": 2
},
"after-reopen": {
"path": "/Users/mac/Library/Caches/CodexBuilds/com.dayu.color/fcp-qa/mask24-after-reopen.json",
"sha256": "effbee122eb84087b9ba389d73a677c65c8d6c0cd3ee8258211906f0fda31bba",
"originalHSLRedHue": 0,
"extraHSLRedHue": 32.0,
"baseMaskKeys": 100,
"extraMaskKeys": 2
}
},
"nativeChecks": 222,
"limitations": [
"Live FCP displays the native mask outline and toolbar, but automated coordinate clicks did not enter the plugin hit/event callbacks. Live canvas drag/rotate/pen gestures are unverified. Direct native OSC regression verifies real Metal overlay, hit testing, queued drag write, one undo and Escape through a host simulator; this is not a live gesture result.",
"Live FCP covers forward, bidirectional and single-frame tracking. Cancellation, stale-target rejection and backward cadence are additionally covered by native simulated host scheduling.",
"Motion, Intel, older systems, non-square-pixel/cropped/retimed projects are unverified. Tracking covers translation, rotation and independent XY scale, not perspective or shear.",
"Extra scalar tool values are static author data. Temporal mask tracks are supported. Spatial masks cannot be exported into Cube; complete presets preserve them."
]
}
+304 -6
查看文件
@@ -1,6 +1,6 @@
{
"bundlePath": "/Library/Plug-Ins/FxPlug/大鱼调色.app/Contents/PlugIns/大鱼调色 XPC Service.pluginkit",
"checks": 158,
"checks": 222,
"gpu": "Apple M4",
"limitations": [
"Finite states and a 64x48 frame; live FCP discovery, inspector interaction, timeline persistence and real host export require separate acceptance.",
@@ -12,7 +12,7 @@
"error": "未提供错误信息",
"name": "runtime-directory",
"pass": true,
"path": "/Users/mac/Library/Caches/CodexBuilds/com.dayu.color/verification-runtime/6821FF9D-5C7C-4DF8-9087-EB12C14C98FD"
"path": "/Users/mac/Library/Caches/CodexBuilds/com.dayu.color/verification-runtime/620C8AC1-C8E5-4503-807C-965B588D8082"
},
{
"descriptors": 234,
@@ -154,7 +154,7 @@
"pass": true
},
{
"name": "complete-version-three-preset-includes-mesh",
"name": "complete-version-four-preset-includes-mesh",
"pass": true
},
{
@@ -816,7 +816,7 @@
"error": "未提供错误信息",
"name": "renderer-export-33cube",
"pass": true,
"path": "/Users/mac/Library/Caches/CodexBuilds/com.dayu.color/verification-runtime/6821FF9D-5C7C-4DF8-9087-EB12C14C98FD/diagnostic-export.cube"
"path": "/Users/mac/Library/Caches/CodexBuilds/com.dayu.color/verification-runtime/620C8AC1-C8E5-4503-807C-965B588D8082/diagnostic-export.cube"
},
{
"bytes": 1186074,
@@ -836,7 +836,7 @@
},
{
"heartbeats": 0,
"maximumGapMS": 82.96920848079026,
"maximumGapMS": 90.16550006344914,
"name": "external-activation-main-loop-responsive",
"pass": true
},
@@ -873,8 +873,306 @@
{
"name": "external-preparation-cancellation",
"pass": true
},
{
"name": "tool-document-two-independent-hsl",
"pass": true
},
{
"name": "tool-document-secure-archive-roundtrip",
"pass": true
},
{
"name": "instance-proxy-batches-multiple-fields-without-clobber",
"pass": true
},
{
"name": "two-native-hsl-panels-with-mask-and-repeat-buttons",
"pass": true
},
{
"name": "tool-document-rejects-duplicate-identity",
"pass": true
},
{
"name": "tool-document-rejects-nonfinite",
"pass": true
},
{
"name": "mask-rational-time-interpolates-independent-geometry",
"pass": true
},
{
"name": "tracking-merge-preserves-manual-keys",
"pass": true
},
{
"name": "render-snapshot-freezes-time-without-author-keys",
"pass": true
},
{
"error": "未提供错误信息",
"name": "empty-tool-document-render",
"pass": true
},
{
"name": "empty-tool-document-preserves-legacy-pixels-exactly",
"pass": true
},
{
"error": "未提供错误信息",
"name": "all-twelve-initialized-tool-types-render",
"pass": true
},
{
"name": "initialized-repeated-tools-are-exactly-neutral",
"pass": true
},
{
"error": "",
"name": "hsl-stack-first-reference",
"pass": true
},
{
"error": "",
"name": "hsl-stack-second-reference",
"pass": true
},
{
"error": "未提供错误信息",
"name": "two-hsl-stack-render",
"pass": true
},
{
"changedComponents": 0,
"maxAbsoluteError": 0,
"name": "two-hsl-stack-matches-independent-sequential-reference",
"nonfiniteComponents": 0,
"nonzeroComponents": 9832,
"pass": true
},
{
"error": "",
"name": "mask-hsl-active-reference",
"pass": true
},
{
"error": "",
"name": "mask-hsl-bypass-reference",
"pass": true
},
{
"error": "未提供错误信息",
"name": "mask-type-0-gpu",
"pass": true
},
{
"name": "mask-type-0-preserves-alpha-finite",
"pass": true
},
{
"maximumError": 6.105005741119385e-05,
"name": "mask-type-0-independent-cpu-coverage",
"pass": true
},
{
"error": "未提供错误信息",
"name": "mask-type-1-gpu",
"pass": true
},
{
"name": "mask-type-1-preserves-alpha-finite",
"pass": true
},
{
"maximumError": 6.105005741119385e-05,
"name": "mask-type-1-independent-cpu-coverage",
"pass": true
},
{
"error": "未提供错误信息",
"name": "mask-type-2-gpu",
"pass": true
},
{
"name": "mask-type-2-preserves-alpha-finite",
"pass": true
},
{
"maximumError": 6.105005741119385e-05,
"name": "mask-type-2-independent-cpu-coverage",
"pass": true
},
{
"error": "未提供错误信息",
"name": "mask-type-3-gpu",
"pass": true
},
{
"name": "mask-type-3-preserves-alpha-finite",
"pass": true
},
{
"maximumError": 0.00043123960494995117,
"name": "mask-type-3-independent-cpu-coverage",
"pass": true
},
{
"error": "未提供错误信息",
"name": "mask-type-4-gpu",
"pass": true
},
{
"name": "mask-type-4-preserves-alpha-finite",
"pass": true
},
{
"maximumError": 0.0005036592483520508,
"name": "mask-type-4-independent-cpu-coverage",
"pass": true
},
{
"error": "未提供错误信息",
"name": "mask-type-5-gpu",
"pass": true
},
{
"name": "mask-type-5-preserves-alpha-finite",
"pass": true
},
{
"maximumError": 0.0005541741847991943,
"name": "mask-type-5-independent-cpu-coverage",
"pass": true
},
{
"error": "未提供错误信息",
"name": "hsl-rectangle-isolated-render",
"pass": true
},
{
"maximumError": 6.103515625e-05,
"name": "per-tool-mask-affects-only-own-region",
"pass": true
},
{
"error": "未提供错误信息",
"name": "mask-eye-disabled-render",
"pass": true
},
{
"name": "disabled-mask-restores-unmasked-tool",
"pass": true
},
{
"error": "未提供错误信息",
"name": "all-one-mask-render",
"pass": true
},
{
"name": "all-one-mask-preserves-native-operation",
"pass": true
},
{
"error": "未提供错误信息",
"name": "all-zero-mask-render",
"pass": true
},
{
"changedComponents": 91,
"maxAbsoluteError": 6.103515625e-05,
"name": "all-zero-mask-bypasses-only-own-tool",
"nonfiniteComponents": 0,
"nonzeroComponents": 9832,
"pass": true
},
{
"name": "cube-export-refuses-spatial-mask-with-clear-error",
"pass": true
},
{
"error": "",
"name": "primary-mask-full-reference",
"pass": true
},
{
"error": "",
"name": "primary-mask-bypass-reference",
"pass": true
},
{
"error": "未提供错误信息",
"name": "primary-cst-mask-render",
"pass": true
},
{
"name": "primary-mask-blends-cst-only-in-selected-region",
"pass": true
},
{
"name": "tracking-captures-real-full-input-texture",
"pass": true
},
{
"centerX": 0.5312505960464478,
"centerY": 0.5260424017906189,
"error": "未提供错误信息",
"keyCount": 6,
"name": "host-callback-metal-tracking-six-exact-frames",
"pass": true
},
{
"name": "tracking-results-use-one-undo-action",
"pass": true
},
{
"name": "duplicate-analysis-cleanup-never-commits-twice",
"pass": true
},
{
"name": "stale-analysis-cannot-overwrite-edited-mask",
"pass": true
},
{
"name": "cancel-keeps-only-contiguous-trusted-segment",
"pass": true
},
{
"name": "bidirectional-passes-share-reference-and-merge-once",
"pass": true
},
{
"name": "backward-single-step-includes-reference-and-one-neighbor",
"pass": true
},
{
"name": "canvas-cold-load-selects-saved-mask-from-immutable-snapshot",
"pass": true
},
{
"coveredPixels": 13508,
"name": "native-osc-real-metal-overlay-transparent-around-controls",
"pass": true
},
{
"name": "native-osc-object-to-canvas-center-hit",
"pass": true
},
{
"name": "native-osc-drag-writes-independent-normalized-geometry",
"pass": true,
"x": 0.550000011920929,
"y": 0.550000011920929
},
{
"name": "native-osc-drag-commits-one-undo-after-callback",
"pass": true
},
{
"name": "native-osc-escape-discards-draft-without-host-edit",
"pass": true
}
],
"runtimePath": "/Users/mac/Library/Caches/CodexBuilds/com.dayu.color/verification-runtime/6821FF9D-5C7C-4DF8-9087-EB12C14C98FD",
"runtimePath": "/Users/mac/Library/Caches/CodexBuilds/com.dayu.color/verification-runtime/620C8AC1-C8E5-4503-807C-965B588D8082",
"scope": "Native model and renderer integration with real Metal/IOSurface textures and fake FxPlug host selectors; no GUI or live host document."
}
+16 -16
查看文件
@@ -1,7 +1,7 @@
{
"package": "/Volumes/备份/大鱼调色/发行包/大鱼调色-1.3.1.pkg",
"sha256": "954b10c581f31d23a8c417a6f37b24fae19939786dce8733b4d6f09c7ed3adae",
"bytes": 14073683,
"package": "/Volumes/备份/大鱼调色/发行包/大鱼调色-1.4.0.pkg",
"sha256": "16a4958e28bc2a43c40e6131067eb03a49aecba5bbe3c0424bc7024fa532af38",
"bytes": 14250425,
"testUnsigned": false,
"installationExecuted": false,
"checks": [
@@ -31,34 +31,34 @@
"source": "/Library/Plug-Ins/FxPlug/大鱼调色.app",
"payload": "Library/Plug-Ins/FxPlug/大鱼调色.app",
"bundleID": "com.dayu.color",
"version": "1.3.1",
"build": "19"
"version": "1.4.0",
"build": "24"
},
{
"source": "/Users/mac/Library/Caches/CodexBuilds/com.dayu.color/pkg-inputs/大鱼调色",
"payload": "Library/Application Support/PKGForge/Payload/com.dayu.color.installer.65103cc9-6665-4d36-b01f-133a9a371475/740F02F8-EDB2-42B1-B5C8-D2D7138B46E7/大鱼调色"
"payload": "Library/Application Support/PKGForge/Payload/com.dayu.color.installer.994cb613-413c-4c58-8e23-fff445d88e9c/9D262E0D-82D6-436F-AF90-929F0C1FFE78/大鱼调色"
}
],
"signature": "Package \"大鱼调色-1.3.1.pkg\":\n Status: signed by a developer certificate issued by Apple for distribution\n Notarization: trusted by the Apple notary service\n Signed with a trusted timestamp on: 2026-11-01 12:55:56 +0000\n Certificate Chain:\n 1. Developer ID Installer: zhong luo (B3W25FX5H5)\n Expires: 2027-02-01 22:12:15 +0000\n SHA256 Fingerprint:\n C0 19 01 3C 67 88 8F 34 65 56 C5 91 3C E5 B6 12 4C 5D A6 DA F9 D8 \n DA 00 37 52 DF F0 F3 E6 00 B4\n ------------------------------------------------------------------------\n 2. Developer ID Certification Authority\n Expires: 2027-02-01 22:12:15 +0000\n SHA256 Fingerprint:\n 7A FC 9D 01 A6 2F 03 A2 DE 96 37 93 6D 4A FE 68 09 0D 2D E1 8D 03 \n F2 9C 88 CF B0 B1 BA 63 58 7F\n ------------------------------------------------------------------------\n 3. Apple Root CA\n Expires: 2035-02-09 21:40:36 +0000\n SHA256 Fingerprint:\n B0 B1 73 0E CB C7 FF 45 05 14 2C 49 F1 29 5E 6E DA 6B CA ED 7E 2C \n 68 C5 BE 91 B5 A1 10 01 F0 24",
"gatekeeper": "/Volumes/备份/大鱼调色/发行包/大鱼调色-1.3.1.pkg: accepted\nsource=Notarized Developer ID",
"signature": "Package \"大鱼调色-1.4.0.pkg\":\n Status: signed by a developer certificate issued by Apple for distribution\n Notarization: trusted by the Apple notary service\n Signed with a trusted timestamp on: 2026-11-01 14:34:31 +0000\n Certificate Chain:\n 1. Developer ID Installer: zhong luo (B3W25FX5H5)\n Expires: 2027-02-01 22:12:15 +0000\n SHA256 Fingerprint:\n C0 19 01 3C 67 88 8F 34 65 56 C5 91 3C E5 B6 12 4C 5D A6 DA F9 D8 \n DA 00 37 52 DF F0 F3 E6 00 B4\n ------------------------------------------------------------------------\n 2. Developer ID Certification Authority\n Expires: 2027-02-01 22:12:15 +0000\n SHA256 Fingerprint:\n 7A FC 9D 01 A6 2F 03 A2 DE 96 37 93 6D 4A FE 68 09 0D 2D E1 8D 03 \n F2 9C 88 CF B0 B1 BA 63 58 7F\n ------------------------------------------------------------------------\n 3. Apple Root CA\n Expires: 2035-02-09 21:40:36 +0000\n SHA256 Fingerprint:\n B0 B1 73 0E CB C7 FF 45 05 14 2C 49 F1 29 5E 6E DA 6B CA ED 7E 2C \n 68 C5 BE 91 B5 A1 10 01 F0 24",
"gatekeeper": "/Volumes/备份/大鱼调色/发行包/大鱼调色-1.4.0.pkg: accepted\nsource=Notarized Developer ID",
"pass": true,
"scope": "Expanded package structural and payload verification only; no installer scripts executed and no host quit or registration performed.",
"notarization": {
"message": "Successfully received submission info",
"id": "da6edea3-11f4-451b-aece-91916cca329a",
"createdDate": "2026-11-01T14:34:33.529Z",
"name": "大鱼调色-1.4.0.pkg",
"status": "Accepted",
"createdDate": "2026-11-01T12:55:58.535Z",
"id": "85cad776-c3d7-4037-9643-24041b269002",
"name": "大鱼调色-1.3.1.pkg"
"message": "Successfully received submission info"
},
"appCompiledSource": "dbb7ca4a995ef832178a32f35939aed7d3a85012",
"appBuild": "19",
"appCompiledSource": "dbf25fe6719f17075362538dad0404951102524d",
"appBuild": "24",
"packageBuilderRemote": "https://dayu.media/git/dayu/pkg-forge.git",
"packageBuilderCommit": "eb53707c0e67d8ddeab8c1270bb079f1050cfafe",
"templateSHA256": {
"大鱼调色.moef": "86d62016bf9089d1eda07cc6a533bcb82d905df18351f48e73d6fb87945e09de",
"大鱼调色.moef": "9b8f6e407545429b77c1de88d4cceb738760771c5a7f1dbd9732bdcc95c23738",
"large.png": "ab12611e8801cff86332ccc505a4cffa0c1120541c2efb9bb9908be2c9fe631a",
"small.png": "41fec3138aee904fc39d6982e6fde809243ffec55298dbfe966f4f48d89caf8a"
},
"installedAppHostAcceptance": "verification/HostBrowserAndReset.json",
"installedAppHostAcceptance": "verification/HostToolMasks.json",
"installScope": "本轮仅生成并验包,未再次执行系统安装;正式 APP 已有独立宿主验收。"
}
+19 -19
查看文件
@@ -3,33 +3,33 @@
"repository": "dayu/dayu-color",
"repositoryID": 52,
"private": false,
"tag": "v1.3.0-spider-balance-20261101",
"releaseCommit": "6528f888affe0acdd4292bc0c5ae0dac3a89b5a5",
"releaseID": 365,
"releaseURL": "https://dayu.media/git/dayu/dayu-color/releases/tag/v1.3.0-spider-balance-20261101",
"assetID": 11,
"assetName": "大鱼调色-1.3.0.pkg",
"downloadURL": "https://dayu.media/git/dayu/dayu-color/releases/download/v1.3.0-spider-balance-20261101/%E5%A4%A7%E9%B1%BC%E8%B0%83%E8%89%B2-1.3.0.pkg",
"bytes": 14066399,
"sha256": "36c251722d3c9e4aaed8d5a09bf5afd3bf84039e9d1161c63635ab9d8224f506",
"tag": "v1.3.1-browser-recents-20261101",
"releaseCommit": "281721bda11484c23f294b4f0d9e0b30ef829288",
"releaseID": 366,
"releaseURL": "https://dayu.media/git/dayu/dayu-color/releases/tag/v1.3.1-browser-recents-20261101",
"assetID": 12,
"assetName": "大鱼调色-1.3.1.pkg",
"downloadURL": "https://dayu.media/git/dayu/dayu-color/releases/download/v1.3.1-browser-recents-20261101/%E5%A4%A7%E9%B1%BC%E8%B0%83%E8%89%B2-1.3.1.pkg",
"bytes": 14073683,
"sha256": "954b10c581f31d23a8c417a6f37b24fae19939786dce8733b4d6f09c7ed3adae",
"existingAssetReused": true,
"verification": "Authenticated full download SHA-256 and byte count, then release/asset read-back.",
"credentialSource": "macOS Keychain: dayu-git-api",
"status": "published-and-download-verified",
"verifiedAt": "2026-11-01T12:32:32.150064+00:00",
"verifiedAt": "2026-11-01T13:00:20.219723+00:00",
"prePublishDraftDownload": {
"passResult": true,
"path": "/Volumes/备份/大鱼调色-1.3.0.pkg",
"bytes": 14066399,
"sha256": "36c251722d3c9e4aaed8d5a09bf5afd3bf84039e9d1161c63635ab9d8224f506",
"sourceURL": "https://dayu.media/git/dayu/dayu-color/releases/download/v1.3.0-spider-balance-20261101/%E5%A4%A7%E9%B1%BC%E8%B0%83%E8%89%B2-1.3.0.pkg",
"source": "Completed authenticated Microsoft Edge draft download; UI confirmed completion and opened containing folder.",
"birthtime": 1793536278.86,
"releaseID": 365,
"assetID": 11,
"path": "/Volumes/备份/大鱼调色-1.3.1.pkg",
"bytes": 14073683,
"sha256": "954b10c581f31d23a8c417a6f37b24fae19939786dce8733b4d6f09c7ed3adae",
"sourceURL": "https://dayu.media/git/dayu/dayu-color/releases/download/v1.3.1-browser-recents-20261101/%E5%A4%A7%E9%B1%BC%E8%B0%83%E8%89%B2-1.3.1.pkg",
"source": "Completed authenticated Edge draft download; downloads view changed to completed and file verified at the saved download destination.",
"birthtime": 1793537923.88,
"releaseID": 366,
"assetID": 12,
"temporaryCopyRemoved": true
},
"actualAppCompiledSource": "c2818cbb1157093f80efd2a85cea0cf1509f565e",
"actualAppCompiledSource": "dbb7ca4a995ef832178a32f35939aed7d3a85012",
"assetUploads": 1,
"credentialValueRecorded": false
}
+36
查看文件
@@ -0,0 +1,36 @@
{
"passResult": true,
"removed": [
{
"path": "/Library/Plug-Ins/FxPlug/.dayu-color-previous-7d4cb59101b145c9831f00eb51f1e512.app",
"version": "1.4.0",
"build": "22",
"reason": "Task-created previous formal install; final installed build24 verified"
},
{
"path": "/Library/Plug-Ins/FxPlug/.dayu-color-previous-793570296f434520b48336b9fc33da85.app",
"version": "1.3.1",
"build": "19",
"reason": "Task-created previous formal install; final installed build24 verified"
},
{
"path": "/Library/Plug-Ins/FxPlug/.dayu-color-previous-eb52cb62e5b64c3dbcbe51b4a4f07173.app",
"version": "1.4.0",
"build": "21",
"reason": "Task-created previous formal install; final installed build24 verified"
},
{
"path": "/Library/Plug-Ins/FxPlug/.dayu-color-previous-cc56f5cdd2894832abaa89e76df4de8b.app",
"version": "1.4.0",
"build": "20",
"reason": "Task-created previous formal install; final installed build24 verified"
}
],
"immediatePreviousBuild23RemovedByDelivery": true,
"formalBuild": "24",
"registry": [
" com.dayu.color.XPC(1.1)\t8C45F711-7E1E-43F1-907D-95297F896CE2\t2026-11-01 14:20:28 +0000\t/Library/Plug-Ins/FxPlug/大鱼调色.app/Contents/PlugIns/大鱼调色 XPC Service.pluginkit"
],
"scope": "Current product standard install dirs, fixed build cache and current checkout; unrelated user archives and products excluded",
"verifiedAt": "2026-11-01T14:33:52.542279+00:00"
}
+20
查看文件
@@ -0,0 +1,20 @@
{
"status": "superseded-before-release",
"version": "1.4.0",
"build": "20",
"sourceCommit": "659a8c540db47ed593059127ab7c5ab018c359c0",
"notaryID": "f3a3ff9e-91e6-4d7f-9e3b-12cb19e74e31",
"nativeChecks": 216,
"liveFCP": {
"addedInitializedSecondHSL": true,
"changedSecondHueTo32": true,
"perInstanceEllipse": true,
"singleStepRealHostKeys": 2,
"undoKeyCount": 0,
"redoKeyCount": 2,
"redoCompletePresetBytesEqual": true,
"oscVerified": false,
"oscBlocker": "Motion wrapper parameter 10005 remained zero; fixed to publish native OSC for build21."
},
"userMediaModified": false
}
+15
查看文件
@@ -0,0 +1,15 @@
{
"passResult": true,
"repository": "https://dayu.media/git/dayu/dayu-color.git",
"sourceCommit": "dbf25fe6719f17075362538dad0404951102524d",
"restoredFiles": 210,
"fsck": "full strict passed",
"rebuiltShaderSHA256": "df82ed0310281e854085063276ab161db7c623511751a1c1c63607b4072c8097",
"formalShaderSHA256": "df82ed0310281e854085063276ab161db7c623511751a1c1c63607b4072c8097",
"templateRebuiltFromNativeModel": true,
"templateSHA256": "9b8f6e407545429b77c1de88d4cceb738760771c5a7f1dbd9732bdcc95c23738",
"clone": "/Users/mac/Library/Caches/CodexBuilds/com.dayu.color/mask-remote-restore-leyx6cd4/source",
"LFS": false,
"submodules": false,
"cloneCleaned": true
}
+5 -3
查看文件
@@ -60,12 +60,14 @@
Plugin/DYDiagnostics.mm,
Plugin/DYGrade.metal,
Plugin/DYInspector.mm,
Plugin/DYTheme.mm,
Plugin/DYLUTLibrary.mm,
Plugin/DYLUTBrowser.mm,
Plugin/DYLUTLibrary.mm,
Plugin/DYModel.mm,
Plugin/DYPlugIn.mm,
Plugin/DYRenderer.mm,
Plugin/DYTheme.mm,
Plugin/DYToolState.mm,
Plugin/DYTracking.metal,
Plugin/Info.plist,
Plugin/main.m,
Plugin/Resources/DayuColorTables.bin,
@@ -121,9 +123,9 @@
Plugin/Resources/InputLUTs/sony_slog3_sgamut3cine_to_rec709.dylut,
"Plugin/Resources/THIRD-PARTY-NOTICES.txt",
"Wrapper Application/AppDelegate.m",
"Wrapper Application/Resources/DayuColor.icns",
"Wrapper Application/Info.plist",
"Wrapper Application/main.m",
"Wrapper Application/Resources/DayuColor.icns",
);
target = 04962E5C3095058F009952AA /* XPC Service */;
};
+10 -2
查看文件
@@ -13,6 +13,7 @@
#include <cstdio>
#include <cstring>
#include <vector>
#include "DYToolTrackingProbe.inc.h"
// Fake host objects implement the real selectors used by the model and renderer.
// They never connect to a host document or enter the FxPrincipal service loop.
@@ -56,9 +57,12 @@
- (BOOL)addFloatSliderWithName:(NSString *)name parameterID:(UInt32)pid defaultValue:(double)value parameterMin:(double)minimum parameterMax:(double)maximum sliderMin:(double)sliderMinimum sliderMax:(double)sliderMaximum delta:(double)delta parameterFlags:(FxParameterFlags)flags {
if(_values[@(pid)]||_custom[@(pid)]){_duplicate=YES;return NO;}_values[@(pid)]=@(value);return YES;
}
- (BOOL)addStringParameterWithName:(NSString*)name parameterID:(UInt32)pid defaultValue:(NSString*)value parameterFlags:(FxParameterFlags)flags{if(_values[@(pid)]||_custom[@(pid)]){_duplicate=YES;return NO;}_custom[@(pid)]=value;return YES;}
- (BOOL)addCustomParameterWithName:(NSString *)name parameterID:(UInt32)pid defaultValue:(NSObject<NSSecureCoding,NSCopying> *)value parameterFlags:(FxParameterFlags)flags {
if(_values[@(pid)]||_custom[@(pid)]){_duplicate=YES;return NO;}_custom[@(pid)]=value;return YES;
}
- (BOOL)getStringParameterValue:(NSString**)value fromParameter:(UInt32)pid{id string=_custom[@(pid)];if(![string isKindOfClass:NSString.class])return NO;if(value)*value=string;return YES;}
- (BOOL)setStringParameterValue:(NSString*)value toParameter:(UInt32)pid{if(![_custom[@(pid)]isKindOfClass:NSString.class])return NO;_custom[@(pid)]=value;return YES;}
- (BOOL)getFloatValue:(double *)value fromParameter:(UInt32)pid atTime:(CMTime)time {
NSNumber *stored=_values[@(pid)];if(!stored)return NO;if(value)*value=stored.doubleValue;return YES;
}
@@ -104,6 +108,7 @@
- (FxRect)imagePixelBounds {return _bounds;}
- (uint64_t)deviceRegistryID {return _registry;}
- (FxImageOrigin)imageOrigin {return _diagnosticOrigin;}
- (double)pixelAspect{return 1;}
- (void)setDiagnosticImageOrigin:(FxImageOrigin)origin {_diagnosticOrigin=origin;}
@end
@@ -173,7 +178,7 @@ extern "C" int DYRunDiagnostics(void) { @autoreleasepool {
for(NSDictionary *section in sections){BOOL base=YES;for(NSDictionary *row in descriptors)if([row[@"pid"]isEqual:section[@"enabled"]])initialGroups&=([row[@"default"]doubleValue]>=.5)==base;}
run.record(@"all-module-eyes-enabled-by-default",initialGroups);
DYDiagnosticManager *manager=[[[DYDiagnosticManager alloc]init]autorelease];error=nil;
run.need(@"native-parameter-creation",DYCreateParameters(manager,&error)&&!manager->_duplicate&&manager->_values.count==descriptors.count&&manager->_custom.count==2,@{@"error":reason(error)});
run.need(@"native-parameter-creation",DYCreateParameters(manager,&error)&&!manager->_duplicate&&manager->_values.count==descriptors.count&&manager->_custom.count==4,@{@"error":reason(error)});
id<FxParameterSettingAPI_v6> setter=[manager apiForProtocol:@protocol(FxParameterSettingAPI_v6)];id<FxParameterRetrievalAPI_v6> getter=[manager apiForProtocol:@protocol(FxParameterRetrievalAPI_v6)];
[setter setFloatValue:.75 toParameter:2000 atTime:kCMTimeZero];double value=0;[getter getFloatValue:&value fromParameter:2000 atTime:kCMTimeZero];DYUniforms restored;DYReadUniforms(manager,kCMTimeZero,&restored);
run.record(@"native-get-set-model-roundtrip",value==.75&&restored.exposure==.75f);
@@ -234,7 +239,7 @@ extern "C" int DYRunDiagnostics(void) { @autoreleasepool {
run.record(@"spider-single-drag-spoke-following-and-pin",dragged.x[0]>initialMesh.x[0]&&dragged.x[1]>initialMesh.x[1]&&dragged.x[3]>initialMesh.x[3]&&dragged.x[4]==initialMesh.x[4]&&dragged.x[5]==initialMesh.x[5]&&dragged.pins[2]);
run.record(@"spider-drag-one-host-undo-group",uiHost->_undoStarts==starts+1&&uiHost->_undoEnds==ends+1&&!uiHost->_undoActive);
error=nil;NSData *spiderArchive=[NSKeyedArchiver archivedDataWithRootObject:spiderSaved requiringSecureCoding:YES error:&error];DYAssetState *decodedSpider=[NSKeyedUnarchiver unarchivedObjectOfClass:DYAssetState.class fromData:spiderArchive error:&error];run.record(@"spider-archive-retains-mesh-pins-and-lut-paths",decodedSpider&&[decodedSpider isEqual:spiderSaved],@{@"error":reason(error)});
NSDictionary *snapshot=[inspector performSelector:@selector(presetSnapshot)];NSData *presetJSON=[NSJSONSerialization dataWithJSONObject:snapshot options:0 error:&error];NSDictionary *decodedPreset=[NSJSONSerialization JSONObjectWithData:presetJSON options:0 error:&error];run.record(@"complete-version-three-preset-includes-mesh",[decodedPreset[@"version"]isEqual:@3]&&[DYSpiderFromJSON(decodedPreset[@"spider"])isEqual:spiderSaved.spiderMesh]);
NSDictionary *snapshot=[inspector performSelector:@selector(presetSnapshot)];NSData *presetJSON=[NSJSONSerialization dataWithJSONObject:snapshot options:0 error:&error];NSDictionary *decodedPreset=[NSJSONSerialization JSONObjectWithData:presetJSON options:0 error:&error];run.record(@"complete-version-four-preset-includes-mesh",[decodedPreset[@"version"]isEqual:@4]&&[DYSpiderFromJSON(decodedPreset[@"spider"])isEqual:spiderSaved.spiderMesh]);
NSDictionary *portable=DYSpiderJSON(spiderSaved.spiderMesh,spiderSaved.spiderLinked);NSData *decodedPortable=DYSpiderFromJSON(portable);run.record(@"spider-json-preset-exact-roundtrip",[decodedPortable isEqual:spiderSaved.spiderMesh]);
NSMutableDictionary *badJSON=[[portable mutableCopy]autorelease];badJSON[@"hues"]=@7;run.record(@"spider-json-rejects-unsupported-topology",!DYSpiderFromJSON(badJSON));auto corrupt=dragged;corrupt.x[0]=NAN;run.record(@"spider-archive-rejects-nonfinite-coordinates",!DYSpiderMeshIsValid([NSData dataWithBytes:&corrupt length:sizeof(corrupt)]));
[disc changeHueCount:12 saturationCount:8];spiderSaved=DYReadAssets(uiHost,kCMTimeZero);auto dense=DYSpiderMesh(spiderSaved.spiderMesh);run.record(@"spider-independent-resolution-and-resample",dense.hues==12&&dense.rings==7&&fabs(dy::meshDelta(dense,0,.6).x)>0);
@@ -412,6 +417,9 @@ extern "C" int DYRunDiagnostics(void) { @autoreleasepool {
}}
run.record(@"user-folder-all-luts-prepared-and-rendered",userCount>0&&allUserFrames,@{@"files":@(userCount),@"sourceFolder":userFolder,@"sourceFilesModified":@NO});
}
#include "DYToolDiagnostics.inc.h"
#include "DYToolTrackingDiagnostics.inc.h"
#include "DYToolCanvasDiagnostics.inc.h"
[gpu release];
} @catch(NSException *exception) {
run.record(@"diagnostic-exception",false,@{@"exception":exception.name?:@"unknown",@"message":exception.reason?:@"unknown"});
+131
查看文件
@@ -1,5 +1,6 @@
#include <metal_stdlib>
#include "DYUniforms.h"
#include "DYToolGPU.h"
#include "SpiderCore/DYColorMath.h"
using namespace metal;
@@ -11,6 +12,12 @@ extern "C" half4 dy_grade(half4 sample, float2 uv, texture2d<half> source,
texture3d<float> hslMixer, texture3d<float> whiteBalance,
texture3d<float> colorGrading, constant DYUniforms& uniforms,
constant float& sceneLevel);
extern "C" half4 dy_gradeMasked(half4 sample, float2 uv, texture2d<half> source,
texture3d<float> preLUT, texture3d<float> look1, texture3d<float> look2,
texture3d<float> look3, texture3d<float> look4, texture3d<float> look5,
texture3d<float> hslMixer, texture3d<float> whiteBalance,
texture3d<float> colorGrading, constant DYUniforms& uniforms,
constant float& sceneLevel,float w0,float w1,float w2,float w3,float w4,float w5,float w6,float w7,float w8,float w9,float w10,float w11);
struct DYRaster {
float4 position [[position]];
@@ -61,6 +68,119 @@ fragment half4 dyFragment(DYRaster in [[stage_in]],
return result;
}
inline float dyToolMaskSoftStep(float low,float high,float value){if(high<=low)return value>=high?1:0;return dySmooth(low,high,value);}
inline float dyToolMaskRangeWeight(float value,thread const DYMaskRange& range){
float low=value>=range.low?1:dyToolMaskSoftStep(range.low-range.softLow,range.low,value);
float high=value<=range.high?1:1-dyToolMaskSoftStep(range.high,range.high+range.softHigh,value);
return low*high;
}
inline float dyToolMaskLeveledCoverage(float raw,thread const DYMaskParameters& p){
float a=dyClamp((raw-p.inputBlack)/(p.inputWhite-p.inputBlack),0,1);
if(p.inputGamma!=1&&a>0&&a<1)a=pow(a,1/p.inputGamma);
return p.outputBlack+(p.outputWhite-p.outputBlack)*a;
}
inline float dyToolMaskFinalCoverage(float a,thread const DYMaskParameters& p){
if(p.flags&DYMaskInvert)a=1-a;
return dyClamp(a*p.strength,0,1);
}
inline float dyToolMaskLevels(float raw,thread const DYMaskParameters& p){return dyToolMaskFinalCoverage(dyToolMaskLeveledCoverage(raw,p),p);}
inline float dyToolMaskHSLWeight(float3 source,thread const DYMaskParameters& p){
float3 c=dyLimit(source);float lo=c.x<c.y?(c.x<c.z?c.x:c.z):(c.y<c.z?c.y:c.z),hi=c.x>c.y?(c.x>c.z?c.x:c.z):(c.y>c.z?c.y:c.z);
// Same signed/HDR interval convention as the quick HSL tools. This is code
// RGB selection; use LumaKey levels when absolute HDR brightness is needed.
float base=lo<0?lo:0,scale=hi-base;if(scale<1)scale=1;
float3 hsl=dyRGBHSL((c-float3{base,base,base})/scale);float weight=1;
if(p.flags&DYMaskHueEnabled){
float distance=dyHueDistance(hsl.x,p.hueCenterTurns),outer=p.hueCoreHalfWidth+p.hueSoftWidth;if(outer>.5f)outer=.5f;
float hue=p.hueCoreHalfWidth>=.5f||distance<=p.hueCoreHalfWidth?1:1-dyToolMaskSoftStep(p.hueCoreHalfWidth,outer,distance);
float chroma=(hi-lo)/scale;weight*=hue*dyToolMaskSoftStep(p.neutralChromaLow,p.neutralChromaHigh,chroma);
}
if(p.flags&DYMaskSaturationEnabled)weight*=dyToolMaskRangeWeight(hsl.y,p.saturationRange);
if(p.flags&DYMaskLightnessEnabled)weight*=dyToolMaskRangeWeight(hsl.z,p.lightnessRange);
return weight;
}
inline float dyToolMaskShapeWeight(float x,float y,thread const DYMaskParameters& p,thread const DYMaskPath& path){
float dx=(x-p.centerX)*p.imageAspect,dy=y-p.centerY,ca=cos(p.angle),sa=sin(p.angle);
float px=dx*ca+dy*sa,py=-dx*sa+dy*ca;
if(p.kind==DYMaskLinearGradient){
if(p.gradientWidth==0)return px>=0?1:0;
return dyToolMaskSoftStep(0,1,.5f+px/(p.gradientWidth>1e-12f?p.gradientWidth:1e-12f));
}
float physicalWidth=p.width*p.imageAspect,physicalHeight=p.height;if(physicalWidth<1e-12f)physicalWidth=1e-12f;if(physicalHeight<1e-12f)physicalHeight=1e-12f;
if(p.kind==DYMaskEllipse){float u=px/(physicalWidth*.5f),v=py/(physicalHeight*.5f),r=sqrt(u*u+v*v);if(p.feather==0)return r<=1?1:0;if(p.version==2&&(p.flags&DYMaskFeatherOutsideFlag))return 1-dyToolMaskSoftStep(1,1+p.feather,r);return 1-dyToolMaskSoftStep(1-p.feather,1,r);}
float shorter=physicalWidth<physicalHeight?physicalWidth:physicalHeight;
if(p.kind==DYMaskRectangle){float ax=px<0?-px:px,ay=py<0?-py:py,a=physicalWidth*.5f-ax,b=physicalHeight*.5f-ay;if(p.version==2&&(p.flags&DYMaskFeatherOutsideFlag)){if(p.feather==0)return a>=0&&b>=0?1:0;return dyToolMaskSoftStep(-p.feather*.5f*shorter,0,a<b?a:b);}if(a<0||b<0)return 0;if(p.feather==0)return 1;return dyToolMaskSoftStep(0,p.feather*.5f,(a<b?a:b)/shorter);}
if(path.count<3||path.count>256)return 0;
float u=px/physicalWidth,v=py/physicalHeight,sx=physicalWidth/shorter,sy=physicalHeight/shorter,distance2=1e10f;bool inside=false;
for(int i=0,j=path.count-1;i<path.count;j=i++){
float ax=path.x[j],ay=path.y[j],bx=path.x[i],by=path.y[i];if((ay>v)!=(by>v))if(u<(bx-ax)*(v-ay)/(by-ay)+ax)inside=!inside;
float ex=(bx-ax)*sx,ey=(by-ay)*sy,xx=(u-ax)*sx,yy=(v-ay)*sy,den=ex*ex+ey*ey,t=den>1e-12f?dyClamp((xx*ex+yy*ey)/den,0,1):0;
xx-=t*ex;yy-=t*ey;float d=xx*xx+yy*yy;if(d<distance2)distance2=d;
}
if(!inside)return 0;if(p.feather==0)return 1;return dyToolMaskSoftStep(0,p.feather*.5f,sqrt(distance2));
}
inline float dyToolMaskRawCoverage(float x,float y,float3 source,thread const DYMaskParameters& p,thread const DYMaskPath& path){return p.kind==DYMaskHSLKey?dyToolMaskHSLWeight(source,p):(p.kind==DYMaskLumaKey?dyLuma(dyLimit(source)):dyToolMaskShapeWeight(x,y,p,path));}
inline float dyToolMaskOperator(float x,float y,float3 source,thread const DYMaskParameters& p,thread const DYMaskPath& path){
if((p.version!=1&&p.version!=2)||p.kind>DYMaskLumaKey)return 0;
float raw=dyToolMaskRawCoverage(x,y,source,p,path);
return dyToolMaskLevels(raw,p);
}
inline float dyToolMask(float x,float y,float3 source,device const DYResolvedMask& value){DYResolvedMask local=value;return dyToolMaskOperator(x,y,source,local.parameters,local.path);}
inline float3 dyToolEncode(float3 linear){return select(1.055f*pow(max(linear,float3(0)),float3(1.f/2.4f))-.055f,linear*12.92f,linear<=.0031308f);}
inline float3 dyToolDecode(float3 encoded){return select(pow(max((encoded+.055f)/1.055f,float3(0)),float3(2.4f)),encoded/12.92f,encoded<=.04045f);}
inline float dyToolCoverage(float2 uv,float3 source,device const DYToolMaskEntry* masks,constant DYToolMaskHeader& h,int section){
float x=h.offsetX+uv.x*h.scaleX,y=h.offsetY+uv.y*h.scaleY;float coverage=1;bool found=false;
for(uint i=0;i<h.count;i++){if(masks[i].section!=section)continue;
// Copy device data to thread storage; shared mask math accepts constant
// descriptors, so evaluate through the address-space-neutral copy below.
float a=dyToolMask(x,y,source,masks[i].mask);
if(!found){coverage=masks[i].combine==1?1-a:a;found=true;}
else if(masks[i].combine==1)coverage*=1-a;else if(masks[i].combine==2)coverage*=a;else coverage=1-(1-coverage)*(1-a);
}return clamp(coverage,0.f,1.f);
}
fragment half4 dyMaskedFragment(DYRaster in [[stage_in]],
texture2d<half> source [[texture(0)]],
texture3d<float> preLUT [[texture(1)]],
texture3d<float> look1 [[texture(2)]],
texture3d<float> look2 [[texture(3)]],
texture3d<float> look3 [[texture(4)]],
texture3d<float> look4 [[texture(5)]],
texture3d<float> look5 [[texture(6)]],
texture3d<float> hslMixer [[texture(7)]],
texture3d<float> whiteBalance [[texture(8)]],
texture3d<float> colorGrading [[texture(9)]],
constant DYUniforms& uniforms [[buffer(0)]],
constant float& sceneLevel [[buffer(1)]],
constant DYRenderOptions& options [[buffer(2)]],
constant DYUniforms& colorUniforms [[buffer(3)]],
device const float* spiderSamples [[buffer(4)]],
constant int2& spiderSize [[buffer(5)]],
device const DYToolMaskEntry* masks [[buffer(6)]],
constant DYToolMaskHeader& maskHeader [[buffer(7)]]) {
constexpr sampler sampleFilter(coord::normalized, address::clamp_to_edge, filter::linear);
half4 sample = source.sample(sampleFilter, in.uv);
if (!(sample.a > half(0.0))) return half4(0.0h);
float weights[12];float3 encoded=dyToolEncode(float3(sample.rgb));
for(int i=0;i<12;i++)weights[i]=dyToolCoverage(in.uv,encoded,masks,maskHeader,i);
half4 result = dy_gradeMasked(sample, in.uv, source, preLUT, look1, look2, look3,
look4, look5, hslMixer, whiteBalance, colorGrading, uniforms, sceneLevel,weights[0],weights[1],weights[2],weights[3],weights[4],weights[5],weights[6],weights[7],weights[8],weights[9],weights[10],weights[11]);
if(options.blackWhiteMix>0.0f && options.blackWhiteMix<1.0f) {
half4 color=dy_gradeMasked(sample,in.uv,source,preLUT,look1,look2,look3,look4,look5,hslMixer,whiteBalance,colorGrading,colorUniforms,sceneLevel,weights[0],weights[1],weights[2],weights[3],weights[4],weights[5],weights[6],weights[7],weights[8],weights[9],weights[10],weights[11]);
result.rgb=mix(color.rgb,result.rgb,half(options.blackWhiteMix));
}
if(spiderSize.x>0 && uniforms.spiderSectionEnabled>.5f && uniforms.spiderMix>0.0f){
float3 color=float3(result.rgb);float3 warped=dyVariableSpider(color,spiderSize.x,spiderSize.y,spiderSamples);
result.rgb=half3(dyLimit(mix(color,warped,uniforms.spiderMix*weights[1])));
}
result.a = sample.a;
if (options.outputPremultiplied) result.rgb *= result.a;
return result;
}
// Optional boundary conversion. Use this before both statistics and grading
// when the host supplies premultiplied RGB; all neighborhood samples then see
// the same straight RGB representation. Source and destination must differ.
@@ -144,3 +264,14 @@ kernel void dyColorManagement(texture2d<float,access::read> source [[texture(0)]
c.rgb=mix(raw.rgb,c.rgb,amount);
destination.write(half4(half3(dyDecode(c.rgb)),half(sample.a)),pos);
}
// Premultiplication is preserved by mixing the two equally-alpha images.
kernel void dyToolBlend(texture2d<float,access::read> before [[texture(0)]],texture2d<float,access::read> after [[texture(1)]],texture2d<half,access::write> output [[texture(2)]],device const DYToolMaskEntry* masks [[buffer(0)]],constant DYToolMaskHeader& h [[buffer(1)]],uint2 pos [[thread_position_in_grid]]){
if(pos.x>=output.get_width()||pos.y>=output.get_height())return;float4 a=before.read(pos),b=after.read(pos);float2 uv=(float2(pos)+.5f)/float2(output.get_width(),output.get_height());float amount=dyToolCoverage(uv,dyToolEncode(a.a>0?(h.premultiplied?a.rgb/a.a:a.rgb):float3(0)),masks,h,h.section);output.write(half4(mix(a,b,amount)),pos);
}
extern "C" float3 dy_skinExtra(float3 color,float3 reference,constant DYUniforms& uniforms);
kernel void dyToolSkin(texture2d<float,access::read> before [[texture(0)]],texture2d<float> reference [[texture(1)]],texture2d<half,access::write> output [[texture(2)]],constant DYUniforms& u [[buffer(0)]],uint2 pos [[thread_position_in_grid]]){
if(pos.x>=output.get_width()||pos.y>=output.get_height())return;constexpr sampler f(coord::normalized,address::clamp_to_edge,filter::linear);float4 a=before.read(pos),b=reference.sample(f,(float2(pos)+.5f)/float2(output.get_width(),output.get_height()));if(a.a>0){float3 c=dy_skinExtra(dyToolEncode(a.rgb/a.a),dyToolEncode(b.a>0?b.rgb/b.a:float3(0)),u);a.rgb=dyToolDecode(c)*a.a;}output.write(half4(a),pos);
}
fragment half4 dyToolCopyFragment(DYRaster in [[stage_in]],texture2d<half> source [[texture(0)]]){constexpr sampler f(coord::normalized,address::clamp_to_edge,filter::linear);return source.sample(f,in.uv);}
+52 -26
查看文件
@@ -1,5 +1,8 @@
#import "DYInspector.h"
#import "DYModel.h"
#import "DYToolState.h"
#import "DYAutoGrade.h"
#import "DYColorTables.h"
#import "DYTheme.h"
#import "DYLUTLibrary.h"
#import "DYLUTBrowser.h"
@@ -121,6 +124,7 @@ static NSArray *DYAccessibleSubviews(NSView *view, BOOL visibleOnly) {
- (NSArray *)accessibilityVisibleChildren { return self.accessibilityChildren; }
- (NSArray *)accessibilityChildrenInNavigationOrder { return self.accessibilityChildren; }
- (id)accessibilityVerticalScrollBar { return self.hasVerticalScroller?self.verticalScroller:nil; }
- (void)scrollWheel:(NSEvent*)event{if(!self.hasVerticalScroller){[self.nextResponder scrollWheel:event];return;}[super scrollWheel:event];}
@end
@interface DYCard : DYFlippedView @end
@@ -378,6 +382,7 @@ static NSImage *DYWheelImage(void) {
@end
#include "DYNewPanels.inc.h"
#include "DYMaskPanel.inc.h"
@interface DYInspector () <DYGraphicDelegate> {
id<PROAPIAccessing> _manager;
@@ -399,6 +404,7 @@ static NSImage *DYWheelImage(void) {
NSMutableDictionary *_tabs;
NSInteger _visibleLooks;
BOOL _refreshing,_graphicUndoOpen;
BOOL _embedded;NSMutableDictionary *_stackViews;NSArray *_stackOrder;CGFloat _stackHeight;
DYSpiderPanel *_spiderPanel;
NSMutableDictionary *_assetLoads,*_assetLoadIDs;
NSUInteger _nextAssetLoadID;
@@ -410,13 +416,16 @@ static NSImage *DYWheelImage(void) {
@end
@implementation DYInspector
#include "DYToolInspector.inc.h"
- (instancetype)initWithAPIManager:(id<PROAPIAccessing>)manager {
return [self initWithAPIManager:manager renderer:nil];
}
- (instancetype)initWithAPIManager:(id<PROAPIAccessing>)manager renderer:(DYRenderer *)renderer {
if((self=[super initWithFrame:NSMakeRect(0,0,360,780)])) {
_assetLoads=[NSMutableDictionary new];_assetLoadIDs=[NSMutableDictionary new];_manager=manager; _renderer=[renderer retain];_library=[DYLUTLibrary new];_tabs=[NSMutableDictionary new];_visibleLooks=1;
_sections=[DYPresentationSections() copy];
_embedded=[manager isKindOfClass:DYToolManager.class];if(_embedded)[(id)_manager retain];
NSArray *presentation=DYPresentationSections();if(_embedded){NSMutableArray *filtered=[NSMutableArray array];for(NSDictionary *s in presentation)if([s[@"key"]isEqual:[(DYToolManager*)manager type]])[filtered addObject:s];presentation=filtered;}
_sections=[presentation copy];_stackViews=[NSMutableDictionary new];_stackOrder=[@[]copy];
_cards=[[NSMutableArray alloc] init]; _controls=[[NSMutableDictionary alloc] init];
_assetButtons=[[NSMutableDictionary alloc] init]; _graphics=[[NSMutableArray alloc] init];
self.autoresizingMask=NSViewWidthSizable;
@@ -430,13 +439,13 @@ static NSImage *DYWheelImage(void) {
_save=[DYButton(@"保存预设",self,@selector(savePreset:)) retain];
_load=[DYButton(@"载入预设",self,@selector(loadPreset:)) retain];
_export=[DYButton(@"导出 LUT",self,@selector(exportLUT:)) retain];
for(NSView *v in @[_brand,_subtitle,_resetAll,_save,_load,_export]) [self addSubview:v];
for(NSView *v in @[_brand,_subtitle,_resetAll,_save,_load,_export]){[self addSubview:v];v.hidden=_embedded;}
NSMutableArray *themes=[NSMutableArray array];for(NSInteger i=0;i<5;i++){
DYSwatchButton *b=[[[DYSwatchButton alloc]initWithFrame:NSZeroRect]autorelease];[b setButtonType:NSButtonTypePushOnPushOff];b.swatch=DYThemeSwatch(i);b.tag=i;b.target=self;b.action=@selector(selectTheme:);b.title=@"";b.bordered=NO;
b.toolTip=[DYThemeNames()[i] stringByAppendingString:@"主题"];b.accessibilityLabel=b.toolTip;[self addSubview:b];[themes addObject:b];
b.toolTip=[DYThemeNames()[i] stringByAppendingString:@"主题"];b.accessibilityLabel=b.toolTip;[self addSubview:b];b.hidden=_embedded;[themes addObject:b];
}_themeButtons=[themes copy];
_scroll=[[DYInspectorScrollView alloc] initWithFrame:NSZeroRect];
_scroll.hasVerticalScroller=YES; _scroll.hasHorizontalScroller=NO; _scroll.drawsBackground=NO;
_scroll.hasVerticalScroller=!_embedded; _scroll.hasHorizontalScroller=NO; _scroll.drawsBackground=NO;
_scroll.autohidesScrollers=YES; _scroll.borderType=NSNoBorder;
_scroll.clipsToBounds=YES;_scroll.wantsLayer=YES;_scroll.layer.masksToBounds=YES;
_scroll.contentView.clipsToBounds=YES;
@@ -460,6 +469,7 @@ static NSImage *DYWheelImage(void) {
for(id graphic in _graphics)if([graphic isKindOfClass:DYPrimaryBalanceWheel.class])[(DYPrimaryBalanceWheel*)graphic setDelegate:nil];
for(NSProgress *p in _assetLoads.allValues)[p cancel];[_assetLoads release];[_assetLoadIDs release];[_menuScan cancel];[_menuScan release];[_pendingAssetMenuCommand release];
[[NSNotificationCenter defaultCenter] removeObserver:self];
if(_embedded)[(id)_manager release];[_stackViews release];[_stackOrder release];
[_brand release]; [_subtitle release]; [_resetAll release]; [_save release]; [_load release]; [_export release];
[_scroll release]; [_document release]; [_sections release]; [_cards release]; [_controls release]; [_assetButtons release]; [_graphics release]; [_sampler release];
[_browser close];[_browser release];[_renderer release];[_library release];[_themeButtons release];[_tabs release];
@@ -481,7 +491,7 @@ static NSImage *DYWheelImage(void) {
}
}
- (void)modelChanged:(NSNotification *)n {
if([NSThread isMainThread]) [self refresh];
if([NSThread isMainThread]) {[self refresh];if(!_embedded&&[n.userInfo[@"scrollToNewTool"]boolValue]){[self layoutSubtreeIfNeeded];[_document scrollPoint:NSMakePoint(0,MAX(0,_document.bounds.size.height-_scroll.contentSize.height))];}}
else dispatch_async(dispatch_get_main_queue(),^{ [self refresh]; });
}
- (void)selectTheme:(NSButton *)button {DYSetThemeIndex(button.tag);}
@@ -609,6 +619,12 @@ static NSImage *DYWheelImage(void) {
}
NSMutableDictionary *record=[NSMutableDictionary dictionaryWithDictionary:@{@"section":section,@"view":card,@"header":header,@"enabled":enabled,@"reset":reset,@"body":body,@"collapsed":@(![@[@"primary",@"spider",@"base"]containsObject:key])}];
if([key isEqual:@"look"]){NSButton *add=DYButton(@"+",self,@selector(addLook:));add.bordered=NO;add.font=[NSFont boldSystemFontOfSize:20];add.accessibilityLabel=@"添加风格 LUT";[card addSubview:add];record[@"add"]=add;}
id<PROAPIAccessing> host=_embedded?[(DYToolManager*)_manager host]:_manager;
NSString *nodeID=_embedded?[(DYToolManager*)_manager nodeID]:[@"base:" stringByAppendingString:key];
DYToolMaskPanel *maskPanel=[[[DYToolMaskPanel alloc]initWithManager:host nodeID:nodeID]autorelease];[card addSubview:maskPanel];[body insertObject:maskPanel atIndex:0];record[@"maskPanel"]=maskPanel;
NSButton *mask=DYButton(@"",self,@selector(toolMask:));mask.tag=index;mask.bordered=NO;mask.image=[NSImage imageWithSystemSymbolName:@"circle.dashed.inset.filled" accessibilityDescription:@"添加蒙版"];mask.toolTip=@"添加本工具的独立蒙版";mask.accessibilityLabel=[section[@"title"]stringByAppendingString:@"添加蒙版"];[card addSubview:mask];record[@"maskButton"]=mask;
NSButton *repeat=DYButton(@"",self,@selector(repeatTool:));repeat.tag=index;repeat.bordered=NO;repeat.image=[NSImage imageWithSystemSymbolName:@"plus.square.on.square" accessibilityDescription:@"再加一层"];repeat.toolTip=@"在工具列表末尾添加一层初始化工具";repeat.accessibilityLabel=[section[@"title"]stringByAppendingString:@"再加一层"];[card addSubview:repeat];record[@"repeatButton"]=repeat;
if(_embedded){NSButton *remove=DYButton(@"删除此层",self,@selector(removeTool:));remove.identifier=@"removeTool";[card addSubview:remove];[body addObject:remove];}
[_cards addObject:record];
index++;
}
@@ -628,6 +644,7 @@ static NSImage *DYWheelImage(void) {
return row;
}
- (BOOL)showRow:(NSView *)row section:(NSString *)section {
if([row.identifier isEqual:@"toolMasks"])return [(DYToolMaskPanel*)row contentHeight]>0;
NSString *key=row.identifier?:@"";NSInteger tab=[_tabs[section]integerValue];
if([key isEqual:@"legacyInput"])return [_tabs[@"legacyInput"]boolValue];
if([section isEqual:@"curve"] && ![key isEqual:@"curveGraph"])return NO;
@@ -641,7 +658,7 @@ static NSImage *DYWheelImage(void) {
if([section isEqual:@"look"]){int slot=0;if(sscanf(key.UTF8String,"asset:look%d",&slot)==1)return slot<_visibleLooks;if([key isEqual:@"postLUTStrength"])return YES;int number=0;if(sscanf(key.UTF8String,"look%dStrength",&number)==1)return number-1<_visibleLooks;return NO;}
return YES;
}
- (CGFloat)heightForRow:(NSView *)row {if([row.identifier isEqual:@"spiderGraph"])return 444;if([row.identifier isEqual:@"primaryBalance"])return 232;if([row.identifier hasPrefix:@"heading:"])return 27;return [row.identifier isEqual:@"curveGraph"]?240:[row.identifier isEqual:@"gradingWheels"]?292:32;}
- (CGFloat)heightForRow:(NSView *)row {if([row isKindOfClass:DYToolMaskPanel.class])return [(DYToolMaskPanel*)row contentHeight];if([row.identifier isEqual:@"spiderGraph"])return 444;if([row.identifier isEqual:@"primaryBalance"])return 232;if([row.identifier hasPrefix:@"heading:"])return 27;return [row.identifier isEqual:@"curveGraph"]?240:[row.identifier isEqual:@"gradingWheels"]?292:32;}
- (void)layout {
[super layout];
CGFloat w=MAX(280,self.bounds.size.width),h=self.bounds.size.height;
@@ -650,23 +667,25 @@ static NSImage *DYWheelImage(void) {
_resetAll.frame=NSMakeRect(w-33,16,23,24);
CGFloat gap=7,bw=(w-32-gap*2)/3;
_save.frame=NSMakeRect(16,50,bw,27); _load.frame=NSMakeRect(16+bw+gap,50,bw,27); _export.frame=NSMakeRect(16+(bw+gap)*2,50,bw,27);
_scroll.frame=NSMakeRect(0,88,w,MAX(80,h-88));
_scroll.frame=_embedded?NSMakeRect(0,0,w,h):NSMakeRect(0,88,w,MAX(80,h-88));
CGFloat cw=MAX(244,_scroll.contentSize.width-32),y=8;
for(NSMutableDictionary *c in _cards) {
DYCard *card=c[@"view"];BOOL collapsed=[c[@"collapsed"]boolValue];NSString *key=c[@"section"][@"key"];
NSArray *body=c[@"body"];CGFloat contentHeight=0;
for(NSView *row in body)if([self showRow:row section:key])contentHeight+=[self heightForRow:row];
for(NSView *row in body)if([self showRow:row section:key]&&(!collapsed||[row isKindOfClass:DYToolMaskPanel.class]))contentHeight+=[self heightForRow:row];
[c[@"enabled"]setFrame:NSMakeRect(12,12,20,20)];
CGFloat titleWidth=MIN(cw-104,MAX(94,[[(NSButton *)c[@"header"]title]sizeWithAttributes:@{NSFontAttributeName:[NSFont boldSystemFontOfSize:12]}].width+36));
CGFloat titleWidth=MIN(cw-143,MAX(94,[[(NSButton *)c[@"header"]title]sizeWithAttributes:@{NSFontAttributeName:[NSFont boldSystemFontOfSize:12]}].width+36));
[c[@"header"]setFrame:NSMakeRect(42,8,titleWidth,28)];
CGFloat headerHeight=43;
card.frame=NSMakeRect(16,y,cw,headerHeight+(collapsed?0:contentHeight+8));y+=card.frame.size.height+12;
[c[@"reset"]setFrame:NSMakeRect(cw-36,10,24,24)];
[c[@"add"]setFrame:NSMakeRect(cw-64,10,24,24)];[c[@"add"]setEnabled:_visibleLooks<5];[c[@"add"]setHidden:collapsed];
card.frame=NSMakeRect(16,y,cw,headerHeight+(contentHeight>0?contentHeight+8:0));y+=card.frame.size.height+12;
[c[@"reset"]setFrame:NSMakeRect(cw-34,10,24,24)];
[c[@"repeatButton"]setFrame:NSMakeRect(cw-62,10,24,24)];[c[@"maskButton"]setFrame:NSMakeRect(cw-90,10,24,24)];
[c[@"add"]setFrame:NSMakeRect(cw-33,headerHeight+contentHeight-28,20,24)];[c[@"add"]setEnabled:_visibleLooks<5];[c[@"add"]setHidden:collapsed];
CGFloat rowY=headerHeight;
for(NSView *row in body) {
BOOL show=!collapsed&&[self showRow:row section:key];row.hidden=!show;if(!show)continue;
BOOL show=(!collapsed||[row isKindOfClass:DYToolMaskPanel.class])&&[self showRow:row section:key];row.hidden=!show;if(!show)continue;
CGFloat rh=[self heightForRow:row];row.frame=NSMakeRect(12,rowY,cw-24,rh-1);rowY+=rh;
if([row.identifier isEqual:@"removeTool"]){/* NSButton fills its row. */}
if([row.identifier isEqual:@"primaryBalance"])for(NSView *v in row.subviews)v.frame=row.bounds;
if([row.identifier hasPrefix:@"heading:"])for(NSView *v in row.subviews)v.frame=NSMakeRect(3,7,row.bounds.size.width-6,18);
if([row.identifier isEqual:@"autoControls"]||[row.identifier isEqual:@"sampleControls"]) {
@@ -689,7 +708,8 @@ static NSImage *DYWheelImage(void) {
[r[@"browse"]setHidden:input];[r[@"eye"]setFrame:NSMakeRect(0,5,18,20)];[r[@"browse"]setFrame:NSMakeRect(r[@"eye"]?20:0,4,20,24)];[r[@"label"]setFrame:NSMakeRect(input?2:r[@"eye"]?43:25,7,input?86:r[@"eye"]?51:69,18)];
[r[@"choose"]setFrame:NSMakeRect(97,3,MAX(65,rw-152),26)];[r[@"folder"]setFrame:NSMakeRect(rw-51,4,24,24)];[r[@"remove"]setFrame:NSMakeRect(rw-23,4,22,24)];
}
[_document setFrameSize:NSMakeSize(_scroll.contentSize.width,MAX(y,_scroll.contentSize.height))];
for(NSString *ID in _stackOrder){DYInspector *child=_stackViews[ID];child.frame=NSMakeRect(0,y,w,MAX(60,child->_stackHeight));[child layoutSubtreeIfNeeded];CGFloat height=MAX(60,child->_stackHeight);child.frame=NSMakeRect(0,y,w,height);y+=height;}
_stackHeight=y;[_document setFrameSize:NSMakeSize(_scroll.contentSize.width,MAX(y,_scroll.contentSize.height))];
}
- (id<FxCustomParameterActionAPI_v4>)actionAPI { return [_manager apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)]; }
- (void)refresh {
@@ -731,6 +751,7 @@ static NSImage *DYWheelImage(void) {
[c[@"enabled"]setToolTip:enabled?@"停用本组,保留参数和展开状态":@"启用本组,保留展开状态"];[c[@"enabled"]setAccessibilityHelp:[c[@"enabled"]toolTip]];
for(NSView *row in c[@"body"])row.alphaValue=enabled?1:.45;
}
id<PROAPIAccessing> maskHost=_embedded?[(DYToolManager*)_manager host]:_manager;NSDictionary *tools=DYReadTools(maskHost,t).document;for(NSDictionary *card in _cards)[card[@"maskPanel"]refreshWithDocument:tools time:t];
DYAssetState *assets=DYReadAssets(_manager,t);[_spiderPanel setMesh:assets.spiderMesh linked:assets.spiderLinked];
double profile=0,configured=0;[get getFloatValue:&profile fromParameter:2013 atTime:t];[get getFloatValue:&configured fromParameter:2236 atTime:t];
DYInspectorToken *oldToken=nil;[get getCustomParameterValue:&oldToken fromParameter:DYInspectorParameterID atTime:t];
@@ -748,9 +769,10 @@ static NSImage *DYWheelImage(void) {
} @finally { [action endAction:self]; _refreshing=NO; }
// Remote layout/accessibility can re-enter the host. Let the parameter
// action and current callback unwind before notifying the remote view.
if(!_embedded)[self synchronizeTools];
if(groupingChanged)dispatch_async(dispatch_get_main_queue(),^{NSAccessibilityPostNotification(self,NSAccessibilityLayoutChangedNotification);});
}
- (void)postChanged { [[NSNotificationCenter defaultCenter] postNotificationName:@"DYModelChanged" object:_manager]; }
- (void)postChanged { [[NSNotificationCenter defaultCenter] postNotificationName:@"DYModelChanged" object:_embedded?[(DYToolManager*)_manager host]:_manager]; }
- (void)scalarChanged:(NSControl *)sender {
if(_refreshing)return;
NSNumber *pid=@(sender.tag); NSDictionary *r=_controls[pid],*d=r[@"descriptor"]; if(!d)return;
@@ -848,6 +870,7 @@ static NSImage *DYWheelImage(void) {
@try{id<FxParameterSettingAPI_v6> set=[_manager apiForProtocol:@protocol(FxParameterSettingAPI_v6)];[set setFloatValue:1 toParameter:2236 atTime:a.currentTime];[self clearPrimaryBypasses:set time:a.currentTime];} @finally{[a endAction:self];}[self postChanged];
}
- (void)resetSection:(NSButton *)sender {
if(_embedded){[self resetRepeatedTool];return;}
[self cancelAssetLoads];
if(sender.tag>=_cards.count)return;
NSDictionary *section=_cards[sender.tag][@"section"];
@@ -884,7 +907,7 @@ static NSImage *DYWheelImage(void) {
@try {
CMTime t=action.currentTime;id<FxParameterSettingAPI_v6> set=[_manager apiForProtocol:@protocol(FxParameterSettingAPI_v6)];
for(NSDictionary *d in DYDescriptors())[set setFloatValue:[d[@"default"] doubleValue] toParameter:[d[@"pid"] unsignedIntValue] atTime:t];
DYAssetState *assets=[[[DYAssetState alloc] init] autorelease];assets.paths=@{};DYWriteAssets(_manager,assets,t);
DYAssetState *assets=[[[DYAssetState alloc] init] autorelease];assets.paths=@{};DYWriteAssets(_manager,assets,t);DYWriteTools(_manager,[[[DYToolDocument alloc]init]autorelease].document,t);
[set setCustomParameterValue:[[[DYInspectorToken alloc]init]autorelease] toParameter:DYInspectorParameterID atTime:t];
for(NSMutableDictionary *card in _cards)card[@"collapsed"]=@(![@[@"primary",@"spider",@"base"]containsObject:card[@"section"][@"key"]]);
} @finally {[action endAction:self];}
@@ -1006,15 +1029,15 @@ static NSImage *DYWheelImage(void) {
}
- (NSDictionary *)presetSnapshot {
id<FxCustomParameterActionAPI_v4> action=[self actionAPI];if(!action)return nil;
NSMutableDictionary *values=[NSMutableDictionary dictionary];NSDictionary *paths=@{},*spider=nil;
NSMutableDictionary *values=[NSMutableDictionary dictionary];NSDictionary *paths=@{},*spider=nil;NSString *tools=nil;
[action startAction:self];
@try {
CMTime t=action.currentTime;id<FxParameterRetrievalAPI_v6> get=[_manager apiForProtocol:@protocol(FxParameterRetrievalAPI_v6)];
for(NSDictionary *d in DYDescriptors()) {double v=[d[@"default"] doubleValue];[get getFloatValue:&v fromParameter:[d[@"pid"] unsignedIntValue] atTime:t];if(std::isfinite(v))values[d[@"key"]]=@(v);}
DYUniforms effective;DYReadUniforms(_manager,t,&effective);values[@"cmConfigured"]=@(effective.cm.configured);values[@"blackWhiteMix"]=@(effective.cm.blackWhiteMix);
DYAssetState *state=DYReadAssets(_manager,t);paths=[[state.paths copy]autorelease]?:@{};spider=DYSpiderJSON(state.spiderMesh,state.spiderLinked);
DYAssetState *state=DYReadAssets(_manager,t);paths=[[state.paths copy]autorelease]?:@{};spider=DYSpiderJSON(state.spiderMesh,state.spiderLinked);NSData *toolData=[NSPropertyListSerialization dataWithPropertyList:DYReadTools(_manager,t).document format:NSPropertyListBinaryFormat_v1_0 options:0 error:nil];tools=[toolData base64EncodedStringWithOptions:0];
} @finally {[action endAction:self];}
return @{@"format":@"com.dayu.color.preset",@"version":@3,@"values":values,@"paths":paths,@"spider":spider};
return @{@"format":@"com.dayu.color.preset",@"version":@4,@"values":values,@"paths":paths,@"spider":spider,@"tools":tools?:@""};
}
- (void)savePreset:(id)sender {
NSDictionary *snapshot=[self presetSnapshot];if(!snapshot)return;
@@ -1027,10 +1050,11 @@ static NSImage *DYWheelImage(void) {
NSOpenPanel *panel=[NSOpenPanel openPanel];panel.allowedFileTypes=@[@"json"];panel.allowsMultipleSelection=NO;panel.canChooseDirectories=NO;
if([panel runModal]!=NSModalResponseOK)return;
NSError *error=nil;NSData *data=[NSData dataWithContentsOfURL:panel.URL options:0 error:&error];
if(!data||data.length>2*1024*1024){[self showError:error.localizedDescription?:@"预设文件过大"];return;}
if(!data||data.length>32*1024*1024){[self showError:error.localizedDescription?:@"预设文件过大"];return;}
id json=[NSJSONSerialization JSONObjectWithData:data options:0 error:&error];
if(![json isKindOfClass:NSDictionary.class]||![json[@"format"] isEqual:@"com.dayu.color.preset"]||![@[@1,@2,@3]containsObject:json[@"version"]]||![json[@"values"] isKindOfClass:NSDictionary.class]||![json[@"paths"] isKindOfClass:NSDictionary.class]){[self showError:@"这不是有效的大鱼调色预设。"];return;}
NSDictionary *values=json[@"values"],*paths=json[@"paths"];NSData *mesh=[json[@"version"]isEqual:@3]?DYSpiderFromJSON(json[@"spider"]):nil;if([json[@"version"]isEqual:@3]&&!mesh){[self showError:@"预设包含无效蜘蛛盘,当前调色未修改。"];return;}
if(![json isKindOfClass:NSDictionary.class]||![json[@"format"] isEqual:@"com.dayu.color.preset"]||![@[@1,@2,@3,@4]containsObject:json[@"version"]]||![json[@"values"] isKindOfClass:NSDictionary.class]||![json[@"paths"] isKindOfClass:NSDictionary.class]){[self showError:@"这不是有效的大鱼调色预设。"];return;}
NSDictionary *values=json[@"values"],*paths=json[@"paths"];NSData *mesh=[json[@"version"]integerValue]>=3?DYSpiderFromJSON(json[@"spider"]):nil;if([json[@"version"]integerValue]>=3&&!mesh){[self showError:@"预设包含无效蜘蛛盘,当前调色未修改。"];return;}
NSDictionary *tools=[[[DYToolDocument alloc]init]autorelease].document;if([json[@"version"]integerValue]>=4){id encoded=json[@"tools"];NSData *binary=[encoded isKindOfClass:NSString.class]?[[[NSData alloc]initWithBase64EncodedString:encoded options:0]autorelease]:nil;tools=binary?[NSPropertyListSerialization propertyListWithData:binary options:NSPropertyListImmutable format:NULL error:nil]:nil;if(!DYValidToolDocument(tools)){[self showError:@"预设包含无效工具或蒙版,当前调色未修改。"];return;}}
for(NSDictionary *d in DYDescriptors()) {
id v=values[d[@"key"]];if(!v)continue;
if(![v isKindOfClass:NSNumber.class]||!std::isfinite([v doubleValue])||[v doubleValue]<[d[@"min"] doubleValue]||[v doubleValue]>[d[@"max"] doubleValue]||(d[@"values"]&&![d[@"values"]containsObject:v])){[self showError:@"预设包含无效参数,尚未修改当前调色。"];return;}
@@ -1041,6 +1065,7 @@ static NSImage *DYWheelImage(void) {
if(![path isKindOfClass:NSString.class]||![path isAbsolutePath]||![[path pathExtension].lowercaseString isEqual:@"cube"]){[self showError:@"预设包含无效 LUT 路径,尚未修改当前调色。"];return;}
if([[NSFileManager defaultManager] isReadableFileAtPath:path])validPaths[key]=path;else [missing addObject:[path lastPathComponent]];
}
NSMutableDictionary *restoredTools=DYMutablePlist(tools);for(NSMutableDictionary *node in restoredTools[@"layers"]){NSMutableDictionary *nodePaths=node[@"paths"];for(NSString *key in [[nodePaths.allKeys copy]autorelease])if(![NSFileManager.defaultManager isReadableFileAtPath:nodePaths[key]]){[missing addObject:[nodePaths[key]lastPathComponent]];[nodePaths removeObjectForKey:key];}}tools=restoredTools;
[self cancelAssetLoads];
id<FxCustomParameterActionAPI_v4> action=[self actionAPI];if(!action)return;
[action startAction:self];
@@ -1048,13 +1073,13 @@ static NSImage *DYWheelImage(void) {
CMTime t=action.currentTime;id<FxParameterSettingAPI_v6> set=[_manager apiForProtocol:@protocol(FxParameterSettingAPI_v6)];
for(NSDictionary *d in DYDescriptors())if(values[d[@"key"]])[set setFloatValue:[values[d[@"key"]] doubleValue] toParameter:[d[@"pid"] unsignedIntValue] atTime:t];
if([json[@"version"]isEqual:@1]&&!values[@"cmConfigured"]){[set setFloatValue:-1 toParameter:2236 atTime:t];[set setFloatValue:1 toParameter:2270 atTime:t];}
DYAssetState *assets=[[[DYAssetState alloc] init] autorelease];assets.paths=validPaths;assets.spiderMesh=mesh;assets.spiderLinked=mesh?[json[@"spider"][@"linked"]boolValue]:YES;DYWriteAssets(_manager,assets,t);
DYAssetState *assets=[[[DYAssetState alloc] init] autorelease];assets.paths=validPaths;assets.spiderMesh=mesh;assets.spiderLinked=mesh?[json[@"spider"][@"linked"]boolValue]:YES;DYWriteAssets(_manager,assets,t);DYWriteTools(_manager,tools,t);
} @finally {[action endAction:self];}
[self postChanged];
if(missing.count)[self showError:[@"调色参数已恢复,以下 LUT 文件需要重新选择:\n" stringByAppendingString:[missing componentsJoinedByString:@"\n"]]];
}
- (void)autoGrade:(id)sender { [[NSNotificationCenter defaultCenter]postNotificationName:@"DYAutoGrade" object:_manager]; }
- (void)autoWhiteBalance:(id)sender { [[NSNotificationCenter defaultCenter]postNotificationName:@"DYAutoWhiteBalance" object:_manager]; }
- (void)autoGrade:(id)sender { if(_embedded){[self writeGraphicValues:DYAutoGrade([_renderer preview])];return;}[[NSNotificationCenter defaultCenter]postNotificationName:@"DYAutoGrade" object:_manager]; }
- (void)autoWhiteBalance:(id)sender { if(_embedded){[self writeGraphicValues:DYAutoWhiteBalance([_renderer preview])];return;}[[NSNotificationCenter defaultCenter]postNotificationName:@"DYAutoWhiteBalance" object:_manager]; }
- (void)sampleWhiteBalance:(id)sender { [self sampleColorForWhiteBalance:YES]; }
- (void)sampleCustomColor:(id)sender { [self sampleColorForWhiteBalance:NO]; }
- (void)sampleColorForWhiteBalance:(BOOL)whiteBalance {
@@ -1063,7 +1088,8 @@ static NSImage *DYWheelImage(void) {
[_sampler showSamplerWithSelectionHandler:^(NSColor *selectedColor) {
NSColor *color=[selectedColor colorUsingColorSpace:NSColorSpace.sRGBColorSpace];
if(color) {
if(whiteBalance)[[NSNotificationCenter defaultCenter]postNotificationName:@"DYWhiteBalanceColor" object:_manager userInfo:@{@"color":color}];
if(whiteBalance&&_embedded){float t=0,i=0;if([DYColorTables neutralizeColor:(vector_float3){(float)color.redComponent,(float)color.greenComponent,(float)color.blueComponent} temperature:&t tint:&i])[self writeGraphicValues:@{@"temperature":@(t),@"tint":@(i)}];}
else if(whiteBalance)[[NSNotificationCenter defaultCenter]postNotificationName:@"DYWhiteBalanceColor" object:_manager userInfo:@{@"color":color}];
else [self writeGraphicValues:@{@"sample0":@(color.redComponent),@"sample1":@(color.greenComponent),@"sample2":@(color.blueComponent)}];
}
[_sampler release];_sampler=nil;
+65
查看文件
@@ -0,0 +1,65 @@
// Native per-tool mask editor, shared by original and repeated tool cards.
@interface DYToolMaskPanel : DYFlippedView
@property(nonatomic,readonly) CGFloat contentHeight;
- (instancetype)initWithManager:(id<PROAPIAccessing>)manager nodeID:(NSString*)nodeID;
- (void)refreshWithDocument:(NSDictionary*)document time:(CMTime)time;
- (void)addMenu:(NSView*)anchor;
@end
@implementation DYToolMaskPanel {
id<PROAPIAccessing> _host;NSString *_nodeID,*_maskID;NSDictionary *_document;CMTime _time;
NSPopUpButton *_list,*_combine;NSButton *_eye,*_add,*_remove,*_invert,*_canvas,*_clear;NSMutableArray *_rows,*_tracking;NSTextField *_status;BOOL _refreshing;CGFloat _contentHeight;
}
@synthesize contentHeight=_contentHeight;
- (instancetype)initWithManager:(id<PROAPIAccessing>)manager nodeID:(NSString*)nodeID{
if((self=[super initWithFrame:NSZeroRect])){_host=manager;_nodeID=[nodeID copy];_rows=[NSMutableArray new];_tracking=[NSMutableArray new];self.identifier=@"toolMasks";
[NSNotificationCenter.defaultCenter addObserver:self selector:@selector(trackingStatus:) name:@"DYToolTrackingStatus" object:_host];
[NSNotificationCenter.defaultCenter addObserver:self selector:@selector(canvasSelected:) name:@"DYToolCanvasSelection" object:_host];
}return self;
}
- (void)buildControls{if(_list)return;
_list=[[NSPopUpButton alloc]initWithFrame:NSZeroRect pullsDown:NO];_list.target=self;_list.action=@selector(selection:);_list.font=[NSFont systemFontOfSize:10];_list.accessibilityLabel=@"本层蒙版";[self addSubview:_list];
_eye=[DYButton(@"",self,@selector(enabled:))retain];_eye.image=[NSImage imageWithSystemSymbolName:@"eye" accessibilityDescription:@"蒙版启用"];_eye.bordered=NO;[_eye setButtonType:NSButtonTypePushOnPushOff];[self addSubview:_eye];
_add=[DYButton(@"+",self,@selector(add:))retain];_add.toolTip=@"再添加一个蒙版";_add.accessibilityLabel=_add.toolTip;[self addSubview:_add];
_remove=[DYButton(@"−",self,@selector(remove:))retain];_remove.toolTip=@"删除选中的蒙版";_remove.accessibilityLabel=_remove.toolTip;[self addSubview:_remove];
_combine=[[NSPopUpButton alloc]initWithFrame:NSZeroRect pullsDown:NO];[_combine addItemsWithTitles:@[@"相加",@"减去",@"相交"]];_combine.target=self;_combine.action=@selector(combine:);_combine.accessibilityLabel=@"蒙版组合方式";[self addSubview:_combine];
_invert=[[NSButton checkboxWithTitle:@"反转" target:self action:@selector(inverted:)]retain];[self addSubview:_invert];
_canvas=[DYButton(@"画面编辑",self,@selector(canvas:))retain];_canvas.toolTip=@"在宿主画面拖动中心、大小、旋转与钢笔节点;回车闭合钢笔";_canvas.accessibilityLabel=@"编辑本层蒙版画面控件";[self addSubview:_canvas];
_clear=[DYButton(@"清除轨迹",self,@selector(clear:))retain];[self addSubview:_clear];
NSArray *names=@[@"强度",@"羽化",@"中心 X",@"中心 Y",@"宽度",@"高度",@"旋转",@"渐变宽度",@"色相中心",@"色相范围",@"色相柔边",@"饱和度下限",@"饱和度上限",@"亮度下限",@"亮度上限",@"输入黑",@"输入白",@"输入伽马"];
for(NSInteger i=0;i<names.count;i++){NSTextField *label=[DYLabel(names[i],10)retain];NSSlider *slider=[[NSSlider alloc]initWithFrame:NSZeroRect];slider.tag=i;slider.target=self;slider.action=@selector(valueChanged:);slider.continuous=NO;slider.controlSize=NSControlSizeSmall;slider.accessibilityLabel=[names[i]stringByAppendingString:@"蒙版"];NSTextField *field=[[NSTextField alloc]initWithFrame:NSZeroRect];field.font=[NSFont monospacedDigitSystemFontOfSize:10 weight:NSFontWeightRegular];field.tag=i;field.target=self;field.action=@selector(valueChanged:);field.accessibilityLabel=[names[i]stringByAppendingString:@"蒙版数值"];field.alignment=NSTextAlignmentRight;[self addSubview:label];[self addSubview:slider];[self addSubview:field];[_rows addObject:@{@"label":label,@"slider":slider,@"field":field}];[label release];[slider release];[field release];}
NSArray *titles=@[@"◀ 单帧",@"◀ 跟踪",@"双向",@"跟踪 ▶",@"单帧 ▶",@"取消"];
for(int i=0;i<6;i++){NSButton *b=DYButton(titles[i],self,@selector(track:));b.tag=((int[]){-2,-1,0,1,2,9})[i];b.font=[NSFont systemFontOfSize:9];b.accessibilityLabel=@[@"反向跟踪一帧",@"反向蒙版跟踪",@"双向蒙版跟踪",@"正向蒙版跟踪",@"正向跟踪一帧",@"取消蒙版跟踪"][i];[self addSubview:b];[_tracking addObject:b];}
_status=[DYLabel(@"",10)retain];_status.maximumNumberOfLines=2;[self addSubview:_status];_contentHeight=0;
}
- (void)dealloc{[NSNotificationCenter.defaultCenter removeObserver:self];[_nodeID release];[_maskID release];[_document release];[_list release];[_combine release];[_eye release];[_add release];[_remove release];[_invert release];[_canvas release];[_clear release];[_rows release];[_tracking release];[_status release];[super dealloc];}
- (NSDictionary*)mask{for(NSDictionary *m in DYMasksForTool(_document,_nodeID))if([m[@"id"]isEqual:_maskID])return m;return nil;}
- (void)refreshWithDocument:(NSDictionary*)doc time:(CMTime)time{
_refreshing=YES;NSDictionary *saved=[doc copy];[_document release];_document=saved;_time=time;NSArray *masks=DYMasksForTool(doc,_nodeID);if(masks.count)[self buildControls];[_list removeAllItems];NSInteger selected=0,index=0;
for(NSDictionary *m in masks){DYMaskParameters p=DYMaskAtTime(m,time);[_list addItemWithTitle:[NSString stringWithFormat:@"%@ %ld",@[@"椭圆",@"矩形",@"钢笔",@"线性渐变",@"HSL 选区",@"亮度选区"][p.kind],(long)index+1]];if([m[@"id"]isEqual:_maskID])selected=index;index++;}
if(!masks.count){_contentHeight=0;_refreshing=NO;return;}[_list selectItemAtIndex:selected];[_maskID release];_maskID=[masks[selected][@"id"]copy];NSDictionary *m=[self mask];DYMaskParameters p=DYMaskAtTime(m,time);
_eye.state=[m[@"enabled"]boolValue]?NSControlStateValueOn:NSControlStateValueOff;_eye.image=[NSImage imageWithSystemSymbolName:[m[@"enabled"]boolValue]?@"eye":@"eye.slash" accessibilityDescription:@"启用蒙版"];[_combine selectItemAtIndex:[m[@"combine"]integerValue]];_invert.state=(p.flags&DYMaskInvert)?NSControlStateValueOn:NSControlStateValueOff;
float values[]={p.strength,p.feather,p.centerX,p.centerY,p.width,p.height,float(p.angle*180.f/M_PI),p.gradientWidth,p.hueCenterTurns*360.f,p.hueCoreHalfWidth*360.f,p.hueSoftWidth*360.f,p.saturationRange.low,p.saturationRange.high,p.lightnessRange.low,p.lightnessRange.high,p.inputBlack,p.inputWhite,p.inputGamma};
NSInteger visible=0;for(NSInteger i=0;i<_rows.count;i++){BOOL show=i==0||(i==1&&p.kind<3)||(i>=2&&i<=6&&p.kind<4)||(i==7&&p.kind==3)||(i>=8&&i<=14&&p.kind==4)||(i>=15&&p.kind>=4);NSDictionary *row=_rows[i];for(NSView *v in row.allValues)v.hidden=!show;if(!show)continue;visible++;double lo=0,hi=1;if(i==2||i==3)lo=-1,hi=2;if(i==4||i==5||i==7)lo=.001,hi=2;if(i==6)lo=-180,hi=180;if(i==8)hi=360;if(i==9||i==10)hi=180;if(i==15)hi=.99;if(i==16)lo=.01,hi=2;if(i==17)lo=.01,hi=4;NSSlider *slider=row[@"slider"];slider.minValue=lo;slider.maxValue=hi;slider.doubleValue=values[i];[row[@"field"]setStringValue:[NSString stringWithFormat:@"%.3f",values[i]]];}
BOOL shape=p.kind<3;for(NSButton *b in _tracking)b.hidden=!shape;_clear.hidden=!shape;_clear.enabled=[m[@"keys"]count]>0;
_status.stringValue=m[@"status"]?:([m[@"keys"]count]?[NSString stringWithFormat:@"%lu 个轨迹键 · 修改几何会在当前帧建立手工键",(unsigned long)[m[@"keys"]count]]:p.kind==2?@"钢笔:在画面工具栏选择钢笔重画,回车闭合;拖动节点和手柄。":@"各蒙版只影响当前工具层");
_contentHeight=108+visible*27+(shape?63:0)+36;[self setNeedsLayout:YES];_refreshing=NO;
}
- (void)layout{[super layout];CGFloat w=self.bounds.size.width;_eye.frame=NSMakeRect(0,2,20,24);_list.frame=NSMakeRect(22,1,MAX(60,w-82),26);_add.frame=NSMakeRect(w-57,1,26,25);_remove.frame=NSMakeRect(w-29,1,26,25);_combine.frame=NSMakeRect(0,33,83,25);_invert.frame=NSMakeRect(88,34,58,23);_canvas.frame=NSMakeRect(w-94,33,94,25);CGFloat y=67;for(NSDictionary *r in _rows){NSTextField *label=r[@"label"];if(label.hidden)continue;label.frame=NSMakeRect(2,y+4,68,18);[r[@"slider"]setFrame:NSMakeRect(72,y+4,MAX(20,w-133),18)];[r[@"field"]setFrame:NSMakeRect(w-57,y+1,55,23)];y+=27;}if(_tracking.count&&![_tracking[0]isHidden]){CGFloat bw=(w-8)/3;for(int i=0;i<6;i++)[_tracking[i]setFrame:NSMakeRect((i%3)*(bw+4),y+(i/3)*28,bw,25)];y+=58;_clear.frame=NSMakeRect(0,y,w,25);y+=29;}_status.frame=NSMakeRect(2,y+2,w-4,33);}
- (void)edit:(NSString*)title block:(void (^)(NSMutableDictionary*,NSMutableDictionary*))block{
id<FxCustomParameterActionAPI_v4>a=[_host apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)];if(!a)return;[a startAction:self];@try{NSMutableDictionary *doc=DYMutablePlist(DYReadTools(_host,a.currentTime).document);NSMutableArray *masks=(id)DYMasksForTool(doc,_nodeID);NSMutableDictionary *mask=nil;for(NSMutableDictionary *m in masks)if([m[@"id"]isEqual:_maskID])mask=m;if(!mask)return;block(doc,mask);if(!DYValidToolDocument(doc)){NSBeep();return;}id<FxUndoAPI>undo=[_host apiForProtocol:@protocol(FxUndoAPI)];[undo startUndoGroup:title];DYWriteTools(_host,doc,a.currentTime);[undo endUndoGroup];}@finally{[a endAction:self];}[NSNotificationCenter.defaultCenter postNotificationName:DYModelChanged object:_host];}
- (void)add:(id)sender{[self addMenu:_add];}
- (void)addMenu:(NSView*)anchor{NSMenu *menu=[[[NSMenu alloc]initWithTitle:@"添加蒙版"]autorelease];for(int i=0;i<6;i++){NSMenuItem *item=[menu addItemWithTitle:@[@"椭圆",@"矩形",@"钢笔",@"线性渐变",@"HSL 选区",@"亮度选区"][i] action:@selector(addKind:) keyEquivalent:@""];item.target=self;item.tag=i;}[menu popUpMenuPositioningItem:nil atLocation:NSMakePoint(0,anchor.bounds.size.height) inView:anchor];}
- (void)addKind:(NSMenuItem*)sender{
id<FxCustomParameterActionAPI_v4>a=[_host apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)];if(!a)return;[a startAction:self];@try{NSMutableDictionary *doc=DYMutablePlist(DYReadTools(_host,a.currentTime).document);NSMutableArray *masks=[[DYMasksForTool(doc,_nodeID)mutableCopy]autorelease];if(masks.count>=DYToolMaskLimit){NSBeep();return;}NSDictionary *mask=DYNewMask(sender.tag);[masks addObject:mask];if(!DYSetToolMasks(doc,_nodeID,masks))return;[_maskID release];_maskID=[mask[@"id"]copy];NSDictionary *staged=[doc copy];[_document release];_document=staged;[self canvas:nil];id<FxUndoAPI>undo=[_host apiForProtocol:@protocol(FxUndoAPI)];[undo startUndoGroup:@"添加工具蒙版"];DYWriteTools(_host,doc,a.currentTime);[undo endUndoGroup];[_maskID release];_maskID=[mask[@"id"]copy];}@finally{[a endAction:self];}[NSNotificationCenter.defaultCenter postNotificationName:DYModelChanged object:_host];[self canvas:nil];}
- (void)selection:(id)sender{NSArray *m=DYMasksForTool(_document,_nodeID);if(_list.indexOfSelectedItem<0||_list.indexOfSelectedItem>=m.count)return;[_maskID release];_maskID=[m[_list.indexOfSelectedItem][@"id"]copy];[self refreshWithDocument:_document time:_time];[self canvas:nil];[NSNotificationCenter.defaultCenter postNotificationName:DYModelChanged object:_host];}
- (void)remove:(id)sender{[self edit:@"删除工具蒙版" block:^(NSMutableDictionary *doc,NSMutableDictionary *mask){NSMutableArray *masks=[[DYMasksForTool(doc,self->_nodeID)mutableCopy]autorelease];[masks removeObject:mask];DYSetToolMasks(doc,self->_nodeID,masks);}];[self canvas:nil];}
- (void)enabled:(NSButton*)sender{[self edit:@"启停蒙版" block:^(NSMutableDictionary *d,NSMutableDictionary *m){m[@"enabled"]=@(sender.state==NSControlStateValueOn);}];}
- (void)combine:(id)sender{[self edit:@"蒙版组合" block:^(NSMutableDictionary *d,NSMutableDictionary *m){m[@"combine"]=@(self->_combine.indexOfSelectedItem);}];}
- (void)inverted:(NSButton*)sender{[self edit:@"反转蒙版" block:^(NSMutableDictionary *d,NSMutableDictionary *m){DYMaskParameters p;[m[@"parameters"]getBytes:&p length:sizeof(p)];if(sender.state)p.flags|=DYMaskInvert;else p.flags&=~DYMaskInvert;m[@"parameters"]=[NSData dataWithBytes:&p length:sizeof(p)];}];}
- (void)valueChanged:(NSControl*)sender{if(_refreshing)return;double value=sender.doubleValue;if(!std::isfinite(value)){NSBeep();return;}NSInteger i=sender.tag;[self edit:@"调整工具蒙版" block:^(NSMutableDictionary *d,NSMutableDictionary *m){DYMaskParameters p=DYMaskAtTime(m,self->_time);float *fields[]={&p.strength,&p.feather,&p.centerX,&p.centerY,&p.width,&p.height,&p.angle,&p.gradientWidth,&p.hueCenterTurns,&p.hueCoreHalfWidth,&p.hueSoftWidth,&p.saturationRange.low,&p.saturationRange.high,&p.lightnessRange.low,&p.lightnessRange.high,&p.inputBlack,&p.inputWhite,&p.inputGamma};*fields[i]=(i==6?value*M_PI/180:i>=8&&i<=10?value/360:value);if(p.kind==DYMaskHSLKey)p.flags|=DYMaskHueEnabled|DYMaskSaturationEnabled|DYMaskLightnessEnabled;if(!dyValidMaskParameters(p))return;if([m[@"keys"]count]&&i<8){NSMutableArray *keys=[[m[@"keys"]mutableCopy]autorelease];[keys filterUsingPredicate:[NSPredicate predicateWithBlock:^BOOL(NSDictionary *key,NSDictionary *bindings){CMTime t=CMTimeMakeWithEpoch([key[@"value"]longLongValue],[key[@"scale"]intValue],[key[@"epoch"]longLongValue]);return CMTimeCompare(t,self->_time)!=0;}]];[keys addObject:DYMaskKey(self->_time,p,YES,1)];[keys sortUsingComparator:^NSComparisonResult(NSDictionary *a,NSDictionary *b){CMTime x=CMTimeMakeWithEpoch([a[@"value"]longLongValue],[a[@"scale"]intValue],[a[@"epoch"]longLongValue]),y=CMTimeMakeWithEpoch([b[@"value"]longLongValue],[b[@"scale"]intValue],[b[@"epoch"]longLongValue]);return (NSComparisonResult)CMTimeCompare(x,y);}];m[@"keys"]=keys;}else m[@"parameters"]=[NSData dataWithBytes:&p length:sizeof(p)];}];}
- (void)canvasSelected:(NSNotification*)n{if([n.userInfo[@"node"]isEqual:_nodeID]&&[n.userInfo[@"mask"]length]){NSString *ID=[n.userInfo[@"mask"]copy];[_maskID release];_maskID=ID;}}
- (void)canvas:(id)sender{[NSNotificationCenter.defaultCenter postNotificationName:@"DYToolCanvasSelection" object:_host userInfo:@{@"node":_nodeID,@"mask":_maskID?:@"",@"document":_document?:@{}}];}
- (void)clear:(id)sender{[self edit:@"清除蒙版轨迹" block:^(NSMutableDictionary *d,NSMutableDictionary *m){DYMaskParameters p=DYMaskAtTime(m,self->_time);m[@"parameters"]=[NSData dataWithBytes:&p length:sizeof(p)];m[@"keys"]=@[];[m removeObjectForKey:@"status"];}];}
- (void)track:(NSButton*)sender{[self canvas:nil];[NSNotificationCenter.defaultCenter postNotificationName:@"DYToolTrack" object:_host userInfo:@{@"node":_nodeID,@"mask":_maskID?:@"",@"direction":@(sender.tag)}];}
- (void)trackingStatus:(NSNotification*)n{if([n.userInfo[@"node"]isEqual:_nodeID])_status.stringValue=n.userInfo[@"message"]?:@"";}
@end
+3
查看文件
@@ -1,4 +1,5 @@
#import "DYModel.h"
#import "DYToolState.h"
#include <cmath>
#include "DYSpiderState.h"
NSString *const DYModelChanged=@"DYModelChanged";
@@ -164,6 +165,8 @@ BOOL DYCreateParameters(id<PROAPIAccessing>m,NSError**error){id<FxParameterCreat
ok=[a addCustomParameterWithName:@"大鱼调色" parameterID:DYInspectorParameterID defaultValue:[[[DYInspectorToken alloc]init]autorelease] parameterFlags:kFxParameterFlag_CUSTOM_UI|kFxParameterFlag_USE_FULL_VIEW_WIDTH|kFxParameterFlag_DONT_DISPLAY_IN_DASHBOARD|kFxParameterFlag_NOT_ANIMATABLE]&&ok;
for(NSDictionary*r in DYDescriptors())ok=[a addFloatSliderWithName:r[@"title"] parameterID:[r[@"pid"]unsignedIntValue] defaultValue:[r[@"default"]doubleValue] parameterMin:[r[@"min"]doubleValue] parameterMax:[r[@"max"]doubleValue] sliderMin:[r[@"min"]doubleValue] sliderMax:[r[@"max"]doubleValue] delta:[r[@"step"]doubleValue] parameterFlags:kFxParameterFlag_HIDDEN|([r[@"notAnimatable"]boolValue]?kFxParameterFlag_NOT_ANIMATABLE:0)]&&ok;
ok=[a addCustomParameterWithName:@"LUT 文件" parameterID:DYAssetsParameterID defaultValue:[[[DYAssetState alloc]init]autorelease] parameterFlags:kFxParameterFlag_HIDDEN|kFxParameterFlag_NOT_ANIMATABLE]&&ok;
ok=[a addCustomParameterWithName:@"工具与蒙版" parameterID:DYToolsParameterID defaultValue:[[[DYToolDocument alloc]init]autorelease] parameterFlags:kFxParameterFlag_HIDDEN|kFxParameterFlag_NOT_ANIMATABLE]&&ok;
ok=[a addStringParameterWithName:@"蒙版画布会话" parameterID:DYCanvasSessionParameterID defaultValue:@"" parameterFlags:kFxParameterFlag_HIDDEN|kFxParameterFlag_NOT_ANIMATABLE|kFxParameterFlag_DONT_SAVE]&&ok;
if(!ok&&error)*error=[NSError errorWithDomain:FxPlugErrorDomain code:kFxError_InvalidParameter userInfo:@{NSLocalizedDescriptionKey:@"无法创建大鱼调色参数"}];return ok;}
@implementation DYAssetState
+ (BOOL)supportsSecureCoding{return YES;}
+1 -1
查看文件
@@ -1,4 +1,4 @@
#import <FxPlug/FxPlugSDK.h>
@interface DYPlugIn : NSObject<FxTileableEffect,FxCustomParameterViewHost_v2>
@interface DYPlugIn : NSObject<FxTileableEffect,FxCustomParameterViewHost_v2,FxAnalyzer>
@property(assign) id<PROAPIAccessing> apiManager;
@end
+18 -8
查看文件
@@ -4,30 +4,40 @@
#import "DYInspector.h"
#import "DYColorTables.h"
#import "DYAutoGrade.h"
#import "DYToolState.h"
#import <CoreImage/CoreImage.h>
#import <os/log.h>
#include "MaskCore/DYTracker.hpp"
#include <atomic>
#include "DYToolHostDeclarations.inc.h"
#include "DYToolFlow.inc.h"
@implementation DYPlugIn {
DYRenderer *_renderer;
BOOL _copyAnalyzed;
#include "DYToolHostIvars.inc.h"
}
- (instancetype)initWithAPIManager:(id<PROAPIAccessing>)manager{if((self=[super init])){_apiManager=manager;_renderer=[DYRenderer new];NSNotificationCenter*n=NSNotificationCenter.defaultCenter;[n addObserver:self selector:@selector(exportRequested:) name:@"DYExportLUT" object:manager];[n addObserver:self selector:@selector(autoRequested:) name:@"DYAutoGrade" object:manager];[n addObserver:self selector:@selector(autoRequested:) name:@"DYAutoWhiteBalance" object:manager];[n addObserver:self selector:@selector(whiteBalanceRequested:) name:@"DYWhiteBalanceColor" object:manager];}return self;}
- (void)dealloc{[NSNotificationCenter.defaultCenter removeObserver:self];[_renderer release];[super dealloc];}
#include "DYToolHostMethods.inc.h"
- (instancetype)initWithAPIManager:(id<PROAPIAccessing>)manager{if((self=[super init])){_apiManager=manager;_renderer=[DYRenderer new];[self initializeToolHost];NSNotificationCenter*n=NSNotificationCenter.defaultCenter;[n addObserver:self selector:@selector(exportRequested:) name:@"DYExportLUT" object:manager];[n addObserver:self selector:@selector(autoRequested:) name:@"DYAutoGrade" object:manager];[n addObserver:self selector:@selector(autoRequested:) name:@"DYAutoWhiteBalance" object:manager];[n addObserver:self selector:@selector(whiteBalanceRequested:) name:@"DYWhiteBalanceColor" object:manager];}return self;}
- (void)dealloc{[self tearDownToolHost];[NSNotificationCenter.defaultCenter removeObserver:self];[_renderer release];[super dealloc];}
- (BOOL)properties:(NSDictionary**)p error:(NSError**)e{*p=@{kFxPropertyKey_MayRemapTime:@NO,kFxPropertyKey_PixelTransformSupport:@(kFxPixelTransform_ScaleTranslate),kFxPropertyKey_VariesWhenParamsAreStatic:@NO,kFxPropertyKey_DesiredProcessingColorInfo:@(kFxImageColorInfo_RGB_LINEAR),kFxPropertyKey_NeedsFullBuffer:@YES};return YES;}
- (BOOL)addParametersWithError:(NSError**)e{return DYCreateParameters(_apiManager,e);}
- (NSSet<Class>*)classesForCustomParameterID:(UInt32)pid{return pid==DYAssetsParameterID?[NSSet setWithObjects:DYAssetState.class,NSDictionary.class,NSString.class,NSData.class,nil]:[NSSet setWithObjects:DYInspectorToken.class,NSDictionary.class,NSString.class,NSNumber.class,nil];}
- (NSView*)createViewForParameterID:(UInt32)pid{return pid==DYInspectorParameterID?[[DYInspector alloc]initWithAPIManager:_apiManager renderer:_renderer]:[[NSView alloc]initWithFrame:NSZeroRect];}
- (BOOL)parameterChanged:(UInt32)pid atTime:(CMTime)t error:(NSError**)e{if(pid==2013||pid==2014||(pid>=2236&&pid<2400)||pid==DYAssetsParameterID)[_renderer invalidatePreview];dispatch_async(dispatch_get_main_queue(),^{[NSNotificationCenter.defaultCenter postNotificationName:DYModelChanged object:self.apiManager];});return YES;}
- (NSSet<Class>*)classesForCustomParameterID:(UInt32)pid{return pid==DYToolsParameterID?[NSSet setWithObjects:DYToolDocument.class,NSDictionary.class,NSArray.class,NSString.class,NSNumber.class,NSData.class,nil]:pid==DYAssetsParameterID?[NSSet setWithObjects:DYAssetState.class,NSDictionary.class,NSString.class,NSData.class,nil]:[NSSet setWithObjects:DYInspectorToken.class,NSDictionary.class,NSString.class,NSNumber.class,nil];}
- (NSView*)createViewForParameterID:(UInt32)pid{[self scheduleToolCanvasRegistration];return pid==DYInspectorParameterID?[[DYInspector alloc]initWithAPIManager:_apiManager renderer:_renderer]:[[NSView alloc]initWithFrame:NSZeroRect];}
- (BOOL)parameterChanged:(UInt32)pid atTime:(CMTime)t error:(NSError**)e{if(pid==DYToolsParameterID)[self adoptToolCanvasDocument:DYReadTools(_apiManager,t).document];if(pid==DYToolsParameterID||pid==2013||pid==2014||(pid>=2236&&pid<2400)||pid==DYAssetsParameterID)[_renderer invalidatePreview];dispatch_async(dispatch_get_main_queue(),^{[NSNotificationCenter.defaultCenter postNotificationName:DYModelChanged object:self.apiManager];});return YES;}
- (BOOL)pluginState:(NSData**)state atTime:(CMTime)t quality:(FxQuality)q error:(NSError**)e{
DYUniforms u;DYReadUniforms(_apiManager,t,&u);DYAssetState*a=DYReadAssets(_apiManager,t);double copyAuto=0;[[_apiManager apiForProtocol:@protocol(FxParameterRetrievalAPI_v6)]getFloatValue:&copyAuto fromParameter:8800 atTime:t];NSDictionary*s=@{@"schema":@1,@"copyAuto":@(copyAuto>.5),@"uniforms":[NSData dataWithBytes:&u length:sizeof(u)],@"paths":a.paths?:@{},@"spider":a.spiderMesh?:[NSData data]};*state=[NSPropertyListSerialization dataWithPropertyList:s format:NSPropertyListBinaryFormat_v1_0 options:0 error:e];return *state!=nil;
DYUniforms u;DYReadUniforms(_apiManager,t,&u);DYAssetState*a=DYReadAssets(_apiManager,t);DYToolDocument *tools=DYReadTools(_apiManager,t);[self adoptToolCanvasDocument:tools.document];double copyAuto=0;[[_apiManager apiForProtocol:@protocol(FxParameterRetrievalAPI_v6)]getFloatValue:&copyAuto fromParameter:8800 atTime:t];NSDictionary*s=@{@"schema":@2,@"tools":DYToolRenderSnapshot(tools.document,t),@"copyAuto":@(copyAuto>.5),@"uniforms":[NSData dataWithBytes:&u length:sizeof(u)],@"paths":a.paths?:@{},@"spider":a.spiderMesh?:[NSData data]};*state=[NSPropertyListSerialization dataWithPropertyList:s format:NSPropertyListBinaryFormat_v1_0 options:0 error:e];return *state!=nil;
}
- (BOOL)destinationImageRect:(FxRect*)rect sourceImages:(NSArray<FxImageTile*>*)src destinationImage:(FxImageTile*)dst pluginState:(NSData*)s atTime:(CMTime)t error:(NSError**)e{if(!src.count)return NO;*rect=src[0].imagePixelBounds;return YES;}
- (BOOL)sourceTileRect:(FxRect*)rect sourceImageIndex:(NSUInteger)i sourceImages:(NSArray<FxImageTile*>*)src destinationTileRect:(FxRect)dstRect destinationImage:(FxImageTile*)dst pluginState:(NSData*)s atTime:(CMTime)t error:(NSError**)e{if(i>=src.count)return NO;*rect=src[i].imagePixelBounds;return YES;}
- (BOOL)renderDestinationImage:(FxImageTile*)dst sourceImages:(NSArray<FxImageTile*>*)src pluginState:(NSData*)s atTime:(CMTime)t error:(NSError**)e{
if(!src.count||!src[0].ioSurface||!dst.ioSurface||!s.length)return NO;NSDictionary*p=[NSPropertyListSerialization propertyListWithData:s options:NSPropertyListImmutable format:NULL error:e];if(![p isKindOfClass:NSDictionary.class])return NO;NSData*b=p[@"uniforms"];if(![p[@"schema"]isEqual:@1]||![b isKindOfClass:NSData.class]||b.length!=sizeof(DYUniforms)||![p[@"paths"]isKindOfClass:NSDictionary.class])return NO;DYUniforms u;[b getBytes:&u length:sizeof(u)];BOOL ok=[_renderer renderSource:src[0] destination:dst uniforms:u paths:p[@"paths"] spider:p[@"spider"] error:e];if(ok){BOOL analyze=NO;@synchronized(self){if(![p[@"copyAuto"]boolValue])_copyAnalyzed=NO;else if(!_copyAnalyzed){_copyAnalyzed=YES;analyze=YES;}}if(analyze){NSDictionary*values=DYAutoGrade([_renderer preview]);if(values)dispatch_async(dispatch_get_main_queue(),^{[self applyValues:values];});}}return ok;
if(!src.count||!src[0].ioSurface||!dst.ioSurface||!s.length)return NO;NSDictionary*p=[NSPropertyListSerialization propertyListWithData:s options:NSPropertyListImmutable format:NULL error:e];if(![p isKindOfClass:NSDictionary.class])return NO;NSData*b=p[@"uniforms"];if(![@[@1,@2]containsObject:p[@"schema"]]||![b isKindOfClass:NSData.class]||b.length!=sizeof(DYUniforms)||![p[@"paths"]isKindOfClass:NSDictionary.class])return NO;DYUniforms u;[b getBytes:&u length:sizeof(u)];BOOL ok=[_renderer renderSource:src[0] destination:dst uniforms:u paths:p[@"paths"] spider:p[@"spider"] tools:p[@"tools"] error:e];if(ok){if(_toolCaptureEnabled&&!_trackingActive.load()){dy::GrayFrame frame=[self toolGrayFrame:src[0] error:nil];if(frame.valid()){@synchronized(self){_toolSourceFrame=std::move(frame);_toolSourceTime=t;}}}BOOL analyze=NO;@synchronized(self){if(![p[@"copyAuto"]boolValue])_copyAnalyzed=NO;else if(!_copyAnalyzed){_copyAnalyzed=YES;analyze=YES;}}if(analyze){NSDictionary*values=DYAutoGrade([_renderer preview]);if(values)dispatch_async(dispatch_get_main_queue(),^{[self applyValues:values];});}}return ok;
}
- (void)alert:(NSString*)message{dispatch_async(dispatch_get_main_queue(),^{NSAlert*a=[NSAlert new];a.messageText=@"大鱼调色";a.informativeText=message?:@"操作未完成";[a runModal];[a release];});}
- (void)exportRequested:(NSNotification*)n{
NSURL*url=n.userInfo[@"url"];if(![url isKindOfClass:NSURL.class])return;id<FxCustomParameterActionAPI_v4>a=[_apiManager apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)];[a startAction:self];DYUniforms u;DYReadUniforms(_apiManager,a.currentTime,&u);DYAssetState *assets=DYReadAssets(_apiManager,a.currentTime);NSDictionary*paths=[assets.paths copy];NSData *mesh=[assets.spiderMesh copy];[a endAction:self];NSError*e=nil;BOOL ok=[_renderer exportLUT:url uniforms:u paths:paths spider:mesh error:&e];[mesh release];[paths release];if(!ok)[self alert:e.localizedDescription];
NSURL*url=n.userInfo[@"url"];if(![url isKindOfClass:NSURL.class])return;id<FxCustomParameterActionAPI_v4>a=[_apiManager apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)];[a startAction:self];DYUniforms u;DYReadUniforms(_apiManager,a.currentTime,&u);DYAssetState *assets=DYReadAssets(_apiManager,a.currentTime);NSDictionary*paths=[assets.paths copy];NSData *mesh=[assets.spiderMesh copy];NSDictionary *tools=[DYReadTools(_apiManager,a.currentTime).document copy];[a endAction:self];NSError*e=nil;BOOL ok=[_renderer exportLUT:url uniforms:u paths:paths spider:mesh tools:tools error:&e];[tools release];[mesh release];[paths release];if(!ok)[self alert:e.localizedDescription];
}
- (void)applyValues:(NSDictionary*)values{if(!values){[self alert:@"尚未拿到当前片段画面,请移动播放头后重试。"];return;}id<FxCustomParameterActionAPI_v4>a=[_apiManager apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)];[a startAction:self];@try{id<FxParameterSettingAPI_v6>s=[_apiManager apiForProtocol:@protocol(FxParameterSettingAPI_v6)];for(NSDictionary*r in DYDescriptors()){NSNumber*v=values[r[@"key"]];if(v)[s setFloatValue:v.doubleValue toParameter:[r[@"pid"]unsignedIntValue] atTime:a.currentTime];}}@finally{[a endAction:self];}[NSNotificationCenter.defaultCenter postNotificationName:DYModelChanged object:_apiManager];}
- (void)autoRequested:(NSNotification*)n{NSData*frame=[_renderer preview];[self applyValues:[n.name isEqual:@"DYAutoGrade"]?DYAutoGrade(frame):DYAutoWhiteBalance(frame)];}
- (void)whiteBalanceRequested:(NSNotification*)n{NSColor*c=[n.userInfo[@"color"]colorUsingColorSpace:NSColorSpace.sRGBColorSpace];if(!c)return;float temp=0,tint=0;if([DYColorTables neutralizeColor:(vector_float3){(float)c.redComponent,(float)c.greenComponent,(float)c.blueComponent} temperature:&temp tint:&tint])[self applyValues:@{@"temperature":@(temp),@"tint":@(tint)}];else [self alert:@"所选颜色过暗,请选择白色或中性灰区域。"];}
@end
#include "DYToolOSC.inc.h"
+3
查看文件
@@ -2,6 +2,7 @@
#import <Metal/Metal.h>
#import <FxPlug/FxPlugSDK.h>
#import "DYUniforms.h"
#import "DYToolState.h"
@interface DYRenderer : NSObject
/// Decode and upload before committing a host parameter. The renderer retains
/// the immutable selected contents independently of the thumbnail cache.
@@ -10,6 +11,8 @@
- (BOOL)exportLUT:(NSURL*)url uniforms:(DYUniforms)uniforms paths:(NSDictionary*)paths error:(NSError**)error;
- (BOOL)renderSource:(FxImageTile*)source destination:(FxImageTile*)destination uniforms:(DYUniforms)uniforms paths:(NSDictionary*)paths spider:(NSData*)spider error:(NSError**)error;
- (BOOL)exportLUT:(NSURL*)url uniforms:(DYUniforms)uniforms paths:(NSDictionary*)paths spider:(NSData*)spider error:(NSError**)error;
- (BOOL)renderSource:(FxImageTile*)source destination:(FxImageTile*)destination uniforms:(DYUniforms)uniforms paths:(NSDictionary*)paths spider:(NSData*)spider tools:(NSDictionary*)tools error:(NSError**)error;
- (BOOL)exportLUT:(NSURL*)url uniforms:(DYUniforms)uniforms paths:(NSDictionary*)paths spider:(NSData*)spider tools:(NSDictionary*)tools error:(NSError**)error;
- (NSData*)preview;
/// Display-encoded float RGBA, 320×180, with the visually top row first.
/// Analysis preview retains the host texture's original row order separately.
+20 -10
查看文件
@@ -1,6 +1,7 @@
#import "DYRenderer.h"
#import "DYModel.h"
#include "DYSpiderState.h"
#include "DYToolGPU.h"
#import "DYColorTables.h"
#import "DYLUTLibrary.h"
#import <QuartzCore/QuartzCore.h>
@@ -11,17 +12,22 @@ static BOOL fail(NSError**e,NSString*m){if(e)*e=[NSError errorWithDomain:@"com.d
static NSArray *inputFiles(){return @[@"",@"apple_log_to_rec709",@"arri_logc3_to_rec709",@"arri_logc4_to_rec709",@"blackmagic_film_gen5_to_rec709",@"canon_clog_bt709_to_rec709",@"canon_clog2_cinema_gamut_to_rec709",@"canon_clog3_cinema_gamut_to_rec709",@"dji_dlog_to_rec709",@"dji_dlog_m_to_rec709",@"fujifilm_flog_to_rec709",@"fujifilm_flog2_to_rec709",@"nikon_nlog_to_rec709",@"panasonic_vlog_vgamut_to_rec709",@"red_log3g10_rwg_to_rec709",@"sony_slog2_sgamut_to_rec709",@"sony_slog3_sgamut3cine_to_rec709",@"sony_hlg_bt2020_to_rec709"];}
static id<MTLTexture> texture3D(id<MTLDevice>d,const float*values,NSUInteger n){MTLTextureDescriptor*t=[MTLTextureDescriptor new];t.textureType=MTLTextureType3D;t.pixelFormat=MTLPixelFormatRGBA32Float;t.width=n;t.height=n;t.depth=n;t.storageMode=MTLStorageModeShared;t.usage=MTLTextureUsageShaderRead;id<MTLTexture>x=[d newTextureWithDescriptor:t];[t release];if(x)[x replaceRegion:MTLRegionMake3D(0,0,0,n,n,n) mipmapLevel:0 slice:0 withBytes:values bytesPerRow:n*16 bytesPerImage:n*n*16];return [x autorelease];}
// A synthetic texture lattice uses exactly the production render path for Cube export.
@interface DYExportTile : FxImageTile { id<MTLTexture> _tex; uint64_t _registry; }
@interface DYExportTile : FxImageTile { id<MTLTexture> _tex; uint64_t _registry; FxRect _bounds;FxImageOrigin _origin; double _pixelAspect; }
- (instancetype)initWithTexture:(id<MTLTexture>)texture registry:(uint64_t)registry;
- (void)setBounds:(FxRect)bounds origin:(FxImageOrigin)origin;
- (void)setPixelAspect:(double)aspect;
@end
@implementation DYExportTile
- (instancetype)initWithTexture:(id<MTLTexture>)texture registry:(uint64_t)registry{if((self=[super init])){_tex=[texture retain];_registry=registry;}return self;}
- (instancetype)initWithTexture:(id<MTLTexture>)texture registry:(uint64_t)registry{if((self=[super init])){_tex=[texture retain];_registry=registry;_bounds=(FxRect){0,0,(SInt32)texture.width,(SInt32)texture.height};_origin=kFxImageOrigin_TOP_LEFT;_pixelAspect=1;}return self;}
- (void)dealloc{[_tex release];[super dealloc];}
- (id<MTLTexture>)metalTextureForDevice:(id<MTLDevice>)d{return d.registryID==_registry?_tex:nil;}
- (FxRect)tilePixelBounds{return (FxRect){0,0,(SInt32)_tex.width,(SInt32)_tex.height};}
- (void)setBounds:(FxRect)bounds origin:(FxImageOrigin)origin{_bounds=bounds;_origin=origin;}
- (FxRect)tilePixelBounds{return _bounds;}
- (FxRect)imagePixelBounds{return self.tilePixelBounds;}
- (uint64_t)deviceRegistryID{return _registry;}
- (FxImageOrigin)imageOrigin{return kFxImageOrigin_TOP_LEFT;}
- (FxImageOrigin)imageOrigin{return _origin;}
- (double)pixelAspect{return _pixelAspect;}
- (void)setPixelAspect:(double)aspect{_pixelAspect=aspect>0?aspect:1;}
@end
static BOOL managed(DYUniforms u,NSDictionary *paths){return u.cm.configured>=0&&(u.cm.configured>.5||(![paths[@"input"]length]&&u.inputProfile<.5));}
static BOOL identityCM(DYUniforms u){
@@ -55,9 +61,11 @@ static void bypassIdleSkin(DYUniforms *u){
NSData *_preview,*_lookLUTPreview;
CFTimeInterval _lastPreview;
BOOL _exporting;
NSDictionary *_toolDocument;
}
@end
@implementation DYRenderer
#include "DYToolRender.inc.h"
- (instancetype)init{if((self=[super init])){_previewLock=[NSObject new];_devices=[NSMutableDictionary new];_luts=[NSMutableDictionary new];_preparedLUTs=[NSMutableDictionary new];_activeLUTPaths=[NSSet new];_lutPreparationQueue=dispatch_queue_create("com.dayu.color.lut-upload",DISPATCH_QUEUE_SERIAL);dispatch_set_target_queue(_lutPreparationQueue,dispatch_get_global_queue(QOS_CLASS_USER_INITIATED,0));_tables=[DYColorTables new];}return self;}
- (void)dealloc{[_devices release];[_luts release];[_preparedLUTs release];[_activeLUTPaths release];dispatch_release(_lutPreparationQueue);[_tables release];[_preview release];[_lookLUTPreview release];[_previewLock release];[super dealloc];}
- (void)trimPreparedLUTsKeeping:(NSString *)path {
@@ -91,7 +99,7 @@ static void bypassIdleSkin(DYUniforms *u){
NSURL*url=[[NSBundle bundleForClass:self.class]URLForResource:@"default" withExtension:@"metallib"];
id<MTLLibrary>lib=[d newLibraryWithURL:url error:err];if(!lib){[d release];return nil;}
id<MTLCommandQueue>q=[d newCommandQueue];entry=[NSMutableDictionary dictionaryWithDictionary:@{@"device":d,@"library":lib,@"queue":q,@"pipelines":[NSMutableDictionary dictionary]}];
for(NSString*fn in @[@"dyUnpremultiply",@"dyWhitesSceneStatistics",@"dyLUTExportKernel",@"dyInputAnalysis",@"dyColorManagement"]){id<MTLFunction>f=[lib newFunctionWithName:fn];if(!f){fail(err,[fn stringByAppendingString:@" 缺失"]);[lib release];[q release];[d release];return nil;}id<MTLComputePipelineState>p=[d newComputePipelineStateWithFunction:f error:err];[f release];if(!p){[lib release];[q release];[d release];return nil;}entry[fn]=p;[p release];}
for(NSString*fn in @[@"dyUnpremultiply",@"dyWhitesSceneStatistics",@"dyLUTExportKernel",@"dyInputAnalysis",@"dyColorManagement",@"dyToolBlend",@"dyToolSkin"]){id<MTLFunction>f=[lib newFunctionWithName:fn];if(!f){fail(err,[fn stringByAppendingString:@" 缺失"]);[lib release];[q release];[d release];return nil;}id<MTLComputePipelineState>p=[d newComputePipelineStateWithFunction:f error:err];[f release];if(!p){[lib release];[q release];[d release];return nil;}entry[fn]=p;[p release];}
float identity[32];for(int z=0;z<2;z++)for(int y=0;y<2;y++)for(int x=0;x<2;x++){int i=((z*2+y)*2+x)*4;identity[i]=x;identity[i+1]=y;identity[i+2]=z;identity[i+3]=1;}id<MTLTexture>neutral=texture3D(d,identity,2);if(!neutral){fail(err,@"无法分配中性 LUT");return nil;}entry[@"identity"]=neutral;
// Preparing before the first frame may use registry 0. Reuse those pipelines
// when the host subsequently supplies that device's actual registry ID.
@@ -121,7 +129,8 @@ static void bypassIdleSkin(DYUniforms *u){
id<MTLTexture>h=[_tables hslForDevice:d uniforms:u],w=[_tables whiteBalanceForDevice:d uniforms:u],g=[_tables gradingForDevice:d uniforms:u];if(!h||!w||!g){fail(err,_tables.lastError?:@"颜色查表构建失败");return nil;}[ts addObjectsFromArray:@[h,w,g]];return ts;
}
- (BOOL)renderSource:(FxImageTile*)src destination:(FxImageTile*)dst uniforms:(DYUniforms)u paths:(NSDictionary*)paths error:(NSError**)err{return [self renderSource:src destination:dst uniforms:u paths:paths spider:nil error:err];}
- (BOOL)renderSource:(FxImageTile*)src destination:(FxImageTile*)dst uniforms:(DYUniforms)u paths:(NSDictionary*)paths spider:(NSData *)spider error:(NSError**)err{@synchronized(self){@autoreleasepool{
- (BOOL)renderSource:(FxImageTile*)src destination:(FxImageTile*)dst uniforms:(DYUniforms)u paths:(NSDictionary*)paths spider:(NSData *)spider error:(NSError**)err{return [self renderLegacy:src destination:dst uniforms:u paths:paths spider:spider masks:@{} error:err];}
- (BOOL)renderLegacy:(FxImageTile*)src destination:(FxImageTile*)dst uniforms:(DYUniforms)u paths:(NSDictionary*)paths spider:(NSData *)spider masks:(NSDictionary*)masks error:(NSError**)err{@synchronized(self){@autoreleasepool{
if(spider.length&&!DYSpiderMeshIsValid(spider))return fail(err,@"蜘蛛盘数据无效");
if(u.primarySectionEnabled<.5){u.inputSectionEnabled=0;u.cm.basisEnabled=0;u.cm.outputEnabled=0;}
@@ -138,13 +147,14 @@ static void bypassIdleSkin(DYUniforms *u){
}
if([e[@"spiderActive"]boolValue]){spiderBuffer=e[@"spiderBuffer"];spiderSize={ [e[@"spiderHues"]intValue],[e[@"spiderRings"]intValue]};}
}
NSMutableDictionary*ps=e[@"pipelines"];NSNumber*format=@(output.pixelFormat);id<MTLRenderPipelineState>pipeline=ps[format];if(!pipeline){MTLRenderPipelineDescriptor*p=[MTLRenderPipelineDescriptor new];p.vertexFunction=[e[@"library"]newFunctionWithName:@"dyVertex"];p.fragmentFunction=[e[@"library"]newFunctionWithName:@"dyFragment"];p.colorAttachments[0].pixelFormat=output.pixelFormat;pipeline=[d newRenderPipelineStateWithDescriptor:p error:err];[p.vertexFunction release];[p.fragmentFunction release];[p release];if(!pipeline)return NO;ps[format]=pipeline;[pipeline release];}
DYToolMaskHeader maskHeader{};id<MTLBuffer>maskBuffer=masks.count?[self maskBuffer:masks tile:src device:d header:&maskHeader]:nil;BOOL hasMasks=maskHeader.count>0;if(hasMasks&&!maskBuffer)return fail(err,@"无法分配蒙版缓冲区");
NSMutableDictionary*ps=e[@"pipelines"];NSString*format=[NSString stringWithFormat:@"%lu-%d",(unsigned long)output.pixelFormat,hasMasks];id<MTLRenderPipelineState>pipeline=ps[format];if(!pipeline){MTLRenderPipelineDescriptor*p=[MTLRenderPipelineDescriptor new];p.vertexFunction=[e[@"library"]newFunctionWithName:@"dyVertex"];p.fragmentFunction=[e[@"library"]newFunctionWithName:hasMasks?@"dyMaskedFragment":@"dyFragment"];p.colorAttachments[0].pixelFormat=output.pixelFormat;pipeline=[d newRenderPipelineStateWithDescriptor:p error:err];[p.vertexFunction release];[p.fragmentFunction release];[p release];if(!pipeline)return NO;ps[format]=pipeline;[pipeline release];}
MTLTextureDescriptor*td=[MTLTextureDescriptor texture2DDescriptorWithPixelFormat:MTLPixelFormatRGBA16Float width:input.width height:input.height mipmapped:NO];td.storageMode=MTLStorageModePrivate;td.usage=MTLTextureUsageShaderRead|MTLTextureUsageShaderWrite;id<MTLTexture>straight=[d newTextureWithDescriptor:td];if(!straight)return fail(err,@"无法分配调色缓冲区");
id<MTLCommandBuffer>cb=[e[@"queue"]commandBuffer];id<MTLComputeCommandEncoder>ce=[cb computeCommandEncoder];[ce setComputePipelineState:e[@"dyUnpremultiply"]];[ce setTexture:input atIndex:0];[ce setTexture:straight atIndex:1];[ce dispatchThreads:MTLSizeMake(input.width,input.height,1) threadsPerThreadgroup:MTLSizeMake(16,16,1)];[ce endEncoding];
if(useCM&&!identityCM(u)&&u.cm.mix>0){
DayuRenderParams cm=DYCMRender(u.cm);cm.stages=(cm.stages&~1)|(u.inputSectionEnabled>.5?1:0);
if(cm.stages){id<MTLTexture>converted=[d newTextureWithDescriptor:td];if(!converted){[straight release];return fail(err,@"无法分配 CST 缓冲区");}
ce=[cb computeCommandEncoder];[ce setComputePipelineState:e[@"dyColorManagement"]];[ce setTexture:straight atIndex:0];[ce setTexture:converted atIndex:1];[ce setBytes:&cm length:sizeof(cm) atIndex:0];[ce setBytes:&u.cm.mix length:4 atIndex:1];[ce dispatchThreads:MTLSizeMake(input.width,input.height,1) threadsPerThreadgroup:MTLSizeMake(16,16,1)];[ce endEncoding];[straight release];straight=converted;
ce=[cb computeCommandEncoder];[ce setComputePipelineState:e[@"dyColorManagement"]];[ce setTexture:straight atIndex:0];[ce setTexture:converted atIndex:1];[ce setBytes:&cm length:sizeof(cm) atIndex:0];[ce setBytes:&u.cm.mix length:4 atIndex:1];[ce dispatchThreads:MTLSizeMake(input.width,input.height,1) threadsPerThreadgroup:MTLSizeMake(16,16,1)];[ce endEncoding];if(hasMasks){id<MTLTexture>blended=[d newTextureWithDescriptor:td];if(!blended){[converted release];[straight release];return fail(err,@"无法分配一级蒙版缓冲区");}maskHeader.section=0;maskHeader.premultiplied=0;[self encodeBlend:straight after:converted output:blended masks:maskBuffer header:maskHeader entry:e commands:cb];[converted release];converted=blended;}[straight release];straight=converted;
}
}
float level=.5;id<MTLBuffer>scene=[d newBufferWithBytes:&level length:4 options:MTLResourceStorageModeShared];
@@ -155,7 +165,7 @@ static void bypassIdleSkin(DYUniforms *u){
if(src.imageOrigin==kFxImageOrigin_BOTTOM_LEFT){top=1-top;bottom=1-bottom;}
DYVertex2D vs[]={{{w/2,-h/2},{r,bottom}},{{-w/2,-h/2},{l,bottom}},{{w/2,h/2},{r,top}},{{-w/2,h/2},{l,top}}};
if(dst.imageOrigin==kFxImageOrigin_BOTTOM_LEFT)for(int i=0;i<4;i++)vs[i].position.y=-vs[i].position.y;
vector_uint2 vp={(unsigned)output.width,(unsigned)output.height};[re setVertexBytes:vs length:sizeof(vs) atIndex:0];[re setVertexBytes:&vp length:sizeof(vp) atIndex:1];[re setViewport:(MTLViewport){0,0,w,h,0,1}];[re setFragmentTexture:straight atIndex:0];for(NSUInteger i=0;i<ts.count;i++)[re setFragmentTexture:ts[i] atIndex:i+1];[re setFragmentBytes:&u length:sizeof(u) atIndex:0];[re setFragmentBuffer:scene offset:0 atIndex:1];DYRenderOptions options={1,bwMix,0,0};[re setFragmentBytes:&options length:sizeof(options) atIndex:2];DYUniforms color=u;color.blackWhiteSectionEnabled=0;[re setFragmentBytes:&color length:sizeof(color) atIndex:3];if(spiderBuffer)[re setFragmentBuffer:spiderBuffer offset:0 atIndex:4];else{float empty[2]={0,0};[re setFragmentBytes:empty length:sizeof(empty) atIndex:4];}[re setFragmentBytes:&spiderSize length:sizeof(spiderSize) atIndex:5];[re drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4];[re endEncoding];[cb commit];[cb waitUntilCompleted];BOOL ok=cb.status==MTLCommandBufferStatusCompleted;
vector_uint2 vp={(unsigned)output.width,(unsigned)output.height};[re setVertexBytes:vs length:sizeof(vs) atIndex:0];[re setVertexBytes:&vp length:sizeof(vp) atIndex:1];[re setViewport:(MTLViewport){0,0,w,h,0,1}];[re setFragmentTexture:straight atIndex:0];for(NSUInteger i=0;i<ts.count;i++)[re setFragmentTexture:ts[i] atIndex:i+1];[re setFragmentBytes:&u length:sizeof(u) atIndex:0];[re setFragmentBuffer:scene offset:0 atIndex:1];DYRenderOptions options={1,bwMix,0,0};[re setFragmentBytes:&options length:sizeof(options) atIndex:2];DYUniforms color=u;color.blackWhiteSectionEnabled=0;[re setFragmentBytes:&color length:sizeof(color) atIndex:3];if(spiderBuffer)[re setFragmentBuffer:spiderBuffer offset:0 atIndex:4];else{float empty[2]={0,0};[re setFragmentBytes:empty length:sizeof(empty) atIndex:4];}[re setFragmentBytes:&spiderSize length:sizeof(spiderSize) atIndex:5];if(hasMasks){[re setFragmentBuffer:maskBuffer offset:0 atIndex:6];[re setFragmentBytes:&maskHeader length:sizeof(maskHeader) atIndex:7];}[re drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4];[re endEncoding];[cb commit];[cb waitUntilCompleted];BOOL ok=cb.status==MTLCommandBufferStatusCompleted;
if(ok&&pb){@synchronized(_previewLock){
[_preview release];_preview=[[NSData alloc]initWithBytes:pb.contents length:320*180*16];
// The analysis kernel reads physical texture rows. Its result remains intact
@@ -179,7 +189,7 @@ static void bypassIdleSkin(DYUniforms *u){
[input replaceRegion:MTLRegionMake2D(0,0,width,height) mipmapLevel:0 withBytes:values.data() bytesPerRow:width*8];
DYExportTile *source=[[[DYExportTile alloc]initWithTexture:input registry:d.registryID]autorelease],*dest=[[[DYExportTile alloc]initWithTexture:output registry:d.registryID]autorelease];
u.textureEnabled=0;u.clarityEnabled=0;u.dehazeEnabled=0;BOOL ok=NO;_exporting=YES;
@try{ok=[self renderSource:source destination:dest uniforms:u paths:paths spider:spider error:err];}@finally{_exporting=NO;}
@try{ok=[self renderSource:source destination:dest uniforms:u paths:paths spider:spider tools:_toolDocument error:err];}@finally{_exporting=NO;}
if(ok)[output getBytes:values.data() bytesPerRow:width*8 fromRegion:MTLRegionMake2D(0,0,width,height) mipmapLevel:0];[input release];[output release];if(!ok)return NO;
NSMutableString *text=[NSMutableString stringWithString:@"TITLE \"大鱼调色\"\n# 包含 CST 与逐像素颜色;不包含纹理、清晰度和逐画面分析。\nLUT_3D_SIZE 33\nDOMAIN_MIN 0 0 0\nDOMAIN_MAX 1 1 1\n"];
for(NSUInteger i=0;i<count;i++){float rgb[3];for(int c=0;c<3;c++){float v=values[i*4+c];rgb[c]=v<=.0031308f?v*12.92f:1.055f*powf(v,1/2.4f)-.055f;if(!std::isfinite(rgb[c]))return fail(err,@"LUT 输出含无效值");}[text appendFormat:@"%.8f %.8f %.8f\n",rgb[0],rgb[1],rgb[2]];}
@@ -0,0 +1,12 @@
{
DYDiagnosticManager *base=[[[DYDiagnosticManager alloc]init]autorelease];DYCreateParameters(base,&error);DYToolCanvasProbe *host=[[[DYToolCanvasProbe alloc]init]autorelease];host->_base=base;host->_time=kCMTimeZero;
NSMutableDictionary *doc=DYMutablePlist([[[DYToolDocument alloc]init]autorelease].document);NSDictionary *mask=DYNewMask(DYMaskRectangle);doc[@"baseMasks"][@"hsl"]=[NSMutableArray arrayWithObject:mask];DYWriteTools(base,doc,kCMTimeZero);
id<DYToolCanvasHostProbe>plugin=(id)[[NSClassFromString(@"DYPlugIn")alloc]initWithAPIManager:host];[plugin scheduleToolCanvasRegistration];NSData *state=nil;[plugin pluginState:&state atTime:kCMTimeZero quality:(FxQuality)0 error:&error];
auto drain=[](){double end=NSProcessInfo.processInfo.systemUptime+.1;while(NSProcessInfo.processInfo.systemUptime<end)[[NSRunLoop mainRunLoop]runMode:NSDefaultRunLoopMode beforeDate:[NSDate dateWithTimeIntervalSinceNow:.005]];};drain();
NSDictionary *snapshot=[plugin toolCanvasMaskAtTime:kCMTimeZero];run.record(@"canvas-cold-load-selects-saved-mask-from-immutable-snapshot",[snapshot[@"id"]isEqual:mask[@"id"]]&&[snapshot[@"parameters"]length]==sizeof(DYMaskParameters));
[NSNotificationCenter.defaultCenter postNotificationName:@"DYToolCanvasSelection" object:host userInfo:@{@"node":@"base:hsl",@"mask":mask[@"id"],@"document":doc}];
id<FxOnScreenControl_v4>osc=(id)[[NSClassFromString(@"DYToolOSC")alloc]initWithAPIManager:host];DYDiagnosticTile *overlay=[[[DYDiagnosticTile alloc]initWithDevice:gpu width:640 height:400]autorelease];[osc drawOSCWithWidth:640 height:400 activePart:0 destinationImage:overlay atTime:kCMTimeZero];Pixels pixels=read(overlay,gpu);NSUInteger opaque=0;BOOL finite=YES;for(NSUInteger i=0;i<640*400;i++){float a=pixels[i*4+3];opaque+=a>.01;finite&=std::isfinite(a);}run.record(@"native-osc-real-metal-overlay-transparent-around-controls",finite&&opaque>100&&opaque<640*400*.2,@{@"coveredPixels":@(opaque)});
NSInteger part=0;[osc hitTestOSCAtMousePositionX:320 mousePositionY:212.5 activePart:&part atTime:kCMTimeZero];run.record(@"native-osc-object-to-canvas-center-hit",part==1);
int undo=base->_undoStarts;BOOL update=NO;[osc mouseDownAtPositionX:320 positionY:212.5 activePart:1 modifiers:0 forceUpdate:&update atTime:kCMTimeZero];[osc mouseDraggedAtPositionX:348 positionY:196.75 activePart:1 modifiers:0 forceUpdate:&update atTime:kCMTimeZero];[osc mouseUpAtPositionX:348 positionY:196.75 activePart:1 modifiers:0 forceUpdate:&update atTime:kCMTimeZero];drain();NSDictionary *moved=DYReadTools(base,kCMTimeZero).document[@"baseMasks"][@"hsl"][0];DYMaskParameters p=DYMaskAtTime(moved,kCMTimeZero);run.record(@"native-osc-drag-writes-independent-normalized-geometry",fabs(p.centerX-.55)<1e-5&&fabs(p.centerY-.55)<1e-5,@{@"x":@(p.centerX),@"y":@(p.centerY)});run.record(@"native-osc-drag-commits-one-undo-after-callback",base->_undoStarts==undo+1&&base->_undoStarts==base->_undoEnds);
NSDictionary *before=[DYReadTools(base,kCMTimeZero).document copy];[plugin adoptToolCanvasDocument:before];[osc mouseDownAtPositionX:348 positionY:196.75 activePart:1 modifiers:0 forceUpdate:&update atTime:kCMTimeZero];[osc mouseDraggedAtPositionX:370 positionY:180 activePart:1 modifiers:0 forceUpdate:&update atTime:kCMTimeZero];BOOL handled=NO;[osc keyDownAtPositionX:370 positionY:180 keyPressed:27 modifiers:0 forceUpdate:&update didHandle:&handled atTime:kCMTimeZero];drain();run.record(@"native-osc-escape-discards-draft-without-host-edit",[before isEqual:DYReadTools(base,kCMTimeZero).document]&&base->_undoStarts==undo+1);[before release];[osc release];[plugin release];
}
@@ -0,0 +1,38 @@
// Nontrivial authoring and GPU regressions; runs as part of the signed CLI self-test.
{
DYToolDocument *empty=[[[DYToolDocument alloc]init]autorelease];NSMutableDictionary *doc=DYMutablePlist(empty.document);
NSMutableDictionary *first=DYMutablePlist(DYNewTool(@"hsl")),*second=DYMutablePlist(DYNewTool(@"hsl"));doc[@"layers"]=[NSMutableArray arrayWithObjects:first,second,nil];
run.need(@"tool-document-two-independent-hsl",DYValidToolDocument(doc)&&![first[@"id"]isEqual:second[@"id"]]);
first[@"values"][@"hsl0_0"]=@32;second[@"values"][@"hsl1_2"]=@55;
DYToolDocument *authored=[[[DYToolDocument alloc]init]autorelease];authored.document=doc;NSData *archive=[NSKeyedArchiver archivedDataWithRootObject:authored requiringSecureCoding:YES error:&error];DYToolDocument *restored=[NSKeyedUnarchiver unarchivedObjectOfClass:DYToolDocument.class fromData:archive error:&error];
run.record(@"tool-document-secure-archive-roundtrip",[restored isEqual:authored]&&restored.hash==authored.hash);
DYToolManager *one=[[[DYToolManager alloc]initWithHost:manager node:first]autorelease];DYWriteTools(manager,doc,kCMTimeZero);id<FxCustomParameterActionAPI_v4>action=(id)one;[action startAction:one];
[(id<FxParameterSettingAPI_v6>)one setFloatValue:17 toParameter:2068 atTime:kCMTimeZero];[(id<FxParameterSettingAPI_v6>)one setFloatValue:26 toParameter:2076 atTime:kCMTimeZero];[action endAction:one];NSDictionary *written=DYReadTools(manager,kCMTimeZero).document;
run.record(@"instance-proxy-batches-multiple-fields-without-clobber",[DYToolWithID(written,first[@"id"])[@"values"][@"hsl0_0"]isEqual:@17]&&[DYToolWithID(written,first[@"id"])[@"values"][@"hsl1_0"]isEqual:@26]&&[DYToolWithID(written,second[@"id"])[@"values"][@"hsl1_2"]isEqual:@55]);
DYInspector *stackInspector=[[[DYInspector alloc]initWithAPIManager:manager renderer:renderer]autorelease];[stackInspector refresh];[stackInspector setFrameSize:NSMakeSize(360,780)];[stackInspector layoutSubtreeIfNeeded];NSDictionary *stackViews=[stackInspector valueForKey:@"_stackViews"];BOOL nativeViews=stackViews.count==2;for(NSString *ID in stackViews){NSArray *c=[stackViews[ID]valueForKey:@"_cards"];nativeViews&=c.count==1&&c[0][@"maskButton"]&&c[0][@"repeatButton"]&&[c[0][@"section"][@"key"]isEqual:@"hsl"];}run.record(@"two-native-hsl-panels-with-mask-and-repeat-buttons",nativeViews);
NSMutableDictionary *invalid=DYMutablePlist(doc);invalid[@"layers"][1][@"id"]=first[@"id"];run.record(@"tool-document-rejects-duplicate-identity",!DYValidToolDocument(invalid));invalid=DYMutablePlist(doc);invalid[@"layers"][0][@"values"][@"hsl0_0"]=@(NAN);run.record(@"tool-document-rejects-nonfinite",!DYValidToolDocument(invalid));
NSMutableDictionary *mask=DYMutablePlist(DYNewMask(DYMaskRectangle));DYMaskParameters p=DYMaskAtTime(mask,kCMTimeZero);p.feather=0;p.width=.5;p.height=.5;mask[@"parameters"]=[NSData dataWithBytes:&p length:sizeof(p)];CMTime a=CMTimeMake(1001,24000),b=CMTimeMake(2002,24000);DYMaskParameters moved=p;moved.centerX=.7;moved.width=.6;moved.angle=.2;mask[@"keys"]=@[DYMaskKey(a,p,YES,1),DYMaskKey(b,moved,NO,.9)];
DYMaskParameters mid=DYMaskAtTime(mask,CMTimeMake(3003,48000));run.record(@"mask-rational-time-interpolates-independent-geometry",fabs(mid.centerX-.6)<1e-6&&fabs(mid.width-.55)<1e-6&&fabs(mid.angle-.1)<1e-6);
DYMaskParameters replacement=p;replacement.centerX=.8;BOOL merged=DYMergeTracking(mask,@[DYMaskKey(a,replacement,NO,.8),DYMaskKey(b,replacement,NO,.8)]);run.record(@"tracking-merge-preserves-manual-keys",merged&&fabs(DYMaskAtTime(mask,a).centerX-.5)<1e-6&&fabs(DYMaskAtTime(mask,b).centerX-.8)<1e-6);
doc=DYMutablePlist(empty.document);doc[@"baseMasks"][@"hsl"]=[NSMutableArray arrayWithObject:mask];NSDictionary *snapshot=DYToolRenderSnapshot(doc,CMTimeMake(3003,48000));DYMaskParameters resolved=DYMaskAtTime(snapshot[@"baseMasks"][@"hsl"][0],kCMTimeZero);run.record(@"render-snapshot-freezes-time-without-author-keys",[snapshot[@"baseMasks"][@"hsl"][0][@"keys"]count]==0&&fabs(resolved.centerX-.65)<1e-6&&[mask[@"keys"]count]==2);
auto renderTools=[&](NSDictionary *tools,DYUniforms u,NSData *mesh,NSString *name){NSError *failure=nil;BOOL ok=[renderer renderSource:source destination:destination uniforms:u paths:@{} spider:mesh tools:tools error:&failure];run.need(name,ok,@{@"error":reason(failure)});return read(destination,gpu);};
[[source metalTextureForDevice:gpu]replaceRegion:MTLRegionMake2D(0,0,width,height) mipmapLevel:0 withBytes:input.data() bytesPerRow:width*8];
Pixels baseline=renderTools(empty.document,defaults,nil,@"empty-tool-document-render");run.record(@"empty-tool-document-preserves-legacy-pixels-exactly",difference(baseline,neutral).maximum==0);
doc=DYMutablePlist(empty.document);for(NSString *type in DYToolTypes())[doc[@"layers"]addObject:DYNewTool(type)];Pixels initialized=renderTools(doc,defaults,nil,@"all-twelve-initialized-tool-types-render");run.record(@"initialized-repeated-tools-are-exactly-neutral",difference(initialized,neutral).maximum==0);
// Reference is two explicit isolated native operations, which catches shared
// uniform or lookup caches, ordering, repeated CST and accidental base replay.
DYUniforms layerOne=DYToolUniforms(first),layerTwo=DYToolUniforms(second);render(run,renderer,source,destination,gpu,layerOne,@{},@"hsl-stack-first-reference");DYDiagnosticTile *intermediate=[[[DYDiagnosticTile alloc]initWithDevice:gpu width:width height:height]autorelease];Pixels single=read(destination,gpu);[[intermediate metalTextureForDevice:gpu]replaceRegion:MTLRegionMake2D(0,0,width,height) mipmapLevel:0 withBytes:single.data() bytesPerRow:width*8];Pixels expected=render(run,renderer,intermediate,destination,gpu,layerTwo,@{},@"hsl-stack-second-reference");
doc=DYMutablePlist(empty.document);doc[@"layers"]=[NSMutableArray arrayWithObjects:first,second,nil];Pixels actual=renderTools(doc,defaults,nil,@"two-hsl-stack-render");run.record(@"two-hsl-stack-matches-independent-sequential-reference",difference(expected,actual).maximum<.003&&difference(actual,single).different>20,measure(difference(expected,actual)));
// A hard rectangle's exterior must match the bypassed tool and its interior
// must match the active tool; alpha cannot change on either side.
DYUniforms hu=defaults;hu.hslHueA.x=32;hu.skinProtection.x=0;Pixels unmasked=render(run,renderer,source,destination,gpu,hu,@{},@"mask-hsl-active-reference");DYUniforms off=hu;off.hslSectionEnabled=0;Pixels noHSL=render(run,renderer,source,destination,gpu,off,@{},@"mask-hsl-bypass-reference");
for(int kind=0;kind<6;kind++){@autoreleasepool{NSMutableDictionary *m=DYMutablePlist(DYNewMask(kind));DYMaskParameters params=DYMaskAtTime(m,kCMTimeZero);params.feather=0;params.width=.5;params.height=.5;params.angle=.21;if(kind==DYMaskLumaKey){params.inputBlack=.2;params.inputWhite=.8;}m[@"parameters"]=[NSData dataWithBytes:&params length:sizeof(params)];doc=DYMutablePlist(empty.document);doc[@"baseMasks"][@"hsl"]=[NSMutableArray arrayWithObject:m];Pixels pixels=renderTools(doc,hu,nil,[NSString stringWithFormat:@"mask-type-%d-gpu",kind]);BOOL finite=difference(pixels,pixels).nonfinite==0,alpha=YES;for(NSUInteger i=0;i<width*height;i++)alpha&=pixels[i*4+3]==input[i*4+3];run.record([NSString stringWithFormat:@"mask-type-%d-preserves-alpha-finite",kind],finite&&alpha);
DYMaskPath path=dyFlattenMask((const DYBezierNode*)[m[@"nodes"]bytes],[m[@"nodes"]length]/sizeof(DYBezierNode));params.imageAspect=float(width)/height;double worst=0;for(NSUInteger y=0;y<height;y++)for(NSUInteger x=0;x<width;x++){auto index=(y*width+x)*4;float a=input[index+3];if(!(a>0))continue;float3 code;auto encode=[](float v){return v<=.0031308f?v*12.92f:1.055f*powf(MAX(0.f,v),1/2.4f)-.055f;};for(int c=0;c<3;c++)code[c]=encode((float)(__fp16)((float)input[index+c]/a));float coverage=dyMaskOperator((x+.5f)/width,(y+.5f)/height,code,params,path);for(int c=0;c<3;c++){float before=encode((float)noHSL[index+c]/a),after=encode((float)unmasked[index+c]/a),mixed=before+(after-before)*coverage;float expected=(mixed<=.04045f?mixed/12.92f:powf(MAX(0.f,(mixed+.055f)/1.055f),2.4f))*a;worst=MAX(worst,fabs(expected-(float)pixels[index+c]));}}run.record([NSString stringWithFormat:@"mask-type-%d-independent-cpu-coverage",kind],worst<.004,@{@"maximumError":@(worst)});}}
mask=DYMutablePlist(DYNewMask(DYMaskRectangle));p=DYMaskAtTime(mask,kCMTimeZero);p.feather=0;p.width=p.height=.5;mask[@"parameters"]=[NSData dataWithBytes:&p length:sizeof(p)];doc=DYMutablePlist(empty.document);doc[@"baseMasks"][@"hsl"]=[NSMutableArray arrayWithObject:mask];actual=renderTools(doc,hu,nil,@"hsl-rectangle-isolated-render");BOOL region=YES;double maxRegion=0;for(NSUInteger y=0;y<height;y++)for(NSUInteger x=0;x<width;x++){BOOL inside=x>=width/4&&x<width*3/4&&y>=height/4&&y<height*3/4;for(int c=0;c<4;c++){auto index=(y*width+x)*4+c;double delta=fabs((float)actual[index]-(float)(inside?unmasked:noHSL)[index]);maxRegion=MAX(maxRegion,delta);region&=delta<.003;}}run.record(@"per-tool-mask-affects-only-own-region",region,@{@"maximumError":@(maxRegion)});
mask[@"enabled"]=@NO;actual=renderTools(doc,hu,nil,@"mask-eye-disabled-render");run.record(@"disabled-mask-restores-unmasked-tool",difference(actual,unmasked).maximum==0);
mask[@"enabled"]=@YES;p.width=p.height=4;mask[@"parameters"]=[NSData dataWithBytes:&p length:sizeof(p)];actual=renderTools(doc,hu,nil,@"all-one-mask-render");run.record(@"all-one-mask-preserves-native-operation",difference(actual,unmasked).maximum<.001);
p.strength=0;mask[@"parameters"]=[NSData dataWithBytes:&p length:sizeof(p)];actual=renderTools(doc,hu,nil,@"all-zero-mask-render");run.record(@"all-zero-mask-bypasses-only-own-tool",difference(actual,noHSL).maximum<.003,measure(difference(actual,noHSL)));
error=nil;NSURL *blocked=[NSURL fileURLWithPath:[runtime stringByAppendingPathComponent:@"masked-export-must-not-exist.cube"]];BOOL exported=[renderer exportLUT:blocked uniforms:hu paths:@{} spider:nil tools:doc error:&error];run.record(@"cube-export-refuses-spatial-mask-with-clear-error",!exported&&error&&![NSFileManager.defaultManager fileExistsAtPath:blocked.path]);
DYUniforms primary=defaults;primary.cm.exposure=.6;Pixels primaryFull=render(run,renderer,source,destination,gpu,primary,@{},@"primary-mask-full-reference");DYUniforms primaryOff=primary;primaryOff.primarySectionEnabled=0;Pixels primaryBypass=render(run,renderer,source,destination,gpu,primaryOff,@{},@"primary-mask-bypass-reference");mask=DYMutablePlist(DYNewMask(DYMaskRectangle));p=DYMaskAtTime(mask,kCMTimeZero);p.feather=0;p.width=p.height=.5;mask[@"parameters"]=[NSData dataWithBytes:&p length:sizeof(p)];doc=DYMutablePlist(empty.document);doc[@"baseMasks"][@"primary"]=[NSMutableArray arrayWithObject:mask];actual=renderTools(doc,primary,nil,@"primary-cst-mask-render");BOOL primaryRegion=YES;for(NSUInteger y=0;y<height;y++)for(NSUInteger x=0;x<width;x++)for(int c=0;c<4;c++){BOOL inside=x>=width/4&&x<width*3/4&&y>=height/4&&y<height*3/4;auto i=(y*width+x)*4+c;primaryRegion&=fabs((float)actual[i]-(float)(inside?primaryFull:primaryBypass)[i])<.003;}run.record(@"primary-mask-blends-cst-only-in-selected-region",primaryRegion);
DYWriteTools(manager,empty.document,kCMTimeZero);
}
+67
查看文件
@@ -0,0 +1,67 @@
#import <Metal/Metal.h>
namespace {
struct FlowOutput {float x,y,error,valid;};
struct PyramidInfo {int width[5],height[5],offset[5],levels;};
class MetalFlow final : public dy::FlowBackend {
id<MTLDevice> device_=nil;
id<MTLCommandQueue> queue_=nil;
id<MTLComputePipelineState> pyramid_=nil,flow_=nil;
id<MTLBuffer> frames_[2]={nil,nil},points_=nil,results_=nil;
PyramidInfo info_{};
int previous_=0;
bool finish(id<MTLCommandBuffer> b) {
[b commit];[b waitUntilCompleted];return b.status==MTLCommandBufferStatusCompleted;
}
void pyramid(id<MTLCommandBuffer> b,id<MTLBuffer> frame) {
for(int i=1;i<info_.levels;i++) {
id<MTLComputeCommandEncoder>e=[b computeCommandEncoder];[e setComputePipelineState:pyramid_];
[e setBuffer:frame offset:0 atIndex:0];[e setBytes:&info_ length:sizeof(info_) atIndex:1];[e setBytes:&i length:sizeof(i) atIndex:2];
[e dispatchThreads:MTLSizeMake(info_.width[i],info_.height[i],1) threadsPerThreadgroup:MTLSizeMake(16,8,1)];[e endEncoding];
}
}
public:
MetalFlow(NSURL* url,NSError** error) {
device_=MTLCreateSystemDefaultDevice();queue_=[device_ newCommandQueue];
id<MTLLibrary> l=[device_ newLibraryWithURL:url error:error];if(!l)return;
id<MTLFunction> p=[l newFunctionWithName:@"dyTrackPyramid"],f=[l newFunctionWithName:@"dyTrackFlow"];
pyramid_=[device_ newComputePipelineStateWithFunction:p error:error];flow_=[device_ newComputePipelineStateWithFunction:f error:error];[p release];[f release];[l release];
}
~MetalFlow(){for(int i=0;i<2;i++)[frames_[i] release];[points_ release];[results_ release];[pyramid_ release];[flow_ release];[queue_ release];[device_ release];}
bool ready()const{return device_&&queue_&&pyramid_&&flow_&&flow_.threadExecutionWidth==32;}
bool reset(const dy::GrayFrame& f) override {
if(!ready()||!f.valid())return false;
info_={};info_.levels=1;info_.width[0]=f.width;info_.height[0]=f.height;
int total=f.width*f.height;
while(info_.levels<5&&info_.width[info_.levels-1]>=80&&info_.height[info_.levels-1]>=80) {
int i=info_.levels++;info_.width[i]=info_.width[i-1]/2;info_.height[i]=info_.height[i-1]/2;
info_.offset[i]=total;total+=info_.width[i]*info_.height[i];
}
for(int i=0;i<2;i++){[frames_[i] release];frames_[i]=nil;}[points_ release];points_=nil;[results_ release];results_=nil;
for(int i=0;i<2;i++)frames_[i]=[device_ newBufferWithLength:total*sizeof(float) options:MTLResourceStorageModeShared];
points_=[device_ newBufferWithLength:180*sizeof(dy::FlowPoint) options:MTLResourceStorageModeShared];
results_=[device_ newBufferWithLength:180*sizeof(FlowOutput) options:MTLResourceStorageModeShared];
if(!frames_[0]||!frames_[1]||!points_||!results_)return false;
previous_=0;memcpy(frames_[0].contents,f.pixels.data(),f.pixels.size()*sizeof(float));
id<MTLCommandBuffer>b=[queue_ commandBuffer];pyramid(b,frames_[0]);return finish(b);
}
bool advance(const dy::GrayFrame& f,const std::vector<dy::FlowPoint>& points,std::vector<dy::FlowMatch>& matches) override {
if(!f.valid()||f.width!=info_.width[0]||f.height!=info_.height[0]||points.empty()||points.size()>180)return false;
int next=1-previous_;memcpy(frames_[next].contents,f.pixels.data(),f.pixels.size()*sizeof(float));
memcpy(points_.contents,points.data(),points.size()*sizeof(dy::FlowPoint));
id<MTLCommandBuffer>b=[queue_ commandBuffer];pyramid(b,frames_[next]);
id<MTLComputeCommandEncoder>e=[b computeCommandEncoder];[e setComputePipelineState:flow_];
[e setBuffer:frames_[previous_] offset:0 atIndex:0];[e setBuffer:frames_[next] offset:0 atIndex:1];
[e setBuffer:points_ offset:0 atIndex:2];[e setBuffer:results_ offset:0 atIndex:3];[e setBytes:&info_ length:sizeof(info_) atIndex:4];
[e dispatchThreads:MTLSizeMake(points.size()*32,1,1) threadsPerThreadgroup:MTLSizeMake(flow_.threadExecutionWidth,1,1)];[e endEncoding];
if(!finish(b))return false;auto*r=static_cast<const FlowOutput*>(results_.contents);
for(size_t i=0;i<points.size();i++)if(r[i].valid>0)matches.push_back({points[i],{r[i].x,r[i].y},r[i].error});
previous_=next;return true;
}
};
}
std::shared_ptr<dy::FlowBackend> DYToolCreateMetalFlow(NSURL* url,NSError** error) {
auto backend=std::make_shared<MetalFlow>(url,error);if(backend->ready())return backend;
if(error&&!*error)*error=[NSError errorWithDomain:@"com.dayu.color.tracking" code:1 userInfo:@{NSLocalizedDescriptionKey:@"Metal 跟踪引擎不可用"}];return {};
}
+4
查看文件
@@ -0,0 +1,4 @@
#pragma once
#include "MaskCore/DYMaskOperator.h"
struct DYToolMaskEntry {DYResolvedMask mask;int section,combine;};
struct DYToolMaskHeader {unsigned count;float offsetX,offsetY,scaleX,scaleY;int section,premultiplied;};
@@ -0,0 +1,7 @@
@class DYPlugIn;
static NSMapTable *DYToolCanvasSessions(void){static NSMapTable *map;static dispatch_once_t once;dispatch_once(&once,^{map=[[NSMapTable strongToWeakObjectsMapTable]retain];});return map;}
@interface DYPlugIn (ToolCanvas)
- (NSDictionary*)toolCanvasMaskAtTime:(CMTime)time;
- (void)toolCanvasEvent:(NSEventType)type point:(NSPoint)point part:(NSInteger)part modifiers:(FxModifierKeys)modifiers key:(unichar)key time:(CMTime)time;
- (BOOL)toolCanvasVisible;
@end
+16
查看文件
@@ -0,0 +1,16 @@
NSString *_toolSession,*_selectedToolNode,*_selectedToolMask;
NSTimer *_toolAnalysisTimer;
BOOL _toolCaptureEnabled,_toolCanvasHidden,_toolDrawingPen,_toolShowCoverage;
NSMutableDictionary *_toolCanvasDraft,*_toolCanvasOriginal;NSDictionary *_toolCanvasDocument;
NSPoint _toolDragStart;DYMaskParameters _toolDragParameters;NSInteger _toolDragPart;
dy::GrayFrame _toolSourceFrame,_trackingReferenceFrame;
CMTime _toolSourceTime,_trackingReferenceTime,_trackingFrameDuration,_trackingPreviousTime;
std::atomic_bool _trackingActive,_trackingFinishing,_trackingInFrame,_trackingCancelled;
BOOL _trackingBackward,_trackingBoth,_trackingSingle,_trackingFlip,_trackingDiscard;
uint64_t _trackingGeneration;double _trackingStarted;
NSString *_trackingNode,*_trackingMaskID,*_trackingMessage;
NSDictionary *_trackingFrozenMask;NSMutableDictionary *_trackingCandidate;
NSMutableArray *_trackingSamples;
DYMaskParameters _trackingSeed;
dy::Tracker _toolTracker;
NSMutableDictionary *_toolCaptureDevices;
+110
查看文件
@@ -0,0 +1,110 @@
- (void)initializeToolHost {
_toolCaptureDevices=[NSMutableDictionary new];_toolCanvasDocument=[[[[DYToolDocument alloc]init]autorelease].document copy];_toolSourceTime=kCMTimeInvalid;
NSNotificationCenter *n=NSNotificationCenter.defaultCenter;[n addObserver:self selector:@selector(toolCanvasSelection:) name:@"DYToolCanvasSelection" object:_apiManager];[n addObserver:self selector:@selector(toolTrackRequested:) name:@"DYToolTrack" object:_apiManager];
}
- (void)tearDownToolHost {
[_toolAnalysisTimer invalidate];[_toolAnalysisTimer release];@synchronized(DYToolCanvasSessions()){if(_toolSession)[DYToolCanvasSessions()removeObjectForKey:_toolSession];}
[_toolCanvasDocument release];[_toolSession release];[_selectedToolNode release];[_selectedToolMask release];[_toolCanvasDraft release];[_toolCanvasOriginal release];[_trackingNode release];[_trackingMaskID release];[_trackingFrozenMask release];[_trackingCandidate release];[_trackingSamples release];[_trackingMessage release];[_toolCaptureDevices release];
}
- (void)adoptToolCanvasDocument:(NSDictionary*)document {
if(!document)return;@synchronized(self){[_toolCanvasDocument release];_toolCanvasDocument=[document copy];if([self toolMask:_selectedToolMask node:_selectedToolNode document:document])return;NSString *node=nil,*maskID=nil;for(NSString *type in DYToolTypes())for(NSDictionary *mask in document[@"baseMasks"][type])if(!node&&[mask[@"enabled"]boolValue]){node=[@"base:" stringByAppendingString:type];maskID=mask[@"id"];}for(NSDictionary *layer in document[@"layers"])for(NSDictionary *mask in layer[@"masks"])if(!node&&[mask[@"enabled"]boolValue]){node=layer[@"id"];maskID=mask[@"id"];}[_selectedToolNode release];_selectedToolNode=[node copy];[_selectedToolMask release];_selectedToolMask=[maskID copy];}
}
- (void)scheduleToolCanvasRegistration {
_toolCaptureEnabled=YES;dispatch_async(dispatch_get_main_queue(),^{id<FxCustomParameterActionAPI_v4>a=[self->_apiManager apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)];if(!a)return;[a startAction:self];@try{if(!self->_toolSession){NSString *session=NSUUID.UUID.UUIDString;id<FxParameterSettingAPI_v6>s=[self->_apiManager apiForProtocol:@protocol(FxParameterSettingAPI_v6)];BOOL accepted=[s setStringParameterValue:session toParameter:DYCanvasSessionParameterID];os_log(OS_LOG_DEFAULT,"dayu_tool_canvas_registered accepted=%{public}d",(int)accepted);{self->_toolSession=[session copy];@synchronized(DYToolCanvasSessions()){[DYToolCanvasSessions()setObject:self forKey:session];}}}}@finally{[a endAction:self];}});
}
- (dy::GrayFrame)toolGrayFrame:(FxImageTile*)tile error:(NSError**)error {
@synchronized(_toolCaptureDevices){FxRect b=tile.tilePixelBounds,image=tile.imagePixelBounds;if(b.left!=image.left||b.right!=image.right||b.bottom!=image.bottom||b.top!=image.top)return {};
NSNumber *key=@(tile.deviceRegistryID);NSMutableDictionary *entry=_toolCaptureDevices[key];if(!entry){NSArray *devices=MTLCopyAllDevices();id<MTLDevice>d=nil;for(id<MTLDevice>candidate in devices)if(candidate.registryID==tile.deviceRegistryID)d=candidate;if(d){id<MTLLibrary>library=[d newLibraryWithURL:[[NSBundle bundleForClass:self.class]URLForResource:@"default" withExtension:@"metallib"]error:error];id<MTLFunction>function=[library newFunctionWithName:@"dyToolCapture"];id<MTLComputePipelineState>pipeline=function?[d newComputePipelineStateWithFunction:function error:error]:nil;id<MTLCommandQueue>queue=[d newCommandQueue];if(pipeline&&queue){entry=[NSMutableDictionary dictionaryWithDictionary:@{@"device":d,@"pipeline":pipeline,@"queue":queue}];_toolCaptureDevices[key]=entry;}[pipeline release];[queue release];[function release];[library release];}[devices release];if(!entry)return {};}
id<MTLTexture>texture=[tile metalTextureForDevice:entry[@"device"]];if(!texture)return {};unsigned width=(unsigned)MIN((NSUInteger)960,texture.width),height=(unsigned)MAX(16.,texture.height*width/(texture.width*MAX(.01,tile.pixelAspect)));if(width<16||height>4096)return {};
id<MTLBuffer>buffer=[entry[@"device"]newBufferWithLength:width*height*sizeof(float) options:MTLResourceStorageModeShared];if(!buffer)return {};vector_uint3 info={width,height,(unsigned)(tile.imageOrigin==kFxImageOrigin_BOTTOM_LEFT)};id<MTLCommandBuffer>commands=[entry[@"queue"]commandBuffer];id<MTLComputeCommandEncoder>encoder=[commands computeCommandEncoder];[encoder setComputePipelineState:entry[@"pipeline"]];[encoder setTexture:texture atIndex:0];[encoder setBuffer:buffer offset:0 atIndex:0];[encoder setBytes:&info length:sizeof(info) atIndex:1];[encoder dispatchThreads:MTLSizeMake(width,height,1) threadsPerThreadgroup:MTLSizeMake(16,16,1)];[encoder endEncoding];[commands commit];[commands waitUntilCompleted];dy::GrayFrame frame;if(commands.status==MTLCommandBufferStatusCompleted){frame={int(width),int(height),std::vector<float>(width*height)};memcpy(frame.pixels.data(),buffer.contents,width*height*sizeof(float));}[buffer release];return frame;
}
}
- (NSMutableDictionary*)toolMask:(NSString*)maskID node:(NSString*)nodeID document:(NSDictionary*)doc {for(NSMutableDictionary *m in DYMasksForTool(doc,nodeID))if([m[@"id"]isEqual:maskID])return m;return nil;}
- (void)toolStatus:(NSString*)message {
NSString *node=[[_trackingNode?:_selectedToolNode copy]autorelease];dispatch_async(dispatch_get_main_queue(),^{[NSNotificationCenter.defaultCenter postNotificationName:@"DYToolTrackingStatus" object:self->_apiManager userInfo:@{@"node":node?:@"",@"message":message?:@""}];});
}
- (void)toolCanvasSelection:(NSNotification*)notification {
NSString *node=notification.userInfo[@"node"],*mask=notification.userInfo[@"mask"];if(!node||!mask)return;NSDictionary *document=notification.userInfo[@"document"];if(document&&DYValidToolDocument(document)){DYToolDocument *immutable=[[[DYToolDocument alloc]init]autorelease];immutable.document=document;[self adoptToolCanvasDocument:immutable.document];}os_log(OS_LOG_DEFAULT,"dayu_tool_canvas_selected");
@synchronized(self){if(_trackingActive.load()&&(![_trackingNode isEqual:node]||![_trackingMaskID isEqual:mask])){_trackingCancelled.store(true);_trackingDiscard=YES;}[_selectedToolNode release];_selectedToolNode=[node copy];[_selectedToolMask release];_selectedToolMask=[mask copy];_toolCanvasHidden=[notification.userInfo[@"hidden"]boolValue];_toolDrawingPen=[notification.userInfo[@"draw"]boolValue];[_toolCanvasDraft release];_toolCanvasDraft=nil;[_toolCanvasOriginal release];_toolCanvasOriginal=nil;}
}
- (BOOL)toolCanvasVisible {@synchronized(self){return _selectedToolNode&&_selectedToolMask&&!_toolCanvasHidden;}}
- (NSDictionary*)toolCanvasMaskAtTime:(CMTime)time {
@synchronized(self){if(_toolCanvasHidden||!_selectedToolMask)return nil;NSDictionary *m=_toolCanvasDraft?:[self toolMask:_selectedToolMask node:_selectedToolNode document:_toolCanvasDocument];if(!m)return nil;DYMaskParameters p=DYMaskAtTime(m,time);return @{@"id":m[@"id"],@"parameters":[NSData dataWithBytes:&p length:sizeof(p)],@"nodes":m[@"nodes"]?:[NSData data],@"drawing":@(_toolDrawingPen),@"coverage":@(_toolShowCoverage)};}
}
- (void)toolTrackRequested:(NSNotification*)notification {
NSInteger direction=[notification.userInfo[@"direction"]integerValue];if(direction==9){_trackingCancelled.store(true);return;}if(_trackingActive.load()){[self toolStatus:@"请先取消当前跟踪"];return;}
id<FxCustomParameterActionAPI_v4>a=[_apiManager apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)];if(!a)return;[a startAction:self];@try{
id<FxAnalysisAPI>analysis=[_apiManager apiForProtocol:@protocol(FxAnalysisAPI)];FxAnalysisState state=[analysis analysisStateForEffect];if(!analysis||state==kFxAnalysisState_AnalysisRequested||state==kFxAnalysisState_AnalysisStarted){[self toolStatus:@"宿主未就绪,请等待当前分析结束"];return;}
CMTime time=a.currentTime;NSDictionary *doc=DYReadTools(_apiManager,time).document;NSDictionary *mask=[self toolMask:notification.userInfo[@"mask"] node:notification.userInfo[@"node"] document:doc];if(!mask||![mask[@"enabled"]boolValue]){[self toolStatus:@"请先选择当前工具的启用蒙版"];return;}DYMaskParameters seed=DYMaskAtTime(mask,time);if(seed.kind>DYMaskBezier||(seed.kind==DYMaskBezier&&[mask[@"nodes"]length]<3*sizeof(DYBezierNode))){[self toolStatus:@"跟踪需要矩形、椭圆或闭合钢笔区域"];return;}
@synchronized(self){if(!_toolSourceFrame.valid()||!CMTIME_IS_NUMERIC(_toolSourceTime)||CMTimeCompare(_toolSourceTime,time)!=0){[self toolStatus:@"请移动播放头至起点,等待当前画面完成后再开始跟踪"];return;}_trackingReferenceFrame=_toolSourceFrame;}
id<FxTimingAPI_v4>timing=[_apiManager apiForProtocol:@protocol(FxTimingAPI_v4)];NSUInteger numerator=[timing timelineFpsNumeratorForEffect:self],denominator=[timing timelineFpsDenominatorForEffect:self];_trackingFrameDuration=numerator&&denominator&&numerator<=INT32_MAX?CMTimeMake(denominator,(int32_t)numerator):kCMTimeInvalid;if(!CMTIME_IS_NUMERIC(_trackingFrameDuration)||_trackingFrameDuration.value<=0){[self toolStatus:@"宿主未提供精确帧长,跟踪未启动"];return;}
[_trackingNode release];_trackingNode=[notification.userInfo[@"node"]copy];[_trackingMaskID release];_trackingMaskID=[notification.userInfo[@"mask"]copy];[_trackingFrozenMask release];_trackingFrozenMask=[mask copy];[_trackingCandidate release];_trackingCandidate=[DYMutablePlist(mask)retain];[_trackingSamples release];_trackingSamples=[NSMutableArray new];[_trackingMessage release];_trackingMessage=nil;
_trackingReferenceTime=time;_trackingSeed=seed;_trackingBackward=direction<0;_trackingBoth=direction==0;_trackingSingle=std::abs((int)direction)==2;_trackingDiscard=NO;_trackingCancelled.store(false);_trackingFinishing.store(false);_trackingActive.store(true);++_trackingGeneration;_trackingStarted=NSProcessInfo.processInfo.systemUptime;
NSError *error=nil;BOOL started=_trackingBackward?[analysis startBackwardAnalysis:kFxAnalysisLocation_GPU error:&error]:[analysis startForwardAnalysis:kFxAnalysisLocation_GPU error:&error];if(!started){_trackingActive.store(false);[self toolStatus:error.localizedDescription?:@"宿主未启动逐帧分析"];return;}
[self toolStatus:@"正在读取宿主源帧并跟踪…"];if(!_toolAnalysisTimer)_toolAnalysisTimer=[[NSTimer scheduledTimerWithTimeInterval:.3 target:self selector:@selector(pollToolAnalysis:) userInfo:nil repeats:YES]retain];
}@finally{[a endAction:self];}
}
- (void)pollToolAnalysis:(NSTimer*)timer {
if(!_trackingActive.load()||_trackingFinishing.load()||_trackingInFrame.load())return;id<FxCustomParameterActionAPI_v4>a=[_apiManager apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)];if(!a)return;[a startAction:self];@try{id<FxAnalysisAPI>api=[_apiManager apiForProtocol:@protocol(FxAnalysisAPI)];FxAnalysisState state=[api analysisStateForEffect];if(state==kFxAnalysisState_AnalysisCompleted||state==kFxAnalysisState_AnalysisInterrupted||(state==kFxAnalysisState_NotAnalyzing&&NSProcessInfo.processInfo.systemUptime-_trackingStarted>2))[self cleanupAnalysis:nil];}@finally{[a endAction:self];}
}
- (BOOL)stopToolAnalysis:(NSString*)message error:(NSError**)error {
if(message){[_trackingMessage release];_trackingMessage=[message copy];if(error)*error=[NSError errorWithDomain:@"com.dayu.color.tracking" code:2 userInfo:@{NSLocalizedDescriptionKey:message}];}[self cleanupAnalysis:nil];return NO;
}
- (BOOL)desiredAnalysisTimeRange:(CMTimeRange*)out forInputWithTimeRange:(CMTimeRange)input error:(NSError**)error {
CMTime end=CMTimeRangeGetEnd(input),ref=_trackingReferenceTime,step=_trackingFrameDuration;if(!CMTIME_IS_NUMERIC(input.start)||!CMTIME_IS_NUMERIC(end)||!CMTIME_IS_NUMERIC(ref)||ref.epoch!=input.start.epoch||ref.epoch!=end.epoch||CMTimeCompare(ref,input.start)<0||CMTimeCompare(ref,end)>=0||!CMTIME_IS_NUMERIC(step)||step.value<=0)return [self stopToolAnalysis:@"跟踪起点或帧长无效" error:error];
CMTime lo=_trackingBackward?input.start:ref,hi=_trackingBackward?CMTimeAdd(ref,step):end;if(_trackingSingle){if(_trackingBackward){lo=CMTimeSubtract(ref,step);if(CMTimeCompare(lo,input.start)<0)lo=input.start;}else hi=CMTimeAdd(ref,CMTimeMultiply(step,2));}if(CMTimeCompare(hi,end)>0)hi=end;if(_trackingBackward&&CMTimeCompare(ref,input.start)==0)return [self stopToolAnalysis:@"已到片段边界,未产生新轨迹" error:error];*out=CMTimeRangeFromTimeToTime(lo,hi);return out->duration.value>0;
}
- (BOOL)setupAnalysisForTimeRange:(CMTimeRange)range frameDuration:(CMTime)duration error:(NSError**)error {
if(!CMTIME_IS_NUMERIC(duration)||duration.value<=0||duration.epoch!=0)return [self stopToolAnalysis:@"宿主分析帧长无效" error:error];_trackingFrameDuration=duration;_trackingPreviousTime=kCMTimeInvalid;_trackingFlip=NO;[_trackingSamples removeAllObjects];auto backend=DYToolCreateMetalFlow([[NSBundle bundleForClass:self.class]URLForResource:@"default" withExtension:@"metallib"],error);if(!backend)return [self stopToolAnalysis:@"Metal 跟踪后端无法启动" error:error];_toolTracker.setBackend(backend);
std::vector<dy::FlowPoint>polygon;NSData *nodes=_trackingCandidate[@"nodes"];if(_trackingSeed.kind==DYMaskBezier){auto path=dyFlattenMask((const DYBezierNode*)nodes.bytes,nodes.length/sizeof(DYBezierNode));for(int i=0;i<path.count;i++)polygon.push_back({path.x[i],path.y[i]});}else if(_trackingSeed.kind==DYMaskRectangle)polygon={{-.5f,-.5f},{.5f,-.5f},{.5f,.5f},{-.5f,.5f}};else for(int i=0;i<128;i++){float angle=i*(2.f*M_PI/128);polygon.push_back({.5f*std::cos(angle),.5f*std::sin(angle)});}_toolTracker.setMask(std::move(polygon));return YES;
}
- (BOOL)analyzeFrame:(FxImageTile*)tile atTime:(CMTime)time error:(NSError**)error {
if(!_trackingActive.load()||_trackingFinishing.load())return NO;_trackingInFrame.store(true);@try{
if(_trackingCancelled.load())return [self stopToolAnalysis:@"已取消;保留最后连续可信轨迹" error:nil];if(_trackingSingle&&_trackingSamples.count>=2)return [self stopToolAnalysis:nil error:nil];if(_trackingSamples.count>=DYToolKeyLimit)return [self stopToolAnalysis:@"轨迹已到数量上限,保留已完成部分" error:error];
CMTime expected=CMTIME_IS_NUMERIC(_trackingPreviousTime)?(_trackingBackward?CMTimeSubtract(_trackingPreviousTime,_trackingFrameDuration):CMTimeAdd(_trackingPreviousTime,_trackingFrameDuration)):_trackingReferenceTime;if(!CMTIME_IS_NUMERIC(time)||time.epoch!=expected.epoch||CMTimeCompare(time,expected)!=0)return [self stopToolAnalysis:@"宿主帧序列不连续,停在最后可信帧" error:error];
dy::GrayFrame frame=[self toolGrayFrame:tile error:error];if(!frame.valid()||frame.width!=_trackingReferenceFrame.width||frame.height!=_trackingReferenceFrame.height)return [self stopToolAnalysis:@"宿主未返回完整源画面" error:error];
if(!_trackingSamples.count){double same=0,flip=0;size_t count=0;for(int y=0;y<frame.height;y+=8)for(int x=0;x<frame.width;x+=8){float p=frame.pixels[y*frame.width+x];same+=fabs(p-_trackingReferenceFrame.pixels[y*frame.width+x]);flip+=fabs(p-_trackingReferenceFrame.pixels[(frame.height-1-y)*frame.width+x]);count++;}same/=MAX(size_t(1),count);flip/=MAX(size_t(1),count);BOOL direct=same<.035&&((same+.008<flip&&same<flip*.8)||flip<.008),reversed=flip<.035&&flip+.008<same&&flip<same*.8;if(!direct&&!reversed)return [self stopToolAnalysis:@"参考画面与分析帧不一致,请重新选择清晰起点" error:error];_trackingFlip=reversed;}
if(_trackingFlip)for(int y=0;y<frame.height/2;y++)for(int x=0;x<frame.width;x++)std::swap(frame.pixels[y*frame.width+x],frame.pixels[(frame.height-1-y)*frame.width+x]);
if(!_trackingSamples.count){if(!_toolTracker.reset(frame,{_trackingSeed.centerX,_trackingSeed.centerY,_trackingSeed.width,_trackingSeed.height,_trackingSeed.angle}))return [self stopToolAnalysis:@"蒙版内纹理不足,未生成不可靠轨迹" error:error];}else if(!_toolTracker.track(frame).valid)return [self stopToolAnalysis:@"失去可靠跟踪,保留最后可信帧" error:error];
auto result=_toolTracker.result();DYMaskParameters p=DYMaskAtTime(_trackingFrozenMask,time);p.centerX=result.cx;p.centerY=result.cy;p.width=_trackingSeed.width*result.scaleX;p.height=_trackingSeed.height*result.scaleY;p.angle=_trackingSeed.angle+result.rotation;if(!dyValidMaskParameters(p))return [self stopToolAnalysis:@"跟踪变换无效,未写入错误结果" error:error];[_trackingSamples addObject:DYMaskKey(time,p,NO,result.confidence)];_trackingPreviousTime=time;
if(_trackingSamples.count%15==0)[self toolStatus:[NSString stringWithFormat:@"已分析 %lu 帧 · 置信度 %.0f%%",(unsigned long)_trackingSamples.count,result.confidence*100]];return YES;
}@finally{_trackingInFrame.store(false);}
}
- (BOOL)cleanupAnalysis:(NSError**)error {
if(!_trackingActive.load()||_trackingFinishing.exchange(true))return YES;BOOL changed=_trackingSamples.count>1;if(changed&&!DYMergeTracking(_trackingCandidate,_trackingSamples)){[_trackingMessage release];_trackingMessage=[@"轨迹合并失败,原蒙版已保留" copy];_trackingDiscard=YES;}
uint64_t generation=_trackingGeneration;BOOL second=_trackingBoth&&!_trackingBackward&&!_trackingCancelled.load()&&!_trackingDiscard;
dispatch_async(dispatch_get_main_queue(),^{if(self->_trackingGeneration!=generation)return;
if(second){self->_trackingBackward=YES;self->_trackingFinishing.store(false);self->_trackingStarted=NSProcessInfo.processInfo.systemUptime;id<FxCustomParameterActionAPI_v4>a=[self->_apiManager apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)];BOOL started=NO;if(a){[a startAction:self];@try{started=[[self->_apiManager apiForProtocol:@protocol(FxAnalysisAPI)]startBackwardAnalysis:kFxAnalysisLocation_GPU error:nil];}@finally{[a endAction:self];}}if(started){[self toolStatus:@"正向完成,正在从同一起点反向跟踪…"];return;}self->_trackingFinishing.store(true);}
BOOL hasResults=![self->_trackingCandidate[@"keys"]isEqual:self->_trackingFrozenMask[@"keys"]];NSString *message=self->_trackingMessage?:[NSString stringWithFormat:@"%@跟踪完成 · %lu 个轨迹键",self->_trackingBoth?@"双向":(self->_trackingBackward?@"反向":@"正向"),(unsigned long)[self->_trackingCandidate[@"keys"]count]];
if(hasResults&&!self->_trackingDiscard){id<FxCustomParameterActionAPI_v4>a=[self->_apiManager apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)];if(a){[a startAction:self];@try{NSMutableDictionary *doc=DYMutablePlist(DYReadTools(self->_apiManager,a.currentTime).document);NSMutableDictionary *mask=[self toolMask:self->_trackingMaskID node:self->_trackingNode document:doc];if(mask&&[mask isEqual:self->_trackingFrozenMask]){self->_trackingCandidate[@"status"]=message;[mask setDictionary:self->_trackingCandidate];id<FxUndoAPI>undo=[self->_apiManager apiForProtocol:@protocol(FxUndoAPI)];[undo startUndoGroup:@"蒙版区域跟踪"];BOOL written=DYWriteTools(self->_apiManager,doc,a.currentTime);[undo endUndoGroup];if(!written)message=@"宿主未接受轨迹,原蒙版已保留";}else message=@"目标工具或蒙版已更改,已丢弃过期跟踪结果";}@finally{[a endAction:self];}}}
CMTime stepTime=self->_trackingPreviousTime;BOOL advance=self->_trackingSingle&&hasResults&&!self->_trackingDiscard&&!self->_trackingCancelled.load()&&CMTIME_IS_NUMERIC(stepTime);
self->_trackingActive.store(false);if(advance){id<FxCustomParameterActionAPI_v4>seek=[self->_apiManager apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)];if(seek){[seek startAction:self];@try{id<FxCommandAPI_v2>command=[self->_apiManager apiForProtocol:@protocol(FxCommandAPI_v2)];[command movePlayheadToTime:stepTime error:nil];}@finally{[seek endAction:self];}}}[self->_toolAnalysisTimer invalidate];[self->_toolAnalysisTimer release];self->_toolAnalysisTimer=nil;[self toolStatus:message];[NSNotificationCenter.defaultCenter postNotificationName:DYModelChanged object:self->_apiManager];
});return YES;
}
- (void)toolCanvasEvent:(NSEventType)type point:(NSPoint)point part:(NSInteger)part modifiers:(FxModifierKeys)modifiers key:(unichar)key time:(CMTime)time {
// Host OSC callbacks hold model/render locks; editing happens after they unwind.
NSString *node=nil,*maskID=nil;@synchronized(self){node=[_selectedToolNode copy];maskID=[_selectedToolMask copy];}
dispatch_async(dispatch_get_main_queue(),^{if(self->_trackingActive.load()||![node isEqual:self->_selectedToolNode]||![maskID isEqual:self->_selectedToolMask])return;
if(type==NSEventTypeKeyDown&&key==27){@synchronized(self){[self->_toolCanvasDraft release];self->_toolCanvasDraft=nil;[self->_toolCanvasOriginal release];self->_toolCanvasOriginal=nil;self->_toolDrawingPen=NO;}return;}
if(part>=10000&&type==NSEventTypeLeftMouseDown){NSInteger item=part-10000;if(item==7){self->_toolShowCoverage=!self->_toolShowCoverage;return;}if(item==8){self->_toolCanvasHidden=YES;return;}if(item==0){self->_toolDrawingPen=NO;return;}
id<FxCustomParameterActionAPI_v4>a=[self->_apiManager apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)];if(!a)return;[a startAction:self];@try{NSMutableDictionary *doc=DYMutablePlist(DYReadTools(self->_apiManager,time).document);NSMutableArray *masks=[[DYMasksForTool(doc,node)mutableCopy]autorelease];if(masks.count>=DYToolMaskLimit)return;NSInteger kind=((int[]){0,2,1,0,3,4,5})[MIN(6,item)];NSDictionary *m=DYNewMask(kind);[masks addObject:m];if(!DYSetToolMasks(doc,node,masks))return;id<FxUndoAPI>u=[self->_apiManager apiForProtocol:@protocol(FxUndoAPI)];[u startUndoGroup:@"添加工具蒙版"];DYWriteTools(self->_apiManager,doc,time);[u endUndoGroup];[self->_selectedToolMask release];self->_selectedToolMask=[m[@"id"]copy];self->_toolDrawingPen=kind==2;[NSNotificationCenter.defaultCenter postNotificationName:@"DYToolCanvasSelection" object:self->_apiManager userInfo:@{@"node":node,@"mask":m[@"id"],@"draw":@(kind==2),@"document":doc}];}@finally{[a endAction:self];}[NSNotificationCenter.defaultCenter postNotificationName:DYModelChanged object:self->_apiManager];return;
}
BOOL commit=NO;
if(type==NSEventTypeLeftMouseDown){id<FxCustomParameterActionAPI_v4>a=[self->_apiManager apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)];if(!a)return;[a startAction:self];@try{NSDictionary *m=[self toolMask:maskID node:node document:DYReadTools(self->_apiManager,time).document];if(!m)return;@synchronized(self){if(!self->_toolCanvasDraft){self->_toolCanvasOriginal=[DYMutablePlist(m)retain];self->_toolCanvasDraft=[DYMutablePlist(m)retain];self->_toolDragParameters=DYMaskAtTime(m,time);self->_toolDragParameters.imageAspect=self->_toolSourceFrame.valid()?float(self->_toolSourceFrame.width)/self->_toolSourceFrame.height:1;self->_toolCanvasDraft[@"parameters"]=[NSData dataWithBytes:&self->_toolDragParameters length:sizeof(DYMaskParameters)];self->_toolCanvasDraft[@"keys"]=@[];if(self->_toolDrawingPen)self->_toolCanvasDraft[@"nodes"]=[NSData data];}self->_toolDragStart=point;self->_toolDragPart=part;self->_toolDragParameters=DYMaskAtTime(self->_toolCanvasDraft,time);
if(self->_toolDrawingPen){DYMaskParameters p=self->_toolDragParameters;float aspect=p.imageAspect;float dx=(point.x-p.centerX)*aspect,dy=point.y-p.centerY,c=cos(p.angle),s=sin(p.angle),x=(dx*c+dy*s)/(p.width*aspect),y=(-dx*s+dy*c)/p.height;DYBezierNode n={x,y,x,y,x,y};NSMutableData *nodes=[[self->_toolCanvasDraft[@"nodes"]mutableCopy]autorelease];if(nodes.length<32*sizeof(n))[nodes appendBytes:&n length:sizeof(n)];self->_toolCanvasDraft[@"nodes"]=nodes;}}
}@finally{[a endAction:self];}return;
}
if(!self->_toolCanvasDraft)return;
if(type==NSEventTypeLeftMouseDragged){@synchronized(self){DYMaskParameters p=self->_toolDragParameters;float dx=point.x-self->_toolDragStart.x,dy=point.y-self->_toolDragStart.y;
if(self->_toolDrawingPen){NSMutableData *nodes=[[self->_toolCanvasDraft[@"nodes"]mutableCopy]autorelease];if(nodes.length){auto *n=(DYBezierNode*)nodes.mutableBytes;NSUInteger last=nodes.length/sizeof(DYBezierNode)-1;float a=p.imageAspect,c=cos(p.angle),s=sin(p.angle),lx=((point.x-p.centerX)*a*c+(point.y-p.centerY)*s)/(p.width*a),ly=(-(point.x-p.centerX)*a*s+(point.y-p.centerY)*c)/p.height;n[last].outX=lx;n[last].outY=ly;n[last].inX=2*n[last].x-lx;n[last].inY=2*n[last].y-ly;self->_toolCanvasDraft[@"nodes"]=nodes;}}
else if(self->_toolDragPart>=1000){NSMutableData *nodes=[[self->_toolCanvasDraft[@"nodes"]mutableCopy]autorelease];NSUInteger index=(self->_toolDragPart-1000)/3,handle=(self->_toolDragPart-1000)%3;if(index<nodes.length/sizeof(DYBezierNode)){auto *n=(DYBezierNode*)nodes.mutableBytes;float a=p.imageAspect,c=cos(p.angle),s=sin(p.angle),lx=((point.x-p.centerX)*a*c+(point.y-p.centerY)*s)/(p.width*a),ly=(-(point.x-p.centerX)*a*s+(point.y-p.centerY)*c)/p.height;if(handle==0){float mx=lx-n[index].x,my=ly-n[index].y;n[index].x=lx;n[index].y=ly;n[index].inX+=mx;n[index].inY+=my;n[index].outX+=mx;n[index].outY+=my;}else if(handle==1){n[index].inX=lx;n[index].inY=ly;}else{n[index].outX=lx;n[index].outY=ly;}self->_toolCanvasDraft[@"nodes"]=nodes;}}
else if(self->_toolDragPart==6){p.angle=atan2((point.y-p.centerY),(point.x-p.centerX)*p.imageAspect)+M_PI/2;}
else if(self->_toolDragPart>=2&&self->_toolDragPart<=5){float a=p.imageAspect,c=cos(p.angle),s=sin(p.angle),x=(point.x-p.centerX)*a,y=point.y-p.centerY;p.width=MAX(.001f,2*fabs(x*c+y*s)/a);p.height=MAX(.001f,2*fabs(-x*s+y*c));}
else {p.centerX+=dx;p.centerY+=dy;}if(dyValidMaskParameters(p))self->_toolCanvasDraft[@"parameters"]=[NSData dataWithBytes:&p length:sizeof(p)];}return;
}
if(type==NSEventTypeLeftMouseUp&&!self->_toolDrawingPen)commit=YES;
if(type==NSEventTypeKeyDown&&(key==13||key==10)&&self->_toolDrawingPen){if([self->_toolCanvasDraft[@"nodes"]length]<3*sizeof(DYBezierNode))return;self->_toolDrawingPen=NO;commit=YES;}
if(commit){id<FxCustomParameterActionAPI_v4>a=[self->_apiManager apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)];if(!a)return;[a startAction:self];@try{NSMutableDictionary *doc=DYMutablePlist(DYReadTools(self->_apiManager,time).document);NSMutableDictionary *current=[self toolMask:maskID node:node document:doc];if(current&&[current isEqual:self->_toolCanvasOriginal]){NSMutableDictionary *draft=DYMutablePlist(self->_toolCanvasDraft);if([current[@"keys"]count]){DYMaskParameters p=DYMaskAtTime(draft,time);NSMutableArray *keys=[[current[@"keys"]mutableCopy]autorelease];NSIndexSet *same=[keys indexesOfObjectsPassingTest:^BOOL(NSDictionary *k,NSUInteger i,BOOL *stop){return CMTimeCompare(CMTimeMakeWithEpoch([k[@"value"]longLongValue],[k[@"scale"]intValue],[k[@"epoch"]longLongValue]),time)==0;}];[keys removeObjectsAtIndexes:same];[keys addObject:DYMaskKey(time,p,YES,1)];draft[@"keys"]=@[];DYMergeTracking(draft,keys);}if(DYValidToolMask(draft)&&![current isEqual:draft]){[current setDictionary:draft];id<FxUndoAPI>undo=[self->_apiManager apiForProtocol:@protocol(FxUndoAPI)];[undo startUndoGroup:@"编辑工具蒙版"];DYWriteTools(self->_apiManager,doc,time);[undo endUndoGroup];}}}@finally{[a endAction:self];}@synchronized(self){[self->_toolCanvasDraft release];self->_toolCanvasDraft=nil;[self->_toolCanvasOriginal release];self->_toolCanvasOriginal=nil;}[NSNotificationCenter.defaultCenter postNotificationName:DYModelChanged object:self->_apiManager];}
});[node release];[maskID release];
}
+19
查看文件
@@ -0,0 +1,19 @@
- (void)synchronizeTools {
id<FxCustomParameterActionAPI_v4>a=[self actionAPI];if(!a)return;[a startAction:self];NSArray *layers=nil;@try{layers=[DYReadTools(_manager,a.currentTime).document[@"layers"]copy];}@finally{[a endAction:self];}
NSMutableArray *order=[NSMutableArray array];NSMutableDictionary *numbers=[NSMutableDictionary dictionary];
for(NSDictionary *node in layers){NSString *ID=node[@"id"],*type=node[@"type"];[order addObject:ID];NSInteger number=MAX(1,[numbers[type]integerValue])+1;numbers[type]=@(number);
DYInspector *view=_stackViews[ID];if(!view){DYToolManager *manager=[[[DYToolManager alloc]initWithHost:_manager node:node]autorelease];view=[[[DYInspector alloc]initWithAPIManager:manager renderer:_renderer]autorelease];_stackViews[ID]=view;[_document addSubview:view];}
if(view->_cards.count){NSDictionary *section=view->_cards[0][@"section"];[view->_cards[0][@"header"]setTitle:[NSString stringWithFormat:@"%@ %ld",section[@"title"],(long)number]];}
[view refresh];[view setNeedsLayout:YES];
}
for(NSString *ID in [[_stackViews.allKeys copy]autorelease])if(![order containsObject:ID]){[_stackViews[ID]removeFromSuperview];[_stackViews removeObjectForKey:ID];}
[_stackOrder release];_stackOrder=[order copy];[layers release];[self setNeedsLayout:YES];
}
- (void)toolMask:(NSButton*)sender{if(sender.tag<0||sender.tag>=_cards.count)return;[(DYToolMaskPanel*)_cards[sender.tag][@"maskPanel"]addMenu:sender];}
- (void)repeatTool:(NSButton*)sender{
if(sender.tag<0||sender.tag>=_cards.count)return;id<PROAPIAccessing>host=_embedded?[(DYToolManager*)_manager host]:_manager;id<FxCustomParameterActionAPI_v4>a=[host apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)];if(!a)return;[a startAction:self];
@try{NSMutableDictionary *doc=DYMutablePlist(DYReadTools(host,a.currentTime).document);NSMutableArray *layers=doc[@"layers"];if(layers.count>=DYToolLimit){[self showError:@"最多可添加 32 个独立工具层。"];return;}NSDictionary *node=DYNewTool(_cards[sender.tag][@"section"][@"key"]);if(!node)return;[layers addObject:node];id<FxUndoAPI>undo=[host apiForProtocol:@protocol(FxUndoAPI)];[undo startUndoGroup:@"再加一层初始化工具"];DYWriteTools(host,doc,a.currentTime);[undo endUndoGroup];}@finally{[a endAction:self];}[NSNotificationCenter.defaultCenter postNotificationName:DYModelChanged object:host userInfo:@{@"scrollToNewTool":@YES}];
}
- (void)removeTool:(id)sender{if(!_embedded)return;id<PROAPIAccessing>host=[(DYToolManager*)_manager host];id<FxCustomParameterActionAPI_v4>a=[host apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)];if(!a)return;[a startAction:self];@try{NSMutableDictionary *doc=DYMutablePlist(DYReadTools(host,a.currentTime).document);NSMutableArray *layers=doc[@"layers"];NSDictionary *node=DYToolWithID(doc,[(DYToolManager*)_manager nodeID]);if(!node)return;[layers removeObject:node];id<FxUndoAPI>undo=[host apiForProtocol:@protocol(FxUndoAPI)];[undo startUndoGroup:@"删除独立工具层"];DYWriteTools(host,doc,a.currentTime);[undo endUndoGroup];}@finally{[a endAction:self];}dispatch_async(dispatch_get_main_queue(),^{[NSNotificationCenter.defaultCenter postNotificationName:DYModelChanged object:host];});}
- (void)resetRepeatedTool{if(!_embedded)return;id<PROAPIAccessing>host=[(DYToolManager*)_manager host];id<FxCustomParameterActionAPI_v4>a=[host apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)];if(!a)return;[a startAction:self];@try{NSMutableDictionary *doc=DYMutablePlist(DYReadTools(host,a.currentTime).document);NSMutableDictionary *node=(id)DYToolWithID(doc,[(DYToolManager*)_manager nodeID]);if(!node)return;NSDictionary *fresh=DYNewTool(node[@"type"]);node[@"values"]=fresh[@"values"];node[@"paths"]=@{};[node removeObjectForKey:@"spider"];node[@"spiderLinked"]=@YES;id<FxUndoAPI>undo=[host apiForProtocol:@protocol(FxUndoAPI)];[undo startUndoGroup:@"还原独立工具层"];DYWriteTools(host,doc,a.currentTime);[undo endUndoGroup];}@finally{[a endAction:self];}[self postChanged];}
+56
查看文件
@@ -0,0 +1,56 @@
// Host-provided canvas coordinates, normalized to the actual object transform.
@interface DYToolOSC : NSObject<FxOnScreenControl_v4>
@property(nonatomic,assign) id<PROAPIAccessing> apiManager;
@end
@implementation DYToolOSC {
id<MTLDevice> _device;id<MTLCommandQueue> _queue;CIContext *_context;
CGFloat _height;NSRect _imageRect;NSDictionary *_mask;NSMutableArray *_handles;NSBezierPath *_outline;NSInteger _lastRoute;NSUInteger _drawCount,_hitDiagnostics,_eventDiagnostics;
}
- (instancetype)initWithAPIManager:(id<PROAPIAccessing>)manager{if((self=[super init])){_apiManager=manager;_handles=[NSMutableArray new];_lastRoute=-1;os_log(OS_LOG_DEFAULT,"dayu_tool_osc_init");}return self;}
- (void)dealloc{[_device release];[_queue release];[_context release];[_mask release];[_handles release];[_outline release];[super dealloc];}
- (FxDrawingCoordinates)drawingCoordinates{return kFxDrawingCoordinates_CANVAS;}
- (DYPlugIn*)pluginAtTime:(CMTime)time{NSString *value=nil;id<FxParameterRetrievalAPI_v6>get=[_apiManager apiForProtocol:@protocol(FxParameterRetrievalAPI_v6)];[get getStringParameterValue:&value fromParameter:DYCanvasSessionParameterID];@synchronized(DYToolCanvasSessions()){return [DYToolCanvasSessions()objectForKey:value];}}
- (NSPoint)canvasPoint:(float)x y:(float)y parameters:(DYMaskParameters)p{
float ca=cos(p.angle),sa=sin(p.angle),aspect=p.imageAspect;float px=x*p.width*aspect,py=y*p.height;float u=p.centerX+(px*ca-py*sa)/aspect,v=p.centerY+px*sa+py*ca;return NSMakePoint(_imageRect.origin.x+u*_imageRect.size.width,_imageRect.origin.y+v*_imageRect.size.height);
}
- (void)addHandle:(NSPoint)p part:(NSInteger)part{[_handles addObject:@{@"point":[NSValue valueWithPoint:p],@"part":@(part)}];}
- (void)drawOSCWithWidth:(NSInteger)width height:(NSInteger)height activePart:(NSInteger)activePart destinationImage:(FxImageTile*)destination atTime:(CMTime)time {@autoreleasepool{
if(!_device||_device.registryID!=destination.deviceRegistryID){[_device release];_device=nil;NSArray *devices=MTLCopyAllDevices();for(id<MTLDevice>d in devices)if(d.registryID==destination.deviceRegistryID)_device=[d retain];[devices release];[_queue release];_queue=[_device newCommandQueue];[_context release];_context=_device?[[CIContext contextWithMTLDevice:_device options:@{kCIContextWorkingColorSpace:NSNull.null,kCIContextOutputColorSpace:NSNull.null}]retain]:nil;}
id<MTLTexture>texture=[destination metalTextureForDevice:_device];if(!texture||!_queue)return;id<MTLCommandBuffer>commands=[_queue commandBuffer];MTLRenderPassDescriptor *pass=[MTLRenderPassDescriptor renderPassDescriptor];pass.colorAttachments[0].texture=texture;pass.colorAttachments[0].loadAction=MTLLoadActionClear;pass.colorAttachments[0].storeAction=MTLStoreActionStore;pass.colorAttachments[0].clearColor=MTLClearColorMake(0,0,0,0);id<MTLRenderCommandEncoder>encoder=[commands renderCommandEncoderWithDescriptor:pass];[encoder endEncoding];
_height=destination.imagePixelBounds.top-destination.imagePixelBounds.bottom;CGFloat canvasWidth=destination.imagePixelBounds.right-destination.imagePixelBounds.left;
id<FxOnScreenControlAPI_v4>api=[_apiManager apiForProtocol:@protocol(FxOnScreenControlAPI_v4)];double lx=0,ly=0,ux=0,uy=0;[api convertPointFromSpace:kFxDrawingCoordinates_OBJECT fromX:0 fromY:0 toSpace:kFxDrawingCoordinates_CANVAS toX:&lx toY:&ly];[api convertPointFromSpace:kFxDrawingCoordinates_OBJECT fromX:1 fromY:1 toSpace:kFxDrawingCoordinates_CANVAS toX:&ux toY:&uy];_imageRect=NSMakeRect(lx,_height-uy,ux-lx,uy-ly);
DYPlugIn *plugin=[self pluginAtTime:time];NSDictionary *mask=[plugin toolCanvasMaskAtTime:time];NSInteger route=(plugin?1:0)+(mask?2:0);if(route!=_lastRoute||_drawCount++<2){_lastRoute=route;os_log(OS_LOG_DEFAULT,"dayu_tool_osc_route plugin=%{public}d mask=%{public}d width=%{public}.2f height=%{public}.2f",plugin!=nil,mask!=nil,_imageRect.size.width,_imageRect.size.height);}[_mask release];_mask=[mask copy];[_handles removeAllObjects];[_outline release];_outline=nil;
if(mask&&canvasWidth>0&&_height>0&&canvasWidth<16384&&_height<16384&&_imageRect.size.width>0&&_imageRect.size.height>0){
NSBitmapImageRep *bitmap=[[[NSBitmapImageRep alloc]initWithBitmapDataPlanes:NULL pixelsWide:(NSInteger)canvasWidth pixelsHigh:(NSInteger)_height bitsPerSample:8 samplesPerPixel:4 hasAlpha:YES isPlanar:NO colorSpaceName:NSDeviceRGBColorSpace bytesPerRow:(NSInteger)canvasWidth*4 bitsPerPixel:32]autorelease];memset(bitmap.bitmapData,0,bitmap.bytesPerRow*bitmap.pixelsHigh);[NSGraphicsContext saveGraphicsState];[NSGraphicsContext setCurrentContext:[NSGraphicsContext graphicsContextWithBitmapImageRep:bitmap]];NSAffineTransform *flip=[NSAffineTransform transform];[flip translateXBy:0 yBy:_height];[flip scaleXBy:1 yBy:-1];[flip concat];
DYMaskParameters p;[mask[@"parameters"]getBytes:&p length:sizeof(p)];p.imageAspect=_imageRect.size.width/_imageRect.size.height;_outline=[[NSBezierPath bezierPath]retain];
if(p.kind==DYMaskBezier){NSData *data=mask[@"nodes"];auto *nodes=(const DYBezierNode*)data.bytes;NSUInteger count=data.length/sizeof(DYBezierNode);for(NSUInteger i=0;i<count;i++){NSPoint anchor=[self canvasPoint:nodes[i].x y:nodes[i].y parameters:p];if(i==0)[_outline moveToPoint:anchor];else{auto a=nodes[i-1],b=nodes[i];[_outline curveToPoint:anchor controlPoint1:[self canvasPoint:a.outX y:a.outY parameters:p] controlPoint2:[self canvasPoint:b.inX y:b.inY parameters:p]];}[self addHandle:anchor part:1000+i*3];for(int j=0;j<2;j++){NSPoint handle=[self canvasPoint:j?nodes[i].outX:nodes[i].inX y:j?nodes[i].outY:nodes[i].inY parameters:p];if(hypot(handle.x-anchor.x,handle.y-anchor.y)>3){NSBezierPath *line=[NSBezierPath bezierPath];[line moveToPoint:anchor];[line lineToPoint:handle];[[NSColor colorWithWhite:1 alpha:.55]setStroke];[line stroke];[self addHandle:handle part:1000+i*3+j+1];}}}
if(count>=3&&![mask[@"drawing"]boolValue]){auto a=nodes[count-1],b=nodes[0];[_outline curveToPoint:[self canvasPoint:b.x y:b.y parameters:p] controlPoint1:[self canvasPoint:a.outX y:a.outY parameters:p] controlPoint2:[self canvasPoint:b.inX y:b.inY parameters:p]];[_outline closePath];}
}else if(p.kind<2){int count=p.kind==DYMaskEllipse?96:4;for(int i=0;i<count;i++){float angle=i*(2.f*M_PI/count),x=p.kind==DYMaskEllipse?.5f*cosf(angle):((float[]){-.5,.5,.5,-.5})[i],y=p.kind==DYMaskEllipse?.5f*sinf(angle):((float[]){-.5,-.5,.5,.5})[i];NSPoint point=[self canvasPoint:x y:y parameters:p];if(i==0)[_outline moveToPoint:point];else[_outline lineToPoint:point];}[_outline closePath];}
else if(p.kind==DYMaskLinearGradient){[_outline moveToPoint:[self canvasPoint:0 y:-2 parameters:p]];[_outline lineToPoint:[self canvasPoint:0 y:2 parameters:p]];}
if([mask[@"coverage"]boolValue]&&p.kind<3){[[NSColor colorWithCalibratedRed:1 green:.7 blue:.05 alpha:.2]setFill];[_outline fill];}
[[NSColor colorWithWhite:0 alpha:.8]setStroke];_outline.lineWidth=3.5;[_outline stroke];[[NSColor colorWithCalibratedRed:1 green:.8 blue:.15 alpha:1]setStroke];_outline.lineWidth=1.5;[_outline stroke];
if(p.kind<4){[self addHandle:[self canvasPoint:0 y:0 parameters:p] part:1];if(p.kind!=DYMaskBezier){for(int i=0;i<4;i++)[self addHandle:[self canvasPoint:((float[]){-.5,.5,.5,-.5})[i] y:((float[]){-.5,-.5,.5,.5})[i] parameters:p] part:2+i];}[self addHandle:[self canvasPoint:0 y:-.68 parameters:p] part:6];}
for(NSDictionary *handle in _handles){NSPoint point=[handle[@"point"]pointValue];NSRect rect=NSMakeRect(point.x-4,point.y-4,8,8);[[NSColor colorWithWhite:.1 alpha:1]setFill];[[NSBezierPath bezierPathWithOvalInRect:rect]fill];[NSColor.whiteColor setStroke];[[NSBezierPath bezierPathWithOvalInRect:rect]stroke];}
NSArray *symbols=@[@"cursorarrow",@"point.topleft.down.to.point.bottomright.curvepath",@"rectangle",@"circle",@"line.diagonal",@"eyedropper",@"circle.lefthalf.filled",@"eye",@"xmark"];
CGFloat toolbarX=MAX(8,_imageRect.origin.x+12),toolbarY=MAX(8,_imageRect.origin.y+12);for(NSInteger i=0;i<symbols.count;i++){NSRect cell=NSMakeRect(toolbarX,toolbarY+i*39,32,34);[[NSColor colorWithWhite:.12 alpha:.9]setFill];[[NSBezierPath bezierPathWithRoundedRect:cell xRadius:5 yRadius:5]fill];NSImage *icon=[NSImage imageWithSystemSymbolName:symbols[i] accessibilityDescription:nil];icon=[icon imageWithSymbolConfiguration:[NSImageSymbolConfiguration configurationWithPaletteColors:@[NSColor.whiteColor]]];[icon drawInRect:NSInsetRect(cell,7,7) fromRect:NSZeroRect operation:NSCompositingOperationSourceOver fraction:1 respectFlipped:YES hints:nil];}
[NSGraphicsContext restoreGraphicsState];CIImage *overlay=[CIImage imageWithCGImage:bitmap.CGImage options:@{kCIImageColorSpace:NSNull.null}];overlay=[overlay imageByApplyingTransform:CGAffineTransformMakeTranslation(0,texture.height-_height)];[_context render:overlay toMTLTexture:texture commandBuffer:commands bounds:CGRectMake(0,0,texture.width,texture.height) colorSpace:nil];
}[commands commit];[commands waitUntilCompleted];
}}
- (NSInteger)partAtPoint:(NSPoint)point {
if(!_mask)return 0;CGFloat x=MAX(8,_imageRect.origin.x+12),y=MAX(8,_imageRect.origin.y+12);for(int i=0;i<9;i++)if(NSPointInRect(point,NSMakeRect(x,y+i*39,32,34)))return 10000+i;
for(NSDictionary *h in _handles){NSPoint p=[h[@"point"]pointValue];if(hypot(p.x-point.x,p.y-point.y)<=9)return [h[@"part"]integerValue];}
DYMaskParameters p;[_mask[@"parameters"]getBytes:&p length:sizeof(p)];if([_mask[@"drawing"]boolValue]||p.kind==DYMaskBezier||p.kind==DYMaskLinearGradient||[_outline containsPoint:point])return 1;return 0;
}
- (void)hitTestOSCAtMousePositionX:(double)x mousePositionY:(double)y activePart:(NSInteger*)part atTime:(CMTime)time{NSInteger hit=[self partAtPoint:NSMakePoint(x,_height-y)];if(part)*part=hit;if(_hitDiagnostics++<16)os_log(OS_LOG_DEFAULT,"dayu_tool_osc_hit x=%{public}.2f y=%{public}.2f height=%{public}.2f rect=%{public}.2f,%{public}.2f,%{public}.2f,%{public}.2f mask=%{public}d hit=%{public}ld",x,y,_height,_imageRect.origin.x,_imageRect.origin.y,_imageRect.size.width,_imageRect.size.height,_mask!=nil,(long)hit);}
- (BOOL)event:(NSEventType)type x:(double)x y:(double)y part:(NSInteger)part modifiers:(FxModifierKeys)modifiers key:(unichar)key time:(CMTime)time {
DYPlugIn *plugin=[self pluginAtTime:time];if(_eventDiagnostics++<12)os_log(OS_LOG_DEFAULT,"dayu_tool_osc_event type=%{public}ld part=%{public}ld x=%{public}.2f y=%{public}.2f plugin=%{public}d",(long)type,(long)part,x,y,plugin!=nil);if(!plugin||![plugin toolCanvasVisible]||_imageRect.size.width<=0||_imageRect.size.height<=0)return NO;NSPoint point=NSMakePoint((x-_imageRect.origin.x)/_imageRect.size.width,(_height-y-_imageRect.origin.y)/_imageRect.size.height);[plugin toolCanvasEvent:type point:point part:part modifiers:modifiers key:key time:time];return YES;
}
- (void)mouseDownAtPositionX:(double)x positionY:(double)y activePart:(NSInteger)part modifiers:(FxModifierKeys)m forceUpdate:(BOOL*)update atTime:(CMTime)t{if(update)*update=[self event:NSEventTypeLeftMouseDown x:x y:y part:part modifiers:m key:0 time:t];}
- (void)mouseDraggedAtPositionX:(double)x positionY:(double)y activePart:(NSInteger)part modifiers:(FxModifierKeys)m forceUpdate:(BOOL*)update atTime:(CMTime)t{if(update)*update=[self event:NSEventTypeLeftMouseDragged x:x y:y part:part modifiers:m key:0 time:t];}
- (void)mouseUpAtPositionX:(double)x positionY:(double)y activePart:(NSInteger)part modifiers:(FxModifierKeys)m forceUpdate:(BOOL*)update atTime:(CMTime)t{if(update)*update=[self event:NSEventTypeLeftMouseUp x:x y:y part:part modifiers:m key:0 time:t];}
- (void)keyDownAtPositionX:(double)x positionY:(double)y keyPressed:(unsigned short)key modifiers:(FxModifierKeys)m forceUpdate:(BOOL*)update didHandle:(BOOL*)handled atTime:(CMTime)t{BOOL result=(key==27||key==13||key==10)&&[self event:NSEventTypeKeyDown x:x y:y part:1 modifiers:m key:key time:t];if(update)*update=result;if(handled)*handled=result;}
- (void)mouseMovedAtPositionX:(double)x positionY:(double)y activePart:(NSInteger)part modifiers:(FxModifierKeys)m forceUpdate:(BOOL*)update atTime:(CMTime)t{[[_apiManager apiForProtocol:@protocol(FxOnScreenControlAPI_v4)]setCursor:part?NSCursor.crosshairCursor:NSCursor.arrowCursor];if(update)*update=NO;}
- (void)mouseEnteredAtPositionX:(double)x positionY:(double)y modifiers:(FxModifierKeys)m forceUpdate:(BOOL*)update atTime:(CMTime)t{if(update)*update=NO;}
- (void)mouseExitedAtPositionX:(double)x positionY:(double)y modifiers:(FxModifierKeys)m forceUpdate:(BOOL*)update atTime:(CMTime)t{if(update)*update=NO;}
- (void)keyUpAtPositionX:(double)x positionY:(double)y keyPressed:(unsigned short)key modifiers:(FxModifierKeys)m forceUpdate:(BOOL*)update didHandle:(BOOL*)handled atTime:(CMTime)t{if(update)*update=NO;if(handled)*handled=NO;}
@end
+45
查看文件
@@ -0,0 +1,45 @@
// Included in DYRenderer; all calls execute under its per-instance recursive lock.
- (id<MTLBuffer>)maskBuffer:(NSDictionary*)groups tile:(FxImageTile*)tile device:(id<MTLDevice>)device header:(DYToolMaskHeader*)h {
std::vector<DYToolMaskEntry> entries;FxRect image=tile.imagePixelBounds,bounds=tile.tilePixelBounds;
float w=image.right-image.left,ht=image.top-image.bottom;BOOL bottom=tile.imageOrigin==kFxImageOrigin_BOTTOM_LEFT;
h->offsetX=(bounds.left-image.left)/w;h->scaleX=(bounds.right-bounds.left)/w;
h->offsetY=bottom?(image.top-bounds.bottom)/ht:(image.top-bounds.top)/ht;h->scaleY=(bottom?-1:1)*(bounds.top-bounds.bottom)/ht;
h->premultiplied=1;
for(NSString *type in groups){NSInteger section=[DYToolTypes()indexOfObject:type];if(section==NSNotFound)continue;
for(NSDictionary *m in groups[type]){if(![m[@"enabled"]boolValue])continue;DYToolMaskEntry entry{};entry.section=(int)section;entry.combine=[m[@"combine"]intValue];[m[@"parameters"]getBytes:&entry.mask.parameters length:sizeof(DYMaskParameters)];entry.mask.parameters.imageAspect=w/ht;NSData *nodes=m[@"nodes"];entry.mask.path=dyFlattenMask((const DYBezierNode*)nodes.bytes,nodes.length/sizeof(DYBezierNode));entries.push_back(entry);}
}h->count=(unsigned)entries.size();if(entries.empty())entries.push_back({});return [[device newBufferWithBytes:entries.data() length:entries.size()*sizeof(DYToolMaskEntry) options:MTLResourceStorageModeShared]autorelease];
}
- (void)encodeBlend:(id<MTLTexture>)before after:(id<MTLTexture>)after output:(id<MTLTexture>)output masks:(id<MTLBuffer>)masks header:(DYToolMaskHeader)h entry:(NSDictionary*)entry commands:(id<MTLCommandBuffer>)commands {
id<MTLComputeCommandEncoder>encoder=[commands computeCommandEncoder];[encoder setComputePipelineState:entry[@"dyToolBlend"]];[encoder setTexture:before atIndex:0];[encoder setTexture:after atIndex:1];[encoder setTexture:output atIndex:2];[encoder setBuffer:masks offset:0 atIndex:0];[encoder setBytes:&h length:sizeof(h) atIndex:1];[encoder dispatchThreads:MTLSizeMake(output.width,output.height,1) threadsPerThreadgroup:MTLSizeMake(16,16,1)];[encoder endEncoding];
}
- (BOOL)copyTile:(FxImageTile*)source to:(FxImageTile*)dest entry:(NSMutableDictionary*)e error:(NSError**)error {
id<MTLDevice>device=e[@"device"];id<MTLTexture>a=[source metalTextureForDevice:device],b=[dest metalTextureForDevice:device];
NSMutableDictionary *pipelines=e[@"pipelines"];NSString *key=[NSString stringWithFormat:@"copy-%lu",(unsigned long)b.pixelFormat];id<MTLRenderPipelineState>pipeline=pipelines[key];
if(!pipeline){MTLRenderPipelineDescriptor *desc=[MTLRenderPipelineDescriptor new];desc.vertexFunction=[e[@"library"]newFunctionWithName:@"dyVertex"];desc.fragmentFunction=[e[@"library"]newFunctionWithName:@"dyToolCopyFragment"];desc.colorAttachments[0].pixelFormat=b.pixelFormat;pipeline=[device newRenderPipelineStateWithDescriptor:desc error:error];[desc.vertexFunction release];[desc.fragmentFunction release];[desc release];if(!pipeline)return NO;pipelines[key]=pipeline;[pipeline release];}
FxRect s=source.tilePixelBounds,t=dest.tilePixelBounds;float width=s.right-s.left,height=s.top-s.bottom,l=(t.left-s.left)/width,r=(t.right-s.left)/width,top=(s.top-t.top)/height,bottom=(s.top-t.bottom)/height;
if(source.imageOrigin==kFxImageOrigin_BOTTOM_LEFT){top=1-top;bottom=1-bottom;}
float w=b.width,h=b.height;DYVertex2D v[]={{{w/2,-h/2},{r,bottom}},{{-w/2,-h/2},{l,bottom}},{{w/2,h/2},{r,top}},{{-w/2,h/2},{l,top}}};if(dest.imageOrigin==kFxImageOrigin_BOTTOM_LEFT)for(auto &vertex:v)vertex.position.y=-vertex.position.y;
vector_uint2 size={(unsigned)b.width,(unsigned)b.height};id<MTLCommandBuffer>cb=[e[@"queue"]commandBuffer];MTLRenderPassDescriptor *pass=[MTLRenderPassDescriptor renderPassDescriptor];pass.colorAttachments[0].texture=b;pass.colorAttachments[0].loadAction=MTLLoadActionDontCare;pass.colorAttachments[0].storeAction=MTLStoreActionStore;id<MTLRenderCommandEncoder>encoder=[cb renderCommandEncoderWithDescriptor:pass];[encoder setRenderPipelineState:pipeline];[encoder setVertexBytes:v length:sizeof(v) atIndex:0];[encoder setVertexBytes:&size length:sizeof(size) atIndex:1];[encoder setFragmentTexture:a atIndex:0];[encoder drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4];[encoder endEncoding];[cb commit];[cb waitUntilCompleted];return cb.status==MTLCommandBufferStatusCompleted?YES:fail(error,cb.error.localizedDescription);
}
- (BOOL)renderSource:(FxImageTile*)src destination:(FxImageTile*)dst uniforms:(DYUniforms)u paths:(NSDictionary*)paths spider:(NSData*)spider tools:(NSDictionary*)tools error:(NSError**)error {@synchronized(self){@autoreleasepool{
if(!tools)return [self renderLegacy:src destination:dst uniforms:u paths:paths spider:spider masks:@{} error:error];if(!DYValidToolDocument(tools))return fail(error,@"工具或蒙版数据损坏,未更改原工程");
NSArray *layers=tools[@"layers"];BOOL active=NO;for(NSDictionary *n in layers)active|=!DYToolIsNeutral(n);
if(!active)return [self renderLegacy:src destination:dst uniforms:u paths:paths spider:spider masks:tools[@"baseMasks"] error:error];
NSMutableDictionary *entry=[self device:dst.deviceRegistryID error:error];if(!entry)return NO;id<MTLDevice>d=entry[@"device"];id<MTLTexture>input=[src metalTextureForDevice:d];
MTLTextureDescriptor *desc=[MTLTextureDescriptor texture2DDescriptorWithPixelFormat:MTLPixelFormatRGBA16Float width:input.width height:input.height mipmapped:NO];desc.storageMode=MTLStorageModePrivate;desc.usage=MTLTextureUsageRenderTarget|MTLTextureUsageShaderRead|MTLTextureUsageShaderWrite;
id<MTLTexture>current=[d newTextureWithDescriptor:desc];if(!current)return fail(error,@"无法分配工具图层缓冲区");DYExportTile *tile=[[DYExportTile alloc]initWithTexture:current registry:d.registryID];[tile setBounds:src.tilePixelBounds origin:src.imageOrigin];[tile setPixelAspect:src.pixelAspect];[current release];
@try{
if(![self renderLegacy:src destination:tile uniforms:u paths:paths spider:spider masks:tools[@"baseMasks"] error:error])return NO;
for(NSDictionary *node in layers){@autoreleasepool{if(DYToolIsNeutral(node))continue;DYUniforms layer=DYToolUniforms(node);NSString *type=node[@"type"];
id<MTLTexture>next=[d newTextureWithDescriptor:desc];if(!next)return fail(error,@"无法分配新增工具缓冲区");DYExportTile *nextTile=[[[DYExportTile alloc]initWithTexture:next registry:d.registryID]autorelease];[nextTile setBounds:src.tilePixelBounds origin:src.imageOrigin];[nextTile setPixelAspect:src.pixelAspect];[next release];
if([type isEqual:@"skin"]){id<MTLCommandBuffer>cb=[entry[@"queue"]commandBuffer];id<MTLComputeCommandEncoder>ce=[cb computeCommandEncoder];[ce setComputePipelineState:entry[@"dyToolSkin"]];[ce setTexture:[tile metalTextureForDevice:d] atIndex:0];[ce setTexture:input atIndex:1];[ce setTexture:[nextTile metalTextureForDevice:d] atIndex:2];[ce setBytes:&layer length:sizeof(layer) atIndex:0];[ce dispatchThreads:MTLSizeMake(input.width,input.height,1) threadsPerThreadgroup:MTLSizeMake(16,16,1)];[ce endEncoding];[cb commit];[cb waitUntilCompleted];if(cb.status!=MTLCommandBufferStatusCompleted)return fail(error,cb.error.localizedDescription);
if([node[@"masks"]count]){id<MTLTexture>blend=[d newTextureWithDescriptor:desc];DYToolMaskHeader h{};h.section=3;id<MTLBuffer>buffer=[self maskBuffer:@{type:node[@"masks"]} tile:tile device:d header:&h];cb=[entry[@"queue"]commandBuffer];[self encodeBlend:[tile metalTextureForDevice:d] after:[nextTile metalTextureForDevice:d] output:blend masks:buffer header:h entry:entry commands:cb];[cb commit];[cb waitUntilCompleted];DYExportTile *blended=[[[DYExportTile alloc]initWithTexture:blend registry:d.registryID]autorelease];[blended setBounds:src.tilePixelBounds origin:src.imageOrigin];[blended setPixelAspect:src.pixelAspect];[blend release];nextTile=blended;if(cb.status!=MTLCommandBufferStatusCompleted)return fail(error,cb.error.localizedDescription);}
}else if(![self renderLegacy:tile destination:nextTile uniforms:layer paths:node[@"paths"] spider:node[@"spider"] masks:@{type:node[@"masks"]} error:error])return NO;
[nextTile retain];[tile release];tile=nextTile;
}}return [self copyTile:tile to:dst entry:entry error:error];
}@finally{[tile release];}
}}}
- (BOOL)exportLUT:(NSURL*)url uniforms:(DYUniforms)u paths:(NSDictionary*)paths spider:(NSData*)spider tools:(NSDictionary*)tools error:(NSError**)error {@synchronized(self){
for(NSArray *masks in [tools[@"baseMasks"]allValues])if(masks.count)return fail(error,@"当前调色含空间蒙版或跟踪,Cube 无法保存这些信息。请先保存完整预设,或移除蒙版后导出。");for(NSDictionary *node in tools[@"layers"])if([node[@"masks"]count])return fail(error,@"新增工具含蒙版,无法完整导出为 Cube。请保存完整预设。");
_toolDocument=tools;BOOL ok=NO;@try{ok=[self exportLUT:url uniforms:u paths:paths spider:spider error:error];}@finally{_toolDocument=nil;}return ok;
}}
+33
查看文件
@@ -0,0 +1,33 @@
#pragma once
#import "DYModel.h"
#include "MaskCore/DYMaskOperator.h"
enum { DYToolsParameterID=9002, DYCanvasSessionParameterID=9003, DYToolLimit=32, DYToolMaskLimit=16, DYToolKeyLimit=16384 };
// Immutable property-list author state. Host float IDs and the legacy ABI stay fixed.
@interface DYToolDocument : NSObject<NSSecureCoding,NSCopying,FxCustomParameterInterpolation_v2>
@property(nonatomic,copy) NSDictionary *document;
@end
NSArray *DYToolTypes(void);
NSDictionary *DYToolSection(NSString *type);
NSDictionary *DYNewTool(NSString *type);
NSDictionary *DYNewMask(NSInteger kind);
BOOL DYValidToolDocument(NSDictionary *document);
BOOL DYValidToolMask(NSDictionary *mask);
NSMutableDictionary *DYMutablePlist(NSDictionary *value);
DYToolDocument *DYReadTools(id<PROAPIAccessing> manager,CMTime time);
BOOL DYWriteTools(id<PROAPIAccessing> manager,NSDictionary *document,CMTime time);
NSArray *DYMasksForTool(NSDictionary *document,NSString *nodeID);
NSDictionary *DYToolWithID(NSDictionary *document,NSString *nodeID);
BOOL DYSetToolMasks(NSMutableDictionary *document,NSString *nodeID,NSArray *masks);
DYMaskParameters DYMaskAtTime(NSDictionary *mask,CMTime time);
NSDictionary *DYMaskKey(CMTime time,DYMaskParameters parameters,BOOL manual,float confidence);
BOOL DYMergeTracking(NSMutableDictionary *mask,NSArray *samples);
NSDictionary *DYToolRenderSnapshot(NSDictionary *document,CMTime time);
DYUniforms DYToolUniforms(NSDictionary *node);
BOOL DYToolIsNeutral(NSDictionary *node);
// Routes an existing native panel to a UUID, batching edits into one host write.
@interface DYToolManager : NSObject<PROAPIAccessing>
@property(nonatomic,readonly) id<PROAPIAccessing> host;
@property(nonatomic,readonly) NSString *nodeID,*type;
- (instancetype)initWithHost:(id<PROAPIAccessing>)host node:(NSDictionary *)node;
@end
+82
查看文件
@@ -0,0 +1,82 @@
#import "DYToolState.h"
#include "DYSpiderState.h"
#include <set>
#import <objc/runtime.h>
NSArray *DYToolTypes(void){return @[@"primary",@"spider",@"base",@"skin",@"look",@"hsl",@"curve",@"grading",@"primaries",@"levels",@"blackwhite",@"balance"];}
NSDictionary *DYToolSection(NSString *type){for(NSDictionary *s in DYSections())if([s[@"key"]isEqual:type])return s;return nil;}
NSMutableDictionary *DYMutablePlist(NSDictionary *value){if(!value)return [NSMutableDictionary dictionary];NSData *data=[NSPropertyListSerialization dataWithPropertyList:value format:NSPropertyListBinaryFormat_v1_0 options:0 error:nil];return [NSPropertyListSerialization propertyListWithData:data options:NSPropertyListMutableContainersAndLeaves format:NULL error:nil];}
static NSDictionary *DYEmptyTools(){return @{@"schema":@1,@"layers":@[],@"baseMasks":@{}};}
static BOOL finiteNumber(id v){return [v isKindOfClass:NSNumber.class]&&std::isfinite([v doubleValue]);}
static BOOL validID(id v){return [v isKindOfClass:NSString.class]&&[[[NSUUID alloc]initWithUUIDString:v]autorelease]!=nil;}
static NSData *parameterData(DYMaskParameters p){return [NSData dataWithBytes:&p length:sizeof(p)];}
static BOOL readParameters(id data,DYMaskParameters *p){if(![data isKindOfClass:NSData.class]||[data length]!=sizeof(*p))return NO;[data getBytes:p length:sizeof(*p)];return dyValidMaskParameters(*p);}
static CMTime keyTime(NSDictionary *key){return CMTimeMakeWithEpoch([key[@"value"]longLongValue],[key[@"scale"]intValue],[key[@"epoch"]longLongValue]);}
NSDictionary *DYNewMask(NSInteger kind){if(kind<0||kind>5)return nil;DYMaskParameters p=dyDefaultMaskParameters();p.kind=(DYMaskKind)kind;p.width=.5;p.height=.5;p.sourceStage=DYMaskSourceOriginal;if(kind==DYMaskHSLKey)p.flags=DYMaskHueEnabled;NSData *nodes=[NSData data];if(kind==DYMaskBezier){DYBezierNode n[4]={};float x[4]={-.5,.5,.5,-.5},y[4]={-.5,-.5,.5,.5};for(int i=0;i<4;i++)n[i]={x[i],y[i],x[i],y[i],x[i],y[i]};nodes=[NSData dataWithBytes:n length:sizeof(n)];}return @{@"id":NSUUID.UUID.UUIDString,@"enabled":@YES,@"combine":@0,@"parameters":parameterData(p),@"nodes":nodes,@"keys":@[]};}
NSDictionary *DYNewTool(NSString *type){if(![DYToolTypes()containsObject:type])return nil;return @{@"id":NSUUID.UUID.UUIDString,@"type":type,@"values":[type isEqual:@"skin"]?@{@"skinStrength":@0}:@{},@"paths":@{},@"spiderLinked":@YES,@"masks":@[]};}
BOOL DYValidToolMask(NSDictionary *mask){
if(![mask isKindOfClass:NSDictionary.class]||!validID(mask[@"id"])||!finiteNumber(mask[@"enabled"])||!finiteNumber(mask[@"combine"])||[mask[@"combine"]integerValue]<0||[mask[@"combine"]integerValue]>2)return NO;
DYMaskParameters p;if(!readParameters(mask[@"parameters"],&p))return NO;NSData *nodes=mask[@"nodes"];if(![nodes isKindOfClass:NSData.class]||nodes.length%sizeof(DYBezierNode)||nodes.length>32*sizeof(DYBezierNode))return NO;
const float *n=(const float*)nodes.bytes;for(NSUInteger i=0;i<nodes.length/4;i++)if(!std::isfinite(n[i])||fabs(n[i])>1000)return NO;
NSArray *keys=mask[@"keys"];if(![keys isKindOfClass:NSArray.class]||keys.count>DYToolKeyLimit)return NO;CMTime last=kCMTimeInvalid;
for(NSDictionary *k in keys){if(![k isKindOfClass:NSDictionary.class]||!finiteNumber(k[@"value"])||!finiteNumber(k[@"scale"])||!finiteNumber(k[@"epoch"])||!finiteNumber(k[@"manual"])||!finiteNumber(k[@"confidence"])||[k[@"confidence"]doubleValue]<0||[k[@"confidence"]doubleValue]>1)return NO;CMTime t=keyTime(k);DYMaskParameters q;if(!CMTIME_IS_NUMERIC(t)||!readParameters(k[@"parameters"],&q)||q.kind!=p.kind||(CMTIME_IS_NUMERIC(last)&&(last.epoch!=t.epoch||CMTimeCompare(last,t)>=0)))return NO;last=t;}return YES;
}
static BOOL validMasks(id masks,NSMutableSet *ids){if(![masks isKindOfClass:NSArray.class]||[masks count]>DYToolMaskLimit)return NO;for(NSDictionary *m in masks){if(!DYValidToolMask(m)||[ids containsObject:m[@"id"]])return NO;[ids addObject:m[@"id"]];}return YES;}
BOOL DYValidToolDocument(NSDictionary *doc){
if(![NSPropertyListSerialization propertyList:doc isValidForFormat:NSPropertyListBinaryFormat_v1_0])return NO;
if(![doc isKindOfClass:NSDictionary.class]||![doc[@"schema"]isEqual:@1]||![doc[@"layers"]isKindOfClass:NSArray.class]||[doc[@"layers"]count]>DYToolLimit||![doc[@"baseMasks"]isKindOfClass:NSDictionary.class]||[doc[@"baseMasks"]count]>DYToolTypes().count)return NO;
NSMutableSet *ids=[NSMutableSet set];for(NSString *key in doc[@"baseMasks"]){if(![DYToolTypes()containsObject:key]||!validMasks(doc[@"baseMasks"][key],ids))return NO;}
NSMutableDictionary *descriptors=[NSMutableDictionary dictionary];for(NSDictionary *d in DYDescriptors())descriptors[d[@"key"]]=d;
for(NSDictionary *node in doc[@"layers"]){if(![node isKindOfClass:NSDictionary.class]||!validID(node[@"id"])||[ids containsObject:node[@"id"]]||![DYToolTypes()containsObject:node[@"type"]]||![node[@"values"]isKindOfClass:NSDictionary.class]||[node[@"values"]count]>descriptors.count||![node[@"paths"]isKindOfClass:NSDictionary.class]||[node[@"paths"]count]>6||!validMasks(node[@"masks"],ids))return NO;[ids addObject:node[@"id"]];
for(NSString *key in node[@"values"]){NSDictionary *d=descriptors[key];id v=node[@"values"][key];if(!d||!finiteNumber(v)||[v doubleValue]<[d[@"min"]doubleValue]||[v doubleValue]>[d[@"max"]doubleValue]||(d[@"values"]&&![d[@"values"]containsObject:@((int)llround([v doubleValue]))]))return NO;}
for(id key in node[@"paths"]){id p=node[@"paths"][key];if(![@[@"input",@"look0",@"look1",@"look2",@"look3",@"look4"]containsObject:key]||![p isKindOfClass:NSString.class]||[p length]>8192||![p isAbsolutePath]||![[p pathExtension].lowercaseString isEqual:@"cube"])return NO;}if(node[@"spider"]&&(![node[@"spider"]isKindOfClass:NSData.class]||!DYSpiderMeshIsValid(node[@"spider"])))return NO;
}NSUInteger totalKeys=0;for(NSArray *masks in [doc[@"baseMasks"]allValues])for(NSDictionary *mask in masks)totalKeys+=[mask[@"keys"]count];for(NSDictionary *node in doc[@"layers"])for(NSDictionary *mask in node[@"masks"])totalKeys+=[mask[@"keys"]count];if(totalKeys>65536)return NO;NSData *bounded=[NSPropertyListSerialization dataWithPropertyList:doc format:NSPropertyListBinaryFormat_v1_0 options:0 error:nil];return bounded&&bounded.length<=24*1024*1024;
}
@implementation DYToolDocument
+ (BOOL)supportsSecureCoding{return YES;}
- (instancetype)init{if((self=[super init]))_document=[DYEmptyTools()copy];return self;}
- (void)dealloc{[_document release];[super dealloc];}
- (void)setDocument:(NSDictionary *)d{if(!DYValidToolDocument(d))return;NSData *b=[NSPropertyListSerialization dataWithPropertyList:d format:NSPropertyListBinaryFormat_v1_0 options:0 error:nil];NSDictionary *immutable=[NSPropertyListSerialization propertyListWithData:b options:NSPropertyListImmutable format:NULL error:nil];[_document release];_document=[immutable retain];}
- (void)encodeWithCoder:(NSCoder*)c{[c encodeObject:_document forKey:@"document"];}
- (instancetype)initWithCoder:(NSCoder*)c{if((self=[self init])){NSDictionary *d=[c decodeObjectOfClasses:[NSSet setWithObjects:NSDictionary.class,NSArray.class,NSString.class,NSNumber.class,NSData.class,nil] forKey:@"document"];if(!DYValidToolDocument(d)){[self release];return nil;}self.document=d;}return self;}
- (id)copyWithZone:(NSZone*)zone{DYToolDocument *v=[[[self class]allocWithZone:zone]init];v.document=_document;return v;}
- (BOOL)isEqual:(id)o{return [o isKindOfClass:DYToolDocument.class]&&[_document isEqual:[o document]];}
- (NSUInteger)hash{return _document.hash;}
- (id)interpolateBetween:(id)other withWeight:(float)weight{return [[self copy]autorelease];}
@end
DYToolDocument *DYReadTools(id<PROAPIAccessing>m,CMTime t){DYToolDocument *d=nil;[[(id)m apiForProtocol:@protocol(FxParameterRetrievalAPI_v6)]getCustomParameterValue:&d fromParameter:DYToolsParameterID atTime:t];return [d isKindOfClass:DYToolDocument.class]?d:[[[DYToolDocument alloc]init]autorelease];}
BOOL DYWriteTools(id<PROAPIAccessing>m,NSDictionary *d,CMTime t){if(!DYValidToolDocument(d))return NO;DYToolDocument *v=[[[DYToolDocument alloc]init]autorelease];v.document=d;return [[m apiForProtocol:@protocol(FxParameterSettingAPI_v6)]setCustomParameterValue:v toParameter:DYToolsParameterID atTime:t];}
NSDictionary *DYToolWithID(NSDictionary *doc,NSString *ID){for(NSDictionary *n in doc[@"layers"])if([n[@"id"]isEqual:ID])return n;return nil;}
NSArray *DYMasksForTool(NSDictionary *doc,NSString *ID){return [ID hasPrefix:@"base:"]?doc[@"baseMasks"][[ID substringFromIndex:5]]?:@[]:DYToolWithID(doc,ID)[@"masks"]?:@[];}
BOOL DYSetToolMasks(NSMutableDictionary *doc,NSString *ID,NSArray *masks){if([ID hasPrefix:@"base:"]){NSString *type=[ID substringFromIndex:5];if(![DYToolTypes()containsObject:type])return NO;doc[@"baseMasks"][type]=masks;}else{NSMutableDictionary *n=(id)DYToolWithID(doc,ID);if(!n)return NO;n[@"masks"]=masks;}return YES;}
DYMaskParameters DYMaskAtTime(NSDictionary *mask,CMTime time){DYMaskParameters p=dyDefaultMaskParameters();readParameters(mask[@"parameters"],&p);NSArray *keys=mask[@"keys"];if(!keys.count||!CMTIME_IS_NUMERIC(time))return p;if(keyTime(keys[0]).epoch!=time.epoch)return p;NSUInteger low=0,high=keys.count;while(low<high){NSUInteger mid=low+(high-low)/2;if(CMTimeCompare(keyTime(keys[mid]),time)<0)low=mid+1;else high=mid;}NSDictionary *left=keys[low?low-1:0],*right=keys[MIN(low,keys.count-1)];DYMaskParameters a,b;readParameters(left[@"parameters"],&a);readParameters(right[@"parameters"],&b);double duration=CMTimeGetSeconds(CMTimeSubtract(keyTime(right),keyTime(left)));float w=duration>0?fmax(0,fmin(1,CMTimeGetSeconds(CMTimeSubtract(time,keyTime(left)))/duration)):0;
// Only temporal geometry/feather/strength interpolate; key selection and levels stay authored.
float *v=&p.centerX,*av=&a.centerX,*bv=&b.centerX;for(int i=0;i<8;i++)v[i]=av[i]+(bv[i]-av[i])*w;return p;}
NSDictionary *DYMaskKey(CMTime t,DYMaskParameters p,BOOL manual,float confidence){return @{@"value":@(t.value),@"scale":@(t.timescale),@"epoch":@(t.epoch),@"parameters":parameterData(p),@"manual":@(manual),@"confidence":@(confidence)};}
BOOL DYMergeTracking(NSMutableDictionary *m,NSArray *samples){if(!samples.count)return YES;NSMutableArray *all=[NSMutableArray array];CMTime lo=keyTime(samples.firstObject),hi=keyTime(samples.lastObject);if(CMTimeCompare(lo,hi)>0)std::swap(lo,hi);for(NSDictionary *key in m[@"keys"])if([key[@"manual"]boolValue]||CMTimeCompare(keyTime(key),lo)<0||CMTimeCompare(keyTime(key),hi)>0)[all addObject:key];for(NSDictionary *key in samples){BOOL manual=NO;for(NSDictionary *old in all)if(CMTimeCompare(keyTime(old),keyTime(key))==0){manual=YES;break;}if(!manual)[all addObject:key];}[all sortUsingComparator:^NSComparisonResult(NSDictionary *a,NSDictionary *b){return (NSComparisonResult)CMTimeCompare(keyTime(a),keyTime(b));}];NSMutableDictionary *candidate=DYMutablePlist(m);candidate[@"keys"]=all;if(!DYValidToolMask(candidate))return NO;m[@"keys"]=all;return YES;}
NSDictionary *DYToolRenderSnapshot(NSDictionary *doc,CMTime t){
auto resolve=[&](NSArray *masks){NSMutableArray *result=[NSMutableArray arrayWithCapacity:masks.count];for(NSDictionary *mask in masks){NSMutableDictionary *m=[[mask mutableCopy]autorelease];m[@"parameters"]=parameterData(DYMaskAtTime(mask,t));m[@"keys"]=@[];[result addObject:m];}return result;};
NSMutableDictionary *out=[[doc mutableCopy]autorelease],*base=[NSMutableDictionary dictionary];for(NSString *type in doc[@"baseMasks"])base[type]=resolve(doc[@"baseMasks"][type]);out[@"baseMasks"]=base;NSMutableArray *layers=[NSMutableArray array];for(NSDictionary *node in doc[@"layers"]){NSMutableDictionary *layer=[[node mutableCopy]autorelease];layer[@"masks"]=resolve(node[@"masks"]);[layers addObject:layer];}out[@"layers"]=layers;return out;
}
DYUniforms DYToolUniforms(NSDictionary *node){DYUniforms u;DYDefaultUniforms(&u);NSString *type=node[@"type"];for(NSDictionary *s in DYSections())for(NSDictionary *d in DYDescriptors())if([d[@"pid"]isEqual:s[@"enabled"]])*(float*)((uint8_t*)&u+[d[@"offset"]unsignedIntegerValue])=0;u.primarySectionEnabled=0;u.cm.configured=-1;u.inputProfile=u.preLUTStrength=0;u.skinProtection.x=0;
NSArray *parts=[type isEqual:@"primary"]?@[@"input",@"primary",@"output"]:[type isEqual:@"base"]?@[@"base",@"color"]:@[type];for(NSString *part in parts){NSDictionary *s=DYToolSection(part);for(NSDictionary *d in DYDescriptors())if([d[@"pid"]isEqual:s[@"enabled"]])*(float*)((uint8_t*)&u+[d[@"offset"]unsignedIntegerValue])=1;}
if([type isEqual:@"primary"]){u.primarySectionEnabled=1;u.cm.configured=1;u.cm.inputTransfer=u.cm.outputTransfer;u.cm.inputGamut=u.cm.outputGamut;}
for(NSDictionary *d in DYDescriptors()){NSNumber *v=node[@"values"][d[@"key"]];if(v&&[d[@"offset"]integerValue]>=0)*(float*)((uint8_t*)&u+[d[@"offset"]unsignedIntegerValue])=v.floatValue;}return u;}
BOOL DYToolIsNeutral(NSDictionary *node){NSString *type=node[@"type"];DYUniforms u=DYToolUniforms(node);NSDictionary *section=DYToolSection(type);BOOL enabled=YES;if([type isEqual:@"primary"])enabled=u.primarySectionEnabled>.5;else if([type isEqual:@"base"])enabled=u.baseSectionEnabled>.5||u.colorSectionEnabled>.5;else for(NSDictionary *d in DYDescriptors())if([d[@"pid"]isEqual:section[@"enabled"]])enabled=*(float*)((uint8_t*)&u+[d[@"offset"]unsignedIntegerValue])>.5;if(!enabled)return YES;if([type isEqual:@"skin"])return u.skinProtection.y==0;if([node[@"type"]isEqual:@"spider"]&&[node[@"spider"]length]){auto mesh=DYSpiderMesh(node[@"spider"]);for(float v:dy::meshSamples(mesh))if(v!=0)return NO;}if([node[@"paths"]count])return NO;for(NSDictionary *d in DYDescriptors()){NSNumber *v=node[@"values"][d[@"key"]];if(v&&v.floatValue!=[d[@"default"]floatValue])return NO;}return YES;}
@implementation DYToolManager {
id<PROAPIAccessing> _host;NSString *_nodeID,*_type;NSInteger _depth;CMTime _time;NSMutableDictionary *_pending;DYInspectorToken *_token;
}
@synthesize host=_host,nodeID=_nodeID,type=_type;
- (instancetype)initWithHost:(id<PROAPIAccessing>)h node:(NSDictionary*)n{if((self=[super init])){_host=h;_nodeID=[n[@"id"]copy];_type=[n[@"type"]copy];}return self;}
- (void)dealloc{[_nodeID release];[_type release];[_pending release];[_token release];[super dealloc];}
- (id)apiForProtocol:(Protocol*)p{if(protocol_isEqual(p,@protocol(FxParameterRetrievalAPI_v6))||protocol_isEqual(p,@protocol(FxParameterSettingAPI_v6))||protocol_isEqual(p,@protocol(FxCustomParameterActionAPI_v4)))return self;return [_host apiForProtocol:p];}
- (void)startAction:(id)sender{if(_depth++==0){[[_host apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)]startAction:sender];_time=[(id<FxCustomParameterActionAPI_v4>)[_host apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)]currentTime];[_pending release];_pending=[DYMutablePlist(DYReadTools(_host,_time).document)retain];}}
- (void)endAction:(id)sender{if(_depth<=0)return;if(--_depth==0){NSDictionary *original=DYReadTools(_host,_time).document;if(![_pending isEqual:original])DYWriteTools(_host,_pending,_time);if(_token)[[_host apiForProtocol:@protocol(FxParameterSettingAPI_v6)]setCustomParameterValue:_token toParameter:DYInspectorParameterID atTime:_time];[_token release];_token=nil;[[_host apiForProtocol:@protocol(FxCustomParameterActionAPI_v4)]endAction:sender];}}
- (CMTime)currentTime{return _time;}
- (NSDictionary*)node{return DYToolWithID(_pending?:DYReadTools(_host,_time).document,_nodeID);}
- (BOOL)getFloatValue:(double*)out fromParameter:(UInt32)pid atTime:(CMTime)t{NSDictionary *n=[self node];DYUniforms u=DYToolUniforms(n?:@{@"type":_type});for(NSDictionary *d in DYDescriptors())if([d[@"pid"]unsignedIntValue]==pid){*out=[d[@"offset"]integerValue]>=0?*(float*)((uint8_t*)&u+[d[@"offset"]unsignedIntegerValue]):[d[@"default"]doubleValue];return YES;}return NO;}
- (BOOL)setFloatValue:(double)v toParameter:(UInt32)pid atTime:(CMTime)t{if(!_depth||!std::isfinite(v))return NO;NSMutableDictionary *n=(id)[self node];if(!n)return NO;for(NSDictionary *d in DYDescriptors())if([d[@"pid"]unsignedIntValue]==pid){n[@"values"][d[@"key"]]=@(v);return YES;}return NO;}
- (BOOL)getCustomParameterValue:(id*)out fromParameter:(UInt32)pid atTime:(CMTime)t{if(pid==DYAssetsParameterID){DYAssetState *a=[[[DYAssetState alloc]init]autorelease];NSDictionary *n=[self node];a.paths=n[@"paths"]?:@{};a.spiderMesh=n[@"spider"];a.spiderLinked=[n[@"spiderLinked"]boolValue];*out=a;return YES;}if(pid==DYInspectorParameterID){DYInspectorToken *global=_token; if(!global)[[_host apiForProtocol:@protocol(FxParameterRetrievalAPI_v6)]getCustomParameterValue:&global fromParameter:pid atTime:t];DYInspectorToken *local=[[[DYInspectorToken alloc]init]autorelease];NSMutableDictionary *folds=[NSMutableDictionary dictionary];for(NSString *key in global.folds)if([key hasPrefix:[_nodeID stringByAppendingString:@":"]])folds[[key substringFromIndex:_nodeID.length+1]]=global.folds[key];local.folds=folds;*out=local;return YES;}return NO;}
- (BOOL)setCustomParameterValue:(id)v toParameter:(UInt32)pid atTime:(CMTime)t{if(!_depth)return NO;NSMutableDictionary *n=(id)[self node];if(!n)return NO;if(pid==DYAssetsParameterID&&[v isKindOfClass:DYAssetState.class]){n[@"paths"]=DYMutablePlist([v paths]);if([v spiderMesh])n[@"spider"]=[v spiderMesh];else[n removeObjectForKey:@"spider"];n[@"spiderLinked"]=@([v spiderLinked]);return YES;}if(pid==DYInspectorParameterID){DYInspectorToken *old=nil;[[_host apiForProtocol:@protocol(FxParameterRetrievalAPI_v6)]getCustomParameterValue:&old fromParameter:pid atTime:t];[_token release];_token=old?[old copy]:[DYInspectorToken new];NSMutableDictionary *folds=[[_token.folds mutableCopy]autorelease];for(NSString *key in [v folds])folds[[_nodeID stringByAppendingFormat:@":%@",key]]=[v folds][key];_token.folds=folds;return YES;}return NO;}
@end
@@ -0,0 +1,19 @@
{
DYDiagnosticManager *base=[[[DYDiagnosticManager alloc]init]autorelease];DYCreateParameters(base,&error);DYToolTrackingProbe *host=[[[DYToolTrackingProbe alloc]init]autorelease];host->_base=base;host->_time=kCMTimeZero;host->_state=kFxAnalysisState_NotAnalyzing;
NSMutableDictionary *doc=DYMutablePlist([[[DYToolDocument alloc]init]autorelease].document),*mask=DYMutablePlist(DYNewMask(DYMaskRectangle));DYMaskParameters p=DYMaskAtTime(mask,kCMTimeZero);p.width=.65;p.height=.65;p.feather=0;mask[@"parameters"]=[NSData dataWithBytes:&p length:sizeof(p)];doc[@"baseMasks"][@"hsl"]=[NSMutableArray arrayWithObject:mask];DYWriteTools(base,doc,kCMTimeZero);
id<DYToolHostProbe>plugin=(id)[[NSClassFromString(@"DYPlugIn")alloc]initWithAPIManager:host];[(NSObject*)plugin setValue:@YES forKey:@"_toolCaptureEnabled"];
const NSUInteger tw=320,th=192;DYDiagnosticTile *frame=[[[DYDiagnosticTile alloc]initWithDevice:gpu width:tw height:th]autorelease],*out=[[[DYDiagnosticTile alloc]initWithDevice:gpu width:tw height:th]autorelease];
auto setFrame=[&](int step){Pixels pixels(tw*th*4);for(NSUInteger y=0;y<th;y++)for(NSUInteger x=0;x<tw;x++){int xx=(int)x-step*2,yy=(int)y-step;uint32_t n=(uint32_t)(xx/3)*73856093u^(uint32_t)(yy/3)*19349663u;n^=n>>13;n*=1274126177u;float code=.15f+.7f*((n>>8)&255)/255.f,linear=code<=.04045f?code/12.92f:powf((code+.055f)/1.055f,2.4f);auto index=(y*tw+x)*4;pixels[index]=pixels[index+1]=pixels[index+2]=linear;pixels[index+3]=1;}[[frame metalTextureForDevice:gpu]replaceRegion:MTLRegionMake2D(0,0,tw,th) mipmapLevel:0 withBytes:pixels.data() bytesPerRow:tw*8];};
auto timeAt=[](int frame){return CMTimeMake(frame*1001,24000);};auto capture=[&](int step){setFrame(step);host->_time=timeAt(step);NSData *state=nil;[plugin pluginState:&state atTime:host->_time quality:(FxQuality)0 error:&error];return [plugin renderDestinationImage:out sourceImages:@[frame] pluginState:state atTime:host->_time error:&error];};
auto request=[&](int direction){if(direction!=9)host->_state=kFxAnalysisState_NotAnalyzing;[plugin toolTrackRequested:[NSNotification notificationWithName:@"DYToolTrack" object:host userInfo:@{@"node":@"base:hsl",@"mask":mask[@"id"],@"direction":@(direction)}]];};
auto drain=[&](){double end=NSProcessInfo.processInfo.systemUptime+.15;while(NSProcessInfo.processInfo.systemUptime<end)[[NSRunLoop mainRunLoop]runMode:NSDefaultRunLoopMode beforeDate:[NSDate dateWithTimeIntervalSinceNow:.005]];};CMTimeRange inputRange=CMTimeRangeMake(kCMTimeZero,CMTimeMake(6*1001,24000)),desired;
run.need(@"tracking-captures-real-full-input-texture",capture(0));int undoBefore=base->_undoStarts;request(1);BOOL callbacks=[plugin desiredAnalysisTimeRange:&desired forInputWithTimeRange:inputRange error:&error]&&[plugin setupAnalysisForTimeRange:desired frameDuration:timeAt(1) error:&error];
for(int i=0;i<6&&callbacks;i++){setFrame(i);callbacks&=[plugin analyzeFrame:frame atTime:timeAt(i) error:&error];}host->_state=kFxAnalysisState_AnalysisCompleted;[plugin cleanupAnalysis:nil];drain();NSDictionary *tracked=DYReadTools(base,kCMTimeZero).document[@"baseMasks"][@"hsl"][0];DYMaskParameters end=DYMaskAtTime(tracked,timeAt(5));run.record(@"host-callback-metal-tracking-six-exact-frames",callbacks&&[tracked[@"keys"]count]==6&&fabs(end.centerX-(.5+10./tw))<.004&&fabs(end.centerY-(.5+5./th))<.004,@{@"keyCount":@([tracked[@"keys"]count]),@"centerX":@(end.centerX),@"centerY":@(end.centerY),@"error":reason(error)});
run.record(@"tracking-results-use-one-undo-action",base->_undoStarts==undoBefore+1&&base->_undoStarts==base->_undoEnds);int writes=base->_undoStarts;[plugin cleanupAnalysis:nil];[plugin cleanupAnalysis:nil];drain();run.record(@"duplicate-analysis-cleanup-never-commits-twice",base->_undoStarts==writes);
// Mid-analysis author edits must reject the result rather than clobber them.
capture(0);request(1);callbacks=[plugin desiredAnalysisTimeRange:&desired forInputWithTimeRange:inputRange error:nil]&&[plugin setupAnalysisForTimeRange:desired frameDuration:timeAt(1) error:nil];for(int i=0;i<3&&callbacks;i++){setFrame(i);callbacks&=[plugin analyzeFrame:frame atTime:timeAt(i) error:nil];}NSMutableDictionary *changed=DYMutablePlist(DYReadTools(base,kCMTimeZero).document);changed[@"baseMasks"][@"hsl"][0][@"enabled"]=@NO;DYWriteTools(base,changed,kCMTimeZero);[plugin cleanupAnalysis:nil];drain();run.record(@"stale-analysis-cannot-overwrite-edited-mask",[DYReadTools(base,kCMTimeZero).document isEqual:changed]&&base->_undoStarts==writes);
DYWriteTools(base,doc,kCMTimeZero);capture(0);request(1);callbacks=[plugin desiredAnalysisTimeRange:&desired forInputWithTimeRange:inputRange error:nil]&&[plugin setupAnalysisForTimeRange:desired frameDuration:timeAt(1) error:nil];for(int i=0;i<3&&callbacks;i++){setFrame(i);callbacks&=[plugin analyzeFrame:frame atTime:timeAt(i) error:nil];}request(9);setFrame(3);BOOL stopped=![plugin analyzeFrame:frame atTime:timeAt(3) error:nil];drain();tracked=DYReadTools(base,kCMTimeZero).document[@"baseMasks"][@"hsl"][0];run.record(@"cancel-keeps-only-contiguous-trusted-segment",callbacks&&stopped&&[tracked[@"keys"]count]==3&&base->_undoStarts==writes+1);
DYWriteTools(base,doc,kCMTimeZero);capture(2);host->_state=kFxAnalysisState_NotAnalyzing;request(0);callbacks=[plugin desiredAnalysisTimeRange:&desired forInputWithTimeRange:inputRange error:nil]&&[plugin setupAnalysisForTimeRange:desired frameDuration:timeAt(1) error:nil];for(int i=2;i<6&&callbacks;i++){setFrame(i);callbacks&=[plugin analyzeFrame:frame atTime:timeAt(i) error:nil];}[plugin cleanupAnalysis:nil];drain();BOOL backward=host->_backwardStarts==1;callbacks&=[plugin desiredAnalysisTimeRange:&desired forInputWithTimeRange:inputRange error:nil]&&[plugin setupAnalysisForTimeRange:desired frameDuration:timeAt(1) error:nil];for(int i=2;i>=0&&callbacks;i--){setFrame(i);callbacks&=[plugin analyzeFrame:frame atTime:timeAt(i) error:nil];}[plugin cleanupAnalysis:nil];drain();tracked=DYReadTools(base,kCMTimeZero).document[@"baseMasks"][@"hsl"][0];run.record(@"bidirectional-passes-share-reference-and-merge-once",callbacks&&backward&&[tracked[@"keys"]count]==6&&base->_undoStarts==writes+2);
DYWriteTools(base,doc,kCMTimeZero);capture(2);host->_state=kFxAnalysisState_NotAnalyzing;request(-2);BOOL range=[plugin desiredAnalysisTimeRange:&desired forInputWithTimeRange:inputRange error:nil]&&CMTimeCompare(desired.start,timeAt(1))==0&&CMTimeCompare(desired.duration,timeAt(2))==0;[plugin setupAnalysisForTimeRange:desired frameDuration:timeAt(1) error:nil];for(int i=2;i>=1;i--){setFrame(i);[plugin analyzeFrame:frame atTime:timeAt(i) error:nil];}setFrame(0);stopped=![plugin analyzeFrame:frame atTime:timeAt(0) error:nil];drain();tracked=DYReadTools(base,kCMTimeZero).document[@"baseMasks"][@"hsl"][0];run.record(@"backward-single-step-includes-reference-and-one-neighbor",range&&stopped&&[tracked[@"keys"]count]==2);
[plugin release];
}
@@ -0,0 +1,37 @@
@interface DYToolTrackingProbe : NSObject<PROAPIAccessing> {
@public
id _base;CMTime _time;FxAnalysisState _state;int _forwardStarts,_backwardStarts;
}
@end
@implementation DYToolTrackingProbe
- (id)apiForProtocol:(Protocol*)protocol{NSString *name=NSStringFromProtocol(protocol);if([@[@"FxAnalysisAPI",@"FxTimingAPI_v4",@"FxCustomParameterActionAPI_v4"]containsObject:name])return self;return [_base apiForProtocol:protocol];}
- (void)startAction:(id)sender{[(id<FxCustomParameterActionAPI_v4>)_base startAction:sender];}
- (void)endAction:(id)sender{[(id<FxCustomParameterActionAPI_v4>)_base endAction:sender];}
- (CMTime)currentTime{return _time;}
- (FxAnalysisState)analysisStateForEffect{return _state;}
- (BOOL)startForwardAnalysis:(FxAnalysisLocation)location error:(NSError**)error{_forwardStarts++;_state=kFxAnalysisState_AnalysisStarted;return YES;}
- (BOOL)startBackwardAnalysis:(FxAnalysisLocation)location error:(NSError**)error{_backwardStarts++;_state=kFxAnalysisState_AnalysisStarted;return YES;}
- (NSUInteger)timelineFpsNumeratorForEffect:(id)effect{return 24000;}
- (NSUInteger)timelineFpsDenominatorForEffect:(id)effect{return 1001;}
@end
@protocol DYToolHostProbe
- (instancetype)initWithAPIManager:(id<PROAPIAccessing>)manager;
- (BOOL)pluginState:(NSData**)state atTime:(CMTime)time quality:(FxQuality)quality error:(NSError**)error;
- (BOOL)renderDestinationImage:(FxImageTile*)dst sourceImages:(NSArray*)src pluginState:(NSData*)state atTime:(CMTime)time error:(NSError**)error;
- (void)toolTrackRequested:(NSNotification*)notification;
- (BOOL)desiredAnalysisTimeRange:(CMTimeRange*)out forInputWithTimeRange:(CMTimeRange)input error:(NSError**)error;
- (BOOL)setupAnalysisForTimeRange:(CMTimeRange)range frameDuration:(CMTime)duration error:(NSError**)error;
- (BOOL)analyzeFrame:(FxImageTile*)frame atTime:(CMTime)time error:(NSError**)error;
- (BOOL)cleanupAnalysis:(NSError**)error;
@end
@interface DYToolCanvasProbe : DYToolTrackingProbe @end
@implementation DYToolCanvasProbe
- (id)apiForProtocol:(Protocol*)p{if([NSStringFromProtocol(p)isEqual:@"FxOnScreenControlAPI_v4"])return self;return [super apiForProtocol:p];}
- (BOOL)convertPointFromSpace:(FxDrawingCoordinates)from fromX:(double)x fromY:(double)y toSpace:(FxDrawingCoordinates)to toX:(double*)outX toY:(double*)outY{if(outX)*outX=40+x*560;if(outY)*outY=55+y*315;return YES;}
@end
@protocol DYToolCanvasHostProbe <DYToolHostProbe>
- (void)scheduleToolCanvasRegistration;
- (void)adoptToolCanvasDocument:(NSDictionary*)document;
- (NSDictionary*)toolCanvasMaskAtTime:(CMTime)time;
@end
+57
查看文件
@@ -0,0 +1,57 @@
#include <metal_stdlib>
using namespace metal;
struct PyramidInfo {int width[5],height[5],offset[5],levels;};
kernel void dyTrackPyramid(device float*f[[buffer(0)]],constant PyramidInfo&i[[buffer(1)]],constant int&level[[buffer(2)]],uint2 p[[thread_position_in_grid]]) {
int w=i.width[level],h=i.height[level];if(p.x>=uint(w)||p.y>=uint(h))return;
int sw=i.width[level-1],sh=i.height[level-1];float sum=0;
for(int y=-1;y<=1;y++)for(int x=-1;x<=1;x++)sum+=f[i.offset[level-1]+clamp(int(p.y)*2+y,0,sh-1)*sw+clamp(int(p.x)*2+x,0,sw-1)]*(x==0?2.f:1.f)*(y==0?2.f:1.f);
f[i.offset[level]+p.y*w+p.x]=sum/16.f;
}
inline bool inside(float2 p,int w,int h){return all(p>=6.f)&&p.x<w-7&&p.y<h-7;}
inline float pixel(device const float*f,int w,float2 p) {
int2 a=int2(p);float2 d=p-float2(a);int idx=a.y*w+a.x;
return mix(mix(f[idx],f[idx+1],d.x),mix(f[idx+w],f[idx+w+1],d.x),d.y);
}
// One SIMD group per feature: lanes cooperatively reduce the 9x9 patch.
// Forward and backward checks stay in the same dispatch and reuse the resident pyramids.
bool trackFlow(device const float*prev,device const float*next,constant PyramidInfo&i,float2 p,float2 guess,thread float2&q,thread float&error,uint lane) {
int level=i.levels-1;for(;level>0;level--){float s=float(1<<level);if(inside(p/s,i.width[level],i.height[level])&&inside(guess/s,i.width[level],i.height[level]))break;}
q=guess/float(1<<level);error=0;
for(;level>=0;level--) {
float2 pp=p/float(1<<level);int w=i.width[level],h=i.height[level];if(!inside(pp,w,h))return false;
device const float*a=prev+i.offset[level];device const float*b=next+i.offset[level];
float ref[3],gx[3],gy[3],mean=0,hxx=0,hxy=0,hyy=0;
for(uint j=0;j<3;j++) {
uint k=lane+j*32;ref[j]=gx[j]=gy[j]=0;if(k>=81)continue;
float2 pos=pp+float2(int(k%9)-4,int(k/9)-4);ref[j]=pixel(a,w,pos);mean+=ref[j];
gx[j]=.5f*(pixel(a,w,pos+float2(1,0))-pixel(a,w,pos-float2(1,0)));
gy[j]=.5f*(pixel(a,w,pos+float2(0,1))-pixel(a,w,pos-float2(0,1)));
hxx+=gx[j]*gx[j];hxy+=gx[j]*gy[j];hyy+=gy[j]*gy[j];
}
mean=simd_sum(mean)/81;hxx=simd_sum(hxx);hxy=simd_sum(hxy);hyy=simd_sum(hyy);
float det=hxx*hyy-hxy*hxy;if(det<1e-8f||hxx+hyy<1e-5f)return false;
for(int iteration=0;iteration<20;iteration++) {
if(!inside(q,w,h))return false;float target[3],tm=0;
for(uint j=0;j<3;j++){uint k=lane+j*32;target[j]=k<81?pixel(b,w,q+float2(int(k%9)-4,int(k/9)-4)):0;tm+=target[j];}
tm=simd_sum(tm)/81;float bx=0,by=0,sse=0;
for(uint j=0;j<3;j++)if(lane+j*32<81){float e=ref[j]-mean-target[j]+tm;bx+=gx[j]*e;by+=gy[j]*e;sse+=e*e;}
bx=simd_sum(bx);by=simd_sum(by);sse=simd_sum(sse);
float2 delta=float2(hyy*bx-hxy*by,hxx*by-hxy*bx)/det;if(!all(isfinite(delta))||length(delta)>8)return false;
q+=delta;error=sqrt(sse/81);if(dot(delta,delta)<.0001f)break;
}
if(level>0)q*=2;
}
return inside(q,i.width[0],i.height[0])&&error<.12f;
}
kernel void dyTrackFlow(device const float*prev[[buffer(0)]],device const float*next[[buffer(1)]],device const float2*points[[buffer(2)]],device float4*results[[buffer(3)]],constant PyramidInfo&i[[buffer(4)]],uint gid[[thread_position_in_grid]],uint lane[[thread_index_in_simdgroup]]) {
uint idx=gid/32;float2 p=points[idx],q=0,back=0;float error=0,backError=0;
bool ok=trackFlow(prev,next,i,p,p,q,error,lane);
if(ok)ok=trackFlow(next,prev,i,q,p,back,backError,lane)&&distance(back,p)<=1.1f;
if(lane==0)results[idx]=float4(q,error,ok?1.f:0.f);
}
// Full host frame -> top-first display luma. Analysis and reference use the
// same sampler, alpha convention and transfer; no 320x180 inspector preview.
kernel void dyToolCapture(texture2d<float> source [[texture(0)]],device float* pixels [[buffer(0)]],constant uint3& info [[buffer(1)]],uint2 pos [[thread_position_in_grid]]){
if(pos.x>=info.x||pos.y>=info.y)return;constexpr sampler f(coord::normalized,address::clamp_to_edge,filter::linear);float2 uv=(float2(pos)+.5f)/float2(info.xy);if(info.z)uv.y=1-uv.y;float4 sample=source.sample(f,uv);float3 linear=sample.a>0?sample.rgb/sample.a:float3(0);float3 encoded=select(1.055f*pow(max(linear,float3(0)),float3(1.f/2.4f))-.055f,linear*12.92f,linear<=.0031308f);pixels[pos.y*info.x+pos.x]=dot(clamp(encoded,0.f,1.f),float3(.2126f,.7152f,.0722f));
}
+25 -3
查看文件
@@ -17,9 +17,9 @@
<key>CFBundlePackageType</key>
<string>XPC!</string>
<key>CFBundleShortVersionString</key>
<string>1.3.1</string>
<string>1.4.0</string>
<key>CFBundleVersion</key>
<string>19</string>
<string>24</string>
<key>NSHumanReadableCopyright</key>
<string></string>
<key>PlugInKit</key>
@@ -71,7 +71,29 @@
<key>uuid</key>
<string>1C17B73B-F229-4C09-A434-EAF6DFF5F22A</string>
<key>version</key>
<string>1.0</string>
<string>1.4.0</string>
</dict>
<dict>
<key>className</key>
<string>DYToolOSC</string>
<key>displayName</key>
<string>大鱼调色蒙版</string>
<key>group</key>
<string>19E2727A-6BCD-4656-B270-7E2BF482A692</string>
<key>infoString</key>
<string>每工具蒙版画面控件</string>
<key>protocolNames</key>
<array>
<string>FxOnScreenControl</string>
</array>
<key>supportedPlugins</key>
<array>
<string>1C17B73B-F229-4C09-A434-EAF6DFF5F22A</string>
</array>
<key>uuid</key>
<string>EF77E6AE-3CA3-463B-B7E1-50222428D5E3</string>
<key>version</key>
<string>1</string>
</dict>
</array>
<key>XPCService</key>
+43
查看文件
@@ -0,0 +1,43 @@
#pragma once
#include "../SpiderCore/DYColorMath.h"
// Anchors and handles are local to maskX/Y/W/H. Empty path preserves legacy ellipses.
struct DYBezierNode { float x,y,inX,inY,outX,outY; };
struct DYMaskPath { int count; float x[256],y[256]; };
inline float dyPathMask(float x,float y,DYREF DYGrade& g,DYREF DYMaskPath& path) {
if(path.count<3)return dyMask(x,y,g);
float aspect=g.imageAspect,dx=(x-g.maskX)*aspect,dy=y-g.maskY;
float c=cos(g.maskAngle),s=sin(g.maskAngle);
float u=(dx*c+dy*s)/(g.maskW*aspect),v=(-dx*s+dy*c)/g.maskH;
bool inside=false;float distance2=1e10f;
// Physical distance in units of the shorter mask axis keeps feathering isotropic.
float shorter=g.maskW*aspect<g.maskH?g.maskW*aspect:g.maskH;
float sx=g.maskW*aspect/shorter,sy=g.maskH/shorter;
for(int i=0,j=path.count-1;i<path.count;j=i++) {
float ax=path.x[j],ay=path.y[j],bx=path.x[i],by=path.y[i];
if((ay>v)!=(by>v))if(u<(bx-ax)*(v-ay)/(by-ay)+ax)inside=!inside;
float ex=(bx-ax)*sx,ey=(by-ay)*sy,px=(u-ax)*sx,py=(v-ay)*sy;
float den=ex*ex+ey*ey,t=den>1e-12f?dyClamp((px*ex+py*ey)/den,0,1):0;
float xx=px-t*ex,yy=py-t*ey,d=xx*xx+yy*yy;if(d<distance2)distance2=d;
}
float a=inside?dySmooth(0,dyClamp(g.feather,.001f,.99f)*.5f,sqrt(distance2)):0;
return g.maskInvert?1-a:a;
}
#ifndef __METAL_VERSION__
#include <algorithm>
inline DYMaskPath dyFlattenMask(const DYBezierNode* nodes,size_t count) {
DYMaskPath path{};if(!nodes||count<3||count>32)return path;
int steps=std::min(24,int(256/count));
for(size_t i=0;i<count;i++) {
auto a=nodes[i],b=nodes[(i+1)%count];
bool line=a.x==a.outX&&a.y==a.outY&&b.x==b.inX&&b.y==b.inY;
int n=line?1:steps;
for(int j=0;j<n;j++) {
float t=float(j)/n,q=1-t;int k=path.count++;
path.x[k]=q*q*q*a.x+3*q*q*t*a.outX+3*q*t*t*b.inX+t*t*t*b.x;
path.y[k]=q*q*q*a.y+3*q*q*t*a.outY+3*q*t*t*b.inY+t*t*t*b.y;
}
}
return path;
}
#endif
@@ -0,0 +1,94 @@
#pragma once
#include "DYMask.h"
#ifndef __METAL_VERSION__
#include <cstdint>
#include <initializer_list>
typedef uint32_t DYMaskUInt;
#else
typedef uint DYMaskUInt;
#endif
// Independent versioned mask mathematics. No spatial blur or hidden input transform.
enum DYMaskKind : DYMaskUInt {DYMaskEllipse=0,DYMaskRectangle=1,DYMaskBezier=2,DYMaskLinearGradient=3,DYMaskHSLKey=4,DYMaskLumaKey=5};
enum DYMaskSourceStage : DYMaskUInt {DYMaskSourceOriginal=0,DYMaskSourceAfterGlobal=1,DYMaskSourceLayerInput=2};
enum DYMaskFeatherPlacement : DYMaskUInt {DYMaskFeatherInside=0,DYMaskFeatherOutside=1};
enum : DYMaskUInt {DYMaskInvert=1,DYMaskHueEnabled=2,DYMaskSaturationEnabled=4,DYMaskLightnessEnabled=8,DYMaskFeatherOutsideFlag=16};
struct DYMaskRange {float low,high,softLow,softHigh;};
struct DYMaskParameters {
DYMaskUInt version,kind,sourceStage,flags;
float centerX,centerY,width,height,angle,feather,strength,gradientWidth,imageAspect,reserved;
float hueCenterTurns,hueCoreHalfWidth,hueSoftWidth,neutralChromaLow,neutralChromaHigh;
DYMaskRange saturationRange,lightnessRange;
float inputBlack,inputWhite,inputGamma,outputBlack,outputWhite;
};
struct DYResolvedMask {DYMaskParameters parameters;DYMaskPath path;};
inline float dyMaskSoftStep(float low,float high,float value){if(high<=low)return value>=high?1:0;return dySmooth(low,high,value);}
inline float dyMaskRangeWeight(float value,DYREF DYMaskRange& range){
float low=value>=range.low?1:dyMaskSoftStep(range.low-range.softLow,range.low,value);
float high=value<=range.high?1:1-dyMaskSoftStep(range.high,range.high+range.softHigh,value);
return low*high;
}
inline float dyMaskLeveledCoverage(float raw,DYREF DYMaskParameters& p){
float a=dyClamp((raw-p.inputBlack)/(p.inputWhite-p.inputBlack),0,1);
if(p.inputGamma!=1&&a>0&&a<1)a=pow(a,1/p.inputGamma);
return p.outputBlack+(p.outputWhite-p.outputBlack)*a;
}
inline float dyMaskFinalCoverage(float a,DYREF DYMaskParameters& p){
if(p.flags&DYMaskInvert)a=1-a;
return dyClamp(a*p.strength,0,1);
}
inline float dyMaskLevels(float raw,DYREF DYMaskParameters& p){return dyMaskFinalCoverage(dyMaskLeveledCoverage(raw,p),p);}
inline float dyMaskHSLWeight(float3 source,DYREF DYMaskParameters& p){
float3 c=dyLimit(source);float lo=c.x<c.y?(c.x<c.z?c.x:c.z):(c.y<c.z?c.y:c.z),hi=c.x>c.y?(c.x>c.z?c.x:c.z):(c.y>c.z?c.y:c.z);
// Same signed/HDR interval convention as the quick HSL tools. This is code
// RGB selection; use LumaKey levels when absolute HDR brightness is needed.
float base=lo<0?lo:0,scale=hi-base;if(scale<1)scale=1;
float3 hsl=dyRGBHSL((c-float3{base,base,base})/scale);float weight=1;
if(p.flags&DYMaskHueEnabled){
float distance=dyHueDistance(hsl.x,p.hueCenterTurns),outer=p.hueCoreHalfWidth+p.hueSoftWidth;if(outer>.5f)outer=.5f;
float hue=p.hueCoreHalfWidth>=.5f||distance<=p.hueCoreHalfWidth?1:1-dyMaskSoftStep(p.hueCoreHalfWidth,outer,distance);
float chroma=(hi-lo)/scale;weight*=hue*dyMaskSoftStep(p.neutralChromaLow,p.neutralChromaHigh,chroma);
}
if(p.flags&DYMaskSaturationEnabled)weight*=dyMaskRangeWeight(hsl.y,p.saturationRange);
if(p.flags&DYMaskLightnessEnabled)weight*=dyMaskRangeWeight(hsl.z,p.lightnessRange);
return weight;
}
inline float dyMaskShapeWeight(float x,float y,DYREF DYMaskParameters& p,DYREF DYMaskPath& path){
float dx=(x-p.centerX)*p.imageAspect,dy=y-p.centerY,ca=cos(p.angle),sa=sin(p.angle);
float px=dx*ca+dy*sa,py=-dx*sa+dy*ca;
if(p.kind==DYMaskLinearGradient){
if(p.gradientWidth==0)return px>=0?1:0;
return dyMaskSoftStep(0,1,.5f+px/(p.gradientWidth>1e-12f?p.gradientWidth:1e-12f));
}
float physicalWidth=p.width*p.imageAspect,physicalHeight=p.height;if(physicalWidth<1e-12f)physicalWidth=1e-12f;if(physicalHeight<1e-12f)physicalHeight=1e-12f;
if(p.kind==DYMaskEllipse){float u=px/(physicalWidth*.5f),v=py/(physicalHeight*.5f),r=sqrt(u*u+v*v);if(p.feather==0)return r<=1?1:0;if(p.version==2&&(p.flags&DYMaskFeatherOutsideFlag))return 1-dyMaskSoftStep(1,1+p.feather,r);return 1-dyMaskSoftStep(1-p.feather,1,r);}
float shorter=physicalWidth<physicalHeight?physicalWidth:physicalHeight;
if(p.kind==DYMaskRectangle){float ax=px<0?-px:px,ay=py<0?-py:py,a=physicalWidth*.5f-ax,b=physicalHeight*.5f-ay;if(p.version==2&&(p.flags&DYMaskFeatherOutsideFlag)){if(p.feather==0)return a>=0&&b>=0?1:0;return dyMaskSoftStep(-p.feather*.5f*shorter,0,a<b?a:b);}if(a<0||b<0)return 0;if(p.feather==0)return 1;return dyMaskSoftStep(0,p.feather*.5f,(a<b?a:b)/shorter);}
if(path.count<3||path.count>256)return 0;
float u=px/physicalWidth,v=py/physicalHeight,sx=physicalWidth/shorter,sy=physicalHeight/shorter,distance2=1e10f;bool inside=false;
for(int i=0,j=path.count-1;i<path.count;j=i++){
float ax=path.x[j],ay=path.y[j],bx=path.x[i],by=path.y[i];if((ay>v)!=(by>v))if(u<(bx-ax)*(v-ay)/(by-ay)+ax)inside=!inside;
float ex=(bx-ax)*sx,ey=(by-ay)*sy,xx=(u-ax)*sx,yy=(v-ay)*sy,den=ex*ex+ey*ey,t=den>1e-12f?dyClamp((xx*ex+yy*ey)/den,0,1):0;
xx-=t*ex;yy-=t*ey;float d=xx*xx+yy*yy;if(d<distance2)distance2=d;
}
if(!inside)return 0;if(p.feather==0)return 1;return dyMaskSoftStep(0,p.feather*.5f,sqrt(distance2));
}
inline float dyMaskRawCoverage(float x,float y,float3 source,DYREF DYMaskParameters& p,DYREF DYMaskPath& path){return p.kind==DYMaskHSLKey?dyMaskHSLWeight(source,p):(p.kind==DYMaskLumaKey?dyLuma(dyLimit(source)):dyMaskShapeWeight(x,y,p,path));}
inline float dyMaskOperator(float x,float y,float3 source,DYREF DYMaskParameters& p,DYREF DYMaskPath& path){
if((p.version!=1&&p.version!=2)||p.kind>DYMaskLumaKey)return 0;
float raw=dyMaskRawCoverage(x,y,source,p,path);
return dyMaskLevels(raw,p);
}
#ifndef __METAL_VERSION__
inline DYMaskParameters dyDefaultMaskParameters(){DYMaskParameters p{};p.version=1;p.centerX=p.centerY=.5f;p.width=p.height=p.gradientWidth=.3f;p.imageAspect=p.strength=1;p.feather=.25f;p.hueCoreHalfWidth=1.f/12;p.hueSoftWidth=1.f/24;p.neutralChromaLow=.002f;p.neutralChromaHigh=.02f;p.saturationRange={0,1,0,0};p.lightnessRange={0,1,0,0};p.inputWhite=p.inputGamma=p.outputWhite=1;return p;}
inline bool dyValidMaskParameters(const DYMaskParameters& p){
if((p.version!=1&&p.version!=2)||p.kind>DYMaskLumaKey||p.sourceStage>DYMaskSourceLayerInput||(p.flags&~(p.version==1?15u:31u)))return false;
if((p.flags&DYMaskFeatherOutsideFlag)&&p.kind!=DYMaskEllipse&&p.kind!=DYMaskRectangle)return false;
const float *values=&p.centerX;for(size_t i=0;i<(sizeof(p)-offsetof(DYMaskParameters,centerX))/sizeof(float);i++)if(!std::isfinite(values[i]))return false;
if(fabs(p.centerX)>1000||fabs(p.centerY)>1000||p.width<=0||p.height<=0||p.width>4000||p.height>4000||fabs(p.angle)>1000032||p.feather<0||p.feather>1||p.strength<0||p.strength>1||p.gradientWidth<0||p.gradientWidth>4000||p.imageAspect<=0||p.imageAspect>10000)return false;
if(p.hueCenterTurns<0||p.hueCenterTurns>1||p.hueCoreHalfWidth<0||p.hueCoreHalfWidth>.5f||p.hueSoftWidth<0||p.hueSoftWidth>.5f||p.neutralChromaLow<0||p.neutralChromaHigh>1||p.neutralChromaHigh<=p.neutralChromaLow)return false;
for(auto range:{p.saturationRange,p.lightnessRange})if(range.low<0||range.high>1||range.low>range.high||range.softLow<0||range.softHigh<0||range.softLow>1||range.softHigh>1)return false;
return p.inputBlack>=-65504&&p.inputWhite<=65504&&p.inputWhite-p.inputBlack>=.000001f&&p.inputGamma>=.01f&&p.inputGamma<=100&&p.outputBlack>=0&&p.outputWhite<=1&&p.outputBlack<=p.outputWhite;
}
static_assert(sizeof(DYMaskRange)==16,"mask range shared ABI");
static_assert(sizeof(DYMaskParameters)==128,"mask descriptor shared ABI");
#endif
+364
查看文件
@@ -0,0 +1,364 @@
#pragma once
// Independent local motion tracker. Coordinates use an image origin at the top left.
// No target application's code or runtime libraries are used here.
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <numeric>
#include <vector>
#include <memory>
namespace dy {
struct GrayFrame {
int width = 0, height = 0;
std::vector<float> pixels;
bool valid() const {
return width >= 16 && height >= 16 &&
pixels.size() == static_cast<size_t>(width) * height;
}
static GrayFrame fromRGBA8(const uint8_t* data, int w, int h, size_t stride) {
if (!data || w <= 0 || h <= 0 || stride < static_cast<size_t>(w) * 4) return {};
GrayFrame f{w, h, std::vector<float>(static_cast<size_t>(w) * h)};
for (int y = 0; y < h; ++y) for (int x = 0; x < w; ++x) {
const auto* p = data + y * stride + x * 4;
f.pixels[y * w + x] = (0.2126f * p[0] + 0.7152f * p[1] + 0.0722f * p[2]) / 255.f;
}
return f;
}
static GrayFrame fromBGRA8(const uint8_t* data, int w, int h, size_t stride) {
if (!data || w <= 0 || h <= 0 || stride < static_cast<size_t>(w) * 4) return {};
GrayFrame f{w, h, std::vector<float>(static_cast<size_t>(w) * h)};
for (int y = 0; y < h; ++y) for (int x = 0; x < w; ++x) {
const auto* p = data + y * stride + x * 4;
f.pixels[y * w + x] = (0.2126f * p[2] + 0.7152f * p[1] + 0.0722f * p[0]) / 255.f;
}
return f;
}
};
struct TrackerROI {
float cx = .5f, cy = .5f, width = .25f, height = .25f, angle = 0;
};
struct TrackResult {
float cx = .5f, cy = .5f;
float scale = 1.f, rotation = 0.f;
float confidence = 0.f;
int inliers = 0, features = 0;
bool valid = false;
// Analysis-only additions; the legacy on-disk DYTrackKey stays unchanged.
float scaleX = 1.f, scaleY = 1.f;
};
struct FlowPoint { float x,y; };
struct FlowMatch { FlowPoint p,q; float error; };
class FlowBackend {
public:
virtual ~FlowBackend() = default;
virtual bool reset(const GrayFrame&) = 0;
virtual bool advance(const GrayFrame&,const std::vector<FlowPoint>&,std::vector<FlowMatch>&) = 0;
};
class Tracker {
using P = FlowPoint;
using Match = FlowMatch;
std::shared_ptr<FlowBackend> backend_;
std::vector<P> mask_;
struct Affine {
double a = 1, b = 0, c = 0, d = 1, tx = 0, ty = 0;
P map(P p) const {
return {static_cast<float>(a*p.x+b*p.y+tx), static_cast<float>(c*p.x+d*p.y+ty)};
}
double determinant() const {return a*d-b*c;}
static Affine compose(const Affine& m,const Affine& n) {
return {m.a*n.a+m.b*n.c,m.a*n.b+m.b*n.d,m.c*n.a+m.d*n.c,m.c*n.b+m.d*n.d,
m.a*n.tx+m.b*n.ty+m.tx,m.c*n.tx+m.d*n.ty+m.ty};
}
bool saneStep() const {
double det=determinant(),trace=a*a+b*b+c*c+d*d;
double delta=std::sqrt(std::max(0.,trace*trace-4*det*det));
double lo=std::sqrt(std::max(0.,(trace-delta)*.5)),hi=std::sqrt(std::max(0.,(trace+delta)*.5));
return std::isfinite(trace)&&std::isfinite(tx)&&std::isfinite(ty)&&det>0&&lo>.85&&hi<1.18&&std::abs(std::atan2(c-b,a+d))<.15;
}
};
using Pyramid = std::vector<GrayFrame>;
Pyramid previous_;
std::vector<P> points_;
TrackerROI initialROI_;
TrackResult result_;
Affine cumulative_;
P center_{};
int width_ = 0, height_ = 0, frameIndex_ = 0;
bool active_ = false;
static float distance(P a, P b) { return std::hypot(a.x-b.x, a.y-b.y); }
static float sample(const GrayFrame& f, float x, float y) {
int ix = static_cast<int>(x), iy = static_cast<int>(y);
float dx = x-ix, dy = y-iy;
const auto* p = f.pixels.data() + iy*f.width+ix;
return (1-dy)*((1-dx)*p[0]+dx*p[1]) + dy*((1-dx)*p[f.width]+dx*p[f.width+1]);
}
static bool inside(const GrayFrame& f, P p, int border) {
return p.x >= border && p.y >= border && p.x < f.width-border-1 && p.y < f.height-border-1;
}
static Pyramid makePyramid(const GrayFrame& f) {
Pyramid p{f};
while (p.size() < 5 && p.back().width >= 80 && p.back().height >= 80) {
const auto& src = p.back();
GrayFrame dst{src.width/2, src.height/2, {}};
dst.pixels.resize(static_cast<size_t>(dst.width)*dst.height);
for (int y=0; y<dst.height; ++y) for (int x=0; x<dst.width; ++x) {
// Separable [1 2 1] blur before decimation suppresses aliasing in aerial detail.
float s=0;
for (int j=-1;j<=1;++j) for (int i=-1;i<=1;++i) {
int xx=std::clamp(x*2+i,0,src.width-1), yy=std::clamp(y*2+j,0,src.height-1);
s += src.pixels[yy*src.width+xx]*(i==0?2.f:1.f)*(j==0?2.f:1.f);
}
dst.pixels[y*dst.width+x]=s/16.f;
}
p.push_back(std::move(dst));
}
return p;
}
static bool flow(const Pyramid& prev, const Pyramid& next, P p, P guess, P& q, float& rmse) {
constexpr int radius=4, side=radius*2+1, count=side*side;
int level=static_cast<int>(std::min(prev.size(),next.size()))-1;
for (;level>0;--level) {
float s=static_cast<float>(1<<level);
if (inside(prev[level],{p.x/s,p.y/s},radius+2) &&
inside(next[level],{guess.x/s,guess.y/s},radius+2)) break;
}
q={guess.x/static_cast<float>(1<<level),guess.y/static_cast<float>(1<<level)};
float lastError=0;
for (;level>=0;--level) {
float s=static_cast<float>(1<<level);
P pp{p.x/s,p.y/s};
if (!inside(prev[level],pp,radius+2)) return false;
float reference[count], gx[count], gy[count], mean=0;
double hxx=0,hxy=0,hyy=0;
int k=0;
for (int y=-radius;y<=radius;++y) for (int x=-radius;x<=radius;++x,++k) {
reference[k]=sample(prev[level],pp.x+x,pp.y+y);
mean+=reference[k];
gx[k]=.5f*(sample(prev[level],pp.x+x+1,pp.y+y)-sample(prev[level],pp.x+x-1,pp.y+y));
gy[k]=.5f*(sample(prev[level],pp.x+x,pp.y+y+1)-sample(prev[level],pp.x+x,pp.y+y-1));
hxx+=gx[k]*gx[k];hxy+=gx[k]*gy[k];hyy+=gy[k]*gy[k];
}
mean/=count;
double det=hxx*hyy-hxy*hxy;
if (det < 1e-8 || (hxx+hyy) < 1e-5) return false;
for (int iteration=0;iteration<20;++iteration) {
if (!inside(next[level],q,radius+2)) return false;
float target[count],targetMean=0;
k=0;
for (int y=-radius;y<=radius;++y) for (int x=-radius;x<=radius;++x,++k) {
target[k]=sample(next[level],q.x+x,q.y+y);targetMean+=target[k];
}
targetMean/=count;
double bx=0,by=0,sse=0;
for (k=0;k<count;++k) {
float e=(reference[k]-mean)-(target[k]-targetMean);
bx+=gx[k]*e;by+=gy[k]*e;sse+=e*e;
}
float dx=static_cast<float>((hyy*bx-hxy*by)/det);
float dy=static_cast<float>((hxx*by-hxy*bx)/det);
if (!std::isfinite(dx) || !std::isfinite(dy) || std::hypot(dx,dy)>8.f) return false;
q.x+=dx;q.y+=dy;lastError=std::sqrt(sse/count);
if (dx*dx+dy*dy<.0001f) break;
}
if (level>0) {q.x*=2;q.y*=2;}
}
rmse=lastError;
return inside(next[0],q,radius+2) && rmse<.12f;
}
std::vector<P> detect(const GrayFrame& frame, const std::vector<P>& existing) const {
struct Candidate {P p;float score;};
std::vector<Candidate> candidates;
float halfW=initialROI_.width*width_*.5f;
float halfH=initialROI_.height*height_*.5f;
float c=std::cos(initialROI_.angle),s=std::sin(initialROI_.angle);
double det=cumulative_.determinant();
float bound=0;
for(float x:{-halfW,halfW})for(float y:{-halfH,halfH}){
auto p=cumulative_.map({initialROI_.cx*width_+c*x-s*y,initialROI_.cy*height_+s*x+c*y});
bound=std::max(bound,distance(p,center_));
}
int minX=std::max(8,static_cast<int>(center_.x-bound));
int maxX=std::min(width_-9,static_cast<int>(center_.x+bound));
int minY=std::max(8,static_cast<int>(center_.y-bound));
int maxY=std::min(height_-9,static_cast<int>(center_.y+bound));
float best=0;
for (int y=minY;y<maxY;y+=2) for (int x=minX;x<maxX;x+=2) {
float dx=x-center_.x,dy=y-center_.y;
float oldX=float((cumulative_.d*dx-cumulative_.b*dy)/det);
float oldY=float((-cumulative_.c*dx+cumulative_.a*dy)/det);dx=oldX;dy=oldY;
float u=(c*dx+s*dy)/(2*halfW),v=(-s*dx+c*dy)/(2*halfH);
if (std::abs(u)>.5f || std::abs(v)>.5f) continue;
if(mask_.size()>=3) {
bool inside=false;
for(size_t i=0,j=mask_.size()-1;i<mask_.size();j=i++) {
P a=mask_[j],b=mask_[i];
if((a.y>v)!=(b.y>v))if(u<(b.x-a.x)*(v-a.y)/(b.y-a.y)+a.x)inside=!inside;
}
if(!inside)continue;
}
double xx=0,xy=0,yy=0;
for (int j=-2;j<=2;++j) for (int i=-2;i<=2;++i) {
int idx=(y+j)*width_+x+i;
float gx=(frame.pixels[idx+1]-frame.pixels[idx-1])*.5f;
float gy=(frame.pixels[idx+width_]-frame.pixels[idx-width_])*.5f;
xx+=gx*gx;xy+=gx*gy;yy+=gy*gy;
}
float score=static_cast<float>((xx+yy-std::sqrt((xx-yy)*(xx-yy)+4*xy*xy))*.5);
best=std::max(best,score);
if (score>.0003f) candidates.push_back({{static_cast<float>(x),static_cast<float>(y)},score});
}
std::sort(candidates.begin(),candidates.end(),[](const auto& a,const auto& b){return a.score>b.score;});
std::vector<P> selected=existing;
float minSpacing=std::max(6.f,std::min(width_,height_)*.014f);
for (const auto& candidate:candidates) {
if (candidate.score < best*.012f || selected.size()>=180) break;
bool near=false;
for (const auto& p:selected) if (distance(p,candidate.p)<minSpacing) {near=true;break;}
if (!near) selected.push_back(candidate.p);
}
return selected;
}
static Affine fitModel(const std::vector<Match>& matches,const std::vector<int>& inliers) {
double px=0,py=0,qx=0,qy=0;
for (int i:inliers) {px+=matches[i].p.x;py+=matches[i].p.y;qx+=matches[i].q.x;qy+=matches[i].q.y;}
double n=static_cast<double>(inliers.size());
px/=n;py/=n;qx/=n;qy/=n;
double xx=0,xy=0,yy=0,ux=0,uy=0,vx=0,vy=0;
for (int i:inliers) {
double x=matches[i].p.x-px,y=matches[i].p.y-py;
double u=matches[i].q.x-qx,v=matches[i].q.y-qy;
xx+=x*x;xy+=x*y;yy+=y*y;ux+=u*x;uy+=u*y;vx+=v*x;vy+=v*y;
}
double det=xx*yy-xy*xy,trace=xx+yy;
if (!std::isfinite(det)||det<1e-5||det<trace*trace*1e-5) return {0,0,0,0,0,0};
double a=(ux*yy-uy*xy)/det,b=(uy*xx-ux*xy)/det;
double c=(vx*yy-vy*xy)/det,d=(vy*xx-vx*xy)/det;
return {a,b,c,d,qx-a*px-b*py,qy-c*px-d*py};
}
static bool estimate(const std::vector<Match>& matches,Affine& model,std::vector<int>& inliers,float& medianError) {
if (matches.size()<8) return false;
std::vector<int> best;
double bestError=std::numeric_limits<double>::max();
// Three non-collinear correspondences constrain all six affine parameters.
uint32_t random=0x6c8e9cf5u;
auto rng=[&](){random=random*1664525u+1013904223u;return random;};
for (int attempt=0;attempt<400;++attempt) {
int i=int(rng()%matches.size()),j=int(rng()%matches.size()),k=int(rng()%matches.size());
if (i==j||i==k||j==k) continue;
auto candidate=fitModel(matches,{i,j,k});
if (!candidate.saneStep()) continue;
std::vector<int> ids;double e=0;
for (size_t k=0;k<matches.size();++k) {
double d=distance(candidate.map(matches[k].p),matches[k].q);
if (d<1.6) {ids.push_back(static_cast<int>(k));e+=d*d;}
}
if (ids.size()>best.size() || (ids.size()==best.size() && e<bestError)) {best=std::move(ids);bestError=e;}
}
if (best.size()<8 || best.size()<matches.size()*.52) return false;
for (int pass=0;pass<3;++pass) {
model=fitModel(matches,best);inliers.clear();
for (size_t i=0;i<matches.size();++i)
if (distance(model.map(matches[i].p),matches[i].q)<1.5f) inliers.push_back(static_cast<int>(i));
if (inliers.size()<8) return false;
best=inliers;
}
std::vector<float> errors;
for (int i:inliers) errors.push_back(distance(model.map(matches[i].p),matches[i].q));
std::nth_element(errors.begin(),errors.begin()+errors.size()/2,errors.end());
medianError=errors[errors.size()/2];
// Reject line-like feature distributions that cannot constrain scale/rotation reliably.
double cx=0,cy=0;
for (int i:inliers) {cx+=matches[i].p.x;cy+=matches[i].p.y;}
cx/=inliers.size();cy/=inliers.size();
double xx=0,xy=0,yy=0;
for (int i:inliers) {double x=matches[i].p.x-cx,y=matches[i].p.y-cy;xx+=x*x;xy+=x*y;yy+=y*y;}
double trace=xx+yy,small=(trace-std::sqrt((xx-yy)*(xx-yy)+4*xy*xy))*.5;
return model.saneStep()&&inliers.size()>=matches.size()*.52&&small>inliers.size()*8 && small>trace*.005;
}
public:
void setBackend(std::shared_ptr<FlowBackend> b) {backend_=std::move(b);active_=false;}
void setMask(std::vector<P> p) {mask_=std::move(p);}
bool reset(const GrayFrame& frame,TrackerROI roi) {
active_=false;points_.clear();previous_.clear();cumulative_={};frameIndex_=0;
result_={roi.cx,roi.cy,1,0,0,0,0,false};
if (!frame.valid() || !std::isfinite(roi.cx) || !std::isfinite(roi.cy) ||
!std::isfinite(roi.width) || !std::isfinite(roi.height) || !std::isfinite(roi.angle) ||
roi.width<=0 || roi.height<=0 || roi.width>8 || roi.height>8 || roi.cx<0 || roi.cx>1 || roi.cy<0 || roi.cy>1) return false;
width_=frame.width;height_=frame.height;initialROI_=roi;
center_={roi.cx*width_,roi.cy*height_};
points_=detect(frame,{});
result_.features=static_cast<int>(points_.size());result_.inliers=result_.features;
if (points_.size()<12) return false;
if(backend_){if(!backend_->reset(frame))return false;}else previous_=makePyramid(frame);active_=true;result_.valid=true;result_.confidence=1;
return true;
}
TrackResult track(const GrayFrame& frame) {
if (!active_ || !frame.valid() || frame.width!=width_ || frame.height!=height_) {
result_.valid=false;result_.confidence=0;active_=false;return result_;
}
Pyramid next;if(!backend_)next=makePyramid(frame);
std::vector<Match> matches;matches.reserve(points_.size());
if(backend_) {
if(!backend_->advance(frame,points_,matches)){active_=false;result_.valid=false;result_.confidence=0;return result_;}
} else for (P p:points_) {
P q,back;float error=0,backError=0;
if (!flow(previous_,next,p,p,q,error)) continue;
if (!flow(next,previous_,q,p,back,backError) || distance(back,p)>1.1f) continue;
matches.push_back({p,q,error});
}
Affine model;std::vector<int> inliers;float medianError=0;
result_.features=static_cast<int>(points_.size());
result_.inliers=0;
if (!estimate(matches,model,inliers,medianError)) {
active_=false;result_.valid=false;result_.confidence=0;return result_;
}
double stepScale=std::sqrt(model.determinant());
double stepRotation=std::atan2(model.c-model.b,model.a+model.d);
P nextCenter=model.map(center_);
float retained=static_cast<float>(inliers.size())/points_.size();
float confidence=std::clamp(retained*std::exp(-medianError*.8f),0.f,1.f);
if (stepScale<.9 || stepScale>1.12 || std::abs(stepRotation)>.12 || confidence<.3f ||
!inside(frame,nextCenter,3) || result_.scale*stepScale<.1 || result_.scale*stepScale>10) {
active_=false;result_.valid=false;result_.confidence=confidence;return result_;
}
auto nextCumulative=Affine::compose(model,cumulative_);
// QR decomposition in the initial shape's axes. Output matches the
// persisted position/rotation/two-axis-size model; shear is not authored.
double cs=std::cos(initialROI_.angle),sn=std::sin(initialROI_.angle);
double ax=nextCumulative.a*cs+nextCumulative.b*sn,ay=nextCumulative.c*cs+nextCumulative.d*sn;
double sx=std::hypot(ax,ay),sy=nextCumulative.determinant()/sx;
if(!std::isfinite(sx)||!std::isfinite(sy)||sx<.1||sx>10||sy<.1||sy>10){active_=false;result_.valid=false;result_.confidence=0;return result_;}
cumulative_=nextCumulative;
center_=nextCenter;
result_.cx=center_.x/width_;result_.cy=center_.y/height_;
result_.scale=static_cast<float>(std::sqrt(cumulative_.determinant()));
result_.scaleX=float(sx);result_.scaleY=float(sy);
double relative=std::atan2(ay,ax)-initialROI_.angle;
result_.rotation+=float(std::remainder(relative-result_.rotation,6.2831853071795864769));
result_.confidence=confidence;result_.inliers=static_cast<int>(inliers.size());result_.valid=true;
points_.clear();
for (int i:inliers) points_.push_back(matches[i].q);
if (++frameIndex_%5==0 || points_.size()<60) points_=detect(frame,points_);
previous_=std::move(next);
return result_;
}
TrackResult result() const {return result_;}
bool active() const {return active_;}
void stop() {active_=false;result_.valid=false;}
};
} // namespace dy
+2 -2
查看文件
@@ -17,9 +17,9 @@
<key>CFBundlePackageType</key>
<string>APPL</string>
<key>CFBundleShortVersionString</key>
<string>1.3.1</string>
<string>1.4.0</string>
<key>CFBundleVersion</key>
<string>19</string>
<string>24</string>
<key>LSMinimumSystemVersion</key>
<string>$(MACOSX_DEPLOYMENT_TARGET)</string>
<key>NSHumanReadableCopyright</key>
+103 -43
查看文件
@@ -1,74 +1,134 @@
# 大鱼调色 FxPlug4:色轮复位、浏览器与最近使用交接
# 大鱼调色:1.4.0(24)蒙版、跟踪与可重复工具交接
更新时间:2026-11-01,Asia/Shanghai。
更新日期:2026-11-01,Asia/Shanghai。当前 APP 已完成正式签名、公证、票据、唯一安装与宿主工作流检查;PKG/Release 状态以本仓库相应验证记录为准。
## 当前 1.3.1(19):色轮复位、可调整浏览器与最近使用
## 本轮结果与入口
实际编译 `dbb7ca4a995ef832178a32f35939aed7d3a85012`,APP 公证 `9e93dc7f-04a3-44f9-a1e4-792bd7b31533`,Accepted;票据、Gatekeeper、唯一正式安装与 FCP 12.4 加载通过。发行标签 `v1.3.1-browser-recents-20261101`,包目标 `../发行包/大鱼调色-1.3.1.pkg`。本版本发布结果见 verification/Package.json 和 verification/Release.json。
十二个模块标题右侧已有“添加蒙版”和“再加一层”。第二个HSL等新增工具使用独立UUID、初始化参数、折叠/启停/复位/删除和自己的蒙版;新增工具依次排在原模块之后。原固定float ID、9001资产和1104字节ABI不变,无蒙版旧工程保留原融合内核。新增一级使用Rec.709/Gamma2.4同域默认,新增肤色保护强度零。
新实例及全部还原的输入默认为 Sony S-Log3(数学 ID 28)与 Sony S-Gamut3.Cine(27);输出 Gamma 2.4 / Rec.709、工作 DI/DWG 不变。一级白平衡的可见复位按钮只写方向和强度为零,保持双击复位与一次撤销。
六种蒙版是椭圆、矩形、钢笔、线性渐变、HSL、亮度;支持相加/减去/相交、启停、反转、羽化、强度和几何数值。几何跟踪从父库固定节点 `f8950384e514685c8809fe8e8ee2dd5f16ad0bd7` 移植Metal光流和仿射RANSAC,并适配本产品FxAnalyzer生命周期;支持正向、反向、双向、单帧、取消及单次撤销,过期目标不回写。当前没有新增对Color Finale二进制的依赖,父工程未修改。
浏览器在 CustomParameterAction scope 中取得并立即请求 FxRemoteWindowAPI_v2 的最小/最大尺寸窗口;首个子视图在 reply 返回前同步附着。当前 FCP 实测独立浮动窗口生效。支持网格/列表、缩略图大小、可拖动分隔条和按库保存的窗口/布局偏好;旧宿主保留可分离弹出框回退。窗口尺寸受宿主 80% 上限及屏幕约束。
作者状态:`DYToolState.h/.mm`,9002静态工具文档、9003不保存的OSC会话。渲染:`DYToolRender.inc.h`、`DYToolGPU.h`、`DYGrade.metal`、`tools/build_masked_kernel.py`。面板:`DYMaskPanel.inc.h`、`DYInspector.mm`。原生画面与跟踪:`DYToolOSC.inc.h`、`DYToolHost*.inc.h`、`DYToolFlow.inc.h`、`DYTracking.metal`、`MaskCore/`。归档使用安全类白名单,预设v4包含完整工具/蒙版/轨迹,兼容v1–3。
最近使用保存在当前 XPC 的 NSUserDefaults,key 以库的规范路径隔离;只记录成功且最新的宿主应用确认,失败、取消、过时回调不写。最多 40 个,去重最新优先,最近分类第一位,全部/文件夹也最近优先。首次打开可从已有当前 LUT 初始化;不能补造旧版本未记录的所有历史。LUT 文件不改动,历史偏好不进 Git/PKG。
实际编译源码 `dbf25fe6719f17075362538dad0404951102524d` 已推送。APP公证 `40fdaaaa-1821-4cc8-bec3-c5dc6d8b9f77` Accepted;正式位置仍为 `/Library/Plug-Ins/FxPlug/大鱼调色.app`,Bundle ID仍为 `com.dayu.color`。Release前后均通过222项原生检查。FCP12.4独立合成工程实测HSL第二层0→32而原层0,独立椭圆/矩形、数值编辑、正向99键、双向100键、新增层单帧2键与播放头前进;一次撤销/重做及正常退出重开后完整预设逐字节一致。
verification/BrowserNative.json 为正式路径 201 项;BrowserCustomization.json 为 23 项真实离屏 AppKit 窗口/布局/历史检查;BrowserRegression.json 含 3,025 项虚拟化、取消和应用确认回归。FCP 的 Sony 默认、可见复位、浮动窗口及系统缩放、两种布局、最近排序和关闭重开见 HostBrowserAndReset.json。自由标题栏/边缘拖动未由自动化独立确认;用户开始操作后保留当前状态,未再重启 FCP。Motion、Intel、旧系统未验收。
**实机画面直接拖动、旋转和钢笔手势尚未确认。** 轮廓和工具栏可见,但验收工具的坐标点击没有进入真实宿主hit/event回调。原生模拟宿主已用真实Metal叠加验证命中、拖动写回、一次撤销与Esc,不能把它当成实机手势通过。后续先确认真实鼠标输入,再判断是否存在OSC宿主差异。Motion、Intel、变速/裁剪/非方像素工程未实测;跟踪不含透视/剪切。新增工具标量为静态作者值,只有蒙版轨迹随时间求值;空间蒙版拒绝Cube导出,应保存完整预设。
远端独立恢复编译提交 178 文件、full/strict fsck 及 Metal 重建与正式库一致,见 verification/BrowserRecovery.json。恢复历史版本时仍使用其各自标签和验证记录,不把当前 Sony 默认替代历史中明确保存的设置。
旧模板实例可能保留关闭OSC的10005值,可先存完整预设,再应用新版效果并载入;不自动覆盖旧效果。当前模板使用父库Boolean发布契约,最新插件解析。中间20–23版均未发布最终包,旧生成APP备份在24版宿主确认后清理。远端独立恢复210文件、strict/full fsck、模型模板和着色器重建一致,临时clone已清理。
历史 1.3.0 APP **1.3.0(18)**;实际编译源码 `c2818cbb1157093f80efd2a85cea0cf1509f565e`,Apple 公证 `5de714ac-dd28-4d2b-926f-6c0f424d0e5d`,Accepted,票据和 Gatekeeper 通过。后续文档和安装包提交不改变 APP 编译来源。
证据:[实现说明](research/ToolMaskImplementation.md)、[移植来源](research/ToolMaskPort.json)、[正式安装](verification/Delivery.json)、[222项原生检查](verification/InstalledSelfTest.json)、[宿主结果及缺口](verification/HostToolMasks.json)、[远端恢复](verification/ToolMaskRecovery.json)、[副本清理](verification/ToolMaskCleanup.json)。打包入口 `Packaging/build_pkg.py`,发布入口 `Packaging/publish_release.py`;版本标签、PKG公证和下载摘要见 `verification/Package.json`、`verification/Release.json`,不要将历史版本记录当作当前发行成功。
## 项目身份
## 以下为1.3.1接手时的历史快照
- 源码:`/Volumes/备份/大鱼调色/大鱼调色`;远程 `https://dayu.media/git/dayu/dayu-color.git`,main。
- 主 ID `com.dayu.color`,XPC `com.dayu.color.XPC`。
- 唯一正式 APP `/Library/Plug-Ins/FxPlug/大鱼调色.app`。
- 固定缓存 `/Users/mac/Library/Caches/CodexBuilds/com.dayu.color`;Xcode scheme `Wrapper Application`,Release。
下面各节中的“当前”“下一阶段”和“尚未实现”均指本轮开发前的1.3.1(19),保留作为兼容背景;最新实现以上文和实现说明为准。历史说明整理本身未编译、替换或操作当时的FCP窗口。
## 用户要求与实现
## 1. 下一阶段目标与当前边界
1. 大鱼 CST 输入转换 → 工作空间一级 → 输出转换已取代新实例的还原 LUT;三个阶段合并为一个一级调色卡片,曲线与色域独立选择。移除四个旁路选项,由一级眼睛统一启停。
2. 一级白平衡改为原 CST 色轮,保留原图、+104° 方位、/5 精细拖动、圆形限幅、双击归零和 BASIS 强度平方×4,增加方向键微调。隐藏两根旧滑块;角度范围修正为 0–360°,旧值保持原解释。
3. 直接移植父级“大鱼调色盘”的可变蜘蛛盘与 CPU/Metal 数学、固定、多选、同列联动、整环/整列及复位;点数 6/8/12/16/24,两轴可独立。中性盘精确直通,眼睛/混合独立,Cube 导出包含蜘蛛盘。
4. 新实例与全部还原默认展开一级调色、蜘蛛盘校色仪、基础调整,其余折叠,所有眼睛开启。标题只折叠,小眼睛只启停,分别保存。用户“沉默展开”按“默认展开”实现。
5. 蜘蛛盘完整网格、固定点、密度和联动状态随现有 DYAssetState 保存;预设 schema 3 写 JSON 网格,旧预设可读。旧阶段/旁路参数保留注册,仅打开旧工程不改变原画面;明确编辑 CST 或复位才清理旧旁路。
用户最新需求:继续增加**蒙版、跟踪,以及自行添加工具的能力**。明确例子是:一层 HSL 不够时,可以再添加一个 HSL,分别调整。
## 实现与来源
这里的核心是“同类工具可有多个独立实例”。新增 HSL 不能只是另一张面板共用原 HSL 的参数。蒙版应能绑定到具体工具实例,跟踪结果应驱动对应蒙版。
`DYNewPanels.inc.h` 是色轮/蜘蛛盘界面适配;`DYSpiderDisc.inc.h` 复用原盘交互,`SpiderCore` 复用原数学,`DYSpiderState.h` 管理归档与 JSON 验证。原 944 字节调色前缀和新增 CST 布局保持,控制尾部追加一级 master、蜘蛛 eye 和 mix。生产 shader 通过当前仓库内源码及已版本化 LLVM 重建。
**上述功能尚未在“大鱼调色”实现。** 当前 1.3.1 是固定模块调色器;“大鱼调色盘”的图层、蒙版和跟踪代码只是下一阶段参考,不能把父库已完成的功能写成当前产品已完成。
参考仓库只读:大鱼 CST `973766b51dbcab3ab5092f1955d753575cd32d89`,大鱼调色盘 `f8950384e514685c8809fe8e8ee2dd5f16ad0bd7`。完整 SHA 摘要见 research/SpiderAndBalanceSources.json;边界见 research/SpiderAndBalanceIntegration.md。兄弟仓库和用户资料未改动。
建议开发次序:工具实例和第二个 HSL → 每实例蒙版 → 宿主画面控件 → 蒙版跟踪 → 持久化、撤销和正式交付。设计、源码入口、迁移风险及验收清单见 [蒙版跟踪与工具栈续作方案](research/MaskTrackingAndToolStack.md)。其中标为“建议”的内容是接手方案,不代表用户已经逐项指定所有类型和操作。
## 验证
## 2. 实际项目与可恢复节点
- verification/SpiderAndBalance.json:正式安装路径 198 项,含真实离屏 AppKit 鼠标事件、撤销配对、归档/preset、9 组原 CPU/生产 Metal 蜘蛛盘像素误差 0、Cube 和 21 组独立 CST 对照。
- verification/SpiderMath.json:25 种网格、204,683 项,CPU/Metal 最大相对误差约 1.79e-6。
- verification/InstalledSelfTest.json:正式版常规 155 项。
- verification/HostSpiderAndBalance.json:FCP 12.4 实际面板、默认、键盘调整、菜单撤销/重做、联动及 12×8 密度、固定和整环、眼睛/折叠、保存重开通过,最后恢复默认。坐标注入未激活远程控件,宿主拖动/双击未确认;不能拿离屏事件冒充该项已验收。
- verification/SpiderRecovery.json:实际编译节点远端独立克隆 168 文件,full/strict fsck,重建 Metal 摘要与正式库一致;临时 clone 已清理。
| 项目 | 当前值 |
| --- | --- |
| 主源码目录 | `/Volumes/备份/大鱼调色/大鱼调色` |
| 远程 / 分支 | `https://dayu.media/git/dayu/dayu-color.git` / `main` |
| 文档整理前 main | `bbdd47d1d74e241f1f144bb2c245204e86973b3f` |
| 本次交接标签 | `handoff-mask-tracking-tools-20261101`;最终提交可通过此标签解析 |
| 当前正式版本 | **1.3.1(19)** |
| APP 实际编译源码 | `dbb7ca4a995ef832178a32f35939aed7d3a85012` |
| 正式版本标签 | `v1.3.1-browser-recents-20261101` |
| 正式版本标签提交 | `281721bda11484c23f294b4f0d9e0b30ef829288` |
| 主 ID / 插件 ID | `com.dayu.color` / `com.dayu.color.XPC` |
| 唯一正式 APP | `/Library/Plug-Ins/FxPlug/大鱼调色.app` |
| 唯一 FCP 模板 | `/Users/mac/Movies/Motion Templates.localized/Effects.localized/大鱼调色/大鱼调色/大鱼调色.moef` |
| 固定构建缓存 | `/Users/mac/Library/Caches/CodexBuilds/com.dayu.color` |
| 工程 / Scheme | `大鱼调色.xcodeproj` / `Wrapper Application`,Release |
Motion、Intel、旧系统和宿主逐像素导出一致性未验收。
工作目录、APP 编译提交、发行标签提交与后续文档提交是不同概念。恢复正式程序源码取编译提交;恢复含包记录的发行节点取版本标签;继续下一阶段从最新 main 或本次交接标签开始。已有历史版本、标签和安装包保留。
## 交付和恢复
## 3. 已交付行为,后续须保留
版本标签 `v1.3.0-spider-balance-20261101`,正式包 `../发行包/大鱼调色-1.3.0.pkg`。本版本 PKG 公证与 Release 下载校验以 verification/Package.json 和 verification/Release.json 为准。历史版本标签和附件保持。
- 一级调色将输入转换、工作空间、一级参数和输出转换放在一张卡片中。使用大鱼 CST 的固定源码数学取代新实例的输入还原 LUT;四个可见旁路选项已移除,一级眼睛统一启停。旧输入 LUT、旧参数 ID 和兼容解释仍保留。
- 新实例及全部还原:输入 **Sony S-Log3(28)/ S-Gamut3.Cine(27)**;工作 **DaVinci Intermediate(10)/ DaVinci Wide Gamut(16)**;输出 **Gamma 2.4(1002)/ Rec.709(22)**;自动色调映射关闭。不要根据曲线名称覆盖用户手选色域。
- 一级白平衡采用原 CST 色轮,保留原图、+104° 方位、/5 精细拖动、双击复位和方向键微调。底部可见“复位”只将该色轮方向、强度置零。原 BASIS 强度平方×4 的数学不变。
- 蜘蛛盘来自“大鱼调色盘”,默认联动 6×6、31 节点;两轴可分别选择 6/8/12/16/24。固定、多选、同列自由点联动、整环/整列、复位、归档和 Cube 导出已接入。中性盘精确直通。
- 新实例默认展开**一级调色、蜘蛛盘校色仪、基础调整**,其他模块折叠,全部眼睛打开。标题仅折叠,眼睛仅启停;状态独立保存。黑白混合默认 0%。
- 风格 LUT 最多五层。库路径 `/Users/mac/Movies/大鱼调色LUT/look LUTs`。后台导入、取消、最后一次选择生效和 UTF-8/16/32 等编码兼容均保留。
- LUT 浏览器在 FCP 中使用独立宿主浮动窗口。网格/列表、缩略图大小、可调整侧栏、窗口/布局偏好按库保存。最近使用分类第一位,成功应用后去重、最新优先,最多 40 个;全部及文件夹也优先显示最近项。旧版未记录的所有历史不能凭空补造;首次打开可从已有当前 LUT 初始化。
- 33³ Cube 导出包含开启的 CST、一级白平衡、蜘蛛盘及其它逐像素色彩操作,遵循眼睛开关,折叠不影响导出;不含纹理、清晰度、去朦胧和逐画面统计。将来出现空间蒙版/跟踪后必须重新定义并明确提示导出边界。
源码检查点:`python3 tools/checkpoint.py '<说明>' <路径...>`;APP:`python3 tools/deliver.py`;PKG:`python3 Packaging/build_pkg.py --pkg-forge-repo /Users/mac/Documents/dayu-git/repositories/pkg-forge`;Release:`python3 Packaging/publish_release.py --tag v1.3.0-spider-balance-20261101 --notes Packaging/Release-1.3.0.md`。入口自带适用锁,勿外层嵌套获取同锁。
## 4. 当前实现结构与兼容约束
用户 LUT `~/Movies/大鱼调色LUT/look LUTs` 不导入、不删除、不打包。验收采用 tools/create_spider_host_fixture.py 生成的独立合成色卡和 1.12 DTD 校验,用户媒体和原有项目未编辑。完整恢复见 RECOVERY.md;凭据与签名私钥独立恢复。
| 文件 / 位置 | 接手用途 |
| --- | --- |
| `大鱼调色/Plugin/DYModel.h/.mm` | 234 个固定 float 参数、参数 ID、默认值、资产与界面归档 |
| `大鱼调色/Plugin/DYUniforms.h` | 当前 CPU/Metal 缓冲 1104 字节;原 944 字节前缀保持;CST 在偏移 944 追加 |
| `大鱼调色/Plugin/DYInspector.mm` | 固定卡片、标题/眼睛、预设 v3、LUT 提交与浏览器宿主 API |
| `大鱼调色/Plugin/DYNewPanels.inc.h` | 一级白平衡色轮、可见复位、蜘蛛盘面板 |
| `大鱼调色/Plugin/DYColorTables.mm` | HSL、白平衡、颜色分级等 LUT 构建与缓存 |
| `大鱼调色/Plugin/DYRenderer.mm` | CST 前段、固定调色链、蜘蛛盘、Metal 资源、预览、Cube 导出 |
| `大鱼调色/Plugin/DYGrade.metal`、`tools/kernels/*.ll` | Metal 边界和已版本化运算内核;当前固定调色链有融合执行,尚非工具栈 |
| `大鱼调色/Plugin/DYPlugIn.mm` | FxTileableEffect、按宿主时间生成渲染状态、归档白名单及导出 |
| `大鱼调色/Plugin/DYLUTBrowser.mm`、`DYLUTLibrary.mm` | 窗口/布局、异步确认、最近使用;不要混入工具作者数据 |
## 1.2.0 正式 PKG
当前两项 custom 参数:`9000 DYInspectorToken`(schema 2,folds 字典),`9001 DYAssetState`(LUT paths、spiderMesh、spiderLinked)。**9001 注册为 NOT_ANIMATABLE**,不能简单把动态工具塞进去就宣称支持宿主参数关键帧。预设 JSON 版本是 **3**;插件临时渲染状态的 schema 是 **1**;它们是不同格式的版本号。
正式包 `../发行包/大鱼调色-1.2.0.pkg`,13,818,397 字节,SHA-256 `9fba4f0c1a313a6da8374b683f7e6b41af70388d7a7a180e26b9e236a9ba64a1`。PKG 公证 `c7b97b0f-57c8-45d3-a4d7-7db8e8694487`,Accepted;Installer 团队 B3W25FX5H5、票据、Gatekeeper 及 20 项展开验包通过。包内 APP 与已验收正式安装一致,未重复运行安装器。
当前 HSL 只有一组 `hsl*` 固定字段和一份 HSL 查表。重复工具需要独立身份、参数、缓存和撤销目标。父库 `DYGrade` 是 1032 字节,与本项目 `DYUniforms` 不同;不能直接复制其参数号、POD、Bundle ID 或整个插件入口覆盖当前产品。
正式 Release 已发布并完整下载校验:[1.2.0 Release](https://dayu.media/git/dayu/dayu-color/releases/tag/v1.2.0-cst-fold-20261101),Release ID 363,附件 ID 10。关联标签完整提交 `8074444259fbacc758ec003aa91a6331b6224a85`,APP 实际编译 `48b00c85799b0226ba32aba3f2e5397aa0e509ed`;附件 13,818,397 字节,SHA-256 `9fba4f0c1a313a6da8374b683f7e6b41af70388d7a7a180e26b9e236a9ba64a1`。草稿下载验证后才发布,发布后再次用上传器完整下载并回读核对;仅一次附件上传,未覆盖历史附件或移动标签。浏览器临时下载副本已按大小、摘要和来源核实清理,本地正式发行包保留。
归档、预设、复制、相等性、hash、允许解码类和渲染状态都必须一起演进。旧字段与数学 ID 不重排;旧工程无新增状态时保留原画面。UI 折叠键在多工具场景下应按实例 ID 隔离,不能全部共用 `hsl`。
## 1.3.0 正式 PKG
## 5. 可复用参考:父级“大鱼调色盘”
正式包 `../发行包/大鱼调色-1.3.0.pkg`,14,066,399 字节,SHA-256 `36c251722d3c9e4aaed8d5a09bf5afd3bf84039e9d1161c63635ab9d8224f506`。PKG 公证 `f6b25757-1e6b-4260-9667-5baecce8b3d4`,Accepted;Installer 团队 B3W25FX5H5、可信时间戳、票据、Gatekeeper 和 20 项真实展开验包通过。包内 APP 与已验收正式安装一致,未重复运行安装器。APP 编译源码 `c2818cbb1157093f80efd2a85cea0cf1509f565e`。正式包保留,临时展开副本由打包入口清理。
只读目录 `/Volumes/备份/大鱼调色/大鱼调色盘`;远程 `https://dayu.media/git/dayu/dayu-colorplate.git`。本次核对干净 HEAD `f8950384e514685c8809fe8e8ee2dd5f16ad0bd7`。其正式 2.0.0(68)编译源码为 `d05994d5f4547687511bef524efe8c881e8a5c9c`,标签 `v2.0.0-build68`。
正式 Release 已发布并完成草稿、正式链接两次完整下载校验:[1.3.0 Release](https://dayu.media/git/dayu/dayu-color/releases/tag/v1.3.0-spider-balance-20261101),Release ID 365,附件 ID 11,关联标签提交 `6528f888affe0acdd4292bc0c5ae0dac3a89b5a5`,实际 APP 编译 `c2818cbb1157093f80efd2a85cea0cf1509f565e`。附件 14,066,399 字节,SHA-256 `36c251722d3c9e4aaed8d5a09bf5afd3bf84039e9d1161c63635ab9d8224f506`;只上传一次,未覆盖历史附件或移动标签。草稿浏览器下载副本已按来源、创建时间、字节数和摘要确认后清理,正式发行包保留。标签远端恢复 172 文件、full/strict fsck 通过,见 verification/SpiderReleaseRecovery.json。
先读父库 `HANDOFF.md`、`research/tracking-host-lifecycle.md` 及 `verification/release-2.0.0-build68.json`。该库记录了矩形/椭圆/闭合钢笔区域、前后/双向/单帧、位置/旋转/独立横纵缩放、取消保留可信段和一次撤销等实现与宿主证据。它输出仿射分解后的这些变换,不能宣传为透视/剪切跟踪或任意遮挡均可靠。
## 1.3.1 正式 PKG
下一阶段按具体功能复用其作者状态、蒙版数学、OSC 和 FxAnalyzer 生命周期适配,源文件导航见续作方案。父库现有交接另有胶片/CMS等任务,**不属于本次“大鱼调色”新增范围**。不改动兄弟仓库、不替换兄弟 APP、不恢复或覆盖其用户调色文件。
正式包 `../发行包/大鱼调色-1.3.1.pkg`,14,073,683 字节,SHA-256 `954b10c581f31d23a8c417a6f37b24fae19939786dce8733b4d6f09c7ed3adae`。PKG 公证 `85cad776-c3d7-4037-9643-24041b269002`,Accepted;Installer 团队 B3W25FX5H5、可信时间戳、票据、Gatekeeper 和 20 项真实展开验包通过。包内 APP 与已验收的正式安装一致,APP 实际编译 `dbb7ca4a995ef832178a32f35939aed7d3a85012`;未重复执行系统安装。
## 6. 验证现状与用户工作保护
| 证据 | 本版本实际覆盖 |
| --- | --- |
| `verification/InstalledSelfTest.json` | 正式路径常规 158 项原生检查 |
| `verification/BrowserNative.json` | 正式路径 201 项,含独立 CST 像素参照、色轮/蜘蛛盘、归档与渲染 |
| `verification/BrowserCustomization.json` | 23 项离屏浏览器、几何/布局/历史检查 |
| `verification/BrowserRegression.json` | 67 项回归,含 3,025 项目录虚拟化、取消及应用确认 |
| `verification/SpiderMath.json` | 25 种网格、204,683 项数学检查 |
| `verification/HostBrowserAndReset.json` | FCP 12.4 的 Sony 默认、可见复位、独立窗口及系统缩放、两种布局、最近排序、浏览器关闭重开 |
| `verification/BrowserRecovery.json` | 编译节点远端恢复 178 文件、fsck、Metal 重建与正式库一致 |
| `verification/BrowserReleaseRecovery.json` | 发行节点远端恢复 184 文件、fsck |
自由标题栏/窗口边缘拖动未由自动化独立确认。用户开始操作浏览器后,保留其当时的网格布局、约 197.97 缩略图大小、窗口位置和 LUT 选择,**未再次重启 FCP 或全部还原**。这些是当时观察,不是要求下一轮强制恢复的偏好;接手以用户最新操作为准。浏览器关闭重开已测,不写成此次已重新冷启动宿主。Motion、Intel、旧系统未验收。
测试库位于 `/Users/mac/Library/Caches/CodexBuilds/com.dayu.color/fcp-qa/大鱼调色_验收.fcpbundle`;本轮独立项目 `大鱼调色_1.3.1_浏览器与复位`。只读/引用现有 LUT,未导入或删除用户 LUT。新功能用独立合成运动素材验收,不修改用户正在工作的调色、跟踪或媒体。
## 7. 正式交付与发布记录
- APP 公证:`9e93dc7f-04a3-44f9-a1e4-792bd7b31533`,Accepted。
- PKG 公证:`85cad776-c3d7-4037-9643-24041b269002`,Accepted。
- 正式包:`/Volumes/备份/大鱼调色/发行包/大鱼调色-1.3.1.pkg`;14,073,683 字节。
- SHA-256:`954b10c581f31d23a8c417a6f37b24fae19939786dce8733b4d6f09c7ed3adae`。
- [1.3.1 Release](https://dayu.media/git/dayu/dayu-color/releases/tag/v1.3.1-browser-recents-20261101),Release ID 366,附件 ID 12;附件下载链接见 `verification/Release.json`。
- APP/PKG 的 Developer ID、票据、Gatekeeper、20 项展开验包通过。草稿与正式链接均完整下载校验,只上传一次。正式 APP 已安装,本轮未重复执行 PKG 安装器。
详细恢复与历史仍在 [RECOVERY.md](RECOVERY.md)。本次整理不修改上述正式发行标签、附件或程序版本。
## 8. 下一位接手的操作入口
1. 读取本文件、续作方案和本机 `/Users/mac/.codex/AGENTS.md`;核对 main、本地未提交改动、远端及同产品任务,保留用户正在操作的 FCP 状态。
2. 先完成工具实例/参数/顺序/迁移合同,以“两个独立 HSL”形成可验收的第一阶段;避免先给所有模块套一个全局蒙版而日后重做。
3. 再按续作方案接蒙版、OSC、精确时间分析、取消和单次 Undo/Redo。每阶段提交并立即推送;只暂存本任务文件。
4. 模型修改后刷新模板:`python3 tools/build_template.py --refresh-model --overwrite`。
5. 编译和 CLI 检查可在固定缓存执行;用户可见验收必须从正式安装的已公证版本进行。正式交付使用 `python3 tools/deliver.py`,它持有产品锁并等待宿主验收输入 `complete`。
6. PKG 入口:`python3 Packaging/build_pkg.py --pkg-forge-repo /Users/mac/Documents/dayu-git/repositories/pkg-forge`。发布入口:`python3 Packaging/publish_release.py --tag <新标签> --notes <对应说明>`。不要复用本次版本号、覆盖旧包或移动旧标签。
7. 产品身份、正式路径、逐层签名、公证、票据、PluginKit 唯一登记、生成副本清理、Release 完整下载及远端恢复都继续按全局约定执行。证书/profile/权限在下次发布时重新复核,凭据不进文档或源码。
可直接用于下一聊的任务描述:
> 先读“大鱼调色FxPlug4交接.md”和 research/MaskTrackingAndToolStack.md,从当前 1.3.1(19)继续。我要能添加多个独立工具,例如第二个 HSL,并给具体工具添加蒙版及蒙版跟踪。参考父级“大鱼调色盘”,保留当前 CST、折叠/眼睛、蜘蛛盘、LUT 浏览器和最近使用行为,保护已有工程和当前用户操作,分阶段验证并完成正式交付。