libmoldeo (Moldeo 1.0 Core)  1.0
libmoldeo es el conjunto de objetos y funciones, que permiten ejecutar las operaciones básicas de la plataforma Moldeo, y que compone su núcleo.
 Todo Clases Namespaces Archivos Funciones Variables 'typedefs' Enumeraciones Valores de enumeraciones Amigas 'defines' Grupos Páginas
moMotion.cpp
Ir a la documentación de este archivo.
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
c
var c
Definition: jquery.js:29
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
a
function a
Definition: jquery.js:41
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
e
function e
Definition: jquery.js:71
d
function d
Definition: jquery.js:41
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