openGL学习笔记三十八： 绘制加雾特效多纹理逼真地图

  从外部Terrain.raw 文件读取高度数据, 法线，添加多纹理支持，形成更真实地图。

涉及函数

	glEnable(GL_FOG); //开启雾特效
	glFogi(GL_FOG_MODE, GL_LINEAR); 
	glFogfv(GL_FOG_COLOR, fogColor);
	glFogf(GL_FOG_START, 0.0);
	glFogf(GL_FOG_END, 50.0);

	glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT);

代码：

terrain.hpp

#pragma once

#include <GL/glew.h>
#include <vector>
#include <glm/glm.hpp>

using namespace glm;

struct  TerrainVert {
	float   x, y, z;
	float   nx, ny, nz;
	float   u, v;
	float   u1, v1;
	float   r, g, b, a;
	float   fog;
};


#define MAP_SIZE    1024
class Terrain
{
public:
	typedef std::vector<TerrainVert>    ArrayVertex;
	typedef std::vector<unsigned short> ArrayIndex;
public:
	ArrayVertex _vertex;
	ArrayIndex  _index;
	int         _drawSize;
	unsigned char*       _data;

public:

	Terrain(void);
	~Terrain(void);

	bool    loadHeight(const char* fileName, unsigned char* pHeightMap, int w, int h);
	float   readHeight(int x, int y, const unsigned char* data);
	float   readFog(int x, int y, const unsigned char* data);
	float    readColor(int x, int y, const unsigned char* data);

	vec3  computeNomal(TerrainVert& v1, TerrainVert& v2, TerrainVert& v3);

	/**
	*   根据给定的x,z世界坐标，计算出来所在位置的高度
	*/
	float   calcHeight(float x, float z, unsigned char* data);
	void    setup(float w, float h);

	void    render();
};

terrain.cpp

#include <stdio.h>
#include "terrain.hpp"

Terrain::Terrain(void)
{
	_data = 0;
}

Terrain::~Terrain(void)
{
	if (_data)
	{
		delete  _data;
	}
}

bool Terrain::loadHeight(const char* fileName, unsigned char* pHeightMap, int w, int h)
{
	FILE*   pFile;
	fopen_s(&pFile, fileName, "rb");
	if (pFile == NULL)
	{
		return  false;
	}
	fread(pHeightMap, 1, w * h, pFile);
	fclose(pFile);
	return  true;
}

float Terrain::readHeight(int x, int y, const unsigned char* data)
{
	x = x % MAP_SIZE;
	y = y % MAP_SIZE;

	return (float)data[x + (y * MAP_SIZE)];
}

float Terrain::readFog(int x, int y, const unsigned char* data)
{
	float h = readHeight(x, y, data);
	if (h > 120)
	{
		return  0;
	}
	return   (120 - h);
}

float Terrain::readColor(int x, int y, const unsigned char* data)
{
	return -0.15f + (readHeight(x, y, data) / 256.0f);
}

glm::vec3 Terrain::computeNomal(TerrainVert& v1, TerrainVert& v2, TerrainVert& v3)
{
	vec3    f1(v2.x - v1.x, v2.y - v1.y, v2.z - v1.z);
	vec3    f2(v3.x - v1.x, v3.y - v1.y, v3.z - v1.z);
	return    normalize(cross(f1, f2));
}

float Terrain::calcHeight(float x, float z, unsigned char* data)
{
	float   startX = -MAP_SIZE * 0.5f;
	float   startY = -MAP_SIZE * 0.5f;
	float   offsetX = x - startX;
	float   offsetZ = z - startY;

	if (offsetX < 0)
	{
		offsetX = 0;
	}
	if (offsetZ < 0)
	{
		offsetZ = 0;
	}
	if (offsetX >= MAP_SIZE)
	{
		offsetX = MAP_SIZE - 1;
	}
	if (offsetZ >= MAP_SIZE)
	{
		offsetZ = MAP_SIZE - 1;
	}

	int     posX = (int)offsetX;
	int     posZ = (int)offsetZ;

	return  readHeight(posX, posZ, data);
}

