progs/vp/vp-tris.c

   1 /* Test glGenProgramsNV(), glIsProgramNV(), glLoadProgramNV() */
   2
   3 #include <assert.h>
   4 #include <string.h>
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <math.h>
   8
   9 #ifndef WIN32
  10 #include <unistd.h>
  11 #include <signal.h>
  12 #endif
  13
  14 #include <GL/glew.h>
  15 #include <GL/glut.h>
  16
  17 static const char *filename = NULL;
  18 static GLuint nr_steps = 4;
  19 static GLuint prim = GL_TRIANGLES;
  20 static GLfloat psz = 1.0;
  21
  22 static void usage( char *name )
  23 {
  24    fprintf( stderr, "usage: %s [ options ] shader_filename\n", name );
  25    fprintf( stderr, "\n" );
  26    fprintf( stderr, "options:\n" );
  27    fprintf( stderr, "    -f     flat shaded\n" );
  28    fprintf( stderr, "    -nNr  subdivision steps\n" );
  29    fprintf( stderr, "    -fps  show frames per second\n" );
  30 }
  31
  32 unsigned show_fps = 0;
  33 unsigned int frame_cnt = 0;
  34
  35 #ifndef WIN32
  36
  37 void alarmhandler(int);
  38
  39 void alarmhandler (int sig)
  40 {
  41    if (sig == SIGALRM) {
  42       printf("%d frames in 5.0 seconds = %.3f FPS\n", frame_cnt,
  43              frame_cnt / 5.0);
  44
  45       frame_cnt = 0;
  46    }
  47    signal(SIGALRM, alarmhandler);
  48    alarm(5);
  49 }
  50
  51 #endif
  52
  53 static void args(int argc, char *argv[])
  54 {
  55    GLint i;
  56
  57    for (i = 1; i < argc; i++) {
  58       if (strncmp(argv[i], "-n", 2) == 0) {
  59          nr_steps = atoi((argv[i]) + 2);
  60       }
  61       else if (strcmp(argv[i], "-f") == 0) {
  62          glShadeModel(GL_FLAT);
  63       }
  64       else if (strcmp(argv[i], "-fps") == 0) {
  65          show_fps = 1;
  66       }
  67       else if (i == argc - 1) {
  68          filename = argv[i];
  69       }
  70       else {
  71          usage(argv[0]);
  72          exit(1);
  73       }
  74    }
  75
  76    if (!filename) {
  77       usage(argv[0]);
  78       exit(1);
  79    }
  80 }
  81
  82
  83
  84 static void Init( void )
  85 {
  86    GLint errno;
  87    GLuint prognum;
  88    char buf[4096];
  89    GLuint sz;
  90    FILE *f;
  91
  92    if ((f = fopen(filename, "r")) == NULL) {
  93       fprintf(stderr, "couldn't open %s\n", filename);
  94       exit(1);
  95    }
  96
  97    sz = (GLuint) fread(buf, 1, sizeof(buf), f);
  98    if (!feof(f)) {
  99       fprintf(stderr, "file too long\n");
 100       exit(1);
 101    }
 102
 103    fprintf(stderr, "%.*s\n", sz, buf);
 104
 105    if (strncmp( buf, "!!VP", 4 ) == 0) {
 106       glEnable( GL_VERTEX_PROGRAM_NV );
 107       glGenProgramsNV( 1, &prognum );
 108       glBindProgramNV( GL_VERTEX_PROGRAM_NV, prognum );
 109       glLoadProgramNV( GL_VERTEX_PROGRAM_NV, prognum, sz, (const GLubyte *) buf );
 110       assert( glIsProgramNV( prognum ) );
 111    }
 112    else {
 113       glEnable(GL_VERTEX_PROGRAM_ARB);
 114
 115       glGenProgramsARB(1, &prognum);
 116
 117       glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prognum);
 118       glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
 119                         sz, (const GLubyte *) buf);
 120       assert(glIsProgramARB(prognum));
 121    }
 122
 123    errno = glGetError();
 124    printf("glGetError = %d\n", errno);
 125    if (errno != GL_NO_ERROR)
 126    {
 127       GLint errorpos;
 128
 129       glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorpos);
 130       printf("errorpos: %d\n", errorpos);
 131       printf("%s\n", (char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB));
 132    }
 133
 134    {
 135       const float Ambient[4] = { 0.0, 1.0, 0.0, 0.0 };
 136       const float Diffuse[4] = { 1.0, 0.0, 0.0, 0.0 };
 137       const float Specular[4] = { 0.0, 0.0, 1.0, 0.0 };
 138       const float Emission[4] = { 0.0, 0.0, 0.0, 1.0 };
 139       glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, Ambient);
 140       glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, Diffuse);
 141       glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, Specular);
 142       glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, Emission);
 143    }
 144 }
 145
 146
 147 union vert {
 148    struct {
 149       GLfloat color[3];
 150       GLfloat pos[3];
 151    } v;
 152    GLfloat f[6];
 153 };
 154
 155 static void make_midpoint( union vert *out,
 156                            const union vert *v0,
 157                            const union vert *v1)
 158 {
 159    int i;
 160    for (i = 0; i < 6; i++)
 161       out->f[i] = v0->f[i] + .5 * (v1->f[i] - v0->f[i]);
 162 }
 163
 164 static void subdiv( union vert *v0,
 165                     union vert *v1,
 166                     union vert *v2,
 167                     GLuint depth )
 168 {
 169    if (depth == 0) {
 170       glColor3fv(v0->v.color);
 171       glVertex3fv(v0->v.pos);
 172       glColor3fv(v1->v.color);
 173       glVertex3fv(v1->v.pos);
 174       glColor3fv(v2->v.color);
 175       glVertex3fv(v2->v.pos);
 176    }
 177    else {
 178       union vert m[3];
 179
 180       make_midpoint(&m[0], v0, v1);
 181       make_midpoint(&m[1], v1, v2);
 182       make_midpoint(&m[2], v2, v0);
 183
 184       subdiv(&m[0], &m[2], v0, depth-1);
 185       subdiv(&m[1], &m[0], v1, depth-1);
 186       subdiv(&m[2], &m[1], v2, depth-1);
 187       subdiv(&m[0], &m[1], &m[2], depth-1);
 188    }
 189 }
 190
 191 /** Assignment */
 192 #define ASSIGN_3V( V, V0, V1, V2 )  \
 193 do {                                \
 194     V[0] = V0;                      \
 195     V[1] = V1;                      \
 196     V[2] = V2;                      \
 197 } while(0)
 198
 199 static void Display( void )
 200 {
 201    glClearColor(0.3, 0.3, 0.3, 1);
 202    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 203    glPointSize(psz);
 204
 205    glBegin(prim);
 206
 207
 208    {
 209       union vert v[3];
 210
 211       ASSIGN_3V(v[0].v.color, 0,0,1);
 212       ASSIGN_3V(v[0].v.pos,  0.9, -0.9, 0.0);
 213       ASSIGN_3V(v[1].v.color, 1,0,0);
 214       ASSIGN_3V(v[1].v.pos, 0.9, 0.9, 0.0);
 215       ASSIGN_3V(v[2].v.color, 0,1,0);
 216       ASSIGN_3V(v[2].v.pos, -0.9, 0, 0.0);
 217
 218       subdiv(&v[0], &v[1], &v[2], nr_steps);
 219    }
 220
 221    glEnd();
 222
 223
 224    glFlush();
 225    if (show_fps) {
 226       ++frame_cnt;
 227       glutPostRedisplay();
 228    }
 229 }
 230
 231
 232 static void Reshape( int width, int height )
 233 {
 234    glViewport( 0, 0, width, height );
 235    glMatrixMode( GL_PROJECTION );
 236    glLoadIdentity();
 237    glOrtho(-1.0, 1.0, -1.0, 1.0, -0.5, 1000.0);
 238    glMatrixMode( GL_MODELVIEW );
 239    glLoadIdentity();
 240    /*glTranslatef( 0.0, 0.0, -15.0 );*/
 241 }
 242
 243
 244 static void Key( unsigned char key, int x, int y )
 245 {
 246    (void) x;
 247    (void) y;
 248    switch (key) {
 249    case 'p':
 250       prim = GL_POINTS;
 251       break;
 252    case 't':
 253       prim = GL_TRIANGLES;
 254       break;
 255    case 's':
 256       psz += .5;
 257       break;
 258    case 'S':
 259       if (psz > .5)
 260          psz -= .5;
 261       break;
 262    case '+':
 263       nr_steps++;
 264       break;
 265    case '-':
 266       if (nr_steps)
 267          nr_steps--;
 268       break;
 269    case ' ':
 270       psz = 1.0;
 271       prim = GL_TRIANGLES;
 272       nr_steps = 4;
 273       break;
 274    case 27:
 275       exit(0);
 276       break;
 277    }
 278    glutPostRedisplay();
 279 }
 280
 281
 282
 283
 284 int main( int argc, char *argv[] )
 285 {
 286    glutInit( &argc, argv );
 287    glutInitWindowPosition( 0, 0 );
 288    glutInitWindowSize( 250, 250 );
 289    glutInitDisplayMode( GLUT_RGB | GLUT_SINGLE | GLUT_DEPTH );
 290    glutCreateWindow(argv[argc-1]);
 291    glewInit();
 292    glutReshapeFunc( Reshape );
 293    glutKeyboardFunc( Key );
 294    glutDisplayFunc( Display );
 295    args( argc, argv );
 296    Init();
 297 #ifndef WIN32
 298    if (show_fps) {
 299       signal(SIGALRM, alarmhandler);
 300       alarm(5);
 301    }
 302 #endif
 303    glutMainLoop();
 304    return 0;
 305 }