plugins/md3model/mdl.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 "mdl.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 "mdlnormals.h"
  33 #include "mdlformat.h"
  34
  35 void istream_read_mdlHeader(PointerInputStream& inputStream, mdlHeader_t& header)
  36 {
  37         inputStream.read(header.ident, 4);
  38         header.version = istream_read_int32_le(inputStream);
  39         header.scale[0] = istream_read_float32_le(inputStream);
  40         header.scale[1] = istream_read_float32_le(inputStream);
  41         header.scale[2] = istream_read_float32_le(inputStream);
  42         header.scale_origin[0] = istream_read_float32_le(inputStream);
  43         header.scale_origin[1] = istream_read_float32_le(inputStream);
  44         header.scale_origin[2] = istream_read_float32_le(inputStream);
  45         header.boundingradius = istream_read_float32_le(inputStream);
  46         header.eyeposition[0] = istream_read_float32_le(inputStream);
  47         header.eyeposition[1] = istream_read_float32_le(inputStream);
  48         header.eyeposition[2] = istream_read_float32_le(inputStream);
  49         header.numskins = istream_read_int32_le(inputStream);
  50         header.skinwidth = istream_read_int32_le(inputStream);
  51         header.skinheight = istream_read_int32_le(inputStream);
  52         header.numverts = istream_read_int32_le(inputStream);
  53         header.numtris = istream_read_int32_le(inputStream);
  54         header.numframes = istream_read_int32_le(inputStream);
  55         header.synctype = istream_read_int32_le(inputStream);
  56         header.flags = istream_read_int32_le(inputStream);
  57         header.size = istream_read_float32_le(inputStream);
  58 }
  59
  60 inline ArbitraryMeshVertex MDLVertex_construct(const mdlHeader_t& header, const mdlXyzNormal_t& xyz, const mdlSt_t& st, bool facesfront)
  61 {
  62   return ArbitraryMeshVertex(
  63     Vertex3f(
  64       xyz.v[0] * header.scale[0] + header.scale_origin[0],
  65       xyz.v[1] * header.scale[1] + header.scale_origin[1],
  66       xyz.v[2] * header.scale[2] + header.scale_origin[2]
  67     ),
  68     Normal3f(
  69       g_mdl_normals[xyz.lightnormalindex][0],
  70       g_mdl_normals[xyz.lightnormalindex][1],
  71       g_mdl_normals[xyz.lightnormalindex][2]
  72     ),
  73     TexCoord2f(
  74     ((float)st.s / header.skinwidth) + ((st.onseam == MDL_ONSEAM && !facesfront) ? 0.5f : 0.0f),
  75       (float)st.t / header.skinheight
  76     )
  77   );
  78 }
  79
  80 class mdlVertex_t
  81 {
  82 public:
  83   inline mdlVertex_t(int vertindex, int facesfront)
  84     : m_vertindex(vertindex), m_facesfront(facesfront)
  85   {}
  86   inline bool operator<(const mdlVertex_t& other) const
  87   {
  88     if(m_facesfront < other.m_facesfront)
  89       return true;
  90     if(other.m_facesfront < m_facesfront)
  91       return false;
  92
  93     if(m_vertindex < other.m_vertindex)
  94       return true;
  95     if(other.m_vertindex < m_vertindex)
  96       return false;
  97
  98     return false;
  99   }
 100   inline bool operator==(const mdlVertex_t& other) const
 101   {
 102     return m_vertindex == other.m_vertindex
 103       && m_facesfront == other.m_facesfront;
 104   }
 105
 106   int m_vertindex;
 107   int m_facesfront;
 108 };
 109
 110 typedef const mdlTriangle_t* mdlTriangleIterator;
 111
 112 void MDLSurface_read(Surface& surface, const byte* buffer, const char* name)
 113 {
 114   mdlHeader_t header;
 115
 116   PointerInputStream inputStream(buffer);
 117   istream_read_mdlHeader(inputStream, header);
 118
 119   for(int i = 0; i < header.numskins; ++i)
 120   {
 121     switch(istream_read_int32_le(inputStream))
 122     {
 123     case MDL_SKIN_SINGLE:
 124       inputStream.seek(header.skinwidth * header.skinheight);
 125       break;
 126     case MDL_SKIN_GROUP:
 127       int numskins = istream_read_int32_le(inputStream);
 128       inputStream.seek(numskins * (4 + (header.skinwidth * header.skinheight)));
 129       break;
 130     }
 131   }
 132
 133   Array<mdlSt_t> mdlSts(header.numverts);
 134   for(Array<mdlSt_t>::iterator i = mdlSts.begin(); i != mdlSts.end(); ++i)
 135   {
 136           (*i).onseam = istream_read_int32_le(inputStream);
 137           (*i).s = istream_read_int32_le(inputStream);
 138           (*i).t = istream_read_int32_le(inputStream);
 139   }
 140
 141   Array<mdlTriangle_t> mdlTriangles(header.numtris);
 142   for(Array<mdlTriangle_t>::iterator i = mdlTriangles.begin(); i != mdlTriangles.end(); ++i)
 143   {
 144           (*i).facesfront = istream_read_int32_le(inputStream);
 145           (*i).vertindex[0] = istream_read_int32_le(inputStream);
 146           (*i).vertindex[1] = istream_read_int32_le(inputStream);
 147           (*i).vertindex[2] = istream_read_int32_le(inputStream);
 148   }
 149
 150   {
 151     bool found = false;
 152     for(int i = 0; i < header.numframes && found == false; i++)
 153     {
 154       switch(istream_read_int32_le(inputStream))
 155       {
 156       case MDL_FRAME_SINGLE:
 157         inputStream.seek(MDL_FRAME_SIZE);
 158         found = true;
 159         break;
 160       case MDL_FRAME_GROUP:
 161         int numframes = istream_read_int32_le(inputStream);
 162         inputStream.seek((MDL_XYZNORMAL_SIZE * 2) + (numframes * 4));
 163         found = true;
 164         break;
 165       }
 166     }
 167   }
 168
 169   Array<mdlXyzNormal_t> mdlXyzNormals(header.numtris);
 170   for(Array<mdlXyzNormal_t>::iterator i = mdlXyzNormals.begin(); i != mdlXyzNormals.end(); ++i)
 171   {
 172           inputStream.read((*i).v, 3);
 173           inputStream.read(&(*i).lightnormalindex, 1);
 174   }
 175
 176   {
 177     VertexBuffer<mdlVertex_t> mdl_vertices;
 178
 179     {
 180       UniqueVertexBuffer<mdlVertex_t> inserter(mdl_vertices);
 181       for(Array<mdlTriangle_t>::iterator i = mdlTriangles.begin(); i != mdlTriangles.end(); ++i)
 182       {
 183         surface.indices().insert(inserter.insert(mdlVertex_t((*i).vertindex[0], (*i).facesfront)));
 184         surface.indices().insert(inserter.insert(mdlVertex_t((*i).vertindex[1], (*i).facesfront)));
 185         surface.indices().insert(inserter.insert(mdlVertex_t((*i).vertindex[2], (*i).facesfront)));
 186       }
 187     }
 188
 189     {
 190       surface.vertices().reserve(mdl_vertices.size());
 191
 192       for(VertexBuffer<mdlVertex_t>::iterator i = mdl_vertices.begin(); i != mdl_vertices.end(); ++i)
 193       {
 194         surface.vertices().push_back(MDLVertex_construct(header, mdlXyzNormals[(*i).m_vertindex], mdlSts[(*i).m_vertindex], (*i).m_facesfront == MDL_FACES_FRONT));
 195       }
 196     }
 197   }
 198
 199   surface.setShader(name);
 200   surface.updateAABB();
 201 }
 202
 203 void MDLModel_read(Model& model, const byte* buffer, const char* name)
 204 {
 205   MDLSurface_read(model.newSurface(), buffer, name);
 206   model.updateAABB();
 207 }
 208
 209 scene::Node& MDLModel_new(const byte* buffer, const char* name)
 210 {
 211   ModelNode* modelNode = new ModelNode();
 212   MDLModel_read(modelNode->model(), buffer, name);
 213   return modelNode->node();
 214 }
 215
 216 scene::Node& MDLModel_default()
 217 {
 218   ModelNode* modelNode = new ModelNode();
 219   Model_constructNull(modelNode->model());
 220   return modelNode->node();
 221 }
 222
 223 scene::Node& MDLModel_fromBuffer(unsigned char* buffer, const char* name)
 224 {
 225   if (!ident_equal(buffer, MDL_IDENT))
 226   {
 227           globalErrorStream() << "MDL read error: incorrect ident\n";
 228     return MDLModel_default();
 229   }
 230   else
 231   {
 232     return MDLModel_new(buffer, name);
 233   }
 234 }
 235
 236 scene::Node& loadMDLModel(ArchiveFile& file)
 237 {
 238   ScopedArchiveBuffer buffer(file);
 239   return MDLModel_fromBuffer(buffer.buffer, file.getName());
 240 }
 241