1 files changed, 276 insertions, 0 deletions

diff --git a/apps/plugins/sdl/progs/quake/r_efrag.c b/apps/plugins/sdl/progs/quake/r_efrag.c
new file mode 100644
index 0000000000..5e4d3f9e06
--- /dev/null
+++ b/apps/plugins/sdl/progs/quake/r_efrag.c
@@ -0,0 +1,276 @@
+/*
+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);
+                }
+        }
+}
+
+