opengl贴图程序

// #include <GL/gl.h>
#include  < GL / glaux.h >  
#include  < glut.h >  

// glaux.lib glut32.lib 

namespace  Test9
... {
    #include <windows.h>        // Header File For Windows
#include <math.h>            // Math Library Header File
#include <stdio.h>            // Header File For Standard Input/Output
#include <glgl.h>            // Header File For The OpenGL32 Library
#include <glglu.h>            // Header File For The GLu32 Library
#include <glglaux.h>        // Header File For The Glaux Library

HDC            hDC=NULL;        // Private GDI Device Context
HGLRC        hRC=NULL;        // Permanent Rendering Context
HWND        hWnd=NULL;        // Holds Our Window Handle
HINSTANCE    hInstance;        // Holds The Instance Of The Application

bool    keys[256];            // Array Used For The Keyboard Routine
bool    active=TRUE;        // Window Active Flag Set To TRUE By Default
bool    fullscreen=TRUE;    // Fullscreen Flag Set To Fullscreen Mode By Default
bool    blend;                // Blending ON/OFF
bool    bp;                    // B Pressed?
bool    fp;                    // F Pressed?

const float piover180 = 0.0174532925f;

GLfloat walkbias = 0;
GLfloat walkbiasangle = 0;
GLfloat rot_x = 0.0f;
GLfloat    rot_y=0;                // Y Rotation
GLfloat    rot_z=0;                
GLfloat    g_z=-5.0f;                // Depth Into The Screen
GLfloat    x=0.0f;                // Depth Into The Screen
GLfloat    y=0.0f;                // Depth Into The Screen

GLuint    filter;                // Which Filter To Use
GLuint    texture[3];            // Storage For 3 Textures

typedef struct tagVERTEX
...{
    float x, y, z;//3D坐标
    float u, v;//纹理坐标
} VERTEX;

typedef struct tagTRIANGLE
...{//Triangle三角形结构
    VERTEX vertex[3];
} TRIANGLE;

typedef struct tagSECTOR
...{
    int numtriangles;// Sector中的三角形个数
    TRIANGLE* triangle;// 指向三角数组的指针
} SECTOR;

SECTOR sector1;                // Our Model Goes Here:

typedef struct...{
    int numPoints;
    VERTEX *vertex;
}MYPOINTS;

MYPOINTS g_pts;

LRESULT    CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);    // Declaration For WndProc

void readstr(FILE *f,char *string)
...{//  读入一个字符串
    do
    ...{
        fgets(string, 255, f);

          int i1=0,i2=strlen(string),i;
          while (string[i1] && (string[i1]==' ' || string[i1]==' '))i1++;
//          printf("i1=%d  ",i1);
//         printf(string);
//         while (string[i2]==' ' || string[i2]==' ')i1--;
          if(i1>=i2)
              continue;
          else if(i1>0)
          ...{
              for (i=i1;i<i2;i++)
              ...{
                 string[i-i1]=string[i];
              }
             string[i2-i1]=0;
//            printf(string);
          }
     } while ((string[0] == '/') || (string[0] == ' '));
    return;
}

void SetupWorld()
...{// 设置我们的世界
    float x, y, z, u, v;
    int numtriangles;
    FILE *filein;
    char oneline[255];
    filein = fopen("world.txt", "rt");                // File To Load World Data From
    CHECK(filein);

    readstr(filein,oneline);
    //printf(oneline);
    sscanf(oneline, "NUMPOLLIES %d ", &numtriangles);
    CHECK(numtriangles>0);
    
    sector1.triangle = new TRIANGLE[numtriangles];
    sector1.numtriangles = numtriangles;
    for (int loop = 0; loop < numtriangles; loop++)
    ...{
        for (int vert = 0; vert < 3; vert++)
        ...{
            readstr(filein,oneline);
            sscanf(oneline, "%f %f %f %f %f", &x, &y, &z, &u, &v);
            sector1.triangle[loop].vertex[vert].x = x;
            sector1.triangle[loop].vertex[vert].y = y;
            sector1.triangle[loop].vertex[vert].z = z;
            sector1.triangle[loop].vertex[vert].u = u;
            sector1.triangle[loop].vertex[vert].v = v;
        }
    }
    fclose(filein);
    return;
}

