radeondot3bump3dlight.cpp

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

/* Copyright (C) Dan Ginsburg ang Dave Gosselin, 2001. 
 * All rights reserved worldwide.
 *
 * This software is provided "as is" without express or implied
 * warranties. You may freely copy and compile this source into
 * applications you distribute provided that the copyright text
 * below is included in the resulting source code, for example:
 * "Portions Copyright (C) Dan Ginsburg ang Dave Gosselin, 2001"
 */
///////////////////////////////////////////////////////////////////////////////
//
//   RadeonDot3Bump.cpp - This sample app shows using DOT3 for bumpmapping.
//                        it packs the light vector into the color and does
//                        a dot with a pre-filtered height map.
//
//   Controls:   [ESC]            - Quit
//
///////////////////////////////////////////////////////////////////////////////

#include <windows.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <glut.h>
#include <stdio.h>
#include "math.h"
#include "glati.h"
#include "wglati.h"
#include "GLTexture.h"
#include "character.h"

#include "BumpObject.h"

// Extension definitions.
#define GL_MIRROR_CLAMP_ATI         0x6080
#define GL_MIRROR_CLAMP_TO_EDGE_ATI 0x6081

// The object to display
BumpObject bumpObject;
char *pofName = NULL;

// The base textures for the object
#define NUM_DEMO_TEXTURES 3
char *textureName[NUM_DEMO_TEXTURES] = {"Fieldstone.tga", "Tile4.tga", 
                                        "White.tga"};
GLuint textureID[NUM_DEMO_TEXTURES];
ATI_GLTexture* texture[NUM_DEMO_TEXTURES];
GLuint currentTexture = 0;

// The pre-filtered heightmap texurue
char *textureDotName[NUM_DEMO_TEXTURES] = {"FieldstoneBumpDOT3.tga", 
                                           "Tile4BumpDOT3.tga",
                                           "WhiteBumpDOT3.tga"};
GLuint textureDotID[NUM_DEMO_TEXTURES];
ATI_GLTexture* textureDot[NUM_DEMO_TEXTURES];

// Cubemap texture
#define CUBEMAP_TEX_SIZE 128
GLuint cubemapID;
GLubyte cubemapPX[3*CUBEMAP_TEX_SIZE*CUBEMAP_TEX_SIZE];
GLubyte cubemapPY[3*CUBEMAP_TEX_SIZE*CUBEMAP_TEX_SIZE];
GLubyte cubemapPZ[3*CUBEMAP_TEX_SIZE*CUBEMAP_TEX_SIZE];
GLubyte cubemapNX[3*CUBEMAP_TEX_SIZE*CUBEMAP_TEX_SIZE];
GLubyte cubemapNY[3*CUBEMAP_TEX_SIZE*CUBEMAP_TEX_SIZE];
GLubyte cubemapNZ[3*CUBEMAP_TEX_SIZE*CUBEMAP_TEX_SIZE];

// 3D Lightmap texture(s?)
#define NUM_LIGHTMAP_TEXTURES 1
GLuint lightmapID[NUM_LIGHTMAP_TEXTURES];
#define SIZE_LIGHTMAP_3D 64
GLubyte lightmap[SIZE_LIGHTMAP_3D*SIZE_LIGHTMAP_3D*SIZE_LIGHTMAP_3D*3];

// Setup text texture
GLuint textID;
ATI_GLTexture* charset;

// Light parameters
GLfloat lightMat[16];
GLfloat lightpos[] = {0.0f, 0.0f, 50.0f, 1.0f};
GLfloat lightDist = 50.0f;

// Viewing parameters
GLfloat viewMat[16];
GLfloat fov = 90.0;
GLfloat clipNear = 0.01;
GLfloat clipFar = 200.0;
GLfloat scaleFactor = 1.0;
GLint width = 640;
GLint height = 480;

