-/*
-Copyright (C) 1999-2007 id Software, Inc. and contributors.
-For a list of contributors, see the accompanying CONTRIBUTORS file.
+/* -------------------------------------------------------------------------------
+
+ Copyright (C) 1999-2007 id Software, Inc. and contributors.
+ For a list of contributors, see the accompanying CONTRIBUTORS file.
-This file is part of GtkRadiant.
+ This file is part of GtkRadiant.
-GtkRadiant is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ GtkRadiant is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-GtkRadiant is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ GtkRadiant is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with GtkRadiant; if not, write to the Free Software
-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ You should have received a copy of the GNU General Public License
+ along with GtkRadiant; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-----------------------------------------------------------------------------------
+ ----------------------------------------------------------------------------------
-This code has been altered significantly from its original form, to support
-several games based on the Quake III Arena engine, in the form of "Q3Map2."
+ This code has been altered significantly from its original form, to support
+ several games based on the Quake III Arena engine, in the form of "Q3Map2."
-------------------------------------------------------------------------------- */
+ ------------------------------------------------------------------------------- */
/*
-LerpDrawVert()
-returns an 50/50 interpolated vert
-*/
-
-void LerpDrawVert( bspDrawVert_t *a, bspDrawVert_t *b, bspDrawVert_t *out )
-{
- int k;
-
-
- out->xyz[ 0 ] = 0.5 * (a->xyz[ 0 ] + b->xyz[ 0 ]);
- out->xyz[ 1 ] = 0.5 * (a->xyz[ 1 ] + b->xyz[ 1 ]);
- out->xyz[ 2 ] = 0.5 * (a->xyz[ 2 ] + b->xyz[ 2 ]);
-
- out->st[ 0 ] = 0.5 * (a->st[ 0 ] + b->st[ 0 ]);
- out->st[ 1 ] = 0.5 * (a->st[ 1 ] + b->st[ 1 ]);
-
- for( k = 0; k < MAX_LIGHTMAPS; k++ )
+ LerpDrawVert()
+ returns an 50/50 interpolated vert
+ */
+
+void LerpDrawVert( bspDrawVert_t *a, bspDrawVert_t *b, bspDrawVert_t *out ){
+ int k;
+
+
+ out->xyz[ 0 ] = 0.5 * ( a->xyz[ 0 ] + b->xyz[ 0 ] );
+ out->xyz[ 1 ] = 0.5 * ( a->xyz[ 1 ] + b->xyz[ 1 ] );
+ out->xyz[ 2 ] = 0.5 * ( a->xyz[ 2 ] + b->xyz[ 2 ] );
+
+ out->st[ 0 ] = 0.5 * ( a->st[ 0 ] + b->st[ 0 ] );
+ out->st[ 1 ] = 0.5 * ( a->st[ 1 ] + b->st[ 1 ] );
+
+ for ( k = 0; k < MAX_LIGHTMAPS; k++ )
{
- out->lightmap[ k ][ 0 ] = 0.5f * (a->lightmap[ k ][ 0 ] + b->lightmap[ k ][ 0 ]);
- out->lightmap[ k ][ 1 ] = 0.5f * (a->lightmap[ k ][ 1 ] + b->lightmap[ k ][ 1 ]);
- out->color[ k ][ 0 ] = (a->color[ k ][ 0 ] + b->color[ k ][ 0 ]) >> 1;
- out->color[ k ][ 1 ] = (a->color[ k ][ 1 ] + b->color[ k ][ 1 ]) >> 1;
- out->color[ k ][ 2 ] = (a->color[ k ][ 2 ] + b->color[ k ][ 2 ]) >> 1;
- out->color[ k ][ 3 ] = (a->color[ k ][ 3 ] + b->color[ k ][ 3 ]) >> 1;
+ out->lightmap[ k ][ 0 ] = 0.5f * ( a->lightmap[ k ][ 0 ] + b->lightmap[ k ][ 0 ] );
+ out->lightmap[ k ][ 1 ] = 0.5f * ( a->lightmap[ k ][ 1 ] + b->lightmap[ k ][ 1 ] );
+ out->color[ k ][ 0 ] = ( a->color[ k ][ 0 ] + b->color[ k ][ 0 ] ) >> 1;
+ out->color[ k ][ 1 ] = ( a->color[ k ][ 1 ] + b->color[ k ][ 1 ] ) >> 1;
+ out->color[ k ][ 2 ] = ( a->color[ k ][ 2 ] + b->color[ k ][ 2 ] ) >> 1;
+ out->color[ k ][ 3 ] = ( a->color[ k ][ 3 ] + b->color[ k ][ 3 ] ) >> 1;
}
-
+
/* ydnar: added normal interpolation */
- out->normal[ 0 ] = 0.5f * (a->normal[ 0 ] + b->normal[ 0 ]);
- out->normal[ 1 ] = 0.5f * (a->normal[ 1 ] + b->normal[ 1 ]);
- out->normal[ 2 ] = 0.5f * (a->normal[ 2 ] + b->normal[ 2 ]);
-
+ out->normal[ 0 ] = 0.5f * ( a->normal[ 0 ] + b->normal[ 0 ] );
+ out->normal[ 1 ] = 0.5f * ( a->normal[ 1 ] + b->normal[ 1 ] );
+ out->normal[ 2 ] = 0.5f * ( a->normal[ 2 ] + b->normal[ 2 ] );
+
/* if the interpolant created a bogus normal, just copy the normal from a */
- if( VectorNormalize( out->normal, out->normal ) == 0 )
+ if ( VectorNormalize( out->normal, out->normal ) == 0 ) {
VectorCopy( a->normal, out->normal );
+ }
}
/*
-LerpDrawVertAmount()
-returns a biased interpolated vert
-*/
-
-void LerpDrawVertAmount( bspDrawVert_t *a, bspDrawVert_t *b, float amount, bspDrawVert_t *out )
-{
- int k;
-
-
- out->xyz[ 0 ] = a->xyz[ 0 ] + amount * (b->xyz[ 0 ] - a->xyz[ 0 ]);
- out->xyz[ 1 ] = a->xyz[ 1 ] + amount * (b->xyz[ 1 ] - a->xyz[ 1 ]);
- out->xyz[ 2 ] = a->xyz[ 2 ] + amount * (b->xyz[ 2 ] - a->xyz[ 2 ]);
-
- out->st[ 0 ] = a->st[ 0 ] + amount * (b->st[ 0 ] - a->st[ 0 ]);
- out->st[ 1 ] = a->st[ 1 ] + amount * (b->st[ 1 ] - a->st[ 1 ]);
-
- for( k = 0; k < MAX_LIGHTMAPS; k++ )
+ LerpDrawVertAmount()
+ returns a biased interpolated vert
+ */
+
+void LerpDrawVertAmount( bspDrawVert_t *a, bspDrawVert_t *b, float amount, bspDrawVert_t *out ){
+ int k;
+
+
+ out->xyz[ 0 ] = a->xyz[ 0 ] + amount * ( b->xyz[ 0 ] - a->xyz[ 0 ] );
+ out->xyz[ 1 ] = a->xyz[ 1 ] + amount * ( b->xyz[ 1 ] - a->xyz[ 1 ] );
+ out->xyz[ 2 ] = a->xyz[ 2 ] + amount * ( b->xyz[ 2 ] - a->xyz[ 2 ] );
+
+ out->st[ 0 ] = a->st[ 0 ] + amount * ( b->st[ 0 ] - a->st[ 0 ] );
+ out->st[ 1 ] = a->st[ 1 ] + amount * ( b->st[ 1 ] - a->st[ 1 ] );
+
+ for ( k = 0; k < MAX_LIGHTMAPS; k++ )
{
- out->lightmap[ k ][ 0 ] = a->lightmap[ k ][ 0 ] + amount * (b->lightmap[ k ][ 0 ] - a->lightmap[ k ][ 0 ]);
- out->lightmap[ k ][ 1 ] = a->lightmap[ k ][ 1 ] + amount * (b->lightmap[ k ][ 1 ] - a->lightmap[ k ][ 1 ]);
- out->color[ k ][ 0 ] = a->color[ k ][ 0 ] + amount * (b->color[ k ][ 0 ] - a->color[ k ][ 0 ]);
- out->color[ k ][ 1 ] = a->color[ k ][ 1 ] + amount * (b->color[ k ][ 1 ] - a->color[ k ][ 1 ]);
- out->color[ k ][ 2 ] = a->color[ k ][ 2 ] + amount * (b->color[ k ][ 2 ] - a->color[ k ][ 2 ]);
- out->color[ k ][ 3 ] = a->color[ k ][ 3 ] + amount * (b->color[ k ][ 3 ] - a->color[ k ][ 3 ]);
+ out->lightmap[ k ][ 0 ] = a->lightmap[ k ][ 0 ] + amount * ( b->lightmap[ k ][ 0 ] - a->lightmap[ k ][ 0 ] );
+ out->lightmap[ k ][ 1 ] = a->lightmap[ k ][ 1 ] + amount * ( b->lightmap[ k ][ 1 ] - a->lightmap[ k ][ 1 ] );
+ out->color[ k ][ 0 ] = a->color[ k ][ 0 ] + amount * ( b->color[ k ][ 0 ] - a->color[ k ][ 0 ] );
+ out->color[ k ][ 1 ] = a->color[ k ][ 1 ] + amount * ( b->color[ k ][ 1 ] - a->color[ k ][ 1 ] );
+ out->color[ k ][ 2 ] = a->color[ k ][ 2 ] + amount * ( b->color[ k ][ 2 ] - a->color[ k ][ 2 ] );
+ out->color[ k ][ 3 ] = a->color[ k ][ 3 ] + amount * ( b->color[ k ][ 3 ] - a->color[ k ][ 3 ] );
}
- out->normal[ 0 ] = a->normal[ 0 ] + amount * (b->normal[ 0 ] - a->normal[ 0 ]);
- out->normal[ 1 ] = a->normal[ 1 ] + amount * (b->normal[ 1 ] - a->normal[ 1 ]);
- out->normal[ 2 ] = a->normal[ 2 ] + amount * (b->normal[ 2 ] - a->normal[ 2 ]);
-
+ out->normal[ 0 ] = a->normal[ 0 ] + amount * ( b->normal[ 0 ] - a->normal[ 0 ] );
+ out->normal[ 1 ] = a->normal[ 1 ] + amount * ( b->normal[ 1 ] - a->normal[ 1 ] );
+ out->normal[ 2 ] = a->normal[ 2 ] + amount * ( b->normal[ 2 ] - a->normal[ 2 ] );
+
/* if the interpolant created a bogus normal, just copy the normal from a */
- if( VectorNormalize( out->normal, out->normal ) == 0 )
+ if ( VectorNormalize( out->normal, out->normal ) == 0 ) {
VectorCopy( a->normal, out->normal );
+ }
}
}
void PrintMesh( mesh_t *m ) {
- int i, j;
+ int i, j;
for ( i = 0 ; i < m->height ; i++ ) {
for ( j = 0 ; j < m->width ; j++ ) {
- Sys_Printf("(%5.2f %5.2f %5.2f) "
- , m->verts[i*m->width+j].xyz[0]
- , m->verts[i*m->width+j].xyz[1]
- , m->verts[i*m->width+j].xyz[2] );
+ Sys_Printf( "(%5.2f %5.2f %5.2f) "
+ , m->verts[i * m->width + j].xyz[0]
+ , m->verts[i * m->width + j].xyz[1]
+ , m->verts[i * m->width + j].xyz[2] );
}
- Sys_Printf("\n");
+ Sys_Printf( "\n" );
}
}
mesh_t *CopyMesh( mesh_t *mesh ) {
- mesh_t *out;
- int size;
+ mesh_t *out;
+ int size;
out = safe_malloc( sizeof( *out ) );
out->width = mesh->width;
/*
-TransposeMesh()
-returns a transposed copy of the mesh, freeing the original
-*/
+ TransposeMesh()
+ returns a transposed copy of the mesh, freeing the original
+ */
mesh_t *TransposeMesh( mesh_t *in ) {
- int w, h;
- mesh_t *out;
+ int w, h;
+ mesh_t *out;
out = safe_malloc( sizeof( *out ) );
out->width = in->height;
}
void InvertMesh( mesh_t *in ) {
- int w, h;
- bspDrawVert_t temp;
+ int w, h;
+ bspDrawVert_t temp;
for ( h = 0 ; h < in->height ; h++ ) {
for ( w = 0 ; w < in->width / 2 ; w++ ) {
}
/*
-=================
-MakeMeshNormals
-
-=================
-*/
-void MakeMeshNormals( mesh_t in )
-{
- int i, j, k, dist;
- vec3_t normal;
- vec3_t sum;
- int count;
- vec3_t base;
- vec3_t delta;
- int x, y;
- bspDrawVert_t *dv;
- vec3_t around[8], temp;
- qboolean good[8];
- qboolean wrapWidth, wrapHeight;
- float len;
- int neighbors[8][2] =
- {
- {0,1}, {1,1}, {1,0}, {1,-1}, {0,-1}, {-1,-1}, {-1,0}, {-1,1}
- };
-
-
+ =================
+ MakeMeshNormals
+
+ =================
+ */
+void MakeMeshNormals( mesh_t in ){
+ int i, j, k, dist;
+ vec3_t normal;
+ vec3_t sum;
+ int count;
+ vec3_t base;
+ vec3_t delta;
+ int x, y;
+ bspDrawVert_t *dv;
+ vec3_t around[8], temp;
+ qboolean good[8];
+ qboolean wrapWidth, wrapHeight;
+ float len;
+ int neighbors[8][2] =
+ {
+ {0,1}, {1,1}, {1,0}, {1,-1}, {0,-1}, {-1,-1}, {-1,0}, {-1,1}
+ };
+
+
wrapWidth = qfalse;
for ( i = 0 ; i < in.height ; i++ ) {
- VectorSubtract( in.verts[i*in.width].xyz,
- in.verts[i*in.width+in.width-1].xyz, delta );
+ VectorSubtract( in.verts[i * in.width].xyz,
+ in.verts[i * in.width + in.width - 1].xyz, delta );
len = VectorLength( delta );
if ( len > 1.0 ) {
break;
wrapHeight = qfalse;
for ( i = 0 ; i < in.width ; i++ ) {
- VectorSubtract( in.verts[i].xyz,
- in.verts[i + (in.height-1)*in.width].xyz, delta );
+ VectorSubtract( in.verts[i].xyz,
+ in.verts[i + ( in.height - 1 ) * in.width].xyz, delta );
len = VectorLength( delta );
if ( len > 1.0 ) {
break;
}
}
- if ( i == in.width) {
+ if ( i == in.width ) {
wrapHeight = qtrue;
}
for ( i = 0 ; i < in.width ; i++ ) {
for ( j = 0 ; j < in.height ; j++ ) {
count = 0;
- dv = &in.verts[j*in.width+i];
+ dv = &in.verts[j * in.width + i];
VectorCopy( dv->xyz, base );
for ( k = 0 ; k < 8 ; k++ ) {
VectorClear( around[k] );
if ( wrapWidth ) {
if ( x < 0 ) {
x = in.width - 1 + x;
- } else if ( x >= in.width ) {
+ }
+ else if ( x >= in.width ) {
x = 1 + x - in.width;
}
}
if ( wrapHeight ) {
if ( y < 0 ) {
y = in.height - 1 + y;
- } else if ( y >= in.height ) {
+ }
+ else if ( y >= in.height ) {
y = 1 + y - in.height;
}
}
if ( x < 0 || x >= in.width || y < 0 || y >= in.height ) {
- break; // edge of patch
+ break; // edge of patch
}
- VectorSubtract( in.verts[y*in.width+x].xyz, base, temp );
+ VectorSubtract( in.verts[y * in.width + x].xyz, base, temp );
if ( VectorNormalize( temp, temp ) == 0 ) {
- continue; // degenerate edge, get more dist
- } else {
+ continue; // degenerate edge, get more dist
+ }
+ else {
good[k] = qtrue;
VectorCopy( temp, around[k] );
- break; // good edge
+ break; // good edge
}
}
}
VectorClear( sum );
for ( k = 0 ; k < 8 ; k++ ) {
- if ( !good[k] || !good[(k+1)&7] ) {
- continue; // didn't get two points
+ if ( !good[k] || !good[( k + 1 ) & 7] ) {
+ continue; // didn't get two points
}
- CrossProduct( around[(k+1)&7], around[k], normal );
+ CrossProduct( around[( k + 1 ) & 7], around[k], normal );
if ( VectorNormalize( normal, normal ) == 0 ) {
continue;
}
}
/*
-PutMeshOnCurve()
-drops the aproximating points onto the curve
-ydnar: fixme: make this use LerpDrawVert() rather than this complicated mess
-*/
+ PutMeshOnCurve()
+ drops the aproximating points onto the curve
+ ydnar: fixme: make this use LerpDrawVert() rather than this complicated mess
+ */
void PutMeshOnCurve( mesh_t in ) {
- int i, j, l, m;
- float prev, next;
-
-
+ int i, j, l, m;
+ float prev, next;
+
+
// put all the aproximating points on the curve
for ( i = 0 ; i < in.width ; i++ ) {
for ( j = 1 ; j < in.height ; j += 2 ) {
for ( l = 0 ; l < 3 ; l++ ) {
- prev = ( in.verts[j*in.width+i].xyz[l] + in.verts[(j+1)*in.width+i].xyz[l] ) * 0.5;
- next = ( in.verts[j*in.width+i].xyz[l] + in.verts[(j-1)*in.width+i].xyz[l] ) * 0.5;
- in.verts[j*in.width+i].xyz[l] = ( prev + next ) * 0.5;
-
+ prev = ( in.verts[j * in.width + i].xyz[l] + in.verts[( j + 1 ) * in.width + i].xyz[l] ) * 0.5;
+ next = ( in.verts[j * in.width + i].xyz[l] + in.verts[( j - 1 ) * in.width + i].xyz[l] ) * 0.5;
+ in.verts[j * in.width + i].xyz[l] = ( prev + next ) * 0.5;
+
/* ydnar: interpolating st coords */
- if( l < 2 )
- {
- prev = ( in.verts[j*in.width+i].st[l] + in.verts[(j+1)*in.width+i].st[l] ) * 0.5;
- next = ( in.verts[j*in.width+i].st[l] + in.verts[(j-1)*in.width+i].st[l] ) * 0.5;
- in.verts[j*in.width+i].st[l] = ( prev + next ) * 0.5;
-
- for( m = 0; m < MAX_LIGHTMAPS; m++ )
+ if ( l < 2 ) {
+ prev = ( in.verts[j * in.width + i].st[l] + in.verts[( j + 1 ) * in.width + i].st[l] ) * 0.5;
+ next = ( in.verts[j * in.width + i].st[l] + in.verts[( j - 1 ) * in.width + i].st[l] ) * 0.5;
+ in.verts[j * in.width + i].st[l] = ( prev + next ) * 0.5;
+
+ for ( m = 0; m < MAX_LIGHTMAPS; m++ )
{
- prev = ( in.verts[j*in.width+i].lightmap[ m ][l] + in.verts[(j+1)*in.width+i].lightmap[ m ][l] ) * 0.5;
- next = ( in.verts[j*in.width+i].lightmap[ m ][l] + in.verts[(j-1)*in.width+i].lightmap[ m ][l] ) * 0.5;
- in.verts[j*in.width+i].lightmap[ m ][l] = ( prev + next ) * 0.5;
+ prev = ( in.verts[j * in.width + i].lightmap[ m ][l] + in.verts[( j + 1 ) * in.width + i].lightmap[ m ][l] ) * 0.5;
+ next = ( in.verts[j * in.width + i].lightmap[ m ][l] + in.verts[( j - 1 ) * in.width + i].lightmap[ m ][l] ) * 0.5;
+ in.verts[j * in.width + i].lightmap[ m ][l] = ( prev + next ) * 0.5;
}
}
}
}
}
-
+
for ( j = 0 ; j < in.height ; j++ ) {
for ( i = 1 ; i < in.width ; i += 2 ) {
for ( l = 0 ; l < 3 ; l++ ) {
- prev = ( in.verts[j*in.width+i].xyz[l] + in.verts[j*in.width+i+1].xyz[l] ) * 0.5;
- next = ( in.verts[j*in.width+i].xyz[l] + in.verts[j*in.width+i-1].xyz[l] ) * 0.5;
- in.verts[j*in.width+i].xyz[l] = ( prev + next ) * 0.5;
-
+ prev = ( in.verts[j * in.width + i].xyz[l] + in.verts[j * in.width + i + 1].xyz[l] ) * 0.5;
+ next = ( in.verts[j * in.width + i].xyz[l] + in.verts[j * in.width + i - 1].xyz[l] ) * 0.5;
+ in.verts[j * in.width + i].xyz[l] = ( prev + next ) * 0.5;
+
/* ydnar: interpolating st coords */
- if( l < 2 )
- {
- prev = ( in.verts[j*in.width+i].st[l] + in.verts[j*in.width+i+1].st[l] ) * 0.5;
- next = ( in.verts[j*in.width+i].st[l] + in.verts[j*in.width+i-1].st[l] ) * 0.5;
- in.verts[j*in.width+i].st[l] = ( prev + next ) * 0.5;
-
- for( m = 0; m < MAX_LIGHTMAPS; m++ )
+ if ( l < 2 ) {
+ prev = ( in.verts[j * in.width + i].st[l] + in.verts[j * in.width + i + 1].st[l] ) * 0.5;
+ next = ( in.verts[j * in.width + i].st[l] + in.verts[j * in.width + i - 1].st[l] ) * 0.5;
+ in.verts[j * in.width + i].st[l] = ( prev + next ) * 0.5;
+
+ for ( m = 0; m < MAX_LIGHTMAPS; m++ )
{
- prev = ( in.verts[j*in.width+i].lightmap[ m ][l] + in.verts[j*in.width+i+1].lightmap[ m ][l] ) * 0.5;
- next = ( in.verts[j*in.width+i].lightmap[ m ][l] + in.verts[j*in.width+i-1].lightmap[ m ][l] ) * 0.5;
- in.verts[j*in.width+i].lightmap[ m ][l] = ( prev + next ) * 0.5;
+ prev = ( in.verts[j * in.width + i].lightmap[ m ][l] + in.verts[j * in.width + i + 1].lightmap[ m ][l] ) * 0.5;
+ next = ( in.verts[j * in.width + i].lightmap[ m ][l] + in.verts[j * in.width + i - 1].lightmap[ m ][l] ) * 0.5;
+ in.verts[j * in.width + i].lightmap[ m ][l] = ( prev + next ) * 0.5;
}
}
}
/*
-=================
-SubdivideMesh
-
-=================
-*/
-mesh_t *SubdivideMesh( mesh_t in, float maxError, float minLength )
-{
- int i, j, k, l;
- bspDrawVert_t prev, next, mid;
- vec3_t prevxyz, nextxyz, midxyz;
- vec3_t delta;
- float len;
- mesh_t out;
-
+ =================
+ SubdivideMesh
+
+ =================
+ */
+mesh_t *SubdivideMesh( mesh_t in, float maxError, float minLength ){
+ int i, j, k, l;
+ bspDrawVert_t prev, next, mid;
+ vec3_t prevxyz, nextxyz, midxyz;
+ vec3_t delta;
+ float len;
+ mesh_t out;
+
/* ydnar: static for os x */
- MAC_STATIC bspDrawVert_t expand[MAX_EXPANDED_AXIS][MAX_EXPANDED_AXIS];
-
-
+ MAC_STATIC bspDrawVert_t expand[MAX_EXPANDED_AXIS][MAX_EXPANDED_AXIS];
+
+
out.width = in.width;
out.height = in.height;
for ( i = 0 ; i < in.width ; i++ ) {
for ( j = 0 ; j < in.height ; j++ ) {
- expand[j][i] = in.verts[j*in.width+i];
+ expand[j][i] = in.verts[j * in.width + i];
}
}
// check subdivided midpoints against control points
for ( i = 0 ; i < out.height ; i++ ) {
for ( l = 0 ; l < 3 ; l++ ) {
- prevxyz[l] = expand[i][j+1].xyz[l] - expand[i][j].xyz[l];
- nextxyz[l] = expand[i][j+2].xyz[l] - expand[i][j+1].xyz[l];
- midxyz[l] = (expand[i][j].xyz[l] + expand[i][j+1].xyz[l] * 2
- + expand[i][j+2].xyz[l] ) * 0.25;
+ prevxyz[l] = expand[i][j + 1].xyz[l] - expand[i][j].xyz[l];
+ nextxyz[l] = expand[i][j + 2].xyz[l] - expand[i][j + 1].xyz[l];
+ midxyz[l] = ( expand[i][j].xyz[l] + expand[i][j + 1].xyz[l] * 2
+ + expand[i][j + 2].xyz[l] ) * 0.25;
}
// if the span length is too long, force a subdivision
- if ( VectorLength( prevxyz ) > minLength
- || VectorLength( nextxyz ) > minLength ) {
+ if ( VectorLength( prevxyz ) > minLength
+ || VectorLength( nextxyz ) > minLength ) {
break;
}
// see if this midpoint is off far enough to subdivide
- VectorSubtract( expand[i][j+1].xyz, midxyz, delta );
+ VectorSubtract( expand[i][j + 1].xyz, midxyz, delta );
len = VectorLength( delta );
if ( len > maxError ) {
break;
}
if ( out.width + 2 >= MAX_EXPANDED_AXIS ) {
- break; // can't subdivide any more
+ break; // can't subdivide any more
}
if ( i == out.height ) {
- continue; // didn't need subdivision
+ continue; // didn't need subdivision
}
// insert two columns and replace the peak
out.width += 2;
for ( i = 0 ; i < out.height ; i++ ) {
- LerpDrawVert( &expand[i][j], &expand[i][j+1], &prev );
- LerpDrawVert( &expand[i][j+1], &expand[i][j+2], &next );
+ LerpDrawVert( &expand[i][j], &expand[i][j + 1], &prev );
+ LerpDrawVert( &expand[i][j + 1], &expand[i][j + 2], &next );
LerpDrawVert( &prev, &next, &mid );
for ( k = out.width - 1 ; k > j + 3 ; k-- ) {
- expand[i][k] = expand[i][k-2];
+ expand[i][k] = expand[i][k - 2];
}
expand[i][j + 1] = prev;
expand[i][j + 2] = mid;
// check subdivided midpoints against control points
for ( i = 0 ; i < out.width ; i++ ) {
for ( l = 0 ; l < 3 ; l++ ) {
- prevxyz[l] = expand[j+1][i].xyz[l] - expand[j][i].xyz[l];
- nextxyz[l] = expand[j+2][i].xyz[l] - expand[j+1][i].xyz[l];
- midxyz[l] = (expand[j][i].xyz[l] + expand[j+1][i].xyz[l] * 2
- + expand[j+2][i].xyz[l] ) * 0.25;
+ prevxyz[l] = expand[j + 1][i].xyz[l] - expand[j][i].xyz[l];
+ nextxyz[l] = expand[j + 2][i].xyz[l] - expand[j + 1][i].xyz[l];
+ midxyz[l] = ( expand[j][i].xyz[l] + expand[j + 1][i].xyz[l] * 2
+ + expand[j + 2][i].xyz[l] ) * 0.25;
}
// if the span length is too long, force a subdivision
- if ( VectorLength( prevxyz ) > minLength
- || VectorLength( nextxyz ) > minLength ) {
+ if ( VectorLength( prevxyz ) > minLength
+ || VectorLength( nextxyz ) > minLength ) {
break;
}
// see if this midpoint is off far enough to subdivide
- VectorSubtract( expand[j+1][i].xyz, midxyz, delta );
+ VectorSubtract( expand[j + 1][i].xyz, midxyz, delta );
len = VectorLength( delta );
if ( len > maxError ) {
break;
}
if ( out.height + 2 >= MAX_EXPANDED_AXIS ) {
- break; // can't subdivide any more
+ break; // can't subdivide any more
}
if ( i == out.width ) {
- continue; // didn't need subdivision
+ continue; // didn't need subdivision
}
// insert two columns and replace the peak
out.height += 2;
for ( i = 0 ; i < out.width ; i++ ) {
- LerpDrawVert( &expand[j][i], &expand[j+1][i], &prev );
- LerpDrawVert( &expand[j+1][i], &expand[j+2][i], &next );
+ LerpDrawVert( &expand[j][i], &expand[j + 1][i], &prev );
+ LerpDrawVert( &expand[j + 1][i], &expand[j + 2][i], &next );
LerpDrawVert( &prev, &next, &mid );
for ( k = out.height - 1 ; k > j + 3 ; k-- ) {
- expand[k][i] = expand[k-2][i];
+ expand[k][i] = expand[k - 2][i];
}
- expand[j+1][i] = prev;
- expand[j+2][i] = mid;
- expand[j+3][i] = next;
+ expand[j + 1][i] = prev;
+ expand[j + 2][i] = mid;
+ expand[j + 3][i] = next;
}
// back up and recheck this set again, it may need more subdivision
out.verts = &expand[0][0];
for ( i = 1 ; i < out.height ; i++ ) {
- memmove( &out.verts[i*out.width], expand[i], out.width * sizeof(bspDrawVert_t) );
+ memmove( &out.verts[i * out.width], expand[i], out.width * sizeof( bspDrawVert_t ) );
}
- return CopyMesh(&out);
+ return CopyMesh( &out );
}
/*
-IterationsForCurve() - ydnar
-given a curve of a certain length, return the number of subdivision iterations
-note: this is affected by subdivision amount
-*/
-
-int IterationsForCurve( float len, int subdivisions )
-{
- int iterations, facets;
-
-
+ IterationsForCurve() - ydnar
+ given a curve of a certain length, return the number of subdivision iterations
+ note: this is affected by subdivision amount
+ */
+
+int IterationsForCurve( float len, int subdivisions ){
+ int iterations, facets;
+
+
/* calculate the number of subdivisions */
- for( iterations = 0; iterations < 3; iterations++ )
+ for ( iterations = 0; iterations < 3; iterations++ )
{
facets = subdivisions * 16 * pow( 2, iterations );
- if( facets >= len )
+ if ( facets >= len ) {
break;
+ }
}
-
+
/* return to caller */
return iterations;
}
/*
-SubdivideMesh2() - ydnar
-subdivides each mesh quad a specified number of times
-*/
-
-mesh_t *SubdivideMesh2( mesh_t in, int iterations )
-{
- int i, j, k;
- bspDrawVert_t prev, next, mid;
- mesh_t out;
-
+ SubdivideMesh2() - ydnar
+ subdivides each mesh quad a specified number of times
+ */
+
+mesh_t *SubdivideMesh2( mesh_t in, int iterations ){
+ int i, j, k;
+ bspDrawVert_t prev, next, mid;
+ mesh_t out;
+
/* ydnar: static for os x */
- MAC_STATIC bspDrawVert_t expand[ MAX_EXPANDED_AXIS ][ MAX_EXPANDED_AXIS ];
-
-
+ MAC_STATIC bspDrawVert_t expand[ MAX_EXPANDED_AXIS ][ MAX_EXPANDED_AXIS ];
+
+
/* initial setup */
out.width = in.width;
out.height = in.height;
- for( i = 0; i < in.width; i++ )
+ for ( i = 0; i < in.width; i++ )
{
- for( j = 0; j < in.height; j++ )
+ for ( j = 0; j < in.height; j++ )
expand[ j ][ i ] = in.verts[ j * in.width + i ];
}
-
+
/* keep chopping */
- for( iterations; iterations > 0; iterations-- )
+ for ( ; iterations > 0; iterations-- )
{
/* horizontal subdivisions */
- for( j = 0; j + 2 < out.width; j += 4 )
+ for ( j = 0; j + 2 < out.width; j += 4 )
{
/* check size limit */
- if( out.width + 2 >= MAX_EXPANDED_AXIS )
+ if ( out.width + 2 >= MAX_EXPANDED_AXIS ) {
break;
-
+ }
+
/* insert two columns and replace the peak */
out.width += 2;
- for( i = 0; i < out.height; i++ )
+ for ( i = 0; i < out.height; i++ )
{
LerpDrawVert( &expand[ i ][ j ], &expand[ i ][ j + 1 ], &prev );
LerpDrawVert( &expand[ i ][ j + 1 ], &expand[ i ][ j + 2 ], &next );
expand[ i ][ j + 2 ] = mid;
expand[ i ][ j + 3 ] = next;
}
-
+
}
/* vertical subdivisions */
for ( j = 0; j + 2 < out.height; j += 4 )
{
/* check size limit */
- if( out.height + 2 >= MAX_EXPANDED_AXIS )
+ if ( out.height + 2 >= MAX_EXPANDED_AXIS ) {
break;
-
+ }
+
/* insert two columns and replace the peak */
out.height += 2;
- for( i = 0; i < out.width; i++ )
+ for ( i = 0; i < out.width; i++ )
{
LerpDrawVert( &expand[ j ][ i ], &expand[ j + 1 ][ i ], &prev );
LerpDrawVert( &expand[ j + 1 ][ i ], &expand[ j + 2 ][ i ], &next );
LerpDrawVert( &prev, &next, &mid );
-
- for( k = out.height - 1; k > j + 3; k-- )
+
+ for ( k = out.height - 1; k > j + 3; k-- )
expand[ k ][ i ] = expand[ k - 2 ][ i ];
expand[ j + 1 ][ i ] = prev;
expand[ j + 2 ][ i ] = mid;
}
}
}
-
+
/* collapse the verts */
out.verts = &expand[ 0 ][ 0 ];
- for( i = 1; i < out.height; i++ )
+ for ( i = 1; i < out.height; i++ )
memmove( &out.verts[ i * out.width ], expand[ i ], out.width * sizeof( bspDrawVert_t ) );
-
+
/* return to sender */
return CopyMesh( &out );
}
/*
-================
-ProjectPointOntoVector
-================
-*/
-void ProjectPointOntoVector( vec3_t point, vec3_t vStart, vec3_t vEnd, vec3_t vProj )
-{
+ ================
+ ProjectPointOntoVector
+ ================
+ */
+void ProjectPointOntoVector( vec3_t point, vec3_t vStart, vec3_t vEnd, vec3_t vProj ){
vec3_t pVec, vec;
VectorSubtract( point, vStart, pVec );
}
/*
-================
-RemoveLinearMeshColumsRows
-================
-*/
+ ================
+ RemoveLinearMeshColumsRows
+ ================
+ */
mesh_t *RemoveLinearMeshColumnsRows( mesh_t *in ) {
- int i, j, k;
- float len, maxLength;
- vec3_t proj, dir;
- mesh_t out;
-
+ int i, j, k;
+ float len, maxLength;
+ vec3_t proj, dir;
+ mesh_t out;
+
/* ydnar: static for os x */
- MAC_STATIC bspDrawVert_t expand[MAX_EXPANDED_AXIS][MAX_EXPANDED_AXIS];
-
+ MAC_STATIC bspDrawVert_t expand[MAX_EXPANDED_AXIS][MAX_EXPANDED_AXIS];
+
out.width = in->width;
out.height = in->height;
for ( i = 0 ; i < in->width ; i++ ) {
for ( j = 0 ; j < in->height ; j++ ) {
- expand[j][i] = in->verts[j*in->width+i];
+ expand[j][i] = in->verts[j * in->width + i];
}
}
for ( j = 1 ; j < out.width - 1; j++ ) {
maxLength = 0;
for ( i = 0 ; i < out.height ; i++ ) {
- ProjectPointOntoVector(expand[i][j].xyz, expand[i][j-1].xyz, expand[i][j+1].xyz, proj);
- VectorSubtract(expand[i][j].xyz, proj, dir);
- len = VectorLength(dir);
- if (len > maxLength) {
+ ProjectPointOntoVector( expand[i][j].xyz, expand[i][j - 1].xyz, expand[i][j + 1].xyz, proj );
+ VectorSubtract( expand[i][j].xyz, proj, dir );
+ len = VectorLength( dir );
+ if ( len > maxLength ) {
maxLength = len;
}
}
- if (maxLength < 0.1)
- {
+ if ( maxLength < 0.1 ) {
out.width--;
for ( i = 0 ; i < out.height ; i++ ) {
- for (k = j; k < out.width; k++) {
- expand[i][k] = expand[i][k+1];
+ for ( k = j; k < out.width; k++ ) {
+ expand[i][k] = expand[i][k + 1];
}
}
j--;
for ( j = 1 ; j < out.height - 1; j++ ) {
maxLength = 0;
for ( i = 0 ; i < out.width ; i++ ) {
- ProjectPointOntoVector(expand[j][i].xyz, expand[j-1][i].xyz, expand[j+1][i].xyz, proj);
- VectorSubtract(expand[j][i].xyz, proj, dir);
- len = VectorLength(dir);
- if (len > maxLength) {
+ ProjectPointOntoVector( expand[j][i].xyz, expand[j - 1][i].xyz, expand[j + 1][i].xyz, proj );
+ VectorSubtract( expand[j][i].xyz, proj, dir );
+ len = VectorLength( dir );
+ if ( len > maxLength ) {
maxLength = len;
}
}
- if (maxLength < 0.1)
- {
+ if ( maxLength < 0.1 ) {
out.height--;
for ( i = 0 ; i < out.width ; i++ ) {
- for (k = j; k < out.height; k++) {
- expand[k][i] = expand[k+1][i];
+ for ( k = j; k < out.height; k++ ) {
+ expand[k][i] = expand[k + 1][i];
}
}
j--;
// collapse the verts
out.verts = &expand[0][0];
for ( i = 1 ; i < out.height ; i++ ) {
- memmove( &out.verts[i*out.width], expand[i], out.width * sizeof(bspDrawVert_t) );
+ memmove( &out.verts[i * out.width], expand[i], out.width * sizeof( bspDrawVert_t ) );
}
- return CopyMesh(&out);
+ return CopyMesh( &out );
}
/*
-=================
-SubdivideMeshQuads
-=================
-*/
-mesh_t *SubdivideMeshQuads( mesh_t *in, float minLength, int maxsize, int *widthtable, int *heighttable )
-{
- int i, j, k, w, h, maxsubdivisions, subdivisions;
- vec3_t dir;
- float length, maxLength, amount;
- mesh_t out;
- bspDrawVert_t expand[MAX_EXPANDED_AXIS][MAX_EXPANDED_AXIS];
+ =================
+ SubdivideMeshQuads
+ =================
+ */
+mesh_t *SubdivideMeshQuads( mesh_t *in, float minLength, int maxsize, int *widthtable, int *heighttable ){
+ int i, j, k, w, h, maxsubdivisions, subdivisions;
+ vec3_t dir;
+ float length, maxLength, amount;
+ mesh_t out;
+ bspDrawVert_t expand[MAX_EXPANDED_AXIS][MAX_EXPANDED_AXIS];
out.width = in->width;
out.height = in->height;
for ( i = 0 ; i < in->width ; i++ ) {
for ( j = 0 ; j < in->height ; j++ ) {
- expand[j][i] = in->verts[j*in->width+i];
+ expand[j][i] = in->verts[j * in->width + i];
}
}
- if (maxsize > MAX_EXPANDED_AXIS)
- Error("SubdivideMeshQuads: maxsize > MAX_EXPANDED_AXIS");
+ if ( maxsize > MAX_EXPANDED_AXIS ) {
+ Error( "SubdivideMeshQuads: maxsize > MAX_EXPANDED_AXIS" );
+ }
// horizontal subdivisions
- maxsubdivisions = (maxsize - in->width) / (in->width - 1);
+ maxsubdivisions = ( maxsize - in->width ) / ( in->width - 1 );
- for ( w = 0, j = 0 ; w < in->width - 1; w++, j += subdivisions + 1) {
+ for ( w = 0, j = 0 ; w < in->width - 1; w++, j += subdivisions + 1 ) {
maxLength = 0;
for ( i = 0 ; i < out.height ; i++ ) {
- VectorSubtract(expand[i][j+1].xyz, expand[i][j].xyz, dir);
+ VectorSubtract( expand[i][j + 1].xyz, expand[i][j].xyz, dir );
length = VectorLength( dir );
- if (length > maxLength) {
+ if ( length > maxLength ) {
maxLength = length;
}
}
-
- subdivisions = (int) (maxLength / minLength);
- if (subdivisions > maxsubdivisions)
+
+ subdivisions = (int) ( maxLength / minLength );
+ if ( subdivisions > maxsubdivisions ) {
subdivisions = maxsubdivisions;
+ }
widthtable[w] = subdivisions + 1;
- if (subdivisions <= 0)
+ if ( subdivisions <= 0 ) {
continue;
+ }
out.width += subdivisions;
for ( i = 0 ; i < out.height ; i++ ) {
for ( k = out.width - 1 ; k > j + subdivisions; k-- ) {
- expand[i][k] = expand[i][k-subdivisions];
+ expand[i][k] = expand[i][k - subdivisions];
}
- for (k = 1; k <= subdivisions; k++)
+ for ( k = 1; k <= subdivisions; k++ )
{
- amount = (float) k / (subdivisions + 1);
- LerpDrawVertAmount(&expand[i][j], &expand[i][j+subdivisions+1], amount, &expand[i][j+k]);
+ amount = (float) k / ( subdivisions + 1 );
+ LerpDrawVertAmount( &expand[i][j], &expand[i][j + subdivisions + 1], amount, &expand[i][j + k] );
}
}
}
- maxsubdivisions = (maxsize - in->height) / (in->height - 1);
+ maxsubdivisions = ( maxsize - in->height ) / ( in->height - 1 );
- for ( h = 0, j = 0 ; h < in->height - 1; h++, j += subdivisions + 1) {
+ for ( h = 0, j = 0 ; h < in->height - 1; h++, j += subdivisions + 1 ) {
maxLength = 0;
for ( i = 0 ; i < out.width ; i++ ) {
- VectorSubtract(expand[j+1][i].xyz, expand[j][i].xyz, dir);
+ VectorSubtract( expand[j + 1][i].xyz, expand[j][i].xyz, dir );
length = VectorLength( dir );
- if (length > maxLength) {
+ if ( length > maxLength ) {
maxLength = length;
}
}
-
- subdivisions = (int) (maxLength / minLength);
- if (subdivisions > maxsubdivisions)
+
+ subdivisions = (int) ( maxLength / minLength );
+ if ( subdivisions > maxsubdivisions ) {
subdivisions = maxsubdivisions;
+ }
heighttable[h] = subdivisions + 1;
- if (subdivisions <= 0)
+ if ( subdivisions <= 0 ) {
continue;
+ }
out.height += subdivisions;
for ( i = 0 ; i < out.width ; i++ ) {
for ( k = out.height - 1 ; k > j + subdivisions; k-- ) {
- expand[k][i] = expand[k-subdivisions][i];
+ expand[k][i] = expand[k - subdivisions][i];
}
- for (k = 1; k <= subdivisions; k++)
+ for ( k = 1; k <= subdivisions; k++ )
{
- amount = (float) k / (subdivisions + 1);
- LerpDrawVertAmount(&expand[j][i], &expand[j+subdivisions+1][i], amount, &expand[j+k][i]);
+ amount = (float) k / ( subdivisions + 1 );
+ LerpDrawVertAmount( &expand[j][i], &expand[j + subdivisions + 1][i], amount, &expand[j + k][i] );
}
}
}
// collapse the verts
out.verts = &expand[0][0];
for ( i = 1 ; i < out.height ; i++ ) {
- memmove( &out.verts[i*out.width], expand[i], out.width * sizeof(bspDrawVert_t) );
+ memmove( &out.verts[i * out.width], expand[i], out.width * sizeof( bspDrawVert_t ) );
}
- return CopyMesh(&out);
+ return CopyMesh( &out );
}
projects / xonotic / netradiant.git / blobdiff