Replace RendererError struct with an enum, and make the RenderCoordinator in WithRenderCoordinator's content property not nullable

Author: jandrokt

Sources/Client/Views/Play/GameView.swift

@@ -44,71 +44,69 @@ struct GameView: View {
   var body: some View {
     JoinServerAndThen(serverDescriptor, with: account) { client in
       WithRenderCoordinator(for: client) { renderCoordinator in
-        if let renderCoordinator = renderCoordinator {
-          VStack {
-            switch state {
-              case .playing:
-                ZStack {
-                  WithController(controller, listening: $inputCaptured) {
-                    if controllerOnly {
+        VStack {
+          switch state {
+            case .playing:
+              ZStack {
+                WithController(controller, listening: $inputCaptured) {
+                  if controllerOnly {
+                    gameView(client: client, renderCoordinator: renderCoordinator)
+                  } else {
+                    InputView(listening: $inputCaptured, cursorCaptured: !inGameMenuPresented && cursorCaptured) {
                       gameView(client: client, renderCoordinator: renderCoordinator)
-                    } else {
-                      InputView(listening: $inputCaptured, cursorCaptured: !inGameMenuPresented && cursorCaptured) {
-                        gameView(client: client, renderCoordinator: renderCoordinator)
-                      }
-                      .onKeyPress { [weak client] key, characters in
-                        client?.press(key, characters)
-                      }
-                      .onKeyRelease { [weak client] key in
-                        client?.release(key)
-                      }
-                      .onMouseMove { [weak client] deltaX, deltaY in
-                        // TODO: Formalise this adjustment factor somewhere
-                        let sensitivityAdjustmentFactor: Float = 0.004
-                        let sensitivity = sensitivityAdjustmentFactor * managedConfig.mouseSensitivity
-                        client?.moveMouse(sensitivity * deltaX, sensitivity * deltaY)
-                      }
-                      .passthroughClicks(!cursorCaptured)
                     }
-                  }
-                  .onButtonPress { [weak client] button in
-                    guard let input = input(for: button) else {
-                      return
+                    .onKeyPress { [weak client] key, characters in
+                      client?.press(key, characters)
                     }
-                    client?.press(input)
-                  }
-                  .onButtonRelease { [weak client] button in
-                    guard let input = input(for: button) else {
-                      return
+                    .onKeyRelease { [weak client] key in
+                      client?.release(key)
                     }
-                    client?.release(input)
-                  }
-                  .onThumbstickMove { [weak client] thumbstick, x, y in
-                    switch thumbstick {
-                      case .left:
-                        client?.moveLeftThumbstick(x, y)
-                      case .right:
-                        client?.moveRightThumbstick(x, y)
+                    .onMouseMove { [weak client] deltaX, deltaY in
+                      // TODO: Formalise this adjustment factor somewhere
+                      let sensitivityAdjustmentFactor: Float = 0.004
+                      let sensitivity = sensitivityAdjustmentFactor * managedConfig.mouseSensitivity
+                      client?.moveMouse(sensitivity * deltaX, sensitivity * deltaY)
                     }
+                    .passthroughClicks(!cursorCaptured)
+                  }
+                }
+                .onButtonPress { [weak client] button in
+                  guard let input = input(for: button) else {
+                    return
                   }
+                  client?.press(input)
                 }
-              case .gpuFrameCaptureComplete(let file):
-                frameCaptureResult(file)
-                  .onAppear {
-                    cursorCaptured = false
-                    inputCaptured = false
+                .onButtonRelease { [weak client] button in
+                  guard let input = input(for: button) else {
+                    return
                   }
-            }
+                  client?.release(input)
+                }
+                .onThumbstickMove { [weak client] thumbstick, x, y in
+                  switch thumbstick {
+                    case .left:
+                      client?.moveLeftThumbstick(x, y)
+                    case .right:
+                      client?.moveRightThumbstick(x, y)
+                  }
+                }
+              }
+            case .gpuFrameCaptureComplete(let file):
+              frameCaptureResult(file)
+                .onAppear {
+                  cursorCaptured = false
+                  inputCaptured = false
+                }
           }
-          .onAppear {
-            modal.onError { [weak client] _ in
-              client?.game.tickScheduler.cancel()
-              cursorCaptured = false
-              inputCaptured = false
-            }
-
-            registerEventHandler(client, renderCoordinator)
+        }
+        .onAppear {
+          modal.onError { [weak client] _ in
+            client?.game.tickScheduler.cancel()
+            cursorCaptured = false
+            inputCaptured = false
           }
+
+          registerEventHandler(client, renderCoordinator)
         }
       } cancellationHandler: {
         appState.update(to: .serverList)

Sources/Client/Views/Play/WithRenderCoordinator.swift

@@ -6,10 +6,10 @@ import DeltaRenderer
 /// without having to introduce additional loading states into views.
 struct WithRenderCoordinator<Content: View>: View {
   var client: Client
-  var content: (RenderCoordinator?) -> Content
+  var content: (RenderCoordinator) -> Content
   var cancel: () -> Void
 
-  init(for client: Client, @ViewBuilder content: @escaping (RenderCoordinator?) -> Content, cancellationHandler cancel: @escaping () -> Void) {
+  init(for client: Client, @ViewBuilder content: @escaping (RenderCoordinator) -> Content, cancellationHandler cancel: @escaping () -> Void) {
     self.client = client
     self.content = content
     self.cancel = cancel
@@ -40,7 +40,7 @@ struct WithRenderCoordinator<Content: View>: View {
       } catch let error as RendererError {
         renderCoordinatorError = error
       } catch {
-        renderCoordinatorError = RendererError(.unknown(error))
+        renderCoordinatorError = RendererError.unknown(error)
       }
     }
   }

Sources/Core/Renderer/RenderCoordinator.swift

@@ -3,23 +3,19 @@ import FirebladeMath
 import MetalKit
 import DeltaCore
 
-public struct RendererError: LocalizedError {
-  public enum ErrorKind {
-    case getMetalDevice
-    case makeRenderCommandQueue
-    case camera(Error)
-    case skyBoxRenderer(Error)
-    case worldRenderer(Error)
-    case guiRenderer(Error)
-    case screenRenderer(Error)
-    case depthState(Error)
-    case unknown(Error)
-  }
-  
-  public let kind: ErrorKind
+public enum RendererError: LocalizedError {
+  case getMetalDevice
+  case makeRenderCommandQueue
+  case camera(Error)
+  case skyBoxRenderer(Error)
+  case worldRenderer(Error)
+  case guiRenderer(Error)
+  case screenRenderer(Error)
+  case depthState(Error)
+  case unknown(Error)
 
   public var errorDescription: String? {
-    switch kind {
+    switch self {
       case .getMetalDevice:
         return "Failed to get metal device"
       case .makeRenderCommandQueue:
@@ -40,10 +36,6 @@ public struct RendererError: LocalizedError {
         return "Failed with an unknown error \(error.labeledLocalizedDescription)"
     }
   }
-  
-  public init(_ kind: ErrorKind) {
-    self.kind = kind
-  }
 }
 
 extension Error {
@@ -109,11 +101,11 @@ public final class RenderCoordinator: NSObject, MTKViewDelegate {
   /// - Parameter client: The client to render for.
   public required init(_ client: Client) throws {
     guard let device = MTLCreateSystemDefaultDevice() else {
-      throw RendererError(.getMetalDevice)
+      throw RendererError.getMetalDevice
     }
 
     guard let commandQueue = device.makeCommandQueue() else {
-      throw RendererError(.makeRenderCommandQueue)
+      throw RendererError.makeRenderCommandQueue
     }
 
     self.client = client
@@ -124,7 +116,7 @@ public final class RenderCoordinator: NSObject, MTKViewDelegate {
     do {
       camera = try Camera(device)
     } catch {
-      throw RendererError(.camera(error))
+      throw RendererError.camera(error)
     }
 
     do {
@@ -134,7 +126,7 @@ public final class RenderCoordinator: NSObject, MTKViewDelegate {
         commandQueue: commandQueue
       )
     } catch {
-      throw RendererError(.skyBoxRenderer(error))
+      throw RendererError.skyBoxRenderer(error)
     }
 
     do {
@@ -145,7 +137,7 @@ public final class RenderCoordinator: NSObject, MTKViewDelegate {
         profiler: profiler
       )
     } catch {
-      throw RendererError(.worldRenderer(error))
+      throw RendererError.worldRenderer(error)
     }
 
     do {
@@ -156,7 +148,7 @@ public final class RenderCoordinator: NSObject, MTKViewDelegate {
         profiler: profiler
       )
     } catch {
-      throw RendererError(.guiRenderer(error))
+      throw RendererError.guiRenderer(error)
     }
 
     do {
@@ -166,14 +158,14 @@ public final class RenderCoordinator: NSObject, MTKViewDelegate {
         profiler: profiler
       )
     } catch {
-      throw RendererError(.screenRenderer(error))
+      throw RendererError.screenRenderer(error)
     }
 
     // Create depth stencil state
     do {
       depthState = try MetalUtil.createDepthState(device: device)
     } catch {
-      throw RendererError(.depthState(error))
+      throw RendererError.depthState(error)
     }
 
     statistics = RenderStatistics(gpuCountersEnabled: false)