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