radeondot3bump3dlight.cpp

游戏编程精华02－含有几十个游戏编程例子

    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                    GL_LINEAR_MIPMAP_NEAREST);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    gszErrMsg[0] = '\0';

    // Load pre-filtered height maps
    printf("Loading: %s\n", textureDotName[i]);
    textureDot[i] = new ATI_GLTexture(textureDotName[i], textureDotID[i],
                                      GL_TRUE, GL_RGBA, GL_RGBA);
    if (gszErrMsg[0] != '\0') printf("Error loading %s: %s\n",
                                     textureDotName[i],gszErrMsg);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                    GL_LINEAR_MIPMAP_NEAREST);
    glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE, GL_REPLACE);
    glEnable(GL_TEXTURE_2D);
  }

  // Handle cubemap
  generateCubemap();

  // Handle 3D lightmaps
  generateLightmap3D();

  // If anisotropy is supported, use it.
  if (anisotropic) {
    GLfloat maxAnisotropy;
    glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy);
    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy);
  }
}

///////////////////////////
// GL Initialization
///////////////////////////
void 
myinit(void){
  // Basic GL setup
  glClearColor(0.0f,0.0f,0.0f,0.0f);
  glShadeModel (GL_SMOOTH);
  glEnable(GL_CULL_FACE);
  glCullFace (GL_BACK);
  glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
  glEnable (GL_DEPTH_TEST);
  glDepthFunc (GL_LEQUAL);
  glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);

  // Load up our model.
  printf("Loading: %s\n", pofName);
  bumpObject.loadObject(pofName);

  // Based on the bounding box set the initial transform.
  float bbox[6];
  bumpObject.getBBox(bbox);
  GLfloat cx = (bbox[3] - bbox[0])/2.0f + bbox[0];
  GLfloat cy = (bbox[4] - bbox[1])/2.0f + bbox[1];
  GLfloat cz = (bbox[5] - bbox[2])/2.0f + bbox[2];
  GLfloat dx = bbox[0] - cx;
  GLfloat dy = bbox[1] - cy;
  GLfloat dz = bbox[2] - cz;
  GLfloat r = sqrt(dx*dx + dy*dy + dz*dz);
  GLfloat ang = (float)(tan((double)((3.141592f/180.0f)*(fov/2.0f))));
  GLfloat dist;
  if ((ang > -0.0000001) && (ang < 0.0000001)) { // Don't divide by zero
    dist = 500.0f;
  } else {
    dist = (r * 1.2f) / ang;
  }
  GLfloat zf = r * 2.2f + fabs(cz);
  if (zf > clipFar) clipFar = zf;
  matrixIdentity(viewMat);
  viewMat[12] = -cx;
  viewMat[13] = -cy;
  viewMat[14] = -(cz + dist);

  // Lighting parameters and scale factors.
  matrixIdentity(lightMat);
  lightpos[2] = lightDist = cz + (r*0.6);
  scaleFactor = dist * 0.03;

  // Texturing
  initTextures();
}

/////////////////////////////////////
// Key input handler
//   key - Which special key pressed
/////////////////////////////////////
void 
KeyFunc(unsigned char key,int x,int y){
  switch(key){
    case '\x1b': // Quit
    case 'Q':
    case 'q':
      exit(0);
      break;
    case 't': // Switch current texture
    case 'T':
      currentTexture = (currentTexture + 1) % NUM_DEMO_TEXTURES;
      break;
    case ' ':
      moving = !moving;
      break;
    case 'v':
    case 'V':
      showVectors = !showVectors;
      break;
    case 'c':
    case 'C':
      showTanCoord = !showTanCoord;
      break;
    case 'm':
    case 'M':
      texturing = (texturing + 1) % 6;
      break;
    case 'w':
    case 'W':
      wireframe = !wireframe;
      break;
  };
  glutPostRedisplay();
}