// A couple of handy colors
static GLfloat white[] = { 1.0f, 1.0f, 1.0f, 1.0f };
static GLfloat black[] = { 0.0f, 0.0f, 0.0f, 1.0f };

// Flags
GLuint wireframe = GL_FALSE;
GLuint moving = GL_TRUE;
GLuint showVectors = GL_FALSE;
GLuint showTanCoord = GL_FALSE;
GLuint anisotropic = GL_TRUE;
GLuint useCubemap = GL_TRUE;
GLuint texturing = 0; // 0 - Full bump mapping (Dot mod Base).
                      // 1 - Just Light Vector dot Filtered height map.
                      // 2 - Light Vector encoded as color
                      // 3 - Just Filtered height map.
                      // 4 - Just Base map.

// Movement variables
GLint leftX = 0;
GLint leftY = 0;
GLuint leftDown = GL_FALSE;
GLint rightX = 0;
GLint rightY = 0;
GLuint rightDown = GL_FALSE;

// Prototypes needed.
PFNGLACTIVETEXTUREARBPROC glActiveTexture;
PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTexture;
PFNGLTEXIMAGE3DEXT glTexImage3DEXT;

//////////////////////////
// Set matrix to identity
//   matrix - Input/Output matrix
//////////////////////////
void 
matrixIdentity(GLfloat matrix[16])
{
  matrix[ 0] = 1.0;  matrix[ 1] = 0.0;  matrix[ 2] = 0.0;  matrix[ 3] = 0.0;
  matrix[ 4] = 0.0;  matrix[ 5] = 1.0;  matrix[ 6] = 0.0;  matrix[ 7] = 0.0;
  matrix[ 8] = 0.0;  matrix[ 9] = 0.0;  matrix[10] = 1.0;  matrix[11] = 0.0;
  matrix[12] = 0.0;  matrix[13] = 0.0;  matrix[14] = 0.0;  matrix[15] = 1.0;
}

//////////////////////////
// Invert a matrix. (Matrix MUST be orhtonormal!)
//   in - Input matrix
//   out - Output matrix
//////////////////////////
void
matrixInvert(GLfloat in[16], GLfloat out[16])
{
  // Transpose rotation
  out[ 0] = in[ 0];  out[ 1] = in[ 4];  out[ 2] = in[ 8];
  out[ 4] = in[ 1];  out[ 5] = in[ 5];  out[ 6] = in[ 9];
  out[ 8] = in[ 2];  out[ 9] = in[ 6];  out[10] = in[10];
  
  // Clear shearing terms
  out[3] = 0.0f; out[7] = 0.0f; out[11] = 0.0f; out[15] = 1.0f;

  // Translation is minus the dot of tranlation and rotations
  out[12] = -(in[12]*in[ 0]) - (in[13]*in[ 1]) - (in[14]*in[ 2]);
  out[13] = -(in[12]*in[ 4]) - (in[13]*in[ 5]) - (in[14]*in[ 6]);
  out[14] = -(in[12]*in[ 8]) - (in[13]*in[ 9]) - (in[14]*in[10]);
}

//////////////////////////
// Multiply a vector by a matrix.
//   vecIn - Input vector
//   m - Input matrix
//   vecOut - Output vector
//////////////////////////
void
vecMatMult(GLfloat vecIn[3], GLfloat m[16], GLfloat vecOut[3]) {
  vecOut[0] = (vecIn[0]*m[ 0]) + (vecIn[1]*m[ 4]) + (vecIn[2]*m[ 8]) + m[12];
  vecOut[1] = (vecIn[0]*m[ 1]) + (vecIn[1]*m[ 5]) + (vecIn[2]*m[ 9]) + m[13];
  vecOut[2] = (vecIn[0]*m[ 2]) + (vecIn[1]*m[ 6]) + (vecIn[2]*m[10]) + m[14];
}

