Quake-III-Arena

map_sin.c (32168B)

---

 /*
 ===========================================================================
 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
 ===========================================================================
 */
 //-----------------------------------------------------------------------------
 //
 //  $Logfile:: /MissionPack/code/bspc/map_sin.c                               $
 
 #include "qbsp.h"
 #include "l_bsp_sin.h"
 #include "aas_map.h"			//AAS_CreateMapBrushes
 
 
 //====================================================================
 
 
 /*
 ===========
 Sin_BrushContents
 ===========
 */
 
 int Sin_BrushContents(mapbrush_t *b)
 {
 	int			contents;
 	side_t		*s;
 	int			i;
 #ifdef SIN
 	float			trans = 0;
 #else
 	int			trans;
 #endif
 
 	s = &b->original_sides[0];
 	contents = s->contents;
 
 #ifdef SIN
 	trans = sin_texinfo[s->texinfo].translucence;
 #else
 	trans = texinfo[s->texinfo].flags;
 #endif
 	for (i=1 ; i<b->numsides ; i++, s++)
 	{
 		s = &b->original_sides[i];
 #ifdef SIN
 		trans += sin_texinfo[s->texinfo].translucence;
 #else
 		trans |= texinfo[s->texinfo].flags;
 #endif
 		if (s->contents != contents)
 		{
 #ifdef SIN
       if ( 
             ( s->contents & CONTENTS_DETAIL && !(contents & CONTENTS_DETAIL) ) ||
             ( !(s->contents & CONTENTS_DETAIL) && contents & CONTENTS_DETAIL ) 
          )
          {
          s->contents |= CONTENTS_DETAIL;
          contents |= CONTENTS_DETAIL;
          continue;
          }
 #endif
 			printf ("Entity %i, Brush %i: mixed face contents\n"
 				, b->entitynum, b->brushnum);
 			break;
 		}
 	}
 
 
 #ifdef SIN
 	if (contents & CONTENTS_FENCE)
 	{
 //		contents |= CONTENTS_TRANSLUCENT;
 		contents |= CONTENTS_DETAIL;
 		contents |= CONTENTS_DUMMYFENCE;
 		contents &= ~CONTENTS_SOLID;
 		contents &= ~CONTENTS_FENCE;
 		contents |= CONTENTS_WINDOW;
 	}
 #endif
 
 	// if any side is translucent, mark the contents
 	// and change solid to window
 #ifdef SIN
 	if ( trans > 0 )
 #else
 	if ( trans & (SURF_TRANS33|SURF_TRANS66) )
 #endif
 	{
 		contents |= CONTENTS_Q2TRANSLUCENT;
 		if (contents & CONTENTS_SOLID)
 		{
 			contents &= ~CONTENTS_SOLID;
 			contents |= CONTENTS_WINDOW;
 		}
 	}
 
 	return contents;
 } //*/
 
 
 //============================================================================
 
 
 
 /*
 =================
 ParseBrush
 =================
 * /
 void ParseBrush (entity_t *mapent)
 {
 	mapbrush_t		*b;
 	int			i,j, k;
 	int			mt;
 	side_t		*side, *s2;
 	int			planenum;
 	brush_texture_t	td;
 #ifdef SIN
    textureref_t newref;
 #endif
 	int			planepts[3][3];
 
 	if (nummapbrushes == MAX_MAP_BRUSHES)
 		Error ("nummapbrushes == MAX_MAP_BRUSHES");
 
 	b = &mapbrushes[nummapbrushes];
 	b->original_sides = &brushsides[nummapbrushsides];
 	b->entitynum = num_entities-1;
 	b->brushnum = nummapbrushes - mapent->firstbrush;
 
 	do
 	{
 		if (!GetToken (true))
 			break;
 		if (!strcmp (token, "}") )
 			break;
 
 		if (nummapbrushsides == MAX_MAP_BRUSHSIDES)
 			Error ("MAX_MAP_BRUSHSIDES");
 		side = &brushsides[nummapbrushsides];
 
 		// read the three point plane definition
 		for (i=0 ; i<3 ; i++)
 		{
 			if (i != 0)
 				GetToken (true);
 			if (strcmp (token, "(") )
 				Error ("parsing brush");
 			
 			for (j=0 ; j<3 ; j++)
 			{
 				GetToken (false);
 				planepts[i][j] = atoi(token);
 			}
 			
 			GetToken (false);
 			if (strcmp (token, ")") )
 				Error ("parsing brush");
 				
 		}
 
 
 		//
 		// read the texturedef
 		//
 		GetToken (false);
 		strcpy (td.name, token);
 
 		GetToken (false);
 		td.shift[0] = atoi(token);
 		GetToken (false);
 		td.shift[1] = atoi(token);
 		GetToken (false);
 #ifdef SIN
 		td.rotate = atof(token);	
 #else
 		td.rotate = atoi(token);	
 #endif
 		GetToken (false);
 		td.scale[0] = atof(token);
 		GetToken (false);
 		td.scale[1] = atof(token);
 
 		// find default flags and values
 		mt = FindMiptex (td.name);
 #ifdef SIN
       // clear out the masks on newref
       memset(&newref,0,sizeof(newref));
       // copy over the name
       strcpy( newref.name, td.name );
 
       ParseSurfaceInfo( &newref );
       MergeRefs( &bsp_textureref[mt], &newref, &td.tref );
       side->contents = td.tref.contents;
       side->surf = td.tref.flags;
 #else
 		td.flags = textureref[mt].flags;
 		td.value = textureref[mt].value;
 		side->contents = textureref[mt].contents;
 		side->surf = td.flags = textureref[mt].flags;
 
 		if (TokenAvailable())
 		{
 			GetToken (false);
 			side->contents = atoi(token);
 			GetToken (false);
 			side->surf = td.flags = atoi(token);
 			GetToken (false);
 			td.value = atoi(token);
 		}
 #endif
 
 		// translucent objects are automatically classified as detail
 #ifdef SIN
 		if ( td.tref.translucence > 0 )
 #else
 		if (side->surf & (SURF_TRANS33|SURF_TRANS66) )
 #endif
 			side->contents |= CONTENTS_DETAIL;
 		if (side->contents & (CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP) )
 			side->contents |= CONTENTS_DETAIL;
 		if (fulldetail)
 			side->contents &= ~CONTENTS_DETAIL;
 		if (!(side->contents & ((LAST_VISIBLE_CONTENTS-1) 
 			| CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP|CONTENTS_MIST)  ) )
 			side->contents |= CONTENTS_SOLID;
 
 		// hints and skips are never detail, and have no content
 		if (side->surf & (SURF_HINT|SURF_SKIP) )
 		{
 			side->contents = 0;
 #ifndef SIN // I think this is a bug of some kind
 			side->surf &= ~CONTENTS_DETAIL;
 #endif
 		}
 
 		//
 		// find the plane number
 		//
 		planenum = PlaneFromPoints (planepts[0], planepts[1], planepts[2]);
 		if (planenum == -1)
 		{
 			printf ("Entity %i, Brush %i: plane with no normal\n"
 				, b->entitynum, b->brushnum);
 			continue;
 		}
 
 		//
 		// see if the plane has been used already
 		//
 		for (k=0 ; k<b->numsides ; k++)
 		{
 			s2 = b->original_sides + k;
 			if (s2->planenum == planenum)
 			{
 				printf ("Entity %i, Brush %i: duplicate plane\n"
 					, b->entitynum, b->brushnum);
 				break;
 			}
 			if ( s2->planenum == (planenum^1) )
 			{
 				printf ("Entity %i, Brush %i: mirrored plane\n"
 					, b->entitynum, b->brushnum);
 				break;
 			}
 		}
 		if (k != b->numsides)
 			continue;		// duplicated
 
 		//
 		// keep this side
 		//
 
 		side = b->original_sides + b->numsides;
 		side->planenum = planenum;
 #ifdef SIN
 		side->texinfo = TexinfoForBrushTexture (&mapplanes[planenum],
 			&td, vec3_origin, &newref);
       // 
       // save off lightinfo
       //
 		side->lightinfo = LightinfoForBrushTexture ( &td );
 #else
 		side->texinfo = TexinfoForBrushTexture (&mapplanes[planenum],
 			&td, vec3_origin);
 
 #endif
 
 		// save the td off in case there is an origin brush and we
 		// have to recalculate the texinfo
 		side_brushtextures[nummapbrushsides] = td;
 #ifdef SIN
       // save off the merged tref for animating textures
 		side_newrefs[nummapbrushsides] = newref;
 #endif
 
 		nummapbrushsides++;
 		b->numsides++;
 	} while (1);
 
 	// get the content for the entire brush
 	b->contents = Sin_BrushContents (b);
 
 	// allow detail brushes to be removed 
 	if (nodetail && (b->contents & CONTENTS_DETAIL) )
 	{
 		b->numsides = 0;
 		return;
 	}
 
 	// allow water brushes to be removed
 	if (nowater && (b->contents & (CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_WATER)) )
 	{
 		b->numsides = 0;
 		return;
 	}
 
 	// create windings for sides and bounds for brush
 	MakeBrushWindings (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;
 	}
 
 	//
 	// 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
 	//
 	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;
 	}
 
 	AddBrushBevels (b);
 
 	nummapbrushes++;
 	mapent->numbrushes++;		
 } //*/
 
 /*
 ================
 MoveBrushesToWorld
 
 Takes all of the brushes from the current entity and
 adds them to the world's brush list.
 
 Used by func_group and func_areaportal
 ================
 * /
 void MoveBrushesToWorld (entity_t *mapent)
 {
 	int			newbrushes;
 	int			worldbrushes;
 	mapbrush_t	*temp;
 	int			i;
 
 	// this is pretty gross, because the brushes are expected to be
 	// in linear order for each entity
 
 	newbrushes = mapent->numbrushes;
 	worldbrushes = entities[0].numbrushes;
 
 	temp = malloc(newbrushes*sizeof(mapbrush_t));
 	memcpy (temp, mapbrushes + mapent->firstbrush, newbrushes*sizeof(mapbrush_t));
 
 #if	0		// let them keep their original brush numbers
 	for (i=0 ; i<newbrushes ; i++)
 		temp[i].entitynum = 0;
 #endif
 
 	// make space to move the brushes (overlapped copy)
 	memmove (mapbrushes + worldbrushes + newbrushes,
 		mapbrushes + worldbrushes,
 		sizeof(mapbrush_t) * (nummapbrushes - worldbrushes - newbrushes) );
 
 	// copy the new brushes down
 	memcpy (mapbrushes + worldbrushes, temp, sizeof(mapbrush_t) * newbrushes);
 
 	// fix up indexes
 	entities[0].numbrushes += newbrushes;
 	for (i=1 ; i<num_entities ; i++)
 		entities[i].firstbrush += newbrushes;
 	free (temp);
 
 	mapent->numbrushes = 0;
 } //*/
 
 /*
 ================
 ParseMapEntity
 ================
 * /
 qboolean	Sin_ParseMapEntity (void)
 {
 	entity_t	*mapent;
 	epair_t		*e;
 	side_t		*s;
 	int			i, j;
 	int			startbrush, startsides;
 	vec_t		newdist;
 	mapbrush_t	*b;
 
 	if (!GetToken (true))
 		return false;
 
 	if (strcmp (token, "{") )
 		Error ("ParseEntity: { not found");
 	
 	if (num_entities == MAX_MAP_ENTITIES)
 		Error ("num_entities == MAX_MAP_ENTITIES");
 
 	startbrush = nummapbrushes;
 	startsides = nummapbrushsides;
 
 	mapent = &entities[num_entities];
 	num_entities++;
 	memset (mapent, 0, sizeof(*mapent));
 	mapent->firstbrush = nummapbrushes;
 	mapent->numbrushes = 0;
 //	mapent->portalareas[0] = -1;
 //	mapent->portalareas[1] = -1;
 
 	do
 	{
 		if (!GetToken (true))
 			Error ("ParseEntity: EOF without closing brace");
 		if (!strcmp (token, "}") )
 			break;
 		if (!strcmp (token, "{") )
 			ParseBrush (mapent);
 		else
 		{
 			e = ParseEpair ();
 #ifdef SIN
          //HACK HACK HACK
          // MED Gotta do this here
          if ( !stricmp(e->key, "surfacefile") )
             {
             if (!surfacefile[0])
                {
                strcpy( surfacefile, e->value );
                }
 		      printf ("--- ParseSurfaceFile ---\n");
 		      printf ("Surface script: %s\n", surfacefile);
 		      if (!ParseSurfaceFile(surfacefile))
                {
 		         Error ("Script file not found: %s\n", surfacefile);
                }
             }
 #endif
 			e->next = mapent->epairs;
 			mapent->epairs = e;
 		}
 	} while (1);
 
 #ifdef SIN
     if (!(strlen(ValueForKey(mapent, "origin")))  && ((num_entities-1) != 0))
         {
         mapbrush_t     *brush;
         vec3_t		    origin;
   	    char		    string[32];
         vec3_t          mins, maxs;
         int			    start, end;
         // Calculate bounds
 
         start = mapent->firstbrush;
 	    end = start + mapent->numbrushes;
 	    ClearBounds (mins, maxs);
 
 	    for (j=start ; j<end ; j++)
             {
 	        brush = &mapbrushes[j];
 		    if (!brush->numsides)
 			    continue;	// not a real brush (origin brush) - shouldn't happen
 		    AddPointToBounds (brush->mins, mins, maxs);
 		    AddPointToBounds (brush->maxs, mins, maxs);
             }
 
         // Set the origin to be the centroid of the entity.
         VectorAdd ( mins, maxs, origin);
 		VectorScale( origin, 0.5f, origin );
 
 		sprintf (string, "%i %i %i", (int)origin[0], (int)origin[1], (int)origin[2]);
 		SetKeyValue ( mapent, "origin", string);
 //        qprintf("Setting origin to %s\n",string);
         }
 #endif
 
 	GetVectorForKey (mapent, "origin", mapent->origin);
 
 #ifdef SIN
 	if (
          (!strcmp ("func_areaportal", ValueForKey (mapent, "classname"))) ||
          (!strcmp ("func_group", ValueForKey (mapent, "classname"))) ||
       	(!strcmp ("detail", ValueForKey (mapent, "classname")) && !entitydetails)
       )
       {
       VectorClear( mapent->origin );
       }
 #endif
 
 	//
 	// if there was an origin brush, offset all of the planes and texinfo
 	//
 	if (mapent->origin[0] || mapent->origin[1] || mapent->origin[2])
 	{
 		for (i=0 ; i<mapent->numbrushes ; i++)
 		{
 			b = &mapbrushes[mapent->firstbrush + i];
 			for (j=0 ; j<b->numsides ; j++)
 			{
 				s = &b->original_sides[j];
 				newdist = mapplanes[s->planenum].dist -
 					DotProduct (mapplanes[s->planenum].normal, mapent->origin);
 				s->planenum = FindFloatPlane (mapplanes[s->planenum].normal, newdist);
 #ifdef SIN
 				s->texinfo = TexinfoForBrushTexture (&mapplanes[s->planenum],
 					&side_brushtextures[s-brushsides], mapent->origin, &side_newrefs[s-brushsides]);
             // 
             // save off lightinfo
             //
             s->lightinfo = LightinfoForBrushTexture (	&side_brushtextures[s-brushsides] );
 #else
 				s->texinfo = TexinfoForBrushTexture (&mapplanes[s->planenum],
 					&side_brushtextures[s-brushsides], mapent->origin);
 #endif
 			}
 			MakeBrushWindings (b);
 		}
 	}
 
 	// group entities are just for editor convenience
 	// toss all brushes into the world entity
 	if (!strcmp ("func_group", ValueForKey (mapent, "classname")))
 	{
 		MoveBrushesToWorld (mapent);
 		mapent->numbrushes = 0;
 		mapent->wasdetail = true;
       FreeValueKeys( mapent );
 		return true;
 	}
 #ifdef SIN
 	// detail entities are just for editor convenience
 	// toss all brushes into the world entity as detail brushes
 	if (!strcmp ("detail", ValueForKey (mapent, "classname")) && !entitydetails)
 	{
 		for (i=0 ; i<mapent->numbrushes ; i++)
 		{
          int j;
          side_t * s;
 			b = &mapbrushes[mapent->firstbrush + i];
    	   if (nodetail)
             {
             b->numsides = 0;
             continue;
             }
          if (!fulldetail)
             {
    	      // set the contents for the entire brush
 	         b->contents |= CONTENTS_DETAIL;
 			   // set the contents in the sides as well
 			   for (j=0, s=b->original_sides ; j<b->numsides ; j++,s++)
 		   	   {
                s->contents |= CONTENTS_DETAIL;
 	   	   	}
             }
          else
             {
    	      // set the contents for the entire brush
 	         b->contents |= CONTENTS_SOLID;
 			   // set the contents in the sides as well
 			   for (j=0, s=b->original_sides ; j<b->numsides ; j++,s++)
 		   	   {
                s->contents |= CONTENTS_SOLID;
 	   	   	}
             }
 		}
 		MoveBrushesToWorld (mapent);
 		mapent->wasdetail = true;
       FreeValueKeys( mapent );
       // kill off the entity
    	// num_entities--;
 		return true;
 	}
 #endif
 
 	// areaportal entities move their brushes, but don't eliminate
 	// the entity
 	if (!strcmp ("func_areaportal", ValueForKey (mapent, "classname")))
 	{
 		char	str[128];
 
 		if (mapent->numbrushes != 1)
 			Error ("Entity %i: func_areaportal can only be a single brush", num_entities-1);
 
 		b = &mapbrushes[nummapbrushes-1];
 		b->contents = CONTENTS_AREAPORTAL;
 		c_areaportals++;
 		mapent->areaportalnum = c_areaportals;
 		// set the portal number as "style"
 		sprintf (str, "%i", c_areaportals);
 		SetKeyValue (mapent, "style", str);
 		MoveBrushesToWorld (mapent);
 		return true;
 	}
 
 	return true;
 } //end of the function Sin_ParseMapEntity */
 
 //===================================================================
 
 /*
 ================
 LoadMapFile
 ================
 * /
 void Sin_LoadMapFile (char *filename)
 {		
 	int		i;
 #ifdef SIN
    int num_detailsides=0;
    int num_detailbrushes=0;
    int num_worldsides=0;
    int num_worldbrushes=0;
    int      j,k;
 #endif
 
 	qprintf ("--- LoadMapFile ---\n");
 
 	LoadScriptFile (filename);
 
 	nummapbrushsides = 0;
 	num_entities = 0;
 	
 	while (ParseMapEntity ())
 	{
 	}
 
 	ClearBounds (map_mins, map_maxs);
 	for (i=0 ; i<entities[0].numbrushes ; i++)
 	{
 		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);
 	}
 #ifdef SIN
    for (j=0;  j<num_entities; j++)
       {
 	   for (i=0 ; i<entities[j].numbrushes ; i++)
 	      {
          side_t * s;
          mapbrush_t *b;
 			b = &mapbrushes[entities[j].firstbrush + i];
          if (b->numsides && b->contents & CONTENTS_DETAIL)
             num_detailbrushes++;
          else if (b->numsides)
             num_worldbrushes++;
 			for (k=0, s=b->original_sides ; k<b->numsides ; k++,s++)
 			   {
             if (s->contents & CONTENTS_DETAIL)
                num_detailsides++;
             else
                num_worldsides++;
 			   }
    	   }
       }
 #endif
 
 	qprintf ("%5i brushes\n", nummapbrushes);
 	qprintf ("%5i clipbrushes\n", c_clipbrushes);
 	qprintf ("%5i total sides\n", nummapbrushsides);
 	qprintf ("%5i boxbevels\n", c_boxbevels);
 	qprintf ("%5i edgebevels\n", c_edgebevels);
 	qprintf ("%5i entities\n", num_entities);
 	qprintf ("%5i planes\n", nummapplanes);
 	qprintf ("%5i areaportals\n", c_areaportals);
 	qprintf ("size: %5.0f,%5.0f,%5.0f to %5.0f,%5.0f,%5.0f\n", map_mins[0],map_mins[1],map_mins[2],
 		map_maxs[0],map_maxs[1],map_maxs[2]);
 #ifdef SIN
 	qprintf ("%5i detailbrushes\n", num_detailbrushes);
 	qprintf ("%5i worldbrushes\n", num_worldbrushes);
 	qprintf ("%5i detailsides\n", num_detailsides);
 	qprintf ("%5i worldsides\n", num_worldsides);
 #endif
 
 } //end of the function Sin_LoadMap */
 
 
 #ifdef ME		//Begin MAP loading from BSP file
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void Sin_CreateMapTexinfo(void)
 {
 	int i;
 	vec_t defaultvec[4] = {1, 0, 0, 0};
 
 	memcpy(map_texinfo[0].vecs[0], defaultvec, sizeof(defaultvec));
 	memcpy(map_texinfo[0].vecs[1], defaultvec, sizeof(defaultvec));
 	map_texinfo[0].flags = 0;
 	map_texinfo[0].value = 0;
 	strcpy(map_texinfo[0].texture, "generic/misc/red");	//no texture
 	map_texinfo[0].nexttexinfo = -1;
 	for (i = 1; i < sin_numtexinfo; i++)
 	{
 		memcpy(map_texinfo[i].vecs, sin_texinfo[i].vecs, sizeof(float) * 2 * 4);
 		map_texinfo[i].flags = sin_texinfo[i].flags;
 		map_texinfo[i].value = 0;
 		strcpy(map_texinfo[i].texture, sin_texinfo[i].texture);
 		map_texinfo[i].nexttexinfo = -1;
 	} //end for
 } //end of the function Sin_CreateMapTexinfo
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void Sin_SetLeafBrushesModelNumbers(int leafnum, int modelnum)
 {
 	int i, brushnum;
 	sin_dleaf_t *leaf;
 
 	leaf = &sin_dleafs[leafnum];
 	for (i = 0; i < leaf->numleafbrushes; i++)
 	{
 		brushnum = sin_dleafbrushes[leaf->firstleafbrush + i];
 		brushmodelnumbers[brushnum] = modelnum;
 		dbrushleafnums[brushnum] = leafnum;
 	} //end for
 } //end of the function Sin_SetLeafBrushesModelNumbers
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void Sin_InitNodeStack(void)
 {
 	nodestackptr = nodestack;
 	nodestacksize = 0;
 } //end of the function Sin_InitNodeStack
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void Sin_PushNodeStack(int num)
 {
 	*nodestackptr = num;
 	nodestackptr++;
 	nodestacksize++;
 	//
 	if (nodestackptr >= &nodestack[NODESTACKSIZE])
 	{
 		Error("Sin_PushNodeStack: stack overflow\n");
 	} //end if
 } //end of the function Sin_PushNodeStack
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int Sin_PopNodeStack(void)
 {
 	//if the stack is empty
 	if (nodestackptr <= nodestack) return -1;
 	//decrease stack pointer
 	nodestackptr--;
 	nodestacksize--;
 	//return the top value from the stack
 	return *nodestackptr;
 } //end of the function Sin_PopNodeStack
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void Sin_SetBrushModelNumbers(entity_t *mapent)
 {
 	int n, pn;
 	int leafnum;
 
 	//
 	Sin_InitNodeStack();
 	//head node (root) of the bsp tree
 	n = sin_dmodels[mapent->modelnum].headnode;
 	pn = 0;
 	
 	do
 	{
 		//if we are in a leaf (negative node number)
 		if (n < 0)
 		{
 			//number of the leaf
 			leafnum = (-n) - 1;
 			//set the brush numbers
 			Sin_SetLeafBrushesModelNumbers(leafnum, mapent->modelnum);
 			//walk back into the tree to find a second child to continue with
 			for (pn = Sin_PopNodeStack(); pn >= 0; n = pn, pn = Sin_PopNodeStack())
 			{
 				//if we took the first child at the parent node
 				if (sin_dnodes[pn].children[0] == n) break;
 			} //end for
 			//if the stack wasn't empty (if not processed whole tree)
 			if (pn >= 0)
 			{
 				//push the parent node again
 				Sin_PushNodeStack(pn);
 				//we proceed with the second child of the parent node
 				n = sin_dnodes[pn].children[1];
 			} //end if
 		} //end if
 		else
 		{
 			//push the current node onto the stack
 			Sin_PushNodeStack(n);
 			//walk forward into the tree to the first child
 			n = sin_dnodes[n].children[0];
 		} //end else
 	} while(pn >= 0);
 } //end of the function Sin_SetBrushModelNumbers
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void Sin_BSPBrushToMapBrush(sin_dbrush_t *bspbrush, entity_t *mapent)
 {
 	mapbrush_t *b;
 	int i, k, n;
 	side_t *side, *s2;
 	int planenum;
 	sin_dbrushside_t *bspbrushside;
 	sin_dplane_t *bspplane;
 
 	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 - sin_dbrushes];
 
 	for (n = 0; n < bspbrush->numsides; n++)
 	{
 		//pointer to the bsp brush side
 		bspbrushside = &sin_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 (sin_dbrushsidetextured[bspbrush->firstside + n]) side->flags |= SFL_TEXTURED;
 		else side->flags &= ~SFL_TEXTURED;
 		//ME: can get side contents and surf directly from BSP file
 		side->contents = bspbrush->contents;
 		//if the texinfo is TEXINFO_NODE
 		if (bspbrushside->texinfo < 0) side->surf = 0;
 		else side->surf = sin_texinfo[bspbrushside->texinfo].flags;
 
 		// translucent objects are automatically classified as detail
 		if (side->surf & (SURF_TRANS33|SURF_TRANS66) )
 			side->contents |= CONTENTS_DETAIL;
 		if (side->contents & (CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP) )
 			side->contents |= CONTENTS_DETAIL;
 		if (fulldetail)
 			side->contents &= ~CONTENTS_DETAIL;
 		if (!(side->contents & ((LAST_VISIBLE_CONTENTS-1) 
 			| CONTENTS_PLAYERCLIP|CONTENTS_MONSTERCLIP|CONTENTS_MIST)  ) )
 			side->contents |= CONTENTS_SOLID;
 
 		// hints and skips are never detail, and have no content
 		if (side->surf & (SURF_HINT|SURF_SKIP) )
 		{
 			side->contents = 0;
 			side->surf &= ~CONTENTS_DETAIL;
 		}
 
 		//ME: get a plane for this side
 		bspplane = &sin_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 (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 Sin_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
 	b->contents = bspbrush->contents;
 	Sin_BrushContents(b);
 
 	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 Sin_BSPBrushToMapBrush
 //===========================================================================
 //===========================================================================
 void Sin_ParseBSPBrushes(entity_t *mapent)
 {
 	int i, testnum = 0;
 
 	//give all the brushes that belong to this entity the number of the
 	//BSP model used by this entity
 	Sin_SetBrushModelNumbers(mapent);
 	//now parse all the brushes with the correct mapent->modelnum
 	for (i = 0; i < sin_numbrushes; i++)
 	{
 		if (brushmodelnumbers[i] == mapent->modelnum)
 		{
 			testnum++;
 			Sin_BSPBrushToMapBrush(&sin_dbrushes[i], mapent);
 		} //end if
 	} //end for
 } //end of the function Sin_ParseBSPBrushes
 //===========================================================================
 //===========================================================================
 qboolean Sin_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 model
 
 	model = ValueForKey(mapent, "model");
 	if (model && *model == '*')
 	{
 		mapent->modelnum = atoi(&model[1]);
 		//Log_Print("model = %s\n", model);
 		//Log_Print("mapent->modelnum = %d\n", mapent->modelnum);
 	} //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
 		Sin_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 Sin_ParseBSPEntity
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void Sin_LoadMapFromBSP(char *filename, int offset, int length)
 {
 	int i;
 
 	Log_Print("-- Sin_LoadMapFromBSP --\n");
 	//loaded map type
 	loadedmaptype = MAPTYPE_SIN;
 
 	Log_Print("Loading map from %s...\n", filename);
 	//load the bsp file
 	Sin_LoadBSPFile(filename, offset, length);
 
 	//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;
 
 	Sin_ParseEntities();
 	//
 	for (i = 0; i < num_entities; i++)
 	{
 		Sin_ParseBSPEntity(i);
 	} //end for
 
 	//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].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
 	//
 	Sin_CreateMapTexinfo();
 } //end of the function Sin_LoadMapFromBSP
 
 void Sin_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 Sin_ResetMapLoading
 
 //End MAP loading from BSP file
 
 #endif //ME