progs/tests/vparray.c

   1 /*
   2  * Test vertex arrays with GL_NV_vertex_program
   3  *
   4  * Based on a stripped-down version of the isosurf demo.
   5  * The vertex program is trivial: compute the resulting
   6  * RGB color as a linear function of vertex XYZ.
   7  */
   8
   9 #include <assert.h>
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <math.h>
  15 #define GL_GLEXT_PROTOTYPES
  16 #include "GL/glut.h"
  17
  18 #define MAXVERTS 10000
  19 static float data[MAXVERTS][6];
  20 static GLint numverts;
  21
  22 static GLfloat xrot;
  23 static GLfloat yrot;
  24 static GLboolean useArrays = GL_FALSE;
  25 static GLboolean useProgram = GL_FALSE;
  26
  27
  28 static void read_surface( char *filename )
  29 {
  30    FILE *f;
  31
  32    f = fopen(filename,"r");
  33    if (!f) {
  34       printf("couldn't read %s\n", filename);
  35       exit(1);
  36    }
  37
  38    numverts = 0;
  39    while (!feof(f) && numverts < MAXVERTS) {
  40       fscanf( f, "%f %f %f  %f %f %f",
  41               &data[numverts][0], &data[numverts][1], &data[numverts][2],
  42               &data[numverts][3], &data[numverts][4], &data[numverts][5] );
  43       numverts++;
  44    }
  45    numverts--;
  46
  47    printf("%d vertices, %d triangles\n", numverts, numverts-2);
  48    printf("data = %p\n", (void *) data);
  49    fclose(f);
  50 }
  51
  52
  53
  54
  55 static void Display(void)
  56 {
  57    if (useProgram)
  58       glEnable(GL_VERTEX_PROGRAM_NV);
  59    else
  60       glDisable(GL_VERTEX_PROGRAM_NV);
  61
  62    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
  63
  64    glPushMatrix();
  65       glRotatef(xrot, 1, 0, 0);
  66       glRotatef(yrot, 0, 1, 0);
  67       glScalef(2, 2, 2);
  68       if (useArrays) {
  69          if (useProgram) {
  70             glVertexAttribPointerNV( 0, 3, GL_FLOAT, 6 * sizeof(GLfloat), data );
  71             glEnableClientState( GL_VERTEX_ATTRIB_ARRAY0_NV );
  72          }
  73          else {
  74             glVertexPointer( 3, GL_FLOAT, 6 * sizeof(GLfloat), data );
  75             glEnableClientState( GL_VERTEX_ARRAY );
  76          }
  77          glNormalPointer( GL_FLOAT, 6 * sizeof(GLfloat), ((GLfloat *) data) + 3);
  78          glEnableClientState( GL_NORMAL_ARRAY );
  79
  80          glDrawArrays(GL_TRIANGLE_STRIP, 0, numverts);
  81
  82          glDisableClientState( GL_VERTEX_ATTRIB_ARRAY0_NV );
  83          glDisableClientState( GL_VERTEX_ARRAY );
  84          glDisableClientState( GL_NORMAL_ARRAY );
  85       }
  86       else {
  87          int i;
  88          glBegin(GL_TRIANGLE_STRIP);
  89          for (i = 0; i < numverts; i++) {
  90             glNormal3fv( data[i] + 3 );
  91             glVertex3fv( data[i] + 0 );
  92          }
  93          glEnd();
  94       }
  95    glPopMatrix();
  96
  97    if (glGetError())
  98       printf("Error!\n");
  99
 100    glutSwapBuffers();
 101 }
 102
 103
 104 static void InitMaterials(void)
 105 {
 106     static float ambient[] = {0.1, 0.1, 0.1, 1.0};
 107     static float diffuse[] = {0.5, 1.0, 1.0, 1.0};
 108     static float position0[] = {0.0, 0.0, 20.0, 0.0};
 109     static float position1[] = {0.0, 0.0, -20.0, 0.0};
 110     static float front_mat_shininess[] = {60.0};
 111     static float front_mat_specular[] = {0.2, 0.2, 0.2, 1.0};
 112     static float front_mat_diffuse[] = {0.5, 0.28, 0.38, 1.0};
 113     /*
 114     static float back_mat_shininess[] = {60.0};
 115     static float back_mat_specular[] = {0.5, 0.5, 0.2, 1.0};
 116     static float back_mat_diffuse[] = {1.0, 1.0, 0.2, 1.0};
 117     */
 118     static float lmodel_ambient[] = {1.0, 1.0, 1.0, 1.0};
 119     static float lmodel_twoside[] = {GL_FALSE};
 120
 121     glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
 122     glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
 123     glLightfv(GL_LIGHT0, GL_POSITION, position0);
 124     glEnable(GL_LIGHT0);
 125
 126     glLightfv(GL_LIGHT1, GL_AMBIENT, ambient);
 127     glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse);
 128     glLightfv(GL_LIGHT1, GL_POSITION, position1);
 129     glEnable(GL_LIGHT1);
 130
 131     glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
 132     glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
 133
 134     glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, front_mat_shininess);
 135     glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, front_mat_specular);
 136     glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, front_mat_diffuse);
 137     glEnable(GL_LIGHTING);
 138 }
 139
 140
 141 static void init_program(void)
 142 {
 143    /*
 144     * c[0..3] = modelview matrix
 145     * c[4..7] = inverse modelview matrix
 146     * c[30] = color scale
 147     * c[31] = color bias
 148     */
 149    static const char prog[] =
 150       "!!VP1.0\n"
 151
 152       "# RGB is proportional to XYZ \n"
 153
 154       "MUL R0, v[OPOS], c[30]; \n"
 155       "ADD o[COL0], R0, c[31]; \n"
 156
 157       "# Continue with typical modelview/projection\n"
 158       "MOV R3, v[OPOS]; \n"
 159       "DP4   o[HPOS].x, c[0], R3 ;      # object x MVP -> clip\n"
 160       "DP4   o[HPOS].y, c[1], R3 ;\n"
 161       "DP4   o[HPOS].z, c[2], R3 ;\n"
 162       "DP4   o[HPOS].w, c[3], R3 ;\n"
 163
 164       "END";
 165
 166    static const GLfloat scale[4] = {2.0, 2.0, 2.0, 0.0};
 167    static const GLfloat bias[4] = {1.0, 1.0, 1.0, 0.0};
 168
 169    if (!glutExtensionSupported("GL_NV_vertex_program")) {
 170       printf("Sorry, this program requires GL_NV_vertex_program");
 171       exit(1);
 172    }
 173
 174    glLoadProgramNV(GL_VERTEX_PROGRAM_NV, 1,
 175                    strlen(prog), (const GLubyte *) prog);
 176    assert(glIsProgramNV(1));
 177    glBindProgramNV(GL_VERTEX_PROGRAM_NV, 1);
 178
 179    /* Load the program registers */
 180    glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 0, GL_MODELVIEW_PROJECTION_NV, GL_IDENTITY_NV);
 181    glTrackMatrixNV(GL_VERTEX_PROGRAM_NV, 4, GL_MODELVIEW, GL_INVERSE_TRANSPOSE_NV);
 182
 183    glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, 30, scale);
 184    glProgramParameter4fvNV(GL_VERTEX_PROGRAM_NV, 31, bias);
 185 }
 186
 187
 188 static void init(void)
 189 {
 190    xrot = 0;
 191    yrot = 0;
 192    glClearColor(0.0, 0.0, 1.0, 0.0);
 193    glEnable( GL_DEPTH_TEST );
 194    glEnable(GL_NORMALIZE);
 195    InitMaterials();
 196    read_surface( "../demos/isosurf.dat" );
 197    init_program();
 198 }
 199
 200
 201 static void Reshape(int width, int height)
 202 {
 203    glViewport(0, 0, (GLint)width, (GLint)height);
 204    glMatrixMode(GL_PROJECTION);
 205    glLoadIdentity();
 206    glFrustum( -1.0, 1.0, -1.0, 1.0, 5, 25 );
 207    glMatrixMode(GL_MODELVIEW);
 208    glLoadIdentity();
 209    glTranslatef(0, 0, -15);
 210 }
 211
 212
 213
 214 static void Key( unsigned char key, int x, int y )
 215 {
 216    (void) x;
 217    (void) y;
 218    switch (key) {
 219    case 27:
 220       exit(0);
 221    case 'a':
 222       useArrays = !useArrays;
 223       printf("use arrays: %s\n", useArrays ? "yes" : "no");
 224       break;
 225    case 'p':
 226       useProgram = !useProgram;
 227       printf("use program: %s\n", useProgram ? "yes" : "no");
 228       break;
 229    }
 230    glutPostRedisplay();
 231 }
 232
 233
 234 static void SpecialKey( int key, int x, int y )
 235 {
 236    (void) x;
 237    (void) y;
 238    switch (key) {
 239    case GLUT_KEY_LEFT:
 240       yrot -= 15.0;
 241       break;
 242    case GLUT_KEY_RIGHT:
 243       yrot += 15.0;
 244       break;
 245    case GLUT_KEY_UP:
 246       xrot += 15.0;
 247       break;
 248    case GLUT_KEY_DOWN:
 249       xrot -= 15.0;
 250       break;
 251    default:
 252       return;
 253    }
 254    glutPostRedisplay();
 255 }
 256
 257
 258
 259 int main(int argc, char **argv)
 260 {
 261    glutInit(&argc, argv);
 262    glutInitDisplayMode( GLUT_DEPTH | GLUT_RGB | GLUT_DOUBLE );
 263    glutInitWindowPosition(0, 0);
 264    glutInitWindowSize(400, 400);
 265    if (glutCreateWindow("Isosurface") <= 0) {
 266       exit(0);
 267    }
 268    glutReshapeFunc(Reshape);
 269    glutKeyboardFunc(Key);
 270    glutSpecialFunc(SpecialKey);
 271    glutDisplayFunc(Display);
 272
 273    init();
 274
 275    glutMainLoop();
 276    return 0;
 277 }