//////////////////////////
// Multiply a vector by just the 3x3 portion of a matrix.
//   vecIn - Input vector
//   m - Input matrix
//   vecOut - Output vector
//////////////////////////
void
vecMat3x3Mult(GLfloat vecIn[3], GLfloat m[16], GLfloat vecOut[3]) {
  vecOut[0] = (vecIn[0]*m[ 0]) + (vecIn[1]*m[ 4]) + (vecIn[2]*m[ 8]);
  vecOut[1] = (vecIn[0]*m[ 1]) + (vecIn[1]*m[ 5]) + (vecIn[2]*m[ 9]);
  vecOut[2] = (vecIn[0]*m[ 2]) + (vecIn[1]*m[ 6]) + (vecIn[2]*m[10]);
}

//////////////////////////
// Setup texture stages for Dot3 Bump-mapping.
//////////////////////////
void
Dot3Bump() {
  // Setup first texture stage to DOT the color (which contains the
  // light vector in tangent space) with the pre-filtered height map.
  glActiveTexture(GL_TEXTURE0_ARB);
  if ((texturing == 0) || (texturing == 1)) {
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, textureDotID[currentTexture]);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
    glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_DOT3_RGBA_EXT);
    
    glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_PRIMARY_COLOR_EXT);
    glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
    
    glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_TEXTURE);
    glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
  } else if (texturing == 3) {
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, textureDotID[currentTexture]);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  } else {
    glDisable(GL_TEXTURE_2D);
    glDisable(GL_TEXTURE_CUBE_MAP_ARB);
  }

  // Setup the second texture stage to modulate the previous dot product
  // and the the base texture.
  glActiveTexture(GL_TEXTURE1_ARB);
  if (texturing == 0) {
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, textureID[currentTexture]);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
    glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);

    glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_PREVIOUS_EXT);
    glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_ALPHA);
    
    glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_TEXTURE);
    glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
  } else if (texturing == 4) {
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, textureID[currentTexture]);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  } else {
    glDisable(GL_TEXTURE_2D);
    glDisable(GL_TEXTURE_CUBE_MAP_ARB);
  }
}

//////////////////////////
// Setup texture stages for Dot3 Bump-mapping with a Cube Map normalization.
//////////////////////////
void
Dot3CubeBump() {
  // Setup first texture stage to take the normal to the light vector
  // encoded as the texture coordinates and use a cube map to get an
  // interpolated normalized vector.
  glActiveTexture(GL_TEXTURE0_ARB);
  glDisable(GL_TEXTURE_GEN_S);
  glDisable(GL_TEXTURE_GEN_T);
  glDisable(GL_TEXTURE_GEN_R);
  if ((texturing == 0) || (texturing == 1) || (texturing == 2)) {
     glDisable(GL_TEXTURE_2D);
     glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, cubemapID);
     glEnable(GL_TEXTURE_CUBE_MAP_ARB);
     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  } else {
    glDisable(GL_TEXTURE_2D);
    glDisable(GL_TEXTURE_CUBE_MAP_ARB);
  }

  // Setup second texture stage to perform the dot product of the
  // first stage (a normalized vector to the light) and the pre-filtered
  // height map.
  glActiveTexture(GL_TEXTURE1_ARB);
  glDisable(GL_TEXTURE_GEN_S);
  glDisable(GL_TEXTURE_GEN_T);
  glDisable(GL_TEXTURE_GEN_R);
  if ((texturing == 0) || (texturing == 1)){
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, textureDotID[currentTexture]);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
    glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_DOT3_RGB_EXT);
    glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_PREVIOUS_EXT);
    glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
    
    glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_TEXTURE);
    glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
  } else if (texturing == 3) {
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, textureDotID[currentTexture]);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  } else {
    glDisable(GL_TEXTURE_2D);
    glDisable(GL_TEXTURE_CUBE_MAP_ARB);
  }

  // Setup third texture stage to modulate the lighting value from
  // the second stage with the base texture map to get the final
  // bump mapped output.
  glActiveTexture(GL_TEXTURE2_ARB);
  glDisable(GL_TEXTURE_GEN_S);
  glDisable(GL_TEXTURE_GEN_T);
  glDisable(GL_TEXTURE_GEN_R);
  if (texturing == 0) {
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, textureID[currentTexture]);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
    glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_MODULATE);

    glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_PREVIOUS_EXT);
    glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);
    
    glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_TEXTURE);
    glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);
  } else if (texturing == 4) {
    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, textureID[currentTexture]);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  } else {
    glDisable(GL_TEXTURE_2D);
    glDisable(GL_TEXTURE_CUBE_MAP_ARB);
  }
}

