119 lines
5.0 KiB
Swift
119 lines
5.0 KiB
Swift
import CoreGraphics
|
||
import Foundation
|
||
|
||
/// dBFS → VU → needle position and angle, all from the meter tokens.
|
||
public enum VUScale {
|
||
public static func vu(fromDbfs dbfs: Double) -> Double {
|
||
dbfs - MeterTokens.vuReferenceDbfs
|
||
}
|
||
|
||
/// 0 = bottom of the scale, 1 = top. The needle may swing slightly past the end (up to 1.03).
|
||
public static func fraction(forVU vu: Double) -> Double {
|
||
min(1.03, max(0, (vu - MeterTokens.vuMin) / (MeterTokens.vuMax - MeterTokens.vuMin)))
|
||
}
|
||
|
||
public static func fraction(forDbfs dbfs: Double) -> Double {
|
||
fraction(forVU: vu(fromDbfs: dbfs))
|
||
}
|
||
|
||
/// Radians from vertical; negative is left of vertical.
|
||
public static func angle(forFraction fraction: Double) -> Double {
|
||
(-MeterTokens.vuArcDegrees / 2 + MeterTokens.vuArcDegrees * fraction) * .pi / 180
|
||
}
|
||
|
||
/// Level as VoiceOver should say it: rounded to steps of 3 VU, clamped to the scale, "stil" for non-finite input.
|
||
public static func spokenLevel(fromDbfs dbfs: Double) -> String {
|
||
guard dbfs.isFinite else { return "stil" }
|
||
let stepped = (vu(fromDbfs: dbfs) / 3).rounded() * 3
|
||
let clamped = min(MeterTokens.vuMax, max(MeterTokens.vuMin, stepped))
|
||
return "\(Int(clamped)) VU"
|
||
}
|
||
}
|
||
|
||
/// Second-order needle: reaches ~99 % in `response` seconds, slight overshoot for damping < 1.
|
||
public struct NeedleSpring: Equatable {
|
||
public private(set) var position: Double
|
||
public private(set) var velocity: Double = 0
|
||
private let omega: Double
|
||
private let zeta: Double
|
||
|
||
public init(response: Double = Motion.needleResponse, damping: Double = Motion.needleDamping, position: Double = 0) {
|
||
self.zeta = damping
|
||
self.omega = 4.6 / (damping * response)
|
||
self.position = position
|
||
}
|
||
|
||
/// Advances the simulation by `dt` seconds in small fixed sub-steps (stable for any frame time).
|
||
@discardableResult
|
||
public mutating func step(target: Double, dt: Double) -> Double {
|
||
var remaining = max(0, dt)
|
||
let h = 1.0 / 240.0
|
||
while remaining > 1e-9 {
|
||
let s = min(h, remaining)
|
||
let acceleration = omega * omega * (target - position) - 2 * zeta * omega * velocity
|
||
velocity += acceleration * s
|
||
position += velocity * s
|
||
remaining -= s
|
||
}
|
||
return position
|
||
}
|
||
}
|
||
|
||
public enum SegmentID: CaseIterable, Hashable {
|
||
case a, b, c, d, e, f, g
|
||
}
|
||
|
||
/// Which segments of a seven-segment digit are lit, and where each segment sits (from the segment tokens).
|
||
public enum SegmentGlyph {
|
||
static let map: [Character: Set<SegmentID>] = [
|
||
"0": [.a, .b, .c, .d, .e, .f], "1": [.b, .c], "2": [.a, .b, .d, .e, .g], "3": [.a, .b, .c, .d, .g],
|
||
"4": [.b, .c, .f, .g], "5": [.a, .c, .d, .f, .g], "6": [.a, .c, .d, .e, .f, .g], "7": [.a, .b, .c],
|
||
"8": Set(SegmentID.allCases), "9": [.a, .b, .c, .d, .f, .g],
|
||
]
|
||
|
||
public static func lit(for character: Character) -> Set<SegmentID> {
|
||
map[character] ?? []
|
||
}
|
||
|
||
/// Hexagonal bar for one segment, inside a `Segment.digitWidth` × `Segment.digitHeight` box.
|
||
public static func polygon(_ id: SegmentID) -> [CGPoint] {
|
||
let width = Segment.digitWidth, height = Segment.digitHeight
|
||
let h = Segment.thickness / 2, gap = Segment.gap
|
||
let left = h, right = width - h, mid = height / 2
|
||
|
||
func horizontal(_ x0: CGFloat, _ x1: CGFloat, _ cy: CGFloat) -> [CGPoint] {
|
||
[CGPoint(x: x0, y: cy), CGPoint(x: x0 + h, y: cy - h), CGPoint(x: x1 - h, y: cy - h),
|
||
CGPoint(x: x1, y: cy), CGPoint(x: x1 - h, y: cy + h), CGPoint(x: x0 + h, y: cy + h)]
|
||
}
|
||
func vertical(_ cx: CGFloat, _ y0: CGFloat, _ y1: CGFloat) -> [CGPoint] {
|
||
[CGPoint(x: cx, y: y0), CGPoint(x: cx + h, y: y0 + h), CGPoint(x: cx + h, y: y1 - h),
|
||
CGPoint(x: cx, y: y1), CGPoint(x: cx - h, y: y1 - h), CGPoint(x: cx - h, y: y0 + h)]
|
||
}
|
||
let x0 = left + h + gap, x1 = right - h - gap
|
||
switch id {
|
||
case .a: return horizontal(x0, x1, h)
|
||
case .g: return horizontal(x0, x1, mid)
|
||
case .d: return horizontal(x0, x1, height - h)
|
||
case .f: return vertical(left, h + h + gap, mid - h - gap)
|
||
case .b: return vertical(right, h + h + gap, mid - h - gap)
|
||
case .e: return vertical(left, mid + h + gap, height - h - h - gap)
|
||
case .c: return vertical(right, mid + h + gap, height - h - h - gap)
|
||
}
|
||
}
|
||
}
|
||
|
||
public enum LEDBar {
|
||
public enum Tone { case green, amber, red }
|
||
|
||
/// The last segment is red, the three before it amber, the rest green.
|
||
public static func tone(forSegment index: Int, segments: Int = MeterTokens.ledSegments) -> Tone {
|
||
if index >= segments - 1 { return .red }
|
||
if index >= segments - 4 { return .amber }
|
||
return .green
|
||
}
|
||
|
||
public static func litCount(forFraction fraction: Double, segments: Int = MeterTokens.ledSegments) -> Int {
|
||
Int((min(1, max(0, fraction)) * Double(segments)).rounded())
|
||
}
|
||
}
|