tmp
[blender.git] / extern / audaspace / include / sequence / SequenceEntry.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 /**
20  * @file SequenceEntry.h
21  * @ingroup sequence
22  * The SequenceEntry class.
23  */
24
25 #include "sequence/AnimateableProperty.h"
26 #include "util/ILockable.h"
27
28 #include <mutex>
29 #include <memory>
30
31 AUD_NAMESPACE_BEGIN
32
33 class ISound;
34
35 /**
36  * This class represents a sequenced entry in a sequencer sound.
37  */
38 class AUD_API SequenceEntry : public ILockable
39 {
40         friend class SequenceHandle;
41 private:
42         /// The status of the entry. Changes every time a non-animated parameter changes.
43         int m_status;
44
45         /// The positional status of the entry. Changes every time the entry is moved.
46         int m_pos_status;
47
48         /// The sound status, changed when the sound is changed.
49         int m_sound_status;
50
51         /// The unique (regarding the sound) ID of the entry.
52         int m_id;
53
54         /// The sound this entry plays.
55         std::shared_ptr<ISound> m_sound;
56
57         /// The begin time.
58         float m_begin;
59
60         /// The end time.
61         float m_end;
62
63         /// How many seconds are skipped at the beginning.
64         float m_skip;
65
66         /// Whether the entry is muted.
67         bool m_muted;
68
69         /// Whether the position to the listener is relative or absolute
70         bool m_relative;
71
72         /// Maximum volume.
73         float m_volume_max;
74
75         /// Minimum volume.
76         float m_volume_min;
77
78         /// Maximum distance.
79         float m_distance_max;
80
81         /// Reference distance;
82         float m_distance_reference;
83
84         /// Attenuation
85         float m_attenuation;
86
87         /// Cone outer angle.
88         float m_cone_angle_outer;
89
90         /// Cone inner angle.
91         float m_cone_angle_inner;
92
93         /// Cone outer volume.
94         float m_cone_volume_outer;
95
96         /// The mutex for locking.
97         std::recursive_mutex m_mutex;
98
99         /// The animated volume.
100         AnimateableProperty m_volume;
101
102         /// The animated panning.
103         AnimateableProperty m_panning;
104
105         /// The animated pitch.
106         AnimateableProperty m_pitch;
107
108         /// The animated location.
109         AnimateableProperty m_location;
110
111         /// The animated orientation.
112         AnimateableProperty m_orientation;
113
114         // delete copy constructor and operator=
115         SequenceEntry(const SequenceEntry&) = delete;
116         SequenceEntry& operator=(const SequenceEntry&) = delete;
117
118 public:
119         /**
120          * Creates a new sequenced entry.
121          * \param sound The sound this entry should play.
122          * \param begin The start time.
123          * \param end The end time or a negative value if determined by the sound.
124          * \param skip How much seconds should be skipped at the beginning.
125          * \param id The ID of the entry.
126          */
127         SequenceEntry(std::shared_ptr<ISound> sound, float begin, float end, float skip, int id);
128         virtual ~SequenceEntry();
129
130         /**
131          * Locks the entry.
132          */
133         virtual void lock();
134
135         /**
136          * Unlocks the previously locked entry.
137          */
138         virtual void unlock();
139
140         /**
141          * Retrieves the sound of the entry.
142          * \return The sound.
143          */
144         std::shared_ptr<ISound> getSound();
145
146         /**
147          * Sets the sound of the entry.
148          * \param sound The new sound.
149          */
150         void setSound(std::shared_ptr<ISound> sound);
151
152         /**
153          * Moves the entry.
154          * \param begin The new start time.
155          * \param end The new end time or a negative value if unknown.
156          * \param skip How many seconds to skip at the beginning.
157          */
158         void move(float begin, float end, float skip);
159
160         /**
161          * Retrieves the muting state of the entry.
162          * \return Whether the entry should is muted or not.
163          */
164         bool isMuted();
165
166         /**
167          * Sets the muting state of the entry.
168          * \param mute Whether the entry should be muted or not.
169          */
170         void mute(bool mute);
171
172         /**
173          * Retrieves the ID of the entry.
174          * \return The ID of the entry.
175          */
176         int getID() const;
177
178         /**
179          * Retrieves one of the animated properties of the entry.
180          * \param type Which animated property to retrieve.
181          * \return A pointer to the animated property, valid as long as the
182          *         entry is.
183          */
184         AnimateableProperty* getAnimProperty(AnimateablePropertyType type);
185
186         /**
187          * Checks whether the source location, velocity and orientation are relative
188          * to the listener.
189          * \return Whether the source is relative.
190          */
191         bool isRelative();
192
193         /**
194          * Sets whether the source location, velocity and orientation are relative
195          * to the listener.
196          * \param relative Whether the source is relative.
197          * \return Whether the action succeeded.
198          */
199         void setRelative(bool relative);
200
201         /**
202          * Retrieves the maximum volume of a source.
203          * \return The maximum volume.
204          */
205         float getVolumeMaximum();
206
207         /**
208          * Sets the maximum volume of a source.
209          * \param volume The new maximum volume.
210          * \return Whether the action succeeded.
211          */
212         void setVolumeMaximum(float volume);
213
214         /**
215          * Retrieves the minimum volume of a source.
216          * \return The minimum volume.
217          */
218         float getVolumeMinimum();
219
220         /**
221          * Sets the minimum volume of a source.
222          * \param volume The new minimum volume.
223          * \return Whether the action succeeded.
224          */
225         void setVolumeMinimum(float volume);
226
227         /**
228          * Retrieves the maximum distance of a source.
229          * If a source is further away from the reader than this distance, the
230          * volume will automatically be set to 0.
231          * \return The maximum distance.
232          */
233         float getDistanceMaximum();
234
235         /**
236          * Sets the maximum distance of a source.
237          * If a source is further away from the reader than this distance, the
238          * volume will automatically be set to 0.
239          * \param distance The new maximum distance.
240          * \return Whether the action succeeded.
241          */
242         void setDistanceMaximum(float distance);
243
244         /**
245          * Retrieves the reference distance of a source.
246          * \return The reference distance.
247          */
248         float getDistanceReference();
249
250         /**
251          * Sets the reference distance of a source.
252          * \param distance The new reference distance.
253          * \return Whether the action succeeded.
254          */
255         void setDistanceReference(float distance);
256
257         /**
258          * Retrieves the attenuation of a source.
259          * \return The attenuation.
260          */
261         float getAttenuation();
262
263         /**
264          * Sets the attenuation of a source.
265          * This value is used for distance calculation.
266          * \param factor The new attenuation.
267          * \return Whether the action succeeded.
268          */
269         void setAttenuation(float factor);
270
271         /**
272          * Retrieves the outer angle of the cone of a source.
273          * \return The outer angle of the cone.
274          */
275         float getConeAngleOuter();
276
277         /**
278          * Sets the outer angle of the cone of a source.
279          * \param angle The new outer angle of the cone.
280          * \return Whether the action succeeded.
281          */
282         void setConeAngleOuter(float angle);
283
284         /**
285          * Retrieves the inner angle of the cone of a source.
286          * \return The inner angle of the cone.
287          */
288         float getConeAngleInner();
289
290         /**
291          * Sets the inner angle of the cone of a source.
292          * \param angle The new inner angle of the cone.
293          * \return Whether the action succeeded.
294          */
295         void setConeAngleInner(float angle);
296
297         /**
298          * Retrieves the outer volume of the cone of a source.
299          * The volume between inner and outer angle is interpolated between inner
300          * volume and this value.
301          * \return The outer volume of the cone.
302          */
303         float getConeVolumeOuter();
304
305         /**
306          * Sets the outer volume of the cone of a source.
307          * The volume between inner and outer angle is interpolated between inner
308          * volume and this value.
309          * \param volume The new outer volume of the cone.
310          * \return Whether the action succeeded.
311          */
312         void setConeVolumeOuter(float volume);
313 };
314
315 AUD_NAMESPACE_END