CALayer drawinContext称为@ 60fps，但以1fps查看更新图形

Question

I am trying to implement a graph drawing view in OSX using Cocoa and Quartz framework using NSBezierPath and add/delete data points as I go.

Doing so in drawRect worked fine as the graph was updating frequently but then I encountered performance problem when I need to increase total datapoints/sampling rate.

I decided to move to drawLayer: inContext: but as the function is called at 60fps, the view isn't updating the graph when the function is call and instead update at 1fps.

What am I doing wrong here?

class CustomDrawLayer: CALayer {


convenience init(view: NSView, drawsAsynchronously : Bool = false) {
    self.init()
    self.bounds = view.bounds
    self.anchorPoint = CGPointZero
    self.opaque = false
    self.frame = view.frame
    self.drawsAsynchronously = drawsAsynchronously

    //        for multiple draws in hosting view
    //        self.delegate = self

}

override func actionForLayer(layer: CALayer, forKey event: String) -> CAAction? {
    return nil
}}

override func drawLayer(layer: CALayer, inContext ctx: CGContext) {

    if layer == self.layer {
        Swift.print("axes drawing")
        graphBounds.origin = self.frame.origin
        graphAxes.drawAxesInRect(graphBounds, axeOrigin: plotOrigin, xPointsToShow: CGFloat(totalSecondsToDisplay), yPointsToShow: CGFloat(totalChannelsToDisplay))
    }

    if layer == self.board {
        Swift.print(1/NSDate().timeIntervalSinceDate(fpsTimer))
        fpsTimer = NSDate()
        drawPointsInGraph(graphAxes, context: ctx)

    }
}

    func drawPointsInGraph(axes: AxesDrawer, context:  CGContext)
    {
            color.set()

            var x : CGFloat = 0
            var y : CGFloat = 0

            for var channel = 0; channel < Int(totalChannelsToDisplay); channel++ {

                path.removeAllPoints()

                var visibleIndex = (dirtyRect.origin.x - axes.position.x) / (axes.pointsPerUnit.x / samplingRate)
                if visibleIndex < 2 {
                    visibleIndex = 2
                }
                for var counter = Int(visibleIndex); counter < dataStream![channel].count; counter++ {

                    if dataStream![channel][counter] == 0  {
                        if path.elementCount > 0 {
                            path.stroke()
                        }

                        break
                    }


                    let position = axes.position
                    let ppY = axes.pointsPerUnit.y
                    let ppX = axes.pointsPerUnit.x

                    let channelYLocation = CGFloat(channel)

                    x = position.x + CGFloat(counter-1) * (ppX / samplingRate)
                    y = ((channelYLocation * ppY) + position.y) + (dataStream![channel][counter-1] * (ppY))
                    path.moveToPoint(CGPoint(x: align(x), y: align(y)))

                    x = position.x + CGFloat(counter) * (ppX / samplingRate)
                    y = ((channelYLocation * ppY) + position.y) + (dataStream![channel][counter] * (ppY) )


                    path.lineToPoint(CGPoint(x: align(x), y: align(y)))




                    if x > (axes.position.x + axes.bounds.width) * 0.9 {

                        graphAxes.forwardStep = 5
                        dirtyRect = graphBounds

                        for var c = 0; c < Int(totalChannelsToDisplay); c++ {
                            for var i = 0; i < Int(samplingRate) * graphAxes.forwardStep; i++
                            {
                                dataStream![c][i] = 0
                            }

                        }

                        return
                    }


                }



                path.stroke()

        }

        if inLiveResize {
            dirtyRect = graphBounds
        } else {
            dirtyRect.origin.x = x
            dirtyRect.origin.y = bounds.minY
            dirtyRect.size.width = 10
            dirtyRect.size.height = bounds.height
        }


    }

Answer 1

If your path needs to be drawn that frequently, check out CAShapeLayer, where you can just change the path property. That will be hardware accelerated and much faster than drawRect or drawLayer.

Answer 2

It is incredibly rare that you should ever call a function at 60 Hz. In no case should you ever try to call a drawing function at 60 Hz; that never makes sense in Cocoa. If you really mean "at the screen refresh interval," see CADisplayLink , which is specifically built to allow you to draw at the screen refresh interval. This may be slower than 60 Hz. If you try to draw exactly at 60 Hz, you can get out of sync and cause beats in your animation. But this really only intended for things like real-time video. If that what you have, then this is the tool, but it doesn't really sound like it.

It's a bit difficult to understand your code. It's not clear where your 60fps comes in. But I'm assuming what you're trying to do is animate drawing the graph. If so, as Mark F notes, see CAShapeLayer. It has automatic path animations built-in, and is definitely what you want. It automatically handles timings and syncing with the screen refresh and GPU optimizations, and lots of other things that you shouldn't try to work around.

Even if CAShapeLayer isn't what you want, you should be looking at Core Animation, which is designed to work with you to animate values and redraw as necessary. It automatically will handle rendering your layer on multiple cores for instance, which will dramatically improve performance. For more on that, see Animating Custom Layer Properties .