quadrics.cpp

一本关于OPenGL的很好的电子书

      glVertex3i(-WORLD_SIZE, 0, z);
      glVertex3i(WORLD_SIZE, 0, z);
    }
  glEnd();

  // turn blending off
  glDisable(GL_BLEND);
} // end DrawGround()


/*****************************************************************************
 DrawStars()

 Draws five quads textured with star images to represent the sky.
*****************************************************************************/
GLvoid DrawStars()
{
  // enable texturing and choose the stars texture
  glEnable(GL_TEXTURE_2D);
  glBindTexture(GL_TEXTURE_2D, g_starsTexture);

  // we don't care about the quad colors, so just replace them with the texture
  glTexEnvf(GL_TEXTURE_2D, GL_TEXTURE_ENV_MODE, GL_REPLACE);

  glBegin(GL_QUADS);
    // -z plane
    glTexCoord2i(0, 0); glVertex3i(-WORLD_SIZE, 0, -WORLD_SIZE);
    glTexCoord2i(0, 2); glVertex3i(WORLD_SIZE, 0, -WORLD_SIZE);
    glTexCoord2i(1, 2); glVertex3i(WORLD_SIZE, WORLD_SIZE, -WORLD_SIZE);
    glTexCoord2i(1, 0); glVertex3i(-WORLD_SIZE, WORLD_SIZE, -WORLD_SIZE);

    // x plane
    glTexCoord2i(0, 0); glVertex3i(WORLD_SIZE, 0, -WORLD_SIZE);
    glTexCoord2i(0, 2); glVertex3i(WORLD_SIZE, 0, WORLD_SIZE);
    glTexCoord2i(1, 2); glVertex3i(WORLD_SIZE, WORLD_SIZE, WORLD_SIZE);
    glTexCoord2i(1, 0); glVertex3i(WORLD_SIZE, WORLD_SIZE, -WORLD_SIZE);

    // z plane
    glTexCoord2i(0, 0); glVertex3i(WORLD_SIZE, 0, WORLD_SIZE);
    glTexCoord2i(0, 2); glVertex3i(-WORLD_SIZE, 0, WORLD_SIZE);
    glTexCoord2i(1, 2); glVertex3i(-WORLD_SIZE, WORLD_SIZE, WORLD_SIZE);
    glTexCoord2i(1, 0); glVertex3i(WORLD_SIZE, WORLD_SIZE, WORLD_SIZE);

    // -x plane
    glTexCoord2i(0, 0); glVertex3i(-WORLD_SIZE, 0, WORLD_SIZE);
    glTexCoord2i(0, 2); glVertex3i(-WORLD_SIZE, 0, -WORLD_SIZE);
    glTexCoord2i(1, 2); glVertex3i(-WORLD_SIZE, WORLD_SIZE, -WORLD_SIZE);
    glTexCoord2i(1, 0); glVertex3i(-WORLD_SIZE, WORLD_SIZE, WORLD_SIZE);

    // y plane, or top
    glTexCoord2i(0, 0); glVertex3i(-WORLD_SIZE, WORLD_SIZE, -WORLD_SIZE);
    glTexCoord2i(0, 2); glVertex3i(WORLD_SIZE, WORLD_SIZE, -WORLD_SIZE);
    glTexCoord2i(2, 2); glVertex3i(WORLD_SIZE, WORLD_SIZE, WORLD_SIZE);
    glTexCoord2i(2, 0); glVertex3i(-WORLD_SIZE, WORLD_SIZE, WORLD_SIZE);
  glEnd();

  glDisable(GL_TEXTURE_2D);
} // end DrawStars()


/*****************************************************************************
 DrawNormalObjects()

 Draw several quadrics with the default quadric settings. rotation is used
 for animation purposes, ranges between 0 and 360, and is increased by 1 every
 frame.
*****************************************************************************/
GLvoid DrawNormalObjects(GLfloat rotation)
{
  // make sure the random color values we get are the same every time
  srand(200);

  // save the existing color properties
  glPushAttrib(GL_CURRENT_BIT);

  // a cylinder
  glPushMatrix();
    glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, rand() % 128);
    glColor3f(FRAND, FRAND, FRAND);
    glTranslatef(-25.0, 0.0, -4.0);
    glRotatef(-90, 1.0, 0.0, 0.0);
    gluCylinder(g_normalObject, 1.0, 1.0, 3.0, 32, 4);
  glPopMatrix();

  // a tapered cylinder
  glPushMatrix();
    glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, rand() % 128);
    glColor3f(FRAND, FRAND, FRAND);
    glTranslatef(5.0, 0.0, 3.0);
    glRotatef(-90, 1.0, 0.0, 0.0);
    gluCylinder(g_normalObject, 2.0, 0.5, 2.0, 32, 4);
  glPopMatrix();

  // a disk with a hole in it
  glPushMatrix();
    glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, rand() % 128);
    glColor3f(FRAND, FRAND, FRAND);
    glTranslatef(50.0, 1.5, -20.0);
    glRotatef(rotation * 10.0f, 0.0, 1.0, 0.0);
    gluDisk(g_normalObject, 0.7, 1.0, 32, 4);
  glPopMatrix();

  // a cone
  glPushMatrix();
    glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, rand() % 128);
    glColor3f(FRAND, FRAND, FRAND);
    glTranslatef(-150.0, 0.5, 0.0);
    glRotatef(-90, 1.0, 0.0, 0.0);
    gluCylinder(g_normalObject, 1.0, 0.0, 2.0, 32, 2);
  glPopMatrix();

  // a bouncing sphere
  glPushMatrix();
    glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, rand() % 128);
    glColor3f(FRAND, FRAND, FRAND);

    // use a sine wave pattern to make the sphere look like it's bouncing
    glTranslatef(5.0f, 3.0f + (float)sin(float(3.14159f*rotation/90.0f)), 50.0f);
    gluSphere(g_normalObject, 2.0f, 32, 20);
  glPopMatrix();

  // restore the previous color values
  glPopAttrib();
} // end DrawNormalObjects()


