/xbmc/visualizations/Goom/goom2k4-0/src/goom_core.c

http://github.com/xbmc/xbmc · C · 895 lines · 673 code · 125 blank · 97 comment · 172 complexity · 958484eaa81db35e20ca48a89aea4453 MD5 · raw file

  1. /**
  2. * file: goom_core.c
  3. * author: Jean-Christophe Hoelt (which is not so proud of it)
  4. *
  5. * Contains the core of goom's work.
  6. *
  7. * (c)2000-2003, by iOS-software.
  8. */
  9. #include <math.h>
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <inttypes.h>
  14. #include "goom.h"
  15. #include "goom_tools.h"
  16. #include "goom_filters.h"
  17. #include "lines.h"
  18. #include "ifs.h"
  19. #include "tentacle3d.h"
  20. #include "gfontlib.h"
  21. #include "sound_tester.h"
  22. #include "goom_plugin_info.h"
  23. #include "goom_fx.h"
  24. #include "goomsl.h"
  25. /* #define VERBOSE */
  26. #define STOP_SPEED 128
  27. /* TODO: put that as variable in PluginInfo */
  28. #define TIME_BTW_CHG 300
  29. static void choose_a_goom_line (PluginInfo *goomInfo, float *param1, float *param2, int *couleur,
  30. int *mode, float *amplitude, int far);
  31. static void update_message (PluginInfo *goomInfo, char *message);
  32. static void init_buffers(PluginInfo *goomInfo, int buffsize)
  33. {
  34. goomInfo->pixel = (guint32 *) malloc (buffsize * sizeof (guint32) + 128);
  35. bzero (goomInfo->pixel, buffsize * sizeof (guint32) + 128);
  36. goomInfo->back = (guint32 *) malloc (buffsize * sizeof (guint32) + 128);
  37. bzero (goomInfo->back, buffsize * sizeof (guint32) + 128);
  38. goomInfo->conv = (Pixel *) malloc (buffsize * sizeof (guint32) + 128);
  39. bzero (goomInfo->conv, buffsize * sizeof (guint32) + 128);
  40. goomInfo->outputBuf = goomInfo->conv;
  41. goomInfo->p1 = (Pixel *) ((1 + ((uintptr_t) (goomInfo->pixel)) / 128) * 128);
  42. goomInfo->p2 = (Pixel *) ((1 + ((uintptr_t) (goomInfo->back)) / 128) * 128);
  43. }
  44. /**************************
  45. * INIT *
  46. **************************/
  47. PluginInfo *goom_init (guint32 resx, guint32 resy)
  48. {
  49. PluginInfo *goomInfo = (PluginInfo*)malloc(sizeof(PluginInfo));
  50. #ifdef VERBOSE
  51. printf ("GOOM: init (%d, %d);\n", resx, resy);
  52. #endif
  53. plugin_info_init(goomInfo,4);
  54. goomInfo->star_fx = flying_star_create();
  55. goomInfo->star_fx.init(&goomInfo->star_fx, goomInfo);
  56. goomInfo->zoomFilter_fx = zoomFilterVisualFXWrapper_create ();
  57. goomInfo->zoomFilter_fx.init(&goomInfo->zoomFilter_fx, goomInfo);
  58. goomInfo->tentacles_fx = tentacle_fx_create();
  59. goomInfo->tentacles_fx.init(&goomInfo->tentacles_fx, goomInfo);
  60. goomInfo->convolve_fx = convolve_create();
  61. goomInfo->convolve_fx.init(&goomInfo->convolve_fx, goomInfo);
  62. plugin_info_add_visual (goomInfo, 0, &goomInfo->zoomFilter_fx);
  63. plugin_info_add_visual (goomInfo, 1, &goomInfo->tentacles_fx);
  64. plugin_info_add_visual (goomInfo, 2, &goomInfo->star_fx);
  65. plugin_info_add_visual (goomInfo, 3, &goomInfo->convolve_fx);
  66. goomInfo->screen.width = resx;
  67. goomInfo->screen.height = resy;
  68. goomInfo->screen.size = resx * resy;
  69. init_buffers(goomInfo, goomInfo->screen.size);
  70. goomInfo->gRandom = goom_random_init((uintptr_t)goomInfo->pixel);
  71. goomInfo->cycle = 0;
  72. goomInfo->ifs_fx = ifs_visualfx_create();
  73. goomInfo->ifs_fx.init(&goomInfo->ifs_fx, goomInfo);
  74. goomInfo->gmline1 = goom_lines_init (goomInfo, resx, goomInfo->screen.height,
  75. GML_HLINE, goomInfo->screen.height, GML_BLACK,
  76. GML_CIRCLE, 0.4f * (float) goomInfo->screen.height, GML_VERT);
  77. goomInfo->gmline2 = goom_lines_init (goomInfo, resx, goomInfo->screen.height,
  78. GML_HLINE, 0, GML_BLACK,
  79. GML_CIRCLE, 0.2f * (float) goomInfo->screen.height, GML_RED);
  80. gfont_load ();
  81. /* goom_set_main_script(goomInfo, goomInfo->main_script_str); */
  82. return goomInfo;
  83. }
  84. void goom_set_resolution (PluginInfo *goomInfo, guint32 resx, guint32 resy)
  85. {
  86. free (goomInfo->pixel);
  87. free (goomInfo->back);
  88. free (goomInfo->conv);
  89. goomInfo->screen.width = resx;
  90. goomInfo->screen.height = resy;
  91. goomInfo->screen.size = resx * resy;
  92. init_buffers(goomInfo, goomInfo->screen.size);
  93. /* init_ifs (goomInfo, resx, goomInfo->screen.height); */
  94. goomInfo->ifs_fx.free(&goomInfo->ifs_fx);
  95. goomInfo->ifs_fx.init(&goomInfo->ifs_fx, goomInfo);
  96. goom_lines_set_res (goomInfo->gmline1, resx, goomInfo->screen.height);
  97. goom_lines_set_res (goomInfo->gmline2, resx, goomInfo->screen.height);
  98. }
  99. int goom_set_screenbuffer(PluginInfo *goomInfo, void *buffer)
  100. {
  101. goomInfo->outputBuf = (Pixel*)buffer;
  102. return 1;
  103. }
  104. /********************************************
  105. * UPDATE *
  106. ********************************************
  107. * WARNING: this is a 600 lines function ! (21-11-2003)
  108. */
  109. guint32 *goom_update (PluginInfo *goomInfo, gint16 data[2][512],
  110. int forceMode, float fps, char *songTitle, char *message)
  111. {
  112. Pixel *return_val;
  113. guint32 pointWidth;
  114. guint32 pointHeight;
  115. int i;
  116. float largfactor; /* elargissement de l'intervalle d'évolution des points */
  117. Pixel *tmp;
  118. ZoomFilterData *pzfd;
  119. /* test if the config has changed, update it if so */
  120. pointWidth = (goomInfo->screen.width * 2) / 5;
  121. pointHeight = ((goomInfo->screen.height) * 2) / 5;
  122. /* ! etude du signal ... */
  123. evaluate_sound (data, &(goomInfo->sound));
  124. /* goom_execute_main_script(goomInfo); */
  125. /* ! calcul du deplacement des petits points ... */
  126. largfactor = goomInfo->sound.speedvar / 150.0f + goomInfo->sound.volume / 1.5f;
  127. if (largfactor > 1.5f)
  128. largfactor = 1.5f;
  129. goomInfo->update.decay_ifs--;
  130. if (goomInfo->update.decay_ifs > 0)
  131. goomInfo->update.ifs_incr += 2;
  132. if (goomInfo->update.decay_ifs == 0)
  133. goomInfo->update.ifs_incr = 0;
  134. if (goomInfo->update.recay_ifs) {
  135. goomInfo->update.ifs_incr -= 2;
  136. goomInfo->update.recay_ifs--;
  137. if ((goomInfo->update.recay_ifs == 0)&&(goomInfo->update.ifs_incr<=0))
  138. goomInfo->update.ifs_incr = 1;
  139. }
  140. if (goomInfo->update.ifs_incr > 0)
  141. goomInfo->ifs_fx.apply(&goomInfo->ifs_fx, goomInfo->p2, goomInfo->p1, goomInfo);
  142. if (goomInfo->curGState->drawPoints) {
  143. for (i = 1; i * 15 <= goomInfo->sound.speedvar*80.0f + 15; i++) {
  144. goomInfo->update.loopvar += goomInfo->sound.speedvar*50 + 1;
  145. pointFilter (goomInfo, goomInfo->p1,
  146. YELLOW,
  147. ((pointWidth - 6.0f) * largfactor + 5.0f),
  148. ((pointHeight - 6.0f) * largfactor + 5.0f),
  149. i * 152.0f, 128.0f, goomInfo->update.loopvar + i * 2032);
  150. pointFilter (goomInfo, goomInfo->p1, ORANGE,
  151. ((pointWidth / 2) * largfactor) / i + 10.0f * i,
  152. ((pointHeight / 2) * largfactor) / i + 10.0f * i,
  153. 96.0f, i * 80.0f, goomInfo->update.loopvar / i);
  154. pointFilter (goomInfo, goomInfo->p1, VIOLET,
  155. ((pointHeight / 3 + 5.0f) * largfactor) / i + 10.0f * i,
  156. ((pointHeight / 3 + 5.0f) * largfactor) / i + 10.0f * i,
  157. i + 122.0f, 134.0f, goomInfo->update.loopvar / i);
  158. pointFilter (goomInfo, goomInfo->p1, BLACK,
  159. ((pointHeight / 3) * largfactor + 20.0f),
  160. ((pointHeight / 3) * largfactor + 20.0f),
  161. 58.0f, i * 66.0f, goomInfo->update.loopvar / i);
  162. pointFilter (goomInfo, goomInfo->p1, WHITE,
  163. (pointHeight * largfactor + 10.0f * i) / i,
  164. (pointHeight * largfactor + 10.0f * i) / i,
  165. 66.0f, 74.0f, goomInfo->update.loopvar + i * 500);
  166. }
  167. }
  168. /* par défaut pas de changement de zoom */
  169. pzfd = NULL;
  170. /*
  171. * Test forceMode
  172. */
  173. #ifdef VERBOSE
  174. if (forceMode != 0) {
  175. printf ("forcemode = %d\n", forceMode);
  176. }
  177. #endif
  178. /* diminuer de 1 le temps de lockage */
  179. /* note pour ceux qui n'ont pas suivis : le lockvar permet d'empecher un */
  180. /* changement d'etat du plugin juste apres un autre changement d'etat. oki */
  181. if (--goomInfo->update.lockvar < 0)
  182. goomInfo->update.lockvar = 0;
  183. /* on verifie qu'il ne se pas un truc interressant avec le son. */
  184. if ((goomInfo->sound.timeSinceLastGoom == 0)
  185. || (forceMode > 0)
  186. || (goomInfo->update.cyclesSinceLastChange > TIME_BTW_CHG)) {
  187. /* changement eventuel de mode */
  188. if (goom_irand(goomInfo->gRandom,16) == 0)
  189. switch (goom_irand(goomInfo->gRandom,34)) {
  190. case 0:
  191. case 10:
  192. goomInfo->update.zoomFilterData.hypercosEffect = goom_irand(goomInfo->gRandom,2);
  193. case 13:
  194. case 20:
  195. case 21:
  196. goomInfo->update.zoomFilterData.mode = WAVE_MODE;
  197. goomInfo->update.zoomFilterData.reverse = 0;
  198. goomInfo->update.zoomFilterData.waveEffect = (goom_irand(goomInfo->gRandom,3) == 0);
  199. if (goom_irand(goomInfo->gRandom,2))
  200. goomInfo->update.zoomFilterData.vitesse = (goomInfo->update.zoomFilterData.vitesse + 127) >> 1;
  201. break;
  202. case 1:
  203. case 11:
  204. goomInfo->update.zoomFilterData.mode = CRYSTAL_BALL_MODE;
  205. goomInfo->update.zoomFilterData.waveEffect = 0;
  206. goomInfo->update.zoomFilterData.hypercosEffect = 0;
  207. break;
  208. case 2:
  209. case 12:
  210. goomInfo->update.zoomFilterData.mode = AMULETTE_MODE;
  211. goomInfo->update.zoomFilterData.waveEffect = 0;
  212. goomInfo->update.zoomFilterData.hypercosEffect = 0;
  213. break;
  214. case 3:
  215. goomInfo->update.zoomFilterData.mode = WATER_MODE;
  216. goomInfo->update.zoomFilterData.waveEffect = 0;
  217. goomInfo->update.zoomFilterData.hypercosEffect = 0;
  218. break;
  219. case 4:
  220. case 14:
  221. goomInfo->update.zoomFilterData.mode = SCRUNCH_MODE;
  222. goomInfo->update.zoomFilterData.waveEffect = 0;
  223. goomInfo->update.zoomFilterData.hypercosEffect = 0;
  224. break;
  225. case 5:
  226. case 15:
  227. case 22:
  228. goomInfo->update.zoomFilterData.mode = HYPERCOS1_MODE;
  229. goomInfo->update.zoomFilterData.waveEffect = 0;
  230. goomInfo->update.zoomFilterData.hypercosEffect = (goom_irand(goomInfo->gRandom,3) == 0);
  231. break;
  232. case 6:
  233. case 16:
  234. goomInfo->update.zoomFilterData.mode = HYPERCOS2_MODE;
  235. goomInfo->update.zoomFilterData.waveEffect = 0;
  236. goomInfo->update.zoomFilterData.hypercosEffect = 0;
  237. break;
  238. case 7:
  239. case 17:
  240. goomInfo->update.zoomFilterData.mode = CRYSTAL_BALL_MODE;
  241. goomInfo->update.zoomFilterData.waveEffect = (goom_irand(goomInfo->gRandom,4) == 0);
  242. goomInfo->update.zoomFilterData.hypercosEffect = goom_irand(goomInfo->gRandom,2);
  243. break;
  244. case 8:
  245. case 18:
  246. case 19:
  247. goomInfo->update.zoomFilterData.mode = SCRUNCH_MODE;
  248. goomInfo->update.zoomFilterData.waveEffect = 1;
  249. goomInfo->update.zoomFilterData.hypercosEffect = 1;
  250. break;
  251. case 29:
  252. case 30:
  253. goomInfo->update.zoomFilterData.mode = YONLY_MODE;
  254. break;
  255. case 31:
  256. case 32:
  257. case 33:
  258. goomInfo->update.zoomFilterData.mode = SPEEDWAY_MODE;
  259. break;
  260. default:
  261. goomInfo->update.zoomFilterData.mode = NORMAL_MODE;
  262. goomInfo->update.zoomFilterData.waveEffect = 0;
  263. goomInfo->update.zoomFilterData.hypercosEffect = 0;
  264. }
  265. }
  266. /* tout ceci ne sera fait qu'en cas de non-blocage */
  267. if (goomInfo->update.lockvar == 0) {
  268. /* reperage de goom (acceleration forte de l'acceleration du volume) */
  269. /* -> coup de boost de la vitesse si besoin.. */
  270. if (goomInfo->sound.timeSinceLastGoom == 0) {
  271. int i;
  272. goomInfo->update.goomvar++;
  273. /* SELECTION OF THE GOOM STATE */
  274. if ((!goomInfo->update.stateSelectionBlocker)&&(goom_irand(goomInfo->gRandom,3))) {
  275. goomInfo->update.stateSelectionRnd = goom_irand(goomInfo->gRandom,goomInfo->statesRangeMax);
  276. goomInfo->update.stateSelectionBlocker = 3;
  277. }
  278. else if (goomInfo->update.stateSelectionBlocker) goomInfo->update.stateSelectionBlocker--;
  279. for (i=0;i<goomInfo->statesNumber;i++)
  280. if ((goomInfo->update.stateSelectionRnd >= goomInfo->states[i].rangemin)
  281. && (goomInfo->update.stateSelectionRnd <= goomInfo->states[i].rangemax))
  282. goomInfo->curGState = &(goomInfo->states[i]);
  283. if ((goomInfo->curGState->drawIFS) && (goomInfo->update.ifs_incr<=0)) {
  284. goomInfo->update.recay_ifs = 5;
  285. goomInfo->update.ifs_incr = 11;
  286. }
  287. if ((!goomInfo->curGState->drawIFS) && (goomInfo->update.ifs_incr>0) && (goomInfo->update.decay_ifs<=0))
  288. goomInfo->update.decay_ifs = 100;
  289. if (!goomInfo->curGState->drawScope)
  290. goomInfo->update.stop_lines = 0xf000 & 5;
  291. if (!goomInfo->curGState->drawScope) {
  292. goomInfo->update.stop_lines = 0;
  293. goomInfo->update.lineMode = goomInfo->update.drawLinesDuration;
  294. }
  295. /* if (goomInfo->update.goomvar % 1 == 0) */
  296. {
  297. guint32 vtmp;
  298. guint32 newvit;
  299. goomInfo->update.lockvar = 50;
  300. newvit = STOP_SPEED + 1 - ((float)3.5f * log10(goomInfo->sound.speedvar * 60 + 1));
  301. /* retablir le zoom avant.. */
  302. if ((goomInfo->update.zoomFilterData.reverse) && (!(goomInfo->cycle % 13)) && (rand () % 5 == 0)) {
  303. goomInfo->update.zoomFilterData.reverse = 0;
  304. goomInfo->update.zoomFilterData.vitesse = STOP_SPEED - 2;
  305. goomInfo->update.lockvar = 75;
  306. }
  307. if (goom_irand(goomInfo->gRandom,10) == 0) {
  308. goomInfo->update.zoomFilterData.reverse = 1;
  309. goomInfo->update.lockvar = 100;
  310. }
  311. if (goom_irand(goomInfo->gRandom,10) == 0)
  312. goomInfo->update.zoomFilterData.vitesse = STOP_SPEED - 1;
  313. if (goom_irand(goomInfo->gRandom,12) == 0)
  314. goomInfo->update.zoomFilterData.vitesse = STOP_SPEED + 1;
  315. /* changement de milieu.. */
  316. switch (goom_irand(goomInfo->gRandom,25)) {
  317. case 0:
  318. case 3:
  319. case 6:
  320. goomInfo->update.zoomFilterData.middleY = goomInfo->screen.height - 1;
  321. goomInfo->update.zoomFilterData.middleX = goomInfo->screen.width / 2;
  322. break;
  323. case 1:
  324. case 4:
  325. goomInfo->update.zoomFilterData.middleX = goomInfo->screen.width - 1;
  326. break;
  327. case 2:
  328. case 5:
  329. goomInfo->update.zoomFilterData.middleX = 1;
  330. break;
  331. default:
  332. goomInfo->update.zoomFilterData.middleY = goomInfo->screen.height / 2;
  333. goomInfo->update.zoomFilterData.middleX = goomInfo->screen.width / 2;
  334. }
  335. if ((goomInfo->update.zoomFilterData.mode == WATER_MODE)
  336. || (goomInfo->update.zoomFilterData.mode == YONLY_MODE)
  337. || (goomInfo->update.zoomFilterData.mode == AMULETTE_MODE)) {
  338. goomInfo->update.zoomFilterData.middleX = goomInfo->screen.width / 2;
  339. goomInfo->update.zoomFilterData.middleY = goomInfo->screen.height / 2;
  340. }
  341. switch (vtmp = (goom_irand(goomInfo->gRandom,15))) {
  342. case 0:
  343. goomInfo->update.zoomFilterData.vPlaneEffect = goom_irand(goomInfo->gRandom,3)
  344. - goom_irand(goomInfo->gRandom,3);
  345. goomInfo->update.zoomFilterData.hPlaneEffect = goom_irand(goomInfo->gRandom,3)
  346. - goom_irand(goomInfo->gRandom,3);
  347. break;
  348. case 3:
  349. goomInfo->update.zoomFilterData.vPlaneEffect = 0;
  350. goomInfo->update.zoomFilterData.hPlaneEffect = goom_irand(goomInfo->gRandom,8)
  351. - goom_irand(goomInfo->gRandom,8);
  352. break;
  353. case 4:
  354. case 5:
  355. case 6:
  356. case 7:
  357. goomInfo->update.zoomFilterData.vPlaneEffect = goom_irand(goomInfo->gRandom,5)
  358. - goom_irand(goomInfo->gRandom,5);
  359. goomInfo->update.zoomFilterData.hPlaneEffect = -goomInfo->update.zoomFilterData.vPlaneEffect;
  360. break;
  361. case 8:
  362. goomInfo->update.zoomFilterData.hPlaneEffect = 5 + goom_irand(goomInfo->gRandom,8);
  363. goomInfo->update.zoomFilterData.vPlaneEffect = -goomInfo->update.zoomFilterData.hPlaneEffect;
  364. break;
  365. case 9:
  366. goomInfo->update.zoomFilterData.vPlaneEffect = 5 + goom_irand(goomInfo->gRandom,8);
  367. goomInfo->update.zoomFilterData.hPlaneEffect = -goomInfo->update.zoomFilterData.hPlaneEffect;
  368. break;
  369. case 13:
  370. goomInfo->update.zoomFilterData.hPlaneEffect = 0;
  371. goomInfo->update.zoomFilterData.vPlaneEffect = goom_irand(goomInfo->gRandom,10)
  372. - goom_irand(goomInfo->gRandom,10);
  373. break;
  374. case 14:
  375. goomInfo->update.zoomFilterData.hPlaneEffect = goom_irand(goomInfo->gRandom,10)
  376. - goom_irand(goomInfo->gRandom,10);
  377. goomInfo->update.zoomFilterData.vPlaneEffect = goom_irand(goomInfo->gRandom,10)
  378. - goom_irand(goomInfo->gRandom,10);
  379. break;
  380. default:
  381. if (vtmp < 10) {
  382. goomInfo->update.zoomFilterData.vPlaneEffect = 0;
  383. goomInfo->update.zoomFilterData.hPlaneEffect = 0;
  384. }
  385. }
  386. if (goom_irand(goomInfo->gRandom,5) != 0)
  387. goomInfo->update.zoomFilterData.noisify = 0;
  388. else {
  389. goomInfo->update.zoomFilterData.noisify = goom_irand(goomInfo->gRandom,2) + 1;
  390. goomInfo->update.lockvar *= 2;
  391. }
  392. if (goomInfo->update.zoomFilterData.mode == AMULETTE_MODE) {
  393. goomInfo->update.zoomFilterData.vPlaneEffect = 0;
  394. goomInfo->update.zoomFilterData.hPlaneEffect = 0;
  395. goomInfo->update.zoomFilterData.noisify = 0;
  396. }
  397. if ((goomInfo->update.zoomFilterData.middleX == 1) || (goomInfo->update.zoomFilterData.middleX == (signed int)goomInfo->screen.width - 1)) {
  398. goomInfo->update.zoomFilterData.vPlaneEffect = 0;
  399. if (goom_irand(goomInfo->gRandom,2))
  400. goomInfo->update.zoomFilterData.hPlaneEffect = 0;
  401. }
  402. if ((signed int)newvit < goomInfo->update.zoomFilterData.vitesse) /* on accelere */
  403. {
  404. pzfd = &goomInfo->update.zoomFilterData;
  405. if (((newvit < STOP_SPEED - 7) &&
  406. (goomInfo->update.zoomFilterData.vitesse < STOP_SPEED - 6) &&
  407. (goomInfo->cycle % 3 == 0)) || (goom_irand(goomInfo->gRandom,40) == 0)) {
  408. goomInfo->update.zoomFilterData.vitesse = STOP_SPEED - goom_irand(goomInfo->gRandom,2)
  409. + goom_irand(goomInfo->gRandom,2);
  410. goomInfo->update.zoomFilterData.reverse = !goomInfo->update.zoomFilterData.reverse;
  411. }
  412. else {
  413. goomInfo->update.zoomFilterData.vitesse = (newvit + goomInfo->update.zoomFilterData.vitesse * 7) / 8;
  414. }
  415. goomInfo->update.lockvar += 50;
  416. }
  417. }
  418. if (goomInfo->update.lockvar > 150) {
  419. goomInfo->update.switchIncr = goomInfo->update.switchIncrAmount;
  420. goomInfo->update.switchMult = 1.0f;
  421. }
  422. }
  423. /* mode mega-lent */
  424. if (goom_irand(goomInfo->gRandom,700) == 0) {
  425. /*
  426. * printf ("coup du sort...\n") ;
  427. */
  428. pzfd = &goomInfo->update.zoomFilterData;
  429. goomInfo->update.zoomFilterData.vitesse = STOP_SPEED - 1;
  430. goomInfo->update.zoomFilterData.pertedec = 8;
  431. goomInfo->update.zoomFilterData.sqrtperte = 16;
  432. goomInfo->update.goomvar = 1;
  433. goomInfo->update.lockvar += 50;
  434. goomInfo->update.switchIncr = goomInfo->update.switchIncrAmount;
  435. goomInfo->update.switchMult = 1.0f;
  436. }
  437. }
  438. /*
  439. * gros frein si la musique est calme
  440. */
  441. if ((goomInfo->sound.speedvar < 0.01f)
  442. && (goomInfo->update.zoomFilterData.vitesse < STOP_SPEED - 4)
  443. && (goomInfo->cycle % 16 == 0)) {
  444. pzfd = &goomInfo->update.zoomFilterData;
  445. goomInfo->update.zoomFilterData.vitesse += 3;
  446. goomInfo->update.zoomFilterData.pertedec = 8;
  447. goomInfo->update.zoomFilterData.sqrtperte = 16;
  448. goomInfo->update.goomvar = 0;
  449. }
  450. /*
  451. * baisser regulierement la vitesse...
  452. */
  453. if ((goomInfo->cycle % 73 == 0) && (goomInfo->update.zoomFilterData.vitesse < STOP_SPEED - 5)) {
  454. pzfd = &goomInfo->update.zoomFilterData;
  455. goomInfo->update.zoomFilterData.vitesse++;
  456. }
  457. /*
  458. * arreter de decrémenter au bout d'un certain temps
  459. */
  460. if ((goomInfo->cycle % 101 == 0) && (goomInfo->update.zoomFilterData.pertedec == 7)) {
  461. pzfd = &goomInfo->update.zoomFilterData;
  462. goomInfo->update.zoomFilterData.pertedec = 8;
  463. goomInfo->update.zoomFilterData.sqrtperte = 16;
  464. }
  465. /*
  466. * Permet de forcer un effet.
  467. */
  468. if ((forceMode > 0) && (forceMode <= NB_FX)) {
  469. pzfd = &goomInfo->update.zoomFilterData;
  470. pzfd->mode = forceMode - 1;
  471. }
  472. if (forceMode == -1) {
  473. pzfd = NULL;
  474. }
  475. /*
  476. * Changement d'effet de zoom !
  477. */
  478. if (pzfd != NULL) {
  479. int dif;
  480. goomInfo->update.cyclesSinceLastChange = 0;
  481. goomInfo->update.switchIncr = goomInfo->update.switchIncrAmount;
  482. dif = goomInfo->update.zoomFilterData.vitesse - goomInfo->update.previousZoomSpeed;
  483. if (dif < 0)
  484. dif = -dif;
  485. if (dif > 2) {
  486. goomInfo->update.switchIncr *= (dif + 2) / 2;
  487. }
  488. goomInfo->update.previousZoomSpeed = goomInfo->update.zoomFilterData.vitesse;
  489. goomInfo->update.switchMult = 1.0f;
  490. if (((goomInfo->sound.timeSinceLastGoom == 0)
  491. && (goomInfo->sound.totalgoom < 2)) || (forceMode > 0)) {
  492. goomInfo->update.switchIncr = 0;
  493. goomInfo->update.switchMult = goomInfo->update.switchMultAmount;
  494. }
  495. }
  496. else {
  497. if (goomInfo->update.cyclesSinceLastChange > TIME_BTW_CHG) {
  498. pzfd = &goomInfo->update.zoomFilterData;
  499. goomInfo->update.cyclesSinceLastChange = 0;
  500. }
  501. else
  502. goomInfo->update.cyclesSinceLastChange++;
  503. }
  504. #ifdef VERBOSE
  505. if (pzfd) {
  506. printf ("GOOM: pzfd->mode = %d\n", pzfd->mode);
  507. }
  508. #endif
  509. /* Zoom here ! */
  510. zoomFilterFastRGB (goomInfo, goomInfo->p1, goomInfo->p2, pzfd, goomInfo->screen.width, goomInfo->screen.height,
  511. goomInfo->update.switchIncr, goomInfo->update.switchMult);
  512. /*
  513. * Affichage tentacule
  514. */
  515. goomInfo->tentacles_fx.apply(&goomInfo->tentacles_fx, goomInfo->p1, goomInfo->p2, goomInfo);
  516. goomInfo->star_fx.apply (&goomInfo->star_fx,goomInfo->p2,goomInfo->p1,goomInfo);
  517. /*
  518. * Affichage de texte
  519. */
  520. {
  521. /*char title[1024];*/
  522. char text[64];
  523. /*
  524. * Le message
  525. */
  526. update_message (goomInfo, message);
  527. if (fps > 0) {
  528. sprintf (text, "%2.0f fps", fps);
  529. goom_draw_text (goomInfo->p1,goomInfo->screen.width,goomInfo->screen.height,
  530. 10, 24, text, 1, 0);
  531. }
  532. /*
  533. * Le titre
  534. */
  535. if (songTitle != NULL) {
  536. strncpy (goomInfo->update.titleText, songTitle, 1023);
  537. goomInfo->update.titleText[1023]=0;
  538. goomInfo->update.timeOfTitleDisplay = 200;
  539. }
  540. if (goomInfo->update.timeOfTitleDisplay) {
  541. goom_draw_text (goomInfo->p1,goomInfo->screen.width,goomInfo->screen.height,
  542. goomInfo->screen.width / 2, goomInfo->screen.height / 2 + 7, goomInfo->update.titleText,
  543. ((float) (190 - goomInfo->update.timeOfTitleDisplay) / 10.0f), 1);
  544. goomInfo->update.timeOfTitleDisplay--;
  545. if (goomInfo->update.timeOfTitleDisplay < 4)
  546. goom_draw_text (goomInfo->p2,goomInfo->screen.width,goomInfo->screen.height,
  547. goomInfo->screen.width / 2, goomInfo->screen.height / 2 + 7, goomInfo->update.titleText,
  548. ((float) (190 - goomInfo->update.timeOfTitleDisplay) / 10.0f), 1);
  549. }
  550. }
  551. /*
  552. * Gestion du Scope
  553. */
  554. /*
  555. * arret demande
  556. */
  557. if ((goomInfo->update.stop_lines & 0xf000)||(!goomInfo->curGState->drawScope)) {
  558. float param1, param2, amplitude;
  559. int couleur;
  560. int mode;
  561. choose_a_goom_line (goomInfo, &param1, &param2, &couleur, &mode, &amplitude,1);
  562. couleur = GML_BLACK;
  563. goom_lines_switch_to (goomInfo->gmline1, mode, param1, amplitude, couleur);
  564. goom_lines_switch_to (goomInfo->gmline2, mode, param2, amplitude, couleur);
  565. goomInfo->update.stop_lines &= 0x0fff;
  566. }
  567. /*
  568. * arret aleatore.. changement de mode de ligne..
  569. */
  570. if (goomInfo->update.lineMode != goomInfo->update.drawLinesDuration) {
  571. goomInfo->update.lineMode--;
  572. if (goomInfo->update.lineMode == -1)
  573. goomInfo->update.lineMode = 0;
  574. }
  575. else
  576. if ((goomInfo->cycle%80==0)&&(goom_irand(goomInfo->gRandom,5)==0)&&goomInfo->update.lineMode)
  577. goomInfo->update.lineMode--;
  578. if ((goomInfo->cycle % 120 == 0)
  579. && (goom_irand(goomInfo->gRandom,4) == 0)
  580. && (goomInfo->curGState->drawScope)) {
  581. if (goomInfo->update.lineMode == 0)
  582. goomInfo->update.lineMode = goomInfo->update.drawLinesDuration;
  583. else if (goomInfo->update.lineMode == goomInfo->update.drawLinesDuration) {
  584. float param1, param2, amplitude;
  585. int couleur1,couleur2;
  586. int mode;
  587. goomInfo->update.lineMode--;
  588. choose_a_goom_line (goomInfo, &param1, &param2, &couleur1,
  589. &mode, &amplitude,goomInfo->update.stop_lines);
  590. couleur2 = 5-couleur1;
  591. if (goomInfo->update.stop_lines) {
  592. goomInfo->update.stop_lines--;
  593. if (goom_irand(goomInfo->gRandom,2))
  594. couleur2=couleur1 = GML_BLACK;
  595. }
  596. goom_lines_switch_to (goomInfo->gmline1, mode, param1, amplitude, couleur1);
  597. goom_lines_switch_to (goomInfo->gmline2, mode, param2, amplitude, couleur2);
  598. }
  599. }
  600. /*
  601. * si on est dans un goom : afficher les lignes...
  602. */
  603. if ((goomInfo->update.lineMode != 0) || (goomInfo->sound.timeSinceLastGoom < 5)) {
  604. goomInfo->gmline2->power = goomInfo->gmline1->power;
  605. goom_lines_draw (goomInfo, goomInfo->gmline1, data[0], goomInfo->p2);
  606. goom_lines_draw (goomInfo, goomInfo->gmline2, data[1], goomInfo->p2);
  607. if (((goomInfo->cycle % 121) == 9) && (goom_irand(goomInfo->gRandom,3) == 1)
  608. && ((goomInfo->update.lineMode == 0) || (goomInfo->update.lineMode == goomInfo->update.drawLinesDuration))) {
  609. float param1, param2, amplitude;
  610. int couleur1,couleur2;
  611. int mode;
  612. choose_a_goom_line (goomInfo, &param1, &param2, &couleur1,
  613. &mode, &amplitude, goomInfo->update.stop_lines);
  614. couleur2 = 5-couleur1;
  615. if (goomInfo->update.stop_lines) {
  616. goomInfo->update.stop_lines--;
  617. if (goom_irand(goomInfo->gRandom,2))
  618. couleur2=couleur1 = GML_BLACK;
  619. }
  620. goom_lines_switch_to (goomInfo->gmline1, mode, param1, amplitude, couleur1);
  621. goom_lines_switch_to (goomInfo->gmline2, mode, param2, amplitude, couleur2);
  622. }
  623. }
  624. return_val = goomInfo->p1;
  625. tmp = goomInfo->p1;
  626. goomInfo->p1 = goomInfo->p2;
  627. goomInfo->p2 = tmp;
  628. /* affichage et swappage des buffers.. */
  629. goomInfo->cycle++;
  630. goomInfo->convolve_fx.apply(&goomInfo->convolve_fx,return_val,goomInfo->outputBuf,goomInfo);
  631. return (guint32*)goomInfo->outputBuf;
  632. }
  633. /****************************************
  634. * CLOSE *
  635. ****************************************/
  636. void goom_close (PluginInfo *goomInfo)
  637. {
  638. if (goomInfo->pixel != NULL)
  639. free (goomInfo->pixel);
  640. if (goomInfo->back != NULL)
  641. free (goomInfo->back);
  642. if (goomInfo->conv != NULL)
  643. free (goomInfo->conv);
  644. goomInfo->pixel = goomInfo->back = NULL;
  645. goomInfo->conv = NULL;
  646. goom_random_free(goomInfo->gRandom);
  647. goom_lines_free (&goomInfo->gmline1);
  648. goom_lines_free (&goomInfo->gmline2);
  649. /* release_ifs (); */
  650. goomInfo->ifs_fx.free(&goomInfo->ifs_fx);
  651. goomInfo->convolve_fx.free(&goomInfo->convolve_fx);
  652. goomInfo->star_fx.free(&goomInfo->star_fx);
  653. goomInfo->tentacles_fx.free(&goomInfo->tentacles_fx);
  654. goomInfo->zoomFilter_fx.free(&goomInfo->zoomFilter_fx);
  655. // Release info visual
  656. free (goomInfo->params);
  657. free (goomInfo->sound.params.params);
  658. // Release PluginInfo
  659. free (goomInfo->visuals);
  660. gsl_free (goomInfo->scanner);
  661. gsl_free (goomInfo->main_scanner);
  662. free(goomInfo);
  663. }
  664. /* *** */
  665. void
  666. choose_a_goom_line (PluginInfo *goomInfo, float *param1, float *param2, int *couleur, int *mode,
  667. float *amplitude, int far)
  668. {
  669. *mode = goom_irand(goomInfo->gRandom,3);
  670. *amplitude = 1.0f;
  671. switch (*mode) {
  672. case GML_CIRCLE:
  673. if (far) {
  674. *param1 = *param2 = 0.47f;
  675. *amplitude = 0.8f;
  676. break;
  677. }
  678. if (goom_irand(goomInfo->gRandom,3) == 0) {
  679. *param1 = *param2 = 0;
  680. *amplitude = 3.0f;
  681. }
  682. else if (goom_irand(goomInfo->gRandom,2)) {
  683. *param1 = 0.40f * goomInfo->screen.height;
  684. *param2 = 0.22f * goomInfo->screen.height;
  685. }
  686. else {
  687. *param1 = *param2 = goomInfo->screen.height * 0.35;
  688. }
  689. break;
  690. case GML_HLINE:
  691. if (goom_irand(goomInfo->gRandom,4) || far) {
  692. *param1 = goomInfo->screen.height / 7;
  693. *param2 = 6.0f * goomInfo->screen.height / 7.0f;
  694. }
  695. else {
  696. *param1 = *param2 = goomInfo->screen.height / 2.0f;
  697. *amplitude = 2.0f;
  698. }
  699. break;
  700. case GML_VLINE:
  701. if (goom_irand(goomInfo->gRandom,3) || far) {
  702. *param1 = goomInfo->screen.width / 7.0f;
  703. *param2 = 6.0f * goomInfo->screen.width / 7.0f;
  704. }
  705. else {
  706. *param1 = *param2 = goomInfo->screen.width / 2.0f;
  707. *amplitude = 1.5f;
  708. }
  709. break;
  710. }
  711. *couleur = goom_irand(goomInfo->gRandom,6);
  712. }
  713. #define ECART_VARIATION 1.5
  714. #define POS_VARIATION 3.0
  715. #define SCROLLING_SPEED 80
  716. /*
  717. * Met a jour l'affichage du message defilant
  718. */
  719. void update_message (PluginInfo *goomInfo, char *message) {
  720. int fin = 0;
  721. if (message) {
  722. int i=1,j=0;
  723. strcpy (goomInfo->update_message.message, message);
  724. for (j=0;goomInfo->update_message.message[j];j++)
  725. if (goomInfo->update_message.message[j]=='\n')
  726. i++;
  727. goomInfo->update_message.numberOfLinesInMessage = i;
  728. goomInfo->update_message.affiche = goomInfo->screen.height + goomInfo->update_message.numberOfLinesInMessage * 25 + 105;
  729. goomInfo->update_message.longueur = strlen(goomInfo->update_message.message);
  730. }
  731. if (goomInfo->update_message.affiche) {
  732. int i = 0;
  733. char *msg = malloc(goomInfo->update_message.longueur + 1);
  734. char *ptr = msg;
  735. int pos;
  736. float ecart;
  737. message = msg;
  738. strcpy (msg, goomInfo->update_message.message);
  739. while (!fin) {
  740. while (1) {
  741. if (*ptr == 0) {
  742. fin = 1;
  743. break;
  744. }
  745. if (*ptr == '\n') {
  746. *ptr = 0;
  747. break;
  748. }
  749. ++ptr;
  750. }
  751. pos = goomInfo->update_message.affiche - (goomInfo->update_message.numberOfLinesInMessage - i)*25;
  752. pos += POS_VARIATION * (cos((double)pos / 20.0));
  753. pos -= SCROLLING_SPEED;
  754. ecart = (ECART_VARIATION * sin((double)pos / 20.0));
  755. if ((fin) && (2 * pos < (int)goomInfo->screen.height))
  756. pos = (int)goomInfo->screen.height / 2;
  757. pos += 7;
  758. goom_draw_text(goomInfo->p1,goomInfo->screen.width,goomInfo->screen.height,
  759. goomInfo->screen.width/2, pos,
  760. message,
  761. ecart,
  762. 1);
  763. message = ++ptr;
  764. i++;
  765. }
  766. goomInfo->update_message.affiche --;
  767. free (msg);
  768. }
  769. }