- Updated UFA:Plugin (mattn2)
[xonotic/netradiant.git] / 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