Index
Documents:
Module File Format Specifications
.
Modules:
libtrackerboy
,
libtrackerboy/apu
,
libtrackerboy/apuio
,
libtrackerboy/common
,
libtrackerboy/data
,
libtrackerboy/editing
,
libtrackerboy/engine
,
libtrackerboy/exports/wav
,
libtrackerboy/io
,
libtrackerboy/ir
,
libtrackerboy/notes
,
libtrackerboy/private/apucontrol
,
libtrackerboy/private/data
,
libtrackerboy/private/endian
,
libtrackerboy/private/enginecontrol
,
libtrackerboy/private/enginestate
,
libtrackerboy/private/hardware
,
libtrackerboy/private/ioblocks
,
libtrackerboy/private/player
,
libtrackerboy/private/ptrarith
,
libtrackerboy/private/synth
,
libtrackerboy/private/utils
,
libtrackerboy/private/wavwriter
,
libtrackerboy/version
.
API symbols
`$`:
data: `$`(s: Sequence): string
data: `$`(wave: WaveData): string
`==`:
common: `==`[T: ptr | ref](lhs: nil.typeof; rhs: Immutable[T]): bool
common: `==`[T](i: Immutable[T]; rhs: T): bool
common: `==`[T](lhs: T; i: Immutable[T]): bool
data: `==`(a, b: SomeTable): bool
data: `==`(a, b: SongList): bool
data: `==`(lhs, rhs: Track): bool
data: `==`(lhs, rhs: TrackView): bool
utils: `==`[T](lhs, rhs: EqRef[T]): bool
`=destroy`:
wavwriter: `=destroy`(w: var WavWriter)
`[]=`:
data: `[]=`(o: var Order; index: Natural; val: OrderRow)
data: `[]=`(s: var Sequence; i: ByteIndex; val: uint8)
data: `[]=`(l: var SongList; i: ByteIndex; s: ref Song)
data: `[]=`(t: var Track; i: ByteIndex; v: TrackRow)
`[]`:
common: `[]`[T](i: Immutable[[type node]]): lent T
common: `[]`[T: not ptr | ref](i: Immutable[T]): lent T
data: `[]`(o: Order; index: Natural): OrderRow
data: `[]`(s: Sequence; i: ByteIndex): uint8
data: `[]`(l: var SongList; i: ByteIndex): ref Song
data: `[]`(l: SongList; i: ByteIndex): Immutable[ref Song]
data: `[]`[T: SomeData](t: var Table[T]; id: TableId): ref T
data: `[]`[T: SomeData](t: Table[T]; id: TableId): Immutable[ref T]
data: `[]`(t: Track; i: ByteIndex): TrackRow
data: `[]`(t: var Track; i: ByteIndex): var TrackRow
data: `[]`(t: TrackView; i: ByteIndex): TrackRow
ir: `[]`(op: Operation; flag: OperationSetting): uint8
add:
data: add(l: var SongList)
data: add(l: var SongList; song: ref Song)
data: add[T: SomeData](t: var Table[T]): TableId
data: add[T: SomeData](t: var Table[T]; id: TableId)
apucontrol: add(l: var ApuWriteList; regaddr, value: uint8)
apply:
engine: apply(apu: var ApuIo; op: ApuOperation; wt: WaveformTable)
Apu:
apu: Apu
ApuIo:
apuio: ApuIo
ApuOperation:
enginestate: ApuOperation
ApuRegister:
apuio: ApuRegister
ApuWrite:
apucontrol: ApuWrite
ApuWriteList:
apucontrol: ApuWriteList
ar10:
ApuRegister.ar10
ar11:
ApuRegister.ar11
ar12:
ApuRegister.ar12
ar13:
ApuRegister.ar13
ar14:
ApuRegister.ar14
ar21:
ApuRegister.ar21
ar22:
ApuRegister.ar22
ar23:
ApuRegister.ar23
ar24:
ApuRegister.ar24
ar30:
ApuRegister.ar30
ar31:
ApuRegister.ar31
ar32:
ApuRegister.ar32
ar33:
ApuRegister.ar33
ar34:
ApuRegister.ar34
ar41:
ApuRegister.ar41
ar42:
ApuRegister.ar42
ar43:
ApuRegister.ar43
ar44:
ApuRegister.ar44
ar50:
ApuRegister.ar50
ar51:
ApuRegister.ar51
ar52:
ApuRegister.ar52
arWaveram:
ApuRegister.arWaveram
availableSamples:
apu: availableSamples(a: Apu): int
batched:
wav: batched(config: WavConfig): seq[WavConfig]
begin:
ioblocks: begin(b: var InputBlock): BlockId
ioblocks: begin(b: var OutputBlock; blockId: BlockId)
BlockId:
ioblocks: BlockId
BlockSize:
ioblocks: BlockSize
ByteIndex:
common: ByteIndex
caCut:
ChannelAction.caCut
caNone:
ChannelAction.caNone
capacity:
data: capacity[T: SomeData](t: Table[T]): static[int]
caShutdown:
ChannelAction.caShutdown
caUpdate:
ChannelAction.caUpdate
ch1:
ChannelId.ch1
ch2:
ChannelId.ch2
ch3:
ChannelId.ch3
ch4:
ChannelId.ch4
ChannelAction:
enginestate: ChannelAction
channelFrequency:
apu: channelFrequency(a: Apu; chno: ChannelId): int
ChannelId:
common: ChannelId
channelMix:
apu: channelMix(a: Apu; chno: ChannelId): MixMode
ChannelState:
enginestate: ChannelState
ChannelUpdate:
enginestate: ChannelUpdate
channelVolume:
apu: channelVolume(a: Apu; chno: ChannelId): int
clamp:
editing: clamp(s: var PatternSelection; maxRows: ByteIndex)
clear:
synth: clear(s: var Synth)
clearChannel:
apucontrol: clearChannel(chno: ChannelId; writes: var ApuWriteList)
close:
wavwriter: close(w: var WavWriter): void
colEffectParamHi1:
TrackColumn.colEffectParamHi1
colEffectParamHi2:
TrackColumn.colEffectParamHi2
colEffectParamHi3:
TrackColumn.colEffectParamHi3
colEffectParamLo1:
TrackColumn.colEffectParamLo1
colEffectParamLo2:
TrackColumn.colEffectParamLo2
colEffectParamLo3:
TrackColumn.colEffectParamLo3
colEffectType1:
TrackColumn.colEffectType1
colEffectType2:
TrackColumn.colEffectType2
colEffectType3:
TrackColumn.colEffectType3
colInstrumentHi:
TrackColumn.colInstrumentHi
colInstrumentLo:
TrackColumn.colInstrumentLo
colNote:
TrackColumn.colNote
ColumnIter:
editing: ColumnIter
columnIter:
editing: columnIter(i: PatternIter; track: int): ColumnIter
columns:
editing: columns(i: ColumnIter): Slice[TrackSelect]
contains:
data: contains[T: SomeData](t: Table[T]; id: TableId): bool
editing: contains(s: PatternSelection; pos: PatternAnchor): bool
ir: contains(op: Operation; flag: OperationFlag): bool
currentFileMajor:
version: currentFileMajor
currentFileMinor:
version: currentFileMinor
currentFileSerial:
version: currentFileSerial
currentFrame:
engine: currentFrame(e: Engine): EngineFrame
currentNote:
engine: currentNote(e: Engine; chno: ChannelId): int
currentSong:
engine: currentSong(e: Engine): Immutable[ref Song]
currentState:
engine: currentState(e: Engine; chno: ChannelId): ChannelState
currentVersion:
version: currentVersion
currentVersionString:
version: currentVersionString
data:
data: data(o: Order): lent seq[OrderRow]
data: data(s: Sequence): lent seq[uint8]
data=:
data: data=(o: var Order; data: sink seq[OrderRow])
data: data=(s: var Sequence; data: sink seq[uint8])
deepEquals:
utils: deepEquals[T](a, b: ref T): bool
defaultInit:
utils: defaultInit(): untyped
defaultRpb:
data: defaultRpb
defaultRpm:
data: defaultRpm
defaultSpeed:
data: defaultSpeed
defaultTickrate:
data: defaultTickrate
defaultTrackSize:
data: defaultTrackSize
deserialize:
io: deserialize(i: var Instrument; stream: Stream): FormatResult
io: deserialize(m: var Module; stream: Stream): FormatResult
io: deserialize(s: var Song; stream: Stream): FormatResult
io: deserialize(w: var Waveform; stream: Stream): FormatResult
dkLoops:
DurationKind.dkLoops
dkSeconds:
DurationKind.dkSeconds
duplicate:
data: duplicate(l: var SongList; i: ByteIndex)
data: duplicate[T: SomeData](t: var Table[T]; id: TableId): TableId
Duration:
wav: Duration
DurationKind:
wav: DurationKind
editPattern:
data: editPattern(s: var Song; orderNo: ByteIndex; value, body: untyped): untyped
editTrack:
data: editTrack(s: var Song; ch: ChannelId; trackId: ByteIndex; value, body: untyped): untyped
Effect:
data: Effect
EffectColumns:
data: EffectColumns
EffectCounts:
data: EffectCounts
EffectIndex:
data: EffectIndex
effectNumber:
editing: effectNumber(column: TrackSelect): EffectIndex
EffectType:
data: EffectType
effectTypeShortensPattern:
data: effectTypeShortensPattern(et: EffectType): bool
Engine:
engine: Engine
EngineFrame:
enginestate: EngineFrame
EqRef:
utils: EqRef
estimateSpeed:
data: estimateSpeed(s: Song; tempo, framerate: float): Speed
etArpeggio:
EffectType.etArpeggio
etAutoPortamento:
EffectType.etAutoPortamento
etDelayedCut:
EffectType.etDelayedCut
etDelayedNote:
EffectType.etDelayedNote
etLock:
EffectType.etLock
etNoEffect:
EffectType.etNoEffect
etNoteSlideDown:
EffectType.etNoteSlideDown
etNoteSlideUp:
EffectType.etNoteSlideUp
etPatternGoto:
EffectType.etPatternGoto
etPatternHalt:
EffectType.etPatternHalt
etPatternSkip:
EffectType.etPatternSkip
etPitchDown:
EffectType.etPitchDown
etPitchUp:
EffectType.etPitchUp
etSetEnvelope:
EffectType.etSetEnvelope
etSetGlobalVolume:
EffectType.etSetGlobalVolume
etSetPanning:
EffectType.etSetPanning
etSetSweep:
EffectType.etSetSweep
etSetTempo:
EffectType.etSetTempo
etSetTimbre:
EffectType.etSetTimbre
etSfx:
EffectType.etSfx
etTuning:
EffectType.etTuning
etVibrato:
EffectType.etVibrato
etVibratoDelay:
EffectType.etVibratoDelay
exportWav:
wav: exportWav(module: Module; config: WavConfig)
fcmArpeggio:
FcMode.fcmArpeggio
fcmNone:
FcMode.fcmNone
fcmNoteSlide:
FcMode.fcmNoteSlide
FcMode:
enginecontrol: FcMode
fcmPitchSlide:
FcMode.fcmPitchSlide
fcmPortamento:
FcMode.fcmPortamento
finish:
ioblocks: finish(b: var OutputBlock)
forflagPresent:
ir: forflagPresent(op: Operation; flag: OperationFlag; body: untyped): untyped
FormatResult:
io: FormatResult
frCannotUpgrade:
FormatResult.frCannotUpgrade
freqArpeggio:
FrequencyMod.freqArpeggio
freqNoteDown:
FrequencyMod.freqNoteDown
freqNoteUp:
FrequencyMod.freqNoteUp
freqPitchDown:
FrequencyMod.freqPitchDown
freqPitchUp:
FrequencyMod.freqPitchUp
freqPortamento:
FrequencyMod.freqPortamento
FrequencyBounds:
enginecontrol: FrequencyBounds
FrequencyControl:
enginecontrol: FrequencyControl
FrequencyLookupFunc:
enginecontrol: FrequencyLookupFunc
FrequencyMod:
ir: FrequencyMod
frInvalidBlock:
FormatResult.frInvalidBlock
frInvalidChannel:
FormatResult.frInvalidChannel
frInvalidCount:
FormatResult.frInvalidCount
frInvalidDuplicateId:
FormatResult.frInvalidDuplicateId
frInvalidId:
FormatResult.frInvalidId
frInvalidRevision:
FormatResult.frInvalidRevision
frInvalidRowCount:
FormatResult.frInvalidRowCount
frInvalidRowNumber:
FormatResult.frInvalidRowNumber
frInvalidSignature:
FormatResult.frInvalidSignature
frInvalidSize:
FormatResult.frInvalidSize
frInvalidSpeed:
FormatResult.frInvalidSpeed
frInvalidTerminator:
FormatResult.frInvalidTerminator
frNone:
FormatResult.frNone
fromIr:
ir: fromIr(ir: TrackIr): Track
frReadError:
FormatResult.frReadError
frWriteError:
FormatResult.frWriteError
gbClockrate:
hardware: gbClockrate
gbVblank:
hardware: gbVblank
getLocked:
engine: getLocked(e: Engine): set[ChannelId]
getRow:
data: getRow(s: var Song; ch: ChannelId; order, row: ByteIndex): var TrackRow
data: getRow(s: Song; ch: ChannelId; order, row: ByteIndex): TrackRow
getSetting:
ir: getSetting(op: Operation; flag: OperationSetting): uint8
getTickrate:
data: getTickrate(m: Module; song: ByteIndex): Tickrate
getTrack:
data: getTrack(s: var Song; ch: ChannelId; order: ByteIndex): Track
getTrackEnvelope:
engine: getTrackEnvelope(e: Engine; chno: ChannelId): uint8
getTrackPanning:
engine: getTrackPanning(e: Engine; chno: ChannelId): uint8
getTrackTimbre:
engine: getTrackTimbre(e: Engine; chno: ChannelId): uint8
getTrackView:
data: getTrackView(s: Song; ch: ChannelId; order: ByteIndex): TrackView
getWrites:
apucontrol: getWrites(op: ApuOperation; wt: WaveformTable; nr51: uint8): ApuWriteList
GlobalState:
enginestate: GlobalState
halt:
engine: halt(e: var Engine)
enginecontrol: halt(r: var MusicRuntime; op: var ApuOperation)
hasColumn:
editing: hasColumn(i: ColumnIter; col: TrackSelect): bool
hasData:
editing: hasData(c: PatternClip): bool
hasWork:
wav: hasWork(ex: WavExporter): bool
hertz:
data: hertz(t: Tickrate): float
Immutable:
common: Immutable
InfoString:
data: InfoString
init:
apu: init(_: typedesc[Apu]; samplerate: int; framerate = 59.7): Apu
data: init(T: typedesc[Instrument]): Instrument
data: init(T: typedesc[Module]): Module
data: init(T: typedesc[Order]): Order
data: init(T: typedesc[SomeTable]): T.typeOf
data: init(T: typedesc[Song]): Song
data: init(T: typedesc[SongList]; len: PositiveByte = 1): SongList
data: init(T: typedesc[Track]; len: TrackLen): Track
data: init(T: typedesc[Track]; view: TrackView): Track
data: init(T: typedesc[TrackView]; track: sink Track): TrackView
data: init(T: typedesc[Waveform]): Waveform
editing: init(T: typedesc[PatternCursor]; row: int; track: int; column: TrackColumn): PatternCursor
editing: init(T: typedesc[PatternSelection]; a: PatternAnchor; b = a): PatternSelection
engine: init(_: typedesc[Engine]): Engine
wav: init(T: typedesc[WavConfig]): WavConfig
wav: init(T: typedesc[WavExporter]; module: Module; config: WavConfig): WavExporter
enginecontrol: init(T: typedesc[MusicRuntime]; song: sink Immutable[ref Song]; orderNo, rowNo: int; patternRepeat: bool): MusicRuntime
enginestate: init(_: typedesc[ChannelState]): ChannelState
enginestate: init(T: typedesc[GlobalState]): GlobalState
ioblocks: init(T: typedesc[InputBlock]; stream: Stream): InputBlock
ioblocks: init(T: typedesc[OutputBlock]; stream: Stream): OutputBlock
player: init(_: typedesc[Player]; framerate: float; seconds: Natural): Player
player: init(_: typedesc[Player]; song: Immutable[ref Song]; loops: Natural): Player
player: init(_: typedesc[Player]; frames: Natural): Player
synth: init(T: typedesc[Synth]; samplerate = 44100; buffersize: Natural = 0): T.typeOf
wavwriter: init(_: typedesc[WavWriter]; filename: sink string; channels, samplerate: int): WavWriter
InputBlock:
ioblocks: InputBlock
insert:
data: insert(o: var Order; data: openArray[OrderRow]; before: ByteIndex)
data: insert(o: var Order; row: OrderRow; before: ByteIndex = 0)
Instrument:
data: Instrument
InstrumentRuntime:
enginecontrol: InstrumentRuntime
InstrumentTable:
data: InstrumentTable
isEffect:
editing: isEffect(column: TrackSelect): bool
isEmpty:
data: isEmpty(row: TrackRow): bool
isFinished:
ioblocks: isFinished(b: InputBlock): bool
isHalted:
engine: isHalted(e: Engine): bool
isLocked:
engine: isLocked(e: Engine; chno: ChannelId): bool
isNil:
common: isNil[T](i: Immutable[[type node]]): bool
isNoop:
ir: isNoop(op: Operation): bool
isPlaying:
player: isPlaying(p: Player): bool
isValid:
data: isValid(t: Track): bool
data: isValid(t: TrackView): bool
editing: isValid(s: PatternSelection; rows: TrackLen): bool
items:
data: items(l: SongList): Immutable[ref Song]
data: items[T: SomeData](t: Table[T]): TableId
data: items(t: Track): TrackRow
data: items(t: TrackView): TrackRow
apucontrol: items(l: ApuWriteList): ApuWrite
iter:
editing: iter(s: PatternSelection): PatternIter
jump:
engine: jump(e: var Engine; pattern: Natural)
enginecontrol: jump(r: var MusicRuntime; pattern: Natural)
len:
data: len(o: Order): int
data: len(s: Sequence): int
data: len(l: SongList): Natural
data: len[T: SomeData](t: Table[T]): int
ir: len(ir: TrackIr): int
LittleEndian:
endian: LittleEndian
lock:
engine: lock(e: var Engine; chno: ChannelId)
enginecontrol: lock(r: var MusicRuntime; chno: ChannelId; op: var ApuOperation)
lookupNoiseNote:
notes: lookupNoiseNote(note: Natural): uint8
lookupToneNote:
notes: lookupToneNote(note: Natural): uint16
mitems:
data: mitems(l: var SongList): ref Song
data: mitems(t: var Track): var TrackRow
mix:
synth: mix(s: var Synth; mode: MixMode; delta: int8; cycletime: uint32)
synth: mix(s: var Synth; mode: static MixMode; delta: int8; cycletime: uint32)
mixDc:
synth: mixDc(s: var Synth; dcLeft, dcRight: PcmF32; cycletime: uint32)
mixLeft:
MixMode.mixLeft
mixMiddle:
MixMode.mixMiddle
MixMode:
common: MixMode
mixMute:
MixMode.mixMute
mixRight:
MixMode.mixRight
Module:
data: Module
ModulePiece:
data: ModulePiece
ModulePrivate:
data: ModulePrivate
moveDown:
data: moveDown(l: var SongList; i: ByteIndex)
moveTo:
editing: moveTo(s: var PatternSelection; pos: PatternAnchor)
moveUp:
data: moveUp(l: var SongList; i: ByteIndex)
MusicRuntime:
enginecontrol: MusicRuntime
naCut:
NoteAction.naCut
naOff:
NoteAction.naOff
naSustain:
NoteAction.naSustain
naTrigger:
NoteAction.naTrigger
new:
data: new(T: typedesc[Instrument]): ref Instrument
data: new(T: typedesc[Module]): ref Module
data: new(T: typedesc[Song]): ref Song
data: new(T: typedesc[Song]; song: Song): ref Song
data: new(T: typedesc[Waveform]): ref Waveform
next:
data: next[T: SomeData](t: Table[T]; start: TableId = 0): Option[TableId]
nextAvailableId:
data: nextAvailableId[T: SomeData](t: Table[T]): TableId
nextUnused:
data: nextUnused(o: Order): OrderRow
NoiseNote:
notes: NoiseNote
note:
notes: note(str: string): uint8
NoteAction:
enginecontrol: NoteAction
noteCut:
notes: noteCut
Operation:
ir: Operation
OperationFlag:
ir: OperationFlag
OperationSetting:
ir: OperationSetting
ops:
ir: ops(ir: TrackIr): tuple[rowno: int, op: Operation]
opsDelay:
OperationFlag.opsDelay
opsDuration:
OperationFlag.opsDuration
opsEnvelope:
OperationFlag.opsEnvelope
opsFreqMod:
OperationFlag.opsFreqMod
opsHalt:
OperationFlag.opsHalt
opsInstrument:
OperationFlag.opsInstrument
opsNote:
OperationFlag.opsNote
opsPanning:
OperationFlag.opsPanning
opsPatternCommand:
OperationFlag.opsPatternCommand
opsShouldLock:
OperationFlag.opsShouldLock
opsSpeed:
OperationFlag.opsSpeed
opsSweep:
OperationFlag.opsSweep
opsTimbre:
OperationFlag.opsTimbre
opsTune:
OperationFlag.opsTune
opsVibrato:
OperationFlag.opsVibrato
opsVibratoDelay:
OperationFlag.opsVibratoDelay
opsVolume:
OperationFlag.opsVolume
Order:
data: Order
OrderId:
data: OrderId
OrderRow:
data: OrderRow
OrderSize:
data: OrderSize
OutputBlock:
ioblocks: OutputBlock
pansLeft:
common: pansLeft(mode: MixMode): bool
pansRight:
common: pansRight(mode: MixMode): bool
parseSequence:
data: parseSequence(str: string; minVal = int8.low; maxVal = int8.high): Sequence
parseWave:
data: parseWave(str: string): WaveData
paste:
editing: paste(c: PatternClip; song: var Song; order: ByteIndex; pos: PatternCursor; mix = false)
PatternAnchor:
editing: PatternAnchor
PatternClip:
editing: PatternClip
PatternCommand:
ir: PatternCommand
PatternCursor:
editing: PatternCursor
PatternIter:
editing: PatternIter
patternLen:
data: patternLen(s: Song; order: ByteIndex): Natural
PatternSelection:
editing: PatternSelection
PatternVisit:
ir: PatternVisit
pcJump:
PatternCommand.pcJump
Pcm:
common: Pcm
PcmF32:
common: PcmF32
pcNext:
PatternCommand.pcNext
pcNone:
PatternCommand.pcNone
play:
engine: play(e: var Engine; song: sink Immutable[ref Song]; pattern, row: Natural = 0)
player: play(p: var Player; engine: var Engine; instruments: InstrumentTable; body: untyped): untyped
Player:
player: Player
PositiveByte:
common: PositiveByte
process:
wav: process(ex: var WavExporter; module: Module)
progress:
wav: progress(ex: WavExporter): int
player: progress(p: Player): int
progressMax:
wav: progressMax(ex: WavExporter): int
player: progressMax(p: Player): int
ptrArith:
ptrarith: ptrArith(body: untyped)
queryInstrument:
data: queryInstrument(row: TrackRow): Option[uint8]
queryNote:
data: queryNote(row: TrackRow): Option[uint8]
read:
ioblocks: read[T](b: var InputBlock; buf: var openArray[T]): bool
ioblocks: read[T: not openArray](b: var InputBlock; val: var T): bool
readData:
ioblocks: readData(b: var InputBlock; data: pointer; size: Natural): bool
readRegister:
apu: readRegister(a: var Apu; reg: uint8): uint8
remove:
data: remove(o: var Order; index: ByteIndex; count: OrderSize = 1)
data: remove(l: var SongList; i: ByteIndex)
data: remove[T: SomeData](t: var Table[T]; id: TableId)
removeAllTracks:
data: removeAllTracks(s: var Song)
removeSamples:
apu: removeSamples(a: var Apu)
reset:
apu: reset(a: var Apu)
engine: reset(e: var Engine)
restore:
editing: restore(c: PatternClip; song: var Song; order: ByteIndex)
revisionMajor:
data: revisionMajor(m: Module): int
revisionMinor:
data: revisionMinor(m: Module): int
rikOp:
RowIrKind.rikOp
rikRest:
RowIrKind.rikRest
rNR10:
hardware: rNR10
rNR11:
hardware: rNR11
rNR12:
hardware: rNR12
rNR13:
hardware: rNR13
rNR14:
hardware: rNR14
rNR21:
hardware: rNR21
rNR22:
hardware: rNR22
rNR23:
hardware: rNR23
rNR24:
hardware: rNR24
rNR30:
hardware: rNR30
rNR31:
hardware: rNR31
rNR32:
hardware: rNR32
rNR33:
hardware: rNR33
rNR34:
hardware: rNR34
rNR41:
hardware: rNR41
rNR42:
hardware: rNR42
rNR43:
hardware: rNR43
rNR44:
hardware: rNR44
rNR50:
hardware: rNR50
rNR51:
hardware: rNR51
rNR52:
hardware: rNR52
RowIr:
ir: RowIr
RowIrKind:
ir: RowIrKind
rows:
editing: rows(i: PatternIter): Slice[int]
run:
apu: run(a: var Apu; cycles: uint32)
runToFrame:
apu: runToFrame(a: var Apu)
rWAVERAM:
hardware: rWAVERAM
samplerate:
synth: samplerate(s: Synth): int
samplerate=:
synth: samplerate=(s: var Synth; samplerate: int)
sampletime:
synth: sampletime(s: Synth; cycletime: uint32): float32
save:
editing: save(c: var PatternClip; song: Song; order: ByteIndex; region: PatternSelection)
selection:
editing: selection(c: PatternClip): PatternSelection
selEffect1:
TrackSelect.selEffect1
selEffect2:
TrackSelect.selEffect2
selEffect3:
TrackSelect.selEffect3
selInstrument:
TrackSelect.selInstrument
selNote:
TrackSelect.selNote
Sequence:
data: Sequence
SequenceInput:
enginecontrol: SequenceInput
SequenceKind:
data: SequenceKind
SequenceSize:
data: SequenceSize
serialize:
io: serialize(i: Instrument; stream: Stream): FormatResult
io: serialize(m: Module; stream: Stream): FormatResult
io: serialize(s: Song; stream: Stream): FormatResult
io: serialize(w: Waveform; stream: Stream): FormatResult
setBufferSize:
apu: setBufferSize(a: var Apu; samples: int)
synth: setBufferSize(s: var Synth; samples: Natural)
setEffect:
data: setEffect(t: var Track; i: ByteIndex; effectNo: EffectIndex; et: EffectType; param = 0'u8)
setEffectParam:
data: setEffectParam(t: var Track; i: ByteIndex; effectNo: EffectIndex; param: uint8)
setEffectType:
data: setEffectType(t: var Track; i: ByteIndex; effectNo: EffectIndex; et: EffectType)
setFramerate:
apu: setFramerate(a: var Apu; framerate: float)
setFromIr:
ir: setFromIr(track: var Track; ir: TrackIr)
setInstrument:
data: setInstrument(t: var Track; i: ByteIndex; instrument: TableId)
setLen:
data: setLen(o: var Order; len: OrderSize)
data: setLen(s: var Sequence; len: SequenceSize)
setNote:
data: setNote(t: var Track; i: ByteIndex; note: uint8)
setSamplerate:
apu: setSamplerate(a: var Apu; samplerate: int)
setTrack:
data: setTrack(s: var Song; ch: ChannelId; order: ByteIndex; track: sink Track)
setup:
engine: setup(apu: var ApuIo)
setVolume:
apu: setVolume(a: var Apu; gain: range[0.0'f32 .. 1.0'f32])
size:
ioblocks: size(ib: InputBlock): int
skArp:
SequenceKind.skArp
skEnvelope:
SequenceKind.skEnvelope
skPanning:
SequenceKind.skPanning
skPitch:
SequenceKind.skPitch
skTimbre:
SequenceKind.skTimbre
SomeData:
data: SomeData
SomeTable:
data: SomeTable
SomeTrack:
data: SomeTrack
SomeWord:
endian: SomeWord
Song:
data: Song
SongList:
data: SongList
SongPath:
ir: SongPath
Speed:
data: Speed
speedToFloat:
data: speedToFloat(speed: Speed): float
speedToTempo:
data: speedToTempo(speed: float; rowsPerBeat: PositiveByte; framerate: float): float
step:
engine: step(e: var Engine; itable: InstrumentTable)
enginecontrol: step(r: var MusicRuntime; itable: InstrumentTable; frame: var EngineFrame; op: var ApuOperation): bool
player: step(p: var Player; engine: var Engine; instruments: InstrumentTable): bool
stepAndApply:
engine: stepAndApply(e: var Engine; itable: InstrumentTable; wtable: WaveformTable; apu: var ApuIo)
swap:
data: swap(o: var Order; i1, i2: ByteIndex)
Synth:
synth: Synth
System:
data: System
systemCustom:
System.systemCustom
systemDmg:
System.systemDmg
systemSgb:
System.systemSgb
TableId:
data: TableId
takeOperation:
engine: takeOperation(e: var Engine): ApuOperation
takeSamples:
apu: takeSamples(a: var Apu; buf: var seq[Pcm])
synth: takeSamples(s: var Synth; endtime: uint32; buf: ptr seq[Pcm])
tempo:
data: tempo(s: Song; framerate: float): float
Tickrate:
data: Tickrate
time:
apu: time(a: Apu): uint32
Timer:
enginecontrol: Timer
toAddress:
apuio: toAddress(reg: ApuRegister): uint8
toAnchor:
editing: toAnchor(c: PatternCursor): PatternAnchor
toBlockId:
ioblocks: toBlockId(str: string): BlockId
toEffectType:
data: toEffectType(x: uint8): EffectType
ir: toEffectType(x: FrequencyMod): EffectType
ir: toEffectType(x: PatternCommand): EffectType
toEqRef:
utils: toEqRef[T](val: ref T): EqRef[T]
toImmutable:
common: toImmutable[T](s: T): Immutable[T]
toInfoString:
data: toInfoString(str: string): InfoString
toIr:
ir: toIr(t: TrackView): TrackIr
toLE:
endian: toLE[T: SomeWord](val: T): LittleEndian[T]
toNE:
endian: toNE[T: SomeWord](val: LittleEndian[T]): T
ToneNote:
notes: ToneNote
toOperation:
ir: toOperation(row: TrackRow): Operation
totalRows:
data: totalRows(t: Track): int
data: totalRows(t: TrackView): int
totalTracks:
data: totalTracks(s: Song): int
Track:
data: Track
TrackColumn:
editing: TrackColumn
TrackControl:
enginecontrol: TrackControl
TrackId:
data: TrackId
trackIds:
data: trackIds(s: Song; ch: ChannelId): ByteIndex
TrackIr:
ir: TrackIr
TrackLen:
data: TrackLen
TrackRow:
data: TrackRow
tracks:
editing: tracks(i: PatternIter): Slice[int]
TrackSelect:
editing: TrackSelect
TrackView:
data: TrackView
translate:
editing: translate(s: var PatternSelection; rows: int)
ufAll:
enginestate: ufAll
ufEnvelope:
UpdateFlag.ufEnvelope
ufFrequency:
UpdateFlag.ufFrequency
ufPanning:
UpdateFlag.ufPanning
ufTimbre:
UpdateFlag.ufTimbre
unitSpeed:
data: unitSpeed
unlock:
engine: unlock(e: var Engine; chno: ChannelId)
enginecontrol: unlock(r: var MusicRuntime; chno: ChannelId; op: var ApuOperation)
UpdateFlag:
enginestate: UpdateFlag
UpdateFlags:
enginestate: UpdateFlags
version:
data: version(m: Module): Version
Version:
version: Version
viewPattern:
data: viewPattern(s: Song; orderNo: ByteIndex; value, body: untyped): untyped
viewTrack:
data: viewTrack(s: Song; ch: ChannelId; trackId: ByteIndex; value, body: untyped): untyped
WavConfig:
wav: WavConfig
WaveData:
data: WaveData
wavedata:
data: wavedata(t: WaveformTable; id: TableId): WaveData
Waveform:
data: Waveform
WaveformTable:
data: WaveformTable
WavExporter:
wav: WavExporter
WavWriter:
wavwriter: WavWriter
willCorrect:
endian: willCorrect
write:
ioblocks: write[T](b: var OutputBlock; data: openArray[T])
ioblocks: write[T: not openArray](b: var OutputBlock; data: T)
wavwriter: write(w: var WavWriter; data: openArray[PcmF32])
writeData:
ioblocks: writeData(b: var OutputBlock; data: pointer; size: Natural)
writeRegister:
apu: writeRegister(a: var Apu; reg, value: uint8)