GenD is wave space (extension for wave terrain) based generator.

Some parameters description:

• GLIDE describes the speed of sliding to next note.
• PGLIDE describes the speed of sliding to desired pitch.
• #-LFO-RoN - Decides whether LFO should reset phase on new note or not
• Radius Link - Decides whether Radius modulation should be equal to volume modulation (G-ADSR & G-LFO) or it's own modulators (R-ADSR & R-LFO)

Used units guide:

• ADSR time units - tick - Length of parts in ticks
• ADSR volume unit - % - Percent of maximum volume level
• G-LFO volume unit - % - Percent of maximum volume level multiplied with sound volume (for example G-LFO-V=0% => Volume doesn't oscilate, is equal to max, G-LFO-V=100% => volume oscilates between 0 and 2*max)
• R-LFO volume unit - % - Percent of maximum amplification of radius oscilator (for example R-LFO-V=0% => Volume doesn't oscilate, is equal to max, G-LFO-V=100% => volume oscilates between 0.5*max and 1.5*max)
• LFO frequency unit - CpT - Cycles per tick
• #OrbSpeed - CpMC - Cycles per main cycle (relative to 'note wave length' length of orbital wave)
• #Shift units - deg - Degrees, 0-360
• BRadius units - deg - Degrees, 0-180
• #Scale units - % - Percent of maximum equal to 360 degrees
• LFO-RP - deg - Reset phase (when RoN is on)

Attribute MIDI/pattern NOTE OFF ACTION tells machine what to do, if NoteOff event happened (either from Midi or from Pattern):

• 0. Does nothing. Just plays note as long, as ADSR is set to.
• 1. If Decay wasn't performing yet, jumps to Decay sequence.
• 2. If Sustain wasn't performed yet, jumps to Sustain sequence.
• 3. If Release wasn't performed yet, jumps to Release sequence.
• 4. Default. Just cuts the note with 'note off' command.

Wave types:

Simple
• Sine -
• Saw -
• Triangle -
• Square -
• Octagon -
• FastSine -
  This is approximation of sine, so it's not so smooth as normal sine, but is a little faster.

Few words about technology:

• There's an abstract 3D space of functions.
• In this space we select a point (XShift,YShift,ZShift).
• Then we select a box with center in that point, and edges equal to (XScale,YScale,ZScale)*BRadius.
• In this box we run 3 independent oscilators characterised by parameters (#OrbitType,#OrbitSpeed,#OrbShift).
• In this way we have a point flying/oscilating in this box around selected point with certain way.
• Then we got series of arguments (X,Y,Z) that we throw into another oscilators (#Osc) and we get final series of arguments (mX,mY,mZ).
• In last stage we are mixing (mX,mY,mZ) to get one "Mix" value. This is done in few ways:
  0. avg - average (mX+mY+mZ)
  1. mult - multiplication (mX*mY*mZ)
  2. max - select maximum among mX,mY,mZ
  3. min - select minimum among mX,mY,mZ
  4. med - select median among mX,mY,mZ
  5. xy+z - ((mX*mY)+mZ)
  6. x+yz - (mX+(mY*mZ))
  7. zx+y - ((mZ*mX)+mY)
  8. avg-quads - (mX²+mY²+mZ²) (saves sign to fight dc offset)
  9. quad-avg-q - (mX²)+mY²+mZ²)² (saves sign to fight dc offset)
  10. avg-mults - (mX*mY+mY*mZ+mZ*mX)
  11. (x>y)?(z):(-z) - if mX is higher than mY, mZ is choosen, otherwise -mZ
  12. (y>z)?(x):(-x) - if mY is higher than mZ, mX is choosen, otherwise -mX
  13. (z>x)?(y):(-y) - if mZ is higher than mX, mY is choosen, otherwise -mY
  14. (x>y)?(x*z):(y*z) - if mX is higher than mY, output is mX*mZ, otherwise mY*mZ
  15. (y>z)?(y*x):(z*x) - if mY is higher than mZ, output is mY*mX, otherwise mZ*mX
  16. (z>x)?(z*y):(x*y) - if mZ is higher than mX, output is mZ*mY, otherwise mX*mY

Here are few images that should help in understanding how machine works:

Few notes:

• In 1.23 fixed adsr timing bug, made some optimalisation and added few mix-modes.
• I've tried to rid of the eventual denormalisation issue with P4 cpus.
• GenD comes in two versions - with inertia (GenD) and without (GenD NI). Version without inertia is 1/3 faster, but the sound quality is worse.
• Since v.1.2. Glide is not reversed and is logarythmic, auto-volume-finder removed as it was causing highs to be louder than lows. Also wavetable was added, but unfortunately it doesn't seem to speed up calculations (you can check it out in attributes: SynthMode(0=math,1=wavetable), Interpolation(0=nearest,1=linear).
• Since machine relies only on my 'lazy' code, it is extremely slow! (On Athlon1700 one channel consumes 15-20% of CPU power). By 'lazy' code I mean that it is rather written to be easy to use and flexible, than to be ultra-fast. For example - all the parameters are classes in which I've implemented inertia, so every parameter is geometrically inertialised - it makes all changes very smooth.

Kozaluss Angeluss (also Kozaki Soft) at http://www.kozaluss.z.pl/