opengl/runGlutMainLoop.cpp

   1
   2 #if defined(_WIN32) || defined(__WIN32__)
   3 #       include <windows.h>
   4 #endif
   5 #include <stdlib.h>
   6 #include <stdio.h>
   7 #include <GL/gl.h>
   8
   9
  10 #include <GL/glut.h>
  11 #include "trackball.h"
  12 #include "readtex.h"
  13 #include "runGlutMainLoop.h"
  14 #include "../core/board.h"
  15 #include "../threads/thread_controller.h"
  16
  17 #ifndef byte
  18 #       define byte        unsigned char
  19 #endif
  20
  21
  22 #define glut_WINDOW_SIZE 500
  23 #define glut_WINDOW_POS_X 500
  24 #define glut_WINDOW_POS_Y 200
  25 #define glut_WINDOW_TITLE "OpenGL GLUT - 3D miny"
  26 #define glut_CUBE_SIZE 0.5f
  27 #define glut_ANGLE 1.0f
  28 #define TEXTURE_FILE "textury/all.sgi"
  29 #define TEXTURE_OFFSET_UNIT_X 0.125f
  30 #define TEXTURE_OFFSET_UNIT_Y 0.25f
  31 #define ALPHA_CONST 0.8f
  32
  33 void (*drawMines)();
  34
  35 //void runGlutMainLoop(int x,int y,int z);
  36
  37 //void * runGlutMainLoop( void * args);
  38
  39 void init(int x,int y,int z);
  40 void display(void);
  41 void reshape(int width,int height);
  42 void keyboard_input(int key,int x,int y);
  43 void idle(void);
  44 void drawMines1(void);
  45 void drawMine(int x,int y,int z);
  46 void initLights(void);
  47 void mouse_input(int button,int state,int x,int y);
  48 void motion(int x,int y);
  49 void displaySub(void);
  50 void makeTextures(void);
  51 void motion_pas(int x,int y);
  52 void forceRedraw(void);
  53
  54 int * minesX;
  55 int * minesY;
  56 int * minesZ;
  57
  58 int w_width;
  59 int w_height;
  60
  61 int win, subWin;
  62
  63 byte mode = 1;
  64 float zoom = 1.0f;
  65
  66 int cropX_min = 0,cropX_max;
  67 int cropY_min = 0,cropY_max;
  68 int cropZ_min = 0,cropZ_max;
  69 int last_x,last_y,last_z;
  70
  71 float mouse_old_x = 0, mouse_old_y = 0;
  72
  73 //Board * board;
  74 Thread_controller * thc;
  75
  76 float curQuat[4], incQuat[4];
  77
  78 const char * strX = "X: min    max";
  79 const char * strY = "Y: min    max";
  80 const char * strZ = "Z: min    max";
  81
  82 int selectXYZ = -1;
  83
  84 GLfloat ambient [] = { 1.0f, 1.0f, 1.0f, 1.0f };
  85
  86 GLfloat diffuse [][4] =
  87 {
  88     { 0.9f, 0.9f, 0.9f, 1.0f  },    // 0 light grey
  89     { 0.0f, 0.0f, 1.0f, 1.0f  },    // 1 blue
  90     { 0.0f, 1.0f, 0.0f, 1.0f  },    // 2 green
  91     { 1.0f, 0.0f, 0.0f, 1.0f  },    // 3 red
  92     { 0.0f, 0.0f, 0.5f, 1.0f  },    // 4 dark blue
  93     { 0.7f, 0.0f, 0.7f, 1.0f  },    // 5 purple
  94     { 0.0f, 0.5f, 0.0f, 1.0f  },    // 6 dark green
  95     { 0.5f, 0.0f, 0.0f, 1.0f  },    // 7 dark red
  96     { 0.32f, 0.32f, 0.32f, 1.0f  },    // 8 grey
  97     { 0.0f, 0.0f, 0.0f, 0.0f  }     // 9 black
  98 };
  99
 100 GLfloat sunDirection [] = { 0.0f, -1.0f, 0.0f };
 101 GLfloat sunPosition [3];
 102
 103 //void runGlutMainLoop(int x,int y,int z )
 104
 105 void forceRedraw(void)
 106 {
 107     glutPostRedisplay();
 108 }
 109
 110 void * runGlutMainLoop( void * args )
 111 {
 112         char *argval = new char [1];
 113         char **argv = new char* [1];
 114         argv[0] = argval;
 115         argval[0] = '\0';
 116         int argc = 1;
 117
 118     thc = (Thread_controller *)args;
 119
 120     glutInit(&argc,argv);
 121     glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA | GLUT_DEPTH);
 122     glutInitWindowSize(glut_WINDOW_SIZE,glut_WINDOW_SIZE);
 123     glutInitWindowPosition(glut_WINDOW_POS_X,glut_WINDOW_POS_Y);
 124     win = glutCreateWindow(glut_WINDOW_TITLE);
 125     w_height = w_width = glut_WINDOW_SIZE;
 126
 127     drawMines = drawMines1;
 128
 129     init(thc->dim[0],thc->dim[1],thc->dim[2]);
 130     initLights();
 131     glutDisplayFunc(display);
 132     glutReshapeFunc(reshape);
 133     glutIdleFunc(idle);
 134     glutMotionFunc(motion);
 135     glutSpecialFunc(keyboard_input);
 136
 137     trackball(curQuat,0.0,0.0,0.0,0.0);
 138
 139     subWin = glutCreateSubWindow(win, 0, 0, 340, 60);
 140     glutDisplayFunc(displaySub);
 141     glutMouseFunc(mouse_input);
 142     glutPassiveMotionFunc(motion_pas);
 143
 144     thc->ptf = &forceRedraw;
 145
 146     glutMainLoop();
 147     return 0;
 148 }
 149
 150 void init(int x,int y,int z)
 151 {
 152
 153
 154     glPolygonMode( GL_FRONT, GL_FILL );
 155         glPolygonMode( GL_BACK, GL_LINE );
 156         glCullFace( GL_BACK );
 157
 158         minesX = &thc->dim[0];
 159         minesY = &thc->dim[1];
 160         minesZ = &thc->dim[2];
 161
 162         sunPosition[0] = 0.0f;
 163         sunPosition[1] = 0.0f;
 164         sunPosition[2] = (*minesY) * 8 * glut_CUBE_SIZE;
 165
 166         cropX_max = last_x = *minesX;
 167         cropY_max = last_y = *minesY;
 168         cropZ_max = last_z = *minesZ;
 169
 170         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 171     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 172
 173     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 174     glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
 175
 176     if(!LoadRGBMipmapsUserAlpha(TEXTURE_FILE, GL_RGBA,ALPHA_CONST)) {
 177         printf("Error: couldn't load texture image\n");
 178     }
 179
 180         glEnable(GL_TEXTURE_2D);
 181         glEnable(GL_LIGHTING);
 182     glEnable(GL_DEPTH_TEST);
 183 }
 184
 185 void initLights(void)
 186 {
 187     glEnable(GL_LIGHT0);
 188     glLightf(GL_LIGHT0,GL_SPOT_CUTOFF,180);
 189
 190     glLightfv(GL_LIGHT0,GL_POSITION, sunPosition );
 191     glLightfv(GL_LIGHT0,GL_SPOT_DIRECTION,sunDirection);
 192
 193 }
 194
 195 void displaySub(void)
 196 {
 197     glClearColor(0.2, 0.2, 0.2, 1.0);
 198     glClear(GL_COLOR_BUFFER_BIT);
 199     glColor3f(1, 1, 1);
 200     glRasterPos2f(-0.95,0.5);
 201     int i,len;
 202     char * pom = (char*)malloc(25*sizeof(char));
 203     if (cropX_min <= 9) sprintf(pom," %i",cropX_min);
 204     else sprintf(pom,"%i",cropX_min);
 205     len = strlen(pom);
 206     for(i=0;i<7;i++)
 207         glutBitmapCharacter(GLUT_BITMAP_9_BY_15, strX[i]);
 208     for(i=0;i<len;i++)
 209         glutBitmapCharacter(GLUT_BITMAP_9_BY_15,pom[i]);
 210
 211     if (cropX_max <= 9) sprintf(pom," %i",cropX_max);
 212     else sprintf(pom,"%i",cropX_max);
 213     len = strlen(pom);
 214
 215     for(i=7;i<14;i++)
 216         glutBitmapCharacter(GLUT_BITMAP_9_BY_15, strX[i]);
 217     for(i=0;i<len;i++)
 218         glutBitmapCharacter(GLUT_BITMAP_9_BY_15,pom[i]);
 219
 220     glRasterPos2f(-0.95,-0.1);
 221     if (cropY_min <= 9) sprintf(pom," %i",cropY_min);
 222     else sprintf(pom,"%i",cropY_min);
 223     len = strlen(pom);
 224     for(i=0;i<7;i++)
 225         glutBitmapCharacter(GLUT_BITMAP_9_BY_15, strY[i]);
 226     for(i=0;i<len;i++)
 227         glutBitmapCharacter(GLUT_BITMAP_9_BY_15,pom[i]);
 228
 229     if (cropY_max <= 9) sprintf(pom," %i",cropY_max);
 230     else sprintf(pom,"%i",cropY_max);
 231     len = strlen(pom);
 232     for(i=7;i<14;i++)
 233         glutBitmapCharacter(GLUT_BITMAP_9_BY_15, strY[i]);
 234     for(i=0;i<len;i++)
 235         glutBitmapCharacter(GLUT_BITMAP_9_BY_15,pom[i]);
 236
 237     glRasterPos2f(-0.95,-0.7);
 238     if (cropZ_min <= 9) sprintf(pom," %i",cropZ_min);
 239     else sprintf(pom,"%i",cropZ_min);
 240     len = strlen(pom);
 241     for(i=0;i<7;i++)
 242         glutBitmapCharacter(GLUT_BITMAP_9_BY_15, strZ[i]);
 243     for(i=0;i<len;i++)
 244         glutBitmapCharacter(GLUT_BITMAP_9_BY_15,pom[i]);
 245
 246     if (cropZ_max <= 9) sprintf(pom," %i",cropZ_max);
 247     else sprintf(pom,"%i",cropZ_max);
 248     len = strlen(pom);
 249     for(i=7;i<14;i++)
 250         glutBitmapCharacter(GLUT_BITMAP_9_BY_15, strZ[i]);
 251     for(i=0;i<len;i++)
 252         glutBitmapCharacter(GLUT_BITMAP_9_BY_15,pom[i]);
 253
 254
 255
 256
 257     if (selectXYZ == 8) glColor3f(1, 0, 0);
 258     else glColor3f(1, 1, 0);
 259     glRasterPos2f(-0.45,0.5);
 260     glutBitmapCharacter(GLUT_BITMAP_9_BY_15,'+');
 261
 262     if (selectXYZ == 9) glColor3f(1, 0, 0);
 263     else glColor3f(1, 1, 0);
 264     glRasterPos2f(-0.38,0.5);
 265     glutBitmapCharacter(GLUT_BITMAP_9_BY_15,'-');
 266
 267     if (selectXYZ == 10) glColor3f(1, 0, 0);
 268     else glColor3f(1, 1, 0);
 269     glRasterPos2f(0.03,0.5);
 270     glutBitmapCharacter(GLUT_BITMAP_9_BY_15,'+');
 271
 272     if (selectXYZ == 11) glColor3f(1, 0, 0);
 273     else glColor3f(1, 1, 0);
 274     glRasterPos2f(0.10,0.5);
 275     glutBitmapCharacter(GLUT_BITMAP_9_BY_15,'-');
 276
 277
 278     if (selectXYZ == 4) glColor3f(1, 0, 0);
 279     else glColor3f(1, 1, 0);
 280     glRasterPos2f(-0.45,-0.1);
 281     glutBitmapCharacter(GLUT_BITMAP_9_BY_15,'+');
 282
 283     if (selectXYZ == 5) glColor3f(1, 0, 0);
 284     else glColor3f(1, 1, 0);
 285     glRasterPos2f(-0.38,-0.1);
 286     glutBitmapCharacter(GLUT_BITMAP_9_BY_15,'-');
 287
 288     if (selectXYZ == 6) glColor3f(1, 0, 0);
 289     else glColor3f(1, 1, 0);
 290     glRasterPos2f(0.03,-0.1);
 291     glutBitmapCharacter(GLUT_BITMAP_9_BY_15,'+');
 292
 293     if (selectXYZ == 7) glColor3f(1, 0, 0);
 294     else glColor3f(1, 1, 0);
 295     glRasterPos2f(0.10,-0.1);
 296     glutBitmapCharacter(GLUT_BITMAP_9_BY_15,'-');
 297
 298
 299     if (selectXYZ == 0) glColor3f(1, 0, 0);
 300     else glColor3f(1, 1, 0);
 301     glRasterPos2f(-0.45,-0.7);
 302     glutBitmapCharacter(GLUT_BITMAP_9_BY_15,'+');
 303
 304     if (selectXYZ == 1) glColor3f(1, 0, 0);
 305     else glColor3f(1, 1, 0);
 306     glRasterPos2f(-0.38,-0.7);
 307     glutBitmapCharacter(GLUT_BITMAP_9_BY_15,'-');
 308
 309     if (selectXYZ == 2) glColor3f(1, 0, 0);
 310     else glColor3f(1, 1, 0);
 311     glRasterPos2f(0.03,-0.7);
 312     glutBitmapCharacter(GLUT_BITMAP_9_BY_15,'+');
 313
 314     if (selectXYZ == 3) glColor3f(1, 0, 0);
 315     else glColor3f(1, 1, 0);
 316     glRasterPos2f(0.10,-0.7);
 317     glutBitmapCharacter(GLUT_BITMAP_9_BY_15,'-');
 318
 319     if (selectXYZ == 12) glColor3f(1, 0, 0);
 320     else glColor3f(1, 1, 0);
 321     glRasterPos2f(0.25,0.5);
 322     sprintf(pom,"SWITCH MODE %i",mode);
 323     len = strlen(pom);
 324     for(i=0;i<len;i++)
 325         glutBitmapCharacter(GLUT_BITMAP_9_BY_15,pom[i]);
 326
 327
 328
 329     free(pom);
 330
 331     glutSwapBuffers();
 332 }
 333
 334 void display(void)
 335 {
 336
 337     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 338
 339     thc->mutex_lock();
 340
 341     if ( last_x != *minesX || last_y != *minesY || last_z != *minesZ )
 342     {
 343         cropX_max = last_x = *minesX;
 344             cropY_max = last_y = *minesY;
 345             cropZ_max = last_z = *minesZ;
 346             glutPostWindowRedisplay(win);
 347     }
 348
 349     glMatrixMode(GL_MODELVIEW);
 350     glLoadIdentity();
 351     int m = *minesX;
 352     if (*minesY > m) m = *minesY;
 353     if (*minesZ > m) m = *minesZ;
 354
 355
 356
 357     gluLookAt( 0.0, 0.0  , glut_CUBE_SIZE * 6 * m * zoom,
 358         0.0,0.0,0.0,
 359         0.0, 1.0, 0.0
 360     );
 361
 362     glPushMatrix();
 363
 364     if (thc->b != 0) drawMines();
 365
 366
 367
 368     glMaterialfv(GL_FRONT,GL_AMBIENT,ambient);
 369     glMaterialfv(GL_FRONT,GL_DIFFUSE,diffuse[0]);
 370
 371     glPopMatrix();
 372
 373     thc->mutex_unlock();
 374
 375     glutSwapBuffers();
 376
 377
 378 }
 379
 380 void reshape(int width,int height)
 381 {
 382
 383     w_width = width;
 384     w_height = height;
 385
 386     glViewport(0,0,width,height);
 387
 388     glMatrixMode(GL_PROJECTION);
 389     glLoadIdentity();
 390     gluPerspective(60.0,(GLdouble)width/height,0.1,200.0);
 391
 392     thc->mutex_lock();
 393
 394     glMatrixMode(GL_MODELVIEW);
 395     glLoadIdentity();
 396     int m = *minesX;
 397     if (*minesY > m) m = *minesY;
 398     if (*minesZ > m) m = *minesZ;
 399
 400     thc->mutex_unlock();
 401
 402     gluLookAt( 0.0, 0.0  , glut_CUBE_SIZE * 6 * m * zoom,
 403         0.0,0.0,0.0,
 404         0.0, 1.0, 0.0
 405     );
 406
 407 }
 408
 409 void idle(void)
 410 {
 411     glutPostRedisplay();
 412 }
 413
 414 void keyboard_input(int key,int x,int y)
 415 {
 416     if (key == GLUT_KEY_LEFT) zoom += 0.025f;
 417     if (key == GLUT_KEY_RIGHT) zoom -= 0.025f;
 418
 419 }
 420
 421 void mouse_input(int button,int state,int x,int y)
 422 {
 423
 424     if( button == GLUT_LEFT_BUTTON )
 425     {
 426         if (state == GLUT_DOWN)
 427         {
 428             switch( selectXYZ )
 429             {
 430                 case 12:
 431                     ++(mode %= 4);
 432                     break;
 433                 case 8:
 434                     if (cropX_min < *minesX-1) cropX_min += 1;
 435                     break;
 436                 case 9:
 437                     if (cropX_min > 0) cropX_min -= 1;
 438                     break;
 439                 case 10:
 440                     if (cropX_max < *minesX) cropX_max += 1;
 441                     break;
 442                 case 11:
 443                     if (cropX_max > 0) cropX_max -= 1;
 444                     break;
 445                 case 4:
 446                     if (cropY_min < *minesY-1) cropY_min += 1;
 447                     break;
 448                 case 5:
 449                     if (cropY_min > 0) cropY_min -= 1;
 450                     break;
 451                 case 6:
 452                     if (cropY_max < *minesY) cropY_max += 1;
 453                     break;
 454                 case 7:
 455                     if (cropY_max > 0) cropY_max -= 1;
 456                     break;
 457                 case 0:
 458                     if (cropZ_min < *minesZ-1) cropZ_min += 1;
 459                     break;
 460                 case 1:
 461                     if (cropZ_min > 0) cropZ_min -= 1;
 462                     break;
 463                 case 2:
 464                     if (cropZ_max < *minesZ) cropZ_max += 1;
 465                     break;
 466                 case 3:
 467                     if (cropZ_max > 0) cropZ_max -= 1;
 468                     break;
 469
 470             }
 471
 472         }
 473     }
 474     glutPostWindowRedisplay(win);
 475
 476 }
 477
 478 void motion(int x, int y)
 479 {
 480     int x1,y1;
 481     x1 = x;
 482     y1 = y;
 483     if (mouse_old_x - x > w_width / 100  ) x = (int)mouse_old_x - w_width / 100;
 484     if (mouse_old_x - x < -w_width / 100) x = (int)mouse_old_x + w_width / 100;
 485
 486     if (mouse_old_y - y > w_height / 100) y = (int)mouse_old_y - w_height/ 100;
 487     if (mouse_old_y - y < -w_height / 100) y = (int)mouse_old_y + w_height / 100;
 488
 489     trackball(incQuat, (2.0 * mouse_old_x - w_width) / w_width,
 490         (w_height - 2.0 * mouse_old_y) / w_height,
 491         (2.0 * x - w_width) / w_width,
 492         (w_height - 2.0 * y) / w_height );
 493
 494
 495     add_quats(incQuat,curQuat,curQuat);
 496
 497     mouse_old_x = x1;
 498     mouse_old_y = y1;
 499
 500     //glutPostRedisplay();
 501
 502
 503 }
 504
 505 void drawMines1(void)
 506 {
 507     int i,j,k;
 508     float m[4][4];
 509
 510     glPushMatrix();
 511
 512
 513
 514     build_rotmatrix(m,curQuat);
 515     glMultMatrixf(&m[0][0]);
 516
 517     glDisable(GL_LIGHTING);
 518     glDisable(GL_TEXTURE_2D);
 519
 520     glBegin(GL_LINES);
 521         glColor3f(1.0, 0.0, 0.0);
 522         glVertex3f(0.0,0.0,0.0);
 523         glVertex3f(glut_CUBE_SIZE * 4 * *minesX,0.0,0.0);
 524
 525         glVertex3f(glut_CUBE_SIZE * 4 * *minesX,0.0,0.0);
 526         glVertex3f(glut_CUBE_SIZE * 4 * *minesX - 2,2.0,0.0);
 527         glVertex3f(glut_CUBE_SIZE * 4 * *minesX,0.0,0.0);
 528         glVertex3f(glut_CUBE_SIZE * 4 * *minesX - 2,-2.0,0.0);
 529
 530         glColor3f(0.0, 1.0, 0.0);
 531         glVertex3f(0.0,0.0,0.0);
 532         glVertex3f(0.0,glut_CUBE_SIZE * 4 * *minesY,0.0);
 533
 534         glVertex3f(0.0,glut_CUBE_SIZE * 4 * *minesY,0.0);
 535         glVertex3f(2.0,glut_CUBE_SIZE * 4 * *minesY-2,0.0);
 536         glVertex3f(0.0,glut_CUBE_SIZE * 4 * *minesY,0.0);
 537         glVertex3f(-2.0,glut_CUBE_SIZE * 4 * *minesY-2,0.0);
 538
 539         glColor3f(0.0, 0.0, 1.0);
 540         glVertex3f(0.0,0.0,0.0);
 541         glVertex3f(0.0,0.0,glut_CUBE_SIZE * 4 * *minesZ);
 542
 543         glVertex3f(0.0,0.0,glut_CUBE_SIZE * 4 * *minesZ);
 544         glVertex3f(2.0,0.0,glut_CUBE_SIZE * 4 * *minesZ-2);
 545         glVertex3f(0.0,0.0,glut_CUBE_SIZE * 4 * *minesZ);
 546         glVertex3f(-2.0,0.0,glut_CUBE_SIZE * 4 * *minesZ-2);
 547
 548
 549     glEnd();
 550
 551     glEnable(GL_LIGHTING);
 552     glEnable(GL_TEXTURE_2D);
 553
 554     glEnable (GL_BLEND);
 555     glDepthMask (GL_FALSE);
 556     glBlendFunc (GL_SRC_ALPHA,GL_ONE_MINUS_SRC_COLOR);
 557
 558     if (mode > 2) glTranslated(-4 * glut_CUBE_SIZE * thc->selected[1], -4 * glut_CUBE_SIZE * thc->selected[2],-4 * glut_CUBE_SIZE * thc->selected[0] );
 559     else glTranslated( -2 * (*minesX-1) * glut_CUBE_SIZE,-2 * (*minesY-1) * glut_CUBE_SIZE,-2 * (*minesZ-1) * glut_CUBE_SIZE  );
 560
 561     glPushAttrib(GL_ALL_ATTRIB_BITS);
 562
 563     for (i = 0;i < *minesX ;i++  )
 564     {
 565         if ((i < thc->selected[1]-2 || i > thc->selected[1]+2) && mode > 2 ) continue;
 566
 567         if (i < cropX_min || i > cropX_max) continue;
 568
 569         for ( j = 0;j < *minesZ; j++ )
 570         {
 571             if ((j < thc->selected[0]-2 || j > thc->selected[0]+2) && mode > 2 ) continue;
 572             if (j < cropZ_min || j > cropZ_max) continue;
 573             for ( k = 0;k < *minesY; k++ )
 574             {
 575                 if ((k < thc->selected[2]-2 || k > thc->selected[2]+2) && mode > 2 ) continue;
 576                 if (k < cropY_min || k > cropY_max) continue;
 577                 glPushMatrix();
 578
 579                 glTranslated( 4 * i * glut_CUBE_SIZE, 4 * k * glut_CUBE_SIZE, 4 * j * glut_CUBE_SIZE );
 580                 glMaterialfv(GL_FRONT, GL_AMBIENT, ambient);
 581                 glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse[0]);
 582
 583                 if ((thc->selected[0] == j && thc->selected[1] == i && thc->selected[2] == k) || thc->selected[0] == -1 || mode % 2  == 1)
 584                 {
 585                     glDepthMask (GL_TRUE);
 586                     glDisable (GL_BLEND);
 587
 588                     if ((thc->selected[3] == j && thc->selected[4] == i && thc->selected[5] == k) )
 589                         glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse[8]);
 590                     drawMine(j,i,k);
 591                     glEnable (GL_BLEND);
 592                     glDepthMask (GL_FALSE);
 593                     glBlendFunc (GL_SRC_ALPHA,GL_ONE_MINUS_SRC_COLOR);
 594
 595                 }
 596                 else
 597                 {
 598                     drawMine(j,i,k);
 599                 }
 600                 glPopMatrix();
 601
 602             }
 603         }
 604     }
 605
 606     glPopAttrib();
 607
 608     glDepthMask (GL_TRUE);
 609     glDisable (GL_BLEND);
 610
 611     glPopMatrix();
 612     glFlush();
 613
 614
 615 }
 616
 617 void drawMine(int x,int y,int z)
 618 {
 619     int val;
 620
 621     //glEnable(GL_TEXTURE_2D);
 622     //glDisable( GL_LIGHTING );
 623
 624     Field f = thc->b->getField(x,y,z);
 625
 626     val = 28;
 627     int total_offsetX = 0;
 628     int total_offsetY = 3;
 629
 630     if ( f.hasMark() )
 631     {
 632         val = 26;
 633         goto calc_offset;
 634     }
 635     if ( !f.isCovered() )
 636     {
 637         if ( f.hasMine() )
 638         {
 639             val = 27;
 640             goto calc_offset;
 641         }
 642         val = f.getNeighboursCnt() - 1;
 643         if (val == -1 ) return;
 644     }
 645
 646 calc_offset:
 647
 648     total_offsetX = val % 8;
 649     total_offsetY -= (val / 8) % 4;
 650
 651
 652     glBegin(GL_QUADS);
 653
 654         // front
 655
 656         glNormal3f(0.0f, 0.0f, 1.0f);
 657
 658         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X, TEXTURE_OFFSET_UNIT_Y * total_offsetY );
 659         glVertex3f( -glut_CUBE_SIZE,-glut_CUBE_SIZE, glut_CUBE_SIZE );
 660
 661         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X + TEXTURE_OFFSET_UNIT_X, TEXTURE_OFFSET_UNIT_Y * total_offsetY );
 662         glVertex3f( glut_CUBE_SIZE,-glut_CUBE_SIZE, glut_CUBE_SIZE );
 663
 664         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X + TEXTURE_OFFSET_UNIT_X, TEXTURE_OFFSET_UNIT_Y * total_offsetY + TEXTURE_OFFSET_UNIT_Y);
 665         glVertex3f( glut_CUBE_SIZE,glut_CUBE_SIZE, glut_CUBE_SIZE );
 666
 667         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X,TEXTURE_OFFSET_UNIT_Y * total_offsetY + TEXTURE_OFFSET_UNIT_Y);
 668         glVertex3f( -glut_CUBE_SIZE,glut_CUBE_SIZE, glut_CUBE_SIZE );
 669
 670         // back
 671         glNormal3f(0.0f, 0.0f, -1.0f);
 672
 673         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X, TEXTURE_OFFSET_UNIT_Y * total_offsetY );
 674         glVertex3f( glut_CUBE_SIZE,-glut_CUBE_SIZE, -glut_CUBE_SIZE );
 675
 676         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X + TEXTURE_OFFSET_UNIT_X, TEXTURE_OFFSET_UNIT_Y * total_offsetY );
 677         glVertex3f( -glut_CUBE_SIZE,-glut_CUBE_SIZE, -glut_CUBE_SIZE );
 678
 679         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X + TEXTURE_OFFSET_UNIT_X, TEXTURE_OFFSET_UNIT_Y * total_offsetY + TEXTURE_OFFSET_UNIT_Y);
 680         glVertex3f( -glut_CUBE_SIZE,glut_CUBE_SIZE, -glut_CUBE_SIZE );
 681
 682         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X,TEXTURE_OFFSET_UNIT_Y * total_offsetY + TEXTURE_OFFSET_UNIT_Y);
 683         glVertex3f( glut_CUBE_SIZE,glut_CUBE_SIZE, -glut_CUBE_SIZE );
 684
 685         // left
 686         glNormal3f(-1.0f, 0.0f, 0.0f);
 687
 688         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X, TEXTURE_OFFSET_UNIT_Y * total_offsetY );
 689         glVertex3f( -glut_CUBE_SIZE,-glut_CUBE_SIZE, -glut_CUBE_SIZE );
 690
 691         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X + TEXTURE_OFFSET_UNIT_X, TEXTURE_OFFSET_UNIT_Y * total_offsetY );
 692         glVertex3f( -glut_CUBE_SIZE,-glut_CUBE_SIZE, glut_CUBE_SIZE );
 693
 694         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X + TEXTURE_OFFSET_UNIT_X, TEXTURE_OFFSET_UNIT_Y * total_offsetY + TEXTURE_OFFSET_UNIT_Y);
 695         glVertex3f( -glut_CUBE_SIZE,glut_CUBE_SIZE, glut_CUBE_SIZE );
 696
 697         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X,TEXTURE_OFFSET_UNIT_Y * total_offsetY + TEXTURE_OFFSET_UNIT_Y);
 698         glVertex3f( -glut_CUBE_SIZE,glut_CUBE_SIZE, -glut_CUBE_SIZE );
 699
 700         // right
 701         glNormal3f(1.0f, 0.0f, 0.0f);
 702
 703         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X, TEXTURE_OFFSET_UNIT_Y * total_offsetY );
 704         glVertex3f( glut_CUBE_SIZE,-glut_CUBE_SIZE, glut_CUBE_SIZE );
 705
 706         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X + TEXTURE_OFFSET_UNIT_X, TEXTURE_OFFSET_UNIT_Y * total_offsetY );
 707         glVertex3f( glut_CUBE_SIZE,-glut_CUBE_SIZE, -glut_CUBE_SIZE );
 708
 709         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X + TEXTURE_OFFSET_UNIT_X, TEXTURE_OFFSET_UNIT_Y * total_offsetY + TEXTURE_OFFSET_UNIT_Y);
 710         glVertex3f( glut_CUBE_SIZE,glut_CUBE_SIZE, -glut_CUBE_SIZE );
 711
 712         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X,TEXTURE_OFFSET_UNIT_Y * total_offsetY + TEXTURE_OFFSET_UNIT_Y);
 713         glVertex3f( glut_CUBE_SIZE,glut_CUBE_SIZE, glut_CUBE_SIZE );
 714
 715         // bottom
 716         glNormal3f(0.0f, -1.0f, 0.0f);
 717
 718         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X, TEXTURE_OFFSET_UNIT_Y * total_offsetY );
 719         glVertex3f( -glut_CUBE_SIZE,-glut_CUBE_SIZE, glut_CUBE_SIZE );
 720
 721         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X + TEXTURE_OFFSET_UNIT_X, TEXTURE_OFFSET_UNIT_Y * total_offsetY );
 722         glVertex3f( -glut_CUBE_SIZE,-glut_CUBE_SIZE, -glut_CUBE_SIZE );
 723
 724         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X + TEXTURE_OFFSET_UNIT_X, TEXTURE_OFFSET_UNIT_Y * total_offsetY + TEXTURE_OFFSET_UNIT_Y);
 725         glVertex3f( glut_CUBE_SIZE,-glut_CUBE_SIZE, -glut_CUBE_SIZE );
 726
 727         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X,TEXTURE_OFFSET_UNIT_Y * total_offsetY + TEXTURE_OFFSET_UNIT_Y);
 728         glVertex3f( glut_CUBE_SIZE,-glut_CUBE_SIZE, glut_CUBE_SIZE );
 729
 730         // top
 731         glNormal3f(0.0f, 1.0f, 0.0f);
 732
 733         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X, TEXTURE_OFFSET_UNIT_Y * total_offsetY );
 734         glVertex3f( -glut_CUBE_SIZE,glut_CUBE_SIZE, glut_CUBE_SIZE );
 735
 736         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X + TEXTURE_OFFSET_UNIT_X, TEXTURE_OFFSET_UNIT_Y * total_offsetY );
 737         glVertex3f( glut_CUBE_SIZE,glut_CUBE_SIZE, glut_CUBE_SIZE );
 738
 739         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X + TEXTURE_OFFSET_UNIT_X, TEXTURE_OFFSET_UNIT_Y * total_offsetY + TEXTURE_OFFSET_UNIT_Y);
 740         glVertex3f( glut_CUBE_SIZE,glut_CUBE_SIZE, -glut_CUBE_SIZE );
 741
 742         glTexCoord2f(total_offsetX * TEXTURE_OFFSET_UNIT_X,TEXTURE_OFFSET_UNIT_Y * total_offsetY + TEXTURE_OFFSET_UNIT_Y);
 743         glVertex3f( -glut_CUBE_SIZE,glut_CUBE_SIZE, -glut_CUBE_SIZE );
 744
 745
 746
 747
 748     glEnd();
 749
 750     //glDisable(GL_TEXTURE_2D);
 751     //glEnable( GL_LIGHTING );
 752
 753
 754 }
 755
 756 void motion_pas(int x,int y)
 757 {
 758
 759     if (y < 54 && y > 37)
 760     {
 761         if (x < 196)
 762         {
 763             if (x > 184 )
 764             {
 765                 selectXYZ = 3;
 766                 return;
 767             }
 768             if (x > 174 )
 769             {
 770                 selectXYZ = 2;
 771                 return;
 772             }
 773         }
 774         if (x < 115)
 775         {
 776             if (x > 104 )
 777             {
 778                 selectXYZ = 1;
 779                 return;
 780             }
 781             if (x > 94 )
 782             {
 783                 selectXYZ = 0;
 784                 return;
 785             }
 786         }
 787     }
 788
 789
 790     if (y < 37 && y > 19)
 791     {
 792         if (x < 196)
 793         {
 794             if (x > 184 )
 795             {
 796                 selectXYZ = 7;
 797                 return;
 798             }
 799             if (x > 174 )
 800             {
 801                 selectXYZ = 6;
 802                 return;
 803             }
 804         }
 805         if (x < 115)
 806         {
 807             if (x > 104 )
 808             {
 809                 selectXYZ = 5;
 810                 return;
 811             }
 812             if (x > 94 )
 813             {
 814                 selectXYZ = 4;
 815                 return;
 816             }
 817         }
 818     }
 819
 820
 821     if (y < 19 && y > 2)
 822     {
 823         if (x < 320 && x > 210)
 824         {
 825             selectXYZ = 12;
 826             return;
 827         }
 828
 829         if (x < 196)
 830         {
 831             if (x > 184 )
 832             {
 833                 selectXYZ = 11;
 834                 return;
 835             }
 836             if (x > 174 )
 837             {
 838                 selectXYZ = 10;
 839                 return;
 840             }
 841         }
 842         if (x < 115)
 843         {
 844             if (x > 104 )
 845             {
 846                 selectXYZ = 9;
 847                 return;
 848             }
 849             if (x > 94 )
 850             {
 851                 selectXYZ = 8;
 852                 return;
 853             }
 854         }
 855     }
 856
 857     selectXYZ = -1;
 858
 859
 860
 861 }
 862
 863
 864
 865
 866
 867
 868
 869
 870
 871
 872
 873