home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / demos / auto_box / auto_box.c next >
Encoding:
C/C++ Source or Header  |  1991-07-12  |  17.9 KB  |  832 lines
  1. /* $XConsortium: auto_box.c,v 5.4 91/07/12 18:04:33 hersh Exp $ */
  2.  
  3. /***********************************************************
  4. Copyright 1989, 1990, 1991 by Sun Microsystems, Inc. and the X Consortium.
  5.  
  6.                         All Rights Reserved
  7.  
  8. Permission to use, copy, modify, and distribute this software and its 
  9. documentation for any purpose and without fee is hereby granted, 
  10. provided that the above copyright notice appear in all copies and that
  11. both that copyright notice and this permission notice appear in 
  12. supporting documentation, and that the names of Sun Microsystems,
  13. the X Consortium, and MIT not be used in advertising or publicity 
  14. pertaining to distribution of the software without specific, written 
  15. prior permission.  
  16.  
  17. SUN MICROSYSTEMS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 
  18. INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT 
  19. SHALL SUN MICROSYSTEMS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
  20. DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  21. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  22. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  23. SOFTWARE.
  24.  
  25. ******************************************************************/
  26.  
  27. #include <stdio.h>
  28. #include <errno.h>
  29. #include <math.h>
  30.  
  31. #ifndef M_PI
  32. #define M_PI  3.14159265358979323846
  33. #endif /* M_PI */
  34.  
  35.  
  36. #ifdef USE_X_DRAWABLE
  37. #include <X11/Xlib.h>
  38. #include <X11/Xatom.h>
  39. #endif /*USE_X_DRAWABLE*/
  40.  
  41. #include <phigs/phigs.h>
  42.  
  43. /* Workstation ids */
  44. #define WS1    1
  45.  
  46. /* Colors */
  47. #define BLACK    0
  48. #define WHITE    1
  49. #define RED    2
  50. #define GREEN    3
  51. #define BLUE    4
  52. #define YELLOW    5
  53. #define CYAN    6
  54. #define MAGENTA    7
  55.  
  56. /* Structure names */
  57. #define ROOT 0
  58. #define CUBE 1
  59. #define SUB  2
  60.  
  61. /* Labels */
  62. #define STYLE   1 
  63. #define QUAD_1  101 
  64. #define QUAD_2    102 
  65. #define QUAD_3    103 
  66. #define QUAD_4    104 
  67. #define QUAD_1_1 105 
  68. #define QUAD_4_1 106 
  69.  
  70. #define WIN_X    200
  71. #define WIN_Y    200
  72. #define WIN_W    400
  73. #define WIN_H    400
  74.  
  75. #define PFILLAREASET3
  76.  
  77. #ifdef PFILLAREASET3
  78. #define    PFILLAREA_CALL    pfill_area_set3( &side_list )
  79. #else /*PFILLAREASET3*/
  80. #define    PFILLAREA_CALL    pfill_area3( &side )
  81. #endif /*PFILLAREASET3*/
  82.  
  83. #ifdef USE_X_DRAWABLE
  84. extern void init_window();
  85. #endif /*USE_X_DRAWABLE*/
  86.  
  87. /* Globals */
  88. Ppoint3        pt;
  89. Pvec3        shift;
  90. Pfloat        x_ang, y_ang, z_ang;
  91. Pvec3        scale;
  92. Pmatrix3    bldmat, bldmat2, bldmat3, bldmat4;
  93.  
  94. static void
  95. setup(n, mat)
  96. int n;
  97. float mat[4][4];
  98. {
  99.     int i, j;
  100.  
  101.     for (i = 0; i < n; i++) {
  102.     for (j = 0; j < n; j++) {
  103.         mat[i][j] = 0;
  104.         if (i == j) mat[i][j] = 1.0;
  105.     }
  106.     }
  107. } 
  108.  
  109. static void
  110. rotate_views()
  111. {
  112.     float   theta;
  113.  
  114.     Pint err;
  115.  
  116. /*
  117.  * ... enable editing in the replace mode -- this will be used to update
  118.  *        rotation angles in 4 views
  119.  */
  120.     pset_disp_upd_st( WS1, PDEFER_WAIT, PMODE_UWOR);
  121.     pset_edit_mode( PEDIT_REPLACE);
  122. /*
  123.  * ...  set some constants for building the matrix
  124.  */
  125.     pt.x =  10.; pt.y = 10.; pt.z = 10.;
  126.     shift.delta_x = 0; shift.delta_y = 0; shift.delta_z = 0;
  127.     scale.delta_x = 1.0; scale.delta_y = 1.0; scale.delta_z = 1.0;
  128. /*
  129.  * ...  make identity matrices
  130.  */
  131.     setup( 4, bldmat);
  132.     setup( 4, bldmat2);
  133.     setup( 4, bldmat3);
  134.     setup( 4, bldmat4);
  135. /*
  136.  * ...  open the structure for editing
  137.  */
  138.  
  139.     popen_struct( SUB);
  140. /*
  141.  * ... increment the angle in a postive angle
  142.  */
  143.  
  144.     for (theta = 0; theta < 4 * M_PI; theta +=.4) {
  145. /*
  146.  * ...  set the pointer and the angles, 
  147.  * ...    find the label, 
  148.  * ...    build the matrix, 
  149.  * ...    update the view
  150.  */
  151.     pset_elem_ptr( 0);
  152. /*
  153.  * ... viewport 1
  154.  */
  155.     x_ang = theta;
  156.     y_ang = 0;
  157.     z_ang = 0;
  158.     pset_elem_ptr_label( 1);
  159.     poffset_elem_ptr( 1);
  160.     pbuild_tran_matrix3(    &pt, &shift, x_ang, y_ang, z_ang,
  161.                 &scale, &err, bldmat);
  162.     pset_local_tran3( bldmat, PTYPE_REPLACE);
  163. /*
  164.  * ... viewport 2
  165.  */
  166.     x_ang = 0;
  167.     y_ang = theta;
  168.  
  169.     pset_elem_ptr_label( 2);
  170.     poffset_elem_ptr( 1);
  171.  
  172.     pbuild_tran_matrix3(    &pt, &shift, x_ang, y_ang, z_ang,
  173.                 &scale,&err,bldmat2);
  174.     pset_local_tran3( bldmat2, PTYPE_REPLACE);
  175. /*
  176.  * ... viewport 3
  177.  */
  178.  
  179.     y_ang = 0;
  180.     z_ang = theta;
  181.  
  182.     pset_elem_ptr_label( 3);
  183.     poffset_elem_ptr( 1);
  184.  
  185.     pbuild_tran_matrix3(    &pt, &shift, x_ang, y_ang, z_ang,
  186.                 &scale, &err, bldmat3);
  187.     pset_local_tran3(bldmat3, PTYPE_REPLACE);
  188. /*
  189.  * ... viewport 4
  190.  */
  191.     x_ang = theta;
  192.     y_ang = theta;
  193.     z_ang = theta;
  194.  
  195.     pset_elem_ptr_label(4);
  196.     poffset_elem_ptr(1);
  197.  
  198.     pbuild_tran_matrix3(    &pt, &shift, x_ang, y_ang, z_ang,
  199.                 &scale, &err, bldmat4);
  200.     pset_local_tran3(bldmat4, PTYPE_REPLACE);
  201.         
  202.     pupd_ws(WS1, PFLAG_PERFORM);
  203.     }
  204. /*
  205.  *  close the structure being edited
  206.  */
  207.     pclose_struct();
  208. }
  209.  
  210. static void
  211. scale_views(scale_factor)
  212. float scale_factor;
  213. {
  214.  
  215.     float  i;
  216.     Pint err;
  217.  
  218. /*
  219.  * ... enable editing in the replace mode -- this will be used to update
  220.  *    the scale matrix in 4 views
  221.  */
  222.     pset_disp_upd_st( WS1, PDEFER_WAIT, PMODE_UWOR);
  223.     pset_edit_mode( PEDIT_REPLACE);
  224. /*
  225.  * ...  open the structure for editing
  226.  */
  227.  
  228.     popen_struct(SUB);
  229. /*
  230.  * ... increment the scale matrix 
  231.  */
  232.  
  233.     for (i = 1; i < 4 ; i += .2) {
  234. /*
  235.  * ...  set the pointer and the angles, find the label, build the matrix, update
  236.  * ...  the view
  237.  */
  238.     pset_elem_ptr(0);
  239. /*
  240.  * ... viewport 1
  241.  */
  242.     scale.delta_x = scale.delta_x * scale_factor; 
  243.     scale.delta_y = scale.delta_y * scale_factor; 
  244.     scale.delta_z = scale.delta_z * scale_factor;
  245.     pset_elem_ptr_label( 1);
  246.     poffset_elem_ptr( 1);
  247.     pbuild_tran_matrix3(&pt, &shift, x_ang, y_ang, z_ang, 
  248.                 &scale, &err, bldmat);
  249.     pset_local_tran3( bldmat, PTYPE_REPLACE);
  250. /*
  251.  * ... viewport 2
  252.  */
  253.     pset_elem_ptr_label(2);
  254.     poffset_elem_ptr(1);
  255.  
  256.     pbuild_tran_matrix3(&pt, &shift, x_ang, y_ang, z_ang,
  257.                 &scale, &err, bldmat2);
  258.     pset_local_tran3(bldmat2, PTYPE_REPLACE);
  259. /*
  260.  * ... viewport 3
  261.  */
  262.  
  263.     pset_elem_ptr_label(3);
  264.     poffset_elem_ptr(1);
  265.  
  266.     pbuild_tran_matrix3(&pt, &shift, x_ang, y_ang, z_ang,
  267.                 &scale, &err, bldmat3);
  268.     pset_local_tran3(bldmat3, PTYPE_REPLACE);
  269. /*
  270.  * ... viewport 4
  271.  */
  272.  
  273.     pset_elem_ptr_label(4);
  274.     poffset_elem_ptr(1);
  275.  
  276.     pbuild_tran_matrix3(&pt, &shift, x_ang, y_ang, z_ang,
  277.                 &scale, &err, bldmat4);
  278.     pset_local_tran3(bldmat4, PTYPE_REPLACE);
  279.  
  280.     pupd_ws(WS1, PFLAG_PERFORM);
  281.     }
  282. /*
  283.  *  close the structure being edited
  284.  */
  285.     pclose_struct();
  286. }
  287.  
  288. /*
  289.  *
  290.  *
  291.  *
  292.  */
  293.  
  294. static void
  295. load_box()
  296. {
  297.     Ppoint3    p[5];
  298.     Pvec3    xlv;
  299.     Pmatrix3    mx;
  300.     Pvec3    scale;
  301.     Pvec3    shift;
  302.     Pint    err;
  303.     Pfloat    xang, yang, zang;
  304.     Ppoint_list_list3 side_list;
  305.     Ppoint_list3 side;
  306.  
  307.     side.num_points = 4;
  308.     side.points = p;
  309.     side_list.num_point_lists = 1;
  310.     side_list.point_lists = &side;
  311.  
  312.  
  313.     setup(4, mx);
  314.  
  315.     popen_struct(CUBE);
  316.     plabel(STYLE);
  317.     pset_int_style(PSTYLE_SOLID );
  318.     pset_hlhsr_id(PHIGS_HLHSR_ID_ON );
  319. /*
  320.  * ... make a square to make a front and back of the cube
  321.  */
  322.     p[0].x = 5; p[0].y = 5; p[0].z = 5;
  323.     p[1].x = 15; p[1].y = 5; p[1].z = 5;
  324.     p[2].x = 15; p[2].y = 15; p[2].z = 5;
  325.     p[3].x = 5; p[3].y = 15; p[3].z = 5;
  326.  
  327. /* front */
  328.     xlv.delta_x = 0; xlv.delta_y = 0; xlv.delta_z = 10;
  329.     ptranslate3( &xlv, &err, mx);
  330.     pset_local_tran3( mx, PTYPE_REPLACE);
  331.  
  332.     pset_int_colr_ind( RED);
  333.     PFILLAREA_CALL;
  334.  
  335. /* back */
  336.  
  337.     xlv.delta_x = 5; xlv.delta_y = 10; xlv.delta_z = 5;
  338.     scale.delta_x = 1.0; scale.delta_y = 1.0; scale.delta_z = 1.0;
  339.     xang = 3.14; yang = 0.0; zang = 0.0; 
  340.     shift.delta_x = 0.; shift.delta_y = 0.; shift.delta_z = 0;
  341.     pbuild_tran_matrix3(&xlv, &shift, xang, yang, zang,
  342.             &scale, &err, mx);
  343.     pset_local_tran3(mx, PTYPE_REPLACE);
  344.  
  345.     pset_int_colr_ind(CYAN);
  346.     PFILLAREA_CALL;
  347.  
  348. /* right */
  349.     xlv.delta_x = 5; xlv.delta_y = 5; xlv.delta_z = 5;
  350.     scale.delta_x = 1.0; scale.delta_y = 1.0; scale.delta_z = 1.0;
  351.     xang = 0.0; yang = 3.14*1.5; zang = 0.0; 
  352.     shift.delta_x = 0.; shift.delta_y = 0.; shift.delta_z = 0;
  353.     pbuild_tran_matrix3(&xlv, &shift, xang, yang, zang,
  354.             &scale, &err, mx);
  355.     pset_local_tran3(mx, PTYPE_REPLACE);
  356.  
  357.     pset_int_colr_ind(GREEN);
  358.     PFILLAREA_CALL;
  359.  
  360. /* left */
  361.     xlv.delta_x = 15; xlv.delta_y = 5; xlv.delta_z = 5;
  362.     scale.delta_x = 1.0; scale.delta_y = 1.0; scale.delta_z = 1.0; 
  363.     xang = 0.0; yang = -3.14*1.5; zang = 0.0; 
  364.     shift.delta_x = 0.; shift.delta_y = 0.; shift.delta_z = 0;
  365.     pbuild_tran_matrix3(&xlv, &shift, xang, yang, zang,
  366.             &scale, &err, mx);
  367.     pset_local_tran3(mx, PTYPE_REPLACE);
  368.  
  369.     pset_int_colr_ind(BLUE);
  370.     PFILLAREA_CALL;
  371.  
  372. /* bottom */
  373.     xlv.delta_x = 5; xlv.delta_y = 5; xlv.delta_z = 5;
  374.     scale.delta_x = 1.0; scale.delta_y = 1.0; scale.delta_z = 1.0;
  375.     xang = -1.5*3.14; yang = 0.0; zang = 0.0; 
  376.     shift.delta_x = 0.; shift.delta_y = 0.; shift.delta_z = 0;
  377.     pbuild_tran_matrix3(&xlv, &shift, xang, yang, zang,
  378.             &scale, &err, mx);
  379.     pset_local_tran3(mx, PTYPE_REPLACE);
  380.  
  381.     pset_int_colr_ind( YELLOW);
  382.     PFILLAREA_CALL;
  383.  
  384. /* top */
  385.     xlv.delta_x = 5; xlv.delta_y = 15; xlv.delta_z = 5;
  386.     scale.delta_x = 1.0; scale.delta_y = 1.0; scale.delta_z = 1.0;
  387.     xang = 1.5*3.14; yang = 0.0; zang = 0.0; 
  388.     shift.delta_x = 0.; shift.delta_y = 0.; shift.delta_z = 0;
  389.     pbuild_tran_matrix3(&xlv, &shift, xang, yang, zang,
  390.             &scale, &err, mx);
  391.     pset_local_tran3(mx, PTYPE_REPLACE);
  392.  
  393.     pset_int_colr_ind(MAGENTA);
  394.     PFILLAREA_CALL;
  395.  
  396.     pclose_struct();
  397. }
  398.     
  399. Pview_map3 view_map = {
  400.     { -20.0, 20.0, -20.0, 20.0},
  401.     { 0.0, .5, 0.5, 1.0, 0.0, 1.0},
  402.     PTYPE_PERSPECT,
  403.     { 0., 0., 1000.0},
  404.     0.0,
  405.     -40.0,
  406.     40.0
  407. };
  408.  
  409. Pview_map3 view_map2 = {
  410.     { -20.0, 20.0, -20.0, 20.0},
  411.     { 0.5, 1.0, 0.5, 1.0, 0.0, 1.0},
  412.     PTYPE_PERSPECT,
  413.     { 0., 0., 1000.0},
  414.     0.0,
  415.     -40.0,
  416.     40.0
  417. };
  418.  
  419. Pview_map3 view_map3 = {
  420.     { -20.0, 20.0, -20.0, 20.0},
  421.     { 0.0, .5, 0., .5, 0.0, 1.0},
  422.     PTYPE_PERSPECT,
  423.     { 0., 0., 1000.0},
  424.     0.0,
  425.     -40.0,
  426.     40.0
  427. };
  428.  
  429. Pview_map3 view_map4 = {
  430.     { -20.0, 20.0, -20.0, 20.0},
  431.     { 0.5, 1.0, 0.,.5, 0.0, 1.0},
  432.     PTYPE_PERSPECT,
  433.     { 0., 0., 1000.0},
  434.     0.0,
  435.     -40.0,
  436.     40.0
  437. };
  438.  
  439. static void
  440. load_views(ws_id)
  441. Pint ws_id; 
  442. {
  443.     static Ppoint3 vrp = {0., 0., 0 };        /*  origin */
  444.     static Pvec3 vpn = {1.0, 1.0, 1.0 };    /*  view plane normal */
  445.     static Pvec3 vup = {0.0, 1.0, 0.0 };    /*  view up vector */
  446.     
  447.     Pview_rep3 vrep;                /*  view structure */
  448.  
  449.     Pint err;
  450.  
  451.     peval_view_ori_matrix3( &vrp, &vpn, &vup, &err, vrep.ori_matrix);
  452.  
  453.     if (err != 0) (void) printf( "view orientation error ");
  454.  
  455.     peval_view_map_matrix3(&view_map, &err, vrep.map_matrix);
  456.  
  457.     if (err != 0) (void) printf( "view mapping error ");
  458.  
  459.     vrep.clip_limit =  view_map.proj_vp;
  460.     vrep.xy_clip = PIND_NO_CLIP;
  461.     vrep.back_clip = PIND_NO_CLIP;
  462.     vrep.front_clip = PIND_NO_CLIP;
  463.     pset_view_rep3( ws_id, 1, &vrep);
  464. /*
  465.  *   viewport # 2
  466.  */
  467.     peval_view_ori_matrix3( &vrp, &vpn, &vup, &err, vrep.ori_matrix);
  468.  
  469.     if (err != 0) (void) printf( "view orientation error ");
  470.  
  471.     peval_view_map_matrix3 ( &view_map2, &err, vrep.map_matrix);
  472.  
  473.     if (err != 0) (void) printf( "view mapping error ");
  474.  
  475.     vrep.clip_limit =  view_map2.proj_vp;
  476.     vrep.xy_clip = PIND_NO_CLIP;
  477.     vrep.back_clip = PIND_NO_CLIP;
  478.     vrep.front_clip = PIND_NO_CLIP;
  479.     pset_view_rep3( ws_id, 2, &vrep);
  480. /*
  481.  *   viewport # 3
  482.  */
  483.     peval_view_ori_matrix3( &vrp, &vpn, &vup, &err, vrep.ori_matrix);
  484.  
  485.     if (err != 0) (void) printf( "view orientation error ");
  486.  
  487.     peval_view_map_matrix3( &view_map3, &err, vrep.map_matrix);
  488.  
  489.     if (err != 0) (void) printf( "view mapping error ");
  490.  
  491.     vrep.clip_limit =  view_map3.proj_vp;
  492.     vrep.xy_clip = PIND_NO_CLIP;
  493.     vrep.back_clip = PIND_NO_CLIP;
  494.     vrep.front_clip = PIND_NO_CLIP;
  495.     pset_view_rep3( ws_id, 3, &vrep);
  496. /*
  497.  *   viewport # 4
  498.  */
  499.     peval_view_ori_matrix3( &vrp, &vpn, &vup, &err, vrep.ori_matrix);
  500.  
  501.     if (err != 0) (void) printf ("view orientation error ");
  502.  
  503.     peval_view_map_matrix3( &view_map4, &err, vrep.map_matrix);
  504.  
  505.     if (err != 0) (void) printf( "view mapping error ");
  506.  
  507.     vrep.clip_limit =  view_map4.proj_vp;
  508.     vrep.xy_clip = PIND_NO_CLIP;
  509.     vrep.back_clip = PIND_NO_CLIP;
  510.     vrep.front_clip = PIND_NO_CLIP;
  511.     pset_view_rep3( ws_id, 4, &vrep);
  512. }
  513. static void
  514. build_css()
  515. {
  516.     Ppoint    line[2];
  517.     Ppoint_list p_line;
  518.     Pmatrix3    r1, r2, r3, r4;
  519.     Ppoint    text_pt;
  520.     char    text_str[32];
  521.  
  522.     setup( 4, r1);
  523.     setup( 4, r2);
  524.     setup( 4, r3);
  525.     setup( 4, r4);
  526.  
  527. /*
  528.  * ... open the root structure
  529.  */
  530.     popen_struct( ROOT);
  531.     pset_hlhsr_mode( WS1, 1);
  532.   
  533. /*
  534.  * ...  set up lines that split the viewports
  535.  */
  536.     pset_linewidth( 3.0);
  537.     pset_line_colr_ind( WHITE);
  538.     line[0].x = .5; line[0].y = 0.0; 
  539.     line[1].x = .5; line[1].y = 1.0;
  540.     p_line.num_points = 2;
  541.     p_line.points = line;
  542.     ppolyline( &p_line);
  543.  
  544.     line[0].x = 0.0; line[0].y = .5;
  545.     line[1].x = 1.0; line[1].y = .5;
  546.     ppolyline( &p_line);
  547. /*
  548.  * ... text to explain each viewport
  549.  */
  550.     pset_text_colr_ind( YELLOW);
  551.     pset_text_font(-2);            /* Server will use default font here */
  552.     pset_char_ht( .025);
  553.     text_pt.x = 0; text_pt.y = .52;
  554.     strcpy( text_str, " X Rotation");
  555.     plabel( QUAD_2);
  556.     ptext( &text_pt, text_str);
  557.    
  558.     text_pt.x = .5; text_pt.y = .58;
  559.     strcpy( text_str, " Y Rotation");
  560.     plabel( QUAD_1);
  561.     ptext( &text_pt, text_str);
  562.     text_pt.y = .52;
  563.     strcpy( text_str, " Backfaces Culled");
  564.     plabel( QUAD_1_1 );
  565.     ptext( &text_pt, text_str);
  566.  
  567.     text_pt.x = 0; text_pt.y = .02;
  568.     strcpy( text_str, " Z Rotation");
  569.     plabel( QUAD_3);
  570.     ptext( &text_pt, text_str);
  571.  
  572.     text_pt.x = .5; text_pt.y = .08;
  573.     strcpy( text_str, " XYZ Rotation");
  574.     plabel( QUAD_4);
  575.     ptext( &text_pt, text_str);
  576.     text_pt.y = .02;
  577.     strcpy( text_str, " Frontfaces Culled");
  578.     plabel( QUAD_4_1 );
  579.     ptext( &text_pt, text_str);
  580.  
  581.     pset_linewidth( 1.0);
  582.  
  583.     pexec_struct( SUB);
  584.     pclose_struct();
  585.  
  586.     popen_struct( SUB);
  587.     pset_view_ind( 1);
  588.     plabel( 1);
  589.     pset_local_tran3( r1, PTYPE_PRECONCAT);
  590.  
  591.     /* Cull no faces in this view */
  592.     pset_face_cull_mode(PCULL_NONE);
  593.  
  594.     pexec_struct( CUBE);
  595.  
  596.     pset_view_ind( 2);
  597.     plabel( 2);
  598.     pset_local_tran3( r2, PTYPE_PRECONCAT);
  599.  
  600.     /* Cull backfaces in this view */
  601.     pset_face_cull_mode(PCULL_BACKFACE);
  602.  
  603.     pexec_struct( CUBE);
  604.  
  605.     pset_view_ind( 3);
  606.     plabel( 3);
  607.     pset_local_tran3( r3, PTYPE_PRECONCAT);
  608.  
  609.     /* Cull no faces in this view */
  610.     pset_face_cull_mode(PCULL_NONE);
  611.  
  612.     pexec_struct( CUBE);
  613.  
  614.     pset_view_ind( 4);
  615.     plabel( 4);
  616.     pset_local_tran3( r4, PTYPE_PRECONCAT);
  617.  
  618.     /* Cull frontfaces in this view */
  619.     pset_face_cull_mode(PCULL_FRONTFACE);
  620.  
  621.     pexec_struct( CUBE);
  622.     pclose_struct();
  623. }
  624.  
  625. static void
  626. edit_css()
  627. {
  628.     popen_struct(CUBE);
  629.     pset_elem_ptr(0);
  630.     pset_elem_ptr_label(STYLE);
  631.     poffset_elem_ptr(1);
  632.     pset_int_style(PSTYLE_HOLLOW);
  633. /*
  634.  * ... close the structure being edited
  635.  */
  636.     pclose_struct();
  637. }
  638.  
  639. static void
  640. relabel_quadrants()
  641. {
  642.     char text_str[32];
  643.     Ppoint text_pt;
  644. /*
  645.  * ... relabel the quadrants
  646.  */
  647.     popen_struct( ROOT);
  648.     strcpy( text_str, " Zooming ");
  649.     text_pt.x = 0; text_pt.y = .52;
  650.     pset_elem_ptr( 0);
  651.     pset_elem_ptr_label( QUAD_2);
  652.     poffset_elem_ptr( 1);
  653.     ptext( &text_pt, text_str);
  654.  
  655.     text_pt.x = .5; text_pt.y = .52;
  656.     pset_elem_ptr_label( QUAD_1);
  657.     poffset_elem_ptr( 1);
  658.     ptext( &text_pt, text_str);
  659.  
  660.     text_pt.x = 0; text_pt.y = .02;
  661.     pset_elem_ptr_label( QUAD_3);
  662.     poffset_elem_ptr( 1);
  663.     ptext( &text_pt, text_str);
  664.  
  665.     text_pt.x = .5; text_pt.y = .02;
  666.     pset_elem_ptr_label( QUAD_4);
  667.     poffset_elem_ptr( 1);
  668.     ptext( &text_pt, text_str);
  669.  
  670.     /* Remove the "culling" text labels from the quadrants */
  671.  
  672.     pset_elem_ptr (0);
  673.     pset_elem_ptr_label( QUAD_1_1);
  674.     poffset_elem_ptr( 1);
  675.     pdel_elem();
  676.     pset_elem_ptr_label( QUAD_4_1);
  677.     poffset_elem_ptr( 1);
  678.     pdel_elem();
  679.  
  680.     pclose_struct();
  681. }
  682.  
  683. static void
  684. init_phigs()
  685. {
  686. #ifdef USE_X_DRAWABLE
  687.     extern Display *appl_display;
  688.     extern Window appl_window;
  689.     Pconnid_x_drawable conn;
  690. #endif /*USE_X_DRAWABLE*/
  691.  
  692.     Pmatrix3 s;
  693.     Pmatrix3 mat;
  694.     Pmatrix3 r1, r2, r3, r4;
  695.  
  696. #ifdef USE_X_DRAWABLE
  697.     conn.display = appl_display;
  698.     conn.drawable_id = appl_window;
  699. #endif /*USE_X_DRAWABLE*/
  700.  
  701. /* Initialization of matrices */
  702.  
  703.     setup( 4, mat);
  704.     setup( 4, s);
  705.  
  706.     setup( 4, r1);
  707.     setup( 4, r2);
  708.     setup( 4, r3);
  709.     setup( 4, r4);
  710. /*
  711.  * ...  set some constants for building the matrix
  712.  */
  713.     pt.x =  10.; pt.y = 10.; pt.z = 10.;
  714.     shift.delta_x = 0; shift.delta_y = 0; shift.delta_z = 0;
  715.     scale.delta_x = 1.0; scale.delta_y = 1.0; scale.delta_z = 1.0;
  716. /*
  717.  * ...  make identity matrices
  718.  */
  719.     setup(4, bldmat);
  720.     setup(4, bldmat2);
  721.     setup(4, bldmat3);
  722.     setup(4, bldmat4);
  723. /*
  724.  *   ... open a phigs workstation 
  725.  */
  726.     popen_phigs( NULL, 0);
  727.     {
  728.     Psys_st    sys_state;
  729.  
  730.     pinq_sys_st( &sys_state );
  731.     if (sys_state != PSYS_ST_PHOP) { exit(1); }
  732.     }
  733. #ifdef USE_X_DRAWABLE
  734.     popen_ws(WS1, (Pconnid)(&conn), phigs_ws_type_x_drawable);
  735. #else /*!USE_X_DRAWABLE*/
  736.     popen_ws(WS1, (Pconnid)NULL, phigs_ws_type_x_tool);
  737. #endif /*USE_X_DRAWABLE*/
  738.     {
  739.     Pws_st  ws_state;
  740.  
  741.     pinq_ws_st(&ws_state);
  742.     if (ws_state != PWS_ST_WSOP) { exit(3); }
  743.     }
  744.  
  745. /*
  746.  * ... initialize the viewports
  747.  */
  748.     load_views(WS1);
  749. /*
  750.  * ... load the structure containing the cube
  751.  */
  752.     load_box(); 
  753.  
  754.     build_css();
  755.  
  756. }
  757.  
  758. static void
  759. init()
  760. {
  761. #ifdef USE_X_DRAWABLE
  762.     init_window();
  763. #endif /* USE_X_DRAWABLE */
  764.     init_phigs();
  765. }
  766.  
  767. static void
  768. draw_image()
  769. {
  770.     float scale_factor;
  771.  
  772. /*
  773.  * ... post the structure  --- display it
  774.  */
  775.  
  776.     ppost_struct (WS1, ROOT, 0.0);
  777. #ifdef IGNORE
  778.     strcpy(buf,"Program will auto rotate and scale ... then exit");
  779.     pmessage( WS1, buf);
  780. #endif /*IGNORE*/
  781. /*
  782.  * ... rotate the four views
  783.  */
  784.     rotate_views();
  785.  
  786. /*
  787.  * ... turn off solids and make wireframe
  788.  */
  789.     edit_css();
  790. /*
  791.  * ... rotate the four views in wireframe
  792.  */
  793.     rotate_views();
  794.  
  795.     relabel_quadrants();
  796.  
  797. /*
  798.  * ... scale down the four views
  799.  */
  800.     scale_factor = .5;
  801.     scale_views( scale_factor );
  802. /*
  803.  * ... scale up the four views
  804.  */
  805.     scale_factor = 2.0;
  806.     scale_views( scale_factor );
  807.  
  808. /*
  809.  * test traversal
  810.  */
  811.     predraw_all_structs( WS1, PFLAG_ALWAYS);
  812. }
  813.  
  814. static void
  815. quit_program()
  816. {
  817. /*    clean up and close 
  818.  *    the workstation and Phigs
  819.  */
  820.     sleep(5);
  821.     pclose_ws(WS1);
  822.     pclose_phigs();
  823. }
  824.  
  825. main()
  826. {
  827.     init();
  828.     draw_image();
  829.     quit_program();
  830.     exit(0);
  831. }
  832.