Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/TelegramUI/Components/Premium/PremiumDiamondComponent/Sources/DiamondLayer.swift

@@ -0,0 +1,393 @@
+import Foundation
+import Display
+import Metal
+import MetalKit
+import MetalEngine
+import ComponentFlow
+import TelegramPresentationData
+import AnimatableProperty
+import SwiftSignalKit
+
+private var metalLibraryValue: MTLLibrary?
+func metalLibrary(device: MTLDevice) -> MTLLibrary? {
+    if let metalLibraryValue {
+        return metalLibraryValue
+    }
+    
+    let mainBundle = Bundle(for: DiamondLayer.self)
+    guard let path = mainBundle.path(forResource: "PremiumDiamondComponentBundle", ofType: "bundle") else {
+        return nil
+    }
+    guard let bundle = Bundle(path: path) else {
+        return nil
+    }
+    guard let library = try? device.makeDefaultLibrary(bundle: bundle) else {
+        return nil
+    }
+    
+    metalLibraryValue = library
+    return library
+}
+
+final class DiamondLayer: MetalEngineSubjectLayer, MetalEngineSubject {
+    var internalData: MetalEngineSubjectInternalData?
+    
+    private final class RenderState: RenderToLayerState {
+        let pipelineState: MTLRenderPipelineState
+                
+        required init?(device: MTLDevice) {
+            guard let library = metalLibrary(device: device) else {
+                return nil
+            }
+            guard let vertexFunction = library.makeFunction(name: "post_vertex_main"),
+                  let fragmentFunction = library.makeFunction(name: "post_fragment_main") else {
+                return nil
+            }
+            
+            let pipelineDescriptor = MTLRenderPipelineDescriptor()
+            pipelineDescriptor.vertexFunction = vertexFunction
+            pipelineDescriptor.fragmentFunction = fragmentFunction
+            pipelineDescriptor.colorAttachments[0].pixelFormat = .bgra8Unorm
+            pipelineDescriptor.colorAttachments[0].isBlendingEnabled = true
+            pipelineDescriptor.colorAttachments[0].rgbBlendOperation = .add
+            pipelineDescriptor.colorAttachments[0].alphaBlendOperation = .add
+            pipelineDescriptor.colorAttachments[0].sourceRGBBlendFactor = .sourceAlpha
+            pipelineDescriptor.colorAttachments[0].sourceAlphaBlendFactor = .sourceAlpha
+            pipelineDescriptor.colorAttachments[0].destinationRGBBlendFactor = .oneMinusSourceAlpha
+            pipelineDescriptor.colorAttachments[0].destinationAlphaBlendFactor = .oneMinusSourceAlpha
+            
+            guard let pipelineState = try? device.makeRenderPipelineState(descriptor: pipelineDescriptor) else {
+                return nil
+            }
+            self.pipelineState = pipelineState
+        }
+    }
+    
+    final class DiamondState: ComputeState {
+        let computePipelineState: MTLComputePipelineState
+        let cubemapTexture: MTLTexture?
+        
+        required init?(device: MTLDevice) {
+            guard let library = metalLibrary(device: device) else {
+                return nil
+            }
+            
+            guard let functionComputeMain = library.makeFunction(name: "compute_main") else {
+                return nil
+            }
+            guard let computePipelineState = try? device.makeComputePipelineState(function: functionComputeMain) else {
+                return nil
+            }
+            self.computePipelineState = computePipelineState
+            
+            self.cubemapTexture = loadCubemap(device: device)
+        }
+    }
+    
+    private var offscreenTexture: PooledTexture?
+    
+    private var rotationX = AnimatableProperty<CGFloat>(value: -15.0 * .pi / 180.0)
+    private var rotationY = AnimatableProperty<CGFloat>(value: 0.0)
+    private var rotationZ = AnimatableProperty<CGFloat>(value: 0.0 * .pi / 180.0)
+    private var time = AnimatableProperty<CGFloat>(value: 0.0)
+    
+    private var startTime = CFAbsoluteTimeGetCurrent()
+    private var interactionStartTme: Double?
+    
+    private var displayLinkSubscription: SharedDisplayLinkDriver.Link?
+    private var hasActiveAnimations: Bool = false
+    
+    private var isExploding = false
+    
+    private var currentRenderSize: CGSize = .zero
+    
+    override init() {
+        super.init()
+        
+        self.isOpaque = false
+        
+        self.didEnterHierarchy = { [weak self] in
+            guard let self else {
+                return
+            }
+            self.displayLinkSubscription = SharedDisplayLinkDriver.shared.add { [weak self] _ in
+                guard let self else {
+                    return
+                }
+                self.updateAnimations()
+                self.setNeedsUpdate()
+            }
+        }
+        
+        self.didExitHierarchy = { [weak self] in
+            guard let self else {
+                return
+            }
+            self.displayLinkSubscription = nil
+        }
+    }
+    
+    override init(layer: Any) {
+        super.init(layer: layer)
+        
+        if let layer = layer as? DiamondLayer {
+            self.rotationX = layer.rotationX
+            self.rotationY = layer.rotationY
+            self.rotationZ = layer.rotationZ
+            self.time = layer.time
+            self.startTime = layer.startTime
+            self.currentRenderSize = layer.currentRenderSize
+        }
+    }
+    
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    
+    @objc func handlePan(_ gesture: UIPanGestureRecognizer) {
+        switch gesture.state {
+        case .began:
+            self.interactionStartTme = CFAbsoluteTimeGetCurrent()
+        case .changed:
+            let translation = gesture.translation(in: gesture.view)
+            let yawPan = -Float(translation.x) * Float.pi / 180.0
+            
+            func rubberBandingOffset(offset: CGFloat, bandingStart: CGFloat) -> CGFloat {
+                let bandedOffset = offset - bandingStart
+                let range: CGFloat = 75.0
+                let coefficient: CGFloat = 0.4
+                return bandingStart + (1.0 - (1.0 / ((bandedOffset * coefficient / range) + 1.0))) * range
+            }
+            
+            var pitchTranslation = rubberBandingOffset(offset: abs(translation.y), bandingStart: 0.0)
+            if translation.y < 0.0 {
+                pitchTranslation *= -1.0
+            }
+            let pitchPan = Float(pitchTranslation) * Float.pi / 180.0
+            
+            self.rotationX.update(value: CGFloat(yawPan), transition: .immediate)
+            self.rotationY.update(value: CGFloat(pitchPan), transition: .immediate)
+            
+        case .ended:
+            let velocity = gesture.velocity(in: gesture.view)
+            
+            if let interactionStartTme = self.interactionStartTme {
+                let delta = CFAbsoluteTimeGetCurrent() - interactionStartTme
+                self.startTime += delta
+                
+                self.interactionStartTme = nil
+            }
+//
+//            var smallAngle = false
+//            let previousYaw = Float(self.rotationX.presentationValue)
+//            if (previousYaw < .pi / 2 && previousYaw > -.pi / 2) && abs(velocity.x) < 200 {
+//                smallAngle = true
+//            }
+            
+            playAppearanceAnimation(velocity: velocity.x, smallAngle: true, explode: false) //, smallAngle: smallAngle, explode: !smallAngle && abs(velocity.x) > 600)
+        default:
+            break
+        }
+        
+        self.setNeedsUpdate()
+    }
+    
+    func playAppearanceAnimation(velocity: CGFloat?, smallAngle: Bool, explode: Bool) {
+        if explode {
+            self.isExploding = true
+            self.time.update(value: 8.0, transition: .spring(duration: 2.0))
+            
+            Queue.mainQueue().after(1.2) {
+                if self.isExploding {
+                    self.isExploding = false
+                    self.startTime = CFAbsoluteTimeGetCurrent() - 8.0
+                }
+            }
+        } else if smallAngle {
+            let transition = ComponentTransition.easeInOut(duration: 0.3)
+            self.rotationX.update(value: 0.0, transition: transition)
+            self.rotationY.update(value: 0.0, transition: transition)
+        }
+        
+    }
+    
+    private func updateAnimations() {
+        let properties = [
+            self.rotationX,
+            self.rotationY,
+            self.rotationZ
+        ]
+        
+        let timestamp = CACurrentMediaTime()
+        var hasAnimations = false
+        for property in properties {
+            if property.tick(timestamp: timestamp) {
+                hasAnimations = true
+            }
+        }
+        
+        let currentTime = CFAbsoluteTimeGetCurrent()
+        if self.time.tick(timestamp: timestamp) {
+            hasAnimations = true
+        }
+        self.hasActiveAnimations = hasAnimations
+        
+        if !self.isExploding && self.interactionStartTme == nil {
+            let elapsedTime = currentTime - self.startTime
+            self.time.update(value: CGFloat(elapsedTime), transition: .immediate)
+        }
+    }
+    
+    func update(context: MetalEngineSubjectContext) {
+        if self.bounds.isEmpty {
+            return
+        }
+        
+        let drawableSize = CGSize(width: self.bounds.width * UIScreen.main.scale, height: self.bounds.height * UIScreen.main.scale)
+        
+        let offscreenTextureSpec = TextureSpec(width: Int(drawableSize.width), height: Int(drawableSize.height), pixelFormat: .rgba8UnsignedNormalized)
+        if self.offscreenTexture == nil || self.offscreenTexture?.spec != offscreenTextureSpec {
+            self.offscreenTexture = MetalEngine.shared.pooledTexture(spec: offscreenTextureSpec)
+        }
+        
+        guard let offscreenTexture = self.offscreenTexture?.get(context: context) else {
+            return
+        }
+        
+        let diamondTexture = context.compute(state: DiamondState.self, inputs: offscreenTexture.placeholer, commands: { commandBuffer, computeState, offscreenTexture -> MTLTexture? in
+            guard let offscreenTexture, let cubemapTexture = computeState.cubemapTexture else {
+                return nil
+            }
+            do {
+                guard let computeEncoder = commandBuffer.makeComputeCommandEncoder() else {
+                    return nil
+                }
+                
+                let threadgroupSize = MTLSize(width: 16, height: 16, depth: 1)
+                let threadgroupCount = MTLSize(width: (offscreenTextureSpec.width + threadgroupSize.width - 1) / threadgroupSize.width, height: (offscreenTextureSpec.height + threadgroupSize.height - 1) / threadgroupSize.height, depth: 1)
+                
+                var iTime = Float(self.time.presentationValue)
+                
+                var iResolution = simd_float2(
+                    Float(drawableSize.width),
+                    Float(drawableSize.height)
+                )
+                
+                var cameraRotation = SIMD3<Float>(
+                    Float(180.0 * .pi / 180.0 + self.rotationX.presentationValue),
+                    Float(18.0 * .pi / 180.0 + self.rotationY.presentationValue),
+                    Float(0.0)
+                )
+                
+                computeEncoder.setComputePipelineState(computeState.computePipelineState)
+                computeEncoder.setBytes(&iTime, length: MemoryLayout<Float>.size, index: 0)
+                computeEncoder.setBytes(&iResolution, length: MemoryLayout<simd_float2>.size, index: 1)
+                computeEncoder.setBytes(&cameraRotation, length: MemoryLayout<simd_float3>.size, index: 2)
+                computeEncoder.setTexture(offscreenTexture, index: 0)
+                computeEncoder.setTexture(cubemapTexture, index: 1)
+                computeEncoder.dispatchThreadgroups(threadgroupCount, threadsPerThreadgroup: threadgroupSize)
+                
+                computeEncoder.endEncoding()
+            }
+            
+            return offscreenTexture
+        })
+        
+                
+        context.renderToLayer(spec: RenderLayerSpec(size: RenderSize(width: Int(drawableSize.width), height: Int(drawableSize.height))), state: RenderState.self, layer: self, inputs: diamondTexture, commands: { encoder, placement, diamondTexture in
+            guard let diamondTexture else {
+                return
+            }
+            
+            let effectiveRect = placement.effectiveRect
+            
+            var iTime = Float(self.time.presentationValue)
+            
+            var rect = SIMD4<Float>(Float(effectiveRect.minX), Float(effectiveRect.minY), Float(effectiveRect.width), Float(effectiveRect.height))
+            encoder.setVertexBytes(&rect, length: 4 * 4, index: 0)
+            
+            var iResolution = simd_float2(
+                Float(drawableSize.width),
+                Float(drawableSize.height)
+            )
+            encoder.setFragmentBytes(&iTime, length: MemoryLayout<Float>.size, index: 0)
+            encoder.setFragmentBytes(&iResolution, length: MemoryLayout<simd_float2>.size, index: 1)
+            encoder.setFragmentTexture(diamondTexture, index: 0)
+            encoder.drawPrimitives(type: .triangle, vertexStart: 0, vertexCount: 6)
+        })
+    }
+}
+
+private func loadCubemap(device: MTLDevice) -> MTLTexture? {
+    let faceNames = ["right", "left", "top", "bottom", "front", "back"].map { "\($0).png" }
+    
+    guard let firstImage = UIImage(named: faceNames[0]) else {
+        return nil
+    }
+    
+    let width = Int(firstImage.size.width)
+    let height = Int(firstImage.size.height)
+    
+    let textureDescriptor = MTLTextureDescriptor.textureCubeDescriptor(
+        pixelFormat: .rgba8Unorm,
+        size: width,
+        mipmapped: true
+    )
+    textureDescriptor.usage = [.shaderRead]
+    
+    guard let cubemapTexture = device.makeTexture(descriptor: textureDescriptor) else {
+        return nil
+    }
+    
+    for (index, faceName) in faceNames.enumerated() {
+        guard let image = UIImage(named: faceName),
+              let cgImage = image.cgImage else {
+            return nil
+        }
+        
+        let colorSpace = CGColorSpaceCreateDeviceRGB()
+        let bytesPerPixel = 4
+        let bytesPerRow = width * bytesPerPixel
+        let bitsPerComponent = 8
+        
+        var pixelData = [UInt8](repeating: 0, count: width * height * bytesPerPixel)
+        
+        guard let context = CGContext(
+            data: &pixelData,
+            width: width,
+            height: height,
+            bitsPerComponent: bitsPerComponent,
+            bytesPerRow: bytesPerRow,
+            space: colorSpace,
+            bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
+        ) else {
+            return nil
+        }
+        
+        context.draw(cgImage, in: CGRect(x: 0, y: 0, width: width, height: height))
+        
+        let region = MTLRegion(origin: MTLOrigin(x: 0, y: 0, z: 0), size: MTLSize(width: width, height: height, depth: 1))
+        
+        cubemapTexture.replace(
+            region: region,
+            mipmapLevel: 0,
+            slice: index,
+            withBytes: pixelData,
+            bytesPerRow: bytesPerRow,
+            bytesPerImage: 0
+        )
+    }
+    
+    if textureDescriptor.mipmapLevelCount > 1 {
+        let commandQueue = device.makeCommandQueue()
+        let commandBuffer = commandQueue?.makeCommandBuffer()
+        let blitEncoder = commandBuffer?.makeBlitCommandEncoder()
+        
+        blitEncoder?.generateMipmaps(for: cubemapTexture)
+        blitEncoder?.endEncoding()
+        commandBuffer?.commit()
+        commandBuffer?.waitUntilCompleted()
+    }
+    
+    return cubemapTexture
+}

