Quake-III-Arena

terrain.cpp (40790B)

---

 /*
 ===========================================================================
 Copyright (C) 1999-2005 Id Software, Inc.
 
 This file is part of Quake III Arena source code.
 
 Quake III Arena source code 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.
 
 Quake III Arena source code 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 Foobar; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 /*
 
 Todo:
 
 immediate:
 Texture placement
 New map format
 q3map
 
 
 later:
 Smoothing brush
 Stitching terrains together
 Cross terrain selection
 
 
 
 
 
 Terrain_ApplyMatrix
 UpdateTerrainInspector
 
 */
 
 #include "stdafx.h"
 #include "qe3.h"
 #include "DialogInfo.h"
 #include "assert.h"
 
 //random in the range [0, 1]
 #define random()			((rand () & 0x7fff) / ((float)0x7fff))
 
 //random in the range [-1, 1]
 #define crandom()			(2.0 * (random() - 0.5))
 
 typedef struct {
 	int		index;
 	vec3_t	xyz;
 	vec4_t	rgba;
 	vec2_t	tc;
 } terravert_t;
 
 /*
 ==============
 Terrain_SetEpair
 sets an epair for the given patch
 ==============
 */
 void Terrain_SetEpair( terrainMesh_t *p, const char *pKey, const char *pValue ) {
 	if ( g_qeglobals.m_bBrushPrimitMode ) {
 		SetKeyValue( p->epairs, pKey, pValue );
 	}
 }
 
 /* 
 =================
 Terrain_GetKeyValue
 =================
 */
 const char *Terrain_GetKeyValue( terrainMesh_t *p, const char *pKey ) {
 	if ( g_qeglobals.m_bBrushPrimitMode ) {
 		return ValueForKey( p->epairs, pKey );
 	}
 	return "";
 }
 
 /*
 ==================
 Terrain_MemorySize
 ==================
 */
 int Terrain_MemorySize( terrainMesh_t *p ) {
 	return _msize( p );
 }
 
 void Terrain_GetVert( terrainMesh_t *pm, int x, int y, float s, float t, terravert_t *v, qtexture_t *texture = NULL ) {
 	terrainVert_t *cell;
 
 	v->index = x + y * pm->width;
 
 	cell = &pm->heightmap[ v->index ];
 
 	v->xyz[ 0 ] = pm->origin[ 0 ] + x * pm->scale_x;
 	v->xyz[ 1 ] = pm->origin[ 1 ] + y * pm->scale_y;
 	v->xyz[ 2 ] = pm->origin[ 2 ] + cell->height;
 
 	VectorCopy( cell->rgba, v->rgba );
 
 	if ( !texture || ( texture == cell->tri.texture ) ) {
 		v->rgba[ 3 ] = 1.0f;
 	} else {
 		v->rgba[ 3 ] = 0.0f;
 	}
 
 	v->tc[ 0 ] = s;
 	v->tc[ 1 ] = t;
 }
 
 void Terrain_GetTriangles( terrainMesh_t *pm, int x, int y, terravert_t *a0, terravert_t *a1, terravert_t *a2, terravert_t *b0, terravert_t *b1, terravert_t *b2, qtexture_t *texture ) {
 	if ( ( x + y ) & 1 ) {
 		// first tri
 		Terrain_GetVert( pm, x, y, 1.0f, 1.0f, a0, texture );
 		Terrain_GetVert( pm, x, y + 1, 1.0f, 0.0f, a1, texture );
 		Terrain_GetVert( pm, x + 1, y + 1, 0.0f, 0.0f, a2, texture );
 
 		// second tri
 		*b0 = *a2;
 		Terrain_GetVert( pm, x + 1, y, 0.0f, 1.0f, b1, texture );
 		*b2 = *a0;
 	} else {
 		// first tri
 		Terrain_GetVert( pm, x, y, 1.0f, 1.0f, a0, texture );
 		Terrain_GetVert( pm, x, y + 1, 1.0f, 0.0f, a1, texture );
 		Terrain_GetVert( pm, x + 1, y, 0.0f, 1.0f, a2, texture );
 
 		// second tri
 		*b0 = *a2;
 		*b1 = *a1;
 		Terrain_GetVert( pm, x + 1, y + 1, 0.0f, 0.0f, b2, texture );
 	}
 }
 
 void Terrain_GetTriangle( terrainMesh_t *pm, int index, terravert_t *a0, terravert_t *a1, terravert_t *a2 ) {
 	int x;
 	int y;
 	int which;
 
 	which = index & 1;
 	index >>= 1;
 	y = index / pm->width;
 	x = index % pm->width;
 
 	if ( ( x + y ) & 1 ) {
 		if ( !which ) {
 			// first tri
 			Terrain_GetVert( pm, x, y, 1.0f, 1.0f, a0 );
 			Terrain_GetVert( pm, x, y + 1, 1.0f, 0.0f, a1 );
 			Terrain_GetVert( pm, x + 1, y + 1, 0.0f, 0.0f, a2 );
 		} else {
 			Terrain_GetVert( pm, x + 1, y + 1, 0.0f, 0.0f, a0 );
 			Terrain_GetVert( pm, x + 1, y, 0.0f, 1.0f, a1 );
 			Terrain_GetVert( pm, x, y, 1.0f, 1.0f, a2 );
 		}
 	} else {
 		if ( !which ) {
 			// first tri
 			Terrain_GetVert( pm, x, y, 1.0f, 1.0f, a0 );
 			Terrain_GetVert( pm, x, y + 1, 1.0f, 0.0f, a1 );
 			Terrain_GetVert( pm, x + 1, y, 0.0f, 1.0f, a2 );
 		} else {
 			Terrain_GetVert( pm, x + 1, y, 0.0f, 1.0f, a0 );
 			Terrain_GetVert( pm, x, y + 1, 1.0f, 0.0f, a1 );
 			Terrain_GetVert( pm, x + 1, y + 1, 0.0f, 0.0f, a2 );
 		}
 	}
 }
 
 void Terrain_Delete( terrainMesh_t *p ) {
 	if ( p->pSymbiot ) {
 		p->pSymbiot->pTerrain = NULL;
 		p->pSymbiot->terrainBrush = false;
 	}
 
 	free( p );
 
 	p = NULL;
    
 	UpdateTerrainInspector();
 }
 
 void Terrain_AddTexture( terrainMesh_t *pm, qtexture_t *texture ) {
 	int i;
 
 	if ( !texture ) {
 		return;
 	}
 
 	for( i = 0; i < pm->numtextures; i++ ) {
 		if ( pm->textures[ i ] == texture ) {
 			return;
 		}
 	}
 
 	if ( pm->numtextures >= MAX_TERRAIN_TEXTURES ) {
 		Warning( "Too many textures on terrain" );
 		return;
 	}
 
 	pm->textures[ pm->numtextures++ ] = texture;
 }
 
 void Terrain_RemoveTexture( terrainMesh_t *p, qtexture_t *texture ) {
 	int i;
 
 	for( i = 0; i < p->numtextures; i++ ) {
 		if ( p->textures[ i ] == texture ) {
 			break;
 		}
 	}
 
 	if ( i < p->numtextures ) {
 		// shift all textures down to remove the texture from the list
 		p->numtextures--;
 		for( ; i < p->numtextures; i++ ) {
 			p->textures[ i ] = p->textures[ i + 1 ];
 		}
 	}
 }
 
 terrainMesh_t *MakeNewTerrain( int width, int height, qtexture_t *texture ) {
 	int				h;
 	int				w;
 	terrainMesh_t	*pm;
 	size_t			size;
 	size_t			heightmapsize;
 	terrainVert_t	*vert;
 	int				index;
 
 	heightmapsize  = sizeof( terrainVert_t ) * width * height;
 	size           = sizeof( terrainMesh_t ) + heightmapsize;
    
 	pm = reinterpret_cast< terrainMesh_t * >( qmalloc( size ) );
    
 	memset( pm, 0x00, size );
 
 	pm->numtextures = 0;
 	pm->width      = width;
 	pm->height     = height;
 	pm->heightmap  = reinterpret_cast< terrainVert_t * >( pm + 1 );
 
 	if ( texture ) {
 		Terrain_AddTexture( pm, texture );
 	}
 
 	index = 0;
 	vert = pm->heightmap;
 	for( h = 0; h < pm->height; h++ ) {
 		for( w = 0; w < pm->width; w++, vert++ ) {
 			vert->tri.index = index++;
 			vert->tri.texture = texture;
 			if ( texture ) {
 				vert->tri.texdef.SetName( texture->name );
 			}
 
 			vert->height = 0;
 
 			VectorClear( vert->normal );
 			VectorSet( vert->rgba, 1.0f, 1.0f, 1.0f );
 			vert->rgba[ 3 ] = 1.0f;
 		}
 	}
    
 	return pm;
 }
 
 brush_t *AddBrushForTerrain( terrainMesh_t *pm, bool bLinkToWorld ) {
 	int		j;
 	vec3_t	vMin;
 	vec3_t	vMax;
 	brush_t	*b;
 	face_t	*f;
 
 	// calculate the face normals
 	Terrain_CalcNormals( pm );
    
 	// find the farthest points in x,y,z
 	Terrain_CalcBounds( pm, vMin, vMax );
 
 	for( j = 0; j < 3; j++ ) {
 		if ( vMin[ j ] == vMax[ j ] ) {
 			vMin[ j ] -= 4;
 			vMax[ j ] += 4;
 		}
 	}
 
 	b = Brush_Create( vMin, vMax, &pm->heightmap->tri.texdef );
 
 	for( f = b->brush_faces; f != NULL; f = f->next ) {
 		// copy the texdef to the brush faces texdef
 		f->texdef = pm->heightmap->tri.texdef;
 	}
 
 	// FIXME: this entire type of linkage needs to be fixed
 	b->pTerrain		= pm;
 	b->terrainBrush = true;
 	pm->pSymbiot    = b;
 	pm->bSelected   = false;
 	pm->bDirty      = true;
 	pm->nListID		= -1;
 
 	if ( bLinkToWorld ) {
 		Brush_AddToList( b, &active_brushes );
 		Entity_LinkBrush( world_entity, b );
 		Brush_Build( b, true );
 	}
   
 	return b;
 }
 
 terrainMesh_t *Terrain_Duplicate( terrainMesh_t *pFrom ) {
 	terrainMesh_t *p;
 	int w;
 	int h;
 	int index;
 
 	p = MakeNewTerrain( pFrom->width, pFrom->height );
    
 	VectorCopy( pFrom->origin, p->origin );
 	VectorCopy( pFrom->mins, p->mins );
 	VectorCopy( pFrom->maxs, p->maxs );
 
 	p->scale_x  = pFrom->scale_x;
 	p->scale_y  = pFrom->scale_y;
 	p->pSymbiot = pFrom->pSymbiot;
 
 	for( index = 0; index < pFrom->numtextures; index++ ) {
 		Terrain_AddTexture( p, pFrom->textures[ index ] );
 	}
 
 	index = 0;
 	for( h = 0; h < p->height; h++ ) {
 		for( w = 0; w < p->width; w++, index++ ) {
 			p->heightmap[ index ] = pFrom->heightmap[ index ];
 		}
 	}
    
 	p->bSelected   = false;
 	p->bDirty      = true;
 	p->nListID     = -1;
 
 	AddBrushForTerrain( p );
 
 	return p;
 }
 
 void Terrain_BrushToMesh( void ) {
 	brush_t			*b;
 	terrainMesh_t	*p;
 
 	if ( !QE_SingleBrush() ) {
 		return;
 	}
 
 	b = selected_brushes.next;
 
 	if ( g_qeglobals.d_terrainWidth	< 1 ) {
 		g_qeglobals.d_terrainWidth = 1;
 	}
 
 	if ( g_qeglobals.d_terrainHeight < 1 ) {
 		g_qeglobals.d_terrainHeight = 1;
 	}
 
 	p = MakeNewTerrain( g_qeglobals.d_terrainWidth + 1, g_qeglobals.d_terrainHeight + 1, b->brush_faces->d_texture );
 	p->scale_x = ( b->maxs[ 0 ] - b->mins[ 0 ] ) / float( p->width - 1 );
 	p->scale_y = ( b->maxs[ 1 ] - b->mins[ 1 ] ) / float( p->height - 1 );
 
 	VectorCopy( b->mins, p->origin );
 
 	b = AddBrushForTerrain( p );
 	Select_Delete();
 	Select_Brush( b );
 }
 
 terrainFace_t *Terrain_ParseFace( terrainFace_t *f ) {
 	// read the texturename
 	GetToken( false );
 	f->texdef.SetName( token );
 
 	// Load the texture, and set the face to that texture's defaults
 	f->texture = Texture_ForName( f->texdef.Name() );
 
 	// read the texturedef
 	GetToken( false );
 	f->texdef.shift[ 0 ] = ( float )atoi( token );
 	GetToken( false );
 	f->texdef.shift[ 1 ] = ( float )atoi( token );
 	GetToken( false );
 	f->texdef.rotate = atof( token );
 	GetToken( false );
 	f->texdef.scale[ 0 ] = atof( token );
 	GetToken( false );
 	f->texdef.scale[ 1 ] = atof( token );
 
 	// the flags and value field aren't necessarily present
 	//f->texture = Texture_ForName( f->texdef.Name() );
 	f->texdef.flags = f->texture->flags;
 	f->texdef.value = f->texture->value;
 	f->texdef.contents = f->texture->contents;
 	
 	if ( TokenAvailable () ) {
 		GetToken (false);
 		f->texdef.contents = atoi(token);
 		GetToken (false);
 		f->texdef.flags = atoi(token);
 		GetToken (false);
 		f->texdef.value = atoi(token);
 	}
 
 	return f;
 }
 
 brush_t *Terrain_Parse( void ) {
 	terrainMesh_t *pm;
 	terrainVert_t *vert;
 	int w;
 	int h;
 
 	GetToken( true );
     if ( strcmp( token, "{" ) ) {
 		return NULL;
 	}
 
 	// get width
 	GetToken( false );
 	w = atoi( token );
 
 	// get height
 	GetToken( false );
 	h = atoi( token );
 
 	pm = MakeNewTerrain( w, h );
 
 	// get scale_x
 	GetToken( false );
 	pm->scale_x = atoi( token );
 
 	// get scale_y
 	GetToken( false );
 	pm->scale_y = atoi( token );
 
 	// get origin
 	GetToken( true );
 	pm->origin[ 0 ] = atoi( token );
 	GetToken( false );
 	pm->origin[ 1 ] = atoi( token );
 	GetToken( false );
 	pm->origin[ 2 ] = atoi( token );
 
 	// get the height map
 	vert = pm->heightmap;
 	for( h = 0; h < pm->height; h++ ) {
 		for( w = 0; w < pm->width; w++, vert++ ) {
 			GetToken( true );
 			vert->height = atoi( token );
 
 			if ( !Terrain_ParseFace( &vert->tri ) ) {
 				Terrain_Delete( pm );
 				return NULL;
 			}
 
 			Terrain_AddTexture( pm, vert->tri.texture );
 		}
 	}
 
 	GetToken( true );
 	if ( strcmp( token, "}" ) ) {
 		Terrain_Delete( pm );
 		return NULL;
 	}
 
 	return AddBrushForTerrain( pm, false );
 }
 
 CString Terrain_SurfaceString( terrainFace_t *face ) {
 	char		temp[ 1024 ];
 	CString		text;
 	const char	*pname;
 
 	pname = face->texdef.Name();
 	if ( pname[ 0 ] == 0 ) {
 		pname = "unnamed";
 	}
 
 	sprintf( temp, "%s %i %i %.2f ", pname, ( int )face->texdef.shift[ 0 ], ( int )face->texdef.shift[ 1 ], face->texdef.rotate );
 	text += temp;
 
 	if ( face->texdef.scale[ 0 ] == ( int )face->texdef.scale[ 0 ] ) {
 		sprintf( temp, "%i ", ( int )face->texdef.scale[ 0 ] );
 	} else {
 		sprintf( temp, "%f ", ( float )face->texdef.scale[ 0 ] );
 	}
 	text += temp;
 
 	if ( face->texdef.scale[ 1 ] == (int)face->texdef.scale[ 1 ] ) {
 		sprintf( temp, "%i", ( int )face->texdef.scale[ 1 ] );
 	} else {
 		sprintf( temp, "%f", ( float )face->texdef.scale[ 1 ] );
 	}
 	text += temp;
 
 	// only output flags and value if not default
 	sprintf( temp, " %i %i %i ", face->texdef.contents, face->texdef.flags, face->texdef.value );
 	text += temp;
    
 	return text;
 }
 
 void Terrain_Write( terrainMesh_t *p, CMemFile *file ) {
 	int w;
 	int h;
 	terrainVert_t *vert;
 
 	MemFile_fprintf( file, " {\n  terrainDef\n  {\n" );
 	MemFile_fprintf( file, "   %d %d %f %f\n", p->width, p->height, p->scale_x, p->scale_y );
 	MemFile_fprintf( file, "   %f %f %f\n", p->origin[ 0 ], p->origin[ 1 ], p->origin[ 2 ] );
 
 	vert = p->heightmap;
 	for( h = 0; h < p->height; h++ ) {
 		for( w = 0; w < p->width; w++, vert++ ) {
 			MemFile_fprintf( file, "   %f %s\n", vert->height, ( const char * )Terrain_SurfaceString( &vert->tri ) );
 		}
 	}
    
 	MemFile_fprintf( file, "  }\n }\n" );
 }
 
 void Terrain_Write( terrainMesh_t *p, FILE *file ) {
 	int w;
 	int h;
 	terrainVert_t *vert;
 
 	fprintf( file, " {\n  terrainDef\n  {\n" );
 	fprintf( file, "   %d %d %f %f\n", p->width, p->height, p->scale_x, p->scale_y );
 	fprintf( file, "   %f %f %f\n", p->origin[ 0 ], p->origin[ 1 ], p->origin[ 2 ] );
 
 	vert = p->heightmap;
 	for( h = 0; h < p->height; h++ ) {
 		for( w = 0; w < p->width; w++, vert++ ) {
 			fprintf( file, "   %f %s\n", vert->height, ( const char * )Terrain_SurfaceString( &vert->tri ) );
 		}
 	}
    
 	fprintf( file, "  }\n }\n" );
 }
 
 void Terrain_Select( terrainMesh_t *p ) {
 	p->bSelected = true;
 }
 
 void Terrain_Deselect( terrainMesh_t *p ) {
 	p->bSelected = false;
 }
 
 void Terrain_Move( terrainMesh_t *pm, const vec3_t vMove, bool bRebuild ) {
 	pm->bDirty = true;
 
 	VectorAdd( pm->origin, vMove, pm->origin );
 
 	if ( bRebuild ) {
 		vec3_t vMin; 
 		vec3_t vMax;
 
 		Terrain_CalcBounds( pm, vMin, vMax );
 	}
   
 	UpdateTerrainInspector();
 }
 
 void UpdateTerrainInspector( void ) {
 	// not written yet
 }
 
 void Terrain_CalcBounds( terrainMesh_t *p, vec3_t &vMin, vec3_t &vMax ) {
 	int w;
 	int h;
 	float f;
 	terrainVert_t *vert;
 
 	vMin[ 0 ] = p->origin[ 0 ];
 	vMin[ 1 ] = p->origin[ 1 ];
 	vMin[ 2 ] = MAX_WORLD_COORD;
 
 	vMax[ 0 ] = p->origin[ 0 ] + ( p->width - 1 ) * p->scale_x;
 	vMax[ 1 ] = p->origin[ 1 ] + ( p->height - 1 ) * p->scale_y;
 	vMax[ 2 ] = MIN_WORLD_COORD;
 
 	p->bDirty = true;
 	vert = p->heightmap;
 	for( h = 0; h < p->height; h++ ) {
 		for( w = 0; w < p->width; w++, vert++ ) {
 			f = p->origin[ 2 ] + vert->height;
 			if ( f < vMin[ 2 ] ) {
 				vMin[ 2 ] = f;
 			}
 
 			if ( f > vMax[ 2 ] ) {
 				vMax[ 2 ] = f;
 			}
 		}
 	}
 }
 
 void CalcTriNormal( const vec3_t a, const vec3_t b, const vec3_t c, vec3_t o ) {
 	vec3_t a1;
 	vec3_t b1;
 
 	VectorSubtract( b, a, a1 );
 	VectorNormalize( a1 );
 
 	VectorSubtract( c, a, b1 );
 	VectorNormalize( b1 );
 
 	CrossProduct( a1, b1, o );
 	VectorNormalize( o );
 }
 
 inline void Terrain_CalcVertPos( terrainMesh_t *p, int x, int y, vec3_t vert ) {
 	int index;
 
 	index = x + y * p->width;
 	vert[ 0 ] = p->origin[ 0 ] + x * p->scale_x;
 	vert[ 1 ] = p->origin[ 1 ] + y * p->scale_y;
 	vert[ 2 ] = p->origin[ 2 ] + p->heightmap[ index ].height;
 	
 	VectorCopy( vert, p->heightmap[ index ].xyz );
 }
    
 void Terrain_CalcNormals( terrainMesh_t *p ) {
 	int				x;
 	int				y;
 	int				width;
 	int				num;
 	terrainVert_t	*vert;
 	vec3_t			norm;
 	terravert_t		a0;
 	terravert_t		a1;
 	terravert_t		a2;
 	terravert_t		b0;
 	terravert_t		b1;
 	terravert_t		b2;
 
 	p->bDirty = true;
 
 	num = p->height * p->width;
 	vert = p->heightmap;
 	//for( x = 0; x < num; x++, vert++ ) {
 	for( y = 0; y < p->height - 1; y++ ) {
 		for( x = 0; x < p->width - 1; x++, vert++ ) {
 			VectorClear( vert->normal );
 			Terrain_CalcVertPos( p, x, y, norm );
 		}
 	}
 
 	width = p->width;
 	vert = p->heightmap;
    
 	for( y = 0; y < p->height - 1; y++ ) {
 		for( x = 0; x < width - 1; x++ ) {
 			Terrain_GetTriangles( p, x, y, &a0, &a1, &a2, &b0, &b1, &b2, NULL );
 
 			CalcTriNormal( a0.xyz, a2.xyz, a1.xyz, norm );
 
 			VectorAdd( vert[ a0.index ].normal, norm, vert[ a0.index ].normal );
 			VectorAdd( vert[ a1.index ].normal, norm, vert[ a1.index ].normal );
 			VectorAdd( vert[ a2.index ].normal, norm, vert[ a2.index ].normal );
 
 			CalcTriNormal( b0.xyz, b2.xyz, b1.xyz, norm );
 
 			VectorAdd( vert[ b0.index ].normal, norm, vert[ b0.index ].normal );
 			VectorAdd( vert[ b1.index ].normal, norm, vert[ b1.index ].normal );
 			VectorAdd( vert[ b2.index ].normal, norm, vert[ b2.index ].normal );
 		}
 	}
    
 	for( x = 0; x < num; x++, vert++ ) {
 		VectorNormalize( vert->normal );
 		//FIXME
 		vert->normal[ 2 ] += 0.5;
 		VectorNormalize( vert->normal );
 		assert( vert->normal[ 2 ] > 0 );
 		VectorSet( vert->rgba, vert->normal[ 2 ], vert->normal[ 2 ], vert->normal[ 2 ] );
 		vert->rgba[ 3 ] = 1.0f;
 	}
 }
 
 void Terrain_FindReplaceTexture( terrainMesh_t *p, const char *pFind, const char *pReplace, bool bForce ) {
 	int				w;
 	int				h;
 	terrainVert_t	*vert;
 	qtexture_t		*texture;
 
 	texture = Texture_ForName( pReplace );
 
 	vert = p->heightmap;
 	for( h = 0; h < p->height; h++ ) {
 		for( w = 0; w < p->width; w++, vert++ ) {
 			if ( bForce || strcmpi( vert->tri.texture->name, pFind ) == 0 ) {
 				vert->tri.texture = texture;
 				vert->tri.texdef.SetName( texture->name );
 			}
 		}
 	}
 
 	if ( bForce ) {
 		p->numtextures = 0;
 		Terrain_AddTexture( p, Texture_ForName( pReplace ) );
 	} else {
 		Terrain_RemoveTexture( p, Texture_ForName( pFind ) );
 		Terrain_AddTexture( p, texture );
 	}
 }
 
 bool Terrain_HasTexture( terrainMesh_t *p, const char *name ) {
 	int w;
 	int h;
 	terrainVert_t *vert;
 
 	vert = p->heightmap;
 	for( h = 0; h < p->height; h++ ) {
 		for( w = 0; w < p->width; w++, vert++ ) {
 			if ( strcmpi( vert->tri.texture->name, name ) == 0 ) {
 				return true;
 			}
 		}
 	}
 
 	return false;
 }
 
 void Terrain_ReplaceQTexture( terrainMesh_t *p, qtexture_t *pOld, qtexture_t *pNew ) {
 	int w;
 	int h;
 	terrainVert_t *vert;
 
 	vert = p->heightmap;
 	for( h = 0; h < p->height; h++ ) {
 		for( w = 0; w < p->width; w++, vert++ ) {
 			if ( vert->tri.texture == pOld ) {
 				vert->tri.texture = pNew;
 				vert->tri.texdef.SetName( pNew->name );
 			}
 		}
 	}
 
 	Terrain_RemoveTexture( p, pOld );
 	Terrain_AddTexture( p, pNew );
 }
 
 void Terrain_SetTexture( terrainMesh_t *p, texdef_t *tex_def ) {
 	int w;
 	int h;
 	qtexture_t *newtex;
 	terrainVert_t *vert;
 
 	p->bDirty = 1;
   
 	newtex = Texture_ForName( tex_def->name );
 
 	p->numtextures = 0;
 	Terrain_AddTexture( p, newtex );
 
 	vert = p->heightmap;
 	for( h = 0; h < p->height; h++ ) {
 		for( w = 0; w < p->width; w++, vert++ ) {
 			vert->tri.texture = newtex;
 			vert->tri.texdef.SetName( newtex->name );
 		}
 	}
    
 	UpdateTerrainInspector();
 }
 
 void Terrain_Scale( terrainMesh_t *p, const vec3_t vOrigin, const vec3_t vAmt, bool bRebuild ) {
 	int    w;
 	int    h;
 	vec3_t pos;
 	terrainVert_t *vert;
 	vec3_t vMin;
 	vec3_t vMax;
 
 	vert = p->heightmap;
 	for( h = 0; h < p->height; h++ ) {
 		pos[ 1 ] = p->origin[ 1 ] + h * p->scale_y;
 		for( w = 0; w < p->width; w++, vert++ ) {
 			pos[ 0 ] = p->origin[ 0 ] + w * p->scale_x;
 			pos[ 2 ] = vert->height;
 
 			if ( ( g_qeglobals.d_select_mode == sel_terrainpoint ) && ( Terrain_PointInMoveList( vert ) == -1 ) ) {
 				continue;
 			}
 
 			vert->height -= vOrigin[ 2 ] - p->origin[ 2 ];
 			vert->height *= vAmt[ 2 ];
 			vert->height += vOrigin[ 2 ] - p->origin[ 2 ];
 		}
 	}
 
 	if ( g_qeglobals.d_select_mode != sel_terrainpoint ) {
 		p->scale_x *= vAmt[ 0 ];
 		p->scale_y *= vAmt[ 1 ];
       
 		p->origin[ 0 ] -= vOrigin[ 0 ];
 		p->origin[ 0 ] *= vAmt[ 0 ];
 		p->origin[ 0 ] += vOrigin[ 0 ];
 
 		p->origin[ 1 ] -= vOrigin[ 1 ];
 		p->origin[ 1 ] *= vAmt[ 1 ];
 		p->origin[ 1 ] += vOrigin[ 1 ];
 	}
 
 	if ( bRebuild ) {
 		Terrain_CalcBounds( p, vMin, vMax );
 		Terrain_CalcNormals( p );
 		Brush_RebuildBrush( p->pSymbiot, vMin, vMax );
 	}
 
 	UpdateTerrainInspector();
 }
 
 bool Terrain_DragScale( terrainMesh_t *p, vec3_t vAmt, vec3_t vMove ) {
 	vec3_t	vMin;
 	vec3_t	vMax;
 	vec3_t	vScale;
 	vec3_t	vTemp;
 	vec3_t	vMid;
 	int		i;
 
 	Terrain_CalcBounds( p, vMin, vMax );
 
 	VectorSubtract( vMax, vMin, vTemp );
 
 	// if we are scaling in the same dimension the terrain has no depth
 	for( i = 0; i < 3; i++ ) {
 		if ( ( vTemp[ i ] == 0 ) && ( vMove[ i ] != 0 ) ) {
 			return false;
 		}
 	}
   
 	for( i = 0; i < 3; i++ ) {
 		vMid[ i ] = ( vMin[ i ] + vMax[ i ] ) / 2;
 	}
 
 	for( i = 0; i < 3; i++ ) {
 		if ( vAmt[ i ] != 0 ) {
 			vScale[i] = 1.0 + vAmt[i] / vTemp[i];
 		} else {
 			vScale[i] = 1.0;
 		}
 	}
 
 	Terrain_Scale( p, vMid, vScale, false );
 	VectorSubtract( vMax, vMin, vTemp );
 	Terrain_CalcBounds( p, vMin, vMax );
   	VectorSubtract( vMax, vMin, vMid );
 	VectorSubtract( vMid, vTemp, vTemp );
 	VectorScale( vTemp, 0.5f, vTemp );
 
 	// abs of both should always be equal
 	if ( !VectorCompare( vMove, vAmt ) ) {
 		for( i = 0; i < 3; i++ ) {
 			if ( vMove[ i ] != vAmt[ i ] ) {
 				vTemp[ i ] = -vTemp[ i ];
 			}
 		}
 	}
 
 	Terrain_CalcNormals( p );
 	Terrain_Move( p, vTemp );
 
 	return true;
 }
 
 void Terrain_ApplyMatrix( terrainMesh_t *p, const vec3_t vOrigin, const vec3_t vMatrix[ 3 ], bool bSnap ) {
 }
 
 void Terrain_DrawFace( brush_t *brush, terrainFace_t *terraface ) {
 	terrainMesh_t	*pm;
 	terravert_t		a0;
 	terravert_t		a1;
 	terravert_t		a2;
 
 	pm = brush->pTerrain;
    
 	Terrain_GetTriangle( pm, terraface->index, &a0, &a1, &a2 );
 
 	qglBindTexture( GL_TEXTURE_2D, terraface->texture->texture_number );
 	qglBegin( GL_TRIANGLES );
 
 	// first tri
 	qglColor4fv( a0.rgba );
 	qglTexCoord2fv( a0.tc );
 	qglVertex3fv( a0.xyz );
 
 	qglColor4fv( a1.rgba );
 	qglTexCoord2fv( a1.tc );
 	qglVertex3fv( a1.xyz );
 
 	qglColor4fv( a2.rgba );
 	qglTexCoord2fv( a2.tc );
 	qglVertex3fv( a2.xyz );
 
 	qglEnd ();
 }
 
 void DrawTerrain( terrainMesh_t *pm, bool bPoints, bool bShade ) {
 	int				i;
 	int				w;
 	int				h;
 	int				x;
 	int				y;
 	//int			n;
 	//float			x1;
 	//float			y1;
 	float			scale_x;
 	float			scale_y;
 	//vec3_t		pSelectedPoints[ MAX_TERRA_POINTS ];
 	//int			nIndex;
 	terravert_t		a0;
 	terravert_t		a1;
 	terravert_t		a2;
 	terravert_t		b0;
 	terravert_t		b1;
 	terravert_t		b2;
 	terrainVert_t	*vert;
 	qtexture_t		*texture;
 
 	h = pm->height - 1;
 	w = pm->width - 1;
    
 	scale_x = pm->scale_x;
 	scale_y = pm->scale_y;
 
 	qglShadeModel (GL_SMOOTH);
 
 	if ( bShade ) {
 		for( i = 0; i < pm->numtextures; i++ ) {
 			texture = pm->textures[ i ];
 
 			qglBindTexture( GL_TEXTURE_2D, texture->texture_number );
 
 			vert = pm->heightmap;
 			for( y = 0; y < h; y++ ) {
 				qglBegin( GL_TRIANGLES );
 
 				for( x = 0; x < w; x++, vert++ ) {
 					Terrain_GetTriangles( pm, x, y, &a0, &a1, &a2, &b0, &b1, &b2, texture );
 
 					// first tri
 					if ( a0.rgba[ 3 ] || a1.rgba[ 3 ] || a2.rgba[ 3 ] ) {
 						qglColor4fv( a0.rgba );
 						qglTexCoord2fv( a0.tc );
 						qglVertex3fv( a0.xyz );
 
 						qglColor4fv( a1.rgba );
 						qglTexCoord2fv( a1.tc );
 						qglVertex3fv( a1.xyz );
 
 						qglColor4fv( a2.rgba );
 						qglTexCoord2fv( a2.tc );
 						qglVertex3fv( a2.xyz );
 					}
 
 					// second tri
 					if ( b0.rgba[ 3 ] || b1.rgba[ 3 ] || b2.rgba[ 3 ] ) {
 						qglColor4fv( b0.rgba );
 						qglTexCoord2fv( b0.tc );
 						qglVertex3fv( b0.xyz );
 
 						qglColor4fv( b1.rgba );
 						qglTexCoord2fv( b1.tc );
 						qglVertex3fv( b1.xyz );
 
 						qglColor4fv( b2.rgba );
 						qglTexCoord2fv( b2.tc );
 						qglVertex3fv( b2.xyz );
 					}
 				}
 
 			qglEnd ();
 			}
 		}
 	} else {
 		for( i = 0; i < pm->numtextures; i++ ) {
 			texture = pm->textures[ i ];
 
 			qglBindTexture( GL_TEXTURE_2D, texture->texture_number );
 
 			vert = pm->heightmap;
 			for( y = 0; y < h; y++ ) {
 				qglBegin( GL_TRIANGLES );
 
 				for( x = 0; x < w; x++, vert++ ) {
 					Terrain_GetTriangles( pm, x, y, &a0, &a1, &a2, &b0, &b1, &b2, texture );
 
 					// first tri
 					if ( a0.rgba[ 3 ] || a1.rgba[ 3 ] || a2.rgba[ 3 ] ) {
 						qglColor4fv( a0.rgba );
 						qglTexCoord2fv( a0.tc );
 						qglVertex3fv( a0.xyz );
 
 						qglColor4fv( a1.rgba );
 						qglTexCoord2fv( a1.tc );
 						qglVertex3fv( a1.xyz );
 
 						qglColor4fv( a2.rgba );
 						qglTexCoord2fv( a2.tc );
 						qglVertex3fv( a2.xyz );
 					}
 
 					// second tri
 					if ( b0.rgba[ 3 ] || b1.rgba[ 3 ] || b2.rgba[ 3 ] ) {
 						qglColor4fv( b0.rgba );
 						qglTexCoord2fv( b0.tc );
 						qglVertex3fv( b0.xyz );
 
 						qglColor4fv( b1.rgba );
 						qglTexCoord2fv( b1.tc );
 						qglVertex3fv( b1.xyz );
 
 						qglColor4fv( b2.rgba );
 						qglTexCoord2fv( b2.tc );
 						qglVertex3fv( b2.xyz );
 					}
 				}
 				qglEnd ();
 			}
 		}
 	}
 
 	qglPushAttrib( GL_CURRENT_BIT );
 
 	bool bDisabledLighting = qglIsEnabled( GL_LIGHTING );
 	if ( bDisabledLighting ) {
 		qglDisable( GL_LIGHTING );
 	}
 
 #if 0
 	terrainVert_t	*currentrow;
 	terrainVert_t	*nextrow;
 	float			x2;
 	float			y2;
 
 	// Draw normals
 	qglDisable( GL_TEXTURE_2D );
 	qglDisable( GL_BLEND );
 	qglColor3f( 1, 1, 1 );
 	qglBegin( GL_LINES );
 
 	y2 = pm->origin[ 1 ];
 	nextrow = pm->heightmap;
 	for( y = 0; y < h; y++ ) {
 		y1 = y2;
 		y2 += scale_y;
 
 		x2 = pm->origin[ 0 ];
 		currentrow = nextrow;
 		nextrow = currentrow + pm->width;
 		for( x = 0; x < w; x++ ) {
 			x1 = x2;
 			x2 += scale_x;
 
 			// normals
 			qglVertex3f( x1, y1, pm->origin[ 2 ] + currentrow[ x ].height );
 			qglVertex3f( x1 + currentrow[ x ].normal[ 0 ] * 16.0f, y1 + currentrow[ x ].normal[ 1 ] * 16.0f, pm->origin[ 2 ] + currentrow[ x ].height + currentrow[ x ].normal[ 2 ] * 16.0f );
 
 			qglVertex3f( x2, y1, pm->origin[ 2 ] + currentrow[ x + 1 ].height );
 			qglVertex3f( x2 + currentrow[ x + 1 ].normal[ 0 ] * 16.0f, y1 + currentrow[ x + 1 ].normal[ 1 ] * 16.0f, pm->origin[ 2 ] + currentrow[ x + 1 ].height + currentrow[ x + 1 ].normal[ 2 ] * 16.0f );
 
 			qglVertex3f( x1, y2, pm->origin[ 2 ] + nextrow[ x ].height );
 			qglVertex3f( x1 + nextrow[ x ].normal[ 0 ] * 16.0f, y2 + nextrow[ x ].normal[ 1 ] * 16.0f, pm->origin[ 2 ] + nextrow[ x ].height + nextrow[ x ].normal[ 2 ] * 16.0f );
 
 			qglVertex3f( x2, y2, pm->origin[ 2 ] + nextrow[ x + 1 ].height );
 			qglVertex3f( x2 + nextrow[ x + 1 ].normal[ 0 ] * 16.0f, y2 + nextrow[ x + 1 ].normal[ 1 ] * 16.0f, pm->origin[ 2 ] + nextrow[ x + 1 ].height + nextrow[ x + 1 ].normal[ 2 ] * 16.0f );
 		}
 	}
 
 	qglEnd ();
 	qglEnable( GL_TEXTURE_2D );
 #endif
 
 #if 0
 	if ( bPoints && ( g_qeglobals.d_select_mode == sel_terrainpoint || g_qeglobals.d_select_mode == sel_area ) ) {
 		qglPointSize( 6 );
 		qglDisable( GL_TEXTURE_2D );
 		qglDisable( GL_BLEND );
 
 		qglBegin( GL_POINTS );
 
 		nIndex = 0;
 
 		qglColor4f( 1, 0, 1, 1 );
 
 		y1 = pm->origin[ 1 ];
 		for ( y = 0; y < pm->height; y++, y1 += pm->scale_y ) {
 			x1 = pm->origin[ 0 ];
 			for( x = 0; x < pm->width; x++, x1 += pm->scale_x ) {
 				// FIXME: need to not do loop lookups inside here
 				n = Terrain_PointInMoveList( &pm->heightmap[ x + y * pm->width ] );
 				if ( n >= 0 ) {
 					VectorSet( pSelectedPoints[ nIndex ], x1, y1, pm->heightmap[ x + y * pm->width ].height + pm->origin[ 2 ] );
 					nIndex++;
 				} else {
 					qglVertex3f( x1, y1, pm->origin[ 2 ] + pm->heightmap[ x + y * pm->width ].height );
 				}
 			}
 		}
 
 		qglEnd();
 		
 		qglEnable( GL_TEXTURE_2D );
 
 		if ( nIndex > 0 ) {
 			qglBegin( GL_POINTS );
 			qglColor4f( 0, 0, 1, 1 );
 			while( nIndex-- > 0 ) {
 				qglVertex3fv( pSelectedPoints[ nIndex ] );
 			}
 		
 			qglEnd();
 		}
 	}
 #endif
 
 	if ( g_qeglobals.d_numterrapoints && ( ( g_qeglobals.d_select_mode == sel_terrainpoint ) || ( g_qeglobals.d_select_mode == sel_terraintexture ) ) ) {
 #if 0 
 		qglPointSize( 6 );
 		qglDisable( GL_TEXTURE_2D );
 		qglDisable( GL_BLEND );
 
 		qglBegin( GL_POINTS );
 
 		qglColor4f( 1, 0, 1, 1 );
 
 		for( i = 0; i < g_qeglobals.d_numterrapoints; i++ ) {
 			qglVertex3fv( g_qeglobals.d_terrapoints[ i ]->xyz );
 		}
 
 		qglEnd();
 			
 		qglEnable( GL_TEXTURE_2D );
 #endif
 
 		brush_t			*pb;
 		terrainMesh_t	*pm;
 
 		pm = NULL;
 		for( pb = active_brushes .next; pb != &active_brushes; pb = pb->next ) {
 			if ( pb->terrainBrush ) {
 				pm = pb->pTerrain;
 				break;
 			}
 		}
 
 		if ( pm ) {
 			qglDisable( GL_TEXTURE_2D );
 			qglBegin( GL_TRIANGLES );
 			qglEnable( GL_BLEND );
 
 			qglColor4f( 0.25, 0.5, 1, 0.35 );
 
 			for( i = 0; i < g_qeglobals.d_numterrapoints; i++ ) {
 				terravert_t		a0;
 				terravert_t		a1;
 				terravert_t		a2;
 
 				qglColor4f( 0.25, 0.5, 1, g_qeglobals.d_terrapoints[ i ]->scale * 0.75 + 0.25 );
 				Terrain_GetTriangle( pm, g_qeglobals.d_terrapoints[ i ]->tri.index * 2, &a0, &a1, &a2 );
 
 				qglVertex3fv( a0.xyz );
 				qglVertex3fv( a1.xyz );
 				qglVertex3fv( a2.xyz );
 
 				Terrain_GetTriangle( pm, g_qeglobals.d_terrapoints[ i ]->tri.index * 2 + 1, &a0, &a1, &a2 );
 
 				qglVertex3fv( a0.xyz );
 				qglVertex3fv( a1.xyz );
 				qglVertex3fv( a2.xyz );
 			}
 			qglEnd();
 			
 			qglDisable( GL_BLEND );
 			qglEnable( GL_TEXTURE_2D );
 		}
 	}
 }
 
 void Terrain_DrawCam( terrainMesh_t *pm ) {
 	qglColor3f( 1,1,1 );
 	qglPushAttrib( GL_ALL_ATTRIB_BITS );
 
 	if ( g_bPatchWireFrame ) {
 		if( pm->bSelected ) {
 			qglLineWidth( 2 );
 		} else {
 			qglLineWidth( 1 );
 		}
 
 		qglDisable( GL_CULL_FACE );
 		qglPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
 		qglDisable( GL_TEXTURE_2D );
 
 		if ( g_PrefsDlg.m_bGLLighting ) {
 			qglDisable( GL_LIGHTING );
 		}
 
 		DrawTerrain( pm, pm->bSelected, true );
 
 		if ( g_PrefsDlg.m_bGLLighting ) {
 			qglEnable( GL_LIGHTING );
 		}
 
 		qglEnable( GL_CULL_FACE );
 		qglLineWidth( 1 );
 	} else {
 		qglEnable( GL_CULL_FACE );
 		qglCullFace( GL_FRONT );
 
 		// draw the textured polys
 		DrawTerrain( pm, pm->bSelected, true );
 
 		// if selected, draw the red tint on the polys
 		if( pm->bSelected ) { // && ( g_qeglobals.d_savedinfo.include & INCLUDE_CAMERATINT ) ) {
 			qglColor4f( 1.0, 0.0, 0.0, 0.3 );
 			qglEnable( GL_BLEND );
 			qglPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
 			qglBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
 
 			DrawTerrain( pm, pm->bSelected );
 
 			qglColor3f( 1, 1, 1 );
 		}
 
 		// draw the backside poly outlines
 		qglCullFace( GL_BACK );
 		qglPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
 		qglDisable( GL_BLEND );
 		DrawTerrain( pm, pm->bSelected, true );
 	}
 
 	qglPopAttrib();
 }
 
 void Terrain_DrawXY( terrainMesh_t *pm, entity_t *owner ) {
 	qglPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
    
 	if ( pm->bSelected ) {
 		qglColor3fv( g_qeglobals.d_savedinfo.colors[ COLOR_SELBRUSHES ] );
 	} else if ( owner != world_entity && _stricmp( owner->eclass->name, "func_group" ) ) {
 		qglColor3fv( owner->eclass->color );
 	} else {
 		//FIXME
 		qglColor3fv( g_qeglobals.d_savedinfo.colors[ COLOR_BRUSHES ] );
 	}
 	
 	qglLineWidth( 1 );
 
 	DrawTerrain( pm, pm->bSelected );
 
 	qglPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
 }
 
 bool OnlyTerrainSelected( void ) {
 	brush_t *pb;
 
 	//if ( numselfaces || selected_brushes.next == &selected_brushes )
 	if ( selected_brushes.next == &selected_brushes ) {
 		return false;
 	}
 
 	for( pb = selected_brushes.next; pb != &selected_brushes; pb = pb->next ) {
 		if ( !pb->terrainBrush ) {
 			return false;
 		}
 	}
    
 	return true;
 }
 
 bool AnyTerrainSelected( void ) {
 	brush_t *pb;
 
 	//if ( numselfaces || selected_brushes.next == &selected_brushes )
 	if ( selected_brushes.next == &selected_brushes ) {
 		return false;
 	}
 
 	for( pb = selected_brushes.next; pb != &selected_brushes; pb = pb->next ) {
 		if ( pb->terrainBrush ) {
 			return true;
 		}
 	}
   
 	return false;
 }
 
 terrainMesh_t *SingleTerrainSelected( void ) {
 	if ( selected_brushes.next->terrainBrush ) {
 		return selected_brushes.next->pTerrain;
 	}
 
 	return NULL;
 }
 
 void Terrain_Edit( void ) {
 	//brush_t *pb;
 	//terrainMesh_t *p;
 	//int i;
 	//int j;
 
 //	g_qeglobals.d_numpoints = 0;
 	g_qeglobals.d_numterrapoints = 0;
 #if 0	
 	for( pb = selected_brushes.next; pb != &selected_brushes ; pb = pb->next ) {
 		if ( pb->terrainBrush ) {
 			p = pb->pTerrain;
 
 			if ( ( g_qeglobals.d_numpoints + p->width * p->height ) > MAX_POINTS ) {
 				Warning( "Too many points on terrain\n" );
 				continue;
 			}
 			for( i = 0; i < p->width; i++ ) {
 				for( j = 0; j < p->height; j++ ) {
 					Terrain_CalcVertPos( p, i, j, g_qeglobals.d_points[ g_qeglobals.d_numpoints ] );
 					g_qeglobals.d_numpoints++;
 				}
 			}
 		}
 	}
 #endif
    
 	g_qeglobals.d_select_mode = sel_terrainpoint;
 }
 
 void Terrain_SelectPointByRay( vec3_t org, vec3_t dir, int buttons ) {
 	float			bestd;
 	terrainFace_t	*face;
 	terrainFace_t	*bestface;
 	brush_t			*pb;
 	float			dist;
 	vec3_t			vec;
 
 	// find the point closest to the ray
 	bestface = NULL;
 	bestd = WORLD_SIZE * 4;
 	for( pb = selected_brushes.next; pb != &selected_brushes; pb = pb->next ) {
 		if ( pb->terrainBrush ) {
 			face = Terrain_Ray( org, dir, pb, &dist );
 			if ( face && ( dist < bestd ) ) {
 				bestface = face;
 				bestd = dist;
 			}
 		}
 	}
 
 	for( pb = active_brushes .next; pb != &active_brushes; pb = pb->next ) {
 		if ( pb->terrainBrush ) {
 			face = Terrain_Ray( org, dir, pb, &dist );
 			if ( face && ( dist < bestd ) ) {
 				bestface = face;
 				bestd = dist;
 			}
 		}
 	}
 
 	if ( !bestface ) {
 		return;
 	}
 	
 	VectorMA( org, bestd, dir, vec );
 	Terrain_AddMovePoint( vec, buttons & MK_CONTROL, buttons & MK_SHIFT, buttons );
 }
 
 void Terrain_AddMovePoint( vec3_t v, bool bMulti, bool bFull, int buttons  ) {
 	brush_t			*pb;
 	terrainMesh_t	*p;
 	terrainVert_t	*vert;
 	int				x;
 	int				y;
 	int				x1, y1;
 	float			dx, dy;
 	float			dist;
 	float			pd;
 
 	if ( !g_bSameView && !bMulti && !bFull ) {
 		g_bSameView = true;
 		return;
 	}
 	
 	g_qeglobals.d_numterrapoints = 0;
 	for( pb = active_brushes .next; pb != &active_brushes; pb = pb->next ) {
 	//for( pb = selected_brushes.next; pb != &selected_brushes; pb = pb->next ) {
 		if ( pb->terrainBrush ) {
 			p = pb->pTerrain;
 	    
 			x = ( v[ 0 ] - p->origin[ 0 ] ) / p->scale_x;
 			y = ( v[ 1 ] - p->origin[ 1 ] ) / p->scale_x;
 			if ( ( x < 0 ) || ( x >= p->width ) || ( y < 0 ) || ( y >= p->height ) ) {
 				continue;
 			}
 
 			vert = p->heightmap;
 			for( y1 = 0; y1 < p->height; y1++ ) {
 				for( x1 = 0; x1 < p->width; x1++, vert++ ) {
 
 					if ( g_qeglobals.d_terrainBrush == TERRAIN_BRUSH_CIRCLE ) {
 						dx = x1 - x;
 						dy = y1 - y;
 						dist = sqrt( dx * dx + dy * dy );
 					} else {
 						dx = abs( x1 - x );
 						dy = abs( y1 - y );
 						if ( dx > dy ) {
 							dist = dx;
 						} else {
 							dist = dy;
 						}
 					}
 
 					pd = dist * 2.0f / g_qeglobals.d_terrainBrushSize;
 					if ( fabs( pd ) <= 1.0f ) {
 						Terrain_AddPoint( p, vert );
 
 						if ( ( buttons & MK_LBUTTON ) && ( g_qeglobals.d_select_mode == sel_terraintexture ) ) {
 							vert->tri.texture = Texture_ForName( g_qeglobals.d_texturewin.texdef.name );
 							vert->tri.texdef.SetName( vert->tri.texture->name );
 							Terrain_AddTexture( p, vert->tri.texture );
 							continue;
 						}
 
 						if ( g_qeglobals.d_terrainFalloff == TERRAIN_FALLOFF_CURVED ) {
 							if ( g_qeglobals.d_terrainBrush == TERRAIN_BRUSH_CIRCLE ) {
 								vert->scale = ( 0.5f + cos( pd * M_PI ) * 0.5f );
 							} else {
 								vert->scale = ( 0.5f + cos( dx/ g_qeglobals.d_terrainBrushSize * M_PI ) * 0.5f ) * ( 0.5f + cos( dy/ g_qeglobals.d_terrainBrushSize * M_PI ) * 0.5f ) - 0.25;
 							}
 						} else {
 							vert->scale = 1.0f - pd;
 						}
 
 						switch( g_qeglobals.d_terrainNoiseType ) {
 						case NOISE_PLUS :
 							vert->scale *= crandom();
 							break;
 
 						case NOISE_PLUSMINUS :
 							vert->scale *= random();
 							break;
 						}
 					}
 				}
 			}
 		}
 	}
 }
 
 void Terrain_UpdateSelected( vec3_t vMove ) {
 	int				i;
 	brush_t			*pb;
 	terrainMesh_t	*p;
 	vec3_t			vMin;
 	vec3_t			vMax;
 
 	if ( g_qeglobals.d_select_mode == sel_terrainpoint ) {
 		for( i = 0; i < g_qeglobals.d_numterrapoints; i++ ) {
 			g_qeglobals.d_terrapoints[ i ]->height += vMove[ 2 ] * g_qeglobals.d_terrapoints[ i ]->scale;
 		}
 	}
 
 	for( pb = active_brushes .next; pb != &active_brushes; pb = pb->next ) {
 //	for( pb = selected_brushes.next; pb != &selected_brushes; pb = pb->next ) {
 		if ( pb->terrainBrush ) {
 			p = pb->pTerrain;
 
 			Terrain_CalcBounds( p, vMin, vMax );
 			Terrain_CalcNormals( p );
 			Brush_RebuildBrush( p->pSymbiot, vMin, vMax );
 		}
 	}
 }
 
 int Terrain_PointInMoveList( terrainVert_t *pf ) {
 	int i;
 
 	for( i = 0; i < g_qeglobals.d_numterrapoints; i++ ) {
 		if ( pf == g_qeglobals.d_terrapoints[ i ] ) {
 			return i;
 		}
 	}
 
 	return -1;
 }
 
 void Terrain_RemovePointFromMoveList( terrainVert_t *v ) {
 	int n;
 	int i;
    
 	while( ( n = Terrain_PointInMoveList( v ) ) >= 0 ) {
 		for( i = n; i < g_qeglobals.d_numterrapoints - 1; i++ ) {
 			g_qeglobals.d_terrapoints[ i ] = g_qeglobals.d_terrapoints[ i + 1 ];
 		}
     
 		g_qeglobals.d_numterrapoints--;
 	}
 }
 
 void Terrain_AddPoint( terrainMesh_t *p, terrainVert_t *v ) {
 	if ( g_qeglobals.d_numterrapoints < MAX_TERRA_POINTS ) {
 		g_qeglobals.d_terrapoints[ g_qeglobals.d_numterrapoints++ ] = v;
 	}
 }
 
 void Terrain_SelectAreaPoints( void ) {
 	brush_t			*pb;
 	terrainMesh_t	*p;
 	int				x;
 	int				y;
 	vec3_t			vec;
 
 	g_qeglobals.d_numterrapoints = 0;
 	g_nPatchClickedView = -1;
 
 	for( pb = selected_brushes.next; pb != &selected_brushes; pb = pb->next ) {
 		if ( pb->terrainBrush ) {
 			p = pb->pTerrain;
 			for( x = 0; x < p->width; x++ ) {
 				for( y = 0; y < p->height; y++ ) {
 					Terrain_CalcVertPos( p, x, y, vec );
 					if ( within( vec, g_qeglobals.d_vAreaTL, g_qeglobals.d_vAreaBR ) ) {
 						if ( g_qeglobals.d_numterrapoints < MAX_TERRA_POINTS ) {
 							g_qeglobals.d_terrapoints[ g_qeglobals.d_numterrapoints++ ] = &p->heightmap[ x + y * p->width ];
 						}
 					}
 				}
 			}
 		}
 	}
 }
 
 #define EPSILON 0.0001
 
 bool RayTriangleIntersect( vec3_t orig, vec3_t dir, vec3_t vert1, vec3_t vert2, vec3_t vert3, float *t ) {
 	float   u;
 	float   v;
 	vec3_t  edge1;
 	vec3_t  edge2;
 	vec3_t  tvec;
 	vec3_t	pvec;
 	vec3_t	qvec;
 	float	det;
 
 	VectorSubtract( vert2, vert1, edge1 );
 	VectorSubtract( vert3, vert1, edge2 );
 
 	// begin calculating determinant - also used to calculate U parameter
 	CrossProduct( dir, edge2, pvec );
 
 	// if determinant is near zero, ray lies in plane of triangle
 	det = DotProduct( edge1, pvec );
 	if ( det < EPSILON ) {
 		return false;
 	}
 
 	// calculate distance from vert1 to ray origin
 	VectorSubtract( orig, vert1, tvec );
 
 	// calculate U parameter and test bounds
 	u = DotProduct( tvec, pvec );
 	if ( ( u < 0.0f ) || ( u > det ) ) {
 		return false;
 	}
 
 	// prepare to test V parameter
 	CrossProduct( tvec, edge1, qvec );
 
 	// calculate V parameter and test bounds
 	v = DotProduct( dir, qvec );
 	if ( ( v < 0.0f ) || ( u + v > det ) ) {
 		return false;
 	}
 
 	// calculate t, scale parameters, ray intersects triangle
 	*t = DotProduct( edge2, qvec ) / det;
 
 	return true;
 }
 
 /*
 ==============
 Terrain_Ray
 
 Itersects a ray with a terrain
 Returns the face hit and the distance along the ray the intersection occured at
 Returns NULL and 0 if not hit at all
 ==============
 */
 terrainFace_t *Terrain_Ray( vec3_t origin, vec3_t dir, brush_t *b, float *dist ) {
 	terrainMesh_t	*pm;
 	int				h;
 	int				w;
 	int				x;
 	int				y;
 	float			best_t;
 	float			t;
 	terravert_t		a0;
 	terravert_t		a1;
 	terravert_t		a2;
 	terravert_t		b0;
 	terravert_t		b1;
 	terravert_t		b2;
 	terrainVert_t	*vert;
 	terrainFace_t	*best;
 
 	best = NULL;
 	best_t = WORLD_SIZE * 2;
 
 	pm = b->pTerrain;
 	h = pm->height - 1;
 	w = pm->width - 1;
    
 	vert = pm->heightmap;
 	for( y = 0; y < h; y++, vert++ ) {
 		for( x = 0; x < w; x++, vert++ ) {
 			Terrain_GetTriangles( pm, x, y, &a0, &a1, &a2, &b0, &b1, &b2, NULL );
 
 			t = WORLD_SIZE * 2;
 			if ( RayTriangleIntersect( origin, dir, a2.xyz, a1.xyz, a0.xyz, &t ) ) {
 				if ( ( t >= 0 ) && ( t < best_t ) ) {
 					best = &vert->tri;
 					best_t = t;
 				}
 			}
 
 			t = WORLD_SIZE * 2;
 			if ( RayTriangleIntersect( origin, dir, b2.xyz, b1.xyz, b0.xyz, &t ) ) {
 				if ( ( t >= 0 ) && ( t < best_t ) ) {
 					best = &vert->tri;
 					best_t = t;
 				}
 			}
 		}
 	}
 
 	if ( !best ) {
 		*dist = 0;
 		return NULL;
 	}
 
 	*dist = best_t;
 
 	return best;
 }
 
 /*
 ============
 Select_TerrainFace
 
 Select the face
 ============
 */
 void Select_TerrainFace ( brush_t * brush, terrainFace_t *terraface ) {
 #if 0
 	UnSelect_Brush( brush );
 
 	if( numselfaces < MAX_SEL_FACES ) {
 		selfaces[numselfaces].face = NULL;
 		selfaces[numselfaces].brush = brush;
 		selfaces[numselfaces].terraface = terraface;
 		numselfaces++;
 	}
 #endif
 }
 
 void Select_TerrainFacesFromBrush( brush_t *brush ) {
 	terrainMesh_t	*pm;
 	int				h;
 	int				w;
 	int				x;
 	int				y;
 
 	pm = brush->pTerrain;
 	h = pm->height - 1;
 	w = pm->width - 1;
    
 	for( y = 0; y < h; y++ ) {
 		for( x = 0; x < w; x++ ) {
 			Select_TerrainFace( brush, &brush->pTerrain->heightmap[ x + y * pm->width ].tri );
 		}
 	}
 }
 
 void SetTerrainTexdef( brush_t *brush, terrainFace_t *face, texdef_t *texdef ) {
 	int	oldFlags;
 	int	oldContents;
 
 	oldFlags = face->texdef.flags;
 	oldContents = face->texdef.contents;
 
 	face->texdef = *texdef;
 
 	face->texdef.flags = ( face->texdef.flags & ~SURF_KEEP ) | ( oldFlags & SURF_KEEP );
 	face->texdef.contents = ( face->texdef.contents & ~CONTENTS_KEEP ) | ( oldContents & CONTENTS_KEEP );
    
 	face->texture = Texture_ForName( texdef->name );
 
 	//Terrain_AddTexture( face->texture );
 }
 
 void RotateTerrainFaceTexture( terrainFace_t *vert, int nAxis, float fDeg ) {
 }
 
 void TerrainFace_FitTexture( terrainFace_t *vert ) {
 }
 
 void Terrain_Init( void ) {
 	g_qeglobals.d_terrainWidth		= 64;
 	g_qeglobals.d_terrainHeight		= 64;
 	g_qeglobals.d_terrainBrushSize	= 12;
 	g_qeglobals.d_terrainNoiseType	= NOISE_NONE;
 	//g_qeglobals.d_terrainFalloff	= TERRAIN_FALLOFF_LINEAR;
 	g_qeglobals.d_terrainFalloff	= TERRAIN_FALLOFF_CURVED;
 	g_qeglobals.d_terrainBrush		= TERRAIN_BRUSH_CIRCLE;
 	//g_qeglobals.d_terrainBrush		= TERRAIN_BRUSH_SQUARE;
 }