void Terrain::setup(float w, float h)
{
	int     step = 8;

	unsigned char*   data = new unsigned char[MAP_SIZE * MAP_SIZE];
	loadHeight("../res/map/Terrain.raw", data, MAP_SIZE, MAP_SIZE);

	/**
	*   产生顶点数据
	*/
	for (int z = 0; z <= MAP_SIZE; z += step)
	{
		for (int x = 0; x <= MAP_SIZE; x += step)
		{
			TerrainVert vert0 = { x, readHeight(x,z,data),  z, 0,0,0,1 };
			vert0.x -= MAP_SIZE* 0.5f;
			vert0.z -= MAP_SIZE* 0.5f;
			vert0.r = 1;
			vert0.g = 1;
			vert0.b = 1;
			vert0.a = 1;
			vert0.u = float(x) / MAP_SIZE;
			vert0.v = float(z) / MAP_SIZE;

			vert0.u1 = vert0.u * 20;
			vert0.v1 = vert0.v * 20;

			vert0.fog = readFog(x, z, data);

			_vertex.push_back(vert0);
		}
	}

	_data = data;

	/**
	*   计算索引数据
	*/
	size_t  col = int(w / step + 0.5f) + 1;
	size_t  row = int(h / step + 0.5f) + 1;

	for (size_t r = 0; r < row - 1; ++r)
	{
		for (size_t i = 0; i < col - 1; ++i)
		{
			_index.push_back((r + 0) * col + i);
			_index.push_back((r + 1) * col + i);
			_index.push_back((r + 0) * col + i + 1);

			_index.push_back((r + 1) * col + i);
			_index.push_back((r + 0) * col + i + 1);
			_index.push_back((r + 1) * col + i + 1);
		}
	}

	/**
	*   计算法线
	*/
	for (size_t i = 0; i < _index.size(); i += 3)
	{
		TerrainVert&    v0 = _vertex[_index[i + 0]];
		TerrainVert&    v1 = _vertex[_index[i + 1]];
		TerrainVert&    v2 = _vertex[_index[i + 2]];
		vec3          nor = computeNomal(v0, v1, v2);

		v0.nx = nor.x;
		v0.ny = nor.y;
		v0.nz = nor.z;

		v1.nx = nor.x;
		v1.ny = nor.y;
		v1.nz = nor.z;

		v2.nx = nor.x;
		v2.ny = nor.y;
		v2.nz = nor.z;
	}
}

void Terrain::render()
{
	glEnableClientState(GL_VERTEX_ARRAY);
	glEnableClientState(GL_COLOR_ARRAY);
	glEnableClientState(GL_NORMAL_ARRAY);
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
	glEnableClientState(GL_FOG_COORD_ARRAY);
	glVertexPointer(3, GL_FLOAT, sizeof(TerrainVert), &_vertex[0].x);
	glNormalPointer(GL_FLOAT, sizeof(TerrainVert), &_vertex[0].nx);
	glColorPointer(4, GL_FLOAT, sizeof(TerrainVert), &_vertex[0].r);

	glClientActiveTextureARB(GL_TEXTURE0_ARB);
	glTexCoordPointer(2, GL_FLOAT, sizeof(TerrainVert), &_vertex[0].u);
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);

	glClientActiveTextureARB(GL_TEXTURE1_ARB);
	glTexCoordPointer(2, GL_FLOAT, sizeof(TerrainVert), &_vertex[0].u1);
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);

	glFogCoordPointer(GL_FLOAT, sizeof(TerrainVert), &_vertex[0].fog);

	glDrawElements(GL_TRIANGLES, _index.size(), GL_UNSIGNED_SHORT, &_index.front());

	glDisableClientState(GL_COLOR_ARRAY);
	glDisableClientState(GL_NORMAL_ARRAY);
	glDisableClientState(GL_FOG_COORD_ARRAY);
}

main.cpp

/*
* 该实例演示 从外部Terrain.raw 文件读取高度数据, 法线，添加多纹理支持，形成更真实地图。
* 例子中需要启动光照
*/

#define GLEW_STATIC
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <iostream>

#include <GL/glew.h>
#include <GLFW/glfw3.h>

#include <glm/vec3.hpp> // glm::vec3
#include <glm/vec4.hpp> // glm::vec4
#include <glm/mat4x4.hpp> // glm::mat4
#include <glm/ext/matrix_transform.hpp> // glm::translate, glm::rotate, glm::scale
#include <glm/ext/matrix_clip_space.hpp>

#include "FreeImage.h"
#include "Terrain.hpp"

#pragma comment(linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"" )  //这行是取消显示控制台

char szTitle[64] = "opengl view";


//glm::vec4 vec(1.0f, 0.0f, 0.0f, 1.0f);//创建一个点
//glm::mat4 trans = glm::mat4(1.0f);//创建单位矩阵
//Window dimensions    
const GLuint WIDTH = 800, HEIGHT = 600;

GLfloat ratio = 1.f;
GLfloat xpos, ypos;

glm::vec3 _eye(800, 600, 400);
glm::vec3 _lookAt(0, 0, 0);
glm::vec3 _up(0, 1, 0);

glm::mat4 _matProj = glm::mat4(1.0f);//创建单位矩阵
glm::mat4 _matView = glm::mat4(1.0f);//创建单位矩阵


float size = 100.0f;

//顶点数据
struct Vertex {
	float x, y, z;
	float u, v;
};

