msvc: Use source folder structure for project file.
[blender.git] / intern / elbeem / intern / attributes.cpp
1 /** \file elbeem/intern/attributes.cpp
2  *  \ingroup elbeem
3  */
4 /******************************************************************************
5  *
6  * El'Beem - Free Surface Fluid Simulation with the Lattice Boltzmann Method
7  * Copyright 2003-2006 Nils Thuerey
8  *
9  * DEPRECATED - replaced by elbeem API, only channels are still used
10  *
11  *****************************************************************************/
12
13 #include "attributes.h"
14 #include "ntl_matrices.h"
15 #include "elbeem.h"
16
17
18
19 /******************************************************************************
20  * attribute conversion functions
21  *****************************************************************************/
22
23 bool Attribute::initChannel(int elemSize) {
24         elemSize=0; // remove warning
25         return false;
26 }
27 string Attribute::getAsString(bool debug) {
28         debug=false; // remove warning
29         return string("");
30 }
31 int Attribute::getAsInt() {
32         return 0;
33 }
34 bool Attribute::getAsBool() {
35         return false;
36 }
37 double Attribute::getAsFloat() {
38         return 0.;
39 }
40 ntlVec3d Attribute::getAsVec3d() {
41         return ntlVec3d(0.);
42 }
43 void Attribute::getAsMat4Gfx(ntlMat4Gfx *mat) {
44         mat=NULL; // remove warning
45 }
46 string Attribute::getCompleteString() {
47         return string("");
48 }
49
50
51 /******************************************************************************
52  * channel returns
53  *****************************************************************************/
54
55 AnimChannel<double> Attribute::getChannelFloat() {
56         return AnimChannel<double>();
57 }
58 AnimChannel<int> Attribute::getChannelInt() { 
59         return AnimChannel<int>();
60 }
61 AnimChannel<ntlVec3d> Attribute::getChannelVec3d() { 
62         return AnimChannel<ntlVec3d>();
63 }
64 AnimChannel<ntlSetVec3f> 
65 Attribute::getChannelSetVec3f() {
66         return AnimChannel<ntlSetVec3f>();
67 }
68
69 /******************************************************************************
70  * check if there were unknown params
71  *****************************************************************************/
72 bool AttributeList::checkUnusedParams() {
73         return false;
74 }
75 void AttributeList::setAllUsed() {
76 }
77
78 /******************************************************************************
79  * Attribute list read functions
80  *****************************************************************************/
81 int AttributeList::readInt(string name, int defaultValue, string source,string target, bool needed) {
82         name=source=target=string(""); needed=false; // remove warning
83         return defaultValue;
84 }
85 bool AttributeList::readBool(string name, bool defaultValue, string source,string target, bool needed) {
86         name=source=target=string(""); needed=false; // remove warning
87         return defaultValue;
88 }
89 double AttributeList::readFloat(string name, double defaultValue, string source,string target, bool needed) {
90         name=source=target=string(""); needed=false; // remove warning
91         return defaultValue;
92 }
93 string AttributeList::readString(string name, string defaultValue, string source,string target, bool needed) {
94         name=source=target=string(""); needed=false; // remove warning
95         return defaultValue;
96 }
97 ntlVec3d AttributeList::readVec3d(string name, ntlVec3d defaultValue, string source,string target, bool needed) {
98         name=source=target=string(""); needed=false; // remove warning
99         return defaultValue;
100 }
101
102 void AttributeList::readMat4Gfx(string name, ntlMat4Gfx defaultValue, string source,string target, bool needed, ntlMat4Gfx *mat) {
103         *mat = defaultValue;
104         name=source=target=string(""); needed=false; mat=NULL; // remove warning
105 }
106
107 // set that a parameter can be given, and will be ignored...
108 bool AttributeList::ignoreParameter(string name, string source) {
109         name = source = ("");
110         return false;
111 }
112                 
113 // read channels
114 AnimChannel<int> AttributeList::readChannelInt(string name, int defaultValue, string source, string target, bool needed) {
115         name=source=target=string(""); needed=false; // remove warning
116         return AnimChannel<int>(defaultValue);
117 }
118 AnimChannel<double> AttributeList::readChannelFloat(string name, double defaultValue, string source, string target, bool needed ) {
119         name=source=target=string(""); needed=false; // remove warning
120         return AnimChannel<double>(defaultValue);
121 }
122 AnimChannel<ntlVec3d> AttributeList::readChannelVec3d(string name, ntlVec3d defaultValue, string source, string target, bool needed ) {
123         name=source=target=string(""); needed=false; // remove warning
124         return AnimChannel<ntlVec3d>(defaultValue);
125 }
126 AnimChannel<ntlSetVec3f> AttributeList::readChannelSetVec3f(string name, ntlSetVec3f defaultValue, string source, string target, bool needed) {
127         name=source=target=string(""); needed=false; // remove warning
128         return AnimChannel<ntlSetVec3f>(defaultValue);
129 }
130 AnimChannel<float> AttributeList::readChannelSinglePrecFloat(string name, float defaultValue, string source, string target, bool needed ) {
131         name=source=target=string(""); needed=false; // remove warning
132         return AnimChannel<float>(defaultValue);
133 }
134 AnimChannel<ntlVec3f> AttributeList::readChannelVec3f(string name, ntlVec3f defaultValue, string source, string target, bool needed) {
135         name=source=target=string(""); needed=false; // remove warning
136         return AnimChannel<ntlVec3f>(defaultValue);
137 }
138
139 /******************************************************************************
140  * destructor
141  *****************************************************************************/
142 AttributeList::~AttributeList() { 
143 };
144
145
146 /******************************************************************************
147  * debugging
148  *****************************************************************************/
149
150 //! debug function, prints value 
151 void Attribute::print() {
152 }
153                 
154 //! debug function, prints all attribs 
155 void AttributeList::print() {
156 }
157
158
159 /******************************************************************************
160  * import attributes from other attribute list
161  *****************************************************************************/
162 void AttributeList::import(AttributeList *oal) {
163         oal=NULL; // remove warning
164 }
165
166
167 /******************************************************************************
168  * channel max finding
169  *****************************************************************************/
170 ntlVec3f channelFindMaxVf (AnimChannel<ntlVec3f> channel) {
171         ntlVec3f ret(0.0);
172         float maxLen = 0.0;
173         for(size_t i=0; i<channel.accessValues().size(); i++) {
174                 float nlen = normNoSqrt(channel.accessValues()[i]);
175                 if(nlen>maxLen) { ret=channel.accessValues()[i]; maxLen=nlen; }
176         }
177         return ret;
178 }
179 ntlVec3d channelFindMaxVd (AnimChannel<ntlVec3d> channel) {
180         ntlVec3d ret(0.0);
181         float maxLen = 0.0;
182         for(size_t i=0; i<channel.accessValues().size(); i++) {
183                 float nlen = normNoSqrt(channel.accessValues()[i]);
184                 if(nlen>maxLen) { ret=channel.accessValues()[i]; maxLen=nlen; }
185         }
186         return ret;
187 }
188 int      channelFindMaxi  (AnimChannel<float   > channel) {
189         int ret = 0;
190         float maxLen = 0.0;
191         for(size_t i=0; i<channel.accessValues().size(); i++) {
192                 float nlen = ABS(channel.accessValues()[i]);
193                 if(nlen>maxLen) { ret= (int)channel.accessValues()[i]; maxLen=nlen; }
194         }
195         return ret;
196 }
197 float    channelFindMaxf  (AnimChannel<float   > channel) {
198         float ret = 0.0;
199         float maxLen = 0.0;
200         for(size_t i=0; i<channel.accessValues().size(); i++) {
201                 float nlen = ABS(channel.accessValues()[i]);
202                 if(nlen>maxLen) { ret=channel.accessValues()[i]; maxLen=nlen; }
203         }
204         return ret;
205 }
206 double   channelFindMaxd  (AnimChannel<double  > channel) {
207         double ret = 0.0;
208         float maxLen = 0.0;
209         for(size_t i=0; i<channel.accessValues().size(); i++) {
210                 float nlen = ABS(channel.accessValues()[i]);
211                 if(nlen>maxLen) { ret=channel.accessValues()[i]; maxLen=nlen; }
212         }
213         return ret;
214 }
215
216 /******************************************************************************
217  // unoptimized channel simplification functions, use elbeem.cpp functions
218  // warning - currently only with single precision
219  *****************************************************************************/
220
221 template<class SCALAR>
222 static bool channelSimplifyScalarT(AnimChannel<SCALAR> &channel) {
223         int   size = channel.getSize();
224         if(size<=1) return false;
225         float *nchannel = new float[2*size];
226         // convert to array
227         for(size_t i=0; i<channel.accessValues().size(); i++) {
228                 nchannel[i*2 + 0] = (float)channel.accessValues()[i];
229                 nchannel[i*2 + 1] = (float)channel.accessTimes()[i];
230         }
231         bool ret = elbeemSimplifyChannelFloat(nchannel, &size);
232         if(ret) {
233                 vector<SCALAR> vals;
234                 vector<double> times;
235                 for(int i=0; i<size; i++) {
236                         vals.push_back(  (SCALAR)(nchannel[i*2 + 0]) );
237                         times.push_back( (double)(nchannel[i*2 + 1]) );
238                 }
239                 channel = AnimChannel<SCALAR>(vals, times);
240         }
241         delete [] nchannel;
242         return ret;
243 }
244 bool channelSimplifyi  (AnimChannel<int   > &channel) { return channelSimplifyScalarT<int>(channel); }
245 bool channelSimplifyf  (AnimChannel<float> &channel) { return channelSimplifyScalarT<float>(channel); }
246 bool channelSimplifyd  (AnimChannel<double  > &channel) { return channelSimplifyScalarT<double>(channel); }
247 template<class VEC>
248 static bool channelSimplifyVecT(AnimChannel<VEC> &channel) {
249         int   size = channel.getSize();
250         if(size<=1) return false;
251         float *nchannel = new float[4*size];
252         // convert to array
253         for(size_t i=0; i<channel.accessValues().size(); i++) {
254                 nchannel[i*4 + 0] = (float)channel.accessValues()[i][0];
255                 nchannel[i*4 + 1] = (float)channel.accessValues()[i][1];
256                 nchannel[i*4 + 2] = (float)channel.accessValues()[i][2];
257                 nchannel[i*4 + 3] = (float)channel.accessTimes()[i];
258         }
259         bool ret = elbeemSimplifyChannelVec3(nchannel, &size);
260         if(ret) {
261                 vector<VEC> vals;
262                 vector<double> times;
263                 for(int i=0; i<size; i++) {
264                         vals.push_back(  VEC(nchannel[i*4 + 0], nchannel[i*4 + 1], nchannel[i*4 + 2] ) );
265                         times.push_back( (double)(nchannel[i*4 + 3]) );
266                 }
267                 channel = AnimChannel<VEC>(vals, times);
268         }
269         delete [] nchannel;
270         return ret;
271 }
272 bool channelSimplifyVf (AnimChannel<ntlVec3f> &channel) {
273         return channelSimplifyVecT<ntlVec3f>(channel);
274 }
275 bool channelSimplifyVd (AnimChannel<ntlVec3d> &channel) {
276         return channelSimplifyVecT<ntlVec3d>(channel);
277 }
278
279 //! debug function, prints channel as string
280 template<class Scalar>
281 string AnimChannel<Scalar>::printChannel() {
282         std::ostringstream ostr;
283         ostr << " CHANNEL #"<<  mValue.size() <<" = { ";
284         for(size_t i=0;i<mValue.size();i++) {
285                 ostr <<"'"<< mValue[i]<<"' ";
286                 ostr << "@"<<mTimes[i]<<"; ";
287         }
288         ostr << " } ";
289         return ostr.str();
290 } // */
291
292 // is now in header file: debugPrintChannel() 
293 // hack to force instantiation
294 void __forceAnimChannelInstantiation() {
295         AnimChannel< float > tmp1;
296         AnimChannel< double > tmp2;
297         AnimChannel< string > tmp3;
298         AnimChannel< ntlVector3Dim<float> > tmp4;
299         AnimChannel< ntlVector3Dim<double> > tmp5;
300         tmp1.debugPrintChannel();
301         tmp2.debugPrintChannel();
302         tmp3.debugPrintChannel();
303         tmp4.debugPrintChannel();
304         tmp5.debugPrintChannel();
305 }
306
307
308 ntlSetVec3f::ntlSetVec3f(double v ) {
309         mVerts.clear();
310         mVerts.push_back( ntlVec3f(v) );
311 }
312 const ntlSetVec3f& 
313 ntlSetVec3f::operator=(double v ) {
314         mVerts.clear();
315         mVerts.push_back( ntlVec3f(v) );
316         return *this;
317 }
318
319 std::ostream& operator<<( std::ostream& os, const ntlSetVec3f& vs ) {
320         os<< "{";
321         for(int j=0;j<(int)vs.mVerts.size();j++)  os<<vs.mVerts[j];
322         os<< "}";
323   return os;
324 }
325
326 ntlSetVec3f& 
327 ntlSetVec3f::operator+=( double v )
328 {
329         for(int j=0;j<(int)(mVerts.size()) ;j++) {
330                 mVerts[j] += v;
331         }
332         return *this;
333 }
334
335 ntlSetVec3f& 
336 ntlSetVec3f::operator+=( const ntlSetVec3f &v )
337 {
338         for(int j=0;j<(int)MIN(mVerts.size(),v.mVerts.size()) ;j++) {
339                 mVerts[j] += v.mVerts[j];
340         }
341         return *this;
342 }
343
344 ntlSetVec3f& 
345 ntlSetVec3f::operator*=( double v )
346 {
347         for(int j=0;j<(int)(mVerts.size()) ;j++) {
348                 mVerts[j] *= v;
349         }
350         return *this;
351 }
352
353 ntlSetVec3f& 
354 ntlSetVec3f::operator*=( const ntlSetVec3f &v )
355 {
356         for(int j=0;j<(int)MIN(mVerts.size(),v.mVerts.size()) ;j++) {
357                 mVerts[j] *= v.mVerts[j];
358         }
359         return *this;
360 }
361
362