* 원문링크 : http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=45

#define MESH_RESOLUTION 4.0f							// 정점당 픽셀수
#define MESH_HEIGHTSCALE 1.0f							// 메쉬 높이 배율
//#define NO_VBOS								// 이부분이 정의되면, VBO는 강제로 사용하지 않도록 설정하게 됩니다.

// VBO 확장 정의(glext.h에서 가져옴)
#define GL_ARRAY_BUFFER_ARB 0x8892
#define GL_STATIC_DRAW_ARB 0x88E4
typedef void (APIENTRY * PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer);
typedef void (APIENTRY * PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint *buffers);
typedef void (APIENTRY * PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint *buffers);
typedef void (APIENTRY * PFNGLBUFFERDATAARBPROC) (GLenum target, int size, const GLvoid *data, GLenum usage);

// VBO 확장 함수 포인터들
PFNGLGENBUFFERSARBPROC glGenBuffersARB = NULL;					// VBO Name 생성 함수
PFNGLBINDBUFFERARBPROC glBindBufferARB = NULL;					// VBO Bind 함수
PFNGLBUFFERDATAARBPROC glBufferDataARB = NULL;					// VBO 데이타 로딩 함수
PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB = NULL;				// VBO 제거 함수

class CVert									// 정점 클래스
{
public:
	float x;								// X 요소
	float y;								// Y 요소
	float z;								// Z 요소
};
typedef CVert CVec;								// 두 타입 각각의 정의가 비슷하므로 이렇게 정의합니다.

class CTexCoord									// 텍스쳐 좌표 클래스
{
public:
	float u;								// U 요소
	float v;								// V 요소
};

class CMesh
{
public:
	// 메쉬 데이타
	int		m_nVertexCount;						// 정점 개수
	CVert*		m_pVertices;						// 정점 데이타
	CTexCoord*	m_pTexCoords;						// 텍스쳐 좌표들
	unsigned int	m_nTextureId;						// 텍스쳐 ID

	// Vertex Buffer Object Names
	unsigned int	m_nVBOVertices;						// 정점 VBO Name
	unsigned int	m_nVBOTexCoords;					// 텍스쳐 좌표 VBO Name

	// 임시 데이타
	AUX_RGBImageRec* m_pTextureImage;					// 높이필드 데이타

public:
	CMesh();								// 매쉬 클래스 생성자
	~CMesh();								// 매쉬 클래스 소멸자

	// 높이필드맵 로더
	bool LoadHeightmap( char* szPath, float flHeightScale, float flResolution );
	// 특정 위치에서의 높이값을 반환합니다
	float PtHeight( int nX, int nY );
	// VBO 구축 함수
	void BuildVBOs();
};

bool		g_fVBOSupported = false;					// ARB_vertex_buffer_object가 지원되는가?
CMesh*		g_pMesh = NULL;							// 매쉬 데이타
float		g_flYRot = 0.0f;						// 회전각
int		g_nFPS = 0, g_nFrames = 0;					// FPS 및 FPS 카운터
DWORD		g_dwLastFPS = 0;						// 최근의 FPS 검사 시간

