add float4x4 extensions

Author: eugenebokhan

README.md

@@ -7,7 +7,7 @@
     <img src="Sources/SIMDTools/SIMDTools.docc/Resources/documentation-art/[email protected]", width="120">
 </p>
 
-Welcome to the documentation for the `SIMDTools` Swift package. This package provides utility functions and extensions for working with SIMD matrices and vectors in Swift.
+`SIMDTools` provides utility functions and extensions for working with SIMD matrices and vectors in Swift.
 
 ## Overview
 

Sources/SIMDTools/SIMDTools.docc/Resources/documentation-art/[email protected]

@@ -365,6 +365,65 @@ public extension simd_float4x4 {
             [dd + offset, ee,  ff, 1]
         )
     }
+
+    /// Returns a scaling matrix to fill the original size exactly within the bounding size, without maintaining the aspect ratio
+    /// - Parameters:
+    ///   - originalSize: The original size of the object
+    ///   - boundingSize: The bounding size to fill the object into
+    /// - Returns: A new scaling matrix
+    static func fillScale(
+        originalSize: SIMD2<Float32>,
+        boundingSize: SIMD2<Float32>
+    ) -> float4x4 {
+        let scaleFactors = boundingSize / originalSize
+        return .scale(value: SIMD3<Float32>(scaleFactors.x, scaleFactors.y, 1))
+    }
+    
+    /// Returns a scaling matrix to fill the original size within the bounding size, maintaining the aspect ratio and cropping excess
+    /// - Parameters:
+    ///   - originalSize: The original size of the object
+    ///   - boundingSize: The bounding size to fill the object into
+    /// - Returns: A new scaling matrix
+    static func aspectFillScale(
+        originalSize: SIMD2<Float32>,
+        boundingSize: SIMD2<Float32>
+    ) -> float4x4 {
+        var newSize = boundingSize
+        let mW = newSize.x / originalSize.x
+        let mH = newSize.y / originalSize.y
+
+        if mH > mW {
+            newSize.x = newSize.y / originalSize.y * originalSize.x
+        } else if mW > mH {
+            newSize.y = newSize.x / originalSize.x * originalSize.y
+        }
+
+        let scaleFactors = newSize / originalSize
+        return .scale(value: SIMD3<Float32>(scaleFactors.x, scaleFactors.y, 1))
+    }
+
+    /// Returns a scaling matrix to fit the original size within the bounding size, maintaining the aspect ratio
+    /// - Parameters:
+    ///   - originalSize: The original size of the object
+    ///   - boundingSize: The bounding size to fit the object into
+    /// - Returns: A new scaling matrix
+    static func aspectFitScale(
+        originalSize: SIMD2<Float32>,
+        boundingSize: SIMD2<Float32>
+    ) -> float4x4 {
+        var newSize = boundingSize
+        let mW = newSize.x / originalSize.x
+        let mH = newSize.y / originalSize.y
+
+        if mH < mW {
+            newSize.x = newSize.y / originalSize.y * originalSize.x
+        } else if mW < mH {
+            newSize.y = newSize.x / originalSize.x * originalSize.y
+        }
+
+        let scaleFactors = newSize / originalSize
+        return .scale(value: SIMD3<Float32>(scaleFactors.x, scaleFactors.y, 1))
+    }
 }
 
 // MARK: - Codable
@@ -397,5 +456,5 @@ extension float4x4: Codable {
         try container.encode(self.columns.2, forKey: .column3)
         try container.encode(self.columns.3, forKey: .column4)
     }
-    
+
 }

Sources/SIMDTools/float4x4+Extensions.swift