//////////////////////////
// Setup texture stages for 3D lightmaps.
//////////////////////////
void
lightmap3D(void) {
  // Load the lightmap as the first texture unit
  glActiveTexture(GL_TEXTURE0_ARB);
  glDisable(GL_TEXTURE_2D);
  glDisable(GL_TEXTURE_CUBE_MAP_ARB);
  glEnable(GL_TEXTURE_3D_EXT);
  glBindTexture(GL_TEXTURE_3D_EXT, lightmapID[0]);
  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

  // Turn on texture generation to give each vertex it's world coordinates
  // as it's texture coordinates. We'll use a texture matrix to convert these
  // into something useful.
  glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  glEnable(GL_TEXTURE_GEN_S);
  GLfloat sgenparams[] = {1.0f, 0.0f, 0.0f, 0.0f};
  glTexGenfv(GL_S, GL_OBJECT_PLANE, sgenparams);
  glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  glEnable(GL_TEXTURE_GEN_T);
  GLfloat tgenparams[] = {0.0f, 1.0f, 0.0f, 0.0f};
  glTexGenfv(GL_T, GL_OBJECT_PLANE, tgenparams);
  glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  GLfloat rgenparams[] = {0.0f, 0.0f, 1.0f, 0.0f};
  glTexGenfv(GL_R, GL_OBJECT_PLANE, rgenparams);
  glEnable(GL_TEXTURE_GEN_S);
  glEnable(GL_TEXTURE_GEN_T);
  glEnable(GL_TEXTURE_GEN_R);

  // Create a texture matrix to convert world space into lightmap space.
  glMatrixMode(GL_TEXTURE);
  glLoadIdentity ();
  GLfloat sf = scaleFactor*0.00125f;
  glScalef(sf, sf, sf);
  GLfloat lp[3];
  vecMatMult(lightpos, lightMat, lp);
  glTranslatef (-lp[0], -lp[1], -lp[2]);
  glMatrixMode(GL_MODELVIEW);

  // Disable second texture unit
  glActiveTexture(GL_TEXTURE1_ARB);
  glDisable(GL_TEXTURE_2D);
  glDisable(GL_TEXTURE_CUBE_MAP_ARB);
  glDisable(GL_TEXTURE_3D_EXT);

  // Disable third texture unit
  glActiveTexture(GL_TEXTURE2_ARB);
  glDisable(GL_TEXTURE_2D);
  glDisable(GL_TEXTURE_CUBE_MAP_ARB);
  glDisable(GL_TEXTURE_3D_EXT);
}

//////////////////////////
// Show the texturing flag label
//////////////////////////
void displayText(GLint textFlag) 
{
  switch (textFlag) {
    case 0:
      flDrawString(0.01, 0.01, "DOT3 Bump mapping");
      break;
    case 1:
      flDrawString(0.01, 0.01, "Normal dot Light Vector");
      break;
    case 2:
      flDrawString(0.01, 0.01, "Light Vector as color");
      break;
    case 3:
      flDrawString(0.01, 0.01, "Pre-Filtered Height Map");
      break;
    case 4:
      flDrawString(0.01, 0.01, "Base Map");
      break;
    case 5:
      flDrawString(0.01, 0.01, "Light Map");
      break;
    default:
      flDrawString(0.01, 0.01, "Unknown Setting");
      break;