bool CMesh :: LoadHeightmap( char* szPath, float flHeightScale, float flResolution )
{
	// 오류검사
	FILE* fTest = fopen( szPath, "r" );					// 이미지를 엽니다
	if( !fTest )								// 반드시 열려야합니다.
		return false;							// 열리지 않았다면, 화일은 없는거겠죠.
	fclose( fTest );							// 핸들을 닫습니다.

	// 텍스쳐 데이타를 로딩합니다
	m_pTextureImage = auxDIBImageLoad( szPath );				// GLaux의 비트맵 로딩 루틴을 사용합니다.

// Generate Vertex Field
	m_nVertexCount = (int) ( m_pTextureImage->sizeX * m_pTextureImage->sizeY * 6 / ( flResolution * flResolution ) );
	m_pVertices = new CVec[m_nVertexCount];					// Allocate Vertex Data
	m_pTexCoords = new CTexCoord[m_nVertexCount];				// Allocate Tex Coord Data
	int nX, nZ, nTri, nIndex=0;						// Create Variables
	float flX, flZ;
	for( nZ = 0; nZ < m_pTextureImage->sizeY; nZ += (int) flResolution )
	{
		for( nX = 0; nX < m_pTextureImage->sizeX; nX += (int) flResolution )
		{
			for( nTri = 0; nTri < 6; nTri++ )
			{
				// Using This Quick Hack, Figure The X,Z Position Of The Point
				flX = (float) nX + ( ( nTri == 1 || nTri == 2 || nTri == 5 ) ? flResolution : 0.0f );
				flZ = (float) nZ + ( ( nTri == 2 || nTri == 4 || nTri == 5 ) ? flResolution : 0.0f );

				// Set The Data, Using PtHeight To Obtain The Y Value
				m_pVertices[nIndex].x = flX - ( m_pTextureImage->sizeX / 2 );
				m_pVertices[nIndex].y = PtHeight( (int) flX, (int) flZ ) *  flHeightScale;
				m_pVertices[nIndex].z = flZ - ( m_pTextureImage->sizeY / 2 );

				// Stretch The Texture Across The Entire Mesh
				m_pTexCoords[nIndex].u = flX / m_pTextureImage->sizeX;
				m_pTexCoords[nIndex].v = flZ / m_pTextureImage->sizeY;

				// Increment Our Index
				nIndex++;
			}
		}
	}

	// Load The Texture Into OpenGL
	glGenTextures( 1, &m_nTextureId );					// Get An Open ID
	glBindTexture( GL_TEXTURE_2D, m_nTextureId );				// Bind The Texture
	glTexImage2D( GL_TEXTURE_2D, 0, 3, m_pTextureImage->sizeX, m_pTextureImage->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, m_pTextureImage->data );
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

	// Free The Texture Data
	if( m_pTextureImage )
	{
		if( m_pTextureImage->data )
			free( m_pTextureImage->data );
		free( m_pTextureImage );
	}
	return true;
}

float CMesh :: PtHeight( int nX, int nY )
{
	// Calculate The Position In The Texture, Careful Not To Overflow
	int nPos = ( ( nX % m_pTextureImage->sizeX )  + ( ( nY % m_pTextureImage->sizeY ) * m_pTextureImage->sizeX ) ) * 3;
	float flR = (float) m_pTextureImage->data[ nPos ];			// Get The Red Component
	float flG = (float) m_pTextureImage->data[ nPos + 1 ];			// Get The Green Component
	float flB = (float) m_pTextureImage->data[ nPos + 2 ];			// Get The Blue Component
	return ( 0.299f * flR + 0.587f * flG + 0.114f * flB );			// Calculate The Height Using The Luminance Algorithm
}

void CMesh :: BuildVBOs()
{
	// Generate And Bind The Vertex Buffer
	glGenBuffersARB( 1, &m_nVBOVertices );					// Get A Valid Name
	glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_nVBOVertices );			// Bind The Buffer
	// Load The Data
	glBufferDataARB( GL_ARRAY_BUFFER_ARB, m_nVertexCount*3*sizeof(float), m_pVertices, GL_STATIC_DRAW_ARB );

	// Generate And Bind The Texture Coordinate Buffer
	glGenBuffersARB( 1, &m_nVBOTexCoords );					// Get A Valid Name
	glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_nVBOTexCoords );		// Bind The Buffer
	// Load The Data
	glBufferDataARB( GL_ARRAY_BUFFER_ARB, m_nVertexCount*2*sizeof(float), m_pTexCoords, GL_STATIC_DRAW_ARB );

	// Our Copy Of The Data Is No Longer Necessary, It Is Safe In The Graphics Card
	delete [] m_pVertices; m_pVertices = NULL;
	delete [] m_pTexCoords; m_pTexCoords = NULL;
}

// Load The Mesh Data
	g_pMesh = new CMesh();							// Instantiate Our Mesh
	if( !g_pMesh->LoadHeightmap( "terrain.bmp",				// Load Our Heightmap
				MESH_HEIGHTSCALE, MESH_RESOLUTION ) )
	{
		MessageBox( NULL, "Error Loading Heightmap", "Error", MB_OK );
		return false;
	}

	// Check For VBOs Supported
