source: trunk/legacy/md2_loader.cc @ 480

// Copyright (C) 2012-2015 ChaosForge Ltd
// http://chaosforge.org/
//
// This file is part of Nova libraries. 
// For conditions of distribution and use, see copying.txt file in root folder.

#include "nv/formats/md2_loader.hh"

#include "nv/core/logging.hh"
#include "nv/interface/data_channel_access.hh"

#include <cstring>

using namespace nv;

// based on http://tfc.duke.free.fr/coding/md2-specs-en.html

// assuming low-endian
#define MD2_MAX_FRAMES    512
#define MD2_MAX_SKINS     32
#define MD2_MAX_VERTS     2048
#define MD2_MAX_TRIANGLES 4096
#define MD2_MAX_TEXCOORDS 2048
#define MD2_NORMAL_COUNT  162

typedef float md2_vec3_t[3];

static const md2_vec3_t md2_normal_table[MD2_NORMAL_COUNT] = {
#include "src/formats/md2_normals.inc"
};

struct md2_header_t
{
        char magic[4];
        int version;

        int skinwidth;
        int skinheight;

        int framesize;

        int num_skins;
        int num_vertices;
        int num_st;
        int num_tris;
        int num_glcmds;
        int num_frames;

        int offset_skins;
        int offset_st;
        int offset_tris;
        int offset_frames;
        int offset_glcmds;
        int offset_end;
};

struct md2_skin_t
{
        char name[64];
};

struct md2_texcoord_t
{
        short s;
        short t;
};

struct md2_triangle_t
{
        unsigned short vertex[3];
        unsigned short st[3];
};

struct md2_vertex_t
{
        uint8 v[3];
        uint8 n;
};

struct md2_frame_t
{
        md2_vec3_t scale;
        md2_vec3_t translate;
        char name[16];
        md2_vertex_t *vertices;
};

struct md2_glcmd_t
{
        float s;
        float t;
        int index;
};

struct md2_t
{
        md2_header_t    header;
        md2_skin_t*     skins;
        md2_texcoord_t* texcoords;
        md2_triangle_t* triangles;
        md2_frame_t*    frames;
        int*            glcmds;
};

static bool check_md2_magic( char* magic )
{
        return magic[0] == 'I' && magic[1] == 'D' && magic[2] == 'P' && magic[3] == '2';
}

static void free_md2_frame( md2_frame_t* frame )
{
        delete[] frame->vertices;
}

static void free_md2( md2_t* md2 )
{
        delete[] md2->skins;
        delete[] md2->texcoords;
        delete[] md2->triangles;
        delete[] md2->glcmds;
        for ( int i = 0; i < md2->header.num_frames; ++i )
        {
                free_md2_frame( &(md2->frames[i]) );
        }
        delete[] md2->frames;
}

static bool read_md2_frame( md2_frame_t* frame, unsigned vcount, nv::stream& source )
{
        frame->vertices = new md2_vertex_t[ vcount ];
        source.read( frame->scale,     sizeof(md2_vec3_t), 1 );
        source.read( frame->translate, sizeof(md2_vec3_t), 1 );
        source.read( frame->name,      sizeof(char), 16 );
        source.read( frame->vertices,  sizeof(md2_vertex_t), vcount );
        return true;
}