//支持定义点和面(三角和四边形)
void SetupWorld2()
...{// 设置我们的世界
    float x, y, z, u, v;
    int numpoints;
    FILE *filein;
    char oneline[255];
    filein = fopen("world2.txt", "rt");                // File To Load World Data From
    CHECK(filein);

    //读入点
    readstr(filein,oneline);
    CHECK(1==sscanf(oneline, "NUMPOINTS %d ", &numpoints));
    CHECK(numpoints>0);
    g_pts.numPoints=numpoints;
    g_pts.vertex=new VERTEX[numpoints];
    
    for (int loop = 0; loop < numpoints; loop++)
    ...{
        readstr(filein,oneline);
        CHECK(5==sscanf(oneline, "%f %f %f %f %f", &x, &y, &z, &u, &v));
        g_pts.vertex[loop].x=x;
        g_pts.vertex[loop].y=y;
        g_pts.vertex[loop].z=z;
        g_pts.vertex[loop].u=u;
        g_pts.vertex[loop].v=v;
    }

    //读入面
    int numtriangles=0;
    readstr(filein,oneline);
    CHECK(1==sscanf(oneline, "NUMPTRIANGLES %d ", &numtriangles));
    CHECK(numtriangles>0);
    sector1.triangle = new TRIANGLE[numtriangles];
    sector1.numtriangles = numtriangles;
    for ( loop = 0; loop < numtriangles; loop++)
    ...{
        int index[3];
        
        readstr(filein,oneline);
        CHECK(3==sscanf(oneline, "%d %d %d",index,index+1,index+2));
        CHECK(index[0]>=0 && index[0]<g_pts.numPoints);
        CHECK(index[1]>=0 && index[1]<g_pts.numPoints);
        CHECK(index[2]>=0 && index[2]<g_pts.numPoints);
        for (int vert = 0; vert < 3; vert++)
        ...{
            sector1.triangle[loop].vertex[vert]= g_pts.vertex[index[vert]];
        }
    }
    fclose(filein);
    return;
}

AUX_RGBImageRec *LoadBMP(char *Filename)                // Loads A Bitmap Image
...{
        FILE *File=NULL;                                // File Handle

        if (!Filename)                                  // Make Sure A Filename Was Given
        ...{
                return NULL;                            // If Not Return NULL
        }

        File=fopen(Filename,"r");                       // Check To See If The File Exists

        if (File)                                       // Does The File Exist?
        ...{
                fclose(File);                           // Close The Handle
                return auxDIBImageLoad(Filename);       // Load The Bitmap And Return A Pointer
        }
        return NULL;                                    // If Load Failed Return NULL
}

int LoadGLTextures()                                    // Load Bitmaps And Convert To Textures
...{
        int Status=FALSE;                               // Status Indicator

        AUX_RGBImageRec *TextureImage[1];               // Create Storage Space For The Texture

        memset(TextureImage,0,sizeof(void *)*1);        // Set The Pointer To NULL

        // Load The Bitmap, Check For Errors, If Bitmap's Not Found Quit
        if (TextureImage[0]=LoadBMP("1.bmp"))
        ...{
                Status=TRUE;                            // Set The Status To TRUE

                glGenTextures(3, &texture[0]);          // Create Three Textures

                // Create Nearest Filtered Texture
                glBindTexture(GL_TEXTURE_2D, texture[0]);
                glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
                glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
                glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);

                // Create Linear Filtered Texture
                glBindTexture(GL_TEXTURE_2D, texture[1]);
                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, TextureImage[0]->sizeX, TextureImage[0]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);

                // Create MipMapped Texture
                glBindTexture(GL_TEXTURE_2D, texture[2]);
                glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
                glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
                gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);
        }
        if (TextureImage[0])                            // If Texture Exists
        ...{
                if (TextureImage[0]->data)              // If Texture Image Exists
                ...{
                        free(TextureImage[0]->data);    // Free The Texture Image Memory
                }

                free(TextureImage[0]);                  // Free The Image Structure
        }

        return Status;                                  // Return The Status
}

