source: trunk/src/formats/md3_loader.cc @ 200

Last change on this file since 200 was 200, checked in by epyon, 12 years ago
  • compilation and warning fixes
File size: 15.1 KB
Line 
1// Copyright (C) 2012-2013 ChaosForge / Kornel Kisielewicz
2// http://chaosforge.org/
3//
4// This file is part of NV Libraries.
5// For conditions of distribution and use, see copyright notice in nv.hh
6
7#include "nv/formats/md3_loader.hh"
8
9#include <glm/gtc/constants.hpp>
10#include "nv/logging.hh"
11#include <cstring>
12
13using namespace nv;
14
15// based on http://www.icculus.org/~phaethon/q3/formats/md3format.html#Surface
16
17// assuming low-endian
18#define MD3_MAX_FRAMES    1024
19#define MD3_MAX_TAGS      16
20#define MD3_MAX_SURFACES  32
21#define MD3_MAX_SHADERS   256
22#define MD3_MAX_VERTS     4096
23#define MD3_MAX_TRIANGLES 8192
24#define MD3_XYZ_SCALE     (1.0f/64.0f)
25
26struct md3_vec3_t
27{
28        float xyz[3];
29};
30
31struct md3_header_t
32{
33        char   ident[4]; // IDP3
34        sint32 version;  // 15
35        uint8  name[64]; // path name
36        sint32 flags;
37        sint32 num_frames;     // Number of Frame objects, with a maximum of MD3_MAX_FRAMES. Current value of MD3_MAX_FRAMES is 1024.
38        sint32 num_tags;       // Number of Tag objects, with a maximum of MD3_MAX_TAGS. Current value of MD3_MAX_TAGS is 16.
39        sint32 num_surfaces;   // Number of Surface objects, with a maximum of MD3_MAX_SURFACES. Current value of MD3_MAX_SURFACES is 32.
40        sint32 num_skins;      // Number of Skin objects. I should note that I have not seen an MD3 using this particular field for anything; this appears to be an artifact from the Quake 2 MD2 format. Surface objects have their own Shader field.
41        sint32 ofs_frames;     // Relative offset from start of MD3 object where Frame objects start. The Frame objects are written sequentially, that is, when you read one Frame object, you do not need to seek() for the next object.
42        sint32 ofs_tags;       // Relative offset from start of MD3 where Tag objects start. Similarly written sequentially.
43        sint32 ofs_surfaces;   // Relative offset from start of MD3 where Surface objects start. Again, written sequentially.
44        sint32 ofs_eof;        // Relative offset from start of MD3 to the end of the MD3 object. Note there is no offset for Skin objects.
45};
46
47struct md3_frame_t
48{
49        md3_vec3_t min_bounds;
50        md3_vec3_t max_bounds;
51        md3_vec3_t local_origin;
52        float      radius;
53        uint8      name[16];
54};
55
56struct md3_tag_t
57{
58        uint8      name[64];
59        md3_vec3_t origin;
60        md3_vec3_t axis[3];
61};
62
63struct md3_surface_header_t
64{
65        char   ident[4]; // IDP3
66        uint8  name[64]; // path name
67        sint32 flags;
68        sint32 num_frames;
69        sint32 num_shaders;
70        sint32 num_verts;
71        sint32 num_triangles;
72        sint32 ofs_triangles;
73        sint32 ofs_shaders;
74        sint32 ofs_st;
75        sint32 ofs_xyznormal;
76        sint32 ofs_end;
77};
78
79struct md3_shader_t
80{
81        uint8  name[64];
82        sint32 shader_index;
83};
84
85struct md3_triangle_t
86{
87        sint32 indexes[3];
88};
89
90struct md3_texcoord_t
91{
92        float  st[2];
93};
94
95struct md3_vertex_t
96{
97        sint16 x;
98        sint16 y;
99        sint16 z;
100        uint16 normal;
101};
102
103struct md3_surface_t
104{
105        md3_surface_header_t header;
106        md3_shader_t*        shaders;
107        md3_triangle_t*      triangles;
108        md3_texcoord_t*      st;
109        md3_vertex_t*        vertices;
110};
111
112struct md3_t
113{
114        md3_header_t   header;
115        md3_frame_t*   frames;
116        md3_tag_t*     tags;
117        md3_surface_t* surfaces;
118        // extra information (not in md3 file)
119        sint32         vertices_per_frame;
120};
121
122static bool check_md3_magic( char* magic )
123{
124        return magic[0] == 'I' && magic[1] == 'D' && magic[2] == 'P' && magic[3] == '3';
125}
126
127static void free_md3_surface( md3_surface_t * surface )
128{
129        delete[] surface->shaders;
130        delete[] surface->triangles;
131        delete[] surface->st;
132        delete[] surface->vertices;
133}
134
135static void free_md3( md3_t * md3 )
136{
137        sint32 count = md3->header.num_surfaces;
138        for ( sint32 i = 0; i < count; ++i )
139        {
140                free_md3_surface( &md3->surfaces[i] );
141        }
142        delete[] md3->frames;
143        delete[] md3->tags;
144        delete[] md3->surfaces;
145}
146
147static bool read_surface( md3_surface_t * surface, nv::stream& source )
148{
149        sint32 pos = static_cast< sint32 >( source.tell() );
150        source.read( &surface->header, sizeof(md3_surface_header_t), 1 );
151
152        if ( !check_md3_magic( surface->header.ident ) )          return false;
153        if ( surface->header.num_frames    >  MD3_MAX_FRAMES )    return false;
154        if ( surface->header.num_shaders   >  MD3_MAX_SHADERS )   return false;
155        if ( surface->header.num_verts     >  MD3_MAX_VERTS )     return false;
156        if ( surface->header.num_triangles >  MD3_MAX_TRIANGLES ) return false;
157
158        surface->shaders   = new md3_shader_t  [ surface->header.num_shaders ];
159        surface->vertices  = new md3_vertex_t  [ surface->header.num_verts * surface->header.num_frames ];
160        surface->st        = new md3_texcoord_t[ surface->header.num_verts ];
161        surface->triangles = new md3_triangle_t[ surface->header.num_triangles ];
162
163        source.seek( pos + surface->header.ofs_shaders, origin::SET );
164        source.read( surface->shaders, sizeof( md3_shader_t ), static_cast<size_t>( surface->header.num_shaders ) );
165
166        source.seek( pos + surface->header.ofs_triangles, origin::SET );
167        source.read( surface->triangles, sizeof( md3_triangle_t ), static_cast<size_t>( surface->header.num_triangles ) );
168
169        source.seek( pos + surface->header.ofs_st, origin::SET );
170        source.read( surface->st, sizeof( md3_texcoord_t ), static_cast<size_t>( surface->header.num_verts ) );
171
172        source.seek( pos + surface->header.ofs_xyznormal, origin::SET );
173        source.read( surface->vertices, sizeof( md3_vertex_t ), static_cast<size_t>( surface->header.num_verts * surface->header.num_frames ) );
174
175        if ( source.tell() != static_cast<std::size_t>( pos + surface->header.ofs_end ) ) return false;
176
177        return true;
178}
179
180static bool read_md3( md3_t * md3, nv::stream& source )
181{
182        md3->frames   = nullptr;
183        md3->tags     = nullptr;
184        md3->surfaces = nullptr;
185
186        source.read( &md3->header, sizeof(md3_header_t), 1 );
187
188        if ( !check_md3_magic( md3->header.ident ) )        return false;
189        if ( md3->header.num_frames   >  MD3_MAX_FRAMES )   return false;
190        if ( md3->header.num_tags     >  MD3_MAX_TAGS )     return false;
191        if ( md3->header.num_surfaces >  MD3_MAX_SURFACES )
192        {
193                // to always have a safe free
194                md3->header.num_surfaces = 0;
195                return false;
196        }
197
198        md3->frames   = new md3_frame_t  [ md3->header.num_frames ];
199        md3->tags     = new md3_tag_t    [ md3->header.num_tags * md3->header.num_frames ];
200        md3->surfaces = new md3_surface_t[ md3->header.num_surfaces ];
201        std::memset( md3->surfaces, 0, static_cast< size_t >( md3->header.num_surfaces ) * sizeof(md3_surface_t) );
202
203        source.seek( md3->header.ofs_frames, origin::SET );
204        source.read( md3->frames, sizeof( md3_frame_t ), static_cast<size_t>( md3->header.num_frames ) );
205
206        source.seek( md3->header.ofs_tags, origin::SET );
207        source.read( md3->tags, sizeof( md3_tag_t ), static_cast<size_t>( md3->header.num_tags * md3->header.num_frames ) );
208
209        source.seek( md3->header.ofs_surfaces, origin::SET );
210        md3->vertices_per_frame = 0;
211
212        for ( sint32 i = 0; i < md3->header.num_surfaces; ++i )
213        {
214                if ( !read_surface( md3->surfaces + i, source ) ) return false;
215                if ( md3->header.num_frames != md3->surfaces[i].header.num_frames ) return false;
216                md3->vertices_per_frame += md3->surfaces[i].header.num_verts;
217        }
218        return true;
219}
220
221static inline vec3 md3_vec3( const md3_vec3_t& v )
222{
223//      return vec3( v.xyz[0], v.xyz[1], v.xyz[2] );
224        return vec3( v.xyz[0], v.xyz[2], v.xyz[1] );
225}
226
227static inline vec2 md3_texcoord( const md3_texcoord_t& v )
228{
229        return vec2( v.st[0], v.st[1] );
230}
231
232static vec3 s_normal_cache[256*256];
233static bool s_normal_ready = false;
234
235md3_loader::md3_loader()
236        : m_md3( nullptr ), m_size( 0 )
237{
238        if ( !s_normal_ready )
239        {
240                float pi      = glm::pi<float>();
241                float convert = (2 * pi) / 255.0f;
242                int n = 0;
243                for ( int lat = 0; lat < 256; ++lat )
244                {
245                        float flat    = lat * convert;
246                        float sin_lat = glm::sin( flat );
247                        float cos_lat = glm::cos( flat );
248                        for ( int lng = 0; lng < 256; ++lng, ++n )
249                        {
250                                float flng    = lng * convert;
251                                float sin_lng = glm::sin( flng );
252                                float cos_lng = glm::cos( flng );
253                                s_normal_cache[n].x = cos_lat * sin_lng;
254//                              s_normal_cache[n].y = sin_lat * sin_lng;
255//                              s_normal_cache[n].z = cos_lng;
256                                s_normal_cache[n].z = sin_lat * sin_lng;
257                                s_normal_cache[n].y = cos_lng;
258                        }
259                }
260
261                s_normal_ready = true;
262        }
263}
264
265
266nv::md3_loader::~md3_loader()
267{
268        if (m_md3 != nullptr)
269        {
270                free_md3( (md3_t*)(m_md3) );
271                delete (md3_t*)m_md3;
272        }
273}
274
275bool nv::md3_loader::load( stream& source )
276{
277        m_tags.clear();
278        m_size = 0;
279
280        m_md3 = (void*)(new md3_t);
281        if ( !read_md3( (md3_t*)m_md3, source ) )
282        {
283                return false;
284        }
285        return true;
286}
287
288mesh* nv::md3_loader::release_mesh()
289{
290        return get_frame( 0 );
291}
292
293mesh* nv::md3_loader::get_frame( sint32 frame )
294{
295        mesh* m = new mesh();
296        md3_t* md3 = (md3_t*)m_md3;
297
298        NV_LOG( LOG_INFO, "Tags:" );
299        for ( sint32 i = 0; i < md3->header.num_tags; ++i )
300        {
301                const md3_tag_t& rtag = md3->tags[i + md3->header.num_tags * frame];
302
303                md3_tag& tag   = m_tags[ (char*)(rtag.name) ];
304                tag.name       = (char*)(rtag.name);
305                vec4 axisx     = vec4( md3_vec3( rtag.axis[0] ), 0.0 );
306                vec4 axisz     = vec4( md3_vec3( rtag.axis[1] ), 0.0 );
307                vec4 axisy     = vec4( md3_vec3( rtag.axis[2] ), 0.0 );
308                vec4 origin    = vec4( md3_vec3( rtag.origin ),  1.0 );
309                tag.transform  = glm::mat4( axisx, axisy, axisz, origin );
310                NV_LOG( LOG_INFO, "Tag " << tag.name << " found" );
311        }
312
313        vertex_attribute< vec3 >* position = m->add_attribute<vec3>("nv_position");
314        vertex_attribute< vec3 >* normal   = m->add_attribute<vec3>("nv_normal");
315        vertex_attribute< vec2 >* texcoord = m->add_attribute<vec2>("nv_texcoord");
316        vertex_attribute< uint16 >* indices  = m->add_indices<uint16>();
317
318        load_positions( position->get(), frame );
319        load_normals( normal->get(), frame );
320
321        load_texcoords( texcoord->get() );
322        load_indicies( indices->get() );
323
324        m_size = indices->get().size();
325        return m;
326}
327
328void nv::md3_loader::load_tags( std::vector<mat4>& t, const std::string& tag )
329{
330        md3_t* md3 = (md3_t*)m_md3;
331        t.clear();
332        for ( sint32 f = 0; f < md3->header.num_frames; ++f )
333        {
334                for ( sint32 i = 0; i < md3->header.num_tags; ++i )
335                {
336                        const md3_tag_t& rtag = md3->tags[i + md3->header.num_tags * f];
337                        std::string rname((char*)(rtag.name));
338                        if (rname == tag)
339                        {
340                                vec4 axisx     = vec4( md3_vec3( rtag.axis[0] ), 0.0 );
341                                vec4 axisz     = vec4( md3_vec3( rtag.axis[1] ), 0.0 );
342                                vec4 axisy     = vec4( md3_vec3( rtag.axis[2] ), 0.0 );
343                                vec4 origin    = vec4( md3_vec3( rtag.origin ),  1.0 );
344                                t.emplace_back( axisx, axisy, axisz, origin );
345                        }
346                }
347
348        }
349}
350
351size_t md3_loader::get_max_frames() const
352{
353        return static_cast< size_t >( ((md3_t*)m_md3)->header.num_frames );
354}
355
356void md3_loader::load_tag_names( std::vector< std::string >& tags )
357{
358        tags.clear();
359        md3_t* md3 = (md3_t*)m_md3;
360        for ( sint32 i = 0; i < md3->header.num_tags; ++i )
361        {
362                const md3_tag_t& rtag = md3->tags[i + md3->header.num_tags];
363                tags.push_back( (char*)(rtag.name) );
364        }
365}
366
367mat4 md3_loader::get_tag( sint32 frame, const std::string& name ) const
368{
369        md3_t* md3 = (md3_t*)m_md3;
370        for ( sint32 i = 0; i < md3->header.num_tags; ++i )
371        {
372                const md3_tag_t& rtag = md3->tags[i + md3->header.num_tags * frame];
373                std::string rname((char*)(rtag.name));
374                if (rname == name)
375                {
376                        vec4 axisx     = vec4( md3_vec3( rtag.axis[0] ), 0.0 );
377                        vec4 axisz     = vec4( md3_vec3( rtag.axis[1] ), 0.0 );
378                        vec4 axisy     = vec4( md3_vec3( rtag.axis[2] ), 0.0 );
379                        vec4 origin    = vec4( md3_vec3( rtag.origin ),  1.0 );
380                        return glm::mat4( axisx, axisy, axisz, origin );
381                }
382        }
383        return glm::mat4();
384}
385
386const md3_tag* md3_loader::get_tag( const std::string& name ) const
387{
388        auto it = m_tags.find( name );
389        if ( it == m_tags.end() ) return nullptr;
390        return &(it->second);
391}
392
393void md3_loader::load_positions( std::vector<vec3>& p, sint32 frame /*=-1*/ )
394{
395        md3_t* md3 = (md3_t*)m_md3;
396        sint32 num_surfaces = md3->header.num_surfaces;
397        p.clear();
398        sint32 current_frame = ( frame == -1 ? 0 : frame );
399        sint32 frame_count   = ( frame == -1 ? md3->header.num_frames : 1 );
400
401        p.reserve( static_cast< size_t >( md3->vertices_per_frame * frame_count ) );
402
403        while ( frame_count > 0 )
404        {
405                for ( sint32 i = 0; i < num_surfaces; ++i )
406                {
407                        md3_surface_t& surface = md3->surfaces[i];
408                        sint32         vcount  = surface.header.num_verts;
409                        sint32         offset  = vcount * current_frame;
410                        sint32         limit   = vcount + offset;
411                        for (sint32 j = offset; j < limit; ++j )
412                        {
413                                md3_vertex_t& v = surface.vertices[j];
414                                p.push_back( vec3( v.x * MD3_XYZ_SCALE, v.z * MD3_XYZ_SCALE, v.y * MD3_XYZ_SCALE ) );
415                        }
416                }
417                ++current_frame;
418                --frame_count;
419        }
420}
421
422void md3_loader::load_normals( std::vector<vec3>& n, sint32 frame /*=-1*/ )
423{
424        md3_t* md3 = (md3_t*)m_md3;
425        sint32 num_surfaces = md3->header.num_surfaces;
426        n.clear();
427        sint32 current_frame = ( frame == -1 ? 0 : frame );
428        sint32 frame_count   = ( frame == -1 ? md3->header.num_frames : 1 );
429
430        n.reserve( static_cast< size_t >( md3->vertices_per_frame * frame_count ) );
431
432        while ( frame_count > 0 )
433        {
434                for ( sint32 i = 0; i < num_surfaces; ++i )
435                {
436                        md3_surface_t& surface = md3->surfaces[i];
437                        sint32         vcount  = surface.header.num_verts;
438                        sint32         offset  = vcount * current_frame;
439                        sint32         limit   = vcount + offset;
440                        for (sint32 j = offset; j < limit; ++j )
441                        {
442                                n.push_back( s_normal_cache[ surface.vertices[j].normal ] );
443                        }
444                }
445                ++current_frame;
446                --frame_count;
447        }
448}
449
450void md3_loader::load_texcoords( std::vector<vec2>& t )
451{
452        md3_t* md3 = (md3_t*)m_md3;
453        sint32 num_surfaces = md3->header.num_surfaces;
454        t.clear();
455        for ( sint32 i = 0; i < num_surfaces; ++i )
456        {
457                const md3_surface_t& surface = md3->surfaces[i];
458                const uint32         vcount  = static_cast< uint32 >( surface.header.num_verts );
459                t.reserve( t.size() + vcount );
460                for (uint32 j = 0; j < vcount; ++j )
461                {
462                        t.push_back( md3_texcoord( surface.st[j] ) );
463                }
464        }
465}
466
467void md3_loader::load_indicies( std::vector<uint16>& idx )
468{
469        md3_t* md3 = (md3_t*)m_md3;
470        sint32 num_surfaces = md3->header.num_surfaces;
471        idx.clear();
472        sint32 index_base = 0;
473        for ( sint32 i = 0; i < num_surfaces; ++i )
474        {
475                const md3_surface_t& surface = md3->surfaces[i];
476                const size_t         tcount  = static_cast< size_t >( surface.header.num_triangles );
477
478                idx.reserve( idx.size() + tcount * 3 );
479                for (size_t j = 0; j < tcount; ++j )
480                {
481                        const md3_triangle_t& t = surface.triangles[j];
482                        idx.push_back( static_cast< uint16 >( index_base + t.indexes[0] ) );
483                        idx.push_back( static_cast< uint16 >( index_base + t.indexes[1] ) );
484                        idx.push_back( static_cast< uint16 >( index_base + t.indexes[2] ) );
485                }
486
487                index_base += surface.header.num_verts;
488        }
489
490}
491
492keyframed_mesh_data::keyframed_mesh_data( keyframed_loader* loader )
493{
494        loader->load_positions( m_positions );
495        loader->load_normals( m_normals );
496        loader->load_texcoords( m_texcoords );
497        loader->load_indicies( m_indices );
498
499        std::vector< std::string > names;
500
501        md3_loader* md3loader = dynamic_cast< md3_loader* >( loader );
502        if ( md3loader != nullptr )
503        {
504                md3loader->load_tag_names( names );
505                for ( auto& name : names )
506                {
507                        md3loader->load_tags( m_tags[ name ], name );
508                }
509        }
510
511        m_frames = loader->get_max_frames();
512}
513
Note: See TracBrowser for help on using the repository browser.