go 2013-11-06T13:15:21+0000
[maximus:clive.git] / src / go.c
1 #include <math.h>
2 #include <stdlib.h>
3
4 #define PI 3.141592653
5 #define SR 48000
6 #define BPM 136
7 #define COUNT 8
8 #define BEATS 5
9
10 struct cellsynth {
11   int subcell;
12   int cell;
13   float freq;
14   float env;
15   float phase;
16   float lop;
17 };
18
19 struct kick {
20   float env;
21   int beat;
22 };
23
24 struct hat {
25   float env;
26   int beat;
27 };
28
29 struct snare {
30   float env;
31   int beat;
32   float x;
33   float y;
34 };
35
36 struct comb {
37   int delwrite;
38   int delread1;
39   int delread2;
40   float delay[SR];
41   int beat;
42   float lop;
43   float gate;
44 };
45
46 typedef struct {
47   float like_a_butterfly;
48   int sample;
49   int beat;
50   struct cellsynth cellsynth[COUNT];
51   struct kick kick;
52   struct hat hat;
53   struct snare snare;
54   struct comb comb;
55 } S;
56
57 int cell(struct cellsynth *s) {
58   int old = s->cell & (1 << s->subcell);
59   s->subcell++;
60   if (s->subcell >= BEATS) {
61     s->subcell = 0;
62     s->cell = (~(((s->cell >> 1) | (s->cell << (BEATS - 1))) ^ s->cell)) & ((1 << BEATS) - 1);
63   }
64   return (!!(s->cell & (1 << s->subcell))) < (!!old);
65 }
66
67 int beat(S *s) {
68   s->sample++;
69   if (s->sample >= 60 * SR / BPM / 4) {
70     s->beat = (s->beat + 1) % 64;
71     s->sample = 0;
72     return 1;
73   }
74   return 0;
75 }
76
77 void trigger(struct cellsynth *s, float k) {
78   s->env += k;
79 }
80
81 float decay(struct cellsynth *s) {
82   return s->lop = (s->env *= 0.9998) * 0.1 + 0.9 * s->lop;
83 }
84
85 float noise() {
86   return rand() / (float) RAND_MAX - 0.5;
87 }
88
89 float phasor(struct cellsynth *s) {
90   s->freq *= exp(noise() / 500);
91   return s->phase = fmodf(s->phase + s->freq/SR, 1);
92 }
93
94 void hit(S *s) {
95   for (int i = 0; i < COUNT; ++i) {
96     trigger(&s->cellsynth[i], cell(&s->cellsynth[i]) * 1.0);// / (i + 1));
97   }
98 }
99
100 float hear(struct cellsynth *s, int i) {
101   return sinf(0.005 * SR / s->freq * decay(s) * sinf(2 * PI * phasor(s)));
102 }
103
104 float hears(S *s) {
105   float h = 0;
106   for (int i = 0; i < COUNT; ++i) {
107     h += hear(&s->cellsynth[i], i);
108   }
109   return sinf(3 * h);
110 }
111
112
113
114 void inits(S *s) {
115   for (int i = 0; i < COUNT; ++i) {
116     s->cellsynth[i].freq = 60 + (60 + noise()) * i;
117 //    s->cellsynth[i].cell = rand() & ((1 << BEATS) - 1);
118 /*
119     s->cellsynth[i].env = 0;
120     s->cellsynth[i].phase = 0;
121     s->cellsynth[i].subcell = 0;
122 */
123   }
124 }
125
126 float hat(struct hat *hat, float fb) {
127   return noise() * (hat->env *= fb);
128 }
129
130 float kick(struct kick *kick) {
131   return tanhf(2 * (kick->env + 1) * sinf((kick->env *= 0.9993) * 16 * PI));
132 }
133
134 float snare(struct snare *s) {
135   s->x = s->x * 0.5 + noise() * (s->env *= 0.9995);
136   s->y = tanhf(s->x + 0.99 * s->y);
137   return s->y;
138 }
139
140 float comb(struct comb *s, float x) {
141   float y = s->delay[(s->delwrite - s->delread1 + SR) % SR];
142   y -= s->delay[(s->delwrite - s->delread2 + SR) % SR];
143   y = x - tanhf(0.5 * y);
144   s->delay[s->delwrite = (s->delwrite + 1) % SR] = (s->lop = 0.5 * s->lop + 0.5 * y);
145   return x + s->gate * y;
146 }
147
148 float go(S *s, float x) {
149
150 //memset(s, 0, sizeof(S));
151 //inits(s);
152
153   if (beat(s)) {
154     hit(s);
155     s->hat.env += (s->hat.beat = (s->hat.beat + 1) % 8) % 4 == 3;
156     s->kick.env += ((s->kick.beat = (s->kick.beat + 1) % 4) == 2);
157     s->snare.env += ((s->snare.beat = (s->snare.beat + 1) % 8) == 3);
158     if (s->kick.beat == 0) {
159       s->comb.beat = (s->comb.beat + 1) % 16;
160       s->comb.delread1 = SR / (50 * (1 + s->comb.beat / 4.0));
161       s->comb.delread2 = SR / (50 * (1 + ((s->comb.beat + 8) % 16) / 4.0));
162     }
163     s->comb.gate = 1;// - s->comb.gate;
164     if (s->beat % 8 == 0) {
165     int i = (s->beat / 8) % COUNT;
166 /*
167     switch(s->beat) {
168       case 0:
169         s->cellsynth[i].freq = 180 + (180 + noise()) * i;
170         break;
171       case 16:
172 */
173         s->cellsynth[i].freq = 60;
174 }
175 /*
176         break;
177       case 32:
178         s->cellsynth[i].freq = 120 + (120 + noise()) * i;
179         break;
180       case 48:
181         s->cellsynth[i].freq = 90 + (90 + noise()) * i;
182         break;
183      }
184 */
185   }
186   return tanhf(hears(s) + 0*hat(&s->hat, 0.999) + 2 * kick(&s->kick) + 0 * snare(&s->snare));// + kick(&s->kick) + hat(&s->hat, 0.998));
187 }