Line data Source code
1 :
2 : /* Copyright (c) 2012, Daniel Nachbaur <danielnachbaur@gmail.com>
3 : * 2012-2013, Stefan.Eilemann@epfl.ch
4 : *
5 : * This library is free software; you can redistribute it and/or modify it under
6 : * the terms of the GNU Lesser General Public License version 2.1 as published
7 : * by the Free Software Foundation.
8 : *
9 : * This library is distributed in the hope that it will be useful, but WITHOUT
10 : * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11 : * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12 : * details.
13 : *
14 : * You should have received a copy of the GNU Lesser General Public License
15 : * along with this library; if not, write to the Free Software Foundation, Inc.,
16 : * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 : */
18 :
19 : #include "equalizer.h"
20 :
21 : #include "configParams.h"
22 : #include "global.h"
23 :
24 : #include <co/dataOStream.h>
25 : #include <co/dataIStream.h>
26 :
27 :
28 : namespace eq
29 : {
30 : namespace fabric
31 : {
32 : namespace detail
33 : {
34 42 : class Equalizer
35 : {
36 : public:
37 630 : Equalizer()
38 : : damping( .5f )
39 630 : , boundaryf( std::numeric_limits<float>::epsilon( ))
40 : , resistancef( .0f )
41 630 : , assembleOnlyLimit( std::numeric_limits< float >::max( ))
42 : , frameRate( 10.f )
43 : , boundary2i( 1, 1 )
44 : , resistance2i( 0, 0 )
45 : , tilesize( 64, 64 )
46 : , mode( fabric::Equalizer::MODE_2D )
47 1890 : , frozen( false )
48 : {
49 630 : const uint32_t flags = eq::fabric::Global::getFlags();
50 630 : switch( flags & fabric::ConfigParams::FLAG_LOAD_EQ_ALL )
51 : {
52 : case fabric::ConfigParams::FLAG_LOAD_EQ_2D:
53 0 : mode = fabric::Equalizer::MODE_2D;
54 0 : break;
55 : case fabric::ConfigParams::FLAG_LOAD_EQ_HORIZONTAL:
56 0 : mode = fabric::Equalizer::MODE_HORIZONTAL;
57 0 : break;
58 : case fabric::ConfigParams::FLAG_LOAD_EQ_VERTICAL:
59 0 : mode = fabric::Equalizer::MODE_VERTICAL;
60 0 : break;
61 : case fabric::ConfigParams::FLAG_NONE:
62 630 : break;
63 : default:
64 0 : LBUNIMPLEMENTED;
65 : }
66 630 : }
67 :
68 175 : Equalizer( const Equalizer& rhs )
69 : : damping( rhs.damping )
70 : , boundaryf( rhs.boundaryf )
71 : , resistancef( rhs.resistancef )
72 : , assembleOnlyLimit( rhs.assembleOnlyLimit )
73 : , frameRate( rhs.frameRate )
74 : , boundary2i( rhs.boundary2i )
75 : , resistance2i( rhs.resistance2i )
76 : , tilesize( rhs.tilesize )
77 : , mode( rhs.mode )
78 175 : , frozen( rhs.frozen )
79 175 : {}
80 :
81 : float damping;
82 : float boundaryf;
83 : float resistancef;
84 : float assembleOnlyLimit;
85 : float frameRate;
86 : Vector2i boundary2i;
87 : Vector2i resistance2i;
88 : Vector2i tilesize;
89 : fabric::Equalizer::Mode mode;
90 : bool frozen;
91 : };
92 : }
93 :
94 630 : Equalizer::Equalizer()
95 630 : : _data( new detail::Equalizer )
96 1260 : , _backup( 0 )
97 630 : {}
98 :
99 137 : Equalizer::Equalizer( const Equalizer& rhs )
100 137 : : _data( new detail::Equalizer( *rhs._data ))
101 274 : , _backup( 0 )
102 137 : {}
103 :
104 : // cppcheck-suppress operatorEqVarError
105 42 : Equalizer& Equalizer::operator=( const Equalizer& rhs )
106 : {
107 42 : if( this == &rhs )
108 0 : return *this;
109 :
110 42 : *_data = *rhs._data;
111 42 : return *this;
112 : }
113 :
114 766 : Equalizer::~Equalizer()
115 : {
116 766 : delete _data;
117 766 : }
118 :
119 0 : void Equalizer::setFrozen( const bool onOff )
120 : {
121 0 : _data->frozen = onOff;
122 0 : }
123 :
124 54 : bool Equalizer::isFrozen() const
125 : {
126 54 : return _data->frozen;
127 : }
128 :
129 84 : void Equalizer::setMode( const Mode mode )
130 : {
131 84 : _data->mode = mode;
132 84 : }
133 :
134 199 : Equalizer::Mode Equalizer::getMode() const
135 : {
136 199 : return _data->mode;
137 : }
138 :
139 21 : void Equalizer::setDamping( const float damping )
140 : {
141 21 : _data->damping = damping;
142 21 : }
143 :
144 180 : float Equalizer::getDamping() const
145 : {
146 180 : return _data->damping;
147 : }
148 :
149 8 : void Equalizer::setFrameRate( const float frameRate )
150 : {
151 8 : _data->frameRate = frameRate;
152 8 : }
153 :
154 12 : float Equalizer::getFrameRate() const
155 : {
156 12 : return _data->frameRate;
157 : }
158 :
159 0 : void Equalizer::setBoundary( const Vector2i& boundary )
160 : {
161 0 : LBASSERT( boundary.x() > 0 && boundary.y() > 0 );
162 0 : _data->boundary2i = boundary;
163 0 : }
164 :
165 0 : void Equalizer::setBoundary( const float boundary )
166 : {
167 0 : LBASSERT( boundary > 0.0f );
168 0 : _data->boundaryf = boundary;
169 0 : }
170 :
171 142 : const Vector2i& Equalizer::getBoundary2i() const
172 : {
173 142 : return _data->boundary2i;
174 : }
175 :
176 142 : float Equalizer::getBoundaryf() const
177 : {
178 142 : return _data->boundaryf;
179 : }
180 :
181 0 : void Equalizer::setResistance( const Vector2i& resistance )
182 : {
183 0 : _data->resistance2i = resistance;
184 0 : }
185 :
186 0 : void Equalizer::setResistance( const float resistance )
187 : {
188 0 : _data->resistancef = resistance;
189 0 : }
190 :
191 142 : const Vector2i& Equalizer::getResistance2i() const
192 : {
193 142 : return _data->resistance2i;
194 : }
195 :
196 142 : float Equalizer::getResistancef() const
197 : {
198 142 : return _data->resistancef;
199 : }
200 :
201 0 : void Equalizer::setAssembleOnlyLimit( const float limit )
202 : {
203 0 : _data->assembleOnlyLimit = limit;
204 0 : }
205 :
206 0 : float Equalizer::getAssembleOnlyLimit() const
207 : {
208 0 : return _data->assembleOnlyLimit;
209 : }
210 :
211 2 : void Equalizer::setTileSize( const Vector2i& size )
212 : {
213 2 : _data->tilesize = size;
214 2 : }
215 :
216 2 : const Vector2i& Equalizer::getTileSize() const
217 : {
218 2 : return _data->tilesize;
219 : }
220 :
221 173 : void Equalizer::serialize( co::DataOStream& os ) const
222 : {
223 173 : os << _data->damping << _data->boundaryf << _data->resistancef
224 346 : << _data->assembleOnlyLimit << _data->frameRate << _data->boundary2i
225 346 : << _data->resistance2i << _data->tilesize << _data->mode
226 346 : << _data->frozen;
227 173 : }
228 :
229 95 : void Equalizer::deserialize( co::DataIStream& is )
230 : {
231 95 : is >> _data->damping >> _data->boundaryf >> _data->resistancef
232 190 : >> _data->assembleOnlyLimit >> _data->frameRate >> _data->boundary2i
233 190 : >> _data->resistance2i >> _data->tilesize >> _data->mode
234 190 : >> _data->frozen;
235 95 : }
236 :
237 38 : void Equalizer::backup()
238 : {
239 38 : _backup = new detail::Equalizer( *_data );
240 38 : }
241 :
242 0 : void Equalizer::restore()
243 : {
244 0 : LBASSERT( _backup );
245 0 : delete _data;
246 0 : _data = _backup;
247 0 : _backup = 0;
248 0 : }
249 :
250 173 : co::DataOStream& operator << ( co::DataOStream& os, const Equalizer& eq )
251 : {
252 173 : eq.serialize( os );
253 173 : return os;
254 : }
255 :
256 95 : co::DataIStream& operator >> ( co::DataIStream& is, Equalizer& eq )
257 : {
258 95 : eq.deserialize( is );
259 95 : return is;
260 : }
261 :
262 142 : std::ostream& operator << ( std::ostream& os, const Equalizer::Mode mode )
263 : {
264 : os << ( mode == Equalizer::MODE_2D ? "2D" :
265 : mode == Equalizer::MODE_VERTICAL ? "VERTICAL" :
266 : mode == Equalizer::MODE_HORIZONTAL ? "HORIZONTAL" :
267 142 : mode == Equalizer::MODE_DB ? "DB" : "ERROR" );
268 142 : return os;
269 : }
270 :
271 : }
272 45 : }
|
