OpenGL地形建模

使用了OpenGL 3.0以及freeglut进行的C++编程，地形数据读取于一个DEM模型

地形效果如下，使用了基本的三角形进行绘图，外加一点简单的光照。贴图没有搞上，正在研究

第一次用OpenGL编程，还有很多地方需要提高，源码见后

#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include <soil.h>

using namespace std;

#include <gl/freeglut.h>
//#include <gl/glaux.h>

#pragma comment(lib, "soil.lib")

#define C 2701
#define R 1801
#define CELLSIZE 50

#define W 256
#define H 256

//=========================================3-1 P.80

static GLfloat spin = 0;
static GLfloat spin_x = 0;
static GLfloat spin_y = 0;
static GLfloat old_x = 0;
static GLfloat old_y = 0;

static GLfloat camerap[3] = {0, 1000, 0};
static GLfloat cameras[3] = {5000, 0, 0};

static int datas [R][C];
static float vectors [(R - 1) * 2][C - 1][3];//The [3] in the last is for x, y and z
static float normals [R][C][3];

static GLuint texName;
//static GLubyte grassImage [H][W][4];

void init (void)
{
    //Light
    GLfloat mat_specular[] = {1, 1, 1, 0};
    GLfloat mat_shininess[] = {1000};
    GLfloat light_position[] = {5000, 5000, 5000, 0};
    GLfloat a_light[] = {1.0f, 1.0f, 1.0f, 1};
    GLfloat lmodel_ambient[] = {0.8, 0.8, 0.8, 1};

    glClearColor(1, 1, 1, 0);
    glShadeModel(GL_SMOOTH);//----------------
    glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
    glLightfv(GL_LIGHT0, GL_POSITION, light_position);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, a_light);
    glLightfv(GL_LIGHT0, GL_SPECULAR, a_light);
    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);

    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_DEPTH_TEST);
    glShadeModel(GL_FLAT);
    
    //Load terrain data
    char str[C * 4 + 1];
    string sdatas;
    ifstream terrainFile(".\\res\\dem.asc");
    if(!terrainFile)
    {
        cerr<<"File is not opened."<<endl;
    }
    cout<<"Terrain file is opened."<<endl<<endl;
    for (int i = 1; i <= 13; i++)
    {
        terrainFile.getline(str, C * 4 + 1);
        cout<<str<<endl;
    }
    cout<<endl<<"Loading terrain data...";
    for (int i = 0; i < R; i++)
    {
        terrainFile.getline(str, C * 4 + 1);
        sdatas = str;
        istringstream datastream(sdatas);
        for (int j = 0; j < C; j++)
        {
            datastream>>datas[i][j];
            //cout<<datas[i][j]<<" ";//just for testing
        }
    }
    cout<<endl<<"Terrain data is loaded."<<endl;
    
    cout<<endl<<"Setting triangle normal vectors...";
    int uy, vy;
    for (int i = 0; i < (R - 1) * 2; i++)
    {
        if (i % 2 == 0)
        {
            for (int j = 0; j < C - 1; j++)
            {
                uy = datas[i / 2][j] - datas[i / 2][j + 1];
                vy = datas[(i / 2) + 1][j] - datas[i / 2][j];
                vectors[i][j][0] = uy;//
                vectors[i][j][1] = 1;//
                vectors[i][j][2] = -vy;//
            }
        }
        else
        {
            for (int j = 0; j < C - 1; j++)
            {
                uy = datas[(i / 2) + 1][j + 1] - datas[(i / 2) + 1][j];
                vy = datas[i / 2][j + 1] - datas[(i / 2) + 1][j + 1];
                vectors[i][j][0] = -uy;//
                vectors[i][j][1] = 1;//
                vectors[i][j][2] = vy;//
            }
        }
    }
    cout<<endl<<"Triangle normal vectors set."<<endl;

    cout<<endl<<"Setting vertex normal vectors...";

    //4 vertexs of the matrix, which need 1 or 2 triangles to define the normal
    //Left top
    normals[0][0][0] = vectors[0][0][0];
    normals[0][0][1] = vectors[0][0][1];
    normals[0][0][2] = vectors[0][0][2];
    //Right bottom
    normals[R - 1][C - 1][0] = vectors[(R - 1) * 2 - 1][C - 2][0];
    normals[R - 1][C - 1][1] = vectors[(R - 1) * 2 - 1][C - 2][1];
    normals[R - 1][C - 1][2] = vectors[(R - 1) * 2 - 1][C - 2][2];
    //Left bottom
    normals[R - 1][0][0] = (vectors[(R - 1) * 2 - 2][0][0] + vectors[(R - 1) * 2 - 1][0][0]) / 2;
    normals[R - 1][0][1] = (vectors[(R - 1) * 2 - 2][0][1] + vectors[(R - 1) * 2 - 1][0][1]) / 2;
    normals[R - 1][0][2] = (vectors[(R - 1) * 2 - 2][0][2] + vectors[(R - 1) * 2 - 1][0][2]) / 2;
    //Right top
    normals[0][0][0] = (vectors[0][C - 2][0] + vectors[1][C - 2][0]) / 2;
    normals[0][0][0] = (vectors[1][C - 2][0] + vectors[1][C - 2][1]) / 2;
    normals[0][0][0] = (vectors[2][C - 2][0] + vectors[1][C - 2][2]) / 2;

    //4 edges of the matrix, which need 4 triangles to define the normal
    //Top
    for (int c = 1; c < C - 1; c++)
    {
        normals[0][c][0] = (vectors[0][c - 1][0]
                            + vectors[1][c - 1][0] 
                            + vectors[0][c][0] 
                            + vectors[1][c][0]) / 4;
        normals[0][c][1] = (vectors[0][c - 1][1] 
                            + vectors[1][c - 1][1] 
                            + vectors[0][c][1] 
                            + vectors[1][c][1]) / 4;
        normals[0][c][2] = (vectors[0][c - 1][2] 
                            + vectors[1][c - 1][2] 
                            + vectors[0][c][2] 
                            + vectors[1][c][2]) / 4;
    }
    //Bottom
    for (int c = 1; c < C - 1; c++)
    {
        normals[R - 1][c][0] = (vectors[(R - 1) * 2 - 1][c - 1][0] 
                                + vectors[(R - 1) * 2 - 2][c - 1][0] 
                                + vectors[(R - 1) * 2 - 1][c][0]
                                + vectors[(R - 1) * 2 - 2][c][0]) / 4;
        normals[R - 1][c][1] = (vectors[(R - 1) * 2 - 1][c - 1][1] 
                                + vectors[(R - 1) * 2 - 2][c - 1][1] 
                                + vectors[(R - 1) * 2 - 1][c][1] 
                                + vectors[(R - 1) * 2 - 2][c][1]) / 4;
        normals[R - 1][c][2] = (vectors[(R - 1) * 2 - 1][c - 1][2] 
                                + vectors[(R - 1) * 2 - 2][c - 1][2] 
                                + vectors[(R - 1) * 2 - 1][c][2] 
                                + vectors[(R - 1) * 2 - 2][c][2]) / 4;
    }
    //Left
    for (int r = 1; r < R - 1; r++)
    {
        normals[r][0][0] = (vectors[r * 2 - 2][0][0]
                            + vectors[r * 2 - 1][0][0]
                            + vectors[r * 2][0][0]
                            + vectors[r * 2 + 1][0][0]) / 4;
        normals[r][0][1] = (vectors[r * 2 - 2][0][1]
                            + vectors[r * 2 - 1][0][1]
                            + vectors[r * 2][0][1]
                            + vectors[r * 2 + 1][0][1]) / 4;
        normals[r][0][2] = (vectors[r * 2 - 2][0][2]
                            + vectors[r * 2 - 1][0][2]
                            + vectors[r * 2][0][2]
                            + vectors[r * 2 + 1][0][2]) / 4;
    }
    //Right
    for (int r = 1; r < R - 1; r++)
    {
        normals[r][0][0] = (vectors[r * 2 - 2][C - 2][0]
                            + vectors[r * 2 - 1][C - 2][0]
                            + vectors[r * 2][C - 2][0]
                            + vectors[r * 2 + 1][C - 2][0]) / 4;
        normals[r][0][1] = (vectors[r * 2 - 2][C - 2][1]
                            + vectors[r * 2 - 1][C - 2][1]
                            + vectors[r * 2][C - 2][1]
                            + vectors[r * 2 + 1][C - 2][1]) / 4;
        normals[r][0][2] = (vectors[r * 2 - 2][C - 2][2]
                            + vectors[r * 2 - 1][C - 2][2]
                            + vectors[r * 2][C - 2][2]
                            + vectors[r * 2 + 1][C - 2][2]) / 4;
    }

    //The rest of the martix, 6 triangles are needed for each
    for (int r = 1; r < R - 1; r++)
    {
        for (int c = 1; c < C - 1; c++)
        {
            normals[r][c][0] = (vectors[r * 2][c][0]
                                + vectors[r * 2 - 1][c - 1][0]
                                + vectors[r * 2 - 1][c][0]
                                + vectors[r * 2][c - 1][0]
                                + vectors[r * 2][c][0]
                                + vectors[r * 2 + 1][c - 1][0]) / 6;
            normals[r][c][1] = (vectors[r * 2][c][1]
                                + vectors[r * 2 - 1][c - 1][1]
                                + vectors[r * 2 - 1][c][1]
                                + vectors[r * 2][c - 1][1]
                                + vectors[r * 2][c][1]
                                + vectors[r * 2 + 1][c - 1][1]) / 6;
            normals[r][c][2] = (vectors[r * 2][c][2]
                                + vectors[r * 2 - 1][c - 1][2]
                                + vectors[r * 2 - 1][c][2]
                                + vectors[r * 2][c - 1][2]
                                + vectors[r * 2][c][2]
                                + vectors[r * 2 + 1][c - 1][2]) / 6;
        }
    }
    cout<<endl<<"Vertex normal vectors set."<<endl;

    //Enable normalize vector
    glEnable(GL_NORMALIZE);

    //Load Texture
    int width, height;
    unsigned char* image = SOIL_load_image(".\\res\\terrain.bmp", &width, &height, 0, SOIL_LOAD_RGBA);
    glGenTextures(1, &texName);
    glBindTexture(GL_TEXTURE_2D, texName);
    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, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image);
    glEnable(GL_TEXTURE_2D);
}

