model_shared.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20 // models.c -- model loading and caching
  21
  22 // models are the only shared resource between a client and server running
  23 // on the same machine.
  24
  25 #include "quakedef.h"
  26
  27 model_t *loadmodel;
  28 char    loadname[32];   // for hunk tags
  29
  30 void Mod_LoadSpriteModel (model_t *mod, void *buffer);
  31 void Mod_LoadBrushModel (model_t *mod, void *buffer);
  32 void Mod_LoadAliasModel (model_t *mod, void *buffer);
  33 void Mod_LoadQ2AliasModel (model_t *mod, void *buffer);
  34 model_t *Mod_LoadModel (model_t *mod, qboolean crash);
  35
  36 #define MAX_MOD_KNOWN   512
  37 model_t mod_known[MAX_MOD_KNOWN];
  38 int             mod_numknown;
  39
  40 extern void Mod_BrushInit();
  41 extern void Mod_AliasInit();
  42 extern void Mod_SpriteInit();
  43
  44 /*
  45 ===============
  46 Mod_Init
  47 ===============
  48 */
  49 void Mod_Init (void)
  50 {
  51         Mod_BrushInit();
  52         Mod_AliasInit();
  53         Mod_SpriteInit();
  54 }
  55
  56 /*
  57 ===============
  58 Mod_Init
  59
  60 Caches the data if needed
  61 ===============
  62 */
  63 void *Mod_Extradata (model_t *mod)
  64 {
  65         void    *r;
  66
  67         r = Cache_Check (&mod->cache);
  68         if (r)
  69                 return r;
  70
  71         Mod_LoadModel (mod, true);
  72
  73         if (!mod->cache.data)
  74                 Host_Error ("Mod_Extradata: caching failed");
  75         return mod->cache.data;
  76 }
  77
  78 /*
  79 ===================
  80 Mod_ClearAll
  81 ===================
  82 */
  83 void Mod_ClearAll (void)
  84 {
  85         int             i;
  86         model_t *mod;
  87
  88         for (i=0 , mod=mod_known ; i<mod_numknown ; i++, mod++)
  89                 if (mod->type != mod_alias)
  90                         mod->needload = true;
  91 }
  92
  93 /*
  94 ==================
  95 Mod_FindName
  96
  97 ==================
  98 */
  99 model_t *Mod_FindName (char *name)
 100 {
 101         int             i;
 102         model_t *mod;
 103
 104         if (!name[0])
 105                 Host_Error ("Mod_ForName: NULL name");
 106
 107 //
 108 // search the currently loaded models
 109 //
 110         for (i=0 , mod=mod_known ; i<mod_numknown ; i++, mod++)
 111                 if (!strcmp (mod->name, name) )
 112                         break;
 113
 114         if (i == mod_numknown)
 115         {
 116                 if (mod_numknown == MAX_MOD_KNOWN)
 117                         Host_Error ("mod_numknown == MAX_MOD_KNOWN");
 118                 strcpy (mod->name, name);
 119                 mod->needload = true;
 120                 mod_numknown++;
 121         }
 122
 123         return mod;
 124 }
 125
 126 /*
 127 ==================
 128 Mod_TouchModel
 129
 130 ==================
 131 */
 132 void Mod_TouchModel (char *name)
 133 {
 134         model_t *mod;
 135
 136         mod = Mod_FindName (name);
 137
 138         if (!mod->needload)
 139         {
 140                 if (mod->type == mod_alias)
 141                         Cache_Check (&mod->cache);
 142         }
 143 }
 144
 145 /*
 146 ==================
 147 Mod_LoadModel
 148
 149 Loads a model into the cache
 150 ==================
 151 */
 152 model_t *Mod_LoadModel (model_t *mod, qboolean crash)
 153 {
 154         void    *d;
 155         unsigned *buf;
 156
 157         if (!mod->needload)
 158         {
 159                 if (mod->type == mod_alias)
 160                 {
 161                         d = Cache_Check (&mod->cache);
 162                         if (d)
 163                                 return mod;
 164                 }
 165                 else
 166                         return mod;             // not cached at all
 167         }
 168
 169         Con_DPrintf("loading model %s\n", mod->name);
 170
 171 // load the file
 172         buf = (unsigned *)COM_LoadMallocFile (mod->name, false);
 173         if (!buf)
 174         {
 175                 if (crash)
 176                         Host_Error ("Mod_NumForName: %s not found", mod->name); // LordHavoc: Sys_Error was *ANNOYING*
 177                 return NULL;
 178         }
 179
 180 // allocate a new model
 181         COM_FileBase (mod->name, loadname);
 182
 183         loadmodel = mod;
 184
 185 // call the apropriate loader
 186         mod->needload = false;
 187
 188         switch (LittleLong(*(unsigned *)buf))
 189         {
 190         case IDPOLYHEADER:
 191                 Mod_LoadAliasModel (mod, buf);
 192                 break;
 193
 194         case MD2IDALIASHEADER: // LordHavoc: added Quake2 model support
 195                 Mod_LoadQ2AliasModel (mod, buf);
 196                 break;
 197
 198         case IDSPRITEHEADER:
 199                 Mod_LoadSpriteModel (mod, buf);
 200                 break;
 201
 202         default:
 203                 Mod_LoadBrushModel (mod, buf);
 204                 break;
 205         }
 206         qfree(buf);
 207
 208         return mod;
 209 }
 210
 211 /*
 212 ==================
 213 Mod_ForName
 214
 215 Loads in a model for the given name
 216 ==================
 217 */
 218 model_t *Mod_ForName (char *name, qboolean crash)
 219 {
 220         model_t *mod;
 221
 222         mod = Mod_FindName (name);
 223
 224         return Mod_LoadModel (mod, crash);
 225 }
 226
 227 byte    *mod_base;
 228
 229 /*
 230 =================
 231 RadiusFromBounds
 232 =================
 233 */
 234 float RadiusFromBounds (vec3_t mins, vec3_t maxs)
 235 {
 236         int             i;
 237         vec3_t  corner;
 238
 239         for (i=0 ; i<3 ; i++)
 240                 corner[i] = fabs(mins[i]) > fabs(maxs[i]) ? fabs(mins[i]) : fabs(maxs[i]);
 241
 242         return Length (corner);
 243 }
 244
 245 //=============================================================================
 246
 247 /*
 248 ================
 249 Mod_Print
 250 ================
 251 */
 252 void Mod_Print (void)
 253 {
 254         int             i;
 255         model_t *mod;
 256
 257         Con_Printf ("Cached models:\n");
 258         for (i=0, mod=mod_known ; i < mod_numknown ; i++, mod++)
 259         {
 260                 Con_Printf ("%8p : %s\n",mod->cache.data, mod->name);
 261         }
 262 }
 263
 264