开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 查看源码
main.c
资源名称：vlc-0.8.1.tar.gz　[点击查看]
上传用户：riyaled888
上传日期：2009-03-27
资源大小：7338k
文件大小：45k
源码类别：

多媒体

开发平台：

MultiPlatform

main.c：源码内容
  1. /*****************************************************************************
  2.  * main.c:
  3.  *****************************************************************************
  4.  * Copyright (C) 2004 VideoLAN
  5.  * $Id: main.c 8243 2004-07-22 21:27:45Z gbazin $
  6.  *
  7.  * Authors: Cyril Deguet <asmax@videolan.org>
  8.  *          Adapted from projectM (http://xmms-projectm.sourceforge.net/)
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23.  *****************************************************************************/
  25. #include "plugin.h"
  26. #include <GL/gl.h>
  27. #include <GL/glu.h>
  28. #include <unistd.h>
  29. #include <math.h>
  30. #include <stdio.h>
  31. #include <string.h>
  32. #include <stdlib.h>
  33. #include "common.h"
  34. #include "preset_types.h"
  35. #include "preset.h"
  36. #include "engine_vars.h"
  37. #include "per_pixel_eqn_types.h"
  38. #include "per_pixel_eqn.h"
  39. #include "interface_types.h"
  40. #include "video_init.h"             //Video Init Routines, resizing/fullscreen, creating pbuffers
  41. #include "PCM.h"                    //Sound data handler (buffering, FFT, etc.)
  42. #include "beat_detect.h"            //beat detection routines
  43. #include "custom_wave_types.h"
  44. #include "custom_wave.h"
  45. #include "custom_shape_types.h"
  46. #include "custom_shape.h"
  47. //#include <dmalloc.h>
  49. // Forward declarations
  51. void read_cfg();
  53. void modulate_opacity_by_volume();
  54. void maximize_colors();
  55. void do_per_pixel_math();
  56. void do_per_frame();
  58. void render_interpolation();
  59. void render_texture_to_screen();
  60. void render_texture_to_studio();
  61. void draw_motion_vectors();
  62. void draw_borders();
  63. void draw_shapes();
  64. void draw_waveform();
  65. void draw_custom_waves();
  67. void reset_per_pixel_matrices();
  68. void init_per_pixel_matrices();
  69. void free_per_pixel_matrices();
  71. int noSwitch=0;
  72. int pcmframes=1;
  73. int freqframes=0;
  74. int totalframes=1;
  76. int studio=0;
  78. extern preset_t * active_preset;
  80. GLuint RenderTargetTextureID;
  82. double wave_o;
  84. //double gx=32;  //size of interpolation
  85. //double gy=24;
  87. int texsize=512;   //size of texture to do actual graphics
  88. int vw=512;           //runtime dimensions
  89. int vh=512;
  90. int fullscreen=0;
  92. int maxsamples=2048; //size of PCM buffer
  93. int numsamples; //size of new PCM info
  94. double *pcmdataL;     //holder for most recent pcm data
  95. double *pcmdataR;     //holder for most recent pcm data
  97. int avgtime=500;  //# frames per preset
  99. char *title = NULL;
  100. int drawtitle;
  101. int title_font;
  102. int other_font;
  104. int correction=1;
  106. double vol;
  108. //per pixel equation variables
  111. double **gridx;  //grid containing interpolated mesh
  112. double **gridy;
  113. double **origtheta;  //grid containing interpolated mesh reference values
  114. double **origrad;
  115. double **origx;  //original mesh
  116. double **origy;
  118. char *buffer; //XXX
  120. int galaktos_init( galaktos_thread_t *p_thread )
  121. {
  122.     init_per_pixel_matrices();
  123.     pcmdataL=(double *)malloc(maxsamples*sizeof(double));
  124.     pcmdataR=(double *)malloc(maxsamples*sizeof(double));
  126.     /* Preset loading function */
  127.     initPresetLoader();
  129.     /* Load default preset directory */
  130. //    loadPresetDir("/home/cyril/.vlc/galaktos");
  131.     loadPresetDir("/etc/projectM/presets");
  133.     initPCM(maxsamples);
  134.     initBeatDetect();
  136.     // mutex = SDL_CreateMutex();
  137.     return 0;
  138. }
  141. void galaktos_done( galaktos_thread_t *p_thread )
  142. {
  143.     free(pcmdataL);
  144.     free(pcmdataR);
  146.     freeBeatDetect();
  147.     freePCM();
  148.     free_per_pixel_matrices();
  149.     closePresetDir();
  150. //    destroyPresetLoader(); XXX segfaults :(
  151. }
  154. int galaktos_update( galaktos_thread_t *p_thread )
  155. {
  156.     static int nohard=0;
  157.     double vdataL[512];  //holders for FFT data (spectrum)
  158.     double vdataR[512];
  160.     avgtime=fps*18;
  161.     totalframes++; //total amount of frames since startup
  163.     Time=(double)(mdate()/1000000);
  165.     frame++;  //number of frames for current preset
  166.     progress= frame/(double)avgtime;
  167.     if (progress>1.0) progress=1.0;
  168.     // printf("start:%d at:%d min:%d stop:%d on:%d %dn",startframe, frame frame-startframe,avgtime,  noSwitch,progress);
  170.     if (frame>avgtime)
  171.     {
  172.         if (noSwitch==0) switchPreset(RANDOM_NEXT,0);
  173.     }
  175.     evalInitConditions();
  176.     evalPerFrameEquations();
  178.     evalCustomWaveInitConditions();
  179.     evalCustomShapeInitConditions();
  181.     //     printf("%f %dn",Time,frame);
  183.     reset_per_pixel_matrices();
  186.     numsamples = getPCMnew(pcmdataR,1,0,fWaveSmoothing,0,0);
  187.     getPCMnew(pcmdataL,0,0,fWaveSmoothing,0,1);
  188.     getPCM(vdataL,512,0,1,0,0);
  189.     getPCM(vdataR,512,1,1,0,0);
  191.     bass=0;mid=0;treb=0;
  193.     getBeatVals(vdataL,vdataR,&vol);
  195.     nohard--;
  196.     if(vol>8.0 && nohard<0 && noSwitch==0)
  197.     {
  199.         switchPreset(RANDOM_NEXT, HARD_CUT);
  200.         nohard=100;
  201.     }
  203.     //BEGIN PASS 1
  204.     //
  205.     //This pass is used to render our texture
  206.     //the texture is drawn to a subsection of the framebuffer
  207.     //and then we perform our manipulations on it
  208.     //in pass 2 we will copy the texture into texture memory
  210.   //  galaktos_glx_activate_pbuffer( p_thread );
  212.     glPushAttrib( GL_ALL_ATTRIB_BITS ); /* Overkill, but safe */
  214.     //   if (RenderTarget) glViewport( 0, 0, RenderTarget->w, RenderTarget->h );
  215.     if (0) {}
  216.     else glViewport( 0, 0, texsize, texsize );
  219.     glMatrixMode( GL_MODELVIEW );
  220.     glPushMatrix();
  221.     glLoadIdentity();
  223.     glMatrixMode( GL_PROJECTION );
  224.     glPushMatrix();
  225.     glLoadIdentity();
  227.     glOrtho(0.0, texsize, 0.0,texsize,10,40);
  229.     do_per_pixel_math();
  231.     do_per_frame();               //apply per-frame effects
  232.     render_interpolation();       //apply per-pixel effects
  233.     draw_motion_vectors();        //draw motion vectors
  234.     draw_borders();               //draw borders
  236.     draw_waveform();
  237.     draw_shapes();
  238.     draw_custom_waves();
  240.     glMatrixMode( GL_MODELVIEW );
  241.     glPopMatrix();
  243.     glMatrixMode( GL_PROJECTION );
  244.     glPopMatrix();
  246.     glPopAttrib();
  248.     //if ( RenderTarget )        SDL_GL_UnlockRenderTarget(RenderTarget);
  249.         /* Copy our rendering to the fake render target texture */
  250.     glBindTexture( GL_TEXTURE_2D, RenderTargetTextureID );
  251.     glCopyTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, 0, 0, texsize, texsize);
  252. //    galaktos_glx_activate_window( p_thread );
  254.     //BEGIN PASS 2
  255.     //
  256.     //end of texture rendering
  257.     //now we copy the texture from the framebuffer to
  258.     //video texture memory and render fullscreen on a quad surface.
  259.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  260.     glMatrixMode(GL_PROJECTION);
  261.     glLoadIdentity();
  263.     glFrustum(-vw*.5, vw*.5, -vh*.5,vh*.5,10,40);
  265.     glLineWidth(texsize/512.0);
  266.     if(studio%2)render_texture_to_studio();
  267.     else render_texture_to_screen();
  269.     glFinish();
  270.     glFlush();
  271.     //  printf("Flush %dn",(SDL_GetTicks()-timestart));
  273.     p_thread->p_opengl->pf_swap( p_thread->p_opengl );
  275.     /* Process events */
  276.     if( p_thread->p_opengl->pf_manage &&
  277.         p_thread->p_opengl->pf_manage( p_thread->p_opengl ) )
  278.     {
  279.         return 1;
  280.     }
  282.     return 0;
  283. }
  286. void free_per_pixel_matrices()
  287. {
  288.     int x;
  290.     for(x = 0; x < gx; x++)
  291.     {
  292.         free(gridx[x]);
  293.         free(gridy[x]);
  294.         free(origtheta[x]);
  295.         free(origrad[x]);
  296.         free(origx[x]);
  297.         free(origy[x]);
  298.         free(x_mesh[x]);
  299.         free(y_mesh[x]);
  300.         free(rad_mesh[x]);
  301.         free(theta_mesh[x]);
  302.     }
  304.     free(origx);
  305.     free(origy);
  306.     free(gridx);
  307.     free(gridy);
  308.     free(x_mesh);
  309.     free(y_mesh);
  310.     free(rad_mesh);
  311.     free(theta_mesh);
  312. }
  315. void init_per_pixel_matrices()
  316. {
  317.     int x,y;
  319.     gridx=(double **)malloc(gx * sizeof(double *));
  320.     gridy=(double **)malloc(gx * sizeof(double *));
  322.     origx=(double **)malloc(gx * sizeof(double *));
  323.     origy=(double **)malloc(gx * sizeof(double *));
  324.     origrad=(double **)malloc(gx * sizeof(double *));
  325.     origtheta=(double **)malloc(gx * sizeof(double *));
  327.     x_mesh=(double **)malloc(gx * sizeof(double *));
  328.     y_mesh=(double **)malloc(gx * sizeof(double *));
  329.     rad_mesh=(double **)malloc(gx * sizeof(double *));
  330.     theta_mesh=(double **)malloc(gx * sizeof(double *));
  332.     sx_mesh=(double **)malloc(gx * sizeof(double *));
  333.     sy_mesh=(double **)malloc(gx * sizeof(double *));
  334.     dx_mesh=(double **)malloc(gx * sizeof(double *));
  335.     dy_mesh=(double **)malloc(gx * sizeof(double *));
  336.     cx_mesh=(double **)malloc(gx * sizeof(double *));
  337.     cy_mesh=(double **)malloc(gx * sizeof(double *));
  338.     zoom_mesh=(double **)malloc(gx * sizeof(double *));
  339.     zoomexp_mesh=(double **)malloc(gx * sizeof(double *));
  340.     rot_mesh=(double **)malloc(gx * sizeof(double *));
  342.     for(x = 0; x < gx; x++)
  343.     {
  344.         gridx[x] = (double *)malloc(gy * sizeof(double));
  345.         gridy[x] = (double *)malloc(gy * sizeof(double));
  347.         origtheta[x] = (double *)malloc(gy * sizeof(double));
  348.         origrad[x] = (double *)malloc(gy * sizeof(double));
  349.         origx[x] = (double *)malloc(gy * sizeof(double));
  350.         origy[x] = (double *)malloc(gy * sizeof(double));
  352.         x_mesh[x] = (double *)malloc(gy * sizeof(double));
  353.         y_mesh[x] = (double *)malloc(gy * sizeof(double));
  355.         rad_mesh[x] = (double *)malloc(gy * sizeof(double));
  356.         theta_mesh[x] = (double *)malloc(gy * sizeof(double));
  358.         sx_mesh[x] = (double *)malloc(gy * sizeof(double));
  359.         sy_mesh[x] = (double *)malloc(gy * sizeof(double));
  360.         dx_mesh[x] = (double *)malloc(gy * sizeof(double));
  361.         dy_mesh[x] = (double *)malloc(gy * sizeof(double));
  362.         cx_mesh[x] = (double *)malloc(gy * sizeof(double));
  363.         cy_mesh[x] = (double *)malloc(gy * sizeof(double));
  365.         zoom_mesh[x] = (double *)malloc(gy * sizeof(double));
  366.         zoomexp_mesh[x] = (double *)malloc(gy * sizeof(double));
  368.         rot_mesh[x] = (double *)malloc(gy * sizeof(double));
  369.     }
  371.     //initialize reference grid values
  372.     for (x=0;x<gx;x++)
  373.     {
  374.         for(y=0;y<gy;y++)
  375.         {
  376.             origx[x][y]=x/(double)(gx-1);
  377.             origy[x][y]=-((y/(double)(gy-1))-1);
  378.             origrad[x][y]=hypot((origx[x][y]-.5)*2,(origy[x][y]-.5)*2) * .7071067;
  379.             origtheta[x][y]=atan2(((origy[x][y]-.5)*2),((origx[x][y]-.5)*2));
  380.             gridx[x][y]=origx[x][y]*texsize;
  381.             gridy[x][y]=origy[x][y]*texsize;
  382.         }
  383.     }
  384. }
  388. //calculate matrices for per_pixel
  389. void do_per_pixel_math()
  390. {
  391.     int x,y;
  393.     double rotx=0,roty=0;
  394.     evalPerPixelEqns();
  396.     if(!isPerPixelEqn(CX_OP))
  397.     {
  398.         for (x=0;x<gx;x++)
  399.         {
  400.             for(y=0;y<gy;y++){
  401.                 cx_mesh[x][y]=cx;
  402.             }
  403.         }
  404.     }
  406.     if(!isPerPixelEqn(CY_OP))
  407.     {
  408.         for (x=0;x<gx;x++)
  409.         {
  410.             for(y=0;y<gy;y++)
  411.             {
  412.                 cy_mesh[x][y]=cy;
  413.             }
  414.         }
  415.     }
  417.     if(isPerPixelEqn(ROT_OP))
  418.     {
  419.         for (x=0;x<gx;x++)
  420.         {
  421.             for(y=0;y<gy;y++)
  422.             {
  423.                 x_mesh[x][y]=x_mesh[x][y]-cx_mesh[x][y];
  424.                 y_mesh[x][y]=y_mesh[x][y]-cy_mesh[x][y];
  425.                 rotx=(x_mesh[x][y])*cos(rot_mesh[x][y])-(y_mesh[x][y])*sin(rot_mesh[x][y]);
  426.                 roty=(x_mesh[x][y])*sin(rot_mesh[x][y])+(y_mesh[x][y])*cos(rot_mesh[x][y]);
  427.                 x_mesh[x][y]=rotx+cx_mesh[x][y];
  428.                 y_mesh[x][y]=roty+cy_mesh[x][y];
  429.             }
  430.         }
  431.     }
  435.     if(!isPerPixelEqn(ZOOM_OP))
  436.     {
  437.         for (x=0;x<gx;x++)
  438.         {
  439.             for(y=0;y<gy;y++)
  440.             {
  441.                 zoom_mesh[x][y]=zoom;
  442.             }
  443.         }
  444.     }
  446.     if(!isPerPixelEqn(ZOOMEXP_OP))
  447.     {
  448.         for (x=0;x<gx;x++)
  449.         {
  450.             for(y=0;y<gy;y++)
  451.             {
  452.                 zoomexp_mesh[x][y]=zoomexp;
  453.             }
  454.         }
  455.     }
  458.     //DO ZOOM PER PIXEL
  459.     for (x=0;x<gx;x++)
  460.     {
  461.         for(y=0;y<gy;y++)
  462.         {
  463.             x_mesh[x][y]=(x_mesh[x][y]-.5)*2;
  464.             y_mesh[x][y]=(y_mesh[x][y]-.5)*2;
  465.             x_mesh[x][y]=x_mesh[x][y]/(((zoom_mesh[x][y]-1)*(pow(rad_mesh[x][y],zoomexp_mesh[x][y])/rad_mesh[x][y]))+1);
  466.             y_mesh[x][y]=y_mesh[x][y]/(((zoom_mesh[x][y]-1)*(pow(rad_mesh[x][y],zoomexp_mesh[x][y])/rad_mesh[x][y]))+1);
  467.             x_mesh[x][y]=(x_mesh[x][y]*.5)+.5;
  468.             y_mesh[x][y]=(y_mesh[x][y]*.5)+.5;
  469.         }
  470.     }
  472.     if(isPerPixelEqn(SX_OP))
  473.     {
  474.         for (x=0;x<gx;x++)
  475.         {
  476.             for(y=0;y<gy;y++)
  477.             {
  478.                 x_mesh[x][y]=((x_mesh[x][y]-cx_mesh[x][y])/sx_mesh[x][y])+cx_mesh[x][y];
  479.             }
  480.         }
  481.     }
  483.     if(isPerPixelEqn(SY_OP))
  484.     {
  485.         for (x=0;x<gx;x++)
  486.         {
  487.             for(y=0;y<gy;y++)
  488.             {
  489.                 y_mesh[x][y]=((y_mesh[x][y]-cy_mesh[x][y])/sy_mesh[x][y])+cy_mesh[x][y];
  490.             }
  491.         }
  492.     }
  494.     if(isPerPixelEqn(DX_OP))
  495.     {
  496.         for (x=0;x<gx;x++)
  497.         {
  498.             for(y=0;y<gy;y++)
  499.             {
  501.                 x_mesh[x][y]=x_mesh[x][y]-dx_mesh[x][y];
  503.             }
  504.         }
  505.     }
  507.     if(isPerPixelEqn(DY_OP))
  508.     {
  509.         for (x=0;x<gx;x++)
  510.         {
  511.             for(y=0;y<gy;y++)
  512.             {
  513.                 y_mesh[x][y]=y_mesh[x][y]-dy_mesh[x][y];
  515.             }
  516.         }
  517.     }
  520. }
  522. void reset_per_pixel_matrices()
  523. {
  524.     int x,y;
  526.     for (x=0;x<gx;x++)
  527.     {
  528.         for(y=0;y<gy;y++)
  529.         {
  530.             x_mesh[x][y]=origx[x][y];
  531.             y_mesh[x][y]=origy[x][y];
  532.             rad_mesh[x][y]=origrad[x][y];
  533.             theta_mesh[x][y]=origtheta[x][y];
  534.         }
  535.     }
  536. }
  540. void draw_custom_waves()
  541. {
  542.     int x;
  544.     custom_wave_t *wavecode;
  545.     glPointSize(texsize/512);
  546.     //printf("%dn",wavecode);
  547.     //  more=isMoreCustomWave();
  548.     // printf("not inner loopn");
  549.     while ((wavecode = nextCustomWave()) != NULL)
  550.     {
  551.         //printf("begin inner loopn");
  552.         if(wavecode->enabled==1)
  553.         {
  554.             // nextCustomWave();
  556.             //glPushMatrix();
  558.             //if(wavecode->bUseDots==1) glEnable(GL_LINE_STIPPLE);
  559.             if (wavecode->bAdditive==0)  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  560.             else    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  561.             if (wavecode->bDrawThick==1)  glLineWidth(2*texsize/512);
  563.             //  xx= ((pcmdataL[x]-pcmdataL[x-1])*80*fWaveScale)*2;
  564.             //yy=pcmdataL[x]*80*fWaveScale,-1;
  565.             //glVertex3f( (wave_x*texsize)+(xx+yy)*cos(45), (wave_y*texsize)+(-yy+xx)*cos(45),-1);
  566.             // printf("samples: %dn", wavecode->samples);
  568.             getPCM(wavecode->value1,wavecode->samples,0,wavecode->bSpectrum,wavecode->smoothing,0);
  569.             getPCM(wavecode->value2,wavecode->samples,1,wavecode->bSpectrum,wavecode->smoothing,0);
  570.             // printf("%fn",pcmL[0]);
  571.             for(x=0;x<wavecode->samples;x++)
  572.             {wavecode->value1[x]=wavecode->value1[x]*wavecode->scaling;}
  574.             for(x=0;x<wavecode->samples;x++)
  575.             {wavecode->value2[x]=wavecode->value2[x]*wavecode->scaling;}
  577.             for(x=0;x<wavecode->samples;x++)
  578.             {wavecode->sample_mesh[x]=((double)x)/((double)(wavecode->samples-1));}
  580.             // printf("mid inner loopn");
  581.             evalPerPointEqns();
  582.             /*
  583.                if(!isPerPointEquation("x"))
  584.                {for(x=0;x<wavecode->samples;x++)
  585.                {cw_x[x]=0;} }
  587.                if(!isPerPointEquation(Y_POINT_OP))
  588.                {for(x=0;x<wavecode->samples;x++)
  589.                {cw_y[x]=0;}}
  591.                if(!isPerPointEquation(R_POINT_OP))
  592.                {for(x=0;x<wavecode->samples;x++)
  593.                {cw_r[x]=wavecode->r;}}
  594.                if(!isPerPointEquation(G_POINT_OP))
  595.                {for(x=0;x<wavecode->samples;x++)
  596.                {cw_g[x]=wavecode->g;}}
  597.                if(!isPerPointEquation(B_POINT_OP))
  598.                {for(x=0;x<wavecode->samples;x++)
  599.                {cw_b[x]=wavecode->b;}}
  600.                if(!isPerPointEquation(A_POINT_OP))
  601.                {for(x=0;x<wavecode->samples;x++)
  602.                {cw_a[x]=wavecode->a;}}
  603.              */
  604.             //put drawing code here
  605.             if (wavecode->bUseDots==1)   glBegin(GL_POINTS);
  606.             else   glBegin(GL_LINE_STRIP);
  608.             for(x=0;x<wavecode->samples;x++)
  609.             {
  610.                 //          printf("x:%f y:%f a:%f g:%f %fn", wavecode->x_mesh[x], wavecode->y_mesh[x], wavecode->a_mesh[x], wavecode->g_mesh[x], wavecode->sample_mesh[x]);
  611.                 glColor4f(wavecode->r_mesh[x],wavecode->g_mesh[x],wavecode->b_mesh[x],wavecode->a_mesh[x]);
  612.                 glVertex3f(wavecode->x_mesh[x]*texsize,-(wavecode->y_mesh[x]-1)*texsize,-1);
  613.             }
  614.             glEnd();
  615.             glPointSize(texsize/512);
  616.             glLineWidth(texsize/512);
  617.             glDisable(GL_LINE_STIPPLE);
  618.             glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  619.             //  glPopMatrix();
  621.         }
  623.     }
  624. }
  628. void draw_shapes()
  629. {
  630.     int i;
  632.     double theta;
  633.     double rad2;
  635.     double pi = 3.14159265;
  636.     double start,inc,xval,yval;
  637.     custom_shape_t *shapecode;
  639.     while ((shapecode = nextCustomShape()) != NULL)
  640.     {
  641.         if(shapecode->enabled==1)
  642.         {
  643.             // printf("drawing shape %fn",shapecode->ang);
  644.             shapecode->y=-((shapecode->y)-1);
  645.             rad2=.5;
  646.             shapecode->rad=shapecode->rad*(texsize*.707*.707*.707*1.04);
  647.             //Additive Drawing or Overwrite
  648.             if (shapecode->additive==0)  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  649.             else    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  651.             glMatrixMode(GL_MODELVIEW);
  652.             glPushMatrix();
  653.             if(correction)
  654.             {
  655.                 glTranslatef(texsize*.5,texsize*.5, 0);
  656.                 glScalef(1.0,vw/(double)vh,1.0);
  657.                 glTranslatef((-texsize*.5) ,(-texsize*.5),0);
  658.             }
  660.             start=.78539+shapecode->ang;
  661.             inc=(pi*2)/(double)shapecode->sides;
  662.             xval=shapecode->x*texsize;
  663.             yval=shapecode->y*texsize;
  665.             if (shapecode->textured)
  666.             {
  667.                 glMatrixMode(GL_TEXTURE);
  668.                 glPushMatrix();
  669.                 glLoadIdentity();
  671.                 glTranslatef(.5,.5, 0);
  672.                 if (correction) glScalef(1,vw/(double)vh,1);
  674.                 glRotatef((shapecode->tex_ang*360/6.280), 0, 0, 1);
  676.                 glScalef(1/(shapecode->tex_zoom),1/(shapecode->tex_zoom),1);
  678.                 // glScalef(1,vh/(double)vw,1);
  679.                 glTranslatef((-.5) ,(-.5),0);
  680.                 // glScalef(1,vw/(double)vh,1);
  681.                 glEnable(GL_TEXTURE_2D);
  684.                 glBegin(GL_TRIANGLE_FAN);
  686.                 glColor4f(shapecode->r,shapecode->g,shapecode->b,shapecode->a);
  687.                 theta=start;
  688.                 glTexCoord2f(.5,.5);
  689.                 glVertex3f(xval,yval,-1);
  690.                 glColor4f(shapecode->r2,shapecode->g2,shapecode->b2,shapecode->a2);
  692.                 for ( i=0;i<shapecode->sides+1;i++)
  693.                 {
  695.                     theta+=inc;
  696.                     //  glColor4f(shapecode->r2,shapecode->g2,shapecode->b2,shapecode->a2);
  697.                     glTexCoord2f(rad2*cos(theta)+.5 ,rad2*sin(theta)+.5 );
  698.                     glVertex3f(shapecode->rad*cos(theta)+xval,shapecode->rad*sin(theta)+yval,-1);
  699.                 }
  700.                 glEnd();
  705.                 glDisable(GL_TEXTURE_2D);
  706.                 glPopMatrix();
  707.                 glMatrixMode(GL_MODELVIEW);
  708.             }
  709.             else
  710.             {//Untextured (use color values)
  711.                 //printf("untextured %f %f %f @:%f,%f %f %fn",shapecode->a2,shapecode->a,shapecode->border_a, shapecode->x,shapecode->y,shapecode->rad,shapecode->ang);
  712.                 //draw first n-1 triangular pieces
  713.                 glBegin(GL_TRIANGLE_FAN);
  715.                 glColor4f(shapecode->r,shapecode->g,shapecode->b,shapecode->a);
  716.                 theta=start;
  717.                 // glTexCoord2f(.5,.5);
  718.                 glVertex3f(xval,yval,-1);
  719.                 glColor4f(shapecode->r2,shapecode->g2,shapecode->b2,shapecode->a2);
  721.                 for ( i=0;i<shapecode->sides+1;i++)
  722.                 {
  724.                     theta+=inc;
  725.                     //  glColor4f(shapecode->r2,shapecode->g2,shapecode->b2,shapecode->a2);
  726.                     //  glTexCoord2f(rad2*cos(theta)+.5 ,rad2*sin(theta)+.5 );
  727.                     glVertex3f(shapecode->rad*cos(theta)+xval,shapecode->rad*sin(theta)+yval,-1);
  728.                 }
  729.                 glEnd();
  732.             }
  733.             if (bWaveThick==1)  glLineWidth(2*texsize/512);
  734.             glBegin(GL_LINE_LOOP);
  735.             glColor4f(shapecode->border_r,shapecode->border_g,shapecode->border_b,shapecode->border_a);
  736.             for ( i=0;i<shapecode->sides;i++)
  737.             {
  738.                 theta+=inc;
  739.                 glVertex3f(shapecode->rad*cos(theta)+xval,shapecode->rad*sin(theta)+yval,-1);
  740.             }
  741.             glEnd();
  742.             if (bWaveThick==1)  glLineWidth(texsize/512);
  744.             glPopMatrix();
  745.         }
  746.     }
  748. }
  751. void draw_waveform()
  752. {
  754.     int x;
  756.     double r,theta;
  758.     double offset,scale,dy2_adj;
  760.     double co;
  762.     double wave_x_temp=0;
  763.     double wave_y_temp=0;
  765.     modulate_opacity_by_volume();
  766.     maximize_colors();
  768.     if(bWaveDots==1) glEnable(GL_LINE_STIPPLE);
  770.     offset=(wave_x-.5)*texsize;
  771.     scale=texsize/505.0;
  773.     //Thick wave drawing
  774.     if (bWaveThick==1)  glLineWidth(2*texsize/512);
  776.     //Additive wave drawing (vice overwrite)
  777.     if (bAdditiveWaves==0)  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  778.     else    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
  780.     switch(nWaveMode)
  781.     {
  782.         case 8://monitor
  784.             glPushMatrix();
  786.             glTranslatef(texsize*.5,texsize*.5, 0);
  787.             glRotated(-wave_mystery*90,0,0,1);
  789.             glTranslatef(-texsize*.5,-texsize*.825, 0);
  791.             /*
  792.                for (x=0;x<16;x++)
  793.                {
  794.                glBegin(GL_LINE_STRIP);
  795.                glColor4f(1.0-(x/15.0),.5,x/15.0,1.0);
  796.                glVertex3f((totalframes%256)*2*scale, -beat_val[x]*fWaveScale+texsize*wave_y,-1);
  797.                glColor4f(.5,.5,.5,1.0);
  798.                glVertex3f((totalframes%256)*2*scale, texsize*wave_y,-1);
  799.                glColor4f(1.0,1.0,0,1.0);
  800.             //glVertex3f((totalframes%256)*scale*2, beat_val_att[x]*fWaveScale+texsize*wave_y,-1);
  801.             glEnd();
  803.             glTranslatef(0,texsize*(1/36.0), 0);
  804.             }
  805.              */
  807.             glTranslatef(0,texsize*(1/18.0), 0);
  810.             glBegin(GL_LINE_STRIP);
  811.             glColor4f(1.0,1.0,0.5,1.0);
  812.             glVertex3f((totalframes%256)*2*scale, treb_att*5*fWaveScale+texsize*wave_y,-1);
  813.             glColor4f(.2,.2,.2,1.0);
  814.             glVertex3f((totalframes%256)*2*scale, texsize*wave_y,-1);
  815.             glColor4f(1.0,1.0,0,1.0);
  816.             glVertex3f((totalframes%256)*scale*2, treb*-5*fWaveScale+texsize*wave_y,-1);
  817.             glEnd();
  819.             glTranslatef(0,texsize*.075, 0);
  820.             glBegin(GL_LINE_STRIP);
  821.             glColor4f(0,1.0,0.0,1.0);
  822.             glVertex3f((totalframes%256)*2*scale, mid_att*5*fWaveScale+texsize*wave_y,-1);
  823.             glColor4f(.2,.2,.2,1.0);
  824.             glVertex3f((totalframes%256)*2*scale, texsize*wave_y,-1);
  825.             glColor4f(.5,1.0,.5,1.0);
  826.             glVertex3f((totalframes%256)*scale*2, mid*-5*fWaveScale+texsize*wave_y,-1);
  827.             glEnd();
  830.             glTranslatef(0,texsize*.075, 0);
  831.             glBegin(GL_LINE_STRIP);
  832.             glColor4f(1.0,0,0,1.0);
  833.             glVertex3f((totalframes%256)*2*scale, bass_att*5*fWaveScale+texsize*wave_y,-1);
  834.             glColor4f(.2,.2,.2,1.0);
  835.             glVertex3f((totalframes%256)*2*scale, texsize*wave_y,-1);
  836.             glColor4f(1.0,.5,.5,1.0);
  837.             glVertex3f((totalframes%256)*scale*2, bass*-5*fWaveScale+texsize*wave_y,-1);
  838.             glEnd();
  841.             glPopMatrix();
  842.             break;
  844.         case 0://circular waveforms
  845.             //  double co;
  846.             glPushMatrix();
  848.             glTranslatef(texsize*.5,texsize*.5, 0);
  849.             glScalef(1.0,vw/(double)vh,1.0);
  850.             glTranslatef((-texsize*.5) ,(-texsize*.5),0);
  852.             wave_y=-1*(wave_y-1.0);
  854.             glBegin(GL_LINE_STRIP);
  856.             for ( x=0;x<numsamples;x++)
  857.             {
  858.                 co= -(abs(x-((numsamples*.5)-1))/numsamples)+1;
  859.                 // printf("%d %fn",x,co);
  860.                 theta=x*(6.28/numsamples);
  861.                 r= ((1+2*wave_mystery)*(texsize/5.0)+
  862.                     ( co*pcmdataL[x]+ (1-co)*pcmdataL[-(x-(numsamples-1))])
  863.                     *25*fWaveScale);
  865.                 glVertex3f(r*cos(theta)+(wave_x*texsize),r*sin(theta)+(wave_y*texsize),-1);
  866.             }
  868.             r= ( (1+2*wave_mystery)*(texsize/5.0)+
  869.                  (0.5*pcmdataL[0]+ 0.5*pcmdataL[numsamples-1])
  870.                  *20*fWaveScale);
  872.             glVertex3f(r*cos(0)+(wave_x*texsize),r*sin(0)+(wave_y*texsize),-1);
  874.             glEnd();
  875.             /*
  876.                glBegin(GL_LINE_LOOP);
  878.                for ( x=0;x<(512/pcmbreak);x++)
  879.                {
  880.                theta=(blockstart+x)*((6.28*pcmbreak)/512.0);
  881.                r= ((1+2*wave_mystery)*(texsize/5.0)+fdata_buffer[fbuffer][0][blockstart+x]*.0025*fWaveScale);
  883.                glVertex3f(r*cos(theta)+(wave_x*texsize),r*sin(theta)+(wave_y*texsize),-1);
  884.                }
  885.                glEnd();
  886.              */
  887.             glPopMatrix();
  889.             break;
  891.         case 1://circularly moving waveform
  892.             //  double co;
  893.             glPushMatrix();
  895.             glTranslatef(texsize*.5,texsize*.5, 0);
  896.             glScalef(1.0,vw/(double)vh,1.0);
  897.             glTranslatef((-texsize*.5) ,(-texsize*.5),0);
  899.             wave_y=-1*(wave_y-1.0);
  901.             glBegin(GL_LINE_STRIP);
  902.             //theta=(frame%512)*(6.28/512.0);
  904.             for ( x=1;x<512;x++)
  905.             {
  906.                 co= -(abs(x-255)/512.0)+1;
  907.                 // printf("%d %fn",x,co);
  908.                 theta=((frame%256)*(2*6.28/512.0))+pcmdataL[x]*.2*fWaveScale;
  909.                 r= ((1+2*wave_mystery)*(texsize/5.0)+
  910.                     (pcmdataL[x]-pcmdataL[x-1])*80*fWaveScale);
  912.                 glVertex3f(r*cos(theta)+(wave_x*texsize),r*sin(theta)+(wave_y*texsize),-1);
  913.             }
  915.             glEnd();
  917.             glPopMatrix();
  919.             break;
  921.         case 2://EXPERIMENTAL
  922.             wave_y=-1*(wave_y-1.0);
  923.             glPushMatrix();
  924.             glBegin(GL_LINE_STRIP);
  925.             double xx,yy;
  926.             // double xr= (wave_x*texsize), yr=(wave_y*texsize);
  927.             xx=0;
  928.             for ( x=1;x<512;x++)
  929.             {
  930.                 //xx = ((pcmdataL[x]-pcmdataL[x-1])*80*fWaveScale)*2;
  931.                 xx += (pcmdataL[x]*fWaveScale);
  932.                 yy= pcmdataL[x]*80*fWaveScale;
  933.                 //  glVertex3f( (wave_x*texsize)+(xx+yy)*2, (wave_y*texsize)+(xx-yy)*2,-1);
  934.                 glVertex3f( (wave_x*texsize)+(xx)*2, (wave_y*texsize)+(yy)*2,-1);
  937.                 //   xr+=fdata_buffer[fbuffer][0][x] *.0005* fWaveScale;
  938.                 //yr=(fdata_buffer[fbuffer][0][x]-fdata_buffer[fbuffer][0][x-1])*.05*fWaveScale+(wave_y*texsize);
  939.                 //glVertex3f(xr,yr,-1);
  941.             }
  942.             glEnd();
  943.             glPopMatrix();
  944.             break;
  946.         case 3://EXPERIMENTAL
  947.             glPushMatrix();
  948.             wave_y=-1*(wave_y-1.0);
  949.             glBegin(GL_LINE_STRIP);
  952.             for ( x=1;x<512;x++)
  953.             {
  954.                 xx= ((pcmdataL[x]-pcmdataL[x-1])*80*fWaveScale)*2;
  955.                 yy=pcmdataL[x]*80*fWaveScale,-1;
  956.                 glVertex3f( (wave_x*texsize)+(xx+yy)*cos(45), (wave_y*texsize)+(-yy+xx)*cos(45),-1);
  957.             }
  958.             glEnd();
  959.             glPopMatrix();
  960.             break;
  962.         case 4://single x-axis derivative waveform
  963.             glPushMatrix();
  964.             wave_y=-1*(wave_y-1.0);
  965.             glTranslatef(texsize*.5,texsize*.5, 0);
  966.             glRotated(-wave_mystery*90,0,0,1);
  967.             glTranslatef(-texsize*.5,-texsize*.5, 0);
  968.             wave_x=(wave_x*.75)+.125;      wave_x=-(wave_x-1);
  969.             glBegin(GL_LINE_STRIP);
  971.             double dy_adj;
  972.             for ( x=1;x<512;x++)
  973.             {
  974.                 dy_adj=  pcmdataL[x]*20*fWaveScale-pcmdataL[x-1]*20*fWaveScale;
  975.                 glVertex3f((x*scale)+dy_adj, pcmdataL[x]*20*fWaveScale+texsize*wave_x,-1);
  976.             }
  977.             glEnd();
  978.             glPopMatrix();
  979.             break;
  981.         case 5://EXPERIMENTAL
  982.             glPushMatrix();
  985.             wave_y=-1*(wave_y-1.0);
  986.             wave_x_temp=(wave_x*.75)+.125;
  987.             wave_x_temp=-(wave_x_temp-1);
  988.             glBegin(GL_LINE_STRIP);
  990.             for ( x=1;x<(512);x++)
  991.             {
  992.                 dy2_adj=  (pcmdataL[x]-pcmdataL[x-1])*20*fWaveScale;
  993.                 glVertex3f((wave_x_temp*texsize)+dy2_adj*2, pcmdataL[x]*20*fWaveScale+texsize*wave_y,-1);
  994.             }
  995.             glEnd();
  996.             glPopMatrix();
  997.             break;
  999.         case 6://single waveform
  1004.             glTranslatef(0,0, -1);
  1006.             //glMatrixMode(GL_MODELVIEW);
  1007.             glPushMatrix();
  1008.             //            glLoadIdentity();
  1010.             glTranslatef(texsize*.5,texsize*.5, 0);
  1011.             glRotated(-wave_mystery*90,0,0,1);
  1013.             wave_x_temp=-2*0.4142*(abs(abs(wave_mystery)-.5)-.5);
  1014.             glScalef(1.0+wave_x_temp,1.0,1.0);
  1015.             glTranslatef(-texsize*.5,-texsize*.5, 0);
  1016.             wave_x_temp=-1*(wave_x-1.0);
  1018.             glBegin(GL_LINE_STRIP);
  1019.             //      wave_x_temp=(wave_x*.75)+.125;
  1020.             //      wave_x_temp=-(wave_x_temp-1);
  1021.             for ( x=0;x<numsamples;x++)
  1022.             {
  1024.                 //glVertex3f(x*scale, fdata_buffer[fbuffer][0][blockstart+x]*.0012*fWaveScale+texsize*wave_x_temp,-1);
  1025.                 glVertex3f(x*texsize/(double)numsamples, pcmdataR[x]*20*fWaveScale+texsize*wave_x_temp,-1);
  1027.                 //glVertex3f(x*scale, texsize*wave_y_temp,-1);
  1028.             }
  1029.             //      printf("%f %fn",texsize*wave_y_temp,wave_y_temp);
  1030.             glEnd();
  1031.             glPopMatrix();
  1032.             break;
  1034.         case 7://dual waveforms
  1036.             glPushMatrix();
  1038.             glTranslatef(texsize*.5,texsize*.5, 0);
  1039.             glRotated(-wave_mystery*90,0,0,1);
  1041.             wave_x_temp=-2*0.4142*(abs(abs(wave_mystery)-.5)-.5);
  1042.             glScalef(1.0+wave_x_temp,1.0,1.0);
  1043.             glTranslatef(-texsize*.5,-texsize*.5, 0);
  1045.             wave_y_temp=-1*(wave_x-1);
  1047.             glBegin(GL_LINE_STRIP);
  1049.             for ( x=0;x<numsamples;x++)
  1050.             {
  1052.                 glVertex3f((x*texsize)/(double)numsamples, pcmdataL[x]*20*fWaveScale+texsize*(wave_y_temp+(wave_y*wave_y*.5)),-1);
  1053.             }
  1054.             glEnd();
  1056.             glBegin(GL_LINE_STRIP);
  1059.             for ( x=0;x<numsamples;x++)
  1060.             {
  1062.                 glVertex3f((x*texsize)/(double)numsamples, pcmdataR[x]*20*fWaveScale+texsize*(wave_y_temp-(wave_y*wave_y*.5)),-1);
  1063.             }
  1064.             glEnd();
  1065.             glPopMatrix();
  1066.             break;
  1068.         default:
  1069.             glBegin(GL_LINE_LOOP);
  1071.             for ( x=0;x<512;x++)
  1072.             {
  1073.                 theta=(x)*(6.28/512.0);
  1074.                 r= (texsize/5.0+pcmdataL[x]*.002);
  1076.                 glVertex3f(r*cos(theta)+(wave_x*texsize),r*sin(theta)+(wave_y*texsize),-1);
  1077.             }
  1078.             glEnd();
  1080.             glBegin(GL_LINE_STRIP);
  1082.             for ( x=0;x<512;x++)
  1083.             {
  1084.                 glVertex3f(x*scale, pcmdataL[x]*20*fWaveScale+(texsize*(wave_x+.1)),-1);
  1085.             }
  1086.             glEnd();
  1088.             glBegin(GL_LINE_STRIP);
  1090.             for ( x=0;x<512;x++)
  1091.             {
  1092.                 glVertex3f(x*scale, pcmdataR[x]*20*fWaveScale+(texsize*(wave_x-.1)),-1);
  1094.             }
  1095.             glEnd();
  1096.             break;
  1097.             if (bWaveThick==1)  glLineWidth(2*texsize/512);
  1098.     }
  1099.     glLineWidth(texsize/512);
  1100.     glDisable(GL_LINE_STIPPLE);
  1101. }
  1104. void maximize_colors()
  1105. {
  1106.     float wave_r_switch=0,wave_g_switch=0,wave_b_switch=0;
  1107.     //wave color brightening
  1108.     //
  1109.     //forces max color value to 1.0 and scales
  1110.     // the rest accordingly
  1112.     if (bMaximizeWaveColor==1)
  1113.     {
  1114.         if(wave_r>=wave_g && wave_r>=wave_b)   //red brightest
  1115.         {
  1116.             wave_b_switch=wave_b*(1/wave_r);
  1117.             wave_g_switch=wave_g*(1/wave_r);
  1118.             wave_r_switch=1.0;
  1119.         }
  1120.         else if   (wave_b>=wave_g && wave_b>=wave_r)         //blue brightest
  1121.         {
  1122.             wave_r_switch=wave_r*(1/wave_b);
  1123.             wave_g_switch=wave_g*(1/wave_b);
  1124.             wave_b_switch=1.0;
  1126.         }
  1128.         else  if (wave_g>=wave_b && wave_g>=wave_r)         //green brightest
  1129.         {
  1130.             wave_b_switch=wave_b*(1/wave_g);
  1131.             wave_r_switch=wave_r*(1/wave_g);
  1132.             wave_g_switch=1.0;
  1133.         }
  1134.         glColor4f(wave_r_switch, wave_g_switch, wave_b_switch, wave_o);
  1135.     }
  1136.     else
  1137.     {
  1138.         glColor4f(wave_r, wave_g, wave_b, wave_o);
  1139.     }
  1141. }
  1144. void modulate_opacity_by_volume()
  1146. {
  1147.     //modulate volume by opacity
  1148.     //
  1149.     //set an upper and lower bound and linearly
  1150.     //calculate the opacity from 0=lower to 1=upper
  1151.     //based on current volume
  1153.     if (bModWaveAlphaByVolume==1)
  1154.     {if (vol<=fModWaveAlphaStart)  wave_o=0.0;
  1155.         else if (vol>=fModWaveAlphaEnd) wave_o=fWaveAlpha;
  1156.         else wave_o=fWaveAlpha*((vol-fModWaveAlphaStart)/(fModWaveAlphaEnd-fModWaveAlphaStart));}
  1157.     else wave_o=fWaveAlpha;
  1158. }
  1161. void draw_motion_vectors()
  1162. {
  1163.     int x,y;
  1165.     double offsetx=mv_dx*texsize, intervalx=texsize/(double)mv_x;
  1166.     double offsety=mv_dy*texsize, intervaly=texsize/(double)mv_y;
  1168.     glPointSize(mv_l);
  1169.     glColor4f(mv_r, mv_g, mv_b, mv_a);
  1170.     glBegin(GL_POINTS);
  1171.     for (x=0;x<mv_x;x++){
  1172.         for(y=0;y<mv_y;y++){
  1173.             glVertex3f(offsetx+x*intervalx,offsety+y*intervaly,-1);
  1174.         }}
  1176.     glEnd();
  1177. }
  1180. void draw_borders()
  1181. {
  1182.     //no additive drawing for borders
  1183.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  1185.     glTranslatef(0,0,-1);
  1186.     //Draw Borders
  1187.     double of=texsize*ob_size*.5;
  1188.     double iff=(texsize*ib_size*.5);
  1189.     double texof=texsize-of;
  1191.     glColor4d(ob_r,ob_g,ob_b,ob_a);
  1193.     glRectd(0,0,of,texsize);
  1194.     glRectd(of,0,texof,of);
  1195.     glRectd(texof,0,texsize,texsize);
  1196.     glRectd(of,texsize,texof,texof);
  1197.     glColor4d(ib_r,ib_g,ib_b,ib_a);
  1198.     glRectd(of,of,of+iff,texof);
  1199.     glRectd(of+iff,of,texof-iff,of+iff);
  1200.     glRectd(texof-iff,of,texof,texof);
  1201.     glRectd(of+iff,texof,texof-iff,texof-iff);
  1202. }
  1205. //Here we render the interpolated mesh, and then apply the texture to it.
  1206. //Well, we actually do the inverse, but its all the same.
  1207. void render_interpolation()
  1208. {
  1210.     int x,y;
  1212.     glMatrixMode(GL_MODELVIEW);
  1213.     glLoadIdentity();
  1214.     glTranslated(0, 0, -9);
  1216.     glColor4f(0.0, 0.0, 0.0,decay);
  1218.     glEnable(GL_TEXTURE_2D);
  1220.     for (x=0;x<gx-1;x++)
  1221.     {
  1222.         glBegin(GL_TRIANGLE_STRIP);
  1223.         for(y=0;y<gy;y++)
  1224.         {
  1225.             glTexCoord4f(x_mesh[x][y], y_mesh[x][y],-1,1); glVertex4f(gridx[x][y], gridy[x][y],-1,1);
  1226.             glTexCoord4f(x_mesh[x+1][y], y_mesh[x+1][y],-1,1); glVertex4f(gridx[x+1][y], gridy[x+1][y],-1,1);
  1227.         }
  1228.         glEnd();
  1229.     }
  1230.     glDisable(GL_TEXTURE_2D);
  1231. }
  1234. void do_per_frame()
  1235. {
  1236.     //Texture wrapping( clamp vs. wrap)
  1237.     if (bTexWrap==0)
  1238.     {
  1239.         glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
  1240.         glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
  1241.     }
  1242.     else
  1243.     {
  1244.         glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  1245.         glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  1246.     }
  1249.     //      glRasterPos2i(0,0);
  1250.     //      glClear(GL_COLOR_BUFFER_BIT);
  1251.     //      glColor4d(0.0, 0.0, 0.0,1.0);
  1253.     //      glMatrixMode(GL_TEXTURE);
  1254.     //  glLoadIdentity();
  1256.     glRasterPos2i(0,0);
  1257.     glClear(GL_COLOR_BUFFER_BIT);
  1258.     glColor4d(0.0, 0.0, 0.0,1.0);
  1260.     glMatrixMode(GL_TEXTURE);
  1261.     glLoadIdentity();
  1263.     glTranslatef(cx,cy, 0);
  1264.     if(correction)  glScalef(1,vw/(double)vh,1);
  1266.     if(!isPerPixelEqn(ROT_OP))
  1267.     {
  1268.         //    printf("ROTATING: rot = %fn", rot);
  1269.         glRotatef(rot*90, 0, 0, 1);
  1270.     }
  1271.     if(!isPerPixelEqn(SX_OP)) glScalef(1/sx,1,1);
  1272.     if(!isPerPixelEqn(SY_OP)) glScalef(1,1/sy,1);
  1274.     if(correction) glScalef(1,vh/(double)vw,1);
  1275.     glTranslatef((-cx) ,(-cy),0);
  1277.     if(!isPerPixelEqn(DX_OP)) glTranslatef(-dx,0,0);
  1278.     if(!isPerPixelEqn(DY_OP)) glTranslatef(0 ,-dy,0);
  1280. }
  1283. //Actually draws the texture to the screen
  1284. //
  1285. //The Video Echo effect is also applied here
  1286. void render_texture_to_screen()
  1287. {
  1288.     glMatrixMode(GL_TEXTURE);
  1289.     glLoadIdentity();
  1291.     glMatrixMode(GL_MODELVIEW);
  1292.     glLoadIdentity();
  1293.     glTranslatef(0, 0, -9);
  1295.     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  1296.     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  1298.     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,  GL_DECAL);
  1299.     glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
  1301.     //       glClear(GL_ACCUM_BUFFER_BIT);
  1302.     glColor4d(0.0, 0.0, 0.0,1.0f);
  1304.     glBegin(GL_QUADS);
  1305.     glVertex4d(-vw*.5,-vh*.5,-1,1);
  1306.     glVertex4d(-vw*.5,  vh*.5,-1,1);
  1307.     glVertex4d(vw*.5,  vh*.5,-1,1);
  1308.     glVertex4d(vw*.5, -vh*.5,-1,1);
  1309.     glEnd();
  1311.     //      glBindTexture( GL_TEXTURE_2D, tex2 );
  1312.     glEnable(GL_TEXTURE_2D);
  1314.     // glAccum(GL_LOAD,0);
  1315.     // if (bDarken==1)  glBlendFunc(GL_SRC_COLOR,GL_ZERO);
  1317.     //Draw giant rectangle and texture it with our texture!
  1318.     glBegin(GL_QUADS);
  1319.     glTexCoord4d(0, 1,0,1); glVertex4d(-vw*.5,-vh*.5,-1,1);
  1320.     glTexCoord4d(0, 0,0,1); glVertex4d(-vw*.5,  vh*.5,-1,1);
  1321.     glTexCoord4d(1, 0,0,1); glVertex4d(vw*.5,  vh*.5,-1,1);
  1322.     glTexCoord4d(1, 1,0,1); glVertex4d(vw*.5, -vh*.5,-1,1);
  1323.     glEnd();
  1325.     glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  1327.     //  if (bDarken==1)  glBlendFunc(GL_SRC_COLOR,GL_ONE_MINUS_SRC_ALPHA);
  1329.     // if (bDarken==1) { glAccum(GL_ACCUM,1-fVideoEchoAlpha); glBlendFunc(GL_SRC_COLOR,GL_ZERO); }
  1331.     glMatrixMode(GL_TEXTURE);
  1333.     //draw video echo
  1334.     glColor4f(0.0, 0.0, 0.0,fVideoEchoAlpha);
  1335.     glTranslated(.5,.5,0);
  1336.     glScaled(1/fVideoEchoZoom,1/fVideoEchoZoom,1);
  1337.     glTranslated(-.5,-.5,0);
  1339.     int flipx=1,flipy=1;
  1340.     switch (((int)nVideoEchoOrientation))
  1341.     {
  1342.         case 0: flipx=1;flipy=1;break;
  1343.         case 1: flipx=-1;flipy=1;break;
  1344.         case 2: flipx=1;flipy=-1;break;
  1345.         case 3: flipx=-1;flipy=-1;break;
  1346.         default: flipx=1;flipy=1; break;
  1347.     }
  1348.     glBegin(GL_QUADS);
  1349.     glTexCoord4d(0, 1,0,1); glVertex4f(-vw*.5*flipx,-vh*.5*flipy,-1,1);
  1350.     glTexCoord4d(0, 0,0,1); glVertex4f(-vw*.5*flipx,  vh*.5*flipy,-1,1);
  1351.     glTexCoord4d(1, 0,0,1); glVertex4f(vw*.5*flipx,  vh*.5*flipy,-1,1);
  1352.     glTexCoord4d(1, 1,0,1); glVertex4f(vw*.5*flipx, -vh*.5*flipy,-1,1);
  1353.     glEnd();
  1356.     glDisable(GL_TEXTURE_2D);
  1357.     glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  1359.     // if (bDarken==1) { glAccum(GL_ACCUM,fVideoEchoAlpha); glAccum(GL_RETURN,1);}
  1361.     if (bInvert==1)
  1362.     {
  1363.         glColor4f(1.0, 1.0, 1.0,1.0);
  1364.         glBlendFunc(GL_ONE_MINUS_DST_COLOR,GL_ZERO);
  1365.         glBegin(GL_QUADS);
  1366.         glVertex4f(-vw*.5*flipx,-vh*.5*flipy,-1,1);
  1367.         glVertex4f(-vw*.5*flipx,  vh*.5*flipy,-1,1);
  1368.         glVertex4f(vw*.5*flipx,  vh*.5*flipy,-1,1);
  1369.         glVertex4f(vw*.5*flipx, -vh*.5*flipy,-1,1);
  1370.         glEnd();
  1371.         glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  1372.     }
  1373. }
  1376. void render_texture_to_studio()
  1377. {
  1378.     glMatrixMode(GL_TEXTURE);
  1379.     glLoadIdentity();
  1381.     glMatrixMode(GL_MODELVIEW);
  1382.     glLoadIdentity();
  1383.     glTranslatef(0, 0, -9);
  1385.     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  1386.     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  1388.     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,  GL_DECAL);
  1389.     glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
  1391.     //       glClear(GL_ACCUM_BUFFER_BIT);
  1392.     glColor4f(0.0, 0.0, 0.0,0.04);
  1394.     glVertex4d(-vw*.5,-vh*.5,-1,1);
  1395.     glVertex4d(-vw*.5,  vh*.5,-1,1);
  1396.     glVertex4d(vw*.5,  vh*.5,-1,1);
  1397.     glVertex4d(vw*.5, -vh*.5,-1,1);
  1398.     glEnd();
  1400.     glColor4f(0.0, 0.0, 0.0,1.0);
  1402.     glBegin(GL_QUADS);
  1403.     glVertex4d(-vw*.5,0,-1,1);
  1404.     glVertex4d(-vw*.5,  vh*.5,-1,1);
  1405.     glVertex4d(vw*.5,  vh*.5,-1,1);
  1406.     glVertex4d(vw*.5, 0,-1,1);
  1407.     glEnd();
  1409.     glBegin(GL_QUADS);
  1410.     glVertex4d(0,-vh*.5,-1,1);
  1411.     glVertex4d(0,  vh*.5,-1,1);
  1412.     glVertex4d(vw*.5,  vh*.5,-1,1);
  1413.     glVertex4d(vw*.5, -vh*.5,-1,1);
  1414.     glEnd();
  1416.     glPushMatrix();
  1417.     glTranslatef(.25*vw, .25*vh, 0);
  1418.     glScalef(.5,.5,1);
  1420.     //      glBindTexture( GL_TEXTURE_2D, tex2 );
  1421.     glEnable(GL_TEXTURE_2D);
  1423.     // glAccum(GL_LOAD,0);
  1424.     // if (bDarken==1)  glBlendFunc(GL_SRC_COLOR,GL_ZERO);
  1426.     //Draw giant rectangle and texture it with our texture!
  1427.     glBegin(GL_QUADS);
  1428.     glTexCoord4d(0, 1,0,1); glVertex4d(-vw*.5,-vh*.5,-1,1);
  1429.     glTexCoord4d(0, 0,0,1); glVertex4d(-vw*.5,  vh*.5,-1,1);
  1430.     glTexCoord4d(1, 0,0,1); glVertex4d(vw*.5,  vh*.5,-1,1);
  1431.     glTexCoord4d(1, 1,0,1); glVertex4d(vw*.5, -vh*.5,-1,1);
  1432.     glEnd();
  1434.     glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  1436.     //  if (bDarken==1)  glBlendFunc(GL_SRC_COLOR,GL_ONE_MINUS_SRC_ALPHA);
  1438.     // if (bDarken==1) { glAccum(GL_ACCUM,1-fVideoEchoAlpha); glBlendFunc(GL_SRC_COLOR,GL_ZERO); }
  1440.     glMatrixMode(GL_TEXTURE);
  1442.     //draw video echo
  1443.     glColor4f(0.0, 0.0, 0.0,fVideoEchoAlpha);
  1444.     glTranslated(.5,.5,0);
  1445.     glScaled(1/fVideoEchoZoom,1/fVideoEchoZoom,1);
  1446.     glTranslated(-.5,-.5,0);
  1448.     int flipx=1,flipy=1;
  1449.     switch (((int)nVideoEchoOrientation))
  1450.     {
  1451.         case 0: flipx=1;flipy=1;break;
  1452.         case 1: flipx=-1;flipy=1;break;
  1453.         case 2: flipx=1;flipy=-1;break;
  1454.         case 3: flipx=-1;flipy=-1;break;
  1455.         default: flipx=1;flipy=1; break;
  1456.     }
  1457.     glBegin(GL_QUADS);
  1458.     glTexCoord4d(0, 1,0,1); glVertex4f(-vw*.5*flipx,-vh*.5*flipy,-1,1);
  1459.     glTexCoord4d(0, 0,0,1); glVertex4f(-vw*.5*flipx,  vh*.5*flipy,-1,1);
  1460.     glTexCoord4d(1, 0,0,1); glVertex4f(vw*.5*flipx,  vh*.5*flipy,-1,1);
  1461.     glTexCoord4d(1, 1,0,1); glVertex4f(vw*.5*flipx, -vh*.5*flipy,-1,1);
  1462.     glEnd();
  1464.     glDisable(GL_TEXTURE_2D);
  1465.     glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  1467.     // if (bDarken==1) { glAccum(GL_ACCUM,fVideoEchoAlpha); glAccum(GL_RETURN,1);}
  1470.     if (bInvert==1)
  1471.     {
  1472.         glColor4f(1.0, 1.0, 1.0,1.0);
  1473.         glBlendFunc(GL_ONE_MINUS_DST_COLOR,GL_ZERO);
  1474.         glBegin(GL_QUADS);
  1475.         glVertex4f(-vw*.5*flipx,-vh*.5*flipy,-1,1);
  1476.         glVertex4f(-vw*.5*flipx,  vh*.5*flipy,-1,1);
  1477.         glVertex4f(vw*.5*flipx,  vh*.5*flipy,-1,1);
  1478.         glVertex4f(vw*.5*flipx, -vh*.5*flipy,-1,1);
  1479.         glEnd();
  1480.         glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  1481.     }
  1483.     //  glTranslated(.5,.5,0);
  1484.     //  glScaled(1/fVideoEchoZoom,1/fVideoEchoZoom,1);
  1485.     //   glTranslated(-.5,-.5,0);
  1486.     //glTranslatef(0,.5*vh,0);
  1488.     //per_pixel monitor
  1489.     //glBlendFunc(GL_ONE_MINUS_DST_COLOR,GL_ZERO);
  1490.     int x,y;
  1491.     glMatrixMode(GL_MODELVIEW);
  1492.     glPopMatrix();
  1493.     glPushMatrix();
  1494.     glTranslatef(.25*vw, -.25*vh, 0);
  1495.     glScalef(.5,.5,1);
  1496.     glColor4f(1,1,1,.6);
  1498.     for (x=0;x<gx;x++)
  1499.     {
  1500.         glBegin(GL_LINE_STRIP);
  1501.         for(y=0;y<gy;y++)
  1502.         {
  1503.             glVertex4f((x_mesh[x][y]-.5)* vw, (y_mesh[x][y]-.5)*vh,-1,1);
  1504.             //glVertex4f((origx[x+1][y]-.5) * vw, (origy[x+1][y]-.5) *vh ,-1,1);
  1505.         }
  1506.         glEnd();
  1507.     }
  1509.     for (y=0;y<gy;y++)
  1510.     {
  1511.         glBegin(GL_LINE_STRIP);
  1512.         for(x=0;x<gx;x++)
  1513.         {
  1514.             glVertex4f((x_mesh[x][y]-.5)* vw, (y_mesh[x][y]-.5)*vh,-1,1);
  1515.             //glVertex4f((origx[x+1][y]-.5) * vw, (origy[x+1][y]-.5) *vh ,-1,1);
  1516.         }
  1517.         glEnd();
  1518.     }
  1520.     /*
  1521.        for (x=0;x<gx-1;x++){
  1522.        glBegin(GL_POINTS);
  1523.        for(y=0;y<gy;y++){
  1524.        glVertex4f((origx[x][y]-.5)* vw, (origy[x][y]-.5)*vh,-1,1);
  1525.        glVertex4f((origx[x+1][y]-.5) * vw, (origy[x+1][y]-.5) *vh ,-1,1);
  1526.        }
  1527.        glEnd();
  1528.        }
  1529.      */
  1530.     // glTranslated(-.5,-.5,0);     glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  1531.     glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  1532.     glMatrixMode(GL_MODELVIEW);
  1533.     glPopMatrix();
  1534.     glPushMatrix();
  1535.     glTranslatef(-.5*vw,0, 0);
  1538.     glTranslatef(0,-vh*.10, 0);
  1539.     glBegin(GL_LINE_STRIP);
  1540.     glColor4f(0,1.0,1.0,1.0);
  1541.     glVertex3f((((totalframes%256)/551.0))*vw, treb_att*-7,-1);
  1542.     glColor4f(1.0,1.0,1.0,1.0);
  1543.     glVertex3f((((totalframes%256)/551.0))*vw,0 ,-1);
  1544.     glColor4f(.5,1.0,1.0,1.0);
  1545.     glVertex3f((((totalframes%256)/551.0))*vw, treb*7,-1);
  1546.     glEnd();
  1548.     glTranslatef(0,-vh*.13, 0);
  1549.     glBegin(GL_LINE_STRIP);
  1550.     glColor4f(0,1.0,0.0,1.0);
  1551.     glVertex3f((((totalframes%256)/551.0))*vw, mid_att*-7,-1);
  1552.     glColor4f(1.0,1.0,1.0,1.0);
  1553.     glVertex3f((((totalframes%256)/551.0))*vw,0 ,-1);
  1554.     glColor4f(.5,1.0,0.0,0.5);
  1555.     glVertex3f((((totalframes%256)/551.0))*vw, mid*7,-1);
  1556.     glEnd();
  1558.     glTranslatef(0,-vh*.13, 0);
  1559.     glBegin(GL_LINE_STRIP);
  1560.     glColor4f(1.0,0.0,0.0,1.0);
  1561.     glVertex3f((((totalframes%256)/551.0))*vw, bass_att*-7,-1);
  1562.     glColor4f(1.0,1.0,1.0,1.0);
  1563.     glVertex3f((((totalframes%256)/551.0))*vw,0 ,-1);
  1564.     glColor4f(.7,0.2,0.2,1.0);
  1565.     glVertex3f((((totalframes%256)/551.0))*vw, bass*7,-1);
  1566.     glEnd();
  1568.     glTranslatef(0,-vh*.13, 0);
  1569.     glBegin(GL_LINES);
  1571.     glColor4f(1.0,1.0,1.0,1.0);
  1572.     glVertex3f((((totalframes%256)/551.0))*vw,0 ,-1);
  1573.     glColor4f(1.0,0.6,1.0,1.0);
  1574.     glVertex3f((((totalframes%256)/551.0))*vw, vol*7,-1);
  1575.     glEnd();
  1577.     glPopMatrix();
  1578. }