---

r_md2.cpp

Go to the documentation of this file.

// OMICRON ENGINE HEADER FILE
//
// --------------------------------------------------------------------------
// Copyright (C) 2001-2002 by Bjoern Paetzel <kolrabi@gmx.de>
//
// This file is part of the Omicron Engine.
//
// The Omicron Engine is free software; you can redistribute it and/or modify
// it under the terms of the  GNU General Public License  as published by the
// Free Software Foundation;  either version  2  of the License,  or (at your
// option) any later version.
//
// The Omicron Engine  is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or  FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License
// for more details.
//
// You should have  received a copy of the  GNU General Public License  along
// with The Omicron Engine;  if not,  write to the  Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
//
// --------------------------------------------------------------------------
// Last modified:       $Date: 2002/12/07 19:02:04 $
// By           :       $Author: kolrabi $
// $Id: r_md2.cpp,v 1.1.1.1 2002/12/07 19:02:04 kolrabi Exp $ 

/*

  $Log: r_md2.cpp,v $
  Revision 1.1.1.1  2002/12/07 19:02:04  kolrabi
  initial release


*/

#include            <string.h>
#include            "omicron/internal.h"
#include            "omicron/file.h"
#include            "omicron/render.h"
#include            "omicron/model.h"
#include            "omicron/md2.h"

static vec3_t       normals[162] =
{
#include            "omicron/anorms.h"
};
 
/**************************************************************************** 
 **************************************************************************** 
 * MD2 FUNCTIONS ************************************************************ 
 **************************************************************************** 
 ****************************************************************************/ 

#pragma pack(1)

md2_c::md2_c()
{
    texData       = NULL;
    triData       = NULL;
    vertData      = NULL;
    frameData     = NULL;
    vertices      = NULL;
    drawvertices  = NULL;
    glIndicesData = NULL;
    vertcount     = 0;
    drawvertcount = 0;
} 
 
md2_c::~md2_c() 
{
    AssertThis;

    unload();
}

void md2_c::unload()
{
    AssertThis;

    SafeArrayDelete(texData         );
    SafeArrayDelete(triData         );
    SafeArrayDelete(vertData        );
    SafeArrayDelete(vertices        );
    SafeArrayDelete(drawvertices    );
    SafeArrayDelete(glIndicesData   );

    if (frameData)
        for (ulong index=0;index<header.numFrames;index++) 
            SafeArrayDelete(frameData[index].pvertices); 

    SafeArrayDelete(frameData); 
}
 
 
/* 
  Name : Load 
*/ 
bool md2_c::load(const char* fileName) 
{ 
    AssertThisV;

    unload();

    file_t *file    = gv.fileman->load(fileName, false);

    gv.fileman->read(&header, sizeof header, 1, file);

    // load skin names
    gv.fileman->seek(file, header.offsetSkins, SEEK_SET);
    gv.fileman->read(skinName, MAX_SKIN_NAME, header.numSkins, file);

    // load texture coordinates
    texData = new texture_coord_s[header.numTexCoords];
    gv.fileman->seek(file, header.offsetTexCoord, SEEK_SET);
    gv.fileman->read(texData, sizeof(texture_coord_s), header.numTexCoords, file);

    // load triangles
    triData = new triangle_s[header.numTriangles];
    gv.fileman->seek(file, header.offsetTriangles, SEEK_SET);
    gv.fileman->read(triData, sizeof(triangle_s), header.numTriangles, file);

    // load frames
    ulong   index;
    ulong   frameVertSize = header.numVertices * sizeof(triangle_vertex_s);

    frameData = new frame_s[header.numFrames];

    memset(frameData, 0, sizeof(frameData));

    gv.fileman->seek(file, header.offsetFrames, SEEK_SET);
    
    for (index = 0; index<header.numFrames; index++)
    {
        gv.fileman->read(&frameData[index], FRAME_HEADER_SIZE, 1, file);

        frameData[index].pvertices = new triangle_vertex_s[header.numVertices];

        gv.fileman->read(frameData[index].pvertices, frameVertSize, 1, file);
    }

    // ------------------------

    gv.fileman->close(file);

    SafeArrayDelete(vertices); 
    SafeArrayDelete(drawvertices); 

    vertcount       = header.numVertices;
    drawvertcount   = header.numTriangles*3;
    vertices        = new vertex_t[vertcount];
    drawvertices    = new vertex_t[drawvertcount];

    set_frame(0);

    return true;
}

void md2_c::set_frame(float frame) 
{ 
    AssertThis;

    ulong frameidx      = (ulong)(floor(frame));
    ulong nextframeidx  = (frameidx+1)%header.numFrames;
    float framefrac     = frame-frameidx;
 
    ulong index         = 0;
    ulong tri           = 0;

    AssertReturn1(vertices);

    vec3_c              scale1  = frameData[frameidx].scale;
    vec3_c              scale2  = frameData[nextframeidx].scale;
    vec3_c              offset1 = frameData[frameidx].translate;
    vec3_c              offset2 = frameData[nextframeidx].translate;

    for (index=0;index<header.numVertices;index++) 
    { 
        vec3_c     tmp, tmp2, tmp3;
        vec3_c     vnorm1, vnorm2;

        tmp.set(    (float)frameData[frameidx].pvertices[index].vertex[0],
                    (float)frameData[frameidx].pvertices[index].vertex[1],
                    (float)frameData[frameidx].pvertices[index].vertex[2]);

        tmp = tmp * scale1 + offset1;

        tmp2.set(   (float)frameData[nextframeidx].pvertices[index].vertex[0],
                    (float)frameData[nextframeidx].pvertices[index].vertex[1],
                    (float)frameData[nextframeidx].pvertices[index].vertex[2]);

        tmp2 = tmp2 * scale2 + offset2;

        (vec3_c::linear(tmp, tmp2, framefrac)).copy(vertices[index].xyz);
        
        vertices[index].uv[0][0] = (float)texData[index].s/(float)header.skinWidth;
        vertices[index].uv[0][1] = (float)texData[index].t/(float)header.skinHeight;

        vnorm1 = normals[frameData[frameidx     ].pvertices[index].lnormal_idx];
        vnorm2 = normals[frameData[nextframeidx ].pvertices[index].lnormal_idx];

        (vec3_c::linear(vnorm1, vnorm2, framefrac).normalize()).copy(vertices[index].normal);
    }

    memset(drawvertices, 0, sizeof(vertex_t)*drawvertcount);

    for (tri = 0; tri<header.numTriangles; tri++)
    {
        for (ulong vert = 0; vert<3; vert++)
        {
            ulong v         = tri*3+vert;
            ulong thevert   = triData[tri].vert_idx[vert];
            ulong texvert   = triData[tri].tex_idx[vert];

            (vec3_c(vertices[thevert].xyz)).copy(drawvertices[v].xyz);
            (vec2_c(vertices[texvert].uv[0])).copy(drawvertices[v].uv[0]);
            (vec3_c(vertices[thevert].normal)).copy(drawvertices[v].normal);
            drawvertices[v].diffuse = 0xFFFFFFFF;
        }
    }
    for (index=0;index<header.numVertices;index++) 
    { 
        ((vec3_c(drawvertices[index].normal)).normalize()).copy(drawvertices[index].normal);
    }
} 

ulong md2_c::get_frame_count()
{
    AssertThisV;

    return header.numFrames;
}

#pragma pack(8)

---