视觉特效与玻璃

if #available(iOS 26.0, *) {
    if let viewClass = NSClassFromString("_UILiquidLensView") as AnyObject as? NSObjectProtocol {
        let allocSelector = NSSelectorFromString("alloc")
        let initSelector = NSSelectorFromString("initWithRestingBackground:")
        let objcAlloc = viewClass.perform(allocSelector).takeUnretainedValue()
        let instance = objcAlloc.perform(initSelector, with: UIView()).takeUnretainedValue()
        self.lensView = instance as? UIView
    }
}

if let lensView = self.lensView {
    lensView.layer.zPosition = 10.0
    self.liftedContainerView.addSubview(self.restingBackgroundView)
    self.containerView.addSubview(self.liftedContainerView)
    self.containerView.addSubview(lensView)
    self.containerView.addSubview(self.contentView)
    lensView.perform(NSSelectorFromString("setLiftedContentView:"), with: self.liftedContainerView)
    lensView.perform(NSSelectorFromString("setOverridePunchoutView:"), with: self.contentView)
}

let liftedInset: CGFloat = params.isLifted ? params.liftedInset : (-params.inset)
let lensBounds = CGRect(origin: CGPoint(), size: CGSize(
    width: params.baseFrame.width + liftedInset * 2.0,
    height: params.baseFrame.height + liftedInset * 2.0
))
let lensCenter = CGPoint(x: params.baseFrame.midX, y: params.baseFrame.midY)
let previousBounds: CGRect = lensView.bounds
transition.animateView {
    lensView.bounds = lensBounds
}
if let info = transition.userData(TransitionInfo.self), info.disableAnimationWorkarounds {
} else {
    lensView.layer.removeAllAnimations()
    lensView.bounds = lensBounds
}
transition.setPosition(view: lensView, position: lensCenter, completion: { [weak self] flag in
    guard let self, flag else { return }
    if !self.isApplyingLensParams { self.isAnimating = false }
})
transition.animatePosition(
    layer: lensView.layer,
    from: CGPoint(x: (lensBounds.width - previousBounds.width) * 0.5, y: 0.0),
    to: CGPoint(), additive: true
)

private static let maximumDuration: Double = 1.0

static let shared = LiquidMorphFrameRateBoost()
private var displayLink: CADisplayLink?
private var count = 0

func claim(screen: UIScreen?) -> Claim {
    assert(Thread.isMainThread)
    self.count += 1
    if self.displayLink == nil, let screen, screen.maximumFramesPerSecond >= 120 {
        let displayLink = CADisplayLink(target: Target(), selector: #selector(Target.tick))
        displayLink.preferredFrameRateRange = CAFrameRateRange(
            minimum: 120.0, maximum: 120.0, preferred: 120.0
        )
        displayLink.add(to: .main, forMode: .common)
        self.displayLink = displayLink
    }
    let claim = Claim()
    DispatchQueue.main.asyncAfter(deadline: .now() + Self.maximumDuration) {
        claim.end()
    }
    return claim
}

let legacySelectionView = GlassBackgroundView.ContentImageView()
self.legacySelectionView = legacySelectionView
if let backgroundView = self.backgroundView {
    backgroundView.contentView.insertSubview(legacySelectionView, at: 0)
} else {
    self.containerView.insertSubview(legacySelectionView, at: 0)
}

let legacyContentMaskView = UIView()
legacyContentMaskView.backgroundColor = .white
self.legacyContentMaskView = legacyContentMaskView
self.contentView.mask = legacyContentMaskView
if let filter = CALayer.luminanceToAlpha() {
    legacyContentMaskView.layer.filters = [filter]
}

let legacyContentMaskBlobView = UIImageView()
self.legacyContentMaskBlobView = legacyContentMaskBlobView
legacyContentMaskView.addSubview(legacyContentMaskBlobView)

static Class portalViewClass = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    portalViewClass = NSClassFromString([@[@"_", @"UI", @"Portal", @"View"] componentsJoinedByString:@""]);
});
if (!portalViewClass) {
    return nil;
}
UIView<UIKitPortalViewProtocol> *view = [[portalViewClass alloc] init];
if (!view) {
    return nil;
}
if (@available(iOS 14.0, *)) {
    view.forwardsClientHitTestingToSourceView = false;
}
view.matchesPosition = matchPosition;
view.matchesTransform = matchPosition;
view.matchesAlpha = false;
if (@available(iOS 14.0, *)) {
    view.allowsHitTesting = false;
}

