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/SequenceData.h"
18 #include "sequence/SequenceReader.h"
19 #include "sequence/SequenceEntry.h"
20
21 #include <mutex>
22
23 AUD_NAMESPACE_BEGIN
24
SequenceData(Specs specs,float fps,bool muted)25 SequenceData::SequenceData(Specs specs, float fps, bool muted) :
26 m_specs(specs),
27 m_status(0),
28 m_entry_status(0),
29 m_id(0),
30 m_muted(muted),
31 m_fps(fps),
32 m_speed_of_sound(343.3f),
33 m_doppler_factor(1),
34 m_distance_model(DISTANCE_MODEL_INVERSE_CLAMPED),
35 m_volume(1, 1.0f),
36 m_location(3),
37 m_orientation(4)
38 {
39 Quaternion q;
40 m_orientation.write(q.get());
41 float f = 1;
42 m_volume.write(&f);
43 }
44
~SequenceData()45 SequenceData::~SequenceData()
46 {
47 }
48
lock()49 void SequenceData::lock()
50 {
51 m_mutex.lock();
52 }
53
unlock()54 void SequenceData::unlock()
55 {
56 m_mutex.unlock();
57 }
58
getSpecs()59 Specs SequenceData::getSpecs()
60 {
61 std::lock_guard<std::recursive_mutex> lock(m_mutex);
62
63 return m_specs;
64 }
65
setSpecs(Specs specs)66 void SequenceData::setSpecs(Specs specs)
67 {
68 std::lock_guard<std::recursive_mutex> lock(m_mutex);
69
70 m_specs = specs;
71 m_status++;
72 }
73
getFPS() const74 float SequenceData::getFPS() const
75 {
76 return m_fps;
77 }
78
setFPS(float fps)79 void SequenceData::setFPS(float fps)
80 {
81 std::lock_guard<std::recursive_mutex> lock(m_mutex);
82
83 m_fps = fps;
84 }
85
mute(bool muted)86 void SequenceData::mute(bool muted)
87 {
88 std::lock_guard<std::recursive_mutex> lock(m_mutex);
89
90 m_muted = muted;
91 }
92
isMuted() const93 bool SequenceData::isMuted() const
94 {
95 return m_muted;
96 }
97
getSpeedOfSound() const98 float SequenceData::getSpeedOfSound() const
99 {
100 return m_speed_of_sound;
101 }
102
setSpeedOfSound(float speed)103 void SequenceData::setSpeedOfSound(float speed)
104 {
105 std::lock_guard<std::recursive_mutex> lock(m_mutex);
106
107 m_speed_of_sound = speed;
108 m_status++;
109 }
110
getDopplerFactor() const111 float SequenceData::getDopplerFactor() const
112 {
113 return m_doppler_factor;
114 }
115
setDopplerFactor(float factor)116 void SequenceData::setDopplerFactor(float factor)
117 {
118 std::lock_guard<std::recursive_mutex> lock(m_mutex);
119
120 m_doppler_factor = factor;
121 m_status++;
122 }
123
getDistanceModel() const124 DistanceModel SequenceData::getDistanceModel() const
125 {
126 return m_distance_model;
127 }
128
setDistanceModel(DistanceModel model)129 void SequenceData::setDistanceModel(DistanceModel model)
130 {
131 std::lock_guard<std::recursive_mutex> lock(m_mutex);
132
133 m_distance_model = model;
134 m_status++;
135 }
136
getAnimProperty(AnimateablePropertyType type)137 AnimateableProperty* SequenceData::getAnimProperty(AnimateablePropertyType type)
138 {
139 switch(type)
140 {
141 case AP_VOLUME:
142 return &m_volume;
143 case AP_LOCATION:
144 return &m_location;
145 case AP_ORIENTATION:
146 return &m_orientation;
147 default:
148 return nullptr;
149 }
150 }
151
add(std::shared_ptr<ISound> sound,double begin,double end,double skip)152 std::shared_ptr<SequenceEntry> SequenceData::add(std::shared_ptr<ISound> sound, double begin, double end, double skip)
153 {
154 std::lock_guard<std::recursive_mutex> lock(m_mutex);
155
156 std::shared_ptr<SequenceEntry> entry = std::shared_ptr<SequenceEntry>(new SequenceEntry(sound, begin, end, skip, m_id++));
157
158 m_entries.push_back(entry);
159 m_entry_status++;
160
161 return entry;
162 }
163
remove(std::shared_ptr<SequenceEntry> entry)164 void SequenceData::remove(std::shared_ptr<SequenceEntry> entry)
165 {
166 std::lock_guard<std::recursive_mutex> lock(m_mutex);
167
168 m_entries.remove(entry);
169 m_entry_status++;
170 }
171
172 AUD_NAMESPACE_END
173