/////////////////////////////////////
// Timer callback
/////////////////////////////////////
void 
TimerFunc(int value){
  // Move the light around if the user requested that.
  if (moving && !rightDown) {
    glPushMatrix();
       glLoadIdentity();
       glMultMatrixf(lightMat);
       glRotatef(2.0f, 1.0f, 1.0f, 0.0f);
       glGetFloatv(GL_MODELVIEW_MATRIX, lightMat);
    glPopMatrix();
    display();
  }
  glutTimerFunc(100,TimerFunc,0);
}

/////////////////////////////////////
// Handle special case key presses
//   key - Which special key was pressed
/////////////////////////////////////
void 
SpecialKeys(int key, int x, int y)
{
  switch (key) {
  case GLUT_KEY_LEFT:
    break;
  case GLUT_KEY_RIGHT:
    break;
  case GLUT_KEY_UP:
    // Move light further from object center
    lightpos[2] += (lightDist * 0.01f);
    break;
  case GLUT_KEY_DOWN:
    // Move light closer to object center
    lightpos[2] -= (lightDist * 0.01f);
    break;
  }
  glutPostRedisplay();
}

/////////////////////////////////////
// Handle mouse movement.
//   x - current x position.
//   y - current y position.
/////////////////////////////////////
void 
MouseMove(int x, int y)
{
  // Left button down so move the object.
  if (leftDown) {
    glMatrixMode(GL_MODELVIEW);
    GLfloat m[16];
    matrixInvert(viewMat, m);
    GLfloat v[3] = {(y - leftY) * 0.3f, (x - leftX) * 0.3f, 0.0f };
    GLfloat o[3];
    vecMat3x3Mult(v, m, o);
    glPushMatrix();
       glLoadIdentity();
       glMultMatrixf(viewMat);
       glRotatef(o[0], 1.0f, 0.0f, 0.0f);
       glRotatef(o[1], 0.0f, 1.0f, 0.0f);
       glRotatef(o[2], 0.0f, 0.0f, 1.0f);
       glGetFloatv(GL_MODELVIEW_MATRIX, viewMat);
    glPopMatrix();
    leftX = x;
    leftY = y;
    glutPostRedisplay();
  }

  // Right button down so move the light.
  if (rightDown) {
    glMatrixMode(GL_MODELVIEW);
    GLfloat m1[16];
    GLfloat m2[16];
    matrixInvert(viewMat, m1);
    matrixInvert(lightMat, m2);
    GLfloat v[3] = {(y - rightY) * 0.3f, (x - rightX) * 0.3f, 0.0f };
    GLfloat o[3];
    vecMat3x3Mult(v, m1, o);
    vecMat3x3Mult(o, m2, v);
    glPushMatrix();
       glLoadIdentity();
       glMultMatrixf(lightMat);
       glRotatef(v[2], 0.0f, 0.0f, 1.0f);
       glRotatef(v[1], 0.0f, 1.0f, 0.0f);
       glRotatef(v[0], 1.0f, 0.0f, 0.0f);
       glGetFloatv(GL_MODELVIEW_MATRIX, lightMat);
    glPopMatrix();
    rightX = x;
    rightY = y;
    glutPostRedisplay();
  }
}
/////////////////////////////////////
// Handle mouse button presses/releases.
//   button - The button pressed.
//   state - Was the button pressed or release.
//   x - current x position.
//   y - current y position.
/////////////////////////////////////
void 
MouseUpDown(int button, int state, int x, int y) 
{
  if (button == GLUT_LEFT_BUTTON) {
    if (state == GLUT_DOWN) {
      leftDown = GL_TRUE;
      leftX = x;
      leftY = y;
    }
    else if (state == GLUT_UP) {
      leftDown = GL_FALSE;
    }
  }
  if (button == GLUT_RIGHT_BUTTON) {
    if (state == GLUT_DOWN) {
      rightDown = GL_TRUE;
      rightX = x;
      rightY = y;
    }
    else if (state == GLUT_UP) {
      rightDown = GL_FALSE;
    }
  }
}

