home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / libs / sphigs / sph_dos.lha / dos / sphdemo / struct.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-26  |  8.9 KB  |  339 lines
  1. #include "SPHDEMO.h"
  2. #include "struct.h"
  3. #include "view.h"
  4.  
  5.  
  6. /* The following two functions use two undocumented SPHIGS routines that
  7.    allow you to enable/disable views without having to unpost/post.
  8.  */
  9.  
  10. void DisplayAllViews (void) {
  11.    SPH_enableView (SIDE_ORTHO_VIEW);
  12.    SPH_enableView (TOP_ORTHO_VIEW);
  13.    SPH_enableView (TEXT_VIEW);
  14.    PartialScreenRenderView ();
  15. }
  16.  
  17. void DisplayOnlyFullRenderView (void) {
  18.    SPH_disableView (SIDE_ORTHO_VIEW);
  19.    SPH_disableView (TOP_ORTHO_VIEW);
  20.    SPH_disableView (TEXT_VIEW);
  21.    FullScreenRenderView ();
  22. }
  23.  
  24.  
  25. void AddChimneyToHouse (int housestruct)
  26. {
  27.    SPH_openStructure (housestruct);
  28.    SPH_setPickIdentifier (231);
  29.    SPH_executeStructure (CHIMNEY_STRUCT);
  30.    SPH_closeStructure ();
  31. }
  32.  
  33. void TakeChimneyFromHouse (int housestruct)
  34. {
  35.    SPH_openStructure (housestruct);
  36.    SPH_deleteElement ();
  37.    SPH_deleteElement ();
  38.    SPH_closeStructure ();
  39. }
  40.  
  41.  
  42. void CreateTextStructure (void)
  43. {
  44.    point textorigin = {0.1, 0.95, 0.5};
  45. #define CarriageReturn   textorigin[Y]-=0.05
  46.    /* SRGP_loadFont (1, "Times.14"); */
  47.    SPH_openStructure (TEXT_STRUCT);
  48.    /* SPH_setTextFont (1); */
  49.    SPH_setTextColor (red);
  50.    SPH_text (textorigin, "Red = View Ref. Point");
  51.    CarriageReturn;
  52.    SPH_setTextColor (orange);
  53.    SPH_text (textorigin, "Orange = Projection Ref. Point");
  54.    CarriageReturn;
  55.    SPH_setTextColor (limegreen);
  56.    SPH_text (textorigin, "Lime = Front Clipping Plane");
  57.    CarriageReturn;
  58.    SPH_setTextColor (forestgreen);
  59.    SPH_text (textorigin, "Forest = Rear Clipping Plane");
  60.    CarriageReturn;
  61.    SPH_closeStructure ();
  62.    SPH_postRoot (TEXT_STRUCT, TEXT_VIEW);
  63. }
  64.  
  65.  
  66.  
  67. void CreateNormalizedHouseStructure (void)
  68. {
  69.    int i;
  70.    point tempv[8];
  71.    
  72.    int faketoparray[] = {1,2,7,6,5,0,1,6};
  73.    int fakesidearray[] = {2,3,8,7,6,1,2,7};
  74.     
  75.    point house_vertices[] = {
  76.        { 0.,10.,0. },
  77.        { 8.,16.,0. },
  78.        { 16.,10.,0. },
  79.        { 16.,0.,0. },    /* Use the SPHIGS "point" data-type! */
  80.        { 0.,0.,0. },
  81.        { 0.,10.,-40. },
  82.        { 8.,16.,-40. },
  83.        { 16.,10.,-40. },
  84.        { 16.,0.,-40. },
  85.        { 0.,0.,-40. }
  86.     };
  87.     
  88.     /* FACETS ARE VERTEX LISTS counter-clockwise from point of view of
  89.        someone OUTSIDE the house. */
  90.     vertex_index house_facets[] = {
  91.        4,3,2,1,0, -1,
  92.        5,6,7,8,9, -1,
  93.        2,7,6,1,   -1,
  94.        2,3,8,7,   -1,
  95.        3,4,9,8,   -1,
  96.        0,5,9,4,   -1,
  97.        0,1,6,5,   -1
  98.     };
  99.  
  100.  
  101.    SPH_openStructure (HOUSE_STRUCT);
  102.    SPH_polyhedron (10, 7, house_vertices, house_facets);
  103.    SPH_closeStructure();
  104.    
  105.    /* Make fake houses (incomplete) for use in wire orthographic depictions */
  106.    for (i=0; i<8; i++)
  107. #ifdef THINK_C
  108.       memcpy(tempv[i], house_vertices[faketoparray[i]], (size_t)sizeof(point)); 
  109. #else
  110.       bcopy (house_vertices[faketoparray[i]], tempv[i], sizeof(point));
  111. #endif
  112.  
  113.    SPH_openStructure (FAKE_HOUSE_TOP_STRUCT);
  114.      SPH_polyLine (8, tempv);
  115.    SPH_closeStructure();
  116.    
  117.    for (i=0; i<8; i++)
  118. #ifdef THINK_C
  119.       memcpy(tempv[i], house_vertices[fakesidearray[i]], (size_t)sizeof(point));
  120. #else
  121.       bcopy (house_vertices[fakesidearray[i]], tempv[i], sizeof(point));   
  122. #endif
  123.  
  124.    SPH_openStructure (FAKE_HOUSE_SIDE_STRUCT);
  125.      SPH_polyLine (8, tempv);
  126.    SPH_closeStructure();
  127. }
  128.  
  129.  
  130. void CreateChimneyStructure ()
  131. {
  132.    matrix mat;
  133.    
  134.    point chim_verts[] = {
  135.       {0.0, 0.0, 0.0},
  136.       {4, 3, 0.0},
  137.       {4, 7, 0.0},
  138.       {0.0, 7, 0.0},
  139.       {0.0, 0.0, -10},
  140.       {4, 3, -10},
  141.       {4, 7, -10},
  142.       {0, 7, -10}
  143.    };
  144.    
  145.    vertex_index chim_facets[] = 
  146.       {0,1,2,3,  -1,
  147.        4,7,6,5,  -1,
  148.        7,4,0,3,  -1,
  149.        1,5,6,2,  -1,
  150.        7,3,2,6,  -1};
  151.        
  152.    SPH_openStructure (CHIMNEY_STRUCT);
  153.    SPH_setInteriorColor (firebrick);
  154.    SPH_translate (0.0,10.1, -30.0, mat); 
  155.    SPH_setModelingTransformation (mat, ASSIGN);
  156.    SPH_polyhedron (8, 5, chim_verts, chim_facets);
  157.    SPH_closeStructure();
  158. }
  159.  
  160.    
  161.  
  162. void CreateAxesStructure ()
  163. {
  164.    point verts[2] = { {0.0,0.0,0.0}, {0.0,0.0,0.0} };
  165.    
  166.    SPH_openStructure (AXES_STRUCT);
  167.       SPH_setLineColor (blue);
  168.       SPH_setLineWidthScaleFactor (2.0);
  169.       SPH_setTextColor (blue);
  170.       
  171.       verts[1][X] = 80.0; SPH_polyLine (2, verts); 
  172.       SPH_text (verts[1], "X"); verts[1][X]=0.0;
  173.       verts[1][Y] = 80.0; SPH_polyLine (2, verts); 
  174.       SPH_text (verts[1], "Y"); verts[1][Y]=0.0;
  175.       verts[1][Z] = 80.0; SPH_polyLine (2, verts); 
  176.       SPH_text (verts[1], "Z"); verts[1][Z]=0.0;
  177.    SPH_closeStructure ();
  178. }
  179.  
  180. extern matrix inverseVO;
  181.  
  182. void CreateCameraStructure ()
  183. {
  184.    vector zerovec={0.0,0.0,0.0};
  185.    double dy, dx, edgex, edgey;
  186.    point p, frontplane[5], backplane[5], edges[2];
  187.    int i;
  188.    
  189.     SPH_openStructure (CAMERA_STRUCT);
  190.     if ((i=SPH_inquireElementPointer()) > 0)
  191.        SPH_deleteElementsInRange (1, i); /*delete all extant*/
  192.  
  193.     /* PLACE AN IMAGE OF THE VRP LOCATION */
  194.     SPH_setMarkerColor (red);
  195.     MAT3mult_vec (p, zerovec, inverseVO);
  196.     SPH_polyMarker (1, &p);
  197.     
  198.     /* PLACE AN IMAGE OF THE PRP LOCATION */
  199.     SPH_setMarkerColor (orange);
  200.     MAT3mult_vec (p, prp1, inverseVO);
  201.     SPH_polyMarker (1, &p);
  202.     
  203.     /* CALCULATE SLOPES OF THE VIEW VOLUME EDGES */
  204.     /* Here, we assume PRP is always (0,0,somethingPositive) */
  205.     /* And, we assume vmin=vmax and umin=umax. */
  206.     if (persptype1 == PERSPECTIVE) {
  207.        dy = vmax1/prp1[Z];
  208.        dx = umax1/prp1[Z];
  209.     }
  210.     else
  211.        dy = dx = 0.0;
  212.     
  213.     /* PLACE LINES FOR THE FRONT AND BACK CLIP PLANES */
  214.     edgex = umax1 + dx*(-fplane1); edgey = vmax1 + dy*(-fplane1);
  215.     MAT3_SET_VEC (frontplane[0], -edgex, +edgey, fplane1);
  216.     MAT3_SET_VEC (frontplane[1], +edgex, +edgey, fplane1);
  217.     MAT3_SET_VEC (frontplane[2], +edgex, -edgey, fplane1);
  218.     MAT3_SET_VEC (frontplane[3], -edgex, -edgey, fplane1);
  219.     edgex = umax1 + dx*(-bplane1); edgey = vmax1 + dy*(-bplane1);
  220.     MAT3_SET_VEC  (backplane[0], -edgex, +edgey, bplane1);
  221.     MAT3_SET_VEC  (backplane[1], +edgex, +edgey, bplane1);
  222.     MAT3_SET_VEC  (backplane[2], +edgex, -edgey, bplane1);
  223.     MAT3_SET_VEC  (backplane[3], -edgex, -edgey, bplane1);
  224.     for (i=0; i<4; i++) {
  225.        MAT3mult_vec (frontplane[i], frontplane[i], inverseVO);
  226.        MAT3mult_vec (backplane[i], backplane[i], inverseVO);
  227.     }
  228.     MAT3_COPY_VEC (frontplane[4], frontplane[0]);
  229.     MAT3_COPY_VEC (backplane[4], backplane[0]);
  230.     SPH_setLineColor (limegreen);
  231.     SPH_setLineWidthScaleFactor (2.0);
  232.     SPH_polyLine (5, frontplane);
  233.     SPH_setLineColor (forestgreen);
  234.     SPH_polyLine (5, backplane);
  235.     for (i=0; i<4; i++) {
  236.        MAT3_COPY_VEC (edges[0], frontplane[i]);
  237.        MAT3_COPY_VEC (edges[1], backplane[i]);
  238.        SPH_polyLine (2, edges);
  239.     }
  240.     SPH_closeStructure ();
  241. }
  242.  
  243.  
  244. void BuildEverything() 
  245. {
  246.    register i;
  247.    matrix temp;
  248.    vector zerovec={0.0,0.0,0.0};
  249.  
  250.    CreateNormalizedHouseStructure();
  251.    CreateAxesStructure();
  252.    CreateTextStructure();
  253.    CreateChimneyStructure();
  254.    
  255.    SPH_openStructure (STREET_STRUCT);
  256.    SPH_setInteriorColor (2);
  257.    SPH_translate (0.0,0.0,0.0, temp);
  258.    SPH_executeStructure (HOUSE_STRUCT);
  259.    SPH_setInteriorColor (4);
  260.    for (i=0; i<5; i++) {
  261.       SPH_setInteriorColor (3+i);
  262.       SPH_translate (20.0,0.0,0.0, temp);
  263.       SPH_setModelingTransformation (temp, PRECONCATENATE);
  264.       SPH_executeStructure (HOUSE_STRUCT);
  265.    }
  266.    SPH_closeStructure();
  267.  
  268.  
  269.    SPH_openStructure (NEIGHBORHOOD_STRUCT);
  270.    SPH_executeStructure (STREET_STRUCT);
  271.    for (i=0; i<2; i++) {
  272.       SPH_translate(0.0,0.0,-70.0, temp);
  273.       SPH_setModelingTransformation (temp, PRECONCATENATE);
  274.       SPH_executeStructure (STREET_STRUCT);
  275.    }
  276.    SPH_closeStructure();
  277.  
  278.  
  279.    SPH_openStructure (FAKE_NEIGHBORHOOD_SIDE_STRUCT);
  280.    SPH_setLineColor (7);
  281.    SPH_executeStructure (FAKE_HOUSE_SIDE_STRUCT);
  282.    for (i=0; i<2; i++) {
  283.       SPH_translate(0.0,0.0,-70.0, temp);
  284.       SPH_setModelingTransformation (temp, PRECONCATENATE);
  285.       SPH_executeStructure (FAKE_HOUSE_SIDE_STRUCT);
  286.    }
  287.    SPH_closeStructure();
  288.    SPH_postRoot (FAKE_NEIGHBORHOOD_SIDE_STRUCT, SIDE_ORTHO_VIEW);
  289.    
  290.    
  291.    SPH_openStructure (FAKE_NEIGHBORHOOD_TOP_STRUCT);
  292.    for (i=0; i<6; i++) {
  293.       int j;
  294.       SPH_setLineColor (i+2);
  295.       for (j=0; j<3; j++) {
  296.          SPH_translate (i*20.0, 0.0,-70.0*j, temp);
  297.          SPH_setModelingTransformation (temp, ASSIGN);
  298.          SPH_executeStructure (FAKE_HOUSE_TOP_STRUCT);
  299.       }
  300.    }
  301.    SPH_closeStructure();
  302.    SPH_postRoot (FAKE_NEIGHBORHOOD_TOP_STRUCT, TOP_ORTHO_VIEW);
  303.  
  304.    SPH_openStructure (GRID_STRUCT);
  305.    {
  306.       register i;
  307.       point p[2];
  308.       
  309.       SPH_setLineColor (yellow);
  310.       
  311.       /* DRAW THE LINES GOING FROM z=10 TO z=(-infinity) */
  312.       MAT3_COPY_VEC (p[0], zerovec);
  313.       MAT3_COPY_VEC (p[1], zerovec);
  314.       p[0][Z] = (double)10;
  315.       p[1][Z] = (double)-200;
  316.       for (i=0; i<=200; i+=20) {
  317.          p[0][X] = p[1][X] = (double)i;
  318.          SPH_polyLine (2, p);
  319.       }
  320.       
  321.       /* DRAW THE LINES GOING FROM x=-10 TO x=infinity */
  322.       MAT3_COPY_VEC (p[0], zerovec);
  323.       MAT3_COPY_VEC (p[1], zerovec);
  324.       p[0][X] = (double)-10;
  325.       p[1][X] = (double)200;
  326.       for (i=0; i<=200; i+=20) {
  327.          p[0][Z] = p[1][Z] = (double)(-i);
  328.          SPH_polyLine (2, p);
  329.       }
  330.    }
  331.    
  332.    SPH_executeStructure (AXES_STRUCT);
  333.    
  334.    SPH_closeStructure ();
  335.  
  336.    SPH_postRoot (CAMERA_STRUCT, TOP_ORTHO_VIEW);
  337.    SPH_postRoot (CAMERA_STRUCT, SIDE_ORTHO_VIEW);
  338. }
  339.