/[svn]/linuxsampler/trunk/src/engines/common/InstrumentScriptVMFunctions.h
ViewVC logotype

Contents of /linuxsampler/trunk/src/engines/common/InstrumentScriptVMFunctions.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3335 - (show annotations) (download) (as text)
Sun Jul 30 14:33:15 2017 UTC (6 years, 7 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 20165 byte(s)
* NKSP: Added built-in script function "change_pan_time()".
* NKSP: Added built-in script function "change_pan_curve()".
* Bumped version (2.0.0.svn75).

1 /*
2 * Copyright (c) 2014 - 2017 Christian Schoenebeck
3 *
4 * http://www.linuxsampler.org
5 *
6 * This file is part of LinuxSampler and released under the same terms.
7 * See README file for details.
8 */
9
10 #ifndef LS_INSTRSCRIPTVMFUNCTIONS_H
11 #define LS_INSTRSCRIPTVMFUNCTIONS_H
12
13 #include "../../common/global.h"
14 #include "../../scriptvm/CoreVMFunctions.h"
15 #include "Note.h"
16
17 namespace LinuxSampler {
18
19 class EventGroup;
20 class InstrumentScriptVM;
21
22 class InstrumentScriptVMFunction_play_note : public VMIntResultFunction {
23 public:
24 InstrumentScriptVMFunction_play_note(InstrumentScriptVM* parent);
25 int minRequiredArgs() const { return 1; }
26 int maxAllowedArgs() const { return 4; }
27 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
28 ExprType_t argType(int iArg) const { return INT_EXPR; }
29 VMFnResult* exec(VMFnArgs* args);
30 protected:
31 InstrumentScriptVM* m_vm;
32 };
33
34 class InstrumentScriptVMFunction_set_controller : public VMIntResultFunction {
35 public:
36 InstrumentScriptVMFunction_set_controller(InstrumentScriptVM* parent);
37 int minRequiredArgs() const { return 2; }
38 int maxAllowedArgs() const { return 2; }
39 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
40 ExprType_t argType(int iArg) const { return INT_EXPR; }
41 VMFnResult* exec(VMFnArgs* args);
42 protected:
43 InstrumentScriptVM* m_vm;
44 };
45
46 class InstrumentScriptVMFunction_ignore_event : public VMEmptyResultFunction {
47 public:
48 InstrumentScriptVMFunction_ignore_event(InstrumentScriptVM* parent);
49 int minRequiredArgs() const { return 0; }
50 int maxAllowedArgs() const { return 1; }
51 bool acceptsArgType(int iArg, ExprType_t type) const;
52 ExprType_t argType(int iArg) const { return INT_EXPR; }
53 VMFnResult* exec(VMFnArgs* args);
54 protected:
55 InstrumentScriptVM* m_vm;
56 };
57
58 class InstrumentScriptVMFunction_ignore_controller : public VMEmptyResultFunction {
59 public:
60 InstrumentScriptVMFunction_ignore_controller(InstrumentScriptVM* parent);
61 int minRequiredArgs() const { return 0; }
62 int maxAllowedArgs() const { return 1; }
63 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
64 ExprType_t argType(int iArg) const { return INT_EXPR; }
65 VMFnResult* exec(VMFnArgs* args);
66 protected:
67 InstrumentScriptVM* m_vm;
68 };
69
70 class InstrumentScriptVMFunction_note_off : public VMEmptyResultFunction {
71 public:
72 InstrumentScriptVMFunction_note_off(InstrumentScriptVM* parent);
73 int minRequiredArgs() const { return 1; }
74 int maxAllowedArgs() const { return 2; }
75 bool acceptsArgType(int iArg, ExprType_t type) const;
76 ExprType_t argType(int iArg) const { return INT_EXPR; }
77 VMFnResult* exec(VMFnArgs* args);
78 protected:
79 InstrumentScriptVM* m_vm;
80 };
81
82 class InstrumentScriptVMFunction_set_event_mark : public VMEmptyResultFunction {
83 public:
84 InstrumentScriptVMFunction_set_event_mark(InstrumentScriptVM* parent);
85 int minRequiredArgs() const { return 2; }
86 int maxAllowedArgs() const { return 2; }
87 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
88 ExprType_t argType(int iArg) const { return INT_EXPR; }
89 VMFnResult* exec(VMFnArgs* args);
90 protected:
91 InstrumentScriptVM* m_vm;
92 };
93
94 class InstrumentScriptVMFunction_delete_event_mark : public VMEmptyResultFunction {
95 public:
96 InstrumentScriptVMFunction_delete_event_mark(InstrumentScriptVM* parent);
97 int minRequiredArgs() const { return 2; }
98 int maxAllowedArgs() const { return 2; }
99 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
100 ExprType_t argType(int iArg) const { return INT_EXPR; }
101 VMFnResult* exec(VMFnArgs* args);
102 protected:
103 InstrumentScriptVM* m_vm;
104 };
105
106 class InstrumentScriptVMFunction_by_marks : public VMFunction {
107 public:
108 InstrumentScriptVMFunction_by_marks(InstrumentScriptVM* parent);
109 int minRequiredArgs() const OVERRIDE { return 1; }
110 int maxAllowedArgs() const OVERRIDE { return 1; }
111 bool acceptsArgType(int iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
112 bool modifiesArg(int iArg) const OVERRIDE { return false; }
113 ExprType_t argType(int iArg) const OVERRIDE { return INT_EXPR; }
114 ExprType_t returnType() OVERRIDE { return INT_ARR_EXPR; }
115 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
116 protected:
117 InstrumentScriptVM* m_vm;
118 class Result : public VMFnResult, public VMIntArrayExpr {
119 public:
120 StmtFlags_t flags;
121 EventGroup* eventGroup;
122
123 int arraySize() const OVERRIDE;
124 int evalIntElement(uint i) OVERRIDE;
125 void assignIntElement(uint i, int value) OVERRIDE {} // ignore assignment
126 VMExpr* resultValue() OVERRIDE { return this; }
127 StmtFlags_t resultFlags() OVERRIDE { return flags; }
128 bool isConstExpr() const OVERRIDE { return false; }
129 } m_result;
130
131 VMFnResult* errorResult();
132 VMFnResult* successResult(EventGroup* eventGroup);
133 };
134
135 class InstrumentScriptVMFunction_change_vol : public VMEmptyResultFunction {
136 public:
137 InstrumentScriptVMFunction_change_vol(InstrumentScriptVM* parent);
138 int minRequiredArgs() const { return 2; }
139 int maxAllowedArgs() const { return 3; }
140 bool acceptsArgType(int iArg, ExprType_t type) const;
141 ExprType_t argType(int iArg) const { return INT_EXPR; }
142 VMFnResult* exec(VMFnArgs* args);
143 protected:
144 InstrumentScriptVM* m_vm;
145 };
146
147 class InstrumentScriptVMFunction_change_tune : public VMEmptyResultFunction {
148 public:
149 InstrumentScriptVMFunction_change_tune(InstrumentScriptVM* parent);
150 int minRequiredArgs() const { return 2; }
151 int maxAllowedArgs() const { return 3; }
152 bool acceptsArgType(int iArg, ExprType_t type) const;
153 ExprType_t argType(int iArg) const { return INT_EXPR; }
154 VMFnResult* exec(VMFnArgs* args);
155 protected:
156 InstrumentScriptVM* m_vm;
157 };
158
159 class InstrumentScriptVMFunction_change_pan : public VMEmptyResultFunction {
160 public:
161 InstrumentScriptVMFunction_change_pan(InstrumentScriptVM* parent);
162 int minRequiredArgs() const { return 2; }
163 int maxAllowedArgs() const { return 3; }
164 bool acceptsArgType(int iArg, ExprType_t type) const;
165 ExprType_t argType(int iArg) const { return INT_EXPR; }
166 VMFnResult* exec(VMFnArgs* args);
167 protected:
168 InstrumentScriptVM* m_vm;
169 };
170
171 class InstrumentScriptVMFunction_change_cutoff : public VMEmptyResultFunction {
172 public:
173 InstrumentScriptVMFunction_change_cutoff(InstrumentScriptVM* parent);
174 int minRequiredArgs() const { return 2; }
175 int maxAllowedArgs() const { return 2; }
176 bool acceptsArgType(int iArg, ExprType_t type) const;
177 ExprType_t argType(int iArg) const { return INT_EXPR; }
178 VMFnResult* exec(VMFnArgs* args);
179 protected:
180 InstrumentScriptVM* m_vm;
181 };
182
183 class InstrumentScriptVMFunction_change_reso : public VMEmptyResultFunction {
184 public:
185 InstrumentScriptVMFunction_change_reso(InstrumentScriptVM* parent);
186 int minRequiredArgs() const { return 2; }
187 int maxAllowedArgs() const { return 2; }
188 bool acceptsArgType(int iArg, ExprType_t type) const;
189 ExprType_t argType(int iArg) const { return INT_EXPR; }
190 VMFnResult* exec(VMFnArgs* args);
191 protected:
192 InstrumentScriptVM* m_vm;
193 };
194
195 class InstrumentScriptVMFunction_change_attack : public VMEmptyResultFunction {
196 public:
197 InstrumentScriptVMFunction_change_attack(InstrumentScriptVM* parent);
198 int minRequiredArgs() const { return 2; }
199 int maxAllowedArgs() const { return 2; }
200 bool acceptsArgType(int iArg, ExprType_t type) const;
201 ExprType_t argType(int iArg) const { return INT_EXPR; }
202 VMFnResult* exec(VMFnArgs* args);
203 protected:
204 InstrumentScriptVM* m_vm;
205 };
206
207 class InstrumentScriptVMFunction_change_decay : public VMEmptyResultFunction {
208 public:
209 InstrumentScriptVMFunction_change_decay(InstrumentScriptVM* parent);
210 int minRequiredArgs() const { return 2; }
211 int maxAllowedArgs() const { return 2; }
212 bool acceptsArgType(int iArg, ExprType_t type) const;
213 ExprType_t argType(int iArg) const { return INT_EXPR; }
214 VMFnResult* exec(VMFnArgs* args);
215 protected:
216 InstrumentScriptVM* m_vm;
217 };
218
219 class InstrumentScriptVMFunction_change_release : public VMEmptyResultFunction {
220 public:
221 InstrumentScriptVMFunction_change_release(InstrumentScriptVM* parent);
222 int minRequiredArgs() const { return 2; }
223 int maxAllowedArgs() const { return 2; }
224 bool acceptsArgType(int iArg, ExprType_t type) const;
225 ExprType_t argType(int iArg) const { return INT_EXPR; }
226 VMFnResult* exec(VMFnArgs* args);
227 protected:
228 InstrumentScriptVM* m_vm;
229 };
230
231 class VMChangeSynthParamFunction : public VMEmptyResultFunction {
232 public:
233 VMChangeSynthParamFunction(InstrumentScriptVM* parent) : m_vm(parent) {}
234 int minRequiredArgs() const { return 2; }
235 int maxAllowedArgs() const { return 2; }
236 bool acceptsArgType(int iArg, ExprType_t type) const;
237 ExprType_t argType(int iArg) const { return INT_EXPR; }
238
239 template<float NoteBase::_Override::*T_noteParam, int T_synthParam,
240 bool T_isNormalizedParam, int T_maxValue, int T_minValue>
241 VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
242 protected:
243 InstrumentScriptVM* m_vm;
244 };
245
246 class InstrumentScriptVMFunction_change_sustain : public VMChangeSynthParamFunction {
247 public:
248 InstrumentScriptVMFunction_change_sustain(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
249 VMFnResult* exec(VMFnArgs* args);
250 };
251
252 class InstrumentScriptVMFunction_change_amp_lfo_depth : public VMChangeSynthParamFunction {
253 public:
254 InstrumentScriptVMFunction_change_amp_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
255 VMFnResult* exec(VMFnArgs* args);
256 };
257
258 class InstrumentScriptVMFunction_change_amp_lfo_freq : public VMChangeSynthParamFunction {
259 public:
260 InstrumentScriptVMFunction_change_amp_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
261 VMFnResult* exec(VMFnArgs* args);
262 };
263
264 class InstrumentScriptVMFunction_change_pitch_lfo_depth : public VMChangeSynthParamFunction {
265 public:
266 InstrumentScriptVMFunction_change_pitch_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
267 VMFnResult* exec(VMFnArgs* args);
268 };
269
270 class InstrumentScriptVMFunction_change_pitch_lfo_freq : public VMChangeSynthParamFunction {
271 public:
272 InstrumentScriptVMFunction_change_pitch_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
273 VMFnResult* exec(VMFnArgs* args);
274 };
275
276 class InstrumentScriptVMFunction_change_vol_time : public VMChangeSynthParamFunction {
277 public:
278 InstrumentScriptVMFunction_change_vol_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
279 VMFnResult* exec(VMFnArgs* args);
280 };
281
282 class InstrumentScriptVMFunction_change_tune_time : public VMChangeSynthParamFunction {
283 public:
284 InstrumentScriptVMFunction_change_tune_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
285 VMFnResult* exec(VMFnArgs* args);
286 };
287
288 class InstrumentScriptVMFunction_change_pan_time : public VMChangeSynthParamFunction {
289 public:
290 InstrumentScriptVMFunction_change_pan_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
291 VMFnResult* exec(VMFnArgs* args);
292 };
293
294 class VMChangeFadeCurveFunction : public VMEmptyResultFunction {
295 public:
296 VMChangeFadeCurveFunction(InstrumentScriptVM* parent) : m_vm(parent) {}
297 int minRequiredArgs() const { return 2; }
298 int maxAllowedArgs() const { return 2; }
299 bool acceptsArgType(int iArg, ExprType_t type) const;
300 ExprType_t argType(int iArg) const { return INT_EXPR; }
301
302 template<fade_curve_t NoteBase::_Override::*T_noteParam, int T_synthParam>
303 VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
304 protected:
305 InstrumentScriptVM* m_vm;
306 };
307
308 class InstrumentScriptVMFunction_change_vol_curve : public VMChangeFadeCurveFunction {
309 public:
310 InstrumentScriptVMFunction_change_vol_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
311 VMFnResult* exec(VMFnArgs* args);
312 };
313
314 class InstrumentScriptVMFunction_change_tune_curve : public VMChangeFadeCurveFunction {
315 public:
316 InstrumentScriptVMFunction_change_tune_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
317 VMFnResult* exec(VMFnArgs* args);
318 };
319
320 class InstrumentScriptVMFunction_change_pan_curve : public VMChangeFadeCurveFunction {
321 public:
322 InstrumentScriptVMFunction_change_pan_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
323 VMFnResult* exec(VMFnArgs* args);
324 };
325
326 class InstrumentScriptVMFunction_fade_in : public VMEmptyResultFunction {
327 public:
328 InstrumentScriptVMFunction_fade_in(InstrumentScriptVM* parent);
329 int minRequiredArgs() const { return 2; }
330 int maxAllowedArgs() const { return 2; }
331 bool acceptsArgType(int iArg, ExprType_t type) const;
332 ExprType_t argType(int iArg) const { return INT_EXPR; }
333 VMFnResult* exec(VMFnArgs* args);
334 protected:
335 InstrumentScriptVM* m_vm;
336 };
337
338 class InstrumentScriptVMFunction_fade_out : public VMEmptyResultFunction {
339 public:
340 InstrumentScriptVMFunction_fade_out(InstrumentScriptVM* parent);
341 int minRequiredArgs() const { return 2; }
342 int maxAllowedArgs() const { return 3; }
343 bool acceptsArgType(int iArg, ExprType_t type) const;
344 ExprType_t argType(int iArg) const { return INT_EXPR; }
345 VMFnResult* exec(VMFnArgs* args);
346 protected:
347 InstrumentScriptVM* m_vm;
348 };
349
350 class InstrumentScriptVMFunction_get_event_par : public VMIntResultFunction {
351 public:
352 InstrumentScriptVMFunction_get_event_par(InstrumentScriptVM* parent);
353 int minRequiredArgs() const { return 2; }
354 int maxAllowedArgs() const { return 2; }
355 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
356 ExprType_t argType(int iArg) const { return INT_EXPR; }
357 VMFnResult* exec(VMFnArgs* args);
358 protected:
359 InstrumentScriptVM* m_vm;
360 };
361
362 class InstrumentScriptVMFunction_set_event_par : public VMEmptyResultFunction {
363 public:
364 InstrumentScriptVMFunction_set_event_par(InstrumentScriptVM* parent);
365 int minRequiredArgs() const { return 3; }
366 int maxAllowedArgs() const { return 3; }
367 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
368 ExprType_t argType(int iArg) const { return INT_EXPR; }
369 VMFnResult* exec(VMFnArgs* args);
370 protected:
371 InstrumentScriptVM* m_vm;
372 };
373
374 class InstrumentScriptVMFunction_change_note : public VMEmptyResultFunction {
375 public:
376 InstrumentScriptVMFunction_change_note(InstrumentScriptVM* parent);
377 int minRequiredArgs() const { return 2; }
378 int maxAllowedArgs() const { return 2; }
379 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
380 ExprType_t argType(int iArg) const { return INT_EXPR; }
381 VMFnResult* exec(VMFnArgs* args);
382 protected:
383 InstrumentScriptVM* m_vm;
384 };
385
386 class InstrumentScriptVMFunction_change_velo : public VMEmptyResultFunction {
387 public:
388 InstrumentScriptVMFunction_change_velo(InstrumentScriptVM* parent);
389 int minRequiredArgs() const { return 2; }
390 int maxAllowedArgs() const { return 2; }
391 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
392 ExprType_t argType(int iArg) const { return INT_EXPR; }
393 VMFnResult* exec(VMFnArgs* args);
394 protected:
395 InstrumentScriptVM* m_vm;
396 };
397
398 class InstrumentScriptVMFunction_change_play_pos : public VMEmptyResultFunction {
399 public:
400 InstrumentScriptVMFunction_change_play_pos(InstrumentScriptVM* parent);
401 int minRequiredArgs() const { return 2; }
402 int maxAllowedArgs() const { return 2; }
403 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR; }
404 ExprType_t argType(int iArg) const { return INT_EXPR; }
405 VMFnResult* exec(VMFnArgs* args);
406 protected:
407 InstrumentScriptVM* m_vm;
408 };
409
410 class InstrumentScriptVMFunction_event_status : public VMIntResultFunction {
411 public:
412 InstrumentScriptVMFunction_event_status(InstrumentScriptVM* parent);
413 int minRequiredArgs() const { return 1; }
414 int maxAllowedArgs() const { return 1; }
415 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
416 ExprType_t argType(int iArg) const { return INT_EXPR; }
417 VMFnResult* exec(VMFnArgs* args);
418 protected:
419 InstrumentScriptVM* m_vm;
420 };
421
422 class InstrumentScriptVMFunction_callback_status : public VMIntResultFunction {
423 public:
424 InstrumentScriptVMFunction_callback_status(InstrumentScriptVM* parent);
425 int minRequiredArgs() const { return 1; }
426 int maxAllowedArgs() const { return 1; }
427 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
428 ExprType_t argType(int iArg) const { return INT_EXPR; }
429 VMFnResult* exec(VMFnArgs* args);
430 protected:
431 InstrumentScriptVM* m_vm;
432 };
433
434 // overrides core wait() implementation
435 class InstrumentScriptVMFunction_wait : public CoreVMFunction_wait {
436 public:
437 InstrumentScriptVMFunction_wait(InstrumentScriptVM* parent);
438 VMFnResult* exec(VMFnArgs* args);
439 };
440
441 class InstrumentScriptVMFunction_stop_wait : public VMEmptyResultFunction {
442 public:
443 InstrumentScriptVMFunction_stop_wait(InstrumentScriptVM* parent);
444 int minRequiredArgs() const { return 1; }
445 int maxAllowedArgs() const { return 2; }
446 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
447 ExprType_t argType(int iArg) const { return INT_EXPR; }
448 VMFnResult* exec(VMFnArgs* args);
449 protected:
450 InstrumentScriptVM* m_vm;
451 };
452
453 class InstrumentScriptVMFunction_abort : public VMEmptyResultFunction {
454 public:
455 InstrumentScriptVMFunction_abort(InstrumentScriptVM* parent);
456 int minRequiredArgs() const { return 1; }
457 int maxAllowedArgs() const { return 1; }
458 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR; }
459 ExprType_t argType(int iArg) const { return INT_EXPR; }
460 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
461 protected:
462 InstrumentScriptVM* m_vm;
463 };
464
465 class InstrumentScriptVMFunction_fork : public VMIntResultFunction {
466 public:
467 InstrumentScriptVMFunction_fork(InstrumentScriptVM* parent);
468 int minRequiredArgs() const { return 0; }
469 int maxAllowedArgs() const { return 2; }
470 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
471 ExprType_t argType(int iArg) const { return INT_EXPR; }
472 VMFnResult* exec(VMFnArgs* args);
473 protected:
474 InstrumentScriptVM* m_vm;
475 };
476
477 } // namespace LinuxSampler
478
479 #endif // LS_INSTRSCRIPTVMFUNCTIONS_H

  ViewVC Help
Powered by ViewVC