tools/quake3/q3data/md3lib.c

   1 #include <assert.h>
   2 #ifdef _WIN32
   3 #include <io.h>
   4 #endif
   5 #include "md3lib.h"
   6
   7 #if defined (__linux__) || defined (__APPLE__)
   8 #define filelength Q_filelength
   9 #endif
  10
  11 /*
  12 ** MD3_ComputeTagFromTri
  13 */
  14 void MD3_ComputeTagFromTri( md3Tag_t *pTag, const float pTri[3][3] )
  15 {
  16         float   len[3];
  17         vec3_t  axes[3], sides[3];
  18         int             longestSide, shortestSide, hypotSide;
  19         int             origin;
  20         int             j;
  21         float   d;
  22
  23         memset( axes, 0, sizeof( axes ) );
  24         memset( sides, 0, sizeof( sides ) );
  25
  26         //
  27         // compute sides
  28         //
  29         for ( j = 0; j < 3; j++ )
  30         {
  31                 sides[j][0] = pTri[(j+1)%3][0] - pTri[j][0];
  32                 sides[j][1] = pTri[(j+1)%3][1] - pTri[j][1];
  33                 sides[j][2] = pTri[(j+1)%3][2] - pTri[j][2];
  34
  35                 len[j] = ( float ) sqrt( DotProduct( sides[j], sides[j] ) );
  36         }
  37
  38 #if 0
  39         if ( len[0] > len[1] && len[0] > len[2] )
  40         {
  41                 longestSide = 0; shortestSide = 1; origin = 2;
  42         }
  43         else if ( len[1] > len[0] && len[1] > len[2] )
  44         {
  45                 longestSide = 1; shortestSide = 2; origin = 0;
  46         }
  47         else if ( len[2] > len[0] && len[2] > len[1] )
  48         {
  49                 longestSide = 2; shortestSide = 0; origin = 1;
  50         }
  51         else
  52         {
  53                 Error( "invalid tag triangle, must be a right triangle with unequal length sides" );
  54         }
  55 #endif
  56         if ( len[0] > len[1] && len[0] > len[2] ) {
  57                 hypotSide = 0;
  58                 origin = 2;
  59         } else if ( len[1] > len[0] && len[1] > len[2] ) {
  60                 hypotSide = 1;
  61                 origin = 0;
  62         } else if ( len[2] > len[0] && len[2] > len[1] ) {
  63                 hypotSide = 2;
  64                 origin = 1;
  65         }
  66         len[hypotSide] = -1;
  67
  68         if ( len[0] > len[1] && len[0] > len[2] ) {
  69                 longestSide = 0;
  70         } else if ( len[1] > len[0] && len[1] > len[2] ) {
  71                 longestSide = 1;
  72         } else if ( len[2] > len[0] && len[2] > len[1] ) {
  73                 longestSide = 2;
  74         }
  75         len[longestSide] = -1;
  76
  77         if ( len[0] > len[1] && len[0] > len[2] ) {
  78                 shortestSide = 0;
  79         } else if ( len[1] > len[0] && len[1] > len[2] ) {
  80                 shortestSide = 1;
  81         } else if ( len[2] > len[0] && len[2] > len[1] ) {
  82                 shortestSide = 2;
  83         }
  84         len[shortestSide] = -1;
  85
  86
  87
  88 //      VectorNormalize( sides[shortestSide], axes[0] );
  89 //      VectorNormalize( sides[longestSide], axes[1] );
  90         VectorNormalize( sides[longestSide], axes[0] );
  91         VectorNormalize( sides[shortestSide], axes[1] );
  92
  93         // project shortest side so that it is exactly 90 degrees to the longer side
  94         d = DotProduct( axes[0], axes[1] );
  95         VectorMA( axes[0], -d, axes[1], axes[0] );
  96         VectorNormalize( axes[0], axes[0] );
  97
  98         CrossProduct( sides[longestSide], sides[shortestSide], axes[2] );
  99         VectorNormalize( axes[2], axes[2] );
 100
 101         pTag->origin[0] = pTri[origin][0];
 102         pTag->origin[1] = pTri[origin][1];
 103         pTag->origin[2] = pTri[origin][2];
 104
 105         VectorCopy( axes[0], pTag->axis[0] );
 106         VectorCopy( axes[1], pTag->axis[1] );
 107         VectorCopy( axes[2], pTag->axis[2] );
 108 }
 109
 110 /*
 111 ==============
 112 MD3_Dump
 113 ==============
 114 */
 115 void MD3_Dump( const char *filename )
 116 {
 117         md3Header_t header;
 118         md3Tag_t *pTag;
 119         md3Surface_t *pSurface;
 120         FILE *fp;
 121         void *_buffer;
 122         void *buffer;
 123         long fileSize;
 124         int i;
 125
 126         if ( ( fp = fopen( filename, "rb" ) ) == 0 )
 127         {
 128                 Error( "Unable to open '%s'\n", filename );
 129         }
 130
 131         fileSize = filelength( fileno( fp ) );
 132         _buffer = malloc( filelength( fileno( fp ) ) );
 133         fread( _buffer, fileSize, 1, fp );
 134         fclose( fp );
 135
 136         buffer = ( char * ) _buffer;
 137         header = *( md3Header_t * ) _buffer;
 138
 139         if ( header.ident != MD3_IDENT )
 140         {
 141                 Error( "Incorrect ident for '%s'\n", filename );
 142         }
 143
 144         printf( "Contents of '%s'\n", filename );
 145         printf( "  version:        %d\n", header.version );
 146         printf( "  name:           %s\n", header.name );
 147         printf( "  num frames:     %d\n", header.numFrames );
 148         printf( "  num tags:       %d\n", header.numTags );
 149         printf( "  num surfaces:   %d\n", header.numSurfaces );
 150         printf( "  num skins:      %d\n", header.numSkins );
 151         printf( "  file size:      %d\n", fileSize );
 152
 153         printf( "--- TAGS ---\n" );
 154         pTag = ( md3Tag_t * ) ( ( ( char * ) buffer ) + header.ofsTags );
 155         for ( i = 0; i < header.numTags; i++, pTag++ )
 156         {
 157                 printf( "  tag %d ('%s')\n", i, pTag->name );
 158                 printf( "    origin: %f,%f,%f\n", pTag->origin[0], pTag->origin[1], pTag->origin[2] );
 159                 printf( "        vf: %f,%f,%f\n", pTag->axis[0][0], pTag->axis[0][1], pTag->axis[0][2] );
 160                 printf( "        vr: %f,%f,%f\n", pTag->axis[1][0], pTag->axis[1][1], pTag->axis[1][2] );
 161                 printf( "        vu: %f,%f,%f\n", pTag->axis[2][0], pTag->axis[2][1], pTag->axis[2][2] );
 162         }
 163
 164         printf( "--- SURFACES ---\n" );
 165         pSurface = ( md3Surface_t * ) ( ( ( char * ) buffer ) + header.ofsSurfaces );
 166
 167         for ( i = 0; i < header.numSurfaces; i++ )
 168         {
 169                 int j;
 170
 171                 md3Shader_t *pShader = ( md3Shader_t * ) ( ( ( char * ) pSurface ) + pSurface->ofsShaders );
 172
 173                 printf( "\n  surface %d ('%s')\n", i, pSurface->name );
 174                 printf( "    num frames: %d\n", pSurface->numFrames );
 175                 printf( "    num shaders: %d\n", pSurface->numShaders );
 176                 printf( "    num tris: %d\n", pSurface->numTriangles );
 177                 printf( "    num verts: %d\n", pSurface->numVerts );
 178
 179                 if ( pSurface->numShaders > 0 )
 180                 {
 181                         printf( "    --- SHADERS ---\n" );
 182
 183                         for ( j = 0; j < pSurface->numShaders; j++, pShader++ )
 184                         {
 185                                 printf( "    shader %d ('%s')\n", j, pShader->name );
 186                         }
 187                 }
 188                 pSurface = ( md3Surface_t * ) ( ( ( char * ) pSurface ) + pSurface->ofsEnd );
 189         }
 190
 191         free( _buffer );
 192 }
 193