engines/common/InstrumentScriptVMFunctions.h

/*
 * Copyright (c) 2014 - 2017 Christian Schoenebeck
 *
 * http://www.linuxsampler.org
 *
 * This file is part of LinuxSampler and released under the same terms.
 * See README file for details.
 */

#ifndef LS_INSTRSCRIPTVMFUNCTIONS_H
#define LS_INSTRSCRIPTVMFUNCTIONS_H

#include "../../common/global.h"
#include "../../scriptvm/CoreVMFunctions.h"
#include "Note.h"

namespace LinuxSampler {

    class EventGroup;
    class InstrumentScriptVM;

    class InstrumentScriptVMFunction_play_note : public VMIntResultFunction {
    public:
        InstrumentScriptVMFunction_play_note(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 1; }
        int maxAllowedArgs() const { return 4; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_set_controller : public VMIntResultFunction {
    public:
        InstrumentScriptVMFunction_set_controller(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_ignore_event : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_ignore_event(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 1; }
        int maxAllowedArgs() const { return 1; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_ignore_controller : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_ignore_controller(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 0; }
        int maxAllowedArgs() const { return 1; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_note_off : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_note_off(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 1; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_set_event_mark : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_set_event_mark(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_delete_event_mark : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_delete_event_mark(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_by_marks : public VMFunction {
    public:
        InstrumentScriptVMFunction_by_marks(InstrumentScriptVM* parent);
        int minRequiredArgs() const OVERRIDE { return 1; }
        int maxAllowedArgs() const OVERRIDE { return 1; }
        bool acceptsArgType(int iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR;}
        bool modifiesArg(int iArg) const OVERRIDE { return false; }
        ExprType_t argType(int iArg) const OVERRIDE { return INT_EXPR; }
        ExprType_t returnType() OVERRIDE { return INT_ARR_EXPR; }
        VMFnResult* exec(VMFnArgs* args) OVERRIDE;
    protected:
        InstrumentScriptVM* m_vm;
        class Result : public VMFnResult, public VMIntArrayExpr {
        public:
            StmtFlags_t flags;
            EventGroup* eventGroup;

            int arraySize() const OVERRIDE;
            int evalIntElement(uint i) OVERRIDE;
            void assignIntElement(uint i, int value) OVERRIDE {} // ignore assignment
            VMExpr* resultValue() OVERRIDE { return this; }
            StmtFlags_t resultFlags() OVERRIDE { return flags; }
            bool isConstExpr() const OVERRIDE { return false; }
        } m_result;

        VMFnResult* errorResult();
        VMFnResult* successResult(EventGroup* eventGroup);
    };

    class InstrumentScriptVMFunction_change_vol : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_vol(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 3; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_change_tune : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_tune(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 3; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_change_pan : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_pan(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 3; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_change_cutoff : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_cutoff(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_change_reso : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_reso(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };
    
    class InstrumentScriptVMFunction_change_attack : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_attack(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_change_decay : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_decay(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };
    
    class InstrumentScriptVMFunction_change_release : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_change_release(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class VMChangeSynthParamFunction : public VMEmptyResultFunction {
    public:
        VMChangeSynthParamFunction(InstrumentScriptVM* parent) : m_vm(parent) {}
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }

        template<float NoteBase::_Override::*T_noteParam, int T_synthParam,
                 bool T_isNormalizedParam, int T_maxValue = 1000000,
                 int T_minValue = 0>
        VMFnResult* execTemplate(VMFnArgs* args, const char* functionName);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_change_amp_lfo_depth : public VMChangeSynthParamFunction {
    public:
        InstrumentScriptVMFunction_change_amp_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
        VMFnResult* exec(VMFnArgs* args);
    };

    class InstrumentScriptVMFunction_change_amp_lfo_freq : public VMChangeSynthParamFunction {
    public:
        InstrumentScriptVMFunction_change_amp_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
        VMFnResult* exec(VMFnArgs* args);
    };

    class InstrumentScriptVMFunction_change_pitch_lfo_depth : public VMChangeSynthParamFunction {
    public:
        InstrumentScriptVMFunction_change_pitch_lfo_depth(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
        VMFnResult* exec(VMFnArgs* args);
    };

    class InstrumentScriptVMFunction_change_pitch_lfo_freq : public VMChangeSynthParamFunction {
    public:
        InstrumentScriptVMFunction_change_pitch_lfo_freq(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
        VMFnResult* exec(VMFnArgs* args);
    };

    class InstrumentScriptVMFunction_change_vol_time : public VMChangeSynthParamFunction {
    public:
        InstrumentScriptVMFunction_change_vol_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
        VMFnResult* exec(VMFnArgs* args);
    };

    class InstrumentScriptVMFunction_change_tune_time : public VMChangeSynthParamFunction {
    public:
        InstrumentScriptVMFunction_change_tune_time(InstrumentScriptVM* parent) : VMChangeSynthParamFunction(parent) {}
        VMFnResult* exec(VMFnArgs* args);
    };

    class InstrumentScriptVMFunction_fade_in : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_fade_in(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_fade_out : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_fade_out(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 2; }
        int maxAllowedArgs() const { return 3; }
        bool acceptsArgType(int iArg, ExprType_t type) const;
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    class InstrumentScriptVMFunction_event_status : public VMIntResultFunction {
    public:
        InstrumentScriptVMFunction_event_status(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 1; }
        int maxAllowedArgs() const { return 1; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

    // overrides core wait() implementation
    class InstrumentScriptVMFunction_wait : public CoreVMFunction_wait {
    public:
        InstrumentScriptVMFunction_wait(InstrumentScriptVM* parent);
        VMFnResult* exec(VMFnArgs* args);
    };

    class InstrumentScriptVMFunction_stop_wait : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_stop_wait(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 1; }
        int maxAllowedArgs() const { return 2; }
        bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR;}
        ExprType_t argType(int iArg) const { return INT_EXPR; }
        VMFnResult* exec(VMFnArgs* args);
    protected:
        InstrumentScriptVM* m_vm;
    };

} // namespace LinuxSampler

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