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 #include "sequence/SequenceEntry.h"
18 #include "sequence/SequenceReader.h"
19 
20 #include <limits>
21 #include <mutex>
22 
23 AUD_NAMESPACE_BEGIN
24 
SequenceEntry(std::shared_ptr<ISound> sound,double begin,double end,double skip,int id)25 SequenceEntry::SequenceEntry(std::shared_ptr<ISound> sound, double begin, double end, double skip, int id) :
26 	m_status(0),
27 	m_pos_status(1),
28 	m_sound_status(0),
29 	m_id(id),
30 	m_sound(sound),
31 	m_begin(begin),
32 	m_end(end),
33 	m_skip(skip),
34 	m_muted(false),
35 	m_relative(true),
36 	m_volume_max(1.0f),
37 	m_volume_min(0),
38 	m_distance_max(std::numeric_limits<float>::max()),
39 	m_distance_reference(1.0f),
40 	m_attenuation(1.0f),
41 	m_cone_angle_outer(360),
42 	m_cone_angle_inner(360),
43 	m_cone_volume_outer(0),
44 	m_volume(1, 1.0f),
45 	m_pitch(1, 1.0f),
46 	m_location(3),
47 	m_orientation(4)
48 {
49 	Quaternion q;
50 	m_orientation.write(q.get());
51 	float f = 1;
52 	m_volume.write(&f);
53 	m_pitch.write(&f);
54 }
55 
~SequenceEntry()56 SequenceEntry::~SequenceEntry()
57 {
58 }
59 
lock()60 void SequenceEntry::lock()
61 {
62 	m_mutex.lock();
63 }
64 
unlock()65 void SequenceEntry::unlock()
66 {
67 	m_mutex.unlock();
68 }
69 
getSound()70 std::shared_ptr<ISound> SequenceEntry::getSound()
71 {
72 	std::lock_guard<std::recursive_mutex> lock(m_mutex);
73 	return m_sound;
74 }
75 
setSound(std::shared_ptr<ISound> sound)76 void SequenceEntry::setSound(std::shared_ptr<ISound> sound)
77 {
78 	std::lock_guard<std::recursive_mutex> lock(m_mutex);
79 
80 	if(m_sound.get() != sound.get())
81 	{
82 		m_sound = sound;
83 		m_sound_status++;
84 	}
85 }
86 
move(double begin,double end,double skip)87 void SequenceEntry::move(double begin, double end, double skip)
88 {
89 	std::lock_guard<std::recursive_mutex> lock(m_mutex);
90 
91 	if(m_begin != begin || m_skip != skip || m_end != end)
92 	{
93 		m_begin = begin;
94 		m_skip = skip;
95 		m_end = end;
96 		m_pos_status++;
97 	}
98 }
99 
isMuted()100 bool SequenceEntry::isMuted()
101 {
102 	return m_muted;
103 }
104 
mute(bool mute)105 void SequenceEntry::mute(bool mute)
106 {
107 	std::lock_guard<std::recursive_mutex> lock(m_mutex);
108 
109 	m_muted = mute;
110 }
111 
getID() const112 int SequenceEntry::getID() const
113 {
114 	return m_id;
115 }
116 
getAnimProperty(AnimateablePropertyType type)117 AnimateableProperty* SequenceEntry::getAnimProperty(AnimateablePropertyType type)
118 {
119 	switch(type)
120 	{
121 	case AP_VOLUME:
122 		return &m_volume;
123 	case AP_PITCH:
124 		return &m_pitch;
125 	case AP_PANNING:
126 		return &m_panning;
127 	case AP_LOCATION:
128 		return &m_location;
129 	case AP_ORIENTATION:
130 		return &m_orientation;
131 	default:
132 		return nullptr;
133 	}
134 }
135 
isRelative()136 bool SequenceEntry::isRelative()
137 {
138 	return m_relative;
139 }
140 
setRelative(bool relative)141 void SequenceEntry::setRelative(bool relative)
142 {
143 	std::lock_guard<std::recursive_mutex> lock(m_mutex);
144 
145 	if(m_relative != relative)
146 	{
147 		m_relative = relative;
148 		m_status++;
149 	}
150 }
151 
getVolumeMaximum()152 float SequenceEntry::getVolumeMaximum()
153 {
154 	return m_volume_max;
155 }
156 
setVolumeMaximum(float volume)157 void SequenceEntry::setVolumeMaximum(float volume)
158 {
159 	std::lock_guard<std::recursive_mutex> lock(m_mutex);
160 
161 	m_volume_max = volume;
162 	m_status++;
163 }
164 
getVolumeMinimum()165 float SequenceEntry::getVolumeMinimum()
166 {
167 	return m_volume_min;
168 }
169 
setVolumeMinimum(float volume)170 void SequenceEntry::setVolumeMinimum(float volume)
171 {
172 	std::lock_guard<std::recursive_mutex> lock(m_mutex);
173 
174 	m_volume_min = volume;
175 	m_status++;
176 }
177 
getDistanceMaximum()178 float SequenceEntry::getDistanceMaximum()
179 {
180 	return m_distance_max;
181 }
182 
setDistanceMaximum(float distance)183 void SequenceEntry::setDistanceMaximum(float distance)
184 {
185 	std::lock_guard<std::recursive_mutex> lock(m_mutex);
186 
187 	m_distance_max = distance;
188 	m_status++;
189 }
190 
getDistanceReference()191 float SequenceEntry::getDistanceReference()
192 {
193 	return m_distance_reference;
194 }
195 
setDistanceReference(float distance)196 void SequenceEntry::setDistanceReference(float distance)
197 {
198 	std::lock_guard<std::recursive_mutex> lock(m_mutex);
199 
200 	m_distance_reference = distance;
201 	m_status++;
202 }
203 
getAttenuation()204 float SequenceEntry::getAttenuation()
205 {
206 	return m_attenuation;
207 }
208 
setAttenuation(float factor)209 void SequenceEntry::setAttenuation(float factor)
210 {
211 	std::lock_guard<std::recursive_mutex> lock(m_mutex);
212 
213 	m_attenuation = factor;
214 	m_status++;
215 }
216 
getConeAngleOuter()217 float SequenceEntry::getConeAngleOuter()
218 {
219 	return m_cone_angle_outer;
220 }
221 
setConeAngleOuter(float angle)222 void SequenceEntry::setConeAngleOuter(float angle)
223 {
224 	std::lock_guard<std::recursive_mutex> lock(m_mutex);
225 
226 	m_cone_angle_outer = angle;
227 	m_status++;
228 }
229 
getConeAngleInner()230 float SequenceEntry::getConeAngleInner()
231 {
232 	return m_cone_angle_inner;
233 }
234 
setConeAngleInner(float angle)235 void SequenceEntry::setConeAngleInner(float angle)
236 {
237 	std::lock_guard<std::recursive_mutex> lock(m_mutex);
238 
239 	m_cone_angle_inner = angle;
240 	m_status++;
241 }
242 
getConeVolumeOuter()243 float SequenceEntry::getConeVolumeOuter()
244 {
245 	return m_cone_volume_outer;
246 }
247 
setConeVolumeOuter(float volume)248 void SequenceEntry::setConeVolumeOuter(float volume)
249 {
250 	std::lock_guard<std::recursive_mutex> lock(m_mutex);
251 
252 	m_cone_volume_outer = volume;
253 	m_status++;
254 }
255 
256 AUD_NAMESPACE_END
257