Modernize Skeleton importing

Author: STREGA

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

@@ -837,26 +837,27 @@ extension GLTransmissionFormat: SkeletonImporter {
         }
         return gltf.scenes[gltf.scene].nodes?.first
     }
-    
-    public func process(data: Data, baseURL: URL, options: SkeletonImporterOptions) async throws -> Skeleton.Joint {
-        let gltf = try gltf(from: data, baseURL: baseURL)
+
+    public func loadSkeleton(options: SkeletonImporterOptions) async throws(GateEngineError) -> RawSkeleton {
         guard let rootNode = skeletonNode(named: options.subobjectName, in: gltf) else {
             throw GateEngineError.failedToDecode("Couldn't find skeleton root.")
         }
-        let rootJoint = Skeleton.Joint(id: rootNode, name: gltf.nodes[rootNode].name)
-        rootJoint.localTransform = gltf.nodes[rootNode].transform
-
-        func addChildren(gltfNode: Int, parentJoint: Skeleton.Joint) {
-            for index in gltf.nodes[gltfNode].children ?? [] {
-                let node = gltf.nodes[index]
-                let joint = Skeleton.Joint(id: index, name: node.name)
-                joint.localTransform = node.transform
-                joint.parent = parentJoint
-                addChildren(gltfNode: index, parentJoint: joint)
+        var rawSkeleton: RawSkeleton = .init()
+        rawSkeleton.joints.append(
+            RawSkeleton.RawJoint(id: rootNode, parent: nil, name: gltf.nodes[rootNode].name, localTransform: gltf.nodes[rootNode].transform)
+        )
+
+        func addChildren(of parentJointID: Int) {
+            for childJointID in gltf.nodes[parentJointID].children ?? [] {
+                let childNode = gltf.nodes[childJointID]
+                rawSkeleton.joints.append(
+                    RawSkeleton.RawJoint(id: childJointID, parent: parentJointID, name: childNode.name, localTransform: childNode.transform)
+                )
+                addChildren(of: childJointID)
             }
         }
-        addChildren(gltfNode: rootNode, parentJoint: rootJoint)
-        return rootJoint
+        addChildren(of: rootNode)
+        return rawSkeleton
     }
 }
 

Sources/GateEngine/Resources/Skinning/Raw/RawSkeleton.swift

@@ -0,0 +1,26 @@
+/*
+ * Copyright © 2025 Dustin Collins (Strega's Gate)
+ * All Rights Reserved.
+ *
+ * http://stregasgate.com
+ */
+
+public struct RawSkeleton: Equatable, Hashable, Codable, Sendable {
+    public var joints: [RawJoint] = []
+    
+    public struct RawJoint: Equatable, Hashable, Identifiable, Codable, Sendable {
+        public typealias ID = Int
+        public let id: ID
+        public var parent: ID?
+        public let name: String?
+        public var localTransform: Transform3
+        
+        public nonisolated func hash(into hasher: inout Hasher) {
+            hasher.combine(id)
+        }
+        
+        public nonisolated static func == (lhs: RawJoint, rhs: RawJoint) -> Bool {
+            lhs.id == rhs.id
+        }
+    }
+}

Sources/GateEngine/Resources/Skinning/Skeleton.swift

@@ -123,6 +123,26 @@ final class SkeletonBackend {
         self.rootJoint = joint
         self.bindPose = Skeleton.Pose(joint)
     }
+    
+    init(rawSkeleton: RawSkeleton) {
+        func createJoint(from rawJoint: RawSkeleton.RawJoint) -> Skeleton.Joint {
+            var joint = Skeleton.Joint(rawJoint: rawJoint)
+            joint.localTransform = rawJoint.localTransform
+            for rawJoint in rawSkeleton.joints {
+                if rawJoint.parent == joint.id {
+                    let child = createJoint(from: rawJoint)
+                    child.parent = joint
+                }
+            }
+            return joint
+        }
+        let rootJoint = createJoint(from: rawSkeleton.joints.first(where: {$0.parent == nil})!)
+        self.rootJoint = rootJoint
+        self.bindPose = Skeleton.Pose(rootJoint)
+    }
+}
+fileprivate extension Skeleton.Joint {
+
 }
 
 extension Skeleton {
@@ -328,6 +348,12 @@ extension Skeleton {
             self.id = id
             self.name = name
         }
+        
+        /// Convenince for constructing a Skeleton from a RawSkeleton
+        fileprivate convenience init(rawJoint: RawSkeleton.RawJoint) {
+            self.init(id: rawJoint.id, name: rawJoint.name)
+            self.localTransform = rawJoint.localTransform
+        }
     }
 }
 
