tools/quake3/q3map2/tjunction.c

   1 /* -------------------------------------------------------------------------------
   2
   3 Copyright (C) 1999-2007 id Software, Inc. and contributors.
   4 For a list of contributors, see the accompanying CONTRIBUTORS file.
   5
   6 This file is part of GtkRadiant.
   7
   8 GtkRadiant is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 GtkRadiant is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GtkRadiant; if not, write to the Free Software
  20 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  21
  22 ----------------------------------------------------------------------------------
  23
  24 This code has been altered significantly from its original form, to support
  25 several games based on the Quake III Arena engine, in the form of "Q3Map2."
  26
  27 ------------------------------------------------------------------------------- */
  28
  29
  30
  31 /* marker */
  32 #define TJUNCTION_C
  33
  34
  35
  36 /* dependencies */
  37 #include "q3map2.h"
  38
  39
  40
  41
  42 typedef struct edgePoint_s {
  43         float           intercept;
  44         vec3_t          xyz;
  45         struct edgePoint_s      *prev, *next;
  46 } edgePoint_t;
  47
  48 typedef struct edgeLine_s {
  49         vec3_t          normal1;
  50         float           dist1;
  51
  52         vec3_t          normal2;
  53         float           dist2;
  54
  55         vec3_t          origin;
  56         vec3_t          dir;
  57
  58         edgePoint_t     chain;          // unused element of doubly linked list
  59 } edgeLine_t;
  60
  61 typedef struct {
  62         float           length;
  63         bspDrawVert_t   *dv[2];
  64 } originalEdge_t;
  65
  66 originalEdge_t  *originalEdges = NULL;
  67 int                             numOriginalEdges;
  68 int                             allocatedOriginalEdges = 0;
  69
  70
  71 edgeLine_t              *edgeLines = NULL;
  72 int                             numEdgeLines;
  73 int                             allocatedEdgeLines = 0;
  74
  75 int                             c_degenerateEdges;
  76 int                             c_addedVerts;
  77 int                             c_totalVerts;
  78
  79 int                             c_natural, c_rotate, c_cant;
  80
  81 // these should be whatever epsilon we actually expect,
  82 // plus SNAP_INT_TO_FLOAT
  83 #define LINE_POSITION_EPSILON   0.25
  84 #define POINT_ON_LINE_EPSILON   0.25
  85
  86 /*
  87 ====================
  88 InsertPointOnEdge
  89 ====================
  90 */
  91 void InsertPointOnEdge( vec3_t v, edgeLine_t *e ) {
  92         vec3_t          delta;
  93         float           d;
  94         edgePoint_t     *p, *scan;
  95
  96         VectorSubtract( v, e->origin, delta );
  97         d = DotProduct( delta, e->dir );
  98
  99         p = safe_malloc( sizeof(edgePoint_t) );
 100         p->intercept = d;
 101         VectorCopy( v, p->xyz );
 102
 103         if ( e->chain.next == &e->chain ) {
 104                 e->chain.next = e->chain.prev = p;
 105                 p->next = p->prev = &e->chain;
 106                 return;
 107         }
 108
 109         scan = e->chain.next;
 110         for ( ; scan != &e->chain ; scan = scan->next ) {
 111                 d = p->intercept - scan->intercept;
 112                 if ( d > -LINE_POSITION_EPSILON && d < LINE_POSITION_EPSILON ) {
 113                         free( p );
 114                         return;         // the point is already set
 115                 }
 116
 117                 if ( p->intercept < scan->intercept ) {
 118                         // insert here
 119                         p->prev = scan->prev;
 120                         p->next = scan;
 121                         scan->prev->next = p;
 122                         scan->prev = p;
 123                         return;
 124                 }
 125         }
 126
 127         // add at the end
 128         p->prev = scan->prev;
 129         p->next = scan;
 130         scan->prev->next = p;
 131         scan->prev = p;
 132 }
 133
 134
 135 /*
 136 ====================
 137 AddEdge
 138 ====================
 139 */
 140 int AddEdge( vec3_t v1, vec3_t v2, qboolean createNonAxial ) {
 141         int                     i;
 142         edgeLine_t      *e;
 143         float           d;
 144         vec3_t          dir;
 145
 146         VectorSubtract( v2, v1, dir );
 147         d = VectorNormalize( dir, dir );
 148         if ( d < 0.1 ) {
 149                 // if we added a 0 length vector, it would make degenerate planes
 150                 c_degenerateEdges++;
 151                 return -1;
 152         }
 153
 154         if ( !createNonAxial ) {
 155                 if ( fabs( dir[0] + dir[1] + dir[2] ) != 1.0 ) {
 156                         AUTOEXPAND_BY_REALLOC(originalEdges, numOriginalEdges, allocatedOriginalEdges, 1024);
 157                         originalEdges[ numOriginalEdges ].dv[0] = (bspDrawVert_t *)v1;
 158                         originalEdges[ numOriginalEdges ].dv[1] = (bspDrawVert_t *)v2;
 159                         originalEdges[ numOriginalEdges ].length = d;
 160                         numOriginalEdges++;
 161                         return -1;
 162                 }
 163         }
 164
 165         for ( i = 0 ; i < numEdgeLines ; i++ ) {
 166                 e = &edgeLines[i];
 167
 168                 d = DotProduct( v1, e->normal1 ) - e->dist1;
 169                 if ( d < -POINT_ON_LINE_EPSILON || d > POINT_ON_LINE_EPSILON ) {
 170                         continue;
 171                 }
 172                 d = DotProduct( v1, e->normal2 ) - e->dist2;
 173                 if ( d < -POINT_ON_LINE_EPSILON || d > POINT_ON_LINE_EPSILON ) {
 174                         continue;
 175                 }
 176
 177                 d = DotProduct( v2, e->normal1 ) - e->dist1;
 178                 if ( d < -POINT_ON_LINE_EPSILON || d > POINT_ON_LINE_EPSILON ) {
 179                         continue;
 180                 }
 181                 d = DotProduct( v2, e->normal2 ) - e->dist2;
 182                 if ( d < -POINT_ON_LINE_EPSILON || d > POINT_ON_LINE_EPSILON ) {
 183                         continue;
 184                 }
 185
 186                 // this is the edge
 187                 InsertPointOnEdge( v1, e );
 188                 InsertPointOnEdge( v2, e );
 189                 return i;
 190         }
 191
 192         // create a new edge
 193         AUTOEXPAND_BY_REALLOC(edgeLines, numEdgeLines, allocatedEdgeLines, 1024);
 194
 195         e = &edgeLines[ numEdgeLines ];
 196         numEdgeLines++;
 197
 198         e->chain.next = e->chain.prev = &e->chain;
 199
 200         VectorCopy( v1, e->origin );
 201         VectorCopy( dir, e->dir );
 202
 203         MakeNormalVectors( e->dir, e->normal1, e->normal2 );
 204         e->dist1 = DotProduct( e->origin, e->normal1 );
 205         e->dist2 = DotProduct( e->origin, e->normal2 );
 206
 207         InsertPointOnEdge( v1, e );
 208         InsertPointOnEdge( v2, e );
 209
 210         return numEdgeLines - 1;
 211 }
 212
 213
 214
 215 /*
 216 AddSurfaceEdges()
 217 adds a surface's edges
 218 */
 219
 220 void AddSurfaceEdges( mapDrawSurface_t *ds )
 221 {
 222         int             i;
 223
 224
 225         for( i = 0; i < ds->numVerts; i++ )
 226         {
 227                 /* save the edge number in the lightmap field so we don't need to look it up again */
 228                 ds->verts[i].lightmap[ 0 ][ 0 ] =
 229                         AddEdge( ds->verts[ i ].xyz, ds->verts[ (i + 1) % ds->numVerts ].xyz, qfalse );
 230         }
 231 }
 232
 233
 234
 235 /*
 236 ColinearEdge()
 237 determines if an edge is colinear
 238 */
 239
 240 qboolean ColinearEdge( vec3_t v1, vec3_t v2, vec3_t v3 )
 241 {
 242         vec3_t  midpoint, dir, offset, on;
 243         float   d;
 244
 245         VectorSubtract( v2, v1, midpoint );
 246         VectorSubtract( v3, v1, dir );
 247         d = VectorNormalize( dir, dir );
 248         if ( d == 0 ) {
 249                 return qfalse;  // degenerate
 250         }
 251
 252         d = DotProduct( midpoint, dir );
 253         VectorScale( dir, d, on );
 254         VectorSubtract( midpoint, on, offset );
 255         d = VectorLength ( offset );
 256
 257         if ( d < 0.1 ) {
 258                 return qtrue;
 259         }
 260
 261         return qfalse;
 262 }
 263
 264
 265
 266 /*
 267 ====================
 268 AddPatchEdges
 269
 270 Add colinear border edges, which will fix some classes of patch to
 271 brush tjunctions
 272 ====================
 273 */
 274 void AddPatchEdges( mapDrawSurface_t *ds ) {
 275         int             i;
 276         float   *v1, *v2, *v3;
 277
 278         for ( i = 0 ; i < ds->patchWidth - 2; i+=2 ) {
 279                 v1 = ds->verts[ i ].xyz;
 280                 v2 = ds->verts[ i + 1 ].xyz;
 281                 v3 = ds->verts[ i + 2 ].xyz;
 282
 283                 // if v2 is the midpoint of v1 to v3, add an edge from v1 to v3
 284                 if ( ColinearEdge( v1, v2, v3 ) ) {
 285                         AddEdge( v1, v3, qfalse );
 286                 }
 287
 288                 v1 = ds->verts[ ( ds->patchHeight - 1 ) * ds->patchWidth + i ].xyz;
 289                 v2 = ds->verts[ ( ds->patchHeight - 1 ) * ds->patchWidth + i + 1 ].xyz;
 290                 v3 = ds->verts[ ( ds->patchHeight - 1 ) * ds->patchWidth + i + 2 ].xyz;
 291
 292                 // if v2 is on the v1 to v3 line, add an edge from v1 to v3
 293                 if ( ColinearEdge( v1, v2, v3 ) ) {
 294                         AddEdge( v1, v3, qfalse );
 295                 }
 296         }
 297
 298         for ( i = 0 ; i < ds->patchHeight - 2 ; i+=2 ) {
 299                 v1 = ds->verts[ i * ds->patchWidth ].xyz;
 300                 v2 = ds->verts[ ( i + 1 ) * ds->patchWidth ].xyz;
 301                 v3 = ds->verts[ ( i + 2 ) * ds->patchWidth ].xyz;
 302
 303                 // if v2 is the midpoint of v1 to v3, add an edge from v1 to v3
 304                 if ( ColinearEdge( v1, v2, v3 ) ) {
 305                         AddEdge( v1, v3, qfalse );
 306                 }
 307
 308                 v1 = ds->verts[ ( ds->patchWidth - 1 ) + i * ds->patchWidth ].xyz;
 309                 v2 = ds->verts[ ( ds->patchWidth - 1 ) + ( i + 1 ) * ds->patchWidth ].xyz;
 310                 v3 = ds->verts[ ( ds->patchWidth - 1 ) + ( i + 2 ) * ds->patchWidth ].xyz;
 311
 312                 // if v2 is the midpoint of v1 to v3, add an edge from v1 to v3
 313                 if ( ColinearEdge( v1, v2, v3 ) ) {
 314                         AddEdge( v1, v3, qfalse );
 315                 }
 316         }
 317
 318
 319 }
 320
 321
 322 /*
 323 ====================
 324 FixSurfaceJunctions
 325 ====================
 326 */
 327 #define MAX_SURFACE_VERTS       256
 328 void FixSurfaceJunctions( mapDrawSurface_t *ds ) {
 329         int                     i, j, k;
 330         edgeLine_t      *e;
 331         edgePoint_t     *p;
 332         int                     originalVerts;
 333         int                     counts[MAX_SURFACE_VERTS];
 334         int                     originals[MAX_SURFACE_VERTS];
 335         int                     firstVert[MAX_SURFACE_VERTS];
 336         bspDrawVert_t   verts[MAX_SURFACE_VERTS], *v1, *v2;
 337         int                     numVerts;
 338         float           start, end, frac, c;
 339         vec3_t          delta;
 340
 341
 342         originalVerts = ds->numVerts;
 343
 344         numVerts = 0;
 345         for ( i = 0 ; i < ds->numVerts ; i++ )
 346         {
 347                 counts[i] = 0;
 348                 firstVert[i] = numVerts;
 349
 350                 // copy first vert
 351                 if ( numVerts == MAX_SURFACE_VERTS ) {
 352                         Error( "MAX_SURFACE_VERTS" );
 353                 }
 354                 verts[numVerts] = ds->verts[i];
 355                 originals[numVerts] = i;
 356                 numVerts++;
 357
 358                 // check to see if there are any t junctions before the next vert
 359                 v1 = &ds->verts[i];
 360                 v2 = &ds->verts[ (i+1) % ds->numVerts ];
 361
 362                 j = (int)ds->verts[i].lightmap[ 0 ][ 0 ];
 363                 if ( j == -1 ) {
 364                         continue;               // degenerate edge
 365                 }
 366                 e = &edgeLines[ j ];
 367
 368                 VectorSubtract( v1->xyz, e->origin, delta );
 369                 start = DotProduct( delta, e->dir );
 370
 371                 VectorSubtract( v2->xyz, e->origin, delta );
 372                 end = DotProduct( delta, e->dir );
 373
 374
 375                 if ( start < end ) {
 376                         p = e->chain.next;
 377                 } else {
 378                         p = e->chain.prev;
 379                 }
 380
 381                 for (  ; p != &e->chain ;  ) {
 382                         if ( start < end ) {
 383                                 if ( p->intercept > end - ON_EPSILON ) {
 384                                         break;
 385                                 }
 386                         } else {
 387                                 if ( p->intercept < end + ON_EPSILON ) {
 388                                         break;
 389                                 }
 390                         }
 391
 392                         if (
 393                                 ( start < end && p->intercept > start + ON_EPSILON ) ||
 394                                 ( start > end && p->intercept < start - ON_EPSILON ) ) {
 395                                 // insert this point
 396                                 if ( numVerts == MAX_SURFACE_VERTS ) {
 397                                         Error( "MAX_SURFACE_VERTS" );
 398                                 }
 399
 400                                 /* take the exact intercept point */
 401                                 VectorCopy( p->xyz, verts[ numVerts ].xyz );
 402
 403                                 /* interpolate the texture coordinates */
 404                                 frac = ( p->intercept - start ) / ( end - start );
 405                                 for ( j = 0 ; j < 2 ; j++ ) {
 406                                         verts[ numVerts ].st[j] = v1->st[j] +
 407                                                 frac * ( v2->st[j] - v1->st[j] );
 408                                 }
 409
 410                                 /* copy the normal (FIXME: what about nonplanar surfaces? */
 411                                 VectorCopy( v1->normal, verts[ numVerts ].normal );
 412
 413                                 /* ydnar: interpolate the color */
 414                                 for( k = 0; k < MAX_LIGHTMAPS; k++ )
 415                                 {
 416                                         for( j = 0; j < 4; j++ )
 417                                         {
 418                                                 c = (float) v1->color[ k ][ j ] + frac * ((float) v2->color[ k ][ j ] - (float) v1->color[ k ][ j ]);
 419                                                 verts[ numVerts ].color[ k ][ j ] = (byte) (c < 255.0f ? c : 255);
 420                                         }
 421                                 }
 422
 423                                 /* next... */
 424                                 originals[ numVerts ] = i;
 425                                 numVerts++;
 426                                 counts[ i ]++;
 427                         }
 428
 429                         if ( start < end ) {
 430                                 p = p->next;
 431                         } else {
 432                                 p = p->prev;
 433                         }
 434                 }
 435         }
 436
 437         c_addedVerts += numVerts - ds->numVerts;
 438         c_totalVerts += numVerts;
 439
 440
 441         // FIXME: check to see if the entire surface degenerated
 442         // after snapping
 443
 444         // rotate the points so that the initial vertex is between
 445         // two non-subdivided edges
 446         for ( i = 0 ; i < numVerts ; i++ ) {
 447                 if ( originals[ (i+1) % numVerts ] == originals[ i ] ) {
 448                         continue;
 449                 }
 450                 j = (i + numVerts - 1 ) % numVerts;
 451                 k = (i + numVerts - 2 ) % numVerts;
 452                 if ( originals[ j ] == originals[ k ] ) {
 453                         continue;
 454                 }
 455                 break;
 456         }
 457
 458         if ( i == 0 ) {
 459                 // fine the way it is
 460                 c_natural++;
 461
 462                 ds->numVerts = numVerts;
 463                 ds->verts = safe_malloc( numVerts * sizeof( *ds->verts ) );
 464                 memcpy( ds->verts, verts, numVerts * sizeof( *ds->verts ) );
 465
 466                 return;
 467         }
 468         if ( i == numVerts ) {
 469                 // create a vertex in the middle to start the fan
 470                 c_cant++;
 471
 472 /*
 473                 memset ( &verts[numVerts], 0, sizeof( verts[numVerts] ) );
 474                 for ( i = 0 ; i < numVerts ; i++ ) {
 475                         for ( j = 0 ; j < 10 ; j++ ) {
 476                                 verts[numVerts].xyz[j] += verts[i].xyz[j];
 477                         }
 478                 }
 479                 for ( j = 0 ; j < 10 ; j++ ) {
 480                         verts[numVerts].xyz[j] /= numVerts;
 481                 }
 482
 483                 i = numVerts;
 484                 numVerts++;
 485 */
 486         } else {
 487                 // just rotate the vertexes
 488                 c_rotate++;
 489
 490         }
 491
 492         ds->numVerts = numVerts;
 493         ds->verts = safe_malloc( numVerts * sizeof( *ds->verts ) );
 494
 495         for ( j = 0 ; j < ds->numVerts ; j++ ) {
 496                 ds->verts[j] = verts[ ( j + i ) % ds->numVerts ];
 497         }
 498 }
 499
 500
 501
 502
 503
 504 /*
 505 FixBrokenSurface() - ydnar
 506 removes nearly coincident verts from a planar winding surface
 507 returns qfalse if the surface is broken
 508 */
 509
 510 extern void SnapWeldVector( vec3_t a, vec3_t b, vec3_t out );
 511
 512 #define DEGENERATE_EPSILON      0.1
 513
 514 int             c_broken = 0;
 515
 516 qboolean FixBrokenSurface( mapDrawSurface_t *ds )
 517 {
 518         qboolean        valid = qtrue;
 519         bspDrawVert_t   *dv1, *dv2, avg;
 520         int                     i, j, k;
 521         float           dist;
 522
 523
 524         /* dummy check */
 525         if( ds == NULL )
 526                 return qfalse;
 527         if( ds->type != SURFACE_FACE )
 528                 return qfalse;
 529
 530         /* check all verts */
 531         for( i = 0; i < ds->numVerts; i++ )
 532         {
 533                 /* don't remove points if winding is a triangle */
 534                 if( ds->numVerts == 3 )
 535                         return valid;
 536
 537                 /* get verts */
 538                 dv1 = &ds->verts[ i ];
 539                 dv2 = &ds->verts[ (i + 1) % ds->numVerts ];
 540
 541                 /* degenerate edge? */
 542                 VectorSubtract( dv1->xyz, dv2->xyz, avg.xyz );
 543                 dist = VectorLength( avg.xyz );
 544                 if( dist < DEGENERATE_EPSILON )
 545                 {
 546                         valid = qfalse;
 547                         Sys_FPrintf( SYS_VRB, "WARNING: Degenerate T-junction edge found, fixing...\n" );
 548
 549                         /* create an average drawvert */
 550                         /* ydnar 2002-01-26: added nearest-integer welding preference */
 551                         SnapWeldVector( dv1->xyz, dv2->xyz, avg.xyz );
 552                         VectorAdd( dv1->normal, dv2->normal, avg.normal );
 553                         VectorNormalize( avg.normal, avg.normal );
 554                         avg.st[ 0 ] = (dv1->st[ 0 ] + dv2->st[ 0 ]) * 0.5f;
 555                         avg.st[ 1 ] = (dv1->st[ 1 ] + dv2->st[ 1 ]) * 0.5f;
 556
 557                         /* lightmap st/colors */
 558                         for( k = 0; k < MAX_LIGHTMAPS; k++ )
 559                         {
 560                                 avg.lightmap[ k ][ 0 ] = (dv1->lightmap[ k ][ 0 ] + dv2->lightmap[ k ][ 0 ]) * 0.5f;
 561                                 avg.lightmap[ k ][ 1 ] = (dv1->lightmap[ k ][ 1 ] + dv2->lightmap[ k ][ 1 ]) * 0.5f;
 562                                 for( j = 0; j < 4; j++ )
 563                                         avg.color[ k ][ j ] = (int) (dv1->color[ k ][ j ] + dv2->color[ k ][ j ]) >> 1;
 564                         }
 565
 566                         /* ydnar: der... */
 567                         memcpy( dv1, &avg, sizeof( avg ) );
 568
 569                         /* move the remaining verts */
 570                         for( k = i + 2; k < ds->numVerts; k++ )
 571                         {
 572                                 /* get verts */
 573                                 dv1 = &ds->verts[ k ];
 574                                 dv2 = &ds->verts[ k - 1 ];
 575
 576                                 /* copy */
 577                                 memcpy( dv2, dv1, sizeof( bspDrawVert_t ) );
 578                         }
 579                         ds->numVerts--;
 580                 }
 581         }
 582
 583         /* one last check and return */
 584         if( ds->numVerts < 3 )
 585                 valid = qfalse;
 586         return valid;
 587 }
 588
 589
 590
 591
 592
 593
 594
 595
 596
 597 /*
 598 ================
 599 EdgeCompare
 600 ================
 601 */
 602 int EdgeCompare( const void *elem1, const void *elem2 ) {
 603         float   d1, d2;
 604
 605         d1 = ((originalEdge_t *)elem1)->length;
 606         d2 = ((originalEdge_t *)elem2)->length;
 607
 608         if ( d1 < d2 ) {
 609                 return -1;
 610         }
 611         if ( d2 > d1 ) {
 612                 return 1;
 613         }
 614         return 0;
 615 }
 616
 617
 618
 619 /*
 620 FixTJunctions
 621 call after the surface list has been pruned
 622 */
 623
 624 void FixTJunctions( entity_t *ent )
 625 {
 626         int                                     i;
 627         mapDrawSurface_t        *ds;
 628         shaderInfo_t            *si;
 629         int                                     axialEdgeLines;
 630         originalEdge_t          *e;
 631
 632
 633         /* meta mode has its own t-junction code (currently not as good as this code) */
 634         //%     if( meta )
 635         //%             return;
 636
 637         /* note it */
 638         Sys_FPrintf( SYS_VRB, "--- FixTJunctions ---\n" );
 639         numEdgeLines = 0;
 640         numOriginalEdges = 0;
 641
 642         // add all the edges
 643         // this actually creates axial edges, but it
 644         // only creates originalEdge_t structures
 645         // for non-axial edges
 646         for ( i = ent->firstDrawSurf ; i < numMapDrawSurfs ; i++ )
 647         {
 648                 /* get surface and early out if possible */
 649                 ds = &mapDrawSurfs[ i ];
 650                 si = ds->shaderInfo;
 651                 if( (si->compileFlags & C_NODRAW) || si->autosprite || si->notjunc || ds->numVerts == 0 )
 652                         continue;
 653
 654                 /* ydnar: gs mods: handle the various types of surfaces */
 655                 switch( ds->type )
 656                 {
 657                         /* handle brush faces */
 658                         case SURFACE_FACE:
 659                                 AddSurfaceEdges( ds );
 660                                 break;
 661
 662                         /* handle patches */
 663                         case SURFACE_PATCH:
 664                                 AddPatchEdges( ds );
 665                                 break;
 666
 667                         /* fixme: make triangle surfaces t-junction */
 668                         default:
 669                                 break;
 670                 }
 671         }
 672
 673         axialEdgeLines = numEdgeLines;
 674
 675         // sort the non-axial edges by length
 676         qsort( originalEdges, numOriginalEdges, sizeof(originalEdges[0]), EdgeCompare );
 677
 678         // add the non-axial edges, longest first
 679         // this gives the most accurate edge description
 680         for ( i = 0 ; i < numOriginalEdges ; i++ ) {
 681                 e = &originalEdges[i];
 682                 e->dv[ 0 ]->lightmap[ 0 ][ 0 ] = AddEdge( e->dv[ 0 ]->xyz, e->dv[ 1 ]->xyz, qtrue );
 683         }
 684
 685         Sys_FPrintf( SYS_VRB, "%9d axial edge lines\n", axialEdgeLines );
 686         Sys_FPrintf( SYS_VRB, "%9d non-axial edge lines\n", numEdgeLines - axialEdgeLines );
 687         Sys_FPrintf( SYS_VRB, "%9d degenerate edges\n", c_degenerateEdges );
 688
 689         // insert any needed vertexes
 690         for( i = ent->firstDrawSurf; i < numMapDrawSurfs ; i++ )
 691         {
 692                 /* get surface and early out if possible */
 693                 ds = &mapDrawSurfs[ i ];
 694                 si = ds->shaderInfo;
 695                 if( (si->compileFlags & C_NODRAW) || si->autosprite || si->notjunc || ds->numVerts == 0 || ds->type != SURFACE_FACE )
 696                         continue;
 697
 698                 /* ydnar: gs mods: handle the various types of surfaces */
 699                 switch( ds->type )
 700                 {
 701                         /* handle brush faces */
 702                         case SURFACE_FACE:
 703                                 FixSurfaceJunctions( ds );
 704                                 if( FixBrokenSurface( ds ) == qfalse )
 705                                 {
 706                                         c_broken++;
 707                                         ClearSurface( ds );
 708                                 }
 709                                 break;
 710
 711                         /* fixme: t-junction triangle models and patches */
 712                         default:
 713                                 break;
 714                 }
 715         }
 716
 717         /* emit some statistics */
 718         Sys_FPrintf( SYS_VRB, "%9d verts added for T-junctions\n", c_addedVerts );
 719         Sys_FPrintf( SYS_VRB, "%9d total verts\n", c_totalVerts );
 720         Sys_FPrintf( SYS_VRB, "%9d naturally ordered\n", c_natural );
 721         Sys_FPrintf( SYS_VRB, "%9d rotated orders\n", c_rotate );
 722         Sys_FPrintf( SYS_VRB, "%9d can't order\n", c_cant );
 723         Sys_FPrintf( SYS_VRB, "%9d broken (degenerate) surfaces removed\n", c_broken );
 724 }