/[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 3212 - (show annotations) (download) (as text)
Thu May 25 13:17:47 2017 UTC (3 years, 9 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 15079 byte(s)
* NKSP: Built-in "ignore_event()" function: argument is now optional,
  like with built-in function "ignore_controller()".

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_amp_lfo_depth : public VMChangeSynthParamFunction {
247 public:
248 InstrumentScriptVMFunction_change_amp_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
249 VMFnResult* exec(VMFnArgs* args);
250 };
251
252 class InstrumentScriptVMFunction_change_amp_lfo_freq : public VMChangeSynthParamFunction {
253 public:
254 InstrumentScriptVMFunction_change_amp_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
255 VMFnResult* exec(VMFnArgs* args);
256 };
257
258 class InstrumentScriptVMFunction_change_pitch_lfo_depth : public VMChangeSynthParamFunction {
259 public:
260 InstrumentScriptVMFunction_change_pitch_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
261 VMFnResult* exec(VMFnArgs* args);
262 };
263
264 class InstrumentScriptVMFunction_change_pitch_lfo_freq : public VMChangeSynthParamFunction {
265 public:
266 InstrumentScriptVMFunction_change_pitch_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
267 VMFnResult* exec(VMFnArgs* args);
268 };
269
270 class InstrumentScriptVMFunction_change_vol_time : public VMChangeSynthParamFunction {
271 public:
272 InstrumentScriptVMFunction_change_vol_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
273 VMFnResult* exec(VMFnArgs* args);
274 };
275
276 class InstrumentScriptVMFunction_change_tune_time : public VMChangeSynthParamFunction {
277 public:
278 InstrumentScriptVMFunction_change_tune_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
279 VMFnResult* exec(VMFnArgs* args);
280 };
281
282 class InstrumentScriptVMFunction_fade_in : public VMEmptyResultFunction {
283 public:
284 InstrumentScriptVMFunction_fade_in(InstrumentScriptVM* parent);
285 int minRequiredArgs() const { return 2; }
286 int maxAllowedArgs() const { return 2; }
287 bool acceptsArgType(int iArg, ExprType_t type) const;
288 ExprType_t argType(int iArg) const { return INT_EXPR; }
289 VMFnResult* exec(VMFnArgs* args);
290 protected:
291 InstrumentScriptVM* m_vm;
292 };
293
294 class InstrumentScriptVMFunction_fade_out : public VMEmptyResultFunction {
295 public:
296 InstrumentScriptVMFunction_fade_out(InstrumentScriptVM* parent);
297 int minRequiredArgs() const { return 2; }
298 int maxAllowedArgs() const { return 3; }
299 bool acceptsArgType(int iArg, ExprType_t type) const;
300 ExprType_t argType(int iArg) const { return INT_EXPR; }
301 VMFnResult* exec(VMFnArgs* args);
302 protected:
303 InstrumentScriptVM* m_vm;
304 };
305
306 class InstrumentScriptVMFunction_get_event_par : public VMIntResultFunction {
307 public:
308 InstrumentScriptVMFunction_get_event_par(InstrumentScriptVM* parent);
309 int minRequiredArgs() const { return 2; }
310 int maxAllowedArgs() const { return 2; }
311 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
312 ExprType_t argType(int iArg) const { return INT_EXPR; }
313 VMFnResult* exec(VMFnArgs* args);
314 protected:
315 InstrumentScriptVM* m_vm;
316 };
317
318 class InstrumentScriptVMFunction_set_event_par : public VMEmptyResultFunction {
319 public:
320 InstrumentScriptVMFunction_set_event_par(InstrumentScriptVM* parent);
321 int minRequiredArgs() const { return 3; }
322 int maxAllowedArgs() const { return 3; }
323 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
324 ExprType_t argType(int iArg) const { return INT_EXPR; }
325 VMFnResult* exec(VMFnArgs* args);
326 protected:
327 InstrumentScriptVM* m_vm;
328 };
329
330 class InstrumentScriptVMFunction_event_status : public VMIntResultFunction {
331 public:
332 InstrumentScriptVMFunction_event_status(InstrumentScriptVM* parent);
333 int minRequiredArgs() const { return 1; }
334 int maxAllowedArgs() const { return 1; }
335 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
336 ExprType_t argType(int iArg) const { return INT_EXPR; }
337 VMFnResult* exec(VMFnArgs* args);
338 protected:
339 InstrumentScriptVM* m_vm;
340 };
341
342 // overrides core wait() implementation
343 class InstrumentScriptVMFunction_wait : public CoreVMFunction_wait {
344 public:
345 InstrumentScriptVMFunction_wait(InstrumentScriptVM* parent);
346 VMFnResult* exec(VMFnArgs* args);
347 };
348
349 class InstrumentScriptVMFunction_stop_wait : public VMEmptyResultFunction {
350 public:
351 InstrumentScriptVMFunction_stop_wait(InstrumentScriptVM* parent);
352 int minRequiredArgs() const { return 1; }
353 int maxAllowedArgs() const { return 2; }
354 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
355 ExprType_t argType(int iArg) const { return INT_EXPR; }
356 VMFnResult* exec(VMFnArgs* args);
357 protected:
358 InstrumentScriptVM* m_vm;
359 };
360
361 } // namespace LinuxSampler
362
363 #endif // LS_INSTRSCRIPTVMFUNCTIONS_H

  ViewVC Help
Powered by ViewVC