chore: More enum unification

Source/CompiledShader.swift

@@ -122,31 +122,10 @@ public enum Compiled {
     
     public enum ShaderPassFilter: String, CaseIterable, Codable {
         case unspecified, linear, nearest
-        
-        private static let mapFrom: [OpenEmuShaders.ShaderPassFilter: Self] = [
-            .unspecified: .unspecified,
-            .linear: .linear,
-            .nearest: .nearest,
-        ]
-        
-        init(_ filter: OpenEmuShaders.ShaderPassFilter) {
-            self = Self.mapFrom[filter]!
-        }
     }
     
     public enum ShaderPassWrap: String, CaseIterable, Codable {
         case border, edge, `repeat`, mirroredRepeat
-        
-        private static let mapFrom: [OpenEmuShaders.ShaderPassWrap: Self] = [
-            .border: .border,
-            .edge: .edge,
-            .repeat: .repeat,
-            .mirroredRepeat: .mirroredRepeat,
-        ]
-        
-        init(_ wrap: OpenEmuShaders.ShaderPassWrap) {
-            self = Self.mapFrom[wrap]!
-        }
     }
     
     public enum ShaderTextureSemantic: String, CaseIterable, Codable, CustomStringConvertible {

Source/ShaderModel.swift

@@ -61,7 +61,7 @@ extension ShaderConfigSerialization {
         
         let pass = ShaderPassModel(pass: i, shader: shader)
         
-        pass.wrapMode = ShaderPassWrap(string: d["wrap_mode\(i)"])
+        pass.wrapMode = .init(string: d["wrap_mode\(i)"])
         
         for (from, to) in strings {
             if let v = d["\(from)\(i)"] {
@@ -97,7 +97,7 @@ extension ShaderConfigSerialization {
             let name = String(t)
             guard let path = d[name] else { continue }
             
-            let wrapMode = ShaderPassWrap(string: d["\(name)_wrap_mode"])
+            let wrapMode = Compiled.ShaderPassWrap(string: d["\(name)_wrap_mode"])
             let linear: Bool?
             if let v = d["\(name)_linear"], let bv = Bool(v) {
                 linear = bv
@@ -179,7 +179,7 @@ public class ShaderModel {
 public class ShaderPassModel {
     public var pass: Int
     public var shader: String
-    public var wrapMode: ShaderPassWrap?
+    public var wrapMode: Compiled.ShaderPassWrap?
     public var alias: String?
     public var scaleType: String?
     public var scaleTypeX: String?
@@ -205,11 +205,11 @@ public class ShaderPassModel {
 public class ShaderTextureModel {
     var name: String
     var path: String
-    var wrapMode: ShaderPassWrap?
+    var wrapMode: Compiled.ShaderPassWrap?
     var linear: Bool?
     var mipmapInput: Bool?
     
-    init(name: String, path: String, wrapMode: ShaderPassWrap?, linear: Bool?, mipmapInput: Bool?) {
+    init(name: String, path: String, wrapMode: Compiled.ShaderPassWrap?, linear: Bool?, mipmapInput: Bool?) {
         self.name = name
         self.path = path
         self.wrapMode = wrapMode

Source/ShaderPassCompiler+Compiled.swift

@@ -54,8 +54,8 @@ extension ShaderPassCompiler {
             .map {
                 Compiled.LUT(url: $0.url,
                              name: $0.name,
-                             filter: .init($0.filter),
-                             wrapMode: .init($0.wrapMode),
+                             filter: $0.filter,
+                             wrapMode: $0.wrapMode,
                              isMipmap: $0.isMipmap)
             }
         
@@ -122,8 +122,8 @@ extension ShaderPassCompiler {
                      frameCountMod: pass.frameCountMod,
                      scaleX: pass.scaleX,
                      scaleY: pass.scaleY,
-                     filter: .init(pass.filter),
-                     wrapMode: .init(pass.wrapMode),
+                     filter: pass.filter,
+                     wrapMode: pass.wrapMode,
                      format: try .init(pass.format),
                      isFeedback: false,
                      buffers: buffers,
@@ -141,11 +141,11 @@ extension ShaderPassCompiler {
                     let wrap: Compiled.ShaderPassWrap
                     let filter: Compiled.ShaderPassFilter
                     if sem == .user {
-                        wrap   = .init(shader.luts[meta.index].wrapMode)
-                        filter = .init(shader.luts[meta.index].filter)
+                        wrap   = shader.luts[meta.index].wrapMode
+                        filter = shader.luts[meta.index].filter
                     } else {
-                        wrap   = .init(shader.passes[ref.passNumber].wrapMode)
-                        filter = .init(shader.passes[ref.passNumber].filter)
+                        wrap   = shader.passes[ref.passNumber].wrapMode
+                        filter = shader.passes[ref.passNumber].filter
                     }
                     
                     textures.append(Compiled.TextureDescriptor(name: meta.name,

Source/ShaderPassCompiler+Reflection.swift

@@ -444,14 +444,6 @@ class ShaderSymbols {
         "PassFeedback": .passFeedback,
         "User": .user,
     ]
-    static let textureSemanticToName: [Compiled.ShaderTextureSemantic: String] = [
-        .original: "Original",
-        .source: "Source",
-        .originalHistory: "OriginalHistory",
-        .passOutput: "PassOutput",
-        .passFeedback: "PassFeedback",
-        .user: "User",
-    ]
     
     static let textureSemanticUniformNames: [String: Compiled.ShaderBufferSemantic] = [
         "OriginalSize": .originalSize,
@@ -461,14 +453,6 @@ class ShaderSymbols {
         "PassFeedbackSize": .passFeedbackSize,
         "UserSize": .userSize,
     ]
-    static let textureSemanticToUniformName: [Compiled.ShaderBufferSemantic: String] = [
-        .originalSize: "OriginalSize",
-        .sourceSize: "SourceSize",
-        .originalHistorySize: "OriginalHistorySize",
-        .passOutputSize: "PassOutputSize",
-        .passFeedbackSize: "PassFeedbackSize",
-        .userSize: "UserSize",
-    ]
     
     static let semanticUniformNames: [String: ShaderBufferSemanticMap] = [
         "MVP": .init(semantic: .mvp, baseType: .fp32, vecSize: 4, cols: 4),
@@ -477,13 +461,6 @@ class ShaderSymbols {
         "FrameCount": .init(semantic: .frameCount, baseType: .uint32, vecSize: 1, cols: 1),
         "FrameDirection": .init(semantic: .frameDirection, baseType: .int32, vecSize: 1, cols: 1),
     ]
-    static let semanticToUniformName: [ShaderBufferSemantic: String] = [
-        .mvp: "MVP",
-        .outputSize: "OutputSize",
-        .finalViewportSize: "FinalViewportSize",
-        .frameCount: "FrameCount",
-        .frameDirection: "FrameDirection",
-    ]
 }
 
 class ShaderPassReflection {

Source/SlangShader.swift

@@ -109,8 +109,8 @@ public final class ShaderPass {
     
     public var scaleX: ShaderPassScale?
     public var scaleY: ShaderPassScale?
-    public var filter: ShaderPassFilter
-    public var wrapMode: ShaderPassWrap
+    public var filter: Compiled.ShaderPassFilter
+    public var wrapMode: Compiled.ShaderPassWrap
     public var isFloat: Bool
     public var issRGB: Bool
     public var isMipmap: Bool
@@ -137,8 +137,8 @@ public final class ShaderPass {
     init(from url: URL, index: Int, dictionary d: [String: AnyObject]) throws {
         self.url        = url
         self.index      = index
-        filter          = ShaderPassFilter(bool: d["filterLinear"] as? Bool)
-        wrapMode        = ShaderPassWrap(string: d["wrapMode"] as? String)
+        filter          = Compiled.ShaderPassFilter(bool: d["filterLinear"] as? Bool)
+        wrapMode        = Compiled.ShaderPassWrap(string: d["wrapMode"] as? String)
         frameCountMod   = d["frameCountMod"] as? UInt ?? 0
         issRGB          = d["srgbFramebuffer"] as? Bool ?? false
         isFloat         = d["floatFramebuffer"] as? Bool ?? false
@@ -184,20 +184,20 @@ public final class ShaderPass {
 public final class ShaderLUT {
     public var url: URL
     public var name: String
-    public var filter: ShaderPassFilter
-    public var wrapMode: ShaderPassWrap
+    public var filter: Compiled.ShaderPassFilter
+    public var wrapMode: Compiled.ShaderPassWrap
     public var isMipmap: Bool
     
     init(url: URL, name: String, dictionary d: [String: AnyObject]) {
         self.url      = url
         self.name     = name
-        self.filter   = ShaderPassFilter(bool: d["linear"] as? Bool)
-        self.wrapMode = ShaderPassWrap(string: d["wrapMode"] as? String)
+        self.filter   = Compiled.ShaderPassFilter(bool: d["linear"] as? Bool)
+        self.wrapMode = Compiled.ShaderPassWrap(string: d["wrapMode"] as? String)
         self.isMipmap = d["mipmapInput"] as? Bool ?? false
     }
 }
 
-extension ShaderPassFilter {
+extension Compiled.ShaderPassFilter {
     init(bool: Bool?) {
         switch bool {
         case true:
@@ -210,10 +210,10 @@ extension ShaderPassFilter {
     }
 }
 
-extension ShaderPassWrap {
+extension Compiled.ShaderPassWrap {
     init(string: String?) {
         guard let v = string else {
-            self = .default
+            self = .border
             return
         }
         
@@ -228,7 +228,7 @@ extension ShaderPassWrap {
             self = .mirroredRepeat
         default:
             // user specified an invalid value
-            self = .default
+            self = .border
         }
     }
 }