/
state.h
372 lines (326 loc) · 11 KB
/
state.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
#ifndef _STATE_H_
#define _STATE_H_
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include "command.h"
#include "every.h"
#include "scale.h"
#include "tele_rand.h"
#include "turtle.h"
#include "types.h"
#define STACK_SIZE 16
#define CV_COUNT 4
#define Q_LENGTH 64
#define TR_COUNT 4
#define TRIGGER_INPUTS 8
#define DELAY_SIZE 16
#define STACK_OP_SIZE 16
#define PATTERN_COUNT 4
#define PATTERN_LENGTH 64
#define SCRIPT_MAX_COMMANDS 6
#define SCRIPT_COUNT 11
#define EXEC_DEPTH 8
#define WHILE_DEPTH 10000
#define RAND_STATES_COUNT 5
#define GRID_GROUP_COUNT 64
#define GRID_MAX_DIMENSION 16
#define GRID_BUTTON_COUNT 256
#define GRID_FADER_COUNT 64
#define GRID_XYPAD_COUNT 8
#define LED_DIM -1
#define LED_BRI -2
#define LED_OFF -3
// H - horizontal, V - vertical
// C - coarse, F - fine
// H must be even, V must be odd
#define FADER_CH_BAR 0
#define FADER_CV_BAR 1
#define FADER_CH_DOT 2
#define FADER_CV_DOT 3
#define FADER_COARSE FADER_CV_DOT
#define FADER_FH_BAR 4
#define FADER_FV_BAR 5
#define FADER_FH_DOT 6
#define FADER_FV_DOT 7
#define METRO_MIN_MS 25
#define METRO_MIN_UNSUPPORTED_MS 2
////////////////////////////////////////////////////////////////////////////////
// SCENE STATE /////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// clang-format off
typedef struct {
// Maintaining this order allows for efficient access to the group
// WARNING: DO NOT CHANGE THE ORDER OF VARIABLES a THROUGH t
int16_t a;
int16_t x;
int16_t b;
int16_t y;
int16_t c;
int16_t z;
int16_t d;
int16_t t;
// END WARNING SECTION
int16_t j[SCRIPT_COUNT];
int16_t k[SCRIPT_COUNT];
int16_t cv[CV_COUNT];
int16_t cv_off[CV_COUNT];
int16_t cv_slew[CV_COUNT];
int16_t drunk;
int16_t drunk_max;
int16_t drunk_min;
int16_t drunk_wrap;
int16_t flip;
int16_t in;
int16_t m;
bool m_act;
bool mutes[TRIGGER_INPUTS]; // TODO: replace with uint8_t bits
int16_t o;
int16_t o_inc;
int16_t o_min;
int16_t o_max;
int16_t o_wrap;
int16_t p_n;
int16_t param;
int16_t q[Q_LENGTH];
int16_t q_n;
int16_t r_min;
int16_t r_max;
int16_t scene;
int64_t time;
uint8_t time_act;
int16_t tr[TR_COUNT];
int16_t tr_pol[TR_COUNT];
int16_t tr_time[TR_COUNT];
int16_t seed;
scale_data_t in_range;
scale_t in_scale;
scale_data_t param_range;
scale_t param_scale;
} scene_variables_t;
// clang-format on
typedef struct {
int16_t idx;
uint16_t len;
uint16_t wrap;
int16_t start;
int16_t end;
int16_t val[PATTERN_LENGTH];
} scene_pattern_t;
typedef struct {
// TODO add a delay variables struct?
tele_command_t commands[DELAY_SIZE];
int16_t time[DELAY_SIZE];
uint8_t origin_script[DELAY_SIZE];
int16_t origin_i[DELAY_SIZE];
uint8_t count;
} scene_delay_t;
typedef struct {
tele_command_t commands[STACK_OP_SIZE];
uint8_t top;
} scene_stack_op_t;
typedef struct {
uint8_t l;
tele_command_t c[SCRIPT_MAX_COMMANDS];
every_count_t every[SCRIPT_MAX_COMMANDS];
uint32_t last_time;
} scene_script_t;
typedef struct {
u8 enabled;
u8 group;
u8 x, y;
u8 w, h;
s16 level;
s8 script;
} grid_common_t;
typedef struct {
u8 enabled;
s8 script;
s16 fader_min;
s16 fader_max;
} grid_group_t;
typedef struct {
grid_common_t common;
u8 latch;
u8 state;
} grid_button_t;
typedef struct {
grid_common_t common;
u8 type;
u8 value;
u8 slide;
u8 slide_acc;
u8 slide_end;
u8 slide_delta;
u8 slide_dir;
} grid_fader_t;
typedef struct {
grid_common_t common;
u8 value_x;
u8 value_y;
} grid_xypad_t;
typedef struct {
u8 grid_dirty;
u8 scr_dirty;
u8 clear_held;
u8 rotate;
u8 dim;
u8 current_group;
u8 latest_group;
u8 latest_button;
u8 latest_fader;
s8 leds[GRID_MAX_DIMENSION][GRID_MAX_DIMENSION];
grid_group_t group[GRID_GROUP_COUNT];
grid_button_t button[GRID_BUTTON_COUNT];
grid_fader_t fader[GRID_FADER_COUNT];
grid_xypad_t xypad[GRID_XYPAD_COUNT];
} scene_grid_t;
typedef union {
struct {
tele_rand_t rand;
tele_rand_t prob;
tele_rand_t toss;
tele_rand_t pattern;
tele_rand_t drunk;
} s;
tele_rand_t a[RAND_STATES_COUNT];
} scene_rand_t;
typedef struct {
bool initializing;
scene_variables_t variables;
scene_pattern_t patterns[PATTERN_COUNT];
scene_delay_t delay;
scene_stack_op_t stack_op;
int16_t tr_pulse_timer[TR_COUNT];
scene_script_t scripts[SCRIPT_COUNT];
scene_turtle_t turtle;
bool every_last;
scene_grid_t grid;
scene_rand_t rand_states;
cal_data_t cal;
} scene_state_t;
extern void ss_init(scene_state_t *ss);
extern void ss_variables_init(scene_state_t *ss);
extern void ss_patterns_init(scene_state_t *ss);
extern void ss_pattern_init(scene_state_t *ss, size_t pattern_no);
extern void ss_grid_init(scene_state_t *ss);
extern void ss_grid_common_init(grid_common_t *gc);
extern void ss_rand_init(scene_state_t *ss);
extern void ss_set_in(scene_state_t *ss, int16_t value);
extern void ss_set_param(scene_state_t *ss, int16_t value);
extern void ss_set_scene(scene_state_t *ss, int16_t value);
extern bool ss_get_mute(scene_state_t *ss, size_t idx);
extern void ss_set_mute(scene_state_t *ss, size_t idx, bool value);
extern int16_t ss_get_pattern_idx(scene_state_t *ss, size_t pattern);
extern void ss_set_pattern_idx(scene_state_t *ss, size_t pattern, int16_t i);
extern int16_t ss_get_pattern_len(scene_state_t *ss, size_t pattern);
extern void ss_set_pattern_len(scene_state_t *ss, size_t pattern, int16_t l);
extern uint16_t ss_get_pattern_wrap(scene_state_t *ss, size_t pattern);
extern void ss_set_pattern_wrap(scene_state_t *ss, size_t pattern,
uint16_t wrap);
extern int16_t ss_get_pattern_start(scene_state_t *ss, size_t pattern);
extern void ss_set_pattern_start(scene_state_t *ss, size_t pattern,
int16_t start);
extern int16_t ss_get_pattern_end(scene_state_t *ss, size_t pattern);
extern void ss_set_pattern_end(scene_state_t *ss, size_t pattern, int16_t end);
extern int16_t ss_get_pattern_val(scene_state_t *ss, size_t pattern,
size_t idx);
extern void ss_set_pattern_val(scene_state_t *ss, size_t pattern, size_t idx,
int16_t val);
extern scene_pattern_t *ss_patterns_ptr(scene_state_t *ss);
extern size_t ss_patterns_size(void);
uint8_t ss_get_script_len(scene_state_t *ss, script_number_t idx);
const tele_command_t *ss_get_script_command(scene_state_t *ss,
script_number_t script_idx,
size_t c_idx);
void ss_copy_script_command(tele_command_t *dest, scene_state_t *ss,
script_number_t script_idx, size_t c_idx);
bool ss_get_script_comment(scene_state_t *ss, script_number_t script_idx,
size_t c_idx);
void ss_set_script_comment(scene_state_t *ss, script_number_t script_idx,
size_t c_idx, uint8_t on);
void ss_toggle_script_comment(scene_state_t *ss, script_number_t script_idx,
size_t c_idx);
void ss_overwrite_script_command(scene_state_t *ss, script_number_t script_idx,
size_t command_idx, const tele_command_t *cmd);
void ss_insert_script_command(scene_state_t *ss, script_number_t script_idx,
size_t command_idx, const tele_command_t *cmd);
void ss_delete_script_command(scene_state_t *ss, script_number_t script_idx,
size_t command_idx);
void ss_clear_script(scene_state_t *ss, size_t script_idx);
scene_script_t *ss_scripts_ptr(scene_state_t *ss);
size_t ss_scripts_size(void);
int16_t ss_get_script_last(scene_state_t *ss, script_number_t idx);
void ss_update_script_last(scene_state_t *ss, script_number_t idx);
every_count_t *ss_get_every(scene_state_t *ss, script_number_t idx,
uint8_t line);
void ss_sync_every(scene_state_t *ss, int16_t count);
bool every_is_now(scene_state_t *ss, every_count_t *e);
bool skip_is_now(scene_state_t *ss, every_count_t *e);
scene_turtle_t *ss_turtle_get(scene_state_t *);
void ss_turtle_set(scene_state_t *, scene_turtle_t *);
int16_t ss_turtle_get_val(scene_state_t *, scene_turtle_t *);
void ss_turtle_set_val(scene_state_t *, scene_turtle_t *, int16_t);
void ss_set_param_scale(scene_state_t *, int16_t, int16_t);
void ss_set_in_scale(scene_state_t *, int16_t, int16_t);
void ss_update_in_scale(scene_state_t *);
void ss_update_param_scale(scene_state_t *);
int16_t ss_get_param(scene_state_t *);
int16_t ss_get_in(scene_state_t *);
int16_t ss_get_in_min(scene_state_t *);
int16_t ss_get_in_max(scene_state_t *);
void ss_set_in_min(scene_state_t *, int16_t);
void ss_set_in_max(scene_state_t *, int16_t);
void ss_reset_in_cal(scene_state_t *);
int16_t ss_get_param_min(scene_state_t *);
int16_t ss_get_param_max(scene_state_t *);
void ss_set_param_min(scene_state_t *, int16_t);
void ss_set_param_max(scene_state_t *, int16_t);
void ss_reset_param_cal(scene_state_t *);
////////////////////////////////////////////////////////////////////////////////
// EXEC STATE //////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
typedef struct {
bool if_else_condition;
int16_t i;
bool while_continue;
uint16_t while_depth;
bool breaking;
script_number_t script_number;
uint8_t line_number;
bool delayed;
} exec_vars_t;
typedef struct {
exec_vars_t variables[EXEC_DEPTH];
uint8_t exec_depth;
bool overflow;
} exec_state_t;
extern void es_init(exec_state_t *es);
extern size_t es_depth(exec_state_t *es);
extern size_t es_push(exec_state_t *es);
extern size_t es_pop(exec_state_t *es);
extern void es_set_script_number(exec_state_t *es, uint8_t script_number);
extern void es_set_line_number(exec_state_t *es, uint8_t line_number);
extern uint8_t es_get_line_number(exec_state_t *es);
extern exec_vars_t *es_variables(exec_state_t *es);
////////////////////////////////////////////////////////////////////////////////
// COMMAND STATE ///////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
typedef struct {
int16_t values[STACK_SIZE];
int16_t top;
} command_state_stack_t;
typedef struct { command_state_stack_t stack; } command_state_t;
extern void cs_init(command_state_t *cs);
extern int16_t cs_stack_size(command_state_t *cs);
// by declaring the following static inline, each compilation unit (i.e. C
// file), gets its own copy of the function
static inline int16_t cs_pop(command_state_t *cs) {
cs->stack.top--;
return cs->stack.values[cs->stack.top];
}
static inline void cs_push(command_state_t *cs, int16_t data) {
cs->stack.values[cs->stack.top] = data;
cs->stack.top++;
}
#endif