libmoldeo (Moldeo 1.0 Core)  1.0
libmoldeo is the group of objects and functions that executes the basic operations of Moldeo 1.0 Platform.
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
moMotion.cpp
Go to the documentation of this file.
1 /*******************************************************************************
2 
3  moMotion.cpp
4 
5  ****************************************************************************
6  * *
7  * This source is free software; you can redistribute it and/or modify *
8  * it under the terms of the GNU General Public License as published by *
9  * the Free Software Foundation; either version 2 of the License, or *
10  * (at your option) any later version. *
11  * *
12  * This code is distributed in the hope that it will be useful, but *
13  * WITHOUT ANY WARRANTY; without even the implied warranty of *
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
15  * General Public License for more details. *
16  * *
17  * A copy of the GNU General Public License is available on the World *
18  * Wide Web at <http://www.gnu.org/copyleft/gpl.html>. You can also *
19  * obtain it by writing to the Free Software Foundation, *
20  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
21  * *
22  ****************************************************************************
23 
24  Copyright(C) 2006 Fabricio Costa
25 
26  Authors:
27  Fabricio Costa
28 
29 
30 *******************************************************************************/
31 
32 // moMotion.cpp: implementation of the moMotion class.
33 //
35 
36 #include <stdlib.h>
37 #include <math.h>
38 #include "moMotion.h"
39 
41 // Construction/Destruction
43 
44 moMotion::moMotion()
45 {
46 
47 }
48 
49 moMotion::~moMotion()
50 {
51 
52 }
53 
54 
56 // Def. de las 3 funciones basicas de movimiento(movx, movy, movz)
58 
59 MOfloat moMotion::movx( moParam& param, moTempo& tempo)
60 {
61  MOdouble ang, mov;
62 
63  ang = tempo.getTempo();
64  mov = movx( param, ang);
65 
66  return mov;
67 }
68 
69 MOfloat moMotion::movx( moParam& param, MOdouble ang)
70 {
71  MOdouble mov = 0.0f;
72  MOdouble a, v, d;
73  MOchar t;
74  MOint cantval, cantfun;
75 
76  cantval = param.GetValue().GetSubValueCount();
77  cantfun = 0;
78 
79  if(cantval >= 1) // Valor constante.
80  {
81  mov = param.GetValue().GetSubValue(0).Float();
82  }
83 
84  while(cantfun*4+1 < cantval)
85  {
86  t = param.GetValue().GetSubValue(cantfun*4+1).Char();
87  a = param.GetValue().GetSubValue(cantfun*4+2).Float();
88  v = param.GetValue().GetSubValue(cantfun*4+3).Float();
89  d = param.GetValue().GetSubValue(cantfun*4+4).Float()*torad;
90  switch( toupper(t))
91  {
92  case 'E': // Esferico.
93  mov += movEsf('x',cantfun, ang, a, v, d);
94  break;
95  case 'L': // Lineal.
96  mov += movLin('x',cantfun, ang, a, v, d);
97  break;
98  case 'S': // Semiesferico.
99  mov += movSEs('x',cantfun, ang, a, v, d);
100  break;
101  case 'C': // Cubico.
102  mov += movCub('x',cantfun, ang, a, v, d);
103  break;
104  case 'F': // Fijo.
105  mov += movFij('x',cantfun, ang, a, v, d);
106  break;
107  case 'B': // Bucle.
108  mov += movBuc('x',cantfun, ang, a, v, d);
109  break;
110  case 'R': // Random.
111  mov += movRan('x',cantfun, ang, a, v, d);
112  break;
113  /*
114  case 'P': // Pulse.
115  mov += movPul('x',cantfun, ang, a, v, d);
116  break;
117  */
118  }
119  cantfun++;
120  }
121 
122  return mov;
123 }
124 
125 MOfloat moMotion::movy( moParam& param, moTempo& tempo)
126 {
127  MOdouble ang, mov;
128 
129  ang = tempo.getTempo();
130  mov = movy( param, ang);
131 
132  return mov;
133 }
134 
135 MOfloat moMotion::movy( moParam& param, MOdouble ang)
136 {
137  MOdouble mov = 0.0f;
138  MOdouble a, v, d;
139  MOchar t;
140  MOint cantval, cantfun;
141 
142  cantval = param.GetValue().GetSubValueCount();
143  cantfun = 0;
144 
145  if(cantval >= 1) // Valor constante.
146  {
147  mov = param.GetValue().GetSubValue(0).Float();
148  }
149 
150  while(cantfun*4+1 < cantval)
151  {
152  t = param.GetValue().GetSubValue(cantfun*4+1).Char();
153  a = param.GetValue().GetSubValue(cantfun*4+2).Float();
154  v = param.GetValue().GetSubValue(cantfun*4+3).Float();
155  d = param.GetValue().GetSubValue(cantfun*4+4).Float()*torad;
156  switch( toupper(t))
157  {
158  case 'E': // Esferico.
159  mov += movEsf('y',cantfun, ang, a, v, d);
160  break;
161  case 'L': // Lineal.
162  mov += movLin('y',cantfun, ang, a, v, d);
163  break;
164  case 'S': // Semiesferico.
165  mov += movSEs('y',cantfun, ang, a, v, d);
166  break;
167  case 'C': // Cubico.
168  mov += movCub('y',cantfun, ang, a, v, d);
169  break;
170  case 'F': // Fijo.
171  mov += movFij('y',cantfun, ang, a, v, d);
172  break;
173  case 'B': // Bucle.
174  mov += movBuc('y',cantfun, ang, a, v, d);
175  break;
176  case 'R': // Random.
177  mov += movRan('y',cantfun, ang, a, v, d);
178  break;
179  case 'G':
180  mov += movGan('y',cantfun, ang, a, v, d);
181  break;
182  case 'P':
183  mov += movPul('x',cantfun, ang, a, v, d);
184  break;
185  }
186  cantfun++;
187  }
188 
189  return mov;
190 }
191 
192 MOfloat moMotion::movz( moParam& param, moTempo& tempo)
193 {
194  MOdouble ang, mov;
195 
196  ang = tempo.getTempo();
197  mov = movz( param, ang);
198 
199  return mov;
200 }
201 
202 MOfloat moMotion::movz( moParam& param, MOdouble ang)
203 {
204  MOdouble mov = 0.0f;
205  MOdouble a, v, d;
206  MOchar t;
207  MOint cantval, cantfun;
208 
209  cantval = param.GetValue().GetSubValueCount();
210  cantfun = 0;
211 
212  if(cantval >= 1) // Valor constante.
213  {
214  mov = param.GetValue().GetSubValue(0).Float();
215  }
216 
217  while(cantfun*4+1 < cantval)
218  {
219  t = param.GetValue().GetSubValue(cantfun*4+1).Char();
220  a = param.GetValue().GetSubValue(cantfun*4+2).Float();
221  v = param.GetValue().GetSubValue(cantfun*4+3).Float();
222  d = param.GetValue().GetSubValue(cantfun*4+4).Float()*torad;
223  switch( toupper(t))
224  {
225  case 'E': // Esferico.
226  mov += movEsf('z',cantfun, ang, a, v, d);
227  break;
228  case 'L': // Lineal.
229  mov += movLin('z',cantfun, ang, a, v, d);
230  break;
231  case 'S': // Semiesferico.
232  mov += movSEs('z',cantfun, ang, a, v, d);
233  break;
234  case 'C': // Cubico.
235  mov += movCub('z',cantfun, ang, a, v, d);
236  break;
237  case 'F': // Fijo.
238  mov += movFij('z',cantfun, ang, a, v, d);
239  break;
240  case 'B': // Bucle.
241  mov += movBuc('z',cantfun, ang, a, v, d);
242  break;
243  case 'R': // Random.
244  mov += movRan('z',cantfun, ang, a, v, d);
245  break;
246  case 'P':
247  mov += movPul('x',cantfun, ang, a, v, d);
248  break;
249  }
250  cantfun++;
251  }
252 
253  return mov;
254 }
255 
256 
257 
259 // Def. de las funciones de movimiento especificas a una forma.
261 
262 MOdouble moMotion::movEsf( char e, int c, double ang, double a, double v, double d)
263 {
264  MOdouble mov = 0.0f;
265  c = c % 2 + 1;
266  // Primera componente.
267  if(c == 1)
268  switch(tolower(e))
269  {
270  case 'x': mov = a*cos(v*(ang-d)); break;
271  case 'y': mov = a*sin(v*(ang-d)); break;
272  case 'z': mov = a*sin(v*(ang-d)); break;
273  }
274  else
275  // Segunda componente.
276  if(c == 2)
277  switch(tolower(e))
278  {
279  case 'x': mov = a*sin(v*(ang-d)); break;
280  case 'y': mov = a*cos(v*(ang-d)); break;
281  case 'z': mov = a*sin(v*(ang-d)); break;
282  }
283  return mov;
284 }
285 
286 MOdouble moMotion::movLin( char e, int c, double ang, double a, double v, double d)
287 {
288  MOdouble mov = 0.0f;
289  c = c % 2 + 1;
290  // Primera componente.
291  if(c == 1)
292  switch(tolower(e))
293  {
294  case 'x': mov = a*sin(v*(ang-d)); break;
295  case 'y': mov = a*sin(v*(ang-d)); break;
296  case 'z': mov = a*sin(v*(ang-d)); break;
297  }
298  else
299  // Segunda componente.
300  if(c == 2)
301  switch(tolower(e))
302  {
303  case 'x': mov = a*sin(v*(ang-d)); break;
304  case 'y': mov = a*sin(v*(ang-d)); break;
305  case 'z': mov = a*sin(v*(ang-d)); break;
306  }
307  return mov;
308 }
309 
310 MOdouble moMotion::movSEs( char e, int c, double ang, double a, double v, double d)
311 {
312  MOdouble mov = 0.0f;
313  c = c % 2 + 1;
314  // Primera componente.
315  if(c == 1)
316  switch(tolower(e))
317  {
318  case 'x': mov = a*fabs(cos(v*(ang-d))); break;
319  case 'y': mov = a*fabs(sin(v*(ang-d))); break;
320  case 'z': mov = a*fabs(sin(v*(ang-d))); break;
321  }
322  else
323  // Segunda componente.
324  if(c == 2)
325  switch(tolower(e))
326  {
327  case 'x': mov = a*fabs(sin(v*(ang-d))); break;
328  case 'y': mov = a*fabs(cos(v*(ang-d))); break;
329  case 'z': mov = a*fabs(sin(v*(ang-d))); break;
330  }
331  return mov;
332 }
333 
334 MOdouble moMotion::movCub( char e, int c, double ang, double a, double v, double d)
335 {
336  MOdouble mov = 0.0f;
337  MOdouble gang = long(v*(ang-d)*togra) % 360;
338  c = c % 2 + 1;
339  // Primera componente.
340  if(c == 1)
341  switch(tolower(e))
342  {
343  case 'x':
344  if(315.0<=gang || gang< 45.0) mov = a;
345  if( 45.0<=gang && gang<135.0) mov = a*cos(v*(ang-d))/sqrt2;
346  if(135.0<=gang && gang<225.0) mov = -a;
347  if(225.0<=gang && gang<315.0) mov = a*cos(v*(ang-d))/sqrt2;
348  break;
349  case 'y':
350  if(315.0<=gang || gang< 45.0) mov = a*sin(v*(ang-d))/sqrt2;
351  if( 45.0<=gang && gang<135.0) mov = a;
352  if(135.0<=gang && gang<225.0) mov = a*sin(v*(ang-d))/sqrt2;
353  if(225.0<=gang && gang<315.0) mov = -a;
354  break;
355  case 'z':
356  if(315.0<=gang || gang< 45.0) mov = a*sin(v*(ang-d))/sqrt2;
357  if( 45.0<=gang && gang<135.0) mov = a;
358  if(135.0<=gang && gang<225.0) mov = a*sin(v*(ang-d))/sqrt2;
359  if(225.0<=gang && gang<315.0) mov = -a;
360  }
361  else
362  // Segunda componente.
363  if(c == 2)
364  switch(tolower(e))
365  {
366  case 'x':
367  if(315.0<=gang || gang< 45.0) mov = -a;
368  if( 45.0<=gang && gang<135.0) mov = a*sin(v*(ang-d))/sqrt2;
369  if(135.0<=gang && gang<225.0) mov = a;
370  if(225.0<=gang && gang<315.0) mov = a*sin(v*(ang-d))/sqrt2;
371  break;
372  case 'y':
373  if(315.0<=gang || gang< 45.0) mov = a*cos(v*(ang-d))/sqrt2;
374  if( 45.0<=gang && gang<135.0) mov = a;
375  if(135.0<=gang && gang<225.0) mov = a*cos(v*(ang-d))/sqrt2;
376  if(225.0<=gang && gang<315.0) mov = -a;
377  break;
378  case 'z':
379  if(315.0<=gang || gang< 45.0) mov = -a;
380  if( 45.0<=gang && gang<135.0) mov = a*sin(v*(ang-d))/sqrt2;
381  if(135.0<=gang && gang<225.0) mov = a;
382  if(225.0<=gang && gang<315.0) mov = a*sin(v*(ang-d))/sqrt2;
383  }
384  return mov;
385 }
386 
387 MOdouble moMotion::movFij( char e, int c, double ang, double a, double v, double d)
388 {
389  return v*(ang-d) + a*sin(v*(ang-d)) + e - e + c - c;
390 }
391 
392 MOdouble moMotion::movBuc( char e, int c, double ang, double a, double v, double d)
393 {
394  MOdouble mov = 0.0f;
395  c = c % 2 + 1 + e - e + c - c;;
396  // Primera componente.
397  if(c == 1)
398  switch(tolower(e))
399  {
400  case 'x': mov = a*cos(v*(ang-d))*sin(ang-d); break;
401  case 'y': mov = a*sin(v*(ang-d))*cos(ang-d); break;
402  case 'z': mov = a*sin(v*(ang-d))*cos(ang-d); break;
403  }
404  else
405  // Segunda componente.
406  if(c == 2)
407  switch(tolower(e))
408  {
409  case 'x': mov = a*sin(v*(ang-d))*cos(ang-d); break;
410  case 'y': mov = a*cos(v*(ang-d))*sin(ang-d); break;
411  case 'z': mov = a*sin(v*(ang-d))*cos(ang-d); break;
412  }
413  return mov;
414 }
415 
416 MOdouble moMotion::movRan( char e, int c, double ang, double a, double v, double d)
417 {
418  MOdouble mov = 0.0f;
419  MOdouble randval, pos;
420 
421  ang = ang*togra - d + e - e + c - c;; // convierto el angulo a grados.
422  pos = v *(MOint)(ang/v + 0.5); // posicion donde debe responder.
423  if(fabs(ang-pos) < 1.0)
424  {
425  randval = rand()/double(RAND_MAX); // value aleatorio entre 0 y 1.
426  mov = 2*a*randval-a; // el value final esta entre -a y a.
427  }
428 
429  return mov;
430 }
431 
432 MOdouble moMotion::movGan( char e, int c, double ang, double a, double v, double d)
433 {
434  MOdouble mov = 0.0f;
435  MOdouble gang = long(v*(ang-d)*togra) % 360;
436 
437  mov =(gang/360.0f) * a + e - e + c - c;;
438 
439  return mov;
440 }
441 
442 MOdouble moMotion::movPul( char e, int c, double ang, double a, double v, double d)
443 {
444  MOdouble mov = 0.0f + e - e + c - c + ang - ang +a -a +v -v +d -d;
445  /*
446  MOdouble x =(ang - PI) / PI; // Using x alone, the pulse is centered at PI and has a width of 2PI.
447  mov = a * pulse(v *(x - d));
448  */
449  return mov;
450 }
451 
452 
moTempo
Tempo, beat, ritmo.
Definition: moTempo.h:44
moValue::GetSubValue
moValueBase & GetSubValue(MOint p_indexsubvalue=0)
Definition: moValue.h:539
moMotion::moMotion
moMotion()
Definition: moMotion.cpp:44
moMotion::~moMotion
virtual ~moMotion()
Definition: moMotion.cpp:49
MOchar
#define MOchar
Definition: moTypes.h:397
torad
#define torad
Definition: moMotion.h:37
MOfloat
#define MOfloat
Definition: moTypes.h:403
moMotion::movx
MOfloat movx(moParam &param, moTempo &tempo)
Definition: moMotion.cpp:59
sqrt2
#define sqrt2
Definition: moMotion.h:39
moData::Float
MOfloat Float() const
Definition: moValue.cpp:835
moMotion::movz
MOfloat movz(moParam &param, moTempo &tempo)
Definition: moMotion.cpp:192
moTempo::getTempo
MOdouble getTempo()
Definition: moTempo.cpp:153
MOint
#define MOint
Definition: moTypes.h:388
moParam::GetValue
moValue & GetValue(MOint i=-1)
Definition: moParam.cpp:1204
MOdouble
#define MOdouble
Definition: moTypes.h:404
moMotion::movy
MOfloat movy(moParam &param, moTempo &tempo)
Definition: moMotion.cpp:125
moValue::GetSubValueCount
MOuint GetSubValueCount()
Definition: moValue.h:545
togra
#define togra
Definition: moMotion.h:38
moData::Char
MOchar Char() const
Definition: moValue.cpp:883