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
moTempo.cpp
Ir a la documentación de este archivo.
1 /*******************************************************************************
2 
3  moTempo.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 #include "moTempo.h"
33 #include "moMath.h"
34 
35 
37  Init();
38 }
39 
41  Stop();
42 }
43 
44 moTempo::moTempo( const moTempo &src) : moTimer() {
45  (*this) = src;
46 }
47 
48 moTempo&
50 
51  (moTimer&)(*this)=(moTimer&)src;
52 
53  m_pFromTempo = src.m_pFromTempo;
54 
55  //version vieja
56  ticks = src.ticks;
57  ticks_0 = src.ticks_0;
58  ticks_1 = src.ticks_1;
59 
60  //propio de moTempo
61  syncro = src.syncro;
62  delta = src.delta;
64  factor = src.factor;
65  //added for precise calculation
66  ang = src.ang;
67 
69  return (*this);
70 }
71 
73  ticks = 0;
74  ticks_0 = 0;
75  ticks_1 = 10000;
76 
77  syncro = 1.0;
78  delta = 1.0;
79  deltaprevious = 1.0;
80  factor = 1.0;
81 
82  beatpulsecount = 0;
83  m_pFromTempo = NULL;
84 
85  // siempre iniciamos encendiendo el timer
86  Start();
87 
88  return true;
89 }
90 
92 
93  Init();
94 
95  syncro = sync;
96 
97  return true;
98 }
99 
101 
102  MOdouble dx,dy;
103  MOulong intv,modv,resv;
104 
105  MOdouble t0;
106 
107  //correcion para continuidad
108  if(deltaprevious!=delta) {
109 
110  intv = ticks - ticks_0;
111  modv = ticks_1 - ticks_0;
112 
113  modv =( modv == 0 ? 1 : modv );
114  dy =(double) 2.0 * moMathf::PI *(factor + deltaprevious - 1.0);
115  dx =(double) modv;
116  ang =(double) intv * dy / dx;
117 
118  t0 = ticks - ang * modv /(2.0 * moMathf::PI *(factor + delta - 1.0) );
119 
120  //corregimos el ticks_0(desfazaje que fuerza el desplazamiento de la funcion para su continuidad)
121  ticks_0 =(int) t0;
122  ticks_1 =(int) t0 + modv;
124  }
125 
126 
127  intv = ticks - ticks_0;
128  modv = ticks_1 - ticks_0;
129  resv = intv % modv;
130  dx =(double) resv /(double) modv;
131  dy =(double) 2.0 * moMathf::PI *(factor + delta - 1.0);
132  ang =(dx!=0.0 ? dy*dx : 0.0);
133  ang*=syncro;
134 /*
135  intv = ticks - ticks_0;
136  modv = ticks_1 - ticks_0;
137  modv =( modv == 0 ? 1 : modv );
138  dy =(double) 2.0 * pi *(factor + delta - 1.0);
139  dx =(double) modv;
140  ang =(double) intv * dy / dx;
141  ang *= syncro;
142 */
143  return (ang);
144 }
145 
147  //return moTimer::Duration();
149  return duration;
150 }
151 
152 
154 
155  MOdouble dx,dy;
156  MOulong intv,modv;
157 
158  MOdouble t0;
159 /*
160  intv = ticks - ticks_0;
161  modv = ticks_1 - ticks_0 +(MOulong) delta;
162  resv = intv % modv;
163  dx =(double) resv /(double) modv;
164  dy =(double) 2.0 * pi;
165  ang =(dx!=0.0 ? factor*dy*dx : 0.0);
166  ang*=syncro;
167 */
168 
169  //correcion para continuidad
170  if(deltaprevious!=delta) {
171 
173  ticks = duration;
174  intv = ticks - ticks_0;
175  modv = ticks_1 - ticks_0;
176 
177 
178 
179  modv =( modv == 0 ? 1 : modv );
180  dy =(double) 2.0 * moMathf::PI *(factor + deltaprevious - 1.0);
181  dx =(double) modv;
182  ang =(double) intv * dy / dx;
183 
184  //t0 = ticks - ang * modv /(2.0 * moMathf::PI *(factor + delta - 1.0) );
185  if ( (factor + delta - 1.0)!=0.0) {
186  t0 = ticks - ang * modv /(2.0 * moMathf::PI *(factor + delta - 1.0) );
187  } else t0 = ticks;
188 
189 
190  //corregimos el ticks_0(desfazaje que fuerza el desplazamiento de la funcion para su continuidad)
191  ticks_0 =(int) t0;
192  ticks_1 =(int) t0 + modv;
194  }
195 
197  ticks = duration;
198  intv = ticks - ticks_0;
199 
200  modv = ticks_1 - ticks_0;
201  modv =( modv == 0 ? 1 : modv );
202  dy =(double) 2.0 * moMathf::PI *(factor + delta - 1.0);
203  dx =(double) modv;
204  ang =(double) intv * dy / dx;
205  ang *= syncro;
206  return (ang);
207 }
208 
210  //beatpulsecount0-> contando tiempo
211  if(beatpulsecount==0 || tik-beat_0 > 10000) { // si pasaron mas de 10' lo toma como el primer beat.
212  //entra el primero
213  beat_0 = tik;//vamos todavia
214  beatpulsecount = 1;//pasamos a 1
215  }
216  else
217  if(beatpulsecount==1) {
218  beat_1 = tik;
219  ticks_0 = beat_0;
220  ticks_1 = beat_1;
221  beatpulsecount = 0;//ya esta, lo tenemos, volvemos a cero
222  delta = 1.0;//reiniciamos el delta, asi podemos resetearlo
223  }
224 }
225 
227  return m_pFromTempo;
228 }
229 
230 void moTempo::SetFromTempo( moTempo *pfromtempo ) {
231  m_pFromTempo = pfromtempo;
232 }
233 
234 void moTempo::getInterpolatedTempo( MOfloat inter_value ) {//ivalue entre 0.0 y 1.0
235  //aca se hace el calculointerpolado
236  inter_value = 0 + inter_value;
237 }
238 
239 
#define MOulong
Definition: moTypes.h:392
Tempo, beat, ritmo.
Definition: moTempo.h:44
virtual void Start()
Inicia el temporizador.
Definition: moTimer.cpp:196
virtual long Duration()
Devuelve el valor del reloj del temporizador.
Definition: moTimer.cpp:211
#define MOboolean
Definition: moTypes.h:385
MOdouble deltaprevious
Definition: moTempo.h:70
MOdouble syncro
Syncronización o factor fraccionario, 1.0 predeterminado, sino KX donde K puede ser fraccional (un nú...
Definition: moTempo.h:79
void SetFromTempo(moTempo *pfromtempo)
Definition: moTempo.cpp:230
#define MOfloat
Definition: moTypes.h:403
MOdouble delta
variacion de frecuencia entre 0X y 2X, delta es real
Definition: moTempo.h:69
MOulong ticks_0
Primer tick del beat.
Definition: moTempo.h:63
void Stop()
Detiene el temporizador.
Definition: moTimer.h:219
MOboolean Init()
Definition: moTempo.cpp:72
MOulong ticks_1
Segundo tick del beat.
Definition: moTempo.h:66
MOdouble getTempo()
Definition: moTempo.cpp:153
MOdouble getPrincipalAngle()
Definition: moTempo.cpp:100
MOulong beat_1
Definition: moTempo.h:84
MOdouble factor
Multiplicador a partir de 2X hasta KX, donde K en principio es entero.
Definition: moTempo.h:76
const MOlong PI
Definition: moMath.cpp:44
void BeatPulse(MOulong tik)
Definition: moTempo.cpp:209
MOulong ticks
tiempo en milisegundos (obsoleto) se usa moTimer ahora.
Definition: moTempo.h:60
#define MOdouble
Definition: moTypes.h:404
Clase para el control de un temporizador (relativo) con identificación.
Definition: moTimer.h:321
MOulong beat_0
Temporales del beat.
Definition: moTempo.h:84
virtual long Duration()
Devuelve el valor del reloj del temporizador.
Definition: moTempo.cpp:146
virtual ~moTempo()
Definition: moTempo.cpp:40
MOulong beatpulsecount
Definition: moTempo.h:84
moTempo()
Definition: moTempo.cpp:36
MOdouble ang
Definition: moTempo.h:81
moTempo & operator=(const moTempo &src)
Definition: moTempo.cpp:49
moTempo * getFromTempo()
Definition: moTempo.cpp:226
void getInterpolatedTempo(MOfloat inter_value)
Definition: moTempo.cpp:234