home *** CD-ROM | disk | FTP | other *** search
/ Resource Library: Graphics / graphics-16000.iso / general / raytrace / renaisnc / delaunay.lha / Delaunay / starbase.c < prev    next >
C/C++ Source or Header  |  1992-01-04  |  7KB  |  314 lines
  1. /*
  2.  *  Null device for animation.  Provides stubs but does nothing.
  3.  */
  4.  
  5. #include <stdio.h>
  6. #include "k-Dtree.h"
  7. #include "Delaunay.h"
  8. #include <starbase.c.h>
  9. #include <sbdl.c.h>
  10.  
  11. #ifndef FALSE
  12. #  define FALSE 0
  13. #endif
  14. #ifndef TRUE
  15. #  define TRUE 1
  16. #endif
  17.  
  18.             /* Options that can be changed by the user */
  19. static int ShowTriangles = 1;
  20. static int ShowCells = 0;
  21. static int AnimationFrozen = 0;
  22. static int filedes;
  23. static int fdmouse;
  24. static int Outline=false;
  25.  
  26. AnimateInitialize( XL,YL,XH,YH) 
  27.      double XL, XH, YL, YH;
  28. {
  29.   /* Set up the user coordinate system.
  30.    *  XL is the x minimum
  31.    *  XH is the x maximum
  32.    *  ...
  33.    *
  34.    *  These are in the range [-1,1] as I recall (don't quote me)
  35.    */
  36.   float pl[2][3];
  37.   float r[3];
  38.   float p1[3];
  39.   float p2[3];
  40.   int cmap_size;
  41.   float xl,xh,yl,yh;
  42.   float size;
  43.  
  44.   inquire_sizes(filedes,pl,r,p1,p2,&cmap_size);
  45.   xl = pl[0][0]; yl = pl[0][1];
  46.   xh = pl[1][0]; yh = pl[1][1];
  47.   if ( (xh-xl)*r[0] < (yh-yl)*r[1] )
  48.     size = fabs(xh-xl)*r[0];
  49.   else
  50.     size = fabs(yh-yl)*r[1];
  51.   set_p1_p2(filedes, METRIC, 10., 10., 10., size-10.0, size-10.0, 20.);
  52.   vdc_extent(filedes, -1.0, -1.0, -1.0,   1.0, 1.0, 1.0);
  53. }
  54.  
  55. static void SetPoint(i, cl)
  56. int i;
  57. float cl[];
  58. {
  59.   float clist[20];
  60.   perPoint* pd;
  61.   Point* p;
  62.  
  63.   pd = PointData + i;
  64.   p = Points + i;
  65.   cl[0] = p->x;
  66.   cl[1] = p->y;
  67.   cl[2] = pd->r; cl[2] /= 255.;
  68.   cl[3] = pd->g; cl[3] /= 255.;
  69.   cl[4] = pd->b; cl[4] /= 255.;
  70. }
  71.  
  72. static void SetPoint2(x,y,r,g,b,cl)
  73. float x,y;
  74. short r,g,b;
  75. float cl[];
  76. {
  77.   cl[0] = x;
  78.   cl[1] = y;
  79.   cl[2] = r; cl[2] /= 255.;
  80.   cl[3] = g; cl[3] /= 255.;
  81.   cl[4] = b; cl[4] /= 255.;
  82. }
  83.  
  84. AnimateShadeTriangle( i, j, k )
  85.      register i,j,k;
  86. {
  87.   /* Shade a single triangle
  88.   ** i,j,k are vertex indicies.
  89.   **   Points[ i|j|k ] contains the vertex coordinates
  90.   **   PointData[ i|j|k ] contains the colors
  91.   */
  92.   float clist[20];
  93.  
  94.   if (!ANIMATING || AnimationFrozen || !ShowTriangles) return;
  95.  
  96.   SetPoint(i, clist);
  97.   SetPoint(j, clist+5);
  98.   SetPoint(k, clist+10);
  99.  
  100.   polygon2d(filedes, clist, 3, 0 );
  101.  
  102.   if ( Outline ) {
  103.     SetPoint(i, clist+15);
  104.     clist[2] = clist[3] = clist[4] = 
  105.     clist[7] = clist[8] = clist[9] = 
  106.     clist[12] = clist[13] = clist[14] =
  107.     clist[17] = clist[18] = clist[19] = 1.;
  108.     polyline2d(filedes,clist,4,0);
  109.   }
  110. }
  111.  
  112.  
  113. AnimateShadeCell( Boundary, Sample )
  114.      RectType *Boundary;
  115.      SampleData *Sample;
  116. {
  117.  
  118.   /* Fill a rectangular cell with a single color value */
  119.   /* PointData[ Sample->index ] contains the color. */
  120.   /* Boundary->{xL,yL,xH,yH} contain the rectangle bounds. */
  121.   float clist[20];
  122.   perPoint* pd;
  123.  
  124.   if (!ANIMATING || AnimationFrozen || !ShowCells) return;
  125.   pd = PointData + Sample->index;
  126.  
  127.   SetPoint2(Boundary->xL,Boundary->yL,pd->r,pd->g,pd->b,clist);
  128.   SetPoint2(Boundary->xL,Boundary->yH,pd->r,pd->g,pd->b,clist+5);
  129.   SetPoint2(Boundary->xH,Boundary->yH,pd->r,pd->g,pd->b,clist+10);
  130.   SetPoint2(Boundary->xH,Boundary->yL,pd->r,pd->g,pd->b,clist+15);
  131.   polygon2d(filedes, clist, 4, 0 );
  132. }
  133.  
  134. void Animate (Animation)
  135.      char *Animation;
  136. {
  137.   char* indev="/dev/hil_0.7";
  138.   char* s;
  139.  
  140.   ANIMATING = true;
  141.  
  142.   /* Initialize the graphics hardware */
  143.   filedes = gopen("/dev/crt0",OUTDEV,"hp98731",INIT);
  144.   if ( filedes < 0 ) {
  145.     fprintf(stderr,"gopen failed.\n");
  146.     exit(1);
  147.   }
  148.   shade_mode(filedes, CMAP_FULL|INIT, FALSE);
  149.   mapping_mode(filedes, ISOTROPIC);
  150.   double_buffer(filedes, 0, 24);
  151.   vertex_format(filedes, 3, 3, 1, 0, 1);
  152.  
  153.   if(s=getenv("SB_INDEV")) indev=s;
  154.   fdmouse = gopen(indev,INDEV,"hp-hil",0);
  155.   if ( fdmouse < 0 ) {
  156.     fprintf(stderr,"Can't open mouse.\n");
  157.   }
  158. } 
  159.  
  160.  
  161.  
  162. static void TrianglesReDraw()
  163. {
  164.   register TrianglePointer T;
  165.  
  166.   /* Step through all the triangles calling Animate Shade Triangle
  167.    * for each one.  These gives us a way to redraw on an expose event.
  168.    */
  169.   T = Triangles;
  170.   do
  171.     {
  172.       AnimateShadeTriangle( T->P1, T->P2, T->P3 );
  173.       T = T->Next;
  174.     }  
  175.   while (T != Triangles);
  176. }
  177.  
  178.  
  179. static void CellsReDraw()
  180. {
  181.   /*
  182.    *  Step through the kD-tree redrawing all leaf cells.
  183.    */
  184.   extern HierarchicalRegion Root;
  185.   extern RectType RootBoundary;
  186.   register HierarchicalRegion *Node;
  187.   RectType LeftBoundary, RightBoundary, Boundary, Overlap;
  188.  
  189.   /* This stack is used to avoid the expense of recursion */
  190.   HierarchicalRegion *NodeStack[MAX_DEPTH];
  191.   RectType BoundaryStack[MAX_DEPTH];
  192.   int levelStack[MAX_DEPTH];
  193.   int nStack, level;
  194.  
  195.   /* Start with the root node on the stack */
  196.   nStack = 0;
  197.   NodeStack[nStack] = &Root;
  198.   BoundaryStack[nStack] = RootBoundary;
  199.   levelStack[nStack++] = 0;
  200.  
  201.   while (nStack > 0) {
  202.  
  203.     /* Get the next node to process from the stack */
  204.     Node = NodeStack[--nStack];
  205.     Boundary = BoundaryStack[nStack];
  206.     level    = levelStack[nStack];
  207.     
  208.     /* Follow the tree down a leaf, pushing the side branches.
  209.      */
  210.     while (! IsLeaf(Node)) {
  211.  
  212.       SplitBoundary( TRUE, Node->splitDirection, Node->splitValue,
  213.             &Boundary, &LeftBoundary );
  214.       if (Node->Left) {
  215.     NodeStack[nStack] = Node->Left;
  216.     BoundaryStack[nStack] = LeftBoundary;
  217.     levelStack[nStack++] = level+1;
  218.       }
  219.       SplitBoundary( FALSE, Node->splitDirection, Node->splitValue, 
  220.             &Boundary, &RightBoundary );
  221.       if (Node->Right) {
  222.     if (nStack >= MAX_DEPTH) {
  223.       fprintf( stderr, "Filter stack overflow!\n"  );
  224.       abort();
  225.     }
  226.     NodeStack[nStack] = Node->Right;
  227.     BoundaryStack[nStack] = RightBoundary;
  228.     levelStack[nStack++] = level+1;
  229.       }
  230.  
  231.       /* Get the next node to process from the stack */
  232.       Node = NodeStack[--nStack];
  233.       Boundary = BoundaryStack[nStack];
  234.       level    = levelStack[nStack];
  235.     }
  236.   
  237.     if (Node == NULL)
  238.       continue;        /* Dead end, go back to the stack loop */
  239.   
  240.     AnimateShadeCell( &Boundary, Node->Sample );
  241.   }
  242. }
  243.  
  244.  
  245. static void AnimateReDraw()
  246. {
  247.   
  248.   /* Force a redraw */
  249.   if (ShowTriangles)    TrianglesReDraw();
  250.   if (ShowCells)        CellsReDraw();
  251. }
  252.  
  253.  
  254. AnimateDoEvent()
  255. {
  256.   double range;
  257.  
  258.   if (!ANIMATING) return;
  259.  
  260.   /* Respond to input events  */
  261. }
  262.  
  263.  
  264. int AnimateCheckInput()
  265. {
  266.   int valid;
  267.   int button;
  268.   int update=0;
  269.   static int last=0;
  270.  
  271.   /* Poll event queue and call AnimateDo Event if one is pending */
  272.   /* Look at mouse buttons */
  273.   if ( fdmouse >= 0 ) {
  274.       sample_choice(fdmouse,1,&valid,&button);
  275.       if ( button != 0 ) {
  276.         switch(button){
  277.         case 1:/* left */
  278.         if ( button != last )
  279.             Outline = !Outline;
  280.         break;
  281.         case 2:/* middle */
  282.         if ( button != last )
  283.             AnimationFrozen = !AnimationFrozen;
  284.         break;
  285.         case 3:/* right */
  286.         if ( button != last ) {
  287.             ShowCells = !ShowCells;
  288.             ShowTriangles = !ShowTriangles;
  289.             clear_view_surface(filedes);
  290.         }
  291.         break;
  292.         default:
  293.         break;
  294.         }
  295.         update = 1;
  296.       }
  297.       last = button;
  298.   }
  299.   if ( update && !AnimationFrozen ) {
  300.     AnimateReDraw();
  301.   }
  302. }
  303.  
  304.  
  305. AnimateExit()
  306. {
  307.   /* Call AnimateDoEvent until the user chooses to stop by ^C or picking
  308.      QUIT from the menu.
  309.   */
  310.   do {AnimateCheckInput();} while (1);
  311.   gclose(filedes);
  312. }
  313.  
  314.