MythTV master
goom_core.cpp
Go to the documentation of this file.
1#include "../config.h"
2
3#include <algorithm>
4#include <cstdio>
5#include <cstring>
6#include <random>
7
8#include "goom_core.h"
9#include "goom_tools.h"
10#include "filters.h"
11#include "lines.h"
12#include "ifs.h"
13#include "tentacle3d.h"
14//#include "gfontlib.h"
15
16//#define VERBOSE
17
18static constexpr gint32 STOP_SPEED { 128 };
19static constexpr int16_t TIME_BTW_CHG { 300 };
20
24static guint32 *pixel;
25static guint32 *back;
26static guint32 *p1, *p2, *tmp;
27static guint32 cycle;
28
29struct GoomState {
30 int m_drawIfs;
31 int m_drawPoints;
32 int m_drawTentacle;
33
34 int m_drawScope;
35 int m_farScope;
36
37 int m_rangeMin;
38 int m_rangeMax;
39};
40
41static constexpr size_t STATES_NB { 8 };
42static constexpr uint16_t STATES_RANGEMAX { 510 };
43const std::array<const GoomState,STATES_NB> kStates {{
44 {1,0,0,1,4, 000, 100},
45 {1,0,0,1,1, 101, 140}, // turned on drawScope
46 {1,0,0,1,2, 141, 200},
47 {0,1,0,1,2, 201, 260},
48 {0,1,0,1,0, 261, 330},
49 {0,1,1,1,4, 331, 400},
50 {0,0,1,1,5, 401, 450}, // turned on drawScope
51 {0,0,1,1,1, 451, 510}
52}};
53
54const GoomState *curGState = &kStates[4];
55
56guint32 resolx, resoly, buffsize, c_black_height = 0, c_offset = 0, c_resoly = 0; /* avec prise en compte de ca */
57
58// effet de ligne..
59static GMLine *gmline1 = nullptr;
60static GMLine *gmline2 = nullptr;
61
62void choose_a_goom_line (float *param1, float *param2, int *couleur, int *mode, float *amplitude, int far);
63
64void goom_init (guint32 resx, guint32 resy, int cinemascope) {
65#ifdef VERBOSE
66 printf ("GOOM: init (%d, %d);\n", resx, resy);
67#endif
68 if (cinemascope)
69 c_black_height = resy / 5;
70 else
71 c_black_height = 0;
72
73 resolx = resx;
74 resoly = resy;
75 buffsize = resx * resy;
76
77 c_offset = c_black_height * resx;
78 c_resoly = resy - (c_black_height * 2);
79
80 pixel = (guint32 *) malloc ((buffsize * sizeof (guint32)) + 128);
81 back = (guint32 *) malloc ((buffsize * sizeof (guint32)) + 128);
82 //RAND_INIT ();
83 srand ((uintptr_t) pixel);
84 if (!rand_tab) rand_tab = (int *) malloc (NB_RAND * sizeof(int)) ;
85 for (size_t i = 0; i < NB_RAND; i++)
86 rand_tab[i] = goom_rand();
87 rand_pos = 0;
88
89 cycle = 0;
90
91 p1 = (guint32 *) ((1 + ((uintptr_t) (pixel)) / 128) * 128);
92 p2 = (guint32 *) ((1 + ((uintptr_t) (back)) / 128) * 128);
93
94 init_ifs (resx, c_resoly);
95 gmline1 = goom_lines_init (resx, c_resoly, GML_HLINE, c_resoly, GML_BLACK, GML_CIRCLE, 0.4F * (float) c_resoly, GML_VERT);
96 gmline2 = goom_lines_init (resx, c_resoly, GML_HLINE, 0, GML_BLACK, GML_CIRCLE, 0.2F * (float) c_resoly, GML_RED);
97
98// gfont_load ();
99
100 tentacle_new ();
101}
102
103
104void goom_set_resolution (guint32 resx, guint32 resy, int cinemascope) {
105 free (pixel);
106 free (back);
107
108 if (cinemascope)
109 c_black_height = resy / 8;
110 else
111 c_black_height = 0;
112
113 c_offset = c_black_height * resx;
114 c_resoly = resy - (c_black_height * 2);
115
116 resolx = resx;
117 resoly = resy;
118 buffsize = resx * resy;
119
120 pixel = (guint32 *) malloc ((buffsize * sizeof (guint32)) + 128);
121 memset (pixel, 0, (buffsize * sizeof (guint32)) + 128);
122 back = (guint32 *) malloc ((buffsize * sizeof (guint32)) + 128);
123 memset (back, 0, (buffsize * sizeof (guint32)) + 128);
124 p1 = (guint32 *) ((1 + ((uintptr_t) (pixel)) / 128) * 128);
125 p2 = (guint32 *) ((1 + ((uintptr_t) (back)) / 128) * 128);
126
127 init_ifs (resx, c_resoly);
128 goom_lines_set_res (gmline1, resx, c_resoly);
129 goom_lines_set_res (gmline2, resx, c_resoly);
130}
131
132
133guint32 * goom_update (GoomDualData& data, int forceMode) {
134 static int s_lockVar = 0; // pour empecher de nouveaux changements
135 static int s_totalGoom = 0; // nombre de gooms par seconds
136 static int s_aGoom = 0; // un goom a eu lieu..
137 static int s_aBigGoom = 0; // un big goom a eu lieu..
138 static int s_speedVar = 0; // vitesse des particules
139
140 // duree de la transition entre afficher les lignes ou pas
141 static constexpr int DRAWLINES { 80 };
142 static int s_lineMode = DRAWLINES; // l'effet lineaire a dessiner
143 static int s_nombreCddc = 0; // nombre de Cycle Depuis Dernier Changement
144 static int s_accelVar=0; // acceleration des particules
145 static int s_stopLines = 0;
146
147 // des points
148 static int s_ifsIncr = 1; // dessiner l'ifs (0 = non: > = increment)
149 static int s_decayIfs = 0; // disparition de l'ifs
150 static int s_recayIfs = 0; // dédisparition de l'ifs
151
152 static constexpr float SWITCHMULT { 29.0F/30.0F };
153 static constexpr int SWITCHINCR { 0x7f };
154 static float s_switchMult = 1.0F;
155 static int s_switchIncr = SWITCHINCR;
156
157 static char s_goomLimit = 2; // sensibilité du goom
158 static ZoomFilterData s_zfd = {
159 127, 8, 16,
160 1, 1, false, NORMAL_MODE,
161 0, 0, false, false, 0
162 };
163
164 ZoomFilterData *pzfd = nullptr;
165
166 /* test if the config has changed, update it if so */
167 guint32 pointWidth = (resolx * 2) / 5;
168 guint32 pointHeight = ((c_resoly) * 2) / 5;
169
170 /* ! etude du signal ... */
171 int incvar = 0; // volume du son
172 for (int i = 0; i < 512; i++) {
173 incvar = std::max<int>(incvar, data[0][i]);
174 }
175
176 int i = s_accelVar;
177 s_accelVar = incvar / 1000;
178
179 if (s_speedVar > 5) {
180 s_accelVar--;
181 if (s_speedVar > 20)
182 s_accelVar--;
183 s_speedVar = std::min(s_speedVar, 40);
184 }
185 s_accelVar--;
186
187 i = s_accelVar - i;
188 if (i<0) i=-i;
189
190 s_speedVar += (s_speedVar + (i/2));
191 s_speedVar /= 2;
192 if ((s_speedVar) && (cycle%9==0)) {
193 s_speedVar -= 1;
194 }
195 if ((s_speedVar) && (cycle%5==0)) {
196 s_speedVar = (s_speedVar*7)/8;
197 }
198
199 s_speedVar = std::clamp(s_speedVar, 0, 50);
200
201
202 /* ! calcul du deplacement des petits points ... */
203
204 // largfactor: elargissement de l'intervalle d'évolution
205 float largfactor = ((float) s_speedVar / 40.0F + (float) incvar / 50000.0F) / 1.5F;
206 largfactor = std::min(largfactor, 1.5F);
207
208 s_decayIfs--;
209 if (s_decayIfs > 0)
210 s_ifsIncr += 2;
211 if (s_decayIfs == 0)
212 s_ifsIncr = 0;
213
214
215 if (s_recayIfs) {
216 s_ifsIncr -= 2;
217 s_recayIfs--;
218 if ((s_recayIfs == 0)&&(s_ifsIncr<=0))
219 s_ifsIncr = 1;
220 }
221
222 if (s_ifsIncr > 0)
223 ifs_update (p1 + c_offset, p2 + c_offset, resolx, c_resoly, s_ifsIncr);
224
225 if (curGState->m_drawPoints) {
226 for (i = 1; i * 15 <= s_speedVar + 15; i++) {
227 static int s_loopVar = 0; // mouvement des points
228 s_loopVar += (s_speedVar*2/3) + 1;
229
230 pointFilter (p1 + c_offset, YELLOW,
231 (((pointWidth - 6.0F) * largfactor) + 5.0F),
232 (((pointHeight - 6.0F) * largfactor) + 5.0F),
233 i * 152.0F, 128.0F, s_loopVar + (i * 2032));
234 pointFilter (p1 + c_offset, ORANGE,
235 (((pointWidth / 2.0F) * largfactor) / i) + (10.0F * i),
236 (((pointHeight / 2.0F) * largfactor) / i) + (10.0F * i),
237 96.0F, i * 80.0F, s_loopVar / i);
238 pointFilter (p1 + c_offset, VIOLET,
239 (((pointHeight / 3.0F + 5.0F) * largfactor) / i) + (10.0F * i),
240 (((pointHeight / 3.0F + 5.0F) * largfactor) / i) + (10.0F * i),
241 i + 122.0F, 134.0F, s_loopVar / i);
242 pointFilter (p1 + c_offset, BLACK,
243 (((pointHeight / 3.0F) * largfactor) + 20.0F),
244 (((pointHeight / 3.0F) * largfactor) + 20.0F),
245 58.0F, i * 66.0F, s_loopVar / i);
246 pointFilter (p1 + c_offset, WHITE,
247 (pointHeight * largfactor + 10.0F * i) / i,
248 (pointHeight * largfactor + 10.0F * i) / i,
249 66.0F, 74.0F, s_loopVar + (i * 500)); }
250 }
251
252 // par défaut pas de changement de zoom
253 pzfd = nullptr;
254
255 /*
256 * Test forceMode
257 */
258#ifdef VERBOSE
259 if (forceMode != 0) {
260 printf ("forcemode = %d\n", forceMode);
261 }
262#endif
263
264
265 // diminuer de 1 le temps de lockage
266 // note pour ceux qui n'ont pas suivis : le lockvar permet d'empecher un
267 // changement d'etat du plugins juste apres un autre changement d'etat. oki
268 //
269 // ?
270 if (--s_lockVar < 0)
271 s_lockVar = 0;
272
273 // temps du goom
274 if (--s_aGoom < 0)
275 s_aGoom = 0;
276
277 // temps du goom
278 if (--s_aBigGoom < 0)
279 s_aBigGoom = 0;
280
281 if ((!s_aBigGoom) && (s_speedVar > 4) && (s_goomLimit > 4) &&
282 ((s_accelVar > (s_goomLimit*9/8)+7)||(s_accelVar < (-s_goomLimit*9/8)-7))) {
283 static int s_couleur =
284 (0xc0<<(ROUGE*8))
285 |(0xc0<<(VERT*8))
286 |(0xf0<<(BLEU*8))
287 |(0xf0<<(ALPHA*8));
288 s_aBigGoom = 100;
289 int size = resolx*c_resoly;
290 for (int j=0;j<size;j++)
291 (p1+c_offset)[j] = (~(p1+c_offset)[j]) | s_couleur;
292 }
293
294 // on verifie qu'il ne se pas un truc interressant avec le son.
295 if ((s_accelVar > s_goomLimit) || (s_accelVar < -s_goomLimit) || (forceMode > 0)
296 || (s_nombreCddc > TIME_BTW_CHG)) {
297
298// if (nombreCDDC > 300) {
299// }
300
301 // UN GOOM !!! YAHOO !
302 s_totalGoom++;
303 s_aGoom = 20; // mais pdt 20 cycles, il n'y en aura plus.
304
305 // changement eventuel de mode
306 if (iRAND(16) == 0)
307 {
308 switch (iRAND (32)) {
309 case 0:
310 case 10:
311 s_zfd.hypercosEffect = iRAND (2);
312 // Checked Fedora26 get-plugins-good sources.
313 // No break statement there.
314 [[fallthrough]];
315 case 13:
316 case 20:
317 case 21:
318 s_zfd.mode = WAVE_MODE;
319 s_zfd.reverse = false;
320 s_zfd.waveEffect = (iRAND (3) == 0);
321 if (iRAND (2))
322 s_zfd.vitesse = (s_zfd.vitesse + 127) >> 1;
323 break;
324 case 1:
325 case 11:
326 s_zfd.mode = CRYSTAL_BALL_MODE;
327 s_zfd.waveEffect = false;
328 s_zfd.hypercosEffect = false;
329 break;
330 case 2:
331 case 12:
332 s_zfd.mode = AMULETTE_MODE;
333 s_zfd.waveEffect = false;
334 s_zfd.hypercosEffect = false;
335 break;
336 case 3:
337 s_zfd.mode = WATER_MODE;
338 s_zfd.waveEffect = false;
339 s_zfd.hypercosEffect = false;
340 break;
341 case 4:
342 case 14:
343 s_zfd.mode = SCRUNCH_MODE;
344 s_zfd.waveEffect = false;
345 s_zfd.hypercosEffect = false;
346 break;
347 case 5:
348 case 15:
349 case 22:
350 s_zfd.mode = HYPERCOS1_MODE;
351 s_zfd.waveEffect = false;
352 s_zfd.hypercosEffect = (iRAND (3) == 0);
353 break;
354 case 6:
355 case 16:
356 s_zfd.mode = HYPERCOS2_MODE;
357 s_zfd.waveEffect = false;
358 s_zfd.hypercosEffect = false;
359 break;
360 case 7:
361 case 17:
362 s_zfd.mode = CRYSTAL_BALL_MODE;
363 s_zfd.waveEffect = (iRAND (4) == 0);
364 s_zfd.hypercosEffect = iRAND (2);
365 break;
366 case 8:
367 case 18:
368 case 19:
369 s_zfd.mode = SCRUNCH_MODE;
370 s_zfd.waveEffect = true;
371 s_zfd.hypercosEffect = true;
372 break;
373 case 29:
374 case 30:
375 s_zfd.mode = YONLY_MODE;
376 break;
377 case 31:
378 case 32:
379 s_zfd.mode = SPEEDWAY_MODE;
380 break;
381 default:
382 s_zfd.mode = NORMAL_MODE;
383 s_zfd.waveEffect = false;
384 s_zfd.hypercosEffect = false;
385 }
386 }
387 }
388
389 // tout ceci ne sera fait qu'en cas de non-blocage
390 if (s_lockVar == 0) {
391 // reperage de goom (acceleration forte de l'acceleration du volume)
392 // -> coup de boost de la vitesse si besoin..
393 if ((s_accelVar > s_goomLimit) || (s_accelVar < -s_goomLimit)) {
394 static int s_rndn = 0;
395 static int s_blocker = 0;
396
397 /* SELECTION OF THE GOOM STATE */
398 if ((!s_blocker)&&(iRAND(3))) {
399 s_rndn = iRAND(STATES_RANGEMAX);
400 s_blocker = 3;
401 }
402 else if (s_blocker)
403 {
404 s_blocker--;
405 }
406
407 (void)s_rndn; // Used in the lambda. Quiet warning.
408 auto goodstate = [&](auto state)
409 { return (s_rndn >= state.m_rangeMin) &&
410 (s_rndn <= state.m_rangeMax); };
411 const auto *it =
412 std::find_if(kStates.cbegin(), kStates.cend(), goodstate);
413 if (it != kStates.cend())
414 curGState = &(*it);
415
416 if ((curGState->m_drawIfs) && (s_ifsIncr<=0)) {
417 s_recayIfs = 5;
418 s_ifsIncr = 11;
419 }
420
421 if ((!curGState->m_drawIfs) && (s_ifsIncr>0) && (s_decayIfs<=0))
422 s_decayIfs = 100;
423
424 if (!curGState->m_drawScope) {
425 s_stopLines = 0;
426 s_lineMode = DRAWLINES;
427 }
428
429 // if (goomvar % 1 == 0)
430 {
431 s_lockVar = 50;
432 guint32 newvit = STOP_SPEED + 1 - (4.0F * log10f(s_speedVar+1));
433 // retablir le zoom avant..
434 // Pseudo-random is good enough. Don't need a true random.
435 // NOLINTNEXTLINE(cert-msc30-c,cert-msc50-cpp)
436 if ((s_zfd.reverse) && (!(cycle % 13)) && (rand () % 5 == 0)) {
437 s_zfd.reverse = false;
438 s_zfd.vitesse = STOP_SPEED - 2;
439 s_lockVar = 75;
440 }
441 if (iRAND (10) == 0) {
442 s_zfd.reverse = true;
443 s_lockVar = 100;
444 }
445
446 if (iRAND (10) == 0)
447 s_zfd.vitesse = STOP_SPEED - 1;
448 if (iRAND (12) == 0)
449 s_zfd.vitesse = STOP_SPEED + 1;
450
451 // changement de milieu..
452 switch (iRAND (25)) {
453 case 0:
454 case 3:
455 case 6:
456 s_zfd.middleY = c_resoly - 1;
457 s_zfd.middleX = resolx / 2;
458 break;
459 case 1:
460 case 4:
461 s_zfd.middleX = resolx - 1;
462 break;
463 case 2:
464 case 5:
465 s_zfd.middleX = 1;
466 break;
467 default:
468 s_zfd.middleY = c_resoly / 2;
469 s_zfd.middleX = resolx / 2;
470 }
471
472 if ((s_zfd.mode == WATER_MODE)
473 || (s_zfd.mode == YONLY_MODE)
474 || (s_zfd.mode == AMULETTE_MODE)) {
475 s_zfd.middleX = resolx / 2;
476 s_zfd.middleY = c_resoly / 2;
477 }
478
479 guint32 vtmp = iRAND (15);
480 switch (vtmp) {
481 case 0:
482
483 // NOLINTNEXTLINE(misc-redundant-expression)
484 s_zfd.vPlaneEffect = iRAND (3) - iRAND (3);
485 // NOLINTNEXTLINE(misc-redundant-expression)
486 s_zfd.hPlaneEffect = iRAND (3) - iRAND (3);
487 break;
488 case 3:
489 s_zfd.vPlaneEffect = 0;
490 // NOLINTNEXTLINE(misc-redundant-expression)
491 s_zfd.hPlaneEffect = iRAND (8) - iRAND (8);
492 break;
493 case 4:
494 case 5:
495 case 6:
496 case 7:
497 // NOLINTNEXTLINE(misc-redundant-expression)
498 s_zfd.vPlaneEffect = iRAND (5) - iRAND (5);
499 s_zfd.hPlaneEffect = -s_zfd.vPlaneEffect;
500 break;
501 case 8:
502 s_zfd.hPlaneEffect = 5 + iRAND (8);
503 s_zfd.vPlaneEffect = -s_zfd.hPlaneEffect;
504 break;
505 case 9:
506 s_zfd.vPlaneEffect = 5 + iRAND (8);
507 s_zfd.hPlaneEffect = -s_zfd.hPlaneEffect;
508 break;
509 case 13:
510 s_zfd.hPlaneEffect = 0;
511 // NOLINTNEXTLINE(misc-redundant-expression)
512 s_zfd.vPlaneEffect = iRAND (10) - iRAND (10);
513 break;
514 case 14:
515 // NOLINTNEXTLINE(misc-redundant-expression)
516 s_zfd.hPlaneEffect = iRAND (10) - iRAND (10);
517 // NOLINTNEXTLINE(misc-redundant-expression)
518 s_zfd.vPlaneEffect = iRAND (10) - iRAND (10);
519 break;
520 default:
521 if (vtmp < 10) {
522 s_zfd.vPlaneEffect = 0;
523 s_zfd.hPlaneEffect = 0;
524 }
525 }
526
527 if (iRAND (5) != 0)
528 s_zfd.noisify = 0;
529 else {
530 s_zfd.noisify = iRAND (2) + 1;
531 s_lockVar *= 2;
532 }
533
534 if (s_zfd.mode == AMULETTE_MODE) {
535 s_zfd.vPlaneEffect = 0;
536 s_zfd.hPlaneEffect = 0;
537 s_zfd.noisify = 0;
538 }
539
540 if ((s_zfd.middleX == 1) || (s_zfd.middleX == (int)resolx - 1)) {
541 s_zfd.vPlaneEffect = 0;
542 s_zfd.hPlaneEffect = iRAND (2) ? 0 : s_zfd.hPlaneEffect;
543 }
544
545 if (newvit < (guint32)s_zfd.vitesse) // on accelere
546 {
547 pzfd = &s_zfd;
548 if (((newvit < STOP_SPEED - 7) &&
549 (s_zfd.vitesse < STOP_SPEED - 6) &&
550 (cycle % 3 == 0)) || (iRAND (40) == 0)) {
551 s_zfd.vitesse = STOP_SPEED - iRAND (2) + iRAND (2);
552 s_zfd.reverse = !s_zfd.reverse;
553 }
554 else {
555 s_zfd.vitesse = (newvit + s_zfd.vitesse * 7) / 8;
556 }
557 s_lockVar += 50;
558 }
559 }
560
561 if (s_lockVar > 150) {
562 s_switchIncr = SWITCHINCR;
563 s_switchMult = 1.0F;
564 }
565 }
566 // mode mega-lent
567 if (iRAND (700) == 0) {
568 pzfd = &s_zfd;
569 s_zfd.vitesse = STOP_SPEED - 1;
570 s_zfd.pertedec = 8;
571 s_zfd.sqrtperte = 16;
572 s_lockVar += 50;
573 s_switchIncr = SWITCHINCR;
574 s_switchMult = 1.0F;
575 }
576 }
577
578 /*
579 * gros frein si la musique est calme
580 */
581 if ((s_speedVar < 1) && (s_zfd.vitesse < STOP_SPEED - 4) && (cycle % 16 == 0)) {
582 pzfd = &s_zfd;
583 s_zfd.vitesse += 3;
584 s_zfd.pertedec = 8;
585 s_zfd.sqrtperte = 16;
586 }
587
588 /*
589 * baisser regulierement la vitesse...
590 */
591 if ((cycle % 73 == 0) && (s_zfd.vitesse < STOP_SPEED - 5)) {
592 pzfd = &s_zfd;
593 s_zfd.vitesse++;
594 }
595
596 /*
597 * arreter de decrémenter au bout d'un certain temps
598 */
599 if ((cycle % 101 == 0) && (s_zfd.pertedec == 7)) {
600 pzfd = &s_zfd;
601 s_zfd.pertedec = 8;
602 s_zfd.sqrtperte = 16;
603 }
604
605 /*
606 * Permet de forcer un effet.
607 */
608 if ((forceMode > 0) && (forceMode <= NB_FX)) {
609 pzfd = &s_zfd;
610 pzfd->mode = forceMode - 1;
611 }
612
613 if (forceMode == -1) {
614 pzfd = nullptr;
615 }
616
617 /*
618 * Changement d'effet de zoom !
619 */
620 if (pzfd != nullptr) {
621 static int s_exvit = 128;
622
623 s_nombreCddc = 0;
624
625 s_switchIncr = SWITCHINCR;
626
627 int dif = s_zfd.vitesse - s_exvit;
628 if (dif < 0)
629 dif = -dif;
630
631 if (dif > 2) {
632 s_switchIncr *= (dif + 2) / 2;
633 }
634 s_exvit = s_zfd.vitesse;
635 s_switchMult = 1.0F;
636
637 if (((s_accelVar > s_goomLimit) && (s_totalGoom < 2)) || (forceMode > 0)) {
638 s_switchIncr = 0;
639 s_switchMult = SWITCHMULT;
640 }
641 }
642 else {
643 if (s_nombreCddc > TIME_BTW_CHG) {
644 pzfd = &s_zfd;
645 s_nombreCddc = 0;
646 }
647 else
648 {
649 s_nombreCddc++;
650 }
651 }
652
653#ifdef VERBOSE
654 if (pzfd) {
655 printf ("GOOM: pzfd->mode = %d\n", pzfd->mode);
656 }
657#endif
658
659 // Zoom here !
660 zoomFilterFastRGB (p1 + c_offset, p2 + c_offset, pzfd, resolx, c_resoly, s_switchIncr, s_switchMult);
661
662 /*
663 * Affichage tentacule
664 */
665
666 if (s_goomLimit!=0)
667 tentacle_update((gint32*)(p2 + c_offset), (gint32*)(p1 + c_offset), resolx, c_resoly, data, (float)s_accelVar/s_goomLimit, curGState->m_drawTentacle);
668 else
669 tentacle_update((gint32*)(p2 + c_offset), (gint32*)(p1 + c_offset), resolx, c_resoly, data,0.0F, curGState->m_drawTentacle);
670
671/*
672 {
673 static char title[1024];
674 static int displayTitle = 0;
675 char text[255];
676
677 if (fps > 0) {
678 int i;
679 if (speedvar>0) {
680 for (i=0;i<speedvar;i++)
681 text[i]='*';
682 text[i]=0;
683 goom_draw_text (p1 + c_offset,resolx,c_resoly, 10, 50, text, 1.0F, 0);
684 }
685 if (accelvar>0) {
686 for (i=0;i<accelvar;i++) {
687 if (i==goomlimit)
688 text[i]='o';
689 else
690 text[i]='*';
691 }
692 text[i]=0;
693 goom_draw_text (p1 + c_offset,resolx,c_resoly, 10, 62, text, 1.0F, 0);
694 }
695 if (agoom==20)
696 goom_draw_text (p1 + c_offset,resolx,c_resoly,10, 80, "GOOM",1.0F, 0);
697 else if (agoom)
698 goom_draw_text (p1 + c_offset,resolx,c_resoly,10, 80, "goom",1.0F, 0);
699 if (abiggoom==200)
700 goom_draw_text (p1 + c_offset,resolx,c_resoly,10, 100, "BGOOM",1.0F, 0);
701 else if (abiggoom)
702 goom_draw_text (p1 + c_offset,resolx,c_resoly,10, 100, "bgoom",1.0F, 0);
703 }
704
705 update_message (message);
706
707 if (fps > 0) {
708 sprintf (text, "%2.f fps", fps);
709 goom_draw_text (p1 + c_offset,resolx,c_resoly, 10, 24, text, 1, 0);
710 }
711
712 if (songTitle != NULL) {
713 sprintf (title, songTitle); // la flemme d'inclure string.h :)
714 displayTitle = 200;
715 }
716
717 if (displayTitle) {
718 goom_draw_text (p1 + c_offset,resolx,c_resoly, resolx / 2, c_resoly / 2 + 7, title, ((float) (190 - displayTitle) / 10.0F), 1);
719 displayTitle--;
720 if (displayTitle < 4)
721 goom_draw_text (p2 + c_offset,resolx,c_resoly, resolx / 2, c_resoly / 2 + 7, title, ((float) (190 - displayTitle) / 10.0F), 1);
722 }
723 }
724*/
725
726 /*
727 * arret demande
728 */
729 if ((s_stopLines & 0xf000)||(!curGState->m_drawScope)) {
730 float param1 = NAN;
731 float param2 = NAN;
732 float amplitude = NAN;
733 int couleur = 0;
734 int mode = 0;
735
736 choose_a_goom_line (&param1, &param2, &couleur, &mode, &amplitude,1);
737 couleur = GML_BLACK;
738
739 goom_lines_switch_to (gmline1, mode, param1, amplitude, couleur);
740 goom_lines_switch_to (gmline2, mode, param2, amplitude, couleur);
741 s_stopLines &= 0x0fff;
742 }
743
744 /*
745 * arret aleatore.. changement de mode de ligne..
746 */
747 if (s_lineMode != DRAWLINES) {
748 s_lineMode--;
749 if (s_lineMode == -1)
750 s_lineMode = 0;
751 }
752 else
753 if ((cycle%80==0)&&(iRAND(5)==0)&&s_lineMode)
754 {
755 s_lineMode--;
756 }
757
758 if ((cycle % 120 == 0)
759 && (iRAND (4) == 0)
760 && (curGState->m_drawScope)) {
761 if (s_lineMode == 0)
762 s_lineMode = DRAWLINES;
763 else if (s_lineMode == DRAWLINES) {
764 float param1 = NAN;
765 float param2 = NAN;
766 float amplitude = NAN;
767 int couleur1 = 0;
768 int couleur2 = 0;
769 int mode = 0;
770
771 s_lineMode--;
772 choose_a_goom_line (&param1, &param2, &couleur1, &mode, &amplitude,s_stopLines);
773
774 couleur2 = 5-couleur1;
775 if (s_stopLines) {
776 s_stopLines--;
777 if (iRAND(2))
778 couleur2=couleur1 = GML_BLACK;
779 }
780
781 goom_lines_switch_to (gmline1, mode, param1, amplitude, couleur1);
782 goom_lines_switch_to (gmline2, mode, param2, amplitude, couleur2);
783 }
784 }
785
786 /*
787 * si on est dans un goom : afficher les lignes...
788 */
789 if ((s_lineMode != 0) || (s_aGoom > 15)) {
790 gmline2->power = gmline1->power;
791
792 goom_lines_draw (gmline1, data[0], p2 + c_offset);
793 goom_lines_draw (gmline2, data[1], p2 + c_offset);
794
795 if (((cycle % 121) == 9) && (iRAND (3) == 1)
796 && ((s_lineMode == 0) || (s_lineMode == DRAWLINES))) {
797 float param1 = NAN;
798 float param2 = NAN;
799 float amplitude = NAN;
800 int couleur1 = 0;
801 int couleur2 = 0;
802 int mode = 0;
803
804 choose_a_goom_line (&param1, &param2, &couleur1, &mode, &amplitude, s_stopLines);
805 couleur2 = 5-couleur1;
806
807 if (s_stopLines) {
808 s_stopLines--;
809 if (iRAND(2))
810 couleur2=couleur1 = GML_BLACK;
811 }
812 goom_lines_switch_to (gmline1, mode, param1, amplitude, couleur1);
813 goom_lines_switch_to (gmline2, mode, param2, amplitude, couleur2);
814 }
815 }
816
817 guint32 *return_val = p1;
818 tmp = p1;
819 p1 = p2;
820 p2 = tmp;
821
822 // affichage et swappage des buffers..
823 cycle++;
824
825 // toute les 2 secondes : vérifier si le taux de goom est correct
826 // et le modifier sinon..
827 if (!(cycle % 64)) {
828 if (s_speedVar<1)
829 s_goomLimit /= 2;
830 if (s_totalGoom > 4) {
831 s_goomLimit++;
832 }
833 if (s_totalGoom > 7) {
834 s_goomLimit*=4/3;
835 s_goomLimit+=2;
836 }
837 if ((s_totalGoom == 0) && (s_goomLimit > 1))
838 s_goomLimit--;
839 if ((s_totalGoom == 1) && (s_goomLimit > 1))
840 s_goomLimit--;
841 s_totalGoom = 0;
842 }
843 return return_val;
844}
845
846void goom_close () {
847 if (pixel != nullptr)
848 free (pixel);
849 if (back != nullptr)
850 free (back);
851 pixel = back = nullptr;
852 RAND_CLOSE ();
853 release_ifs ();
854 goom_lines_free (&gmline1);
855 goom_lines_free (&gmline2);
856 tentacle_free();
857}
858
859
860void choose_a_goom_line (float *param1, float *param2, int *couleur, int *mode, float *amplitude, int far) {
861 *mode = iRAND (3);
862 *amplitude = 1.0F;
863 switch (*mode) {
864 case GML_CIRCLE:
865 if (far) {
866 *param1 = *param2 = 0.47F;
867 *amplitude = 0.8F;
868 break;
869 }
870 if (iRAND (3) == 0) {
871 *param1 = *param2 = 0;
872 *amplitude = 3.0F;
873 }
874 else if (iRAND (2)) {
875 *param1 = 0.40F * c_resoly;
876 *param2 = 0.22F * c_resoly;
877 }
878 else {
879 *param1 = *param2 = c_resoly * 0.35F;
880 }
881 break;
882 case GML_HLINE:
883 if (iRAND (4) || far) {
884 *param1 = c_resoly / 7.0F;
885 *param2 = 6.0F * c_resoly / 7.0F;
886 }
887 else {
888 *param1 = *param2 = c_resoly / 2.0F;
889 *amplitude = 2.0F;
890 }
891 break;
892 case GML_VLINE:
893 if (iRAND (3) || far) {
894 *param1 = resolx / 7.0F;
895 *param2 = 6.0F * resolx / 7.0F;
896 }
897 else {
898 *param1 = *param2 = resolx / 2.0F;
899 *amplitude = 1.5F;
900 }
901 break;
902 }
903
904 *couleur = iRAND (6);
905}
906
907/*
908void goom_set_font (int ***chars, int *width, int *height) {
909 if (chars == nullptr)
910 return ;
911}
912*/
913
914/*
915void update_message (char *message) {
916
917 static int nbl;
918 static char msg2 [0x800];
919 static int affiche = 0;
920 static int longueur;
921 int fin = 0;
922
923 if (message) {
924 int i=1,j=0;
925 sprintf (msg2,message);
926 for (j=0;msg2[j];j++)
927 if (msg2[j]=='\n')
928 i++;
929 nbl = i;
930 affiche = resoly + nbl * 25 + 105;
931 longueur = strlen (msg2);
932 }
933 if (affiche) {
934 int i = 0;
935 char *msg=malloc(longueur+1);
936 char *ptr = msg;
937 int pos;
938 float ecart;
939 message = msg;
940 sprintf (msg,msg2);
941
942 while (!fin) {
943 while (1) {
944 if (*ptr == 0) {
945 fin = 1;
946 break;
947 }
948 if (*ptr == '\n') {
949 *ptr = 0;
950 break;
951 }
952 ++ptr;
953 }
954 pos = affiche - (nbl-i)*25;
955 pos += 6.0*(cos((double)pos/20.0));
956 pos -= 80;
957 ecart = (1.0+2.0*sin((double)pos/20.0));
958 if ((fin) && (2 * pos < (int)resoly))
959 pos = (int)resoly / 2;
960 pos += 7;
961
962 goom_draw_text(p1 + c_offset,resolx,c_resoly, resolx/2, pos, message, ecart, 1);
963 message = ++ptr;
964 i++;
965 }
966 affiche --;
967 free (msg);
968 }
969}
970*/
971
972guint32 goom_rand (void)
973{
974 static std::random_device rd;
975 static std::mt19937 mt(rd());
976 return mt();
977}
zoomFilterFastRGB
void zoomFilterFastRGB(Uint *pix1, Uint *pix2, ZoomFilterData *zf, Uint resx, Uint resy, int switchIncr, float switchMult)
Definition: filters.cpp:490
pointFilter
void pointFilter(Uint *pix1, Color c, float t1, float t2, float t3, float t4, Uint cycle)
Definition: filters.cpp:721
YONLY_MODE
#define YONLY_MODE
Definition: filters.h:37
CRYSTAL_BALL_MODE
#define CRYSTAL_BALL_MODE
Definition: filters.h:31
HYPERCOS2_MODE
#define HYPERCOS2_MODE
Definition: filters.h:36
AMULETTE_MODE
#define AMULETTE_MODE
Definition: filters.h:33
WAVE_MODE
#define WAVE_MODE
Definition: filters.h:30
WATER_MODE
#define WATER_MODE
Definition: filters.h:34
NORMAL_MODE
#define NORMAL_MODE
Definition: filters.h:29
SCRUNCH_MODE
#define SCRUNCH_MODE
Definition: filters.h:32
SPEEDWAY_MODE
#define SPEEDWAY_MODE
Definition: filters.h:38
HYPERCOS1_MODE
#define HYPERCOS1_MODE
Definition: filters.h:35
back
static guint32 * back
Definition: goom_core.cpp:25
goom_init
void goom_init(guint32 resx, guint32 resy, int cinemascope)
Definition: goom_core.cpp:64
cycle
static guint32 cycle
Definition: goom_core.cpp:27
resolx
guint32 resolx
Definition: goom_core.cpp:56
gmline2
static GMLine * gmline2
Definition: goom_core.cpp:60
goom_set_resolution
void goom_set_resolution(guint32 resx, guint32 resy, int cinemascope)
Definition: goom_core.cpp:104
resoly
guint32 resoly
Definition: goom_core.cpp:56
STATES_NB
static constexpr size_t STATES_NB
Definition: goom_core.cpp:41
TIME_BTW_CHG
static constexpr int16_t TIME_BTW_CHG
Definition: goom_core.cpp:19
curGState
const GoomState * curGState
Definition: goom_core.cpp:54
gmline1
static GMLine * gmline1
Definition: goom_core.cpp:59
c_resoly
guint32 c_resoly
Definition: goom_core.cpp:56
choose_a_goom_line
void choose_a_goom_line(float *param1, float *param2, int *couleur, int *mode, float *amplitude, int far)
Definition: goom_core.cpp:860
pixel
static guint32 * pixel
--------------------------------------------------—**
Definition: goom_core.cpp:24
p2
static guint32 * p2
Definition: goom_core.cpp:26
buffsize
guint32 buffsize
Definition: goom_core.cpp:56
kStates
const std::array< const GoomState, STATES_NB > kStates
Definition: goom_core.cpp:43
goom_close
void goom_close()
Definition: goom_core.cpp:846
STOP_SPEED
static constexpr gint32 STOP_SPEED
Definition: goom_core.cpp:18
c_offset
guint32 c_offset
Definition: goom_core.cpp:56
STATES_RANGEMAX
static constexpr uint16_t STATES_RANGEMAX
Definition: goom_core.cpp:42
goom_update
guint32 * goom_update(GoomDualData &data, int forceMode)
Definition: goom_core.cpp:133
c_black_height
guint32 c_black_height
Definition: goom_core.cpp:56
goom_rand
guint32 goom_rand(void)
Definition: goom_core.cpp:972
p1
static guint32 * p1
Definition: goom_core.cpp:26
tmp
static guint32 * tmp
Definition: goom_core.cpp:26
goom_core.h
GoomDualData
std::array< GoomSingleData, 2 > GoomDualData
Definition: goom_core.h:13
NB_FX
#define NB_FX
Definition: goom_core.h:10
goom_tools.h
iRAND
static unsigned int iRAND(int i)
Definition: goom_tools.h:42
NB_RAND
static constexpr size_t NB_RAND
Definition: goom_tools.h:13
RAND_CLOSE
static void RAND_CLOSE()
Definition: goom_tools.h:35
rand_tab
int * rand_tab
Definition: graphic.cpp:16
rand_pos
static unsigned short rand_pos
Definition: goom_tools.h:17
gint32
#define gint32
Definition: goomconfig.h:38
VERT
#define VERT
Definition: goomconfig.h:12
ROUGE
#define ROUGE
position des composantes
Definition: goomconfig.h:10
guint32
#define guint32
Definition: goomconfig.h:35
BLEU
#define BLEU
Definition: goomconfig.h:11
ALPHA
#define ALPHA
Definition: goomconfig.h:13
VIOLET
const Color VIOLET
Definition: graphic.cpp:10
YELLOW
const Color YELLOW
Definition: graphic.cpp:8
WHITE
const Color WHITE
Definition: graphic.cpp:4
ORANGE
const Color ORANGE
Definition: graphic.cpp:9
BLACK
const Color BLACK
Definition: graphic.cpp:3
init_ifs
void init_ifs(int width, int height)
Definition: ifs.cpp:166
release_ifs
void release_ifs()
Definition: ifs.cpp:487
ifs_update
void ifs_update(guint32 *data, const guint32 *back, int width, int height, int increment)
Definition: ifs_display.cpp:13
uint16_t
unsigned short uint16_t
Definition: iso6937tables.h:3
goom_lines_set_res
void goom_lines_set_res(GMLine *gml, int rx, int ry)
Definition: lines.cpp:95
goom_lines_init
GMLine * goom_lines_init(int rx, int ry, int IDsrc, float paramS, int coulS, int IDdest, float paramD, int coulD)
Definition: lines.cpp:154
goom_lines_switch_to
void goom_lines_switch_to(GMLine *gml, int IDdest, float param, float amplitude, int col)
Definition: lines.cpp:142
goom_lines_draw
void goom_lines_draw(GMLine *line, const GoomSingleData &data, unsigned int *p)
Definition: lines.cpp:200
goom_lines_free
void goom_lines_free(GMLine **l)
Definition: lines.cpp:191
GML_BLACK
#define GML_BLACK
Definition: lines.h:59
GML_RED
#define GML_RED
Definition: lines.h:54
GML_CIRCLE
#define GML_CIRCLE
Definition: lines.h:42
GML_HLINE
#define GML_HLINE
Definition: lines.h:45
GML_VLINE
#define GML_VLINE
Definition: lines.h:48
GML_VERT
#define GML_VERT
Definition: lines.h:57
clamp
static eu8 clamp(eu8 value, eu8 low, eu8 high)
Definition: pxsup2dast.c:206
GMLine
Definition: lines.h:22
GMLine::power
float power
Definition: lines.h:37
GoomState::m_drawTentacle
int m_drawTentacle
Definition: goom_core.cpp:32
GoomState::m_rangeMax
int m_rangeMax
Definition: goom_core.cpp:38
GoomState::m_drawIfs
int m_drawIfs
Definition: goom_core.cpp:30
GoomState::m_rangeMin
int m_rangeMin
Definition: goom_core.cpp:37
GoomState::m_drawScope
int m_drawScope
Definition: goom_core.cpp:34
GoomState::m_drawPoints
int m_drawPoints
Definition: goom_core.cpp:31
GoomState::m_farScope
int m_farScope
Definition: goom_core.cpp:35
ZoomFilterData::hypercosEffect
bool hypercosEffect
Definition: filters.h:23
ZoomFilterData::pertedec
unsigned char pertedec
Definition: filters.h:13
ZoomFilterData::waveEffect
bool waveEffect
Definition: filters.h:22
ZoomFilterData::vPlaneEffect
int vPlaneEffect
Definition: filters.h:20
ZoomFilterData::noisify
char noisify
Definition: filters.h:25
ZoomFilterData::reverse
bool reverse
Definition: filters.h:16
ZoomFilterData::hPlaneEffect
int hPlaneEffect
Definition: filters.h:19
ZoomFilterData::sqrtperte
unsigned char sqrtperte
Definition: filters.h:14
tentacle_new
void tentacle_new(void)
Definition: tentacle3d.cpp:28
tentacle_free
void tentacle_free(void)
Definition: tentacle3d.cpp:21
tentacle_update
void tentacle_update(int *buf, int *back, int W, int H, GoomDualData &data, float rapport, int drawit)
Definition: tentacle3d.cpp:142
Generated on Sun Dec 14 2025 03:16:47 for MythTV by doxygen 1.9.4