APLCrossDissolveRenderer.swift

/*
 Copyright (C) 2017 Apple Inc. All Rights Reserved.
 See LICENSE.txt for this sample’s licensing information
 
 Abstract:
 APLCrossDissolveRenderer subclass of APLMetalRenderer, renders the given source buffers to perform a cross
  dissolve over the time range of the transition.
 */

import Foundation
import CoreVideo
import MetalKit

class APLCrossDissolveRenderer: APLMetalRenderer {

    /// Vertex coordinates used for drawing our geomentric primitives (triangles).
    fileprivate let vertexArray: [Float] = [

        -1.0, 1.0, 0, 1,
        -1.0, -1.0, 0, 1,
        1.0, -1.0, 0, 1,
        -1.0, 1.0, 0, 1,
        1.0, -1.0, 0, 1,
        1.0, 1.0, 0, 1
    ]

    /// Texture coordinates used for drawing textures in the texture coordinate system.
    fileprivate let textureCoordsArray: [Float] = [

        0.0, 0.0,
        0.0, 1.0,
        1.0, 1.0,
        0.0, 0.0,
        1.0, 1.0,
        1.0, 0.0
    ]

    /// The colors for each vertex coordinate.
    fileprivate let colorArray: [Float] = [

        1, 0, 0, 1,
        0, 1, 0, 1,
        0, 0, 1, 1,
        1, 0, 0, 1,
        0, 0, 1, 1,
        1, 0, 1, 1
    ]

    /// MTLRenderPipelineState objects that contains compiled rendering state, including vertex and fragment shaders.
    fileprivate var foregroundRenderPipelineState: MTLRenderPipelineState?
    fileprivate var backgroundRenderPipelineState: MTLRenderPipelineState?

    /// MTLBuffer used for vertex data.
    fileprivate var vertexBuffer: MTLBuffer?
    /// MTLBuffer used for texture data.
    fileprivate var textureCoordBuffer: MTLBuffer?
    /// MTLBuffer used for color data.
    fileprivate var colorBuffer: MTLBuffer?

    /*
     Instance of RenderPixelBuffers to maintain references to pixel buffers until they are no longer
     needed.
    */
    fileprivate var pixelBuffers: RenderPixelBuffers?

    override init?() {

        super.init()

        // The default library contains all of the shader functions that were compiled into our app bundle.
        guard let library = device.newDefaultLibrary() else { return nil }

        // Retrieve the functions that will comprise our pipeline.

        // Load the vertex program into the library
        guard let vertexFunc = library.makeFunction(name: "passthroughVertexShader") else { return nil }

        // Load the fragment program into the library
        guard let fragmentFunc = library.makeFunction(name: "texturedQuadFragmentShader") else { return nil }

        vertexBuffer =
            device.makeBuffer(bytes: vertexArray,
                              length: vertexArray.count * MemoryLayout.size(ofValue: vertexArray[0]),
                              options: .storageModeShared)

        textureCoordBuffer =
            device.makeBuffer(bytes: textureCoordsArray,
                              length: textureCoordsArray.count * MemoryLayout.size(ofValue: textureCoordsArray[0]),
                              options: .storageModeShared)

        colorBuffer =
            device.makeBuffer(bytes: colorArray,
                              length: colorArray.count * MemoryLayout.size(ofValue: colorArray[0]),
                              options: .storageModeShared)

        // Compile the functions and other state into a pipeline object.
        do {
            foregroundRenderPipelineState =
                try buildForegroundRenderPipelineState(vertexFunc, fragmentFunction: fragmentFunc)

            backgroundRenderPipelineState =
                try buildBackgroundRenderPipelineState(vertexFunc, fragmentFunction: fragmentFunc)
        } catch {
            print("Unable to compile render pipeline state due to error:\(error)")
            return nil
        }
    }

    func setupRenderPassDescriptorForTexture(_ texture: MTLTexture) -> MTLRenderPassDescriptor {

        /*
         MTLRenderPassDescriptor contains attachments that are the rendering destination for pixels
         generated by a rendering pass.
        */
        let renderPassDescriptor = MTLRenderPassDescriptor()

        // Associate the texture object with the attachment.
        renderPassDescriptor.colorAttachments[0].texture = texture
        // Set color to use when the color attachment is cleared.
        renderPassDescriptor.colorAttachments[0].clearColor = MTLClearColor(red: 0, green: 0, blue: 0, alpha: 1.0)
        renderPassDescriptor.colorAttachments[0].loadAction = .clear
        renderPassDescriptor.colorAttachments[0].storeAction = .store

        return renderPassDescriptor
    }

    func buildForegroundRenderPipelineState(_ vertexFunction: MTLFunction, fragmentFunction: MTLFunction) throws -> MTLRenderPipelineState {

        // A MTLRenderPipelineDescriptor object that describes the attributes of the render pipeline state.
        let pipelineDescriptor = MTLRenderPipelineDescriptor()

        // A string to help identify this object.
        pipelineDescriptor.label = "Render Pipeline"
        pipelineDescriptor.vertexFunction = vertexFunction
        pipelineDescriptor.fragmentFunction = fragmentFunction
        // Pixel format of the color attachments texture: BGRA.
        pipelineDescriptor.colorAttachments[0].pixelFormat = MTLPixelFormat.bgra8Unorm
        pipelineDescriptor.colorAttachments[0].isBlendingEnabled = false

        return try device.makeRenderPipelineState(descriptor: pipelineDescriptor)
    }

