9 #include "goom_tools.h"
19 #define STOP_SPEED 128
22 goom_init (GoomData * goomdata, guint32 resx, guint32 resy)
25 printf ("GOOM: init (%d, %d);\n", resx, resy);
29 goomdata->buffsize = 0;
31 goomdata->pixel = NULL;
32 goomdata->back = NULL;
36 goom_set_resolution (goomdata, resx, resy);
37 RAND_INIT (goomdata, GPOINTER_TO_INT (goomdata->pixel));
41 goomdata->goomlimit = 2; /* sensibilité du goom */
42 goomdata->zfd = zoomFilterNew ();
43 goomdata->lockvar = 0; /* pour empecher de nouveaux changements */
44 goomdata->goomvar = 0; /* boucle des gooms */
45 goomdata->totalgoom = 0; /* nombre de gooms par seconds */
46 goomdata->agoom = 0; /* un goom a eu lieu.. */
47 goomdata->loopvar = 0; /* mouvement des points */
48 goomdata->speedvar = 0; /* vitesse des particules */
49 goomdata->lineMode = 0; /* l'effet lineaire a dessiner */
53 goom_set_resolution (GoomData * goomdata, guint32 resx, guint32 resy)
55 guint32 buffsize = resx * resy;
57 if ((goomdata->resolx == resx) && (goomdata->resoly == resy))
60 if (goomdata->buffsize < buffsize) {
62 free (goomdata->pixel);
64 free (goomdata->back);
65 goomdata->pixel = (guint32 *) malloc (buffsize * sizeof (guint32) + 128);
66 goomdata->back = (guint32 *) malloc (buffsize * sizeof (guint32) + 128);
67 goomdata->buffsize = buffsize;
70 (void *) (((unsigned long) goomdata->pixel + 0x7f) & (~0x7f));
71 goomdata->p2 = (void *) (((unsigned long) goomdata->back + 0x7f) & (~0x7f));
74 goomdata->resolx = resx;
75 goomdata->resoly = resy;
77 memset (goomdata->pixel, 0, buffsize * sizeof (guint32) + 128);
78 memset (goomdata->back, 0, buffsize * sizeof (guint32) + 128);
82 goom_update (GoomData * goomdata, gint16 data[2][512])
87 int incvar; /* volume du son */
88 int accelvar; /* acceleration des particules */
90 float largfactor; /* elargissement de l'intervalle d'évolution des points */
92 int resolx = goomdata->resolx;
93 int resoly = goomdata->resoly;
94 ZoomFilterData *pzfd = goomdata->zfd;
97 /* test if the config has changed, update it if so */
99 pointWidth = (resolx * 2) / 5;
100 pointHeight = (resoly * 2) / 5;
102 /* ! etude du signal ... */
104 for (i = 0; i < 512; i++) {
105 if (incvar < data[0][i])
109 accelvar = incvar / 5000;
110 if (goomdata->speedvar > 5) {
112 if (goomdata->speedvar > 20)
114 if (goomdata->speedvar > 40)
115 goomdata->speedvar = 40;
118 goomdata->speedvar += accelvar;
120 if (goomdata->speedvar < 0)
121 goomdata->speedvar = 0;
122 if (goomdata->speedvar > 40)
123 goomdata->speedvar = 40;
126 /* ! calcul du deplacement des petits points ... */
129 ((float) goomdata->speedvar / 40.0f + (float) incvar / 50000.0f) / 1.5f;
130 if (largfactor > 1.5f)
133 for (i = 1; i * 15 <= goomdata->speedvar + 15; i++) {
134 goomdata->loopvar += goomdata->speedvar + 1;
136 pointFilter (goomdata,
138 ((pointWidth - 6.0f) * largfactor + 5.0f),
139 ((pointHeight - 6.0f) * largfactor + 5.0f),
140 i * 152.0f, 128.0f, goomdata->loopvar + i * 2032);
141 pointFilter (goomdata, ORANGE,
142 ((pointWidth / 2) * largfactor) / i + 10.0f * i,
143 ((pointHeight / 2) * largfactor) / i + 10.0f * i,
144 96.0f, i * 80.0f, goomdata->loopvar / i);
145 pointFilter (goomdata, VIOLET,
146 ((pointHeight / 3 + 5.0f) * largfactor) / i + 10.0f * i,
147 ((pointHeight / 3 + 5.0f) * largfactor) / i + 10.0f * i,
148 i + 122.0f, 134.0f, goomdata->loopvar / i);
149 pointFilter (goomdata, BLACK,
150 ((pointHeight / 3) * largfactor + 20.0f),
151 ((pointHeight / 3) * largfactor + 20.0f),
152 58.0f, i * 66.0f, goomdata->loopvar / i);
153 pointFilter (goomdata, WHITE,
154 (pointHeight * largfactor + 10.0f * i) / i,
155 (pointHeight * largfactor + 10.0f * i) / i,
156 66.0f, 74.0f, goomdata->loopvar + i * 500);
159 /* diminuer de 1 le temps de lockage */
160 /* note pour ceux qui n'ont pas suivis : le lockvar permet d'empecher un */
161 /* changement d'etat du plugins juste apres un autre changement d'etat. oki ? */
162 if (--goomdata->lockvar < 0)
163 goomdata->lockvar = 0;
166 if (--goomdata->agoom < 0)
169 /* on verifie qu'il ne se pas un truc interressant avec le son. */
170 if ((accelvar > goomdata->goomlimit) || (accelvar < -goomdata->goomlimit)) {
171 /* UN GOOM !!! YAHOO ! */
172 goomdata->totalgoom++;
173 goomdata->agoom = 20; /* mais pdt 20 cycles, il n'y en aura plus. */
174 goomdata->lineMode = (goomdata->lineMode + 1) % 20; /* Tous les 10 gooms on change de mode lineaire */
176 /* changement eventuel de mode */
177 switch (iRAND (goomdata, 10)) {
181 pzfd->mode = WAVE_MODE;
182 pzfd->vitesse = STOP_SPEED - 1;
187 pzfd->mode = CRYSTAL_BALL_MODE;
190 pzfd->mode = AMULETTE_MODE;
193 pzfd->mode = WATER_MODE;
196 pzfd->mode = SCRUNCH_MODE;
199 pzfd->mode = NORMAL_MODE;
203 /* tout ceci ne sera fait qu'en cas de non-blocage */
204 if (goomdata->lockvar == 0) {
205 /* reperage de goom (acceleration forte de l'acceleration du volume) */
206 /* -> coup de boost de la vitesse si besoin.. */
207 if ((accelvar > goomdata->goomlimit) || (accelvar < -goomdata->goomlimit)) {
209 /*if (goomvar % 1 == 0) */
214 newvit = STOP_SPEED - goomdata->speedvar / 2;
215 /* retablir le zoom avant.. */
216 if ((pzfd->reverse) && (!(goomdata->cycle % 12)) && (rand () % 3 == 0)) {
218 pzfd->vitesse = STOP_SPEED - 2;
219 goomdata->lockvar = 50;
221 if (iRAND (goomdata, 10) == 0) {
223 goomdata->lockvar = 100;
226 /* changement de milieu.. */
227 switch (iRAND (goomdata, 20)) {
229 pzfd->middleY = resoly - 1;
230 pzfd->middleX = resolx / 2;
233 pzfd->middleX = resolx - 1;
239 pzfd->middleY = resoly / 2;
240 pzfd->middleX = resolx / 2;
243 if (pzfd->mode == WATER_MODE) {
244 pzfd->middleX = resolx / 2;
245 pzfd->middleY = resoly / 2;
248 switch (vtmp = (iRAND (goomdata, 27))) {
250 pzfd->vPlaneEffect = iRAND (goomdata, 3);
251 pzfd->vPlaneEffect -= iRAND (goomdata, 3);
252 pzfd->hPlaneEffect = iRAND (goomdata, 3);
253 pzfd->hPlaneEffect -= iRAND (goomdata, 3);
256 pzfd->vPlaneEffect = 0;
257 pzfd->hPlaneEffect = iRAND (goomdata, 8);
258 pzfd->hPlaneEffect -= iRAND (goomdata, 8);
264 pzfd->vPlaneEffect = iRAND (goomdata, 5);
265 pzfd->vPlaneEffect -= iRAND (goomdata, 5);
266 pzfd->hPlaneEffect = -pzfd->vPlaneEffect;
269 pzfd->hPlaneEffect = 5 + iRAND (goomdata, 8);
270 pzfd->vPlaneEffect = -pzfd->hPlaneEffect;
273 pzfd->vPlaneEffect = 5 + iRAND (goomdata, 8);
274 pzfd->hPlaneEffect = -pzfd->hPlaneEffect;
277 pzfd->hPlaneEffect = 0;
278 pzfd->vPlaneEffect = iRAND (goomdata, 10);
279 pzfd->vPlaneEffect -= iRAND (goomdata, 10);
283 pzfd->vPlaneEffect = 0;
284 pzfd->hPlaneEffect = 0;
288 if (iRAND (goomdata, 3) != 0)
291 pzfd->noisify = iRAND (goomdata, 3) + 2;
292 goomdata->lockvar *= 3;
295 if (pzfd->mode == AMULETTE_MODE) {
296 pzfd->vPlaneEffect = 0;
297 pzfd->hPlaneEffect = 0;
301 if ((pzfd->middleX == 1) || (pzfd->middleX == resolx - 1)) {
302 pzfd->vPlaneEffect = 0;
303 pzfd->hPlaneEffect = iRAND (goomdata, 2) ? 0 : pzfd->hPlaneEffect;
306 if (newvit < pzfd->vitesse) { /* on accelere */
308 if (((newvit < STOP_SPEED - 7) &&
309 (pzfd->vitesse < STOP_SPEED - 6) &&
310 (goomdata->cycle % 3 == 0)) || (iRAND (goomdata, 40) == 0)) {
311 pzfd->vitesse = STOP_SPEED - 1;
312 pzfd->reverse = !pzfd->reverse;
314 pzfd->vitesse = (newvit + pzfd->vitesse * 4) / 5;
316 goomdata->lockvar += 50;
321 if (iRAND (goomdata, 1000) == 0) {
323 printf ("coup du sort...\n") ;
326 pzfd->vitesse = STOP_SPEED - 1;
328 pzfd->sqrtperte = 16;
329 goomdata->goomvar = 1;
330 goomdata->lockvar += 70;
334 /* gros frein si la musique est calme */
335 if ((goomdata->speedvar < 1) && (pzfd->vitesse < STOP_SPEED - 4)
336 && (goomdata->cycle % 16 == 0)) {
338 printf ("++slow part... %i\n", zfd.vitesse) ;
343 pzfd->sqrtperte = 16;
344 goomdata->goomvar = 0;
346 printf ("--slow part... %i\n", zfd.vitesse) ;
350 /* baisser regulierement la vitesse... */
351 if ((goomdata->cycle % 73 == 0) && (pzfd->vitesse < STOP_SPEED - 5)) {
353 printf ("slow down...\n") ;
359 /* arreter de decrémenter au bout d'un certain temps */
360 if ((goomdata->cycle % 101 == 0) && (pzfd->pertedec == 7)) {
363 pzfd->sqrtperte = 16;
367 zoomFilterFastRGB (goomdata, pzfd, zfd_update);
369 /* si on est dans un goom : afficher les lignes... */
370 if (goomdata->agoom > 15)
371 goom_lines (goomdata, data, ((pzfd->middleX == resolx / 2)
372 && (pzfd->middleY == resoly / 2)
373 && (pzfd->mode != WATER_MODE))
374 ? (goomdata->lineMode / 10) : 0, goomdata->p2, goomdata->agoom - 15);
376 return_val = goomdata->p2;
378 goomdata->p1 = goomdata->p2;
381 /* affichage et swappage des buffers.. */
384 /* tous les 100 cycles : vérifier si le taux de goom est correct */
385 /* et le modifier sinon.. */
386 if (!(goomdata->cycle % 100)) {
387 if (goomdata->totalgoom > 15) {
388 /* printf ("less gooms\n") ; */
389 goomdata->goomlimit++;
391 if ((goomdata->totalgoom == 0) && (goomdata->goomlimit > 1))
392 goomdata->goomlimit--;
394 goomdata->totalgoom = 0;
400 goom_close (GoomData * goomdata)
402 if (goomdata->pixel != NULL)
403 free (goomdata->pixel);
404 if (goomdata->back != NULL)
405 free (goomdata->back);
406 if (goomdata->zfd != NULL) {
407 zoomFilterDestroy (goomdata->zfd);
408 goomdata->zfd = NULL;
410 goomdata->pixel = goomdata->back = NULL;
411 RAND_CLOSE (goomdata);