home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / demos / GL / flight / shadow.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  7.6 KB  |  430 lines
  1. /*
  2.  * Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17.  
  18. /*
  19.  *  flight/shadow.c $Revision: 1.20 $
  20.  */
  21.  
  22. #include "flight.h"
  23. #include "light.h"
  24. #include <stdio.h>
  25.  
  26. int newtarget = TRUE;
  27. int shadow_target;
  28.  
  29.  
  30. /*
  31.  *  start up code specific to flight
  32.  */
  33. shadow_start()
  34. {
  35.     int itemp;
  36.  
  37.     view_switch = PLANE_VIEW;            /* view from plane    */
  38.     plane_fov = tower_fov = 400;
  39.     reset_fov(400);
  40.     view_angle = 0;
  41.     debug = timeit = FALSE;
  42.  
  43.     read_objects(FALSE);
  44.  
  45.     /*
  46.      *  read network buffers
  47.      */
  48.     for (itemp=0; itemp<16; itemp++)
  49.     get_indata(1);
  50.     qenter(REDRAW, 0);
  51.     qenter(KEYBD, 't');
  52.  
  53.     tick_counter = int_tps;
  54.  
  55.     restart = 0;
  56. }
  57.  
  58.  
  59. /*
  60.  *  main loop for shadow
  61.  */
  62. shadow_loop()
  63. {
  64.     unsigned char frame_count = 0;    /* count of frames */
  65.  
  66.     while (!restart)
  67.     {
  68.     viewport(0, xmaxwindow, 0, ymaxwindow);
  69.     zclear();
  70.  
  71.     tick_counter--;
  72.  
  73.     /*
  74.      *  read all queue entries
  75.      */
  76.     shadow_read_queue();
  77.  
  78.     /*
  79.      *  update time
  80.      */
  81.     if (!frame_count)
  82.         update_ftime();        /* every 256 frames */
  83.     frame_count++;
  84.  
  85.     /*
  86.      *  read network packets
  87.      */
  88.     shadow_read_network();
  89.  
  90.     /*
  91.      *  draw the out the window scene
  92.      */
  93.     draw_scene();
  94.  
  95.     draw_messages();        /* display any network messages    */
  96.  
  97.     ortho2(-0.5, xmaxscreen+0.5, -0.5, ymaxscreen+.5);
  98.     draw_report();
  99.  
  100.     swapbuffers();
  101.  
  102.     if (tick_counter == 0)        /* only update them every second */
  103.     {
  104.         time_end = times(&tms_end_buf);
  105.         check_time();
  106.         time_start = times(&tms_start_buf);
  107.         tick_counter = int_tps;        /* reset tick counter */
  108.     }
  109.     }
  110. }
  111.  
  112.  
  113.  
  114. shadow_read_queue()
  115. {
  116.     short type, val;
  117.  
  118.     while (qtest())
  119.     {
  120.     switch(type = qread(&val))
  121.     {
  122.         case REDRAW:
  123.         break;
  124.         case WINQUIT:
  125.         end_of_program();
  126.         break;
  127.         case KEYBD:
  128.         switch(val)
  129.         {
  130.             case 27:
  131.             end_of_program();
  132.             case 'z':
  133.             case 'x':
  134.             if (view_switch == TOWER_VIEW)
  135.             {
  136.                 if (val == 'x')
  137.                 {
  138.                 if (tower_fov > 30)
  139.                     tower_fov -= 25;
  140.                 }
  141.                 else
  142.                 {
  143.                 if (tower_fov < 600)
  144.                     tower_fov += 25;
  145.                 }
  146.                 reset_fov(tower_fov);
  147.             }
  148.             else if (wingman_view)
  149.             {
  150.                 if (val == 'x')
  151.                 {
  152.                 if (wmfollow > 0) wmfollow--;
  153.                 }
  154.                 else
  155.                 if (wmfollow < 9) wmfollow++;
  156.             }
  157.             break;
  158.             case 'd':
  159.             if (view_switch == PLANE_VIEW)
  160.             {
  161.                 view_switch = TOWER_VIEW;
  162.                 reset_fov(tower_fov);
  163.             }
  164.             else if (view_switch == TOWER_VIEW)
  165.             {
  166.                 view_switch = PLANE_VIEW;
  167.                 reset_fov(plane_fov);
  168.             }
  169.             break;
  170.             case 'W':
  171.             wingman_view = !wingman_view;
  172.             break;
  173.             case 't':    /* get next plane in array */
  174.             {
  175.                 static int index = -1;
  176.                 if (planes[++index]->alive <= 0)
  177.                 index = 1;
  178.                 shadow_target = PLANE_ID(planes[index]);
  179.                 newtarget = TRUE;
  180.             }
  181.             break;
  182.             case 'm':
  183.             set_fog_density(-1);
  184.             break;
  185.             case 'M':
  186.             set_fog_density(1);
  187.             break;
  188.             case 'n':
  189.             set_ftime(ftime + 5);
  190.             break;
  191.             case 'N':
  192.             set_ftime(ftime - 5);
  193.             break;
  194.             case 'h':
  195.             show_help = !show_help;
  196.             break;
  197.             case 'r':
  198.             restart = 1;
  199.             case 'p':
  200.             wait_for_input();
  201.             break;
  202.             case 'T':
  203.             threat_mode = !threat_mode;
  204.             break;
  205.             case 'I':
  206.             stopit();
  207.             break;
  208.             case '?':
  209.             timeit = !timeit;
  210.             tick_counter = TPS;
  211.             break;
  212. #ifdef DEBUG
  213.             case '-':
  214.             case '_':
  215.             rewind_if(-10);
  216.             break;
  217.             case '+':
  218.             case '=':
  219.             rewind_if(10);
  220.             break;
  221.             case '0':
  222.             case '1':
  223.             case '2':
  224.             case '3':
  225.             case '4':
  226.             case '5':
  227.             case '6':
  228.             case '7':
  229.             case '8':
  230.             case '9':
  231.             debug ^= 1 << (val-'0');
  232.             break;
  233. #endif
  234.             default:
  235.             break;
  236.         }
  237.         break;
  238.         case F1KEY:     /* toggle fog */
  239.         if (val)
  240.             fogit = !fogit && (getgdesc(GD_FOGVERTEX) > 0);
  241.         break;
  242.         case F2KEY:     /* toggle texturing */
  243.         if (val)
  244.             texit = !texit && (getgdesc(GD_TEXTURE) > 0);
  245.         break;
  246.         case LEFTARROWKEY:
  247.         if (val && view_switch == PLANE_VIEW)
  248.         {
  249.             view_angle -= 50;
  250.             if (view_angle <= -1800)
  251.             view_angle += 3600;
  252.         }
  253.         break;
  254.         case RIGHTARROWKEY:
  255.         if (val && view_switch == PLANE_VIEW)
  256.         {
  257.             view_angle += 50;
  258.             if (view_angle > 1800)
  259.             view_angle -= 3600;
  260.         }
  261.         break;
  262.         case UPARROWKEY:
  263.         if (val && view_switch == PLANE_VIEW)
  264.             view_angle = 0;
  265.         break;
  266.         case DOWNARROWKEY:
  267.         if (val && view_switch == PLANE_VIEW)
  268.             view_angle = 1800;
  269.         break;
  270.         case PAUSEKEY:
  271.         if (val)
  272.             read_pause = !read_pause;
  273.         break;
  274.         case HOMEKEY:
  275.         if (val)
  276.             read_reset = TRUE;
  277.         break;
  278.         case F9KEY:
  279.         if (val)
  280.             read_speed = 0.2;
  281.         break;
  282.         case F10KEY:
  283.         if (val)
  284.             read_speed = 1.0;
  285.         break;
  286.         case F11KEY:
  287.         if (val)
  288.             read_speed = 5.0;
  289.         break;
  290.         case F12KEY:
  291.         if (val)
  292.             read_backwards = !read_backwards;
  293.         break;
  294.         default:
  295.         break;
  296.     }
  297.     }
  298. }
  299.  
  300.  
  301. shadow_read_network()
  302. {
  303.     Plane pp = planes[0];
  304.  
  305.     /*
  306.      *  read network packets
  307.      */
  308.     get_indata(1);
  309.  
  310.     /*
  311.      *  set pointers to incoming data buffers
  312.      */
  313.     pp = lookup_plane(shadow_target);
  314.     if (pp == NULL)            /* if its not there, use first    */
  315.     {
  316.     shadow_target = PLANE_ID(planes[0]);
  317.     pp = lookup_plane(shadow_target);
  318.     }
  319.     if (pp == NULL)            /* if its still not there    */
  320.     {
  321.     pp = planes[0];
  322.     strcpy(pp->myname, "no one");
  323.     pp->x = START_X;
  324.     pp->y = START_Y;
  325.     pp->z = START_Z;
  326.     pp->elevation = 0;
  327.     pp->twist = 0;
  328.     pp->azimuth = START_AZIMUTH;
  329.     pp->type = F15;
  330.     }
  331.     else                /* swap pp and planes[0]    */
  332.     {
  333.     int i;
  334.     Plane p, *ppp, pf;
  335.     Plane_hist ph;
  336.  
  337.     i = 0;
  338.     FOR_EACH_PLANE (p, ppp)
  339.     {
  340.         if (p == pp)
  341.            break;
  342.         i++;
  343.     }
  344.     planes[i] = planes[0];
  345.     planes[0] = pp;
  346.     ph = plane_hists[i];
  347.     plane_hists[i] = plane_hists[0];
  348.     plane_hists[0] = ph;
  349.     if (inf)
  350.     {
  351.         pf = plane_futures[i];
  352.         plane_futures[i] = plane_futures[0];
  353.         plane_futures[0] = pf;
  354.     }
  355.     }
  356.  
  357.     if (newtarget)
  358.     {
  359.     /*
  360.      *  init wingman info
  361.      */
  362.     for(wmspos = 0; wmspos < 10; wmspos++)
  363.     {
  364.         wm_x[wmspos] = pp->x;
  365.         wm_y[wmspos] = pp->y;
  366.         wm_z[wmspos] = pp->z;
  367.         wm_twist[wmspos] = pp->twist;
  368.         wm_elevation[wmspos] = pp->elevation;
  369.         wm_azimuth[wmspos] = pp->azimuth;
  370.     }
  371.     wmpos = wmspos - wmfollow;
  372.     if (wmpos < 0)
  373.         wmpos += 10;
  374.     wmspos = 0;
  375.     newtarget = FALSE;
  376.  
  377.     /*
  378.      *  init view position
  379.      */
  380.     switch(pp->type)
  381.     {
  382.         case C150:
  383.         pilot_eye[Y] = 5.0;
  384.         pilot_eye[Z] = -0.0;
  385.         break;
  386.         case B747:
  387.         pilot_eye[Y] = 30.0;
  388.         pilot_eye[Z] = -92.0;
  389.         break;
  390.         case F15:
  391.         pilot_eye[Y] = 4.8;
  392.         pilot_eye[Z] = -26.0;
  393.         break;
  394.         case F16:
  395.         pilot_eye[Y] = 3.5;
  396.         pilot_eye[Z] = -13.0;
  397.         break;
  398.         case F18:
  399.         pilot_eye[Y] = 4.3;
  400.         pilot_eye[Z] = -13.5;
  401.         break;
  402.         case P38:
  403.         pilot_eye[Y] = 2.3;
  404.         pilot_eye[Z] = -3.0;
  405.         break;
  406.         case F14:
  407.         pilot_eye[Y] = 4.8;
  408.         pilot_eye[Z] = -26.0;
  409.         break;
  410.         case B727:
  411.         pilot_eye[Y] = 2.0;
  412.         pilot_eye[Z] = -66.0;
  413.         break;
  414.     }
  415.     }
  416.     else
  417.     {
  418.     wm_x[wmspos] = pp->x;
  419.     wm_y[wmspos] = pp->y;
  420.     wm_z[wmspos] = pp->z;
  421.     wm_twist[wmspos] = pp->twist;
  422.     wm_elevation[wmspos] = pp->elevation;
  423.     wm_azimuth[wmspos] = pp->azimuth;
  424.     wmpos = wmspos - wmfollow;
  425.     if (wmpos < 0)
  426.         wmpos += 10;
  427.     wmspos = (wmspos+1) % 10;
  428.     }
  429. }
  430.