Cockpit/panel.cxx

   1 /**************************************************************************
   2  * panel.cxx -- routines to draw an instrument panel
   3  *
   4  * Written by Friedemann Reinhard, started June 1998.
   5  *
   6  * Copyright(C)1998 Friedemann Reinhard-reinhard@theorie2.physik.uni-erlangen.de
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of the
  11  * License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  *
  22  * $Id$
  23  * (Log is kept at end of this file)
  24  **************************************************************************/
  25
  26
  27 #ifdef HAVE_CONFIG_H
  28 #  include <config.h>
  29 #endif
  30
  31 #ifdef HAVE_WINDOWS_H
  32 #  include <windows.h>
  33 #endif
  34
  35 #include <GL/glut.h>
  36 #include <XGL/xgl.h>
  37
  38 #include <stdlib.h>
  39 #include <stdio.h>
  40 #include <string.h>
  41 #include <string>
  42 #include <math.h>
  43
  44 #include <Aircraft/aircraft.hxx>
  45 #include <Debug/fg_debug.h>
  46 #include <Main/options.hxx>
  47 #include <Main/views.hxx>
  48
  49 #include "panel.hxx"
  50 #include "cockpit.hxx"
  51 #include "hud.hxx"
  52
  53 #define IMAGIC      0x01da
  54 #define IMAGIC_SWAP 0xda01
  55
  56 #define SWAP_SHORT_BYTES(x) ((((x) & 0xff) << 8) | (((x) & 0xff00) >> 8))
  57 #define SWAP_LONG_BYTES(x) (((((x) & 0xff) << 24) | (((x) & 0xff00) << 8)) | \
  58 ((((x) & 0xff0000) >> 8) | (((x) & 0xff000000) >> 24)))
  59
  60 typedef struct {
  61     unsigned short imagic;
  62     unsigned short type;
  63     unsigned short dim;
  64     unsigned short sizeX, sizeY, sizeZ;
  65     unsigned long min, max;
  66     unsigned long wasteBytes;
  67     char name[80];
  68     unsigned long colorMap;
  69     FILE *file;
  70     unsigned char *tmp[5];
  71     unsigned long rleEnd;
  72     unsigned long *rowStart;
  73     unsigned long *rowSize;
  74 } Image;
  75
  76
  77 IMAGE *imag;
  78 IMAGE *img2;
  79 IMAGE *img;
  80
  81 static GLuint panel_list;
  82 static GLuint panel_tex_id;
  83 static GLubyte tex[32][128][3];
  84 static GLint stencil[1024][768];
  85 static float alphahist;
  86 static float Xzoom, Yzoom;
  87 // static GLint viewport[4];
  88 // static GLdouble mvmatrix[16], projmatrix[16];
  89 static Pointer pointer[20];
  90 static float NumPoint = 4;
  91 static double var[20];
  92 static double offset;
  93 static float alpha;
  94
  95 /* image.c THIS FILE WAS COPIED FROM THE MESA GRAPHICS LIBRARY */
  96
  97
  98 static Image *ImageOpen(char *fileName)
  99 {
 100   Image *image;
 101   unsigned long *rowStart, *rowSize, ulTmp;
 102   int x, i;
 103
 104   image = (Image *)malloc(sizeof(Image));
 105   if (image == NULL)
 106     {
 107       fprintf(stderr, "Out of memory!\n");
 108       exit(-1);
 109     }
 110   if ((image->file = fopen(fileName, "rb")) == NULL)
 111     {
 112       perror(fileName);
 113       exit(-1);
 114     }
 115   /*
 116    *    Read the image header
 117    */
 118   fread(image, 1, 12, image->file);
 119   /*
 120    *    Check byte order
 121    */
 122   if (image->imagic == IMAGIC_SWAP)
 123     {
 124       image->type = SWAP_SHORT_BYTES(image->type);
 125       image->dim = SWAP_SHORT_BYTES(image->dim);
 126       image->sizeX = SWAP_SHORT_BYTES(image->sizeX);
 127       image->sizeY = SWAP_SHORT_BYTES(image->sizeY);
 128       image->sizeZ = SWAP_SHORT_BYTES(image->sizeZ);
 129     }
 130
 131   for ( i = 0 ; i <= image->sizeZ ; i++ )
 132     {
 133       image->tmp[i] = (unsigned char *)malloc(image->sizeX*256);
 134       if (image->tmp[i] == NULL )
 135         {
 136           fprintf(stderr, "Out of memory!\n");
 137           exit(-1);
 138         }
 139     }
 140
 141   if ((image->type & 0xFF00) == 0x0100) /* RLE image */
 142     {
 143       x = image->sizeY * image->sizeZ * sizeof(long);
 144       image->rowStart = (unsigned long *)malloc(x);
 145       image->rowSize = (unsigned long *)malloc(x);
 146       if (image->rowStart == NULL || image->rowSize == NULL)
 147         {
 148           fprintf(stderr, "Out of memory!\n");
 149           exit(-1);
 150         }
 151       image->rleEnd = 512 + (2 * x);
 152       fseek(image->file, 512, SEEK_SET);
 153       fread(image->rowStart, 1, x, image->file);
 154       fread(image->rowSize, 1, x, image->file);
 155       if (image->imagic == IMAGIC_SWAP)
 156         {
 157           x /= sizeof(long);
 158           rowStart = image->rowStart;
 159           rowSize = image->rowSize;
 160           while (x--)
 161             {
 162               ulTmp = *rowStart;
 163               *rowStart++ = SWAP_LONG_BYTES(ulTmp);
 164               ulTmp = *rowSize;
 165               *rowSize++ = SWAP_LONG_BYTES(ulTmp);
 166             }
 167         }
 168     }
 169   return image;
 170 }
 171
 172 static void ImageClose( Image *image)
 173 {
 174   int i;
 175
 176   fclose(image->file);
 177   for ( i = 0 ; i <= image->sizeZ ; i++ )
 178     free(image->tmp[i]);
 179   free(image);
 180 }
 181
 182 static void ImageGetRow( Image *image, unsigned char *buf, int y, int z)
 183 {
 184   unsigned char *iPtr, *oPtr, pixel;
 185   int count;
 186
 187   if ((image->type & 0xFF00) == 0x0100)  /* RLE image */
 188     {
 189       fseek(image->file, image->rowStart[y+z*image->sizeY], SEEK_SET);
 190       fread(image->tmp[0], 1, (unsigned int)image->rowSize[y+z*image->sizeY],
 191             image->file);
 192
 193       iPtr = image->tmp[0];
 194       oPtr = buf;
 195       while (1)
 196         {
 197           pixel = *iPtr++;
 198           count = (int)(pixel & 0x7F);
 199           if (!count)
 200             return;
 201           if (pixel & 0x80)
 202             {
 203               while (count--)
 204                 {
 205                   *oPtr++ = *iPtr++;
 206                 }
 207             }
 208           else
 209             {
 210               pixel = *iPtr++;
 211               while (count--)
 212                 {
 213                   *oPtr++ = pixel;
 214                 }
 215             }
 216         }
 217     }
 218   else /* verbatim image */
 219     {
 220       fseek(image->file, 512+(y*image->sizeX)+(z*image->sizeX*image->sizeY),
 221             SEEK_SET);
 222       fread(buf, 1, image->sizeX, image->file);
 223     }
 224 }
 225
 226 static void ImageGetRawData( Image *image, char *data)
 227 {
 228   int i, j, k;
 229   int remain;
 230
 231   switch ( image->sizeZ )
 232     {
 233     case 1:
 234       remain = image->sizeX % 4;
 235       break;
 236     case 2:
 237       remain = image->sizeX % 2;
 238       break;
 239     case 3:
 240       remain = (image->sizeX * 3) & 0x3;
 241       if (remain)
 242         remain = 4 - remain;
 243       break;
 244     case 4:
 245       remain = 0;
 246       break;
 247     }
 248
 249   for (i = 0; i < image->sizeY; i++)
 250     {
 251       for ( k = 0; k < image->sizeZ ; k++ )
 252         ImageGetRow(image, image->tmp[k+1], i, k);
 253       for (j = 0; j < image->sizeX; j++)
 254         for ( k = 1; k <= image->sizeZ ; k++ )
 255           *data++ = *(image->tmp[k] + j);
 256       data += remain;
 257     }
 258 }
 259
 260 static IMAGE *ImageLoad(char *fileName)
 261 {
 262   Image *image;
 263   IMAGE *final;
 264   int sx;
 265
 266   image = ImageOpen(fileName);
 267
 268   final = (IMAGE *)malloc(sizeof(IMAGE));
 269   if (final == NULL)
 270     {
 271       fprintf(stderr, "Out of memory!\n");
 272       exit(-1);
 273     }
 274   final->imagic = image->imagic;
 275   final->type = image->type;
 276   final->dim = image->dim;
 277   final->sizeX = image->sizeX;
 278   final->sizeY = image->sizeY;
 279   final->sizeZ = image->sizeZ;
 280
 281   /*
 282    * Round up so rows are long-word aligned
 283    */
 284   sx = ( (image->sizeX) * (image->sizeZ) + 3) >> 2;
 285
 286   final->data
 287     = (unsigned char *)malloc( sx * image->sizeY * sizeof(unsigned int));
 288
 289   if (final->data == NULL)
 290     {
 291       fprintf(stderr, "Out of memory!\n");
 292       exit(-1);
 293     }
 294
 295   ImageGetRawData(image, final->data);
 296   ImageClose(image);
 297   return final;
 298 }
 299
 300 /* Beginning of the "panel-code" */
 301 void fgPanelInit ( void ) {
 302     fgVIEW *v;
 303     string tpath;
 304     // char *root;
 305     int x, y, i;
 306
 307     v = &current_view;
 308
 309     Xzoom = (float)((float)(current_view.winWidth)/1024);
 310     Yzoom = (float)((float)(current_view.winHeight)/768);
 311
 312 pointer[1].XPos = 352;
 313 pointer[1].YPos = 156;
 314 pointer[1].radius = 4;
 315 pointer[1].length = 32;
 316 pointer[1].width = 3;
 317 pointer[1].angle = 30;
 318 pointer[1].value1 = 0;
 319 pointer[1].value2 = 3000;
 320 pointer[1].alpha1 = 0;
 321 pointer[1].alpha2 = 1080;
 322 pointer[1].variable = 1;
 323 pointer[1].teXpos = 59;
 324 pointer[1].texYpos = 199;
 325
 326 pointer[0].XPos = 352;
 327 pointer[0].YPos = 156;
 328 pointer[0].radius = 4;
 329 pointer[0].length = 25;
 330 pointer[0].width = 4;
 331 pointer[0].angle = 30;
 332 pointer[0].value1 = 0;
 333 pointer[0].value2 = 10000;
 334 pointer[0].alpha1 = 0;
 335 pointer[0].alpha2 = 360;
 336 pointer[0].variable = 1;
 337 pointer[0].teXpos = 59;
 338 pointer[0].texYpos = 199;
 339
 340 pointer[2].XPos = 352;
 341 pointer[2].YPos = 48;
 342 pointer[2].radius = 4;
 343 pointer[2].length = 30;
 344 pointer[2].width = 3;
 345 pointer[2].angle = 30;
 346 pointer[2].value1 = -3;
 347 pointer[2].value2 = 3;
 348 pointer[2].alpha1 = 100;
 349 pointer[2].alpha2 = 440;
 350 pointer[2].variable = 2;
 351 pointer[2].teXpos = 63;
 352 pointer[2].texYpos = 68;
 353
 354
 355 pointer[3].XPos = 451;
 356 pointer[3].YPos = 125;
 357 pointer[3].radius = 9;
 358 pointer[3].length = 20;
 359 pointer[3].width = 5;
 360 pointer[3].angle = 50;
 361 pointer[3].value1 = 0.0;
 362 pointer[3].value2 = 1.0;
 363 pointer[3].alpha1 = 280;
 364 pointer[3].alpha2 = 540;
 365 pointer[3].variable = 3;
 366 pointer[3].teXpos = 162;
 367 pointer[3].texYpos = 40;
 368
 369 for(i=0;i<NumPoint;i++){
 370 CreatePointer(&pointer[i]);
 371 }
 372 #ifdef GL_VERSION_1_1
 373     xglGenTextures(1, &panel_tex_id);
 374     xglBindTexture(GL_TEXTURE_2D, panel_tex_id);
 375 #elif GL_EXT_texture_object
 376     xglGenTexturesEXT(1, &panel_tex_id);
 377     xglBindTextureEXT(GL_TEXTURE_2D, panel_tex_id);
 378 #else
 379 #  error port me
 380 #endif
 381     xglMatrixMode(GL_PROJECTION);
 382     xglPushMatrix();
 383     xglLoadIdentity();
 384     xglViewport(0, 0, 640, 480);
 385     gluOrtho2D(0, 640, 0, 480);
 386     xglMatrixMode(GL_MODELVIEW);
 387     xglPushMatrix();
 388     xglLoadIdentity();
 389     xglClearStencil(0x0);
 390     xglClear(GL_STENCIL_BUFFER_BIT);
 391     xglEnable(GL_STENCIL_TEST);
 392     //xglPixelStorei(GL_UNPACK_ROW_LENGTH, 32);
 393     xglPixelStorei(GL_UNPACK_ALIGNMENT, 4);
 394     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 395     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 396     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 397     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 398
 399     /* load in the texture data */
 400     // current_options.get_fg_root(root);
 401     // tpath[0] = '\0';
 402     // strcat(tpath, "/home/fried/Flugsim/FlightGear-0.52");
 403     // strcat(tpath, "/Textures/");
 404     // strcat(tpath, "arthor.rgb");
 405
 406  //   if ( (imag = ImageLoad(tpath)) == NULL ){
 407  //     fgPrintf( FG_COCKPIT, FG_EXIT,
 408                  // "Error loading cockpit texture %s\n", tpath );
 409    // }
 410
 411     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 256);
 412     // tpath[0] = '\0';
 413     // strcat(tpath, "/home/fried/Flugsim/FlightGear-0.52");
 414     tpath = current_options.get_fg_root() + "/Textures/gauges.rgb";
 415     if((img = ImageLoad( (char *)tpath.c_str() ))==NULL){
 416     }
 417
 418     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 1024);
 419
 420     // tpath[0] = '\0';
 421     // strcat(tpath,"/home/fried/Flugsim/FlightGear-0.52" );
 422     tpath = current_options.get_fg_root() + "/Textures/Fullone.rgb";
 423
 424     if ((img2 = ImageLoad( (char *)tpath.c_str() ))==NULL ){
 425         }
 426
 427 for ( y = 0; y < 768; y++ ) {
 428         for ( x = 0; x < 1024; x++ ) {
 429             if ( (img2->data[(y+x*768)*3] == 0) && (img2->data[(y+x*768)*3+1] == 0) && (img2->data[(y+x*768)*3+2] == 0) ) {
 430                 stencil[x][y]=0x0;//0x0
 431             } else {
 432                 stencil[x][y]=0x1;//0x1
 433             }
 434         }
 435     }
 436     xglPixelZoom(Xzoom, Yzoom);
 437     xglPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 438     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 1024);
 439     xglStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
 440     xglRasterPos2i(0,0);
 441     xglDrawPixels(1024, 768, GL_STENCIL_INDEX, GL_UNSIGNED_INT, (GLvoid *)(stencil));
 442     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 1024);
 443     xglStencilFunc(GL_EQUAL, 0x1, 0x1);//0x1..
 444     xglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 445     xglRasterPos2i(0,0);
 446     xglPixelZoom(Xzoom, Yzoom);
 447    // xglDrawPixels(1024, 768, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid *)(img2->data));
 448     xglStencilFunc(GL_NOTEQUAL, 0x1, 0x1);
 449     xglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 450     xglEnable(GL_STENCIL_TEST);
 451     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 256);
 452     xglTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256, 256, 0, GL_RGB,
 453                   GL_UNSIGNED_BYTE, (GLvoid *)(img->data));
 454 // #ifdef GL_VERSION_1_1
 455    //  xglBindTexture(GL_TEXTURE_2D, panel_tex_id[1]);
 456 // #elif GL_EXT_texture_object
 457    //  xglBindTextureEXT(GL_TEXTURE_2D, panel_tex_id[1]);
 458 // #else
 459 // # error port me
 460 // #endif
 461    //  xglPixelStorei(GL_UNPACK_ROW_LENGTH, 256);
 462    //  xglTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid *)(img->data));
 463     xglMatrixMode(GL_MODELVIEW);
 464     xglPopMatrix();
 465 }
 466
 467 void fgPanelReInit( void){
 468     fgVIEW *v;
 469     fgOPTIONS *o;
 470     int x, y, i;
 471
 472     o = &current_options;
 473     v = &current_view;
 474
 475     Xzoom = (float)((float)(current_view.winWidth)/1024);
 476     Yzoom = (float)((float)(current_view.winHeight)/768);
 477
 478     xglMatrixMode(GL_PROJECTION);
 479     xglPushMatrix();
 480     xglLoadIdentity();
 481     xglViewport(0, 0, 640, 480);
 482     gluOrtho2D(0, 640, 0, 480);
 483     xglMatrixMode(GL_MODELVIEW);
 484     xglPushMatrix();
 485     xglLoadIdentity();
 486     xglClearStencil(0x0);
 487     xglClear(GL_STENCIL_BUFFER_BIT);
 488     xglEnable(GL_STENCIL_TEST);
 489     xglPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 490     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 491     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 492     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 493     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 494
 495     xglPixelZoom(Xzoom, Yzoom);
 496     xglPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 497     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 1024);
 498     xglStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
 499     xglRasterPos2i(0,0);
 500     xglDrawPixels(1024, 768, GL_STENCIL_INDEX, GL_UNSIGNED_INT, (GLvoid *)(stencil));
 501     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 1024);
 502     xglStencilFunc(GL_EQUAL, 0x1, 0x1);//0x1..
 503     xglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 504     xglRasterPos2i(0,0);
 505     xglPixelZoom(Xzoom, Yzoom);
 506     xglDrawPixels(1024, 768, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid *)(img2->data));
 507     xglStencilFunc(GL_NOTEQUAL, 0x1, 0x1);
 508     xglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 509     xglEnable(GL_STENCIL_TEST);
 510 }
 511
 512 void fgPanelUpdate ( void ) {
 513     fgVIEW *v;
 514     float alpha;
 515     double pitch;
 516     double roll;
 517     float alpharad;
 518     double speed;
 519     int i;
 520     var[0] = get_speed();
 521     var[1] = get_altitude();
 522     var[2] = get_aoa(); // A placeholder. It should be the vertical speed once.
 523     var[3] = get_throttleval();
 524     v = &current_view;
 525     xglMatrixMode(GL_PROJECTION);
 526     xglPushMatrix();
 527     xglLoadIdentity();
 528     gluOrtho2D(0, 640, 0, 480);
 529     xglMatrixMode(GL_MODELVIEW);
 530     xglPushMatrix();
 531     xglLoadIdentity();
 532     xglDisable(GL_DEPTH_TEST);
 533     xglDisable(GL_LIGHTING);
 534     xglStencilFunc(GL_EQUAL, 0x1, 0x1);
 535     xglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 536     // xglEnable(GL_STENCIL_TEST);
 537         xglEnable(GL_TEXTURE_2D);
 538 #ifdef GL_VERSION_1_1
 539     xglBindTexture(GL_TEXTURE_2D, panel_tex_id);
 540 #elif GL_EXT_texture_object
 541     xglBindTextureEXT(GL_TEXTURE_2D, panel_tex_id);
 542 #else
 543 #  error port me
 544 #endif
 545     xglMatrixMode(GL_MODELVIEW);
 546     xglPopMatrix();
 547     xglPushMatrix();
 548     for(i=0;i<NumPoint;i++){
 549     xglLoadIdentity();
 550     xglTranslatef(pointer[i].XPos, pointer[i].YPos, 0.0);
 551     xglRotatef(-pointer[i].hist, 0.0, 0.0, 1.0);
 552     ErasePointer(pointer[i]);
 553     xglLoadIdentity();
 554     }
 555     for(i=0;i<NumPoint;i++){
 556     pointer[i].hist = UpdatePointer( pointer[i]);
 557     xglPopMatrix();
 558     xglPushMatrix();
 559     }
 560     xglDisable(GL_TEXTURE_2D);
 561     xglPopMatrix();
 562     xglRasterPos2i(0, 0);
 563   //  horizont();  //Let's do this, when Michael's horizont image is ready
 564     xglEnable(GL_DEPTH_TEST);
 565     xglEnable(GL_STENCIL_TEST);
 566     xglStencilFunc(GL_NOTEQUAL, 0x1, 0x1);//1 1
 567     xglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 568     xglEnable(GL_LIGHTING);
 569     xglDisable(GL_TEXTURE_2D);
 570     xglDisable(GL_BLEND);
 571     xglDisable(GL_ALPHA_TEST);
 572     xglMatrixMode(GL_PROJECTION);
 573     xglPopMatrix();
 574     xglMatrixMode(GL_MODELVIEW);
 575     xglPopMatrix();
 576 }
 577
 578 void horizont(void){
 579     double pitch;
 580     double roll;
 581     pitch = get_pitch() * RAD_TO_DEG;
 582     roll = get_roll() * RAD_TO_DEG;
 583     xglEnable(GL_TEXTURE_2D);
 584     xglMatrixMode(GL_MODELVIEW);
 585     xglLoadIdentity();
 586    xglDisable(GL_STENCIL_TEST);
 587     xglStencilFunc(GL_NOTEQUAL, 0x1, 0x1);
 588     xglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 589     xglTranslatef(200, 130, 0);
 590     xglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
 591     #ifdef GL_VERSION_1_1
 592     xglBindTexture(GL_TEXTURE_2D, panel_tex_id);
 593     #elif GL_EXT_texture_object
 594     xglBindTextureEXT(GL_TEXTURE_2D, panel_tex_id);
 595     #else
 596     #  error port me
 597     #endif
 598     xglMatrixMode(GL_TEXTURE);
 599     xglLoadIdentity();
 600     //xglTranslatef(0.0, 0.33, 0.0);
 601     xglScalef(0.5, 0.5, 0.0);
 602     xglTranslatef(0.0, (pitch / 45), 0.0);
 603     xglTranslatef(1.0, 1.0, 0.0);
 604     xglRotatef(-roll, 0.0, 0.0, 1.0);
 605     xglTranslatef(-0.5, -0.5, 0.0);
 606     xglBegin(GL_POLYGON);
 607     xglTexCoord2f(0.0, 0.1); xglVertex2f(0.0, 0.0);
 608     xglTexCoord2f(1.0, 0.1); xglVertex2f(70.0, 0.0);
 609     xglTexCoord2f(1.0, 0.9); xglVertex2f(70.0, 70.0);
 610     xglTexCoord2f(0.0, 0.9); xglVertex2f(0.0, 70.0);
 611     xglEnd();
 612     xglPopMatrix();
 613     xglMatrixMode(GL_PROJECTION);
 614     xglPopMatrix();
 615     xglDisable(GL_TEXTURE_2D);
 616     xglEnable(GL_STENCIL_TEST);
 617     }
 618
 619 float UpdatePointer(Pointer pointer){
 620     double pitch;
 621     double roll;
 622     float alpharad;
 623     double speed;
 624     glEnableClientState(GL_VERTEX_ARRAY);
 625     glVertexPointer(2, GL_FLOAT, 0, pointer.vertices);
 626     alpha=((((float)((var[pointer.variable]) - (pointer.value1)))/(pointer.value2 - pointer.value1))*(pointer.alpha2 - pointer.alpha1) + pointer.alpha1);
 627         if (alpha < pointer.alpha1)
 628                 alpha = pointer.alpha1;
 629         if (alpha > pointer.alpha2)
 630                 alpha = pointer.alpha2;
 631     xglMatrixMode(GL_MODELVIEW);
 632     xglPushMatrix();
 633     xglLoadIdentity();
 634     xglDisable(GL_TEXTURE_2D);
 635     xglTranslatef(pointer.XPos, pointer.YPos, 0);
 636     xglRotatef(-alpha, 0.0, 0.0, 1.0);
 637     xglColor4f(1.0, 1.0, 1.0, 1.0);
 638     glDrawArrays(GL_POLYGON, 0, 10);
 639     return alpha;
 640     xglEnable(GL_TEXTURE_2D);
 641     glDisableClientState(GL_VERTEX_ARRAY);
 642 }
 643
 644 void ErasePointer(Pointer pointer){
 645 int i, j;
 646 float a;
 647 float ififth;
 648
 649 xglEnable(GL_TEXTURE_2D);
 650 xglEnable(GL_TEXTURE_GEN_S);
 651 xglEnable(GL_TEXTURE_GEN_T);
 652 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
 653 //glTexGenfv(GL_S, GL_EYE_PLANE, currentCoeff);
 654 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
 655 //glTexGenfv(GL_T, GL_EYE_PLANE, currentCoeff);
 656 xglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 657 xglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 658 xglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
 659 xglMatrixMode(GL_TEXTURE);
 660 xglLoadIdentity();
 661
 662     #ifdef GL_VERSION_1_1
 663     xglBindTexture(GL_TEXTURE_2D, panel_tex_id);
 664     #elif GL_EXT_texture_object
 665     xglBindTextureEXT(GL_TEXTURE_2D, panel_tex_id);
 666     #else
 667     #  error port me
 668     #endif
 669
 670 xglMatrixMode(GL_TEXTURE);
 671 xglLoadIdentity();
 672 xglTranslatef(-((float)(((float)(pointer.XPos)/0.625)/256)) /* - 0.057143*/, -((float)(((float)(pointer.YPos)/0.625)/256)), 0.0);
 673 xglTranslatef(pointer.teXpos/256 , pointer.texYpos/256, 0.0);
 674 xglScalef(0.00625, 0.00625, 1.0);
 675 //xglTranslatef(-pointer.teXpos , -pointer.texYpos, 0.0);
 676
 677         xglBegin(GL_POLYGON);
 678 xglVertex2f(pointer.vertices[0], pointer.vertices[1]);
 679 xglVertex2f(pointer.vertices[2], pointer.vertices[3]);
 680 xglVertex2f(pointer.vertices[4], pointer.vertices[5]);
 681 xglVertex2f(pointer.vertices[16], pointer.vertices[17]);
 682 xglVertex2f(pointer.vertices[18], pointer.vertices[19]);
 683         xglEnd();
 684
 685         xglLoadIdentity();
 686         xglMatrixMode(GL_MODELVIEW);
 687         xglPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
 688         xglPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
 689         xglDisable(GL_TEXTURE_2D);
 690         xglDisable(GL_TEXTURE_GEN_S);
 691         xglDisable(GL_TEXTURE_GEN_T);
 692
 693 }
 694
 695 void CreatePointer(Pointer *pointer){
 696 int i;
 697 float alpha;
 698 float alphastep;
 699 float r = pointer->radius;
 700 float angle = pointer->angle;
 701 float length = pointer->length;
 702 float width = pointer->width;
 703
 704 pointer->vertices[0] = 0;
 705 pointer->vertices[1] = length;
 706 pointer->vertices[2] = -(width/2);
 707 pointer->vertices[3] = length - ((width/2)/(tan(angle*DEG_TO_RAD/2)));
 708 pointer->vertices[4] = -(width/2);
 709 pointer->vertices[5] = cos(asin((width/2)/r))*r;
 710 alphastep = (asin((width/2)/r)+asin((width/2)/r))/5;
 711 alpha = asin(-(width/2)/r);
 712 for(i=0;i<5;i++){
 713 alpha += alphastep;
 714 pointer->vertices[(i*2)+6] = sin(alpha)*r;
 715 }
 716 alpha = asin(-(width/2)/r);
 717 for(i=0;i<5;i++){
 718 alpha +=alphastep;
 719 pointer->vertices[(i*2)+7]= cos(alpha)*r;
 720 }
 721 pointer->vertices[16] = - pointer->vertices[4];
 722 pointer->vertices[17] = pointer->vertices[5];
 723 pointer->vertices[18] = - pointer->vertices[2];
 724 pointer->vertices[19] = pointer->vertices[3];
 725 }
 726
 727
 728 /* $Log$
 729 /* Revision 1.8  1998/10/16 23:27:37  curt
 730 /* C++-ifying.
 731 /*
 732  * Revision 1.7  1998/08/31 20:45:31  curt
 733  * Tweaks from Friedemann.
 734  *
 735  * Revision 1.6  1998/08/28 18:14:40  curt
 736  * Added new cockpit code from Friedemann Reinhard
 737  * <mpt218@faupt212.physik.uni-erlangen.de>
 738  *
 739  * Revision 1.1  1998/06/27 16:47:54  curt
 740  * Incorporated Friedemann Reinhard's <mpt218@faupt212.physik.uni-erlangen.de>
 741  * first pass at an isntrument panel.
 742  *
 743  */