@@ -3,12 +3,12 @@ import simd
 @testable import SIMDTools
 
 class Float4x4Tests: XCTestCase {
-
+    
     func testIdentityMatrix() {
         let identity = float4x4.identity
         XCTAssertEqual(identity, float4x4(diagonal: SIMD4<Float>(1, 1, 1, 1)))
     }
-
+    
     func testTranslationMatrix() {
         let translation = float4x4.translate(value: SIMD3<Float>(2.0, 3.0, 4.0))
         let expected = float4x4(
@@ -19,7 +19,7 @@ class Float4x4Tests: XCTestCase {
         )
         XCTAssertEqual(translation, expected)
     }
-
+    
     func testRotationMatrixX() {
         let angle = Angle(degrees: 90)
         let rotation = float4x4.rotate(x: angle)
@@ -31,7 +31,7 @@ class Float4x4Tests: XCTestCase {
         )
         XCTAssertEqual(rotation, expected)
     }
-
+    
     func testRotationMatrixY() {
         let angle = Angle(degrees: 90)
         let rotation = float4x4.rotate(y: angle)
@@ -43,7 +43,7 @@ class Float4x4Tests: XCTestCase {
         )
         XCTAssertEqual(rotation, expected)
     }
-
+    
     func testRotationMatrixZ() {
         let angle = Angle(degrees: 90)
         let rotation = float4x4.rotate(z: angle)
@@ -55,7 +55,7 @@ class Float4x4Tests: XCTestCase {
         )
         XCTAssertEqual(rotation, expected)
     }
-
+    
     func testShearXYMatrix() {
         let shear = float4x4.shear(xy: SIMD2<Float>(1.0, 0.5))
         let expected = float4x4(
@@ -66,7 +66,7 @@ class Float4x4Tests: XCTestCase {
         )
         XCTAssertEqual(shear, expected)
     }
-
+    
     func testShearXZMatrix() {
         let shear = float4x4.shear(xz: SIMD2<Float>(1.0, 0.5))
         let expected = float4x4(
@@ -77,7 +77,7 @@ class Float4x4Tests: XCTestCase {
         )
         XCTAssertEqual(shear, expected)
     }
-
+    
     func testShearYZMatrix() {
         let shear = float4x4.shear(yz: SIMD2<Float>(1.0, 0.5))
         let expected = float4x4(
@@ -88,7 +88,7 @@ class Float4x4Tests: XCTestCase {
         )
         XCTAssertEqual(shear, expected)
     }
-
+    
     func testScalingMatrix() {
         let scaling = float4x4.scale(value: SIMD3<Float>(2.0, 3.0, 4.0))
         let expected = float4x4(
@@ -99,5 +99,94 @@ class Float4x4Tests: XCTestCase {
         )
         XCTAssertEqual(scaling, expected)
     }
-
+    
+    // Helper function to compare float4x4 matrices
+    func assertMatrix(_ matrix1: float4x4, isCloseTo matrix2: float4x4, accuracy: Float = 1e-6) {
+        for i in 0..<4 {
+            for j in 0..<4 {
+                XCTAssertEqual(matrix1[i][j], matrix2[i][j], accuracy: accuracy, "Matrices differ at [\(i)][\(j)]")
+            }
+        }
+    }
+    
+    func testFillScale() {
+        let originalSize = SIMD2<Float>(100, 50)
+        let boundingSize = SIMD2<Float>(200, 150)
+        
+        let expectedMatrix = float4x4(
+            [2, 0, 0, 0],
+            [0, 3, 0, 0],
+            [0, 0, 1, 0],
+            [0, 0, 0, 1]
+        )
+        
+        let resultMatrix = float4x4.fillScale(originalSize: originalSize, boundingSize: boundingSize)
+        
+        assertMatrix(resultMatrix, isCloseTo: expectedMatrix)
+    }
+    
+    func testAspectFillScale() {
+        let originalSize = SIMD2<Float>(100, 50)
+        let boundingSize = SIMD2<Float>(200, 150)
+        
+        let expectedMatrix = float4x4(
+            [3, 0, 0, 0],
+            [0, 3, 0, 0],
+            [0, 0, 1, 0],
+            [0, 0, 0, 1]
+        )
+        
+        let resultMatrix = float4x4.aspectFillScale(originalSize: originalSize, boundingSize: boundingSize)
+        
+        assertMatrix(resultMatrix, isCloseTo: expectedMatrix)
+    }
+    
+    func testAspectFitScale() {
+        let originalSize = SIMD2<Float>(100, 50)
+        let boundingSize = SIMD2<Float>(200, 150)
+        
+        let expectedMatrix = float4x4(
+            [2, 0, 0, 0],
+            [0, 2, 0, 0],
+            [0, 0, 1, 0],
+            [0, 0, 0, 1]
+        )
+        
+        let resultMatrix = float4x4.aspectFitScale(originalSize: originalSize, boundingSize: boundingSize)
+        
+        assertMatrix(resultMatrix, isCloseTo: expectedMatrix)
+    }
+    
+    func testAspectFillScaleSquareBounds() {
+        let originalSize = SIMD2<Float>(100, 50)
+        let boundingSize = SIMD2<Float>(200, 200)
+        
+        let expectedMatrix = float4x4(
+            [4, 0, 0, 0],
+            [0, 4, 0, 0],
+            [0, 0, 1, 0],
+            [0, 0, 0, 1]
+        )
+        
+        let resultMatrix = float4x4.aspectFillScale(originalSize: originalSize, boundingSize: boundingSize)
+        
+        assertMatrix(resultMatrix, isCloseTo: expectedMatrix)
+    }
+    
+    func testAspectFitScaleSquareBounds() {
+        let originalSize = SIMD2<Float>(100, 50)
+        let boundingSize = SIMD2<Float>(200, 200)
+        
+        let expectedMatrix = float4x4(
+            [2, 0, 0, 0],
+            [0, 2, 0, 0],
+            [0, 0, 1, 0],
+            [0, 0, 0, 1]
+        )
+        
+        let resultMatrix = float4x4.aspectFitScale(originalSize: originalSize, boundingSize: boundingSize)
+        
+        assertMatrix(resultMatrix, isCloseTo: expectedMatrix)
+    }
+    
 }