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 
18 static constexpr gint32 STOP_SPEED { 128 };
19 static constexpr int16_t TIME_BTW_CHG { 300 };
20 
24 static guint32 *pixel;
25 static guint32 *back;
26 static guint32 *p1, *p2, *tmp;
27 static guint32 cycle;
28 
29 struct 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 
41 static constexpr size_t STATES_NB { 8 };
42 static constexpr uint16_t STATES_RANGEMAX { 510 };
43 const 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 
54 const GoomState *curGState = &kStates[4];
55 
56 guint32 resolx, resoly, buffsize, c_black_height = 0, c_offset = 0, c_resoly = 0; /* avec prise en compte de ca */
57 
58 // effet de ligne..
59 static GMLine *gmline1 = nullptr;
60 static GMLine *gmline2 = nullptr;
61 
62 void choose_a_goom_line (float *param1, float *param2, int *couleur, int *mode, float *amplitude, int far);
63 
64 void 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 
104 void 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 
133 guint32 * 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 
846 void 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 
860 void 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.35;
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 /*
908 void goom_set_font (int ***chars, int *width, int *height) {
909  if (chars == nullptr)
910  return ;
911 }
912 */
913 
914 /*
915 void 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 
972 guint32 goom_rand (void)
973 {
974  static std::random_device rd;
975  static std::mt19937 mt(rd());
976  return mt();
977 }
GoomDualData
std::array< GoomSingleData, 2 > GoomDualData
Definition: goom_core.h:13
buffsize
guint32 buffsize
Definition: goom_core.cpp:56
lines.h
VIOLET
const Color VIOLET
Definition: graphic.cpp:10
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
back
static guint32 * back
Definition: goom_core.cpp:25
gint32
#define gint32
Definition: goomconfig.h:38
ZoomFilterData::sqrtperte
unsigned char sqrtperte
Definition: filters.h:14
goom_lines_switch_to
void goom_lines_switch_to(GMLine *gml, int IDdest, float param, float amplitude, int col)
Definition: lines.cpp:142
GML_CIRCLE
#define GML_CIRCLE
Definition: lines.h:42
gmline2
static GMLine * gmline2
Definition: goom_core.cpp:60
GoomState::m_drawPoints
int m_drawPoints
Definition: goom_core.cpp:31
GML_BLACK
#define GML_BLACK
Definition: lines.h:59
ifs_update
void ifs_update(guint32 *data, const guint32 *back, int width, int height, int increment)
Definition: ifs_display.cpp:13
NORMAL_MODE
#define NORMAL_MODE
Definition: filters.h:29
ZoomFilterData::reverse
bool reverse
Definition: filters.h:16
pointFilter
void pointFilter(Uint *pix1, Color c, float t1, float t2, float t3, float t4, Uint cycle)
Definition: filters.cpp:721
ZoomFilterData::waveEffect
bool waveEffect
Definition: filters.h:22
pixel
static guint32 * pixel
--------------------------------------------------—**
Definition: goom_core.cpp:24
GMLine::power
float power
Definition: lines.h:37
goom_lines_free
void goom_lines_free(GMLine **l)
Definition: lines.cpp:191
GoomState::m_rangeMin
int m_rangeMin
Definition: goom_core.cpp:37
GoomState
Definition: goom_core.cpp:29
goom_set_resolution
void goom_set_resolution(guint32 resx, guint32 resy, int cinemascope)
Definition: goom_core.cpp:104
tmp
static guint32 * tmp
Definition: goom_core.cpp:26
GML_HLINE
#define GML_HLINE
Definition: lines.h:45
resoly
guint32 resoly
Definition: goom_core.cpp:56
GML_RED
#define GML_RED
Definition: lines.h:54
goom_lines_set_res
void goom_lines_set_res(GMLine *gml, int rx, int ry)
Definition: lines.cpp:95
filters.h
ZoomFilterData::vitesse
int vitesse
Definition: filters.h:11
zoomFilterFastRGB
void zoomFilterFastRGB(Uint *pix1, Uint *pix2, ZoomFilterData *zf, Uint resx, Uint resy, int switchIncr, float switchMult)
Definition: filters.cpp:490
ZoomFilterData::noisify
char noisify
Definition: filters.h:25
STATES_NB
static constexpr size_t STATES_NB
Definition: goom_core.cpp:41
resolx
guint32 resolx
Definition: goom_core.cpp:56
tentacle_free
void tentacle_free(void)
Definition: tentacle3d.cpp:21
tentacle_new
void tentacle_new(void)
Definition: tentacle3d.cpp:28
goom_lines_draw
void goom_lines_draw(GMLine *line, const GoomSingleData &data, unsigned int *p)
Definition: lines.cpp:200
tentacle_update
void tentacle_update(int *buf, int *back, int W, int H, GoomDualData &data, float rapport, int drawit)
Definition: tentacle3d.cpp:142
ifs.h
ZoomFilterData::hypercosEffect
bool hypercosEffect
Definition: filters.h:23
goom_rand
guint32 goom_rand(void)
Definition: goom_core.cpp:972
WAVE_MODE
#define WAVE_MODE
Definition: filters.h:30
tentacle3d.h
GML_VLINE
#define GML_VLINE
Definition: lines.h:48
GoomState::m_drawIfs
int m_drawIfs
Definition: goom_core.cpp:30
goom_core.h
p2
static guint32 * p2
Definition: goom_core.cpp:26
ZoomFilterData::pertedec
unsigned char pertedec
Definition: filters.h:13
GML_VERT
#define GML_VERT
Definition: lines.h:57
GoomState::m_drawTentacle
int m_drawTentacle
Definition: goom_core.cpp:32
NB_RAND
static constexpr size_t NB_RAND
Definition: goom_tools.h:13
c_offset
guint32 c_offset
Definition: goom_core.cpp:56
CRYSTAL_BALL_MODE
#define CRYSTAL_BALL_MODE
Definition: filters.h:31
gmline1
static GMLine * gmline1
Definition: goom_core.cpp:59
NB_FX
#define NB_FX
Definition: goom_core.h:10
kStates
const std::array< const GoomState, STATES_NB > kStates
Definition: goom_core.cpp:43
GMLine
Definition: lines.h:21
goom_init
void goom_init(guint32 resx, guint32 resy, int cinemascope)
Definition: goom_core.cpp:64
SCRUNCH_MODE
#define SCRUNCH_MODE
Definition: filters.h:32
clamp
static eu8 clamp(eu8 value, eu8 low, eu8 high)
Definition: pxsup2dast.c:204
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
p1
static guint32 * p1
Definition: goom_core.cpp:26
iRAND
static unsigned int iRAND(int i)
Definition: goom_tools.h:42
BLACK
const Color BLACK
Definition: graphic.cpp:3
GoomState::m_rangeMax
int m_rangeMax
Definition: goom_core.cpp:38
TIME_BTW_CHG
static constexpr int16_t TIME_BTW_CHG
Definition: goom_core.cpp:19
goom_update
guint32 * goom_update(GoomDualData &data, int forceMode)
Definition: goom_core.cpp:133
YONLY_MODE
#define YONLY_MODE
Definition: filters.h:37
goom_close
void goom_close()
Definition: goom_core.cpp:846
STOP_SPEED
static constexpr gint32 STOP_SPEED
Definition: goom_core.cpp:18
ZoomFilterData
Definition: filters.h:9
rand_pos
static unsigned short rand_pos
Definition: goom_tools.h:17
ZoomFilterData::middleX
int middleX
Definition: filters.h:15
BLEU
#define BLEU
Definition: goomconfig.h:11
ORANGE
const Color ORANGE
Definition: graphic.cpp:9
cycle
static guint32 cycle
Definition: goom_core.cpp:27
goom_tools.h
ROUGE
#define ROUGE
position des composantes
Definition: goomconfig.h:10
rand_tab
int * rand_tab
Definition: graphic.cpp:16
WATER_MODE
#define WATER_MODE
Definition: filters.h:34
HYPERCOS2_MODE
#define HYPERCOS2_MODE
Definition: filters.h:36
AMULETTE_MODE
#define AMULETTE_MODE
Definition: filters.h:33
c_resoly
guint32 c_resoly
Definition: goom_core.cpp:56
ZoomFilterData::vPlaneEffect
int vPlaneEffect
Definition: filters.h:20
ZoomFilterData::mode
char mode
Definition: filters.h:17
VERT
#define VERT
Definition: goomconfig.h:12
RAND_CLOSE
static void RAND_CLOSE()
Definition: goom_tools.h:35
release_ifs
void release_ifs()
Definition: ifs.cpp:487
uint16_t
unsigned short uint16_t
Definition: iso6937tables.h:3
guint32
#define guint32
Definition: goomconfig.h:35
STATES_RANGEMAX
static constexpr uint16_t STATES_RANGEMAX
Definition: goom_core.cpp:42
GoomState::m_drawScope
int m_drawScope
Definition: goom_core.cpp:34
SPEEDWAY_MODE
#define SPEEDWAY_MODE
Definition: filters.h:38
c_black_height
guint32 c_black_height
Definition: goom_core.cpp:56
ZoomFilterData::hPlaneEffect
int hPlaneEffect
Definition: filters.h:19
HYPERCOS1_MODE
#define HYPERCOS1_MODE
Definition: filters.h:35
curGState
const GoomState * curGState
Definition: goom_core.cpp:54
WHITE
const Color WHITE
Definition: graphic.cpp:4
init_ifs
void init_ifs(int width, int height)
Definition: ifs.cpp:166
ALPHA
#define ALPHA
Definition: goomconfig.h:13
YELLOW
const Color YELLOW
Definition: graphic.cpp:8
GoomState::m_farScope
int m_farScope
Definition: goom_core.cpp:35
ZoomFilterData::middleY
int middleY
Definition: filters.h:15
Generated on Thu Feb 6 2025 03:17:19 for MythTV by   doxygen 1.8.17