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 0 : class Equalizer
35 : {
36 : public:
37 1010 : Equalizer()
38 : : damping( .5f )
39 1010 : , boundaryf( std::numeric_limits<float>::epsilon( ))
40 : , resistancef( .0f )
41 1010 : , 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 3030 : , frozen( false )
48 : {
49 1010 : const uint32_t flags = eq::fabric::Global::getFlags();
50 1010 : 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 1010 : break;
63 : default:
64 0 : LBUNIMPLEMENTED;
65 : }
66 1010 : }
67 :
68 4 : 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 4 : , frozen( rhs.frozen )
79 4 : {}
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 1010 : Equalizer::Equalizer()
95 1010 : : _data( new detail::Equalizer )
96 2020 : , _backup( 0 )
97 1010 : {}
98 :
99 4 : Equalizer::Equalizer( const Equalizer& rhs )
100 4 : : _data( new detail::Equalizer( *rhs._data ))
101 8 : , _backup( 0 )
102 4 : {}
103 :
104 : // cppcheck-suppress operatorEqVarError
105 0 : Equalizer& Equalizer::operator=( const Equalizer& rhs )
106 : {
107 0 : if( this == &rhs )
108 0 : return *this;
109 :
110 0 : *_data = *rhs._data;
111 0 : return *this;
112 : }
113 :
114 1012 : Equalizer::~Equalizer()
115 : {
116 1012 : delete _data;
117 1012 : }
118 :
119 0 : void Equalizer::setFrozen( const bool onOff )
120 : {
121 0 : _data->frozen = onOff;
122 0 : }
123 :
124 0 : bool Equalizer::isFrozen() const
125 : {
126 0 : return _data->frozen;
127 : }
128 :
129 140 : void Equalizer::setMode( const Mode mode )
130 : {
131 140 : _data->mode = mode;
132 140 : }
133 :
134 94 : Equalizer::Mode Equalizer::getMode() const
135 : {
136 94 : return _data->mode;
137 : }
138 :
139 10 : void Equalizer::setDamping( const float damping )
140 : {
141 10 : _data->damping = damping;
142 10 : }
143 :
144 106 : float Equalizer::getDamping() const
145 : {
146 106 : return _data->damping;
147 : }
148 :
149 16 : void Equalizer::setFrameRate( const float frameRate )
150 : {
151 16 : _data->frameRate = frameRate;
152 16 : }
153 :
154 24 : float Equalizer::getFrameRate() const
155 : {
156 24 : 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 94 : const Vector2i& Equalizer::getBoundary2i() const
172 : {
173 94 : return _data->boundary2i;
174 : }
175 :
176 94 : float Equalizer::getBoundaryf() const
177 : {
178 94 : 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 94 : const Vector2i& Equalizer::getResistance2i() const
192 : {
193 94 : return _data->resistance2i;
194 : }
195 :
196 94 : float Equalizer::getResistancef() const
197 : {
198 94 : 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 4 : void Equalizer::setTileSize( const Vector2i& size )
212 : {
213 4 : _data->tilesize = size;
214 4 : }
215 :
216 4 : const Vector2i& Equalizer::getTileSize() const
217 : {
218 4 : return _data->tilesize;
219 : }
220 :
221 14 : void Equalizer::serialize( co::DataOStream& os ) const
222 : {
223 14 : os << _data->damping << _data->boundaryf << _data->resistancef
224 28 : << _data->assembleOnlyLimit << _data->frameRate << _data->boundary2i
225 28 : << _data->resistance2i << _data->tilesize << _data->mode
226 28 : << _data->frozen;
227 14 : }
228 :
229 8 : void Equalizer::deserialize( co::DataIStream& is )
230 : {
231 8 : is >> _data->damping >> _data->boundaryf >> _data->resistancef
232 16 : >> _data->assembleOnlyLimit >> _data->frameRate >> _data->boundary2i
233 16 : >> _data->resistance2i >> _data->tilesize >> _data->mode
234 16 : >> _data->frozen;
235 8 : }
236 :
237 0 : void Equalizer::backup()
238 : {
239 0 : _backup = new detail::Equalizer( *_data );
240 0 : }
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 14 : co::DataOStream& operator << ( co::DataOStream& os, const Equalizer& eq )
251 : {
252 14 : eq.serialize( os );
253 14 : return os;
254 : }
255 :
256 8 : co::DataIStream& operator >> ( co::DataIStream& is, Equalizer& eq )
257 : {
258 8 : eq.deserialize( is );
259 8 : return is;
260 : }
261 :
262 94 : 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 94 : mode == Equalizer::MODE_DB ? "DB" : "ERROR" );
268 94 : return os;
269 : }
270 :
271 : }
272 84 : }
|
