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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 3691 - (hide annotations) (download) (as text)
Fri Jan 3 12:35:20 2020 UTC (4 years, 3 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 31941 byte(s) 
* NKSP: Implemented built-in script function "set_rpn()".

* NKSP: Implemented built-in script function "set_nrpn()".

* Bumped version (2.1.1.svn31).
1 schoenebeck 2596 /*
2 schoenebeck 3691 * Copyright (c) 2014 - 2020 Christian Schoenebeck
3 schoenebeck 2596 *
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 schoenebeck 3118 #include "Note.h"
16 schoenebeck 2596
17     namespace LinuxSampler {
18    
19 schoenebeck 2630 class EventGroup;
20 schoenebeck 2596 class InstrumentScriptVM;
21    
22 schoenebeck 3581 class InstrumentScriptVMFunction_play_note FINAL : public VMIntResultFunction {
23 schoenebeck 3588 using Super = VMIntResultFunction; // just an alias for the super class
24 schoenebeck 2596 public:
25     InstrumentScriptVMFunction_play_note(InstrumentScriptVM* parent);
26 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
27     bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
28 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 1; }
29     vmint maxAllowedArgs() const OVERRIDE { return 4; }
30 schoenebeck 3587 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
31     bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
32     bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
33 schoenebeck 3588 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
34     std::function<void(String)> wrn) OVERRIDE;
35 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
36 schoenebeck 2596 protected:
37     InstrumentScriptVM* m_vm;
38     };
39    
40 schoenebeck 3581 class InstrumentScriptVMFunction_set_controller FINAL : public VMIntResultFunction {
41 schoenebeck 2600 public:
42     InstrumentScriptVMFunction_set_controller(InstrumentScriptVM* parent);
43 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
44     bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
45 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
46     vmint maxAllowedArgs() const OVERRIDE { return 2; }
47     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
48     VMFnResult* exec(VMFnArgs* args) OVERRIDE;
49 schoenebeck 2600 protected:
50     InstrumentScriptVM* m_vm;
51     };
52    
53 schoenebeck 3691 class InstrumentScriptVMFunction_set_rpn FINAL : public VMIntResultFunction {
54     public:
55     InstrumentScriptVMFunction_set_rpn(InstrumentScriptVM* parent);
56     StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
57     bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
58     vmint minRequiredArgs() const OVERRIDE { return 2; }
59     vmint maxAllowedArgs() const OVERRIDE { return 2; }
60     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
61     VMFnResult* exec(VMFnArgs* args) OVERRIDE;
62     protected:
63     InstrumentScriptVM* m_vm;
64     };
65    
66     class InstrumentScriptVMFunction_set_nrpn FINAL : public VMIntResultFunction {
67     public:
68     InstrumentScriptVMFunction_set_nrpn(InstrumentScriptVM* parent);
69     StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
70     bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
71     vmint minRequiredArgs() const OVERRIDE { return 2; }
72     vmint maxAllowedArgs() const OVERRIDE { return 2; }
73     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
74     VMFnResult* exec(VMFnArgs* args) OVERRIDE;
75     protected:
76     InstrumentScriptVM* m_vm;
77     };
78    
79 schoenebeck 3581 class InstrumentScriptVMFunction_ignore_event FINAL : public VMEmptyResultFunction {
80 schoenebeck 2598 public:
81     InstrumentScriptVMFunction_ignore_event(InstrumentScriptVM* parent);
82 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 0; }
83     vmint maxAllowedArgs() const OVERRIDE { return 1; }
84     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
85     VMFnResult* exec(VMFnArgs* args) OVERRIDE;
86 schoenebeck 2598 protected:
87     InstrumentScriptVM* m_vm;
88     };
89    
90 schoenebeck 3581 class InstrumentScriptVMFunction_ignore_controller FINAL : public VMEmptyResultFunction {
91 schoenebeck 2598 public:
92     InstrumentScriptVMFunction_ignore_controller(InstrumentScriptVM* parent);
93 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 0; }
94     vmint maxAllowedArgs() const OVERRIDE { return 1; }
95     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
96     VMFnResult* exec(VMFnArgs* args) OVERRIDE;
97 schoenebeck 2598 protected:
98     InstrumentScriptVM* m_vm;
99     };
100    
101 schoenebeck 3581 class InstrumentScriptVMFunction_note_off FINAL : public VMEmptyResultFunction {
102 schoenebeck 3588 using Super = VMEmptyResultFunction; // just an alias for the super class
103 schoenebeck 2629 public:
104     InstrumentScriptVMFunction_note_off(InstrumentScriptVM* parent);
105 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 1; }
106     vmint maxAllowedArgs() const OVERRIDE { return 2; }
107     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
108 schoenebeck 3588 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
109     std::function<void(String)> wrn) OVERRIDE;
110 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
111 schoenebeck 2630 protected:
112     InstrumentScriptVM* m_vm;
113     };
114    
115 schoenebeck 3581 class InstrumentScriptVMFunction_set_event_mark FINAL : public VMEmptyResultFunction {
116 schoenebeck 3588 using Super = VMEmptyResultFunction; // just an alias for the super class
117 schoenebeck 2630 public:
118     InstrumentScriptVMFunction_set_event_mark(InstrumentScriptVM* parent);
119 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
120     vmint maxAllowedArgs() const OVERRIDE { return 2; }
121     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
122 schoenebeck 3588 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
123     std::function<void(String)> wrn) OVERRIDE;
124 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
125 schoenebeck 2629 protected:
126     InstrumentScriptVM* m_vm;
127     };
128    
129 schoenebeck 3581 class InstrumentScriptVMFunction_delete_event_mark FINAL : public VMEmptyResultFunction {
130 schoenebeck 3588 using Super = VMEmptyResultFunction; // just an alias for the super class
131 schoenebeck 2630 public:
132     InstrumentScriptVMFunction_delete_event_mark(InstrumentScriptVM* parent);
133 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
134     vmint maxAllowedArgs() const OVERRIDE { return 2; }
135     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
136 schoenebeck 3588 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
137     std::function<void(String)> wrn) OVERRIDE;
138 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
139 schoenebeck 2630 protected:
140     InstrumentScriptVM* m_vm;
141     };
142    
143 schoenebeck 3581 class InstrumentScriptVMFunction_by_marks FINAL : public VMFunction {
144 schoenebeck 3588 using Super = VMFunction; // just an alias for the super class
145 schoenebeck 2630 public:
146     InstrumentScriptVMFunction_by_marks(InstrumentScriptVM* parent);
147 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
148     bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
149 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 1; }
150     vmint maxAllowedArgs() const OVERRIDE { return 1; }
151     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
152     bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
153 schoenebeck 3577 ExprType_t returnType(VMFnArgs* args) OVERRIDE { return INT_ARR_EXPR; }
154 schoenebeck 3588 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
155     std::function<void(String)> wrn) OVERRIDE;
156 schoenebeck 3054 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
157 schoenebeck 2630 protected:
158     InstrumentScriptVM* m_vm;
159     class Result : public VMFnResult, public VMIntArrayExpr {
160     public:
161     StmtFlags_t flags;
162     EventGroup* eventGroup;
163    
164 schoenebeck 3557 vmint arraySize() const OVERRIDE;
165     vmint evalIntElement(vmuint i) OVERRIDE;
166     void assignIntElement(vmuint i, vmint value) OVERRIDE {} // ignore assignment
167 schoenebeck 3581 vmfloat unitFactorOfElement(vmuint i) const OVERRIDE { return VM_NO_FACTOR; }
168     void assignElementUnitFactor(vmuint i, vmfloat factor) OVERRIDE {} // ignore assignment
169 schoenebeck 2630 VMExpr* resultValue() OVERRIDE { return this; }
170 schoenebeck 3054 StmtFlags_t resultFlags() OVERRIDE { return flags; }
171 schoenebeck 2945 bool isConstExpr() const OVERRIDE { return false; }
172 schoenebeck 2630 } m_result;
173    
174     VMFnResult* errorResult();
175     VMFnResult* successResult(EventGroup* eventGroup);
176     };
177    
178 schoenebeck 3581 class InstrumentScriptVMFunction_change_vol FINAL : public VMEmptyResultFunction {
179 schoenebeck 2931 public:
180     InstrumentScriptVMFunction_change_vol(InstrumentScriptVM* parent);
181 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
182     vmint maxAllowedArgs() const OVERRIDE { return 3; }
183     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
184 schoenebeck 3561 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
185 schoenebeck 3564 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
186 schoenebeck 3561 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
187 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
188 schoenebeck 2931 protected:
189     InstrumentScriptVM* m_vm;
190     };
191    
192 schoenebeck 3581 class InstrumentScriptVMFunction_change_tune FINAL : public VMEmptyResultFunction {
193 schoenebeck 2931 public:
194     InstrumentScriptVMFunction_change_tune(InstrumentScriptVM* parent);
195 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
196     vmint maxAllowedArgs() const OVERRIDE { return 3; }
197     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
198 schoenebeck 3564 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
199 schoenebeck 3561 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
200 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
201 schoenebeck 2931 protected:
202     InstrumentScriptVM* m_vm;
203     };
204    
205 schoenebeck 3581 class InstrumentScriptVMFunction_change_pan FINAL : public VMEmptyResultFunction {
206 schoenebeck 2931 public:
207     InstrumentScriptVMFunction_change_pan(InstrumentScriptVM* parent);
208 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
209     vmint maxAllowedArgs() const OVERRIDE { return 3; }
210     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
211 schoenebeck 3561 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
212 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
213 schoenebeck 2931 protected:
214     InstrumentScriptVM* m_vm;
215     };
216    
217 schoenebeck 3581 class InstrumentScriptVMFunction_change_cutoff FINAL : public VMEmptyResultFunction {
218 schoenebeck 3588 using Super = VMEmptyResultFunction; // just an alias for the super class
219 schoenebeck 2935 public:
220     InstrumentScriptVMFunction_change_cutoff(InstrumentScriptVM* parent);
221 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
222     vmint maxAllowedArgs() const OVERRIDE { return 2; }
223     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
224 schoenebeck 3561 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
225 schoenebeck 3564 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
226 schoenebeck 3561 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
227 schoenebeck 3588 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
228     std::function<void(String)> wrn) OVERRIDE;
229 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
230 schoenebeck 2935 protected:
231     InstrumentScriptVM* m_vm;
232     };
233    
234 schoenebeck 3581 class InstrumentScriptVMFunction_change_reso FINAL : public VMEmptyResultFunction {
235 schoenebeck 2935 public:
236     InstrumentScriptVMFunction_change_reso(InstrumentScriptVM* parent);
237 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
238     vmint maxAllowedArgs() const OVERRIDE { return 2; }
239     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
240 schoenebeck 3561 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
241 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
242 schoenebeck 2935 protected:
243     InstrumentScriptVM* m_vm;
244     };
245 schoenebeck 2953
246 schoenebeck 3581 class InstrumentScriptVMFunction_change_attack FINAL : public VMEmptyResultFunction {
247 schoenebeck 3588 using Super = VMEmptyResultFunction; // just an alias for the super class
248 schoenebeck 2953 public:
249     InstrumentScriptVMFunction_change_attack(InstrumentScriptVM* parent);
250 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
251     vmint maxAllowedArgs() const OVERRIDE { return 2; }
252     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
253 schoenebeck 3561 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
254 schoenebeck 3564 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
255 schoenebeck 3561 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
256 schoenebeck 3588 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
257     std::function<void(String)> wrn) OVERRIDE;
258 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
259 schoenebeck 2953 protected:
260     InstrumentScriptVM* m_vm;
261     };
262 schoenebeck 2935
263 schoenebeck 3581 class InstrumentScriptVMFunction_change_decay FINAL : public VMEmptyResultFunction {
264 schoenebeck 3588 using Super = VMEmptyResultFunction; // just an alias for the super class
265 schoenebeck 2953 public:
266     InstrumentScriptVMFunction_change_decay(InstrumentScriptVM* parent);
267 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
268     vmint maxAllowedArgs() const OVERRIDE { return 2; }
269     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
270 schoenebeck 3561 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
271 schoenebeck 3564 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
272 schoenebeck 3561 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
273 schoenebeck 3588 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
274     std::function<void(String)> wrn) OVERRIDE;
275 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
276 schoenebeck 2953 protected:
277     InstrumentScriptVM* m_vm;
278     };
279    
280 schoenebeck 3581 class InstrumentScriptVMFunction_change_release FINAL : public VMEmptyResultFunction {
281 schoenebeck 3588 using Super = VMEmptyResultFunction; // just an alias for the super class
282 schoenebeck 2953 public:
283     InstrumentScriptVMFunction_change_release(InstrumentScriptVM* parent);
284 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
285     vmint maxAllowedArgs() const OVERRIDE { return 2; }
286     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
287 schoenebeck 3561 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
288 schoenebeck 3564 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
289 schoenebeck 3561 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
290 schoenebeck 3588 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
291     std::function<void(String)> wrn) OVERRIDE;
292 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
293 schoenebeck 2953 protected:
294     InstrumentScriptVM* m_vm;
295     };
296    
297 schoenebeck 3118 class VMChangeSynthParamFunction : public VMEmptyResultFunction {
298 schoenebeck 3588 using Super = VMEmptyResultFunction; // just an alias for the super class
299 schoenebeck 3118 public:
300 schoenebeck 3587 struct Opt_t {
301     InstrumentScriptVM* vm = NULL; ///< Parent object owning the built-in function implementation object.
302     bool acceptFinal = false; ///< Whether built-in function allows 'final' operator for its 2nd function argument.
303     StdUnit_t unit = VM_NO_UNIT; ///< Whether built-in functions accepts a unit type for its 2nd function argument and if yes which one.
304     bool acceptUnitPrefix = false; ///< Whether built-in function accepts metric unit prefix(es) for its 2nd function argument.
305     bool acceptReal = false; ///< Whether the built-in function accepts both int and real number as data type for its 2nd function argument (otherwise its int only if false).
306     };
307     VMChangeSynthParamFunction(const Opt_t& opt)
308     : m_vm(opt.vm), m_acceptReal(opt.acceptReal),
309     m_acceptFinal(opt.acceptFinal),
310     m_acceptUnitPrefix(opt.acceptUnitPrefix), m_unit(opt.unit) {}
311 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
312     vmint maxAllowedArgs() const OVERRIDE { return 2; }
313     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
314 schoenebeck 3561 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
315 schoenebeck 3564 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
316 schoenebeck 3561 bool acceptsArgFinal(vmint iArg) const OVERRIDE;
317 schoenebeck 3588 void checkArgs(VMFnArgs* args, std::function<void(String)> err,
318     std::function<void(String)> wrn) OVERRIDE;
319 schoenebeck 3118
320 schoenebeck 3561 template<class T_NoteParamType, T_NoteParamType NoteBase::_Override::*T_noteParam,
321     vmint T_synthParam,
322     vmint T_minValueNorm, vmint T_maxValueNorm, bool T_normalizeNorm,
323     vmint T_minValueUnit, vmint T_maxValueUnit,
324     MetricPrefix_t T_unitPrefix0, MetricPrefix_t ... T_unitPrefixN>
325 schoenebeck 3118 VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
326     protected:
327 schoenebeck 3587 InstrumentScriptVM* const m_vm;
328     const bool m_acceptReal;
329 schoenebeck 3561 const bool m_acceptFinal;
330 schoenebeck 3564 const bool m_acceptUnitPrefix;
331 schoenebeck 3561 const StdUnit_t m_unit;
332 schoenebeck 3118 };
333    
334 schoenebeck 3581 class InstrumentScriptVMFunction_change_sustain FINAL : public VMChangeSynthParamFunction {
335 schoenebeck 3316 public:
336 schoenebeck 3587 InstrumentScriptVMFunction_change_sustain(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
337     .vm = parent,
338     .acceptFinal = true,
339     .unit = VM_BEL,
340     .acceptUnitPrefix = true,
341     .acceptReal = true,
342     }) {}
343 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
344 schoenebeck 3316 };
345    
346 schoenebeck 3581 class InstrumentScriptVMFunction_change_cutoff_attack FINAL : public VMChangeSynthParamFunction {
347 schoenebeck 3360 public:
348 schoenebeck 3587 InstrumentScriptVMFunction_change_cutoff_attack(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
349     .vm = parent,
350     .acceptFinal = true,
351     .unit = VM_SECOND,
352     .acceptUnitPrefix = true,
353     .acceptReal = true,
354     }) {}
355 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
356 schoenebeck 3360 };
357    
358 schoenebeck 3581 class InstrumentScriptVMFunction_change_cutoff_decay FINAL : public VMChangeSynthParamFunction {
359 schoenebeck 3360 public:
360 schoenebeck 3587 InstrumentScriptVMFunction_change_cutoff_decay(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
361     .vm = parent,
362     .acceptFinal = true,
363     .unit = VM_SECOND,
364     .acceptUnitPrefix = true,
365     .acceptReal = true,
366     }) {}
367 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
368 schoenebeck 3360 };
369    
370 schoenebeck 3581 class InstrumentScriptVMFunction_change_cutoff_sustain FINAL : public VMChangeSynthParamFunction {
371 schoenebeck 3360 public:
372 schoenebeck 3587 InstrumentScriptVMFunction_change_cutoff_sustain(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
373     .vm = parent,
374     .acceptFinal = true,
375     .unit = VM_BEL,
376     .acceptUnitPrefix = true,
377     .acceptReal = true,
378     }) {}
379 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
380 schoenebeck 3360 };
381    
382 schoenebeck 3581 class InstrumentScriptVMFunction_change_cutoff_release FINAL : public VMChangeSynthParamFunction {
383 schoenebeck 3360 public:
384 schoenebeck 3587 InstrumentScriptVMFunction_change_cutoff_release(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
385     .vm = parent,
386     .acceptFinal = true,
387     .unit = VM_SECOND,
388     .acceptUnitPrefix = true,
389     .acceptReal = true,
390     }) {}
391 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
392 schoenebeck 3360 };
393    
394 schoenebeck 3581 class InstrumentScriptVMFunction_change_amp_lfo_depth FINAL : public VMChangeSynthParamFunction {
395 schoenebeck 3118 public:
396 schoenebeck 3587 InstrumentScriptVMFunction_change_amp_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
397     .vm = parent,
398     .acceptFinal = true,
399     .unit = VM_NO_UNIT,
400     .acceptUnitPrefix = false,
401     .acceptReal = false,
402     }) {}
403 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
404 schoenebeck 3118 };
405    
406 schoenebeck 3581 class InstrumentScriptVMFunction_change_amp_lfo_freq FINAL : public VMChangeSynthParamFunction {
407 schoenebeck 3118 public:
408 schoenebeck 3587 InstrumentScriptVMFunction_change_amp_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
409     .vm = parent,
410     .acceptFinal = true,
411     .unit = VM_HERTZ,
412     .acceptUnitPrefix = true,
413     .acceptReal = true,
414     }) {}
415 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
416 schoenebeck 3118 };
417    
418 schoenebeck 3581 class InstrumentScriptVMFunction_change_cutoff_lfo_depth FINAL : public VMChangeSynthParamFunction {
419 schoenebeck 3360 public:
420 schoenebeck 3587 InstrumentScriptVMFunction_change_cutoff_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
421     .vm = parent,
422     .acceptFinal = true,
423     .unit = VM_NO_UNIT,
424     .acceptUnitPrefix = false,
425     .acceptReal = false,
426     }) {}
427 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
428 schoenebeck 3360 };
429    
430 schoenebeck 3581 class InstrumentScriptVMFunction_change_cutoff_lfo_freq FINAL : public VMChangeSynthParamFunction {
431 schoenebeck 3360 public:
432 schoenebeck 3587 InstrumentScriptVMFunction_change_cutoff_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
433     .vm = parent,
434     .acceptFinal = true,
435     .unit = VM_HERTZ,
436     .acceptUnitPrefix = true,
437     .acceptReal = true,
438     }) {}
439 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
440 schoenebeck 3360 };
441    
442 schoenebeck 3581 class InstrumentScriptVMFunction_change_pitch_lfo_depth FINAL : public VMChangeSynthParamFunction {
443 schoenebeck 3118 public:
444 schoenebeck 3587 InstrumentScriptVMFunction_change_pitch_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
445     .vm = parent,
446     .acceptFinal = true,
447     .unit = VM_NO_UNIT,
448     .acceptUnitPrefix = false,
449     .acceptReal = false,
450     }) {}
451 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
452 schoenebeck 3118 };
453    
454 schoenebeck 3581 class InstrumentScriptVMFunction_change_pitch_lfo_freq FINAL : public VMChangeSynthParamFunction {
455 schoenebeck 3118 public:
456 schoenebeck 3587 InstrumentScriptVMFunction_change_pitch_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
457     .vm = parent,
458     .acceptFinal = true,
459     .unit = VM_HERTZ,
460     .acceptUnitPrefix = true,
461     .acceptReal = true,
462     }) {}
463 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
464 schoenebeck 3118 };
465    
466 schoenebeck 3581 class InstrumentScriptVMFunction_change_vol_time FINAL : public VMChangeSynthParamFunction {
467 schoenebeck 3188 public:
468 schoenebeck 3587 InstrumentScriptVMFunction_change_vol_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
469     .vm = parent,
470     .acceptFinal = false,
471     .unit = VM_SECOND,
472     .acceptUnitPrefix = true,
473     .acceptReal = true,
474     }) {}
475 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
476 schoenebeck 3188 };
477    
478 schoenebeck 3581 class InstrumentScriptVMFunction_change_tune_time FINAL : public VMChangeSynthParamFunction {
479 schoenebeck 3188 public:
480 schoenebeck 3587 InstrumentScriptVMFunction_change_tune_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
481     .vm = parent,
482     .acceptFinal = false,
483     .unit = VM_SECOND,
484     .acceptUnitPrefix = true,
485     .acceptReal = true,
486     }) {}
487 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
488 schoenebeck 3188 };
489    
490 schoenebeck 3581 class InstrumentScriptVMFunction_change_pan_time FINAL : public VMChangeSynthParamFunction {
491 schoenebeck 3335 public:
492 schoenebeck 3587 InstrumentScriptVMFunction_change_pan_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction({
493     .vm = parent,
494     .acceptFinal = false,
495     .unit = VM_SECOND,
496     .acceptUnitPrefix = true,
497     .acceptReal = true,
498     }) {}
499 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
500 schoenebeck 3335 };
501    
502 schoenebeck 3246 class VMChangeFadeCurveFunction : public VMEmptyResultFunction {
503     public:
504     VMChangeFadeCurveFunction(InstrumentScriptVM* parent) : m_vm(parent) {}
505 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
506     vmint maxAllowedArgs() const OVERRIDE { return 2; }
507     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
508 schoenebeck 3246
509 schoenebeck 3557 template<fade_curve_t NoteBase::_Override::*T_noteParam, vmint T_synthParam>
510 schoenebeck 3246 VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
511     protected:
512     InstrumentScriptVM* m_vm;
513     };
514    
515 schoenebeck 3581 class InstrumentScriptVMFunction_change_vol_curve FINAL : public VMChangeFadeCurveFunction {
516 schoenebeck 3246 public:
517     InstrumentScriptVMFunction_change_vol_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
518 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
519 schoenebeck 3246 };
520    
521 schoenebeck 3581 class InstrumentScriptVMFunction_change_tune_curve FINAL : public VMChangeFadeCurveFunction {
522 schoenebeck 3246 public:
523     InstrumentScriptVMFunction_change_tune_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
524 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
525 schoenebeck 3246 };
526    
527 schoenebeck 3581 class InstrumentScriptVMFunction_change_pan_curve FINAL : public VMChangeFadeCurveFunction {
528 schoenebeck 3335 public:
529     InstrumentScriptVMFunction_change_pan_curve(InstrumentScriptVM* parent) : VMChangeFadeCurveFunction(parent) {}
530 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
531 schoenebeck 3335 };
532    
533 schoenebeck 3581 class InstrumentScriptVMFunction_fade_in FINAL : public VMEmptyResultFunction {
534 schoenebeck 3188 public:
535     InstrumentScriptVMFunction_fade_in(InstrumentScriptVM* parent);
536 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
537     vmint maxAllowedArgs() const OVERRIDE { return 2; }
538     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
539 schoenebeck 3561 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
540 schoenebeck 3564 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
541 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
542 schoenebeck 3188 protected:
543     InstrumentScriptVM* m_vm;
544     };
545    
546 schoenebeck 3581 class InstrumentScriptVMFunction_fade_out FINAL : public VMEmptyResultFunction {
547 schoenebeck 3188 public:
548     InstrumentScriptVMFunction_fade_out(InstrumentScriptVM* parent);
549 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
550     vmint maxAllowedArgs() const OVERRIDE { return 3; }
551     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
552 schoenebeck 3561 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
553 schoenebeck 3564 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
554 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
555 schoenebeck 3188 protected:
556     InstrumentScriptVM* m_vm;
557     };
558    
559 schoenebeck 3581 class InstrumentScriptVMFunction_get_event_par FINAL : public VMIntResultFunction {
560 schoenebeck 3193 public:
561     InstrumentScriptVMFunction_get_event_par(InstrumentScriptVM* parent);
562 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
563     bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
564 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
565     vmint maxAllowedArgs() const OVERRIDE { return 2; }
566     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
567     VMFnResult* exec(VMFnArgs* args) OVERRIDE;
568 schoenebeck 3193 protected:
569     InstrumentScriptVM* m_vm;
570     };
571    
572 schoenebeck 3581 class InstrumentScriptVMFunction_set_event_par FINAL : public VMEmptyResultFunction {
573 schoenebeck 3193 public:
574     InstrumentScriptVMFunction_set_event_par(InstrumentScriptVM* parent);
575 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 3; }
576     vmint maxAllowedArgs() const OVERRIDE { return 3; }
577     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
578     VMFnResult* exec(VMFnArgs* args) OVERRIDE;
579 schoenebeck 3193 protected:
580     InstrumentScriptVM* m_vm;
581     };
582    
583 schoenebeck 3581 class InstrumentScriptVMFunction_change_note FINAL : public VMEmptyResultFunction {
584 schoenebeck 3214 public:
585     InstrumentScriptVMFunction_change_note(InstrumentScriptVM* parent);
586 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
587     vmint maxAllowedArgs() const OVERRIDE { return 2; }
588     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
589     VMFnResult* exec(VMFnArgs* args) OVERRIDE;
590 schoenebeck 3214 protected:
591     InstrumentScriptVM* m_vm;
592     };
593    
594 schoenebeck 3581 class InstrumentScriptVMFunction_change_velo FINAL : public VMEmptyResultFunction {
595 schoenebeck 3214 public:
596     InstrumentScriptVMFunction_change_velo(InstrumentScriptVM* parent);
597 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
598     vmint maxAllowedArgs() const OVERRIDE { return 2; }
599     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
600     VMFnResult* exec(VMFnArgs* args) OVERRIDE;
601 schoenebeck 3214 protected:
602     InstrumentScriptVM* m_vm;
603     };
604    
605 schoenebeck 3581 class InstrumentScriptVMFunction_change_play_pos FINAL : public VMEmptyResultFunction {
606 schoenebeck 3255 public:
607     InstrumentScriptVMFunction_change_play_pos(InstrumentScriptVM* parent);
608 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 2; }
609     vmint maxAllowedArgs() const OVERRIDE { return 2; }
610 schoenebeck 3587 bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
611 schoenebeck 3561 bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
612 schoenebeck 3564 bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
613 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
614 schoenebeck 3255 protected:
615     InstrumentScriptVM* m_vm;
616     };
617    
618 schoenebeck 3581 class InstrumentScriptVMFunction_event_status FINAL : public VMIntResultFunction {
619 schoenebeck 2935 public:
620     InstrumentScriptVMFunction_event_status(InstrumentScriptVM* parent);
621 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
622     bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
623 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 1; }
624     vmint maxAllowedArgs() const OVERRIDE { return 1; }
625     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
626     VMFnResult* exec(VMFnArgs* args) OVERRIDE;
627 schoenebeck 2935 protected:
628     InstrumentScriptVM* m_vm;
629     };
630    
631 schoenebeck 3581 class InstrumentScriptVMFunction_callback_status FINAL : public VMIntResultFunction {
632 schoenebeck 3296 public:
633     InstrumentScriptVMFunction_callback_status(InstrumentScriptVM* parent);
634 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
635     bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
636 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 1; }
637     vmint maxAllowedArgs() const OVERRIDE { return 1; }
638     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
639     VMFnResult* exec(VMFnArgs* args) OVERRIDE;
640 schoenebeck 3296 protected:
641     InstrumentScriptVM* m_vm;
642     };
643    
644 schoenebeck 2948 // overrides core wait() implementation
645 schoenebeck 3581 class InstrumentScriptVMFunction_wait FINAL : public CoreVMFunction_wait {
646 schoenebeck 2948 public:
647     InstrumentScriptVMFunction_wait(InstrumentScriptVM* parent);
648 schoenebeck 3557 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
649 schoenebeck 2948 };
650    
651 schoenebeck 3581 class InstrumentScriptVMFunction_stop_wait FINAL : public VMEmptyResultFunction {
652 schoenebeck 2948 public:
653     InstrumentScriptVMFunction_stop_wait(InstrumentScriptVM* parent);
654 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 1; }
655     vmint maxAllowedArgs() const OVERRIDE { return 2; }
656     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
657     VMFnResult* exec(VMFnArgs* args) OVERRIDE;
658 schoenebeck 2948 protected:
659     InstrumentScriptVM* m_vm;
660     };
661    
662 schoenebeck 3581 class InstrumentScriptVMFunction_abort FINAL : public VMEmptyResultFunction {
663 schoenebeck 3277 public:
664     InstrumentScriptVMFunction_abort(InstrumentScriptVM* parent);
665 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 1; }
666     vmint maxAllowedArgs() const OVERRIDE { return 1; }
667     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
668 schoenebeck 3277 VMFnResult* exec(VMFnArgs* args) OVERRIDE;
669     protected:
670     InstrumentScriptVM* m_vm;
671     };
672    
673 schoenebeck 3581 class InstrumentScriptVMFunction_fork FINAL : public VMIntResultFunction {
674 schoenebeck 3293 public:
675     InstrumentScriptVMFunction_fork(InstrumentScriptVM* parent);
676 schoenebeck 3581 StdUnit_t returnUnitType(VMFnArgs* args) OVERRIDE { return VM_NO_UNIT; }
677     bool returnsFinal(VMFnArgs* args) OVERRIDE { return false; }
678 schoenebeck 3557 vmint minRequiredArgs() const OVERRIDE { return 0; }
679     vmint maxAllowedArgs() const OVERRIDE { return 2; }
680     bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
681     VMFnResult* exec(VMFnArgs* args) OVERRIDE;
682 schoenebeck 3293 protected:
683     InstrumentScriptVM* m_vm;
684     };
685    
686 schoenebeck 2596 } // namespace LinuxSampler
687    
688     #endif // LS_INSTRSCRIPTVMFUNCTIONS_H
  ViewVC Help
Powered by ViewVC