/*
void spindisplay (void)
{
    
    glutPostRedisplay();
}
*/

void processMouse(int button, int state, int x, int y)  
{  
    if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)  
    {  
        old_x = x; 
        old_y = y;  
    }
}  

void onMouseMove(int x, int y)  
{  
    spin_x += y - old_y;
    spin_y += x - old_x;
    spin = sqrt(spin_x*spin_x + spin_y*spin_y);
    if (spin > 360)
    {
        spin -= 360;
    }

    glutPostRedisplay();  

    old_x = x;  
    old_y = y;  
}  

void onKeyboardType(unsigned char key, int x, int y)
{
    if (key == 'r' || key == 'R')
    {
        spin_x = 10;
        spin_y = 0;
        spin = 0;
        glutPostRedisplay();  
    }

    if (key == 'w' || key == 'W')
    {
        camerap[0] += 1000;
        glutPostRedisplay();  
    }
    if (key == 's' || key == 'S')
    {
        camerap[0] -= 1000;
        glutPostRedisplay();  
    }
    if (key == 'a' || key == 'A')
    {
        camerap[2] -= 1000;
        glutPostRedisplay();  
    }
    if (key == 'd' || key == 'D')
    {
        camerap[2] += 1000;
        glutPostRedisplay();  
    }
}

