@@ -1,7 +1,3 @@
1−// TODO: Render metaballs on layer/view instead of image
2−// TODO: Remove references to view size from shader
3−// TODO: Make shader ignore metaballs that are outside a certain area of tolerance (eg ±100 from borders)
4−
51// TODO: Make graphics have edges only according to graph (instead of being a complete graph)
62
73// TODO: Interpolate metaball colors
@@ -11,44 +7,113 @@
117import Metal
128import UIKit
139
14−class MetalMetaballRenderer: MetaballRenderer {
10+var i = 0
11+
12+class MetalMetaballRenderer {
1513
1614 typealias TargetView = UIImageView
1715
18− static let context = MTLContext()
16+ let targetView: TargetView
17+
18+ let context = MTLContext()
19+ var activeComputeContext: MTLComputeContext
20+ var idleComputeContext: MTLComputeContext
21+
22+ let dataSource: MetaballDataSource
23+
24+ let semaphore = dispatch_semaphore_create(2)
25+
26+ enum RendererState {
27+ case Idle
28+ case Running
29+ case Ending
30+ }
31+
32+ var state: RendererState = .Idle {
33+ willSet {
34+ if state == .Idle {
35+ if newValue == .Running {
36+ updateTargetView()
37+ }
38+ }
39+ }
40+ }
41+
42+ required init(dataSource: MetaballDataSource, frame: CGRect) {
43+ self.dataSource = dataSource
44+
45+ targetView = TargetView(frame: frame)
46+
47+ let width = Int(frame.width)
48+ let height = Int(frame.height)
49+ let textureDescriptor =
50+ MTLTextureDescriptor.texture2DDescriptorWithPixelFormat(.BGRA8Unorm, width: width, height: height, mipmapped: false)
51+
52+ let texture1 = context.device.newTextureWithDescriptor(textureDescriptor)
53+ activeComputeContext = MTLComputeContext(size: targetView.size, texture: texture1)
54+ let texture2 = context.device.newTextureWithDescriptor(textureDescriptor)
55+ idleComputeContext = MTLComputeContext(size: targetView.size, texture: texture2)
56+ }
57+
58+ func updateTargetView() {
59+
60+ let timeout = dispatch_time(DISPATCH_TIME_NOW, 1000000000)
61+ dispatch_semaphore_wait(semaphore, timeout)
62+
63+ print("Update \(i++)!")
64+
65+ state = .Ending
66+
67+ dispatch_async(dispatch_get_global_queue(Int(QOS_CLASS_USER_INTERACTIVE.rawValue), 0)) { () -> Void in
68+
69+ let computeContext = self.activeComputeContext
70+ swap(&self.activeComputeContext, &self.idleComputeContext)
71+
72+ // Render graphics to metal texture
73+ self.renderToContext(computeContext)
1974
20− static func updateTargetView(imageView: UIImageView, dataSource: MetaballDataSource) {
21− let metaballs = dataSource.metaballs
75+ if self.state != .Running {
76+ self.state = .Idle
77+ } else {
78+ self.updateTargetView()
79+ }
80+
81+ // Transform metal texture into image
82+ let uiimage = self.createImageFromContext(computeContext)
83+
84+ dispatch_semaphore_signal(self.semaphore)
85+
86+ dispatch_async(dispatch_get_main_queue(), { () -> Void in
87+ // Send image to view
88+ self.targetView.image = uiimage
89+ })
90+ }
91+ }
92+
93+ func renderToContext(computeContext: MTLComputeContext) {
94+ let width = Int(targetView.width)
95+ let height = Int(targetView.height)
2296
2397 let kernelFunction: MTLFunction?
2498 let pipeline: MTLComputePipelineState
25− var internalTexture: MTLTexture! = nil
26−
2799 do {
100+ // Get long-lived objects
28101 kernelFunction = context.library.newFunctionWithName("drawMetaballs")
29102 pipeline = try context.device.newComputePipelineStateWithFunction(kernelFunction!)
30103
31− let width = Int(imageView.width)
32− let height = Int(imageView.height)
33−
34− let textureDescriptor =
35− MTLTextureDescriptor.texture2DDescriptorWithPixelFormat(.BGRA8Unorm, width: width, height: height, mipmapped: false)
36−
37− internalTexture = context.device.newTextureWithDescriptor(textureDescriptor)
104+ // Configure info for computing
38105 let threadGroupCounts = MTLSizeMake(8, 8, 1)
39106 let threadGroups = MTLSizeMake(width / threadGroupCounts.width,
40107 height / threadGroupCounts.height, 1)
41108
42− //
43− let metaballInfoTexture = metaballTexture(metaballs)
44−
45− //
109+ // Send commands to metal and render
46110 let commandBuffer = context.commandQueue.commandBuffer()
47111
48112 let commandEncoder = commandBuffer.computeCommandEncoder()
49113 commandEncoder.setComputePipelineState(pipeline)
50− commandEncoder.setTexture(internalTexture, atIndex: 0)
51− commandEncoder.setTexture(metaballInfoTexture, atIndex: 1)
114+ commandEncoder.setTexture(computeContext.texture, atIndex: 0)
115+ let metaballInfoBuffer = metaballBuffer()
116+ commandEncoder.setBuffer(metaballInfoBuffer, offset: 0, atIndex: 0)
52117 commandEncoder.dispatchThreadgroups(threadGroups,
53118 threadsPerThreadgroup: threadGroupCounts)
54119 commandEncoder.endEncoding()
@@ -59,30 +124,32 @@ class MetalMetaballRenderer: MetaballRenderer {
59124 } catch _ {
60125 print("Error!")
61126 }
62−
63− imageView.image = image(texture: internalTexture)
64127 }
65128
66− static func image(texture texture: MTLTexture) -> UIImage {
129+ func createImageFromContext(computeContext: MTLComputeContext) -> UIImage {
130+ let texture = computeContext.texture
131+
132+ // Get image info
67133 let imageSize = CGSizeMake(CGFloat(texture.width),
68134 CGFloat(texture.height))
69−
70135 let width = Int(imageSize.width)
71136 let height = Int(imageSize.height)
72−
73137 let imageByteCount = width * height * 4
74− let imageBytes = malloc(imageByteCount)
75138 let bytesPerRow = width * 4
76139 let region = MTLRegionMake2D(0, 0, width, height)
77− texture.getBytes(imageBytes, bytesPerRow: bytesPerRow,
78− fromRegion: region, mipmapLevel: 0)
79140
80− let provider = CGDataProviderCreateWithData(nil, imageBytes,
81− imageByteCount) {
82− (_, data, _) -> Void in
83− free(UnsafeMutablePointer<Void>(data))
141+ // Allocate the buffer if needed
142+ if computeContext.imageBuffer == nil {
143+ computeContext.imageBuffer = malloc(imageByteCount)
84144 }
85145
146+ // Transfer texture info into image buffer
147+ texture.getBytes(computeContext.imageBuffer, bytesPerRow: bytesPerRow,
148+ fromRegion: region, mipmapLevel: 0)
149+
150+ // Get info for UIImage
151+ let provider = CGDataProviderCreateWithData(nil, computeContext.imageBuffer,
152+ imageByteCount, nil)
86153 let bitsPerComponent = 8
87154 let bitsperPixel = 32
88155 let colorSpaceRef = CGColorSpaceCreateDeviceRGB()
@@ -90,37 +157,39 @@ class MetalMetaballRenderer: MetaballRenderer {
90157 CGImageAlphaInfo.PremultipliedLast.rawValue |
91158 CGBitmapInfo.ByteOrder32Big.rawValue)
92159 let renderingIntent = CGColorRenderingIntent.RenderingIntentDefault
160+
161+ // Create UIImage from image buffer
93162 let imageRef = CGImageCreate(width, height,
94163 bitsPerComponent, bitsperPixel, bytesPerRow,
95164 colorSpaceRef, bitmapInfo, provider,
96165 nil, false, renderingIntent)
97166 let image = UIImage(CGImage: imageRef!, scale: 0.0,
98− orientation: UIImageOrientation.DownMirrored)
167+ orientation: UIImageOrientation.Up)
99168
100169 return image
101170 }
102171
103− static func metaballTexture(metaballs: [Metaball]) -> MTLTexture {
104− let floats: [Float] = metaballs.reduce([Float(metaballs.count)]) { (var array, metaball) -> [Float] in
105− array.append(Float(metaball.midX))
106− array.append(Float(metaball.midY))
172+ func metaballBuffer() -> MTLBuffer {
173+ // Create Float array for buffer
174+ // Exclude metaballs far from the view's bounds
175+ let border: CGFloat = 100
176+ let metaballs = self.dataSource.metaballs
177+ var floats: [Float] = metaballs.reduce([Float(0)]) { (var array, metaball) -> [Float] in
178+ let x = CGFloat(metaball.midX)
179+ let y = CGFloat(metaball.midY)
180+ if -border < x ≤ targetView.width + border &&
181+ -border < y ≤ targetView.height + border {
182+ array.append(Float(x))
183+ array.append(Float(y))
184+ }
107185 return array
108186 }
109− let size = floats.count
187+ // Add array size to start of array so metal knows how far to go
188+ floats[0] = Float(floats.count) / 2
110189
111− let textureDescriptor =
112− MTLTextureDescriptor.texture2DDescriptorWithPixelFormat(
113− .R32Float, width: size, height: 1, mipmapped: false)
114−
115− let texture = context.device.newTextureWithDescriptor(textureDescriptor)
116−
117− let region = MTLRegionMake2D(0, 0, size, 1)
190+ // Create buffer
191+ let buffer = context.device.newBufferWithBytes(floats, length: floats.count * sizeof(Float), options: .StorageModeShared)
118192
119− texture.replaceRegion(region, mipmapLevel: 0, withBytes: floats,
120− bytesPerRow: sizeof(Float) * size)
121−
122− return texture
193+ return buffer
123194 }
124−
125195}
126−