furnace

furnace copied to clipboard

Add ADSR macro mode in where the values are generated by an ADSR envelope with the following parameters:

• Level
• Delay
• Attack
• Hold
• Decay
• Sustain
• Hold 2
• Decay 2
• Release

Add LFO macro mode with the following parameters:

• Bottom level
• Top level
• Speed
• Waveform (sine, triangle, saw or square)
• Loop
• Global?

A suggestion: maybe make the LFO and ADSR modes non-mutually-exclusive.

Something like two simultaneous option categories:

ADSR
* Delay
* Level
* Attack
* Hold
* Decay
* Sustain
* Hold 2
* Decay 2
* Release
* Inverted (((another idea; see explanation below)))
* Loop (((to get closer to a general-purpose SSG-EG)))

LFO
* Delay (((delays on an LFO are also useful)))
* Bottom level
* Top level
* Speed
* Waveform (sine, triangle, saw or square)
* Loop
* Global? (((I don't know what this means so I can't comment on it)))

The math for combining the ADSR and the LFO is probably doing something similar to multiplying/averaging the values but don't quote me on that

An explanation for Inverted (boolean): if it's true, the envelope works "upside down", with the attack going from top to bottom, and the decay going from bottom to top.

And, just for confirmation: when processing this into macro values, the amount of values per second is the same as the tick rate, right? It would be cool to add, on the top of the graphical representation of the LFO/Envelope (white), a series of rectangles (yellow) to show the values that will be set, depending on the tick rate (the higher the tick rate, the thinner the rectangles).

And another idea (and I don't even think it's very good but I still wanna write about it, sorry not sorry): instead of having multiple holds and decays on the envelope, structure it as a series of points, kinda like a feature ZynAddSubFX has (I don't know how that would look in furnace's UI, though).

For example: this insane graph here could be represented as something like (with the letters being the height of each point):

Initial Value: A

[Point 1]
Time from last: 0.2s
Value: B

[Point 2]
Time from last: 1s
Value: C

[Point 3]
Time from last: 0.2s
Value: D

[Point 4]
Time from last: 0.2s
Value: E
Loop back to: Point 3

[Point 5] (((since it's after the loop point it's assumed to go here after release)))
Value: [Release]
Time to end: 0.5s

By the way: the "loop back to" could also maybe be Point 4 itself and, in that case, it'd be a sustain point.

This isn't a very valuable idea, since complex envelopes are pretty rare and combining an LFO with an Envelope already helps a lot with that, but here's it in case it ever becomes relevant.

Implemented.

Will not implement ADSR+LFO yet, taking possibility of hardware playback into consideration (don't want to add too much complexity since one mult is slow already).