/*****************************************************************************
 DrawWireframeObjects()

 Draw several objects using the lines, or wireframe, drawing style.
*****************************************************************************/
GLvoid DrawWireframeObjects(GLfloat rotation)
{
  // make sure the random color values we get are the same every time
  srand(300);

  // save the existing color properties
  glPushAttrib(GL_CURRENT_BIT);

  // enable blending to get anti-aliased lines.
  glEnable(GL_BLEND);

  // a couple of spheres that chase each other around
  glPushMatrix();
    glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, rand() % 128);
    glColor3f(FRAND, FRAND, FRAND);
    glTranslatef(-20.0f, 2.0f, -20.0f);
    glRotatef(rotation * 2.0f, 1.0f, 0.0f, 0.0f);
    glRotatef(rotation * 2.0f, 0.0f, 1.0f, 0.0f);
    glRotatef(rotation * 2.0f, 0.0f, 0.0f, 1.0f);
    glTranslatef(-0.4f, 0.0f, 0.0f);
    gluSphere(g_wireframeObject, 0.3f, 16, 10);
  glPopMatrix();

  glPushMatrix();
    glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, rand() % 128);
    glColor3f(FRAND, FRAND, FRAND);
    glTranslatef(-20.0f, 2.0f, -20.0f);
    glRotatef(-rotation * 2.0f, 1.0f, 0.0f, 0.0f);
    glRotatef(-rotation * 2.0f, 0.0f, 1.0f, 0.0f);
    glRotatef(-rotation * 2.0f, 0.0f, 0.0f, 1.0f);
    glTranslatef(0.4f, 0.0f, 0.0f);
    gluSphere(g_wireframeObject, 0.3f, 16, 10);
  glPopMatrix();

  // an inverted cone
  glPushMatrix();
    glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, rand() % 128);
    glColor3f(FRAND, FRAND, FRAND);
    glTranslatef(-150.0, 0.5, 0.0);
    glRotatef(-90, 1.0, 0.0, 0.0);
    gluCylinder(g_wireframeObject, 0.0, 0.5, 3.0, 32, 4);
  glPopMatrix();

  // a filled disk
  glPushMatrix();
    glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, rand() % 128);
    glColor3f(FRAND, FRAND, FRAND);
    glTranslatef(-40.0, 0.5, 20.0);
    glRotatef(45.0, 1.0, 0.0, 0.0);
    gluDisk(g_wireframeObject, 0.0, 0.5, 32, 4);
  glPopMatrix();

  glDisable(GL_BLEND);

  // restore previous attributes
  glPopAttrib();
} // DrawWireframeObjects()

