oof

public/system-files/lib.orc.bak

@@ -0,0 +1,414 @@
+;       instruments management
+instr KillImpl
+  Sinstr = p4
+  if (nstrnum(Sinstr) > 0) then
+    turnoff2(Sinstr, 0, 0)
+  endif
+  turnoff
+endin
+
+opcode kill, 0, S
+	Sinstr xin
+	schedule("KillImpl", 0, .05, Sinstr)
+endop
+    
+opcode refresh, 0, S
+	Sinstr xin
+	if (nstrnum(Sinstr) > 0) then
+    	    kill(Sinstr)
+    	    schedule(Sinstr, ksmps / sr, -1)
+	endif
+endop
+
+#define _endin #
+endin
+refresh("livecoding")
+#
+
+opcode rint, i, ii
+	imin, imax xin
+	irnd = int(random:i(imin, int(imax) + 0.99))
+	xout irnd
+endop
+
+opcode rint, k, kk
+	kmin, kmax xin
+	krnd = int(random:k(kmin, int(kmax) + 0.99))
+	xout krnd
+endop
+
+opcode euclidian, k, kkkk
+  konset, kdiv, kpulses, krot xin
+  kphasor = gkphasor
+  kph = int( ( ( (kphasor + krot)  * kdiv) / 1) * kpulses)
+  keucval = int((konset / kpulses) * kph)
+  kold_euc init i(keucval)
+  kold_ph init i(kph)
+  kres = ((kold_euc != keucval) && (kold_ph != kph)) ? 1 : 0
+  kold_euc = keucval
+  kold_ph = kph
+  xout kres
+endop
+
+// Simple rhythm array
+opcode array_rhythm, k, k[]
+  karr[] xin
+  kmet = gkbeat
+  kcnt init 0
+  ilen = lenarray(karr)
+  ktrig = 0
+  if ( kmet > 0 ) then  
+    kval = karr[kcnt]
+    ktrig = kval
+    kcnt = (kcnt + 1) % ilen 
+  endif
+
+  xout ktrig
+endop
+
+opcode trunc, k, k
+  kx xin
+  ky = (kx < 0) ? -(floor(-kx)) : floor(kx)
+  xout ky
+endop
+opcode mfmod, k, kk
+  kone, ktwo xin
+  kres = kone - trunc(kone/ktwo) * ktwo
+  xout kres
+endop
+
+opcode phase_trig, k, k
+  kphase xin
+  kold init 1
+  ktrigger init 0
+  ktrigger = 0
+  if (kold > kphase) then 
+    ktrigger = 1
+  endif
+  kold = kphase
+  xout ktrigger
+endop
+
+opcode downprint, 0, kki
+  kprint, kdown, imargin xin
+  kcnt init 0
+  if (kcnt == 0) then 
+    printk2(kprint, imargin)
+  endif
+  kcnt = (kcnt + 1) % kdown
+endop
+
+  
+opcode phasor_fqmult, k, kk
+  kphase, kmult xin
+  if (kmult <= 0) then 
+    kmult = 1
+  endif
+  kfphase init 0
+  if (kmult <= 1) then 
+    kfphase = mfmod(gkslowph * (kmult * 100), 1)
+  elseif (kmult > 1) then 
+    kfphase = mfmod(gkslowph * (kmult * 100), 1)
+    ;kfphase= mfmod(gkphasor * kmult, 1)
+  endif
+  xout kfphase
+endop
+
+opcode rh_subd, k, k[]P
+  karr[], kpdiv xin
+  ilen = lenarray(karr)
+  if (kpdiv <= 0) then 
+    kpdiv = ilen
+  endif
+  kdiv = kpdiv
+  kph = phasor_fqmult(gkphasor, kdiv )
+  ktr = phase_trig(kph)
+  kidx init 0
+  ktrigger = 0
+  if (ktr == 1) then 
+    ktrigger = karr[kidx]
+    kidx = (kidx+1) % ilen
+  endif
+  xout ktrigger
+endop
+
+opcode rhythm, k, k[]P
+  karr[], kpdiv xin
+  ilen = lenarray(karr)
+  if (kpdiv <= 0) then 
+    kpdiv = ilen
+  endif
+  kdiv = kpdiv
+  kph = phasor_fqmult(gkphasor, kdiv)
+  ktr = phase_trig(kph)
+  kidx init 0
+  ktrigger = 0
+  if (ktr == 1) then 
+    ktrigger = karr[kidx]
+    kidx = (kidx+1) % ilen
+  endif
+  xout ktrigger
+endop
+  
+opcode beat, k, k
+  kmult xin
+  kmult = limit:k(kmult, 0.001, 1000)
+  km = rhythm(array(1), kmult)
+  ;kph = phasor:k(kmult * gktempo)
+  ;km = phase_trig(kph)
+  xout km
+endop
+
+opcode swing, k, kk
+  kspeed, ksw xin
+  ktrig init 0
+  kold init 0
+  kph = phasor_fqmult(gkphasor, kspeed)
+  ktr1 = phase_trig(kph)
+  ktr2 = 0
+  if (kold < ksw && kph >= ksw) then 
+   ktr2 = 0.6
+  endif
+  kold = kph
+  ktrig = limit:k(ktr1 + ktr2, 0, 1)
+  xout ktrig
+endop
+  
+opcode drunk, k, kk
+  kspeed, kdrunk xin
+  kold init 0
+  kspeed = limit:k(kspeed, 0.001, 1000)
+  knoi = random:k(0, kdrunk)
+
+  kph = phasor_fqmult(gkphasor, kspeed)
+  ;kph = phase_incr_mod(gkphasor, 1/ kspeed)
+  ktrig = limit:k(phase_trig(kph) + ((kold < knoi && kph > knoi) ? 1 : 0), 0, 1) 
+
+  kold = kph
+  xout ktrig
+endop
+
+
+opcode filter_first_trig, k, k
+  ktrig xin
+  ksub init 1
+  ktrig -= ksub
+  ksub = 0
+  xout ktrig
+endop
+
+opcode check_trig, k, k
+  ktrig xin 
+  kf = filter_first_trig(ktrig)
+  kres = (changed:k(kf) > 0 && kf > 0) ? 1 : 0
+  xout kres
+endop
+
+opcode to_tempo_dur, k, k
+  kdur xin
+  ktdur = kdur / gktempo
+  xout ktdur
+endop
+
+opcode chance, k, kk
+  kmin, kmax xin
+  kres = random:k(kmin, kmax)
+  xout kres
+endop
+
+opcode alternate, k, kkkO
+  kone, ktwo, kspeed, kduty xin
+
+  if (kduty == 0) then 
+    kduty = 0.5
+  endif
+  if (kspeed <= 0) then 
+    kspeed = 1
+  endif
+  kspeed = limit:k(to_tempo_dur(kspeed), 0.0001, 1000)
+  kph = phasor_fqmult(gkphasor, kspeed)
+  kres init i(kone)
+  if (kph < kduty) then 
+    kres = kone
+  else 
+    kres = ktwo
+  endif
+  xout kres
+endop
+
+opcode trajectory, k, kkk
+  kfrom, kdur, kto xin
+  kdur = to_tempo_dur(kdur)
+  kres = linseg:k( i(kfrom), i(kdur), i(kto) )
+  xout kres
+endop
+
+opcode oscillation, k, kkk
+  kmin, kmax, kspeed xin
+  if (kmin > kmax) then
+    ktmp = kmin
+    kmin = kmax
+    kmax = ktmp
+  endif
+  kspeed = limit:k(gktempo / kspeed, 0.001, 1000)
+  
+  kfq = kspeed ; / gktempo
+  iphs init i(gkphasor)
+  kosc = oscili(0.5, kfq, -1, iphs) + 0.5
+  kres = kosc * (kmax - kmin) + kmin
+  xout kres
+endop
+
+opcode sequence, k, k[]P
+  karr[], kpdiv xin
+  ilen = lenarray(karr)
+  if (kpdiv <= 0) then 
+    kpdiv = ilen
+  endif
+  kdiv = kpdiv
+  kph = phasor_fqmult(gkphasor, kdiv )
+  ktr = phase_trig(kph)
+  kidx init 0
+  if (ktr == 1) then 
+    kidx = (kidx+1) % ilen
+  endif
+  ktrigger = karr[kidx]
+  xout ktrigger
+endop
+
+opcode random_array_int, i[], iii
+	isize, imin, imax xin	
+	iarr[] init isize
+
+	icnt init 0
+	while icnt < isize do 
+		iarr[icnt] = int(random:i(imin, imax+0.99))
+		icnt += 1
+	od
+	xout iarr
+endop
+
+opcode random_array_int, k[], iii
+	isize, imin, imax xin
+	kArr[] init isize
+	icnt init 0
+	iArr[] = random_array_int(isize, imin, imax)
+	while icnt < isize do
+		kArr[icnt] = iArr[icnt]
+		icnt += 1
+	od
+	xout kArr
+endop
+
+#define arr #fillarray(#
+
+; kind of random based savage
+opcode savage_1, k, 0
+  k1 = gkmirlorenz_x
+  k2 = abs(oscili:k(1, gkmirlorenz_y * 6 + 0.01))
+  k3 = rspline:k(0, gkmirlorenz_z, 1, 5)
+
+  kfq = gkmirlorenz_x * rspline:k(1, 3, 1, 5) + 0.001
+  kmod = beat(kfq) ;lfo:k(1, kfq, 3)
+
+  ksel init 0
+  ksel_sig init 0
+  if (trigger:k(kmod, 0.5, 0) == 1) then 
+    ksel = rint:k(0, 2)
+  endif
+
+  if (ksel == 0) then 
+    ksel_sig = k1
+  elseif (ksel == 1) then 
+    ksel_sig = k2
+  elseif (ksel == 2) then 
+    ksel_sig = k3 
+  endif
+  
+  kres = (kmod > 0) ? ksel_sig : 0
+  xout kres
+endop
+
+; direct lorenz savage mode 
+opcode savage_2, k, 0
+  kmult = pow(abs(lfo:k(1, rspline:k(0, gklorenz_x, 0.1, 3), 1)),3)
+  kmod = abs(poscil:k( pow(gkmirlorenz_z, 3) * kmult, gkmirlorenz_x * gkmirlorenz_y * 40))
+  xout kmod
+endop
+
+; pwm based savage mode
+opcode savage_3, k, 0
+  kduty = gkmirlorenz_y
+  kph = phasor:k(gkmirlorenz_x * 5 )
+  kres init 0
+  if (kph < kduty) then
+    kres = 1
+  else 
+    kres = 0
+  endif
+
+  kmult = mirror:k(gklorenz_z, 0, 1)
+  kres *= kmult
+  xout kres
+endop
+
+opcode savage_4, k, 0
+  iarr[] = fillarray(random:i(0, 1), random:i(0, 1), random:i(0, 1), random:i(0, 1))
+
+  kchange init 1
+  kchange = changed:k(round(abs(gklorenz_x )))
+  kmod init 1
+  if (kchange == 1) then 
+    iarr[0] = random:i(0, 1)
+    iarr[1] = random:i(0, 1)
+    iarr[2] = random:i(0, 1)
+    iarr[3] = random:i(0, 1)
+  endif
+  ksel = int(abs(gklorenz_x) * 4.99) % 4
+  kres = limit:k (lineto(iarr[ksel], mirror:k(abs(gklorenz_y), 0, 1) ), 0, 1)
+  xout kres
+endop
+
+opcode savage_5, k, 0
+  kamp = pow(abs(gklorenz_x), 2)
+  kfq = 8 - (0.01 + abs(gklorenz_y) * 8)
+  kmod = oscili:k(kamp, kfq)
+  xout kmod
+endop
+  
+opcode chaos_rhythm, k, kk
+  kchoice, kthresh xin 
+  kthresh = limit:k(kthresh, 0, 1)
+  kchoice = int(limit:k(kchoice, 1, 3.99))
+  kval init 0
+  if (kchoice == 1) then 
+    kval = gkmirlorenz_x
+  elseif (kchoice == 2) then 
+    kval = gkmirlorenz_y
+  elseif (kchoice == 3) then 
+    kval = gkmirlorenz_z
+  endif
+
+  kres = trigger:k(kval, kthresh, 2)
+  xout kres
+endop
+
+opcode chaos_control, k, kkk
+  kchoice, kmin, kmax xin
+  kmax = max:k(kmin, kmax)
+  kmin = min:k(kmin, kmax)
+  kchoice = int(limit:k(kchoice, 1, 3.99))
+  kval init 0
+  if (kchoice == 1) then 
+    kval = gkmirlorenz_x
+  elseif (kchoice == 2) then 
+    kval = gkmirlorenz_y
+  elseif (kchoice == 3) then 
+    kval = gkmirlorenz_z
+  endif
+  kdiff = kmax - kmin
+  kres = kval * kdiff + kmin
+  xout kres
+endop
+
+