From 4aaa5f0ddc5383a10fe5bb498ceeb077b16ff76f Mon Sep 17 00:00:00 2001 From: Kyle Date: Sun, 18 Jan 2026 17:33:47 +0800 Subject: [PATCH 1/4] Add ShapeStyledDisplayList support --- .../RendererEffect/RendererEffect.swift | 4 +- .../ShapeStyle/ShapeStyleRendering.swift | 137 ++++++++++++++++-- .../ShapeStyle/ShapeStyledLeafView.swift | 85 +++++++++-- 3 files changed, 200 insertions(+), 26 deletions(-) diff --git a/Sources/OpenSwiftUICore/Render/RendererEffect/RendererEffect.swift b/Sources/OpenSwiftUICore/Render/RendererEffect/RendererEffect.swift index f455009f8..d25e5a2da 100644 --- a/Sources/OpenSwiftUICore/Render/RendererEffect/RendererEffect.swift +++ b/Sources/OpenSwiftUICore/Render/RendererEffect/RendererEffect.swift @@ -179,13 +179,13 @@ private struct RendererEffectDisplayList: Rule, AsyncAttribute, Scrapeab } let version = DisplayList.Version(forUpdate: ()) let proxy = GeometryProxy( - owner: .current!, + owner: attribute.identifier, size: $size, environment: $environment, transform: $transform, position: $position, safeAreaInsets: $safeAreaInsets, - seed: .init(bitPattern: numericCast(version.value)) + seed: UInt32(truncatingIfNeeded: version.value) ) let e: DisplayList.Effect diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRendering.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRendering.swift index b0be82412..74b6edab5 100644 --- a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRendering.swift +++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRendering.swift @@ -2,10 +2,13 @@ // ShapeStyleRendering.swift // OpenSwiftUICore // -// Audited for 6.0.87 +// Audited for 6.5.4 // Status: WIP // ID: 3890C65F12EA82A4BC5FBD33046B67FA (SwiftUICore) +package import OpenAttributeGraphShims +package import OpenCoreGraphicsShims + extension ShapeStyle { package typealias RenderedShape = _ShapeStyle_RenderedShape package typealias RenderedLayers = _ShapeStyle_RenderedLayers @@ -21,32 +24,128 @@ package struct _ShapeStyle_RenderedShape { case image(GraphicsImage) case alphaMask(DisplayList.Item) } + + var shape: ShapeStyle.RenderedShape.Shape + + var contentSeed: DisplayList.Seed + + var frame: CGRect + + var interpolatorData: (group: DisplayList.InterpolatorGroup, serial: UInt32)? + + var item: DisplayList.Item + + var options: DisplayList.Options + + @Attribute var environment: EnvironmentValues + + var blendMode: GraphicsBlendMode = .normal + + var opacity: Float + + private struct LayerNeeds: OptionSet { + let rawValue: UInt8 + } + + private var layerNeedes: LayerNeeds + + package init( + _ shape: ShapeStyle.RenderedShape.Shape, + frame: CGRect, + identity: DisplayList.Identity, + version: DisplayList.Version, + contentSeed: DisplayList.Seed, + options: DisplayList.Options, + environment: Attribute + ) { + self.shape = shape + self.contentSeed = contentSeed + self.frame = frame + self.interpolatorData = nil + self.item = .init( + .empty, + frame: frame, + identity: identity, + version: version + ) + self.options = options + self._environment = environment + self.blendMode = .normal + self.opacity = 1.0 + self.layerNeedes = [] + } + + package mutating func renderItem( + name: ShapeStyle.Name, + styles: Attribute, + layers: inout ShapeStyle.RenderedLayers + ) { + _openSwiftUIUnimplementedFailure() + } + + package mutating func commitItem() -> DisplayList.Item { + _openSwiftUIUnimplementedFailure() + } + + package mutating func background(_ other: inout ShapeStyle.RenderedShape) { + _openSwiftUIUnimplementedFailure() + } } package struct _ShapeStyle_RenderedLayers { + var group: ShapeStyle.InterpolatorGroup? + + private enum Layers { + case empty + case item(DisplayList.Item) + case itesm([DisplayList.Item]) + } + + private var layers: Layers = .empty + + init(group: ShapeStyle.InterpolatorGroup?) { + self.group = group + } + + func commit( + shape: inout ShapeStyle.RenderedShape, + options: DisplayList.Options + ) -> DisplayList { + _openSwiftUIUnimplementedFailure() + } + + func beginLayer( + id: ShapeStyle.LayerID, + style: ShapeStyle.Pack.Style?, + shape: inout ShapeStyle.RenderedShape + ) { + _openSwiftUIUnimplementedFailure() + } + + func endLayer(shape: inout ShapeStyle.RenderedShape) { + _openSwiftUIUnimplementedFailure() + } } +// MARK: - _ShapeStyle_LayerID + package enum _ShapeStyle_LayerID: Equatable { case unstyled - case styled(_ShapeStyle_Name, UInt16) - case customStyle(Swift.UInt32) + case styled(ShapeStyle.Name, UInt16) + case customStyle(UInt32) case named(String?) } -final package class _ShapeStyle_InterpolatorGroup/*: DisplayList.InterpolatorGroup*/ { - struct Layer { +final package class _ShapeStyle_InterpolatorGroup: DisplayList.InterpolatorGroup { + private struct Layer { let id: ShapeStyle.LayerID - let serial: UInt32 - var style: ShapeStyle.Pack.Style - var state: DisplayList.InterpolatorLayer - var isRemoved:Bool } - var layers: [Layer] = [] + private var layers: [Layer] = [] var contentsScale: Float = .zero @@ -57,11 +156,23 @@ final package class _ShapeStyle_InterpolatorGroup/*: DisplayList.InterpolatorGro var cursor: Int32 = .zero - init() { - _openSwiftUIEmptyStub() - } +// init() { +// _openSwiftUIEmptyStub() +// } } extension DisplayList { struct InterpolatorLayer {} } + + +extension ShapeStyle.Pack.Style { + package func draw( + _ path: Path, + style: PathDrawingStyle, + in ctx: GraphicsContext, + bounds: CGRect? + ) { + _openSwiftUIUnimplementedFailure() + } +} diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyledLeafView.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyledLeafView.swift index bf10f96c2..11e534c6e 100644 --- a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyledLeafView.swift +++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyledLeafView.swift @@ -4,7 +4,7 @@ // // Audited for 6.5.4 // Status: WIP -// ID: E1641985C375D8826E6966D4F238A1B8 +// ID: E1641985C375D8826E6966D4F238A1B8 (SwiftUICore) package import Foundation package import OpenAttributeGraphShims @@ -122,7 +122,7 @@ package struct ShapeStyledResponderData: ContentResponder where V: ShapeStyle // TODO: ShapeStyledResponderFilter -// MARK: - ShapeStyledDisplayList [WIP] +// MARK: - ShapeStyledDisplayList struct ShapeStyledDisplayList: StatefulRule, AsyncAttribute where V: ShapeStyledLeafView { let group: ShapeStyle.InterpolatorGroup? @@ -174,16 +174,79 @@ struct ShapeStyledDisplayList: StatefulRule, AsyncAttribute where V: ShapeSty typealias Value = DisplayList - func updateValue() { - // FIXME - let view = view as! StyledTextContentView - var item = DisplayList.Item( - .content(.init(.text(view, CGSize(width: 50, height: 50)), seed: .init())), - frame: .zero, + mutating func updateValue() { + var (view, viewChanged) = $view.changedValue() + + let shouldUpdateSeed: Bool + let version: DisplayList.Version + let mustUpdate = view.mustUpdate(data: data, position: $position) + + if mustUpdate || viewChanged || contentSeed.value == 0 { + shouldUpdateSeed = true + version = .init(forUpdate: ()) + } else { + let excluding = [$position.identifier, $containerPosition.identifier, $view.identifier] + shouldUpdateSeed = Graph.anyInputsChanged(excluding: excluding) + version = .init(forUpdate: ()) + } + if shouldUpdateSeed { + contentSeed = .init(version) + } + + let proxy = GeometryProxy( + owner: attribute.identifier, + size: $animatedSize, + environment: $environment, + transform: $transform, + position: $position, + safeAreaInsets: $safeAreaInsets, + seed: UInt32(truncatingIfNeeded: version.value) + ) + let position = position + let containerPosition = containerPosition + let resultSize = V.animatesSize ? animatedSize.value : size + let framedShape = proxy.asCurrent { + view.shape(in: resultSize) + } + let offset = position - containerPosition + var layers = ShapeStyle.RenderedLayers(group: group) + if V.hasBackground { + let backgroundFramedShape = proxy.asCurrent { + view.backgroundShape(in: resultSize) + } + switch backgroundFramedShape.shape { + case .empty: break + default: + var renderedShape = ShapeStyle.RenderedShape( + backgroundFramedShape.shape, + frame: backgroundFramedShape.frame.offset(by: offset), + identity: identity, + version: version, + contentSeed: contentSeed, + options: options, + environment: $environment + ) + renderedShape.renderItem( + name: .background, + styles: $styles, + layers: &layers + ) + } + } + var renderedShape = ShapeStyle.RenderedShape( + framedShape.shape, + frame: framedShape.frame.offset(by: offset), identity: identity, - version: .init() + version: version, + contentSeed: contentSeed, + options: options, + environment: $environment + ) + renderedShape.renderItem( + name: .foreground, + styles: $styles, + layers: &layers ) - item.canonicalize(options: options) - value = DisplayList(item) + value = layers.commit(shape: &renderedShape, options: options) } } From 67a68a3e680a2c0843fba9cecad0f02c3ccef7c4 Mon Sep 17 00:00:00 2001 From: Kyle Date: Sun, 18 Jan 2026 18:39:55 +0800 Subject: [PATCH 2/4] Add _ShapeStyle_RenderedLayers support for image --- .../ShapeStyle/ShapeStyleRendering.swift | 74 ++++++++++++++++++- 1 file changed, 73 insertions(+), 1 deletion(-) diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRendering.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRendering.swift index 74b6edab5..719da750c 100644 --- a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRendering.swift +++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRendering.swift @@ -80,7 +80,48 @@ package struct _ShapeStyle_RenderedShape { styles: Attribute, layers: inout ShapeStyle.RenderedLayers ) { - _openSwiftUIUnimplementedFailure() + switch shape { + case let .text(contentView): + // Text rendering + _ = contentView + _openSwiftUIUnimplementedWarning() + break + case let .image(graphicsImage): + if graphicsImage.isTemplate { + if case let .vectorGlyph(glygh) = graphicsImage.contents { + renderVectorGlyph( + glygh, + size: graphicsImage.size, + orientation: graphicsImage.orientation, + name: name, + styles: styles.value, + layers: &layers + ) + } else { + let style = styles.value[name, 0] + layers.beginLayer( + id: .styled(name, 0), + style: style, + shape: &self + ) + render(style: style) + layers.endLayer(shape: &self) + } + } else { + renderUnstyledImage(graphicsImage, layers: &layers) + } + case .path, .alphaMask: + let style = styles.value[name, 0] + layers.beginLayer( + id: .styled(name, 0), + style: style, + shape: &self + ) + render(style: style) + layers.endLayer(shape: &self) + case .empty: + break + } } package mutating func commitItem() -> DisplayList.Item { @@ -90,6 +131,37 @@ package struct _ShapeStyle_RenderedShape { package mutating func background(_ other: inout ShapeStyle.RenderedShape) { _openSwiftUIUnimplementedFailure() } + + private func render(style: ShapeStyle.Pack.Style) { + _openSwiftUIUnimplementedFailure() + } + + private func renderVectorGlyph( + _ glyph: ResolvedVectorGlyph, + size: CGSize, + orientation: Image.Orientation, + name: ShapeStyle.Name, + styles: ShapeStyle.Pack, + layers: inout ShapeStyle.RenderedLayers + ) { + _openSwiftUIUnimplementedFailure() + } + + private mutating func renderUnstyledImage( + _ graphicsImage: GraphicsImage, + layers: inout ShapeStyle.RenderedLayers + ) { + layers.beginLayer( + id: .unstyled, + style: nil, + shape: &self + ) + item.value = .content(DisplayList.Content( + .image(graphicsImage), + seed: contentSeed + )) + layers.endLayer(shape: &self) + } } package struct _ShapeStyle_RenderedLayers { From 1dcc76c34119b836b13cef509a44b1e2d4bc9b3a Mon Sep 17 00:00:00 2001 From: Kyle Date: Sun, 18 Jan 2026 20:43:58 +0800 Subject: [PATCH 3/4] Add image render support --- .../Render/DisplayList/DisplayList.swift | 51 +++++++- .../ShapeStyle/ShapeStyleRendering.swift | 113 ++++++++++++++++-- 2 files changed, 152 insertions(+), 12 deletions(-) diff --git a/Sources/OpenSwiftUICore/Render/DisplayList/DisplayList.swift b/Sources/OpenSwiftUICore/Render/DisplayList/DisplayList.swift index 77eed5913..b7c2cf11b 100644 --- a/Sources/OpenSwiftUICore/Render/DisplayList/DisplayList.swift +++ b/Sources/OpenSwiftUICore/Render/DisplayList/DisplayList.swift @@ -492,7 +492,45 @@ extension DisplayList.Item { extension DisplayList { // FIXME - package class InterpolatorGroup {} + package class InterpolatorGroup { + private struct Contents { + var list: DisplayList + var origin: CGPoint + var rbList: ORBDisplayListContents + var nextTime: Time + var numericValue: Float? + } + + private struct Removed { + var contents: Contents + var interpolator: ORBDisplayListInterpolator? + var transition: ORBTransition? + var animation: ORBAnimation + var listener: AnimationListener? + var begin: Time + var duration: Double + var phase: Phase + } + + private enum Phase { + case pending + case first + case second + case running + } + +// private var contents: Contents +// private var removed: [Removed] +// var time: Time +// var renderer: DisplayList.GraphicsRenderer? +// var contentSeed: DisplayList.Seed +// var supportsVFD: Bool +// var needsUpdate: Bool + + init() { +// _openSwiftUIUnimplementedFailure() + } + } } package struct AccessibilityNodeAttachment {} @@ -511,3 +549,14 @@ extension GraphicsContext { package protocol _DisplayList_AnyEffectAnimation {} package struct ResolvedShadowStyle {} + +extension DisplayList.Item { + func addDrawingGroup(contentSeed: DisplayList.Seed) { + _openSwiftUIUnimplementedWarning() + } +} + +package class ORBDisplayListContents {} +package class ORBDisplayListInterpolator {} +package struct ORBTransition {} +package class ORBAnimation {} diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRendering.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRendering.swift index 719da750c..55c6112ec 100644 --- a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRendering.swift +++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRendering.swift @@ -45,6 +45,8 @@ package struct _ShapeStyle_RenderedShape { private struct LayerNeeds: OptionSet { let rawValue: UInt8 + + static let drawingGroup: LayerNeeds = .init(rawValue: 1 << 0) } private var layerNeedes: LayerNeeds @@ -125,13 +127,53 @@ package struct _ShapeStyle_RenderedShape { } package mutating func commitItem() -> DisplayList.Item { - _openSwiftUIUnimplementedFailure() + defer { + blendMode = .normal + opacity = 1.0 + layerNeedes = [] + item.value = .empty + } + guard opacity != .zero, !frame.isEmpty else { + item.value = .empty + if let data = interpolatorData { + addEffect(.interpolatorLayer(data.group, serial: data.serial)) + interpolatorData = nil + } + return item + } + item.canonicalize(options: options) + if let data = interpolatorData { + addEffect(.interpolatorLayer(data.group, serial: data.serial)) + interpolatorData = nil + } + if layerNeedes.contains(.drawingGroup) { + item.addDrawingGroup(contentSeed: contentSeed) + } + if blendMode != .blendMode(.normal) { + addEffect(.blendMode(blendMode)) + } + if opacity != 1.0 { + addEffect(.opacity(opacity)) + } + return item } package mutating func background(_ other: inout ShapeStyle.RenderedShape) { _openSwiftUIUnimplementedFailure() } + private mutating func addEffect(_ effect: DisplayList.Effect) { + _openSwiftUIUnimplementedWarning() +// let displayList = DisplayList(item) +// item = .init( +// .effect(effect, displayList), +// frame: frame, +// identity: item.identity, +// version: item.version +// ) +// item.canonicalize(options: options) + } + private func render(style: ShapeStyle.Pack.Style) { _openSwiftUIUnimplementedFailure() } @@ -170,7 +212,7 @@ package struct _ShapeStyle_RenderedLayers { private enum Layers { case empty case item(DisplayList.Item) - case itesm([DisplayList.Item]) + case items([DisplayList.Item]) } private var layers: Layers = .empty @@ -179,23 +221,63 @@ package struct _ShapeStyle_RenderedLayers { self.group = group } - func commit( + mutating func commit( shape: inout ShapeStyle.RenderedShape, options: DisplayList.Options ) -> DisplayList { - _openSwiftUIUnimplementedFailure() + if let group { + _openSwiftUIUnimplementedWarning() + } + switch layers { + case .empty: + return .init() + case let .item(item): + let displayList = DisplayList(item) + layers = .empty + return displayList + case let .items(items): + let displayList = DisplayList(items) + _openSwiftUIUnimplementedFailure() + layers = .empty + } } - func beginLayer( + mutating func beginLayer( id: ShapeStyle.LayerID, style: ShapeStyle.Pack.Style?, shape: inout ShapeStyle.RenderedShape ) { - _openSwiftUIUnimplementedFailure() + guard let group else { + return + } + // FIXME + _ = group.addLayer(id: id, style: style) + // TODO: interpolatorData update + // interpolatorData = + _openSwiftUIUnimplementedWarning() } - func endLayer(shape: inout ShapeStyle.RenderedShape) { - _openSwiftUIUnimplementedFailure() + mutating func endLayer(shape: inout ShapeStyle.RenderedShape) { + let newItem = shape.commitItem() + switch layers { + case .empty: + layers = .item(newItem) + case let .item(item): + var oldItem = item + let offset = CGSize(shape.frame.origin) + oldItem.frame.origin -= offset + layers = .items([ + oldItem, + newItem, + ]) + case let .items(items): + var items = items + // TODO + let offset = CGSize(shape.frame.origin) + items[0].frame.origin -= offset + items.append(newItem) + layers = .items(items) + } } } @@ -228,9 +310,18 @@ final package class _ShapeStyle_InterpolatorGroup: DisplayList.InterpolatorGroup var cursor: Int32 = .zero -// init() { -// _openSwiftUIEmptyStub() -// } + fileprivate enum AddLayerResult { + case interpolatorData(group: DisplayList.InterpolatorGroup, serial: UInt32) + case none // FIXME + } + + fileprivate func addLayer( + id: ShapeStyle.LayerID, + style: ShapeStyle.Pack.Style? + ) -> AddLayerResult { + _openSwiftUIUnimplementedWarning() + return .none + } } extension DisplayList { From 4793eb4bf28340cdbdc6c63ffcf235ddcb95e835 Mon Sep 17 00:00:00 2001 From: Kyle Date: Sun, 18 Jan 2026 23:55:10 +0800 Subject: [PATCH 4/4] Add addEffect node --- .../ShapeStyle/ShapeStyleRendering.swift | 27 ++++++++++--------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRendering.swift b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRendering.swift index 55c6112ec..a738cb9da 100644 --- a/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRendering.swift +++ b/Sources/OpenSwiftUICore/Shape/ShapeStyle/ShapeStyleRendering.swift @@ -163,15 +163,14 @@ package struct _ShapeStyle_RenderedShape { } private mutating func addEffect(_ effect: DisplayList.Effect) { - _openSwiftUIUnimplementedWarning() -// let displayList = DisplayList(item) -// item = .init( -// .effect(effect, displayList), -// frame: frame, -// identity: item.identity, -// version: item.version -// ) -// item.canonicalize(options: options) + let effectItem = DisplayList.Item( + item.value, + frame: CGRect(origin: .zero, size: item.size), + identity: .none, + version: item.version + ) + item.value = .effect(effect, DisplayList(effectItem)) + item.canonicalize(options: options) } private func render(style: ShapeStyle.Pack.Style) { @@ -251,9 +250,11 @@ package struct _ShapeStyle_RenderedLayers { return } // FIXME - _ = group.addLayer(id: id, style: style) - // TODO: interpolatorData update - // interpolatorData = + guard case let .interpolatorData(group: group, serial: serial) = group.addLayer(id: id, style: style) else { + _openSwiftUIUnimplementedWarning() + return + } +// shape.interpolatorData = (group, serial) _openSwiftUIUnimplementedWarning() } @@ -320,7 +321,7 @@ final package class _ShapeStyle_InterpolatorGroup: DisplayList.InterpolatorGroup style: ShapeStyle.Pack.Style? ) -> AddLayerResult { _openSwiftUIUnimplementedWarning() - return .none + return .interpolatorData(group: .init(), serial: 0) } }