//-----------------------------------------------------------------------------
//           Name: ogl_dot3_bump_mapping.cpp
//         Author: Kevin Harris
//  Last Modified: 04/21/05
//    Description: This sample demonstrates how to perform Dot3 per-pixel bump
//                 mapping using a normal map and the GL_DOT3_RGB_EXT
//                 texture-blending operation. This technique is sometimes
//                 referred to as per-pixel lighting or per-pixel attenuation,
//                 but Dot3 per-pixel bump-mapping is what most programmers
//                 know it as.
//
//                 This sample also demonstrates how to create tangent,
//                 binormal, and normal vectors, for each vertex of our test
//                 geometry (a simple cube). These vectors are used during
//                 rendering to define an inverse tangent matrix for each
//                 vertex. This has to be done because a normal-map stores its
//                 normals in tangent-space. Therefore, we need an inverse
//                 tangent matrix so we can transform our scene's light vector
//                 from object-space into tangent-space. Once transformed, we
//                 then encode this new light vector as a RGB color and pass
//                 it into the texture blending stage as the vertex's Diffuse
//                 color.
//
// Additional Notes:
//
//                 The phrase "Dot3" comes form the mathematical operation that
//                 combines a light vector with a surface normal.
//
//                 The phrase "Per-pixel" comes from the fact that for every
//                 pixel in the base texture map, we store a unique surface
//                 normal to light it. These surface normals are passed into the
//                 texture blending stage via a normal-map. A normal-map is a
//                 texture where normals (x,y,z) have been encoded and stored
//                 as (r,g,b).
//
//   Control Keys: d/D - Toggle Dot3 bump mapping
//                 l/L - Toggle the usage of regular lighting in addition
//                       to the per-pixel lighting effect of bump mapping.
//                 m/M - Toggle motion of point light
//                 Up Arrow - Move the test cube closer
//                 Down Arrow - Move the test cube away
//-----------------------------------------------------------------------------#define STRICT
#define WIN32_LEAN_AND_MEAN#include <windows.h>
#include <mmsystem.h>
// Do this to access M_PI, which is not officially part of the C/C++ standard.
#define _USE_MATH_DEFINES
#include <math.h>
#include <stdlib.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glaux.h>
#include "geometry.h"
#include "matrix4x4f.h"
#include "vector3f.h"
#include "resource.h"//-----------------------------------------------------------------------------
// FUNCTION POINTERS FOR OPENGL EXTENSIONS
//-----------------------------------------------------------------------------// For convenience, this project ships with its own "glext.h" extension header
// file. If you have trouble running this sample, it may be that this "glext.h"
// file is defining something that your hardware doesn抰 actually support.
// Try recompiling the sample using your own local, vendor-specific "glext.h"
// header file.#include "glext.h"      // Sample's header file
//#include <GL/glext.h> // Your local header filePFNGLACTIVETEXTUREPROC       glActiveTexture       = NULL;
PFNGLMULTITEXCOORD2FPROC     glMultiTexCoord2f     = NULL;
PFNGLCLIENTACTIVETEXTUREPROC glClientActiveTexture = NULL;//-----------------------------------------------------------------------------
// GLOBALS
//-----------------------------------------------------------------------------
HDC   g_hDC  = NULL;
HGLRC g_hRC  = NULL;
HWND  g_hWnd = NULL;GLuint g_textureID = -1;
GLuint g_normalmapTextureID = -1;
bool g_bDoDot3BumpMapping = true;
bool g_bMoveLightAbout = true;
bool g_bToggleRegularLighting = false;
GLfloat g_lightPosition[] = { 0.0f, 0.0f, 0.0f, 1.0f }; // Point Light's positionfloat g_fDistance = -5.0f;
float g_fSpinX = 0.0f;
float g_fSpinY = 0.0f;float  g_fElpasedTime;
double g_dCurTime;
double g_dLastTime;struct Vertex
{float tu, tv;float r, g, b, a;float nx, ny, nz;float x, y, z;
};const int NUM_VERTICES = 24;Vertex g_cubeVertices[NUM_VERTICES] =
{
//    tu   tv     r    g    b    a      nx    ny    nz       x     y     z // Front face{ 0.0f,0.0f,  1.0f,1.0f,1.0f,1.0f,  0.0f, 0.0f, 1.0f,  -1.0f,-1.0f, 1.0f },{ 1.0f,0.0f,  1.0f,1.0f,1.0f,1.0f,  0.0f, 0.0f, 1.0f,   1.0f,-1.0f, 1.0f },{ 1.0f,1.0f,  1.0f,1.0f,1.0f,1.0f,  0.0f, 0.0f, 1.0f,   1.0f, 1.0f, 1.0f },{ 0.0f,1.0f,  1.0f,1.0f,1.0f,1.0f,  0.0f, 0.0f, 1.0f,  -1.0f, 1.0f, 1.0f },// Back face{ 1.0f,0.0f,  1.0f,1.0f,1.0f,1.0f,  0.0f, 0.0f,-1.0f,  -1.0f,-1.0f,-1.0f },{ 1.0f,1.0f,  1.0f,1.0f,1.0f,1.0f,  0.0f, 0.0f,-1.0f,  -1.0f, 1.0f,-1.0f },{ 0.0f,1.0f,  1.0f,1.0f,1.0f,1.0f,  0.0f, 0.0f,-1.0f,   1.0f, 1.0f,-1.0f },{ 0.0f,0.0f,  1.0f,1.0f,1.0f,1.0f,  0.0f, 0.0f,-1.0f,   1.0f,-1.0f,-1.0f },// Top face{ 0.0f,1.0f,  1.0f,1.0f,1.0f,1.0f,  0.0f, 1.0f, 0.0f,  -1.0f, 1.0f,-1.0f },{ 0.0f,0.0f,  1.0f,1.0f,1.0f,1.0f,  0.0f, 1.0f, 0.0f,  -1.0f, 1.0f, 1.0f },{ 1.0f,0.0f,  1.0f,1.0f,1.0f,1.0f,  0.0f, 1.0f, 0.0f,   1.0f, 1.0f, 1.0f },{ 1.0f,1.0f,  1.0f,1.0f,1.0f,1.0f,  0.0f, 1.0f, 0.0f,   1.0f, 1.0f,-1.0f },// Bottom face{ 1.0f,1.0f,  1.0f,1.0f,1.0f,1.0f,  0.0f,-1.0f, 0.0f,  -1.0f,-1.0f,-1.0f },{ 0.0f,1.0f,  1.0f,1.0f,1.0f,1.0f,  0.0f,-1.0f, 0.0f,   1.0f,-1.0f,-1.0f },{ 0.0f,0.0f,  1.0f,1.0f,1.0f,1.0f,  0.0f,-1.0f, 0.0f,   1.0f,-1.0f, 1.0f },{ 1.0f,0.0f,  1.0f,1.0f,1.0f,1.0f,  0.0f,-1.0f, 0.0f,  -1.0f,-1.0f, 1.0f },// Right face{ 1.0f,0.0f,  1.0f,1.0f,1.0f,1.0f,  1.0f, 0.0f, 0.0f,   1.0f,-1.0f,-1.0f },{ 1.0f,1.0f,  1.0f,1.0f,1.0f,1.0f,  1.0f, 0.0f, 0.0f,   1.0f, 1.0f,-1.0f },{ 0.0f,1.0f,  1.0f,1.0f,1.0f,1.0f,  1.0f, 0.0f, 0.0f,   1.0f, 1.0f, 1.0f },{ 0.0f,0.0f,  1.0f,1.0f,1.0f,1.0f,  1.0f, 0.0f, 0.0f,   1.0f,-1.0f, 1.0f },// Left face{ 0.0f,0.0f,  1.0f,1.0f,1.0f,1.0f, -1.0f, 0.0f, 0.0f,  -1.0f,-1.0f,-1.0f },{ 1.0f,0.0f,  1.0f,1.0f,1.0f,1.0f, -1.0f, 0.0f, 0.0f,  -1.0f,-1.0f, 1.0f },{ 1.0f,1.0f,  1.0f,1.0f,1.0f,1.0f, -1.0f, 0.0f, 0.0f,  -1.0f, 1.0f, 1.0f },{ 0.0f,1.0f,  1.0f,1.0f,1.0f,1.0f, -1.0f, 0.0f, 0.0f,  -1.0f, 1.0f,-1.0f }
};// For each vertex defined above, we'll need to create a Tangent, BiNormal, and
// Normal vector, which together define a tangent matrix for Dot3 bump mapping.
vector3f g_vTangents[NUM_VERTICES];
vector3f g_vBiNormals[NUM_VERTICES];
vector3f g_vNormals[NUM_VERTICES];//-----------------------------------------------------------------------------
// PROTOTYPES
//-----------------------------------------------------------------------------
int WINAPI WinMain(HINSTANCE g_hInstance,HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow);
LRESULT CALLBACK WindowProc(HWND g_hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
void loadTexture(void);
void init(void);
void render(void);
void shutDown(void);
vector3f scaleAndBiasVectorAsRGBColor(vector3f* vVector);
void computeTangentsMatricesForEachVertex(void);
void createTangentSpaceVectors( vector3f *v1, vector3f *v2, vector3f *v3,float v1u, float v1v, float v2u, float v2v, float v3u, float v3v, vector3f *vTangent, vector3f *vBiNormal, vector3f *vNormal );//-----------------------------------------------------------------------------
// Name: WinMain()
// Desc: The application's entry point
//-----------------------------------------------------------------------------
int WINAPI WinMain( HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR     lpCmdLine,int       nCmdShow )
{WNDCLASSEX winClass;MSG        uMsg;memset(&uMsg,0,sizeof(uMsg));winClass.lpszClassName = "MY_WINDOWS_CLASS";winClass.cbSize        = sizeof(WNDCLASSEX);winClass.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;winClass.lpfnWndProc   = WindowProc;winClass.hInstance     = hInstance;winClass.hIcon         = LoadIcon(hInstance, (LPCTSTR)IDI_OPENGL_ICON);winClass.hIconSm       = LoadIcon(hInstance, (LPCTSTR)IDI_OPENGL_ICON);winClass.hCursor       = LoadCursor(NULL, IDC_ARROW);winClass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);winClass.lpszMenuName  = NULL;winClass.cbClsExtra    = 0;winClass.cbWndExtra    = 0;if( !RegisterClassEx(&winClass) )return E_FAIL;g_hWnd = CreateWindowEx( NULL,"MY_WINDOWS_CLASS","OpenGL - Dot3 Per-Pixel Bump Mapping",WS_OVERLAPPEDWINDOW,0,0, 640,480, NULL, NULL, hInstance, NULL );if( g_hWnd == NULL )return E_FAIL;ShowWindow( g_hWnd, nCmdShow );UpdateWindow( g_hWnd );init();while( uMsg.message != WM_QUIT ){if( PeekMessage( &uMsg, NULL, 0, 0, PM_REMOVE ) ){ TranslateMessage( &uMsg );DispatchMessage( &uMsg );}else{g_dCurTime     = timeGetTime();g_fElpasedTime = (float)((g_dCurTime - g_dLastTime) * 0.001);g_dLastTime    = g_dCurTime;render();}}shutDown();UnregisterClass( "MY_WINDOWS_CLASS", hInstance );return uMsg.wParam;
}//-----------------------------------------------------------------------------
// Name: WindowProc()
// Desc: The window's message handler
//-----------------------------------------------------------------------------
LRESULT CALLBACK WindowProc( HWND   g_hWnd, UINT   msg, WPARAM wParam, LPARAM lParam )
{static POINT ptLastMousePosit;static POINT ptCurrentMousePosit;static bool bMousing;switch( msg ){case WM_CHAR:{switch( wParam ){case 'd':case 'D':g_bDoDot3BumpMapping = !g_bDoDot3BumpMapping;break;case 'l':case 'L':g_bToggleRegularLighting = !g_bToggleRegularLighting;break;case 'm':case 'M':g_bMoveLightAbout = !g_bMoveLightAbout;break;}}break;case WM_KEYDOWN:{switch( wParam ){case VK_ESCAPE:PostQuitMessage(0);break;case 38: // Up Arrow Keyg_fDistance += 0.1f;break;case 40: // Down Arrow Keyg_fDistance -= 0.1f;break;}}break;case WM_LBUTTONDOWN:{ptLastMousePosit.x = ptCurrentMousePosit.x = LOWORD (lParam);ptLastMousePosit.y = ptCurrentMousePosit.y = HIWORD (lParam);bMousing = true;}break;case WM_LBUTTONUP:{bMousing = false;}break;case WM_MOUSEMOVE:{ptCurrentMousePosit.x = LOWORD (lParam);ptCurrentMousePosit.y = HIWORD (lParam);if( bMousing ){g_fSpinX -= (ptCurrentMousePosit.x - ptLastMousePosit.x);g_fSpinY -= (ptCurrentMousePosit.y - ptLastMousePosit.y);}ptLastMousePosit.x = ptCurrentMousePosit.x;ptLastMousePosit.y = ptCurrentMousePosit.y;}break;case WM_SIZE:{int nWidth  = LOWORD(lParam); int nHeight = HIWORD(lParam);glViewport(0, 0, nWidth, nHeight);glMatrixMode( GL_PROJECTION );glLoadIdentity();gluPerspective( 45.0, (GLdouble)nWidth / (GLdouble)nHeight, 0.1, 100.0);}break;case WM_CLOSE:{PostQuitMessage(0); }case WM_DESTROY:{PostQuitMessage(0);}break;default:{return DefWindowProc( g_hWnd, msg, wParam, lParam );}break;}return 0;
}//-----------------------------------------------------------------------------
// Name: loadTexture()
// Desc:
//-----------------------------------------------------------------------------
void loadTexture(void)
{//// Load the normal map...//AUX_RGBImageRec *pTextureImage = auxDIBImageLoad( ".\\stone_wall_normal_map.bmp" );//AUX_RGBImageRec *pTextureImage = auxDIBImageLoad( ".\\test_normal_map.bmp" );if( pTextureImage != NULL ){glGenTextures( 1, &g_normalmapTextureID );glBindTexture( GL_TEXTURE_2D, g_normalmapTextureID );glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR );glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR );glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, pTextureImage->sizeX, pTextureImage->sizeY, 0,GL_RGB, GL_UNSIGNED_BYTE, pTextureImage->data );}if( pTextureImage ){if( pTextureImage->data )free( pTextureImage->data );free( pTextureImage );}//// Load the base texture//pTextureImage = auxDIBImageLoad( ".\\stone_wall.bmp" );//pTextureImage = auxDIBImageLoad( ".\\checker_with_numbers.bmp" );if( pTextureImage != NULL ){glGenTextures( 1, &g_textureID );glBindTexture( GL_TEXTURE_2D, g_textureID );glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR );glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR );glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, pTextureImage->sizeX, pTextureImage->sizeY, 0,GL_RGB, GL_UNSIGNED_BYTE, pTextureImage->data );}if( pTextureImage ){if( pTextureImage->data )free( pTextureImage->data );free( pTextureImage );}
}//-----------------------------------------------------------------------------
// Name: init()
// Desc:
//-----------------------------------------------------------------------------
void init( void )
{GLuint PixelFormat;PIXELFORMATDESCRIPTOR pfd;memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));pfd.nSize      = sizeof(PIXELFORMATDESCRIPTOR);pfd.nVersion   = 1;pfd.dwFlags    = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;pfd.iPixelType = PFD_TYPE_RGBA;pfd.cColorBits = 16;pfd.cDepthBits = 16;g_hDC = GetDC( g_hWnd );PixelFormat = ChoosePixelFormat( g_hDC, &pfd );SetPixelFormat( g_hDC, PixelFormat, &pfd);g_hRC = wglCreateContext( g_hDC );wglMakeCurrent( g_hDC, g_hRC );glClearColor( 0.35f, 0.53f, 0.7f, 1.0f );glEnable( GL_TEXTURE_2D );glEnable( GL_DEPTH_TEST );//glShadeModel( GL_FLAT );glShadeModel( GL_SMOOTH ); // Supposedly this is important to set when doing Dot3, but I notice no difference.glMatrixMode( GL_PROJECTION );glLoadIdentity();gluPerspective( 45.0f, 640.0f / 480.0f, 0.1f, 100.0f);// Set up the view matrixglMatrixMode( GL_MODELVIEW );glLoadIdentity();// For lighting, pull our material colors from the vertex color...glColorMaterial( GL_FRONT, GL_AMBIENT_AND_DIFFUSE );glEnable( GL_COLOR_MATERIAL );// Set light 0 to be a pure white point lightGLfloat diffuse_light0[]  = { 1.0f, 1.0f,  1.0f, 1.0f };glLightfv( GL_LIGHT0, GL_DIFFUSE, diffuse_light0 );glLightfv( GL_LIGHT0, GL_POSITION, g_lightPosition );glEnable( GL_LIGHTING );glEnable( GL_LIGHT0 );// Enable some dim, gray ambient lighting so objects that are not lit // by the other lights are not completely black.GLfloat ambient_lightModel[] = { 0.2f, 0.2f, 0.2f, 0.2f };glLightModelfv( GL_LIGHT_MODEL_AMBIENT, ambient_lightModel );loadTexture();//// If the required extension is present, get the addresses of its // functions that we wish to use...////// GL_ARB_multitexture//char *ext = (char*)glGetString( GL_EXTENSIONS );if( strstr( ext, "GL_ARB_multitexture" ) == NULL ){MessageBox(NULL,"GL_ARB_multitexture extension was not found","ERROR",MB_OK|MB_ICONEXCLAMATION);return;}else{glActiveTexture       = (PFNGLCLIENTACTIVETEXTUREPROC)wglGetProcAddress("glActiveTexture");glMultiTexCoord2f     = (PFNGLMULTITEXCOORD2FPROC)wglGetProcAddress("glMultiTexCoord2f");glClientActiveTexture = (PFNGLACTIVETEXTUREARBPROC)wglGetProcAddress("glClientActiveTexture");if( !glActiveTexture || !glMultiTexCoord2f || !glClientActiveTexture ){MessageBox(NULL,"One or more GL_ARB_multitexture functions were not found","ERROR",MB_OK|MB_ICONEXCLAMATION);return;}}//// GL_EXT_texture_env_combine//if( strstr( ext, "GL_EXT_texture_env_combine" ) == NULL ){MessageBox(NULL,"GL_EXT_texture_env_combine extension was not found","ERROR",MB_OK|MB_ICONEXCLAMATION);return;}//// For each vertex, create a tangent vector, binormal, and normal//// Initialize the inverse tangent matrix for each vertex to the identity // matrix before we get started.for( int i = 0; i < NUM_VERTICES; ++i ){g_vTangents[i]  = vector3f( 1.0f, 0.0f, 0.0f );g_vBiNormals[i] = vector3f( 0.0f, 1.0f, 0.0f );g_vNormals[i]   = vector3f( 0.0f, 0.0f, 1.0f );}computeTangentsMatricesForEachVertex();}//-----------------------------------------------------------------------------
// Name: shutDown()
// Desc:
//-----------------------------------------------------------------------------
void shutDown(void)
{glDeleteTextures( 1, &g_textureID );glDeleteTextures( 1, &g_normalmapTextureID );if( g_hRC != NULL ){wglMakeCurrent( NULL, NULL );wglDeleteContext( g_hRC );g_hRC = NULL;                           }if( g_hDC != NULL ){ReleaseDC( g_hWnd, g_hDC );g_hDC = NULL;}
}//-----------------------------------------------------------------------------
// Name: computeTangentsMatricesForEachVertex()
// 对每一个顶点计算切线矩阵
// Desc:
//-----------------------------------------------------------------------------
void computeTangentsMatricesForEachVertex(void)
{vector3f v1;vector3f v2;vector3f v3;vector3f vTangent;vector3f vBiNormal;vector3f vNormal;//// For each cube face defined in the vertex array, compute a tangent matrix // for each of the four vertices that define it.//for( int i = 0; i < NUM_VERTICES; i += 4 ) // Use += 4 to process 1 face at a time{//// Vertex 0 of current cube face...////  v2//    3----2//    |    |//    |    |//    0----1//  v1      v3//v1 = vector3f(g_cubeVertices[i].x,g_cubeVertices[i].y,g_cubeVertices[i].z);v2 = vector3f(g_cubeVertices[i+3].x,g_cubeVertices[i+3].y,g_cubeVertices[i+3].z);v3 = vector3f(g_cubeVertices[i+1].x,g_cubeVertices[i+1].y,g_cubeVertices[i+1].z);createTangentSpaceVectors( &v1,&v2,&v3,g_cubeVertices[i].tu, g_cubeVertices[i].tv,g_cubeVertices[i+3].tu, g_cubeVertices[i+3].tv,g_cubeVertices[i+1].tu, g_cubeVertices[i+1].tv,&vTangent, &vBiNormal, &vNormal );g_vTangents[i]  = vTangent;g_vBiNormals[i] = vBiNormal;g_vNormals[i]   = vNormal;//// Vertex 1 of current cube face...////          v3//    3----2//    |    |//    |    |//    0----1//  v2      v1//v1 = vector3f(g_cubeVertices[i+1].x,g_cubeVertices[i+1].y,g_cubeVertices[i+1].z);v2 = vector3f(g_cubeVertices[i].x,g_cubeVertices[i].y,g_cubeVertices[i].z);v3 = vector3f(g_cubeVertices[i+2].x,g_cubeVertices[i+2].y,g_cubeVertices[i+2].z);createTangentSpaceVectors( &v1,&v2,&v3,g_cubeVertices[i+1].tu, g_cubeVertices[i+1].tv,g_cubeVertices[i].tu, g_cubeVertices[i].tv,g_cubeVertices[i+2].tu, g_cubeVertices[i+2].tv,&vTangent, &vBiNormal, &vNormal );g_vTangents[i+1]  = vTangent;g_vBiNormals[i+1] = vBiNormal;g_vNormals[i+1]   = vNormal;//// Vertex 2 of current cube face...////  v3      v1//    3----2//    |    |//    |    |//    0----1//          v2//v1 = vector3f(g_cubeVertices[i+2].x,g_cubeVertices[i+2].y,g_cubeVertices[i+2].z);v2 = vector3f(g_cubeVertices[i+1].x,g_cubeVertices[i+1].y,g_cubeVertices[i+1].z);v3 = vector3f(g_cubeVertices[i+3].x,g_cubeVertices[i+3].y,g_cubeVertices[i+3].z);createTangentSpaceVectors( &v1,&v2,&v3,g_cubeVertices[i+2].tu, g_cubeVertices[i+2].tv,g_cubeVertices[i+1].tu, g_cubeVertices[i+1].tv,g_cubeVertices[i+3].tu, g_cubeVertices[i+3].tv,&vTangent, &vBiNormal, &vNormal );g_vTangents[i+2]  = vTangent;g_vBiNormals[i+2] = vBiNormal;g_vNormals[i+2]   = vNormal;//// Vertex 3 of current cube face...////  v1      v2//    3----2//    |    |//    |    |//    0----1//  v3//v1 = vector3f(g_cubeVertices[i+3].x,g_cubeVertices[i+3].y,g_cubeVertices[i+3].z);v2 = vector3f(g_cubeVertices[i+2].x,g_cubeVertices[i+2].y,g_cubeVertices[i+2].z);v3 = vector3f(g_cubeVertices[i].x,g_cubeVertices[i].y,g_cubeVertices[i].z);createTangentSpaceVectors( &v1,&v2,&v3,g_cubeVertices[i+3].tu, g_cubeVertices[i+3].tv,g_cubeVertices[i+2].tu, g_cubeVertices[i+2].tv,g_cubeVertices[i].tu, g_cubeVertices[i].tv,&vTangent, &vBiNormal, &vNormal );g_vTangents[i+3]  = vTangent;g_vBiNormals[i+3] = vBiNormal;g_vNormals[i+3]   = vNormal;}
}//-----------------------------------------------------------------------------
// Name: createTangentSpaceVectors()
// Desc: Given a vertex (v1) and two other vertices (v2 & v3) which define a
//       triangle, this function will return Tangent, BiNormal, and Normal,
//       vectors which can be used to define the tangent matrix for the first
//       vertex's position (v1).
//
// Args: v1        - vertex 1
//       v2        - vertex 2
//       v3        - vertex 3
//       v1u, v1v  - texture-coordinates of vertex 1
//       v2u, v2v  - texture-coordinates of vertex 2
//       v3u, v3v  - texture-coordinates of vertex 3
//       vTangent  - When the function returns, this will be set as the tangent vector
//       vBiNormal - When the function returns, this will be set as the binormal vector
//       vNormal   - When the function returns, this will be set as the normal vector
//
// Note: This function is based on an article by By Jakob Gath and Sbren Dreijer.
// http://www.blacksmith-studios.dk/projects/downloads/tangent_matrix_derivation.php
//------------------------------------------------------------------------------void createTangentSpaceVectors( vector3f *v1,vector3f *v2,vector3f *v3,float v1u, float v1v,float v2u, float v2v,float v3u, float v3v,vector3f *vTangent,vector3f *vBiNormal,vector3f *vNormal )
{// Create edge vectors from vertex 1 to vectors 2 and 3.vector3f vDirVec_v2_to_v1 = *v2 - *v1;vector3f vDirVec_v3_to_v1 = *v3 - *v1;// Create edge vectors from the texture coordinates of vertex 1 to vector 2.float vDirVec_v2u_to_v1u = v2u - v1u;float vDirVec_v2v_to_v1v = v2v - v1v;// Create edge vectors from the texture coordinates of vertex 1 to vector 3.float vDirVec_v3u_to_v1u = v3u - v1u;float vDirVec_v3v_to_v1v = v3v - v1v;float fDenominator = vDirVec_v2u_to_v1u * vDirVec_v3v_to_v1v - vDirVec_v3u_to_v1u * vDirVec_v2v_to_v1v;if( fDenominator < 0.0001f && fDenominator > -0.0001f ){// We're too close to zero and we're at risk of a divide-by-zero! // Set the tangent matrix to the identity matrix and do nothing.*vTangent  = vector3f( 1.0f, 0.0f, 0.0f );*vBiNormal = vector3f( 0.0f, 1.0f, 0.0f );*vNormal   = vector3f( 0.0f, 0.0f, 1.0f );}else{// Calculate and cache the reciprocal valuefloat fScale1 = 1.0f / fDenominator;vector3f T;vector3f B;vector3f N;T = vector3f((vDirVec_v3v_to_v1v * vDirVec_v2_to_v1.x - vDirVec_v2v_to_v1v * vDirVec_v3_to_v1.x) * fScale1,(vDirVec_v3v_to_v1v * vDirVec_v2_to_v1.y - vDirVec_v2v_to_v1v * vDirVec_v3_to_v1.y) * fScale1,(vDirVec_v3v_to_v1v * vDirVec_v2_to_v1.z - vDirVec_v2v_to_v1v * vDirVec_v3_to_v1.z) * fScale1);B = vector3f((-vDirVec_v3u_to_v1u * vDirVec_v2_to_v1.x + vDirVec_v2u_to_v1u * vDirVec_v3_to_v1.x) * fScale1,(-vDirVec_v3u_to_v1u * vDirVec_v2_to_v1.y + vDirVec_v2u_to_v1u * vDirVec_v3_to_v1.y) * fScale1,(-vDirVec_v3u_to_v1u * vDirVec_v2_to_v1.z + vDirVec_v2u_to_v1u * vDirVec_v3_to_v1.z) * fScale1);// The normal N is calculated as the cross product between T and BN = crossProduct( T, B );// Calculate and cache the reciprocal valuefloat fScale2 = 1.0f / ((T.x * B.y * N.z - T.z * B.y * N.x) + (B.x * N.y * T.z - B.z * N.y * T.x) + (N.x * T.y * B.z - N.z * T.y * B.x));//// Use the temporary T (Tangent), (B) Binormal, and N (Normal) vectors // to calculate the inverse of the tangent matrix that they represent.// The inverse of the tangent matrix is what we want since we need that// to transform the light's vector into tangent-space.//(*vTangent).x =   crossProduct( B, N ).x * fScale2;(*vTangent).y = -(crossProduct( N, T ).x * fScale2);(*vTangent).z =   crossProduct( T, B ).x * fScale2;(*vTangent).normalize();(*vBiNormal).x = -(crossProduct( B, N ).y * fScale2);(*vBiNormal).y =   crossProduct( N, T ).y * fScale2;(*vBiNormal).z = -(crossProduct( T, B ).y * fScale2);(*vBiNormal).normalize();(*vNormal).x =   crossProduct( B, N ).z * fScale2;(*vNormal).y = -(crossProduct( N, T ).z * fScale2);(*vNormal).z =   crossProduct( T, B ).z * fScale2;(*vNormal).normalize();//// NOTE: Since the texture-space of Direct3D and OpenGL are laid-out //       differently, a single normal map can't look right in both //       unless you make some adjustments somewhere.////       You can adjust or fix this problem in three ways:////       1. Create two normal maps: one for OpenGL and one for Direct3D.//       2. Flip the normal map image over as you load it into a texture //          object.//       3. Flip the binormal over when computing the tangent-space//          matrix.//// Since the normal map used by this sample was created for Direct3D,// I've decided to simply flip the binormal.//*vBiNormal = *vBiNormal * -1.0f;}
}//-----------------------------------------------------------------------------
// Name: scaleAndBiasVectorAsRGBColor()
// Desc:
//-----------------------------------------------------------------------------
vector3f scaleAndBiasVectorAsRGBColor( vector3f* vVector )
{vector3f vScaledAndBiasedVector;vScaledAndBiasedVector.x = ((*vVector).x * 0.5f) + 0.5f;vScaledAndBiasedVector.y = ((*vVector).y * 0.5f) + 0.5f;vScaledAndBiasedVector.z = ((*vVector).z * 0.5f) + 0.5f;return vScaledAndBiasedVector;
}//-----------------------------------------------------------------------------
// Name: render()
// Desc:
//-----------------------------------------------------------------------------
void render( void )
{// Clear the screen and the depth bufferglClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );glMatrixMode( GL_MODELVIEW );glLoadIdentity();// Translate our view back a bitglTranslatef( 0.0f, 0.0f, g_fDistance );if( g_bMoveLightAbout == true ){//// Spin our point light around the cube...//static float fAngle = 0;fAngle += 60 * g_fElpasedTime;// Wrap it around, if it gets too bigwhile(fAngle > 360.0f) fAngle -= 360.0f;while(fAngle < 0.0f)   fAngle += 360.0f;float x = sinf( DEGTORAD(fAngle) );float y = cosf( DEGTORAD(fAngle) );// The call to glLightfv is just like calling glTranslatef on our// light's position.g_lightPosition[0] = 1.2f * x;g_lightPosition[1] = 1.2f * y;g_lightPosition[2] = 2.0f;glLightfv( GL_LIGHT0, GL_POSITION, g_lightPosition );}// Spin the cube via mouse input.glRotatef( -g_fSpinY, 1.0f, 0.0f, 0.0f );glRotatef( -g_fSpinX, 0.0f, 1.0f, 0.0f );//// Set texture units to some known state...//glActiveTexture(GL_TEXTURE0);glMatrixMode(GL_TEXTURE);glLoadIdentity();glMatrixMode(GL_MODELVIEW);glDisable(GL_TEXTURE_3D_EXT);glDisable(GL_TEXTURE_CUBE_MAP_ARB);glDisable(GL_TEXTURE_2D);glDisable(GL_TEXTURE_GEN_S);glDisable(GL_TEXTURE_GEN_T);glDisable(GL_TEXTURE_GEN_R);glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);glActiveTexture(GL_TEXTURE1);glMatrixMode(GL_TEXTURE);glLoadIdentity();glMatrixMode(GL_MODELVIEW);glDisable(GL_TEXTURE_3D_EXT);glDisable(GL_TEXTURE_CUBE_MAP_ARB);glDisable(GL_TEXTURE_2D);glDisable(GL_TEXTURE_GEN_S);glDisable(GL_TEXTURE_GEN_T);glDisable(GL_TEXTURE_GEN_R);glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);if( g_bToggleRegularLighting == true )glEnable( GL_LIGHTING );elseglDisable( GL_LIGHTING );if( g_bDoDot3BumpMapping == true ){        //// Render a Dot3 bump mapped cube...////// STAGE 0//// Use GL_DOT3_RGB_EXT to find the dot-product of (N.L), where N is // stored in the normal map, and L is passed in as the PRIMARY_COLOR// using the standard glColor3f call.//glActiveTexture(GL_TEXTURE0);glBindTexture (GL_TEXTURE_2D, g_normalmapTextureID);glEnable(GL_TEXTURE_2D);glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);      // Perform a Dot3 operation...glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_DOT3_RGB_EXT); glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);           // between the N (of N.L) which is stored in a normal map texture...glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_PRIMARY_COLOR_EXT); // with the L (of N.L) which is stored in the vertex's diffuse color.glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);//// STAGE 1//// Modulate the base texture by N.L calculated in STAGE 0.//glActiveTexture(GL_TEXTURE1);glBindTexture (GL_TEXTURE_2D, g_textureID);glEnable(GL_TEXTURE_2D);glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);  // Modulate...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);    // the color argument passed down from the previous stage (stage 0) with...glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, GL_TEXTURE);glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, GL_SRC_COLOR);    // the texture for this stage with.//// Transform the light's position from eye-space to object-space//vector3f vLightPosES;    // Light position (in eye-space)vector3f vLightPosOS;    // Light position (in object-space)vector3f vVertToLightOS; // L vector of N.L (in object-space)vector3f vVertToLightTS; // L vector of N.L (in tangent-space)// Get the light's current position, which is in eye-space.float fLightsPosition[4];glGetLightfv( GL_LIGHT0, GL_POSITION, fLightsPosition );vLightPosES.x = fLightsPosition[0];vLightPosES.y = fLightsPosition[1];vLightPosES.z = fLightsPosition[2];// Transform the light's position from eye-space into object-spacematrix4x4f modelViewMatrix;matrix4x4f modelViewMatrixInverse;glGetFloatv(GL_MODELVIEW_MATRIX, &modelViewMatrix.m[0] );modelViewMatrixInverse = matrix4x4f::invertMatrix( &modelViewMatrix );vLightPosOS = vLightPosES;modelViewMatrixInverse.transformPoint( &vLightPosOS );//// Now, render our textured test cube, which consists of 6 quads...//vector3f vCurrentVertex;glBegin( GL_QUADS );{for( int i = 0; i < NUM_VERTICES; ++i ){vCurrentVertex.x = g_cubeVertices[i].x;vCurrentVertex.y = g_cubeVertices[i].y;vCurrentVertex.z = g_cubeVertices[i].z;glMultiTexCoord2f( GL_TEXTURE0, g_cubeVertices[i].tu, g_cubeVertices[i].tv );glMultiTexCoord2f( GL_TEXTURE1, g_cubeVertices[i].tu, g_cubeVertices[i].tv );//// For each vertex, rotate L (of N.L) into tangent-space and // pass it into OpenGL's texture blending system by packing it // into the glVertex3f for that vertex.//vVertToLightOS = vLightPosOS - vCurrentVertex;vVertToLightOS.normalize();//// Build up an inverse tangent-space matrix using the Tangent, // Binormal, and Normal calculated for the current vertex and // then use it to transform our L vector (of N.L), which is in // object-space, into tangent-space.//// A tangent matrix is of the form://// |Tx Bx Nx 0|// |Ty By Ny 0|// |Tz Bz Nz 0|// |0  0  0  1|//// Note: Our vectors have already been inverted, so there is no // need to invert our tangent matrix once we build it up.////                         Tangent          Binormal           Normalmatrix4x4f invTangentMatrix( g_vTangents[i].x, g_vBiNormals[i].x, g_vNormals[i].x, 0.0f,g_vTangents[i].y, g_vBiNormals[i].y, g_vNormals[i].y, 0.0f,g_vTangents[i].z, g_vBiNormals[i].z, g_vNormals[i].z, 0.0f,0.0f,             0.0f,              0.0f,            1.0f );vVertToLightTS = vVertToLightOS;invTangentMatrix.transformVector( &vVertToLightTS );//// Last but not least, we must scale and bias our L vector // before passing it as a vertex color since colors have a // clamped range of [0,1]. If we don't do this any negative // components of our L vector will get clamped and the vector // will be wrong. Of course, the hardware assumes that we are // going to do this, so it will simply decode the original // vector back out by reversing the scale and bias we've // performed here.//vector3f vVertToLightTS_scaledAndBiased = scaleAndBiasVectorAsRGBColor( &vVertToLightTS );glColor3f( vVertToLightTS_scaledAndBiased.x,vVertToLightTS_scaledAndBiased.y,vVertToLightTS_scaledAndBiased.z );//glColor3f( 0.8,//  0.6,//  0.5 );glNormal3f( g_cubeVertices[i].nx, g_cubeVertices[i].ny, g_cubeVertices[i].nz );glVertex3f( vCurrentVertex.x, vCurrentVertex.y, vCurrentVertex.z );}}glEnd();/// glTranslatef(1,0,0);glDisable(GL_LIGHTING);#if 1glDisable(GL_DEPTH_TEST);glCullFace(GL_BACK);glEnable(GL_CULL_FACE);glEnable(GL_BLEND);glBlendFunc(GL_ONE,GL_ONE);glActiveTexture(GL_TEXTURE0);glBindTexture (GL_TEXTURE_2D, g_textureID);glEnable(GL_TEXTURE_2D);glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);glActiveTexture(GL_TEXTURE1);glDisable(GL_TEXTURE_2D);glBegin( GL_QUADS );{for( int i = 0; i < NUM_VERTICES; ++i ){glMultiTexCoord2f( GL_TEXTURE0, g_cubeVertices[i].tu, g_cubeVertices[i].tv );glMultiTexCoord2f( GL_TEXTURE1, g_cubeVertices[i].tu, g_cubeVertices[i].tv );//glColor3f( g_cubeVertices[i].r, g_cubeVertices[i].g, g_cubeVertices[i].b );//glNormal3f( g_cubeVertices[i].nx, g_cubeVertices[i].ny, g_cubeVertices[i].nz );glVertex3f( g_cubeVertices[i].x, g_cubeVertices[i].y, g_cubeVertices[i].z );}}glEnd();glDisable(GL_BLEND);glEnable(GL_DEPTH_TEST);
#endif}else{        //// Render a regular textured cube with no Dot3 bump mapping...////// STAGE 0//glActiveTexture(GL_TEXTURE0);glBindTexture (GL_TEXTURE_2D, g_textureID);glEnable(GL_TEXTURE_2D);glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_REPLACE);   glTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, GL_TEXTURE);glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, GL_SRC_COLOR);//// STAGE 1//glActiveTexture(GL_TEXTURE1);glDisable(GL_TEXTURE_2D);glBegin( GL_QUADS );{for( int i = 0; i < NUM_VERTICES; ++i ){glMultiTexCoord2f( GL_TEXTURE0, g_cubeVertices[i].tu, g_cubeVertices[i].tv );glMultiTexCoord2f( GL_TEXTURE1, g_cubeVertices[i].tu, g_cubeVertices[i].tv );glColor3f( g_cubeVertices[i].r, g_cubeVertices[i].g, g_cubeVertices[i].b );glNormal3f( g_cubeVertices[i].nx, g_cubeVertices[i].ny, g_cubeVertices[i].nz );glVertex3f( g_cubeVertices[i].x, g_cubeVertices[i].y, g_cubeVertices[i].z );}}glEnd();}//// Reset texture unit state//glActiveTexture(GL_TEXTURE0);glMatrixMode(GL_TEXTURE);glLoadIdentity();glMatrixMode(GL_MODELVIEW);glDisable(GL_TEXTURE_3D_EXT);glDisable(GL_TEXTURE_CUBE_MAP_ARB);glDisable(GL_TEXTURE_2D);glDisable(GL_TEXTURE_GEN_S);glDisable(GL_TEXTURE_GEN_T);glDisable(GL_TEXTURE_GEN_R);glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);glActiveTexture(GL_TEXTURE1);glMatrixMode(GL_TEXTURE);glLoadIdentity();glMatrixMode(GL_MODELVIEW);glDisable(GL_TEXTURE_3D_EXT);glDisable(GL_TEXTURE_CUBE_MAP_ARB);glDisable(GL_TEXTURE_2D);glDisable(GL_TEXTURE_GEN_S);glDisable(GL_TEXTURE_GEN_T);glDisable(GL_TEXTURE_GEN_R);glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);//// Render a small white sphere to mark the point light's position...//glDisable( GL_LIGHTING );glMatrixMode( GL_MODELVIEW );glLoadIdentity();glTranslatef( 0.0f, 0.0f, g_fDistance );glTranslatef( g_lightPosition[0], g_lightPosition[1], g_lightPosition[2] );glColor3f( 1.0f, 1.0f, 1.0f );renderSolidSphere( 0.05f, 8, 8 );glEnable( GL_LIGHTING );SwapBuffers( g_hDC );
}