Assistant APIs (#100)

Author: codefiesta

Sources/VimKit/Geometry+Mesh.swift

@@ -10,7 +10,7 @@ import VimKitShaders
 extension Instance {
 
     /// Convenience var that returns the bounding box.
-    var boundingBox: MDLAxisAlignedBoundingBox {
+    public var boundingBox: MDLAxisAlignedBoundingBox {
         .init(maxBounds: maxBounds, minBounds: minBounds)
     }
 

Sources/VimKit/Geometry.swift

@@ -916,6 +916,14 @@ extension Geometry {
 
 extension Geometry {
 
+    /// Returns the instance with the specified id.
+    /// - Parameter id: the instance id
+    /// - Returns: the instance with the specified id or nil
+    public func instance(id: Int) -> Instance? {
+        guard let index = instanceOffsets.firstIndex(of: id) else { return nil }
+        return instances[index]
+    }
+
     /// Toggles the instance hidden state to `.selected` or
     /// - Parameters:
     ///   - id: the index of the instances to select or deselect
@@ -935,6 +943,15 @@ extension Geometry {
         }
     }
 
+    /// Toggles the instance hidden state of all instances from `.selected` to `.default`
+    public func deselectAll() {
+        for (i, value) in instances.enumerated() {
+            if value.state == .selected {
+                instances[i].state = .default
+            }
+        }
+    }
+
     /// Convenience var that returns a count of the selected instances.
     public var selectedCount: Int {
         instances.filter{ $0.state == .selected }.count

Sources/VimKit/Renderer/RenderPass+Indirect.swift

@@ -53,7 +53,7 @@ class RenderPassIndirect: RenderPass {
 
     /// Boolean flag indicating if indirect command buffers should perform depth occlusion testing or not.
     /// Frustum testing will always happen
-    open var enableDepthTesting: Bool {
+    var enableDepthTesting: Bool {
         context.vim.options.enableDepthTesting
     }
 

Sources/VimKit/Renderer/RenderPass+Shapes.swift

@@ -50,7 +50,7 @@ class RenderPassShapes: RenderPass {
         encode(descriptor: descriptor, renderEncoder: renderEncoder)
 
         // Draw the clip planes
-        drawClipPlanes(descriptor: descriptor, renderEncoder: renderEncoder)
+        //drawClipPlanes(descriptor: descriptor, renderEncoder: renderEncoder)
     }
 
     /// Encodes the buffer data into the render encoder.

Sources/VimKit/Renderer/Renderer+Drawing.swift

@@ -8,14 +8,10 @@
 import MetalKit
 import VimKitShaders
 
-///  The render encoder label.
-private let renderEncoderLabel = "VimRenderEncoder"
-///  The render encoder debug group.
-private let renderEncoderDebugGroupName = "VimDrawGroup"
-private let labelOnScreenCommandBuffer = "OnScreenCommandBuffer"
+/// The label for the off-screen commands to execute. Used by indirect rendering compute encoder to dispatch threads.
 private let labelOffScreenCommandBuffer = "OffScreenCommandBuffer"
-///  The minimum amount of instanced meshes to implement frustum culling.
-private let minFrustumCullingThreshold = 1024
+/// The label for the on-screen commands to execute.
+private let labelOnScreenCommandBuffer = "OnScreenCommandBuffer"
 
 #if !os(visionOS)
 

Sources/VimKit/Renderer/Renderer.swift

@@ -188,22 +188,26 @@ extension Renderer {
     /// Informs the renderer that the model was tapped at the specified point.
     /// Creates a region at the specified point the size of a single pixel and
     /// grabs the byte encoded at that pixel on the instance index texture.
-    /// - Parameter point: the screen point
-    public func didTap(at point: SIMD2<Float>) {
+    /// - Parameters:
+    ///   - pixelLocation: the screen pixel location (unscaled)
+    ///   - displayScale: the screen display scale
+    public func didTap(at pixelLocation: SIMD2<Float>, _ displayScale: Float = 2.0) {
         guard let geometry, let texture = instancePickingTexture else { return }
-        let region = MTLRegionMake2D(Int(point.x), Int(point.y), 1, 1)
+
+        let displayLocation = pixelLocation * displayScale
+        let region = MTLRegionMake2D(Int(displayLocation.x), Int(displayLocation.y), 1, 1)
         let bytesPerRow = MemoryLayout<Int32>.stride * texture.width
-        var pixel: Int32 = .empty
-        texture.getBytes(&pixel, bytesPerRow: bytesPerRow, from: region, mipmapLevel: 0)
-        guard pixel != .empty else {
+        var pixelBytes: Int32 = .empty
+        texture.getBytes(&pixelBytes, bytesPerRow: bytesPerRow, from: region, mipmapLevel: 0)
+        guard pixelBytes != .empty else {
             context.vim.erase()
             return
         }
 
-        let id = Int(pixel)
+        let id = Int(pixelBytes)
         guard let index = geometry.instanceOffsets.firstIndex(of: id) else { return }
 
-        let query = camera.unprojectPoint(point)
+        let query = camera.unprojectPoint(displayLocation)
         var point3D: SIMD3<Float> = .zero
 
         // Raycast into the instance
@@ -213,7 +217,7 @@ extension Renderer {
         }
 
         // Select the instance so the event gets published.
-        context.vim.select(id: id, point: point3D)
+        context.vim.select(id: id, pixel: pixelLocation, point: point3D)
     }
 }
 

Sources/VimKit/Views/RendererContainerViewCoordinator.swift

@@ -69,9 +69,10 @@ extension RendererContainerViewCoordinator {
             // where UIView 0,0 is in the top left with positive values of Y going down
             let frame = view.frame
             let location = gesture.location(in: view)
+
             let y = frame.height - location.y // Flip the Y coordinate
-            let point: SIMD2<Float> = [Float(location.x), Float(y)] * contentScaleFactor
-            renderer.didTap(at: point)
+            let point: SIMD2<Float> = [Float(location.x), Float(y)]
+            renderer.didTap(at: point, contentScaleFactor)
         default:
             break
         }
@@ -84,9 +85,10 @@ extension RendererContainerViewCoordinator {
         guard let view = gesture.view else { return }
         switch gesture.state {
         case .recognized:
-            let location = gesture.location(in: view) * view.contentScaleFactor
+            let contentScaleFactor = Float(view.contentScaleFactor)
+            let location = gesture.location(in: view)
             let point: SIMD2<Float> = [Float(location.x), Float(location.y)]
-            renderer.didTap(at: point)
+            renderer.didTap(at: point, contentScaleFactor)
         default:
             break
         }

Sources/VimKit/Vim+Camera.swift

@@ -213,6 +213,22 @@ extension Vim {
             position = p
         }
 
+        /// Frames the bounding box by zooming to it's extents and applies clip planes around the box if specified. 
+        /// - Parameters:
+        ///   - box: the box to frame
+        ///   - clip: if true, the camera will add clip planes around to the box.
+        public func zoom(to box: MDLAxisAlignedBoundingBox, clip: Bool = false) {
+            if clip {
+                clipPlanes = box.planes
+            }
+            let center = box.center
+            let radius = box.radius
+            let fovRadians = fovDegrees.radians
+            let distance = radius / sin(fovRadians / 2)
+            let eye = center - distance * forward
+            look(at: box.center, from: eye)
+        }
+
         /// Projects a point from the 3D world coordinate system of the scene to the 2D pixel coordinate system.
         /// - Parameters:
         ///   - point: A point in the world coordinate system of the scene.

Sources/VimKit/Vim.swift

@@ -30,9 +30,9 @@ public class Vim: NSObject, ObservableObject, @unchecked Sendable {
         /// An instance has been selected or deselected.
         /// - Parameter Int: the instance identifer
         /// - Parameter Bool: true if the instance has been selected, false if de-selected.
-        /// - Parameter Int: the total count of selected instances.
+        /// - Parameter SIMD2<Float>: the 2D pixel point on the screen that was selected
         /// - Parameter SIMD3<Float>: the 3D positon of the selected object.
-        case selected(Int, Bool, Int, SIMD3<Float>)
+        case selected(Int, Bool, SIMD2<Float>, SIMD3<Float>)
 
         /// An instance has been hidden or shown.
         /// - Parameter Int: the total count of hidden instances.
@@ -290,18 +290,20 @@ extension Vim {
 
     /// Erases a previous published event to downstream event subscribers.
     public func erase() {
+        geometry?.deselectAll()
         eventPublisher.send(.empty)
     }
 
     /// Toggles an instance selection state for the instance with the specified id.
     /// - Parameters:
     ///   - id: the id of the instance to select (or deselect if already selected).
+    ///   - pixel: the pixel location of the selection point inside the 2D viewport
     ///   - point: the point in 3D space where the object was selected
     @MainActor
-    public func select(id: Int, point: SIMD3<Float> = .zero) {
+    public func select(id: Int, pixel: SIMD2<Float> = .zero, point: SIMD3<Float> = .zero) {
         guard let geometry else { return }
         let selected = geometry.select(id: id)
-        eventPublisher.send(.selected(id, selected, 1, point))
+        eventPublisher.send(.selected(id, selected, pixel, point))
     }
 
     /// Toggles an instance hidden state for the instance with the specified id

Sources/VimKitShaders/Resources/Indirect.metal

@@ -54,18 +54,19 @@ static bool isInsideViewFrustumAndClipPlanes(const Camera camera,
         }
 
         const float4 clipPlane = camera.clipPlanes[i];
-
+        const float3 planeNormal = normalize(clipPlane.xyz);
+        
         // Skip the plane if it's not valid
         if (isinf(clipPlane.w)) { continue; }
 
-        if (-dot(clipPlane.xyz, corners[0].xyz) + clipPlane.w < 0 &&
-            -dot(clipPlane.xyz, corners[1].xyz) + clipPlane.w < 0 &&
-            -dot(clipPlane.xyz, corners[2].xyz) + clipPlane.w < 0 &&
-            -dot(clipPlane.xyz, corners[3].xyz) + clipPlane.w < 0 &&
-            -dot(clipPlane.xyz, corners[4].xyz) + clipPlane.w < 0 &&
-            -dot(clipPlane.xyz, corners[5].xyz) + clipPlane.w < 0 &&
-            -dot(clipPlane.xyz, corners[6].xyz) + clipPlane.w < 0 &&
-            -dot(clipPlane.xyz, corners[7].xyz) + clipPlane.w < 0) {
+        if (-dot(planeNormal, corners[0].xyz) + clipPlane.w < 0 &&
+            -dot(planeNormal, corners[1].xyz) + clipPlane.w < 0 &&
+            -dot(planeNormal, corners[2].xyz) + clipPlane.w < 0 &&
+            -dot(planeNormal, corners[3].xyz) + clipPlane.w < 0 &&
+            -dot(planeNormal, corners[4].xyz) + clipPlane.w < 0 &&
+            -dot(planeNormal, corners[5].xyz) + clipPlane.w < 0 &&
+            -dot(planeNormal, corners[6].xyz) + clipPlane.w < 0 &&
+            -dot(planeNormal, corners[7].xyz) + clipPlane.w < 0) {
             // Not visible - all corners returned negative
             return false;
         }