Added missing documentation to the source code in the Playdate bindings target.

Sources/PlaydateKit/Sound/Synth/Classes/Instrument.swift

@@ -72,10 +72,13 @@ extension Sound {
             Instrument.api.pointee.setPitchBend.unsafelyUnwrapped(pointer, bend)
         }
 
+        /// The range of `setPitchBend(_:)`, in half-steps.
         public func setPitchBendRange(halfSteps: Float) {
             Instrument.api.pointee.setPitchBendRange.unsafelyUnwrapped(pointer, halfSteps)
         }
 
+        /// Transposes played notes by `halfSteps` (fractional values
+        /// allowed).
         public func setTranspose(halfSteps: Float) {
             Instrument.api.pointee.setTranspose.unsafelyUnwrapped(pointer, halfSteps)
         }
@@ -85,20 +88,24 @@ extension Sound {
             Instrument.api.pointee.noteOff.unsafelyUnwrapped(pointer, note, when)
         }
 
+        /// Releases every playing voice at time `when` (0 = now).
         public func allNotesOff(when: UInt32 = 0) {
             Instrument.api.pointee.allNotesOff.unsafelyUnwrapped(pointer, when)
         }
 
+        /// Sets the volume of the left and right channels, 0...1.
         public func setVolume(left: Float, right: Float) {
             Instrument.api.pointee.setVolume.unsafelyUnwrapped(pointer, left, right)
         }
 
+        /// The volume of the left and right channels.
         public var volume: (left: Float, right: Float) {
             var left: Float = 0, right: Float = 0
             Instrument.api.pointee.getVolume.unsafelyUnwrapped(pointer, &left, &right)
             return (left, right)
         }
 
+        /// The number of voices currently playing.
         public var activeVoiceCount: Int {
             Int(Instrument.api.pointee.activeVoiceCount.unsafelyUnwrapped(pointer))
         }

Sources/PlaydateKit/Sound/Synth/Classes/Sequence.swift

@@ -47,10 +47,12 @@ extension Sound {
             }
         }
 
+        /// Stops playback.
         public func stop() {
             Sequence.api.pointee.stop.unsafelyUnwrapped(pointer)
         }
 
+        /// Whether the sequence is playing.
         public var isPlaying: Bool {
             Sequence.api.pointee.isPlaying.unsafelyUnwrapped(pointer) != 0
         }

Sources/PlaydateKit/Sound/Synth/Classes/SequenceTrack.swift

@@ -45,10 +45,12 @@ extension Sound {
             SequenceTrack.api.pointee.addNoteEvent.unsafelyUnwrapped(pointer, step, length, note, velocity)
         }
 
+        /// Removes the note at `step`, if any.
         public func removeNote(step: UInt32, note: MIDINote) {
             SequenceTrack.api.pointee.removeNoteEvent.unsafelyUnwrapped(pointer, step, note)
         }
 
+        /// Removes all notes from the track.
         public func clearNotes() {
             SequenceTrack.api.pointee.clearNotes.unsafelyUnwrapped(pointer)
         }
@@ -94,6 +96,7 @@ extension Sound {
             return ControlSignal(pointer: signal, isOwned: false)
         }
 
+        /// Removes all control signal events from the track.
         public func clearControlEvents() {
             SequenceTrack.api.pointee.clearControlEvents.unsafelyUnwrapped(pointer)
         }
@@ -103,10 +106,12 @@ extension Sound {
             Int(SequenceTrack.api.pointee.getPolyphony.unsafelyUnwrapped(pointer))
         }
 
+        /// The number of notes currently playing.
         public var activeVoiceCount: Int {
             Int(SequenceTrack.api.pointee.activeVoiceCount.unsafelyUnwrapped(pointer))
         }
 
+        /// Mutes or unmutes the track.
         public func setMuted(_ muted: Bool) {
             SequenceTrack.api.pointee.setMuted.unsafelyUnwrapped(pointer, muted ? 1 : 0)
         }

Sources/PlaydateKit/Sound/Synth/Classes/Synth.swift

@@ -108,18 +108,22 @@ extension Sound {
 
         // MARK: Envelope
 
+        /// The envelope's attack time, in seconds.
         public func setAttackTime(_ attack: Float) {
             Synth.api.pointee.setAttackTime.unsafelyUnwrapped(pointer, attack)
         }
 
+        /// The envelope's decay time, in seconds.
         public func setDecayTime(_ decay: Float) {
             Synth.api.pointee.setDecayTime.unsafelyUnwrapped(pointer, decay)
         }
 
+        /// The envelope's sustain level, 0...1.
         public func setSustainLevel(_ sustain: Float) {
             Synth.api.pointee.setSustainLevel.unsafelyUnwrapped(pointer, sustain)
         }
 
+        /// The envelope's release time, in seconds.
         public func setReleaseTime(_ release: Float) {
             Synth.api.pointee.setReleaseTime.unsafelyUnwrapped(pointer, release)
         }
@@ -142,6 +146,7 @@ extension Sound {
             Synth.api.pointee.setTranspose.unsafelyUnwrapped(pointer, halfSteps)
         }
 
+        /// Modulates the synth's frequency.
         public var frequencyModulator: SignalValue? {
             get { SignalValue.wrap(Synth.api.pointee.getFrequencyModulator.unsafelyUnwrapped(pointer)) }
             set {
@@ -150,6 +155,7 @@ extension Sound {
             }
         }
 
+        /// Modulates the synth's amplitude.
         public var amplitudeModulator: SignalValue? {
             get { SignalValue.wrap(Synth.api.pointee.getAmplitudeModulator.unsafelyUnwrapped(pointer)) }
             set {
@@ -170,12 +176,14 @@ extension Sound {
             Synth.api.pointee.setParameter.unsafelyUnwrapped(pointer, Int32(parameter), value) != 0
         }
 
+        /// Modulates a generator parameter.
         public func setParameterModulator(_ parameter: Int, _ modulator: SignalValue?) {
             retain(modulator)
             Synth.api.pointee.setParameterModulator.unsafelyUnwrapped(pointer, Int32(parameter),
                                                               modulator?.pointer)
         }
 
+        /// The modulator installed on a generator parameter, if any.
         public func parameterModulator(_ parameter: Int) -> SignalValue? {
             SignalValue.wrap(Synth.api.pointee.getParameterModulator.unsafelyUnwrapped(pointer, Int32(parameter)))
         }