home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / demos / GL / flight / land2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  10.5 KB  |  482 lines
  1. /*
  2.  * Copyright 1984-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/land2.c $Revision: 1.16 $
  20.  *
  21.  *  contains world definitions
  22.  */
  23.  
  24. #include "flight.h"
  25. #include "light.h"
  26. #include <stdio.h>
  27.  
  28.  
  29. draw_grid()
  30. {
  31.     int x;
  32.     static float nup[] = {0.0, 0.0, 1.0};
  33.  
  34.     if (in_cmode)
  35.     color(ci_table[C_DIRT]);
  36.     else
  37.     setmaterial(MAT_DIRT);
  38.  
  39.     pushmatrix();
  40.     rotate(-900, 'x');                    /* z = -y */
  41.     n3f(nup);
  42.  
  43.     for (x = -55000; x <= 55000; x += 10000)        /* grid lines */
  44.     {
  45.     move2i(x, -50000);
  46.     draw2i(x, 50000);
  47.     }
  48.     for (x = -50000; x <= 50000; x += 10000)
  49.     {
  50.     move2i(-55000, x);
  51.     draw2i(55000, x);
  52.     }
  53.  
  54.     rectfs(6000, -14000, 6020, -14030);            /* threats */
  55.     rectfi(-20000, -15000, -20040, -15020);
  56.     rectfi(3000, -34000, 3010, -34030);
  57.  
  58.     popmatrix();
  59. }
  60.  
  61. /*
  62.  *  setup_world setsup a
  63.  */
  64. setup_world()
  65. {
  66.     if (hud)
  67.     viewport(0, xmaxwindow, 0, ymaxwindow);
  68.     else
  69.     viewport(1, xmaxwindow-1, ymiddle, ymaxwindow-1);
  70.  
  71.     perspective(fov, ar, 4.0, 1.0e6);
  72. }
  73.  
  74. clearz()
  75. {
  76.     if (hud)
  77.     viewport(0, xmaxwindow, 0, ymaxwindow);
  78.     else
  79.     viewport(1, xmaxwindow-1, ymiddle, ymaxwindow-1);
  80.  
  81.     zclear();
  82. }
  83.  
  84. #define EDGE 512000
  85.  
  86. /*
  87.  *  draw_infinite_world()
  88.  *  draws those objects at an effectively infinite range
  89.  *  i.e. sky, ground stars, sun, moon
  90.  */
  91. draw_infinite_world(elv)
  92.     float elv;
  93. {
  94.     static long sky[3] = {0, EDGE, 0};
  95.     static long horizon1[11][3] = {{-EDGE,     0, -EDGE},
  96.                    {-EDGE>>2,  0, -EDGE>>2},
  97.                    {-EDGE>>3,  0, -EDGE>>3},
  98.                    {-EDGE>>4,  0, -EDGE>>4},
  99.                    {-EDGE>>5,  0, -EDGE>>5},
  100.                    {-EDGE>>6,  0, -EDGE>>6},
  101.                    {-EDGE>>7,  0, -EDGE>>7},
  102.                    {-EDGE>>8,  0, -EDGE>>8},
  103.                    {-EDGE>>9,  0, -EDGE>>9},
  104.                    {-EDGE>>10, 0, -EDGE>>10},
  105.                    { 0,        0,  0}};
  106.     static long horizon2[11][3] = {{-EDGE,     0,  EDGE},
  107.                    {-EDGE>>2,  0,  EDGE>>2},
  108.                    {-EDGE>>3,  0,  EDGE>>3},
  109.                    {-EDGE>>4,  0,  EDGE>>4},
  110.                    {-EDGE>>5,  0,  EDGE>>5},
  111.                    {-EDGE>>6,  0,  EDGE>>6},
  112.                    {-EDGE>>7,  0,  EDGE>>7},
  113.                    {-EDGE>>8,  0,  EDGE>>8},
  114.                    {-EDGE>>9,  0,  EDGE>>9},
  115.                    {-EDGE>>10, 0,  EDGE>>10},
  116.                    { 0,        0,  0}};
  117.     static long horizon3[11][3] = {{ EDGE,     0,  EDGE},
  118.                    { EDGE>>2,  0,  EDGE>>2},
  119.                    { EDGE>>3,  0,  EDGE>>3},
  120.                    { EDGE>>4,  0,  EDGE>>4},
  121.                    { EDGE>>5,  0,  EDGE>>5},
  122.                    { EDGE>>6,  0,  EDGE>>6},
  123.                    { EDGE>>7,  0,  EDGE>>7},
  124.                    { EDGE>>8,  0,  EDGE>>8},
  125.                    { EDGE>>9,  0,  EDGE>>9},
  126.                    { EDGE>>10, 0,  EDGE>>10},
  127.                    { 0,        0,  0}};
  128.     static long horizon4[11][3] = {{ EDGE,     0, -EDGE},
  129.                    { EDGE>>2,  0, -EDGE>>2},
  130.                    { EDGE>>3,  0, -EDGE>>3},
  131.                    { EDGE>>4,  0, -EDGE>>4},
  132.                    { EDGE>>5,  0, -EDGE>>5},
  133.                    { EDGE>>6,  0, -EDGE>>6},
  134.                    { EDGE>>7,  0, -EDGE>>7},
  135.                    { EDGE>>8,  0, -EDGE>>8},
  136.                    { EDGE>>9,  0, -EDGE>>9},
  137.                    { EDGE>>10, 0, -EDGE>>10},
  138.                    { 0,        0,  0}};
  139.     static float hst1[11][3] = {{-EDGE,     -EDGE},
  140.                 {-EDGE>>2,  -EDGE>>2},
  141.                 {-EDGE>>3,  -EDGE>>3},
  142.                 {-EDGE>>4,  -EDGE>>4},
  143.                 {-EDGE>>5,  -EDGE>>5},
  144.                 {-EDGE>>6,  -EDGE>>6},
  145.                 {-EDGE>>7,  -EDGE>>7},
  146.                 {-EDGE>>8,  -EDGE>>8},
  147.                 {-EDGE>>9,  -EDGE>>9},
  148.                 {-EDGE>>10, -EDGE>>10},
  149.                 { 0,        0}};
  150.     static float hst2[11][3] = {{-EDGE,     EDGE},
  151.                 {-EDGE>>2,  EDGE>>2},
  152.                 {-EDGE>>3,  EDGE>>3},
  153.                 {-EDGE>>4,  EDGE>>4},
  154.                 {-EDGE>>5,  EDGE>>5},
  155.                 {-EDGE>>6,  EDGE>>6},
  156.                 {-EDGE>>7,  EDGE>>7},
  157.                 {-EDGE>>8,  EDGE>>8},
  158.                 {-EDGE>>9,  EDGE>>9},
  159.                 {-EDGE>>10, EDGE>>10},
  160.                 { 0,        0}};
  161.     static float hst3[11][3] = {{ EDGE,     EDGE},
  162.                 { EDGE>>2,  EDGE>>2},
  163.                 { EDGE>>3,  EDGE>>3},
  164.                 { EDGE>>4,  EDGE>>4},
  165.                 { EDGE>>5,  EDGE>>5},
  166.                 { EDGE>>6,  EDGE>>6},
  167.                 { EDGE>>7,  EDGE>>7},
  168.                 { EDGE>>8,  EDGE>>8},
  169.                 { EDGE>>9,  EDGE>>9},
  170.                 { EDGE>>10, EDGE>>10},
  171.                 { 0,        0}};
  172.     static float hst4[11][3] = {{ EDGE,     0, -EDGE},
  173.                 { EDGE>>2,  -EDGE>>2},
  174.                 { EDGE>>3,  -EDGE>>3},
  175.                 { EDGE>>4,  -EDGE>>4},
  176.                 { EDGE>>5,  -EDGE>>5},
  177.                 { EDGE>>6,  -EDGE>>6},
  178.                 { EDGE>>7,  -EDGE>>7},
  179.                 { EDGE>>8,  -EDGE>>8},
  180.                 { EDGE>>9,  -EDGE>>9},
  181.                 { EDGE>>10, -EDGE>>10},
  182.                 { 0,        0}};
  183.     static float gnormal[3] = {0.0, 1.0, 0.0};
  184.     int groundz;
  185.     int i;
  186.     Plane p, *pp;
  187.  
  188.     if (in_cmode)
  189.     {
  190.     color(ci_table[C_SWAMP]);
  191.     bgnpolygon();
  192.     v3i(horizon1[0]);
  193.     v3i(horizon2[0]);
  194.     v3i(horizon3[0]);
  195.     v3i(horizon4[0]);
  196.     endpolygon();
  197.  
  198.     color(ci_table[C_SKY]);
  199.     bgntmesh();
  200.     v3i(horizon1[0]);
  201.     v3i(horizon2[0]);
  202.     v3i(sky);
  203.     v3i(horizon3[0]);
  204.     swaptmesh();
  205.     v3i(horizon4[0]);
  206.     v3i(horizon1[0]);
  207.     endtmesh();
  208.  
  209.     return;
  210.     }
  211.  
  212.     groundz = FALSE;
  213.     FOR_EACH_PLANE (p, pp)
  214.     {
  215.     if ((p->y <= 10.0 && p->status <= MEXPLODE) ||
  216.         (p->mstatus && p->my <= 100.0 && p->mstatus <= MEXPLODE))
  217.         groundz = TRUE;
  218.     }
  219.  
  220.     if (groundz)
  221.     zbuffer(TRUE);
  222.  
  223.     lighting(ON);
  224.     setmaterial(MAT_SWAMP);
  225.     n3f(gnormal);
  226.     for (i=0; i < 10; i++)
  227.     {
  228.     bgnpolygon();
  229.     v3i(horizon1[i]);
  230.     v3i(horizon2[i]);
  231.     v3i(horizon2[i+1]);
  232.     v3i(horizon1[i+1]);
  233.     endpolygon();
  234.     bgnpolygon();
  235.     v3i(horizon2[i]);
  236.     v3i(horizon3[i]);
  237.     v3i(horizon3[i+1]);
  238.     v3i(horizon2[i+1]);
  239.     endpolygon();
  240.     bgnpolygon();
  241.     v3i(horizon3[i]);
  242.     v3i(horizon4[i]);
  243.     v3i(horizon4[i+1]);
  244.     v3i(horizon3[i+1]);
  245.     endpolygon();
  246.     bgnpolygon();
  247.     v3i(horizon4[i]);
  248.     v3i(horizon1[i]);
  249.     v3i(horizon1[i+1]);
  250.     v3i(horizon4[i+1]);
  251.     endpolygon();
  252.     }
  253.     lighting(OFF);
  254.  
  255.     if (groundz)
  256.     zbuffer(FALSE);
  257.  
  258.     bgntmesh();
  259.     cpack(cp_W_horizon);
  260.     v3i(horizon1[0]);
  261.     v3i(horizon2[0]);
  262.     cpack(cp_sky);
  263.     v3i(sky);
  264.     cpack(cp_E_horizon);
  265.     v3i(horizon3[0]);
  266.     swaptmesh();
  267.     v3i(horizon4[0]);
  268.     cpack(cp_W_horizon);
  269.     v3i(horizon1[0]);
  270.     endtmesh();
  271.  
  272.     /*
  273.      *  sun
  274.      */
  275.  
  276.     /*
  277.     draw_cloud_layer();
  278.     */
  279. }
  280.  
  281.  
  282. #define CLOUD_ELEV 4000.0
  283. #define CLOUD_TSCALE 0.00003
  284. #define CLOUD_R 100
  285. #define CLOUD_S 12
  286. #define CLOUD_D 1.14
  287. #define CLOUD_START 1.0
  288.  
  289. draw_cloud_layer()
  290. {
  291.     static float cv[CLOUD_S][CLOUD_R][4];
  292.     static float cv0[4];
  293.     static float ct[CLOUD_S][CLOUD_R][2];
  294.     static float ct0[2];
  295.     static first_time = TRUE;
  296.     float s, c;
  297.     int i, j;
  298.     Plane pp = planes[0];
  299.  
  300.     if (first_time)
  301.     {
  302.     first_time = FALSE;
  303.  
  304.     for (i=0; i < CLOUD_S; i++)
  305.     {
  306.         cv0[X] = 0.0;
  307.         cv0[Y] = CLOUD_ELEV;
  308.         cv0[Z] = 0.0;
  309.         ct0[X] = 0.0;
  310.         ct0[Y] = 0.0;
  311.         gl_sincos((1800/CLOUD_S) + (3600/CLOUD_S)*i, &s, &c);
  312.         cv[i][0][X] = c * CLOUD_START;
  313.         cv[i][0][Y] = CLOUD_ELEV;
  314.         cv[i][0][Z] = s * CLOUD_START;
  315.         ct[i][0][X] = c * CLOUD_TSCALE * CLOUD_START;
  316.         ct[i][0][Y] = s * CLOUD_TSCALE * CLOUD_START;
  317.         for (j=1; j < CLOUD_R; j++)
  318.         {
  319.         cv[i][j][X] = cv[i][j-1][X] * CLOUD_D;
  320.         cv[i][j][Y] = CLOUD_ELEV;
  321.         cv[i][j][Z] = cv[i][j-1][Z] * CLOUD_D;
  322.         ct[i][j][X] = ct[i][j-1][X] * CLOUD_D;
  323.         ct[i][j][Y] = ct[i][j-1][Y] * CLOUD_D;
  324.         }
  325.     }
  326.     }
  327.  
  328.     zbuffer(TRUE);
  329.  
  330.     if (texit)
  331.     {
  332.     texturing(ON);
  333.     mmode(MTEXTURE);
  334.     translate(pp->x * CLOUD_TSCALE, pp->z * CLOUD_TSCALE, 0.0);
  335.     mmode(MVIEWING);
  336.     }
  337.  
  338.     if (pp->y < CLOUD_ELEV)
  339.     cpack(0xffaaaaaa);
  340.     else
  341.     cpack(0xffeeeeee);
  342.  
  343.     for (i=0; i < CLOUD_S; i++)
  344.     {
  345.     bgnpolygon();
  346.     t2f(ct[i][j]);
  347.     v3f(cv[i][j]);
  348.     t2f(ct0);
  349.     v3f(cv0);
  350.     t2f(ct[i+1][j]);
  351.     v3f(cv[i+1][j]);
  352.     endpolygon();
  353.     }
  354.     bgnpolygon();
  355.     t2f(ct[7][j]);
  356.     v3f(cv[7][j]);
  357.     t2f(ct0);
  358.     v3f(cv0);
  359.     t2f(ct[0][j]);
  360.     v3f(cv[0][j]);
  361.     endpolygon();
  362.  
  363.     for (j=0; j < CLOUD_R-1; j++)
  364.     {
  365.     bgntmesh();
  366.     for (i=0; i < CLOUD_S; i++)
  367.     {
  368.         t2f(ct[i][j+1]);
  369.         v3f(cv[i][j+1]);
  370.         t2f(ct[i][j]);
  371.         v3f(cv[i][j]);
  372.     }
  373.     t2f(ct[0][j+1]);
  374.     v3f(cv[0][j+1]);
  375.     t2f(ct[0][j]);
  376.     v3f(cv[0][j]);
  377.     endtmesh();
  378.     }
  379.  
  380.     if (texit)
  381.     {
  382.     texturing(OFF);
  383.     mmode(MTEXTURE);
  384.     loadmatrix(identmat);
  385.     mmode(MVIEWING);
  386.     }
  387.  
  388.     zbuffer(FALSE);
  389. }
  390.  
  391.  
  392. genstripe(x1, y1, x2, y2)
  393.     Icoord x1, y1, x2, y2;
  394. {
  395.     rectfs(x1, y1, x2, y2);
  396.     rectfs(-x1, y1, -x2, y2);
  397.     rectfs(x1, 8500-y1, x2, 8500-y2);
  398.     rectfs(-x1, 8500-y1, -x2, 8500-y2);
  399. }
  400.  
  401.  
  402. draw_vasi_lights()
  403. {
  404.     register int i;
  405.  
  406.     static float v1[5][2] = {{ 160.0, 0.0}, { 160.0, 3.0},
  407.                  { 163.0, 3.0}, { 163.0, 0.0}, { 161.5, 1.5}};
  408.     static float v2[5][2] = {{ 180.0, 0.0}, { 180.0, 3.0},
  409.                  { 183.0, 3.0}, { 183.0, 0.0}, { 181.5, 1.5}};
  410.     static float v3[5][2] = {{ 200.0, 0.0}, { 200.0, 3.0},
  411.                  { 203.0, 3.0}, { 203.0, 0.0}, { 201.5, 1.5}};
  412.     static float v4[5][2] = {{-160.0, 0.0}, {-160.0, 3.0},
  413.                  {-163.0, 3.0}, {-163.0, 0.0}, {-161.5, 1.5}};
  414.     static float v5[5][2] = {{-180.0, 0.0}, {-180.0, 3.0},
  415.                  {-183.0, 3.0}, {-183.0, 0.0}, {-181.5, 1.5}};
  416.     static float v6[5][2] = {{-200.0, 0.0}, {-200.0, 3.0},
  417.                  {-203.0, 3.0}, {-203.0, 0.0}, {-201.5, 1.5}};
  418.  
  419.     bgnpolygon(); for (i=0; i < 4; i++) v2f(v1[i]); endpolygon();
  420.     bgnpolygon(); for (i=0; i < 4; i++) v2f(v2[i]); endpolygon();
  421.     bgnpolygon(); for (i=0; i < 4; i++) v2f(v3[i]); endpolygon();
  422.     bgnpolygon(); for (i=0; i < 4; i++) v2f(v4[i]); endpolygon();
  423.     bgnpolygon(); for (i=0; i < 4; i++) v2f(v5[i]); endpolygon();
  424.     bgnpolygon(); for (i=0; i < 4; i++) v2f(v6[i]); endpolygon();
  425.  
  426.     bgnpoint();
  427.     v2f(v1[4]);
  428.     v2f(v2[4]);
  429.     v2f(v3[4]);
  430.     v2f(v4[4]);
  431.     v2f(v5[4]);
  432.     v2f(v6[4]);
  433.     endpoint();
  434. }
  435.  
  436.  
  437. /*
  438.  *  draw VASI lights , plane is at pz
  439.  */
  440. draw_vasi(pp)
  441.     Plane pp;
  442. {
  443.     float temp1, temp2;
  444.     float trans1, trans2;
  445.  
  446.     temp1 = temp2 = 0.0;
  447.     if (pp->z > -4000.0)
  448.     {
  449.     trans1 = -800;
  450.     trans2 = 700;
  451.     if (pp->z != -1150.0)
  452.         temp1 = pp->y/(pp->z + 1150.0);
  453.     if (pp->z != -500.0)
  454.         temp2 = pp->y/(pp->z + 500.0);
  455.     }
  456.     else
  457.     {
  458.     trans1 = -7700;
  459.     trans2 = -700;
  460.     if (pp->z != -6850.0)
  461.         temp1 = pp->y/(-6850.0 - pp->z);
  462.     if (pp->z != -7500.0)
  463.         temp2 = pp->y/(-7500.0 - pp->z);
  464.     }
  465.  
  466.     pushmatrix();
  467.     if (temp1 < 12.0/200.0)
  468.     COLOR(C_RED);
  469.     else
  470.     COLOR(C_WHITE);
  471.     translate(0.0, 0.0, trans1);
  472.     draw_vasi_lights();
  473.  
  474.     if (temp2 < 12.0/200.0)
  475.     COLOR(C_RED);
  476.     else
  477.     COLOR(C_WHITE);
  478.     translate(0.0, 0.0, trans2);
  479.     draw_vasi_lights();
  480.     popmatrix();
  481. }
  482.