func reloadPortal(sourceView: PortalSourceView) {
    self.view.sourceView = sourceView
    self.sourceView = sourceView

    if let portalSuperview = self.view.superview,
       let index = portalSuperview.subviews.firstIndex(of: self.view) {
        portalSuperview.insertSubview(self.view, at: index)
    } else if let portalSuperlayer = self.view.layer.superlayer,
              let index = portalSuperlayer.sublayers?.firstIndex(of: self.view.layer) {
        portalSuperlayer.insertSublayer(self.view.layer, at: UInt32(index))
    }
}

func disablePortal() {
    self.view.sourceView = nil
    self.sourceView = nil
}

let sourceView: PortalSourceView?
switch type {
case .free:
    sourceView = self.freeBackgroundPortalSourceView
case .incoming:
    sourceView = self.incomingBackgroundPortalSourceView
case .outgoing:
    sourceView = self.outgoingBackgroundPortalSourceView
}

guard let sourceView, let portalView = PortalView(matchPosition: true) else {
    return nil
}
sourceView.addPortal(view: portalView)
return WallpaperBackgroundNodeImpl.BubbleBackgroundPortalNodeImpl(
    portalView: portalView
)

if self.enableBlur && !sharedIsReduceTransparencyEnabled
    && ((self._color.alpha > .ulpOfOne && self._color.alpha < 0.95) || forceKeepBlur) {
    if self.effectView == nil {
        let effectView = UIVisualEffectView(effect: UIBlurEffect(style: .light))
        for subview in effectView.subviews {
            if subview.description.contains("VisualEffectSubview") {
                subview.isHidden = true
            }
        }
        if let sublayer = effectView.layer.sublayers?[0], let filters = sublayer.filters {
            sublayer.backgroundColor = nil
            sublayer.isOpaque = false
            var allowedKeys: [String] = ["gaussianBlur"]
            if self.enableSaturation { allowedKeys.append("colorSaturate") }
            sublayer.filters = filters.filter { filter in
                let filterName = String(describing: filter)
                return allowedKeys.contains(filterName)
            }
        }
    }
}

private let backdropLayerClass: NSObject? = {
    let name = ("CA" as NSString).appendingFormat("BackdropLayer")
    if let cls = NSClassFromString(name as String) as AnyObject as? NSObject {
        return cls
    }
    return nil
}()

if let blurFilter = CALayer.blur(), let colorMatrixFilter = CALayer.colorMatrix() {
    blurFilter.setValue(2.0 as NSNumber, forKey: "inputRadius")
    var matrix: [Float32] = [
        2.6705, -1.1087999, -0.1117, 0.0, 0.049999997,
        -0.3295, 1.8914, -0.111899994, 0.0, 0.049999997,
        -0.3297, -1.1084, 2.8881, 0.0, 0.049999997,
        0.0, 0.0, 0.0, 1.0, 0.0
    ]
    colorMatrixFilter.setValue(NSValue(bytes: &matrix,
        objCType: "{CAColorMatrix=ffffffffffffffffffff}"), forKey: "inputColorMatrix")
    colorMatrixFilter.setValue(true as NSNumber, forKey: "inputBackdropAware")
    backdropLayer.filters = [colorMatrixFilter, blurFilter]
}

let meshTransform = MeshTransform.roundedRect(
    width: size.width,
    height: size.height,
    cornerRadius: cornerRadius,
    displacementMagnitudeU: displacementMagnitudeU,
    displacementMagnitudeV: displacementMagnitudeV,
    outerEdgeDistance: outerEdgeDistance
).mesh.makeValue()

if let meshTransform {
    if !transition.animation.isImmediate,
       let previousTransform = backdropLayer.value(forKey: "meshTransform") as? NSObject {
        backdropLayer.removeAnimation(forKey: "meshTransform")
        backdropLayer.setValue(meshTransform, forKey: "meshTransform")
        transition.animateMeshTransform(
            layer: backdropLayer, from: previousTransform, to: meshTransform
        )
    } else {
        backdropLayer.setValue(meshTransform, forKey: "meshTransform")
    }
}