static bool read_md2( md2_t* md2, nv::stream& source )
{
        md2->frames     = nullptr;
        md2->skins      = nullptr;
        md2->texcoords  = nullptr;
        md2->triangles  = nullptr;
        md2->glcmds     = nullptr;

        source.read( &(md2->header), sizeof(md2_header_t), 1 );

        if ( !check_md2_magic( md2->header.magic )       ||
                md2->header.num_skins    > MD2_MAX_SKINS     ||
                md2->header.num_vertices > MD2_MAX_VERTS     ||
                md2->header.num_st       > MD2_MAX_TEXCOORDS ||
                md2->header.num_tris     > MD2_MAX_TRIANGLES ||
                md2->header.num_frames   > MD2_MAX_FRAMES )
        {
                return false;
        }

        NV_LOG_INFO( "num_skins    = ", md2->header.num_skins );
        NV_LOG_INFO( "num_vertices = ", md2->header.num_vertices );
        NV_LOG_INFO( "num_st       = ", md2->header.num_st );
        NV_LOG_INFO( "num_tris     = ", md2->header.num_tris );
        NV_LOG_INFO( "num_frames   = ", md2->header.num_frames );


        md2->skins      = new md2_skin_t    [ md2->header.num_skins ];
        md2->texcoords  = new md2_texcoord_t[ md2->header.num_st ];
        md2->triangles  = new md2_triangle_t[ md2->header.num_tris ];
        md2->glcmds     = new int           [ md2->header.num_glcmds ];
        
        source.seek( md2->header.offset_skins, origin::SET );
        source.read( md2->skins, sizeof( md2_skin_t ), static_cast<nv::size_t>( md2->header.num_skins ) );

        source.seek( md2->header.offset_st, origin::SET );
        source.read( md2->texcoords, sizeof( md2_texcoord_t ), static_cast<nv::size_t>( md2->header.num_st ) );

        source.seek( md2->header.offset_tris, origin::SET );
        source.read( md2->triangles, sizeof( md2_triangle_t ), static_cast<nv::size_t>( md2->header.num_tris ) );

        source.seek( md2->header.offset_glcmds, origin::SET);
        source.read( md2->glcmds, sizeof( int ), static_cast<nv::size_t>( md2->header.num_glcmds ) );

        md2->frames    = new md2_frame_t   [ md2->header.num_frames ];
        source.seek( md2->header.offset_frames, origin::SET );
        for ( int i = 0; i < md2->header.num_frames; ++i )
        {
                if (!read_md2_frame( &(md2->frames[i]), static_cast<unsigned>( md2->header.num_vertices ), source ) ) return false;
        }

        return true;
}

static inline vec3 md2_vec3( const md2_vec3_t& v )
{
        //      return vec3( v[0], v[1], v[2] );
        return vec3( v[0], v[2], v[1] );
}

static vec3 s_md2_normal_cache[MD2_NORMAL_COUNT];
static bool s_md2_normal_ready = false;

md2_loader::md2_loader( string_table* strings ) 
        : mesh_loader( strings ), m_md2( nullptr )
{
        if ( !s_md2_normal_ready )
        {
                for ( int i = 0; i < MD2_NORMAL_COUNT; ++i )
                {
                        s_md2_normal_cache[i].x = md2_normal_table[i][0];
//                      s_md2_normal_cache[i].y = md2_normal_table[i][1];
//                      s_md2_normal_cache[i].z = md2_normal_table[i][2];
                        s_md2_normal_cache[i].y = md2_normal_table[i][2];
                        s_md2_normal_cache[i].z = md2_normal_table[i][1];
                }
        }
}


md2_loader::~md2_loader()
{
        md2_t* md2 = reinterpret_cast< md2_t* >( m_md2 );
        if ( md2 != nullptr)
        {
                free_md2( md2 );
                delete md2;
        }
}

bool md2_loader::load( stream& source )
{
        md2_t* md2 = new md2_t; 
        m_md2 = md2;
        if ( !read_md2( md2, source ) )
        {
                return false;
        }
        reindex();
        return true;
}

nv::size_t md2_loader::get_max_frames() const
{
        return static_cast<size_t>( reinterpret_cast<md2_t*>( m_md2 )->header.num_frames );
}