/*****************************************************************************
 DrawTexturedObjects()

 Draws a few textured objects, including a rocket that moves through the world
*****************************************************************************/
GLvoid DrawTexturedObjects(GLfloat rotation)
{
  // used for the motion of the rocket
  static GLfloat rocketX = 30.0f;
  static GLfloat rocketZ = 30.0f;
  rocketX -= 0.05f;
  rocketZ -= 0.05f;

  if (rocketX < -(GLfloat)WORLD_SIZE)
  {
    rocketX = (GLfloat)WORLD_SIZE;
    rocketZ = (GLfloat)WORLD_SIZE;
  }

  // used in animating the rocket flames
  static GLfloat counter = 0.0f;
  counter += 0.05f;

  if (counter > 1.0f)
    counter = 0.0f;


  // make sure the random color values we get are the same every time
  srand(700);

  // save the existing color properties
  glPushAttrib(GL_CURRENT_BIT);

  // enable texturing and select the rocket texture
  glEnable(GL_TEXTURE_2D);
  glBindTexture(GL_TEXTURE_2D, g_rocketTexture);

  // draw the checked portion of the rocket cylinder
  glPushMatrix();
    glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, 128);
    glColor3f(1.0, 1.0, 1.0);
    glTranslatef(rocketX, 3.0, rocketZ);
    glRotatef(-135.0, 0.0, 1.0, 0.0);
    gluCylinder(g_texturedObject, 0.5, 0.5, 3.0, 32, 8);
  glPopMatrix();

  // load the fire texture and draw the rocket's flames
  glBindTexture(GL_TEXTURE_2D, g_fireTexture);
  glPushMatrix();
    glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, rand() % 128);
    glColor3f(1.0, 1.0, 1.0);
    glTranslatef(rocketX, 3.0, rocketZ);
    glRotatef(-135, 0.0, 1.0, 0.0);
    glTranslatef(0.0, 0.0, -1.0);
    glRotatef(rotation, 0.0, 0.0, 1.0);

    // translate the texture coords to move the flames
    glMatrixMode(GL_TEXTURE);
    glPushMatrix();
      glTranslatef(0.0, counter, 0.0);
      gluCylinder(g_texturedObject, 0.0, 0.5, 1.5, 64, 8);
    glPopMatrix();

    glMatrixMode(GL_MODELVIEW);
  glPopMatrix();

  // a rotating sphere
  glPushMatrix();
    glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, rand() % 128);
    glColor3f(FRAND, FRAND, FRAND);
    glTranslatef(100.0, 4.0, -100.0);
    glRotatef(rotation, 0.0, 1.0, 0.0);
    gluSphere(g_texturedObject, 4.0, 32, 20);
  glPopMatrix();

  glDisable(GL_TEXTURE_2D);

  // draw the untextured, white portion of the rocket cylinder
  glPushMatrix();
    glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, 128);
    glColor3f(1.0f, 1.0f, 1.0f);
    glTranslatef(rocketX, 3.0f, rocketZ);
    glRotatef(-135.0f, 0.0f, 1.0f, 0.0f);
    glTranslatef(0.0f, 0.0f, 3.0f);
    gluCylinder(g_normalObject, 0.5f, 0.5f, 2.0f, 32, 8);
  glPopMatrix();

  // draw the black nosecone of the rocket
  glPushMatrix();
    glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, 128);
    glColor3f(0.2f, 0.2f, 0.2f);
    glTranslatef(rocketX, 3.0f, rocketZ);
    glRotatef(-135, 0.0f, 1.0f, 0.0f);
    glTranslatef(0.0f, 0.0f, 5.0f);
    gluCylinder(g_normalObject, 0.5f, 0.0f, 1.5f, 32, 4);
  glPopMatrix();

  // restore previous attributes
  glPopAttrib();
} // end DrawTexturedObjects()

/*****************************************************************************
 DrawFlatshadedObjects()

 Draws several quadrics using flat shading.
*****************************************************************************/
GLvoid DrawFlatshadedObjects(GLfloat rotation)
{
  glShadeModel(GL_FLAT);
  // used locally for animation
  static GLfloat scaleFactor = 1.0f;
  static GLfloat scaleFactorDelta = 0.001f;

  scaleFactor += scaleFactorDelta;

  if (scaleFactor >= 1.5f || scaleFactor <= 1.0f)
    scaleFactorDelta = -scaleFactorDelta;

  
  // make sure the random color values we get are the same every time
  srand(400);

  // save the existing color properties
  glPushAttrib(GL_CURRENT_BIT);

  // 2 stacked, tapered cylinders
  glPushMatrix();
    glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, rand() % 128);
    glColor3f(FRAND, FRAND, FRAND);
    glTranslatef(83.0f, 0.0f, -10.0f);
    glRotatef(-90, 1.0f, 0.0f, 0.0f);
    glScalef(scaleFactor, scaleFactor, scaleFactor);
    gluCylinder(g_flatshadedObject, 2.0f, 1.0f, 3.0f, 8, 2);
  glPopMatrix();

  glPushMatrix();
    glTranslatef(83.0f, 3.0f * scaleFactor, -10.0f);
    glRotatef(-90, 1.0f, 0.0f, 0.0f);
    glScalef(scaleFactor, scaleFactor, scaleFactor);
    gluCylinder(g_flatshadedObject, 1.0f, 2.0f, 3.0f, 8, 2);
  glPopMatrix();

  // a sphere
  glPushMatrix();
    glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, rand() % 128);
    glColor3f(FRAND, FRAND, FRAND);
    glTranslatef(50.0f, 3.0f, 30.0f);
    glRotatef(-90, 1.0f, 0.0f, 0.0f);
    gluSphere(g_flatshadedObject, 2.0f, 8, 8);
  glPopMatrix();

  // restore previous attributes
  glPopAttrib();
  glShadeModel(GL_SMOOTH);
} // end DrawFlatshadedObjects()


/****************************************************************************
 LoadTexture()

 Loads the texture from the specified file and stores it in iTexture.
*****************************************************************************/
void LoadTexture(char *filename, GLuint &texture)
{
  // get a texture object
  glGenTextures(1, &texture);
  glBindTexture(GL_TEXTURE_2D, texture);

  // load the bitmap
  BITMAPINFOHEADER bitmapInfoHeader;
  unsigned char *buffer = LoadBitmapFile(filename, &bitmapInfoHeader);

  // set up the texture
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexImage2D(GL_TEXTURE_2D, 0, 3, bitmapInfoHeader.biWidth, bitmapInfoHeader.biHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, buffer);

  // we're done with the bitmap data
  free(buffer);
} // end LoadTexture()