plugins/md3model/md3.cpp

   1 /*
   2 Copyright (C) 2001-2006, William Joseph.
   3 All Rights Reserved.
   4
   5 This file is part of GtkRadiant.
   6
   7 GtkRadiant is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 GtkRadiant is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GtkRadiant; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20 */
  21
  22 #include "md3.h"
  23
  24 #include "ifilesystem.h"
  25 #include "imodel.h"
  26
  27 #include "imagelib.h"
  28 #include "bytestreamutils.h"
  29
  30 #include "model.h"
  31 #include "ident.h"
  32 #include "md3normals.h"
  33
  34 // the maximum size of game reletive pathnames
  35 #define MAX_QPATH               64
  36
  37 /*
  38 ========================================================================
  39
  40 .MD3 triangle model file format
  41
  42 ========================================================================
  43 */
  44
  45 const unsigned char MD3_IDENT[4] = { 'I', 'D', 'P', '3', };
  46 #define MD3_VERSION                     15
  47
  48 // limits
  49 #define MD3_MAX_LODS            4
  50 #define MD3_MAX_TRIANGLES       8192    // per surface
  51 #define MD3_MAX_VERTS           4096    // per surface
  52 #define MD3_MAX_SHADERS         256             // per surface
  53 #define MD3_MAX_FRAMES          1024    // per model
  54 #define MD3_MAX_SURFACES        32              // per model
  55 #define MD3_MAX_TAGS            16              // per frame
  56
  57 // vertex scales
  58 #define MD3_XYZ_SCALE           (1.f / 64)
  59
  60 typedef float float3[3];
  61
  62 void istream_read_float3(PointerInputStream& inputStream, float3 f)
  63 {
  64   f[0] = istream_read_float32_le(inputStream);
  65   f[1] = istream_read_float32_le(inputStream);
  66   f[2] = istream_read_float32_le(inputStream);
  67 }
  68
  69 typedef struct md3Frame_s {
  70         float3          bounds[2];
  71         float3          localOrigin;
  72         float           radius;
  73         char            name[16];
  74 } md3Frame_t;
  75
  76 void istream_read_md3Frame(PointerInputStream& inputStream, md3Frame_t& frame)
  77 {
  78   istream_read_float3(inputStream, frame.bounds[0]);
  79   istream_read_float3(inputStream, frame.bounds[1]);
  80   istream_read_float3(inputStream, frame.localOrigin);
  81   frame.radius = istream_read_float32_le(inputStream);
  82   inputStream.read(reinterpret_cast<unsigned char*>(frame.name), 16);
  83 }
  84
  85 typedef struct md3Tag_s {
  86         char            name[MAX_QPATH];        // tag name
  87         float3          origin;
  88         float3          axis[3];
  89 } md3Tag_t;
  90
  91 void istream_read_md3Shader(PointerInputStream& inputStream, md3Tag_t& tag)
  92 {
  93   inputStream.read(reinterpret_cast<unsigned char*>(tag.name), MAX_QPATH);
  94   istream_read_float3(inputStream, tag.origin);
  95   istream_read_float3(inputStream, tag.axis[0]);
  96   istream_read_float3(inputStream, tag.axis[1]);
  97   istream_read_float3(inputStream, tag.axis[2]);
  98 }
  99
 100 /*
 101 ** md3Surface_t
 102 **
 103 ** CHUNK                        SIZE
 104 ** header                       sizeof( md3Surface_t )
 105 ** shaders                      sizeof( md3Shader_t ) * numShaders
 106 ** triangles[0]         sizeof( md3Triangle_t ) * numTriangles
 107 ** st                           sizeof( md3St_t ) * numVerts
 108 ** XyzNormals           sizeof( md3XyzNormal_t ) * numVerts * numFrames
 109 */
 110 typedef struct {
 111   char ident[4];                                //
 112
 113   char name[MAX_QPATH]; // polyset name
 114
 115   int flags;
 116   int numFrames; // all surfaces in a model should have the same
 117
 118   int numShaders; // all surfaces in a model should have the same
 119   int numVerts;
 120
 121   int numTriangles;
 122   int ofsTriangles;
 123
 124   int ofsShaders; // offset from start of md3Surface_t
 125   int ofsSt; // texture coords are common for all frames
 126   int ofsXyzNormals; // numVerts * numFrames
 127
 128   int ofsEnd; // next surface follows
 129 } md3Surface_t;
 130
 131 void istream_read_md3Surface(PointerInputStream& inputStream, md3Surface_t& surface)
 132 {
 133   inputStream.read(reinterpret_cast<unsigned char*>(surface.ident), 4);
 134   inputStream.read(reinterpret_cast<unsigned char*>(surface.name), MAX_QPATH);
 135   surface.flags = istream_read_int32_le(inputStream);
 136   surface.numFrames = istream_read_int32_le(inputStream);
 137   surface.numShaders = istream_read_int32_le(inputStream);
 138   surface.numVerts = istream_read_int32_le(inputStream);
 139   surface.numTriangles = istream_read_int32_le(inputStream);
 140   surface.ofsTriangles = istream_read_int32_le(inputStream);
 141   surface.ofsShaders = istream_read_int32_le(inputStream);
 142   surface.ofsSt = istream_read_int32_le(inputStream);
 143   surface.ofsXyzNormals = istream_read_int32_le(inputStream);
 144   surface.ofsEnd = istream_read_int32_le(inputStream);
 145 }
 146
 147 typedef struct {
 148         char                    name[MAX_QPATH];
 149         int                             shaderIndex;    // for in-game use
 150 } md3Shader_t;
 151
 152 void istream_read_md3Shader(PointerInputStream& inputStream, md3Shader_t& shader)
 153 {
 154   inputStream.read(reinterpret_cast<unsigned char*>(shader.name), MAX_QPATH);
 155   shader.shaderIndex = istream_read_int32_le(inputStream);
 156 }
 157
 158 typedef struct {
 159         int                     indexes[3];
 160 } md3Triangle_t;
 161
 162 void istream_read_md3Triangle(PointerInputStream& inputStream, md3Triangle_t& triangle)
 163 {
 164   triangle.indexes[0] = istream_read_int32_le(inputStream);
 165   triangle.indexes[1] = istream_read_int32_le(inputStream);
 166   triangle.indexes[2] = istream_read_int32_le(inputStream);
 167 }
 168
 169 typedef struct {
 170         float           st[2];
 171 } md3St_t;
 172
 173 void istream_read_md3St(PointerInputStream& inputStream, md3St_t& st)
 174 {
 175   st.st[0] = istream_read_float32_le(inputStream);
 176   st.st[1] = istream_read_float32_le(inputStream);
 177 }
 178
 179 typedef struct {
 180         short           xyz[3];
 181         short           normal;
 182 } md3XyzNormal_t;
 183
 184 void istream_read_md3XyzNormal(PointerInputStream& inputStream, md3XyzNormal_t& xyz)
 185 {
 186   xyz.xyz[0] = istream_read_int16_le(inputStream);
 187   xyz.xyz[1] = istream_read_int16_le(inputStream);
 188   xyz.xyz[2] = istream_read_int16_le(inputStream);
 189   xyz.normal = istream_read_int16_le(inputStream);
 190 }
 191
 192 typedef struct {
 193         char            ident[4];
 194         int                     version;
 195
 196         char            name[MAX_QPATH];        // model name
 197
 198         int                     flags;
 199
 200         int                     numFrames;
 201         int                     numTags;
 202         int                     numSurfaces;
 203
 204         int                     numSkins;
 205
 206         int                     ofsFrames;                      // offset for first frame
 207         int                     ofsTags;                        // numFrames * numTags
 208         int                     ofsSurfaces;            // first surface, others follow
 209
 210         int                     ofsEnd;                         // end of file
 211 } md3Header_t;
 212
 213 void istream_read_md3Header(PointerInputStream& inputStream, md3Header_t& header)
 214 {
 215   inputStream.read(reinterpret_cast<unsigned char*>(header.ident), 4);
 216   header.version = istream_read_int32_le(inputStream);
 217   inputStream.read(reinterpret_cast<unsigned char*>(header.name), MAX_QPATH);
 218   header.flags = istream_read_int32_le(inputStream);
 219   header.numFrames = istream_read_int32_le(inputStream);
 220   header.numTags = istream_read_int32_le(inputStream);
 221   header.numSurfaces = istream_read_int32_le(inputStream);
 222   header.numSkins = istream_read_int32_le(inputStream);
 223   header.ofsFrames = istream_read_int32_le(inputStream);
 224   header.ofsTags = istream_read_int32_le(inputStream);
 225   header.ofsSurfaces = istream_read_int32_le(inputStream);
 226   header.ofsEnd = istream_read_int32_le(inputStream);
 227 }
 228
 229 int MD3Surface_read(Surface& surface, unsigned char* buffer)
 230 {
 231         md3Surface_t md3Surface;
 232   {
 233     PointerInputStream inputStream(buffer);
 234     istream_read_md3Surface(inputStream, md3Surface);
 235   }
 236
 237   {
 238     surface.vertices().reserve(md3Surface.numVerts);
 239
 240     PointerInputStream xyzNormalStream(buffer + md3Surface.ofsXyzNormals);
 241     PointerInputStream stStream(buffer + md3Surface.ofsSt);
 242
 243      // read verts into vertex array - xyz, st, normal
 244     for(int i = 0; i < md3Surface.numVerts; i++)
 245           {
 246             md3XyzNormal_t md3Xyz;
 247       istream_read_md3XyzNormal(xyzNormalStream, md3Xyz);
 248
 249       md3St_t md3St;
 250       istream_read_md3St(stStream, md3St);
 251
 252       surface.vertices().push_back(
 253         ArbitraryMeshVertex(
 254           Vertex3f( md3Xyz.xyz[0] * MD3_XYZ_SCALE, md3Xyz.xyz[1] * MD3_XYZ_SCALE, md3Xyz.xyz[2] * MD3_XYZ_SCALE),
 255           DecodeNormal(reinterpret_cast<byte*>(&md3Xyz.normal)),
 256           TexCoord2f(md3St.st[0], md3St.st[1])
 257         )
 258       );
 259     }
 260   }
 261
 262   {
 263           surface.indices().reserve(md3Surface.numTriangles * 3);
 264
 265     PointerInputStream inputStream(buffer + md3Surface.ofsTriangles);
 266     for(int i = 0; i < md3Surface.numTriangles; i++)
 267     {
 268             md3Triangle_t md3Triangle;
 269       istream_read_md3Triangle(inputStream, md3Triangle);
 270       surface.indices().insert(md3Triangle.indexes[0]);
 271       surface.indices().insert(md3Triangle.indexes[1]);
 272       surface.indices().insert(md3Triangle.indexes[2]);
 273     }
 274   }
 275
 276   {
 277           md3Shader_t md3Shader;
 278     {
 279       PointerInputStream inputStream(buffer + md3Surface.ofsShaders);
 280       istream_read_md3Shader(inputStream, md3Shader);
 281     }
 282     surface.setShader(md3Shader.name);
 283   }
 284
 285         surface.updateAABB();
 286
 287   return md3Surface.ofsEnd;
 288 }
 289
 290 void MD3Model_read(Model& model, unsigned char* buffer)
 291 {
 292   md3Header_t md3Header;
 293   {
 294     PointerInputStream inputStream(buffer);
 295     istream_read_md3Header(inputStream, md3Header);
 296   }
 297
 298   unsigned char* surfacePosition = buffer + md3Header.ofsSurfaces;
 299
 300   for(int i = 0; i != md3Header.numSurfaces; ++i)
 301         {
 302     surfacePosition += MD3Surface_read(model.newSurface(), surfacePosition);
 303   }
 304
 305   model.updateAABB();
 306 }
 307
 308 scene::Node& MD3Model_new(unsigned char* buffer)
 309 {
 310   ModelNode* modelNode = new ModelNode();
 311   MD3Model_read(modelNode->model(), buffer);
 312   return modelNode->node();
 313 }
 314
 315 scene::Node& MD3Model_default()
 316 {
 317   ModelNode* modelNode = new ModelNode();
 318   Model_constructNull(modelNode->model());
 319   return modelNode->node();
 320 }
 321
 322 scene::Node& MD3Model_fromBuffer(unsigned char* buffer)
 323 {
 324   if (!ident_equal(buffer, MD3_IDENT))
 325   {
 326           globalErrorStream() << "MD3 read error: incorrect ident\n";
 327     return MD3Model_default();
 328   }
 329   else
 330   {
 331     return MD3Model_new(buffer);
 332   }
 333 }
 334
 335 scene::Node& loadMD3Model(ArchiveFile& file)
 336 {
 337   ScopedArchiveBuffer buffer(file);
 338   return MD3Model_fromBuffer(buffer.buffer);
 339 }
 340