#ifndef NO_VBOS
	g_fVBOSupported = IsExtensionSupported( "GL_ARB_vertex_buffer_object" );
	if( g_fVBOSupported )
	{
		// Get Pointers To The GL Functions
		glGenBuffersARB = (PFNGLGENBUFFERSARBPROC) wglGetProcAddress("glGenBuffersARB");
		glBindBufferARB = (PFNGLBINDBUFFERARBPROC) wglGetProcAddress("glBindBufferARB");
		glBufferDataARB = (PFNGLBUFFERDATAARBPROC) wglGetProcAddress("glBufferDataARB");
		glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC) wglGetProcAddress("glDeleteBuffersARB");
		// Load Vertex Data Into The Graphics Card Memory
		g_pMesh->BuildVBOs();						// Build The VBOs
	}
#else /* NO_VBOS */
	g_fVBOSupported = false;
#endif

bool IsExtensionSupported( char* szTargetExtension )
{
	const unsigned char *pszExtensions = NULL;
	const unsigned char *pszStart;
	unsigned char *pszWhere, *pszTerminator;

	// Extension names should not have spaces
	pszWhere = (unsigned char *) strchr( szTargetExtension, ' ' );
	if( pszWhere || *szTargetExtension == '\0' )
		return false;

	// Get Extensions String
	pszExtensions = glGetString( GL_EXTENSIONS );

	// Search The Extensions String For An Exact Copy
	pszStart = pszExtensions;
	for(;;)
	{
		pszWhere = (unsigned char *) strstr( (const char *) pszStart, szTargetExtension );
		if( !pszWhere )
			break;
		pszTerminator = pszWhere + strlen( szTargetExtension );
		if( pszWhere == pszStart || *( pszWhere - 1 ) == ' ' )
			if( *pszTerminator == ' ' || *pszTerminator == '\0' )
				return true;
		pszStart = pszTerminator;
	}
	return false;
}

void Draw (void)
{
	glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);			// Clear Screen And Depth Buffer
	glLoadIdentity ();							// Reset The Modelview Matrix

	// Get FPS
	if( GetTickCount() - g_dwLastFPS >= 1000 )				// When A Second Has Passed...
	{
		g_dwLastFPS = GetTickCount();					// Update Our Time Variable
		g_nFPS = g_nFrames;						// Save The FPS
		g_nFrames = 0;							// Reset The FPS Counter

		char szTitle[256]={0};						// Build The Title String
		sprintf( szTitle, "Lesson 45: NeHe & Paul Frazee's VBO Tut - %d Triangles, %d FPS", g_pMesh->m_nVertexCount / 3, g_nFPS );
		if( g_fVBOSupported )						// Include A Notice About VBOs
			strcat( szTitle, ", Using VBOs" );
		else
			strcat( szTitle, ", Not Using VBOs" );
		SetWindowText( g_window->hWnd, szTitle );			// Set The Title
	}
	g_nFrames++;								// Increment Our FPS Counter

	// Move The Camera
	glTranslatef( 0.0f, -220.0f, 0.0f );					// Move Above The Terrain
	glRotatef( 10.0f, 1.0f, 0.0f, 0.0f );					// Look Down Slightly
	glRotatef( g_flYRot, 0.0f, 1.0f, 0.0f );				// Rotate The Camera

	// Set Pointers To Our Data
	if( g_fVBOSupported )
	{
		glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh->m_nVBOVertices );
		glVertexPointer( 3, GL_FLOAT, 0, (char *) NULL );		// Set The Vertex Pointer To The Vertex Buffer
		glBindBufferARB( GL_ARRAY_BUFFER_ARB, g_pMesh->m_nVBOTexCoords );
		glTexCoordPointer( 2, GL_FLOAT, 0, (char *) NULL );		// Set The TexCoord Pointer To The TexCoord Buffer
	} else
	{
		glVertexPointer( 3, GL_FLOAT, 0, g_pMesh->m_pVertices );	// Set The Vertex Pointer To Our Vertex Data
		glTexCoordPointer( 2, GL_FLOAT, 0, g_pMesh->m_pTexCoords );	// Set The Vertex Pointer To Our TexCoord Data
	}

	// Render
	glDrawArrays( GL_TRIANGLES, 0, g_pMesh->m_nVertexCount );		// Draw All Of The Triangles At Once

	// Disable Pointers
	glDisableClientState( GL_VERTEX_ARRAY );				// Disable Vertex Arrays
	glDisableClientState( GL_TEXTURE_COORD_ARRAY );				// Disable Texture Coord Arrays
}