psp/video_hardware_entity_fragment.cpp

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3 Copyright (C) 2007 Peter Mackay and Chris Swindle.
   4
   5 This program is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13
  14 See the GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19
  20 */
  21 // r_efrag.c
  22
  23 extern "C"
  24 {
  25 #include "../quakedef.h"
  26 }
  27
  28 mnode_t *r_pefragtopnode;
  29
  30
  31 //===========================================================================
  32
  33 /*
  34 ===============================================================================
  35
  36                                         ENTITY FRAGMENT FUNCTIONS
  37
  38 ===============================================================================
  39 */
  40
  41 efrag_t         **lastlink;
  42
  43 vec3_t          r_emins, r_emaxs;
  44
  45 entity_t        *r_addent;
  46
  47
  48 /*
  49 ================
  50 R_RemoveEfrags
  51
  52 Call when removing an object from the world or moving it to another position
  53 ================
  54 */
  55 void R_RemoveEfrags (entity_t *ent)
  56 {
  57         efrag_t         *ef, *old, *walk, **prev;
  58
  59         ef = ent->efrag;
  60
  61         while (ef)
  62         {
  63                 prev = &ef->leaf->efrags;
  64                 while (1)
  65                 {
  66                         walk = *prev;
  67                         if (!walk)
  68                                 break;
  69                         if (walk == ef)
  70                         {       // remove this fragment
  71                                 *prev = ef->leafnext;
  72                                 break;
  73                         }
  74                         else
  75                                 prev = &walk->leafnext;
  76                 }
  77
  78                 old = ef;
  79                 ef = ef->entnext;
  80
  81         // put it on the free list
  82                 old->entnext = cl.free_efrags;
  83                 cl.free_efrags = old;
  84         }
  85
  86         ent->efrag = NULL;
  87 }
  88
  89 /*
  90 ===================
  91 R_SplitEntityOnNode
  92 ===================
  93 */
  94 void R_SplitEntityOnNode (mnode_t *node)
  95 {
  96         efrag_t         *ef;
  97         mplane_t        *splitplane;
  98         mleaf_t         *leaf;
  99         int                     sides;
 100
 101         if (node->contents == CONTENTS_SOLID)
 102         {
 103                 return;
 104         }
 105
 106 // add an efrag if the node is a leaf
 107
 108         if ( node->contents < 0)
 109         {
 110                 if (!r_pefragtopnode)
 111                         r_pefragtopnode = node;
 112
 113                 leaf = (mleaf_t *)node;
 114
 115 // grab an efrag off the free list
 116                 ef = cl.free_efrags;
 117                 if (!ef)
 118                 {
 119                         Con_Printf ("Too many efrags!\n");
 120                         return;         // no free fragments...
 121                 }
 122                 cl.free_efrags = cl.free_efrags->entnext;
 123
 124                 ef->entity = r_addent;
 125
 126 // add the entity link
 127                 *lastlink = ef;
 128                 lastlink = &ef->entnext;
 129                 ef->entnext = NULL;
 130
 131 // set the leaf links
 132                 ef->leaf = leaf;
 133                 ef->leafnext = leaf->efrags;
 134                 leaf->efrags = ef;
 135
 136                 return;
 137         }
 138
 139 // NODE_MIXED
 140
 141         splitplane = node->plane;
 142         sides = BOX_ON_PLANE_SIDE(r_emins, r_emaxs, splitplane);
 143
 144         if (sides == 3)
 145         {
 146         // split on this plane
 147         // if this is the first splitter of this bmodel, remember it
 148                 if (!r_pefragtopnode)
 149                         r_pefragtopnode = node;
 150         }
 151
 152 // recurse down the contacted sides
 153         if (sides & 1)
 154                 R_SplitEntityOnNode (node->children[0]);
 155
 156         if (sides & 2)
 157                 R_SplitEntityOnNode (node->children[1]);
 158 }
 159
 160
 161
 162 /*
 163 ===========
 164 R_AddEfrags
 165 ===========
 166 */
 167 void R_AddEfrags (entity_t *ent)
 168 {
 169         model_t         *entmodel;
 170         int                     i;
 171
 172         if (!ent->model)
 173                 return;
 174
 175         r_addent = ent;
 176
 177         lastlink = &ent->efrag;
 178         r_pefragtopnode = NULL;
 179
 180         entmodel = ent->model;
 181
 182         for (i=0 ; i<3 ; i++)
 183         {
 184                 r_emins[i] = ent->origin[i] + entmodel->mins[i];
 185                 r_emaxs[i] = ent->origin[i] + entmodel->maxs[i];
 186         }
 187
 188         R_SplitEntityOnNode (cl.worldmodel->nodes);
 189
 190         ent->topnode = r_pefragtopnode;
 191 }
 192
 193
 194 /*
 195 ================
 196 R_StoreEfrags
 197
 198 // FIXME: a lot of this goes away with edge-based
 199 ================
 200 */
 201 void R_StoreEfrags (efrag_t **ppefrag)
 202 {
 203         entity_t        *pent;
 204         model_t         *clmodel;
 205         efrag_t         *pefrag;
 206
 207
 208         while ((pefrag = *ppefrag) != NULL)
 209         {
 210                 pent = pefrag->entity;
 211                 clmodel = pent->model;
 212
 213                 switch (clmodel->type)
 214                 {
 215                 case mod_alias:
 216                 case mod_brush:
 217                 case mod_sprite:
 218                         pent = pefrag->entity;
 219
 220                         if ((pent->visframe != r_framecount) &&
 221                                 (cl_numvisedicts < MAX_VISEDICTS))
 222                         {
 223                                 cl_visedicts[cl_numvisedicts++] = pent;
 224
 225                         // mark that we've recorded this entity for this frame
 226                                 pent->visframe = r_framecount;
 227                         }
 228
 229                         ppefrag = &pefrag->leafnext;
 230                         break;
 231
 232                 default:
 233                         Sys_Error ("R_StoreEfrags: Bad entity type %d\n", clmodel->type);
 234                 }
 235         }
 236 }
 237
 238