Class Pattern<T>

Namespace

Sigil.Sound

Assembly

Sigil.Sound.Notes.dll

Values arranged in cycle time, as a question you can ask of any stretch of time: "what happens between 3 and 4.5?". Because it is a function and not a stored list, Fast, Rev, Every and friends compose freely and a pattern can run forever or change from cycle to cycle. Build one with Sigil.Sound.Pat or Sigil.Sound.Mini (Mini.Notes("c3 [e3 g3]*2 ~ <b3 d4>")), reshape it with the methods on Sigil.Sound.PatternExtensions.

public sealed class Pattern<T>

Type Parameters

T

What happens at each event: a Sigil.Sound.Note, a number to drive a parameter, anything.

Inheritance

object

Pattern<T>

Inherited Members

object.Equals(object?)

object.Equals(object?, object?)

object.GetHashCode()

object.GetType()

object.ReferenceEquals(object?, object?)

object.ToString()

Extension Methods

PatternExtensions.Degrade<T>(Pattern<T>, double, int)

PatternExtensions.Euclid<T>(Pattern<T>, int, int, int)

PatternExtensions.Every<T>(Pattern<T>, int, Func<Pattern<T>, Pattern<T>>)

PatternExtensions.Fast<T>(Pattern<T>, Fraction)

PatternExtensions.Fast<T>(Pattern<T>, int)

PatternExtensions.Fast<T>(Pattern<T>, double)

PatternExtensions.Rev<T>(Pattern<T>)

PatternExtensions.Select<T, TResult>(Pattern<T>, Func<T, TResult>)

PatternExtensions.SelectMany<T, TResult>(Pattern<T>, Func<T, IReadOnlyList<TResult>>)

PatternExtensions.Shift<T>(Pattern<T>, Fraction)

PatternExtensions.Shift<T>(Pattern<T>, double)

PatternExtensions.Slow<T>(Pattern<T>, Fraction)

PatternExtensions.Slow<T>(Pattern<T>, int)

PatternExtensions.Slow<T>(Pattern<T>, double)

PatternExtensions.Sometimes<T>(Pattern<T>, double, Func<Pattern<T>, Pattern<T>>, int)

PatternExtensions.Where<T>(Pattern<T>, Func<T, bool>)

Remarks

Time is in cycles, not beats or seconds: cycle 0 is [0, 1), cycle 1 is [1, 2). How long a cycle lasts is up to whatever plays the pattern (Sigil.Sound.Pat.BeatsPerCycle beats when converted with ToPattern). Queries fill a list you own, so asking again with the same list allocates nothing once it has grown.

Methods

Cycle(long)

The events of one cycle, in a new list. Convenient for tests and tools; real-time code should call Sigil.Sound.Pattern`1.Query(Sigil.Sound.Arc,System.Collections.Generic.List{Sigil.Sound.PatternEvent{`0}}).

public List<PatternEvent<T>> Cycle(long cycle)

Parameters

cycle long

Returns

List<PatternEvent<T>>

Query(Arc, List<PatternEvent<T>>)

Adds the events that touch arc to output, ordered by when they start. The list is not cleared first. An event that straddles the end of the arc comes back cut to the arc (see Sigil.Sound.PatternEvent`1.Part); check Sigil.Sound.PatternEvent`1.HasOnset to play only those that start in it.

public void Query(Arc arc, List<PatternEvent<T>> output)

Parameters

arc Arc

output List<PatternEvent<T>>

Validate(int)

Asks the pattern for its first cycles cycles and throws if that fails, so a pattern that cannot be played (too many events a cycle, or nested too deeply) is refused when it is built and not found out while audio is running. Sigil.Sound.Pat.MaxEvents is the limit. Playing a pattern checks it for you; this is for code that consumes one itself.

public void Validate(int cycles = 64)

Parameters

cycles int

How many cycles to check, counting from cycle 0.

Exceptions

InvalidOperationException

The pattern is too dense or too deeply nested.