plugins/md3model/md5.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 "md5.h"
  23
  24 #include "iscriplib.h"
  25 #include "imodel.h"
  26
  27 #include "archivelib.h"
  28 #include "stringio.h"
  29
  30 #include "model.h"
  31
  32 #define MD5_RETURN_FALSE_IF_FAIL(expression) if(!(expression)) { globalErrorStream() << "md5 parse failed: " #expression "\n"; return false; } else
  33
  34 bool MD5_parseToken(Tokeniser& tokeniser, const char* string)
  35 {
  36   const char* token = tokeniser.getToken();
  37   MD5_RETURN_FALSE_IF_FAIL(token != 0);
  38   return string_equal(token, string);
  39 }
  40
  41 bool MD5_parseFloat(Tokeniser& tokeniser, float& f)
  42 {
  43   const char* token = tokeniser.getToken();
  44   MD5_RETURN_FALSE_IF_FAIL(token != 0);
  45   return string_parse_float(token, f);
  46 }
  47
  48 bool MD5_parseString(Tokeniser& tokeniser, const char*& s)
  49 {
  50   const char* token = tokeniser.getToken();
  51   MD5_RETURN_FALSE_IF_FAIL(token != 0);
  52   s = token;
  53   return true;
  54 }
  55
  56 bool MD5_parseInteger(Tokeniser& tokeniser, int& i)
  57 {
  58   const char* token = tokeniser.getToken();
  59   MD5_RETURN_FALSE_IF_FAIL(token != 0);
  60   return string_parse_int(token, i);
  61 }
  62
  63 bool MD5_parseSize(Tokeniser& tokeniser, std::size_t& i)
  64 {
  65   const char* token = tokeniser.getToken();
  66   MD5_RETURN_FALSE_IF_FAIL(token != 0);
  67   return string_parse_size(token, i);
  68 }
  69
  70 bool MD5_parseVector3(Tokeniser& tokeniser, Vector3& v)
  71 {
  72   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "("));
  73   MD5_RETURN_FALSE_IF_FAIL(MD5_parseFloat(tokeniser, v.x()));
  74   MD5_RETURN_FALSE_IF_FAIL(MD5_parseFloat(tokeniser, v.y()));
  75   MD5_RETURN_FALSE_IF_FAIL(MD5_parseFloat(tokeniser, v.z()));
  76   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, ")"));
  77   return true;
  78 }
  79
  80 template<typename Element>
  81 inline Element float_squared(const Element& f)
  82 {
  83   return f * f;
  84 }
  85
  86 class MD5Joint
  87 {
  88 public:
  89   int parent;
  90   Vector3 position;
  91   Vector4 rotation;
  92 };
  93
  94 typedef Array<MD5Joint> MD5Joints;
  95
  96 class MD5Vert
  97 {
  98 public:
  99   std::size_t index;
 100   float u;
 101   float v;
 102   std::size_t weight_index;
 103   std::size_t weight_count;
 104 };
 105
 106 typedef Array<MD5Vert> MD5Verts;
 107
 108 class MD5Tri
 109 {
 110 public:
 111   std::size_t index;
 112   std::size_t a;
 113   std::size_t b;
 114   std::size_t c;
 115 };
 116
 117 typedef Array<MD5Tri> MD5Tris;
 118
 119 class MD5Weight
 120 {
 121 public:
 122   std::size_t index;
 123   std::size_t joint;
 124   float t;
 125   Vector3 v;
 126 };
 127
 128 typedef Array<MD5Weight> MD5Weights;
 129
 130 typedef float MD5Component;
 131 typedef Array<MD5Component> MD5Components;
 132
 133 class MD5Frame
 134 {
 135 public:
 136   MD5Components m_components;
 137 };
 138
 139 typedef Array<MD5Weight> MD5Weights;
 140
 141 bool MD5_parseVersion(Tokeniser& tokeniser)
 142 {
 143   {
 144     const char* versionKey = tokeniser.getToken();
 145     if(versionKey == 0 || !string_equal(versionKey, "MD5Version"))
 146     {
 147       globalErrorStream() << "not a valid md5 file\n";
 148       return false;
 149     }
 150   }
 151   {
 152     const char* versionValue = tokeniser.getToken();
 153     if(versionValue == 0 || !string_equal(versionValue, "10"))
 154     {
 155       globalErrorStream() << "only md5 version 10 supported\n";
 156       return false;
 157     }
 158   }
 159
 160   return true;
 161 }
 162
 163 bool MD5Anim_parse(Tokeniser& tokeniser)
 164 {
 165   MD5_RETURN_FALSE_IF_FAIL(MD5_parseVersion(tokeniser));
 166   tokeniser.nextLine();
 167
 168   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "commandline"));
 169   const char* commandline;
 170   MD5_RETURN_FALSE_IF_FAIL(MD5_parseString(tokeniser, commandline));
 171   tokeniser.nextLine();
 172
 173   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "numFrames"));
 174   std::size_t numFrames;
 175   MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, numFrames));
 176   tokeniser.nextLine();
 177
 178   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "numJoints"));
 179   std::size_t numJoints;
 180   MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, numJoints));
 181   tokeniser.nextLine();
 182
 183   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "frameRate"));
 184   std::size_t frameRate;
 185   MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, frameRate));
 186   tokeniser.nextLine();
 187
 188   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "numAnimatedComponents"));
 189   std::size_t numAnimatedComponents;
 190   MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, numAnimatedComponents));
 191   tokeniser.nextLine();
 192
 193   // parse heirarchy
 194   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "hierarchy"));
 195   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "{"));
 196   tokeniser.nextLine();
 197
 198   for(std::size_t i = 0; i < numJoints; ++i)
 199   {
 200     const char* name;
 201     MD5_RETURN_FALSE_IF_FAIL(MD5_parseString(tokeniser, name));
 202     int parent;
 203     MD5_RETURN_FALSE_IF_FAIL(MD5_parseInteger(tokeniser, parent));
 204     std::size_t flags;
 205     MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, flags));
 206     std::size_t index;
 207     MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, index));
 208     tokeniser.nextLine();
 209   }
 210
 211   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "}"));
 212   tokeniser.nextLine();
 213
 214   // parse bounds
 215   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "bounds"));
 216   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "{"));
 217   tokeniser.nextLine();
 218
 219   for(std::size_t i = 0; i < numFrames; ++i)
 220   {
 221     Vector3 mins;
 222     MD5_RETURN_FALSE_IF_FAIL(MD5_parseVector3(tokeniser, mins));
 223     Vector3 maxs;
 224     MD5_RETURN_FALSE_IF_FAIL(MD5_parseVector3(tokeniser, maxs));
 225     tokeniser.nextLine();
 226   }
 227
 228   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "}"));
 229   tokeniser.nextLine();
 230
 231   // parse baseframe
 232   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "baseframe"));
 233   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "{"));
 234   tokeniser.nextLine();
 235
 236   for(std::size_t i = 0; i < numJoints; ++i)
 237   {
 238     Vector3 position;
 239     MD5_RETURN_FALSE_IF_FAIL(MD5_parseVector3(tokeniser, position));
 240     Vector3 rotation;
 241     MD5_RETURN_FALSE_IF_FAIL(MD5_parseVector3(tokeniser, rotation));
 242     tokeniser.nextLine();
 243   }
 244
 245   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "}"));
 246   tokeniser.nextLine();
 247
 248   // parse frames
 249   for(std::size_t i = 0; i < numFrames; ++i)
 250   {
 251     MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "frame"));
 252     MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "{"));
 253     tokeniser.nextLine();
 254
 255     for(std::size_t i = 0; i < numAnimatedComponents; ++i)
 256     {
 257       float component;
 258       MD5_RETURN_FALSE_IF_FAIL(MD5_parseFloat(tokeniser, component));
 259       tokeniser.nextLine();
 260     }
 261
 262     MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "}"));
 263     tokeniser.nextLine();
 264   }
 265
 266   return true;
 267 }
 268
 269 bool MD5Model_parse(Model& model, Tokeniser& tokeniser)
 270 {
 271   MD5_RETURN_FALSE_IF_FAIL(MD5_parseVersion(tokeniser));
 272   tokeniser.nextLine();
 273
 274   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "commandline"));
 275   const char* commandline;
 276   MD5_RETURN_FALSE_IF_FAIL(MD5_parseString(tokeniser, commandline));
 277   tokeniser.nextLine();
 278
 279   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "numJoints"));
 280   std::size_t numJoints;
 281   MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, numJoints));
 282   tokeniser.nextLine();
 283
 284   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "numMeshes"));
 285   std::size_t numMeshes;
 286   MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, numMeshes));
 287   tokeniser.nextLine();
 288
 289   MD5Joints joints(numJoints);
 290
 291   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "joints"));
 292   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "{"));
 293   tokeniser.nextLine();
 294
 295   for(MD5Joints::iterator i = joints.begin(); i != joints.end(); ++i)
 296   {
 297     const char* jointName;
 298     MD5_RETURN_FALSE_IF_FAIL(MD5_parseString(tokeniser, jointName));
 299     MD5_RETURN_FALSE_IF_FAIL(MD5_parseInteger(tokeniser, (*i).parent));
 300     MD5_RETURN_FALSE_IF_FAIL(MD5_parseVector3(tokeniser, (*i).position));
 301     MD5_RETURN_FALSE_IF_FAIL(MD5_parseVector3(tokeniser, vector4_to_vector3((*i).rotation)));
 302     (*i).rotation.w() = -static_cast<float>(sqrt(1.0f - (float_squared((*i).rotation.x()) + float_squared((*i).rotation.y()) + float_squared((*i).rotation.z()))));
 303     tokeniser.nextLine();
 304   }
 305
 306   MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "}"));
 307   tokeniser.nextLine();
 308
 309   for(std::size_t i = 0; i < numMeshes; ++i)
 310   {
 311     Surface& surface = model.newSurface();
 312
 313     MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "mesh"));
 314     MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "{"));
 315     tokeniser.nextLine();
 316
 317     MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "shader"));
 318     const char* shader;
 319     MD5_RETURN_FALSE_IF_FAIL(MD5_parseString(tokeniser, shader));
 320     surface.setShader(shader);
 321     tokeniser.nextLine();
 322
 323     MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "numverts"));
 324     std::size_t numVerts;
 325     MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, numVerts));
 326     tokeniser.nextLine();
 327
 328     MD5Verts verts(numVerts);
 329
 330     for(MD5Verts::iterator j = verts.begin(); j != verts.end(); ++j)
 331     {
 332       MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "vert"));
 333       MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, (*j).index));
 334       MD5_RETURN_FALSE_IF_FAIL((*j).index == std::size_t(j - verts.begin()));
 335       MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "("));
 336       MD5_RETURN_FALSE_IF_FAIL(MD5_parseFloat(tokeniser, (*j).u));
 337       MD5_RETURN_FALSE_IF_FAIL(MD5_parseFloat(tokeniser, (*j).v));
 338       MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, ")"));
 339       MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, (*j).weight_index));
 340       MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, (*j).weight_count));
 341       tokeniser.nextLine();
 342     }
 343
 344     MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "numtris"));
 345     std::size_t numTris;
 346     MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, numTris));
 347     tokeniser.nextLine();
 348
 349     MD5Tris tris(numTris);
 350
 351     for(MD5Tris::iterator j = tris.begin(); j != tris.end(); ++j)
 352     {
 353       MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "tri"));
 354       MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, (*j).index));
 355       MD5_RETURN_FALSE_IF_FAIL((*j).index == std::size_t(j - tris.begin()));
 356       MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, (*j).a));
 357       MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, (*j).b));
 358       MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, (*j).c));
 359       tokeniser.nextLine();
 360     }
 361
 362     MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "numweights"));
 363     std::size_t numWeights;
 364     MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, numWeights));
 365     tokeniser.nextLine();
 366
 367     MD5Weights weights(numWeights);
 368
 369     for(MD5Weights::iterator j = weights.begin(); j != weights.end(); ++j)
 370     {
 371       MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "weight"));
 372       MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, (*j).index));
 373       MD5_RETURN_FALSE_IF_FAIL((*j).index == std::size_t(j - weights.begin()));
 374       MD5_RETURN_FALSE_IF_FAIL(MD5_parseSize(tokeniser, (*j).joint));
 375       MD5_RETURN_FALSE_IF_FAIL(MD5_parseFloat(tokeniser, (*j).t));
 376       MD5_RETURN_FALSE_IF_FAIL(MD5_parseVector3(tokeniser, (*j).v));
 377       tokeniser.nextLine();
 378     }
 379
 380     MD5_RETURN_FALSE_IF_FAIL(MD5_parseToken(tokeniser, "}"));
 381     tokeniser.nextLine();
 382
 383     for(MD5Verts::iterator j = verts.begin(); j != verts.end(); ++j)
 384     {
 385       MD5Vert& vert = (*j);
 386
 387       Vector3 skinned(0, 0, 0);
 388       for(std::size_t k = 0; k != vert.weight_count; ++k)
 389       {
 390         MD5Weight& weight = weights[vert.weight_index + k];
 391         MD5Joint& joint = joints[weight.joint];
 392
 393         skinned += (quaternion_transformed_point(joint.rotation, weight.v) + joint.position) * weight.t;
 394       }
 395
 396       surface.vertices().push_back(ArbitraryMeshVertex(vertex3f_for_vector3(skinned), Normal3f(0, 0, 0), TexCoord2f(vert.u, vert.v)));
 397     }
 398
 399     for(MD5Tris::iterator j = tris.begin(); j != tris.end(); ++j)
 400     {
 401       MD5Tri& tri = (*j);
 402       surface.indices().insert(RenderIndex(tri.a));
 403       surface.indices().insert(RenderIndex(tri.b));
 404       surface.indices().insert(RenderIndex(tri.c));
 405     }
 406
 407     for(Surface::indices_t::iterator j = surface.indices().begin(); j != surface.indices().end(); j += 3)
 408     {
 409                         ArbitraryMeshVertex& a = surface.vertices()[*(j + 0)];
 410                         ArbitraryMeshVertex& b = surface.vertices()[*(j + 1)];
 411                         ArbitraryMeshVertex& c = surface.vertices()[*(j + 2)];
 412                         Vector3 weightedNormal(
 413         vector3_cross(
 414           reinterpret_cast<const Vector3&>(c.vertex) - reinterpret_cast<const Vector3&>(a.vertex),
 415           reinterpret_cast<const Vector3&>(b.vertex) - reinterpret_cast<const Vector3&>(a.vertex)
 416         )
 417       );
 418       reinterpret_cast<Vector3&>(a.normal) += weightedNormal;
 419       reinterpret_cast<Vector3&>(b.normal) += weightedNormal;
 420       reinterpret_cast<Vector3&>(c.normal) += weightedNormal;
 421     }
 422
 423     for(Surface::vertices_t::iterator j = surface.vertices().begin(); j != surface.vertices().end(); ++j)
 424     {
 425       vector3_normalise(reinterpret_cast<Vector3&>((*j).normal));
 426     }
 427
 428     surface.updateAABB();
 429   }
 430
 431   model.updateAABB();
 432
 433   return true;
 434 }
 435
 436 void MD5Model_construct(Model& model, TextInputStream& inputStream)
 437 {
 438   Tokeniser& tokeniser = GlobalScriptLibrary().m_pfnNewSimpleTokeniser(inputStream);
 439   MD5Model_parse(model, tokeniser);
 440   tokeniser.release();
 441 }
 442
 443 scene::Node& MD5Model_new(TextInputStream& inputStream)
 444 {
 445   ModelNode* modelNode = new ModelNode();
 446   MD5Model_construct(modelNode->model(), inputStream);
 447   return modelNode->node();
 448 }
 449
 450 scene::Node& loadMD5Model(ArchiveFile& file)
 451 {
 452   BinaryToTextInputStream<InputStream> inputStream(file.getInputStream());
 453   return MD5Model_new(inputStream);
 454 }