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