if let cgImage = image?.cgImage {
    variableBlur.setValue(cgImage, forKey: "inputMaskImage")
}
self.layer.filters = [variableBlur]

let baseHeight = max(1.0, params.gradient.height + inwardsExtension)
let resizingInverted = params.placement.position != .bottom
self.gradientImage = generateImage(CGSize(width: 1.0, height: baseHeight), opaque: false,
    rotatedContext: { size, context in
        let gradientColors = [
            UIColor.white.withAlphaComponent(1.0).cgColor,
            UIColor.white.withAlphaComponent(0.0).cgColor
        ] as CFArray
        let gradient = CGGradient(colorsSpace: CGColorSpaceCreateDeviceRGB(),
            colors: gradientColors, locations: [0.0, 1.0])!
        context.drawLinearGradient(gradient, start: .zero,
            end: CGPoint(x: 0.0, y: size.height), options: [])
    }
)?.resizableImage(withCapInsets: UIEdgeInsets(bottom: baseHeight), resizingMode: .stretch)

if self.backdropLayer != nil {
    if let displacementMapLayer = self.displacementMapLayer {
        let baseMapResolution = (
            x: max(2, resolution.x / 2),
            y: max(2, resolution.y / 2)
        )
        let mapResolution = self.adaptiveDisplacementMapResolution(
            from: baseMapResolution
        )
        displacementMapLayer.contents = self.makeDisplacementMapImage(
            size: size, resolution: mapResolution, params: params
        )
        self.transformContainerLayer.setValue(nil, forKey: "meshTransform")
    } else {
        if let meshTransform = self.makeRippleMeshTransform(
            size: size, resolution: resolution, params: params
        ) {
            self.transformContainerLayer.setValue(meshTransform, forKey: "meshTransform")
        }
    }
}

float2 sampleOffset = float2(0.0);
for (int i = 0; i < 3; i++) {
    if (uniforms.layerRimGlass[i].y == 0.0) {
        continue;
    }
    LiquidGlassShapeSample shape = liquidGlassShape(samples, i, point, uniforms);
    float coverage = liquidGlassCoverage(shape.distance, pixelsPerPoint);
    float falloff = 1.0 - saturate(max(shape.distance, 0.0) / uniforms.glassBand);
    sampleOffset += shape.inwardNormal * (
        uniforms.glassShift * falloff * falloff * coverage
    );
}

float2 encoded = saturate(
    0.5 - 0.5 * sampleOffset / uniforms.glassAmount
);
return half4(half(encoded.x), half(encoded.y), 1.0, 1.0);

let spec = RenderLayerSpec(
    size: renderSize,
    edgeInset: Constants.edgeInset,
    prefersDedicatedSurface: true
)
context.renderToLayer(
    spec: spec,
    state: LiquidGlassShapesRenderState<Pass, Kind>.self,
    layer: layer,
    inputs: samples,
    commands: { encoder, placement, samples in
        guard let samples else { return }
        encoder.setFragmentBytes(&uniforms,
            length: MemoryLayout<LiquidGlassShapesUniforms>.stride, index: 0)
        encoder.setFragmentBuffer(samples, offset: 0, index: 1)
        encoder.drawPrimitives(type: .triangle, vertexStart: 0, vertexCount: 6)
    }
)

/// Private `CAEmitterBehavior` bridge (no public API exists for the twinkle / attractor).
@available(iOS 13.0, *)
extension CAEmitterCell {
    static func createEmitterBehavior(type: String) -> NSObject {
        let selector = ["behaviorWith", "Type:"].joined()
        let behaviorClass = NSClassFromString(["CA", "Emitter", "Behavior"].joined())
            as! NSObject.Type
        let behaviorWithType = behaviorClass.method(
            for: NSSelectorFromString(selector)
        )!
        let castedBehaviorWithType = unsafeBitCast(
            behaviorWithType,
            to: (@convention(c) (Any?, Selector, Any?) -> NSObject).self
        )
        return castedBehaviorWithType(
            behaviorClass, NSSelectorFromString(selector), type
        )
    }
}

