tmp
[blender.git] / extern / audaspace / bindings / C / AUD_Handle.h
1 /*******************************************************************************
2  * Copyright 2009-2016 Jörg Müller
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *   http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  ******************************************************************************/
16
17 #pragma once
18
19 #include "AUD_Types.h"
20
21 #ifdef __cplusplus
22 extern "C" {
23 #endif
24
25 /// Status of a playback handle.
26 typedef enum
27 {
28         AUD_STATUS_INVALID = 0,                 /// Invalid handle. Maybe due to stopping.
29         AUD_STATUS_PLAYING,                             /// Sound is playing.
30         AUD_STATUS_PAUSED,                              /// Sound is being paused.
31         AUD_STATUS_STOPPED                              /// Sound is stopped but kept in the device.
32 } AUD_Status;
33
34 /**
35  * Pauses a played back sound.
36  * \param handle The handle to the sound.
37  * \return Whether the handle has been playing or not.
38  */
39 extern AUD_API int AUD_Handle_pause(AUD_Handle* handle);
40
41 /**
42  * Resumes a paused sound.
43  * \param handle The handle to the sound.
44  * \return Whether the handle has been paused or not.
45  */
46 extern AUD_API int AUD_Handle_resume(AUD_Handle* handle);
47
48 /**
49  * Stops a playing or paused sound.
50  * \param handle The handle to the sound.
51  * \return Whether the handle has been valid or not.
52  */
53 extern AUD_API int AUD_Handle_stop(AUD_Handle* handle);
54
55 /**
56  * Retrieves the attenuation of a handle.
57  * param handle The handle to get the attenuation from.
58  * return The attenuation of the handle.
59  */
60 extern AUD_API float AUD_Handle_getAttenuation(AUD_Handle* handle);
61
62 /**
63  * Sets the attenuation of a handle.
64  * param handle The handle to set the attenuation from.
65  * param value The new attenuation to set.
66  */
67 extern AUD_API int AUD_Handle_setAttenuation(AUD_Handle* handle, float value);
68
69 /**
70  * Retrieves the cone angle inner of a handle.
71  * param handle The handle to get the cone angle inner from.
72  * return The cone angle inner of the handle.
73  */
74 extern AUD_API float AUD_Handle_getConeAngleInner(AUD_Handle* handle);
75
76 /**
77  * Sets the cone angle inner of a handle.
78  * param handle The handle to set the cone angle inner from.
79  * param value The new cone angle inner to set.
80  */
81 extern AUD_API int AUD_Handle_setConeAngleInner(AUD_Handle* handle, float value);
82
83 /**
84  * Retrieves the cone angle outer of a handle.
85  * param handle The handle to get the cone angle outer from.
86  * return The cone angle outer of the handle.
87  */
88 extern AUD_API float AUD_Handle_getConeAngleOuter(AUD_Handle* handle);
89
90 /**
91  * Sets the cone angle outer of a handle.
92  * param handle The handle to set the cone angle outer from.
93  * param value The new cone angle outer to set.
94  */
95 extern AUD_API int AUD_Handle_setConeAngleOuter(AUD_Handle* handle, float value);
96
97 /**
98  * Retrieves the cone volume outer of a handle.
99  * param handle The handle to get the cone volume outer from.
100  * return The cone volume outer of the handle.
101  */
102 extern AUD_API float AUD_Handle_getConeVolumeOuter(AUD_Handle* handle);
103
104 /**
105  * Sets the cone volume outer of a handle.
106  * param handle The handle to set the cone volume outer from.
107  * param value The new cone volume outer to set.
108  */
109 extern AUD_API int AUD_Handle_setConeVolumeOuter(AUD_Handle* handle, float value);
110
111 /**
112  * Retrieves the distance maximum of a handle.
113  * param handle The handle to get the distance maximum from.
114  * return The distance maximum of the handle.
115  */
116 extern AUD_API float AUD_Handle_getDistanceMaximum(AUD_Handle* handle);
117
118 /**
119  * Sets the distance maximum of a handle.
120  * param handle The handle to set the distance maximum from.
121  * param value The new distance maximum to set.
122  */
123 extern AUD_API int AUD_Handle_setDistanceMaximum(AUD_Handle* handle, float value);
124
125 /**
126  * Retrieves the distance reference of a handle.
127  * param handle The handle to get the distance reference from.
128  * return The distance reference of the handle.
129  */
130 extern AUD_API float AUD_Handle_getDistanceReference(AUD_Handle* handle);
131
132 /**
133  * Sets the distance reference of a handle.
134  * param handle The handle to set the distance reference from.
135  * param value The new distance reference to set.
136  */
137 extern AUD_API int AUD_Handle_setDistanceReference(AUD_Handle* handle, float value);
138
139 /**
140  * Retrieves the keep of a handle.
141  * param handle The handle to get the keep from.
142  * return The keep of the handle.
143  */
144 extern AUD_API int AUD_Handle_doesKeep(AUD_Handle* handle);
145
146 /**
147  * Sets the keep of a handle.
148  * param handle The handle to set the keep from.
149  * param value The new keep to set.
150  */
151 extern AUD_API int AUD_Handle_setKeep(AUD_Handle* handle, int value);
152
153 /**
154  * Retrieves the location of a handle.
155  * param handle The handle to get the location from.
156  * return The location of the handle.
157  */
158 extern AUD_API int AUD_Handle_getLocation(AUD_Handle* handle, float value[3]);
159
160 /**
161  * Sets the location of a handle.
162  * param handle The handle to set the location from.
163  * param value The new location to set.
164  */
165 extern AUD_API int AUD_Handle_setLocation(AUD_Handle* handle, const float value[3]);
166
167 /**
168  * Retrieves the loop count of a handle.
169  * param handle The handle to get the loop count from.
170  * return The loop count of the handle.
171  */
172 extern AUD_API int AUD_Handle_getLoopCount(AUD_Handle* handle);
173
174 /**
175  * Sets the loop count of a handle.
176  * param handle The handle to set the loop count from.
177  * param value The new loop count to set.
178  */
179 extern AUD_API int AUD_Handle_setLoopCount(AUD_Handle* handle, int value);
180
181 /**
182  * Retrieves the orientation of a handle.
183  * param handle The handle to get the orientation from.
184  * return The orientation of the handle.
185  */
186 extern AUD_API int AUD_Handle_getOrientation(AUD_Handle* handle, float value[4]);
187
188 /**
189  * Sets the orientation of a handle.
190  * param handle The handle to set the orientation from.
191  * param value The new orientation to set.
192  */
193 extern AUD_API int AUD_Handle_setOrientation(AUD_Handle* handle, const float value[4]);
194
195 /**
196  * Retrieves the pitch of a handle.
197  * param handle The handle to get the pitch from.
198  * return The pitch of the handle.
199  */
200 extern AUD_API float AUD_Handle_getPitch(AUD_Handle* handle);
201
202 /**
203  * Sets the pitch of a handle.
204  * param handle The handle to set the pitch from.
205  * param value The new pitch to set.
206  */
207 extern AUD_API int AUD_Handle_setPitch(AUD_Handle* handle, float value);
208
209 /**
210  * Retrieves the position of a handle.
211  * param handle The handle to get the position from.
212  * return The position of the handle.
213  */
214 extern AUD_API float AUD_Handle_getPosition(AUD_Handle* handle);
215
216 /**
217  * Sets the position of a handle.
218  * param handle The handle to set the position from.
219  * param value The new position to set.
220  */
221 extern AUD_API int AUD_Handle_setPosition(AUD_Handle* handle, float value);
222
223 /**
224  * Retrieves the relative of a handle.
225  * param handle The handle to get the relative from.
226  * return The relative of the handle.
227  */
228 extern AUD_API int AUD_Handle_isRelative(AUD_Handle* handle);
229
230 /**
231  * Sets the relative of a handle.
232  * param handle The handle to set the relative from.
233  * param value The new relative to set.
234  */
235 extern AUD_API int AUD_Handle_setRelative(AUD_Handle* handle, int value);
236
237 /**
238  * Retrieves the status of a handle.
239  * param handle The handle to get the status from.
240  * return The status of the handle.
241  */
242 extern AUD_API AUD_Status AUD_Handle_getStatus(AUD_Handle* handle);
243
244 /**
245  * Retrieves the velocity of a handle.
246  * param handle The handle to get the velocity from.
247  * return The velocity of the handle.
248  */
249 extern AUD_API int AUD_Handle_getVelocity(AUD_Handle* handle, float value[3]);
250
251 /**
252  * Sets the velocity of a handle.
253  * param handle The handle to set the velocity from.
254  * param value The new velocity to set.
255  */
256 extern AUD_API int AUD_Handle_setVelocity(AUD_Handle* handle, const float value[3]);
257
258 /**
259  * Retrieves the volume of a handle.
260  * param handle The handle to get the volume from.
261  * return The volume of the handle.
262  */
263 extern AUD_API float AUD_Handle_getVolume(AUD_Handle* handle);
264
265 /**
266  * Sets the volume of a handle.
267  * param handle The handle to set the volume from.
268  * param value The new volume to set.
269  */
270 extern AUD_API int AUD_Handle_setVolume(AUD_Handle* handle, float value);
271
272 /**
273  * Retrieves the volume maximum of a handle.
274  * param handle The handle to get the volume maximum from.
275  * return The volume maximum of the handle.
276  */
277 extern AUD_API float AUD_Handle_getVolumeMaximum(AUD_Handle* handle);
278
279 /**
280  * Sets the volume maximum of a handle.
281  * param handle The handle to set the volume maximum from.
282  * param value The new volume maximum to set.
283  */
284 extern AUD_API int AUD_Handle_setVolumeMaximum(AUD_Handle* handle, float value);
285
286 /**
287  * Retrieves the volume minimum of a handle.
288  * param handle The handle to get the volume minimum from.
289  * return The volume minimum of the handle.
290  */
291 extern AUD_API float AUD_Handle_getVolumeMinimum(AUD_Handle* handle);
292
293 /**
294  * Sets the volume minimum of a handle.
295  * param handle The handle to set the volume minimum from.
296  * param value The new volume minimum to set.
297  */
298 extern AUD_API int AUD_Handle_setVolumeMinimum(AUD_Handle* handle, float value);
299
300 /**
301  * Frees a handle.
302  * \param channel Handle to free.
303  */
304 extern AUD_API void AUD_Handle_free(AUD_Handle* channel);
305
306 #ifdef __cplusplus
307 }
308 #endif