q3cellshading/q3radiant/terrain.cpp

/*
===========================================================================
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;
}