Correct typos (#31)

correct a whole slew of typos using typos-cli

Author: gregcotten

Package.swift

@@ -86,7 +86,7 @@ let package = Package(
                             .define("GATEENGINE_CLOSES_ALLWINDOWS_WITH_MAINWINDOW", .when(platforms: [.macOS, .windows, .linux])),
                             /// Checks for reloadable resources and reloads them if they have changed
                             .define("GATEENGINE_ENABLE_HOTRELOADING", .when(platforms: [.macOS, .windows, .linux], configuration: .debug)),
-                            /// The host platfrom requests the main window, so GateEngine won't create one until it's requested
+                            /// The host platform requests the main window, so GateEngine won't create one until it's requested
                             .define("GATEENGINE_PLATFORM_CREATES_MAINWINDOW", .when(platforms: [.iOS, .tvOS])),
                             /// The host platform can't be usaed to compile HTML5 products
                             .define("GATEENGINE_WASI_UNSUPPORTED_HOST", .when(platforms: [.windows])),
@@ -99,7 +99,7 @@ let package = Package(
                         #if false // Options for development of GateEngine. These should be commented out for tagged version releases.
                         #warning("GateEngine development options are enabled. These can cause strange build errors on some platforms.")
 
-                        // Options for developemnt of WASI platform
+                        // Options for developments of WASI platform
                         #if false
                         settings.append(contentsOf: [
                             /// Allows HTML5 platform to be compiled from a compatible host, such as macOS. This allows the IDE to show compile errors without targeting WASI.
@@ -110,11 +110,11 @@ let package = Package(
                         #endif
 
                         settings.append(contentsOf: [
-                            /// Printes the output of generated shaders
+                            /// Printers the output of generated shaders
                             .define("GATEENGINE_LOG_SHADERS"),
-                            /// Enables varius additional checks and output for rendering
+                            /// Enables various additional checks and output for rendering
                             .define("GATEENGINE_DEBUG_RENDERING"),
-                            /// Enables varius additional checks and output for input
+                            /// Enables various additional checks and output for input
                             .define("GATEENGINE_DEBUG_HID"),
                             /// Forces Apple platforms to use OpenGL for rendering
                             .define("GATEENGINE_FORCE_OPNEGL_APPLE", .when(platforms: [.macOS, .iOS, .tvOS])),

Sources/GameMath/2D Types/2D Physics/2D Colliders/AxisAlignedBoundingBox2D.swift

@@ -16,7 +16,7 @@ public struct AxisAlignedBoundingBox2D: Collider2D {
     /// The updated radius of the collider
     /// Use the `update(transform:)` function to update this value.
     public private(set) var radius: Size2
-    /// The updated offest of the collider
+    /// The updated offset of the collider
     /// Use the `update(transform:)` function to update this value.
     public private(set) var offset: Position2
 
@@ -185,7 +185,7 @@ public struct AxisAlignedBoundingBox2D: Collider2D {
         case let collider as AxisAlignedBoundingBox2D:
             return interpenetration(comparing: collider)
         default:
-            // Other colliders forward their check to AABB. If we get here there is no implimentation.
+            // Other colliders forward their check to AABB. If we get here there is no implementation.
             fatalError("Unhandled collider: \(type(of: collider))")
         }
     }
@@ -211,22 +211,22 @@ public struct AxisAlignedBoundingBox2D: Collider2D {
         let minPosition = rhs.center + rhs.offset - rhs.radius
         guard self.contains(minPosition, withThreshold: threshold) else {return false}
 
-        let maxPositon = minPosition + rhs.size
-        guard self.contains(maxPositon, withThreshold: threshold) else {return false}
+        let maxPosition = minPosition + rhs.size
+        guard self.contains(maxPosition, withThreshold: threshold) else {return false}
 
         return true
     }
 
     /// `true` if `rhs` is inside `self`
     public func contains(_ rhs: Position2, withThreshold threshold: Float = 0) -> Bool {
-        let positon = self.position - (self.radius + threshold)
+        let position = self.position - (self.radius + threshold)
 
-        guard rhs.x >= positon.x else {return false}
-        guard rhs.y >= positon.y else {return false}
+        guard rhs.x >= position.x else {return false}
+        guard rhs.y >= position.y else {return false}
 
         let size = self.size + threshold
-        guard rhs.x <= positon.x + size.x else {return false}
-        guard rhs.y <= positon.y + size.y else {return false}
+        guard rhs.x <= position.x + size.x else {return false}
+        guard rhs.y <= position.y + size.y else {return false}
 
         return true
     }

Sources/GameMath/2D Types/2D Physics/2D Colliders/BoundingCircle2D.swift

@@ -141,7 +141,7 @@ public extension BoundingCircle2D {
     @inlinable @inline(__always)
     func surfaceNormal(facing point: Position2) -> Direction2 {
         let position = self.position
-        // If the points are the same there is no direction, return a defualt
+        // If the points are the same there is no direction, return a default
         guard point != position else {return .up}
         return Direction2(from: self.position, to: point)
     }

Sources/GameMath/2D Types/2D Physics/2D Colliders/BoundingEllipsoid2D.swift

@@ -110,7 +110,7 @@ public extension BoundingEllipsoid2D {
 
     func surfaceNormal(facing point: Position2) -> Direction2 {
         let position = self.position
-        // If the points are the same there is no direction, return a defualt
+        // If the points are the same there is no direction, return a default
         guard point != position else {return .up}
         return Direction2(from: position / radius, to: point / radius) * radius
     }

Sources/GameMath/2D Types/Transform2.swift

@@ -36,7 +36,7 @@ public struct Transform2 {
 
     private var _needsUpdate: Bool = true
     private lazy var _matrix: Matrix4x4 = .identity
-    private lazy var _roationMatrix: Matrix4x4 = .identity
+    private lazy var _rotationMatrix: Matrix4x4 = .identity
     private lazy var _scaleMatrix: Matrix4x4 = .identity
 }
 #else
@@ -71,7 +71,7 @@ public struct Transform2 {
 
     private var _needsUpdate: Bool = true
     private lazy var _matrix: Matrix4x4 = .identity
-    private lazy var _roationMatrix: Matrix4x4 = .identity
+    private lazy var _rotationMatrix: Matrix4x4 = .identity
     private lazy var _scaleMatrix: Matrix4x4 = .identity
 }
 #endif

Sources/GameMath/3D Types/3D Physics/3D Colliders/OrientedBoundingBox3D.swift

@@ -362,7 +362,7 @@ extension OrientedBoundingBox3D {
 
 extension OrientedBoundingBox3D {
     @inline(__always)
-    public var verticies: [Position3] {
+    public var vertices: [Position3] {
         let x = self.radius.width
         let y = self.radius.height
         let z = self.radius.depth
@@ -379,12 +379,12 @@ extension OrientedBoundingBox3D {
     }
     @inline(__always)
     func vertexSpan(along axis: Direction3) -> ClosedRange<Float> {
-        let verticies = self.verticies
+        let vertices = self.vertices
 
-        var min = verticies[0].dot(axis)
+        var min = vertices[0].dot(axis)
         var max = min
 
-        for vertex in verticies {
+        for vertex in vertices {
             let d = vertex.dot(axis)
 
             if d < min {
@@ -455,13 +455,13 @@ extension OrientedBoundingBox3D {
     }
 
     @inline(__always)
-    static func getNumHitPoints(_ box0: OrientedBoundingBox3D, _ hitNormal: Direction3, _ penetration: Float, _ vertIndexs: inout [Array<Position3>.Index]) -> [Position3] {
-        let verticies = box0.verticies
+    static func getNumHitPoints(_ box0: OrientedBoundingBox3D, _ hitNormal: Direction3, _ penetration: Float, _ vertIndexes: inout [Array<Position3>.Index]) -> [Position3] {
+        let vertices = box0.vertices
 
-        var planePoint = verticies[0]
-        var maxdist = verticies[0].dot(hitNormal)
+        var planePoint = vertices[0]
+        var maxdist = vertices[0].dot(hitNormal)
 
-        for vertex in verticies {
+        for vertex in vertices {
             let d = vertex.dot(hitNormal)
             if d > maxdist {
                 maxdist = d
@@ -475,21 +475,21 @@ extension OrientedBoundingBox3D {
         d -= penetration + 0.01
 
         var collisionPoints: [Position3] = []
-        for index in verticies.indices {
-            let vertex = verticies[index]
+        for index in vertices.indices {
+            let vertex = vertices[index]
             let side = vertex.dot(hitNormal) - d
 
             if side > 0 {
                 collisionPoints.append(vertex)
-                vertIndexs.append(index)
+                vertIndexes.append(index)
             }
         }
 
         return collisionPoints
     }
 
     @inline(__always)
-    static func sortVertices(_ verticies: inout [Position3], _ vertexIndicies: inout [Array<Position3>.Index]) {
+    static func sortVertices(_ vertices: inout [Position3], _ vertexIndices: inout [Array<Position3>.Index]) {
         let faces = [[4,0,3,7],
                      [1,5,6,2],
                      [0,1,2,3],
@@ -498,27 +498,27 @@ extension OrientedBoundingBox3D {
                      [6,7,3,2]]
 
         var sortedVerts: [Position3] = [] // New correct clockwise order
-        var sortedIndicies: [Array<Position3>.Index] = []
+        var sortedIndices: [Array<Position3>.Index] = []
 
         for face in faces where sortedVerts.count < 4 {
             var count = 0
-            for vertexIndex in vertexIndicies where count < 4 {
+            for vertexIndex in vertexIndices where count < 4 {
                 if face.contains(vertexIndex) {
                     count += 1
                 }
             }
             if count == 4 {
                 for index in face {
-                    sortedVerts.append(verticies[vertexIndicies.firstIndex(of: index)!])
-                    sortedIndicies.append(index)
+                    sortedVerts.append(vertices[vertexIndices.firstIndex(of: index)!])
+                    sortedIndices.append(index)
                 }
                 break
             }
         }
 
         assert(sortedVerts.count == 4, "Must be 4 matching verts")
-        verticies = sortedVerts
-        vertexIndicies = sortedIndicies
+        vertices = sortedVerts
+        vertexIndices = sortedIndices
     }
 
     @inline(__always)
@@ -552,12 +552,12 @@ extension OrientedBoundingBox3D {
 
     @inline(__always)
     static func clipFaceFaceVerts(_ verts0: inout [Position3],
-                                  _ vertIndexs0: inout [Array<Position3>.Index],
+                                  _ vertIndexes0: inout [Array<Position3>.Index],
                                   _ verts1: inout [Position3],
-                                  _ vertIndexs1: inout [Array<Position3>.Index]) -> [Position3] {
+                                  _ vertIndexes1: inout [Array<Position3>.Index]) -> [Position3] {
 
-        sortVertices(&verts0, &vertIndexs0)
-        sortVertices(&verts1, &vertIndexs1)
+        sortVertices(&verts0, &vertIndexes0)
+        sortVertices(&verts1, &vertIndexes1)
 
         // Work out the normal for the face
         let v0 = verts0[1] - verts0[0]
@@ -657,8 +657,8 @@ extension OrientedBoundingBox3D {
     }
 
     @inline(__always)
-    static func clipLinePlane(_ verts0: [Position3], _ vertIndexs0: [Array<Position3>.Index], _ box0: OrientedBoundingBox3D,
-                              _ verts1: [Position3], _ vertIndexs1: [Array<Position3>.Index], _ box1: OrientedBoundingBox3D) -> [Position3] {
+    static func clipLinePlane(_ verts0: [Position3], _ vertIndexes0: [Array<Position3>.Index], _ box0: OrientedBoundingBox3D,
+                              _ verts1: [Position3], _ vertIndexes1: [Array<Position3>.Index], _ box1: OrientedBoundingBox3D) -> [Position3] {
 
         let p1 = closestPtPointOBB(verts0[0], box1)
         let p2 = closestPtPointOBB(verts0[1], box1)

Sources/GameMath/3D Types/Position3.swift

@@ -81,7 +81,7 @@ public extension Position3 {
 
 public extension Position3 {
     /** The distance between `from` and `self`
-    - parameter from: A value representing the source positon.
+    - parameter from: A value representing the source position.
      */
     @_transparent
     func distance(from: Self) -> Float {
@@ -90,8 +90,8 @@ public extension Position3 {
         return distance.squareRoot()
     }
 
-    /** Returns true when the distance from `self` and  `rhs` is less then `threshhold`
-    - parameter rhs: A value representing the destination positon.
+    /** Returns true when the distance from `self` and  `rhs` is less then `threshold`
+    - parameter rhs: A value representing the destination position.
     - parameter threshold: The maximum distance that is considered "near".
      */
     @_transparent

Sources/GameMath/3D Types/Quaternion.swift

@@ -310,8 +310,8 @@ extension Quaternion {
     /**
      Creates a quaternion a forward direction and optionally constrained to an Euler angle.
      - Parameter direction: The forward axis
-     - Parameter up: The relative up vector, defualt is  `Direction3.up`.
-     - Parameter right: The relative right axis. Defualt value is  `Direction3.right`.
+     - Parameter up: The relative up vector, default is  `Direction3.up`.
+     - Parameter right: The relative right axis. Default value is  `Direction3.right`.
      - Parameter constraint: Limits the rotation to an Euler angle. Use this to look in directions without a roll.
      */
     @inlinable

Sources/GameMath/3D Types/Vector3.swift

@@ -116,7 +116,7 @@ public extension Vector3 {
     /**
      Returns a new instance with `x` incremented by `value`.
      - parameter value: The amount to add to `x`. To subtract use a negatie value.
-     - returns: A new Self with `x` incrmented by `value`.
+     - returns: A new Self with `x` incremented by `value`.
     */
     @_transparent
     func addingToX(_ value: Float) -> Self {
@@ -125,7 +125,7 @@ public extension Vector3 {
     /**
      Returns a new instance with `y` incremented by `value`.
      - parameter value: The amount to add to `y`. To subtract use a negatie value.
-     - returns: A new Self with `y` incrmented by `value`.
+     - returns: A new Self with `y` incremented by `value`.
     */
     @_transparent
     func addingToY(_ value: Float) -> Self {
@@ -134,7 +134,7 @@ public extension Vector3 {
     /**
      Returns a new instance with `z` incremented by `value`.
      - parameter value: The amount to add to `z`. To subtract use a negatie value.
-     - returns: A new Self with `z` incrmented by `value`.
+     - returns: A new Self with `z` incremented by `value`.
     */
     @_transparent
     func addingToZ(_ value: Float) -> Self {

Sources/GameMath/BitStream.swift

@@ -61,7 +61,7 @@ public struct BitStream {
     }
 
     /**
-     Move the current read postion.
+     Move the current read position.
      - parameter numBits: The number of bits to move the read position.
      */
     @_transparent