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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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