Subversion Repositories Kolibri OS

/*

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 the Free Software

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

*/

// r_efrag.c

#include "quakedef.h"

#include "r_local.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 == cl_entities)

		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) &&

				(cl_numvisedicts < MAX_VISEDICTS))

			{

				cl_visedicts[cl_numvisedicts++] = 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);

		}

	}

}