├── HelpSource ├── Classes │ ├── PBPZ2.schelp │ ├── PBRZ2.schelp │ ├── PBlip.schelp │ ├── PChanged.schelp │ ├── PClip.schelp │ ├── PClipNoise.schelp │ ├── PCombN.schelp │ ├── PCuspN.schelp │ ├── PDC.schelp │ ├── PDelay1.schelp │ ├── PDelay2.schelp │ ├── PDelayN.schelp │ ├── PDust.schelp │ ├── PDust2.schelp │ ├── PExpRand.schelp │ ├── PFBSineN.schelp │ ├── PFSinOsc.schelp │ ├── PFold.schelp │ ├── PGate.schelp │ ├── PGbmanN.schelp │ ├── PHPZ1.schelp │ ├── PHPZ2.schelp │ ├── PHasher.schelp │ ├── PHenonN.schelp │ ├── PIRand.schelp │ ├── PImpulse.schelp │ ├── PInRange.schelp │ ├── PInRect.schelp │ ├── PIntegrator.schelp │ ├── PLFClipNoise.schelp │ ├── PLFNoise0.schelp │ ├── PLFNoise1.schelp │ ├── PLFNoise2.schelp │ ├── PLFPulse.schelp │ ├── PLFSaw.schelp │ ├── PLFTri.schelp │ ├── PLPZ1.schelp │ ├── PLPZ2.schelp │ ├── PLastValue.schelp │ ├── PLatch.schelp │ ├── PLatoocarfianN.schelp │ ├── PLinCongN.schelp │ ├── PLinExp.schelp │ ├── PLinLin.schelp │ ├── PLine.schelp │ ├── PLorenzN.schelp │ ├── PMantissaMask.schelp │ ├── PMouseButton.schelp │ ├── PMouseX.schelp │ ├── PMouseY.schelp │ ├── POnePole.schelp │ ├── POneZero.schelp │ ├── PPeak.schelp │ ├── PPulse.schelp │ ├── PPulseCount.schelp │ ├── PQuadN.schelp │ ├── PRand.schelp │ ├── PRunningMax.schelp │ ├── PRunningMin.schelp │ ├── PSaw.schelp │ ├── PSchmidt.schelp │ ├── PSilent.schelp │ ├── PSinOsc.schelp │ ├── PStandardN.schelp │ ├── PTDelay.schelp │ ├── PToggleFF.schelp │ ├── PTrig.schelp │ ├── PTrig1.schelp │ ├── PWhiteNoise.schelp │ ├── PWrap.schelp │ └── PXLine.schelp └── Overviews │ └── UGenPatterns.schelp ├── PChaos.sc ├── PDelays.sc ├── PFSinOsc.sc ├── PFilter.sc ├── PLine.sc ├── PNoise.sc ├── POsc.sc ├── PTrig.sc ├── README.md ├── UGenPatterns.quark ├── osx └── scide_scapp │ └── PMacUGens.sc └── scide_scqt └── PMacUGens.sc /HelpSource/Classes/PBPZ2.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PBPZ2 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/BPZ2:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: mul 16 | 17 | ARGUMENT:: add 18 | 19 | EXAMPLES:: 20 | 21 | CODE:: 22 | s.boot; 23 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PBPZ2(Pseq([12, 0, 0, 0, 0, 3, 0, 0, 0, 0], inf)).trace+50).play 24 | a.stop 25 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PBPZ2(PImpulse(8), PSaw(64)).trace).play 26 | a.stop 27 | :: 28 | -------------------------------------------------------------------------------- /HelpSource/Classes/PBRZ2.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PBRZ2 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/BRZ2:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: mul 16 | 17 | ARGUMENT:: add 18 | 19 | EXAMPLES:: 20 | 21 | CODE:: 22 | s.boot; 23 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PBRZ2(Pseq([12, 0, 0, 0, 0, 3, 0, 0, 0, 0], inf)).trace+50).play 24 | a.stop 25 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PBRZ2(PImpulse(8), PSaw(64)).trace).play 26 | a.stop 27 | :: 28 | -------------------------------------------------------------------------------- /HelpSource/Classes/PBlip.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PBlip 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Blip:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: freq 14 | 15 | ARGUMENT:: numharm 16 | 17 | ARGUMENT:: mul 18 | 19 | ARGUMENT:: add 20 | 21 | ARGUMENT:: length 22 | Number of values produced. 23 | 24 | EXAMPLES:: 25 | 26 | CODE:: 27 | s.boot; 28 | {Blip.ar(10, 3)}.plot(0.1) 29 | a= Pbind(\dur, 0.1, \midinote, PBlip(10, 3, 10, 70).trace).play 30 | a.stop 31 | a= Pbind(\dur, 0.1, \midinote, PBlip(PLine(100, 1, 100).trace, 3, 10, 70)).play 32 | a.stop 33 | a= Pbind(\dur, 0.1, \midinote, PBlip(10, PLine(100, 1, 100).trace, 10, 70)).play 34 | a.stop 35 | :: 36 | -------------------------------------------------------------------------------- /HelpSource/Classes/PChanged.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PChanged 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Changed:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: threshold 16 | 17 | ARGUMENT:: mul 18 | 19 | ARGUMENT:: add 20 | 21 | EXAMPLES:: 22 | 23 | CODE:: 24 | s.boot; 25 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PChanged(Pseq([12, 0, 0, 0, 0, 3, 0, 0, 0, 0], inf)).trace+60).play 26 | a.stop 27 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PChanged(PWhiteNoise(10).trace, 3)).play 28 | a.stop 29 | :: 30 | -------------------------------------------------------------------------------- /HelpSource/Classes/PClip.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PClip 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Clip:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: lo 16 | 17 | ARGUMENT:: hi 18 | 19 | EXAMPLES:: 20 | 21 | CODE:: 22 | s.boot; 23 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PClip(Pseq([0, 2, 4, 5], inf), 2, 4).trace*5+50).play 24 | a.stop 25 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PClip(PSinOsc(16), 0.5, 1).trace*0.5).play 26 | a.stop 27 | :: 28 | -------------------------------------------------------------------------------- /HelpSource/Classes/PClipNoise.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PClipNoise 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/ClipNoise:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: mul 14 | 15 | ARGUMENT:: add 16 | 17 | ARGUMENT:: length 18 | Number of values produced. 19 | 20 | EXAMPLES:: 21 | 22 | CODE:: 23 | s.boot; 24 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PClipNoise(10, 60).trace).play 25 | a.stop 26 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PClipNoise(0.25, 0.25).trace).play 27 | a.stop 28 | :: 29 | -------------------------------------------------------------------------------- /HelpSource/Classes/PCombN.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PCombN 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/CombN:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: maxdelaytime 16 | Fixed. 17 | 18 | ARGUMENT:: delaytime 19 | 20 | ARGUMENT:: decaytime 21 | Differs from CombN. Here feedback factor. 22 | 23 | ARGUMENT:: mul 24 | 25 | ARGUMENT:: add 26 | 27 | EXAMPLES:: 28 | 29 | CODE:: 30 | s.boot; 31 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PCombN(Pseq([12, 0, 0, 0, 0, 0, 0, 0, 0, 0], inf), 3, 3, 0.5).trace+50).play 32 | a.stop 33 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PCombN(PImpulse(16), 2, 2, 0.25).trace).play 34 | a.stop 35 | :: 36 | -------------------------------------------------------------------------------- /HelpSource/Classes/PCuspN.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PCuspN 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Cusp Map. 8 | 9 | Based on link::Classes/CuspN:: 10 | 11 | CLASSMETHODS:: 12 | 13 | METHOD:: new 14 | 15 | ARGUMENT:: freq 16 | 17 | ARGUMENT:: a 18 | 19 | ARGUMENT:: b 20 | 21 | ARGUMENT:: xi 22 | initial value 23 | 24 | ARGUMENT:: mul 25 | 26 | ARGUMENT:: add 27 | 28 | ARGUMENT:: length 29 | Number of values produced. 30 | 31 | EXAMPLES:: 32 | 33 | CODE:: 34 | s.boot; 35 | {CuspN.ar(1000)}.plot(0.1); 36 | PCuspN(1).asStream.nextN(100).plot; //similar 37 | 38 | PCuspN(1, 2, 1.8).asStream.nextN(100).plot; 39 | a= Pbind(\dur, 0.1, \midinote, PCuspN(1, 2, 1.8, mul:6, add:60)).play 40 | a.stop 41 | :: 42 | -------------------------------------------------------------------------------- /HelpSource/Classes/PDC.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PDC 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/DC:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: in 14 | dc value 15 | 16 | ARGUMENT:: length 17 | Number of values produced. 18 | 19 | EXAMPLES:: 20 | 21 | CODE:: 22 | s.boot; 23 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PDC(60).trace).play 24 | a.stop 25 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PDC(0.2).trace).play 26 | a.stop 27 | :: 28 | -------------------------------------------------------------------------------- /HelpSource/Classes/PDelay1.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PDelay1 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Delay1:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: mul 16 | 17 | ARGUMENT:: add 18 | 19 | EXAMPLES:: 20 | 21 | CODE:: 22 | s.boot; 23 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PDelay1(Pseq([0, 2, 4, 5], inf), 2, 4).trace+50).play 24 | a.stop 25 | a= Pbind(\dur, 1/6, \legato, 0.2, \abc, Pseq([3, 2, 2, 0, 2, 2, 2], inf), \degree, Pkey(\abc), \amp, PDelay1(Pkey(\abc), 0.25).trace).play 26 | a.stop 27 | :: 28 | -------------------------------------------------------------------------------- /HelpSource/Classes/PDelay2.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PDelay2 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Delay2:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: mul 16 | 17 | ARGUMENT:: add 18 | 19 | EXAMPLES:: 20 | 21 | CODE:: 22 | s.boot; 23 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PDelay2(Pseq([0, 2, 4, 5], inf), 2, 4).trace+50).play 24 | a.stop 25 | a= Pbind(\dur, 1/6, \legato, 0.2, \abc, Pseq([3, 2, 2, 0, 2, 2, 2], inf), \degree, Pkey(\abc), \amp, PDelay2(Pkey(\abc), 0.25).trace).play 26 | a.stop 27 | :: 28 | -------------------------------------------------------------------------------- /HelpSource/Classes/PDelayN.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PDelayN 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/DelayN:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: maxdelaytime 16 | Fixed. 17 | 18 | ARGUMENT:: delaytime 19 | 20 | ARGUMENT:: mul 21 | 22 | ARGUMENT:: add 23 | 24 | EXAMPLES:: 25 | 26 | CODE:: 27 | s.boot; 28 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PDelayN(Pseq([1, 2, 4, 5], inf), 3, 3).trace+50).play 29 | a.stop 30 | a= Pbind(\dur, 1/6, \legato, 0.2, \abc, Pseq([3, 2, 2, 0, 2, 2, 2], inf), \degree, Pkey(\abc), \amp, PDelayN(Pkey(\abc), 3, 3, 0.25).trace).play 31 | a.stop 32 | 33 | ( 34 | Ppar([ 35 | Pbind(\degree, Pseq([5, 4, 3, 2, 1, 0], inf)), 36 | Pbind(\degree, PDelayN(Pseq([0, -4, -2, -1], inf), 3, 3).trace), 37 | ]).play; 38 | ) 39 | :: 40 | -------------------------------------------------------------------------------- /HelpSource/Classes/PDust.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PDust 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Dust:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: density 14 | 15 | ARGUMENT:: mul 16 | 17 | ARGUMENT:: add 18 | 19 | ARGUMENT:: length 20 | Number of values produced. 21 | 22 | EXAMPLES:: 23 | 24 | CODE:: 25 | {Dust.ar(1000)}.plot(0.1); 26 | PDust(10).asStream.nextN(100).plot; //similar 27 | :: 28 | -------------------------------------------------------------------------------- /HelpSource/Classes/PDust2.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PDust2 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Dust2:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: density 14 | 15 | ARGUMENT:: mul 16 | 17 | ARGUMENT:: add 18 | 19 | ARGUMENT:: length 20 | Number of values produced. 21 | 22 | EXAMPLES:: 23 | 24 | CODE:: 25 | {Dust2.ar(1000)}.plot(0.1); 26 | PDust2(10).asStream.nextN(100).plot; //similar 27 | :: 28 | -------------------------------------------------------------------------------- /HelpSource/Classes/PExpRand.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PExpRand 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/ExpRand:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: lo 14 | 15 | ARGUMENT:: hi 16 | 17 | ARGUMENT:: length 18 | Number of values produced. 19 | 20 | EXAMPLES:: 21 | 22 | CODE:: 23 | s.boot; 24 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PExpRand(60, 70).trace).play 25 | a.stop 26 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PExpRand(0.001, 1).trace).play 27 | a.stop 28 | :: 29 | -------------------------------------------------------------------------------- /HelpSource/Classes/PFBSineN.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PFBSineN 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Feedback Sine with Linear Congruential Phase Indexing. 8 | 9 | Based on link::Classes/FBSineN:: 10 | 11 | CLASSMETHODS:: 12 | 13 | METHOD:: new 14 | 15 | ARGUMENT:: freq 16 | 17 | ARGUMENT:: im 18 | 19 | ARGUMENT:: fb 20 | 21 | ARGUMENT:: a 22 | 23 | ARGUMENT:: c 24 | 25 | ARGUMENT:: xi 26 | initial value 27 | 28 | ARGUMENT:: yi 29 | initial value 30 | 31 | ARGUMENT:: mul 32 | 33 | ARGUMENT:: add 34 | 35 | ARGUMENT:: length 36 | Number of values produced. 37 | 38 | EXAMPLES:: 39 | 40 | CODE:: 41 | s.boot; 42 | {FBSineN.ar(1000, 1.4)}.plot(0.1); 43 | PFBSineN(1, 1.4).asStream.nextN(100).plot; //similar 44 | 45 | PFBSineN(1, 1.5, 1.2, 1.05).asStream.nextN(100).plot; 46 | a= Pbind(\dur, 0.1, \midinote, PFBSineN(1, 1.5, 1.2, 1.05, mul:6, add:60)).play 47 | a.stop 48 | :: 49 | -------------------------------------------------------------------------------- /HelpSource/Classes/PFSinOsc.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PFSinOsc 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/FSinOsc:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: freq 14 | 15 | ARGUMENT:: iphase 16 | Fixed. 17 | 18 | ARGUMENT:: mul 19 | 20 | ARGUMENT:: add 21 | 22 | ARGUMENT:: length 23 | Number of values produced. 24 | 25 | EXAMPLES:: 26 | 27 | CODE:: 28 | s.boot; 29 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PFSinOsc(16, pi, 10, 60).trace).play 30 | a.stop 31 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PFSinOsc(16*PSinOsc(64, 0, 0.1, 1), 1.5pi, 0.25, 0.25).trace).play 32 | a.stop 33 | :: 34 | -------------------------------------------------------------------------------- /HelpSource/Classes/PFold.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PFold 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Fold:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: lo 16 | 17 | ARGUMENT:: hi 18 | 19 | EXAMPLES:: 20 | 21 | CODE:: 22 | s.boot; 23 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PFold(Pseq([0, 2, 4, 5], inf), 2, 4).trace*5+50).play 24 | a.stop 25 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PFold(PSinOsc(16), 0.5, 1).trace*0.5).play 26 | a.stop 27 | :: 28 | -------------------------------------------------------------------------------- /HelpSource/Classes/PGate.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PGate 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Gate:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: trig 16 | 17 | EXAMPLES:: 18 | 19 | CODE:: 20 | s.boot; 21 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PGate(Pseq([0, 2, 4, 5], inf), Pseq([0, 0, 0, 1, 1, 1, 1, 1], inf)).trace*5+50).play 22 | a.stop 23 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PGate(PSaw(64, 0.5, 0.5), PSinOsc(8)).trace*0.5).play 24 | a.stop 25 | :: 26 | -------------------------------------------------------------------------------- /HelpSource/Classes/PGbmanN.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PGbmanN 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Gingerbreadman Map. 8 | 9 | Based on link::Classes/GbmanN:: 10 | 11 | CLASSMETHODS:: 12 | 13 | METHOD:: new 14 | 15 | ARGUMENT:: freq 16 | 17 | ARGUMENT:: xi 18 | initial value 19 | 20 | ARGUMENT:: yi 21 | initial value 22 | 23 | ARGUMENT:: mul 24 | 25 | ARGUMENT:: add 26 | 27 | ARGUMENT:: length 28 | Number of values produced. 29 | 30 | EXAMPLES:: 31 | 32 | CODE:: 33 | s.boot; 34 | {GbmanN.ar(10000)}.plot(0.1); 35 | PGbmanN(1).asStream.nextN(1000).plot; //similar 36 | 37 | PGbmanN(1).asStream.nextN(500).plot; 38 | a= Pbind(\dur, 0.1, \midinote, PGbmanN(1, mul:3, add:60)).play 39 | a.stop 40 | :: 41 | -------------------------------------------------------------------------------- /HelpSource/Classes/PHPZ1.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PHPZ1 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/HPZ1:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: mul 16 | 17 | ARGUMENT:: add 18 | 19 | EXAMPLES:: 20 | 21 | CODE:: 22 | s.boot; 23 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PHPZ1(Pseq([12, 0, 0, 0, 0, 3, 0, 0, 0, 0], inf)).trace+50).play 24 | a.stop 25 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PHPZ1(PImpulse(8), PSaw(64)).trace).play 26 | a.stop 27 | :: 28 | -------------------------------------------------------------------------------- /HelpSource/Classes/PHPZ2.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PHPZ2 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/HPZ2:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: mul 16 | 17 | ARGUMENT:: add 18 | 19 | EXAMPLES:: 20 | 21 | CODE:: 22 | s.boot; 23 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PHPZ2(Pseq([12, 0, 0, 0, 0, 3, 0, 0, 0, 0], inf)).trace+50).play 24 | a.stop 25 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PHPZ2(PImpulse(8), PSaw(64)).trace).play 26 | a.stop 27 | :: 28 | -------------------------------------------------------------------------------- /HelpSource/Classes/PHasher.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PHasher 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Hasher:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: in 14 | 15 | ARGUMENT:: mul 16 | 17 | ARGUMENT:: add 18 | 19 | ARGUMENT:: length 20 | Number of values produced. 21 | 22 | EXAMPLES:: 23 | 24 | CODE:: 25 | {Hasher.ar(Line.ar(-1, 1, 0.1).round(0.02))}.plot(0.1); 26 | PHasher(Pseries(-1, 0.02, 100)).asStream.nextN(100).plot; //similar 27 | 28 | a= Pbind(\dur, 0.1, \midinote, PHasher(PLFSaw(8), mul:6, add:60)).play 29 | a.stop 30 | a= Pbind(\dur, 0.1, \midinote, PHasher(PLFSaw(8.001), mul:6, add:60)).play 31 | a.stop 32 | :: 33 | -------------------------------------------------------------------------------- /HelpSource/Classes/PHenonN.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PHenonN 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Henon Map. 8 | 9 | Based on link::Classes/HenonN:: 10 | 11 | CLASSMETHODS:: 12 | 13 | METHOD:: new 14 | 15 | ARGUMENT:: freq 16 | 17 | ARGUMENT:: a 18 | 19 | ARGUMENT:: b 20 | 21 | ARGUMENT:: x0 22 | initial value 23 | 24 | ARGUMENT:: x1 25 | second value 26 | 27 | ARGUMENT:: mul 28 | 29 | ARGUMENT:: add 30 | 31 | ARGUMENT:: length 32 | Number of values produced. 33 | 34 | EXAMPLES:: 35 | 36 | CODE:: 37 | s.boot; 38 | {HenonN.ar(1000)}.plot(0.1); 39 | PHenonN(1).asStream.nextN(100).plot; //similar 40 | 41 | PHenonN(1, 1.1, 0.33).asStream.nextN(100).plot; 42 | a= Pbind(\dur, 0.1, \midinote, PHenonN(1, 1.1, 0.33, mul:6, add:60)).play 43 | a.stop 44 | :: 45 | -------------------------------------------------------------------------------- /HelpSource/Classes/PIRand.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PIRand 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/IRand:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: lo 14 | 15 | ARGUMENT:: hi 16 | 17 | ARGUMENT:: length 18 | Number of values produced. 19 | 20 | EXAMPLES:: 21 | 22 | CODE:: 23 | s.boot; 24 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PIRand(60, 70).trace).play 25 | a.stop 26 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PIRand(0, 1).trace).play 27 | a.stop 28 | :: 29 | -------------------------------------------------------------------------------- /HelpSource/Classes/PImpulse.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PImpulse 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Impulse:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: freq 14 | 15 | ARGUMENT:: phase 16 | 17 | ARGUMENT:: mul 18 | 19 | ARGUMENT:: add 20 | 21 | ARGUMENT:: length 22 | Number of values produced. 23 | 24 | EXAMPLES:: 25 | 26 | CODE:: 27 | s.boot; 28 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PImpulse(8, 0, 10, 60).trace).play 29 | a.stop 30 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PImpulse(4*PSinOsc(16, 0, 0.1, 1), 0, 0.5, 0.125).trace).play 31 | a.stop 32 | :: 33 | -------------------------------------------------------------------------------- /HelpSource/Classes/PInRange.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PInRange 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/InRange:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: lo 16 | 17 | ARGUMENT:: hi 18 | 19 | EXAMPLES:: 20 | 21 | CODE:: 22 | s.boot; 23 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PInRange(Pseq([0, 2, 4, 5], inf), 2, 4).trace*5+50).play 24 | a.stop 25 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PInRange(PSinOsc(8), 0.3, 1).trace*0.5).play 26 | a.stop 27 | :: 28 | -------------------------------------------------------------------------------- /HelpSource/Classes/PInRect.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PInRect 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/InRect:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | pattern x-position 15 | 16 | ARGUMENT:: y 17 | pattern y-position 18 | 19 | ARGUMENT:: rect 20 | a link::Classes/Rect:: object. 21 | 22 | EXAMPLES:: 23 | 24 | CODE:: 25 | s.boot; 26 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PInRect(Pseq([0, 2, 4, 5], inf), Pseq([0, 1, 2], inf), Rect(2, 2, 4, 4)).trace*5+50).play 27 | a.stop 28 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PInRect(5, 5, Pseq([Rect(0, 0, 10, 10), Rect(6, 6, 7, 7)], inf)).trace*0.5).play 29 | a.stop 30 | :: 31 | -------------------------------------------------------------------------------- /HelpSource/Classes/PIntegrator.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PIntegrator 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Integrator:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: coef 16 | 17 | ARGUMENT:: mul 18 | 19 | ARGUMENT:: add 20 | 21 | EXAMPLES:: 22 | 23 | CODE:: 24 | s.boot; 25 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PIntegrator(Pseq([12, 0, 0, 0, 0, 0, 0, 0, 0, 0], inf), 0.1).trace+50).play 26 | a.stop 27 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PIntegrator(PImpulse(8), PSaw(64)).trace).play 28 | a.stop 29 | :: 30 | -------------------------------------------------------------------------------- /HelpSource/Classes/PLFClipNoise.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PLFClipNoise 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/LFClipNoise:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: freq 14 | 15 | ARGUMENT:: mul 16 | 17 | ARGUMENT:: add 18 | 19 | ARGUMENT:: length 20 | Number of values produced. 21 | 22 | EXAMPLES:: 23 | 24 | CODE:: 25 | {LFClipNoise.ar(100)}.plot(0.1); 26 | PLFClipNoise(10).asStream.nextN(100).plot; //similar 27 | 28 | a= Pbind(\dur, 0.1, \midinote, PLFClipNoise(8, mul:6, add:60)).play 29 | a.stop 30 | :: 31 | -------------------------------------------------------------------------------- /HelpSource/Classes/PLFNoise0.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PLFNoise0 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/LFNoise0:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: freq 14 | 15 | ARGUMENT:: mul 16 | 17 | ARGUMENT:: add 18 | 19 | ARGUMENT:: length 20 | Number of values produced. 21 | 22 | EXAMPLES:: 23 | 24 | CODE:: 25 | {LFNoise0.ar(100)}.plot(0.1); 26 | PLFNoise0(10).asStream.nextN(100).plot; //similar 27 | 28 | a= Pbind(\dur, 0.1, \midinote, PLFNoise0(3, mul:6, add:60)).play 29 | a.stop 30 | :: 31 | -------------------------------------------------------------------------------- /HelpSource/Classes/PLFNoise1.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PLFNoise1 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/LFNoise1:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: freq 14 | 15 | ARGUMENT:: mul 16 | 17 | ARGUMENT:: add 18 | 19 | ARGUMENT:: length 20 | Number of values produced. 21 | 22 | EXAMPLES:: 23 | 24 | CODE:: 25 | {LFNoise1.ar(100)}.plot(0.1); 26 | PLFNoise1(10).asStream.nextN(100).plot; //similar 27 | 28 | a= Pbind(\dur, 0.1, \midinote, PLFNoise1(8, mul:6, add:60)).play 29 | a.stop 30 | :: 31 | -------------------------------------------------------------------------------- /HelpSource/Classes/PLFNoise2.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PLFNoise2 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/LFNoise2:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: freq 14 | 15 | ARGUMENT:: mul 16 | 17 | ARGUMENT:: add 18 | 19 | ARGUMENT:: length 20 | Number of values produced. 21 | 22 | EXAMPLES:: 23 | 24 | CODE:: 25 | {LFNoise2.ar(100)}.plot(0.1); 26 | PLFNoise2(10).asStream.nextN(100).plot; //similar 27 | 28 | a= Pbind(\dur, 0.1, \midinote, PLFNoise2(8, mul:6, add:60)).play 29 | a.stop 30 | :: 31 | -------------------------------------------------------------------------------- /HelpSource/Classes/PLFPulse.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PLFPulse 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/LFPulse:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: freq 14 | 15 | ARGUMENT:: iphase 16 | Fixed. 17 | 18 | ARGUMENT:: width 19 | 20 | ARGUMENT:: mul 21 | 22 | ARGUMENT:: add 23 | 24 | ARGUMENT:: length 25 | Number of values produced. 26 | 27 | EXAMPLES:: 28 | 29 | CODE:: 30 | s.boot; 31 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PLFPulse(16, 0, 0.5, 10, 60).trace).play 32 | a.stop 33 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PLFPulse(PSinOsc(64, 0, 8, 12), 0, 0.33, 0.25).trace).play 34 | a.stop 35 | :: 36 | -------------------------------------------------------------------------------- /HelpSource/Classes/PLFSaw.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PLFSaw 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/LFSaw:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: freq 14 | 15 | ARGUMENT:: iphase 16 | Fixed. 17 | 18 | ARGUMENT:: mul 19 | 20 | ARGUMENT:: add 21 | 22 | ARGUMENT:: length 23 | Number of values produced. 24 | 25 | EXAMPLES:: 26 | 27 | CODE:: 28 | s.boot; 29 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PLFSaw(16, 0.5, 10, 60).trace).play 30 | a.stop 31 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PLFSaw(16*PSinOsc(64, 0, 0.1, 1), 0.5, 0.25, 0.25).trace).play 32 | a.stop 33 | :: 34 | -------------------------------------------------------------------------------- /HelpSource/Classes/PLFTri.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PLFTri 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/LFTri:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: freq 14 | 15 | ARGUMENT:: iphase 16 | Fixed. 17 | 18 | ARGUMENT:: mul 19 | 20 | ARGUMENT:: add 21 | 22 | ARGUMENT:: length 23 | Number of values produced. 24 | 25 | EXAMPLES:: 26 | 27 | CODE:: 28 | s.boot; 29 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PLFTri(16, 0, 10, 60).trace).play 30 | a.stop 31 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PLFTri(16*PSinOsc(64, 0, 0.1, 1), 0, 0.25, 0.25).trace).play 32 | a.stop 33 | :: 34 | -------------------------------------------------------------------------------- /HelpSource/Classes/PLPZ1.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PLPZ1 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/LPZ1:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: mul 16 | 17 | ARGUMENT:: add 18 | 19 | EXAMPLES:: 20 | 21 | CODE:: 22 | s.boot; 23 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PLPZ1(Pseq([12, 0, 0, 0, 0, 3, 0, 0, 0, 0], inf)).trace+50).play 24 | a.stop 25 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PLPZ1(PImpulse(8), PSaw(64)).trace).play 26 | a.stop 27 | :: 28 | -------------------------------------------------------------------------------- /HelpSource/Classes/PLPZ2.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PLPZ2 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/LPZ2:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: mul 16 | 17 | ARGUMENT:: add 18 | 19 | EXAMPLES:: 20 | 21 | CODE:: 22 | s.boot; 23 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PLPZ2(Pseq([12, 0, 0, 0, 0, 3, 0, 0, 0, 0], inf)).trace+50).play 24 | a.stop 25 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PLPZ2(PImpulse(8), PSaw(64)).trace).play 26 | a.stop 27 | :: 28 | -------------------------------------------------------------------------------- /HelpSource/Classes/PLastValue.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PLastValue 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/LastValue:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: diff 16 | 17 | EXAMPLES:: 18 | 19 | CODE:: 20 | s.boot; 21 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PLastValue(Pseq([0, 2, 4, 5, 0, 4, 4, 4, 4, 4, 4, 4], inf), 2).trace*5+50).play 22 | a.stop 23 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PLastValue(PSaw(12), PSinOsc(64, 0.5, 0.5)).trace*0.5).play 24 | a.stop 25 | :: 26 | -------------------------------------------------------------------------------- /HelpSource/Classes/PLatch.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PLatch 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Latch:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: trig 16 | 17 | EXAMPLES:: 18 | 19 | CODE:: 20 | s.boot; 21 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PLatch(Pseq([0, 2, 4, 5], inf), Pseq([0, 1, 1, 1, 1], inf)).trace*5+50).play 22 | a.stop 23 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PLatch(PSinOsc(8), PSinOsc(16)).trace*0.5).play 24 | a.stop 25 | :: 26 | -------------------------------------------------------------------------------- /HelpSource/Classes/PLatoocarfianN.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PLatoocarfianN 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Latoocarfian. 8 | 9 | Based on link::Classes/LatoocarfianN:: 10 | 11 | CLASSMETHODS:: 12 | 13 | METHOD:: new 14 | 15 | ARGUMENT:: freq 16 | 17 | ARGUMENT:: a 18 | 19 | ARGUMENT:: b 20 | 21 | ARGUMENT:: c 22 | 23 | ARGUMENT:: d 24 | 25 | ARGUMENT:: xi 26 | initial value 27 | 28 | ARGUMENT:: yi 29 | initial value 30 | 31 | ARGUMENT:: mul 32 | 33 | ARGUMENT:: add 34 | 35 | ARGUMENT:: length 36 | Number of values produced. 37 | 38 | EXAMPLES:: 39 | 40 | CODE:: 41 | s.boot; 42 | {LatoocarfianN.ar(1000)}.plot(0.1); 43 | PLatoocarfianN(1).asStream.nextN(100).plot; //similar 44 | 45 | PLatoocarfianN(1, 2).asStream.nextN(100).plot; 46 | a= Pbind(\dur, 0.1, \midinote, PLatoocarfianN(1, 2, mul:6, add:60)).play 47 | a.stop 48 | :: 49 | -------------------------------------------------------------------------------- /HelpSource/Classes/PLinCongN.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PLinCongN 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Linear Congruential. 8 | 9 | Based on link::Classes/LinCongN:: 10 | 11 | CLASSMETHODS:: 12 | 13 | METHOD:: new 14 | 15 | ARGUMENT:: freq 16 | 17 | ARGUMENT:: a 18 | 19 | ARGUMENT:: c 20 | 21 | ARGUMENT:: m 22 | 23 | ARGUMENT:: xi 24 | initial value 25 | 26 | ARGUMENT:: mul 27 | 28 | ARGUMENT:: add 29 | 30 | ARGUMENT:: length 31 | Number of values produced. 32 | 33 | EXAMPLES:: 34 | 35 | CODE:: 36 | s.boot; 37 | {LinCongN.ar(1000)}.plot(0.1); 38 | PLinCongN(1).asStream.nextN(100).plot; //similar 39 | 40 | PLinCongN(1, 2, 0.14).asStream.nextN(100).plot; 41 | a= Pbind(\dur, 0.1, \midinote, PLinCongN(1, 2, 0.14, mul:6, add:60)).play 42 | a.stop 43 | :: 44 | -------------------------------------------------------------------------------- /HelpSource/Classes/PLinExp.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PLinExp 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/LinExp:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: srclo 16 | 17 | ARGUMENT:: srchi 18 | 19 | ARGUMENT:: dstlo 20 | 21 | ARGUMENT:: dsthi 22 | 23 | EXAMPLES:: 24 | 25 | CODE:: 26 | s.boot; 27 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PLinExp(Pseq([0, 1, 2, 3, 4], inf), 0, 4, 50, 60).trace).play 28 | a.stop 29 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PLinExp(PSinOsc(16), -1, 1, 0.001, 0.5).trace).play 30 | a.stop 31 | :: 32 | -------------------------------------------------------------------------------- /HelpSource/Classes/PLinLin.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PLinLin 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/PLinLin:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: srclo 16 | 17 | ARGUMENT:: srchi 18 | 19 | ARGUMENT:: dstlo 20 | 21 | ARGUMENT:: dsthi 22 | 23 | EXAMPLES:: 24 | 25 | CODE:: 26 | s.boot; 27 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PLinLin(Pseq([0, 1, 2, 3, 4], inf), 0, 4, 50, 60).trace).play 28 | a.stop 29 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PLinLin(PSinOsc(16), -1, 1, 0.001, 0.5).trace).play 30 | a.stop 31 | :: 32 | -------------------------------------------------------------------------------- /HelpSource/Classes/PLine.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PLine 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Line:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: start 14 | Fixed. 15 | 16 | ARGUMENT:: end 17 | Fixed. 18 | 19 | ARGUMENT:: dur 20 | Fixed. 21 | 22 | ARGUMENT:: mul 23 | 24 | ARGUMENT:: add 25 | 26 | ARGUMENT:: length 27 | Number of values produced. 28 | 29 | EXAMPLES:: 30 | 31 | CODE:: 32 | s.boot; 33 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PLine(0, 12, 16, 1, 50).trace).play 34 | a.stop 35 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PLine(0.8, 0, 32).trace).play 36 | a.stop 37 | :: 38 | -------------------------------------------------------------------------------- /HelpSource/Classes/PLorenzN.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PLorenzN 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Lorenz Attractor. 8 | 9 | Based on link::Classes/LorenzL:: 10 | 11 | NOTE:: this class will easily go out of bounds and produce inf, NaN or nil results. Careful tuning of the parameters is necessary. 12 | :: 13 | 14 | CLASSMETHODS:: 15 | 16 | METHOD:: new 17 | 18 | ARGUMENT:: freq 19 | 20 | ARGUMENT:: s 21 | sigma 22 | 23 | ARGUMENT:: r 24 | rho 25 | 26 | ARGUMENT:: b 27 | beta 28 | 29 | ARGUMENT:: h 30 | step amount 31 | 32 | ARGUMENT:: xi 33 | initial value 34 | 35 | ARGUMENT:: yi 36 | initial value 37 | 38 | ARGUMENT:: zi 39 | initial value 40 | 41 | ARGUMENT:: mul 42 | 43 | ARGUMENT:: add 44 | 45 | ARGUMENT:: length 46 | Number of values produced. 47 | 48 | EXAMPLES:: 49 | 50 | CODE:: 51 | s.boot; 52 | {LorenzL.ar(10000)}.plot(0.1); 53 | PLorenzN(0.066).asStream.nextN(10000).plot; //similar 54 | 55 | PLorenzN(0.2, 15, 20, 2.8, 0.05).asStream.nextN(1000).plot; 56 | a= Pbind(\dur, 0.05, \midinote, PLorenzN(0.2, 15, 20, 2.8, 0.05, mul:8, add:60)).play 57 | a.stop 58 | :: 59 | -------------------------------------------------------------------------------- /HelpSource/Classes/PMantissaMask.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PMantissaMask 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/MantissaMask:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: in 14 | 15 | ARGUMENT:: bits 16 | 17 | ARGUMENT:: mul 18 | 19 | ARGUMENT:: add 20 | 21 | ARGUMENT:: length 22 | Number of values produced. 23 | 24 | EXAMPLES:: 25 | 26 | CODE:: 27 | {MantissaMask.ar(Line.ar(-1, 1, 0.1))}.plot(0.1); 28 | PMantissaMask(Pseries(-1, 0.02, 100)).asStream.nextN(100).plot; //similar 29 | :: 30 | -------------------------------------------------------------------------------- /HelpSource/Classes/PMouseButton.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PMouseButton 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/MouseButton:: 8 | 9 | NOTE:: 10 | mac osx only, lag is not implemented 11 | :: 12 | NOTE:: 13 | only osx, and only sc3.4 or sc3.5 in 32bit mode (i.e. something is broken under 64bit sc3.5) 14 | :: 15 | 16 | CLASSMETHODS:: 17 | 18 | METHOD:: new 19 | 20 | ARGUMENT:: minval 21 | 22 | ARGUMENT:: maxval 23 | 24 | ARGUMENT:: lag 25 | NOTE:: 26 | not implemented 27 | :: 28 | 29 | ARGUMENT:: length 30 | Number of values produced. 31 | 32 | EXAMPLES:: 33 | 34 | CODE:: 35 | s.boot; 36 | a= Pbind(\dur, 1/3, \legato, 0.4, \freq, PMouseButton(400, 800).trace).play 37 | a.stop 38 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PMouseButton(0, 0.2).trace).play 39 | a.stop 40 | :: 41 | -------------------------------------------------------------------------------- /HelpSource/Classes/PMouseX.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PMouseX 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns, Classes/PMouseY 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/MouseX:: 8 | 9 | NOTE:: 10 | Qt GUI only (will not work on headless). 11 | 12 | When instantiating the class for the first time, the very first reading will be erroneous. It will read the cursor as CODE::Point(0, 0)::. A kind of workaround is to manually set the LINK::#*cursorPosition:: classvar before start using LINK::Classes/PMouseX:: or LINK::Classes/PMouseY::. 13 | :: 14 | 15 | CLASSMETHODS:: 16 | 17 | METHOD:: new 18 | 19 | ARGUMENT:: minval 20 | 21 | ARGUMENT:: maxval 22 | 23 | ARGUMENT:: warp 24 | 0 for linear and 1 for exponential. The symbols CODE::\linear:: and CODE::\exponential:: also work. 25 | 26 | ARGUMENT:: lag 27 | NOTE:: 28 | Might be a bit shakey when running several LINK::Classes/PMouseX:: or LINK::Classes/PMouseY:: with different lag times all at once. For efficiency they all share the same LINK::Classes/SkipJack:: and thereby may override each other's lag. 29 | :: 30 | 31 | ARGUMENT:: length 32 | Number of values produced. 33 | 34 | METHOD:: cursorPosition 35 | Current mouse coordinates as a LINK::Classes/Point::. 36 | 37 | METHOD:: updateRate 38 | How fast to poll the cursor position internally. Default is 0.1 seconds between each reading. Needs to be set before instantiating any LINK::Classes/PMouseX:: or LINK::Classes/PMouseY:: for the first time. 39 | 40 | 41 | INSTANCEMETHODS:: 42 | 43 | PRIVATE:: initPMouse, prCursor, prBounds 44 | 45 | EXAMPLES:: 46 | 47 | CODE:: 48 | s.boot; 49 | a= Pbind(\dur, 1/3, \legato, 0.4, \freq, PMouseX(400, 800, 1).trace).play 50 | a.stop 51 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PMouseX(0, 0.5, 0).trace).play 52 | a.stop 53 | :: 54 | -------------------------------------------------------------------------------- /HelpSource/Classes/PMouseY.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PMouseY 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns, Classes/PMouseX 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/MouseY:: 8 | 9 | NOTE:: 10 | Qt GUI only (will not work on headless). 11 | 12 | When instantiating the class for the first time, the very first reading will be erroneous. It will read the cursor as CODE::Point(0, 0)::. A kind of workaround is to manually set the LINK::#*cursorPosition:: classvar before start using LINK::Classes/PMouseX:: or LINK::Classes/PMouseY::. 13 | :: 14 | 15 | CLASSMETHODS:: 16 | 17 | INSTANCEMETHODS:: 18 | 19 | PRIVATE:: prCursor, prBounds 20 | 21 | EXAMPLES:: 22 | 23 | CODE:: 24 | s.boot; 25 | a= Pbind(\dur, 1/3, \legato, 0.4, \freq, PMouseY(400, 800, 1).trace).play 26 | a.stop 27 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PMouseY(0, 0.5, 0).trace).play 28 | a.stop 29 | :: 30 | -------------------------------------------------------------------------------- /HelpSource/Classes/POnePole.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: POnePole 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/OnePole:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: coef 16 | 17 | ARGUMENT:: mul 18 | 19 | ARGUMENT:: add 20 | 21 | EXAMPLES:: 22 | 23 | CODE:: 24 | s.boot; 25 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, POnePole(Pseq([12, 0, 0, 0, 0, 0, 0, 0, 0, 0], inf), 0.25).trace+50).play 26 | a.stop 27 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, POnePole(PImpulse(8), PSaw(64)).trace).play 28 | a.stop 29 | :: 30 | -------------------------------------------------------------------------------- /HelpSource/Classes/POneZero.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: POneZero 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/OneZero:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: coef 16 | 17 | ARGUMENT:: mul 18 | 19 | ARGUMENT:: add 20 | 21 | EXAMPLES:: 22 | 23 | CODE:: 24 | s.boot; 25 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, POneZero(Pseq([12, 0, 0, 0, 0, 0, 0, 0, 0, 0], inf), 0.25).trace+50).play 26 | a.stop 27 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, POneZero(PImpulse(8), PSaw(64)).trace).play 28 | a.stop 29 | :: 30 | -------------------------------------------------------------------------------- /HelpSource/Classes/PPeak.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PPeak 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Peak:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: reset 16 | 17 | EXAMPLES:: 18 | 19 | CODE:: 20 | s.boot; 21 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PPeak(Pseq([0, 2, 4, 5], inf)).trace+50).play 22 | a.stop 23 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PPeak(PSaw(12), PSinOsc(14)).trace*0.5).play 24 | a.stop 25 | :: 26 | -------------------------------------------------------------------------------- /HelpSource/Classes/PPulse.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PPulse 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Pulse:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: freq 14 | 15 | ARGUMENT:: width 16 | 17 | ARGUMENT:: mul 18 | 19 | ARGUMENT:: add 20 | 21 | ARGUMENT:: length 22 | Number of values produced. 23 | 24 | EXAMPLES:: 25 | 26 | CODE:: 27 | s.boot; 28 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PPulse(16, 0.5, 10, 60).trace).play 29 | a.stop 30 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PPulse(PSinOsc(64, 0, 8, 12), 0.33, 0.25).trace).play 31 | a.stop 32 | :: 33 | -------------------------------------------------------------------------------- /HelpSource/Classes/PPulseCount.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PPulseCount 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/PulseCount:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: reset 16 | 17 | EXAMPLES:: 18 | 19 | CODE:: 20 | s.boot; 21 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PPulseCount(Pseq([0, 2, 4, 5], inf)).trace+50).play 22 | a.stop 23 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PPulseCount(PSinOsc(8), PSinOsc(14)).trace*0.5).play 24 | a.stop 25 | :: 26 | -------------------------------------------------------------------------------- /HelpSource/Classes/PQuadN.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PQuadN 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | General Quadratic Map. 8 | 9 | Based on link::Classes/QuadN:: 10 | 11 | CLASSMETHODS:: 12 | 13 | METHOD:: new 14 | 15 | ARGUMENT:: freq 16 | 17 | ARGUMENT:: a 18 | 19 | ARGUMENT:: b 20 | 21 | ARGUMENT:: c 22 | 23 | ARGUMENT:: xi 24 | initial value 25 | 26 | ARGUMENT:: mul 27 | 28 | ARGUMENT:: add 29 | 30 | ARGUMENT:: length 31 | Number of values produced. 32 | 33 | EXAMPLES:: 34 | 35 | CODE:: 36 | s.boot; 37 | {QuadN.ar(1000)}.plot(0.1); 38 | PQuadN(1).asStream.nextN(100).plot; //similar 39 | 40 | PQuadN(1, 1, -1, -0.95).asStream.nextN(100).plot; 41 | a= Pbind(\dur, 0.1, \midinote, PQuadN(1, 1, -1, -0.95, mul:6, add:60)).play 42 | a.stop 43 | :: 44 | -------------------------------------------------------------------------------- /HelpSource/Classes/PRand.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PRand 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Rand:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: lo 14 | 15 | ARGUMENT:: hi 16 | 17 | ARGUMENT:: length 18 | Number of values produced. 19 | 20 | EXAMPLES:: 21 | 22 | CODE:: 23 | s.boot; 24 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PRand(60, 70).trace).play 25 | a.stop 26 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PRand(0, 1).trace).play 27 | a.stop 28 | :: 29 | -------------------------------------------------------------------------------- /HelpSource/Classes/PRunningMax.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PRunningMax 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/RunningMax:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: reset 16 | 17 | EXAMPLES:: 18 | 19 | CODE:: 20 | s.boot; 21 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PRunningMax(Pseq([0, 2, -4, 5], inf)).trace+50).play 22 | a.stop 23 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PRunningMax(PSaw(12), PSinOsc(14)).trace*0.5).play 24 | a.stop 25 | :: 26 | -------------------------------------------------------------------------------- /HelpSource/Classes/PRunningMin.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PRunningMin 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/RunningMin:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: reset 16 | 17 | EXAMPLES:: 18 | 19 | CODE:: 20 | s.boot; 21 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PRunningMin(Pseq([0, 2, -4, 5], inf)).trace+50).play 22 | a.stop 23 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PRunningMin(PSaw(12), PSinOsc(14)).trace*0.5).play 24 | a.stop 25 | :: 26 | -------------------------------------------------------------------------------- /HelpSource/Classes/PSaw.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PSaw 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Saw:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: freq 14 | 15 | ARGUMENT:: mul 16 | 17 | ARGUMENT:: add 18 | 19 | ARGUMENT:: length 20 | Number of values produced. 21 | 22 | EXAMPLES:: 23 | 24 | CODE:: 25 | s.boot; 26 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PSaw(16, 10, 60).trace).play 27 | a.stop 28 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PSaw(16*PSinOsc(64, 0, 0.1, 1), 0.25, 0.25).trace).play 29 | a.stop 30 | :: 31 | -------------------------------------------------------------------------------- /HelpSource/Classes/PSchmidt.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PSchmidt 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Schmidt:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: lo 16 | 17 | ARGUMENT:: hi 18 | 19 | EXAMPLES:: 20 | 21 | CODE:: 22 | s.boot; 23 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PSchmidt(Pseq([0, 2, 4, 6, 5, 3, 1], 1), 2.5, 4.5).trace*5+60).play 24 | a.stop 25 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PSchmidt(PSinOsc(16), 0.5, 0.7).trace*0.5).play 26 | a.stop 27 | :: 28 | -------------------------------------------------------------------------------- /HelpSource/Classes/PSilent.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PSilent 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Silent:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: numChannels 14 | if more than one then return an array of zeros. 15 | 16 | ARGUMENT:: length 17 | Number of values produced. 18 | 19 | EXAMPLES:: 20 | 21 | CODE:: 22 | s.boot; 23 | a= Pbind(\dur, 1/3, \legato, 0.4, \amp, PSilent().trace).play 24 | a.stop 25 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PSilent(2).trace).play 26 | a.stop 27 | :: 28 | -------------------------------------------------------------------------------- /HelpSource/Classes/PSinOsc.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PSinOsc 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/SinOsc:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: freq 14 | 15 | ARGUMENT:: phase 16 | 17 | ARGUMENT:: mul 18 | 19 | ARGUMENT:: add 20 | 21 | ARGUMENT:: length 22 | Number of values produced. 23 | 24 | EXAMPLES:: 25 | 26 | CODE:: 27 | s.boot; 28 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PSinOsc(16, 0, 10, 60).trace).play 29 | a.stop 30 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PSinOsc(16*PSinOsc(64, 0, 0.1, 1), 1.5pi, 0.25, 0.25).trace).play 31 | a.stop 32 | :: 33 | -------------------------------------------------------------------------------- /HelpSource/Classes/PStandardN.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PStandardN 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Standard Map. 8 | 9 | Based on link::Classes/StandardN:: 10 | 11 | CLASSMETHODS:: 12 | 13 | METHOD:: new 14 | 15 | ARGUMENT:: freq 16 | 17 | ARGUMENT:: k 18 | 19 | ARGUMENT:: xi 20 | initial value 21 | 22 | ARGUMENT:: yi 23 | initial value 24 | 25 | ARGUMENT:: mul 26 | 27 | ARGUMENT:: add 28 | 29 | ARGUMENT:: length 30 | Number of values produced. 31 | 32 | EXAMPLES:: 33 | 34 | CODE:: 35 | s.boot; 36 | {StandardN.ar(1000, 1.4)}.plot(0.1); 37 | PStandardN(1, 1.4).asStream.nextN(100).plot; //similar 38 | 39 | PStandardN(1, 1.4).asStream.nextN(100).plot; 40 | a= Pbind(\dur, 0.1, \midinote, PStandardN(1, 1.4, mul:6, add:60)).play 41 | a.stop 42 | :: 43 | -------------------------------------------------------------------------------- /HelpSource/Classes/PTDelay.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PTDelay 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/TDelay:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: dur 16 | 17 | EXAMPLES:: 18 | 19 | CODE:: 20 | s.boot; 21 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PTDelay(Pseq([0, 2, 4, 4], inf), 1).trace*5+50).play 22 | a.stop 23 | a= Pbind(\dur, 1/6, \legato, 0.2, \degree, Pseq([0, 1, 2, 3], inf), \amp, PTDelay(PImpulse(4), Pstutter(8, Pseq([1, 2, 3], inf))).trace*0.5).play 24 | a.stop 25 | :: 26 | -------------------------------------------------------------------------------- /HelpSource/Classes/PToggleFF.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PToggleFF 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/ToggleFF:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | EXAMPLES:: 16 | 17 | CODE:: 18 | s.boot; 19 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PToggleFF(Pseq([0, 2, 4, 5], inf)).trace*5+50).play 20 | a.stop 21 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PToggleFF(PSinOsc(PSinOsc(8, 2, 4))).trace*0.5).play 22 | a.stop 23 | :: 24 | -------------------------------------------------------------------------------- /HelpSource/Classes/PTrig.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PTrig 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Trig:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: dur 16 | 17 | EXAMPLES:: 18 | 19 | CODE:: 20 | s.boot; 21 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PTrig(Pseq([0, 2, 4, 4], inf), 2).trace*5+50).play 22 | a.stop 23 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PTrig(PSinOsc(PSinOsc(8, 0, 4))).trace*0.5).play 24 | a.stop 25 | :: 26 | -------------------------------------------------------------------------------- /HelpSource/Classes/PTrig1.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PTrig1 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Trig1:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: dur 16 | 17 | EXAMPLES:: 18 | 19 | CODE:: 20 | s.boot; 21 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PTrig1(Pseq([0, 2, 4, 4], inf), 2).trace*5+50).play 22 | a.stop 23 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PTrig1(PSinOsc(PSinOsc(8, 0, 4))).trace*0.5).play 24 | a.stop 25 | :: 26 | -------------------------------------------------------------------------------- /HelpSource/Classes/PWhiteNoise.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PWhiteNoise 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/WhiteNoise:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: mul 14 | 15 | ARGUMENT:: add 16 | 17 | ARGUMENT:: length 18 | Number of values produced. 19 | 20 | EXAMPLES:: 21 | 22 | CODE:: 23 | s.boot; 24 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PWhiteNoise(10, 60).trace).play 25 | a.stop 26 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PWhiteNoise(PSinOsc(64, 0, 0.5, 0.5), 0).trace).play 27 | a.stop 28 | :: 29 | -------------------------------------------------------------------------------- /HelpSource/Classes/PWrap.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PWrap 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Modifiers 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/Wrap:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: pattern 14 | 15 | ARGUMENT:: lo 16 | 17 | ARGUMENT:: hi 18 | 19 | EXAMPLES:: 20 | 21 | CODE:: 22 | s.boot; 23 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PWrap(Pseq([0, 2, 4, 5], inf), 2, 4).trace*5+50).play 24 | a.stop 25 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PWrap(PSinOsc(16), 0.5, 1).trace*0.5).play 26 | a.stop 27 | :: 28 | -------------------------------------------------------------------------------- /HelpSource/Classes/PXLine.schelp: -------------------------------------------------------------------------------- 1 | CLASS:: PXLine 2 | SUMMARY:: UGenPatterns quark library 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns>Generators 4 | RELATED:: Overviews/UGenPatterns 5 | 6 | DESCRIPTION:: 7 | Based on link::Classes/XLine:: 8 | 9 | CLASSMETHODS:: 10 | 11 | METHOD:: new 12 | 13 | ARGUMENT:: start 14 | Fixed. 15 | 16 | ARGUMENT:: end 17 | Fixed. 18 | 19 | ARGUMENT:: dur 20 | Fixed. Integer number of steps to reach end. 21 | 22 | ARGUMENT:: mul 23 | 24 | ARGUMENT:: add 25 | 26 | ARGUMENT:: length 27 | Number of values produced. 28 | 29 | EXAMPLES:: 30 | 31 | CODE:: 32 | s.boot; 33 | a= Pbind(\dur, 1/3, \legato, 0.4, \midinote, PXLine(1, 13, 16, 1, 49).trace).play 34 | a.stop 35 | a= Pbind(\dur, 1/6, \legato, 0.2, \amp, PXLine(0.8, 0.001, 32).trace).play 36 | a.stop 37 | :: 38 | -------------------------------------------------------------------------------- /HelpSource/Overviews/UGenPatterns.schelp: -------------------------------------------------------------------------------- 1 | TITLE:: UGenPatterns 2 | SUMMARY:: a library of patterns acting as ugens 3 | CATEGORIES:: Streams-Patterns-Events>UGenPatterns 4 | 5 | The main idea behind the UGenPatterns quark is to take advantage of the interface we've already learned by using the normal audio UGens. It simplifies things like LFO modulation on a stream of numbers. No need to do the math - just reuse the knowledge you have about how for example SinOsc works. 6 | 7 | SECTION:: Generators 8 | 9 | LIST:: 10 | ## link::Classes/PBlip:: 11 | ## link::Classes/PClipNoise:: 12 | ## link::Classes/PCuspN:: 13 | ## link::Classes/PDC:: 14 | ## link::Classes/PDust:: 15 | ## link::Classes/PDust2:: 16 | ## link::Classes/PExpRand:: 17 | ## link::Classes/PFBSineN:: 18 | ## link::Classes/PFSinOsc:: 19 | ## link::Classes/PGbmanN:: 20 | ## link::Classes/PHenonN:: 21 | ## link::Classes/PImpulse:: 22 | ## link::Classes/PIRand:: 23 | ## link::Classes/PLatoocarfianN:: 24 | ## link::Classes/PLFClipNoise:: 25 | ## link::Classes/PLFNoise0:: 26 | ## link::Classes/PLFNoise1:: 27 | ## link::Classes/PLFNoise2:: 28 | ## link::Classes/PLFPulse:: 29 | ## link::Classes/PLFSaw:: 30 | ## link::Classes/PLFTri:: 31 | ## link::Classes/PLinCongN:: 32 | ## link::Classes/PLine:: 33 | ## link::Classes/PLorenzN:: 34 | ## link::Classes/PMouseButton:: footnote::macOS only with an old SuperCollider version (3.5 or earler):: 35 | ## link::Classes/PMouseX:: footnote::Qt GUI only:: 36 | ## link::Classes/PMouseY:: footnote::Qt GUI only:: 37 | ## link::Classes/PPulse:: 38 | ## link::Classes/PQuadN:: 39 | ## link::Classes/PRand:: 40 | ## link::Classes/PSaw:: 41 | ## link::Classes/PSilent:: 42 | ## link::Classes/PSinOsc:: 43 | ## link::Classes/PWhiteNoise:: 44 | ## link::Classes/PXLine:: 45 | :: 46 | 47 | SECTION:: Modifiers 48 | 49 | LIST:: 50 | ## link::Classes/PBPZ2:: 51 | ## link::Classes/PBRZ2:: 52 | ## link::Classes/PClip:: 53 | ## link::Classes/PCombN:: 54 | ## link::Classes/PDelay1:: 55 | ## link::Classes/PDelay2:: 56 | ## link::Classes/PDelayN:: 57 | ## link::Classes/PFold:: 58 | ## link::Classes/PGate:: 59 | ## link::Classes/PHasher:: 60 | ## link::Classes/PHPZ1:: 61 | ## link::Classes/PHPZ2:: 62 | ## link::Classes/PInRange:: 63 | ## link::Classes/PInRect:: 64 | ## link::Classes/PIntegrator:: 65 | ## link::Classes/PLastValue:: 66 | ## link::Classes/PLatch:: 67 | ## link::Classes/PLinExp:: 68 | ## link::Classes/PLinLin:: 69 | ## link::Classes/PLPZ1:: 70 | ## link::Classes/PLPZ2:: 71 | ## link::Classes/PMantissaMask:: 72 | ## link::Classes/POnePole:: 73 | ## link::Classes/POneZero:: 74 | ## link::Classes/PPeak:: 75 | ## link::Classes/PPulseCount:: 76 | ## link::Classes/PRunningMax:: 77 | ## link::Classes/PRunningMin:: 78 | ## link::Classes/PSchmidt:: 79 | ## link::Classes/PTDelay:: 80 | ## link::Classes/PToggleFF:: 81 | ## link::Classes/PTrig:: 82 | ## link::Classes/PTrig1:: 83 | ## link::Classes/PWrap:: 84 | :: 85 | 86 | EXAMPLES:: 87 | 88 | code:: 89 | s.boot 90 | 91 | //slow variation (+/- 10hz) on switching frequencies 92 | a= Pbind(\freq, PLFPulse(8).linlin(0, 1, 400, 800)+PSinOsc(40).linlin(-1, 1, -10, 10), \dur, 0.25).play 93 | a.stop 94 | 95 | //or the same thing without using linlin 96 | a= Pbind(\freq, PLFPulse(8, 0, 0.5, 400, 400)+PSinOsc(40, 0, 10), \dur, 0.25).play 97 | a.stop 98 | 99 | 100 | //--comparison 101 | 102 | //the equivalent without this ugenpatterns quark would be something like this... (only standard patterns) 103 | a= Pbind(\dur, 0.25, \freq, Pn(Pstutter(4, Pseq([800, 400])))+(sin(Ptime()/Pkey(\dur)*2pi*(1/40))*10).trace).play 104 | a.stop 105 | 106 | 107 | //and the equivalent (well, roughly) synth as well... (compare how time is handled differently in the original examples above) 108 | ( 109 | a= { 110 | var dur= 0.25; 111 | var env= Decay2.ar(Impulse.ar(1/dur), 0.01, 0.5); 112 | SinOsc.ar(LFPulse.kr(1/(8*dur), 0, 0.5, 400, 400)+SinOsc.ar(1/(40*dur), 0, 10))*env; 113 | }.play 114 | ) 115 | a.free 116 | 117 | 118 | //--nesting 119 | 120 | //here a PSinOsc is modulating the amount of lfo 121 | a= Pbind(\freq, PLFPulse(8, 0, 0.5, 400, 400)+PSinOsc(40, 0, PSinOsc(30, 0, 100)), \dur, 0.25).play 122 | a.stop 123 | 124 | 125 | //--binary ops 126 | 127 | //here duration is controlled by two 'ring modulated' sinosc patterns 128 | a= Pbind(\freq, PLFPulse(8, 0, 0.5, 400, 400)+PSinOsc(40, 0, 10), \dur, PSinOsc(50, 0, 0.2, 0.25)*PSinOsc(20, 0, 0.2, 0.5), \legato, Pkey(\dur)).play 129 | a.stop 130 | :: 131 | -------------------------------------------------------------------------------- /PChaos.sc: -------------------------------------------------------------------------------- 1 | //redFrik 2 | 3 | PQuadN : Pattern { 4 | var <>freq, <>a, <>b, <>c, mul, <>add, <>length; 5 | *new {|freq= 22050, a= 1, b= -1, c= -0.75, xi= 0, mul= 1, add= 0, length= inf| 6 | ^super.newCopyArgs(freq, a, b, c, xi, mul, add, length); 7 | } 8 | storeArgs {^[freq, a, b, c, xi, mul, add, length]} 9 | embedInStream {|inval| 10 | var freqStr= freq.asStream; 11 | var aStr= a.asStream; 12 | var bStr= b.asStream; 13 | var cStr= c.asStream; 14 | var mulStr= mul.asStream; 15 | var addStr= add.asStream; 16 | var freqVal, aVal, bVal, cVal, mulVal, addVal; 17 | var x= xi; 18 | length.value(inval).do{ 19 | addVal= addStr.next(inval); 20 | mulVal= mulStr.next(inval); 21 | cVal= cStr.next(inval); 22 | bVal= bStr.next(inval); 23 | aVal= aStr.next(inval); 24 | freqVal= freqStr.next(inval); 25 | if(addVal.isNil or:{mulVal.isNil or:{cVal.isNil 26 | or:{bVal.isNil or:{aVal.isNil or:{freqVal.isNil}}} 27 | }}, {^inval}); 28 | x= aVal*x**2+(bVal*x)+cVal; 29 | x= x*freqVal; 30 | inval= (x*mulVal+addVal).yield; 31 | }; 32 | ^inval; 33 | } 34 | } 35 | 36 | PCuspN : Pattern { 37 | var <>freq, <>a, <>b, mul, <>add, <>length; 38 | *new {|freq= 22050, a= 1, b= 1.9, xi= 0, mul= 1, add= 0, length= inf| 39 | ^super.newCopyArgs(freq, a, b, xi, mul, add, length); 40 | } 41 | storeArgs {^[freq, a, b, xi, mul, add, length]} 42 | embedInStream {|inval| 43 | var freqStr= freq.asStream; 44 | var aStr= a.asStream; 45 | var bStr= b.asStream; 46 | var mulStr= mul.asStream; 47 | var addStr= add.asStream; 48 | var freqVal, aVal, bVal, mulVal, addVal; 49 | var x= xi; 50 | length.value(inval).do{ 51 | addVal= addStr.next(inval); 52 | mulVal= mulStr.next(inval); 53 | bVal= bStr.next(inval); 54 | aVal= aStr.next(inval); 55 | freqVal= freqStr.next(inval); 56 | if(addVal.isNil or:{mulVal.isNil or:{bVal.isNil 57 | or:{aVal.isNil or:{freqVal.isNil}} 58 | }}, {^inval}); 59 | x= aVal-(bVal*sqrt(abs(x))); 60 | x= x*freqVal; 61 | inval= (x*mulVal+addVal).yield; 62 | }; 63 | ^inval; 64 | } 65 | } 66 | 67 | PGbmanN : Pattern { 68 | var <>freq, mul, <>add, <>length; 69 | *new {|freq= 22050, xi= 1.2, yi= 2.1, mul= 1, add= 0, length= inf| 70 | ^super.newCopyArgs(freq, xi, yi, mul, add, length); 71 | } 72 | storeArgs {^[freq, xi, yi, mul, add, length]} 73 | embedInStream {|inval| 74 | var freqStr= freq.asStream; 75 | var mulStr= mul.asStream; 76 | var addStr= add.asStream; 77 | var freqVal, mulVal, addVal; 78 | var x= xi, y= yi; 79 | length.value(inval).do{ 80 | var xPrev; 81 | addVal= addStr.next(inval); 82 | mulVal= mulStr.next(inval); 83 | freqVal= freqStr.next(inval); 84 | if(addVal.isNil or:{mulVal.isNil or:{freqVal.isNil 85 | }}, {^inval}); 86 | xPrev= x; 87 | x= 1-y+abs(xPrev); 88 | y= xPrev; 89 | x= x*freqVal; 90 | inval= (x*mulVal+addVal).yield; 91 | }; 92 | ^inval; 93 | } 94 | } 95 | 96 | PHenonN : Pattern { 97 | var <>freq, <>a, <>b, mul, <>add, <>length; 98 | *new {|freq= 22050, a= 1.4, b= 0.3, x0= 0, x1= 0, mul= 1, add= 0, length= inf| 99 | ^super.newCopyArgs(freq, a, b, x0, x1, mul, add, length); 100 | } 101 | storeArgs {^[freq, a, b, x0, x1, mul, add, length]} 102 | embedInStream {|inval| 103 | var freqStr= freq.asStream; 104 | var aStr= a.asStream; 105 | var bStr= b.asStream; 106 | var mulStr= mul.asStream; 107 | var addStr= add.asStream; 108 | var freqVal, aVal, bVal, mulVal, addVal; 109 | var x; 110 | length.value(inval).do{ 111 | addVal= addStr.next(inval); 112 | mulVal= mulStr.next(inval); 113 | bVal= bStr.next(inval); 114 | aVal= aStr.next(inval); 115 | freqVal= freqStr.next(inval); 116 | if(addVal.isNil or:{mulVal.isNil or:{bVal.isNil or:{aVal.isNil 117 | or:{freqVal.isNil} 118 | }}}, {^inval}); 119 | x= 1-(aVal*(x1**2))+(bVal*x0); 120 | x= x*freqVal; 121 | inval= (x*mulVal+addVal).yield; 122 | x0= x1; 123 | x1= x; 124 | }; 125 | ^inval; 126 | } 127 | } 128 | 129 | PLatoocarfianN : Pattern { 130 | var <>freq, <>a, <>b, <>c, <>d, mul, <>add, <>length; 131 | *new {|freq= 22050, a= 1, b= 3, c= 0.5, d= 0.5, xi= 0.5, yi= 0.5, mul= 1, add= 0, length= inf| 132 | ^super.newCopyArgs(freq, a, b, c, d, xi, yi, mul, add, length); 133 | } 134 | storeArgs {^[freq, a, b, c, d, xi, yi, mul, add, length]} 135 | embedInStream {|inval| 136 | var freqStr= freq.asStream; 137 | var aStr= a.asStream; 138 | var bStr= b.asStream; 139 | var cStr= c.asStream; 140 | var dStr= d.asStream; 141 | var mulStr= mul.asStream; 142 | var addStr= add.asStream; 143 | var freqVal, aVal, bVal, cVal, dVal, mulVal, addVal; 144 | var x= xi, y= yi; 145 | length.value(inval).do{ 146 | var x1; 147 | addVal= addStr.next(inval); 148 | mulVal= mulStr.next(inval); 149 | dVal= dStr.next(inval); 150 | cVal= cStr.next(inval); 151 | bVal= bStr.next(inval); 152 | aVal= aStr.next(inval); 153 | freqVal= freqStr.next(inval); 154 | if(addVal.isNil or:{mulVal.isNil or:{dVal.isNil or:{cVal.isNil 155 | or:{bVal.isNil or:{aVal.isNil or:{freqVal.isNil}}} 156 | }}}, {^inval}); 157 | x1= sin(bVal*y)+(cVal*sin(bVal*x)); 158 | y= sin(aVal*x)+(dVal*sin(aVal*y)); 159 | x1= x1*freqVal; 160 | inval= (x*mulVal+addVal).yield; 161 | x= x1; 162 | }; 163 | ^inval; 164 | } 165 | } 166 | 167 | PLinCongN : Pattern { 168 | var <>freq, <>a, <>c, <>m, mul, <>add, <>length; 169 | *new {|freq= 22050, a= 1.1, c= 0.13, m= 1, xi= 0, mul= 1, add= 0, length= inf| 170 | ^super.newCopyArgs(freq, a, c, m, xi, mul, add, length); 171 | } 172 | storeArgs {^[freq, a, c, m, xi, mul, add, length]} 173 | embedInStream {|inval| 174 | var freqStr= freq.asStream; 175 | var aStr= a.asStream; 176 | var cStr= c.asStream; 177 | var mStr= m.asStream; 178 | var mulStr= mul.asStream; 179 | var addStr= add.asStream; 180 | var freqVal, aVal, cVal, mVal, mulVal, addVal; 181 | var x= xi; 182 | length.value(inval).do{ 183 | addVal= addStr.next(inval); 184 | mulVal= mulStr.next(inval); 185 | mVal= mStr.next(inval); 186 | cVal= cStr.next(inval); 187 | aVal= aStr.next(inval); 188 | freqVal= freqStr.next(inval); 189 | if(addVal.isNil or:{mulVal.isNil or:{mVal.isNil or:{cVal.isNil 190 | or:{aVal.isNil or:{freqVal.isNil}} 191 | }}}, {^inval}); 192 | x= aVal*x+cVal%mVal; 193 | x= x*freqVal; 194 | inval= (x*mulVal+addVal).yield; 195 | }; 196 | ^inval; 197 | } 198 | } 199 | 200 | PStandardN : Pattern { 201 | var <>freq, <>k, mul, <>add, <>length; 202 | *new {|freq= 22050, k= 1, xi= 0.5, yi= 0, mul= 1, add= 0, length= inf| 203 | ^super.newCopyArgs(freq, k, xi, yi, mul, add, length); 204 | } 205 | storeArgs {^[freq, k, xi, yi, mul, add, length]} 206 | embedInStream {|inval| 207 | var freqStr= freq.asStream; 208 | var kStr= k.asStream; 209 | var mulStr= mul.asStream; 210 | var addStr= add.asStream; 211 | var freqVal, kVal, mulVal, addVal; 212 | var x= xi, y= yi; 213 | length.value(inval).do{ 214 | addVal= addStr.next(inval); 215 | mulVal= mulStr.next(inval); 216 | kVal= kStr.next(inval); 217 | freqVal= freqStr.next(inval); 218 | if(addVal.isNil or:{mulVal.isNil or:{kVal.isNil or:{freqVal.isNil 219 | }}}, {^inval}); 220 | y= y+(kVal*sin(x))%2pi; 221 | x= x+y%2pi; 222 | x= x*freqVal; 223 | inval= (x-pi*(1/pi)*mulVal+addVal).yield; 224 | }; 225 | ^inval; 226 | } 227 | } 228 | 229 | PFBSineN : Pattern { 230 | var <>freq, <>im, <>fb, <>a, <>c, mul, <>add, <>length; 231 | *new {|freq= 22050, im= 1, fb= 0.1, a= 1.1, c= 0.5, xi= 0.1, yi= 0.1, mul= 1, add= 0, length= inf| 232 | ^super.newCopyArgs(freq, im, fb, a, c, xi, yi, mul, add, length); 233 | } 234 | storeArgs {^[freq, im, fb, a, c, xi, yi, mul, add, length]} 235 | embedInStream {|inval| 236 | var freqStr= freq.asStream; 237 | var imStr= im.asStream; 238 | var fbStr= fb.asStream; 239 | var aStr= a.asStream; 240 | var cStr= c.asStream; 241 | var mulStr= mul.asStream; 242 | var addStr= add.asStream; 243 | var freqVal, imVal, fbVal, aVal, cVal, mulVal, addVal; 244 | var x= xi, y= yi; 245 | length.value(inval).do{ 246 | addVal= addStr.next(inval); 247 | mulVal= mulStr.next(inval); 248 | cVal= cStr.next(inval); 249 | aVal= aStr.next(inval); 250 | fbVal= fbStr.next(inval); 251 | imVal= imStr.next(inval); 252 | freqVal= freqStr.next(inval); 253 | if(addVal.isNil or:{mulVal.isNil or:{cVal.isNil or:{aVal.isNil 254 | or:{fbVal.isNil or:{imVal.isNil or:{freqVal.isNil}}} 255 | }}}, {^inval}); 256 | x= sin(imVal*freqVal*y+(fbVal*x)); 257 | y= aVal*y+cVal%2pi; 258 | inval= (x*mulVal+addVal).yield; 259 | }; 260 | ^inval; 261 | } 262 | } 263 | 264 | PLorenzN : Pattern { 265 | var <>freq, <>s, <>r, <>b, <>h, mul, <>add, <>length; 266 | *new {|freq= 22050, s= 10, r= 28, b= 2.667, h= 0.05, xi= 0.1, yi= 0, zi= 0, mul= 1, add= 0, length= inf| 267 | ^super.newCopyArgs(freq, s, r, b, h, xi, yi, zi, mul, add, length); 268 | } 269 | storeArgs {^[freq, s, r, b, h, xi, yi, zi, mul, add, length]} 270 | embedInStream {|inval| 271 | var freqStr= freq.asStream; 272 | var sStr= s.asStream; 273 | var rStr= r.asStream; 274 | var bStr= b.asStream; 275 | var hStr= h.asStream; 276 | var mulStr= mul.asStream; 277 | var addStr= add.asStream; 278 | var freqVal, sVal, rVal, bVal, hVal, mulVal, addVal; 279 | var x= xi, y= yi, z= zi; 280 | length.value(inval).do{ 281 | var vx, vy, vz; 282 | addVal= addStr.next(inval); 283 | mulVal= mulStr.next(inval); 284 | hVal= hStr.next(inval); 285 | bVal= bStr.next(inval); 286 | rVal= rStr.next(inval); 287 | sVal= sStr.next(inval); 288 | freqVal= freqStr.next(inval); 289 | if(addVal.isNil or:{mulVal.isNil or:{hVal.isNil or:{bVal.isNil 290 | or:{rVal.isNil or:{sVal.isNil or:{freqVal.isNil}}} 291 | }}}, {^inval}); 292 | vx= sVal*(y-x); 293 | vy= x*(rVal-z)-y; 294 | vz= x*y-(bVal*z); 295 | x= x+(vx*hVal*freqVal); 296 | y= y+(vy*hVal*freqVal); 297 | z= z+(vz*hVal*freqVal); 298 | inval= (x*0.04*mulVal+addVal).yield; //hardcoded value from ChaosUGens.cpp 299 | }; 300 | ^inval; 301 | } 302 | } 303 | -------------------------------------------------------------------------------- /PDelays.sc: -------------------------------------------------------------------------------- 1 | //redFrik 2 | 3 | 4 | PDelay1 : FilterPattern { 5 | var <>mul, <>add; 6 | *new {|pattern, mul= 1, add= 0| 7 | ^super.newCopyArgs(pattern, mul, add); 8 | } 9 | storeArgs {^[pattern, mul, add]} 10 | embedInStream {|inval| 11 | var evtStr= pattern.asStream; 12 | var mulStr= mul.asStream; 13 | var addStr= add.asStream; 14 | var outVal, mulVal, addVal; 15 | var prev= 0; 16 | loop{ 17 | outVal= evtStr.next(inval); 18 | if(outVal.isNil, {^inval}); 19 | mulVal= mulStr.next(outVal); 20 | if(mulVal.isNil, {^inval}); 21 | addVal= addStr.next(outVal); 22 | if(addVal.isNil, {^inval}); 23 | 24 | inval= (prev*mulVal+addVal).yield; 25 | prev= outVal; 26 | }; 27 | } 28 | } 29 | 30 | PDelay2 : PDelay1 { 31 | embedInStream {|inval| 32 | var evtStr= pattern.asStream; 33 | var mulStr= mul.asStream; 34 | var addStr= add.asStream; 35 | var outVal, mulVal, addVal; 36 | var prev= 0, prev2= 0; 37 | loop{ 38 | outVal= evtStr.next(inval); 39 | if(outVal.isNil, {^inval}); 40 | mulVal= mulStr.next(outVal); 41 | if(mulVal.isNil, {^inval}); 42 | addVal= addStr.next(outVal); 43 | if(addVal.isNil, {^inval}); 44 | 45 | inval= (prev2*mulVal+addVal).yield; 46 | prev2= prev; 47 | prev= outVal; 48 | }; 49 | } 50 | } 51 | 52 | PDelayN : FilterPattern { 53 | var <>maxdelaytime, <>delaytime, <>mul, <>add; 54 | *new {|pattern, maxdelaytime= 2, delaytime= 2, mul= 1, add= 0| 55 | ^super.newCopyArgs(pattern, maxdelaytime, delaytime, mul, add); 56 | } 57 | storeArgs {^[pattern, maxdelaytime, delaytime, mul, add]} 58 | embedInStream {|inval| 59 | var evtStr= pattern.asStream; 60 | var delStr= delaytime.asStream; 61 | var mulStr= mul.asStream; 62 | var addStr= add.asStream; 63 | var outVal, delVal, mulVal, addVal; 64 | var delay= Array.fill(maxdelaytime.round, {0}); 65 | loop{ 66 | outVal= evtStr.next(inval); 67 | if(outVal.isNil, {^inval}); 68 | delVal= delStr.next(outVal); 69 | if(delVal.isNil, {^inval}); 70 | mulVal= mulStr.next(outVal); 71 | if(mulVal.isNil, {^inval}); 72 | addVal= addStr.next(outVal); 73 | if(addVal.isNil, {^inval}); 74 | 75 | inval= (delay[0]*mulVal+addVal).yield; 76 | delay= delay.drop(1).add(0).put(delaytime.round.min(maxdelaytime.round-1), outVal); 77 | }; 78 | } 79 | } 80 | 81 | PCombN : FilterPattern { 82 | var <>maxdelaytime, <>delaytime, <>decaytime, <>mul, <>add; 83 | *new {|pattern, maxdelaytime= 2, delaytime= 2, decaytime= 0.5, mul= 1, add= 0| 84 | ^super.newCopyArgs(pattern, maxdelaytime, delaytime, decaytime, mul, add); 85 | } 86 | storeArgs {^[pattern, maxdelaytime, delaytime, decaytime, mul, add]} 87 | embedInStream {|inval| 88 | var evtStr= pattern.asStream; 89 | var delStr= delaytime.asStream; 90 | var decStr= decaytime.asStream; 91 | var mulStr= mul.asStream; 92 | var addStr= add.asStream; 93 | var outVal, delVal, decVal, mulVal, addVal; 94 | var now, delay= Array.fill(maxdelaytime.round, {0}); 95 | loop{ 96 | outVal= evtStr.next(inval); 97 | if(outVal.isNil, {^inval}); 98 | delVal= delStr.next(outVal); 99 | if(delVal.isNil, {^inval}); 100 | decVal= decStr.next(outVal); 101 | if(decVal.isNil, {^inval}); 102 | mulVal= mulStr.next(outVal); 103 | if(mulVal.isNil, {^inval}); 104 | addVal= addStr.next(outVal); 105 | if(addVal.isNil, {^inval}); 106 | 107 | now= delay[0]; 108 | inval= (now*mulVal+addVal).yield; 109 | delay= delay.drop(1).add(0).put(delaytime.round.min(maxdelaytime.round-1), outVal+(now*decVal)); 110 | }; 111 | } 112 | } 113 | -------------------------------------------------------------------------------- /PFSinOsc.sc: -------------------------------------------------------------------------------- 1 | //redFrik 2 | 3 | 4 | PFSinOsc : Pattern { 5 | var <>freq, <>iphase, <>mul, <>add, <>length; 6 | *new {|freq= 440, iphase= 0, mul= 1, add= 0, length= inf| 7 | ^super.newCopyArgs(freq, iphase, mul, add, length); 8 | } 9 | storeArgs {^[freq, iphase, mul, add, length]} 10 | embedInStream {|inval| 11 | var freqStr= freq.asStream; 12 | var mulStr= mul.asStream; 13 | var addStr= add.asStream; 14 | var freqVal, mulVal, addVal; 15 | var theta= 0; 16 | length.value(inval).do{ 17 | addVal= addStr.next(inval); 18 | mulVal= mulStr.next(inval); 19 | freqVal= freqStr.next(inval); 20 | if(addVal.isNil or:{mulVal.isNil or:{freqVal.isNil}}, {^inval}); 21 | inval= (sin(theta/freqVal*2pi+iphase)*mulVal+addVal).yield; 22 | theta= theta+1; 23 | }; 24 | ^inval; 25 | } 26 | } 27 | 28 | PBlip : Pattern { 29 | var <>freq, <>numharm, <>mul, <>add, <>length; 30 | *new {|freq= 440, numharm= 200, mul= 1, add= 0, length= inf| 31 | ^super.newCopyArgs(freq, numharm, mul, add, length); 32 | } 33 | storeArgs {^[freq, numharm, mul, add, length]} 34 | embedInStream {|inval| 35 | var freqStr= freq.asStream; 36 | var numharmStr= numharm.asStream; 37 | var mulStr= mul.asStream; 38 | var addStr= add.asStream; 39 | var freqVal, numharmVal, mulVal, addVal; 40 | var theta= 0, arr; 41 | length.value(inval).do{ 42 | addVal= addStr.next(inval); 43 | mulVal= mulStr.next(inval); 44 | numharmVal= numharmStr.next(inval); 45 | freqVal= freqStr.next(inval); 46 | if(addVal.isNil or:{mulVal.isNil or:{numharmVal.isNil or:{freqVal.isNil}}}, { 47 | ^inval; 48 | }); 49 | arr= freqVal.harmonics(numharmVal.asInteger.max(1)+1).drop(1); 50 | inval= (arr.sum{|a| sin(theta/a*2pi+0.5pi)/arr.size}*mulVal+addVal).yield; 51 | theta= theta+1; 52 | }; 53 | ^inval; 54 | } 55 | } 56 | 57 | PSaw : Pattern { 58 | var <>freq, <>mul, <>add, <>length; 59 | *new {|freq= 440, mul= 1, add= 0, length= inf| 60 | ^super.newCopyArgs(freq, mul, add, length); 61 | } 62 | storeArgs {^[freq, mul, add, length]} 63 | embedInStream {|inval| 64 | var freqStr= freq.asStream; 65 | var mulStr= mul.asStream; 66 | var addStr= add.asStream; 67 | var freqVal, mulVal, addVal; 68 | var counter= 0; 69 | length.value(inval).do{ 70 | addVal= addStr.next(inval); 71 | mulVal= mulStr.next(inval); 72 | freqVal= freqStr.next(inval); 73 | if(addVal.isNil or:{mulVal.isNil or:{freqVal.isNil}}, {^inval}); 74 | inval= (counter*2-1*mulVal+addVal).yield; 75 | counter= counter+freqVal.reciprocal%1; 76 | }; 77 | ^inval; 78 | } 79 | } 80 | 81 | PPulse : Pattern { 82 | var <>freq, <>width, <>mul, <>add, <>length; 83 | *new {|freq= 440, width= 0.5, mul= 1, add= 0, length= inf| 84 | ^super.newCopyArgs(freq, width, mul, add, length); 85 | } 86 | storeArgs {^[freq, width, mul, add, length]} 87 | embedInStream {|inval| 88 | var freqStr= freq.asStream; 89 | var widthStr= width.asStream; 90 | var mulStr= mul.asStream; 91 | var addStr= add.asStream; 92 | var freqVal, widthVal, mulVal, addVal; 93 | var counter= 0; 94 | length.value(inval).do{ 95 | addVal= addStr.next(inval); 96 | mulVal= mulStr.next(inval); 97 | widthVal= widthStr.next(inval); 98 | freqVal= freqStr.next(inval); 99 | if(addVal.isNil or:{mulVal.isNil or:{widthVal.isNil or:{freqVal.isNil}}}, {^inval}); 100 | if(countercoef, <>mul, <>add; 6 | *new {|pattern, coef= 0.5, mul= 1, add= 0| 7 | ^super.newCopyArgs(pattern, coef, mul, add); 8 | } 9 | storeArgs {^[pattern, coef, mul, add]} 10 | embedInStream {|inval| 11 | var evtStr= pattern.asStream; 12 | var cofStr= coef.asStream; 13 | var mulStr= mul.asStream; 14 | var addStr= add.asStream; 15 | var outVal, cofVal, mulVal, addVal; 16 | var prev= 0, out; 17 | loop{ 18 | outVal= evtStr.next(inval); 19 | if(outVal.isNil, {^inval}); 20 | cofVal= cofStr.next(outVal); 21 | if(cofVal.isNil, {^inval}); 22 | mulVal= mulStr.next(outVal); 23 | if(mulVal.isNil, {^inval}); 24 | addVal= addStr.next(outVal); 25 | if(addVal.isNil, {^inval}); 26 | 27 | out= (1-cofVal.abs*outVal+(cofVal*prev)); 28 | inval= (out*mulVal+addVal).yield; 29 | prev= out; 30 | }; 31 | } 32 | } 33 | 34 | POneZero : POnePole { 35 | embedInStream {|inval| 36 | var evtStr= pattern.asStream; 37 | var cofStr= coef.asStream; 38 | var mulStr= mul.asStream; 39 | var addStr= add.asStream; 40 | var outVal, cofVal, mulVal, addVal; 41 | var prev= 0, out; 42 | loop{ 43 | outVal= evtStr.next(inval); 44 | if(outVal.isNil, {^inval}); 45 | cofVal= cofStr.next(outVal); 46 | if(cofVal.isNil, {^inval}); 47 | mulVal= mulStr.next(outVal); 48 | if(mulVal.isNil, {^inval}); 49 | addVal= addStr.next(outVal); 50 | if(addVal.isNil, {^inval}); 51 | 52 | out= (1-cofVal.abs*outVal+(cofVal*prev)); 53 | inval= (out*mulVal+addVal).yield; 54 | prev= outVal; 55 | }; 56 | } 57 | } 58 | 59 | PIntegrator : FilterPattern { 60 | var <>coef, <>mul, <>add; 61 | *new {|pattern, coef= 1.0, mul= 1, add= 0| 62 | ^super.newCopyArgs(pattern, coef, mul, add); 63 | } 64 | storeArgs {^[pattern, coef, mul, add]} 65 | embedInStream {|inval| 66 | var evtStr= pattern.asStream; 67 | var cofStr= coef.asStream; 68 | var mulStr= mul.asStream; 69 | var addStr= add.asStream; 70 | var outVal, cofVal, mulVal, addVal; 71 | var prev= 0, out; 72 | loop{ 73 | outVal= evtStr.next(inval); 74 | if(outVal.isNil, {^inval}); 75 | cofVal= cofStr.next(outVal); 76 | if(cofVal.isNil, {^inval}); 77 | mulVal= mulStr.next(outVal); 78 | if(mulVal.isNil, {^inval}); 79 | addVal= addStr.next(outVal); 80 | if(addVal.isNil, {^inval}); 81 | 82 | out= outVal+(cofVal*prev); 83 | inval= (out*mulVal+addVal).yield; 84 | prev= out; 85 | }; 86 | } 87 | } 88 | 89 | PLPZ1 : FilterPattern { 90 | var <>mul, <>add; 91 | *new {|pattern, mul= 1, add= 0| 92 | ^super.newCopyArgs(pattern, mul, add); 93 | } 94 | storeArgs {^[pattern, mul, add]} 95 | embedInStream {|inval| 96 | var evtStr= pattern.asStream; 97 | var mulStr= mul.asStream; 98 | var addStr= add.asStream; 99 | var outVal, mulVal, addVal; 100 | var prev= 0, out; 101 | loop{ 102 | outVal= evtStr.next(inval); 103 | if(outVal.isNil, {^inval}); 104 | mulVal= mulStr.next(outVal); 105 | if(mulVal.isNil, {^inval}); 106 | addVal= addStr.next(outVal); 107 | if(addVal.isNil, {^inval}); 108 | 109 | out= 0.5*(outVal+prev); 110 | inval= (out*mulVal+addVal).yield; 111 | prev= outVal; 112 | }; 113 | } 114 | } 115 | 116 | PHPZ1 : PLPZ1 { 117 | embedInStream {|inval| 118 | var evtStr= pattern.asStream; 119 | var mulStr= mul.asStream; 120 | var addStr= add.asStream; 121 | var outVal, mulVal, addVal; 122 | var prev= 0, out; 123 | loop{ 124 | outVal= evtStr.next(inval); 125 | if(outVal.isNil, {^inval}); 126 | mulVal= mulStr.next(outVal); 127 | if(mulVal.isNil, {^inval}); 128 | addVal= addStr.next(outVal); 129 | if(addVal.isNil, {^inval}); 130 | 131 | out= 0.5*(outVal-prev); 132 | inval= (out*mulVal+addVal).yield; 133 | prev= outVal; 134 | }; 135 | } 136 | } 137 | 138 | PChanged : FilterPattern { 139 | *new {|pattern, threshold= 0, mul= 1, add= 0| 140 | ^Pif(PHPZ1(pattern, mul, add).abs>threshold, 1, 0); 141 | } 142 | } 143 | 144 | PLPZ2 : FilterPattern { 145 | var <>mul, <>add; 146 | *new {|pattern, mul= 1, add= 0| 147 | ^super.newCopyArgs(pattern, mul, add); 148 | } 149 | storeArgs {^[pattern, mul, add]} 150 | embedInStream {|inval| 151 | var evtStr= pattern.asStream; 152 | var mulStr= mul.asStream; 153 | var addStr= add.asStream; 154 | var outVal, mulVal, addVal; 155 | var prev= 0, prev2= 0, out; 156 | loop{ 157 | outVal= evtStr.next(inval); 158 | if(outVal.isNil, {^inval}); 159 | mulVal= mulStr.next(outVal); 160 | if(mulVal.isNil, {^inval}); 161 | addVal= addStr.next(outVal); 162 | if(addVal.isNil, {^inval}); 163 | 164 | out= 0.25*(outVal+(2*prev)+prev2); 165 | inval= (out*mulVal+addVal).yield; 166 | prev2= prev; 167 | prev= outVal; 168 | }; 169 | } 170 | } 171 | 172 | PHPZ2 : PLPZ2 { 173 | embedInStream {|inval| 174 | var evtStr= pattern.asStream; 175 | var mulStr= mul.asStream; 176 | var addStr= add.asStream; 177 | var outVal, mulVal, addVal; 178 | var prev= 0, prev2= 0, out; 179 | loop{ 180 | outVal= evtStr.next(inval); 181 | if(outVal.isNil, {^inval}); 182 | mulVal= mulStr.next(outVal); 183 | if(mulVal.isNil, {^inval}); 184 | addVal= addStr.next(outVal); 185 | if(addVal.isNil, {^inval}); 186 | 187 | out= 0.25*(outVal-(2*prev)+prev2); 188 | inval= (out*mulVal+addVal).yield; 189 | prev2= prev; 190 | prev= outVal; 191 | }; 192 | } 193 | } 194 | 195 | PBPZ2 : PLPZ2 { 196 | embedInStream {|inval| 197 | var evtStr= pattern.asStream; 198 | var mulStr= mul.asStream; 199 | var addStr= add.asStream; 200 | var outVal, mulVal, addVal; 201 | var prev= 0, prev2= 0, out; 202 | loop{ 203 | outVal= evtStr.next(inval); 204 | if(outVal.isNil, {^inval}); 205 | mulVal= mulStr.next(outVal); 206 | if(mulVal.isNil, {^inval}); 207 | addVal= addStr.next(outVal); 208 | if(addVal.isNil, {^inval}); 209 | 210 | out= 0.5*(outVal-prev2); 211 | inval= (out*mulVal+addVal).yield; 212 | prev2= prev; 213 | prev= outVal; 214 | }; 215 | } 216 | } 217 | 218 | PBRZ2 : PLPZ2 { 219 | embedInStream {|inval| 220 | var evtStr= pattern.asStream; 221 | var mulStr= mul.asStream; 222 | var addStr= add.asStream; 223 | var outVal, mulVal, addVal; 224 | var prev= 0, prev2= 0, out; 225 | loop{ 226 | outVal= evtStr.next(inval); 227 | if(outVal.isNil, {^inval}); 228 | mulVal= mulStr.next(outVal); 229 | if(mulVal.isNil, {^inval}); 230 | addVal= addStr.next(outVal); 231 | if(addVal.isNil, {^inval}); 232 | 233 | out= 0.5*(outVal+prev2); 234 | inval= (out*mulVal+addVal).yield; 235 | prev2= prev; 236 | prev= outVal; 237 | }; 238 | } 239 | } 240 | -------------------------------------------------------------------------------- /PLine.sc: -------------------------------------------------------------------------------- 1 | //redFrik 2 | 3 | 4 | PLine : Pattern { 5 | var <>start, <>end, <>dur, <>mul, <>add, <>length; 6 | *new {|start= 0, end= 1, dur= 1, mul= 1, add= 0, length= inf| 7 | ^super.newCopyArgs(start, end, dur, mul, add, length); 8 | } 9 | storeArgs {^[start, end, dur, mul, add, length]} 10 | embedInStream {|inval| 11 | var mulStr= mul.asStream; 12 | var addStr= add.asStream; 13 | var mulVal, addVal; 14 | var counter= 0; 15 | length.value(inval).do{ 16 | addVal= addStr.next(inval); 17 | mulVal= mulStr.next(inval); 18 | if(addVal.isNil or:{mulVal.isNil}, {^inval}); 19 | inval= (counter.linlin(0, 1, start, end)*mulVal+addVal).yield; 20 | counter= (counter+dur.reciprocal).min(1); 21 | }; 22 | ^inval; 23 | } 24 | } 25 | 26 | PXLine : PLine { 27 | *new {|start= 1, end= 2, dur= 1, mul= 1, add= 0, length= inf| 28 | ^super.newCopyArgs(start, end, dur, mul, add, length); 29 | } 30 | embedInStream {|inval| 31 | var mulStr= mul.asStream; 32 | var addStr= add.asStream; 33 | var mulVal, addVal; 34 | var counter= 0; 35 | length.value(inval).do{ 36 | addVal= addStr.next(inval); 37 | mulVal= mulStr.next(inval); 38 | if(addVal.isNil or:{mulVal.isNil}, {^inval}); 39 | inval= (counter.linexp(0, 1, start, end)*mulVal+addVal).yield; 40 | counter= (counter+dur.reciprocal).min(1); 41 | }; 42 | ^inval; 43 | } 44 | } 45 | 46 | PLinExp : FilterPattern { 47 | var <>srclo, <>srchi, <>dstlo, <>dsthi; 48 | *new {|pattern, srclo= 0, srchi= 1, dstlo= 1, dsthi= 2| 49 | ^super.newCopyArgs(pattern, srclo, srchi, dstlo, dsthi); 50 | } 51 | storeArgs {^[pattern, srclo, srchi, dstlo, dsthi]} 52 | embedInStream {|inval| 53 | var evtStr= pattern.asStream; 54 | var sloStr= srclo.asStream; 55 | var shiStr= srchi.asStream; 56 | var dloStr= dstlo.asStream; 57 | var dhiStr= dsthi.asStream; 58 | var outVal, sloVal, shiVal, dloVal, dhiVal; 59 | loop{ 60 | outVal= evtStr.next(inval); 61 | if(outVal.isNil, {^inval}); 62 | sloVal= sloStr.next(outVal); 63 | if(sloVal.isNil, {^inval}); 64 | shiVal= shiStr.next(outVal); 65 | if(shiVal.isNil, {^inval}); 66 | dloVal= dloStr.next(outVal); 67 | if(dloVal.isNil, {^inval}); 68 | dhiVal= dhiStr.next(outVal); 69 | if(dhiVal.isNil, {^inval}); 70 | 71 | inval= outVal.linexp(sloVal, shiVal, dloVal, dhiVal).yield; 72 | }; 73 | } 74 | } 75 | 76 | PLinLin : FilterPattern { 77 | var <>srclo, <>srchi, <>dstlo, <>dsthi; 78 | *new {|pattern, srclo= 0, srchi= 1, dstlo= 1, dsthi= 2| 79 | ^super.newCopyArgs(pattern, srclo, srchi, dstlo, dsthi); 80 | } 81 | storeArgs {^[pattern, srclo, srchi, dstlo, dsthi]} 82 | embedInStream {|inval| 83 | var evtStr= pattern.asStream; 84 | var sloStr= srclo.asStream; 85 | var shiStr= srchi.asStream; 86 | var dloStr= dstlo.asStream; 87 | var dhiStr= dsthi.asStream; 88 | var outVal, sloVal, shiVal, dloVal, dhiVal; 89 | loop{ 90 | outVal= evtStr.next(inval); 91 | if(outVal.isNil, {^inval}); 92 | sloVal= sloStr.next(outVal); 93 | if(sloVal.isNil, {^inval}); 94 | shiVal= shiStr.next(outVal); 95 | if(shiVal.isNil, {^inval}); 96 | dloVal= dloStr.next(outVal); 97 | if(dloVal.isNil, {^inval}); 98 | dhiVal= dhiStr.next(outVal); 99 | if(dhiVal.isNil, {^inval}); 100 | 101 | inval= outVal.linlin(sloVal, shiVal, dloVal, dhiVal).yield; 102 | }; 103 | } 104 | } 105 | 106 | PDC : Pattern { 107 | var <>in, <>length; 108 | *new {|in= 0, length= inf| 109 | ^super.newCopyArgs(in, length); 110 | } 111 | storeArgs {^[in, length]} 112 | embedInStream {|inval| 113 | var inStr= in.asStream; 114 | var inVal; 115 | length.value(inval).do{ 116 | inVal= inStr.next(inval); 117 | if(inVal.isNil, {^inval}); 118 | inval= inVal.yield; 119 | }; 120 | ^inval; 121 | } 122 | } 123 | 124 | PSilent : Pattern { 125 | var <>numChannels, <>length; 126 | *new {|numChannels= 1, length= inf| 127 | ^super.newCopyArgs(numChannels, length); 128 | } 129 | storeArgs {^[numChannels, length]} 130 | embedInStream {|inval| 131 | var numStr= numChannels.asStream; 132 | var numVal; 133 | length.value(inval).do{ 134 | numVal= numStr.next(inval); 135 | if(numVal.isNil, {^inval}); 136 | if(numVal>1, { 137 | inval= 0.dup(numVal).yield; 138 | }, { 139 | inval= 0.yield; 140 | }); 141 | }; 142 | ^inval; 143 | } 144 | } 145 | -------------------------------------------------------------------------------- /PNoise.sc: -------------------------------------------------------------------------------- 1 | //redFrik 2 | 3 | PRand : Pattern { 4 | var <>lo, <>hi, <>length; 5 | *new {|lo= 0, hi= 1, length= inf| 6 | ^super.newCopyArgs(lo, hi, length); 7 | } 8 | storeArgs {^[lo, hi, length]} 9 | embedInStream {|inval| 10 | var loStr= lo.asStream; 11 | var hiStr= hi.asStream; 12 | var loVal, hiVal; 13 | length.value(inval).do{ 14 | loVal= loStr.next(inval); 15 | hiVal= hiStr.next(inval); 16 | if(loVal.isNil or:{hiVal.isNil}, {^inval}); 17 | inval= lo.asFloat.rrand(hi).yield; 18 | }; 19 | ^inval; 20 | } 21 | } 22 | 23 | PIRand : Pattern { 24 | var <>lo, <>hi, <>length; 25 | *new {|lo= 0, hi= 127, length= inf| 26 | ^super.newCopyArgs(lo, hi, length); 27 | } 28 | storeArgs {^[lo, hi, length]} 29 | embedInStream {|inval| 30 | var loStr= lo.asStream; 31 | var hiStr= hi.asStream; 32 | var loVal, hiVal; 33 | length.value(inval).do{ 34 | loVal= loStr.next(inval); 35 | hiVal= hiStr.next(inval); 36 | if(loVal.isNil or:{hiVal.isNil}, {^inval}); 37 | inval= lo.rrand(hi).asInteger.yield; 38 | }; 39 | ^inval; 40 | } 41 | } 42 | 43 | PExpRand : Pattern { 44 | var <>lo, <>hi, <>length; 45 | *new {|lo= 0.01, hi= 1, length= inf| 46 | ^super.newCopyArgs(lo, hi, length); 47 | } 48 | storeArgs {^[lo, hi, length]} 49 | embedInStream {|inval| 50 | var loStr= lo.asStream; 51 | var hiStr= hi.asStream; 52 | var loVal, hiVal; 53 | length.value(inval).do{ 54 | loVal= loStr.next(inval); 55 | hiVal= hiStr.next(inval); 56 | if(loVal.isNil or:{hiVal.isNil}, {^inval}); 57 | inval= lo.exprand(hi).yield; 58 | }; 59 | ^inval; 60 | } 61 | } 62 | 63 | PWhiteNoise : Pattern { 64 | var <>mul, <>add, <>length; 65 | *new {|mul= 1, add= 0, length= inf| 66 | ^super.newCopyArgs(mul, add, length); 67 | } 68 | storeArgs {^[mul, add, length]} 69 | embedInStream {|inval| 70 | var mulStr= mul.asStream; 71 | var addStr= add.asStream; 72 | var mulVal, addVal; 73 | length.value(inval).do{ 74 | addVal= addStr.next(inval); 75 | mulVal= mulStr.next(inval); 76 | if(addVal.isNil or:{mulVal.isNil}, {^inval}); 77 | inval= (mulVal.rand+addVal).yield; 78 | }; 79 | ^inval; 80 | } 81 | } 82 | 83 | PClipNoise : PWhiteNoise { 84 | embedInStream {|inval| 85 | var mulStr= mul.asStream; 86 | var addStr= add.asStream; 87 | var mulVal, addVal; 88 | length.value(inval).do{ 89 | addVal= addStr.next(inval); 90 | mulVal= mulStr.next(inval); 91 | if(addVal.isNil or:{mulVal.isNil}, {^inval}); 92 | inval= ((2.rand*2*mulVal-mulVal)+addVal).yield; 93 | }; 94 | ^inval; 95 | } 96 | } 97 | 98 | PLFNoise0 : Pattern { 99 | var <>freq, <>mul, <>add, <>length; 100 | *new {|freq= 500, mul= 1, add= 0, length= inf| 101 | ^super.newCopyArgs(freq, mul, add, length); 102 | } 103 | storeArgs {^[freq, mul, add, length]} 104 | embedInStream {|inval| 105 | var freqStr= freq.asStream; 106 | var mulStr= mul.asStream; 107 | var addStr= add.asStream; 108 | var freqVal, mulVal, addVal; 109 | var outval, counter= 0; 110 | length.value(inval).do{ 111 | addVal= addStr.next(inval); 112 | mulVal= mulStr.next(inval); 113 | freqVal= freqStr.next(inval); 114 | if(addVal.isNil or:{mulVal.isNil or:{freqVal.isNil}}, {^inval}); 115 | if(counter<=0, { 116 | counter= freqVal; 117 | outval= mulVal.asFloat.rand2+addVal; 118 | }); 119 | inval= outval.yield; 120 | counter= counter-1; 121 | }; 122 | ^inval; 123 | } 124 | } 125 | 126 | PLFNoise1 : PLFNoise0 { 127 | embedInStream {|inval| 128 | var freqStr= freq.asStream; 129 | var mulStr= mul.asStream; 130 | var addStr= add.asStream; 131 | var freqVal, mulVal, addVal; 132 | var outval, nextval; 133 | var counter= 0; 134 | length.value(inval).do{ 135 | addVal= addStr.next(inval); 136 | mulVal= mulStr.next(inval); 137 | freqVal= freqStr.next(inval); 138 | if(addVal.isNil or:{mulVal.isNil or:{freqVal.isNil}}, {^inval}); 139 | if(counter<=0, { 140 | counter= freqVal; 141 | outval= nextval??{mulVal.asFloat.rand2+addVal}; 142 | nextval= mulVal.asFloat.rand2+addVal; 143 | }); 144 | inval= counter.linlin(0, freqVal, nextval, outval).yield; 145 | counter= counter-1; 146 | }; 147 | ^inval; 148 | } 149 | } 150 | 151 | PLFNoise2 : PLFNoise0 { 152 | embedInStream {|inval| 153 | var freqStr= freq.asStream; 154 | var mulStr= mul.asStream; 155 | var addStr= add.asStream; 156 | var freqVal, mulVal, addVal; 157 | var outval, nextval; 158 | var value, nextmidpt; 159 | var slope= 0, curve; 160 | var counter= 0; 161 | length.value(inval).do{ 162 | addVal= addStr.next(inval); 163 | mulVal= mulStr.next(inval); 164 | freqVal= freqStr.next(inval); 165 | if(addVal.isNil or:{mulVal.isNil or:{freqVal.isNil}}, {^inval}); 166 | if(counter<=0, { 167 | counter= freqVal; 168 | value= nextval??{mulVal.asFloat.rand2+addVal}; 169 | nextval= mulVal.asFloat.rand2+addVal; 170 | outval= nextmidpt??{value}; 171 | nextmidpt= (nextval+value)*0.5; 172 | curve= 2*(nextmidpt-outval-(freqVal*slope))/(freqVal*freqVal+freqVal); 173 | }); 174 | inval= outval.yield; 175 | slope= slope+curve; 176 | outval= outval+slope; 177 | counter= counter-1; 178 | }; 179 | ^inval; 180 | } 181 | } 182 | 183 | PLFClipNoise : PLFNoise0 { 184 | embedInStream {|inval| 185 | var freqStr= freq.asStream; 186 | var mulStr= mul.asStream; 187 | var addStr= add.asStream; 188 | var freqVal, mulVal, addVal; 189 | var outval, counter= 0; 190 | length.value(inval).do{ 191 | addVal= addStr.next(inval); 192 | mulVal= mulStr.next(inval); 193 | freqVal= freqStr.next(inval); 194 | if(addVal.isNil or:{mulVal.isNil or:{freqVal.isNil}}, {^inval}); 195 | if(counter<=0, { 196 | counter= freqVal; 197 | outval= 2.rand*2-1*mulVal+addVal; 198 | }); 199 | inval= outval.yield; 200 | counter= counter-1; 201 | }; 202 | ^inval; 203 | } 204 | } 205 | 206 | PHasher : Pattern { 207 | var <>in, <>mul, <>add, <>length; 208 | *new {|in= 0, mul= 1, add= 0, length= inf| 209 | ^super.newCopyArgs(in, mul, add, length); 210 | } 211 | storeArgs {^[in, mul, add, length]} 212 | embedInStream {|inval| 213 | var inStr= in.asStream; 214 | var mulStr= mul.asStream; 215 | var addStr= add.asStream; 216 | var inVal, mulVal, addVal; 217 | var outval, hash; 218 | length.value(inval).do{ 219 | addVal= addStr.next(inval); 220 | mulVal= mulStr.next(inval); 221 | inVal= inStr.next(inval); 222 | if(addVal.isNil or:{mulVal.isNil or:{inVal.isNil}}, {^inval}); 223 | outval= 0; 224 | hash= inVal.hash; 225 | 23.do{|i| 226 | outval= outval+(2.pow(i)*hash.rightShift(i+9).bitAnd(1)); 227 | }; 228 | outval= Float.from32Bits(0x40000000|outval.asInteger)-3; 229 | outval= outval*mulVal+addVal; 230 | inval= outval.yield; 231 | }; 232 | ^inval; 233 | } 234 | } 235 | 236 | PMantissaMask : Pattern { 237 | var <>in, <>bits, <>mul, <>add, <>length; 238 | *new {|in= 0, bits= 3, mul= 1, add= 0, length= inf| 239 | ^super.newCopyArgs(in, bits, mul, add, length); 240 | } 241 | storeArgs {^[in, bits, mul, add, length]} 242 | embedInStream {|inval| 243 | var inStr= in.asStream; 244 | var bitsStr= bits.asStream; 245 | var mulStr= mul.asStream; 246 | var addStr= add.asStream; 247 | var inVal, bitsVal, mulVal, addVal; 248 | var outval, mask; 249 | length.value(inval).do{ 250 | addVal= addStr.next(inval); 251 | mulVal= mulStr.next(inval); 252 | bitsVal= bitsStr.next(inval); 253 | inVal= inStr.next(inval); 254 | if(addVal.isNil or:{mulVal.isNil or:{bitsVal.isNil or:{inVal.isNil}}}, {^inval}); 255 | mask= -1<<(23-bitsVal); 256 | outval= Float.from32Bits(mask&inVal.asFloat.as32Bits); 257 | outval= outval*mulVal+addVal; 258 | inval= outval.yield; 259 | }; 260 | ^inval; 261 | } 262 | } 263 | 264 | PDust : Pattern { 265 | var <>density, <>mul, <>add, <>length; 266 | *new {|density= 0, mul= 1, add= 0, length= inf| 267 | ^super.newCopyArgs(density, mul, add, length); 268 | } 269 | storeArgs {^[density, mul, add, length]} 270 | embedInStream {|inval| 271 | var densityStr= density.asStream; 272 | var mulStr= mul.asStream; 273 | var addStr= add.asStream; 274 | var densityVal, mulVal, addVal; 275 | var outval; 276 | length.value(inval).do{ 277 | addVal= addStr.next(inval); 278 | mulVal= mulStr.next(inval); 279 | densityVal= densityStr.next(inval); 280 | if(addVal.isNil or:{mulVal.isNil or:{densityVal.isNil}}, {^inval}); 281 | outval= if((1/density).coin, {1.0.rand}, {0.0}); 282 | outval= outval*mulVal+addVal; 283 | inval= outval.yield; 284 | }; 285 | ^inval; 286 | } 287 | } 288 | 289 | PDust2 : PDust { 290 | embedInStream {|inval| 291 | var densityStr= density.asStream; 292 | var mulStr= mul.asStream; 293 | var addStr= add.asStream; 294 | var densityVal, mulVal, addVal; 295 | var outval; 296 | length.value(inval).do{ 297 | addVal= addStr.next(inval); 298 | mulVal= mulStr.next(inval); 299 | densityVal= densityStr.next(inval); 300 | if(addVal.isNil or:{mulVal.isNil or:{densityVal.isNil}}, {^inval}); 301 | outval= if((1/density).coin, {1.0.rand2}, {0.0}); 302 | outval= outval*mulVal+addVal; 303 | inval= outval.yield; 304 | }; 305 | ^inval; 306 | } 307 | } 308 | -------------------------------------------------------------------------------- /POsc.sc: -------------------------------------------------------------------------------- 1 | //redFrik 2 | 3 | 4 | PSinOsc : Pattern { 5 | var <>freq, <>phase, <>mul, <>add, <>length; 6 | *new {|freq= 440, phase= 0, mul= 1, add= 0, length= inf| 7 | ^super.newCopyArgs(freq, phase, mul, add, length); 8 | } 9 | storeArgs {^[freq, phase, mul, add, length]} 10 | embedInStream {|inval| 11 | var freqStr= freq.asStream; 12 | var phaseStr= phase.asStream; 13 | var mulStr= mul.asStream; 14 | var addStr= add.asStream; 15 | var freqVal, phaseVal, mulVal, addVal; 16 | var theta= 0; 17 | length.value(inval).do{ 18 | addVal= addStr.next(inval); 19 | mulVal= mulStr.next(inval); 20 | phaseVal= phaseStr.next(inval); 21 | freqVal= freqStr.next(inval); 22 | if(addVal.isNil or:{mulVal.isNil or:{phaseVal.isNil or:{freqVal.isNil}}}, {^inval}); 23 | inval= (sin(theta/freqVal*2pi+phaseVal)*mulVal+addVal).yield; 24 | theta= theta+1; 25 | }; 26 | ^inval; 27 | } 28 | } 29 | 30 | PLFSaw : Pattern { 31 | var <>freq, <>iphase, <>mul, <>add, <>length; 32 | *new {|freq= 440, iphase= 0, mul= 1, add= 0, length= inf| 33 | ^super.newCopyArgs(freq, iphase, mul, add, length); 34 | } 35 | storeArgs {^[freq, iphase, mul, add, length]} 36 | embedInStream {|inval| 37 | var freqStr= freq.asStream; 38 | var mulStr= mul.asStream; 39 | var addStr= add.asStream; 40 | var freqVal, mulVal, addVal; 41 | var counter= iphase; 42 | length.value(inval).do{ 43 | addVal= addStr.next(inval); 44 | mulVal= mulStr.next(inval); 45 | freqVal= freqStr.next(inval); 46 | if(addVal.isNil or:{mulVal.isNil or:{freqVal.isNil}}, {^inval}); 47 | inval= (counter*2-1*mulVal+addVal).yield; 48 | counter= counter+freqVal.reciprocal%1; 49 | }; 50 | ^inval; 51 | } 52 | } 53 | 54 | PLFTri : PLFSaw { 55 | embedInStream {|inval| 56 | var freqStr= freq.asStream; 57 | var mulStr= mul.asStream; 58 | var addStr= add.asStream; 59 | var freqVal, mulVal, addVal; 60 | var counter= iphase; 61 | length.value(inval).do{ 62 | addVal= addStr.next(inval); 63 | mulVal= mulStr.next(inval); 64 | freqVal= freqStr.next(inval); 65 | if(addVal.isNil or:{mulVal.isNil or:{freqVal.isNil}}, {^inval}); 66 | inval= ((counter*2).fold(-1, 1)*2-1*mulVal+addVal).yield; 67 | counter= counter+freqVal.reciprocal%1; 68 | }; 69 | ^inval; 70 | } 71 | } 72 | 73 | PLFPulse : Pattern { 74 | var <>freq, <>iphase, <>width, <>mul, <>add, <>length; 75 | *new {|freq= 440, iphase= 0, width= 0.5, mul= 1, add= 0, length= inf| 76 | ^super.newCopyArgs(freq, iphase, width, mul, add, length); 77 | } 78 | storeArgs {^[freq, iphase, width, mul, add, length]} 79 | embedInStream {|inval| 80 | var freqStr= freq.asStream; 81 | var widthStr= width.asStream; 82 | var mulStr= mul.asStream; 83 | var addStr= add.asStream; 84 | var freqVal, widthVal, mulVal, addVal; 85 | var counter= iphase; 86 | length.value(inval).do{ 87 | addVal= addStr.next(inval); 88 | mulVal= mulStr.next(inval); 89 | widthVal= widthStr.next(inval); 90 | freqVal= freqStr.next(inval); 91 | if(addVal.isNil or:{mulVal.isNil or:{widthVal.isNil or:{freqVal.isNil}}}, {^inval}); 92 | if(counterfreq, <>phase, <>mul, <>add, <>length; 105 | *new {|freq= 440, phase= 0, mul= 1, add= 0, length= inf| 106 | ^super.newCopyArgs(freq, phase, mul, add, length); 107 | } 108 | storeArgs {^[freq, phase, mul, add, length]} 109 | embedInStream {|inval| 110 | var freqStr= freq.asStream; 111 | var phaseStr= phase.asStream; 112 | var mulStr= mul.asStream; 113 | var addStr= add.asStream; 114 | var freqVal, phaseVal, mulVal, addVal; 115 | var counter= 0, flag= false; 116 | length.value(inval).do{ 117 | addVal= addStr.next(inval); 118 | mulVal= mulStr.next(inval); 119 | phaseVal= phaseStr.next(inval); 120 | freqVal= freqStr.next(inval); 121 | if(addVal.isNil or:{mulVal.isNil or:{phaseVal.isNil or:{freqVal.isNil}}}, {^inval}); 122 | if(counter>=phaseVal and:{flag.not}, { 123 | inval= (mulVal+addVal).yield; 124 | flag= true; 125 | }, { 126 | inval= addVal.yield; 127 | }); 128 | counter= counter+freqVal.reciprocal; 129 | if(counter>=1, { 130 | counter= counter%1; 131 | flag= false; 132 | }); 133 | }; 134 | ^inval; 135 | } 136 | } -------------------------------------------------------------------------------- /PTrig.sc: -------------------------------------------------------------------------------- 1 | //redFrik 2 | 3 | 4 | PTrig1 : FilterPattern { 5 | var <>dur; 6 | *new {|pattern, dur= 1| 7 | ^super.newCopyArgs(pattern, dur); 8 | } 9 | storeArgs {^[pattern, dur]} 10 | embedInStream {|inval| 11 | var evtStr= pattern.asStream; 12 | var durStr= dur.asStream; 13 | var outVal, durVal; 14 | var counter= 0, prev= 0; 15 | loop{ 16 | outVal= evtStr.next(inval); 17 | if(outVal.isNil, {^inval}); 18 | durVal= durStr.next(outVal); 19 | if(durVal.isNil, {^inval}); 20 | 21 | if(prev<=0 and:{outVal>0 and:{counter==0}}, { 22 | counter= durVal; 23 | }); 24 | inval= (counter>0).binaryValue.yield; 25 | counter= (counter-1).max(0); 26 | prev= outVal; 27 | }; 28 | } 29 | } 30 | 31 | PTrig : PTrig1 { 32 | embedInStream {|inval| 33 | var evtStr= pattern.asStream; 34 | var durStr= dur.asStream; 35 | var outVal, durVal; 36 | var counter= 0, prev= 0, trig= 0; 37 | loop{ 38 | outVal= evtStr.next(inval); 39 | if(outVal.isNil, {^inval}); 40 | durVal= durStr.next(outVal); 41 | if(durVal.isNil, {^inval}); 42 | 43 | if(prev<=0 and:{outVal>0 and:{counter==0}}, { 44 | counter= durVal; 45 | trig= outVal; 46 | }); 47 | if(counter>0, { 48 | inval= trig.yield; 49 | }, { 50 | inval= 0.yield; 51 | }); 52 | counter= (counter-1).max(0); 53 | prev= outVal; 54 | }; 55 | } 56 | } 57 | 58 | PTDelay : PTrig1 { 59 | embedInStream {|inval| 60 | var evtStr= pattern.asStream; 61 | var durStr= dur.asStream; 62 | var outVal, durVal; 63 | var counter= 0, prev= 0; 64 | loop{ 65 | outVal= evtStr.next(inval); 66 | if(outVal.isNil, {^inval}); 67 | durVal= durStr.next(outVal); 68 | if(durVal.isNil, {^inval}); 69 | 70 | if(prev<=0 and:{outVal>0 and:{counter==0}}, { 71 | counter= durVal+1; 72 | }); 73 | if(counter>1, { 74 | inval= 0.yield; 75 | }, { 76 | if(counter==1, { 77 | inval= 1.yield; 78 | }, { 79 | inval= 0.yield; 80 | }); 81 | }); 82 | counter= (counter-1).max(0); 83 | prev= outVal; 84 | }; 85 | } 86 | } 87 | 88 | PLatch : FilterPattern { 89 | var <>trig; 90 | *new {|pattern, trig= 0| 91 | ^super.newCopyArgs(pattern, trig); 92 | } 93 | storeArgs {^[pattern, trig]} 94 | embedInStream {|inval| 95 | var evtStr= pattern.asStream; 96 | var trgStr= trig.asStream; 97 | var outVal, trgVal; 98 | var prev= 0, hold; 99 | loop{ 100 | outVal= evtStr.next(inval); 101 | if(outVal.isNil, {^inval}); 102 | trgVal= trgStr.next(outVal); 103 | if(trgVal.isNil, {^inval}); 104 | 105 | if(prev<=0 and:{trgVal>0}, { 106 | hold= outVal; 107 | }); 108 | if(hold.notNil, { 109 | if(trgVal<=0, { 110 | hold= nil; 111 | inval= outVal.yield; 112 | }, { 113 | inval= hold.yield; 114 | }); 115 | }, { 116 | inval= outVal.yield; 117 | }); 118 | prev= trgVal; 119 | }; 120 | } 121 | } 122 | 123 | PGate : PLatch { 124 | embedInStream {|inval| 125 | var evtStr= pattern.asStream; 126 | var trgStr= trig.asStream; 127 | var outVal, trgVal; 128 | var hold; 129 | loop{ 130 | outVal= evtStr.next(inval); 131 | if(outVal.isNil, {^inval}); 132 | trgVal= trgStr.next(outVal); 133 | if(trgVal.isNil, {^inval}); 134 | 135 | if(trgVal>0, { 136 | hold= outVal; 137 | inval= outVal.yield; 138 | }, { 139 | if(hold.isNil, {hold= outVal}); 140 | inval= hold.yield; 141 | }); 142 | }; 143 | } 144 | } 145 | 146 | PPulseCount : FilterPattern { 147 | var <>reset; 148 | *new {|pattern, reset= 0| 149 | ^super.newCopyArgs(pattern, reset); 150 | } 151 | storeArgs {^[pattern, reset]} 152 | embedInStream {|inval| 153 | var evtStr= pattern.asStream; 154 | var rstStr= reset.asStream; 155 | var outVal, rstVal; 156 | var counter= 0, prev= 0, prev2= 0; 157 | loop{ 158 | outVal= evtStr.next(inval); 159 | if(outVal.isNil, {^inval}); 160 | rstVal= rstStr.next(outVal); 161 | if(rstVal.isNil, {^inval}); 162 | 163 | if(prev<=0 and:{outVal>0}, { 164 | counter= counter+1; 165 | }); 166 | if(prev2<=0 and:{rstVal>0}, { 167 | counter= 0; 168 | }); 169 | inval= counter.yield; 170 | prev= outVal; 171 | prev2= rstVal; 172 | }; 173 | } 174 | } 175 | 176 | PPeak : PPulseCount { 177 | embedInStream {|inval| 178 | var evtStr= pattern.asStream; 179 | var rstStr= reset.asStream; 180 | var outVal, rstVal; 181 | var peak, prev= 0; 182 | loop{ 183 | outVal= evtStr.next(inval); 184 | if(outVal.isNil, {^inval}); 185 | rstVal= rstStr.next(outVal); 186 | if(rstVal.isNil, {^inval}); 187 | 188 | if(peak.isNil, {peak= outVal}); 189 | if(outVal.abs>peak, { 190 | peak= outVal.abs; 191 | }); 192 | if(prev<=0 and:{rstVal>0}, { 193 | peak= outVal.abs; 194 | }); 195 | inval= peak.yield; 196 | prev= rstVal; 197 | }; 198 | } 199 | } 200 | 201 | PRunningMin : PPeak { 202 | embedInStream {|inval| 203 | var evtStr= pattern.asStream; 204 | var rstStr= reset.asStream; 205 | var outVal, rstVal; 206 | var peak, prev= 0; 207 | loop{ 208 | outVal= evtStr.next(inval); 209 | if(outVal.isNil, {^inval}); 210 | rstVal= rstStr.next(outVal); 211 | if(rstVal.isNil, {^inval}); 212 | 213 | if(peak.isNil, {peak= outVal}); 214 | if(outVal0}, { 218 | peak= outVal; 219 | }); 220 | inval= peak.yield; 221 | prev= rstVal; 222 | }; 223 | } 224 | } 225 | 226 | PRunningMax : PPeak { 227 | embedInStream {|inval| 228 | var evtStr= pattern.asStream; 229 | var rstStr= reset.asStream; 230 | var outVal, rstVal; 231 | var peak, prev= 0; 232 | loop{ 233 | outVal= evtStr.next(inval); 234 | if(outVal.isNil, {^inval}); 235 | rstVal= rstStr.next(outVal); 236 | if(rstVal.isNil, {^inval}); 237 | 238 | if(peak.isNil, {peak= outVal}); 239 | if(outVal>peak, { 240 | peak= outVal; 241 | }); 242 | if(prev<=0 and:{rstVal>0}, { 243 | peak= outVal; 244 | }); 245 | inval= peak.yield; 246 | prev= rstVal; 247 | }; 248 | } 249 | } 250 | 251 | PToggleFF : FilterPattern { 252 | *new {|pattern| 253 | ^super.newCopyArgs(pattern); 254 | } 255 | storeArgs {^[pattern]} 256 | embedInStream {|inval| 257 | var evtStr= pattern.asStream; 258 | var outVal; 259 | var toggle= 0, prev= 0; 260 | loop{ 261 | outVal= evtStr.next(inval); 262 | if(outVal.isNil, {^inval}); 263 | 264 | if(prev<=0 and:{outVal>0}, { 265 | toggle= 1-toggle; 266 | }); 267 | inval= toggle.yield; 268 | prev= outVal; 269 | }; 270 | } 271 | } 272 | 273 | PInRange : FilterPattern { 274 | var <>lo, <>hi; 275 | *new {|pattern, lo= 0, hi= 1| 276 | ^super.newCopyArgs(pattern, lo, hi); 277 | } 278 | storeArgs {^[pattern, lo, hi]} 279 | embedInStream {|inval| 280 | var evtStr= pattern.asStream; 281 | var lowStr= lo.asStream; 282 | var higStr= hi.asStream; 283 | var outVal, lowVal, higVal; 284 | loop{ 285 | outVal= evtStr.next(inval); 286 | if(outVal.isNil, {^inval}); 287 | lowVal= lowStr.next(outVal); 288 | if(lowVal.isNil, {^inval}); 289 | higVal= higStr.next(outVal); 290 | if(higVal.isNil, {^inval}); 291 | 292 | inval= (outVal>=lowVal and:{outVal<=higVal}).binaryValue.yield; 293 | }; 294 | } 295 | } 296 | 297 | PInRect : FilterPattern { 298 | var <>y= 0, <>rect; 299 | *new {|pattern, y= 0, rect| 300 | ^super.newCopyArgs(pattern, y, rect); 301 | } 302 | storeArgs {^[pattern, y, rect]} 303 | embedInStream {|inval| 304 | var xStr= pattern.asStream; 305 | var yStr= y.asStream; 306 | var rectStr= rect.asStream; 307 | var xVal, yVal, rectVal; 308 | loop{ 309 | xVal= xStr.next(inval); 310 | if(xVal.isNil, {^inval}); 311 | yVal= yStr.next(inval); 312 | if(yVal.isNil, {^inval}); 313 | rectVal= rectStr.next(inval); 314 | if(rectVal.isNil, {^inval}); 315 | 316 | inval= rectVal.containsPoint(Point(xVal, yVal)).binaryValue.yield; 317 | }; 318 | } 319 | } 320 | 321 | PFold : PInRange { 322 | embedInStream {|inval| 323 | var evtStr= pattern.asStream; 324 | var lowStr= lo.asStream; 325 | var higStr= hi.asStream; 326 | var outVal, lowVal, higVal; 327 | loop{ 328 | outVal= evtStr.next(inval); 329 | if(outVal.isNil, {^inval}); 330 | lowVal= lowStr.next(outVal); 331 | if(lowVal.isNil, {^inval}); 332 | higVal= higStr.next(outVal); 333 | if(higVal.isNil, {^inval}); 334 | 335 | inval= outVal.fold(lowVal, higVal).yield; 336 | }; 337 | } 338 | } 339 | 340 | PClip : PInRange { 341 | embedInStream {|inval| 342 | var evtStr= pattern.asStream; 343 | var lowStr= lo.asStream; 344 | var higStr= hi.asStream; 345 | var outVal, lowVal, higVal; 346 | loop{ 347 | outVal= evtStr.next(inval); 348 | if(outVal.isNil, {^inval}); 349 | lowVal= lowStr.next(outVal); 350 | if(lowVal.isNil, {^inval}); 351 | higVal= higStr.next(outVal); 352 | if(higVal.isNil, {^inval}); 353 | 354 | inval= outVal.clip(lowVal, higVal).yield; 355 | }; 356 | } 357 | } 358 | 359 | PWrap : PInRange { 360 | embedInStream {|inval| 361 | var evtStr= pattern.asStream; 362 | var lowStr= lo.asStream; 363 | var higStr= hi.asStream; 364 | var outVal, lowVal, higVal; 365 | loop{ 366 | outVal= evtStr.next(inval); 367 | if(outVal.isNil, {^inval}); 368 | lowVal= lowStr.next(outVal); 369 | if(lowVal.isNil, {^inval}); 370 | higVal= higStr.next(outVal); 371 | if(higVal.isNil, {^inval}); 372 | 373 | inval= outVal.wrap(lowVal, higVal).yield; 374 | }; 375 | } 376 | } 377 | 378 | PSchmidt : PInRange { 379 | embedInStream {|inval| 380 | var state= 0; 381 | var evtStr= pattern.asStream; 382 | var lowStr= lo.asStream; 383 | var higStr= hi.asStream; 384 | var outVal, lowVal, higVal; 385 | loop{ 386 | outVal= evtStr.next(inval); 387 | if(outVal.isNil, {^inval}); 388 | lowVal= lowStr.next(outVal); 389 | if(lowVal.isNil, {^inval}); 390 | higVal= higStr.next(outVal); 391 | if(higVal.isNil, {^inval}); 392 | 393 | if(state==1, { 394 | if(outValhigVal, { 399 | state= 1; 400 | }); 401 | }); 402 | inval= state.yield; 403 | }; 404 | } 405 | } 406 | 407 | PLastValue : FilterPattern { 408 | var <>diff; 409 | *new {|pattern, diff= 0.01| 410 | ^super.newCopyArgs(pattern, diff); 411 | } 412 | storeArgs {^[pattern, diff]} 413 | embedInStream {|inval| 414 | var evtStr= pattern.asStream; 415 | var difStr= diff.asStream; 416 | var outVal, difVal; 417 | var prev= 0, hold; 418 | loop{ 419 | outVal= evtStr.next(inval); 420 | if(outVal.isNil, {^inval}); 421 | difVal= difStr.next(outVal); 422 | if(difVal.isNil, {^inval}); 423 | 424 | if((outVal-prev).abs>difVal, { 425 | hold= prev; 426 | }); 427 | if(hold.isNil, {hold= outVal}); 428 | inval= hold.yield; 429 | prev= outVal; 430 | }; 431 | } 432 | } 433 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | a [Quark](https://supercollider-quarks.github.io/quarks/) for [SuperCollider](https://supercollider.github.io) 2 | 3 | install it from within supercollider with the command `Quarks.install("UGenPatterns")` and then recompile. 4 | 5 | See Overview -> UGenPatterns in the help system. 6 | 7 | # UGenPatterns 8 | 9 | The main idea behind the UGenPatterns quark is to take advantage of the interface we've already learned by using the normal audio UGens. It simplifies things like LFO modulation on a stream of numbers. No need to do the math - just reuse the knowledge you have about how for example SinOsc works. 10 | 11 | --- 12 | 13 | ## Generators 14 | * PBlip 15 | * PClipNoise 16 | * PCuspN 17 | * PDC 18 | * PDust 19 | * PDust2 20 | * PExpRand 21 | * PFBSineN 22 | * PFSinOsc 23 | * PGbmanN 24 | * PHenonN 25 | * PImpulse 26 | * PIRand 27 | * PLatoocarfianN 28 | * PLFClipNoise 29 | * PLFNoise0 30 | * PLFNoise1 31 | * PLFNoise2 32 | * PLFPulse 33 | * PLFSaw 34 | * PLFTri 35 | * PLinCongN 36 | * PLine 37 | * PLorenzN 38 | * PMouseButton[^1] 39 | * PMouseX[^2] 40 | * PMouseY[^2] 41 | * PPulse 42 | * PQuadN 43 | * PRand 44 | * PSaw 45 | * PSilent 46 | * PSinOsc 47 | * PWhiteNoise 48 | * PXLine 49 | 50 | ## Modifiers 51 | * PBPZ2 52 | * PBRZ2 53 | * PClip 54 | * PCombN 55 | * PDelay1 56 | * PDelay2 57 | * PDelayN 58 | * PFold 59 | * PGate 60 | * PHasher 61 | * PHPZ1 62 | * PHPZ2 63 | * PInRange 64 | * PInRect 65 | * PIntegrator 66 | * PLastValue 67 | * PLatch 68 | * PLinExp 69 | * PLinLin 70 | * PLPZ1 71 | * PLPZ2 72 | * PMantissaMask 73 | * POnePole 74 | * POneZero 75 | * PPeak 76 | * PPulseCount 77 | * PRunningMax 78 | * PRunningMin 79 | * PSchmidt 80 | * PTDelay 81 | * PToggleFF 82 | * PTrig 83 | * PTrig1 84 | * PWrap 85 | 86 | [^1]: macOS only with an old SuperCollider version (3.5 or earler) 87 | [^2]: Qt GUI only 88 | -------------------------------------------------------------------------------- /UGenPatterns.quark: -------------------------------------------------------------------------------- 1 | ( 2 | \name: "UGenPatterns", 3 | \path: "UGenPatterns", 4 | \schelp: "Overviews/UGenPatterns", 5 | \since: "2009", 6 | \version: "1.4", 7 | \summary: "patterns acting as ugens", 8 | \author: "redFrik" 9 | ) 10 | -------------------------------------------------------------------------------- /osx/scide_scapp/PMacUGens.sc: -------------------------------------------------------------------------------- 1 | //redFrik 2 | 3 | //only osx, and only sc3.4 or sc3.5 in 32bit mode (i.e. something is broken under 64bit sc3.5) 4 | 5 | /* 6 | PMouseX : Pattern { 7 | classvar screenBounds; 8 | var <>minval, <>maxval, <>warp, <>lag, <>length; 9 | *new {|minval= 0, maxval= 1, warp= 0, lag= 0.2, length= inf| 10 | ^super.newCopyArgs(minval, maxval, warp, lag, length); 11 | } 12 | *initClass { 13 | StartUp.add({ 14 | screenBounds= Window.screenBounds; 15 | }); 16 | } 17 | storeArgs {^[minval, maxval, warp, lag, length]} 18 | embedInStream {|inval| 19 | var minStr= minval.asStream; 20 | var maxStr= maxval.asStream; 21 | var warpStr= warp.asStream; 22 | //var lagStr= lag.asStream; 23 | var minVal, maxVal, warpVal/*, lagVal*/; 24 | var mouse; 25 | length.value(inval).do{ 26 | minVal= minStr.next(inval); 27 | maxVal= maxStr.next(inval); 28 | warpVal= warpStr.next(inval); 29 | //lagVal= lagStr.next(inval); 30 | if(minVal.isNil or:{maxVal.isNil or:{warpVal.isNil /*or:{lagVal.isNil}*/}}, {^inval}); 31 | mouse= SCNSObject("NSEvent", "mouseLocation").x; 32 | if(warp==0 or:{warp==\linear}, { 33 | inval= mouse.linlin(0, screenBounds.width, minVal, maxVal).yield; 34 | }, { 35 | if(warp==1 or:{warp==\exponential}, { 36 | inval= mouse.linexp(0, screenBounds.width, minVal, maxVal).yield; 37 | }, { 38 | (this.class.name++": lag argument not recognized.").warn; 39 | ^inval; 40 | }); 41 | }); 42 | }; 43 | ^inval; 44 | } 45 | } 46 | 47 | PMouseY : PMouseX { 48 | embedInStream {|inval| 49 | var minStr= minval.asStream; 50 | var maxStr= maxval.asStream; 51 | var warpStr= warp.asStream; 52 | //var lagStr= lag.asStream; 53 | var minVal, maxVal, warpVal, lagVal; 54 | var mouse; 55 | length.value(inval).do{ 56 | minVal= minStr.next(inval); 57 | maxVal= maxStr.next(inval); 58 | warpVal= warpStr.next(inval); 59 | //lagVal= lagStr.next(inval); 60 | if(minVal.isNil or:{maxVal.isNil or:{warpVal.isNil /*or:{lagVal.isNil}*/}}, {^inval}); 61 | mouse= SCNSObject("NSEvent", "mouseLocation").y; 62 | if(warp==0 or:{warp==\linear}, { 63 | inval= mouse.linlin(0, screenBounds.height, minVal, maxVal).yield; 64 | }, { 65 | if(warp==1 or:{warp==\exponential}, { 66 | inval= mouse.linexp(0, screenBounds.height, minVal, maxVal).yield; 67 | }, { 68 | (this.class.name++": lag argument not recognized.").warn; 69 | ^inval; 70 | }); 71 | }); 72 | }; 73 | ^inval; 74 | } 75 | } 76 | */ 77 | 78 | PMouseButton : Pattern { 79 | var <>minval, <>maxval, <>lag, <>length; 80 | *new {|minval= 0, maxval= 1, lag= 0.2, length= inf| 81 | ^super.newCopyArgs(minval, maxval, lag, length); 82 | } 83 | storeArgs {^[minval, maxval, lag, length]} 84 | embedInStream {|inval| 85 | var minStr= minval.asStream; 86 | var maxStr= maxval.asStream; 87 | //var lagStr= lag.asStream; 88 | var minVal, maxVal/*, lagVal*/; 89 | var mouse; 90 | length.value(inval).do{ 91 | minVal= minStr.next(inval); 92 | maxVal= maxStr.next(inval); 93 | //lagVal= lagStr.next(inval); 94 | if(minVal.isNil or:{maxVal.isNil /*or:{lagVal.isNil}*/}, {^inval}); 95 | mouse= SCNSObject("NSEvent", "pressedMouseButtons"); 96 | inval= mouse.linlin(0, 1, minVal, maxVal).yield; 97 | }; 98 | ^inval; 99 | } 100 | } 101 | -------------------------------------------------------------------------------- /scide_scqt/PMacUGens.sc: -------------------------------------------------------------------------------- 1 | //redFrik 2 | 3 | //requires Qt GUI 4 | 5 | PMouseX : Pattern { 6 | classvar >updateRate= 0.1, screenBounds, <>cursorPosition, cursorLag; 7 | 8 | var <>minval, <>maxval, <>warp, <>lag, <>length; 9 | *new {|minval= 0, maxval= 1, warp= 0, lag= 0.2, length= inf| 10 | ^super.newCopyArgs(minval, maxval, warp, lag, length).initPMouse; 11 | } 12 | initPMouse { 13 | if(SkipJack.all.any{|x| x.name==\PMouse}.not, { 14 | cursorLag= 0.2; 15 | cursorPosition= cursorPosition ?? {Point(0, 0)}; 16 | screenBounds= Window.screenBounds; 17 | SkipJack({ 18 | var cp= QtGUI.cursorPosition; 19 | cursorPosition= cursorPosition+(cp-cursorPosition/(cursorLag+1)); 20 | }, updateRate, false, \PMouse, AppClock); 21 | }); 22 | } 23 | storeArgs {^[minval, maxval, warp, lag, length]} 24 | embedInStream {|inval| 25 | var minStr= minval.asStream; 26 | var maxStr= maxval.asStream; 27 | var warpStr= warp.asStream; 28 | var lagStr= lag.asStream; 29 | var minVal, maxVal, warpVal, lagVal; 30 | var mouse; 31 | length.value(inval).do{ 32 | minVal= minStr.next(inval); 33 | maxVal= maxStr.next(inval); 34 | warpVal= warpStr.next(inval); 35 | lagVal= lagStr.next(inval); 36 | if(minVal.isNil or:{maxVal.isNil or:{warpVal.isNil or:{lagVal.isNil}}}, {^inval}); 37 | cursorLag= lagVal.max(0); 38 | mouse= this.prCursor; 39 | if(warp==0 or:{warp==\linear}, { 40 | inval= mouse.linlin(0, this.prBounds, minVal, maxVal).yield; 41 | }, { 42 | if(warp==1 or:{warp==\exponential}, { 43 | inval= mouse.linexp(0, this.prBounds, minVal, maxVal).yield; 44 | }, { 45 | (this.class.name++": lag argument not recognized.").warn; 46 | ^inval; 47 | }); 48 | }); 49 | }; 50 | ^inval; 51 | } 52 | prCursor {^cursorPosition.x} 53 | prBounds {^screenBounds.width} 54 | } 55 | 56 | PMouseY : PMouseX { 57 | prCursor {^cursorPosition.y} 58 | prBounds {^screenBounds.height} 59 | } 60 | 61 | /* 62 | PMouseButton : Pattern { 63 | } 64 | */ 65 | --------------------------------------------------------------------------------