reverb-m1

Scene.swift (3505B)

---

 // Demo scene: a spinning cube at 1.5 m, a ground grid, and reference pillars at several depths.
 import simd
 
 /// A run of vertices in the shared scene buffer, drawn with one model matrix.
 struct SceneItem { var first: Int; var count: Int; var model: simd_float4x4; var spins = false; var floorGrid = false }
 
 /// Eye height above the floor in metres (the head sits at the origin, -Y is down).
 let floorY: Float = -1.4
 
 enum Scene {
     /// Axis-aligned box centred at `c` with full size `s`, as 12 triangles. Nil colour = per-face colours.
     static func box(center c: SIMD3<Float>, size s: SIMD3<Float>, color: SIMD3<Float>? = nil) -> [Vertex] {
         let faces: [(n: SIMD3<Float>, u: SIMD3<Float>, v: SIMD3<Float>, c: SIMD3<Float>)] = [
             ([1, 0, 0], [0, 0, -1], [0, 1, 0], [0.95, 0.30, 0.25]),
             ([-1, 0, 0], [0, 0, 1], [0, 1, 0], [0.25, 0.80, 0.95]),
             ([0, 1, 0], [1, 0, 0], [0, 0, -1], [0.40, 0.90, 0.35]),
             ([0, -1, 0], [1, 0, 0], [0, 0, 1], [0.95, 0.85, 0.30]),
             ([0, 0, 1], [1, 0, 0], [0, 1, 0], [0.75, 0.40, 0.95]),
             ([0, 0, -1], [-1, 0, 0], [0, 1, 0], [0.95, 0.60, 0.20]),
         ]
         var out: [Vertex] = []
         for f in faces {
             let ctr = c + f.n * s * 0.5
             let du = f.u * s * 0.5, dv = f.v * s * 0.5
             let p: [SIMD3<Float>] = [ctr - du - dv, ctr + du - dv, ctr + du + dv, ctr - du + dv]
             for i in [0, 1, 2, 0, 2, 3] { out.append(Vertex(pos: p[i], normal: f.n, color: color ?? f.c)) }
         }
         return out
     }
 
     /// Builds the whole scene: one vertex array plus the items that index into it.
     static func make() -> (vertices: [Vertex], items: [SceneItem]) {
         var verts: [Vertex] = [], items: [SceneItem] = []
         func add(_ v: [Vertex], _ model: simd_float4x4 = matrix_identity_float4x4, spins: Bool = false, floorGrid: Bool = false) {
             items.append(SceneItem(first: verts.count, count: v.count, model: model, spins: spins, floorGrid: floorGrid))
             verts += v
         }
         // Hero cube: unit cube scaled to 0.4 m, 1.5 m ahead at eye level, spun by the renderer.
         add(box(center: .zero, size: [1, 1, 1]), translation([0, 0, -1.5]) * scale(0.4), spins: true)
 
         // One floor surface; the fragment shader draws a pixel-filtered metric grid.
         // Thin geometry otherwise compresses the transverse lines below one panel pixel at distance.
         add(box(center: [0, floorY - 0.01, -20], size: [60, 0.02, 60], color: [0.10, 0.11, 0.15]), floorGrid: true)
 
         // Reference pillars at increasing depth, alternating sides, in distinct colours.
         let pillars: [(x: Float, z: Float, c: SIMD3<Float>)] = [
             (-0.5, -0.7, [0.95, 0.35, 0.35]), (0.9, -2.5, [0.35, 0.85, 0.45]),
             (-1.6, -4.0, [0.40, 0.55, 0.95]), (2.2, -6.0, [0.95, 0.80, 0.30]),
             (-3.0, -9.0, [0.85, 0.40, 0.90]), (4.0, -14.0, [0.30, 0.85, 0.85]),
         ]
         for p in pillars {
             let h: Float = 1.0   // 1 m tall pillars standing on the floor
             add(box(center: [p.x, floorY + h / 2, p.z], size: [0.25, h, 0.25], color: p.c))
         }
         // Small cubes floating at head height, near and far, to compare parallax at the same height.
         add(box(center: [0.35, 0.1, -0.5], size: [0.08, 0.08, 0.08]))
         add(box(center: [-1.2, 0.1, -3.0], size: [0.3, 0.3, 0.3]))
         add(box(center: [1.8, 0.1, -8.0], size: [0.8, 0.8, 0.8]))
         return (verts, items)
     }
 }