---

r_kmf.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:05 $
// By           :       $Author: kolrabi $
// $Id: r_kmf.cpp,v 1.1.1.1 2002/12/07 19:02:05 kolrabi Exp $ 

/*

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


*/

#include            <string.h>

#include            "omicron/internal.h"
#include            "omicron/file.h"
#include            "omicron/render.h"
#include            "omicron/model.h"

/**************************************************************************** 
 **************************************************************************** 
 * MD2 FUNCTIONS ************************************************************ 
 **************************************************************************** 
 ****************************************************************************/ 
 
kmf_c::kmf_c() 
{ 
    memset(&header, 0, sizeof(header));
    verts           = NULL;
    tris            = NULL;
    mods            = NULL;
    normals         = NULL;
    tmpdrawvertices = NULL;
    drawvertices    = NULL;
    shader          = NULL;
} 
 
kmf_c::~kmf_c() 
{ 
    AssertThis;

    unload();
}

void kmf_c::unload()
{
    AssertThis;

    SafeArrayDelete(verts);
    SafeArrayDelete(tris);
    SafeArrayDelete(mods);
    SafeArrayDelete(normals);
    SafeArrayDelete(tmpdrawvertices);
    SafeArrayDelete(drawvertices);
}

bool kmf_c::load(const char *filename)
{
    AssertThisV;
    AssertReturnValue1(filename, 0);

    unload();

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

    AssertReturnValue1(file, 0);

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

    if (header.version != 3                 ||    // wrong version
        memcmp(header.magic, KMF_MAGIC, 4)  ||    // wrong magic
        !header.framecount)                       // no content
    {
        gv.fileman->close(file);
        return false;
    }

    shader = shader_load(header.texturename);

    mods  = new kmf_vertmodifier_t[header.framecount];
    gv.fileman->read(mods,  sizeof(kmf_vertmodifier_t), 
      header.framecount, file);

    tris  = new ulong[header.triangles*3];
    gv.fileman->read(tris,  sizeof(ulong), 
      header.triangles*3, file);

    verts = new kmf_vertex_t[header.vertices*header.framecount];
    gv.fileman->read(verts, sizeof(kmf_vertex_t), 
      header.vertices*header.framecount, file);

    normals = new uchar[header.framecount*header.triangles*3*3];
    gv.fileman->read(normals, sizeof(char), 
      header.framecount*header.triangles*3*3, file);

    tmpdrawvertices = new vertex_t[header.vertices];

    drawvertices = new vertex_t[header.triangles*3];
    drawvertcount = header.triangles*3;

    gv.fileman->close(file);

    set_frame(0);

    return true;
}

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

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

    vec3_t   pos1, pos2;
    vec2_t   uv1,  uv2;
    vec3_t   norm1, norm2;
    vec3_c  tmp;

    AssertReturn1(verts);

    for (index=0; index<header.vertices; index++) 
    { 
        ulong     vertindex1 = index+frameidx*header.vertices;
        ulong     vertindex2 = index+nextframeidx*header.vertices;


        for (i=0; i<3; i++)
        {
            pos1[i] = ((float)((uchar)verts[vertindex1].pos[i]))/255.0f*
                mods[frameidx].scale[i]+mods[frameidx].offset[i];

            pos2[i] = ((float)((uchar)verts[vertindex2].pos[i]))/255.0f*
                mods[nextframeidx].scale[i]+mods[nextframeidx].offset[i];
        }

        float t;

        t = pos1[2];        pos1[2] = pos1[1];        pos1[1] = -t;
        t = pos2[2];        pos2[2] = pos2[1];        pos2[1] = -t;

        uv1[0] = verts[vertindex1].uv[0]/255.0f;
        uv1[1] = verts[vertindex1].uv[1]/255.0f;
        uv2[0] = verts[vertindex2].uv[0]/255.0f;
        uv2[1] = verts[vertindex2].uv[1]/255.0f;

        tmp.linear(pos1, pos2, framefrac);
        tmp.copy(tmpdrawvertices[index].xyz);

        vec2_c::linear(uv1, uv2, framefrac).copy(tmpdrawvertices[index].uv[0]);
        tmpdrawvertices[index].diffuse = -1;

        tmp.unpack_normal(verts[vertindex1].normal); tmp.copy(norm1);
        tmp.unpack_normal(verts[vertindex2].normal); tmp.copy(norm2);

        tmp.linear(norm1, norm2, framefrac);
        tmp.normalize().copy(tmpdrawvertices[index].normal);
    }

    for (tri = 0; tri<header.triangles; tri++)
    {
//        ulong nindex1 = frameidx*header.triangles*9+9*tri;
//        ulong nindex2 = nextframeidx*header.triangles*9+9*tri;

        for (ulong vert = 0; vert<3; vert++)
        {
            drawvertices[tri*3+vert] = tmpdrawvertices[tris[tri*3+vert]];
/*
            norm1[0] = ((float)(normals[nindex1+vert*3+0]-127))/127.0f;
            norm1[1] = ((float)(normals[nindex1+vert*3+1]-127))/127.0f;
            norm1[2] = ((float)(normals[nindex1+vert*3+2]-127))/127.0f;

            norm2[0] = ((float)(normals[nindex2+vert*3+0]-127))/127.0f;
            norm2[1] = ((float)(normals[nindex2+vert*3+1]-127))/127.0f;
            norm2[2] = ((float)(normals[nindex2+vert*3+2]-127))/127.0f;

            //vector_linear(norm1, norm2,  framefrac, drawvertices[tri*3+vert].normal);
//            vector_normalize(drawvertices[tri*3+vert].xyz, drawvertices[tri*3+vert].normal);
*/
        }
    }
}

ulong kmf_c::get_frame_count()
{  
    AssertThisV;

    return header.framecount;
} 

void kmf_c::draw()
{
    AssertThis;

    gv.renderer->use_shader(shader);
    gv.renderer->render_verts(drawvertices, drawvertcount, PT_TRIANGLES);
}

---