quakeforge/qw/source/r_efrag.c

/*
	r_efrag.c

	(description)

	Copyright (C) 1996-1997  Id Software, Inc.

	This program 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.

	This program 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 this program; if not, write to:

		Free Software Foundation, Inc.
		59 Temple Place - Suite 330
		Boston, MA  02111-1307, USA

	$Id$
*/

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include "bothdefs.h"
#include "cl_main.h"
#include "cl_tent.h"
#include "QF/console.h"
#include "r_local.h"
#include "QF/sys.h"

mnode_t    *r_pefragtopnode;


//===========================================================================

/*
					ENTITY FRAGMENT FUNCTIONS
*/

efrag_t   **lastlink;

vec3_t      r_emins, r_emaxs;

entity_t   *r_addent;


/*
	R_RemoveEfrags

	Call when removing an object from the world or moving it to another position
*/
void
R_RemoveEfrags (entity_t *ent)
{
	efrag_t    *ef, *old, *walk, **prev;

	ef = ent->efrag;

	while (ef) {
		prev = &ef->leaf->efrags;
		while (1) {
			walk = *prev;
			if (!walk)
				break;
			if (walk == ef) {			// remove this fragment
				*prev = ef->leafnext;
				break;
			} else
				prev = &walk->leafnext;
		}

		old = ef;
		ef = ef->entnext;

		// put it on the free list
		old->entnext = cl.free_efrags;
		cl.free_efrags = old;
	}

	ent->efrag = NULL;
}

/*
	R_SplitEntityOnNode
*/
void
R_SplitEntityOnNode (mnode_t *node)
{
	efrag_t    *ef;
	mplane_t   *splitplane;
	mleaf_t    *leaf;
	int         sides;

	if (node->contents == CONTENTS_SOLID) {
		return;
	}
// add an efrag if the node is a leaf

	if (node->contents < 0) {
		if (!r_pefragtopnode)
			r_pefragtopnode = node;

		leaf = (mleaf_t *) node;

// grab an efrag off the free list
		ef = cl.free_efrags;
		if (!ef) {
			Con_Printf ("Too many efrags!\n");
			return;						// no free fragments...
		}
		cl.free_efrags = cl.free_efrags->entnext;

		ef->entity = r_addent;

// add the entity link  
		*lastlink = ef;
		lastlink = &ef->entnext;
		ef->entnext = NULL;

// set the leaf links
		ef->leaf = leaf;
		ef->leafnext = leaf->efrags;
		leaf->efrags = ef;

		return;
	}
// NODE_MIXED

	splitplane = node->plane;
	sides = BOX_ON_PLANE_SIDE (r_emins, r_emaxs, splitplane);

	if (sides == 3) {
		// split on this plane
		// if this is the first splitter of this bmodel, remember it
		if (!r_pefragtopnode)
			r_pefragtopnode = node;
	}
// recurse down the contacted sides
	if (sides & 1)
		R_SplitEntityOnNode (node->children[0]);

	if (sides & 2)
		R_SplitEntityOnNode (node->children[1]);
}


/*
	R_SplitEntityOnNode2
*/
void
R_SplitEntityOnNode2 (mnode_t *node)
{
	mplane_t   *splitplane;
	int         sides;

	if (node->visframe != r_visframecount)
		return;

	if (node->contents < 0) {
		if (node->contents != CONTENTS_SOLID)
			r_pefragtopnode = node;		// we've reached a non-solid leaf, so 
										// it's visible and not BSP clipped
		return;
	}

	splitplane = node->plane;
	sides = BOX_ON_PLANE_SIDE (r_emins, r_emaxs, splitplane);

	if (sides == 3) {
		// remember first splitter
		r_pefragtopnode = node;
		return;
	}
// not split yet; recurse down the contacted side
	if (sides & 1)
		R_SplitEntityOnNode2 (node->children[0]);
	else
		R_SplitEntityOnNode2 (node->children[1]);
}


/*
	R_AddEfrags
*/
void
R_AddEfrags (entity_t *ent)
{
	model_t    *entmodel;
	int         i;

	if (!ent->model)
		return;

	if (ent == &r_worldentity)
		return;							// never add the world

	r_addent = ent;

	lastlink = &ent->efrag;
	r_pefragtopnode = NULL;

	entmodel = ent->model;

	for (i = 0; i < 3; i++) {
		r_emins[i] = ent->origin[i] + entmodel->mins[i];
		r_emaxs[i] = ent->origin[i] + entmodel->maxs[i];
	}

	R_SplitEntityOnNode (cl.worldmodel->nodes);

	ent->topnode = r_pefragtopnode;
}


/*
	R_StoreEfrags

	// FIXME: a lot of this goes away with edge-based
*/
void
R_StoreEfrags (efrag_t **ppefrag)
{
	entity_t   *pent;
	model_t    *clmodel;
	efrag_t    *pefrag;


	while ((pefrag = *ppefrag) != NULL) {
		pent = pefrag->entity;
		clmodel = pent->model;

		switch (clmodel->type) {
			case mod_alias:
			case mod_brush:
			case mod_sprite:
				pent = pefrag->entity;

				if (pent->visframe != r_framecount) {
					entity_t **ent = CL_NewTempEntity ();
					if (!ent)
						return;
					*ent = pent;

					// mark that we've recorded this entity for this frame
					pent->visframe = r_framecount;
				}

				ppefrag = &pefrag->leafnext;
				break;

			default:
				Sys_Error ("R_StoreEfrags: Bad entity type %d\n",
						   clmodel->type);
		}
	}
}