/////////////////////////////////////
// Determine if a particular extension is supported
//   extension -- Name of the extension to check
/////////////////////////////////////
int 
extensionSupported(const char *extension)
{
  static const GLubyte *extensions = NULL;
  const GLubyte *start;
  GLubyte *where, *terminator;

  where = (GLubyte *) strchr(extension, ' ');
  if (where || *extension == '\0')
    return 0;

  if (!extensions)
    extensions = glGetString(GL_EXTENSIONS);

  start = extensions;
  for (;;) {
    where = (GLubyte *) strstr((const char *) start, extension);
    if (!where)
      break;
    terminator = where + strlen(extension);
    if (where == start || *(where - 1) == ' ') {
      if (*terminator == ' ' || *terminator == '\0') {
        return 1;
      }
    }
    start = terminator;
  }
  return 0;
}

/////////////////////////////////////
// Check to make sure the extensions we need are available.
/////////////////////////////////////
void
checkExtensions() {
  if (!extensionSupported("GL_ARB_multitexture")){
    printf("No GL_ARB_multitexture support!\n");
    Sleep(5000);
    exit(0);
  }
  glActiveTexture = (PFNGLACTIVETEXTUREARBPROC) wglGetProcAddress("glActiveTextureARB");
  if (glActiveTexture == NULL) {
    printf("No glActiveTexture function available\n");
    Sleep(5000);
    exit(0);
  }
  glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREARBPROC) wglGetProcAddress("glClientActiveTextureARB");
  if (glClientActiveTexture == NULL) {
    printf("No glClientActiveTexture function available\n");
    Sleep(5000);
    exit(0);
  }
  if (!extensionSupported("GL_EXT_texture_env_combine")){
    printf("No GL_EXT_texture_env_combine support!\n");
    Sleep(5000);
    exit(0);
  }
  if (!extensionSupported("GL_ARB_texture_cube_map")){
    printf("No GL_ARB_texture_cube_map support!\n");
    Sleep(5000);
    exit(0);
  }
  if (!extensionSupported("GL_EXT_texture_env_dot3")){
    printf("No GL_EXT_texture_env_dot3 support!\n");
    Sleep(5000);
    exit(0);
  }
  if (!extensionSupported("GL_EXT_texture3D")){
    printf("No GL_EXT_texture3D support!\n");
    Sleep(5000);
    exit(0);
  }
  glTexImage3DEXT = (PFNGLTEXIMAGE3DEXT)wglGetProcAddress("glTexImage3DEXT");
  if (glTexImage3DEXT == NULL) {
    printf("No glTexImage3DEXT function available\n");
    Sleep(5000);
    exit(0);
  }
  if (!extensionSupported("GL_EXT_texture_filter_anisotropic")){
    anisotropic = GL_FALSE;
  }
}

/////////////////////////////////////
// Entry point
/////////////////////////////////////
void 
main(int argc,char **argv){
  // If the user specified a file name use that instead.
  if (argc == 2) {
    pofName = argv[1];
  } else {
    pofName = "crackbox.pof";
  }

  printf("Radeon Dot3 Bump Demo\n");
  printf("June 26, 2000\n");
  printf(" m             - Show stages of the bumpmapping process\n");
  printf(" t             - Cycle through textures\n");
  printf(" v             - Toggle vector drawing\n");
  printf(" c             - Toggle display of tangent coordinate system\n");
  printf(" w             - Toggle wireframe\n");
  printf(" UP ARROW      - Move light source further from object center\n");
  printf(" DOWN ARROW    - Move light source closer to object center\n");
  printf(" LEFT + MOUSE  - Rotate Object\n");
  printf(" RIGHT + MOUSE - Rotate Light\n");
  printf(" SPACE         - Toggle Motion\n");
  printf(" ESC           - Quit program\n");
  printf("\n");

  // Create window.
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH);
  glutInitWindowSize(width, height);
  glutCreateWindow("DOT3 Bump Demo");

  // Check extensions.
  checkExtensions();

  // Setup GLUT callbacks.
  glutDisplayFunc(display);
  glutReshapeFunc(MyReshape);
  glutKeyboardFunc(KeyFunc);
  glutSpecialFunc(SpecialKeys);
  glutMotionFunc(MouseMove);
  glutMouseFunc(MouseUpDown);
  myinit();
  glutTimerFunc(100,TimerFunc,0);
  glutMainLoop();
}