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