[MetalKit]Ray tracing in a Swift playground射线追踪

本系列文章是对 http://metalkit.org 上面MetalKit内容的全面翻译和学习.

MetalKit系统文章目录

---

今天我们从Peter Shirley’s mini book导入ray tracer射线追踪器到Swiftplayground中.我将不会解释什么是Ray Tracing射线追踪及它是怎么工作的,我会请你自己先去读一读这本书因为它对Kindle订阅者是免费的.如果你不是订阅者,只需要像我一样购买这本书就行了.如果你对这个话题感兴趣,那花费$2.99是绝对值得的.

我们要做的第一件事就是创建一个数据结构体来保存像素信息.在playground中,在Sources文件夹下创建一个新文件命名为pixel.swift.下一步,编写Pixel结构体.它只是一个简单结构体,各用一个变量来保存 RGBA 通道.我们初始化alpha通道为255,这意味着在[0~255]范围的完全不透明:

public struct Pixel {
    var r: UInt8
    var g: UInt8
    var b: UInt8
    var a: UInt8
    init(red: UInt8, green: UInt8, blue: UInt8) {
        r = red
        g = green
        b = blue
        a = 255
    }
}

下一步,我们需要创建一个数组来保存屏幕上的像素.为了计算每个像素的颜色,我们只需要给所有像素的Red设置为0,同时Green则从屏幕左下角的0(没有任何绿色)渐变到屏幕右上角的255(纯绿色).同样,Blue颜色从屏幕顶部的0渐变到屏幕底部的255.

public func makePixelSet(width: Int, _ height: Int) -> ([Pixel], Int, Int) {
    var pixel = Pixel(red: 0, green: 0, blue: 0)
    var pixels = [Pixel](count: width * height, repeatedValue: pixel)
    for i in 0..

最后,我们需要一个方法来从像素创建出一个可绘制的图片.Core Image框架提供了CGImageCreate()方法,它只需要几个参数就可以渲染图片:

public func imageFromPixels(pixels: ([Pixel], width: Int, height: Int)) -> CIImage {
    let bitsPerComponent = 8
    let bitsPerPixel = 32
    let rgbColorSpace = CGColorSpaceCreateDeviceRGB()
    let bitmapInfo = CGBitmapInfo(rawValue: CGImageAlphaInfo.PremultipliedLast.rawValue) // alpha is last

    let providerRef = CGDataProviderCreateWithCFData(NSData(bytes: pixels.0, length: pixels.0.count * sizeof(Pixel)))
    let image = CGImageCreate(pixels.1, pixels.2, bitsPerComponent, bitsPerPixel, pixels.1 * sizeof(Pixel), rgbColorSpace, bitmapInfo, providerRef, nil, true, CGColorRenderingIntent.RenderingIntentDefault)
    return CIImage(CGImage: image!)
}

下一步,在playground主页中用给定的width和height创建一个窗口像素的集合,并用这个集合来创建渲染出的图片:

let width = 800
let height = 400
var pixelSet = makePixelSet(width, height)
var image = imageFromPixels(pixelSet)
image

你应该能看到下面的图面:

raytracing1.png

OK,你可能会好奇,但是ray tracing射线追踪在哪里呢?我们稍后再解释这个.在Sources文件夹下面,让我们创建一个便利的类命名为vec3.swift,在里面放一些数学工具方法:

struct vec3 {
    var x = 0.0
    var y = 0.0
    var z = 0.0
}

func * (left: Double, right: vec3) -> vec3 {
    return vec3(x: left * right.x, y: left * right.y, z: left * right.z)
}

func + (left: vec3, right: vec3) -> vec3 {
    return vec3(x: left.x + right.x, y: left.y + right.y, z: left.z + right.z)
}

func - (left: vec3, right: vec3) -> vec3 {
    return vec3(x: left.x - right.x, y: left.y - right.y, z: left.z - right.z)
}

func dot (left: vec3, _ right: vec3) -> Double {
    return left.x * right.x + left.y * right.y + left.z * right.z
}

func unit_vector(v: vec3) -> vec3 {
    let length : Double = sqrt(dot(v, v))
    return vec3(x: v.x/length, y: v.y/length, z: v.z/length)
}

下一步,我们需要创建一个ray射线结构体.它拥有一个origin原点成员,一个direction方向,还有一个方法可以计算任意给定参数的ray tracing方程式:

struct ray {
    var origin: vec3
    var direction: vec3
    func point_at_parameter(t: Double) -> vec3 {
        return origin + t * direction
    }
}

然后我们需要计算颜色,基于ray射线是否接触到我们在屏幕中间创建的sphere球体:

func color(r: ray) -> vec3 {
    let minusZ = vec3(x: 0, y: 0, z: -1.0)
    var t = hit_sphere(minusZ, 0.5, r)
    if t > 0.0 {
        let norm = unit_vector(r.point_at_parameter(t) - minusZ)
        return 0.5 * vec3(x: norm.x + 1.0, y: norm.y + 1.0, z: norm.z + 1.0)
    }
    let unit_direction = unit_vector(r.direction)
    t = 0.5 * (unit_direction.y + 1.0)
    return (1.0 - t) * vec3(x: 1.0, y: 1.0, z: 1.0) + t * vec3(x: 0.5, y: 0.7, z: 1.0)
}

你注意到我们用到了另一个方法,叫hit_sphere(),来确定我们的射线是撞到了球体,或者没有接触球体:

func hit_sphere(center: vec3, _ radius: Double, _ r: ray) -> Double {
    let oc = r.origin - center
    let a = dot(r.direction, r.direction)
    let b = 2.0 * dot(oc, r.direction)
    let c = dot(oc, oc) - radius * radius
    let discriminant = b * b - 4 * a * c
    if discriminant < 0 {
        return -1.0
    } else {
        return (-b - sqrt(discriminant)) / (2.0 * a)
    }
}

回到pixel.swift文件,更改makePixelSet(:),使其在每个像素被加入集合前,给每个像素创建一个ray射线并计算它的color颜色:

public func makePixelSet(width: Int, _ height: Int) -> ([Pixel], Int, Int) {
    var pixel = Pixel(red: 0, green: 0, blue: 0)
    var pixels = [Pixel](count: width * height, repeatedValue: pixel)
    let lower_left_corner = vec3(x: -2.0, y: 1.0, z: -1.0)
    let horizontal = vec3(x: 4.0, y: 0, z: 0)
    let vertical = vec3(x: 0, y: -2.0, z: 0)
    let origin = vec3()
    for i in 0..

在playground的主页面,看看产生的新图像:

raytracing2.png

敬请关注本文的第2部分,我们将会计算灯光和阴影,产生更真实的图像渲染.

源代码source code 已发布在Github上.
下次见!