1 /* -------------------------------------------------------------------------------
3 Copyright (C) 1999-2007 id Software, Inc. and contributors.
4 For a list of contributors, see the accompanying CONTRIBUTORS file.
6 This file is part of GtkRadiant.
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.
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.
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
22 ----------------------------------------------------------------------------------
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."
27 ------------------------------------------------------------------------------- */
32 #define SURFACE_META_C
41 #define LIGHTMAP_EXCEEDED -1
44 #define ST_EXCEEDED -4
45 #define UNSUITABLE_TRIANGLE -10
46 #define VERTS_EXCEEDED -1000
47 #define INDEXES_EXCEEDED -2000
49 #define GROW_META_VERTS 1024
50 #define GROW_META_TRIANGLES 1024
52 static int numMetaSurfaces, numPatchMetaSurfaces;
54 static int maxMetaVerts = 0;
55 static int numMetaVerts = 0;
56 static int firstSearchMetaVert = 0;
57 static bspDrawVert_t *metaVerts = NULL;
59 static int maxMetaTriangles = 0;
60 static int numMetaTriangles = 0;
61 static metaTriangle_t *metaTriangles = NULL;
67 called before staring a new entity to clear out the triangle list
70 void ClearMetaTriangles( void ){
79 finds a matching metavertex in the global list, returning its index
82 static int FindMetaVertex( bspDrawVert_t *src ){
84 bspDrawVert_t *v, *temp;
87 /* try to find an existing drawvert */
88 for ( i = firstSearchMetaVert, v = &metaVerts[ i ]; i < numMetaVerts; i++, v++ )
90 if ( memcmp( src, v, sizeof( bspDrawVert_t ) ) == 0 ) {
96 if ( numMetaVerts >= maxMetaVerts ) {
97 /* reallocate more room */
98 maxMetaVerts += GROW_META_VERTS;
99 temp = safe_malloc( maxMetaVerts * sizeof( bspDrawVert_t ) );
100 if ( metaVerts != NULL ) {
101 memcpy( temp, metaVerts, numMetaVerts * sizeof( bspDrawVert_t ) );
107 /* add the triangle */
108 memcpy( &metaVerts[ numMetaVerts ], src, sizeof( bspDrawVert_t ) );
111 /* return the count */
112 return ( numMetaVerts - 1 );
119 adds a new meta triangle, allocating more memory if necessary
122 static int AddMetaTriangle( void ){
123 metaTriangle_t *temp;
127 if ( numMetaTriangles >= maxMetaTriangles ) {
128 /* reallocate more room */
129 maxMetaTriangles += GROW_META_TRIANGLES;
130 temp = safe_malloc( maxMetaTriangles * sizeof( metaTriangle_t ) );
131 if ( metaTriangles != NULL ) {
132 memcpy( temp, metaTriangles, numMetaTriangles * sizeof( metaTriangle_t ) );
133 free( metaTriangles );
135 metaTriangles = temp;
138 /* increment and return */
140 return numMetaTriangles - 1;
147 finds a matching metatriangle in the global list,
148 otherwise adds it and returns the index to the metatriangle
151 int FindMetaTriangle( metaTriangle_t *src, bspDrawVert_t *a, bspDrawVert_t *b, bspDrawVert_t *c, int planeNum ){
157 /* detect degenerate triangles fixme: do something proper here */
158 VectorSubtract( a->xyz, b->xyz, dir );
159 if ( VectorLength( dir ) < 0.125f ) {
162 VectorSubtract( b->xyz, c->xyz, dir );
163 if ( VectorLength( dir ) < 0.125f ) {
166 VectorSubtract( c->xyz, a->xyz, dir );
167 if ( VectorLength( dir ) < 0.125f ) {
172 if ( planeNum >= 0 ) {
173 /* because of precision issues with small triangles, try to use the specified plane */
174 src->planeNum = planeNum;
175 VectorCopy( mapplanes[ planeNum ].normal, src->plane );
176 src->plane[ 3 ] = mapplanes[ planeNum ].dist;
180 /* calculate a plane from the triangle's points (and bail if a plane can't be constructed) */
182 if ( PlaneFromPoints( src->plane, a->xyz, b->xyz, c->xyz ) == qfalse ) {
187 /* ydnar 2002-10-03: repair any bogus normals (busted ase import kludge) */
188 if ( VectorLength( a->normal ) <= 0.0f ) {
189 VectorCopy( src->plane, a->normal );
191 if ( VectorLength( b->normal ) <= 0.0f ) {
192 VectorCopy( src->plane, b->normal );
194 if ( VectorLength( c->normal ) <= 0.0f ) {
195 VectorCopy( src->plane, c->normal );
198 /* ydnar 2002-10-04: set lightmap axis if not already set */
199 if ( !( src->si->compileFlags & C_VERTEXLIT ) &&
200 src->lightmapAxis[ 0 ] == 0.0f && src->lightmapAxis[ 1 ] == 0.0f && src->lightmapAxis[ 2 ] == 0.0f ) {
201 /* the shader can specify an explicit lightmap axis */
202 if ( src->si->lightmapAxis[ 0 ] || src->si->lightmapAxis[ 1 ] || src->si->lightmapAxis[ 2 ] ) {
203 VectorCopy( src->si->lightmapAxis, src->lightmapAxis );
206 /* new axis-finding code */
208 CalcLightmapAxis( src->plane, src->lightmapAxis );
212 /* fill out the src triangle */
213 src->indexes[ 0 ] = FindMetaVertex( a );
214 src->indexes[ 1 ] = FindMetaVertex( b );
215 src->indexes[ 2 ] = FindMetaVertex( c );
217 /* try to find an existing triangle */
218 #ifdef USE_EXHAUSTIVE_SEARCH
224 for ( i = 0, tri = metaTriangles; i < numMetaTriangles; i++, tri++ )
226 if ( memcmp( src, tri, sizeof( metaTriangle_t ) ) == 0 ) {
233 /* get a new triangle */
234 triIndex = AddMetaTriangle();
236 /* add the triangle */
237 memcpy( &metaTriangles[ triIndex ], src, sizeof( metaTriangle_t ) );
239 /* return the triangle index */
246 SurfaceToMetaTriangles()
247 converts a classified surface to metatriangles
250 static void SurfaceToMetaTriangles( mapDrawSurface_t *ds ){
253 bspDrawVert_t a, b, c;
256 /* only handle certain types of surfaces */
257 if ( ds->type != SURFACE_FACE &&
258 ds->type != SURFACE_META &&
259 ds->type != SURFACE_FORCED_META &&
260 ds->type != SURFACE_DECAL ) {
264 /* speed at the expense of memory */
265 firstSearchMetaVert = numMetaVerts;
267 /* only handle valid surfaces */
268 if ( ds->type != SURFACE_BAD && ds->numVerts >= 3 && ds->numIndexes >= 3 ) {
269 /* walk the indexes and create triangles */
270 for ( i = 0; i < ds->numIndexes; i += 3 )
272 /* sanity check the indexes */
273 if ( ds->indexes[ i ] == ds->indexes[ i + 1 ] ||
274 ds->indexes[ i ] == ds->indexes[ i + 2 ] ||
275 ds->indexes[ i + 1 ] == ds->indexes[ i + 2 ] ) {
276 //% Sys_Printf( "%d! ", ds->numVerts );
280 /* build a metatriangle */
281 src.si = ds->shaderInfo;
282 src.side = ( ds->sideRef != NULL ? ds->sideRef->side : NULL );
283 src.entityNum = ds->entityNum;
284 src.surfaceNum = ds->surfaceNum;
285 src.planeNum = ds->planeNum;
286 src.castShadows = ds->castShadows;
287 src.recvShadows = ds->recvShadows;
288 src.fogNum = ds->fogNum;
289 src.sampleSize = ds->sampleSize;
290 src.shadeAngleDegrees = ds->shadeAngleDegrees;
291 VectorCopy( ds->lightmapAxis, src.lightmapAxis );
294 memcpy( &a, &ds->verts[ ds->indexes[ i ] ], sizeof( a ) );
295 memcpy( &b, &ds->verts[ ds->indexes[ i + 1 ] ], sizeof( b ) );
296 memcpy( &c, &ds->verts[ ds->indexes[ i + 2 ] ], sizeof( c ) );
297 FindMetaTriangle( &src, &a, &b, &c, ds->planeNum );
304 /* clear the surface (free verts and indexes, sets it to SURFACE_BAD) */
311 TriangulatePatchSurface()
312 creates triangles from a patch
315 void TriangulatePatchSurface( entity_t *e, mapDrawSurface_t *ds ){
316 int iterations, x, y, pw[ 5 ], r;
317 mapDrawSurface_t *dsNew;
318 mesh_t src, *subdivided, *mesh;
321 int patchSubdivision;
323 /* vortex: _patchMeta, _patchQuality, _patchSubdivide support */
324 forcePatchMeta = IntForKey( e, "_patchMeta" );
325 if ( !forcePatchMeta ) {
326 forcePatchMeta = IntForKey( e, "patchMeta" );
328 patchQuality = IntForKey( e, "_patchQuality" );
329 if ( !patchQuality ) {
330 patchQuality = IntForKey( e, "patchQuality" );
332 if ( !patchQuality ) {
335 patchSubdivision = IntForKey( e, "_patchSubdivide" );
336 if ( !patchSubdivision ) {
337 patchSubdivision = IntForKey( e, "patchSubdivide" );
340 /* try to early out */
341 if ( ds->numVerts == 0 || ds->type != SURFACE_PATCH || ( patchMeta == qfalse && !forcePatchMeta ) ) {
345 /* make a mesh from the drawsurf */
346 src.width = ds->patchWidth;
347 src.height = ds->patchHeight;
348 src.verts = ds->verts;
349 //% subdivided = SubdivideMesh( src, 8, 999 );
350 if ( patchSubdivision ) {
351 iterations = IterationsForCurve( ds->longestCurve, patchSubdivision );
354 iterations = IterationsForCurve( ds->longestCurve, patchSubdivisions / patchQuality );
357 subdivided = SubdivideMesh2( src, iterations ); //% ds->maxIterations
359 /* fit it to the curve and remove colinear verts on rows/columns */
360 PutMeshOnCurve( *subdivided );
361 mesh = RemoveLinearMeshColumnsRows( subdivided );
362 FreeMesh( subdivided );
363 //% MakeMeshNormals( mesh );
365 /* make a copy of the drawsurface */
366 dsNew = AllocDrawSurface( SURFACE_META );
367 memcpy( dsNew, ds, sizeof( *ds ) );
369 /* if the patch is nonsolid, then discard it */
370 if ( !( ds->shaderInfo->compileFlags & C_SOLID ) ) {
374 /* set new pointer */
377 /* basic transmogrification */
378 ds->type = SURFACE_META;
380 ds->indexes = safe_malloc( mesh->width * mesh->height * 6 * sizeof( int ) );
382 /* copy the verts in */
383 ds->numVerts = ( mesh->width * mesh->height );
384 ds->verts = mesh->verts;
386 /* iterate through the mesh quads */
387 for ( y = 0; y < ( mesh->height - 1 ); y++ )
389 for ( x = 0; x < ( mesh->width - 1 ); x++ )
392 pw[ 0 ] = x + ( y * mesh->width );
393 pw[ 1 ] = x + ( ( y + 1 ) * mesh->width );
394 pw[ 2 ] = x + 1 + ( ( y + 1 ) * mesh->width );
395 pw[ 3 ] = x + 1 + ( y * mesh->width );
396 pw[ 4 ] = x + ( y * mesh->width ); /* same as pw[ 0 ] */
401 /* make first triangle */
402 ds->indexes[ ds->numIndexes++ ] = pw[ r + 0 ];
403 ds->indexes[ ds->numIndexes++ ] = pw[ r + 1 ];
404 ds->indexes[ ds->numIndexes++ ] = pw[ r + 2 ];
406 /* make second triangle */
407 ds->indexes[ ds->numIndexes++ ] = pw[ r + 0 ];
408 ds->indexes[ ds->numIndexes++ ] = pw[ r + 2 ];
409 ds->indexes[ ds->numIndexes++ ] = pw[ r + 3 ];
413 /* free the mesh, but not the verts */
417 numPatchMetaSurfaces++;
420 ClassifySurfaces( 1, ds );
425 #define TINY_AREA 1.0f
426 #define MAXAREA_MAXTRIES 8
427 int MaxAreaIndexes( bspDrawVert_t *vert, int cnt, int *indexes ){
428 int r, s, t, bestR = 0, bestS = 1, bestT = 2;
430 double A, bestA = -1, V, bestV = -1;
431 vec3_t ab, ac, bc, cross;
439 /* calculate total area */
441 for ( i = 1; i + 1 < cnt; ++i )
443 VectorSubtract( vert[i].xyz, vert[0].xyz, ab );
444 VectorSubtract( vert[i + 1].xyz, vert[0].xyz, ac );
445 CrossProduct( ab, ac, cross );
446 A += VectorLength( cross );
449 for ( i = 0; i < cnt; ++i )
451 VectorSubtract( vert[( i + 1 ) % cnt].xyz, vert[i].xyz, ab );
452 V += VectorLength( ab );
455 /* calculate shift width from the area sensibly, assuming the polygon
456 * fits about 25% of the screen in both dimensions
457 * we assume 1280x1024
458 * 1 pixel is then about sqrt(A) / (0.25 * screenwidth)
459 * 8 pixels are then about sqrt(A) / (0.25 * 1280) * 8
460 * 8 pixels are then about sqrt(A) * 0.025
462 shiftWidth = sqrt( A ) * 0.0125;
463 /* 3->1 6->2 12->3 ... */
464 if ( A - ceil( log( cnt / 1.5 ) / log( 2 ) ) * V * shiftWidth * 2 < 0 ) {
465 /* printf("Small triangle detected (area %f, circumference %f), adjusting shiftWidth from %f to ", A, V, shiftWidth); */
466 shiftWidth = A / ( ceil( log( cnt / 1.5 ) / log( 2 ) ) * V * 2 );
467 /* printf("%f\n", shiftWidth); */
470 /* find the triangle with highest area */
471 for ( r = 0; r + 2 < cnt; ++r )
472 for ( s = r + 1; s + 1 < cnt; ++s )
473 for ( t = s + 1; t < cnt; ++t )
475 VectorSubtract( vert[s].xyz, vert[r].xyz, ab );
476 VectorSubtract( vert[t].xyz, vert[r].xyz, ac );
477 VectorSubtract( vert[t].xyz, vert[s].xyz, bc );
478 CrossProduct( ab, ac, cross );
479 A = VectorLength( cross );
481 V = A - ( VectorLength( ab ) - VectorLength( ac ) - VectorLength( bc ) ) * shiftWidth;
482 /* value = A - circumference * shiftWidth, i.e. we back out by shiftWidth units from each side, to prevent too acute triangles */
483 /* this kind of simulates "number of shiftWidth*shiftWidth fragments in the triangle not touched by an edge" */
485 if ( bestA < 0 || V > bestV ) {
496 printf("value was REALLY bad\n");
499 for ( try = 0; try < MAXAREA_MAXTRIES; ++try )
502 bestR = rand() % cnt;
503 bestS = rand() % cnt;
504 bestT = rand() % cnt;
505 if ( bestR == bestS || bestR == bestT || bestS == bestT ) {
509 // abc acb bac bca cab cba
510 if ( bestR > bestS ) {
515 // abc acb abc bca acb bca
516 if ( bestS > bestT ) {
521 // abc abc abc bac abc bac
522 if ( bestR > bestS ) {
527 // abc abc abc abc abc abc
529 VectorSubtract( vert[bestS].xyz, vert[bestR].xyz, ab );
530 VectorSubtract( vert[bestT].xyz, vert[bestR].xyz, ac );
531 CrossProduct( ab, ac, cross );
532 bestA = VectorLength( cross );
535 if ( bestA < TINY_AREA ) {
536 /* the biggest triangle is degenerate - then every other is too, and the other algorithms wouldn't generate anything useful either */
541 indexes[i++] = bestR;
542 indexes[i++] = bestS;
543 indexes[i++] = bestT;
546 /* identify the other fragments */
548 /* full polygon without triangle (bestR,bestS,bestT) = three new polygons:
554 j = MaxAreaIndexes( vert + bestR, bestS - bestR + 1, indexes + i );
561 /* uses 3*(bestS-bestR+1)-6 */
562 j = MaxAreaIndexes( vert + bestS, bestT - bestS + 1, indexes + i );
569 /* uses 3*(bestT-bestS+1)-6 */
571 /* can'bestT recurse this one directly... therefore, buffering */
572 if ( cnt + bestR - bestT + 1 >= 3 ) {
573 buf = safe_malloc( sizeof( *vert ) * ( cnt + bestR - bestT + 1 ) );
574 memcpy( buf, vert + bestT, sizeof( *vert ) * ( cnt - bestT ) );
575 memcpy( buf + ( cnt - bestT ), vert, sizeof( *vert ) * ( bestR + 1 ) );
576 j = MaxAreaIndexes( buf, cnt + bestR - bestT + 1, indexes + i );
583 indexes[i] = ( indexes[i] + bestT ) % cnt;
584 /* uses 3*(cnt+bestR-bestT+1)-6 */
588 /* together 3 + 3*(cnt+3) - 18 = 3*cnt-6 q.e.d. */
598 MaxAreaFaceSurface() - divVerent
599 creates a triangle list using max area indexes
602 void MaxAreaFaceSurface( mapDrawSurface_t *ds ){
604 /* try to early out */
605 if ( !ds->numVerts || ( ds->type != SURFACE_FACE && ds->type != SURFACE_DECAL ) ) {
609 /* is this a simple triangle? */
610 if ( ds->numVerts == 3 ) {
612 ds->indexes = safe_malloc( ds->numIndexes * sizeof( int ) );
613 VectorSet( ds->indexes, 0, 1, 2 );
614 numMaxAreaSurfaces++;
619 ds->numIndexes = 3 * ds->numVerts - 6;
620 ds->indexes = safe_malloc( ds->numIndexes * sizeof( int ) );
621 n = MaxAreaIndexes( ds->verts, ds->numVerts, ds->indexes );
623 /* whatever we do, it's degenerate */
626 StripFaceSurface( ds );
632 numMaxAreaSurfaces++;
635 ClassifySurfaces( 1, ds );
641 FanFaceSurface() - ydnar
642 creates a tri-fan from a brush face winding
643 loosely based on SurfaceAsTriFan()
646 void FanFaceSurface( mapDrawSurface_t *ds ){
647 int i, j, k, a, b, c, color[ MAX_LIGHTMAPS ][ 4 ];
648 bspDrawVert_t *verts, *centroid, *dv;
652 /* try to early out */
653 if ( !ds->numVerts || ( ds->type != SURFACE_FACE && ds->type != SURFACE_DECAL ) ) {
657 /* add a new vertex at the beginning of the surface */
658 verts = safe_malloc( ( ds->numVerts + 1 ) * sizeof( bspDrawVert_t ) );
659 memset( verts, 0, sizeof( bspDrawVert_t ) );
660 memcpy( &verts[ 1 ], ds->verts, ds->numVerts * sizeof( bspDrawVert_t ) );
664 /* add up the drawverts to create a centroid */
665 centroid = &verts[ 0 ];
666 memset( color, 0, 4 * MAX_LIGHTMAPS * sizeof( int ) );
667 for ( i = 1, dv = &verts[ 1 ]; i < ( ds->numVerts + 1 ); i++, dv++ )
669 VectorAdd( centroid->xyz, dv->xyz, centroid->xyz );
670 VectorAdd( centroid->normal, dv->normal, centroid->normal );
671 for ( j = 0; j < 4; j++ )
673 for ( k = 0; k < MAX_LIGHTMAPS; k++ )
674 color[ k ][ j ] += dv->color[ k ][ j ];
676 centroid->st[ j ] += dv->st[ j ];
677 for ( k = 0; k < MAX_LIGHTMAPS; k++ )
678 centroid->lightmap[ k ][ j ] += dv->lightmap[ k ][ j ];
683 /* average the centroid */
684 iv = 1.0f / ds->numVerts;
685 VectorScale( centroid->xyz, iv, centroid->xyz );
686 if ( VectorNormalize( centroid->normal, centroid->normal ) <= 0 ) {
687 VectorCopy( verts[ 1 ].normal, centroid->normal );
689 for ( j = 0; j < 4; j++ )
691 for ( k = 0; k < MAX_LIGHTMAPS; k++ )
693 color[ k ][ j ] /= ds->numVerts;
694 centroid->color[ k ][ j ] = ( color[ k ][ j ] < 255.0f ? color[ k ][ j ] : 255 );
697 centroid->st[ j ] *= iv;
698 for ( k = 0; k < MAX_LIGHTMAPS; k++ )
699 centroid->lightmap[ k ][ j ] *= iv;
703 /* add to vert count */
706 /* fill indexes in triangle fan order */
708 ds->indexes = safe_malloc( ds->numVerts * 3 * sizeof( int ) );
709 for ( i = 1; i < ds->numVerts; i++ )
713 c = ( i + 1 ) % ds->numVerts;
715 ds->indexes[ ds->numIndexes++ ] = a;
716 ds->indexes[ ds->numIndexes++ ] = b;
717 ds->indexes[ ds->numIndexes++ ] = c;
724 ClassifySurfaces( 1, ds );
730 StripFaceSurface() - ydnar
731 attempts to create a valid tri-strip w/o degenerate triangles from a brush face winding
732 based on SurfaceAsTriStrip()
735 #define MAX_INDEXES 1024
737 void StripFaceSurface( mapDrawSurface_t *ds ){
738 int i, r, least, rotate, numIndexes, ni, a, b, c, indexes[ MAX_INDEXES ];
742 /* try to early out */
743 if ( !ds->numVerts || ( ds->type != SURFACE_FACE && ds->type != SURFACE_DECAL ) ) {
747 /* is this a simple triangle? */
748 if ( ds->numVerts == 3 ) {
750 VectorSet( indexes, 0, 1, 2 );
754 /* ydnar: find smallest coordinate */
756 if ( ds->shaderInfo != NULL && ds->shaderInfo->autosprite == qfalse ) {
757 for ( i = 0; i < ds->numVerts; i++ )
760 v1 = ds->verts[ i ].xyz;
761 v2 = ds->verts[ least ].xyz;
764 if ( v1[ 0 ] < v2[ 0 ] ||
765 ( v1[ 0 ] == v2[ 0 ] && v1[ 1 ] < v2[ 1 ] ) ||
766 ( v1[ 0 ] == v2[ 0 ] && v1[ 1 ] == v2[ 1 ] && v1[ 2 ] < v2[ 2 ] ) ) {
772 /* determine the triangle strip order */
773 numIndexes = ( ds->numVerts - 2 ) * 3;
774 if ( numIndexes > MAX_INDEXES ) {
775 Error( "MAX_INDEXES exceeded for surface (%d > %d) (%d verts)", numIndexes, MAX_INDEXES, ds->numVerts );
778 /* try all possible orderings of the points looking for a non-degenerate strip order */
780 for ( r = 0; r < ds->numVerts; r++ )
783 rotate = ( r + least ) % ds->numVerts;
785 /* walk the winding in both directions */
786 for ( ni = 0, i = 0; i < ds->numVerts - 2 - i; i++ )
789 a = ( ds->numVerts - 1 - i + rotate ) % ds->numVerts;
790 b = ( i + rotate ) % ds->numVerts;
791 c = ( ds->numVerts - 2 - i + rotate ) % ds->numVerts;
793 /* test this triangle */
794 if ( ds->numVerts > 4 && IsTriangleDegenerate( ds->verts, a, b, c ) ) {
801 /* handle end case */
802 if ( i + 1 != ds->numVerts - 1 - i ) {
804 a = ( ds->numVerts - 2 - i + rotate ) % ds->numVerts;
805 b = ( i + rotate ) % ds->numVerts;
806 c = ( i + 1 + rotate ) % ds->numVerts;
809 if ( ds->numVerts > 4 && IsTriangleDegenerate( ds->verts, a, b, c ) ) {
819 if ( ni == numIndexes ) {
824 /* if any triangle in the strip is degenerate, render from a centered fan point instead */
825 if ( ni < numIndexes ) {
826 FanFaceSurface( ds );
831 /* copy strip triangle indexes */
832 ds->numIndexes = numIndexes;
833 ds->indexes = safe_malloc( ds->numIndexes * sizeof( int ) );
834 memcpy( ds->indexes, indexes, ds->numIndexes * sizeof( int ) );
840 ClassifySurfaces( 1, ds );
847 vortex: prints meta statistics in general output
850 void EmitMetaStats(){
851 Sys_Printf( "--- EmitMetaStats ---\n" );
852 Sys_Printf( "%9d total meta surfaces\n", numMetaSurfaces );
853 Sys_Printf( "%9d stripped surfaces\n", numStripSurfaces );
854 Sys_Printf( "%9d fanned surfaces\n", numFanSurfaces );
855 Sys_Printf( "%9d maxarea'd surfaces\n", numMaxAreaSurfaces );
856 Sys_Printf( "%9d patch meta surfaces\n", numPatchMetaSurfaces );
857 Sys_Printf( "%9d meta verts\n", numMetaVerts );
858 Sys_Printf( "%9d meta triangles\n", numMetaTriangles );
864 MakeEntityMetaTriangles()
865 builds meta triangles from brush faces (tristrips and fans)
868 void MakeEntityMetaTriangles( entity_t *e ){
869 int i, f, fOld, start;
870 mapDrawSurface_t *ds;
874 Sys_FPrintf( SYS_VRB, "--- MakeEntityMetaTriangles ---\n" );
878 start = I_FloatTime();
880 /* walk the list of surfaces in the entity */
881 for ( i = e->firstDrawSurf; i < numMapDrawSurfs; i++ )
884 f = 10 * ( i - e->firstDrawSurf ) / ( numMapDrawSurfs - e->firstDrawSurf );
887 Sys_FPrintf( SYS_VRB, "%d...", f );
891 ds = &mapDrawSurfs[ i ];
892 if ( ds->numVerts <= 0 ) {
896 /* ignore autosprite surfaces */
897 if ( ds->shaderInfo->autosprite ) {
901 /* meta this surface? */
902 if ( meta == qfalse && ds->shaderInfo->forceMeta == qfalse ) {
911 if ( maxAreaFaceSurface ) {
912 MaxAreaFaceSurface( ds );
915 StripFaceSurface( ds );
917 SurfaceToMetaTriangles( ds );
921 TriangulatePatchSurface( e, ds );
924 case SURFACE_TRIANGLES:
927 case SURFACE_FORCED_META:
929 SurfaceToMetaTriangles( ds );
938 if ( ( numMapDrawSurfs - e->firstDrawSurf ) ) {
939 Sys_FPrintf( SYS_VRB, " (%d)\n", (int) ( I_FloatTime() - start ) );
942 /* emit some stats */
943 Sys_FPrintf( SYS_VRB, "%9d total meta surfaces\n", numMetaSurfaces );
944 Sys_FPrintf( SYS_VRB, "%9d stripped surfaces\n", numStripSurfaces );
945 Sys_FPrintf( SYS_VRB, "%9d fanned surfaces\n", numFanSurfaces );
946 Sys_FPrintf( SYS_VRB, "%9d maxarea'd surfaces\n", numMaxAreaSurfaces );
947 Sys_FPrintf( SYS_VRB, "%9d patch meta surfaces\n", numPatchMetaSurfaces );
948 Sys_FPrintf( SYS_VRB, "%9d meta verts\n", numMetaVerts );
949 Sys_FPrintf( SYS_VRB, "%9d meta triangles\n", numMetaTriangles );
952 TidyEntitySurfaces( e );
959 sets up an edge structure from a plane and 2 points that the edge ab falls lies in
962 typedef struct edge_s
965 vec_t length, kingpinLength;
971 void CreateEdge( vec4_t plane, vec3_t a, vec3_t b, edge_t *edge ){
972 /* copy edge origin */
973 VectorCopy( a, edge->origin );
975 /* create vector aligned with winding direction of edge */
976 VectorSubtract( b, a, edge->edge );
978 if ( fabs( edge->edge[ 0 ] ) > fabs( edge->edge[ 1 ] ) && fabs( edge->edge[ 0 ] ) > fabs( edge->edge[ 2 ] ) ) {
981 else if ( fabs( edge->edge[ 1 ] ) > fabs( edge->edge[ 0 ] ) && fabs( edge->edge[ 1 ] ) > fabs( edge->edge[ 2 ] ) ) {
987 edge->kingpinLength = edge->edge[ edge->kingpin ];
989 VectorNormalize( edge->edge, edge->edge );
990 edge->edge[ 3 ] = DotProduct( a, edge->edge );
991 edge->length = DotProduct( b, edge->edge ) - edge->edge[ 3 ];
993 /* create perpendicular plane that edge lies in */
994 CrossProduct( plane, edge->edge, edge->plane );
995 edge->plane[ 3 ] = DotProduct( a, edge->plane );
1002 fixes t-junctions on meta triangles
1005 #define TJ_PLANE_EPSILON ( 1.0f / 8.0f )
1006 #define TJ_EDGE_EPSILON ( 1.0f / 8.0f )
1007 #define TJ_POINT_EPSILON ( 1.0f / 8.0f )
1009 void FixMetaTJunctions( void ){
1010 int i, j, k, f, fOld, start, vertIndex, triIndex, numTJuncs;
1011 metaTriangle_t *tri, *newTri;
1013 bspDrawVert_t *a, *b, *c, junc;
1020 /* this code is crap; revisit later */
1024 Sys_FPrintf( SYS_VRB, "--- FixMetaTJunctions ---\n" );
1028 start = I_FloatTime();
1030 /* walk triangle list */
1032 for ( i = 0; i < numMetaTriangles; i++ )
1035 tri = &metaTriangles[ i ];
1037 /* print pacifier */
1038 f = 10 * i / numMetaTriangles;
1041 Sys_FPrintf( SYS_VRB, "%d...", f );
1044 /* attempt to early out */
1046 if ( ( si->compileFlags & C_NODRAW ) || si->autosprite || si->notjunc ) {
1050 /* calculate planes */
1051 VectorCopy( tri->plane, plane );
1052 plane[ 3 ] = tri->plane[ 3 ];
1053 CreateEdge( plane, metaVerts[ tri->indexes[ 0 ] ].xyz, metaVerts[ tri->indexes[ 1 ] ].xyz, &edges[ 0 ] );
1054 CreateEdge( plane, metaVerts[ tri->indexes[ 1 ] ].xyz, metaVerts[ tri->indexes[ 2 ] ].xyz, &edges[ 1 ] );
1055 CreateEdge( plane, metaVerts[ tri->indexes[ 2 ] ].xyz, metaVerts[ tri->indexes[ 0 ] ].xyz, &edges[ 2 ] );
1057 /* walk meta vert list */
1058 for ( j = 0; j < numMetaVerts; j++ )
1061 VectorCopy( metaVerts[ j ].xyz, pt );
1063 /* determine if point lies in the triangle's plane */
1064 dist = DotProduct( pt, plane ) - plane[ 3 ];
1065 if ( fabs( dist ) > TJ_PLANE_EPSILON ) {
1069 /* skip this point if it already exists in the triangle */
1070 for ( k = 0; k < 3; k++ )
1072 if ( fabs( pt[ 0 ] - metaVerts[ tri->indexes[ k ] ].xyz[ 0 ] ) <= TJ_POINT_EPSILON &&
1073 fabs( pt[ 1 ] - metaVerts[ tri->indexes[ k ] ].xyz[ 1 ] ) <= TJ_POINT_EPSILON &&
1074 fabs( pt[ 2 ] - metaVerts[ tri->indexes[ k ] ].xyz[ 2 ] ) <= TJ_POINT_EPSILON ) {
1083 for ( k = 0; k < 3; k++ )
1085 /* ignore bogus edges */
1086 if ( fabs( edges[ k ].kingpinLength ) < TJ_EDGE_EPSILON ) {
1090 /* determine if point lies on the edge */
1091 dist = DotProduct( pt, edges[ k ].plane ) - edges[ k ].plane[ 3 ];
1092 if ( fabs( dist ) > TJ_EDGE_EPSILON ) {
1096 /* determine how far along the edge the point lies */
1097 amount = ( pt[ edges[ k ].kingpin ] - edges[ k ].origin[ edges[ k ].kingpin ] ) / edges[ k ].kingpinLength;
1098 if ( amount <= 0.0f || amount >= 1.0f ) {
1103 dist = DotProduct( pt, edges[ k ].edge ) - edges[ k ].edge[ 3 ];
1104 if ( dist <= -0.0f || dist >= edges[ k ].length ) {
1107 amount = dist / edges[ k ].length;
1110 /* the edge opposite the zero-weighted vertex was hit, so use that as an amount */
1111 a = &metaVerts[ tri->indexes[ k % 3 ] ];
1112 b = &metaVerts[ tri->indexes[ ( k + 1 ) % 3 ] ];
1113 c = &metaVerts[ tri->indexes[ ( k + 2 ) % 3 ] ];
1116 LerpDrawVertAmount( a, b, amount, &junc );
1117 VectorCopy( pt, junc.xyz );
1119 /* compare against existing verts */
1120 if ( VectorCompare( junc.xyz, a->xyz ) || VectorCompare( junc.xyz, b->xyz ) || VectorCompare( junc.xyz, c->xyz ) ) {
1124 /* see if we can just re-use the existing vert */
1125 if ( !memcmp( &metaVerts[ j ], &junc, sizeof( junc ) ) ) {
1130 /* find new vertex (note: a and b are invalid pointers after this) */
1131 firstSearchMetaVert = numMetaVerts;
1132 vertIndex = FindMetaVertex( &junc );
1133 if ( vertIndex < 0 ) {
1138 /* make new triangle */
1139 triIndex = AddMetaTriangle();
1140 if ( triIndex < 0 ) {
1145 tri = &metaTriangles[ i ];
1146 newTri = &metaTriangles[ triIndex ];
1148 /* copy the triangle */
1149 memcpy( newTri, tri, sizeof( *tri ) );
1152 tri->indexes[ ( k + 1 ) % 3 ] = vertIndex;
1153 newTri->indexes[ k ] = vertIndex;
1155 /* recalculate edges */
1156 CreateEdge( plane, metaVerts[ tri->indexes[ 0 ] ].xyz, metaVerts[ tri->indexes[ 1 ] ].xyz, &edges[ 0 ] );
1157 CreateEdge( plane, metaVerts[ tri->indexes[ 1 ] ].xyz, metaVerts[ tri->indexes[ 2 ] ].xyz, &edges[ 1 ] );
1158 CreateEdge( plane, metaVerts[ tri->indexes[ 2 ] ].xyz, metaVerts[ tri->indexes[ 0 ] ].xyz, &edges[ 2 ] );
1161 metaVerts[ vertIndex ].color[ 0 ][ 0 ] = 255;
1162 metaVerts[ vertIndex ].color[ 0 ][ 1 ] = 204;
1163 metaVerts[ vertIndex ].color[ 0 ][ 2 ] = 0;
1165 /* add to counter and end processing of this vert */
1173 Sys_FPrintf( SYS_VRB, " (%d)\n", (int) ( I_FloatTime() - start ) );
1175 /* emit some stats */
1176 Sys_FPrintf( SYS_VRB, "%9d T-junctions added\n", numTJuncs );
1182 SmoothMetaTriangles()
1183 averages coincident vertex normals in the meta triangles
1186 #define MAX_SAMPLES 256
1187 #define THETA_EPSILON 0.000001
1188 #define EQUAL_NORMAL_EPSILON 0.01
1190 void SmoothMetaTriangles( void ){
1191 int i, j, k, f, fOld, start, cs, numVerts, numVotes, numSmoothed;
1192 float shadeAngle, defaultShadeAngle, maxShadeAngle, dot, testAngle;
1193 metaTriangle_t *tri;
1196 vec3_t average, diff;
1197 int indexes[ MAX_SAMPLES ];
1198 vec3_t votes[ MAX_SAMPLES ];
1201 Sys_FPrintf( SYS_VRB, "--- SmoothMetaTriangles ---\n" );
1203 /* allocate shade angle table */
1204 shadeAngles = safe_malloc( numMetaVerts * sizeof( float ) );
1205 memset( shadeAngles, 0, numMetaVerts * sizeof( float ) );
1207 /* allocate smoothed table */
1208 cs = ( numMetaVerts / 8 ) + 1;
1209 smoothed = safe_malloc( cs );
1210 memset( smoothed, 0, cs );
1212 /* set default shade angle */
1213 defaultShadeAngle = DEG2RAD( npDegrees );
1214 maxShadeAngle = 0.0f;
1216 /* run through every surface and flag verts belonging to non-lightmapped surfaces
1217 and set per-vertex smoothing angle */
1218 for ( i = 0, tri = &metaTriangles[ i ]; i < numMetaTriangles; i++, tri++ )
1220 shadeAngle = defaultShadeAngle;
1222 /* get shade angle from shader */
1223 if ( tri->si->shadeAngleDegrees > 0.0f ) {
1224 shadeAngle = DEG2RAD( tri->si->shadeAngleDegrees );
1226 /* get shade angle from entity */
1227 else if ( tri->shadeAngleDegrees > 0.0f ) {
1228 shadeAngle = DEG2RAD( tri->shadeAngleDegrees );
1231 if ( shadeAngle <= 0.0f ) {
1232 shadeAngle = defaultShadeAngle;
1235 if ( shadeAngle > maxShadeAngle ) {
1236 maxShadeAngle = shadeAngle;
1239 /* flag its verts */
1240 for ( j = 0; j < 3; j++ )
1242 shadeAngles[ tri->indexes[ j ] ] = shadeAngle;
1243 if ( shadeAngle <= 0 ) {
1244 smoothed[ tri->indexes[ j ] >> 3 ] |= ( 1 << ( tri->indexes[ j ] & 7 ) );
1249 /* bail if no surfaces have a shade angle */
1250 if ( maxShadeAngle <= 0 ) {
1251 Sys_FPrintf( SYS_VRB, "No smoothing angles specified, aborting\n" );
1252 free( shadeAngles );
1259 start = I_FloatTime();
1261 /* go through the list of vertexes */
1263 for ( i = 0; i < numMetaVerts; i++ )
1265 /* print pacifier */
1266 f = 10 * i / numMetaVerts;
1269 Sys_FPrintf( SYS_VRB, "%d...", f );
1272 /* already smoothed? */
1273 if ( smoothed[ i >> 3 ] & ( 1 << ( i & 7 ) ) ) {
1278 VectorClear( average );
1282 /* build a table of coincident vertexes */
1283 for ( j = i; j < numMetaVerts && numVerts < MAX_SAMPLES; j++ )
1285 /* already smoothed? */
1286 if ( smoothed[ j >> 3 ] & ( 1 << ( j & 7 ) ) ) {
1291 if ( VectorCompare( metaVerts[ i ].xyz, metaVerts[ j ].xyz ) == qfalse ) {
1295 /* use smallest shade angle */
1296 shadeAngle = ( shadeAngles[ i ] < shadeAngles[ j ] ? shadeAngles[ i ] : shadeAngles[ j ] );
1298 /* check shade angle */
1299 dot = DotProduct( metaVerts[ i ].normal, metaVerts[ j ].normal );
1303 else if ( dot < -1.0 ) {
1306 testAngle = acos( dot ) + THETA_EPSILON;
1307 if ( testAngle >= shadeAngle ) {
1311 /* add to the list */
1312 indexes[ numVerts++ ] = j;
1315 smoothed[ j >> 3 ] |= ( 1 << ( j & 7 ) );
1317 /* see if this normal has already been voted */
1318 for ( k = 0; k < numVotes; k++ )
1320 VectorSubtract( metaVerts[ j ].normal, votes[ k ], diff );
1321 if ( fabs( diff[ 0 ] ) < EQUAL_NORMAL_EPSILON &&
1322 fabs( diff[ 1 ] ) < EQUAL_NORMAL_EPSILON &&
1323 fabs( diff[ 2 ] ) < EQUAL_NORMAL_EPSILON ) {
1328 /* add a new vote? */
1329 if ( k == numVotes && numVotes < MAX_SAMPLES ) {
1330 VectorAdd( average, metaVerts[ j ].normal, average );
1331 VectorCopy( metaVerts[ j ].normal, votes[ numVotes ] );
1336 /* don't average for less than 2 verts */
1337 if ( numVerts < 2 ) {
1341 /* average normal */
1342 if ( VectorNormalize( average, average ) > 0 ) {
1344 for ( j = 0; j < numVerts; j++ )
1345 VectorCopy( average, metaVerts[ indexes[ j ] ].normal );
1350 /* free the tables */
1351 free( shadeAngles );
1355 Sys_FPrintf( SYS_VRB, " (%d)\n", (int) ( I_FloatTime() - start ) );
1357 /* emit some stats */
1358 Sys_FPrintf( SYS_VRB, "%9d smoothed vertexes\n", numSmoothed );
1364 AddMetaVertToSurface()
1365 adds a drawvert to a surface unless an existing vert matching already exists
1366 returns the index of that vert (or < 0 on failure)
1369 int AddMetaVertToSurface( mapDrawSurface_t *ds, bspDrawVert_t *dv1, int *coincident ){
1374 /* go through the verts and find a suitable candidate */
1375 for ( i = 0; i < ds->numVerts; i++ )
1378 dv2 = &ds->verts[ i ];
1380 /* compare xyz and normal */
1381 if ( VectorCompare( dv1->xyz, dv2->xyz ) == qfalse ) {
1384 if ( VectorCompare( dv1->normal, dv2->normal ) == qfalse ) {
1388 /* good enough at this point */
1391 /* compare texture coordinates and color */
1392 if ( dv1->st[ 0 ] != dv2->st[ 0 ] || dv1->st[ 1 ] != dv2->st[ 1 ] ) {
1395 if ( dv1->color[ 0 ][ 3 ] != dv2->color[ 0 ][ 3 ] ) {
1399 /* found a winner */
1404 /* overflow check */
1405 if ( ds->numVerts >= ( ( ds->shaderInfo->compileFlags & C_VERTEXLIT ) ? maxSurfaceVerts : maxLMSurfaceVerts ) ) {
1406 return VERTS_EXCEEDED;
1409 /* made it this far, add the vert and return */
1410 dv2 = &ds->verts[ ds->numVerts++ ];
1412 return ( ds->numVerts - 1 );
1419 AddMetaTriangleToSurface()
1420 attempts to add a metatriangle to a surface
1421 returns the score of the triangle added
1424 #define AXIS_SCORE 100000
1425 #define AXIS_MIN 100000
1426 #define VERT_SCORE 10000
1427 #define SURFACE_SCORE 1000
1429 #define ST_SCORE2 ( 2 * ( ST_SCORE ) )
1431 #define DEFAULT_ADEQUATE_SCORE ( (AXIS_MIN) +1 * ( VERT_SCORE ) )
1432 #define DEFAULT_GOOD_SCORE ( (AXIS_MIN) +2 * (VERT_SCORE) +4 * ( ST_SCORE ) )
1433 #define PERFECT_SCORE ( (AXIS_MIN) +3 * ( VERT_SCORE ) + (SURFACE_SCORE) +4 * ( ST_SCORE ) )
1435 #define ADEQUATE_SCORE ( metaAdequateScore >= 0 ? metaAdequateScore : DEFAULT_ADEQUATE_SCORE )
1436 #define GOOD_SCORE ( metaGoodScore >= 0 ? metaGoodScore : DEFAULT_GOOD_SCORE )
1438 static int AddMetaTriangleToSurface( mapDrawSurface_t *ds, metaTriangle_t *tri, qboolean testAdd ){
1440 int i, score, coincident, ai, bi, ci, oldTexRange[ 2 ];
1443 qboolean inTexRange;
1444 mapDrawSurface_t old;
1447 /* overflow check */
1448 if ( ds->numIndexes >= maxSurfaceIndexes ) {
1452 /* test the triangle */
1453 if ( ds->entityNum != tri->entityNum ) { /* ydnar: added 2002-07-06 */
1456 if ( ds->castShadows != tri->castShadows || ds->recvShadows != tri->recvShadows ) {
1459 if ( ds->shaderInfo != tri->si || ds->fogNum != tri->fogNum || ds->sampleSize != tri->sampleSize ) {
1463 if ( !( ds->shaderInfo->compileFlags & C_VERTEXLIT ) &&
1464 //% VectorCompare( ds->lightmapAxis, tri->lightmapAxis ) == qfalse )
1465 DotProduct( ds->lightmapAxis, tri->plane ) < 0.25f ) {
1470 /* planar surfaces will only merge with triangles in the same plane */
1471 if ( npDegrees == 0.0f && ds->shaderInfo->nonplanar == qfalse && ds->planeNum >= 0 ) {
1472 if ( VectorCompare( mapplanes[ ds->planeNum ].normal, tri->plane ) == qfalse || mapplanes[ ds->planeNum ].dist != tri->plane[ 3 ] ) {
1475 if ( tri->planeNum >= 0 && tri->planeNum != ds->planeNum ) {
1480 if ( metaMaxBBoxDistance >= 0 ) {
1481 if ( ds->numIndexes > 0 ) {
1482 VectorCopy( ds->mins, mins );
1483 VectorCopy( ds->maxs, maxs );
1484 mins[0] -= metaMaxBBoxDistance;
1485 mins[1] -= metaMaxBBoxDistance;
1486 mins[2] -= metaMaxBBoxDistance;
1487 maxs[0] += metaMaxBBoxDistance;
1488 maxs[1] += metaMaxBBoxDistance;
1489 maxs[2] += metaMaxBBoxDistance;
1490 #define CHECK_1D( mins, v, maxs ) ( ( mins ) <= ( v ) && ( v ) <= ( maxs ) )
1491 #define CHECK_3D( mins, v, maxs ) ( CHECK_1D( ( mins )[0], ( v )[0], ( maxs )[0] ) && CHECK_1D( ( mins )[1], ( v )[1], ( maxs )[1] ) && CHECK_1D( ( mins )[2], ( v )[2], ( maxs )[2] ) )
1492 VectorCopy( metaVerts[ tri->indexes[ 0 ] ].xyz, p );
1493 if ( !CHECK_3D( mins, p, maxs ) ) {
1494 VectorCopy( metaVerts[ tri->indexes[ 1 ] ].xyz, p );
1495 if ( !CHECK_3D( mins, p, maxs ) ) {
1496 VectorCopy( metaVerts[ tri->indexes[ 2 ] ].xyz, p );
1497 if ( !CHECK_3D( mins, p, maxs ) ) {
1507 /* set initial score */
1508 score = tri->surfaceNum == ds->surfaceNum ? SURFACE_SCORE : 0;
1510 /* score the the dot product of lightmap axis to plane */
1511 if ( ( ds->shaderInfo->compileFlags & C_VERTEXLIT ) || VectorCompare( ds->lightmapAxis, tri->lightmapAxis ) ) {
1512 score += AXIS_SCORE;
1515 score += AXIS_SCORE * DotProduct( ds->lightmapAxis, tri->plane );
1518 /* preserve old drawsurface if this fails */
1519 memcpy( &old, ds, sizeof( *ds ) );
1521 /* attempt to add the verts */
1523 ai = AddMetaVertToSurface( ds, &metaVerts[ tri->indexes[ 0 ] ], &coincident );
1524 bi = AddMetaVertToSurface( ds, &metaVerts[ tri->indexes[ 1 ] ], &coincident );
1525 ci = AddMetaVertToSurface( ds, &metaVerts[ tri->indexes[ 2 ] ], &coincident );
1527 /* check vertex underflow */
1528 if ( ai < 0 || bi < 0 || ci < 0 ) {
1529 memcpy( ds, &old, sizeof( *ds ) );
1533 /* score coincident vertex count (2003-02-14: changed so this only matters on planar surfaces) */
1534 score += ( coincident * VERT_SCORE );
1536 /* add new vertex bounds to mins/maxs */
1537 VectorCopy( ds->mins, mins );
1538 VectorCopy( ds->maxs, maxs );
1539 AddPointToBounds( metaVerts[ tri->indexes[ 0 ] ].xyz, mins, maxs );
1540 AddPointToBounds( metaVerts[ tri->indexes[ 1 ] ].xyz, mins, maxs );
1541 AddPointToBounds( metaVerts[ tri->indexes[ 2 ] ].xyz, mins, maxs );
1543 /* check lightmap bounds overflow (after at least 1 triangle has been added) */
1544 if ( !( ds->shaderInfo->compileFlags & C_VERTEXLIT ) &&
1545 ds->numIndexes > 0 && VectorLength( ds->lightmapAxis ) > 0.0f &&
1546 ( VectorCompare( ds->mins, mins ) == qfalse || VectorCompare( ds->maxs, maxs ) == qfalse ) ) {
1547 /* set maximum size before lightmap scaling (normally 2032 units) */
1548 /* 2004-02-24: scale lightmap test size by 2 to catch larger brush faces */
1549 /* 2004-04-11: reverting to actual lightmap size */
1550 lmMax = ( ds->sampleSize * ( ds->shaderInfo->lmCustomWidth - 1 ) );
1551 for ( i = 0; i < 3; i++ )
1553 if ( ( maxs[ i ] - mins[ i ] ) > lmMax ) {
1554 memcpy( ds, &old, sizeof( *ds ) );
1560 /* check texture range overflow */
1561 oldTexRange[ 0 ] = ds->texRange[ 0 ];
1562 oldTexRange[ 1 ] = ds->texRange[ 1 ];
1563 inTexRange = CalcSurfaceTextureRange( ds );
1565 if ( inTexRange == qfalse && ds->numIndexes > 0 ) {
1566 memcpy( ds, &old, sizeof( *ds ) );
1567 return UNSUITABLE_TRIANGLE;
1570 /* score texture range */
1571 if ( ds->texRange[ 0 ] <= oldTexRange[ 0 ] ) {
1574 else if ( ds->texRange[ 0 ] > oldTexRange[ 0 ] && oldTexRange[ 1 ] > oldTexRange[ 0 ] ) {
1578 if ( ds->texRange[ 1 ] <= oldTexRange[ 1 ] ) {
1581 else if ( ds->texRange[ 1 ] > oldTexRange[ 1 ] && oldTexRange[ 0 ] > oldTexRange[ 1 ] ) {
1586 /* go through the indexes and try to find an existing triangle that matches abc */
1587 for ( i = 0; i < ds->numIndexes; i += 3 )
1589 /* 2002-03-11 (birthday!): rotate the triangle 3x to find an existing triangle */
1590 if ( ( ai == ds->indexes[ i ] && bi == ds->indexes[ i + 1 ] && ci == ds->indexes[ i + 2 ] ) ||
1591 ( bi == ds->indexes[ i ] && ci == ds->indexes[ i + 1 ] && ai == ds->indexes[ i + 2 ] ) ||
1592 ( ci == ds->indexes[ i ] && ai == ds->indexes[ i + 1 ] && bi == ds->indexes[ i + 2 ] ) ) {
1593 /* triangle already present */
1594 memcpy( ds, &old, sizeof( *ds ) );
1599 /* rotate the triangle 3x to find an inverse triangle (error case) */
1600 if ( ( ai == ds->indexes[ i ] && bi == ds->indexes[ i + 2 ] && ci == ds->indexes[ i + 1 ] ) ||
1601 ( bi == ds->indexes[ i ] && ci == ds->indexes[ i + 2 ] && ai == ds->indexes[ i + 1 ] ) ||
1602 ( ci == ds->indexes[ i ] && ai == ds->indexes[ i + 2 ] && bi == ds->indexes[ i + 1 ] ) ) {
1604 Sys_FPrintf( SYS_WRN, "WARNING: Flipped triangle: (%6.0f %6.0f %6.0f) (%6.0f %6.0f %6.0f) (%6.0f %6.0f %6.0f)\n",
1605 ds->verts[ ai ].xyz[ 0 ], ds->verts[ ai ].xyz[ 1 ], ds->verts[ ai ].xyz[ 2 ],
1606 ds->verts[ bi ].xyz[ 0 ], ds->verts[ bi ].xyz[ 1 ], ds->verts[ bi ].xyz[ 2 ],
1607 ds->verts[ ci ].xyz[ 0 ], ds->verts[ ci ].xyz[ 1 ], ds->verts[ ci ].xyz[ 2 ] );
1609 /* reverse triangle already present */
1610 memcpy( ds, &old, sizeof( *ds ) );
1616 /* add the triangle indexes */
1617 if ( ds->numIndexes < maxSurfaceIndexes ) {
1618 ds->indexes[ ds->numIndexes++ ] = ai;
1620 if ( ds->numIndexes < maxSurfaceIndexes ) {
1621 ds->indexes[ ds->numIndexes++ ] = bi;
1623 if ( ds->numIndexes < maxSurfaceIndexes ) {
1624 ds->indexes[ ds->numIndexes++ ] = ci;
1627 /* check index overflow */
1628 if ( ds->numIndexes >= maxSurfaceIndexes ) {
1629 memcpy( ds, &old, sizeof( *ds ) );
1633 /* sanity check the indexes */
1634 if ( ds->numIndexes >= 3 &&
1635 ( ds->indexes[ ds->numIndexes - 3 ] == ds->indexes[ ds->numIndexes - 2 ] ||
1636 ds->indexes[ ds->numIndexes - 3 ] == ds->indexes[ ds->numIndexes - 1 ] ||
1637 ds->indexes[ ds->numIndexes - 2 ] == ds->indexes[ ds->numIndexes - 1 ] ) ) {
1638 Sys_Printf( "DEG:%d! ", ds->numVerts );
1643 memcpy( ds, &old, sizeof( *ds ) );
1647 /* copy bounds back to surface */
1648 VectorCopy( mins, ds->mins );
1649 VectorCopy( maxs, ds->maxs );
1651 /* mark triangle as used */
1655 /* add a side reference */
1656 ds->sideRef = AllocSideRef( tri->side, ds->sideRef );
1658 /* return to sender */
1665 MetaTrianglesToSurface()
1666 creates map drawsurface(s) from the list of possibles
1669 static void MetaTrianglesToSurface( int numPossibles, metaTriangle_t *possibles, int *fOld, int *numAdded ){
1670 int i, j, f, best, score, bestScore;
1671 metaTriangle_t *seed, *test;
1672 mapDrawSurface_t *ds;
1673 bspDrawVert_t *verts;
1678 /* allocate arrays */
1679 verts = safe_malloc( sizeof( *verts ) * maxSurfaceVerts );
1680 indexes = safe_malloc( sizeof( *indexes ) * maxSurfaceIndexes );
1682 /* walk the list of triangles */
1683 for ( i = 0, seed = possibles; i < numPossibles; i++, seed++ )
1685 /* skip this triangle if it has already been merged */
1686 if ( seed->si == NULL ) {
1690 /* -----------------------------------------------------------------
1691 initial drawsurf construction
1692 ----------------------------------------------------------------- */
1694 /* start a new drawsurface */
1695 ds = AllocDrawSurface( SURFACE_META );
1696 ds->entityNum = seed->entityNum;
1697 ds->surfaceNum = seed->surfaceNum;
1698 ds->castShadows = seed->castShadows;
1699 ds->recvShadows = seed->recvShadows;
1701 ds->shaderInfo = seed->si;
1702 ds->planeNum = seed->planeNum;
1703 ds->fogNum = seed->fogNum;
1704 ds->sampleSize = seed->sampleSize;
1705 ds->shadeAngleDegrees = seed->shadeAngleDegrees;
1707 ds->indexes = indexes;
1708 VectorCopy( seed->lightmapAxis, ds->lightmapAxis );
1709 ds->sideRef = AllocSideRef( seed->side, NULL );
1711 ClearBounds( ds->mins, ds->maxs );
1713 /* clear verts/indexes */
1714 memset( verts, 0, sizeof( *verts ) * maxSurfaceVerts );
1715 memset( indexes, 0, sizeof( *indexes ) * maxSurfaceIndexes );
1717 /* add the first triangle */
1718 if ( AddMetaTriangleToSurface( ds, seed, qfalse ) ) {
1722 /* -----------------------------------------------------------------
1724 ----------------------------------------------------------------- */
1726 /* progressively walk the list until no more triangles can be added */
1730 /* print pacifier */
1731 f = 10 * *numAdded / numMetaTriangles;
1734 Sys_FPrintf( SYS_VRB, "%d...", f );
1737 /* reset best score */
1742 /* walk the list of possible candidates for merging */
1743 for ( j = i + 1, test = &possibles[ j ]; j < numPossibles; j++, test++ )
1745 /* skip this triangle if it has already been merged */
1746 if ( test->si == NULL ) {
1750 /* score this triangle */
1751 score = AddMetaTriangleToSurface( ds, test, qtrue );
1752 if ( score > bestScore ) {
1756 /* if we have a score over a certain threshold, just use it */
1757 if ( bestScore >= GOOD_SCORE ) {
1758 if ( AddMetaTriangleToSurface( ds, &possibles[ best ], qfalse ) ) {
1770 /* add best candidate */
1771 if ( best >= 0 && bestScore > ADEQUATE_SCORE ) {
1772 if ( AddMetaTriangleToSurface( ds, &possibles[ best ], qfalse ) ) {
1781 /* copy the verts and indexes to the new surface */
1782 ds->verts = safe_malloc( ds->numVerts * sizeof( bspDrawVert_t ) );
1783 memcpy( ds->verts, verts, ds->numVerts * sizeof( bspDrawVert_t ) );
1784 ds->indexes = safe_malloc( ds->numIndexes * sizeof( int ) );
1785 memcpy( ds->indexes, indexes, ds->numIndexes * sizeof( int ) );
1787 /* classify the surface */
1788 ClassifySurfaces( 1, ds );
1791 numMergedSurfaces++;
1802 CompareMetaTriangles()
1803 compare function for qsort()
1806 static int CompareMetaTriangles( const void *a, const void *b ){
1808 vec3_t aMins, bMins;
1812 if ( ( (const metaTriangle_t*) a )->si < ( (const metaTriangle_t*) b )->si ) {
1815 else if ( ( (const metaTriangle_t*) a )->si > ( (const metaTriangle_t*) b )->si ) {
1820 else if ( ( (const metaTriangle_t*) a )->fogNum < ( (const metaTriangle_t*) b )->fogNum ) {
1823 else if ( ( (const metaTriangle_t*) a )->fogNum > ( (const metaTriangle_t*) b )->fogNum ) {
1829 else if ( npDegrees == 0.0f && ( (const metaTriangle_t*) a )->si->nonplanar == qfalse &&
1830 ( (const metaTriangle_t*) a )->planeNum >= 0 && ( (const metaTriangle_t*) a )->planeNum >= 0 ) {
1831 if ( ( (const metaTriangle_t*) a )->plane[ 3 ] < ( (const metaTriangle_t*) b )->plane[ 3 ] ) {
1834 else if ( ( (const metaTriangle_t*) a )->plane[ 3 ] > ( (const metaTriangle_t*) b )->plane[ 3 ] ) {
1837 else if ( ( (const metaTriangle_t*) a )->plane[ 0 ] < ( (const metaTriangle_t*) b )->plane[ 0 ] ) {
1840 else if ( ( (const metaTriangle_t*) a )->plane[ 0 ] > ( (const metaTriangle_t*) b )->plane[ 0 ] ) {
1843 else if ( ( (const metaTriangle_t*) a )->plane[ 1 ] < ( (const metaTriangle_t*) b )->plane[ 1 ] ) {
1846 else if ( ( (const metaTriangle_t*) a )->plane[ 1 ] > ( (const metaTriangle_t*) b )->plane[ 1 ] ) {
1849 else if ( ( (const metaTriangle_t*) a )->plane[ 2 ] < ( (const metaTriangle_t*) b )->plane[ 2 ] ) {
1852 else if ( ( (const metaTriangle_t*) a )->plane[ 2 ] > ( (const metaTriangle_t*) b )->plane[ 2 ] ) {
1858 /* then position in world */
1861 VectorSet( aMins, 999999, 999999, 999999 );
1862 VectorSet( bMins, 999999, 999999, 999999 );
1863 for ( i = 0; i < 3; i++ )
1865 av = ( (const metaTriangle_t*) a )->indexes[ i ];
1866 bv = ( (const metaTriangle_t*) b )->indexes[ i ];
1867 for ( j = 0; j < 3; j++ )
1869 if ( metaVerts[ av ].xyz[ j ] < aMins[ j ] ) {
1870 aMins[ j ] = metaVerts[ av ].xyz[ j ];
1872 if ( metaVerts[ bv ].xyz[ j ] < bMins[ j ] ) {
1873 bMins[ j ] = metaVerts[ bv ].xyz[ j ];
1879 for ( i = 0; i < 3; i++ )
1881 if ( aMins[ i ] < bMins[ i ] ) {
1884 else if ( aMins[ i ] > bMins[ i ] ) {
1889 /* functionally equivalent */
1896 MergeMetaTriangles()
1897 merges meta triangles into drawsurfaces
1900 void MergeMetaTriangles( void ){
1901 int i, j, fOld, start, numAdded;
1902 metaTriangle_t *head, *end;
1905 /* only do this if there are meta triangles */
1906 if ( numMetaTriangles <= 0 ) {
1911 Sys_FPrintf( SYS_VRB, "--- MergeMetaTriangles ---\n" );
1913 /* sort the triangles by shader major, fognum minor */
1914 qsort( metaTriangles, numMetaTriangles, sizeof( metaTriangle_t ), CompareMetaTriangles );
1918 start = I_FloatTime();
1922 for ( i = 0, j = 0; i < numMetaTriangles; i = j )
1924 /* get head of list */
1925 head = &metaTriangles[ i ];
1927 /* skip this triangle if it has already been merged */
1928 if ( head->si == NULL ) {
1934 for ( j = i + 1; j < numMetaTriangles; j++ )
1936 /* get end of list */
1937 end = &metaTriangles[ j ];
1938 if ( head->si != end->si || head->fogNum != end->fogNum ) {
1944 /* try to merge this list of possible merge candidates */
1945 MetaTrianglesToSurface( ( j - i ), head, &fOld, &numAdded );
1948 /* clear meta triangle list */
1949 ClearMetaTriangles();
1953 Sys_FPrintf( SYS_VRB, " (%d)\n", (int) ( I_FloatTime() - start ) );
1956 /* emit some stats */
1957 Sys_FPrintf( SYS_VRB, "%9d surfaces merged\n", numMergedSurfaces );
1958 Sys_FPrintf( SYS_VRB, "%9d vertexes merged\n", numMergedVerts );