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       exit(1);
 103    }
 104
 105    fprintf(stderr, "%.*s\n", sz, buf);
 106
 107    if (strncmp( buf, "!!VP", 4 ) == 0) {
 108       glEnable( GL_VERTEX_PROGRAM_NV );
 109       glGenProgramsNV( 1, &prognum );
 110       glBindProgramNV( GL_VERTEX_PROGRAM_NV, prognum );
 111       glLoadProgramNV( GL_VERTEX_PROGRAM_NV, prognum, sz, (const GLubyte *) buf );
 112       assert( glIsProgramNV( prognum ) );
 113    }
 114    else {
 115       glEnable(GL_VERTEX_PROGRAM_ARB);
 116
 117       glGenProgramsARB(1, &prognum);
 118
 119       glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prognum);
 120       glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
 121                         sz, (const GLubyte *) buf);
 122       if (glGetError()) {
 123          printf("Program failed to compile:\n%s\n", buf);
 124          printf("Error: %s\n",
 125                 (char *) glGetString(GL_PROGRAM_ERROR_STRING_ARB));
 126          exit(1);
 127       }
 128       assert(glIsProgramARB(prognum));
 129    }
 130
 131    errno = glGetError();
 132    printf("glGetError = %d\n", errno);
 133    if (errno != GL_NO_ERROR)
 134    {
 135       GLint errorpos;
 136
 137       glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorpos);
 138       printf("errorpos: %d\n", errorpos);
 139       printf("%s\n", (char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB));
 140    }
 141
 142    {
 143       const float Ambient[4] = { 0.0, 1.0, 0.0, 0.0 };
 144       const float Diffuse[4] = { 1.0, 0.0, 0.0, 0.0 };
 145       const float Specular[4] = { 0.0, 0.0, 1.0, 0.0 };
 146       const float Emission[4] = { 0.0, 0.0, 0.0, 1.0 };
 147       glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, Ambient);
 148       glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, Diffuse);
 149       glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, Specular);
 150       glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, Emission);
 151    }
 152 }
 153
 154
 155 union vert {
 156    struct {
 157       GLfloat color[3];
 158       GLfloat pos[3];
 159    } v;
 160    GLfloat f[6];
 161 };
 162
 163 static void make_midpoint( union vert *out,
 164                            const union vert *v0,
 165                            const union vert *v1)
 166 {
 167    int i;
 168    for (i = 0; i < 6; i++)
 169       out->f[i] = v0->f[i] + .5 * (v1->f[i] - v0->f[i]);
 170 }
 171
 172 static void subdiv( union vert *v0,
 173                     union vert *v1,
 174                     union vert *v2,
 175                     GLuint depth )
 176 {
 177    if (depth == 0) {
 178       glColor3fv(v0->v.color);
 179       glVertex3fv(v0->v.pos);
 180       glColor3fv(v1->v.color);
 181       glVertex3fv(v1->v.pos);
 182       glColor3fv(v2->v.color);
 183       glVertex3fv(v2->v.pos);
 184    }
 185    else {
 186       union vert m[3];
 187
 188       make_midpoint(&m[0], v0, v1);
 189       make_midpoint(&m[1], v1, v2);
 190       make_midpoint(&m[2], v2, v0);
 191
 192       subdiv(&m[0], &m[2], v0, depth-1);
 193       subdiv(&m[1], &m[0], v1, depth-1);
 194       subdiv(&m[2], &m[1], v2, depth-1);
 195       subdiv(&m[0], &m[1], &m[2], depth-1);
 196    }
 197 }
 198
 199 static void enable( GLenum value, GLboolean flag )
 200 {
 201    if (flag)
 202       glEnable(value);
 203    else
 204       glDisable(value);
 205 }
 206
 207 /** Assignment */
 208 #define ASSIGN_3V( V, V0, V1, V2 )  \
 209 do {                                \
 210     V[0] = V0;                      \
 211     V[1] = V1;                      \
 212     V[2] = V2;                      \
 213 } while(0)
 214
 215 static void Display( void )
 216 {
 217    glClearColor(0.3, 0.3, 0.3, 1);
 218    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 219    glPointSize(psz);
 220
 221    enable( GL_POINT_SMOOTH, pointsmooth );
 222    enable( GL_VERTEX_PROGRAM_POINT_SIZE_ARB, program_point_size );
 223
 224    glBegin(prim);
 225
 226
 227    {
 228       union vert v[3];
 229
 230       ASSIGN_3V(v[0].v.color, 0,0,1);
 231       ASSIGN_3V(v[0].v.pos,  0.9, -0.9, 0.0);
 232       ASSIGN_3V(v[1].v.color, 1,0,0);
 233       ASSIGN_3V(v[1].v.pos, 0.9, 0.9, 0.0);
 234       ASSIGN_3V(v[2].v.color, 0,1,0);
 235       ASSIGN_3V(v[2].v.pos, -0.9, 0, 0.0);
 236
 237       subdiv(&v[0], &v[1], &v[2], nr_steps);
 238    }
 239
 240    glEnd();
 241
 242
 243    glFlush();
 244    if (show_fps) {
 245       ++frame_cnt;
 246       glutPostRedisplay();
 247    }
 248 }
 249
 250
 251 static void Reshape( int width, int height )
 252 {
 253    glViewport( 0, 0, width, height );
 254    glMatrixMode( GL_PROJECTION );
 255    glLoadIdentity();
 256    glOrtho(-1.0, 1.0, -1.0, 1.0, -0.5, 1000.0);
 257    glMatrixMode( GL_MODELVIEW );
 258    glLoadIdentity();
 259    /*glTranslatef( 0.0, 0.0, -15.0 );*/
 260 }
 261
 262
 263 static void Key( unsigned char key, int x, int y )
 264 {
 265    (void) x;
 266    (void) y;
 267    switch (key) {
 268    case 'p':
 269       prim = GL_POINTS;
 270       break;
 271    case 't':
 272       prim = GL_TRIANGLES;
 273       break;
 274    case 's':
 275       psz += .5;
 276       break;
 277    case 'S':
 278       if (psz > .5)
 279          psz -= .5;
 280       break;
 281    case 'm':
 282       pointsmooth = !pointsmooth;
 283       break;
 284    case 'z':
 285       program_point_size = !program_point_size;
 286       break;
 287    case '+':
 288       nr_steps++;
 289       break;
 290    case '-':
 291       if (nr_steps)
 292          nr_steps--;
 293       break;
 294    case ' ':
 295       psz = 1.0;
 296       prim = GL_TRIANGLES;
 297       nr_steps = 4;
 298       break;
 299    case 27:
 300       exit(0);
 301       break;
 302    }
 303    glutPostRedisplay();
 304 }
 305
 306
 307
 308
 309 int main( int argc, char *argv[] )
 310 {
 311    glutInit( &argc, argv );
 312    glutInitWindowPosition( 0, 0 );
 313    glutInitWindowSize( 250, 250 );
 314    glutInitDisplayMode( GLUT_RGB | GLUT_SINGLE | GLUT_DEPTH );
 315    glutCreateWindow(argv[argc-1]);
 316    glewInit();
 317    glutReshapeFunc( Reshape );
 318    glutKeyboardFunc( Key );
 319    glutDisplayFunc( Display );
 320    args( argc, argv );
 321    Init();
 322 #ifndef WIN32
 323    if (show_fps) {
 324       signal(SIGALRM, alarmhandler);
 325       alarm(5);
 326    }
 327 #endif
 328    glutMainLoop();
 329    return 0;
 330 }