创建无框架的无尽cgpath [英] Create endless cgpath without framedrops

问题描述

我需要连续创建一个cgpath.目前，我是这样的:

I need to create a cgpath continuously. At the moment I do it like that:

 func createLine(){
        var rand = randomBetweenNumbers(1, 2)
        currentY--
        if rand < 1.5{
            currentX--
            CGPathAddLineToPoint(leftPath, nil, currentX, currentY)
        }else{
            currentX++
            CGPathAddLineToPoint(leftPath, nil, currentX, currentY)
        }
        CGPathAddLineToPoint(rightPath, nil, currentX+tileSize, currentY)
        lineNode.path = leftPath
        rightNode.path = rightPath

}

并这样称呼它:

NSTimer.scheduledTimerWithTimeInterval(0.05, target: self, selector: Selector("startTile"), userInfo: nil, repeats: true)

但是问题是，帧随着时间下降越来越低.我是否需要更改某些内容，以使帧速率不再下降?

But the problem is, that the frames drop lower and lower over time. Is there something I have to change so that the framerate no longer drops?

我的目标是创建一条随机的无尽路径.

My goal is to create a random endless path.

推荐答案

在绘制逐渐增加的线数的同时保持较高的FPS数量的关键是迅速达到一种状态，即在场景中添加更多的线很少甚至没有对帧速率的影响.至少有两种方法可以做到这一点.

The key to maintaining a high FPS count while drawing a progressively increasing number of lines is to quickly reach a state where adding more lines to the scene has little or no effect on frame rate. There are at least two ways to accomplish this.

这两者中最直接的方法是定期将先前绘制的线条转换为SKTexture，并将结果显示为SKSpriteNode的纹理.步骤如下:

The most straightforward of the two is to periodically convert the previously drawn lines to an SKTexture and display the results as texture of an SKSpriteNode. Here are the steps:

1. 创建一个SKNode用作行容器
2. 创建一个SKSpriteNode用作线条画布
3. 创建一个SKShapeNode用于绘制新线条
4. 将容器添加到场景中，并将画布和形状节点添加到容器中
5. 使用形状节点的path属性绘制一组连接的线段
6. 当行数达到预定值时，将容器的内容转换为"SKTexture"
7. 将画布的texture属性设置为SKTexture.请注意，由于画布也是容器的子级，因此其内容也将添加到纹理中
8. 起泡，冲洗，然后重复步骤5-7

1. Create an SKNode to be used as a line container
2. Create an SKSpriteNode that will be used as a line canvas
3. Create an SKShapeNode to be used to draw new lines
4. Add the container to the scene and the canvas and shape node to the container
5. Draw a set of connected line segments using the path property of the shape node
6. When the line count reaches a predetermined value, convert the contents of the container to an 'SKTexture'
7. Set the texture property of the canvas to the SKTexture. Note that since the canvas is also a child of the container, its contents will also be added to the texture
8. Lather, rinse, repeat steps 5 - 7

下面是Swift中的一个示例实现，该示例在iPhone 6设备上以60 FPS绘制了无休止的线条(您应该在不使用模拟器的设备上测试性能):

Here's an example implementation in Swift that draws an endless set of lines at 60 FPS on an iPhone 6 device (you should test performance on a device not with the simulator):

class GameScene: SKScene {
    // 1. Create container to hold new and old lines
    var lineContainer = SKNode()
    // 2. Create canvas
    var lineCanvas:SKSpriteNode?
    // 3. Create shape to draw new lines
    var lineNode = SKShapeNode()

    var lastDrawTime:Int64 = 0
    var lineCount = 0
    var timeScan:Int64 = 0
    var path = CGPathCreateMutable()

    var lastPoint = CGPointZero

    override func didMoveToView(view:SKView) {
        scaleMode = .ResizeFill

        // 4. Add the container to the scene and the canvas to the container 
        addChild(lineContainer)
        lineCanvas = SKSpriteNode(color:SKColor.clearColor(),size:view.frame.size)
        lineCanvas!.anchorPoint = CGPointZero
        lineCanvas!.position = CGPointZero
        lineContainer.addChild(lineCanvas!)
        lastPoint = CGPointMake(view.frame.size.width/2.0, view.frame.size.height/2.0)
    }

    // Returns a random value in the specified range
    func randomInRange(minValue:CGFloat, maxValue:CGFloat) -> CGFloat {
        let r = CGFloat(Double(arc4random_uniform(UInt32.max))/Double(UInt32.max))
        return (maxValue-minValue) * r + minValue
    }

    func drawLine() {
        if (CGPathIsEmpty(path)) {
            // Create a new line that starts where the previous line ended
            CGPathMoveToPoint(path, nil, lastPoint.x, lastPoint.y)
            lineNode.path = nil
            lineNode.lineWidth = 1.0
            lineNode.strokeColor = SKColor.blueColor()
            lineNode.zPosition = 100
            lineContainer.addChild(lineNode)
        }
        // Add a random line segment
        let x = randomInRange(size.width*0.1, maxValue: size.width*0.9)
        let y = randomInRange(size.height*0.1, maxValue: size.height*0.9)
        CGPathAddLineToPoint(path, nil, x, y)
        lineNode.path = path
        // Save the current point so we can connect the next line to the end of the last line
        lastPoint = CGPointMake(x, y)
    }

    override func update(currentTime: CFTimeInterval) {
        let lineDrawTime = timeScan / 10
        // 5. Draw a new line every 10 updates. Increment line count
        if (lineDrawTime != lastDrawTime) {
            drawLine()
            ++lineCount
        }
        // 6. and 7. Add all newly and previously drawn lines to the canvas
        if (lineCount == 8) {
            addLinesToTexture()
            lineCount = 0
        }
        lastDrawTime = lineDrawTime
        ++timeScan
    }

    func addLinesToTexture () {
        // Convert the contents of the line container to an SKTexture
        let texture = self.view!.textureFromNode(lineContainer)
        // Display the texture
        lineCanvas!.texture = texture
        // Start a new line
        lineNode.removeFromParent()
        path = CGPathCreateMutable()
    }
}

这篇关于创建无框架的无尽cgpath的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！