mirror of
https://github.com/DrBeef/RTCWQuest.git
synced 2025-03-01 06:41:08 +00:00
729 lines
23 KiB
C
729 lines
23 KiB
C
/*
|
||
===========================================================================
|
||
|
||
Return to Castle Wolfenstein single player GPL Source Code
|
||
Copyright (C) 1999-2010 id Software LLC, a ZeniMax Media company.
|
||
|
||
This file is part of the Return to Castle Wolfenstein single player GPL Source Code (RTCW SP Source Code).
|
||
|
||
RTCW SP 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 3 of the License, or
|
||
(at your option) any later version.
|
||
|
||
RTCW SP 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 RTCW SP Source Code. If not, see <http://www.gnu.org/licenses/>.
|
||
|
||
In addition, the RTCW SP Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the RTCW SP Source Code. If not, please request a copy in writing from id Software at the address below.
|
||
|
||
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
||
|
||
===========================================================================
|
||
*/
|
||
|
||
//===========================================================================
|
||
//
|
||
// Name: map_q3.c
|
||
// Function: map loading
|
||
// Programmer: Mr Elusive (MrElusive@demigod.demon.nl)
|
||
// Last update: 1999-07-02
|
||
// Tab Size: 3
|
||
//===========================================================================
|
||
|
||
#include "qbsp.h"
|
||
#include "l_mem.h"
|
||
#include "../botlib/aasfile.h" //aas_bbox_t
|
||
#include "aas_store.h" //AAS_MAX_BBOXES
|
||
#include "aas_cfg.h"
|
||
#include "aas_map.h" //AAS_CreateMapBrushes
|
||
#include "l_bsp_q3.h"
|
||
#include "../qcommon/cm_patch.h"
|
||
#include "../game/surfaceflags.h"
|
||
|
||
#define NODESTACKSIZE 1024
|
||
//===========================================================================
|
||
//
|
||
// Parameter: -
|
||
// Returns: -
|
||
// Changes Globals: -
|
||
//===========================================================================
|
||
void PrintContents( int contents );
|
||
|
||
int Q3_BrushContents( mapbrush_t *b ) {
|
||
int contents, i, mixed, hint;
|
||
side_t *s;
|
||
|
||
s = &b->original_sides[0];
|
||
contents = s->contents;
|
||
//
|
||
mixed = false;
|
||
hint = false;
|
||
for ( i = 1; i < b->numsides; i++ )
|
||
{
|
||
s = &b->original_sides[i];
|
||
if ( s->contents != contents ) {
|
||
mixed = true;
|
||
}
|
||
if ( s->surf & ( SURF_HINT | SURF_SKIP ) ) {
|
||
hint = true;
|
||
}
|
||
contents |= s->contents;
|
||
} //end for
|
||
//
|
||
if ( hint ) {
|
||
if ( contents ) {
|
||
Log_Write( "WARNING: hint brush with contents: " );
|
||
PrintContents( contents );
|
||
Log_Write( "\r\n" );
|
||
//
|
||
Log_Write( "brush contents is: " );
|
||
PrintContents( b->contents );
|
||
Log_Write( "\r\n" );
|
||
} //end if
|
||
return 0;
|
||
} //end if
|
||
//Log_Write("brush %d contents ", nummapbrushes);
|
||
//PrintContents(contents);
|
||
//Log_Write("\r\n");
|
||
//remove ladder and fog contents
|
||
contents &= ~( CONTENTS_LADDER | CONTENTS_FOG );
|
||
//
|
||
if ( mixed ) {
|
||
Log_Write( "Entity %i, Brush %i: mixed face contents "
|
||
, b->entitynum, b->brushnum );
|
||
PrintContents( contents );
|
||
Log_Write( "\r\n" );
|
||
//
|
||
Log_Write( "brush contents is: " );
|
||
PrintContents( b->contents );
|
||
Log_Write( "\r\n" );
|
||
//
|
||
if ( contents & CONTENTS_DONOTENTER ) {
|
||
return CONTENTS_DONOTENTER; //Log_Print("mixed contents with donotenter\n");
|
||
}
|
||
/*
|
||
Log_Print("contents:"); PrintContents(contents);
|
||
Log_Print("\ncontents:"); PrintContents(s->contents);
|
||
Log_Print("\n");
|
||
Log_Print("texture name = %s\n", texinfo[s->texinfo].texture);
|
||
*/
|
||
//if liquid brush
|
||
if ( contents & ( CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_WATER ) ) {
|
||
return ( contents & ( CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_WATER ) );
|
||
} //end if
|
||
if ( contents & CONTENTS_PLAYERCLIP ) {
|
||
return ( contents & CONTENTS_PLAYERCLIP );
|
||
}
|
||
return ( contents & CONTENTS_SOLID );
|
||
} //end if
|
||
/*
|
||
if (contents & CONTENTS_AREAPORTAL)
|
||
{
|
||
static int num;
|
||
Log_Write("Entity %i, Brush %i: area portal %d\r\n", b->entitynum, b->brushnum, num++);
|
||
} //end if*/
|
||
if ( contents == ( contents & CONTENTS_STRUCTURAL ) ) {
|
||
//Log_Print("brush %i is only structural\n", b->brushnum);
|
||
contents = 0;
|
||
} //end if
|
||
if ( contents & CONTENTS_DONOTENTER ) {
|
||
Log_Print( "brush %i is a donotenter brush, c = %X\n", b->brushnum, contents );
|
||
} //end if
|
||
return contents;
|
||
} //end of the function Q3_BrushContents
|
||
//===========================================================================
|
||
//
|
||
// Parameter: -
|
||
// Returns: -
|
||
// Changes Globals: -
|
||
//===========================================================================
|
||
void Q3_DPlanes2MapPlanes( void ) {
|
||
int i;
|
||
|
||
for ( i = 0; i < q3_numplanes; i++ )
|
||
{
|
||
dplanes2mapplanes[i] = FindFloatPlane( q3_dplanes[i].normal, q3_dplanes[i].dist );
|
||
} //end for
|
||
} //end of the function Q3_DPlanes2MapPlanes
|
||
//===========================================================================
|
||
//
|
||
// Parameter: -
|
||
// Returns: -
|
||
// Changes Globals: -
|
||
//===========================================================================
|
||
void Q3_BSPBrushToMapBrush( q3_dbrush_t *bspbrush, entity_t *mapent ) {
|
||
mapbrush_t *b;
|
||
int i, k, n;
|
||
side_t *side, *s2;
|
||
int planenum;
|
||
q3_dbrushside_t *bspbrushside;
|
||
q3_dplane_t *bspplane;
|
||
int contentFlags = 0;
|
||
|
||
if ( nummapbrushes >= MAX_MAPFILE_BRUSHES ) {
|
||
Error( "nummapbrushes >= MAX_MAPFILE_BRUSHES" );
|
||
}
|
||
|
||
b = &mapbrushes[nummapbrushes];
|
||
b->original_sides = &brushsides[nummapbrushsides];
|
||
b->entitynum = mapent - entities;
|
||
b->brushnum = nummapbrushes - mapent->firstbrush;
|
||
b->leafnum = dbrushleafnums[bspbrush - q3_dbrushes];
|
||
|
||
for ( n = 0; n < bspbrush->numSides; n++ )
|
||
{
|
||
//pointer to the bsp brush side
|
||
bspbrushside = &q3_dbrushsides[bspbrush->firstSide + n];
|
||
|
||
if ( nummapbrushsides >= MAX_MAPFILE_BRUSHSIDES ) {
|
||
Error( "MAX_MAPFILE_BRUSHSIDES" );
|
||
} //end if
|
||
//pointer to the map brush side
|
||
side = &brushsides[nummapbrushsides];
|
||
//if the BSP brush side is textured
|
||
if ( q3_dbrushsidetextured[bspbrush->firstSide + n] ) {
|
||
side->flags |= SFL_TEXTURED | SFL_VISIBLE;
|
||
} else { side->flags &= ~SFL_TEXTURED;}
|
||
//NOTE: all Quake3 sides are assumed textured
|
||
//side->flags |= SFL_TEXTURED|SFL_VISIBLE;
|
||
//
|
||
if ( bspbrushside->shaderNum < 0 ) {
|
||
side->contents = 0;
|
||
side->surf = 0;
|
||
} //end if
|
||
else
|
||
{
|
||
side->contents = q3_dshaders[bspbrushside->shaderNum].contentFlags;
|
||
side->surf = q3_dshaders[bspbrushside->shaderNum].surfaceFlags;
|
||
|
||
if ( strstr( q3_dshaders[bspbrushside->shaderNum].shader, "common/hint" ) ) {
|
||
//Log_Print("found hint side\n");
|
||
side->surf |= SURF_HINT;
|
||
} //end if
|
||
|
||
// Ridah, mark ladder brushes
|
||
if ( cfg.rs_allowladders && strstr( q3_dshaders[bspbrushside->shaderNum].shader, "common/ladder" ) ) {
|
||
//Log_Print("found ladder side\n");
|
||
side->contents |= CONTENTS_LADDER;
|
||
contentFlags |= CONTENTS_LADDER;
|
||
} //end if
|
||
// done.
|
||
|
||
} //end else
|
||
//
|
||
|
||
if ( !( strstr( q3_dshaders[bspbrushside->shaderNum].shader, "common/slip" ) ) ) {
|
||
side->flags |= SFL_VISIBLE;
|
||
} else if ( side->surf & SURF_NODRAW ) {
|
||
side->flags |= SFL_TEXTURED | SFL_VISIBLE;
|
||
} //end if
|
||
/*
|
||
if (side->contents & (CONTENTS_TRANSLUCENT|CONTENTS_STRUCTURAL))
|
||
{
|
||
side->flags |= SFL_TEXTURED|SFL_VISIBLE;
|
||
} //end if*/
|
||
|
||
// hints and skips are never detail, and have no content
|
||
if ( side->surf & ( SURF_HINT | SURF_SKIP ) ) {
|
||
side->contents = 0;
|
||
//Log_Print("found hint brush side\n");
|
||
}
|
||
/*
|
||
if ((side->surf & SURF_NODRAW) && (side->surf & SURF_NOIMPACT))
|
||
{
|
||
side->contents = 0;
|
||
side->surf &= ~CONTENTS_DETAIL;
|
||
Log_Print("probably found hint brush in a BSP without hints being used\n");
|
||
} //end if*/
|
||
|
||
/*
|
||
// RF, ignore slick brushes (causes ladder issues)
|
||
if (strstr(q3_dshaders[bspbrushside->shaderNum].shader, "common/slick"))
|
||
{
|
||
//Log_Print("found hint side\n");
|
||
b->numsides = 0;
|
||
b->contents = 0;
|
||
return; // get out of here
|
||
} //end if
|
||
*/
|
||
|
||
//ME: get a plane for this side
|
||
bspplane = &q3_dplanes[bspbrushside->planeNum];
|
||
planenum = FindFloatPlane( bspplane->normal, bspplane->dist );
|
||
//
|
||
// see if the plane has been used already
|
||
//
|
||
//ME: this really shouldn't happen!!!
|
||
//ME: otherwise the bsp file is corrupted??
|
||
//ME: still it seems to happen, maybe Johny Boy's
|
||
//ME: brush bevel adding is crappy ?
|
||
for ( k = 0; k < b->numsides; k++ )
|
||
{
|
||
s2 = b->original_sides + k;
|
||
// if (DotProduct (mapplanes[s2->planenum].normal, mapplanes[planenum].normal) > 0.999
|
||
// && fabs(mapplanes[s2->planenum].dist - mapplanes[planenum].dist) < 0.01 )
|
||
|
||
if ( s2->planenum == planenum ) {
|
||
Log_Print( "Entity %i, Brush %i: duplicate plane\n"
|
||
, b->entitynum, b->brushnum );
|
||
break;
|
||
}
|
||
if ( s2->planenum == ( planenum ^ 1 ) ) {
|
||
Log_Print( "Entity %i, Brush %i: mirrored plane\n"
|
||
, b->entitynum, b->brushnum );
|
||
break;
|
||
}
|
||
}
|
||
if ( k != b->numsides ) {
|
||
continue; // duplicated
|
||
|
||
}
|
||
//
|
||
// keep this side
|
||
//
|
||
//ME: reset pointer to side, why? hell I dunno (pointer is set above already)
|
||
side = b->original_sides + b->numsides;
|
||
//ME: store the plane number
|
||
side->planenum = planenum;
|
||
//ME: texinfo is already stored when bsp is loaded
|
||
//NOTE: check for TEXINFO_NODE, otherwise crash in Q3_BrushContents
|
||
//if (bspbrushside->texinfo < 0) side->texinfo = 0;
|
||
//else side->texinfo = bspbrushside->texinfo;
|
||
|
||
// save the td off in case there is an origin brush and we
|
||
// have to recalculate the texinfo
|
||
// ME: don't need to recalculate because it's already done
|
||
// (for non-world entities) in the BSP file
|
||
// side_brushtextures[nummapbrushsides] = td;
|
||
|
||
nummapbrushsides++;
|
||
b->numsides++;
|
||
} //end for
|
||
|
||
// get the content for the entire brush
|
||
//Quake3 bsp brushes don't have a contents
|
||
b->contents = q3_dshaders[bspbrush->shaderNum].contentFlags | contentFlags;
|
||
// Ridah, Wolf has ladders (if we call Q3_BrushContents(), we'll get the solid area bug
|
||
b->contents &= ~( /*CONTENTS_LADDER|*/ CONTENTS_FOG | CONTENTS_STRUCTURAL );
|
||
//b->contents = Q3_BrushContents(b);
|
||
//
|
||
// Ridah, CONTENTS_MOSTERCLIP should prevent AAS from being created, but not clip players/AI in the game
|
||
if ( b->contents & CONTENTS_MONSTERCLIP ) {
|
||
b->contents |= CONTENTS_PLAYERCLIP;
|
||
}
|
||
|
||
// func_explosive's not solid
|
||
if ( !strcmp( "func_explosive", ValueForKey( &entities[b->entitynum], "classname" ) ) ||
|
||
!strcmp( "func_invisible_user", ValueForKey( &entities[b->entitynum], "classname" ) ) ||
|
||
!strcmp( "script_mover", ValueForKey( &entities[b->entitynum], "classname" ) ) ||
|
||
!strcmp( "func_static", ValueForKey( &entities[b->entitynum], "classname" ) ) ) {
|
||
Log_Print( "Ignoring %s brush..\n", ValueForKey( &entities[b->entitynum], "classname" ) );
|
||
b->numsides = 0;
|
||
b->contents = 0;
|
||
return;
|
||
}
|
||
|
||
if ( BrushExists( b ) ) {
|
||
c_squattbrushes++;
|
||
b->numsides = 0;
|
||
return;
|
||
} //end if
|
||
|
||
//if we're creating AAS
|
||
if ( create_aas ) {
|
||
//create the AAS brushes from this brush, don't add brush bevels
|
||
AAS_CreateMapBrushes( b, mapent, false );
|
||
return;
|
||
} //end if
|
||
|
||
// allow detail brushes to be removed
|
||
if ( nodetail && ( b->contents & CONTENTS_DETAIL ) ) {
|
||
b->numsides = 0;
|
||
return;
|
||
} //end if
|
||
|
||
// allow water brushes to be removed
|
||
if ( nowater && ( b->contents & ( CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_WATER ) ) ) {
|
||
b->numsides = 0;
|
||
return;
|
||
} //end if
|
||
|
||
|
||
// create windings for sides and bounds for brush
|
||
MakeBrushWindings( b );
|
||
|
||
//mark brushes without winding or with a tiny window as bevels
|
||
MarkBrushBevels( b );
|
||
|
||
// brushes that will not be visible at all will never be
|
||
// used as bsp splitters
|
||
if ( b->contents & ( CONTENTS_PLAYERCLIP | CONTENTS_MONSTERCLIP ) ) {
|
||
c_clipbrushes++;
|
||
for ( i = 0; i < b->numsides; i++ )
|
||
b->original_sides[i].texinfo = TEXINFO_NODE;
|
||
} //end for
|
||
|
||
//
|
||
// origin brushes are removed, but they set
|
||
// the rotation origin for the rest of the brushes
|
||
// in the entity. After the entire entity is parsed,
|
||
// the planenums and texinfos will be adjusted for
|
||
// the origin brush
|
||
//
|
||
//ME: not needed because the entities in the BSP file already
|
||
// have an origin set
|
||
// if (b->contents & CONTENTS_ORIGIN)
|
||
// {
|
||
// char string[32];
|
||
// vec3_t origin;
|
||
//
|
||
// if (num_entities == 1)
|
||
// {
|
||
// Error ("Entity %i, Brush %i: origin brushes not allowed in world"
|
||
// , b->entitynum, b->brushnum);
|
||
// return;
|
||
// }
|
||
//
|
||
// VectorAdd (b->mins, b->maxs, origin);
|
||
// VectorScale (origin, 0.5, origin);
|
||
//
|
||
// sprintf (string, "%i %i %i", (int)origin[0], (int)origin[1], (int)origin[2]);
|
||
// SetKeyValue (&entities[b->entitynum], "origin", string);
|
||
//
|
||
// VectorCopy (origin, entities[b->entitynum].origin);
|
||
//
|
||
// // don't keep this brush
|
||
// b->numsides = 0;
|
||
//
|
||
// return;
|
||
// }
|
||
|
||
//ME: the bsp brushes already have bevels, so we won't try to
|
||
// add them again (especially since Johny Boy's bevel adding might
|
||
// be crappy)
|
||
// AddBrushBevels(b);
|
||
|
||
nummapbrushes++;
|
||
mapent->numbrushes++;
|
||
} //end of the function Q3_BSPBrushToMapBrush
|
||
//===========================================================================
|
||
//===========================================================================
|
||
void Q3_ParseBSPBrushes( entity_t *mapent ) {
|
||
int i;
|
||
|
||
/*
|
||
//give all the brushes that belong to this entity the number of the
|
||
//BSP model used by this entity
|
||
Q3_SetBrushModelNumbers(mapent);
|
||
//now parse all the brushes with the correct mapent->modelnum
|
||
for (i = 0; i < q3_numbrushes; i++)
|
||
{
|
||
if (brushmodelnumbers[i] == mapent->modelnum)
|
||
{
|
||
Q3_BSPBrushToMapBrush(&q3_dbrushes[i], mapent);
|
||
} //end if
|
||
} //end for
|
||
*/
|
||
for ( i = 0; i < q3_dmodels[mapent->modelnum].numBrushes; i++ )
|
||
{
|
||
Q3_BSPBrushToMapBrush( &q3_dbrushes[q3_dmodels[mapent->modelnum].firstBrush + i], mapent );
|
||
} //end for
|
||
} //end of the function Q3_ParseBSPBrushes
|
||
//===========================================================================
|
||
//===========================================================================
|
||
qboolean Q3_ParseBSPEntity( int entnum ) {
|
||
entity_t *mapent;
|
||
char *model;
|
||
int startbrush, startsides;
|
||
|
||
startbrush = nummapbrushes;
|
||
startsides = nummapbrushsides;
|
||
|
||
mapent = &entities[entnum]; //num_entities];
|
||
mapent->firstbrush = nummapbrushes;
|
||
mapent->numbrushes = 0;
|
||
mapent->modelnum = -1; //-1 = no BSP model
|
||
|
||
model = ValueForKey( mapent, "model" );
|
||
if ( model && strlen( model ) ) {
|
||
if ( *model == '*' ) {
|
||
//get the model number of this entity (skip the leading *)
|
||
mapent->modelnum = atoi( &model[1] );
|
||
} //end if
|
||
} //end if
|
||
|
||
GetVectorForKey( mapent, "origin", mapent->origin );
|
||
|
||
//if this is the world entity it has model number zero
|
||
//the world entity has no model key
|
||
if ( !strcmp( "worldspawn", ValueForKey( mapent, "classname" ) ) ) {
|
||
mapent->modelnum = 0;
|
||
} //end if
|
||
//if the map entity has a BSP model (a modelnum of -1 is used for
|
||
//entities that aren't using a BSP model)
|
||
if ( mapent->modelnum >= 0 ) {
|
||
//parse the bsp brushes
|
||
Q3_ParseBSPBrushes( mapent );
|
||
} //end if
|
||
//
|
||
//the origin of the entity is already taken into account
|
||
//
|
||
//func_group entities can't be in the bsp file
|
||
//
|
||
//check out the func_areaportal entities
|
||
if ( !strcmp( "func_areaportal", ValueForKey( mapent, "classname" ) ) ) {
|
||
c_areaportals++;
|
||
mapent->areaportalnum = c_areaportals;
|
||
return true;
|
||
} //end if
|
||
return true;
|
||
} //end of the function Q3_ParseBSPEntity
|
||
//===========================================================================
|
||
//
|
||
// Parameter: -
|
||
// Returns: -
|
||
// Changes Globals: -
|
||
//===========================================================================
|
||
#define MAX_PATCH_VERTS 1024
|
||
|
||
void AAS_CreateCurveBrushes( void ) {
|
||
int i, j, n, planenum, numcurvebrushes = 0;
|
||
q3_dsurface_t *surface;
|
||
q3_drawVert_t *dv_p;
|
||
vec3_t points[MAX_PATCH_VERTS];
|
||
int width, height, c;
|
||
patchCollide_t *pc;
|
||
facet_t *facet;
|
||
mapbrush_t *brush;
|
||
side_t *side;
|
||
entity_t *mapent;
|
||
winding_t *winding;
|
||
|
||
qprintf( "nummapbrushsides = %d\n", nummapbrushsides );
|
||
mapent = &entities[0];
|
||
for ( i = 0; i < q3_numDrawSurfaces; i++ )
|
||
{
|
||
surface = &q3_drawSurfaces[i];
|
||
if ( !surface->patchWidth ) {
|
||
continue;
|
||
}
|
||
//if the curve is not solid
|
||
if ( !( q3_dshaders[surface->shaderNum].contentFlags & ( CONTENTS_SOLID | CONTENTS_PLAYERCLIP ) ) ) {
|
||
//Log_Print("skipped non-solid curve\n");
|
||
continue;
|
||
} //end if
|
||
//
|
||
width = surface->patchWidth;
|
||
height = surface->patchHeight;
|
||
c = width * height;
|
||
if ( c > MAX_PATCH_VERTS ) {
|
||
Error( "ParseMesh: MAX_PATCH_VERTS" );
|
||
} //end if
|
||
|
||
dv_p = q3_drawVerts + surface->firstVert;
|
||
for ( j = 0 ; j < c ; j++, dv_p++ )
|
||
{
|
||
points[j][0] = dv_p->xyz[0];
|
||
points[j][1] = dv_p->xyz[1];
|
||
points[j][2] = dv_p->xyz[2];
|
||
} //end for
|
||
// create the internal facet structure
|
||
pc = CM_GeneratePatchCollide( width, height, points );
|
||
//
|
||
for ( j = 0; j < pc->numFacets; j++ )
|
||
{
|
||
facet = &pc->facets[j];
|
||
//
|
||
brush = &mapbrushes[nummapbrushes];
|
||
brush->original_sides = &brushsides[nummapbrushsides];
|
||
brush->entitynum = 0;
|
||
brush->brushnum = nummapbrushes - mapent->firstbrush;
|
||
//
|
||
brush->numsides = facet->numBorders + 2;
|
||
nummapbrushsides += brush->numsides;
|
||
brush->contents = CONTENTS_SOLID;
|
||
//
|
||
//qprintf("\r%6d curve brushes", nummapbrushsides);//++numcurvebrushes);
|
||
qprintf( "\r%6d curve brushes", ++numcurvebrushes );
|
||
//
|
||
planenum = FindFloatPlane( pc->planes[facet->surfacePlane].plane, pc->planes[facet->surfacePlane].plane[3] );
|
||
//
|
||
side = &brush->original_sides[0];
|
||
side->planenum = planenum;
|
||
side->contents = CONTENTS_SOLID;
|
||
side->flags |= SFL_TEXTURED | SFL_VISIBLE | SFL_CURVE;
|
||
side->surf = 0;
|
||
//
|
||
side = &brush->original_sides[1];
|
||
if ( create_aas ) {
|
||
//the plane is expanded later so it's not a problem that
|
||
//these first two opposite sides are coplanar
|
||
side->planenum = planenum ^ 1;
|
||
} //end if
|
||
else
|
||
{
|
||
side->planenum = FindFloatPlane( mapplanes[planenum ^ 1].normal, mapplanes[planenum ^ 1].dist + 1 );
|
||
side->flags |= SFL_TEXTURED | SFL_VISIBLE;
|
||
} //end else
|
||
side->contents = CONTENTS_SOLID;
|
||
side->flags |= SFL_CURVE;
|
||
side->surf = 0;
|
||
//
|
||
winding = BaseWindingForPlane( mapplanes[side->planenum].normal, mapplanes[side->planenum].dist );
|
||
for ( n = 0; n < facet->numBorders; n++ )
|
||
{
|
||
//never use the surface plane as a border
|
||
if ( facet->borderPlanes[n] == facet->surfacePlane ) {
|
||
continue;
|
||
}
|
||
//
|
||
side = &brush->original_sides[2 + n];
|
||
side->planenum = FindFloatPlane( pc->planes[facet->borderPlanes[n]].plane, pc->planes[facet->borderPlanes[n]].plane[3] );
|
||
if ( facet->borderInward[n] ) {
|
||
side->planenum ^= 1;
|
||
}
|
||
side->contents = CONTENTS_SOLID;
|
||
side->flags |= SFL_TEXTURED | SFL_CURVE;
|
||
side->surf = 0;
|
||
//chop the winding in place
|
||
if ( winding ) {
|
||
ChopWindingInPlace( &winding, mapplanes[side->planenum ^ 1].normal, mapplanes[side->planenum ^ 1].dist, 0.1 ); //CLIP_EPSILON);
|
||
}
|
||
} //end for
|
||
//VectorCopy(pc->bounds[0], brush->mins);
|
||
//VectorCopy(pc->bounds[1], brush->maxs);
|
||
if ( !winding ) {
|
||
Log_Print( "WARNING: AAS_CreateCurveBrushes: no winding\n" );
|
||
brush->numsides = 0;
|
||
continue;
|
||
} //end if
|
||
brush->original_sides[0].winding = winding;
|
||
WindingBounds( winding, brush->mins, brush->maxs );
|
||
for ( n = 0; n < 3; n++ )
|
||
{
|
||
//IDBUG: all the indexes into the mins and maxs were zero (not using i)
|
||
if ( brush->mins[n] < -MAX_MAP_BOUNDS || brush->maxs[n] > MAX_MAP_BOUNDS ) {
|
||
Log_Print( "entity %i, brush %i: bounds out of range\n", brush->entitynum, brush->brushnum );
|
||
Log_Print( "brush->mins[%d] = %f, brush->maxs[%d] = %f\n", n, brush->mins[n], n, brush->maxs[n] );
|
||
brush->numsides = 0; //remove the brush
|
||
break;
|
||
} //end if
|
||
if ( brush->mins[n] > MAX_MAP_BOUNDS || brush->maxs[n] < -MAX_MAP_BOUNDS ) {
|
||
Log_Print( "entity %i, brush %i: no visible sides on brush\n", brush->entitynum, brush->brushnum );
|
||
Log_Print( "brush->mins[%d] = %f, brush->maxs[%d] = %f\n", n, brush->mins[n], n, brush->maxs[n] );
|
||
brush->numsides = 0; //remove the brush
|
||
break;
|
||
} //end if
|
||
} //end for
|
||
if ( create_aas ) {
|
||
//NOTE: brush bevels now already added
|
||
//AddBrushBevels(brush);
|
||
AAS_CreateMapBrushes( brush, mapent, false );
|
||
} //end if
|
||
else
|
||
{
|
||
// create windings for sides and bounds for brush
|
||
MakeBrushWindings( brush );
|
||
AddBrushBevels( brush );
|
||
nummapbrushes++;
|
||
mapent->numbrushes++;
|
||
} //end else
|
||
} //end for
|
||
} //end for
|
||
//qprintf("\r%6d curve brushes", nummapbrushsides);//++numcurvebrushes);
|
||
qprintf( "\r%6d curve brushes\n", numcurvebrushes );
|
||
} //end of the function AAS_CreateCurveBrushes
|
||
//===========================================================================
|
||
//
|
||
// Parameter: -
|
||
// Returns: -
|
||
// Changes Globals: -
|
||
//===========================================================================
|
||
void AAS_ExpandMapBrush( mapbrush_t *brush, vec3_t mins, vec3_t maxs );
|
||
|
||
void Q3_LoadMapFromBSP( struct quakefile_s *qf ) {
|
||
int i;
|
||
//vec3_t mins = {-1,-1,-1}, maxs = {1, 1, 1}; // TTimo: unused
|
||
|
||
Log_Print( "-- Q3_LoadMapFromBSP --\n" );
|
||
//loaded map type
|
||
loadedmaptype = MAPTYPE_QUAKE3;
|
||
|
||
Log_Print( "Loading map from %s...\n", qf->filename );
|
||
//load the bsp file
|
||
Q3_LoadBSPFile( qf );
|
||
|
||
//create an index from bsp planes to map planes
|
||
//DPlanes2MapPlanes();
|
||
//clear brush model numbers
|
||
for ( i = 0; i < MAX_MAPFILE_BRUSHES; i++ )
|
||
brushmodelnumbers[i] = -1;
|
||
|
||
nummapbrushsides = 0;
|
||
num_entities = 0;
|
||
|
||
Q3_ParseEntities();
|
||
//
|
||
for ( i = 0; i < num_entities; i++ )
|
||
{
|
||
Q3_ParseBSPEntity( i );
|
||
} //end for
|
||
|
||
AAS_CreateCurveBrushes();
|
||
//get the map mins and maxs from the world model
|
||
ClearBounds( map_mins, map_maxs );
|
||
for ( i = 0; i < entities[0].numbrushes; i++ )
|
||
{
|
||
if ( mapbrushes[i].numsides <= 0 ) {
|
||
continue;
|
||
}
|
||
//if (mapbrushes[i].mins[0] > 4096)
|
||
// continue; //no valid points
|
||
AddPointToBounds( mapbrushes[i].mins, map_mins, map_maxs );
|
||
AddPointToBounds( mapbrushes[i].maxs, map_mins, map_maxs );
|
||
} //end for
|
||
/*/
|
||
for (i = 0; i < nummapbrushes; i++)
|
||
{
|
||
//if (!mapbrushes[i].original_sides) continue;
|
||
//AddBrushBevels(&mapbrushes[i]);
|
||
//AAS_ExpandMapBrush(&mapbrushes[i], mins, maxs);
|
||
} //end for*/
|
||
/*
|
||
for (i = 0; i < nummapbrushsides; i++)
|
||
{
|
||
Log_Write("side %d flags = %d", i, brushsides[i].flags);
|
||
} //end for
|
||
for (i = 0; i < nummapbrushes; i++)
|
||
{
|
||
Log_Write("brush contents: ");
|
||
PrintContents(mapbrushes[i].contents);
|
||
Log_Print("\n");
|
||
} //end for*/
|
||
if ( writeaasmap ) {
|
||
char name[MAX_QPATH];
|
||
strncpy( name, qf->filename, sizeof( name ) );
|
||
StripExtension( name );
|
||
strcat( name, "_aas.map" );
|
||
WriteMapFile( name );
|
||
}
|
||
} //end of the function Q3_LoadMapFromBSP
|
||
//===========================================================================
|
||
//
|
||
// Parameter: -
|
||
// Returns: -
|
||
// Changes Globals: -
|
||
//===========================================================================
|
||
void Q3_ResetMapLoading( void ) {
|
||
//reset for map loading from bsp
|
||
memset( nodestack, 0, NODESTACKSIZE * sizeof( int ) );
|
||
nodestackptr = NULL;
|
||
nodestacksize = 0;
|
||
memset( brushmodelnumbers, 0, MAX_MAPFILE_BRUSHES * sizeof( int ) );
|
||
} //end of the function Q3_ResetMapLoading
|
||
|