Rename SplatScenePoint to SplatPoint and EncodedSplat to EncodedSplatPoint

- Add SplatScenePoint typealiase for backwards compatibility

Author: scier

MetalSplatter/Resources/ShaderCommon.h

@@ -70,7 +70,7 @@ typedef struct
     Uniforms uniforms[kMaxViewCount];
 } UniformsArray;
 
-// Keep in sync with EncodedSplat
+// Keep in sync with EncodedSplatPoint
 typedef struct
 {
     packed_float3 position;

MetalSplatter/Sources/EncodedSplat.swift …Splatter/Sources/EncodedSplatPoint.swiftMetalSplatter/Sources/EncodedSplat.swift renamed to MetalSplatter/Sources/EncodedSplatPoint.swift MetalSplatter/Sources/EncodedSplat.swift renamed to MetalSplatter/Sources/EncodedSplatPoint.swift

@@ -22,7 +22,7 @@ struct PackedRGBHalf4 {
 }
 
 // Keep in sync with Shaders.metal : Splat
-public struct EncodedSplat {
+public struct EncodedSplatPoint {
     var position: MTLPackedFloat3
     var colorSH0: PackedRGBHalf4 // sh0 color + opacity
     var covA: PackedHalf3
@@ -31,8 +31,8 @@ public struct EncodedSplat {
 
 // MARK: - Splat Conversion
 
-extension EncodedSplat {
-    public init(_ splat: SplatScenePoint) {
+extension EncodedSplatPoint {
+    public init(_ splat: SplatPoint) {
         self.init(position: splat.position,
                   colorSH0: splat.color.sh0,
                   opacity: splat.opacity.asLinearFloat,
@@ -43,7 +43,7 @@ extension EncodedSplat {
     /// Creates a splat with explicit raw SH0 coefficients.
     /// - Parameters:
     ///   - position: World-space position
-    ///   - colorSH0: SH degree-0 coefficients (NOT sRGB color; use `SplatScenePoint.Color.sh0` to convert)
+    ///   - colorSH0: SH degree-0 coefficients (NOT sRGB color; use `SplatPoint.Color.sh0` to convert)
     ///   - opacity: Linear opacity (0-1)
     ///   - scale: Linear scale
     ///   - rotation: Rotation quaternion
@@ -60,3 +60,8 @@ extension EncodedSplat {
                   covB: PackedHalf3(x: Float16(cov3D[1, 1]), y: Float16(cov3D[1, 2]), z: Float16(cov3D[2, 2])))
     }
 }
+
+// MARK: - Deprecated
+
+@available(*, deprecated, renamed: "EncodedSplatPoint")
+public typealias EncodedSplat = EncodedSplatPoint

MetalSplatter/Sources/SplatChunk+sortByLocality.swift

@@ -67,7 +67,7 @@ extension SplatChunk {
     }
 }
 
-fileprivate extension MetalBuffer where T == EncodedSplat {
+fileprivate extension MetalBuffer where T == EncodedSplatPoint {
     // Define a bounding box which doesn't quite include all the splats, just most of them
     func bounds(withinSigmaMultiple sigmaMultiple: Float) -> (min: SIMD3<Float>, max: SIMD3<Float>) {
         var sum = SIMD3<Float>.zero

MetalSplatter/Sources/SplatChunk.swift

@@ -18,7 +18,7 @@ public struct ChunkID: Hashable, Sendable, Equatable {
 /// Created externally and added to a SplatRenderer via `addChunk(_:)`.
 public struct SplatChunk: @unchecked Sendable {
     /// The splat data buffer
-    public let splats: MetalBuffer<EncodedSplat>
+    public let splats: MetalBuffer<EncodedSplatPoint>
 
     /// Optional buffer containing higher-order spherical harmonics coefficients.
     /// This is nil for SH degree 0 (view-independent color).
@@ -39,7 +39,7 @@ public struct SplatChunk: @unchecked Sendable {
     ///   - splats: The Metal buffer containing splat data (with raw SH0 in color field)
     ///   - shCoefficients: Optional buffer with higher-order SH coefficients (nil for SH0)
     ///   - shDegree: The spherical harmonics degree for this chunk
-    public init(splats: MetalBuffer<EncodedSplat>,
+    public init(splats: MetalBuffer<EncodedSplatPoint>,
                 shCoefficients: MetalBuffer<Float16>? = nil,
                 shDegree: SHDegree = .sh0) {
         self.splats = splats
@@ -52,16 +52,16 @@ public struct SplatChunk: @unchecked Sendable {
     ///   - device: Metal device for buffer allocation
     ///   - points: Array of scene points with SH data
     public init(device: MTLDevice,
-                from points: [SplatScenePoint]) throws {
+                from points: [SplatPoint]) throws {
         // Determine the SH degree from the data
         let shDegree = points.first?.color.shDegree ?? .sh0
 
         // Create splat buffer - always stores raw SH0 coefficients
-        let splatBuffer = try MetalBuffer<EncodedSplat>(device: device, capacity: points.count)
+        let splatBuffer = try MetalBuffer<EncodedSplatPoint>(device: device, capacity: points.count)
         splatBuffer.count = points.count
 
         for (i, point) in points.enumerated() {
-            splatBuffer.values[i] = EncodedSplat(point)
+            splatBuffer.values[i] = EncodedSplatPoint(point)
         }
 
         // Create SH coefficient buffer if we have higher-order SH

MetalSplatter/Sources/SplatRenderer+Deprecated.swift

@@ -4,8 +4,8 @@ import SplatIO
 
 /// Deprecated convenience methods and type aliases for backwards compatibility.
 extension SplatRenderer {
-    @available(*, deprecated, renamed: "EncodedSplat")
-    public typealias Splat = EncodedSplat
+    @available(*, deprecated, renamed: "EncodedSplatPoint")
+    public typealias Splat = EncodedSplatPoint
 }
 
 /// Deprecated convenience methods for backwards compatibility.
@@ -23,11 +23,11 @@ extension SplatRenderer {
     /// Adds splat points as a new chunk.
     /// - Parameter points: The splat points to add
     /// - Note: This method creates a single chunk containing all provided splats.
-    @available(*, deprecated, message: "Use SplatChunk and addChunk(_:) instead. Create a MetalBuffer<EncodedSplat>, wrap in SplatChunk, then call addChunk.")
-    public func add(_ points: [SplatScenePoint]) async throws {
-        let buffer = try MetalBuffer<EncodedSplat>(device: device)
+    @available(*, deprecated, message: "Use SplatChunk and addChunk(_:) instead. Create a MetalBuffer<EncodedSplatPoint>, wrap in SplatChunk, then call addChunk.")
+    public func add(_ points: [SplatPoint]) async throws {
+        let buffer = try MetalBuffer<EncodedSplatPoint>(device: device)
         try buffer.ensureCapacity(points.count)
-        buffer.append(points.map { EncodedSplat($0) })
+        buffer.append(points.map { EncodedSplatPoint($0) })
 
         let chunk = SplatChunk(splats: buffer, shCoefficients: nil, shDegree: .sh0)
         await addChunk(chunk)
@@ -37,7 +37,7 @@ extension SplatRenderer {
     /// - Parameter point: The splat point to add
     /// - Note: This method creates a single chunk containing the provided splat.
     @available(*, deprecated, message: "Use SplatChunk and addChunk(_:) instead.")
-    public func add(_ point: SplatScenePoint) async throws {
+    public func add(_ point: SplatPoint) async throws {
         try await add([point])
     }
 

MetalSplatter/Sources/SplatSorter.swift

@@ -5,7 +5,7 @@ import Synchronization
 
 /**
  SplatSorter creates a sorted list of splat indices across multiple chunks. It is given a reference to
- an array of chunk buffers (each a MetalBuffer<EncodedSplat>), which may be periodically updated
+ an array of chunk buffers (each a MetalBuffer<EncodedSplatPoint>), which may be periodically updated
  using the exclusive access mechanism described below. On each frame, a renderer provides the latest camera
  pose, and then obtains a reference to the latest sorted list of chunked splat indices, which may be one or
  more frames out-of-date. After rendering is completed, it explicitly releases this reference. Between
@@ -88,7 +88,7 @@ class SplatSorter: @unchecked Sendable {
     /// Represents a chunk for sorting purposes
     struct ChunkReference {
         let chunkIndex: UInt16
-        let buffer: MetalBuffer<EncodedSplat>
+        let buffer: MetalBuffer<EncodedSplatPoint>
     }
 
     private struct IndexBuffer {

MetalSplatter/Tests/ChunkTests.swift

@@ -38,14 +38,14 @@ final class ChunkTests: XCTestCase {
     // MARK: - SplatChunk Tests
 
     func testSplatChunkCreation() throws {
-        let buffer = try MetalBuffer<EncodedSplat>(device: device)
+        let buffer = try MetalBuffer<EncodedSplatPoint>(device: device)
         let chunk = SplatChunk(splats: buffer)
 
         XCTAssertEqual(chunk.splatCount, 0)
     }
 
     func testSplatChunkSplatCount() throws {
-        let buffer = try MetalBuffer<EncodedSplat>(device: device)
+        let buffer = try MetalBuffer<EncodedSplatPoint>(device: device)
         try buffer.ensureCapacity(5)
         for i in 0..<5 {
             buffer.append(makeSplat(at: SIMD3<Float>(Float(i), 0, 0)))
@@ -75,8 +75,8 @@ final class ChunkTests: XCTestCase {
 
     // MARK: - Helper Functions
 
-    func makeSplat(at position: SIMD3<Float>) -> EncodedSplat {
-        EncodedSplat(position: position,
+    func makeSplat(at position: SIMD3<Float>) -> EncodedSplatPoint {
+        EncodedSplatPoint(position: position,
                      colorSH0: SIMD3<Float>(1, 1, 1),
                      opacity: 1.0,
                      scale: SIMD3<Float>(0.1, 0.1, 0.1),
@@ -107,16 +107,16 @@ final class SplatRendererChunkTests: XCTestCase {
     }
 
     func makeChunk(splatCount: Int) throws -> SplatChunk {
-        let buffer = try MetalBuffer<EncodedSplat>(device: device)
+        let buffer = try MetalBuffer<EncodedSplatPoint>(device: device)
         try buffer.ensureCapacity(splatCount)
         for i in 0..<splatCount {
             buffer.append(makeSplat(at: SIMD3<Float>(Float(i), 0, 0)))
         }
         return SplatChunk(splats: buffer)
     }
 
-    func makeSplat(at position: SIMD3<Float>) -> EncodedSplat {
-        EncodedSplat(position: position,
+    func makeSplat(at position: SIMD3<Float>) -> EncodedSplatPoint {
+        EncodedSplatPoint(position: position,
                      colorSH0: SIMD3<Float>(1, 1, 1),
                      opacity: 1.0,
                      scale: SIMD3<Float>(0.1, 0.1, 0.1),

MetalSplatter/Tests/SplatSorterTests.swift

@@ -7,17 +7,17 @@ final class SplatSorterTests: XCTestCase {
     var device: MTLDevice!
 
     /// Helper to create a test splat at a given position
-    func makeSplat(at position: SIMD3<Float>) -> EncodedSplat {
-        EncodedSplat(position: position,
+    func makeSplat(at position: SIMD3<Float>) -> EncodedSplatPoint {
+        EncodedSplatPoint(position: position,
                      colorSH0: SIMD3<Float>(1, 1, 1),
                      opacity: 1.0,
                      scale: SIMD3<Float>(0.1, 0.1, 0.1),
                      rotation: simd_quatf(ix: 0, iy: 0, iz: 0, r: 1))
     }
 
     /// Helper to create a splat buffer with test data
-    func makeSplatBuffer(positions: [SIMD3<Float>]) throws -> MetalBuffer<EncodedSplat> {
-        let buffer = try MetalBuffer<EncodedSplat>(device: device)
+    func makeSplatBuffer(positions: [SIMD3<Float>]) throws -> MetalBuffer<EncodedSplatPoint> {
+        let buffer = try MetalBuffer<EncodedSplatPoint>(device: device)
         try buffer.ensureCapacity(positions.count)
         for position in positions {
             buffer.append(makeSplat(at: position))
@@ -329,7 +329,7 @@ final class SplatSorterTests: XCTestCase {
 
     func testEmptyChunks() async throws {
         let sorter = try SplatSorter(device: device)
-        let emptyBuffer = try MetalBuffer<EncodedSplat>(device: device)
+        let emptyBuffer = try MetalBuffer<EncodedSplatPoint>(device: device)
         let chunk = SplatSorter.ChunkReference(chunkIndex: 0, buffer: emptyBuffer)
 
         sorter.setChunks([chunk])

SplatConverter/Sources/SplatConverter.swift

@@ -112,7 +112,7 @@ struct SplatConverter: AsyncParsableCommand {
         let outputLabel: String?
         var error: Swift.Error?
 
-        var points: [SplatScenePoint] = []
+        var points: [SplatPoint] = []
         var currentOffset = 0
         var readCount = 0
 
@@ -130,7 +130,7 @@ struct SplatConverter: AsyncParsableCommand {
             self.outputLabel = outputLabel
         }
 
-        func didRead(points: [SplatIO.SplatScenePoint]) {
+        func didRead(points: [SplatIO.SplatPoint]) {
             readCount += points.count
 
             let newCurrentOffset = currentOffset + points.count

SplatIO/Sources/AutodetectSceneReader.swift

@@ -11,7 +11,7 @@ public class AutodetectSceneReader: SplatSceneReader {
         self.url = url
     }
 
-    public func read() async throws -> AsyncThrowingStream<[SplatScenePoint], Swift.Error> {
+    public func read() async throws -> AsyncThrowingStream<[SplatPoint], Swift.Error> {
         let reader: SplatSceneReader =
         switch SplatFileFormat(for: url) {
         case .ply: try SplatPLYSceneReader(url)