3D Audio GSoC:
[blender.git] / intern / audaspace / intern / AUD_SequencerEntry.cpp
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * Copyright 2009-2011 Jörg Hermann Müller
7  *
8  * This file is part of AudaSpace.
9  *
10  * Audaspace is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * AudaSpace is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with Audaspace; if not, write to the Free Software Foundation,
22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file audaspace/intern/AUD_SequencerEntry.cpp
28  *  \ingroup audaspaceintern
29  */
30
31
32 #include "AUD_SequencerEntry.h"
33 #include "AUD_SequencerReader.h"
34
35 #include <cmath>
36 #include <limits>
37
38 AUD_SequencerEntry::AUD_SequencerEntry(AUD_Reference<AUD_IFactory> sound, float begin, float end, float skip, int id) :
39         m_status(0),
40         m_pos_status(1),
41         m_sound_status(0),
42         m_id(id),
43         m_sound(sound),
44         m_begin(begin),
45         m_end(end),
46         m_skip(skip),
47         m_muted(false),
48         m_relative(true),
49         m_volume_max(1.0f),
50         m_volume_min(0),
51         m_distance_max(std::numeric_limits<float>::max()),
52         m_distance_reference(1.0f),
53         m_attenuation(1.0f),
54         m_cone_angle_outer(360),
55         m_cone_angle_inner(360),
56         m_cone_volume_outer(0),
57         m_location(3),
58         m_orientation(4)
59 {
60         AUD_Quaternion q;
61         m_orientation.write(q.get());
62         float f = 1;
63         m_volume.write(&f);
64         m_pitch.write(&f);
65 }
66
67 void AUD_SequencerEntry::setSound(AUD_Reference<AUD_IFactory> sound)
68 {
69         if(m_sound.get() != sound.get())
70         {
71                 m_sound = sound;
72                 m_sound_status++;
73         }
74 }
75
76 void AUD_SequencerEntry::move(float begin, float end, float skip)
77 {
78         if(m_begin != begin || m_skip != skip || m_end != end)
79         {
80                 m_begin = begin;
81                 m_skip = skip;
82                 m_end = end;
83                 m_pos_status++;
84         }
85 }
86
87 void AUD_SequencerEntry::mute(bool mute)
88 {
89         m_muted = mute;
90 }
91
92 int AUD_SequencerEntry::getID() const
93 {
94         return m_id;
95 }
96
97 AUD_AnimateableProperty* AUD_SequencerEntry::getAnimProperty(AUD_AnimateablePropertyType type)
98 {
99         switch(type)
100         {
101         case AUD_AP_VOLUME:
102                 return &m_volume;
103         case AUD_AP_PITCH:
104                 return &m_pitch;
105         case AUD_AP_PANNING:
106                 return &m_panning;
107         case AUD_AP_LOCATION:
108                 return &m_location;
109         case AUD_AP_ORIENTATION:
110                 return &m_orientation;
111         default:
112                 return NULL;
113         }
114 }
115
116 void AUD_SequencerEntry::updateAll(float volume_max, float volume_min, float distance_max,
117                                                                    float distance_reference, float attenuation, float cone_angle_outer,
118                                                                    float cone_angle_inner, float cone_volume_outer)
119 {
120         if(volume_max != m_volume_max)
121         {
122                 m_volume_max = volume_max;
123                 m_status++;
124         }
125
126         if(volume_min != m_volume_min)
127         {
128                 m_volume_min = volume_min;
129                 m_status++;
130         }
131
132         if(distance_max != m_distance_max)
133         {
134                 m_distance_max = distance_max;
135                 m_status++;
136         }
137
138         if(distance_reference != m_distance_reference)
139         {
140                 m_distance_reference = distance_reference;
141                 m_status++;
142         }
143
144         if(attenuation != m_attenuation)
145         {
146                 m_attenuation = attenuation;
147                 m_status++;
148         }
149
150         if(cone_angle_outer != m_cone_angle_outer)
151         {
152                 m_cone_angle_outer = cone_angle_outer;
153                 m_status++;
154         }
155
156         if(cone_angle_inner != m_cone_angle_inner)
157         {
158                 m_cone_angle_inner = cone_angle_inner;
159                 m_status++;
160         }
161
162         if(cone_volume_outer != m_cone_volume_outer)
163         {
164                 m_cone_volume_outer = cone_volume_outer;
165                 m_status++;
166         }
167 }
168
169 bool AUD_SequencerEntry::isRelative()
170 {
171         return m_relative;
172 }
173
174 void AUD_SequencerEntry::setRelative(bool relative)
175 {
176         if(m_relative != relative)
177         {
178                 m_relative = relative;
179                 m_status++;
180         }
181 }
182
183 float AUD_SequencerEntry::getVolumeMaximum()
184 {
185         return m_volume_max;
186 }
187
188 void AUD_SequencerEntry::setVolumeMaximum(float volume)
189 {
190         m_volume_max = volume;
191         m_status++;
192 }
193
194 float AUD_SequencerEntry::getVolumeMinimum()
195 {
196         return m_volume_min;
197 }
198
199 void AUD_SequencerEntry::setVolumeMinimum(float volume)
200 {
201         m_volume_min = volume;
202         m_status++;
203 }
204
205 float AUD_SequencerEntry::getDistanceMaximum()
206 {
207         return m_distance_max;
208 }
209
210 void AUD_SequencerEntry::setDistanceMaximum(float distance)
211 {
212         m_distance_max = distance;
213         m_status++;
214 }
215
216 float AUD_SequencerEntry::getDistanceReference()
217 {
218         return m_distance_reference;
219 }
220
221 void AUD_SequencerEntry::setDistanceReference(float distance)
222 {
223         m_distance_reference = distance;
224         m_status++;
225 }
226
227 float AUD_SequencerEntry::getAttenuation()
228 {
229         return m_attenuation;
230 }
231
232 void AUD_SequencerEntry::setAttenuation(float factor)
233 {
234         m_attenuation = factor;
235         m_status++;
236 }
237
238 float AUD_SequencerEntry::getConeAngleOuter()
239 {
240         return m_cone_angle_outer;
241 }
242
243 void AUD_SequencerEntry::setConeAngleOuter(float angle)
244 {
245         m_cone_angle_outer = angle;
246         m_status++;
247 }
248
249 float AUD_SequencerEntry::getConeAngleInner()
250 {
251         return m_cone_angle_inner;
252 }
253
254 void AUD_SequencerEntry::setConeAngleInner(float angle)
255 {
256         m_cone_angle_inner = angle;
257         m_status++;
258 }
259
260 float AUD_SequencerEntry::getConeVolumeOuter()
261 {
262         return m_cone_volume_outer;
263 }
264
265 void AUD_SequencerEntry::setConeVolumeOuter(float volume)
266 {
267         m_cone_volume_outer = volume;
268         m_status++;
269 }