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 ------------------------------------------------------------------------------- */
43 returns an 50/50 interpolated vert
46 void LerpDrawVert( bspDrawVert_t *a, bspDrawVert_t *b, bspDrawVert_t *out ){
50 out->xyz[ 0 ] = 0.5 * ( a->xyz[ 0 ] + b->xyz[ 0 ] );
51 out->xyz[ 1 ] = 0.5 * ( a->xyz[ 1 ] + b->xyz[ 1 ] );
52 out->xyz[ 2 ] = 0.5 * ( a->xyz[ 2 ] + b->xyz[ 2 ] );
54 out->st[ 0 ] = 0.5 * ( a->st[ 0 ] + b->st[ 0 ] );
55 out->st[ 1 ] = 0.5 * ( a->st[ 1 ] + b->st[ 1 ] );
57 for ( k = 0; k < MAX_LIGHTMAPS; k++ )
59 out->lightmap[ k ][ 0 ] = 0.5f * ( a->lightmap[ k ][ 0 ] + b->lightmap[ k ][ 0 ] );
60 out->lightmap[ k ][ 1 ] = 0.5f * ( a->lightmap[ k ][ 1 ] + b->lightmap[ k ][ 1 ] );
61 out->color[ k ][ 0 ] = ( a->color[ k ][ 0 ] + b->color[ k ][ 0 ] ) >> 1;
62 out->color[ k ][ 1 ] = ( a->color[ k ][ 1 ] + b->color[ k ][ 1 ] ) >> 1;
63 out->color[ k ][ 2 ] = ( a->color[ k ][ 2 ] + b->color[ k ][ 2 ] ) >> 1;
64 out->color[ k ][ 3 ] = ( a->color[ k ][ 3 ] + b->color[ k ][ 3 ] ) >> 1;
67 /* ydnar: added normal interpolation */
68 out->normal[ 0 ] = 0.5f * ( a->normal[ 0 ] + b->normal[ 0 ] );
69 out->normal[ 1 ] = 0.5f * ( a->normal[ 1 ] + b->normal[ 1 ] );
70 out->normal[ 2 ] = 0.5f * ( a->normal[ 2 ] + b->normal[ 2 ] );
72 /* if the interpolant created a bogus normal, just copy the normal from a */
73 if ( VectorNormalize( out->normal, out->normal ) == 0 ) {
74 VectorCopy( a->normal, out->normal );
82 returns a biased interpolated vert
85 void LerpDrawVertAmount( bspDrawVert_t *a, bspDrawVert_t *b, float amount, bspDrawVert_t *out ){
89 out->xyz[ 0 ] = a->xyz[ 0 ] + amount * ( b->xyz[ 0 ] - a->xyz[ 0 ] );
90 out->xyz[ 1 ] = a->xyz[ 1 ] + amount * ( b->xyz[ 1 ] - a->xyz[ 1 ] );
91 out->xyz[ 2 ] = a->xyz[ 2 ] + amount * ( b->xyz[ 2 ] - a->xyz[ 2 ] );
93 out->st[ 0 ] = a->st[ 0 ] + amount * ( b->st[ 0 ] - a->st[ 0 ] );
94 out->st[ 1 ] = a->st[ 1 ] + amount * ( b->st[ 1 ] - a->st[ 1 ] );
96 for ( k = 0; k < MAX_LIGHTMAPS; k++ )
98 out->lightmap[ k ][ 0 ] = a->lightmap[ k ][ 0 ] + amount * ( b->lightmap[ k ][ 0 ] - a->lightmap[ k ][ 0 ] );
99 out->lightmap[ k ][ 1 ] = a->lightmap[ k ][ 1 ] + amount * ( b->lightmap[ k ][ 1 ] - a->lightmap[ k ][ 1 ] );
100 out->color[ k ][ 0 ] = a->color[ k ][ 0 ] + amount * ( b->color[ k ][ 0 ] - a->color[ k ][ 0 ] );
101 out->color[ k ][ 1 ] = a->color[ k ][ 1 ] + amount * ( b->color[ k ][ 1 ] - a->color[ k ][ 1 ] );
102 out->color[ k ][ 2 ] = a->color[ k ][ 2 ] + amount * ( b->color[ k ][ 2 ] - a->color[ k ][ 2 ] );
103 out->color[ k ][ 3 ] = a->color[ k ][ 3 ] + amount * ( b->color[ k ][ 3 ] - a->color[ k ][ 3 ] );
106 out->normal[ 0 ] = a->normal[ 0 ] + amount * ( b->normal[ 0 ] - a->normal[ 0 ] );
107 out->normal[ 1 ] = a->normal[ 1 ] + amount * ( b->normal[ 1 ] - a->normal[ 1 ] );
108 out->normal[ 2 ] = a->normal[ 2 ] + amount * ( b->normal[ 2 ] - a->normal[ 2 ] );
110 /* if the interpolant created a bogus normal, just copy the normal from a */
111 if ( VectorNormalize( out->normal, out->normal ) == 0 ) {
112 VectorCopy( a->normal, out->normal );
117 void FreeMesh( mesh_t *m ) {
122 void PrintMesh( mesh_t *m ) {
125 for ( i = 0 ; i < m->height ; i++ ) {
126 for ( j = 0 ; j < m->width ; j++ ) {
127 Sys_Printf( "(%5.2f %5.2f %5.2f) "
128 , m->verts[i * m->width + j].xyz[0]
129 , m->verts[i * m->width + j].xyz[1]
130 , m->verts[i * m->width + j].xyz[2] );
137 mesh_t *CopyMesh( mesh_t *mesh ) {
141 out = safe_malloc( sizeof( *out ) );
142 out->width = mesh->width;
143 out->height = mesh->height;
145 size = out->width * out->height * sizeof( *out->verts );
146 out->verts = safe_malloc( size );
147 memcpy( out->verts, mesh->verts, size );
155 returns a transposed copy of the mesh, freeing the original
158 mesh_t *TransposeMesh( mesh_t *in ) {
162 out = safe_malloc( sizeof( *out ) );
163 out->width = in->height;
164 out->height = in->width;
165 out->verts = safe_malloc( out->width * out->height * sizeof( bspDrawVert_t ) );
167 for ( h = 0 ; h < in->height ; h++ ) {
168 for ( w = 0 ; w < in->width ; w++ ) {
169 out->verts[ w * in->height + h ] = in->verts[ h * in->width + w ];
178 void InvertMesh( mesh_t *in ) {
182 for ( h = 0 ; h < in->height ; h++ ) {
183 for ( w = 0 ; w < in->width / 2 ; w++ ) {
184 temp = in->verts[ h * in->width + w ];
185 in->verts[ h * in->width + w ] = in->verts[ h * in->width + in->width - 1 - w ];
186 in->verts[ h * in->width + in->width - 1 - w ] = temp;
197 void MakeMeshNormals( mesh_t in ){
206 vec3_t around[8], temp;
208 qboolean wrapWidth, wrapHeight;
210 int neighbors[8][2] =
212 {0,1}, {1,1}, {1,0}, {1,-1}, {0,-1}, {-1,-1}, {-1,0}, {-1,1}
217 for ( i = 0 ; i < in.height ; i++ ) {
218 VectorSubtract( in.verts[i * in.width].xyz,
219 in.verts[i * in.width + in.width - 1].xyz, delta );
220 len = VectorLength( delta );
225 if ( i == in.height ) {
230 for ( i = 0 ; i < in.width ; i++ ) {
231 VectorSubtract( in.verts[i].xyz,
232 in.verts[i + ( in.height - 1 ) * in.width].xyz, delta );
233 len = VectorLength( delta );
238 if ( i == in.width ) {
243 for ( i = 0 ; i < in.width ; i++ ) {
244 for ( j = 0 ; j < in.height ; j++ ) {
246 dv = &in.verts[j * in.width + i];
247 VectorCopy( dv->xyz, base );
248 for ( k = 0 ; k < 8 ; k++ ) {
249 VectorClear( around[k] );
252 for ( dist = 1 ; dist <= 3 ; dist++ ) {
253 x = i + neighbors[k][0] * dist;
254 y = j + neighbors[k][1] * dist;
257 x = in.width - 1 + x;
259 else if ( x >= in.width ) {
260 x = 1 + x - in.width;
265 y = in.height - 1 + y;
267 else if ( y >= in.height ) {
268 y = 1 + y - in.height;
272 if ( x < 0 || x >= in.width || y < 0 || y >= in.height ) {
273 break; // edge of patch
275 VectorSubtract( in.verts[y * in.width + x].xyz, base, temp );
276 if ( VectorNormalize( temp, temp ) == 0 ) {
277 continue; // degenerate edge, get more dist
281 VectorCopy( temp, around[k] );
288 for ( k = 0 ; k < 8 ; k++ ) {
289 if ( !good[k] || !good[( k + 1 ) & 7] ) {
290 continue; // didn't get two points
292 CrossProduct( around[( k + 1 ) & 7], around[k], normal );
293 if ( VectorNormalize( normal, normal ) == 0 ) {
296 VectorAdd( normal, sum, sum );
300 //Sys_Printf("bad normal\n");
303 VectorNormalize( sum, dv->normal );
310 drops the aproximating points onto the curve
311 ydnar: fixme: make this use LerpDrawVert() rather than this complicated mess
314 void PutMeshOnCurve( mesh_t in ) {
319 // put all the aproximating points on the curve
320 for ( i = 0 ; i < in.width ; i++ ) {
321 for ( j = 1 ; j < in.height ; j += 2 ) {
322 for ( l = 0 ; l < 3 ; l++ ) {
323 prev = ( in.verts[j * in.width + i].xyz[l] + in.verts[( j + 1 ) * in.width + i].xyz[l] ) * 0.5;
324 next = ( in.verts[j * in.width + i].xyz[l] + in.verts[( j - 1 ) * in.width + i].xyz[l] ) * 0.5;
325 in.verts[j * in.width + i].xyz[l] = ( prev + next ) * 0.5;
327 /* ydnar: interpolating st coords */
329 prev = ( in.verts[j * in.width + i].st[l] + in.verts[( j + 1 ) * in.width + i].st[l] ) * 0.5;
330 next = ( in.verts[j * in.width + i].st[l] + in.verts[( j - 1 ) * in.width + i].st[l] ) * 0.5;
331 in.verts[j * in.width + i].st[l] = ( prev + next ) * 0.5;
333 for ( m = 0; m < MAX_LIGHTMAPS; m++ )
335 prev = ( in.verts[j * in.width + i].lightmap[ m ][l] + in.verts[( j + 1 ) * in.width + i].lightmap[ m ][l] ) * 0.5;
336 next = ( in.verts[j * in.width + i].lightmap[ m ][l] + in.verts[( j - 1 ) * in.width + i].lightmap[ m ][l] ) * 0.5;
337 in.verts[j * in.width + i].lightmap[ m ][l] = ( prev + next ) * 0.5;
344 for ( j = 0 ; j < in.height ; j++ ) {
345 for ( i = 1 ; i < in.width ; i += 2 ) {
346 for ( l = 0 ; l < 3 ; l++ ) {
347 prev = ( in.verts[j * in.width + i].xyz[l] + in.verts[j * in.width + i + 1].xyz[l] ) * 0.5;
348 next = ( in.verts[j * in.width + i].xyz[l] + in.verts[j * in.width + i - 1].xyz[l] ) * 0.5;
349 in.verts[j * in.width + i].xyz[l] = ( prev + next ) * 0.5;
351 /* ydnar: interpolating st coords */
353 prev = ( in.verts[j * in.width + i].st[l] + in.verts[j * in.width + i + 1].st[l] ) * 0.5;
354 next = ( in.verts[j * in.width + i].st[l] + in.verts[j * in.width + i - 1].st[l] ) * 0.5;
355 in.verts[j * in.width + i].st[l] = ( prev + next ) * 0.5;
357 for ( m = 0; m < MAX_LIGHTMAPS; m++ )
359 prev = ( in.verts[j * in.width + i].lightmap[ m ][l] + in.verts[j * in.width + i + 1].lightmap[ m ][l] ) * 0.5;
360 next = ( in.verts[j * in.width + i].lightmap[ m ][l] + in.verts[j * in.width + i - 1].lightmap[ m ][l] ) * 0.5;
361 in.verts[j * in.width + i].lightmap[ m ][l] = ( prev + next ) * 0.5;
376 mesh_t *SubdivideMesh( mesh_t in, float maxError, float minLength ){
378 bspDrawVert_t prev, next, mid;
379 vec3_t prevxyz, nextxyz, midxyz;
384 bspDrawVert_t expand[MAX_EXPANDED_AXIS][MAX_EXPANDED_AXIS];
387 out.width = in.width;
388 out.height = in.height;
390 for ( i = 0 ; i < in.width ; i++ ) {
391 for ( j = 0 ; j < in.height ; j++ ) {
392 expand[j][i] = in.verts[j * in.width + i];
396 // horizontal subdivisions
397 for ( j = 0 ; j + 2 < out.width ; j += 2 ) {
398 // check subdivided midpoints against control points
399 for ( i = 0 ; i < out.height ; i++ ) {
400 for ( l = 0 ; l < 3 ; l++ ) {
401 prevxyz[l] = expand[i][j + 1].xyz[l] - expand[i][j].xyz[l];
402 nextxyz[l] = expand[i][j + 2].xyz[l] - expand[i][j + 1].xyz[l];
403 midxyz[l] = ( expand[i][j].xyz[l] + expand[i][j + 1].xyz[l] * 2
404 + expand[i][j + 2].xyz[l] ) * 0.25;
407 // if the span length is too long, force a subdivision
408 if ( VectorLength( prevxyz ) > minLength
409 || VectorLength( nextxyz ) > minLength ) {
413 // see if this midpoint is off far enough to subdivide
414 VectorSubtract( expand[i][j + 1].xyz, midxyz, delta );
415 len = VectorLength( delta );
416 if ( len > maxError ) {
421 if ( out.width + 2 >= MAX_EXPANDED_AXIS ) {
422 break; // can't subdivide any more
425 if ( i == out.height ) {
426 continue; // didn't need subdivision
429 // insert two columns and replace the peak
432 for ( i = 0 ; i < out.height ; i++ ) {
433 LerpDrawVert( &expand[i][j], &expand[i][j + 1], &prev );
434 LerpDrawVert( &expand[i][j + 1], &expand[i][j + 2], &next );
435 LerpDrawVert( &prev, &next, &mid );
437 for ( k = out.width - 1 ; k > j + 3 ; k-- ) {
438 expand[i][k] = expand[i][k - 2];
440 expand[i][j + 1] = prev;
441 expand[i][j + 2] = mid;
442 expand[i][j + 3] = next;
445 // back up and recheck this set again, it may need more subdivision
450 // vertical subdivisions
451 for ( j = 0 ; j + 2 < out.height ; j += 2 ) {
452 // check subdivided midpoints against control points
453 for ( i = 0 ; i < out.width ; i++ ) {
454 for ( l = 0 ; l < 3 ; l++ ) {
455 prevxyz[l] = expand[j + 1][i].xyz[l] - expand[j][i].xyz[l];
456 nextxyz[l] = expand[j + 2][i].xyz[l] - expand[j + 1][i].xyz[l];
457 midxyz[l] = ( expand[j][i].xyz[l] + expand[j + 1][i].xyz[l] * 2
458 + expand[j + 2][i].xyz[l] ) * 0.25;
461 // if the span length is too long, force a subdivision
462 if ( VectorLength( prevxyz ) > minLength
463 || VectorLength( nextxyz ) > minLength ) {
466 // see if this midpoint is off far enough to subdivide
467 VectorSubtract( expand[j + 1][i].xyz, midxyz, delta );
468 len = VectorLength( delta );
469 if ( len > maxError ) {
474 if ( out.height + 2 >= MAX_EXPANDED_AXIS ) {
475 break; // can't subdivide any more
478 if ( i == out.width ) {
479 continue; // didn't need subdivision
482 // insert two columns and replace the peak
485 for ( i = 0 ; i < out.width ; i++ ) {
486 LerpDrawVert( &expand[j][i], &expand[j + 1][i], &prev );
487 LerpDrawVert( &expand[j + 1][i], &expand[j + 2][i], &next );
488 LerpDrawVert( &prev, &next, &mid );
490 for ( k = out.height - 1 ; k > j + 3 ; k-- ) {
491 expand[k][i] = expand[k - 2][i];
493 expand[j + 1][i] = prev;
494 expand[j + 2][i] = mid;
495 expand[j + 3][i] = next;
498 // back up and recheck this set again, it may need more subdivision
503 // collapse the verts
505 out.verts = &expand[0][0];
506 for ( i = 1 ; i < out.height ; i++ ) {
507 memmove( &out.verts[i * out.width], expand[i], out.width * sizeof( bspDrawVert_t ) );
510 return CopyMesh( &out );
516 IterationsForCurve() - ydnar
517 given a curve of a certain length, return the number of subdivision iterations
518 note: this is affected by subdivision amount
521 int IterationsForCurve( float len, int subdivisions ){
522 int iterations, facets;
525 /* calculate the number of subdivisions */
526 for ( iterations = 0; iterations < 3; iterations++ )
528 facets = subdivisions * 16 * pow( 2, iterations );
529 if ( facets >= len ) {
534 /* return to caller */
540 SubdivideMesh2() - ydnar
541 subdivides each mesh quad a specified number of times
544 mesh_t *SubdivideMesh2( mesh_t in, int iterations ){
546 bspDrawVert_t prev, next, mid;
549 bspDrawVert_t expand[ MAX_EXPANDED_AXIS ][ MAX_EXPANDED_AXIS ];
553 out.width = in.width;
554 out.height = in.height;
555 for ( i = 0; i < in.width; i++ )
557 for ( j = 0; j < in.height; j++ )
558 expand[ j ][ i ] = in.verts[ j * in.width + i ];
562 for ( ; iterations > 0; iterations-- )
564 /* horizontal subdivisions */
565 for ( j = 0; j + 2 < out.width; j += 4 )
567 /* check size limit */
568 if ( out.width + 2 >= MAX_EXPANDED_AXIS ) {
572 /* insert two columns and replace the peak */
574 for ( i = 0; i < out.height; i++ )
576 LerpDrawVert( &expand[ i ][ j ], &expand[ i ][ j + 1 ], &prev );
577 LerpDrawVert( &expand[ i ][ j + 1 ], &expand[ i ][ j + 2 ], &next );
578 LerpDrawVert( &prev, &next, &mid );
580 for ( k = out.width - 1 ; k > j + 3; k-- )
581 expand [ i ][ k ] = expand[ i ][ k - 2 ];
582 expand[ i ][ j + 1 ] = prev;
583 expand[ i ][ j + 2 ] = mid;
584 expand[ i ][ j + 3 ] = next;
589 /* vertical subdivisions */
590 for ( j = 0; j + 2 < out.height; j += 4 )
592 /* check size limit */
593 if ( out.height + 2 >= MAX_EXPANDED_AXIS ) {
597 /* insert two columns and replace the peak */
599 for ( i = 0; i < out.width; i++ )
601 LerpDrawVert( &expand[ j ][ i ], &expand[ j + 1 ][ i ], &prev );
602 LerpDrawVert( &expand[ j + 1 ][ i ], &expand[ j + 2 ][ i ], &next );
603 LerpDrawVert( &prev, &next, &mid );
605 for ( k = out.height - 1; k > j + 3; k-- )
606 expand[ k ][ i ] = expand[ k - 2 ][ i ];
607 expand[ j + 1 ][ i ] = prev;
608 expand[ j + 2 ][ i ] = mid;
609 expand[ j + 3 ][ i ] = next;
614 /* collapse the verts */
615 out.verts = &expand[ 0 ][ 0 ];
616 for ( i = 1; i < out.height; i++ )
617 memmove( &out.verts[ i * out.width ], expand[ i ], out.width * sizeof( bspDrawVert_t ) );
619 /* return to sender */
620 return CopyMesh( &out );
631 ProjectPointOntoVector
634 void ProjectPointOntoVector( vec3_t point, vec3_t vStart, vec3_t vEnd, vec3_t vProj ){
637 VectorSubtract( point, vStart, pVec );
638 VectorSubtract( vEnd, vStart, vec );
639 VectorNormalize( vec, vec );
640 // project onto the directional vector for this segment
641 VectorMA( vStart, DotProduct( pVec, vec ), vec, vProj );
646 RemoveLinearMeshColumsRows
649 mesh_t *RemoveLinearMeshColumnsRows( mesh_t *in ) {
651 float len, maxLength;
655 bspDrawVert_t expand[MAX_EXPANDED_AXIS][MAX_EXPANDED_AXIS];
658 out.width = in->width;
659 out.height = in->height;
661 for ( i = 0 ; i < in->width ; i++ ) {
662 for ( j = 0 ; j < in->height ; j++ ) {
663 expand[j][i] = in->verts[j * in->width + i];
667 for ( j = 1 ; j < out.width - 1; j++ ) {
669 for ( i = 0 ; i < out.height ; i++ ) {
670 ProjectPointOntoVector( expand[i][j].xyz, expand[i][j - 1].xyz, expand[i][j + 1].xyz, proj );
671 VectorSubtract( expand[i][j].xyz, proj, dir );
672 len = VectorLength( dir );
673 if ( len > maxLength ) {
677 if ( maxLength < 0.1 ) {
679 for ( i = 0 ; i < out.height ; i++ ) {
680 for ( k = j; k < out.width; k++ ) {
681 expand[i][k] = expand[i][k + 1];
687 for ( j = 1 ; j < out.height - 1; j++ ) {
689 for ( i = 0 ; i < out.width ; i++ ) {
690 ProjectPointOntoVector( expand[j][i].xyz, expand[j - 1][i].xyz, expand[j + 1][i].xyz, proj );
691 VectorSubtract( expand[j][i].xyz, proj, dir );
692 len = VectorLength( dir );
693 if ( len > maxLength ) {
697 if ( maxLength < 0.1 ) {
699 for ( i = 0 ; i < out.width ; i++ ) {
700 for ( k = j; k < out.height; k++ ) {
701 expand[k][i] = expand[k + 1][i];
707 // collapse the verts
708 out.verts = &expand[0][0];
709 for ( i = 1 ; i < out.height ; i++ ) {
710 memmove( &out.verts[i * out.width], expand[i], out.width * sizeof( bspDrawVert_t ) );
713 return CopyMesh( &out );
723 mesh_t *SubdivideMeshQuads( mesh_t *in, float minLength, int maxsize, int *widthtable, int *heighttable ){
724 int i, j, k, w, h, maxsubdivisions, subdivisions;
726 float length, maxLength, amount;
728 bspDrawVert_t expand[MAX_EXPANDED_AXIS][MAX_EXPANDED_AXIS];
730 out.width = in->width;
731 out.height = in->height;
733 for ( i = 0 ; i < in->width ; i++ ) {
734 for ( j = 0 ; j < in->height ; j++ ) {
735 expand[j][i] = in->verts[j * in->width + i];
739 if ( maxsize > MAX_EXPANDED_AXIS ) {
740 Error( "SubdivideMeshQuads: maxsize > MAX_EXPANDED_AXIS" );
743 // horizontal subdivisions
745 maxsubdivisions = ( maxsize - in->width ) / ( in->width - 1 );
747 for ( w = 0, j = 0 ; w < in->width - 1; w++, j += subdivisions + 1 ) {
749 for ( i = 0 ; i < out.height ; i++ ) {
750 VectorSubtract( expand[i][j + 1].xyz, expand[i][j].xyz, dir );
751 length = VectorLength( dir );
752 if ( length > maxLength ) {
757 subdivisions = (int) ( maxLength / minLength );
758 if ( subdivisions > maxsubdivisions ) {
759 subdivisions = maxsubdivisions;
762 widthtable[w] = subdivisions + 1;
763 if ( subdivisions <= 0 ) {
767 out.width += subdivisions;
769 for ( i = 0 ; i < out.height ; i++ ) {
770 for ( k = out.width - 1 ; k > j + subdivisions; k-- ) {
771 expand[i][k] = expand[i][k - subdivisions];
773 for ( k = 1; k <= subdivisions; k++ )
775 amount = (float) k / ( subdivisions + 1 );
776 LerpDrawVertAmount( &expand[i][j], &expand[i][j + subdivisions + 1], amount, &expand[i][j + k] );
781 maxsubdivisions = ( maxsize - in->height ) / ( in->height - 1 );
783 for ( h = 0, j = 0 ; h < in->height - 1; h++, j += subdivisions + 1 ) {
785 for ( i = 0 ; i < out.width ; i++ ) {
786 VectorSubtract( expand[j + 1][i].xyz, expand[j][i].xyz, dir );
787 length = VectorLength( dir );
788 if ( length > maxLength ) {
793 subdivisions = (int) ( maxLength / minLength );
794 if ( subdivisions > maxsubdivisions ) {
795 subdivisions = maxsubdivisions;
798 heighttable[h] = subdivisions + 1;
799 if ( subdivisions <= 0 ) {
803 out.height += subdivisions;
805 for ( i = 0 ; i < out.width ; i++ ) {
806 for ( k = out.height - 1 ; k > j + subdivisions; k-- ) {
807 expand[k][i] = expand[k - subdivisions][i];
809 for ( k = 1; k <= subdivisions; k++ )
811 amount = (float) k / ( subdivisions + 1 );
812 LerpDrawVertAmount( &expand[j][i], &expand[j + subdivisions + 1][i], amount, &expand[j + k][i] );
817 // collapse the verts
818 out.verts = &expand[0][0];
819 for ( i = 1 ; i < out.height ; i++ ) {
820 memmove( &out.verts[i * out.width], expand[i], out.width * sizeof( bspDrawVert_t ) );
823 return CopyMesh( &out );