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 0; }
        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, int T_minValue>
        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_get_event_par : public VMIntResultFunction {
    public:
        InstrumentScriptVMFunction_get_event_par(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_set_event_par : public VMEmptyResultFunction {
    public:
        InstrumentScriptVMFunction_set_event_par(InstrumentScriptVM* parent);
        int minRequiredArgs() const { return 3; }
        int maxAllowedArgs() const { return 3; }
        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_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	schoenebeck	2596	/*
2	schoenebeck	3118	* Copyright (c) 2014 - 2017 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	2598	class InstrumentScriptVMFunction_play_note : public VMIntResultFunction {
23	schoenebeck	2596	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	schoenebeck	2600	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	schoenebeck	2598	class InstrumentScriptVMFunction_ignore_event : public VMEmptyResultFunction {
47			public:
48			InstrumentScriptVMFunction_ignore_event(InstrumentScriptVM* parent);
49	schoenebeck	3212	int minRequiredArgs() const { return 0; }
50	schoenebeck	2598	int maxAllowedArgs() const { return 1; }
51	schoenebeck	2630	bool acceptsArgType(int iArg, ExprType_t type) const;
52	schoenebeck	2598	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	schoenebeck	2629	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	schoenebeck	2630	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	schoenebeck	2629	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	schoenebeck	2630	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	schoenebeck	3054	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	schoenebeck	2945	bool modifiesArg(int iArg) const OVERRIDE { return false; }
113	schoenebeck	3054	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	schoenebeck	2630	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	schoenebeck	3054	StmtFlags_t resultFlags() OVERRIDE { return flags; }
128	schoenebeck	2945	bool isConstExpr() const OVERRIDE { return false; }
129	schoenebeck	2630	} m_result;
130
131			VMFnResult* errorResult();
132			VMFnResult* successResult(EventGroup* eventGroup);
133			};
134
135	schoenebeck	2931	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	schoenebeck	2935	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	schoenebeck	2953
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	schoenebeck	2935
207	schoenebeck	2953	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	schoenebeck	3118	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	schoenebeck	3188	template<float NoteBase::_Override::*T_noteParam, int T_synthParam,
240	schoenebeck	3193	bool T_isNormalizedParam, int T_maxValue, int T_minValue>
241	schoenebeck	3118	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	schoenebeck	3188	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	schoenebeck	3193	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	schoenebeck	2935	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	schoenebeck	2948	// 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	schoenebeck	2596	} // namespace LinuxSampler
362
363			#endif // LS_INSTRSCRIPTVMFUNCTIONS_H