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.h>
  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[4];
  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[0]);
 374     xglGenTextures(1, &panel_tex_id[1]);
 375     xglBindTexture(GL_TEXTURE_2D, panel_tex_id[0]);
 376 #elif GL_EXT_texture_object
 377     xglGenTexturesEXT(1, &panel_tex_id[0]);
 378     xglGenTexturesEXT(1, &panel_tex_id[1]);
 379     xglBindTextureEXT(GL_TEXTURE_2D, panel_tex_id[0]);
 380 #else
 381 #  error port me
 382 #endif
 383     xglMatrixMode(GL_PROJECTION);
 384     xglPushMatrix();
 385     xglLoadIdentity();
 386     xglViewport(0, 0, 640, 480);
 387     gluOrtho2D(0, 640, 0, 480);
 388     xglMatrixMode(GL_MODELVIEW);
 389     xglPushMatrix();
 390     xglLoadIdentity();
 391     xglClearStencil(0x0);
 392     xglClear(GL_STENCIL_BUFFER_BIT);
 393     xglEnable(GL_STENCIL_TEST);
 394     //xglPixelStorei(GL_UNPACK_ROW_LENGTH, 32);
 395     xglPixelStorei(GL_UNPACK_ALIGNMENT, 4);
 396     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 397     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 398     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 399     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 400
 401     /* load in the texture data */
 402     // current_options.get_fg_root(root);
 403     // tpath[0] = '\0';
 404     // strcat(tpath, "/home/fried/Flugsim/FlightGear-0.52");
 405     // strcat(tpath, "/Textures/");
 406     // strcat(tpath, "arthor.rgb");
 407
 408  //   if ( (imag = ImageLoad(tpath)) == NULL ){
 409  //     fgPrintf( FG_COCKPIT, FG_EXIT,
 410                  // "Error loading cockpit texture %s\n", tpath );
 411    // }
 412
 413     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 256);
 414     // tpath[0] = '\0';
 415     // strcat(tpath, "/home/fried/Flugsim/FlightGear-0.52");
 416     tpath = current_options.get_fg_root() + "/Textures/gauges.rgb";
 417     if((img = ImageLoad( (char *)tpath.c_str() ))==NULL){
 418     }
 419
 420     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 1024);
 421
 422     // tpath[0] = '\0';
 423     // strcat(tpath,"/home/fried/Flugsim/FlightGear-0.52" );
 424     tpath = current_options.get_fg_root() + "/Textures/Fullone.rgb";
 425
 426     if ((img2 = ImageLoad( (char *)tpath.c_str() ))==NULL ){
 427         }
 428
 429 for ( y = 0; y < 768; y++ ) {
 430         for ( x = 0; x < 1024; x++ ) {
 431             if ( (img2->data[(y+x*768)*3] == 0) && (img2->data[(y+x*768)*3+1] == 0) && (img2->data[(y+x*768)*3+2] == 0) ) {
 432                 stencil[x][y]=0x0;//0x0
 433             } else {
 434                 stencil[x][y]=0x1;//0x1
 435             }
 436         }
 437     }
 438     xglPixelZoom(Xzoom, Yzoom);
 439     xglPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 440     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 1024);
 441     xglStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
 442     xglRasterPos2i(0,0);
 443     xglDrawPixels(1024, 768, GL_STENCIL_INDEX, GL_UNSIGNED_INT, (GLvoid *)(stencil));
 444     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 1024);
 445     xglStencilFunc(GL_EQUAL, 0x1, 0x1);//0x1..
 446     xglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 447     xglRasterPos2i(0,0);
 448     xglPixelZoom(Xzoom, Yzoom);
 449    // xglDrawPixels(1024, 768, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid *)(img2->data));
 450     xglStencilFunc(GL_NOTEQUAL, 0x1, 0x1);
 451     xglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 452     xglEnable(GL_STENCIL_TEST);
 453     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 256);
 454     xglTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256, 256, 0, GL_RGB,
 455                   GL_UNSIGNED_BYTE, (GLvoid *)(img->data));
 456 // #ifdef GL_VERSION_1_1
 457    //  xglBindTexture(GL_TEXTURE_2D, panel_tex_id[1]);
 458 // #elif GL_EXT_texture_object
 459    //  xglBindTextureEXT(GL_TEXTURE_2D, panel_tex_id[1]);
 460 // #else
 461 // # error port me
 462 // #endif
 463    //  xglPixelStorei(GL_UNPACK_ROW_LENGTH, 256);
 464    //  xglTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 256, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid *)(img->data));
 465     xglMatrixMode(GL_MODELVIEW);
 466     xglPopMatrix();
 467 }
 468
 469 void fgPanelReInit( void){
 470     fgVIEW *v;
 471     fgOPTIONS *o;
 472     int x, y, i;
 473
 474     o = &current_options;
 475     v = &current_view;
 476
 477     Xzoom = (float)((float)(current_view.winWidth)/1024);
 478     Yzoom = (float)((float)(current_view.winHeight)/768);
 479
 480     xglMatrixMode(GL_PROJECTION);
 481     xglPushMatrix();
 482     xglLoadIdentity();
 483     xglViewport(0, 0, 640, 480);
 484     gluOrtho2D(0, 640, 0, 480);
 485     xglMatrixMode(GL_MODELVIEW);
 486     xglPushMatrix();
 487     xglLoadIdentity();
 488     xglClearStencil(0x0);
 489     xglClear(GL_STENCIL_BUFFER_BIT);
 490     xglEnable(GL_STENCIL_TEST);
 491     xglPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 492     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 493     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 494     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 495     xglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 496
 497     xglPixelZoom(Xzoom, Yzoom);
 498     xglPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 499     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 1024);
 500     xglStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
 501     xglRasterPos2i(0,0);
 502     xglDrawPixels(1024, 768, GL_STENCIL_INDEX, GL_UNSIGNED_INT, (GLvoid *)(stencil));
 503     xglPixelStorei(GL_UNPACK_ROW_LENGTH, 1024);
 504     xglStencilFunc(GL_EQUAL, 0x1, 0x1);//0x1..
 505     xglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 506     xglRasterPos2i(0,0);
 507     xglPixelZoom(Xzoom, Yzoom);
 508     xglDrawPixels(1024, 768, GL_RGB, GL_UNSIGNED_BYTE, (GLvoid *)(img2->data));
 509     xglStencilFunc(GL_NOTEQUAL, 0x1, 0x1);
 510     xglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 511     xglEnable(GL_STENCIL_TEST);
 512 }
 513
 514 void fgPanelUpdate ( void ) {
 515     fgVIEW *v;
 516     float alpha;
 517     double pitch;
 518     double roll;
 519     float alpharad;
 520     double speed;
 521     int i;
 522     var[0] = get_speed();
 523     var[1] = get_altitude();
 524     var[2] = get_aoa(); // A placeholder. It should be the vertical speed once.
 525     var[3] = get_throttleval();
 526     v = &current_view;
 527     xglMatrixMode(GL_PROJECTION);
 528     xglPushMatrix();
 529     xglLoadIdentity();
 530     gluOrtho2D(0, 640, 0, 480);
 531     xglMatrixMode(GL_MODELVIEW);
 532     xglPushMatrix();
 533     xglLoadIdentity();
 534     xglDisable(GL_DEPTH_TEST);
 535     xglDisable(GL_LIGHTING);
 536     xglStencilFunc(GL_EQUAL, 0x1, 0x1);
 537     xglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 538     // xglEnable(GL_STENCIL_TEST);
 539         xglEnable(GL_TEXTURE_2D);
 540 #ifdef GL_VERSION_1_1
 541     xglBindTexture(GL_TEXTURE_2D, panel_tex_id[0]);
 542 #elif GL_EXT_texture_object
 543     xglBindTextureEXT(GL_TEXTURE_2D, panel_tex_id[0]);
 544 #else
 545 #  error port me
 546 #endif
 547     xglMatrixMode(GL_MODELVIEW);
 548     xglPopMatrix();
 549     xglPushMatrix();
 550     for(i=0;i<NumPoint;i++){
 551     xglLoadIdentity();
 552     xglTranslatef(pointer[i].XPos, pointer[i].YPos, 0.0);
 553     xglRotatef(-pointer[i].hist, 0.0, 0.0, 1.0);
 554     ErasePointer(pointer[i]);
 555     xglLoadIdentity();
 556     }
 557     for(i=0;i<NumPoint;i++){
 558     pointer[i].hist = UpdatePointer( pointer[i]);
 559     xglPopMatrix();
 560     xglPushMatrix();
 561     }
 562     xglDisable(GL_TEXTURE_2D);
 563     xglPopMatrix();
 564     xglRasterPos2i(0, 0);
 565   //  horizont();  //Let's do this, when Michael's horizont image is ready
 566     xglEnable(GL_DEPTH_TEST);
 567     xglEnable(GL_STENCIL_TEST);
 568     xglStencilFunc(GL_NOTEQUAL, 0x1, 0x1);//1 1
 569     xglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 570     xglEnable(GL_LIGHTING);
 571     xglDisable(GL_TEXTURE_2D);
 572     xglDisable(GL_BLEND);
 573     xglDisable(GL_ALPHA_TEST);
 574     xglMatrixMode(GL_PROJECTION);
 575     xglPopMatrix();
 576     xglMatrixMode(GL_MODELVIEW);
 577     xglPopMatrix();
 578 }
 579
 580 void horizont(void){
 581     double pitch;
 582     double roll;
 583     pitch = get_pitch() * RAD_TO_DEG;
 584     roll = get_roll() * RAD_TO_DEG;
 585     xglEnable(GL_TEXTURE_2D);
 586     xglMatrixMode(GL_MODELVIEW);
 587     xglLoadIdentity();
 588    xglDisable(GL_STENCIL_TEST);
 589     xglStencilFunc(GL_NOTEQUAL, 0x1, 0x1);
 590     xglStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 591     xglTranslatef(200, 130, 0);
 592     xglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
 593     #ifdef GL_VERSION_1_1
 594     xglBindTexture(GL_TEXTURE_2D, panel_tex_id[0]);
 595     #elif GL_EXT_texture_object
 596     xglBindTextureEXT(GL_TEXTURE_2D, panel_tex_id[0]);
 597     #else
 598     #  error port me
 599     #endif
 600     xglMatrixMode(GL_TEXTURE);
 601     xglLoadIdentity();
 602     //xglTranslatef(0.0, 0.33, 0.0);
 603     xglScalef(0.5, 0.5, 0.0);
 604     xglTranslatef(0.0, (pitch / 45), 0.0);
 605     xglTranslatef(1.0, 1.0, 0.0);
 606     xglRotatef(-roll, 0.0, 0.0, 1.0);
 607     xglTranslatef(-0.5, -0.5, 0.0);
 608     xglBegin(GL_POLYGON);
 609     xglTexCoord2f(0.0, 0.1); xglVertex2f(0.0, 0.0);
 610     xglTexCoord2f(1.0, 0.1); xglVertex2f(70.0, 0.0);
 611     xglTexCoord2f(1.0, 0.9); xglVertex2f(70.0, 70.0);
 612     xglTexCoord2f(0.0, 0.9); xglVertex2f(0.0, 70.0);
 613     xglEnd();
 614     xglPopMatrix();
 615     xglMatrixMode(GL_PROJECTION);
 616     xglPopMatrix();
 617     xglDisable(GL_TEXTURE_2D);
 618     xglEnable(GL_STENCIL_TEST);
 619     }
 620
 621 float UpdatePointer(Pointer pointer){
 622     double pitch;
 623     double roll;
 624     float alpharad;
 625     double speed;
 626     glEnableClientState(GL_VERTEX_ARRAY);
 627     glVertexPointer(2, GL_FLOAT, 0, pointer.vertices);
 628     alpha=((((float)((var[pointer.variable]) - (pointer.value1)))/(pointer.value2 - pointer.value1))*(pointer.alpha2 - pointer.alpha1) + pointer.alpha1);
 629         if (alpha < pointer.alpha1)
 630                 alpha = pointer.alpha1;
 631         if (alpha > pointer.alpha2)
 632                 alpha = pointer.alpha2;
 633     xglMatrixMode(GL_MODELVIEW);
 634     xglPushMatrix();
 635     xglLoadIdentity();
 636     xglDisable(GL_TEXTURE_2D);
 637     xglTranslatef(pointer.XPos, pointer.YPos, 0);
 638     xglRotatef(-alpha, 0.0, 0.0, 1.0);
 639     xglColor4f(1.0, 1.0, 1.0, 1.0);
 640     glDrawArrays(GL_POLYGON, 0, 10);
 641     return alpha;
 642     xglEnable(GL_TEXTURE_2D);
 643     glDisableClientState(GL_VERTEX_ARRAY);
 644 }
 645
 646 void ErasePointer(Pointer pointer){
 647 int i, j;
 648 float a;
 649 float ififth;
 650
 651 xglEnable(GL_TEXTURE_2D);
 652 xglEnable(GL_TEXTURE_GEN_S);
 653 xglEnable(GL_TEXTURE_GEN_T);
 654 glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
 655 //glTexGenfv(GL_S, GL_EYE_PLANE, currentCoeff);
 656 glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
 657 //glTexGenfv(GL_T, GL_EYE_PLANE, currentCoeff);
 658 xglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 659 xglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 660 xglTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
 661 xglMatrixMode(GL_TEXTURE);
 662 xglLoadIdentity();
 663
 664     #ifdef GL_VERSION_1_1
 665     xglBindTexture(GL_TEXTURE_2D, panel_tex_id[0]);
 666     #elif GL_EXT_texture_object
 667     xglBindTextureEXT(GL_TEXTURE_2D, panel_tex_id[0]);
 668     #else
 669     #  error port me
 670     #endif
 671
 672 xglMatrixMode(GL_TEXTURE);
 673 xglLoadIdentity();
 674 xglTranslatef(-((float)(((float)(pointer.XPos)/0.625)/256)) /* - 0.057143*/, -((float)(((float)(pointer.YPos)/0.625)/256)), 0.0);
 675 xglTranslatef(pointer.teXpos/256 , pointer.texYpos/256, 0.0);
 676 xglScalef(0.00625, 0.00625, 1.0);
 677 //xglTranslatef(-pointer.teXpos , -pointer.texYpos, 0.0);
 678
 679         xglBegin(GL_POLYGON);
 680 xglVertex2f(pointer.vertices[0], pointer.vertices[1]);
 681 xglVertex2f(pointer.vertices[2], pointer.vertices[3]);
 682 xglVertex2f(pointer.vertices[4], pointer.vertices[5]);
 683 xglVertex2f(pointer.vertices[16], pointer.vertices[17]);
 684 xglVertex2f(pointer.vertices[18], pointer.vertices[19]);
 685         xglEnd();
 686
 687         xglLoadIdentity();
 688         xglMatrixMode(GL_MODELVIEW);
 689         xglPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
 690         xglPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
 691         xglDisable(GL_TEXTURE_2D);
 692         xglDisable(GL_TEXTURE_GEN_S);
 693         xglDisable(GL_TEXTURE_GEN_T);
 694
 695 }
 696
 697 void CreatePointer(Pointer *pointer){
 698 int i;
 699 float alpha;
 700 float alphastep;
 701 float r = pointer->radius;
 702 float angle = pointer->angle;
 703 float length = pointer->length;
 704 float width = pointer->width;
 705
 706 pointer->vertices[0] = 0;
 707 pointer->vertices[1] = length;
 708 pointer->vertices[2] = -(width/2);
 709 pointer->vertices[3] = length - ((width/2)/(tan(angle*DEG_TO_RAD/2)));
 710 pointer->vertices[4] = -(width/2);
 711 pointer->vertices[5] = cos(asin((width/2)/r))*r;
 712 alphastep = (asin((width/2)/r)+asin((width/2)/r))/5;
 713 alpha = asin(-(width/2)/r);
 714 for(i=0;i<5;i++){
 715 alpha += alphastep;
 716 pointer->vertices[(i*2)+6] = sin(alpha)*r;
 717 }
 718 alpha = asin(-(width/2)/r);
 719 for(i=0;i<5;i++){
 720 alpha +=alphastep;
 721 pointer->vertices[(i*2)+7]= cos(alpha)*r;
 722 }
 723 pointer->vertices[16] = - pointer->vertices[4];
 724 pointer->vertices[17] = pointer->vertices[5];
 725 pointer->vertices[18] = - pointer->vertices[2];
 726 pointer->vertices[19] = pointer->vertices[3];
 727 }
 728
 729
 730 /* $Log$
 731 /* Revision 1.6  1998/08/28 18:14:40  curt
 732 /* Added new cockpit code from Friedemann Reinhard
 733 /* <mpt218@faupt212.physik.uni-erlangen.de>
 734 /*
 735  * Revision 1.1  1998/06/27 16:47:54  curt
 736  * Incorporated Friedemann Reinhard's <mpt218@faupt212.physik.uni-erlangen.de>
 737  * first pass at an isntrument panel.
 738  *
 739  */
 740
 741
 742