submodules/TelegramUI/Components/Premium/PremiumDiamondComponent/Sources/PremiumDiamondComponent.swift

@@ -0,0 +1,273 @@
+import Foundation
+import UIKit
+import Display
+import ComponentFlow
+import SwiftSignalKit
+import SceneKit
+import GZip
+import AppBundle
+import LegacyComponents
+import PremiumStarComponent
+import TelegramPresentationData
+
+private let sceneVersion: Int = 5
+
+private func deg2rad(_ number: Float) -> Float {
+    return number * .pi / 180
+}
+
+private func rad2deg(_ number: Float) -> Float {
+    return number * 180.0 / .pi
+}
+
+public final class PremiumDiamondComponent: Component {
+    let theme: PresentationTheme
+    
+    public init(theme: PresentationTheme) {
+        self.theme = theme
+    }
+    
+    public static func ==(lhs: PremiumDiamondComponent, rhs: PremiumDiamondComponent) -> Bool {
+        return lhs.theme === rhs.theme
+    }
+    
+    public final class View: UIView, SCNSceneRendererDelegate, ComponentTaggedView {
+        public final class Tag {
+            public init() {
+                
+            }
+        }
+        
+        public func matches(tag: Any) -> Bool {
+            if let _ = tag as? Tag {
+                return true
+            }
+            return false
+        }
+        
+        private var _ready = Promise<Bool>()
+        public var ready: Signal<Bool, NoError> {
+            return self._ready.get()
+        }
+                
+        private let sceneView: SCNView
+        
+        private let diamondLayer: DiamondLayer
+        
+        private var timer: SwiftSignalKit.Timer?
+                
+        private var component: PremiumDiamondComponent?
+        
+        override init(frame: CGRect) {
+            self.sceneView = SCNView(frame: CGRect(origin: .zero, size: CGSize(width: 64.0, height: 64.0)))
+            self.sceneView.backgroundColor = .clear
+            self.sceneView.transform = CGAffineTransform(scaleX: 0.5, y: 0.5)
+            self.sceneView.isUserInteractionEnabled = false
+            self.sceneView.preferredFramesPerSecond = 60
+            self.sceneView.isJitteringEnabled = true
+            
+            self.diamondLayer = DiamondLayer()
+            
+            super.init(frame: frame)
+            
+            self.addSubview(self.sceneView)
+            
+            self.layer.addSublayer(self.diamondLayer)
+            
+            self.setup()
+            
+            let panGestureRecoginzer = UIPanGestureRecognizer(target: self.diamondLayer, action: #selector(self.diamondLayer.handlePan(_:)))
+            self.addGestureRecognizer(panGestureRecoginzer)
+            
+            self.disablesInteractiveModalDismiss = true
+            self.disablesInteractiveTransitionGestureRecognizer = true
+        }
+        
+        required init?(coder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+        
+        deinit {
+            self.timer?.invalidate()
+        }
+                
+        private func setup() {
+            guard let scene = loadCompressedScene(name: "gift2", version: sceneVersion) else {
+                return
+            }
+            
+            self.sceneView.scene = scene
+            self.sceneView.delegate = self
+            
+            let names: [String] = [
+                "particles_left",
+                "particles_right",
+                "particles_left_bottom",
+                "particles_right_bottom",
+                "particles_center"
+            ]
+            
+            let particleColor = UIColor(rgb: 0x428df4) //0x3b9bff)
+            for name in names {
+                if let node = scene.rootNode.childNode(withName: name, recursively: false), let particleSystem = node.particleSystems?.first {
+                    particleSystem.particleIntensity = min(1.0, 2.0 * particleSystem.particleIntensity)
+                    particleSystem.particleIntensityVariation = 0.05
+                    particleSystem.particleColor = particleColor
+                    particleSystem.particleColorVariation = SCNVector4Make(0.0, 0.0, 0.1, 0.0)
+                                      
+                    if let propertyControllers = particleSystem.propertyControllers, let sizeController = propertyControllers[.size], let colorController = propertyControllers[.color] {
+                        let animation = CAKeyframeAnimation()
+                        if let existing = colorController.animation as? CAKeyframeAnimation {
+                            animation.keyTimes = existing.keyTimes
+                            animation.values = existing.values?.compactMap { ($0 as? UIColor)?.alpha } ?? []
+                        } else {
+                            animation.values = [ 0.0, 1.0, 1.0, 0.0 ]
+                        }
+                        let opacityController = SCNParticlePropertyController(animation: animation)
+                        particleSystem.propertyControllers = [
+                            .size: sizeController,
+                            .opacity: opacityController
+                        ]
+                    }
+                }
+            }
+            
+            //let _ = self.sceneView.snapshot()
+        }
+        
+        private var didSetReady = false
+        public func renderer(_ renderer: SCNSceneRenderer, didRenderScene scene: SCNScene, atTime time: TimeInterval) {
+            if !self.didSetReady {
+                self.didSetReady = true
+                
+                Queue.mainQueue().justDispatch {
+                    self._ready.set(.single(true))
+                    self.onReady()
+                }
+            }
+        }
+        
+        private func onReady() {
+            self.setupScaleAnimation()
+            
+            self.playAppearanceAnimation(mirror: true, explode: true)
+        }
+        
+        private func setupScaleAnimation() {
+            let animation = CABasicAnimation(keyPath: "transform.scale")
+            animation.duration = 2.0
+            animation.fromValue = 0.9
+            animation.toValue = 1.0
+            animation.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)
+            animation.autoreverses = true
+            animation.repeatCount = .infinity
+
+            self.diamondLayer.add(animation, forKey: "scale")
+        }
+        
+        private func playAppearanceAnimation(velocity: CGFloat? = nil, smallAngle: Bool = false, mirror: Bool = false, explode: Bool = false) {
+            guard let scene = self.sceneView.scene else {
+                return
+            }
+                        
+            if explode, let node = scene.rootNode.childNode(withName: "swirl", recursively: false), let particlesLeft = scene.rootNode.childNode(withName: "particles_left", recursively: false), let particlesRight = scene.rootNode.childNode(withName: "particles_right", recursively: false), let particlesBottomLeft = scene.rootNode.childNode(withName: "particles_left_bottom", recursively: false), let particlesBottomRight = scene.rootNode.childNode(withName: "particles_right_bottom", recursively: false) {
+                if let leftParticleSystem = particlesLeft.particleSystems?.first, let rightParticleSystem = particlesRight.particleSystems?.first, let leftBottomParticleSystem = particlesBottomLeft.particleSystems?.first, let rightBottomParticleSystem = particlesBottomRight.particleSystems?.first {
+                    leftParticleSystem.speedFactor = 2.0
+                    leftParticleSystem.particleVelocity = 1.6
+                    leftParticleSystem.birthRate = 60.0
+                    leftParticleSystem.particleLifeSpan = 4.0
+                    
+                    rightParticleSystem.speedFactor = 2.0
+                    rightParticleSystem.particleVelocity = 1.6
+                    rightParticleSystem.birthRate = 60.0
+                    rightParticleSystem.particleLifeSpan = 4.0
+                    
+                    leftBottomParticleSystem.particleVelocity = 1.6
+                    leftBottomParticleSystem.birthRate = 24.0
+                    leftBottomParticleSystem.particleLifeSpan = 7.0
+                    
+                    rightBottomParticleSystem.particleVelocity = 1.6
+                    rightBottomParticleSystem.birthRate = 24.0
+                    rightBottomParticleSystem.particleLifeSpan = 7.0
+                    
+                    node.physicsField?.isActive = true
+                    Queue.mainQueue().after(1.0) {
+                        node.physicsField?.isActive = false
+                        
+                        leftParticleSystem.birthRate = 15.0
+                        leftParticleSystem.particleVelocity = 1.0
+                        leftParticleSystem.particleLifeSpan = 3.0
+                        
+                        rightParticleSystem.birthRate = 15.0
+                        rightParticleSystem.particleVelocity = 1.0
+                        rightParticleSystem.particleLifeSpan = 3.0
+                        
+                        leftBottomParticleSystem.particleVelocity = 1.0
+                        leftBottomParticleSystem.birthRate = 10.0
+                        leftBottomParticleSystem.particleLifeSpan = 5.0
+                        
+                        rightBottomParticleSystem.particleVelocity = 1.0
+                        rightBottomParticleSystem.birthRate = 10.0
+                        rightBottomParticleSystem.particleLifeSpan = 5.0
+                        
+                        let leftAnimation = POPBasicAnimation()
+                        leftAnimation.property = (POPAnimatableProperty.property(withName: "speedFactor", initializer: { property in
+                            property?.readBlock = { particleSystem, values in
+                                values?.pointee = (particleSystem as! SCNParticleSystem).speedFactor
+                            }
+                            property?.writeBlock = { particleSystem, values in
+                                (particleSystem as! SCNParticleSystem).speedFactor = values!.pointee
+                            }
+                            property?.threshold = 0.01
+                        }) as! POPAnimatableProperty)
+                        leftAnimation.fromValue = 1.2 as NSNumber
+                        leftAnimation.toValue = 0.85 as NSNumber
+                        leftAnimation.timingFunction = CAMediaTimingFunction(name: CAMediaTimingFunctionName.linear)
+                        leftAnimation.duration = 0.5
+                        leftParticleSystem.pop_add(leftAnimation, forKey: "speedFactor")
+                        
+                        let rightAnimation = POPBasicAnimation()
+                        rightAnimation.property = (POPAnimatableProperty.property(withName: "speedFactor", initializer: { property in
+                            property?.readBlock = { particleSystem, values in
+                                values?.pointee = (particleSystem as! SCNParticleSystem).speedFactor
+                            }
+                            property?.writeBlock = { particleSystem, values in
+                                (particleSystem as! SCNParticleSystem).speedFactor = values!.pointee
+                            }
+                            property?.threshold = 0.01
+                        }) as! POPAnimatableProperty)
+                        rightAnimation.fromValue = 1.2 as NSNumber
+                        rightAnimation.toValue = 0.85 as NSNumber
+                        rightAnimation.timingFunction = CAMediaTimingFunction(name: CAMediaTimingFunctionName.linear)
+                        rightAnimation.duration = 0.5
+                        rightParticleSystem.pop_add(rightAnimation, forKey: "speedFactor")
+                    }
+                }
+                
+                self.diamondLayer.playAppearanceAnimation(velocity:nil, smallAngle: false, explode: true)
+            }
+        }
+        
+        func update(component: PremiumDiamondComponent, availableSize: CGSize, transition: ComponentTransition) -> CGSize {
+            self.component = component
+            
+            self.sceneView.backgroundColor = component.theme.list.blocksBackgroundColor
+            
+            self.sceneView.bounds = CGRect(origin: .zero, size: CGSize(width: availableSize.width * 2.0, height: availableSize.height * 2.0))
+            self.sceneView.center = CGPoint(x: availableSize.width / 2.0, y: availableSize.height / 2.0)
+        
+            self.diamondLayer.bounds = CGRect(origin: .zero, size: CGSize(width: availableSize.height, height: availableSize.height))
+            self.diamondLayer.position = CGPoint(x: availableSize.width / 2.0, y: availableSize.height / 2.0 - 8.0)
+                        
+            return availableSize
+        }
+    }
+    
+    public func makeView() -> View {
+        return View(frame: CGRect())
+    }
+    
+    public func update(view: View, availableSize: CGSize, state: EmptyComponentState, environment: Environment<Empty>, transition: ComponentTransition) -> CGSize {
+        return view.update(component: self, availableSize: availableSize, transition: transition)
+    }
+}