GLvoid ReSizeGLScene(GLsizei width, GLsizei height)        // Resize And Initialize The GL Window
...{
    if (height==0)                                        // Prevent A Divide By Zero By
    ...{
        height=1;                                        // Making Height Equal One
    }

    glViewport(0,0,width,height);                        // Reset The Current Viewport

    glMatrixMode(GL_PROJECTION);                        // Select The Projection Matrix
    glLoadIdentity();                                    // Reset The Projection Matrix

    // Calculate The Aspect Ratio Of The Window
    gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);

    glMatrixMode(GL_MODELVIEW);                            // Select The Modelview Matrix
    glLoadIdentity();                                    // Reset The Modelview Matrix
}

int InitGL(GLvoid)                                        // All Setup For OpenGL Goes Here
...{
    if (!LoadGLTextures())                                // Jump To Texture Loading Routine
    ...{
        return FALSE;                                    // If Texture Didn't Load Return FALSE
    }

    glEnable(GL_TEXTURE_2D);                            // Enable Texture Mapping
    glBlendFunc(GL_SRC_ALPHA,GL_ONE);                    // Set The Blending Function For Translucency
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);                // This Will Clear The Background Color To Black
    glClearDepth(1.0);                                    // Enables Clearing Of The Depth Buffer
    glDepthFunc(GL_LESS);                                // The Type Of Depth Test To Do
    glEnable(GL_DEPTH_TEST);                            // Enables Depth Testing
    glShadeModel(GL_SMOOTH);                            // Enables Smooth Color Shading
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);    // Really Nice Perspective Calculations

    SetupWorld2();//建立世界

    return TRUE;                                        // Initialization Went OK
}

int DrawGLScene(GLvoid)                                    // Here's Where We Do All The Drawing
...{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);    // Clear The Screen And The Depth Buffer
    glLoadIdentity();                                    // Reset The View

    GLfloat x_m, y_m, z_m, u_m, v_m;
    static DWORD tickCnt=GetTickCount();
    int numtriangles;

    glTranslatef(x, y, g_z);

#if 1
    glRotatef(rot_x,1.0f,0,0);
    glRotatef(rot_y,0,1.0f,0);
    glRotatef(rot_z,0,0,1.0f);
#else
    int norm=sqrt(rot_x*rot_x+rot_y*rot_y+rot_z*rot_z);
    int ang_x=0;
    int ang_y=0;
    int ang_z=0;

    if(norm>10)
    ...{
        ang_x=rot_x/norm;
        ang_y=rot_y/norm;
        ang_z=rot_z/norm;
    }
    else
        norm=0;
    glRotatef(norm,rot_x,rot_y,rot_z);
#endif

    if(GetTickCount()-tickCnt>1000)
    ...{
        printf("Trans %8g %8g %8g ",x,y,g_z);
        printf("Rot   %8g %8g %8g ",rot_x,rot_y,rot_z);
        tickCnt=GetTickCount();
    }
    
    glBindTexture(GL_TEXTURE_2D, texture[filter]);
    
    numtriangles = sector1.numtriangles;
    
    // Process Each Triangle
    for (int loop_m = 0; loop_m < numtriangles; loop_m++)
    ...{
        glBegin(GL_TRIANGLES);
            glNormal3f( 0.0f, 0.0f, 1.0f);
            x_m = sector1.triangle[loop_m].vertex[0].x;
            y_m = sector1.triangle[loop_m].vertex[0].y;
            z_m = sector1.triangle[loop_m].vertex[0].z;
            u_m = sector1.triangle[loop_m].vertex[0].u;
            v_m = sector1.triangle[loop_m].vertex[0].v;
            glTexCoord2f(u_m,v_m); glVertex3f(x_m,y_m,z_m);
            
            x_m = sector1.triangle[loop_m].vertex[1].x;
            y_m = sector1.triangle[loop_m].vertex[1].y;
            z_m = sector1.triangle[loop_m].vertex[1].z;
            u_m = sector1.triangle[loop_m].vertex[1].u;
            v_m = sector1.triangle[loop_m].vertex[1].v;
            glTexCoord2f(u_m,v_m); glVertex3f(x_m,y_m,z_m);
            
            x_m = sector1.triangle[loop_m].vertex[2].x;
            y_m = sector1.triangle[loop_m].vertex[2].y;
            z_m = sector1.triangle[loop_m].vertex[2].z;
            u_m = sector1.triangle[loop_m].vertex[2].u;
            v_m = sector1.triangle[loop_m].vertex[2].v;
            glTexCoord2f(u_m,v_m); glVertex3f(x_m,y_m,z_m);
        glEnd();
    }
    return TRUE;                                        // Everything Went OK
}

