Use native type

Author: STREGA

Sources/GameMath/2D Types (New)/Rectn.swift

@@ -5,8 +5,8 @@
  * http://stregasgate.com
  */
 
-public typealias Rect2i = Rect2n<Int32>
-public typealias Rect2f = Rect2n<Float32>
+public typealias Rect2i = Rect2n<Int>
+public typealias Rect2f = Rect2n<Float>
 
 public struct Rect2n<Scalar: Vector2n.ScalarType> {
     public var position: Position2n<Scalar>

Sources/GameMath/2D Types (New)/Vector2n.swift

@@ -15,8 +15,8 @@ public protocol Vector2n<Scalar> {
     init(x: Scalar, y: Scalar)
 }
 
-public typealias Position2i = Position2n<Int32>
-public typealias Position2f = Position2n<Float32>
+public typealias Position2i = Position2n<Int>
+public typealias Position2f = Position2n<Float>
 public struct Position2n<Scalar: Vector2n.ScalarType>: Vector2n {
     public typealias Vector2Counterpart = Position2
     public var x: Scalar
@@ -35,8 +35,8 @@ extension Position2n: Sendable where Scalar: Sendable { }
 extension Position2n: Codable where Scalar: Codable { }
 extension Position2n: BinaryCodable where Scalar: BinaryCodable { }
 
-public typealias Size2i = Size2n<Int32>
-public typealias Size2f = Size2n<Float32>
+public typealias Size2i = Size2n<Int>
+public typealias Size2f = Size2n<Float>
 public struct Size2n<Scalar: Vector2n.ScalarType>: Vector2n {
     public typealias Vector2Counterpart = Size2
     public var x: Scalar
@@ -65,58 +65,6 @@ public extension Size2n {
     }
 }
 
-public extension Vector2n where Scalar: BinaryInteger {
-    @inlinable
-    @_disfavoredOverload
-    static func castInit<T1: BinaryInteger, T2: BinaryInteger>(width: T1, height: T2) -> Self {
-        return .init(x: Scalar(width), y: Scalar(height))
-    }
-    
-    @inlinable
-    @_disfavoredOverload
-    static func castInit<T1: BinaryFloatingPoint, T2: BinaryFloatingPoint>(width: T1, height: T2) -> Self {
-        return .init(x: Scalar(width), y: Scalar(height))
-    }
-    
-    @inlinable
-    @_disfavoredOverload
-    static func castInit<T1: BinaryInteger, T2: BinaryFloatingPoint>(width: T1, height: T2) -> Self {
-        return .init(x: Scalar(width), y: Scalar(height))
-    }
-    
-    @inlinable
-    @_disfavoredOverload
-    static func castInit<T1: BinaryFloatingPoint, T2: BinaryInteger>(width: T1, height: T2) -> Self {
-        return .init(x: Scalar(width), y: Scalar(height))
-    }
-}
-
-public extension Vector2n where Scalar: BinaryFloatingPoint {
-    @inlinable
-    @_disfavoredOverload
-    static func castInit<T1: BinaryInteger, T2: BinaryInteger>(width: T1, height: T2) -> Self {
-        return .init(x: Scalar(width), y: Scalar(height))
-    }
-    
-    @inlinable
-    @_disfavoredOverload
-    static func castInit<T1: BinaryFloatingPoint, T2: BinaryFloatingPoint>(width: T1, height: T2) -> Self {
-        return .init(x: Scalar(width), y: Scalar(height))
-    }
-    
-    @inlinable
-    @_disfavoredOverload
-    static func castInit<T1: BinaryInteger, T2: BinaryFloatingPoint>(width: T1, height: T2) -> Self {
-        return .init(x: Scalar(width), y: Scalar(height))
-    }
-    
-    @inlinable
-    @_disfavoredOverload
-    static func castInit<T1: BinaryFloatingPoint, T2: BinaryInteger>(width: T1, height: T2) -> Self {
-        return .init(x: Scalar(width), y: Scalar(height))
-    }
-}
-
 extension Vector2n where Scalar: BinaryInteger {
     @inlinable
     public init(_ vector2n: some Vector2n<Scalar>) {
@@ -206,25 +154,6 @@ public extension Vector2n where Scalar: Numeric {
     }
 }
 
-extension Vector2n where Scalar: Comparable {
-    public static func < (lhs: Self, rhs: some Vector2n<Scalar>) -> Bool {
-        return lhs.x < rhs.x && lhs.y < rhs.y
-    }
-}
-
-extension Vector2n where Scalar: Equatable {
-    public static func == (lhs: Self, rhs: some Vector2n<Scalar>) -> Bool {
-        return lhs.x == rhs.x && lhs.y == rhs.y
-    }
-}
-
-extension Vector2n where Scalar: Hashable {
-    public func hash(into hasher: inout Hasher) {
-        hasher.combine(x)
-        hasher.combine(y)
-    }
-}
-
 public extension Vector2n where Scalar: FloatingPoint {
     @inlinable
     static func / (lhs: Self, rhs: some Vector2n<Scalar>) -> Self {
@@ -249,6 +178,27 @@ public extension Vector2n where Scalar: FixedWidthInteger {
     }
 }
 
+public extension Vector2n where Scalar: Comparable {
+    @inlinable
+    static func < (lhs: Self, rhs: some Vector2n<Scalar>) -> Bool {
+        return lhs.x < rhs.x && lhs.y < rhs.y
+    }
+}
+
+extension Vector2n where Scalar: Equatable {
+    @inlinable
+    public static func == (lhs: Self, rhs: some Vector2n<Scalar>) -> Bool {
+        return lhs.x == rhs.x && lhs.y == rhs.y
+    }
+}
+
+extension Vector2n where Scalar: Hashable {
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(x)
+        hasher.combine(y)
+    }
+}
+
 extension Vector2n where Scalar: BinaryCodable {
     public func encode(into data: inout ContiguousArray<UInt8>, version: BinaryCodableVersion) throws {
         try self.x.encode(into: &data, version: version)

Sources/GameMath/3D Types (New)/Vector3n.swift

@@ -16,8 +16,8 @@ public protocol Vector3n<Scalar> {
     init(x: Scalar, y: Scalar, z: Scalar)
 }
 
-public typealias Position3i = Position3n<Int32>
-public typealias Position3f = Position3n<Float32>
+public typealias Position3i = Position3n<Int>
+public typealias Position3f = Position3n<Float>
 public struct Position3n<Scalar: Vector3n.ScalarType>: Vector3n {
     public typealias Vector3Counterpart = Position3
     public var x: Scalar
@@ -38,8 +38,8 @@ extension Position3n: Sendable where Scalar: Sendable { }
 extension Position3n: Codable where Scalar: Codable { }
 extension Position3n: BinaryCodable where Scalar: BinaryCodable { }
 
-public typealias Size3i = Size3n<Int32>
-public typealias Size3f = Size3n<Float32>
+public typealias Size3i = Size3n<Int>
+public typealias Size3f = Size3n<Float>
 public struct Size3n<Scalar: Vector3n.ScalarType>: Vector3n {
     public typealias Vector3Counterpart = Size3
     public var x: Scalar
@@ -144,26 +144,6 @@ public extension Vector3n where Scalar: AdditiveArithmetic {
     static var zero: Self {Self(x: .zero, y: .zero, z: .zero)}
 }
 
-extension Vector3n where Scalar: Comparable {
-    public static func < (lhs: Self, rhs: Self) -> Bool {
-        return lhs.x < rhs.x && lhs.y < rhs.y && lhs.z < rhs.z
-    }
-}
-
-extension Vector3n where Scalar: Equatable {
-    public static func == (lhs: Self, rhs: Self) -> Bool {
-        return lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z
-    }
-}
-
-extension Vector3n where Scalar: Hashable {
-    public func hash(into hasher: inout Hasher) {
-        hasher.combine(x)
-        hasher.combine(y)
-        hasher.combine(z)
-    }
-}
-
 public extension Vector3n where Scalar: FloatingPoint {
     @inlinable
     static func / (lhs: Self, rhs: Self) -> Self {
@@ -188,6 +168,26 @@ public extension Vector3n where Scalar: FixedWidthInteger {
     }
 }
 
+public extension Vector3n where Scalar: Comparable {
+    static func < (lhs: Self, rhs: Self) -> Bool {
+        return lhs.x < rhs.x && lhs.y < rhs.y && lhs.z < rhs.z
+    }
+}
+
+extension Vector3n where Scalar: Equatable {
+    public static func == (lhs: Self, rhs: Self) -> Bool {
+        return lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z
+    }
+}
+
+extension Vector3n where Scalar: Hashable {
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(x)
+        hasher.combine(y)
+        hasher.combine(z)
+    }
+}
+
 extension Vector3n where Scalar: BinaryCodable {
     public func encode(into data: inout ContiguousArray<UInt8>, version: BinaryCodableVersion) throws {
         try self.x.encode(into: &data, version: version)

Sources/GateEngine/ECS/2D Specific/Sprite/SpriteComponent.swift

@@ -105,8 +105,8 @@ public final class SpriteComponent: Component {
            let texture = spriteSheet?.texture,
            texture.state == .ready
         {
-            let columns = Float(texture.size.width / Int32(spriteSize.width))
-            let rows = Float(texture.size.height / Int32(spriteSize.height))
+            let columns = Float(texture.size.width / Int(spriteSize.width))
+            let rows = Float(texture.size.height / Int(spriteSize.height))
             let startFrame = (animation.spriteSheetStart.y * columns) + animation.spriteSheetStart.x
             let endFrame = {
                 if let frameCount = animation.frameCount {

Sources/GateEngine/ECS/StandardRenderingSystem.swift

@@ -9,19 +9,19 @@ import GameMath
 
 @RenderingSystem(drawing: .afterGameView)
 public final class StandardRenderingSystem: RenderingSystem {
-    internal var verticalResolution: Float? = nil
+    internal var verticalResolution: UInt? = nil
     internal lazy var renderTarget: RenderTarget = RenderTarget()
 
     public convenience init(verticalResolution: UInt) {
         self.init()
-        self.verticalResolution = Float(verticalResolution)
+        self.verticalResolution = verticalResolution
     }
 
     public override func render(context: ECSContext, into view: GameView, withTimePassed deltaTime: Float) {
         if let verticalResolution = verticalResolution {
-            var width = verticalResolution * view.frame.size.aspectRatio
+            var width = Float(verticalResolution) * view.frame.size.aspectRatio
             width -= width.truncatingRemainder(dividingBy: 2)
-            renderTarget.size = Size2i(width: Int32(width), height: Int32(verticalResolution))
+            renderTarget.size = Size2i(width: Int(width), height: Int(verticalResolution))
         }
 
         do {  // 3D

Sources/GateEngine/Helpers/TextureAtlas.swift

@@ -212,7 +212,7 @@ public final class TextureAtlasBuilder {
     }
 
     public func generateAtlas() -> TextureAtlas {
-        let textureSize: Size2i = .castInit(width: self.searchGrid.width * blockSize, height: self.searchGrid.height * blockSize)
+        let textureSize: Size2i = .init(width: self.searchGrid.width * blockSize, height: self.searchGrid.height * blockSize)
 
         let dstWidth = Int(textureSize.width * 4)
 

Sources/GateEngine/Resources/Import & Export/Coding/PNGCoder.swift

@@ -277,7 +277,7 @@ enum LibSPNG {
                     throw GateEngineError.failedToDecode(String(cString: spng_strerror(header_err)))
                 }
 
-                return RawTexture(imageSize: .castInit(width: header.width, height: header.height), imageData: out)
+                return RawTexture(imageSize: Size2i(width: Int(header.width), height: Int(header.height)), imageData: out)
             }
         }catch let error as GateEngineError {
             throw error // Typed throws not supported by closures as of Swift 6.2

Sources/GateEngine/Resources/Import & Export/Importers/ApplePlatformImageImporter.swift

@@ -43,7 +43,7 @@ public final class ApplePlatformImageImporter: TextureImporter {
             guard let image = CGImageSourceCreateImageAtIndex(imageSource, 0, nil) else {
                 throw GateEngineError.failedToDecode("Failed to decode subimage zero.")
             }
-            self.size = .castInit(width: image.width, height: image.height)
+            self.size = Size2i(width: image.width, height: image.height)
             guard let data = image.dataProvider?.data as? Data else {
                 throw GateEngineError.failedToDecode("Failed to decode data.")
             }

Sources/GateEngine/Resources/Import & Export/Importers/TiledTSJImporter.swift

@@ -115,10 +115,10 @@ public final class TiledTSJImporter: TileSetImporter {
         let texturePath = basePath + "/" + file.image
 
         return await TileSetBackend(
-            texture: Texture(path: texturePath, sizeHint: .castInit(width: file.imagewidth, height: file.imageheight)),
+            texture: Texture(path: texturePath, sizeHint: .init(width: file.imagewidth, height: file.imageheight)),
             count: file.tilecount,
             columns: file.columns,
-            tileSize: .castInit(width: file.tilewidth, height: file.tileheight),
+            tileSize: .init(width: file.tilewidth, height: file.tileheight),
             tiles: tiles
         )
     }

Sources/GateEngine/Resources/Tiles/TileSet.swift

@@ -73,7 +73,7 @@ import GameMath
     public func rectForTile(_ tile: TileMap.Tile) -> Rect {
         let row = tile.id / columns
         let column = tile.id % columns
-        let position = Position2i(x: tileSize.width * Int32(column), y: tileSize.height * Int32(row))
+        let position = Position2i(x: tileSize.width * column, y: tileSize.height * row)
         let size = Size2(Float(tileSize.width), Float(tileSize.height))
         return Rect(position: position.vector2, size: size)
     }