-
Notifications
You must be signed in to change notification settings - Fork 5
/
sndgrp.h
282 lines (203 loc) · 8.69 KB
/
sndgrp.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
#pragma once
#ifndef __INTERGEN_GENERATED__sndgrp_H__
#define __INTERGEN_GENERATED__sndgrp_H__
//@file Interface file for sndgrp interface generated by intergen
//See LICENSE file for copyright and license information
#include <comm/commexception.h>
#include <comm/intergen/ifc.h>
namespace snd { class group; }
#include <ot/sound_cfg.h>
namespace snd {
class group;
}
namespace ot {
////////////////////////////////////////////////////////////////////////////////
///Interface
class sndgrp
: public intergen_interface
{
public:
// --- interface methods ---
///Load sound files from object or package directory
//@param filename relative path to the sound file
//@note in case of an independent sound group, filename refers to the relative path in data or program directory
uint load_sound( const coid::token& filename );
///
//@param bone bone id
//@param type sound type
uint create_source( uint bone, ot::sound_type type = ot::sound_type::universal );
uint create_source_wo_bone( ot::sound_type type = ot::sound_type::universal );
/// set source ECEF position once it's used source always be using ECEF
void set_source_ecef( uint source_id, const double3& pos );
///
void play( uint id, uint snd, bool looping, bool enqueue, bool break_prev_loops = true );
/// Play sound once, discarding older sounds
void play_sound( uint id, uint snd );
/// Play looped sound, breaking other sounds
void play_loop( uint id, uint snd );
/// Enqueue sound once, previous loops are finished and then discarded
void enqueue_sound( uint id, uint snd );
/// Enqueue looped sound. If @break_prev_loops is true, previous loops are removed after completion,
/// and only this sound remains looped. Otherwise the new sound is added to the loop chain.
void enqueue_loop( uint id, uint snd, bool break_prev_loops = true );
///
bool is_playing( uint id );
bool is_looping( uint id );
void stop( uint id );
///
void set_pitch( uint id, float pitch );
/// Open AL distance attenuation model
/// https://www.desmos.com/calculator/f20nyvlupa
void set_ref_distance( uint id, float ref_dist );
///
void set_gain( uint id, float gain );
// --- creators ---
///Internal constructor
static iref<sndgrp> _get_sndgrp( snd::group* p ) {
return _get_sndgrp<sndgrp>(0, p);
}
template<class T>
static iref<T> _get_sndgrp( T* _subclass_, snd::group* p );
///Create a sound group object
//@note
static iref<sndgrp> create() {
return create<sndgrp>(0);
}
template<class T>
static iref<T> create( T* _subclass_ );
// --- internal helpers ---
///Interface revision hash
static const int HASHID = 1696759525;
///Interface name (full ns::class string)
static const coid::tokenhash& IFCNAME() {
static const coid::tokenhash _name = "ot::sndgrp";
return _name;
}
int intergen_hash_id() const override final { return HASHID; }
bool iface_is_derived( int hash ) const override final {
return hash == HASHID;
}
const coid::tokenhash& intergen_interface_name() const override final {
return IFCNAME();
}
static const coid::token& intergen_default_creator_static( EBackend bck ) {
static const coid::token _dc("ot::sndgrp.create@1696759525");
static const coid::token _djs("ot::sndgrp@wrapper.js");
static const coid::token _djsc("ot::sndgrp@wrapper.jsc");
static const coid::token _dlua("ot::sndgrp@wrapper.lua");
static const coid::token _dnone;
switch(bck) {
case IFC_BACKEND_CXX: return _dc;
case IFC_BACKEND_JS: return _djs;
case IFC_BACKEND_JSC: return _djsc;
case IFC_BACKEND_LUA: return _dlua;
default: return _dnone;
}
}
template<enum EBackend B>
static void* intergen_wrapper_cache() {
static void* _cached_wrapper=0;
if (!_cached_wrapper) {
const coid::token& tok = intergen_default_creator_static(B);
_cached_wrapper = coid::interface_register::get_interface_creator(tok);
}
return _cached_wrapper;
}
void* intergen_wrapper( EBackend bck ) const override final {
switch(bck) {
case IFC_BACKEND_JS: return intergen_wrapper_cache<IFC_BACKEND_JS>();
case IFC_BACKEND_JSC: return intergen_wrapper_cache<IFC_BACKEND_JSC>();
case IFC_BACKEND_LUA: return intergen_wrapper_cache<IFC_BACKEND_LUA>();
default: return 0;
}
}
EBackend intergen_backend() const override { return IFC_BACKEND_CXX; }
const coid::token& intergen_default_creator( EBackend bck ) const override final {
return intergen_default_creator_static(bck);
}
///Client registrator
template<class C>
static int register_client()
{
static_assert(std::is_base_of<sndgrp, C>::value, "not a base class");
typedef iref<intergen_interface> (*fn_client)(void*, intergen_interface*);
fn_client cc = [](void*, intergen_interface*) -> iref<intergen_interface> { return new C; };
coid::token type = typeid(C).name();
type.consume("class ");
type.consume("struct ");
coid::charstr tmp = "ot::sndgrp";
tmp << "@client-1696759525" << '.' << type;
coid::interface_register::register_interface_creator(tmp, cc);
return 0;
}
protected:
sndgrp()
{}
};
////////////////////////////////////////////////////////////////////////////////
template<class T>
inline iref<T> sndgrp::_get_sndgrp( T* _subclass_, snd::group* p )
{
typedef iref<T> (*fn_creator)(sndgrp*, snd::group*);
static fn_creator create = 0;
static const coid::token ifckey = "ot::sndgrp._get_sndgrp@1696759525";
if (!create)
create = reinterpret_cast<fn_creator>(
coid::interface_register::get_interface_creator(ifckey));
if (!create) {
log_mismatch("_get_sndgrp", "ot::sndgrp._get_sndgrp", "@1696759525");
return 0;
}
return create(_subclass_, p);
}
////////////////////////////////////////////////////////////////////////////////
template<class T>
inline iref<T> sndgrp::create( T* _subclass_ )
{
typedef iref<T> (*fn_creator)(sndgrp*);
static fn_creator create = 0;
static const coid::token ifckey = "ot::sndgrp.create@1696759525";
if (!create)
create = reinterpret_cast<fn_creator>(
coid::interface_register::get_interface_creator(ifckey));
if (!create) {
log_mismatch("create", "ot::sndgrp.create", "@1696759525");
return 0;
}
return create(_subclass_);
}
#pragma warning(push)
#pragma warning(disable : 4191)
inline uint sndgrp::load_sound( const coid::token& filename )
{ return VT_CALL(uint,(const coid::token&),0)(filename); }
inline uint sndgrp::create_source( uint bone, ot::sound_type type )
{ return VT_CALL(uint,(uint,ot::sound_type),1)(bone,type); }
inline uint sndgrp::create_source_wo_bone( ot::sound_type type )
{ return VT_CALL(uint,(ot::sound_type),2)(type); }
inline void sndgrp::set_source_ecef( uint source_id, const double3& pos )
{ return VT_CALL(void,(uint,const double3&),3)(source_id,pos); }
inline void sndgrp::play( uint id, uint snd, bool looping, bool enqueue, bool break_prev_loops )
{ return VT_CALL(void,(uint,uint,bool,bool,bool),4)(id,snd,looping,enqueue,break_prev_loops); }
inline void sndgrp::play_sound( uint id, uint snd )
{ return VT_CALL(void,(uint,uint),5)(id,snd); }
inline void sndgrp::play_loop( uint id, uint snd )
{ return VT_CALL(void,(uint,uint),6)(id,snd); }
inline void sndgrp::enqueue_sound( uint id, uint snd )
{ return VT_CALL(void,(uint,uint),7)(id,snd); }
inline void sndgrp::enqueue_loop( uint id, uint snd, bool break_prev_loops )
{ return VT_CALL(void,(uint,uint,bool),8)(id,snd,break_prev_loops); }
inline bool sndgrp::is_playing( uint id )
{ return VT_CALL(bool,(uint),9)(id); }
inline bool sndgrp::is_looping( uint id )
{ return VT_CALL(bool,(uint),10)(id); }
inline void sndgrp::stop( uint id )
{ return VT_CALL(void,(uint),11)(id); }
inline void sndgrp::set_pitch( uint id, float pitch )
{ return VT_CALL(void,(uint,float),12)(id,pitch); }
inline void sndgrp::set_ref_distance( uint id, float ref_dist )
{ return VT_CALL(void,(uint,float),13)(id,ref_dist); }
inline void sndgrp::set_gain( uint id, float gain )
{ return VT_CALL(void,(uint,float),14)(id,gain); }
#pragma warning(pop)
} //namespace
#endif //__INTERGEN_GENERATED__sndgrp_H__