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