Speed up calculation slightly

Engine/Core/Extensions/simd/simd_float3+Extension.swift

@@ -16,8 +16,15 @@ extension simd_float3 {
     public var normalized: simd_float3 {
         self / norm
     }
+    public mutating func normalize() {
+        self /= norm
+    }
     public func randomPerpendicular(length: Float = 1) -> simd_float3 {
-        cross(self, simd_float3.random()).normalized * length
+        let randomVector = simd_float3.random()
+        var perpendicular = cross(self, randomVector)
+        perpendicular.normalize()
+        perpendicular *= length
+        return perpendicular
     }
     public init(_ x: Int, _ y: Int, _ z: Int) {
         self.init(Float(x), Float(y), Float(z))

Engine/Core/Extensions/simd/simd_float3x3+Extension.swift

@@ -10,9 +10,12 @@ extension simd_float3x3 {
     }
     public static func from(directionVector binormal: simd_float3) -> simd_float3x3 {
         assertEqual(length(binormal), 1)
-        var normal = simd_float3.random().normalized
-        normal = (normal - dot(binormal, normal) * binormal).normalized
-        let tangent = cross(normal, binormal).normalized
+        var normal = simd_float3.random()
+        normal.normalize()
+        normal = (normal - dot(binormal, normal) * binormal)
+        normal.normalize()
+        var tangent = cross(normal, binormal)
+        tangent.normalize()
         assert(dot(normal, binormal) == 0)
         assert(dot(tangent, binormal) == 0)
         return simd_float3x3(tangent, normal, -binormal)

Engine/Core/Scene/Ray/PNRay.swift

@@ -18,7 +18,8 @@ public struct PNRay {
 }
 
 func * (_ lhs: simd_float4x4, _ rhs: PNRay) -> PNRay {
-    let ldir = simd_float3x3(lhs.rotation) * rhs.direction
+    var ldir = simd_float3x3(lhs.rotation) * rhs.direction
+    ldir.normalize()
     let lori = lhs * simd_float4(rhs.origin, 1)
-    return PNRay(origin: lori.xyz, direction: ldir.normalized)
+    return PNRay(origin: lori.xyz, direction: ldir)
 }