/afs/csl.tjhsst.edu/students/2007/kkassing/work/libhemi/mesh.h

Go to the documentation of this file.

#ifndef __HEMI__MESH_H__
#define __HEMI__MESH_H__

#include "hemi.h"
#include "md2.h"
#include "md3.h"
#include "md5.h"
#include "smd.h"

typedef struct hemi_buffer hemi_buffer_t;
typedef struct hemi_edge hemi_edge_t;
typedef struct hemi_face hemi_face_t;
typedef struct hemi_opts hemi_opts_t;
typedef struct hemi_model hemi_model_t;
typedef struct hemi_mesh hemi_mesh_t;
typedef struct hemi_part hemi_part_t;
typedef struct hemi_action hemi_action_t;
typedef struct hemi_tag hemi_tag_t;
typedef struct hemi_bone hemi_bone_t;
typedef struct hemi_hdr hemi_hdr_t;
typedef struct hemi_animparams hemi_animparams_t;
typedef struct hemi_attachment hemi_attachment_t;
typedef struct hemi_svert hemi_svert_t;
typedef struct hemi_weight hemi_weight_t;

#define HEMI_VERSION 3

// changed normals to per-frame
// changed materials to indexes into a hemi_mesh array of material pointers

struct hemi_buffer
{
        vec3** verts;
        int num_verts;
        int num_frames;

        vec2* coords;
        int num_coords;

        vec3** normals;
        int num_normals;

        hemi_tag_t** tags;
        int num_tags;

// skeletal animation
        hemi_svert_t* sverts;
        int num_sverts;

        hemi_bone_t* bones;
        int num_bones;

        hemi_weight_t* weights;
        int num_weights;
};

struct hemi_weight
{
        int bone;
        float bias;
        vec3 pos;
};

struct hemi_svert
{
        int* weights;
        int num_weights;

        vec4 pos; // cached vertex (4th val is cache status)
};

struct hemi_bone
{
        char* name;
        hemi_bone_t* parent;

        vec3* offset;
        quat* orient;

        mat44 trans; // this is temporary
};

struct hemi_tag
{
        vec3 offset;
        quat rotation;
};

struct hemi_edge
{
        int vert;                       // start pos
        int coord;      
        int normal;

        hemi_edge_t* opposite;
        hemi_face_t* face;
        hemi_edge_t* next;
};

struct hemi_face
{
        hemi_edge_t* edge;              // first edge
        int normal;
};

struct hemi_opts
{
        uint ** tris;   // temporary
        uint * trilens; // for debug only

        uint** strips;
        uint* strip_lens;
        uint num_strips;
        uint* free_tris;
        uint free_tri_len;
};

struct hemi_action
{
        char* name;
        int start;
        int end;
        float fps;
};

struct hemi_animparams
{
        int action;
        int frame;
        float interp;
        int nextaction;
};

struct hemi_attachment
{
        int tag;
        hemi_model_t* model;

        hemi_attachment_t* next;
};

struct hemi_model
{
        hemi_animparams_t anim;
        hemi_attachment_t* attachments;
};

struct hemi_mesh
{
        hemi_buffer_t* buffer;
        
        hemi_part_t* parts;
        int num_parts;

        hemi_action_t* actions;
        int num_actions;

        alloy_material_t** materials;
        int num_materials;
};

struct hemi_part
{
        hemi_mesh_t* mesh;

        int material;
        
        hemi_edge_t* edges;
        uint num_edges;

        hemi_face_t* faces;
        uint num_faces;
        
        hemi_opts_t* opts;
};

struct hemi_hdr
{
        char id[5];
        int ver;

        int num_parts;          
        int ofs_parts;          
        
        int num_normals;        
        int ofs_normals;        
        int num_coords;         
        int ofs_coords;         

        int num_frames;         
        int num_verts;          
        int ofs_verts;          
        int num_tags;           
        int ofs_tags;           
        
        int num_bones;
        int ofs_bones;
        int num_weights;
        int ofs_weights;

        int num_actions;
        int ofs_actions;

        int num_materials;
        int ofs_materials;


        // reserved for animation
        // reserved for bones
        // reserved for packed-in textures
        // reserved for collision hull
        // reserved for LOD
        // reserved for optimizations
};

void hemi_initmesh(hemi_mesh_t*);

int hemi_convert_md2(hemi_md2_t*,hemi_mesh_t*);
int hemi_convert_md3(hemi_md3_t*,hemi_mesh_t*);
int hemi_convert_md5(hemi_md5_t*,hemi_mesh_t*);
int hemi_convert_smd(hemi_smd_t*,hemi_mesh_t*);

void hemi_render(hemi_mesh_t*);
void hemi_render_frame(hemi_mesh_t*,int);
void hemi_render_interpolated(hemi_mesh_t*,int,int,float);
void hemi_render_skeletal(hemi_mesh_t*,int);
void hemi_render_skeletal_interpolated(hemi_mesh_t*,int,int,float);
void hemi_render_skeletal_optimized(hemi_mesh_t*,int);
void hemi_render_skeletal_optimized_interpolated(hemi_mesh_t*,int,int,float);
void hemi_render_md5(hemi_md5_t*,int);


void hemi_apply_tag(hemi_mesh_t*,int,int,int,float);

void hemi_free_mesh(hemi_mesh_t*);

void hemi_save(const char*, hemi_mesh_t*);
void hemi_load(const char*, hemi_mesh_t*);


#endif

---