home *** CD-ROM | disk | FTP | other *** search
/ Virtual Reality Zone / VRZONE.ISO / mac / PC / PCGLOVE / GLOVE / OBJGLV.ZIP / SRC / DEMO4B / RENDER.CPP < prev    next >
C/C++ Source or Header  |  1993-05-03  |  16KB  |  689 lines
  1. /* Written by Bernie Roehl, January 1992 */
  2. /* Redone by Dave Stampe for integer, fast polys, colors etc */
  3. /* Modified by Bernie Roehl to support surface types */
  4.  
  5. /* Copyright 1992 by Dave Stampe and Bernie Roehl.
  6.    May be freely used to write software for release into the public domain;
  7.    all commercial endeavours MUST contact Bernie Roehl and Dave Stamrpe
  8.    for permission to incorporate any part of this software into their
  9.    products!
  10.  */
  11.  
  12. /* Contact: broehl@sunee.waterloo.edu or dstampe@sunee.waterloo.edu */
  13.  
  14. #include <stdio.h>
  15. #include <dos.h>
  16. #include <conio.h>
  17.  
  18. #include "rend386.hpp"
  19. #include "vd2.hpp"
  20. #include "intmath.h"
  21. #include "splits.hpp"
  22. #include "colormap.hpp"
  23. #include "pointer.hpp"
  24. #include "cursor.hpp"
  25. #include "demo4.hpp"
  26.  
  27. #include "isr.hpp"
  28.  
  29. extern int ticks_per_second;
  30.  
  31. #define MAIN_VGA  1  /* for multi-VGA only */
  32. #define LEFT_VGA  2
  33. #define RIGHT_VGA 4
  34. #define ALL_VGA   7
  35.  
  36. #define MONOSCOPIC 0 /* stereo types */
  37. #define SWITCHED   1
  38. #define SPLITLR    3
  39. #define SEPARATE   5
  40.  
  41. struct Screeninfo *screeninfo;
  42.  
  43. //extern int set_colors(); /* defined in color file */
  44. extern int reset_colors();
  45. extern int screen_clear_color;
  46. extern int sky_color;
  47. extern int ground_color;
  48. extern int wireframe_color;
  49. extern int highlight_color;
  50. extern int highest_color;
  51.  
  52. extern int use_wide;
  53. extern int use_ht;
  54. extern int use_BW;
  55. extern int vdmode;
  56.  
  57. long display_tilt =8*65536L; /* correction for display toe-in */
  58.  
  59. enter_graphics() /* enter and setup graphics screen */
  60. {
  61.     int i;
  62.  
  63.     set_gmode(vdmode);
  64.     set_vpage(0);
  65.     set_drawpage(0);
  66.     clr_page(0,0);
  67.     set_colors(use_BW);
  68.  
  69.     return(0);
  70. }
  71.  
  72.  
  73. exit_graphics() /* exit and restore text screen */
  74. {
  75.     exit_gmode();
  76.     return 0;
  77. }
  78.  
  79. void clear_display(int pge)
  80. {
  81.     clr_page(pge,screen_clear_color);
  82. }
  83.  
  84. void ptpoly(int count, int *pcoords, int color)
  85. {
  86.     int surface_type = (color>>12)&3;
  87.  
  88.     color &= 0xFFF;
  89.  
  90.     switch (surface_type) {
  91.     case 0:
  92.     case 1:
  93.         fastpoly(count, pcoords, color);
  94.         break;
  95.     case 2:
  96.         m_fastpoly(count, pcoords, color, 0xFF, 0x00);
  97.         break;
  98.     case 3:
  99.         m_fastpoly(count, pcoords, color, 0xAA, 0xFF);
  100.         break;
  101.     }
  102. }
  103.  
  104.  
  105. extern int above_horizon(long x, long y, VIEW *v);
  106. extern long y_horizon(long x, VIEW *v);
  107. extern long x_horizon(long y, VIEW *v);
  108. extern int clr_block(int left, int top, int right, int bottom, int page, int color);
  109.  
  110. static void five(int x1, int y1, int x2, int y2, int x3, int y3,
  111.     int x4, int y4, int x5, int y5, int color)
  112. {
  113.     int p[10];
  114.     p[0] = x1; 
  115.     p[1] = y1;
  116.     p[2] = x2; 
  117.     p[3] = y2;
  118.     p[4] = x3; 
  119.     p[5] = y3;
  120.     p[6] = x4; 
  121.     p[7] = y4;
  122.     p[8] = x5;
  123.     p[9] = y5;
  124.  
  125.     ptpoly(5,&p[0], color);
  126. }
  127.  
  128. static void four(int x1, int y1, int x2, int y2, int x3, int y3,
  129.     int x4, int y4, int color)
  130. {
  131.     int p[8];
  132.     p[0] = x1; 
  133.     p[1] = y1;
  134.     p[2] = x2;
  135.     p[3] = y2;
  136.     p[4] = x3; 
  137.     p[5] = y3;
  138.     p[6] = x4; 
  139.     p[7] = y4;
  140.  
  141.     ptpoly(4,&p[0], color);
  142. }
  143.  
  144. static void three(int x1, int y1, int x2, int y2, int x3, int y3, int color)
  145. {
  146.     int p[6];
  147.     p[0] = x1; 
  148.     p[1] = y1;
  149.     p[2] = x2; 
  150.     p[3] = y2;
  151.     p[4] = x3; 
  152.     p[5] = y3;
  153.  
  154.     ptpoly(3,&p[0], color);
  155. }
  156.  
  157.  
  158. static void horizon(VIEW *v, int page)
  159. {
  160.     int l = v->left;
  161.     int r = v->right;
  162.     int t = v->top;
  163.     int b = v->bottom-1;
  164.     int mf1;
  165.     int pl,pr,pt,pb;
  166.  
  167.     mf1 = (above_horizon(l,t,v) ) +
  168.         (above_horizon(r,t,v)<<1) +
  169.         (above_horizon(l,b,v)<<2) +
  170.         (above_horizon(r,b,v)<<3) ;
  171.  
  172.     set_drawpage(page);
  173.     setup_hdwe(0);
  174.  
  175.     switch(mf1)
  176.     {
  177.     case 0:
  178.         clr_block(l, t, r, b, page, ground_color);
  179.         break;
  180.     case 15:
  181.         clr_block(l, t, r, b, page, sky_color);
  182.         break;
  183.     case 3:
  184.         pl = y_horizon(l,v);
  185.         pr = y_horizon(r,v);
  186.         if (pl == pr)
  187.         {
  188.             clr_block(l,t,r,pl-1,page,sky_color);
  189.             clr_block(l,pl,r,b,page,ground_color);
  190.             break;
  191.         }
  192.         four(r,t,l,t,l,pl,r,pr,sky_color);
  193.         four(l,b,r,b,r,pr,l,pl,ground_color);
  194.         break;
  195.     case 12:
  196.         pl = y_horizon(l,v);
  197.         pr = y_horizon(r,v);
  198.         if (pl == pr)
  199.         {
  200.             clr_block(l,t,r,pl-1,page,ground_color);
  201.             clr_block(l,pl,r,b,page,sky_color);
  202.             break;
  203.         }
  204.         four(r,t,l,t,l,pl,r,pr,ground_color);
  205.         four(l,b,r,b,r,pr,l,pl,sky_color);
  206.         break;
  207.     case 5:
  208.         pt = x_horizon(t,v);
  209.         pb = x_horizon(b,v);
  210.         four(l,t,l,b,pb,b,pt,t,sky_color);
  211.         four(r,b,r,t,pt,t,pb,b,ground_color);
  212.         break;
  213.     case 10:
  214.         pt = x_horizon(t,v);
  215.         pb = x_horizon(b,v);
  216.         four(l,t,l,b,pb,b,pt,t,ground_color);
  217.         four(r,b,r,t,pt,t,pb,b,sky_color);
  218.         break;
  219.     case 1:
  220.         pt = x_horizon(t,v);
  221.         pl = y_horizon(l,v);
  222.         three(l,t,l,pl,pt,t,sky_color);
  223.         five(l,b,r,b,r,t,pt,t,l,pl,ground_color);
  224.         break;
  225.     case 14:
  226.         pt = x_horizon(t,v);
  227.         pl = y_horizon(l,v);
  228.         three(l,t,l,pl,pt,t,ground_color);
  229.         five(l,b,r,b,r,t,pt,t,l,pl,sky_color);
  230.         break;
  231.     case 2:
  232.         pt = x_horizon(t,v);
  233.         pr = y_horizon(r,v);
  234.         three(r,t,pt,t,r,pr,sky_color);
  235.         five(l,t,l,b,r,b,r,pr,pt,t,ground_color);
  236.         break;
  237.     case 13:
  238.         pt = x_horizon(t,v);
  239.         pr = y_horizon(r,v);
  240.         three(r,t,pt,t,r,pr,ground_color);
  241.         five(l,t,l,b,r,b,r,pr,pt,t,sky_color);
  242.         break;
  243.     case 4:
  244.         pb = x_horizon(b,v);
  245.         pl = y_horizon(l,v);
  246.         three(l,pl,l,b,pb,b,sky_color);
  247.         five(r,b,r,t,l,t,l,pl,pb,b,ground_color);
  248.         break;
  249.     case 11:
  250.         pb = x_horizon(b,v);
  251.         pl = y_horizon(l,v);
  252.         three(l,pl,l,b,pb,b,ground_color);
  253.         five(r,b,r,t,l,t,l,pl,pb,b,sky_color);
  254.         break;
  255.     case 8:
  256.         pb = x_horizon(b,v);
  257.         pr = y_horizon(r,v);
  258.         three(pb,b,r,b,r,pr,sky_color);
  259.         five(r,t,l,t,l,b,pb,b,r,pr,ground_color);
  260.         break;
  261.     case 7:
  262.         pb = x_horizon(b,v);
  263.         pr = y_horizon(r,v);
  264.         three(pb,b,r,b,r,pr,ground_color);
  265.         five(r,t,l,t,l,b,pb,b,r,pr,sky_color);
  266.         break;
  267.     }
  268.     reset_hdwe();
  269. }
  270.  
  271.  
  272. extern volatile int has_switched; /* 3 when Sega has shown both eyes */
  273. extern int v_page;
  274. extern int fancy_background, reflection_pool, have_logo, show_logo;
  275. extern int do_screen_clear, do_horizon;
  276. extern int reframe, use_frame;
  277. extern int stereo_type;
  278. extern int swap_eyes;
  279. extern int left_page, right_page;
  280. extern STEREO default_stereo;
  281. extern SPLIT *split_tree;
  282. extern int show_location, show_compass, show_framerate;
  283.  
  284. extern int screen_clear_color;
  285.  
  286. long last_render_time = 8; /* time in 1/180 sec to redraw */
  287.  
  288. static int ccyc[30] = { 
  289.     0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
  290.     14,13,12,11,10,9,8,7,6,5,4,3,2,1 };
  291.  
  292. void background(int page, int top, int bot, int color)
  293. {
  294.     int inc = (top + (color & 15)) % 30;
  295.     color &= 0xF0;
  296.  
  297.     for (; top <= bot; top += 2)
  298.     {
  299.         clr_block(0, top, 319, top+1, page, color+ccyc[inc]);
  300.         if ((++inc) == 30) inc = 0;
  301.     }
  302. }
  303.  
  304. void reflection(int page, int top, int bot, int step)
  305. {
  306.     int src = top-step;
  307.  
  308.     for( ; top <= bot; top++)
  309.     {
  310.         copy_block(page, 0, src, page, 0, top, 320, 1);
  311.         src -= step;
  312.     }
  313. }
  314.  
  315. static void coord_ref(int xc, int yc, int size, VIEW *v, int xcolor, int ycolor, int zcolor, int bcolor)
  316. {
  317.     long x, y, z;
  318.     MATRIX m;
  319.  
  320.     if (show_compass == 0) return;
  321.  
  322.     view_to_matrix(v,m);
  323.     m[3][0] = m[3][1] = m[3][2] = 0;
  324.     matrix_transpose(m,m);
  325.  
  326.     setup_hdwe(0);
  327.     x = size; 
  328.     y = 0; 
  329.     z = 0;
  330.     matrix_point(m, &x, &y, &z);
  331.     if (v->orientation & XFLIP)
  332.     {
  333.         vgaline(xc,yc,xc-x,yc-y,bcolor);
  334.         printxyr(xc-x-5,yc-y,bcolor,"x",1);
  335.         setup_hdwe(0);
  336.         vgaline(xc-1,yc+1,xc-1-x,yc+1-y,xcolor);
  337.         printxyr(xc-x-5-1,yc-y+1,xcolor,"x",1);
  338.     }
  339.     else
  340.         {
  341.         vgaline(xc,yc,x+xc,yc-y,bcolor);
  342.         printxyr(x+xc+5,yc-y,bcolor,"x",0);
  343.         setup_hdwe(0);
  344.         vgaline(xc+1,yc+1,x+xc+1,yc-y+1,xcolor);
  345.         printxyr(x+xc+5+1,yc-y+1,xcolor,"x",0);
  346.     }
  347.  
  348.     setup_hdwe(0);
  349.     y = size; 
  350.     x = 0; 
  351.     z = 0;
  352.     matrix_point(m, &x, &y, &z);
  353.     if (v->orientation & XFLIP)
  354.     {
  355.         vgaline(xc,yc,xc-x,yc-y,bcolor);
  356.         printxyr(xc-x-5,yc-y,bcolor,"y",1);
  357.         setup_hdwe(0);
  358.         vgaline(xc-1,yc+1,xc-1-x,yc+1-y,ycolor);
  359.         printxyr(xc-x-5-1,yc-y+1,ycolor,"y",1);
  360.     }
  361.     else
  362.         {
  363.         vgaline(xc,yc,x+xc,yc-y,bcolor);
  364.         printxyr(x+xc+5,yc-y,bcolor,"y",0);
  365.         setup_hdwe(0);
  366.         vgaline(xc+1,yc+1,x+xc+1,yc-y+1,ycolor);
  367.         printxyr(x+xc+5+1,yc-y+1,ycolor,"y",0);
  368.     }
  369.  
  370.     setup_hdwe(0);
  371.     z = size; 
  372.     y = 0; 
  373.     x = 0;
  374.     matrix_point(m, &x, &y, &z);
  375.     if (v->orientation & XFLIP)
  376.     {
  377.         vgaline(xc,yc,xc-x,yc-y,bcolor);
  378.         printxyr(xc-x-5,yc-y,bcolor,"z",1);
  379.         setup_hdwe(0);
  380.         vgaline(xc-1,yc+1,xc-1-x,yc+1-y,zcolor);
  381.         printxyr(xc-x-5-1,yc-y+1,zcolor,"z",1);
  382.     }
  383.     else
  384.         {
  385.         vgaline(xc,yc,x+xc,yc-y,bcolor);
  386.         printxyr(x+xc+5,yc-y,bcolor,"z",0);
  387.         setup_hdwe(0);
  388.         vgaline(xc+1,yc+1,x+xc+1,yc-y+1,zcolor);
  389.         printxyr(x+xc+5+1,yc-y+1,zcolor,"z",0);
  390.     }
  391.     reset_hdwe();
  392. }
  393.  
  394.  
  395. static VIEW left_view, right_view;
  396.  
  397. extern int frame_x, frame_y, frame_w, frame_h;
  398.  
  399. void reset_screens()
  400. {
  401.     int i;
  402.     cursor_hide();
  403.     for (i = 0; i < 4; ++i) {
  404.         if (use_frame)
  405.             copy_block(3, 0, 0, i, frame_x, frame_y, frame_w, frame_h);
  406.         else
  407.             clear_display(i);
  408.     }
  409.     cursor_show(v_page);
  410. }
  411.  
  412. void screen_refresh(VIEW *current_view) /* now does stereo drawing */
  413. {
  414.     long old_time = tempISR::currentTime();
  415.     int mxpge = 2;
  416.     if (screeninfo->pages < 3) mxpge = 1;
  417.  
  418.     if (stereo_type == MONOSCOPIC)
  419.     {
  420.         if (reframe && use_frame) {
  421.             copy_block((v_page == 3) ? 0 : (v_page + 1), 0, 0,
  422.                 v_page, 0, 0, 320, 200);
  423.             reframe = 0;
  424.         }
  425.         if (++v_page > mxpge) v_page = 0; /* use 3 pages to avoid flicker */
  426.         set_drawpage(v_page);
  427.         if (fancy_background)
  428.         {
  429.             if (have_logo && show_logo)
  430.                 background(v_page, 30, reflection_pool ? 160 : 199, 0xBF);
  431.             else background(v_page, 0, reflection_pool ? 160 : 199, 0xB0);
  432.         }
  433.         else if (use_frame && do_screen_clear && !do_horizon)
  434.             clr_block(current_view->left,current_view->top,
  435.                 current_view->right,current_view->bottom,
  436.                 v_page,screen_clear_color);
  437.         else if (do_horizon) {
  438.             horizon(current_view,v_page);
  439.         }
  440.         else if (do_screen_clear)
  441.             clear_display(v_page);
  442.         if (have_logo && show_logo)
  443.             copy_block(3, 0, 0, v_page, 0, 0, 320, 30);
  444.         render_set_view(current_view);
  445.         render_split(split_tree, current_view);
  446.         if (reflection_pool) reflection(v_page, 160, 199, 3);
  447.         status_on_screen();
  448.         coord_ref(250,65,35,current_view,15,13,10,0);
  449.         set_vpage(v_page);
  450.         cursor_hide();
  451.     }
  452.  else if (stereo_type==SPLITLR)
  453.     {
  454.     if (++v_page > mxpge) v_page = 0; /* use 3 pages to avoid flicker */
  455.         make_stereo_view(current_view,&left_view,LEFT_EYE);
  456.  
  457.     set_drawpage(v_page);
  458.     render_set_view(&left_view);
  459.     if (do_horizon) horizon(&left_view,v_page);
  460.     else clear_display(v_page);
  461.  
  462.     render_split(split_tree, &left_view);
  463.     make_stereo_view(current_view,&right_view,RIGHT_EYE);
  464.     render_set_view(&right_view);
  465.     if (do_horizon) horizon(&right_view,v_page);
  466.     render_split(split_tree, &right_view);
  467.     set_vpage(v_page);
  468.     cursor_hide();
  469.     if (mxpge < 2) vsync();
  470.     }
  471.  else
  472.     {
  473.     v_page = v_page ^ 2;
  474.  
  475.     if (stereo_type == SWITCHED)
  476.         {
  477.         make_stereo_view(current_view,&left_view,0);
  478.         while ((has_switched&1) == 0) if (kbhit()) break;
  479.         if (do_horizon) horizon(&left_view,v_page);
  480.         else if (do_screen_clear)
  481.         clear_display(v_page);
  482.         set_drawpage(v_page);
  483.         render_set_view(&left_view);
  484.         render_split(split_tree, &left_view);
  485.         setup_hdwe(0);
  486. //        printxyr(20,10,0,"L",0);
  487.         status_on_screen();
  488.         reset_hdwe();
  489.         coord_ref(250,65,35,current_view,15,13,10,0);
  490.         make_stereo_view(current_view,&right_view,1);
  491.         while ((has_switched&2) == 0) if (kbhit()) break;
  492.         if (do_horizon) horizon(&right_view,v_page+1);
  493.         else if (do_screen_clear)
  494.             clear_display(v_page+1); /* right page */
  495.         set_drawpage(v_page+1);
  496.         render_set_view(&right_view);
  497.         render_split(split_tree, &right_view);
  498.         setup_hdwe(0);
  499. //        printxyr(300,10,0,"R",0);
  500.         status_on_screen();
  501.         reset_hdwe();
  502.         coord_ref(250,65,35,current_view,15,13,10,0);
  503.         disable();
  504.         if (swap_eyes)
  505.             {
  506.             left_page = v_page+1; /* display them now */
  507.             right_page = v_page;
  508.             }
  509.         else
  510.             {
  511.             left_page = v_page;
  512.             right_page = v_page+1;
  513.             }
  514.         has_switched = 0;
  515.         enable();
  516.         cursor_hide();
  517.         }
  518.     else if (stereo_type == SEPARATE) /* wide- angle display with seperate VGA cards */
  519.         {
  520.         set_drawpage(v_page);
  521.         VGA_select(swap_eyes ? RIGHT_VGA : LEFT_VGA|MAIN_VGA);
  522.         make_stereo_view(current_view, &left_view,0);
  523.         if (do_horizon) horizon(&left_view,v_page);
  524.         else if (do_screen_clear)
  525.                 clear_display(v_page);
  526.         render_set_view(&left_view);
  527.         render_split(split_tree, &left_view);
  528.         setup_hdwe(0);
  529. //        printxyr(20,10,0,"L",0);
  530.         reset_hdwe();
  531.  
  532.         VGA_select(swap_eyes ? LEFT_VGA|MAIN_VGA : RIGHT_VGA);
  533.         make_stereo_view(current_view, &right_view, 1);
  534.         if (do_horizon) horizon(&right_view,v_page);
  535.         else if (do_screen_clear)
  536.                 clear_display(v_page);
  537.         render_set_view(&right_view);
  538.         render_split(split_tree, &right_view);
  539.         setup_hdwe(0);
  540. //        printxyr(20,10,0,"R",1);
  541.         coord_ref(60,175,25,&right_view,15,14,13,0);
  542.         reset_hdwe();
  543.  
  544.         VGA_select(LEFT_VGA|MAIN_VGA);
  545.         set_vpage(v_page);
  546.         VGA_select(LEFT_VGA);
  547.         VGA_select(RIGHT_VGA);
  548.         set_vpage(v_page);
  549.         VGA_select(MAIN_VGA);
  550.         cursor_hide();
  551.         }
  552.     }
  553.  
  554.     last_render_time = tempISR::currentTime() - old_time;
  555.     if (last_render_time == 0) last_render_time++;
  556.     if (show_framerate)
  557.     {
  558.         char c[69];
  559.         sprintf(c,"Frames/sec: %d",tempISR::getTicksPerSecond()/last_render_time);
  560.         printxyr(5,170,15,c,0);
  561.     }
  562.     set_drawpage(v_page);
  563.     cursor_show(v_page);
  564.  
  565. }
  566.  
  567.  
  568.  
  569. /********************************************************/
  570. /* USER ROUTINES CALLED BY THE RENDERING LIBRARY        */
  571. /* KEEP THIS AS FAST AS POSSIBLE: SOME MAY BE           */
  572. /* CALLED UP TO 1000 TIMES PER SCREEN!                  */
  573. /********************************************************/
  574.  
  575. extern int wireframe;
  576.  
  577. /* USER ROUTINE TO SETUP FOR POLY DRAWING - CALLED ONCE PER FRAME */
  578. void user_setup_blitter()
  579. {
  580.     setup_hdwe(0);
  581. }
  582.  
  583. /* USER ROUTINE TO RECOVER AFTER POLY DRAWING: ONCE PER FRAME */
  584. void user_reset_blitter()
  585. {
  586.     reset_hdwe();
  587. }
  588.  
  589.  
  590. /* USER ROUTINE TO DRAW TEXT BOXES */
  591. void user_box(int x1, int y1, int x2, int y2, int color)
  592. {
  593.     int av[8];
  594.  
  595.     setup_hdwe(0);
  596.  
  597.     if (x1 < screeninfo->xmin) x1 = screeninfo->xmin; 
  598.     if (x2 < screeninfo->xmin) x2 = screeninfo->xmin;
  599.     if (y1 < screeninfo->ymin) y1 = screeninfo->ymin; 
  600.     if (y2 < screeninfo->ymin) y2 = screeninfo->ymin;
  601.     if (x1 > screeninfo->xmax) x1 = screeninfo->xmax; 
  602.     if (x2 > screeninfo->xmax) x2 = screeninfo->xmax;
  603.     if (y1 > screeninfo->ymax) y1 = screeninfo->ymax; 
  604.     if (y2 > screeninfo->ymax) y2 = screeninfo->ymax;
  605.  
  606.     av[0] = x1; 
  607.     av[1] = y1;
  608.     av[2] = x1; 
  609.     av[3] = y2;
  610.     av[4] = x2; 
  611.     av[5] = y2;
  612.     av[6] = x2; 
  613.     av[7] = y1;
  614.  
  615.     fastpoly(4, &av[0], color);
  616.     reset_hdwe();
  617. }
  618.  
  619. /* USER ROUTINE TO DRAW TEXT */
  620. void user_text(int x, int y, int color, char *string)
  621. {
  622.     printxyr(x, y, color, string,0);
  623. }
  624.  
  625.  
  626. static int x1, y1;
  627. static void vlineto(int x, int y, int color)
  628. {
  629.     vgaline(x,y,x1,y1,color);
  630.     x1 = x; 
  631.     y1 = y;
  632. }
  633.  
  634. /* CALLED FROM RENDREP TO DRAW POLYS */
  635.  
  636. #pragma argsused
  637. void user_render_poly(int number, int *pcoords, unsigned color, long maxz)
  638. {
  639.     int i;
  640.  
  641.     if (number == 1)
  642.     {
  643.         setup_hdwe(0);
  644.         vgapoint(pcoords[0], pcoords[1], color);
  645.         reset_hdwe();
  646.         return;
  647.     }
  648.     if (number == 2)
  649.     {
  650.         vgaline(pcoords[0],pcoords[1],pcoords[2],pcoords[3],color);
  651.         return;
  652.     }
  653.     if (!wireframe)
  654.     {
  655.         ptpoly(number, pcoords, color);
  656.  
  657.         if (color & 0x8000) /* highlighted? */
  658.         {
  659.             x1 = pcoords[0];
  660.             y1 = pcoords[1];
  661.             for (i = 1; i < number; ++i) vlineto(pcoords[i+i], pcoords[i+i+1], highlight_color);
  662.             vlineto(pcoords[0], pcoords[1], highlight_color);
  663.         }
  664.     }
  665.     else
  666.         {
  667.         x1 = pcoords[0];
  668.         y1 = pcoords[1];
  669.         for (i = 1; i < number; ++i) vlineto(pcoords[i+i], pcoords[i+i+1], wireframe_color);
  670.         vlineto(pcoords[0], pcoords[1], wireframe_color);
  671.     }
  672. }
  673.  
  674. void vgabox(int left, int top, int right, int bottom, int color)
  675. {
  676.     setup_hdwe(0);
  677.     vgaline(left, top, right, top, color);
  678.     vgaline(right, top, right, bottom, color);
  679.     vgaline(right, bottom, left, bottom, color);
  680.     vgaline(left, bottom, left, top, color);
  681.     reset_hdwe();
  682. }
  683.  
  684. #pragma argsused
  685. void VGA_select(int x)
  686. {
  687.  
  688. }
  689.