Vertex g_cubeVertices[] =
{
	{ -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 },
	{ -1.0f, 1.0f, 1.0f, 0.0f, 1.0f },

	{ -1.0f, -1.0f, -1.0f, 1.0f, 0.0f },
	{ -1.0f, 1.0f, -1.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, 0.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 },

	{ -1.0f, -1.0f, -1.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, 0.0f },

	{ 1.0f, -1.0f, -1.0f, 1.0f, 0.0f },
	{ 1.0f, 1.0f, -1.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, 0.0f, 0.0f },
	{ -1.0f, -1.0f, 1.0f, 1.0f, 0.0f },
	{ -1.0f, 1.0f, 1.0f, 1.0f, 1.0f },
	{ -1.0f, 1.0f, -1.0f, 0.0f, 1.0f },

	// 地面数据
	{ -size, -1.0f, -size, 0.0f, 0.0f },
	{ -size, -1.0f, size, 100.0f, 0.0f },
	{ size, -1.0f, size, 100.0f, 100.0f },
	{ size, 0.0f, -size, 0.0f, 100.0f }
};

//纹理ID
GLuint  _texture;
GLuint  _vbo;

//地面纹理
GLuint  _texGround;
GLuint  _texDetail;
GLuint  _terrainTex;

Terrain _terrain;


static void error_callback(int error, const char* description) {
	fputs(description, stderr);
}

static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) {
	std::cout << "key " << key << std::endl;

	switch(key) {
		case GLFW_KEY_ESCAPE:
			glfwSetWindowShouldClose(window, GL_TRUE);
			break;
		case GLFW_KEY_UP:
			_eye.z  -=  0.1f;   //这里修改摄像机参数
			break;
		case GLFW_KEY_DOWN:
			_eye.z  +=  0.1f;
			break;
		case GLFW_KEY_RIGHT:
			_eye.x  -=  1.0f;
			break;
		case GLFW_KEY_LEFT:
			_eye.x  +=  1.0f;
			break;

		default:
			break;
	}
}

static void mouse_button_callback(GLFWwindow* window, int button, int action, int mods) {
	if(action != GLFW_PRESS)
		return;

	switch(button) {
		case GLFW_MOUSE_BUTTON_LEFT:
			std::cout << "Mosue left button clicked!" << std::endl;
			break;
		case GLFW_MOUSE_BUTTON_MIDDLE:
			std::cout << "Mosue middle button clicked!" << std::endl;
			break;
		case GLFW_MOUSE_BUTTON_RIGHT:
			std::cout << "Mosue right button clicked!" << std::endl;
			break;
		default:
			return;
	}
	return;
}

static void cursor_position_callback(GLFWwindow* window, double x, double y) {
	//std::cout << "Mouse position move to X: " << x << " Y: " << y << std::endl;
	xpos = float((x - WIDTH / 2) / WIDTH) * 2;
	ypos = float(0 - (y - HEIGHT / 2) / HEIGHT) * 2;
	return;
}

static void scroll_callback(GLFWwindow* window, double x, double y) {
	return;
}

static unsigned createTexture(int w, int h, const void* data, GLenum type) {
	unsigned    texId;
	glGenTextures(1, &texId);
	glBindTexture(GL_TEXTURE_2D, texId);
	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, type, w, h, 0, type, GL_UNSIGNED_BYTE, data);

	return  texId;
}
/**
*   使用FreeImage加载图片
*/
static unsigned createTextureFromImage(const char* fileName) {
	//1 获取图片格式
	FREE_IMAGE_FORMAT fifmt = FreeImage_GetFileType(fileName, 0);
	if(fifmt == FIF_UNKNOWN) {
		return  0;
	}
	//2 加载图片
	FIBITMAP    *dib = FreeImage_Load(fifmt, fileName, 0);

	FREE_IMAGE_COLOR_TYPE type = FreeImage_GetColorType(dib);

	//3 获取数据指针
	FIBITMAP*   temp = dib;
	dib = FreeImage_ConvertTo32Bits(dib);
	FreeImage_Unload(temp);

	BYTE*   pixels = (BYTE*)FreeImage_GetBits(dib);
	int     width = FreeImage_GetWidth(dib);
	int     height = FreeImage_GetHeight(dib);

	for(int i = 0; i < width * height * 4; i += 4) {
		BYTE temp = pixels[i];
		pixels[i] = pixels[i + 2];
		pixels[i + 2] = temp;
	}

	unsigned    res = createTexture(width, height, pixels, GL_RGBA);
	FreeImage_Unload(dib);
	return      res;
}