@@ -473,12 +499,8 @@ extension Skeleton.Pose.Joint: Hashable {
 
 // MARK: - Resource Manager
 
-public protocol SkeletonImporter: AnyObject {
-    init()
-
-    func process(data: Data, baseURL: URL, options: SkeletonImporterOptions) async throws -> Skeleton.Joint
-
-    static func supportedFileExtensions() -> [String]
+public protocol SkeletonImporter: ResourceImporter {
+    func loadSkeleton(options: SkeletonImporterOptions) async throws(GateEngineError) -> RawSkeleton
 }
 
 public struct SkeletonImporterOptions: Equatable, Hashable, Sendable {
@@ -498,13 +520,11 @@ extension ResourceManager {
         guard importers.skeletonImporters.contains(where: { $0 == type }) == false else { return }
         importers.skeletonImporters.insert(type, at: 0)
     }
-
-    fileprivate func importerForFileType(_ file: String) -> (any SkeletonImporter)? {
+    
+    func skeletonImporterForPath(_ path: String) async throws -> (any SkeletonImporter)? {
         for type in self.importers.skeletonImporters {
-            if type.supportedFileExtensions().contains(where: {
-                $0.caseInsensitiveCompare(file) == .orderedSame
-            }) {
-                return type.init()
+            if type.canProcessFile(path) {
+                return try await self.importers.getImporter(path: path, type: type)
             }
         }
         return nil
@@ -556,6 +576,22 @@ extension ResourceManager.Cache {
     }
 }
 
+extension RawSkeleton {
+    public init(path: String, options: SkeletonImporterOptions = .none) async throws {
+        guard
+            let importer: any SkeletonImporter = try await Game.unsafeShared.resourceManager.skeletonImporterForPath(path)
+        else {
+            throw GateEngineError.failedToLoad("No importer for \(URL(fileURLWithPath: path).pathExtension).")
+        }
+
+        do {
+            self = try await importer.loadSkeleton(options: options)
+        } catch {
+            throw GateEngineError(error)
+        }
+    }
+}
+
 @MainActor
 extension ResourceManager {
     func changeCacheHint(_ cacheHint: CacheHint, for key: Cache.SkeletonKey) {
@@ -626,23 +662,13 @@ extension ResourceManager {
             let path = key.requestedPath
 
             do {
-                guard let fileExtension = path.components(separatedBy: ".").last else {
-                    throw GateEngineError.failedToLoad("Unknown file type.")
-                }
-                guard let importer: any SkeletonImporter = Game.unsafeShared.resourceManager.importerForFileType(fileExtension) else {
-                    throw GateEngineError.failedToLoad("No importer for \(fileExtension).")
-                }
-
-                let data = try await Platform.current.loadResource(from: path)
-                let rootJoint: Skeleton.Joint = try await importer.process(
-                    data: data,
-                    baseURL: URL(string: path)!.deletingLastPathComponent(),
+                let rawSkeleton = try await RawSkeleton(
+                    path: key.requestedPath,
                     options: key.options
                 )
-
                 Task { @MainActor in
                     if let cache = cache.skeletons[key] {
-                        cache.skeletonBackend = SkeletonBackend(rootJoint: rootJoint)
+                        cache.skeletonBackend = SkeletonBackend(rawSkeleton: rawSkeleton)
                         cache.state = .ready
                     }else{
                         Log.warn("Resource \"\(path)\" was deallocated before being " + (isFirstLoad ? "loaded." : "re-loaded."))