private static func emitterMaskImage(size: CGSize, position: CGPoint) -> UIImage? {
    guard size.width > 0, size.height > 0 else { return nil }
    let renderer = UIGraphicsImageRenderer(size: size)
    return renderer.image { ctx in
        let c = ctx.cgContext
        c.clear(CGRect(origin: .zero, size: size))
        let locations: [CGFloat] = [0.0, 0.7, 0.95, 1.0]
        let colors = [
            UIColor(white: 1, alpha: 0).cgColor,
            UIColor(white: 1, alpha: 0).cgColor,
            UIColor(white: 1, alpha: 1).cgColor,
            UIColor(white: 1, alpha: 1).cgColor
        ] as CFArray
        let endRadius = min(10.0, min(size.width, size.height) * 0.4)
        c.drawRadialGradient(gradient, startCenter: position, startRadius: 0,
            endCenter: position, endRadius: endRadius, options: .drawsAfterEndLocation)
    }
}

self.contentView.layer.removeAnimation(forKey: "contents")
self.contentView.layer.add(animation, forKey: "contents")

if !self.rawCloneNodes.isEmpty {
    let cloneAnimation = CAKeyframeAnimation(keyPath: "contents")
    cloneAnimation.values = images.map { $0.0.cgImage! }
    cloneAnimation.duration = animation.duration
    cloneAnimation.calculationMode = animation.calculationMode
    cloneAnimation.isRemovedOnCompletion = animation.isRemovedOnCompletion
    cloneAnimation.fillMode = animation.fillMode
    cloneAnimation.beginTime = animation.beginTime
    for cloneNode in self.rawCloneNodes {
        if let value = cloneNode.value {
            value.image = images.last?.0
            value.layer.removeAnimation(forKey: "contents")
            value.layer.add(cloneAnimation, forKey: "contents")
        }
    }
}

if extendAnimation || backwards {
    self.invalidated = true
} else {
    if self.phase == 0 {
        self.phase = 7
    } else {
        self.phase = self.phase - 1
    }
}
if self.useSharedAnimationPhase {
    GradientBackgroundNode.sharedPhase = self.phase
    GradientBackgroundNode.sharedAnimationSyncPipe.putNext(
        SharedAnimationUpdate(phase: self.phase, sender: self)
    )
}
if let size = self.validLayout {
    self.updateLayout(size: size, transition: transition,
        extendAnimation: extendAnimation, backwards: backwards, completion: completion)
} else {
    completion()
}

let travelDelta = params.containerWidth + params.gradientWidth
let animation = self.maskLayer.makeAnimation(
    from: 0.0 as NSNumber,
    to: travelDelta as NSNumber,
    keyPath: "position.x",
    timingFunction: CAMediaTimingFunctionName.easeOut.rawValue,
    duration: self.duration,
    delay: 0.0,
    mediaTimingFunction: nil,
    removeOnCompletion: true,
    additive: true
)
animation.repeatCount = Float.infinity
self.maskLayer.add(animation, forKey: "shimmer")

let travelDistance = containerWidth + gradientWidth
let maskWidth = size.width + 2.0 * travelDistance
let staticPositionX = -gradientWidth * 0.5 - offsetX
let maskPosition = CGPoint(x: staticPositionX, y: size.height * 0.5)
transition.setBounds(layer: self.maskLayer, bounds: maskBounds)
transition.setPosition(layer: self.maskLayer, position: maskPosition)

let graphicsInset = bubbleTearHorizontalOverhang + bubbleTearGraphicsHorizontalInset
let graphicsX = graphicsInset + self.tailInsets.left
let graphicsWidth = max(0.0, size.width - graphicsInset * 2.0
    - self.tailInsets.left - self.tailInsets.right)

if let topEdgeView {
    topEdgeView.frame = CGRect(
        x: graphicsX,
        y: bubbleTearEdgeInset,
        width: graphicsWidth,
        height: bubbleTearEdgeHeight - UIScreenPixel
    )
}
if let bottomEdgeView {
    bottomEdgeView.frame = CGRect(
        x: graphicsX,
        y: size.height - bubbleTearEdgeHeight - bubbleTearEdgeInset,
        width: graphicsWidth,
        height: bubbleTearEdgeHeight
    )
}