static void onInit() {
	_texture    =   createTextureFromImage("../res/1.jpg");
	_texGround  =   createTextureFromImage("../res/map/dimian.jpg");
	_texDetail  =    createTextureFromImage("../res/map/Detail.bmp");
	_terrainTex = createTextureFromImage("../res/map/Terrain.bmp");
	glGenBuffers(1, &_vbo);
	glBindBuffer(GL_ARRAY_BUFFER, _vbo);
	glBufferData(GL_ARRAY_BUFFER, sizeof(g_cubeVertices), g_cubeVertices, GL_STATIC_DRAW);
	glBindBuffer(GL_ARRAY_BUFFER, 0);

	_terrain.setup(1024, 1024);
	//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);  //opengl 绘制网格


	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);

	GLfloat diffuse_light0[] = { 1.0f, 1.0f, 1.0f, 1.0f };
	GLfloat position_light0[] = { 0, 200, 0, 0.0f };
	GLfloat ambient_lightModel[] = { 1, 1, 1, 1.0f };

	glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse_light0);
	glLightfv(GL_LIGHT0, GL_POSITION, position_light0);
	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient_lightModel);


	float fogColor[4] = { 0.8f, 0.8f, 0.8f, 1.0f };

	glEnable(GL_FOG);
	glFogi(GL_FOG_MODE, GL_LINEAR);
	glFogfv(GL_FOG_COLOR, fogColor);
	glFogf(GL_FOG_START, 0.0);
	glFogf(GL_FOG_END, 50.0);

	glFogi(GL_FOG_COORDINATE_SOURCE_EXT, GL_FOG_COORDINATE_EXT);
}

static void onDestory() {
	glDeleteTextures(1, &_texture);
	glDeleteTextures(1, &_texGround);
	glDeleteBuffers(1, &_vbo);   //删除VBO 显存中释放VBO内存
}

// 绘制
static void render(GLFWwindow * window) {

	glClearColor(0, 0, 0, 1);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	glEnable(GL_DEPTH_TEST);
	glEnable(GL_TEXTURE_2D);

	glMatrixMode(GL_MODELVIEW);

	_matView = glm::lookAt(_eye, _lookAt, _up); //使用glm数学库 根据公式计算得到视图矩阵  这公式可以推倒出来

	//摄像机围绕目标旋转
	//static float angle = 0; //旋转角度
	//float r = 10;           //旋转半径
	//_eye.x = cos(angle * glm::pi<double>() / 180) * r;
	//_eye.z = sin(angle * glm::pi<double>() / 180) * r;
	//angle += 1;  //角度每帧加一

	glm::mat4 matVP = _matProj * _matView;
	glLoadMatrixf(&matVP[0][0]);

	glBindTexture(GL_TEXTURE_2D, _texture);
	
	glEnableClientState(GL_VERTEX_ARRAY);
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
	//开始使用ID为 _vbo  的buffer 接下来的操作针对这个VBO
	glBindBuffer(GL_ARRAY_BUFFER, _vbo);
	
	float* addrVertex = (float*)0;
	float* uvAddress = (float*)12;
	
	glVertexPointer(3, GL_FLOAT, sizeof(Vertex), addrVertex);
	glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex), uvAddress);
	
	// 绘制 立方体
	glDrawArrays(GL_QUADS, 0, 24);
	glBindBuffer(GL_ARRAY_BUFFER, 0);

	//绘制地面
	//glLoadIdentity(); //这里打开 地面就不会跟着旋转 说明摄像机操作的是模型矩阵
	//多纹理操作

	glActiveTextureARB(GL_TEXTURE0_ARB);
	glEnable(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, _terrainTex);

	glActiveTextureARB(GL_TEXTURE1_ARB);
	glEnable(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, _texDetail);

	_terrain.render();

	glfwSwapBuffers(window);
	glfwPollEvents();
}

int main(void) {
	GLFWwindow * window;

	glfwSetErrorCallback(error_callback);

	if(!glfwInit())
		return -1;

	window = glfwCreateWindow(WIDTH, HEIGHT, szTitle, NULL, NULL);
	if(!window) {
		glfwTerminate();
		exit(EXIT_FAILURE);
	}

	glfwSetKeyCallback(window, key_callback);
	glfwSetMouseButtonCallback(window, mouse_button_callback);
	glfwSetCursorPosCallback(window, cursor_position_callback);
	glfwSetScrollCallback(window, scroll_callback);

	glfwMakeContextCurrent(window);

	glewExperimental = GL_TRUE;
	glewInit();
	onInit();
	glViewport(0, 0, WIDTH, HEIGHT); //设置opengl视口 即看到的显示区域

	_matProj = glm::perspective(glm::radians(60.0f), float(WIDTH) / float(HEIGHT), 0.1f, 2000.0f);//使用glm数学库 根据公式计算得到投影矩阵  这公式可以推倒出来

	while(!glfwWindowShouldClose(window)) {
		render(window);
	}

	onDestory();
	glfwDestroyWindow(window);

	glfwTerminate();
	return 0;
}

运行结果：