Refactor to use RawTexture and new GameMath types

Author: STREGA

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

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

Sources/GateEngine/ECS/2D Specific/TileMap/TileMapSystem.swift

@@ -52,18 +52,18 @@ public final class TileMapSystem: System {
 
             let tileSize = tileSet.tileSize
 
-            let wM: Float = 1 / tileSet.texture.size.width
-            let hM: Float = 1 / tileSet.texture.size.height
+            let wM: Float = 1 / Float(tileSet.texture.size.width)
+            let hM: Float = 1 / Float(tileSet.texture.size.height)
             for hIndex in 0 ..< Int(tileMap.size.height) {
                 for wIndex in 0 ..< Int(tileMap.size.width) {
                     let tile = layer.tileAtCoordinate(TileMap.Layer.Coordinate(column: wIndex, row: hIndex))
                     guard tile.id > -1 else {continue}
                     let tileRect = tileSet.rectForTile(tile)
                     let position = Position2(
-                        x: Float(wIndex) * tileSize.width,
-                        y: Float(hIndex) * tileSize.height
+                        x: Float(wIndex) * Float(tileSize.width),
+                        y: Float(hIndex) * Float(tileSize.height)
                     )
-                    let rect = Rect(position: position, size: tileSize)
+                    let rect = Rect(position: position, size: tileSize.vector2)
                     var v1 = Vertex(
                         px: rect.x,
                         py: rect.y,

Sources/GateEngine/ECS/StandardRenderingSystem.swift

@@ -20,7 +20,7 @@ public final class StandardRenderingSystem: RenderingSystem {
         if let verticalResolution = verticalResolution {
             var width = verticalResolution * view.frame.size.aspectRatio
             width -= width.truncatingRemainder(dividingBy: 2)
-            renderTarget.size = Size2(width: width, height: verticalResolution)
+            renderTarget.size = Size2i(width: Int32(width), height: Int32(verticalResolution))
         }
 
         do {  // 3D

Sources/GateEngine/Helpers/TextureAtlas.swift

@@ -7,21 +7,19 @@
 #if GATEENGINE_PLATFORM_HAS_SynchronousFileSystem
 import Foundation
 
-public struct TextureAtlas {
-    public let imageSize: Size2
-    public let imageData: Data
+public struct TextureAtlas: Sendable {
+    public let rawTexture: RawTexture
     private let blockSize: Int
     private let textures: [Texture]
 
     internal struct Texture {
         let path: String
-        let size: Size2
+        let size: Size2i
         let coordinate: (x: Int, y: Int)
     }
 
-    internal init(size: Size2, data: Data, blockSize: Int, textures: [Texture]) {
-        self.imageSize = size
-        self.imageData = data
+    internal init(rawTexture: RawTexture, blockSize: Int, textures: [Texture]) {
+        self.rawTexture = rawTexture
         self.blockSize = blockSize
         self.textures = textures
     }
@@ -44,12 +42,12 @@ public struct TextureAtlas {
         var uv = inUV
 
         //Scale
-        uv.x *= texture.size.width / imageSize.width
-        uv.y *= texture.size.height / imageSize.height
+        uv.x *= Float(texture.size.width) / Float(rawTexture.imageSize.width)
+        uv.y *= Float(texture.size.height) / Float(rawTexture.imageSize.height)
 
         //Offset
-        uv.x += Float(texture.coordinate.x * blockSize) * (1 / imageSize.width)
-        uv.y += Float(texture.coordinate.y * blockSize) * (1 / imageSize.height)
+        uv.x += Float(texture.coordinate.x * blockSize) * (1 / Float(rawTexture.imageSize.width))
+        uv.y += Float(texture.coordinate.y * blockSize) * (1 / Float(rawTexture.imageSize.height))
 
         return uv
     }
@@ -60,14 +58,17 @@ public struct TextureAtlas {
         return Rect(
             x: Float(texture.coordinate.x * blockSize),
             y: Float(texture.coordinate.y * blockSize),
-            width: texture.size.width,
-            height: texture.size.height
+            width: Float(texture.size.width),
+            height: Float(texture.size.height)
         )
     }
 
     @MainActor
     public func createTexture(withMipMapping mipMapping: MipMapping = .auto(levels: .max)) -> GateEngine.Texture {
-        return GateEngine.Texture(data: imageData, size: imageSize, mipMapping: mipMapping)
+        return GateEngine.Texture(
+            rawTexture: rawTexture, 
+            mipMapping: mipMapping
+        )
     }
 }
 
@@ -84,28 +85,26 @@ extension TextureAtlasBuilder {
         }
     }
     struct TextureData: Equatable, Hashable, Sendable {
-        let width: Int
-        let height: Int
+        let size: Size2i
         let imageData: Data
         var coordinate: (x: Int, y: Int)
 
         nonisolated static func == (lhs: TextureData, rhs: TextureData) -> Bool {
-            guard lhs.width == rhs.width && lhs.height == rhs.height else {return false}
+            guard lhs.size == rhs.size else {return false}
             return lhs.imageData.elementsEqual(rhs.imageData)
         }
         nonisolated func hash(into hasher: inout Hasher) {
-            hasher.combine(width)
-            hasher.combine(height)
+            hasher.combine(size)
             hasher.combine(imageData)
         }
     }
 
-    func textureBlocksWide(texturePixelWidth: Float) -> Int {
-        return Int(ceil(texturePixelWidth / Float(blockSize)))
+    func textureBlocksWide(texturePixelWidth: Int) -> Int {
+        return texturePixelWidth / blockSize
     }
 
-    func textureBlocksTall(texturePixelHeight: Float) -> Int {
-        return Int(ceil(texturePixelHeight / Float(blockSize)))
+    func textureBlocksTall(texturePixelHeight: Int) -> Int {
+        return texturePixelHeight / blockSize
     }
 }
 
@@ -149,18 +148,16 @@ public final class TextureAtlasBuilder {
 
         let importer = PNGImporter()
         try importer.synchronousPrepareToImportResourceFrom(path: unresolvedPath)
-        let png = try importer.loadTexture(options: .none)
-        let width = Int(png.size.width)
-        let height = Int(png.size.height)
+        let rawTexture = try importer.loadTexture(options: .none)
 
-        var textureData = TextureData(width: width, height: height, imageData: png.data, coordinate: (0,0))
+        var textureData = TextureData(size: rawTexture.imageSize, imageData: rawTexture.imageData, coordinate: (0,0))
         var dataIndex = self.textureDatas.endIndex
         if sacrificePerformanceForSize, let existingIndex = self.textureDatas.firstIndex(where: {$0 == textureData}) {
             dataIndex = existingIndex
         }else{
             let coord = searchGrid.firstUnoccupiedFor(
-                width: textureBlocksWide(texturePixelWidth: png.size.width),
-                height: textureBlocksTall(texturePixelHeight: png.size.height),
+                width: textureBlocksWide(texturePixelWidth: Int(rawTexture.imageSize.width)),
+                height: textureBlocksTall(texturePixelHeight: Int(rawTexture.imageSize.height)),
                 markOccupied: true
             )
             textureData.coordinate = coord
@@ -190,8 +187,8 @@ public final class TextureAtlasBuilder {
                     false,
                     x: textureData.coordinate.x,
                     y: textureData.coordinate.y,
-                    width: textureBlocksWide(texturePixelWidth: Float(textureData.width)),
-                    height: textureBlocksTall(texturePixelHeight: Float(textureData.height))
+                    width: textureBlocksWide(texturePixelWidth: Int(textureData.size.width)),
+                    height: textureBlocksTall(texturePixelHeight: Int(textureData.size.height))
                 )
 
                 // Reindex the Texture dataIndex values
@@ -215,7 +212,7 @@ public final class TextureAtlasBuilder {
     }
 
     public func generateAtlas() -> TextureAtlas {
-        let textureSize: Size2 = Size2(Float(self.searchGrid.width * blockSize), Float(self.searchGrid.height * blockSize))
+        let textureSize: Size2i = .castInit(width: self.searchGrid.width * blockSize, height: self.searchGrid.height * blockSize)
 
         let dstWidth = Int(textureSize.width * 4)
 
@@ -227,9 +224,9 @@ public final class TextureAtlasBuilder {
                 var coord = textureData.coordinate
                 coord.x *= blockSize
                 coord.y *= blockSize
-                let srcWidth = textureData.width * 4
+                let srcWidth = Int(textureData.size.width) * 4
                 let x = (coord.x * 4)
-                for row in 0 ..< textureData.height {
+                for row in 0 ..< Int(textureData.size.height) {
                     let srcStart = srcWidth * row
                     let srcRange = srcStart ..< (srcStart + srcWidth)
 
@@ -248,15 +245,14 @@ public final class TextureAtlasBuilder {
 
 
         let atlas = TextureAtlas(
-            size: textureSize,
-            data: imageData,
+            rawTexture: RawTexture(imageSize: textureSize, imageData: imageData),
             blockSize: blockSize,
             textures: textures.indices.map({
                 let texture = textures[$0]
                 let textureData = textureDatas[texture.dataIndex]
                 return TextureAtlas.Texture(
                     path: texture.resourcePath,
-                    size: Size2(Float(textureData.width), Float(textureData.height)),
+                    size: textureData.size,
                     coordinate: textureData.coordinate
                 )
             })

Sources/GateEngine/Resources/Animation/ObjectAnimation3D.swift

@@ -619,10 +619,10 @@ extension ResourceManager {
 
             do {
                 guard let fileExtension = path.components(separatedBy: ".").last else {
-                    throw GateEngineError.failedToLoad("Unknown file type.")
+                    throw GateEngineError.failedToLoad(resource: path, "Unknown file type.")
                 }
                 guard let importer: any ObjectAnimation3DImporter = Game.unsafeShared.resourceManager.importerForFileType(fileExtension) else {
-                    throw GateEngineError.failedToLoad("No importer for \(fileExtension).")
+                    throw GateEngineError.failedToLoad(resource: path, "No importer for \(fileExtension).")
                 }
 
                 let data = try await Platform.current.loadResource(from: path)

Sources/GateEngine/Resources/Geometry/Geometry.swift

@@ -132,7 +132,7 @@ extension Geometry: Equatable, Hashable {
 // MARK: - Resource Manager
 
 public protocol GeometryImporter: ResourceImporter {
-    func loadGeometry(options: GeometryImporterOptions) async throws -> RawGeometry
+    func loadGeometry(options: GeometryImporterOptions) async throws(GateEngineError) -> RawGeometry
 }
 
 public struct GeometryImporterOptions: Equatable, Hashable, Sendable {
@@ -197,7 +197,7 @@ extension RawGeometry {
         guard
             let importer: any GeometryImporter = try await Game.unsafeShared.resourceManager.geometryImporterForPath(path)
         else {
-            throw GateEngineError.failedToLoad("No importer for \(URL(fileURLWithPath: path).pathExtension).")
+            throw GateEngineError.failedToLoad(resource: path, "No importer for \(URL(fileURLWithPath: path).pathExtension).")
         }
 
         do {

Sources/GateEngine/Resources/Geometry/Lines.swift

@@ -69,7 +69,7 @@ extension RawLines {
     }
     public init(path: String, options: GeometryImporterOptions = .none) async throws {
         guard let importer: any GeometryImporter = try await Game.unsafeShared.resourceManager.geometryImporterForPath(path) else {
-            throw GateEngineError.failedToLoad("No importer for \(URL(fileURLWithPath: path).pathExtension).")
+            throw GateEngineError.failedToLoad(resource: path, "No importer for \(URL(fileURLWithPath: path).pathExtension).")
         }
 
         do {

Sources/GateEngine/Resources/Geometry/Points.swift

@@ -69,7 +69,7 @@ extension RawPoints {
     }
     public init(path: String, options: GeometryImporterOptions = .none) async throws {
         guard let importer: any GeometryImporter = try await Game.unsafeShared.resourceManager.geometryImporterForPath(path) else {
-            throw GateEngineError.failedToLoad("No importer for \(URL(fileURLWithPath: path).pathExtension).")
+            throw GateEngineError.failedToLoad(resource: path, "No importer for \(URL(fileURLWithPath: path).pathExtension).")
         }
 
         do {

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

@@ -5,21 +5,15 @@
  * http://stregasgate.com
  */
 
-public final class PNGDecoder {
-    public func decode(_ data: Data) throws(GateEngineError) -> Image {
+public struct PNGDecoder {
+    public func decode(_ data: Data) throws(GateEngineError) -> RawTexture {
 #if canImport(LibSPNG)
         try LibSPNG.decode(data: data)
 #else
         fatalError("PNGDecoder is not supported on this platform.")
 #endif
     }
-    
-    public struct Image {
-        let width: Int
-        let height: Int
-        let data: Data
-    }
-    
+
     public init() {
 
     }
@@ -36,19 +30,19 @@ public final class PNGDecoder {
 /**
  Encodes raw pixel data as PNG formatted data.
  */
-public final class PNGEncoder {
+public struct PNGEncoder {
     /**
      - parameter data: RGBA8 formatted image data
      - parameter width: The count of pixel columns for `data`
      - parameter height: The count of pixel rows for `data`
      - parameter sacrificePerformanceToShrinkData: `true` if extra processingshould be done to produce smaller PNG data.
      */
-    public func encode(_ data: Data, width: Int, height: Int, sacrificePerformanceToShrinkData: Bool = false) throws(GateEngineError) -> Data {
+    public func encode(_ rawTexture: RawTexture, sacrificePerformanceToShrinkData: Bool = false) throws(GateEngineError) -> Data {
 #if canImport(LibSPNG)
         if sacrificePerformanceToShrinkData {
-            try LibSPNG.encodeSmallest(data: data, width: width, height: height)
+            try LibSPNG.encodeSmallest(data: rawTexture.imageData, width: Int(rawTexture.imageSize.width), height: Int(rawTexture.imageSize.height))
         }else{
-            try LibSPNG.encodeRGBA(data: data, width: width, height: height, optimizeAlpha: false)
+            try LibSPNG.encodeRGBA(data: rawTexture.imageData, width: Int(rawTexture.imageSize.width), height: Int(rawTexture.imageSize.height), optimizeAlpha: false)
         }
 #else
         fatalError("PNGEncoder is not supported on this platform.")
@@ -235,7 +229,7 @@ enum LibSPNG {
     }
 
     @inlinable
-    static func decode(data: Data) throws(GateEngineError) -> PNGDecoder.Image {
+    static func decode(data: Data) throws(GateEngineError) -> RawTexture {
         do {
             return try data.withUnsafeBytes { data in
                 /* Create a context */
@@ -283,7 +277,7 @@ enum LibSPNG {
                     throw GateEngineError.failedToDecode(String(cString: spng_strerror(header_err)))
                 }
 
-                return PNGDecoder.Image(width: Int(header.width), height: Int(header.height), data: out)
+                return RawTexture(imageSize: .castInit(width: header.width, height: 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

@@ -14,7 +14,7 @@ import UniformTypeIdentifiers
 
 public final class ApplePlatformImageImporter: TextureImporter {
     var data: Data! = nil
-    var size: Size2! = nil
+    var size: Size2i! = nil
     public required init() {}
 
     public func synchronousPrepareToImportResourceFrom(path: String) throws(GateEngineError) {
@@ -38,23 +38,23 @@ public final class ApplePlatformImageImporter: TextureImporter {
     func populateFromData(_ data: Data) throws(GateEngineError) {
         do {
             guard let imageSource = CGImageSourceCreateWithData(data as CFData, nil) else {
-                throw GateEngineError.generic("Failed to decode image source.")
+                throw GateEngineError.failedToDecode("Failed to decode image source.")
             }
             guard let image = CGImageSourceCreateImageAtIndex(imageSource, 0, nil) else {
-                throw GateEngineError.generic("Failed to decode subimage zero.")
+                throw GateEngineError.failedToDecode("Failed to decode subimage zero.")
             }
-            self.size = Size2(Float(image.width), Float(image.height))
+            self.size = .castInit(width: image.width, height: image.height)
             guard let data = image.dataProvider?.data as? Data else {
-                throw GateEngineError.generic("Failed to decode data.")
+                throw GateEngineError.failedToDecode("Failed to decode data.")
             }
             self.data = data
         }catch{
             throw GateEngineError(error)
         }
     }
 
-    public func loadTexture(options: TextureImporterOptions) throws(GateEngineError) -> (data: Data, size: Size2) {
-        return (data, size)
+    public func loadTexture(options: TextureImporterOptions) throws(GateEngineError) -> RawTexture {
+        return RawTexture(imageSize: size, imageData: data)
     }
 
     public static func canProcessFile(_ path: String) -> Bool {