home *** CD-ROM | disk | FTP | other *** search
/ gondwana.ecr.mu.oz.au/pub/ / Graphics.tar / Graphics / VOGLE.ZIP / VOGLE / EXAMPLES / XVIEW / XVLCUBE.C < prev   
Encoding:
C/C++ Source or Header  |  1994-04-27  |  6.8 KB  |  448 lines
  1. #include <stdio.h>
  2. #include <math.h>
  3. #include <xview/xview.h>
  4. #include <xview/canvas.h>
  5. #include <xview/panel.h>
  6. #include "vogle.h"
  7.  
  8. #define SIZE    512
  9.  
  10. int    vinited = 0;
  11.  
  12. #define DOUBLEB        1
  13. #define BACKFACE    2
  14. #define FILL        4
  15. #define HATCH        8
  16.  
  17. #define TRANS           25.0
  18. #define SCAL            0.1
  19.  
  20. unsigned    flags = DOUBLEB | HATCH;
  21.  
  22. int    thing = HATCH;
  23.  
  24. float   tdir = TRANS;
  25. float   scal = 1.0 + SCAL;
  26. int     but, nplanes;
  27.  
  28. Display    *dpy;
  29. Window    win;
  30.  
  31. Panel_item     toggle;
  32.  
  33. do_plus()
  34. {
  35.     tdir = TRANS;
  36. }
  37.  
  38. do_minus()
  39. {
  40.     tdir = -tdir;
  41.  
  42.     if (scal < 1.0)
  43.         scal = 1.0 + SCAL;
  44.     else
  45.         scal = 1.0 - SCAL;
  46. }
  47.  
  48. do_back()
  49. {
  50.     if (flags & BACKFACE) {
  51.         backface(1);
  52.     } else {
  53.         backface(0);
  54.     }
  55. }
  56.  
  57. do_fill()
  58. {
  59.     if (flags & FILL) {
  60.         polyhatch(0);
  61.         polyfill(1);
  62.     } else {
  63.         polyfill(0);
  64.     }
  65. }
  66.  
  67. do_hatch()
  68. {
  69.     if (flags & HATCH) {
  70.         polyfill(0);
  71.         polyhatch(1);
  72.     } else {
  73.         polyhatch(0);
  74.     }
  75. }
  76.  
  77. do_scale()
  78. {
  79.     scale(scal, scal, scal);
  80. }
  81.  
  82. do_x()
  83. {
  84.     translate(tdir, 0.0, 0.0);
  85. }
  86. do_y()
  87. {
  88.     translate(0.0, tdir, 0.0);
  89. }
  90.  
  91. do_z()
  92. {
  93.     translate(0.0, 0.0, tdir);
  94. }
  95.  
  96. do_double()
  97. {
  98.     if (flags & DOUBLEB) {
  99.         backbuffer();
  100.     } else {
  101.         frontbuffer();
  102.     }
  103. }
  104.  
  105. quit()
  106. {
  107.     vexit();
  108.     exit(0);
  109. }
  110.  
  111.  
  112. resize(win, event, arg, type)
  113.     Xv_window       win;
  114.     Event           *event;
  115.     Notify_arg      arg;
  116.     Notify_event_type type;
  117. {
  118.     int    w, h;
  119.     
  120.     w = xv_get(win, XV_WIDTH);
  121.         h = xv_get(win, XV_HEIGHT);
  122.  
  123.     fprintf(stderr, "Resize proc: 0x%x, 0x%x (%d %d)\n", dpy, win, w, h);
  124.  
  125.         vo_xt_win_size(w, h);
  126.     viewport(-1.0, 1.0, -1.0, 1.0);
  127. }
  128.  
  129. menu_proc(menu, menu_item)
  130.     Menu        menu;
  131.     Menu_item    menu_item;
  132. {
  133.     char    *choice = (char *)xv_get(menu_item, MENU_STRING);
  134.  
  135.     if (!strcmp(choice, "DoubleBuffer")) {
  136.         if (flags & DOUBLEB)
  137.             flags &= ~DOUBLEB;
  138.         else
  139.             flags |= DOUBLEB;
  140.  
  141.         do_double();
  142.     } else if (!strcmp(choice, "Backface")) {
  143.         if (flags & BACKFACE)
  144.             flags &= ~BACKFACE;
  145.         else
  146.             flags |= BACKFACE;
  147.  
  148.         do_back();
  149.     } else if (!strcmp(choice, "Filled")) {
  150.         if (flags & FILL)
  151.             flags &= ~FILL;
  152.         else {
  153.             flags |= FILL;
  154.             flags &= ~HATCH;
  155.         }
  156.  
  157.         do_fill();
  158.     } else if (!strcmp(choice, "Hatched")) {
  159.         if (flags & HATCH)
  160.             flags &= ~HATCH;
  161.         else {
  162.             flags |= HATCH;
  163.             flags &= ~FILL;
  164.         }
  165.  
  166.         do_hatch();
  167.     } else if (!strcmp(choice, "QUIT"))
  168.         quit();
  169.  
  170.     xv_set(toggle, PANEL_VALUE, flags, NULL);
  171. }
  172.  
  173. /*
  174.  * Call menu_show() to display menu on right mouse button push.
  175.  */
  176. void
  177. my_event_proc(window, event)
  178.     Xv_Window window;
  179.     Event *event;
  180. {
  181.     if (event_action(event) == ACTION_MENU && event_is_down(event)) {
  182.         Menu menu = (Menu)xv_get(window, WIN_CLIENT_DATA);
  183.         menu_show(menu, window, event, NULL);
  184.     }
  185. }
  186.  
  187.  
  188.  
  189. toggle_selected(item, value, event)
  190.     Panel_item item;
  191.     unsigned value;
  192.     Event *event;
  193. {
  194.     char    buf[32];
  195.     Frame    frame = xv_get(item, PANEL_CLIENT_DATA);
  196.  
  197.     buf[0] = 0;
  198.  
  199.     if (event_id(event) == MS_LEFT) {
  200.         if (flags & HATCH)
  201.             if (value & FILL) {
  202.                 value &= ~HATCH;
  203.                 flags |= FILL;
  204.                 do_fill();
  205.             }
  206.  
  207.         if (flags & FILL)
  208.             if (value & HATCH) {
  209.                 value &= ~FILL;
  210.                 flags |= HATCH;
  211.                 do_hatch();
  212.             }
  213.  
  214.         flags = value;
  215.         do_back();
  216.         do_double();
  217.  
  218.         xv_set(item, PANEL_VALUE, flags, NULL);
  219.         xv_set(toggle, PANEL_VALUE, flags, NULL);
  220.  
  221.         return XV_OK;
  222.     }
  223.     return XV_ERROR;
  224. }
  225.  
  226. void
  227. do_hatchp(item, val, event)
  228.     Panel_item    item;
  229.     int        val;
  230.     Event        *event;
  231. {
  232.     hatchpitch((float)val);
  233. }
  234.  
  235. void
  236. do_hatcha(item, val, event)
  237.     Panel_item    item;
  238.     int        val;
  239.     Event        *event;
  240. {
  241.     hatchang((float)val);
  242. }
  243.  
  244. main(ac, av)
  245.     int    ac;
  246.     char    **av;
  247.     {
  248.     Frame        frame;
  249.     Canvas        canvas;
  250.     Panel        panel;
  251.     Menu        menu;
  252.     Notify_value    drawscene();
  253.     int        w, h;
  254.  
  255.     frame = xv_create(
  256.         0, FRAME,
  257.         FRAME_LABEL, av[1],
  258.         WIN_HEIGHT, SIZE,
  259.         WIN_WIDTH, SIZE,
  260.     0);
  261.  
  262.     canvas = xv_create(
  263.         frame, CANVAS,
  264.         CANVAS_RESIZE_PROC, resize,
  265.         WIN_HEIGHT, SIZE,
  266.         WIN_WIDTH, SIZE,
  267.     0);
  268.  
  269.     menu = xv_create(0, MENU, 
  270.         MENU_TITLE_ITEM, "Gunge",
  271.         MENU_STRINGS, "DoubleBuffer",
  272.                   "Backface",
  273.                   "Filled",
  274.                   "Hatched",
  275.                   "QUIT",
  276.                   NULL,
  277.         MENU_NOTIFY_PROC, menu_proc,
  278.         NULL
  279.     );
  280.  
  281.  
  282.     xv_set(canvas_paint_window(canvas),
  283.         WIN_CONSUME_EVENTS,  WIN_MOUSE_BUTTONS, NULL,
  284.         WIN_EVENT_PROC,  my_event_proc,
  285.         /* associate the menu to the canvas win for easy retrieval */
  286.         WIN_CLIENT_DATA,  menu,
  287.         NULL
  288.     );
  289.  
  290.     panel = xv_create(
  291.         frame, PANEL, 
  292.         WIN_BELOW, canvas,
  293.         WIN_X, 0,
  294.     0);
  295.  
  296.  
  297.     toggle = (Panel_item)xv_create(panel, PANEL_TOGGLE,
  298.         /*PANEL_FEEDBACK,         PANEL_MARKED,*/
  299.         PANEL_LABEL_STRING,     "Choices",
  300.         PANEL_VALUE,            flags, /* choice 1 */
  301.         PANEL_CHOICE_STRINGS,   "Double Buffer",
  302.                     "Backface",
  303.                     "Filled",
  304.                     "Hatched",
  305.                      NULL,
  306.         PANEL_NOTIFY_PROC,      toggle_selected,
  307.         PANEL_CLIENT_DATA,      frame,
  308.     0);
  309.  
  310.     panel_create_item(
  311.         panel, PANEL_BUTTON,
  312.         PANEL_LABEL_STRING, "Scale",
  313.  
  314.         PANEL_NEXT_ROW, -1, 
  315.         PANEL_NOTIFY_PROC, do_scale,
  316.     0);
  317.  
  318.     panel_create_item(
  319.         panel, PANEL_BUTTON,
  320.         PANEL_LABEL_STRING, "X-trans",
  321.  
  322.         PANEL_NOTIFY_PROC, do_x,
  323.     0);
  324.  
  325.     panel_create_item(
  326.         panel, PANEL_BUTTON,
  327.         PANEL_LABEL_STRING, "Y-trans",
  328.  
  329.         PANEL_NOTIFY_PROC, do_y,
  330.     0);
  331.  
  332.     panel_create_item(
  333.         panel, PANEL_BUTTON,
  334.         PANEL_LABEL_STRING, "Z-trans",
  335.  
  336.         PANEL_NOTIFY_PROC, do_z,
  337.     0);
  338.  
  339.     panel_create_item(
  340.         panel, PANEL_BUTTON,
  341.         PANEL_LABEL_STRING, "QUIT",
  342.  
  343.         PANEL_NOTIFY_PROC, quit,
  344.     0);
  345.  
  346.     panel_create_item(
  347.         panel, PANEL_BUTTON,
  348.         PANEL_LABEL_STRING, " + ",
  349.  
  350.         PANEL_NOTIFY_PROC, do_plus,
  351.     0);
  352.  
  353.     panel_create_item(
  354.         panel, PANEL_BUTTON,
  355.         PANEL_LABEL_STRING, " - ",
  356.         PANEL_NOTIFY_PROC, do_minus,
  357.     0);
  358.  
  359.     xv_set(panel, PANEL_LAYOUT, PANEL_VERTICAL, 0);
  360.  
  361.     panel_create_item(panel, PANEL_SLIDER,
  362.         PANEL_LABEL_STRING, "Hatchpitch",
  363.         PANEL_VALUE, 40,
  364.         PANEL_MIN_VALUE, 1,
  365.         PANEL_MAX_VALUE, 200,
  366.         PANEL_SLIDER_WIDTH, 200,
  367.         PANEL_NOTIFY_PROC, do_hatchp,
  368.         PANEL_NOTIFY_LEVEL, PANEL_ALL,
  369.         NULL
  370.     );
  371.         
  372.     panel_create_item(panel, PANEL_SLIDER,
  373.         PANEL_LABEL_STRING, "Hatchangle",
  374.         PANEL_VALUE, 40,
  375.         PANEL_MIN_VALUE, 0,
  376.         PANEL_MAX_VALUE, 180,
  377.         PANEL_SLIDER_WIDTH, 200,
  378.         PANEL_NOTIFY_PROC, do_hatcha,
  379.         PANEL_NOTIFY_LEVEL, PANEL_ALL,
  380.         NULL
  381.     );
  382.  
  383.  
  384.     window_fit(panel);
  385.     window_fit(frame);
  386.  
  387.     w = (int)window_get(canvas, WIN_WIDTH);
  388.     h = (int)window_get(canvas, WIN_HEIGHT);
  389.     win = (Window)xv_get(canvas_paint_window(canvas), XV_XID);
  390.     dpy = (Display *)xv_get(frame, XV_DISPLAY);
  391.  
  392.     vo_xt_window(dpy, win, w, h);
  393.     vinit("X11");
  394.  
  395.     setup_lcube();
  396.  
  397.     polyhatch(1);
  398.     hatchang(45.0);
  399.  
  400.     vinited = 1;
  401.  
  402. #define USE_TIMER 1
  403. #ifdef USE_TIMER
  404. /* The following sets the timer */
  405.  
  406.     /* FAST AS POSSIBLE */
  407.  
  408.     notify_set_itimer_func(frame,
  409.         (Notify_func)drawscene, ITIMER_REAL, &NOTIFY_POLLING_ITIMER, NULL);
  410.  
  411.     xv_main_loop(frame);
  412.  
  413. #else
  414.     xv_set(frame, WIN_SHOW, TRUE, NULL);
  415.  
  416.     while(1) {
  417.         XFlush(dpy);
  418.         notify_dispatch();
  419.         drawscene((Notify_client)canvas, 1);
  420.     }
  421. #endif
  422. }
  423.  
  424. Notify_value
  425. drawscene(c, fd)
  426.     Notify_client c;
  427.     int    fd;
  428. {
  429.     float    x, y;
  430.  
  431.     (void)slocator(&x, &y);
  432.     x *= 90;
  433.     y *= 90;
  434.     pushmatrix();
  435.         rotate(x, 'y');
  436.         rotate(y, 'x');
  437.         color(BLACK);
  438.         clear();
  439.         callobj(thing);
  440.     popmatrix();
  441.  
  442.     if (flags & DOUBLEB)
  443.         swapbuffers();
  444.  
  445.     return NOTIFY_DONE;
  446. }
  447.  
  448.