Merge commit '830125fad042fad35dc029b6eb57c8156ad7e176'
[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         f[0] = istream_read_float32_le( inputStream );
64         f[1] = istream_read_float32_le( inputStream );
65         f[2] = istream_read_float32_le( inputStream );
66 }
67
68 typedef struct md3Frame_s {
69         float3 bounds[2];
70         float3 localOrigin;
71         float radius;
72         char name[16];
73 } md3Frame_t;
74
75 void istream_read_md3Frame( PointerInputStream& inputStream, md3Frame_t& frame ){
76         istream_read_float3( inputStream, frame.bounds[0] );
77         istream_read_float3( inputStream, frame.bounds[1] );
78         istream_read_float3( inputStream, frame.localOrigin );
79         frame.radius = istream_read_float32_le( inputStream );
80         inputStream.read( reinterpret_cast<unsigned char*>( frame.name ), 16 );
81 }
82
83 typedef struct md3Tag_s {
84         char name[MAX_QPATH];           // tag name
85         float3 origin;
86         float3 axis[3];
87 } md3Tag_t;
88
89 void istream_read_md3Shader( PointerInputStream& inputStream, md3Tag_t& tag ){
90         inputStream.read( reinterpret_cast<unsigned char*>( tag.name ), MAX_QPATH );
91         istream_read_float3( inputStream, tag.origin );
92         istream_read_float3( inputStream, tag.axis[0] );
93         istream_read_float3( inputStream, tag.axis[1] );
94         istream_read_float3( inputStream, tag.axis[2] );
95 }
96
97 /*
98 ** md3Surface_t
99 **
100 ** CHUNK                        SIZE
101 ** header                       sizeof( md3Surface_t )
102 ** shaders                      sizeof( md3Shader_t ) * numShaders
103 ** triangles[0]         sizeof( md3Triangle_t ) * numTriangles
104 ** st                           sizeof( md3St_t ) * numVerts
105 ** XyzNormals           sizeof( md3XyzNormal_t ) * numVerts * numFrames
106 */
107 typedef struct {
108         char ident[4];              //
109
110         char name[MAX_QPATH]; // polyset name
111
112         int flags;
113         int numFrames; // all surfaces in a model should have the same
114
115         int numShaders; // all surfaces in a model should have the same
116         int numVerts;
117
118         int numTriangles;
119         int ofsTriangles;
120
121         int ofsShaders; // offset from start of md3Surface_t
122         int ofsSt; // texture coords are common for all frames
123         int ofsXyzNormals; // numVerts * numFrames
124
125         int ofsEnd; // next surface follows
126 } md3Surface_t;
127
128 void istream_read_md3Surface( PointerInputStream& inputStream, md3Surface_t& surface ){
129         inputStream.read( reinterpret_cast<unsigned char*>( surface.ident ), 4 );
130         inputStream.read( reinterpret_cast<unsigned char*>( surface.name ), MAX_QPATH );
131         surface.flags = istream_read_int32_le( inputStream );
132         surface.numFrames = istream_read_int32_le( inputStream );
133         surface.numShaders = istream_read_int32_le( inputStream );
134         surface.numVerts = istream_read_int32_le( inputStream );
135         surface.numTriangles = istream_read_int32_le( inputStream );
136         surface.ofsTriangles = istream_read_int32_le( inputStream );
137         surface.ofsShaders = istream_read_int32_le( inputStream );
138         surface.ofsSt = istream_read_int32_le( inputStream );
139         surface.ofsXyzNormals = istream_read_int32_le( inputStream );
140         surface.ofsEnd = istream_read_int32_le( inputStream );
141 }
142
143 typedef struct {
144         char name[MAX_QPATH];
145         int shaderIndex;                // for in-game use
146 } md3Shader_t;
147
148 void istream_read_md3Shader( PointerInputStream& inputStream, md3Shader_t& shader ){
149         inputStream.read( reinterpret_cast<unsigned char*>( shader.name ), MAX_QPATH );
150         shader.shaderIndex = istream_read_int32_le( inputStream );
151 }
152
153 typedef struct {
154         int indexes[3];
155 } md3Triangle_t;
156
157 void istream_read_md3Triangle( PointerInputStream& inputStream, md3Triangle_t& triangle ){
158         triangle.indexes[0] = istream_read_int32_le( inputStream );
159         triangle.indexes[1] = istream_read_int32_le( inputStream );
160         triangle.indexes[2] = istream_read_int32_le( inputStream );
161 }
162
163 typedef struct {
164         float st[2];
165 } md3St_t;
166
167 void istream_read_md3St( PointerInputStream& inputStream, md3St_t& st ){
168         st.st[0] = istream_read_float32_le( inputStream );
169         st.st[1] = istream_read_float32_le( inputStream );
170 }
171
172 typedef struct {
173         short xyz[3];
174         short normal;
175 } md3XyzNormal_t;
176
177 void istream_read_md3XyzNormal( PointerInputStream& inputStream, md3XyzNormal_t& xyz ){
178         xyz.xyz[0] = istream_read_int16_le( inputStream );
179         xyz.xyz[1] = istream_read_int16_le( inputStream );
180         xyz.xyz[2] = istream_read_int16_le( inputStream );
181         xyz.normal = istream_read_int16_le( inputStream );
182 }
183
184 typedef struct {
185         char ident[4];
186         int version;
187
188         char name[MAX_QPATH];           // model name
189
190         int flags;
191
192         int numFrames;
193         int numTags;
194         int numSurfaces;
195
196         int numSkins;
197
198         int ofsFrames;                  // offset for first frame
199         int ofsTags;                    // numFrames * numTags
200         int ofsSurfaces;                // first surface, others follow
201
202         int ofsEnd;                     // end of file
203 } md3Header_t;
204
205 void istream_read_md3Header( PointerInputStream& inputStream, md3Header_t& header ){
206         inputStream.read( reinterpret_cast<unsigned char*>( header.ident ), 4 );
207         header.version = istream_read_int32_le( inputStream );
208         inputStream.read( reinterpret_cast<unsigned char*>( header.name ), MAX_QPATH );
209         header.flags = istream_read_int32_le( inputStream );
210         header.numFrames = istream_read_int32_le( inputStream );
211         header.numTags = istream_read_int32_le( inputStream );
212         header.numSurfaces = istream_read_int32_le( inputStream );
213         header.numSkins = istream_read_int32_le( inputStream );
214         header.ofsFrames = istream_read_int32_le( inputStream );
215         header.ofsTags = istream_read_int32_le( inputStream );
216         header.ofsSurfaces = istream_read_int32_le( inputStream );
217         header.ofsEnd = istream_read_int32_le( inputStream );
218 }
219
220 int MD3Surface_read( Surface& surface, unsigned char* buffer ){
221         md3Surface_t md3Surface;
222         {
223                 PointerInputStream inputStream( buffer );
224                 istream_read_md3Surface( inputStream, md3Surface );
225         }
226
227         {
228                 surface.vertices().reserve( md3Surface.numVerts );
229
230                 PointerInputStream xyzNormalStream( buffer + md3Surface.ofsXyzNormals );
231                 PointerInputStream stStream( buffer + md3Surface.ofsSt );
232
233                 // read verts into vertex array - xyz, st, normal
234                 for ( int i = 0; i < md3Surface.numVerts; i++ )
235                 {
236                         md3XyzNormal_t md3Xyz;
237                         istream_read_md3XyzNormal( xyzNormalStream, md3Xyz );
238
239                         md3St_t md3St;
240                         istream_read_md3St( stStream, md3St );
241
242                         surface.vertices().push_back(
243                                 ArbitraryMeshVertex(
244                                         Vertex3f( md3Xyz.xyz[0] * MD3_XYZ_SCALE, md3Xyz.xyz[1] * MD3_XYZ_SCALE, md3Xyz.xyz[2] * MD3_XYZ_SCALE ),
245                                         DecodeNormal( reinterpret_cast<byte*>( &md3Xyz.normal ) ),
246                                         TexCoord2f( md3St.st[0], md3St.st[1] )
247                                         )
248                                 );
249                 }
250         }
251
252         {
253                 surface.indices().reserve( md3Surface.numTriangles * 3 );
254
255                 PointerInputStream inputStream( buffer + md3Surface.ofsTriangles );
256                 for ( int i = 0; i < md3Surface.numTriangles; i++ )
257                 {
258                         md3Triangle_t md3Triangle;
259                         istream_read_md3Triangle( inputStream, md3Triangle );
260                         surface.indices().insert( md3Triangle.indexes[0] );
261                         surface.indices().insert( md3Triangle.indexes[1] );
262                         surface.indices().insert( md3Triangle.indexes[2] );
263                 }
264         }
265
266         {
267                 md3Shader_t md3Shader;
268                 {
269                         PointerInputStream inputStream( buffer + md3Surface.ofsShaders );
270                         istream_read_md3Shader( inputStream, md3Shader );
271                 }
272                 surface.setShader( md3Shader.name );
273         }
274
275         surface.updateAABB();
276
277         return md3Surface.ofsEnd;
278 }
279
280 void MD3Model_read( Model& model, unsigned char* buffer ){
281         md3Header_t md3Header;
282         {
283                 PointerInputStream inputStream( buffer );
284                 istream_read_md3Header( inputStream, md3Header );
285         }
286
287         unsigned char* surfacePosition = buffer + md3Header.ofsSurfaces;
288
289         for ( int i = 0; i != md3Header.numSurfaces; ++i )
290         {
291                 surfacePosition += MD3Surface_read( model.newSurface(), surfacePosition );
292         }
293
294         model.updateAABB();
295 }
296
297 scene::Node& MD3Model_new( unsigned char* buffer ){
298         ModelNode* modelNode = new ModelNode();
299         MD3Model_read( modelNode->model(), buffer );
300         return modelNode->node();
301 }
302
303 scene::Node& MD3Model_default(){
304         ModelNode* modelNode = new ModelNode();
305         Model_constructNull( modelNode->model() );
306         return modelNode->node();
307 }
308
309 scene::Node& MD3Model_fromBuffer( unsigned char* buffer ){
310         if ( !ident_equal( buffer, MD3_IDENT ) ) {
311                 globalErrorStream() << "MD3 read error: incorrect ident\n";
312                 return MD3Model_default();
313         }
314         else
315         {
316                 return MD3Model_new( buffer );
317         }
318 }
319
320 scene::Node& loadMD3Model( ArchiveFile& file ){
321         ScopedArchiveBuffer buffer( file );
322         return MD3Model_fromBuffer( buffer.buffer );
323 }