src/hid/common/hidgl.c

   1 /*
   2  *                            COPYRIGHT
   3  *
   4  *  PCB, interactive printed circuit board design
   5  *  Copyright (C) 2009-2011 PCB Contributers (See ChangeLog for details)
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #ifdef HAVE_STRING_H
  30 #include <string.h>
  31 #endif
  32 #include <math.h>
  33 #include <assert.h>
  34
  35 /* The Linux OpenGL ABI 1.0 spec requires that we define
  36  * GL_GLEXT_PROTOTYPES before including gl.h or glx.h for extensions
  37  * in order to get prototypes:
  38  *   http://www.opengl.org/registry/ABI/
  39  */
  40 #define GL_GLEXT_PROTOTYPES 1
  41
  42 /* This follows autoconf's recommendation for the AX_CHECK_GL macro
  43    https://www.gnu.org/software/autoconf-archive/ax_check_gl.html */
  44 #if defined HAVE_WINDOWS_H && defined _WIN32
  45 #  include <windows.h>
  46 #endif
  47 #if defined HAVE_GL_GL_H
  48 #  include <GL/gl.h>
  49 #elif defined HAVE_OPENGL_GL_H
  50 #  include <OpenGL/gl.h>
  51 #else
  52 #  error autoconf couldnt find gl.h
  53 #endif
  54
  55 /* This follows autoconf's recommendation for the AX_CHECK_GLU macro
  56    https://www.gnu.org/software/autoconf-archive/ax_check_glu.html */
  57 #if defined HAVE_GL_GLU_H
  58 #  include <GL/glu.h>
  59 #elif defined HAVE_OPENGL_GLU_H
  60 #  include <OpenGL/glu.h>
  61 #else
  62 #  error autoconf couldnt find glu.h
  63 #endif
  64
  65 #include "action.h"
  66 #include "crosshair.h"
  67 #include "data.h"
  68 #include "error.h"
  69 #include "global.h"
  70 #include "mymem.h"
  71 #include "clip.h"
  72
  73 #include "hid.h"
  74 #include "hidgl.h"
  75 #include "rtree.h"
  76
  77 #ifdef HAVE_LIBDMALLOC
  78 #include <dmalloc.h>
  79 #endif
  80
  81
  82 triangle_buffer buffer;
  83 float global_depth = 0;
  84
  85 static void
  86 hidgl_init_triangle_array (triangle_buffer *buffer)
  87 {
  88   buffer->triangle_count = 0;
  89   buffer->coord_comp_count = 0;
  90 }
  91
  92 void
  93 hidgl_flush_triangles (triangle_buffer *buffer)
  94 {
  95   if (buffer->triangle_count == 0)
  96     return;
  97
  98   glEnableClientState (GL_VERTEX_ARRAY);
  99   glVertexPointer (3, GL_FLOAT, 0, buffer->triangle_array);
 100   glDrawArrays (GL_TRIANGLES, 0, buffer->triangle_count * 3);
 101   glDisableClientState (GL_VERTEX_ARRAY);
 102
 103   buffer->triangle_count = 0;
 104   buffer->coord_comp_count = 0;
 105 }
 106
 107 void
 108 hidgl_ensure_triangle_space (triangle_buffer *buffer, int count)
 109 {
 110   if (count > TRIANGLE_ARRAY_SIZE)
 111     {
 112       fprintf (stderr, "Not enough space in vertex buffer\n");
 113       fprintf (stderr, "Requested %i triangles, %i available\n",
 114                        count, TRIANGLE_ARRAY_SIZE);
 115       exit (1);
 116     }
 117   if (count > TRIANGLE_ARRAY_SIZE - buffer->triangle_count)
 118     hidgl_flush_triangles (buffer);
 119 }
 120
 121 void
 122 hidgl_set_depth (float depth)
 123 {
 124   global_depth = depth;
 125 }
 126
 127 /*!
 128  * \brief Draw the grid on the 3D canvas
 129  */
 130 void
 131 hidgl_draw_grid (BoxType *drawn_area, double coord_per_px)
 132 {
 133   static GLfloat *points = 0;
 134   static int npoints = 0;
 135   Coord x1, y1, x2, y2, n, i;
 136   double x, y;
 137   double pixels;
 138   double grid_px;
 139   double point_size;
 140
 141   if (!Settings.DrawGrid)
 142     return; /* grid hidden */
 143
 144   /* Find the bounding grid points, all others lay between them */
 145   x1 = GridFit (MAX (0, drawn_area->X1), PCB->Grid, PCB->GridOffsetX);
 146   y1 = GridFit (MAX (0, drawn_area->Y1), PCB->Grid, PCB->GridOffsetY);
 147   x2 = GridFit (MIN (PCB->MaxWidth, drawn_area->X2), PCB->Grid, PCB->GridOffsetX);
 148   y2 = GridFit (MIN (PCB->MaxHeight, drawn_area->Y2), PCB->Grid, PCB->GridOffsetY);
 149
 150   if (x1 > x2)
 151     {
 152       Coord tmp = x1;
 153       x1 = x2;
 154       x2 = tmp;
 155     }
 156
 157   if (y1 > y2)
 158     {
 159       Coord tmp = y1;
 160       y1 = y2;
 161       y2 = tmp;
 162     }
 163
 164   n = (int) ((x2 - x1) / PCB->Grid + 0.5) + 1; /* Number of points in one row */
 165   if (n > npoints)
 166     { /* [n]points are static, reallocate if we need more memory */
 167       npoints = n + 10;
 168       points = realloc (points, npoints * 3 * sizeof (GLfloat));
 169     }
 170
 171   pixels = (x2 - x1) / coord_per_px; /* visible grid area in pixels */
 172   grid_px = pixels / n; /* distance between grid dots in pixels */
 173   point_size = 1.0 + grid_px / 30.0;
 174   /* limit the maximum and minimum size of the grid dot - these should really be taken from settings */
 175   if (point_size > 4)
 176     {
 177       point_size = 4;
 178     }
 179   else if (point_size < 1)
 180     {
 181       point_size = 1;
 182     }
 183   /* ensure grid point size is an integer value to prevent moira artefacts */
 184   point_size = (int)(point_size + 0.5);
 185
 186   glPointSize (point_size);
 187   glEnableClientState (GL_VERTEX_ARRAY);
 188   glVertexPointer (3, GL_FLOAT, 0, points);
 189
 190   n = 0;
 191   for (x = x1; x <= x2; x += PCB->Grid)
 192     { /* compute all the x coordinates */
 193       points[3 * n + 0] = x;
 194       points[3 * n + 2] = global_depth;
 195       n++;
 196     }
 197   for (y = y1; y <= y2; y += PCB->Grid)
 198     { /* reuse the row of points at each y */
 199       for (i = 0; i < n; i++)
 200         points[3 * i + 1] = y;
 201       /* draw all the points in a row for a given y */
 202       glDrawArrays (GL_POINTS, 0, n);
 203     }
 204
 205   glDisableClientState (GL_VERTEX_ARRAY);
 206   glPointSize (1);
 207 }
 208
 209 #define MAX_PIXELS_ARC_TO_CHORD 0.5
 210 #define MIN_SLICES 6
 211 int calc_slices (float pix_radius, float sweep_angle)
 212 {
 213   float slices;
 214
 215   if (pix_radius <= MAX_PIXELS_ARC_TO_CHORD)
 216     return MIN_SLICES;
 217
 218   slices = sweep_angle / acosf (1 - MAX_PIXELS_ARC_TO_CHORD / pix_radius) / 2.;
 219   return (int)ceilf (slices);
 220 }
 221
 222 #define MIN_TRIANGLES_PER_CAP 3
 223 #define MAX_TRIANGLES_PER_CAP 90
 224 static void draw_cap (Coord width, Coord x, Coord y, Angle angle, double scale)
 225 {
 226   float last_capx, last_capy;
 227   float capx, capy;
 228   float radius = width / 2.;
 229   int slices = calc_slices (radius / scale, M_PI);
 230   int i;
 231
 232   if (slices < MIN_TRIANGLES_PER_CAP)
 233     slices = MIN_TRIANGLES_PER_CAP;
 234
 235   if (slices > MAX_TRIANGLES_PER_CAP)
 236     slices = MAX_TRIANGLES_PER_CAP;
 237
 238   hidgl_ensure_triangle_space (&buffer, slices);
 239
 240   last_capx =  radius * cosf (angle * M_PI / 180.) + x;
 241   last_capy = -radius * sinf (angle * M_PI / 180.) + y;
 242   for (i = 0; i < slices; i++) {
 243     capx =  radius * cosf (angle * M_PI / 180. + ((float)(i + 1)) * M_PI / (float)slices) + x;
 244     capy = -radius * sinf (angle * M_PI / 180. + ((float)(i + 1)) * M_PI / (float)slices) + y;
 245     hidgl_add_triangle (&buffer, last_capx, last_capy, capx, capy, x, y);
 246     last_capx = capx;
 247     last_capy = capy;
 248   }
 249 }
 250
 251 void
 252 hidgl_draw_line (int cap, Coord width, Coord x1, Coord y1, Coord x2, Coord y2, double scale)
 253 {
 254   double angle;
 255   double deltax, deltay, length;
 256   float wdx, wdy;
 257   int circular_caps = 0;
 258   int hairline = 0;
 259
 260   if (width == 0.0)
 261     hairline = 1;
 262
 263   if (width < scale)
 264     width = scale;
 265
 266   deltax = x2 - x1;
 267   deltay = y2 - y1;
 268
 269   length = hypot (deltax, deltay);
 270
 271   if (length == 0) {
 272     /* Assume the orientation of the line is horizontal */
 273     wdx = -width / 2.;
 274     wdy = 0;
 275     length = 1.;
 276     deltax = 1.;
 277     deltay = 0.;
 278   } else {
 279     wdy = deltax * width / 2. / length;
 280     wdx = -deltay * width / 2. / length;
 281   }
 282
 283   angle = -180. / M_PI * atan2 (deltay, deltax);
 284
 285   switch (cap) {
 286     case Trace_Cap:
 287     case Round_Cap:
 288       circular_caps = 1;
 289       break;
 290
 291     case Square_Cap:
 292     case Beveled_Cap:
 293       x1 -= deltax * width / 2. / length;
 294       y1 -= deltay * width / 2. / length;
 295       x2 += deltax * width / 2. / length;
 296       y2 += deltay * width / 2. / length;
 297       break;
 298   }
 299
 300   hidgl_ensure_triangle_space (&buffer, 2);
 301   hidgl_add_triangle (&buffer, x1 - wdx, y1 - wdy,
 302                                x2 - wdx, y2 - wdy,
 303                                x2 + wdx, y2 + wdy);
 304   hidgl_add_triangle (&buffer, x1 - wdx, y1 - wdy,
 305                                x2 + wdx, y2 + wdy,
 306                                x1 + wdx, y1 + wdy);
 307
 308   /* Don't bother capping hairlines */
 309   if (circular_caps && !hairline)
 310     {
 311       draw_cap (width, x1, y1, angle + 90., scale);
 312       draw_cap (width, x2, y2, angle - 90., scale);
 313     }
 314 }
 315
 316 #define MIN_SLICES_PER_ARC 6
 317 #define MAX_SLICES_PER_ARC 360
 318 void
 319 hidgl_draw_arc (Coord width, Coord x, Coord y, Coord rx, Coord ry,
 320                 Angle start_angle, Angle delta_angle, double scale)
 321 {
 322   float last_inner_x, last_inner_y;
 323   float last_outer_x, last_outer_y;
 324   float inner_x, inner_y;
 325   float outer_x, outer_y;
 326   float inner_r;
 327   float outer_r;
 328   float cos_ang, sin_ang;
 329   float start_angle_rad;
 330   float delta_angle_rad;
 331   float angle_incr_rad;
 332   int slices;
 333   int i;
 334   int hairline = 0;
 335
 336   if (width == 0.0)
 337     hairline = 1;
 338
 339   if (width < scale)
 340     width = scale;
 341
 342   inner_r = rx - width / 2.;
 343   outer_r = rx + width / 2.;
 344
 345   if (delta_angle < 0) {
 346     start_angle += delta_angle;
 347     delta_angle = - delta_angle;
 348   }
 349
 350   start_angle_rad = start_angle * M_PI / 180.;
 351   delta_angle_rad = delta_angle * M_PI / 180.;
 352
 353   slices = calc_slices ((rx + width / 2.) / scale, delta_angle_rad);
 354
 355   if (slices < MIN_SLICES_PER_ARC)
 356     slices = MIN_SLICES_PER_ARC;
 357
 358   if (slices > MAX_SLICES_PER_ARC)
 359     slices = MAX_SLICES_PER_ARC;
 360
 361   hidgl_ensure_triangle_space (&buffer, 2 * slices);
 362
 363   angle_incr_rad = delta_angle_rad / (float)slices;
 364
 365   cos_ang = cosf (start_angle_rad);
 366   sin_ang = sinf (start_angle_rad);
 367   last_inner_x = -inner_r * cos_ang + x;  last_inner_y = inner_r * sin_ang + y;
 368   last_outer_x = -outer_r * cos_ang + x;  last_outer_y = outer_r * sin_ang + y;
 369   for (i = 1; i <= slices; i++) {
 370     cos_ang = cosf (start_angle_rad + ((float)(i)) * angle_incr_rad);
 371     sin_ang = sinf (start_angle_rad + ((float)(i)) * angle_incr_rad);
 372     inner_x = -inner_r * cos_ang + x;  inner_y = inner_r * sin_ang + y;
 373     outer_x = -outer_r * cos_ang + x;  outer_y = outer_r * sin_ang + y;
 374     hidgl_add_triangle (&buffer, last_inner_x, last_inner_y,
 375                                  last_outer_x, last_outer_y,
 376                                  outer_x, outer_y);
 377     hidgl_add_triangle (&buffer, last_inner_x, last_inner_y,
 378                                  inner_x, inner_y,
 379                                  outer_x, outer_y);
 380     last_inner_x = inner_x;  last_inner_y = inner_y;
 381     last_outer_x = outer_x;  last_outer_y = outer_y;
 382   }
 383
 384   /* Don't bother capping hairlines */
 385   if (hairline)
 386     return;
 387
 388   draw_cap (width, x + rx * -cosf (start_angle_rad),
 389                    y + rx *  sinf (start_angle_rad),
 390                    start_angle, scale);
 391   draw_cap (width, x + rx * -cosf (start_angle_rad + delta_angle_rad),
 392                    y + rx *  sinf (start_angle_rad + delta_angle_rad),
 393                    start_angle + delta_angle + 180., scale);
 394 }
 395
 396 void
 397 hidgl_draw_rect (Coord x1, Coord y1, Coord x2, Coord y2)
 398 {
 399   glBegin (GL_LINE_LOOP);
 400   glVertex3f (x1, y1, global_depth);
 401   glVertex3f (x1, y2, global_depth);
 402   glVertex3f (x2, y2, global_depth);
 403   glVertex3f (x2, y1, global_depth);
 404   glEnd ();
 405 }
 406
 407
 408 void
 409 hidgl_fill_circle (Coord vx, Coord vy, Coord vr, double scale)
 410 {
 411 #define MIN_TRIANGLES_PER_CIRCLE 6
 412 #define MAX_TRIANGLES_PER_CIRCLE 360
 413   float last_x, last_y;
 414   float radius = vr;
 415   int slices;
 416   int i;
 417
 418   slices = calc_slices (vr / scale, 2 * M_PI);
 419
 420   if (slices < MIN_TRIANGLES_PER_CIRCLE)
 421     slices = MIN_TRIANGLES_PER_CIRCLE;
 422
 423   if (slices > MAX_TRIANGLES_PER_CIRCLE)
 424     slices = MAX_TRIANGLES_PER_CIRCLE;
 425
 426   hidgl_ensure_triangle_space (&buffer, slices);
 427
 428   last_x = vx + vr;
 429   last_y = vy;
 430
 431   for (i = 0; i < slices; i++) {
 432     float x, y;
 433     x = radius * cosf (((float)(i + 1)) * 2. * M_PI / (float)slices) + vx;
 434     y = radius * sinf (((float)(i + 1)) * 2. * M_PI / (float)slices) + vy;
 435     hidgl_add_triangle (&buffer, vx, vy, last_x, last_y, x, y);
 436     last_x = x;
 437     last_y = y;
 438   }
 439 }
 440
 441 #define MAX_COMBINED_MALLOCS 2500
 442 static void *combined_to_free [MAX_COMBINED_MALLOCS];
 443 static int combined_num_to_free = 0;
 444
 445 static GLenum tessVertexType;
 446 static int stashed_vertices;
 447 static int triangle_comp_idx;
 448
 449 #ifndef CALLBACK
 450 #define CALLBACK
 451 #endif
 452
 453 static void CALLBACK
 454 myError (GLenum errno)
 455 {
 456   printf ("gluTess error: %s\n", gluErrorString (errno));
 457 }
 458
 459 static void CALLBACK
 460 myCombine ( GLdouble coords[3], void *vertex_data[4], GLfloat weight[4], void **dataOut )
 461 {
 462 #define MAX_COMBINED_VERTICES 2500
 463   static GLdouble combined_vertices [3 * MAX_COMBINED_VERTICES];
 464   static int num_combined_vertices = 0;
 465
 466   GLdouble *new_vertex;
 467
 468   if (num_combined_vertices < MAX_COMBINED_VERTICES)
 469     {
 470       new_vertex = &combined_vertices [3 * num_combined_vertices];
 471       num_combined_vertices ++;
 472     }
 473   else
 474     {
 475       new_vertex = malloc (3 * sizeof (GLdouble));
 476
 477       if (combined_num_to_free < MAX_COMBINED_MALLOCS)
 478         combined_to_free [combined_num_to_free ++] = new_vertex;
 479       else
 480         printf ("myCombine leaking %lu bytes of memory\n",
 481                     (unsigned long)3 * sizeof (GLdouble));
 482     }
 483
 484   new_vertex[0] = coords[0];
 485   new_vertex[1] = coords[1];
 486   new_vertex[2] = coords[2];
 487
 488   *dataOut = new_vertex;
 489 }
 490
 491 static void CALLBACK
 492 myBegin (GLenum type)
 493 {
 494   tessVertexType = type;
 495   stashed_vertices = 0;
 496   triangle_comp_idx = 0;
 497 }
 498
 499 static double global_scale;
 500
 501 static void CALLBACK
 502 myVertex (GLdouble *vertex_data)
 503 {
 504   static GLfloat triangle_vertices [2 * 3];
 505
 506   if (tessVertexType == GL_TRIANGLE_STRIP ||
 507       tessVertexType == GL_TRIANGLE_FAN)
 508     {
 509       if (stashed_vertices < 2)
 510         {
 511           triangle_vertices [triangle_comp_idx ++] = vertex_data [0];
 512           triangle_vertices [triangle_comp_idx ++] = vertex_data [1];
 513           stashed_vertices ++;
 514         }
 515       else
 516         {
 517           hidgl_ensure_triangle_space (&buffer, 1);
 518           hidgl_add_triangle (&buffer,
 519                               triangle_vertices [0], triangle_vertices [1],
 520                               triangle_vertices [2], triangle_vertices [3],
 521                               vertex_data [0], vertex_data [1]);
 522
 523           if (tessVertexType == GL_TRIANGLE_STRIP)
 524             {
 525               /* STRIP saves the last two vertices for re-use in the next triangle */
 526               triangle_vertices [0] = triangle_vertices [2];
 527               triangle_vertices [1] = triangle_vertices [3];
 528             }
 529           /* Both FAN and STRIP save the last vertex for re-use in the next triangle */
 530           triangle_vertices [2] = vertex_data [0];
 531           triangle_vertices [3] = vertex_data [1];
 532         }
 533     }
 534   else if (tessVertexType == GL_TRIANGLES)
 535     {
 536       triangle_vertices [triangle_comp_idx ++] = vertex_data [0];
 537       triangle_vertices [triangle_comp_idx ++] = vertex_data [1];
 538       stashed_vertices ++;
 539       if (stashed_vertices == 3)
 540         {
 541           hidgl_ensure_triangle_space (&buffer, 1);
 542           hidgl_add_triangle (&buffer,
 543                               triangle_vertices [0], triangle_vertices [1],
 544                               triangle_vertices [2], triangle_vertices [3],
 545                               triangle_vertices [4], triangle_vertices [5]);
 546           triangle_comp_idx = 0;
 547           stashed_vertices = 0;
 548         }
 549     }
 550   else
 551     printf ("Vertex received with unknown type\n");
 552 }
 553
 554 static void
 555 myFreeCombined ()
 556 {
 557   while (combined_num_to_free)
 558     free (combined_to_free [-- combined_num_to_free]);
 559 }
 560
 561 void
 562 hidgl_fill_polygon (int n_coords, Coord *x, Coord *y)
 563 {
 564   int i;
 565   GLUtesselator *tobj;
 566   GLdouble *vertices;
 567
 568   assert (n_coords > 0);
 569
 570   vertices = malloc (sizeof(GLdouble) * n_coords * 3);
 571
 572   tobj = gluNewTess ();
 573   gluTessCallback(tobj, GLU_TESS_BEGIN,   (_GLUfuncptr)myBegin);
 574   gluTessCallback(tobj, GLU_TESS_VERTEX,  (_GLUfuncptr)myVertex);
 575   gluTessCallback(tobj, GLU_TESS_COMBINE, (_GLUfuncptr)myCombine);
 576   gluTessCallback(tobj, GLU_TESS_ERROR,   (_GLUfuncptr)myError);
 577
 578   gluTessBeginPolygon (tobj, NULL);
 579   gluTessBeginContour (tobj);
 580
 581   for (i = 0; i < n_coords; i++)
 582     {
 583       vertices [0 + i * 3] = x[i];
 584       vertices [1 + i * 3] = y[i];
 585       vertices [2 + i * 3] = 0.;
 586       gluTessVertex (tobj, &vertices [i * 3], &vertices [i * 3]);
 587     }
 588
 589   gluTessEndContour (tobj);
 590   gluTessEndPolygon (tobj);
 591   gluDeleteTess (tobj);
 592
 593   myFreeCombined ();
 594   free (vertices);
 595 }
 596
 597 void
 598 tesselate_contour (GLUtesselator *tobj, PLINE *contour, GLdouble *vertices,
 599                    double scale)
 600 {
 601   VNODE *vn = &contour->head;
 602   int offset = 0;
 603
 604   /* If the contour is round, and hidgl_fill_circle would use
 605    * less slices than we have vertices to draw it, then call
 606    * hidgl_fill_circle to draw this contour.
 607    */
 608   if (contour->is_round) {
 609     double slices = calc_slices (contour->radius / scale, 2 * M_PI);
 610     if (slices < contour->Count) {
 611       hidgl_fill_circle (contour->cx, contour->cy, contour->radius, scale);
 612       return;
 613     }
 614   }
 615
 616   gluTessBeginPolygon (tobj, NULL);
 617   gluTessBeginContour (tobj);
 618   do {
 619     vertices [0 + offset] = vn->point[0];
 620     vertices [1 + offset] = vn->point[1];
 621     vertices [2 + offset] = 0.;
 622     gluTessVertex (tobj, &vertices [offset], &vertices [offset]);
 623     offset += 3;
 624   } while ((vn = vn->next) != &contour->head);
 625   gluTessEndContour (tobj);
 626   gluTessEndPolygon (tobj);
 627 }
 628
 629 struct do_hole_info {
 630   GLUtesselator *tobj;
 631   GLdouble *vertices;
 632   double scale;
 633 };
 634
 635 static int
 636 do_hole (const BoxType *b, void *cl)
 637 {
 638   struct do_hole_info *info = cl;
 639   PLINE *curc = (PLINE *) b;
 640
 641   /* Ignore the outer contour - we draw it first explicitly*/
 642   if (curc->Flags.orient == PLF_DIR) {
 643     return 0;
 644   }
 645
 646   tesselate_contour (info->tobj, curc, info->vertices, info->scale);
 647   return 1;
 648 }
 649
 650 static GLint stencil_bits;
 651 static int dirty_bits = 0;
 652 static int assigned_bits = 0;
 653
 654 static void
 655 fill_polyarea (POLYAREA *pa, const BoxType *clip_box, double scale)
 656 {
 657   int vertex_count = 0;
 658   PLINE *contour;
 659   struct do_hole_info info;
 660   int stencil_bit;
 661
 662   info.scale = scale;
 663   global_scale = scale;
 664
 665   stencil_bit = hidgl_assign_clear_stencil_bit ();
 666   if (!stencil_bit)
 667     {
 668       printf ("hidgl_fill_pcb_polygon: No free stencil bits, aborting polygon\n");
 669       return;
 670     }
 671
 672   /* Flush out any existing geoemtry to be rendered */
 673   hidgl_flush_triangles (&buffer);
 674
 675   /* Walk the polygon structure, counting vertices */
 676   /* This gives an upper bound on the amount of storage required */
 677   for (contour = pa->contours; contour != NULL; contour = contour->next)
 678     vertex_count = MAX (vertex_count, contour->Count);
 679
 680   info.vertices = malloc (sizeof(GLdouble) * vertex_count * 3);
 681   info.tobj = gluNewTess ();
 682   gluTessCallback(info.tobj, GLU_TESS_BEGIN,   (_GLUfuncptr)myBegin);
 683   gluTessCallback(info.tobj, GLU_TESS_VERTEX,  (_GLUfuncptr)myVertex);
 684   gluTessCallback(info.tobj, GLU_TESS_COMBINE, (_GLUfuncptr)myCombine);
 685   gluTessCallback(info.tobj, GLU_TESS_ERROR,   (_GLUfuncptr)myError);
 686
 687   glPushAttrib (GL_STENCIL_BUFFER_BIT);                 /* Save the write mask etc.. for final restore */
 688   glEnable (GL_STENCIL_TEST);
 689   glPushAttrib (GL_STENCIL_BUFFER_BIT |                 /* Resave the stencil write-mask etc.., and */
 690                 GL_COLOR_BUFFER_BIT);                   /* the colour buffer write mask etc.. for part way restore */
 691   glStencilMask (stencil_bit);                          /* Only write to our stencil bit */
 692   glStencilFunc (GL_ALWAYS, stencil_bit, stencil_bit);  /* Always pass stencil test, ref value is our bit */
 693   glColorMask (0, 0, 0, 0);                             /* Disable writting in color buffer */
 694
 695   glStencilOp (GL_KEEP, GL_KEEP, GL_REPLACE);           /* Stencil pass => replace stencil value */
 696
 697   /* Drawing operations now set our reference bit in the stencil buffer */
 698
 699   r_search (pa->contour_tree, clip_box, NULL, do_hole, &info);
 700   hidgl_flush_triangles (&buffer);
 701
 702   glPopAttrib ();                               /* Restore the colour and stencil buffer write-mask etc.. */
 703
 704   glStencilOp (GL_KEEP, GL_KEEP, GL_INVERT);    /* This allows us to toggle the bit on any subcompositing bitplane */
 705                                                 /* If the stencil test has passed, we know that bit is 0, so we're */
 706                                                 /* effectively just setting it to 1. */
 707
 708   glStencilFunc (GL_GEQUAL, 0, assigned_bits);  /* Pass stencil test if all assigned bits clear, */
 709                                                 /* reference is all assigned bits so we set */
 710                                                 /* any bits permitted by the stencil writemask */
 711
 712   /* Drawing operations as masked to areas where the stencil buffer is '0' */
 713
 714   /* Draw the polygon outer */
 715   tesselate_contour (info.tobj, pa->contours, info.vertices, scale);
 716
 717   hidgl_flush_triangles (&buffer);
 718
 719   /* Unassign our stencil buffer bit */
 720   hidgl_return_stencil_bit (stencil_bit);
 721
 722   glPopAttrib ();                               /* Restore the stencil buffer write-mask etc.. */
 723
 724   gluDeleteTess (info.tobj);
 725   myFreeCombined ();
 726   free (info.vertices);
 727 }
 728
 729 void
 730 hidgl_fill_pcb_polygon (PolygonType *poly, const BoxType *clip_box, double scale)
 731 {
 732   if (poly->Clipped == NULL)
 733     return;
 734
 735   fill_polyarea (poly->Clipped, clip_box, scale);
 736
 737   if (TEST_FLAG (FULLPOLYFLAG, poly))
 738     {
 739       POLYAREA *pa;
 740
 741       for (pa = poly->Clipped->f; pa != poly->Clipped; pa = pa->f)
 742         fill_polyarea (pa, clip_box, scale);
 743     }
 744 }
 745
 746 void
 747 hidgl_fill_rect (Coord x1, Coord y1, Coord x2, Coord y2)
 748 {
 749   hidgl_ensure_triangle_space (&buffer, 2);
 750   hidgl_add_triangle (&buffer, x1, y1, x1, y2, x2, y2);
 751   hidgl_add_triangle (&buffer, x2, y1, x2, y2, x1, y1);
 752 }
 753
 754 void
 755 hidgl_init (void)
 756 {
 757   glGetIntegerv (GL_STENCIL_BITS, &stencil_bits);
 758
 759   if (stencil_bits == 0)
 760     {
 761       printf ("No stencil bits available.\n"
 762               "Cannot mask polygon holes or subcomposite layers\n");
 763       /* TODO: Flag this to the HID so it can revert to the dicer? */
 764     }
 765   else if (stencil_bits == 1)
 766     {
 767       printf ("Only one stencil bitplane available\n"
 768               "Cannot use stencil buffer to sub-composite layers.\n");
 769       /* Do we need to disable that somewhere? */
 770     }
 771 }
 772
 773 void
 774 hidgl_start_render (void)
 775 {
 776   hidgl_init ();
 777   hidgl_init_triangle_array (&buffer);
 778 }
 779
 780 void
 781 hidgl_finish_render (void)
 782 {
 783 }
 784
 785 int
 786 hidgl_stencil_bits (void)
 787 {
 788   return stencil_bits;
 789 }
 790
 791 static void
 792 hidgl_clean_unassigned_stencil (void)
 793 {
 794   glPushAttrib (GL_STENCIL_BUFFER_BIT);
 795   glStencilMask (~assigned_bits);
 796   glClearStencil (0);
 797   glClear (GL_STENCIL_BUFFER_BIT);
 798   glPopAttrib ();
 799 }
 800
 801 int
 802 hidgl_assign_clear_stencil_bit (void)
 803 {
 804   int stencil_bitmask = (1 << stencil_bits) - 1;
 805   int test;
 806   int first_dirty = 0;
 807
 808   if (assigned_bits == stencil_bitmask)
 809     {
 810       printf ("No more stencil bits available, total of %i already assigned\n",
 811               stencil_bits);
 812       return 0;
 813     }
 814
 815   /* Look for a bitplane we don't have to clear */
 816   for (test = 1; test & stencil_bitmask; test <<= 1)
 817     {
 818       if (!(test & dirty_bits))
 819         {
 820           assigned_bits |= test;
 821           dirty_bits |= test;
 822           return test;
 823         }
 824       else if (!first_dirty && !(test & assigned_bits))
 825         {
 826           first_dirty = test;
 827         }
 828     }
 829
 830   /* Didn't find any non dirty planes. Clear those dirty ones which aren't in use */
 831   hidgl_clean_unassigned_stencil ();
 832   assigned_bits |= first_dirty;
 833   dirty_bits = assigned_bits;
 834
 835   return first_dirty;
 836 }
 837
 838 void
 839 hidgl_return_stencil_bit (int bit)
 840 {
 841   assigned_bits &= ~bit;
 842 }
 843
 844 void
 845 hidgl_reset_stencil_usage (void)
 846 {
 847   assigned_bits = 0;
 848   dirty_bits = 0;
 849 }