/[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 3118 - (show annotations) (download) (as text)
Fri Apr 21 13:33:03 2017 UTC (2 months, 1 week ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 12436 byte(s)
* NKSP: Fixed crash when using built-in script array variable "%ALL_EVENTS".
* NKSP: Added built-in function "change_amp_lfo_depth()".
* NKSP: Added built-in function "change_amp_lfo_freq()".
* NKSP: Added built-in function "change_pitch_lfo_depth()".
* NKSP: Added built-in function "change_pitch_lfo_freq()".
* Bumped version (2.0.0.svn44).

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 1; }
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 VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
241 protected:
242 InstrumentScriptVM* m_vm;
243 };
244
245 class InstrumentScriptVMFunction_change_amp_lfo_depth : public VMChangeSynthParamFunction {
246 public:
247 InstrumentScriptVMFunction_change_amp_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
248 VMFnResult* exec(VMFnArgs* args);
249 };
250
251 class InstrumentScriptVMFunction_change_amp_lfo_freq : public VMChangeSynthParamFunction {
252 public:
253 InstrumentScriptVMFunction_change_amp_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
254 VMFnResult* exec(VMFnArgs* args);
255 };
256
257 class InstrumentScriptVMFunction_change_pitch_lfo_depth : public VMChangeSynthParamFunction {
258 public:
259 InstrumentScriptVMFunction_change_pitch_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
260 VMFnResult* exec(VMFnArgs* args);
261 };
262
263 class InstrumentScriptVMFunction_change_pitch_lfo_freq : public VMChangeSynthParamFunction {
264 public:
265 InstrumentScriptVMFunction_change_pitch_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
266 VMFnResult* exec(VMFnArgs* args);
267 };
268
269 class InstrumentScriptVMFunction_event_status : public VMIntResultFunction {
270 public:
271 InstrumentScriptVMFunction_event_status(InstrumentScriptVM* parent);
272 int minRequiredArgs() const { return 1; }
273 int maxAllowedArgs() const { return 1; }
274 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
275 ExprType_t argType(int iArg) const { return INT_EXPR; }
276 VMFnResult* exec(VMFnArgs* args);
277 protected:
278 InstrumentScriptVM* m_vm;
279 };
280
281 // overrides core wait() implementation
282 class InstrumentScriptVMFunction_wait : public CoreVMFunction_wait {
283 public:
284 InstrumentScriptVMFunction_wait(InstrumentScriptVM* parent);
285 VMFnResult* exec(VMFnArgs* args);
286 };
287
288 class InstrumentScriptVMFunction_stop_wait : public VMEmptyResultFunction {
289 public:
290 InstrumentScriptVMFunction_stop_wait(InstrumentScriptVM* parent);
291 int minRequiredArgs() const { return 1; }
292 int maxAllowedArgs() const { return 2; }
293 bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
294 ExprType_t argType(int iArg) const { return INT_EXPR; }
295 VMFnResult* exec(VMFnArgs* args);
296 protected:
297 InstrumentScriptVM* m_vm;
298 };
299
300 } // namespace LinuxSampler
301
302 #endif // LS_INSTRSCRIPTVMFUNCTIONS_H

  ViewVC Help
Powered by ViewVC