void display (void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glColor3f(1, 0.25, 0.25);
    glLoadIdentity();

    //Moving camera
    gluLookAt(camerap[0], camerap[1], camerap[2], 5000 + camerap[0], 0 + camerap[1], 0 + camerap[2], 0, 1, 0);
    glScalef(1, 1, 1);
    glRotatef(spin, spin_x, spin_y, 0);

    //Drawing loop
    for (int r = 0; r < R - 1; r++)
    {
        glBegin(GL_TRIANGLE_STRIP);
            for (int c = 0; c < C - 1; c++)
            {
                //Normal Vector
                glNormal3f(normals[r][c][0], normals[r][c][1], normals[r][c][2]);
                //glTexCoord2d(c/C, 1 - r / R);
                glVertex3f(c * 50,datas[r][c],r * 50);
                
                //Normal Vector
                glNormal3f(normals[r + 1][c][0], normals[r][c][1], normals[r][c][2]);
                //glTexCoord2d(c/C, 1 - (r + 1) / R);
                glVertex3f(c * 50,datas[r + 1][c],r * 50 + 50);
            }
        glEnd();
    }
    glFlush();
}

void reshape(int w, int h)
{
    glViewport(0, 0, (GLsizei)w, (GLsizei)h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    //glFrustum(-1, 1, -1, 1, 1.5, 20);
    gluPerspective(60, 1, 1, 99999);
    glMatrixMode(GL_MODELVIEW);
}

int main (int argc, char** argv)
{
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(1280, 720);
    glutInitWindowPosition(100, 100);
    glutCreateWindow(argv[0]);
    init();
    glutDisplayFunc(display);
    //glutIdleFunc(spindisplay);
    glutReshapeFunc(reshape);
    glutMotionFunc(onMouseMove);
    glutMouseFunc(processMouse);
    glutKeyboardFunc(onKeyboardType);
    glutMainLoop();
    return 0;
}