1736 lines
42 KiB
C++
Executable File
1736 lines
42 KiB
C++
Executable File
/*
|
|
===========================================================================
|
|
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;
|
|
}
|