Audaspace:
[blender.git] / intern / audaspace / intern / AUD_SequencerEntry.h
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * Copyright 2009-2011 Jörg Hermann Müller
5  *
6  * This file is part of AudaSpace.
7  *
8  * Audaspace is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * AudaSpace is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with Audaspace; if not, write to the Free Software Foundation,
20  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 /** \file audaspace/intern/AUD_SequencerEntry.h
26  *  \ingroup audaspaceintern
27  */
28
29
30 #ifndef __AUD_SEQUENCERENTRY_H__
31 #define __AUD_SEQUENCERENTRY_H__
32
33 #include "AUD_AnimateableProperty.h"
34 #include "AUD_IFactory.h"
35 #include "AUD_ILockable.h"
36
37 #include <pthread.h>
38 #include <boost/shared_ptr.hpp>
39
40 /**
41  * This class represents a sequenced entry in a sequencer factory.
42  */
43 class AUD_SequencerEntry : public AUD_ILockable
44 {
45         friend class AUD_SequencerHandle;
46 private:
47         /// The status of the entry. Changes every time a non-animated parameter changes.
48         int m_status;
49
50         /// The positional status of the entry. Changes every time the entry is moved.
51         int m_pos_status;
52
53         /// The sound status, changed when the sound is changed.
54         int m_sound_status;
55
56         /// The unique (regarding the factory) ID of the entry.
57         int m_id;
58
59         /// The sound this entry plays.
60         boost::shared_ptr<AUD_IFactory> m_sound;
61
62         /// The begin time.
63         float m_begin;
64
65         /// The end time.
66         float m_end;
67
68         /// How many seconds are skipped at the beginning.
69         float m_skip;
70
71         /// Whether the entry is muted.
72         bool m_muted;
73
74         /// Whether the position to the listener is relative or absolute
75         bool m_relative;
76
77         /// Maximum volume.
78         float m_volume_max;
79
80         /// Minimum volume.
81         float m_volume_min;
82
83         /// Maximum distance.
84         float m_distance_max;
85
86         /// Reference distance;
87         float m_distance_reference;
88
89         /// Attenuation
90         float m_attenuation;
91
92         /// Cone outer angle.
93         float m_cone_angle_outer;
94
95         /// Cone inner angle.
96         float m_cone_angle_inner;
97
98         /// Cone outer volume.
99         float m_cone_volume_outer;
100
101         /// The mutex for locking.
102         pthread_mutex_t m_mutex;
103
104         /// The animated volume.
105         AUD_AnimateableProperty m_volume;
106
107         /// The animated panning.
108         AUD_AnimateableProperty m_panning;
109
110         /// The animated pitch.
111         AUD_AnimateableProperty m_pitch;
112
113         /// The animated location.
114         AUD_AnimateableProperty m_location;
115
116         /// The animated orientation.
117         AUD_AnimateableProperty m_orientation;
118
119 public:
120         /**
121          * Creates a new sequenced entry.
122          * \param sound The sound this entry should play.
123          * \param begin The start time.
124          * \param end The end time or a negative value if determined by the sound.
125          * \param skip How much seconds should be skipped at the beginning.
126          * \param id The ID of the entry.
127          */
128         AUD_SequencerEntry(boost::shared_ptr<AUD_IFactory> sound, float begin, float end, float skip, int id);
129         virtual ~AUD_SequencerEntry();
130
131         /**
132          * Locks the entry.
133          */
134         virtual void lock();
135
136         /**
137          * Unlocks the previously locked entry.
138          */
139         virtual void unlock();
140
141         /**
142          * Sets the sound of the entry.
143          * \param sound The new sound.
144          */
145         void setSound(boost::shared_ptr<AUD_IFactory> sound);
146
147         /**
148          * Moves the entry.
149          * \param begin The new start time.
150          * \param end The new end time or a negative value if unknown.
151          * \param skip How many seconds to skip at the beginning.
152          */
153         void move(float begin, float end, float skip);
154
155         /**
156          * Sets the muting state of the entry.
157          * \param mute Whether the entry should be muted or not.
158          */
159         void mute(bool mute);
160
161         /**
162          * Retrieves the ID of the entry.
163          * \return The ID of the entry.
164          */
165         int getID() const;
166
167         /**
168          * Retrieves one of the animated properties of the entry.
169          * \param type Which animated property to retrieve.
170          * \return A pointer to the animated property, valid as long as the
171          *         entry is.
172          */
173         AUD_AnimateableProperty* getAnimProperty(AUD_AnimateablePropertyType type);
174
175         /**
176          * Updates all non-animated parameters of the entry.
177          * \param volume_max The maximum volume.
178          * \param volume_min The minimum volume.
179          * \param distance_max The maximum distance.
180          * \param distance_reference The reference distance.
181          * \param attenuation The attenuation.
182          * \param cone_angle_outer The outer cone opening angle.
183          * \param cone_angle_inner The inner cone opening angle.
184          * \param cone_volume_outer The volume outside the outer cone.
185          */
186         void updateAll(float volume_max, float volume_min, float distance_max,
187                                    float distance_reference, float attenuation, float cone_angle_outer,
188                                    float cone_angle_inner, float cone_volume_outer);
189
190         /**
191          * Checks whether the source location, velocity and orientation are relative
192          * to the listener.
193          * \return Whether the source is relative.
194          */
195         bool isRelative();
196
197         /**
198          * Sets whether the source location, velocity and orientation are relative
199          * to the listener.
200          * \param relative Whether the source is relative.
201          * \return Whether the action succeeded.
202          */
203         void setRelative(bool relative);
204
205         /**
206          * Retrieves the maximum volume of a source.
207          * \return The maximum volume.
208          */
209         float getVolumeMaximum();
210
211         /**
212          * Sets the maximum volume of a source.
213          * \param volume The new maximum volume.
214          * \return Whether the action succeeded.
215          */
216         void setVolumeMaximum(float volume);
217
218         /**
219          * Retrieves the minimum volume of a source.
220          * \return The minimum volume.
221          */
222         float getVolumeMinimum();
223
224         /**
225          * Sets the minimum volume of a source.
226          * \param volume The new minimum volume.
227          * \return Whether the action succeeded.
228          */
229         void setVolumeMinimum(float volume);
230
231         /**
232          * Retrieves the maximum distance of a source.
233          * If a source is further away from the reader than this distance, the
234          * volume will automatically be set to 0.
235          * \return The maximum distance.
236          */
237         float getDistanceMaximum();
238
239         /**
240          * Sets the maximum distance of a source.
241          * If a source is further away from the reader than this distance, the
242          * volume will automatically be set to 0.
243          * \param distance The new maximum distance.
244          * \return Whether the action succeeded.
245          */
246         void setDistanceMaximum(float distance);
247
248         /**
249          * Retrieves the reference distance of a source.
250          * \return The reference distance.
251          */
252         float getDistanceReference();
253
254         /**
255          * Sets the reference distance of a source.
256          * \param distance The new reference distance.
257          * \return Whether the action succeeded.
258          */
259         void setDistanceReference(float distance);
260
261         /**
262          * Retrieves the attenuation of a source.
263          * \return The attenuation.
264          */
265         float getAttenuation();
266
267         /**
268          * Sets the attenuation of a source.
269          * This value is used for distance calculation.
270          * \param factor The new attenuation.
271          * \return Whether the action succeeded.
272          */
273         void setAttenuation(float factor);
274
275         /**
276          * Retrieves the outer angle of the cone of a source.
277          * \return The outer angle of the cone.
278          */
279         float getConeAngleOuter();
280
281         /**
282          * Sets the outer angle of the cone of a source.
283          * \param angle The new outer angle of the cone.
284          * \return Whether the action succeeded.
285          */
286         void setConeAngleOuter(float angle);
287
288         /**
289          * Retrieves the inner angle of the cone of a source.
290          * \return The inner angle of the cone.
291          */
292         float getConeAngleInner();
293
294         /**
295          * Sets the inner angle of the cone of a source.
296          * \param angle The new inner angle of the cone.
297          * \return Whether the action succeeded.
298          */
299         void setConeAngleInner(float angle);
300
301         /**
302          * Retrieves the outer volume of the cone of a source.
303          * The volume between inner and outer angle is interpolated between inner
304          * volume and this value.
305          * \return The outer volume of the cone.
306          */
307         float getConeVolumeOuter();
308
309         /**
310          * Sets the outer volume of the cone of a source.
311          * The volume between inner and outer angle is interpolated between inner
312          * volume and this value.
313          * \param volume The new outer volume of the cone.
314          * \return Whether the action succeeded.
315          */
316         void setConeVolumeOuter(float volume);
317 };
318
319 #endif //__AUD_SEQUENCERENTRY_H__