GLvoid KillGLWindow(GLvoid)                                // Properly Kill The Window
...{
    if (fullscreen)                                        // Are We In Fullscreen Mode?
    ...{
        ChangeDisplaySettings(NULL,0);                    // If So Switch Back To The Desktop
        ShowCursor(TRUE);                                // Show Mouse Pointer
    }

    if (hRC)                                            // Do We Have A Rendering Context?
    ...{
        if (!wglMakeCurrent(NULL,NULL))                    // Are We Able To Release The DC And RC Contexts?
        ...{
            MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        }

        if (!wglDeleteContext(hRC))                        // Are We Able To Delete The RC?
        ...{
            MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        }
        hRC=NULL;                                        // Set RC To NULL
    }

    if (hDC && !ReleaseDC(hWnd,hDC))                    // Are We Able To Release The DC
    ...{
        MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        hDC=NULL;                                        // Set DC To NULL
    }

    if (hWnd && !DestroyWindow(hWnd))                    // Are We Able To Destroy The Window?
    ...{
        MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        hWnd=NULL;                                        // Set hWnd To NULL
    }

    if (!UnregisterClass("OpenGL",hInstance))            // Are We Able To Unregister Class
    ...{
        MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
        hInstance=NULL;                                    // Set hInstance To NULL
    }
}

/**//*    This Code Creates Our OpenGL Window.  Parameters Are:                    *
 *    title            - Title To Appear At The Top Of The Window                *
 *    width            - Width Of The GL Window Or Fullscreen Mode                *
 *    height            - Height Of The GL Window Or Fullscreen Mode            *
 *    bits            - Number Of Bits To Use For Color (8/16/24/32)            *
 *    fullscreenflag    - Use Fullscreen Mode (TRUE) Or Windowed Mode (FALSE)    */
 
BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
...{
    GLuint        PixelFormat;            // Holds The Results After Searching For A Match
    WNDCLASS    wc;                        // Windows Class Structure
    DWORD        dwExStyle;                // Window Extended Style
    DWORD        dwStyle;                // Window Style
    RECT        WindowRect;                // Grabs Rectangle Upper Left / Lower Right Values
    WindowRect.left=(long)0;            // Set Left Value To 0
    WindowRect.right=(long)width;        // Set Right Value To Requested Width
    WindowRect.top=(long)0;                // Set Top Value To 0
    WindowRect.bottom=(long)height;        // Set Bottom Value To Requested Height

    fullscreen=fullscreenflag;            // Set The Global Fullscreen Flag

    hInstance            = GetModuleHandle(NULL);                // Grab An Instance For Our Window
    wc.style            = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;    // Redraw On Size, And Own DC For Window.
    wc.lpfnWndProc        = (WNDPROC) WndProc;                    // WndProc Handles Messages
    wc.cbClsExtra        = 0;                                    // No Extra Window Data
    wc.cbWndExtra        = 0;                                    // No Extra Window Data
    wc.hInstance        = hInstance;                            // Set The Instance
    wc.hIcon            = LoadIcon(NULL, IDI_WINLOGO);            // Load The Default Icon
    wc.hCursor            = LoadCursor(NULL, IDC_ARROW);            // Load The Arrow Pointer
    wc.hbrBackground    = NULL;                                    // No Background Required For GL
    wc.lpszMenuName        = NULL;                                    // We Don't Want A Menu
    wc.lpszClassName    = "OpenGL";                                // Set The Class Name

    if (!RegisterClass(&wc))                                    // Attempt To Register The Window Class
    ...{
        MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                            // Return FALSE
    }
    
    if (fullscreen)                                                // Attempt Fullscreen Mode?
    ...{
        DEVMODE dmScreenSettings;                                // Device Mode
        memset(&dmScreenSettings,0,sizeof(dmScreenSettings));    // Makes Sure Memory's Cleared
        dmScreenSettings.dmSize=sizeof(dmScreenSettings);        // Size Of The Devmode Structure
        dmScreenSettings.dmPelsWidth    = width;                // Selected Screen Width
        dmScreenSettings.dmPelsHeight    = height;                // Selected Screen Height
        dmScreenSettings.dmBitsPerPel    = bits;                    // Selected Bits Per Pixel
        dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

        // Try To Set Selected Mode And Get Results.  NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
        if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
        ...{
            // If The Mode Fails, Offer Two Options.  Quit Or Use Windowed Mode.
            if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By Your Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
            ...{
                fullscreen=FALSE;        // Windowed Mode Selected.  Fullscreen = FALSE
            }
            else
            ...{
                // Pop Up A Message Box Letting User Know The Program Is Closing.
                MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
                return FALSE;                                    // Return FALSE
            }
        }
    }

    if (fullscreen)                                                // Are We Still In Fullscreen Mode?
    ...{
        dwExStyle=WS_EX_APPWINDOW;                                // Window Extended Style
        dwStyle=WS_POPUP;                                        // Windows Style
        ShowCursor(FALSE);                                        // Hide Mouse Pointer
    }
    else
    ...{
        dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;            // Window Extended Style
        dwStyle=WS_OVERLAPPEDWINDOW;                            // Windows Style
    }

    AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);        // Adjust Window To True Requested Size

    // Create The Window
    if (!(hWnd=CreateWindowEx(    dwExStyle,                            // Extended Style For The Window
                                "OpenGL",                            // Class Name
                                title,                                // Window Title
                                dwStyle |                            // Defined Window Style
                                WS_CLIPSIBLINGS |                    // Required Window Style
                                WS_CLIPCHILDREN,                    // Required Window Style
                                0, 0,                                // Window Position
                                WindowRect.right-WindowRect.left,    // Calculate Window Width
                                WindowRect.bottom-WindowRect.top,    // Calculate Window Height
                                NULL,                                // No Parent Window
                                NULL,                                // No Menu
                                hInstance,                            // Instance
                                NULL)))                                // Dont Pass Anything To WM_CREATE
    ...{
        KillGLWindow();                                // Reset The Display
        MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                // Return FALSE
    }

    static    PIXELFORMATDESCRIPTOR pfd=                // pfd Tells Windows How We Want Things To Be
    ...{
        sizeof(PIXELFORMATDESCRIPTOR),                // Size Of This Pixel Format Descriptor
        1,                                            // Version Number
        PFD_DRAW_TO_WINDOW |                        // Format Must Support Window
        PFD_SUPPORT_OPENGL |                        // Format Must Support OpenGL
        PFD_DOUBLEBUFFER,                            // Must Support Double Buffering
        PFD_TYPE_RGBA,                                // Request An RGBA Format
        bits,                                        // Select Our Color Depth
        0, 0, 0, 0, 0, 0,                            // Color Bits Ignored
        0,                                            // No Alpha Buffer
        0,                                            // Shift Bit Ignored
        0,                                            // No Accumulation Buffer
        0, 0, 0, 0,                                    // Accumulation Bits Ignored
        16,                                            // 16Bit Z-Buffer (Depth Buffer)  
        0,                                            // No Stencil Buffer
        0,                                            // No Auxiliary Buffer
        PFD_MAIN_PLANE,                                // Main Drawing Layer
        0,                                            // Reserved
        0, 0, 0                                        // Layer Masks Ignored
    };
    
    if (!(hDC=GetDC(hWnd)))                            // Did We Get A Device Context?
    ...{
        KillGLWindow();                                // Reset The Display
        MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                // Return FALSE
    }

    if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd)))    // Did Windows Find A Matching Pixel Format?
    ...{
        KillGLWindow();                                // Reset The Display
        MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                // Return FALSE
    }

    if(!SetPixelFormat(hDC,PixelFormat,&pfd))        // Are We Able To Set The Pixel Format?
    ...{
        KillGLWindow();                                // Reset The Display
        MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                // Return FALSE
    }

    if (!(hRC=wglCreateContext(hDC)))                // Are We Able To Get A Rendering Context?
    ...{
        KillGLWindow();                                // Reset The Display
        MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                // Return FALSE
    }

    if(!wglMakeCurrent(hDC,hRC))                    // Try To Activate The Rendering Context
    ...{
        KillGLWindow();                                // Reset The Display
        MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                // Return FALSE
    }

    ShowWindow(hWnd,SW_SHOW);                        // Show The Window
    SetForegroundWindow(hWnd);                        // Slightly Higher Priority
    SetFocus(hWnd);                                    // Sets Keyboard Focus To The Window
    ReSizeGLScene(width, height);                    // Set Up Our Perspective GL Screen

    if (!InitGL())                                    // Initialize Our Newly Created GL Window
    ...{
        KillGLWindow();                                // Reset The Display
        MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;                                // Return FALSE
    }

    return TRUE;                                    // Success
}