    func buildBackgroundRenderPipelineState(_ vertexFunction: MTLFunction, fragmentFunction: MTLFunction) throws -> MTLRenderPipelineState {

        // A render pipeline descriptor describes the configuration of our programmable pipeline.
        let pipelineDescriptor = MTLRenderPipelineDescriptor()

        // A string to help identify the object.
        pipelineDescriptor.label = "Render Pipeline - Blending"
        // Provide the vertex and shader function and the pixel format to be used.
        pipelineDescriptor.vertexFunction = vertexFunction
        pipelineDescriptor.fragmentFunction = fragmentFunction
        // Pixel format of the color attachments texture: BGRA.
        pipelineDescriptor.colorAttachments[0].pixelFormat = MTLPixelFormat.bgra8Unorm

        /*
         Enable blending. The blend descriptor property values are then used to determine how source and
         destination color values are combined.
        */
        pipelineDescriptor.colorAttachments[0].isBlendingEnabled = true

        // Specify custom blend operations to perform the cross dissolve effect.

        // Add portions of both source and destination pixel values.
        pipelineDescriptor.colorAttachments[0].rgbBlendOperation = .add
        pipelineDescriptor.colorAttachments[0].alphaBlendOperation = .add
        // Use Blend factor of one.
        pipelineDescriptor.colorAttachments[0].sourceRGBBlendFactor = .one
        pipelineDescriptor.colorAttachments[0].sourceAlphaBlendFactor = .one
        // Blend factor of 1- alpha value.
        pipelineDescriptor.colorAttachments[0].destinationRGBBlendFactor = .oneMinusBlendAlpha
        // Blend factor of alpha.
        pipelineDescriptor.colorAttachments[0].destinationAlphaBlendFactor = .blendAlpha

        return try device.makeRenderPipelineState(descriptor: pipelineDescriptor)
    }

    func renderTexture(_ renderEncoder: MTLRenderCommandEncoder, texture: MTLTexture,
                       pipelineState: MTLRenderPipelineState) {

        // Set the current render pipeline state object.
        renderEncoder.setRenderPipelineState(pipelineState)

        // Specify vertex, color and texture buffers for the vertex shader function.
        renderEncoder.setVertexBuffer(vertexBuffer, offset:0, at:0)
        renderEncoder.setVertexBuffer(colorBuffer, offset:0, at:1)
        renderEncoder.setVertexBuffer(textureCoordBuffer, offset: 0, at: 2)

        // Set a texture for the fragment shader function.
        renderEncoder.setFragmentTexture(texture, at:0)

        // Tell the render context we want to draw our primitives.
        renderEncoder.drawPrimitives(type: .triangle, vertexStart: 0, vertexCount: 6, instanceCount: 1)
    }

    override func renderPixelBuffer(_ destinationPixelBuffer: CVPixelBuffer,
                                    usingForegroundSourceBuffer foregroundPixelBuffer: CVPixelBuffer,
                                    andBackgroundSourceBuffer backgroundPixelBuffer: CVPixelBuffer,
                                    forTweenFactor tween: Float) {

        // Create a MTLTexture from the CVPixelBuffer.
        guard let foregroundTexture = buildTextureForPixelBuffer(foregroundPixelBuffer) else { return }
        guard let backgroundTexture = buildTextureForPixelBuffer(backgroundPixelBuffer) else { return }
        guard let destinationTexture = buildTextureForPixelBuffer(destinationPixelBuffer) else { return }

        /*
         We must maintain a reference to the pixel buffer until the Metal rendering is complete. This is because the
         'buildTextureForPixelBuffer' function above uses CVMetalTextureCacheCreateTextureFromImage to create a
         Metal texture (CVMetalTexture) from the IOSurface that backs the CVPixelBuffer, but
         CVMetalTextureCacheCreateTextureFromImage doesn't increment the use count of the IOSurface; only the
         CVPixelBuffer, and the CVMTLTexture own this IOSurface. Therefore we must maintain a reference to either
         the pixel buffer or Metal texture until the Metal rendering is done. The MTLCommandBuffer completion
         handler below is then used to release these references.
         */
        pixelBuffers = RenderPixelBuffers(foregroundPixelBuffer,
                                          backgroundTexture: backgroundPixelBuffer,
                                          destinationTexture: destinationPixelBuffer)

        // Create a new command buffer for each renderpass to the current drawable.
        let commandBuffer = commandQueue.makeCommandBuffer()
        commandBuffer.label = "MyCommand"

        /*
         Obtain a drawable texture for this render pass and set up the renderpass
         descriptor for the command encoder to render into.
         */
        let renderPassDescriptor = setupRenderPassDescriptorForTexture(destinationTexture)

        // Create a render command encoder so we can render into something.
        let renderEncoder = commandBuffer.makeRenderCommandEncoder(descriptor: renderPassDescriptor)
        renderEncoder.label = "MyRenderEncoder"

        guard let foregroundPipelineState = foregroundRenderPipelineState else { return }

        // Render foreground texture.
        renderTexture(renderEncoder, texture: foregroundTexture,
                      pipelineState: foregroundPipelineState)

        renderEncoder.setBlendColor(red: 0, green: 0, blue: 0, alpha: tween)

        guard let backgroundPipelineState = backgroundRenderPipelineState else { return }

        // Render background texture.
        renderTexture(renderEncoder, texture: backgroundTexture,
                      pipelineState: backgroundPipelineState)

        // We're done encoding commands.
        renderEncoder.endEncoding()

        // Use the command buffer completion block to release the reference to the pixel buffers.
        commandBuffer.addCompletedHandler({ _ in
            self.pixelBuffers = nil // Release the reference to the pixel buffers.
        })

        // Finalize rendering here & push the command buffer to the GPU.
        commandBuffer.commit()
    }
}