void nv::md2_loader::reindex()
{
        md2_t* md2 = reinterpret_cast< md2_t* >( m_md2 );
        uint32 num_indexes = static_cast< uint32 >( md2->header.num_tris * 3 );

        uint32 stats_reuse      = 0;
        uint32 stats_collision  = 0;

        vector< sint32 > index_translation( static_cast< uint32 >( md2->header.num_vertices ), -1 );

        m_new_indexes.clear();
        m_new_indexes.reserve( num_indexes );
        m_new_vindexes.reserve( num_indexes );
        m_new_tindexes.reserve( num_indexes );

        uint16 index_count = 0;

        for ( int i = 0; i < md2->header.num_tris; ++i )
        {
                const md2_triangle_t& t = md2->triangles[i];
                for ( int j = 0; j < 3; ++j )
                {
                        uint16 index  = t.vertex[j];
                        uint16 tindex = t.st[j];

                        if ( index_translation[ index ] != -1 )
                        {
                                uint16 prev = static_cast< uint16 >( index_translation[ index ] );
                                if ( m_new_tindexes[ prev ] == tindex )
                                {
                                        m_new_indexes.push_back( prev );
                                        stats_reuse++;
                                        continue;
                                }
                        }
                        
                        m_new_vindexes.push_back( index );
                        m_new_tindexes.push_back( tindex );
                        m_new_indexes.push_back( index_count );
                        if ( index_translation[ index ] == -1 )
                        {
                                index_translation[ index ] = index_count;
                        }
                        else
                        {
                                stats_collision++;
                        }
                        index_count++;
                }
        }

        NV_LOG_INFO( "New vertex count = ", m_new_vindexes.size() );
        NV_LOG_INFO( "Collisions       = ", stats_collision );
        NV_LOG_INFO( "Reuse count      = ", stats_reuse );
}


struct vtx_md2_pn
{
        nv::vec3 position;
        nv::vec3 normal;
};

struct vtx_md2_t
{
        nv::vec2 texcoord;
};


data_channel_set* nv::md2_loader::release_mesh_data( size_t )
{
        data_channel_set* data = data_channel_set_creator::create_set( 3 );
        release_mesh_frame( data, -1 );
        return data;
}

void nv::md2_loader::release_mesh_frame( data_channel_set* data, sint32 frame )
{
        md2_t* md2 = reinterpret_cast< md2_t* >( m_md2 );
        size_t num_frames = static_cast< size_t >( md2->header.num_frames );
        size_t num_verts  =     m_new_vindexes.size();
        size_t current_frame = ( frame == -1 ? 0 : static_cast< size_t >( frame ) );
        size_t frame_count   = ( frame == -1 ? num_frames : 1 );

        data_channel_set_creator maccess( data );
        vtx_md2_pn* vtx_pn = maccess.add_channel< vtx_md2_pn >( num_verts * frame_count ).data();
        vtx_md2_t* vtx_t   = maccess.add_channel< vtx_md2_t >( num_verts ).data();
        uint16* icp        = &maccess.add_channel< index_u16 >( m_new_indexes.size() ).data()->index;

        maccess.set_name( make_name( "md2_mesh" ) );

        uint32 index = 0;
        while ( frame_count > 0 )
        {
                const md2_frame_t& cframe = md2->frames[current_frame];
                NV_LOG_INFO( "FrameID = ", cframe.name );

                vec3 scale     = md2_vec3( cframe.scale );
                vec3 translate = md2_vec3( cframe.translate );

                for (size_t i = 0; i < num_verts; ++i )
                {
                        const md2_vertex_t& v = cframe.vertices[ m_new_vindexes[ i ] ];
                        vtx_pn[index].position = vec3( v.v[0], v.v[2], v.v[1] ) * scale + translate;
                        vtx_pn[index].normal   = s_md2_normal_cache[ v.n ];
                        index++;
                }
                ++current_frame;
                --frame_count;
        }

        vec2 scale( 1.0f / static_cast<float>( md2->header.skinwidth ), 1.0f / static_cast<float>( md2->header.skinheight ) );
        for (size_t i = 0; i < num_verts; ++i )
        {
                const md2_texcoord_t& st = md2->texcoords[ m_new_tindexes[ i ] ];
                vtx_t[i].texcoord = scale * vec2( st.s, st.t );
        }

        if ( m_new_indexes.size() > 0 )
        {
                raw_copy_n( m_new_indexes.data(), m_new_indexes.size(), icp );
        }

}