LRESULT CALLBACK WndProc(    HWND    hWnd,            // Handle For This Window
                            UINT    uMsg,            // Message For This Window
                            WPARAM    wParam,            // Additional Message Information
                            LPARAM    lParam)            // Additional Message Information
...{
    switch (uMsg)                                    // Check For Windows Messages
    ...{
        case WM_ACTIVATE:                            // Watch For Window Activate Message
        ...{
            if (!HIWORD(wParam))                    // Check Minimization State
            ...{
                active=TRUE;                        // Program Is Active
            }
            else
            ...{
                active=FALSE;                        // Program Is No Longer Active
            }

            return 0;                                // Return To The Message Loop
        }

        case WM_SYSCOMMAND:                            // Intercept System Commands
        ...{
            switch (wParam)                            // Check System Calls
            ...{
                case SC_SCREENSAVE:                    // Screensaver Trying To Start?
                case SC_MONITORPOWER:                // Monitor Trying To Enter Powersave?
                return 0;                            // Prevent From Happening
            }
            break;                                    // Exit
        }

        case WM_CLOSE:                                // Did We Receive A Close Message?
        ...{
            PostQuitMessage(0);                        // Send A Quit Message
            return 0;                                // Jump Back
        }

        case WM_KEYDOWN:                            // Is A Key Being Held Down?
        ...{
            keys[wParam] = TRUE;                    // If So, Mark It As TRUE
            return 0;                                // Jump Back
        }

        case WM_KEYUP:                                // Has A Key Been Released?
        ...{
            keys[wParam] = FALSE;                    // If So, Mark It As FALSE
            return 0;                                // Jump Back
        }

        case WM_SIZE:                                // Resize The OpenGL Window
        ...{
            ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));  // LoWord=Width, HiWord=Height
            return 0;                                // Jump Back
        }
    }

    // Pass All Unhandled Messages To DefWindowProc
    return DefWindowProc(hWnd,uMsg,wParam,lParam);
}

int WINAPI WinMain(    HINSTANCE    hInstance,            // Instance
                    HINSTANCE    hPrevInstance,        // Previous Instance
                    LPSTR        lpCmdLine,            // Command Line Parameters
                    int            nCmdShow)            // Window Show State
