PMG

#include <Windows.h>
#include "glut/glut.h"
#include <gl\GL.h>
#include <math.h>
#include <time.h>
#include <stdio.h>
#include <conio.h>

#pragma comment (lib,"OpenGL32.lib")
#pragma comment (lib,"glut32.lib")

#ifdef _UNICODE
#undef _UNICODE
#include "il/il.h"
#include "il/ilu.h"

#define _UNICODE
#else
#include <il.h>
#endif

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

//32 битный указатель на цвет для удобства работы
struct color {
   unsigned char b;
   unsigned char g;
   unsigned char r;
   unsigned char a;
} *hmap;


unsigned int hwidth;
unsigned int hheight;

class vertex{
public:
   float x;
   float y;
   float z;
   float nx;
   float ny;
   float nz;


};


float angle = 0.0f;
#define ZOOM_SCALE 50



vertex* initVertex(){
   ilInit();
   ILuint image;
   ilGenImages(1,&image);
   ilBindImage(image);
   ilLoadImage("hmap.jpg");
   
   //на всякий случай защитимся от загрузки не 32 битныx файлов
   ilConvertImage(IL_RGBA,IL_UNSIGNED_BYTE);

   //Получаем нужные для нас сведения о карте высоты
   hmap = (color*)ilGetData();
   hwidth = ilGetInteger(IL_IMAGE_WIDTH);
   hheight = ilGetInteger(IL_IMAGE_HEIGHT);   

   //заполняем координаты
   int counter = 0;
   vertex *v = new vertex [(hwidth)*(hheight)];
   for(unsigned int i = 0; i < (hheight); i++){
      for(unsigned int j = 0; j < (hwidth); j++){
         
         v[counter].x = i * 5;         
         v[counter].y = hmap[counter].g - 100;
         v[counter].z = j * 5;
         counter++;
      }
   }
   
   return v;
}

vertex* initNormals(vertex* v){
   //заполняем нормали
   for(unsigned int i = 0; i < (hheight*hwidth); i++){
      float Qx = v[i+1].x - v[i].x;
      float Qy = v[i+1].y - v[i].y;
      float Qz = v[i+1].z - v[i].z;
      float Px = v[i+2].x - v[i].x;
      float Py = v[i+2].y - v[i].y;
      float Pz = v[i+2].z - v[i].z;
      v[i].nx = v[i+1].nx = v[i+2].nx = Py*Qz - Pz*Qy;
      v[i].ny = v[i+1].ny = v[i+2].ny = Pz*Qx - Px*Qz;
      v[i].nz = v[i+1].nz = v[i+2].nz = Px*Qy - Py*Qx;
      //нормализация нормали
      float len = 1.0f/sqrtf(v[i].nx * v[i].nx + v[i].ny * v[i].ny + v[i].nz * v[i].nz);
      v[i].nx *= len;
      v[i].ny *= len;
      v[i].nz *= len;      
   }

   return v;
}




int* index(){
   
   int count = 0;

   int* Indices = new int [3*2*(hheight - 1)*(hwidth - 1)];

      for (unsigned int x = 0; x < (hwidth - 1); x++){
         
         for (unsigned int y = 0; y < (hheight - 1); y++){

                Indices[count++] = y * hheight + x;
                Indices[count++] = (y + 1) * hheight + x;
                Indices[count++] = (y + 1) * hheight + x + 1;
                Indices[count++] = y * hheight + x;
                Indices[count++] = (y + 1) * hheight + x + 1;
                Indices[count++] = y * hheight + x + 1;
         }
      }

return Indices;
}


vertex* N;
vertex* M;
vertex* V;

int* Ind;



void reshape(int width, int height){
   //задаем размер окна вывода
   glViewport(0, 0, width, height);
   //установка матрицы проекции в перспективную
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   float z = 100;
   glFrustum(-ZOOM_SCALE,ZOOM_SCALE,-ZOOM_SCALE,ZOOM_SCALE,ZOOM_SCALE*1.2f,10000);
   glTranslatef(0,0,-2*ZOOM_SCALE);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   //включим глубину, свет и источник света 0
   glEnable(GL_DEPTH);
   glEnable(GL_TEXTURE_2D);
}

float n = 0;

//рисуем кадр


void draw(void){
   glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
   
   glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
   glLoadIdentity();
   angle += 0.1f;
   
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   glRotatef(30, 1, 0, 0);
   glRotatef(angle, 0, 1, 0);
   
   float pos[4] = {200,100,200,1};
   glLightfv(GL_LIGHT0, GL_POSITION, pos);
   
   
   glBegin(GL_LINES);
   
   glColor3f(1.0f, 0.0f, 0.0f);
   glVertex3f(0.0, 0.0f, 0.0f);
   glVertex3f(50.0, 0.0f, 0.0f);
   
   glColor3f(0.0f, 1.0f, 0.0f);
   glVertex3f(0.0, 0.0f, 0.0f);
   glVertex3f(0.0f, 50.0f, 0.0f);
   
   glColor3f(0.0f, 0.0f, 1.0f);
   glVertex3f(0.0, 0.0f, 0.0f);
   glVertex3f(0.0f, 0.0f, 50.0f);
   
   glEnd();
   
   glEnableClientState(GL_VERTEX_ARRAY);
   glEnableClientState(GL_NORMAL_ARRAY);
   glNormalPointer(GL_FLOAT,6*sizeof(float),&V[3]);
   glVertexPointer(3,GL_FLOAT,6*sizeof(float),V);
   glDrawElements(GL_TRIANGLES,3*2*(hheight-1)*(hwidth-1),GL_UNSIGNED_INT,Ind);
   glDisableClientState(GL_NORMAL_ARRAY);
   glDisableClientState(GL_VERTEX_ARRAY); 
   glFlush();
   glutSwapBuffers(); 
   glutPostRedisplay();
 
}

void main (int argc, char **argv){
   
   glutInit(&argc, argv);
   glutInitWindowSize(400, 300);
   glutInitWindowPosition(200, 100);

   N = initVertex();
   V = initNormals(N);
   Ind = index();
   //создание окна
   glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
   glutCreateWindow("Hello world"); 
   glutReshapeFunc(reshape);
   glutDisplayFunc(draw); 
   glDisable(GL_LIGHTING); 
   glEnable(GL_COLOR_MATERIAL); 
   glutMainLoop();
 
}