tools/quake3/q3map2/model.c

   1 /*\r
   2 Copyright (C) 1999-2007 id Software, Inc. and contributors.\r
   3 For a list of contributors, see the accompanying CONTRIBUTORS file.\r
   4 \r
   5 This file is part of GtkRadiant.\r
   6 \r
   7 GtkRadiant is free software; you can redistribute it and/or modify\r
   8 it under the terms of the GNU General Public License as published by\r
   9 the Free Software Foundation; either version 2 of the License, or\r
  10 (at your option) any later version.\r
  11 \r
  12 GtkRadiant is distributed in the hope that it will be useful,\r
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  15 GNU General Public License for more details.\r
  16 \r
  17 You should have received a copy of the GNU General Public License\r
  18 along with GtkRadiant; if not, write to the Free Software\r
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA\r
  20 \r
  21 ----------------------------------------------------------------------------------\r
  22 \r
  23 This code has been altered significantly from its original form, to support\r
  24 several games based on the Quake III Arena engine, in the form of "Q3Map2."\r
  25 \r
  26 ------------------------------------------------------------------------------- */\r
  27 \r
  28 \r
  29 \r
  30 /* marker */\r
  31 #define MODEL_C\r
  32 \r
  33 \r
  34 \r
  35 /* dependencies */\r
  36 #include "q3map2.h"\r
  37 \r
  38 \r
  39 \r
  40 /* \r
  41 PicoPrintFunc()\r
  42 callback for picomodel.lib\r
  43 */\r
  44 \r
  45 void PicoPrintFunc( int level, const char *str )\r
  46 {\r
  47         if( str == NULL )\r
  48                 return;\r
  49         switch( level )\r
  50         {\r
  51                 case PICO_NORMAL:\r
  52                         Sys_Printf( "%s\n", str );\r
  53                         break;\r
  54                 \r
  55                 case PICO_VERBOSE:\r
  56                         Sys_FPrintf( SYS_VRB, "%s\n", str );\r
  57                         break;\r
  58                 \r
  59                 case PICO_WARNING:\r
  60                         Sys_Printf( "WARNING: %s\n", str );\r
  61                         break;\r
  62                 \r
  63                 case PICO_ERROR:\r
  64                         Sys_Printf( "ERROR: %s\n", str );\r
  65                         break;\r
  66                 \r
  67                 case PICO_FATAL:\r
  68                         Error( "ERROR: %s\n", str );\r
  69                         break;\r
  70         }\r
  71 }\r
  72 \r
  73 \r
  74 \r
  75 /* \r
  76 PicoLoadFileFunc()\r
  77 callback for picomodel.lib\r
  78 */\r
  79 \r
  80 void PicoLoadFileFunc( char *name, byte **buffer, int *bufSize )\r
  81 {\r
  82         *bufSize = vfsLoadFile( (const char*) name, (void**) buffer, 0 );\r
  83 }\r
  84 \r
  85 \r
  86 \r
  87 /*\r
  88 FindModel() - ydnar\r
  89 finds an existing picoModel and returns a pointer to the picoModel_t struct or NULL if not found\r
  90 */\r
  91 \r
  92 picoModel_t *FindModel( char *name, int frame )\r
  93 {\r
  94         int                     i;\r
  95         \r
  96         \r
  97         /* init */\r
  98         if( numPicoModels <= 0 )\r
  99                 memset( picoModels, 0, sizeof( picoModels ) );\r
 100         \r
 101         /* dummy check */\r
 102         if( name == NULL || name[ 0 ] == '\0' )\r
 103                 return NULL;\r
 104         \r
 105         /* search list */\r
 106         for( i = 0; i < MAX_MODELS; i++ )\r
 107         {\r
 108                 if( picoModels[ i ] != NULL &&\r
 109                         !strcmp( PicoGetModelName( picoModels[ i ] ), name ) &&\r
 110                         PicoGetModelFrameNum( picoModels[ i ] ) == frame )\r
 111                         return picoModels[ i ];\r
 112         }\r
 113         \r
 114         /* no matching picoModel found */\r
 115         return NULL;\r
 116 }\r
 117 \r
 118 \r
 119 \r
 120 /*\r
 121 LoadModel() - ydnar\r
 122 loads a picoModel and returns a pointer to the picoModel_t struct or NULL if not found\r
 123 */\r
 124 \r
 125 picoModel_t *LoadModel( char *name, int frame )\r
 126 {\r
 127         int                             i;\r
 128         picoModel_t             *model, **pm;\r
 129         \r
 130         \r
 131         /* init */\r
 132         if( numPicoModels <= 0 )\r
 133                 memset( picoModels, 0, sizeof( picoModels ) );\r
 134         \r
 135         /* dummy check */\r
 136         if( name == NULL || name[ 0 ] == '\0' )\r
 137                 return NULL;\r
 138         \r
 139         /* try to find existing picoModel */\r
 140         model = FindModel( name, frame );\r
 141         if( model != NULL )\r
 142                 return model;\r
 143         \r
 144         /* none found, so find first non-null picoModel */\r
 145         pm = NULL;\r
 146         for( i = 0; i < MAX_MODELS; i++ )\r
 147         {\r
 148                 if( picoModels[ i ] == NULL )\r
 149                 {\r
 150                         pm = &picoModels[ i ];\r
 151                         break;\r
 152                 }\r
 153         }\r
 154         \r
 155         /* too many picoModels? */\r
 156         if( pm == NULL )\r
 157                 Error( "MAX_MODELS (%d) exceeded, there are too many model files referenced by the map.", MAX_MODELS );\r
 158         \r
 159         /* attempt to parse model */\r
 160         *pm = PicoLoadModel( (char*) name, frame );\r
 161         \r
 162         /* if loading failed, make a bogus model to silence the rest of the warnings */\r
 163         if( *pm == NULL )\r
 164         {\r
 165                 /* allocate a new model */\r
 166                 *pm = PicoNewModel();\r
 167                 if( *pm == NULL )\r
 168                         return NULL;\r
 169                 \r
 170                 /* set data */\r
 171                 PicoSetModelName( *pm, name );\r
 172                 PicoSetModelFrameNum( *pm, frame );\r
 173         }\r
 174         \r
 175         /* debug code */\r
 176         #if 0\r
 177         {\r
 178                 int                             numSurfaces, numVertexes;\r
 179                 picoSurface_t   *ps;\r
 180                 \r
 181                 \r
 182                 Sys_Printf( "Model %s\n", name );\r
 183                 numSurfaces = PicoGetModelNumSurfaces( *pm );\r
 184                 for( i = 0; i < numSurfaces; i++ )\r
 185                 {\r
 186                         ps = PicoGetModelSurface( *pm, i );\r
 187                         numVertexes = PicoGetSurfaceNumVertexes( ps );\r
 188                         Sys_Printf( "Surface %d has %d vertexes\n", i, numVertexes );\r
 189                 }\r
 190         }\r
 191         #endif\r
 192         \r
 193         /* set count */\r
 194         if( *pm != NULL )\r
 195                 numPicoModels++;\r
 196         \r
 197         /* return the picoModel */\r
 198         return *pm;\r
 199 }\r
 200 \r
 201 \r
 202 \r
 203 /*\r
 204 InsertModel() - ydnar\r
 205 adds a picomodel into the bsp\r
 206 */\r
 207 \r
 208 void InsertModel( char *name, int frame, m4x4_t transform, remap_t *remap, shaderInfo_t *celShader, int eNum, int castShadows, int recvShadows, int spawnFlags, float lightmapScale )\r
 209 {\r
 210         int                                     i, j, k, s, numSurfaces;\r
 211         m4x4_t                          identity, nTransform;\r
 212         picoModel_t                     *model;\r
 213         picoShader_t            *shader;\r
 214         picoSurface_t           *surface;\r
 215         shaderInfo_t            *si;\r
 216         mapDrawSurface_t        *ds;\r
 217         bspDrawVert_t           *dv;\r
 218         char                            *picoShaderName;\r
 219         char                            shaderName[ MAX_QPATH ];\r
 220         picoVec_t                       *xyz, *normal, *st;\r
 221         byte                            *color;\r
 222         picoIndex_t                     *indexes;\r
 223         remap_t                         *rm, *glob;\r
 224         \r
 225         \r
 226         /* get model */\r
 227         model = LoadModel( name, frame );\r
 228         if( model == NULL )\r
 229                 return;\r
 230         \r
 231         /* handle null matrix */\r
 232         if( transform == NULL )\r
 233         {\r
 234                 m4x4_identity( identity );\r
 235                 transform = identity;\r
 236         }\r
 237         \r
 238         /* hack: Stable-1_2 and trunk have differing row/column major matrix order\r
 239            this transpose is necessary with Stable-1_2\r
 240            uncomment the following line with old m4x4_t (non 1.3/spog_branch) code */\r
 241         //%     m4x4_transpose( transform );\r
 242         \r
 243         /* create transform matrix for normals */\r
 244         memcpy( nTransform, transform, sizeof( m4x4_t ) );\r
 245         if( m4x4_invert( nTransform ) )\r
 246                 Sys_FPrintf( SYS_VRB, "WARNING: Can't invert model transform matrix, using transpose instead\n" );\r
 247         m4x4_transpose( nTransform );\r
 248         \r
 249         /* fix bogus lightmap scale */\r
 250         if( lightmapScale <= 0.0f )\r
 251                 lightmapScale = 1.0f;\r
 252         \r
 253         /* each surface on the model will become a new map drawsurface */\r
 254         numSurfaces = PicoGetModelNumSurfaces( model );\r
 255         //%     Sys_FPrintf( SYS_VRB, "Model %s has %d surfaces\n", name, numSurfaces );\r
 256         for( s = 0; s < numSurfaces; s++ )\r
 257         {\r
 258                 /* get surface */\r
 259                 surface = PicoGetModelSurface( model, s );\r
 260                 if( surface == NULL )\r
 261                         continue;\r
 262                 \r
 263                 /* only handle triangle surfaces initially (fixme: support patches) */\r
 264                 if( PicoGetSurfaceType( surface ) != PICO_TRIANGLES )\r
 265                         continue;\r
 266                 \r
 267                 /* fix the surface's normals */\r
 268                 PicoFixSurfaceNormals( surface );\r
 269                 \r
 270                 /* allocate a surface (ydnar: gs mods) */\r
 271                 ds = AllocDrawSurface( SURFACE_TRIANGLES );\r
 272                 ds->entityNum = eNum;\r
 273                 ds->castShadows = castShadows;\r
 274                 ds->recvShadows = recvShadows;\r
 275                 \r
 276                 /* get shader name */\r
 277         shader = PicoGetSurfaceShader( surface );\r
 278                 if( shader == NULL )\r
 279                         picoShaderName = "";\r
 280                 else\r
 281                         picoShaderName = PicoGetShaderName( shader );\r
 282                 \r
 283                 /* handle shader remapping */\r
 284                 glob = NULL;\r
 285                 for( rm = remap; rm != NULL; rm = rm->next )\r
 286                 {\r
 287                         if( rm->from[ 0 ] == '*' && rm->from[ 1 ] == '\0' )\r
 288                                 glob = rm;\r
 289                         else if( !Q_stricmp( picoShaderName, rm->from ) )\r
 290                         {\r
 291                                 Sys_FPrintf( SYS_VRB, "Remapping %s to %s\n", picoShaderName, rm->to );\r
 292                                 picoShaderName = rm->to;\r
 293                                 glob = NULL;\r
 294                                 break;\r
 295                         }\r
 296                 }\r
 297                 \r
 298                 if( glob != NULL )\r
 299                 {\r
 300                         Sys_FPrintf( SYS_VRB, "Globbing %s to %s\n", picoShaderName, glob->to );\r
 301                         picoShaderName = glob->to;\r
 302                 }\r
 303                 \r
 304                 /* shader renaming for sof2 */\r
 305                 if( renameModelShaders )\r
 306                 {\r
 307                         strcpy( shaderName, picoShaderName );\r
 308                         StripExtension( shaderName );\r
 309                         if( spawnFlags & 1 )\r
 310                                 strcat( shaderName, "_RMG_BSP" );\r
 311                         else\r
 312                                 strcat( shaderName, "_BSP" );\r
 313                         si = ShaderInfoForShader( shaderName );\r
 314                 }\r
 315                 else\r
 316                         si = ShaderInfoForShader( picoShaderName );\r
 317                 \r
 318                 /* set shader */\r
 319                 ds->shaderInfo = si;\r
 320                 \r
 321                 /* set lightmap scale */\r
 322                 ds->lightmapScale = lightmapScale;\r
 323                 \r
 324                 /* force to meta? */\r
 325                 if( si != NULL && si->forceMeta )\r
 326                         ds->type = SURFACE_FORCED_META;\r
 327                 \r
 328                 /* set particulars */\r
 329                 ds->numVerts = PicoGetSurfaceNumVertexes( surface );\r
 330                 ds->verts = safe_malloc( ds->numVerts * sizeof( ds->verts[ 0 ] ) );\r
 331                 memset( ds->verts, 0, ds->numVerts * sizeof( ds->verts[ 0 ] ) );\r
 332                 \r
 333                 ds->numIndexes = PicoGetSurfaceNumIndexes( surface );\r
 334                 ds->indexes = safe_malloc( ds->numIndexes * sizeof( ds->indexes[ 0 ] ) );\r
 335                 memset( ds->indexes, 0, ds->numIndexes * sizeof( ds->indexes[ 0 ] ) );\r
 336                 \r
 337                 /* copy vertexes */\r
 338                 for( i = 0; i < ds->numVerts; i++ )\r
 339                 {\r
 340                         /* get vertex */\r
 341                         dv = &ds->verts[ i ];\r
 342                         \r
 343                         /* xyz and normal */\r
 344                         xyz = PicoGetSurfaceXYZ( surface, i );\r
 345                         VectorCopy( xyz, dv->xyz );\r
 346                         m4x4_transform_point( transform, dv->xyz );\r
 347                         \r
 348                         normal = PicoGetSurfaceNormal( surface, i );\r
 349                         VectorCopy( normal, dv->normal );\r
 350                         m4x4_transform_normal( nTransform, dv->normal );\r
 351                         VectorNormalize( dv->normal, dv->normal );\r
 352 \r
 353                         /* ydnar: tek-fu celshading support for flat shaded shit */\r
 354                         if( flat )\r
 355                         {\r
 356                                 dv->st[ 0 ] = si->stFlat[ 0 ];\r
 357                                 dv->st[ 1 ] = si->stFlat[ 1 ];\r
 358                         }\r
 359                         \r
 360                         /* ydnar: gs mods: added support for explicit shader texcoord generation */\r
 361                         else if( si->tcGen )\r
 362                         {\r
 363                                 /* project the texture */\r
 364                                 dv->st[ 0 ] = DotProduct( si->vecs[ 0 ], dv->xyz );\r
 365                                 dv->st[ 1 ] = DotProduct( si->vecs[ 1 ], dv->xyz );\r
 366                         }\r
 367                         \r
 368                         /* normal texture coordinates */\r
 369                         {\r
 370                                 st = PicoGetSurfaceST( surface, 0, i );\r
 371                                 dv->st[ 0 ] = st[ 0 ];\r
 372                                 dv->st[ 1 ] = st[ 1 ];\r
 373                         }\r
 374                         \r
 375                         /* set lightmap/color bits */\r
 376                         color = PicoGetSurfaceColor( surface, 0, i );\r
 377                         for( j = 0; j < MAX_LIGHTMAPS; j++ )\r
 378                         {\r
 379                                 dv->lightmap[ j ][ 0 ] = 0.0f;\r
 380                                 dv->lightmap[ j ][ 1 ] = 0.0f;\r
 381                                 dv->color[ j ][ 0 ] = color[ 0 ];\r
 382                                 dv->color[ j ][ 1 ] = color[ 1 ];\r
 383                                 dv->color[ j ][ 2 ] = color[ 2 ];\r
 384                                 dv->color[ j ][ 3 ] = color[ 3 ];\r
 385                         }\r
 386                 }\r
 387                 \r
 388                 /* copy indexes */\r
 389                 indexes = PicoGetSurfaceIndexes( surface, 0 );\r
 390                 for( i = 0; i < ds->numIndexes; i++ )\r
 391                         ds->indexes[ i ] = indexes[ i ];\r
 392                 \r
 393                 /* set cel shader */\r
 394                 ds->celShader = celShader;\r
 395                 \r
 396                 /* finish surface */\r
 397                 FinishSurface( ds );\r
 398                 \r
 399                 /* ydnar: giant hack land: generate clipping brushes for model triangles */\r
 400                 if( si->clipModel || (spawnFlags & 2) ) /* 2nd bit */\r
 401                 {\r
 402                         vec3_t          points[ 3 ], backs[ 3 ];\r
 403                         vec4_t          plane, reverse, pa, pb, pc;\r
 404                         vec3_t          nadir;\r
 405                         \r
 406                         \r
 407                         /* temp hack */\r
 408                         if( (si->compileFlags & C_TRANSLUCENT) || !(si->compileFlags & C_SOLID) )\r
 409                                 continue;\r
 410                         \r
 411                         /* overflow check */\r
 412                         if( (nummapplanes + 64) >= (MAX_MAP_PLANES >> 1) )\r
 413                                 continue;\r
 414                         \r
 415                         /* walk triangle list */\r
 416                         for( i = 0; i < ds->numIndexes; i += 3 )\r
 417                         {\r
 418                                 /* overflow hack */\r
 419                                 if( (nummapplanes + 64) >= (MAX_MAP_PLANES >> 1) )\r
 420                                 {\r
 421                                         Sys_Printf( "WARNING: MAX_MAP_PLANES (%d) hit generating clip brushes for model %s.\n",\r
 422                                                 MAX_MAP_PLANES, name );\r
 423                                         break;\r
 424                                 }\r
 425                                 \r
 426                                 /* make points and back points */\r
 427                                 for( j = 0; j < 3; j++ )\r
 428                                 {\r
 429                                         /* get vertex */\r
 430                                         dv = &ds->verts[ ds->indexes[ i + j ] ];\r
 431                                         \r
 432                                         /* copy xyz */\r
 433                                         VectorCopy( dv->xyz, points[ j ] );\r
 434                                         VectorCopy( dv->xyz, backs[ j ] );\r
 435                                         \r
 436                                         /* find nearest axial to normal and push back points opposite */\r
 437                                         /* note: this doesn't work as well as simply using the plane of the triangle, below */\r
 438                                         for( k = 0; k < 3; k++ )\r
 439                                         {\r
 440                                                 if( fabs( dv->normal[ k ] ) > fabs( dv->normal[ (k + 1) % 3 ] ) &&\r
 441                                                         fabs( dv->normal[ k ] ) > fabs( dv->normal[ (k + 2) % 3 ] ) )\r
 442                                                 {\r
 443                                                         backs[ j ][ k ] += dv->normal[ k ] < 0.0f ? 64.0f : -64.0f;\r
 444                                                         break;\r
 445                                                 }\r
 446                                         }\r
 447                                 }\r
 448                                 \r
 449                                 /* make plane for triangle */\r
 450                                 if( PlaneFromPoints( plane, points[ 0 ], points[ 1 ], points[ 2 ] ) )\r
 451                                 {\r
 452                                         /* regenerate back points */\r
 453                                         for( j = 0; j < 3; j++ )\r
 454                                         {\r
 455                                                 /* get vertex */\r
 456                                                 dv = &ds->verts[ ds->indexes[ i + j ] ];\r
 457                                                 \r
 458                                                 /* copy xyz */\r
 459                                                 VectorCopy( dv->xyz, backs[ j ] );\r
 460                                                 \r
 461                                                 /* find nearest axial to plane normal and push back points opposite */\r
 462                                                 for( k = 0; k < 3; k++ )\r
 463                                                 {\r
 464                                                         if( fabs( plane[ k ] ) > fabs( plane[ (k + 1) % 3 ] ) &&\r
 465                                                                 fabs( plane[ k ] ) > fabs( plane[ (k + 2) % 3 ] ) )\r
 466                                                         {\r
 467                                                                 backs[ j ][ k ] += plane[ k ] < 0.0f ? 64.0f : -64.0f;\r
 468                                                                 break;\r
 469                                                         }\r
 470                                                 }\r
 471                                         }\r
 472                                         \r
 473                                         /* make back plane */\r
 474                                         VectorScale( plane, -1.0f, reverse );\r
 475                                         reverse[ 3 ] = -(plane[ 3 ] - 1);\r
 476                                         \r
 477                                         /* make back pyramid point */\r
 478                                         VectorCopy( points[ 0 ], nadir );\r
 479                                         VectorAdd( nadir, points[ 1 ], nadir );\r
 480                                         VectorAdd( nadir, points[ 2 ], nadir );\r
 481                                         VectorScale( nadir, 0.3333333333333f, nadir );\r
 482                                         VectorMA( nadir, -2.0f, plane, nadir );\r
 483                                         \r
 484                                         /* make 3 more planes */\r
 485                                         //%     if( PlaneFromPoints( pa, points[ 2 ], points[ 1 ], nadir ) &&\r
 486                                         //%             PlaneFromPoints( pb, points[ 1 ], points[ 0 ], nadir ) &&\r
 487                                         //%             PlaneFromPoints( pc, points[ 0 ], points[ 2 ], nadir ) )\r
 488                                         if( PlaneFromPoints( pa, points[ 2 ], points[ 1 ], backs[ 1 ] ) &&\r
 489                                                 PlaneFromPoints( pb, points[ 1 ], points[ 0 ], backs[ 0 ] ) &&\r
 490                                                 PlaneFromPoints( pc, points[ 0 ], points[ 2 ], backs[ 2 ] ) )\r
 491                                         {\r
 492                                                 /* build a brush */\r
 493                                                 buildBrush = AllocBrush( 48 );\r
 494                                                 \r
 495                                                 buildBrush->entityNum = mapEntityNum;\r
 496                                                 buildBrush->original = buildBrush;\r
 497                                                 buildBrush->contentShader = si;\r
 498                                                 buildBrush->compileFlags = si->compileFlags;\r
 499                                                 buildBrush->contentFlags = si->contentFlags;\r
 500                                                 buildBrush->detail = qtrue;\r
 501                                                 \r
 502                                                 /* set up brush sides */\r
 503                                                 buildBrush->numsides = 5;\r
 504                                                 for( j = 0; j < buildBrush->numsides; j++ )\r
 505                                                         buildBrush->sides[ j ].shaderInfo = si;\r
 506                                                 buildBrush->sides[ 0 ].planenum = FindFloatPlane( plane, plane[ 3 ], 3, points );\r
 507                                                 buildBrush->sides[ 1 ].planenum = FindFloatPlane( pa, pa[ 3 ], 1, &points[ 2 ] );\r
 508                                                 buildBrush->sides[ 2 ].planenum = FindFloatPlane( pb, pb[ 3 ], 1, &points[ 1 ] );\r
 509                                                 buildBrush->sides[ 3 ].planenum = FindFloatPlane( pc, pc[ 3 ], 1, &points[ 0 ] );\r
 510                                                 buildBrush->sides[ 4 ].planenum = FindFloatPlane( reverse, reverse[ 3 ], 3, points );\r
 511                                                 \r
 512                                                 /* add to entity */\r
 513                                                 if( CreateBrushWindings( buildBrush ) )\r
 514                                                 {\r
 515                                                         AddBrushBevels();\r
 516                                                         //%     EmitBrushes( buildBrush, NULL, NULL );\r
 517                                                         buildBrush->next = entities[ mapEntityNum ].brushes;\r
 518                                                         entities[ mapEntityNum ].brushes = buildBrush;\r
 519                                                         entities[ mapEntityNum ].numBrushes++;\r
 520                                                 }\r
 521                                                 else\r
 522                                                         free( buildBrush );\r
 523                                         }\r
 524                                 }\r
 525                         }\r
 526                 }\r
 527         }\r
 528 }\r
 529 \r
 530 \r
 531 \r
 532 /*\r
 533 AddTriangleModels()\r
 534 adds misc_model surfaces to the bsp\r
 535 */\r
 536 \r
 537 void AddTriangleModels( entity_t *e )\r
 538 {\r
 539         int                             num, frame, castShadows, recvShadows, spawnFlags;\r
 540         entity_t                *e2;\r
 541         const char              *targetName;\r
 542         const char              *target, *model, *value;\r
 543         char                    shader[ MAX_QPATH ];\r
 544         shaderInfo_t    *celShader;\r
 545         float                   temp, baseLightmapScale, lightmapScale;\r
 546         vec3_t                  origin, scale, angles;\r
 547         m4x4_t                  transform;\r
 548         epair_t                 *ep;\r
 549         remap_t                 *remap, *remap2;\r
 550         char                    *split;\r
 551         \r
 552         \r
 553         /* note it */\r
 554         Sys_FPrintf( SYS_VRB, "--- AddTriangleModels ---\n" );\r
 555         \r
 556         /* get current brush entity targetname */\r
 557         if( e == entities )\r
 558                 targetName = "";\r
 559         else\r
 560         {\r
 561                 targetName = ValueForKey( e, "targetname" );\r
 562         \r
 563                 /* misc_model entities target non-worldspawn brush model entities */\r
 564                 if( targetName[ 0 ] == '\0' )\r
 565                         return;\r
 566         }\r
 567         \r
 568         /* get lightmap scale */\r
 569         baseLightmapScale = FloatForKey( e, "_lightmapscale" );\r
 570         if( baseLightmapScale <= 0.0f )\r
 571                 baseLightmapScale = 0.0f;\r
 572         \r
 573         /* walk the entity list */\r
 574         for( num = 1; num < numEntities; num++ )\r
 575         {\r
 576                 /* get e2 */\r
 577                 e2 = &entities[ num ];\r
 578                 \r
 579                 /* convert misc_models into raw geometry */\r
 580                 if( Q_stricmp( "misc_model", ValueForKey( e2, "classname" ) ) )\r
 581                         continue;\r
 582 \r
 583                 /* ydnar: added support for md3 models on non-worldspawn models */\r
 584                 target = ValueForKey( e2, "target" );\r
 585                 if( strcmp( target, targetName ) )\r
 586                         continue;\r
 587                 \r
 588                 /* get model name */\r
 589                 model = ValueForKey( e2, "model" );\r
 590                 if( model[ 0 ] == '\0' )\r
 591                 {\r
 592                         Sys_Printf( "WARNING: misc_model at %i %i %i without a model key\n",\r
 593                                 (int) origin[ 0 ], (int) origin[ 1 ], (int) origin[ 2 ] );\r
 594                         continue;\r
 595                 }\r
 596                 \r
 597                 /* get model frame */\r
 598                 frame = IntForKey( e2, "_frame" );\r
 599                 \r
 600                 /* worldspawn (and func_groups) default to cast/recv shadows in worldspawn group */\r
 601                 if( e == entities )\r
 602                 {\r
 603                         castShadows = WORLDSPAWN_CAST_SHADOWS;\r
 604                         recvShadows = WORLDSPAWN_RECV_SHADOWS;\r
 605                 }\r
 606                 \r
 607                 /* other entities don't cast any shadows, but recv worldspawn shadows */\r
 608                 else\r
 609                 {\r
 610                         castShadows = ENTITY_CAST_SHADOWS;\r
 611                         recvShadows = ENTITY_RECV_SHADOWS;\r
 612                 }\r
 613                 \r
 614                 /* get explicit shadow flags */\r
 615                 GetEntityShadowFlags( e2, e, &castShadows, &recvShadows );\r
 616                 \r
 617                 /* get spawnflags */\r
 618                 spawnFlags = IntForKey( e2, "spawnflags" );\r
 619                 \r
 620                 /* get origin */\r
 621                 GetVectorForKey( e2, "origin", origin );\r
 622                 VectorSubtract( origin, e->origin, origin );    /* offset by parent */\r
 623                 \r
 624                 /* get scale */\r
 625                 scale[ 0 ] = scale[ 1 ] = scale[ 2 ] = 1.0f;\r
 626                 temp = FloatForKey( e2, "modelscale" );\r
 627                 if( temp != 0.0f )\r
 628                         scale[ 0 ] = scale[ 1 ] = scale[ 2 ] = temp;\r
 629                 value = ValueForKey( e2, "modelscale_vec" );\r
 630                 if( value[ 0 ] != '\0' )\r
 631                         sscanf( value, "%f %f %f", &scale[ 0 ], &scale[ 1 ], &scale[ 2 ] );\r
 632                 \r
 633                 /* get "angle" (yaw) or "angles" (pitch yaw roll) */\r
 634                 angles[ 0 ] = angles[ 1 ] = angles[ 2 ] = 0.0f;\r
 635                 angles[ 2 ] = FloatForKey( e2, "angle" );\r
 636                 value = ValueForKey( e2, "angles" );\r
 637                 if( value[ 0 ] != '\0' )\r
 638                         sscanf( value, "%f %f %f", &angles[ 1 ], &angles[ 2 ], &angles[ 0 ] );\r
 639                 \r
 640                 /* set transform matrix (thanks spog) */\r
 641                 m4x4_identity( transform );\r
 642                 m4x4_pivoted_transform_by_vec3( transform, origin, angles, eXYZ, scale, vec3_origin );\r
 643                 \r
 644                 /* get shader remappings */\r
 645                 remap = NULL;\r
 646                 for( ep = e2->epairs; ep != NULL; ep = ep->next )\r
 647                 {\r
 648                         /* look for keys prefixed with "_remap" */\r
 649                         if( ep->key != NULL && ep->value != NULL &&\r
 650                                 ep->key[ 0 ] != '\0' && ep->value[ 0 ] != '\0' &&\r
 651                                 !Q_strncasecmp( ep->key, "_remap", 6 ) )\r
 652                         {\r
 653                                 /* create new remapping */\r
 654                                 remap2 = remap;\r
 655                                 remap = safe_malloc( sizeof( *remap ) );\r
 656                                 remap->next = remap2;\r
 657                                 strcpy( remap->from, ep->value );\r
 658                                 \r
 659                                 /* split the string */\r
 660                                 split = strchr( remap->from, ';' );\r
 661                                 if( split == NULL )\r
 662                                 {\r
 663                                         Sys_Printf( "WARNING: Shader _remap key found in misc_model without a ; character\n" );\r
 664                                         free( remap );\r
 665                                         remap = remap2;\r
 666                                         continue;\r
 667                                 }\r
 668                                 \r
 669                                 /* store the split */\r
 670                                 *split = '\0';\r
 671                                 strcpy( remap->to, (split + 1) );\r
 672                                 \r
 673                                 /* note it */\r
 674                                 //%     Sys_FPrintf( SYS_VRB, "Remapping %s to %s\n", remap->from, remap->to );\r
 675                         }\r
 676                 }\r
 677                 \r
 678                 /* ydnar: cel shader support */\r
 679                 value = ValueForKey( e2, "_celshader" );\r
 680                 if( value[ 0 ] == '\0' )\r
 681                         value = ValueForKey( &entities[ 0 ], "_celshader" );\r
 682                 if( value[ 0 ] != '\0' )\r
 683                 {\r
 684                         sprintf( shader, "textures/%s", value );\r
 685                         celShader = ShaderInfoForShader( shader );\r
 686                 }\r
 687                 else\r
 688                         celShader = NULL;\r
 689                 \r
 690                 /* get lightmap scale */\r
 691                 lightmapScale = FloatForKey( e2, "_lightmapscale" );\r
 692                 if( lightmapScale <= 0.0f )\r
 693                         lightmapScale = baseLightmapScale;\r
 694                 \r
 695                 /* insert the model */\r
 696                 InsertModel( (char*) model, frame, transform, remap, celShader, mapEntityNum, castShadows, recvShadows, spawnFlags, lightmapScale );\r
 697                 \r
 698                 /* free shader remappings */\r
 699                 while( remap != NULL )\r
 700                 {\r
 701                         remap2 = remap->next;\r
 702                         free( remap );\r
 703                         remap = remap2;\r
 704                 }\r
 705         }\r
 706 }\r