...{
    MSG        msg;                                    // Windows Message Structure
    BOOL    done=FALSE;                                // Bool Variable To Exit Loop

    // Ask The User Which Screen Mode They Prefer
    if (MessageBox(NULL,"Would You Like To Run In Fullscreen Mode?", "Start FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDNO)
    ...{
        fullscreen=FALSE;                            // Windowed Mode
    }

    // Create Our OpenGL Window
    if (!CreateGLWindow("Lionel Brits & NeHe's 3D World Tutorial",640,480,16,fullscreen))
    ...{
        return 0;                                    // Quit If Window Was Not Created
    }

    while(!done)                                    // Loop That Runs While done=FALSE
    ...{
        if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))    // Is There A Message Waiting?
        ...{
            if (msg.message==WM_QUIT)                // Have We Received A Quit Message?
            ...{
                done=TRUE;                            // If So done=TRUE
            }
            else                                    // If Not, Deal With Window Messages
            ...{
                TranslateMessage(&msg);                // Translate The Message
                DispatchMessage(&msg);                // Dispatch The Message
            }
        }
        else                                        // If There Are No Messages
        ...{
            // Draw The Scene.  Watch For ESC Key And Quit Messages From DrawGLScene()
            if ((active && !DrawGLScene()) || keys[VK_ESCAPE])    // Active?  Was There A Quit Received?
            ...{
                done=TRUE;                            // ESC or DrawGLScene Signalled A Quit
            }
            else                                    // Not Time To Quit, Update Screen
            ...{
                SwapBuffers(hDC);                    // Swap Buffers (Double Buffering)
                if (keys['B'] && !bp)
                ...{
                    bp=TRUE;
                    blend=!blend;
                    if (!blend)
                    ...{
                        glDisable(GL_BLEND);
                        glEnable(GL_DEPTH_TEST);
                    }
                    else
                    ...{
                        glEnable(GL_BLEND);
                        glDisable(GL_DEPTH_TEST);
                    }
                }
                if (!keys['B'])
                ...{
                    bp=FALSE;
                }

                if (keys['F'] && !fp)
                ...{
                    fp=TRUE;
                    filter+=1;
                    if (filter>2)
                    ...{
                        filter=0;
                    }
                }
                if (!keys['F'])
                ...{
                    fp=FALSE;
                }
                
                if (keys['R'])//Reset totation matrix
                ...{
                    rot_x=rot_y=rot_z=0;
                }
                
                if (keys['T'])//Reset totation matrix
                ...{
                    x=y=0;
                    g_z=-5;
                }

                if (keys[VK_F1])//pgup
                ...{
                    x-=0.01f;
                }

                if (keys[VK_F2])
                ...{
                    x+=0.01f;
                }

                if (keys[VK_F3])//pgup
                ...{
                    y-=0.01f;
                }

                if (keys[VK_F4])
                ...{
                    y+=0.01f;
                }

                if (keys[VK_F5])//pgup
                ...{
                    g_z-=0.01f;
                }

                if (keys[VK_F6])
                ...{
                    g_z+=0.01f;
                }


                if (keys[VK_PRIOR])//pgup
                ...{
                    rot_z-=1.0f;
                }

                if (keys[VK_NEXT])
                ...{
                    rot_z+=1.0f;
                }


                if (keys[VK_RIGHT])
                ...{
                    rot_y -= 1.0f;
                    
                }

                if (keys[VK_LEFT])
                ...{
                    rot_y += 1.0f;
                }

                if (keys[VK_UP])
                ...{
                    rot_x-= 1.0f;
                }

                if (keys[VK_DOWN])
                ...{
                    rot_x+= 1.0f;
                }

//                 if (keys[VK_ESCAPE])                        // Is F1 Being Pressed?
//                 {
//                     keys[VK_F1]=FALSE;                    // If So Make Key FALSE
//                     KillGLWindow();                        // Kill Our Current Window
//                     fullscreen=!fullscreen;                // Toggle Fullscreen / Windowed Mode
//                     // Recreate Our OpenGL Window
//                     if (!CreateGLWindow("Lionel Brits & NeHe's 3D World Tutorial",640,480,16,fullscreen))
//                     {
//                         return 0;                        // Quit If Window Was Not Created
//                     }
//                 }
            }
        }
    }

    // Shutdown
    KillGLWindow();                                        // Kill The Window
    return (msg.wParam);                                // Exit The Program
}
}
int  _tmain( int  argc, TCHAR *  argv[], TCHAR *  envp[])
... {
    int nRetCode = 0;
    
    // initialize MFC and print and error on failure
    if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))
    ...{
        // TODO: change error code to suit your needs
        cerr << _T("Fatal Error: MFC initialization failed") << endl;
        nRetCode = 1;
    }
    else
    ...{
        // TODO: code your application's behavior here.
        CString strHello;
        strHello.LoadString(IDS_HELLO);
        cout << (LPCTSTR)strHello << endl;
    }
    //Test1::main2();
    Test9::WinMain(0,0,0,SW_SHOWNORMAL);
    return nRetCode;
}

 附上测试使用的world2.txt

NUMPOINTS  8
0    0    0    0    1
1    0    0     0.25    1
1    0    1     0.75    1
0    0    1   1    1

0    1    0    0   0
1    1    0    0.25   0
1    1    1    0.75   0
0    1    1   1    0

NUMPTRIANGLES  8
0   1   4
4   1   5
1   2   5
2   5   6

2   3   6
3   6   7
0   3   7
0   7   4

mud.bmp