ubergames/gtkradiant
0
0
Fork 0
mirror of https://github.com/UberGames/GtkRadiant.git synced 2024-11-24 21:01:24 +00:00
Code Issues Projects Releases Packages Wiki Activity
gtkradiant/libs/picomodel/pm_fm.c

642 lines
20 KiB
C
Raw Blame History

/* -----------------------------------------------------------------------------
PicoModel Library
Copyright (c) 2002, Randy Reddig & seaw0lf
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list
of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
Neither the names of the copyright holders nor the names of its contributors may
be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------- */
/*
Nurail: Used pm_md3.c (Randy Reddig) as a template.
*/
/* marker */
#define PM_FM_C
/* dependencies */
#include "pm_fm.h"
//#define FM_VERBOSE_DBG 0
#undef FM_VERBOSE_DBG
#undef FM_DBG
typedef struct index_LUT_s
{
short Vert;
short ST;
struct index_LUT_s *next;
} index_LUT_t;
typedef struct index_DUP_LUT_s
{
short ST;
short OldVert;
} index_DUP_LUT_t;
// _fm_canload()
static int _fm_canload( PM_PARAMS_CANLOAD ){
fm_t fm;
unsigned char *bb;
int fm_file_pos;
bb = (unsigned char *) buffer;
// Header
fm.fm_header_hdr = (fm_chunk_header_t *) bb;
fm_file_pos = sizeof( fm_chunk_header_t ) + fm.fm_header_hdr->size;
#ifdef FM_VERBOSE_DBG
_pico_printf( PICO_VERBOSE, "IDENT: %s\n", (unsigned char *) fm.fm_header_hdr->ident );
#endif
if ( ( strcmp( fm.fm_header_hdr->ident, FM_HEADERCHUNKNAME ) ) ) {
#ifdef FM_DBG
_pico_printf( PICO_WARNING, "FM Header Ident incorrect\n" );
#endif
return PICO_PMV_ERROR_IDENT;
}
// check fm
if ( _pico_little_long( fm.fm_header_hdr->version ) != FM_HEADERCHUNKVER ) {
#ifdef FM_DBG
_pico_printf( PICO_WARNING, "FM Header Version incorrect\n" );
#endif
return PICO_PMV_ERROR_VERSION;
}
// Skin
fm.fm_skin_hdr = (fm_chunk_header_t *) ( bb + fm_file_pos );
fm_file_pos += sizeof( fm_chunk_header_t ) + fm.fm_skin_hdr->size;
#ifdef FM_VERBOSE_DBG
_pico_printf( PICO_VERBOSE, "SKIN: %s\n", (unsigned char *) fm.fm_skin_hdr->ident );
#endif
if ( ( strcmp( fm.fm_skin_hdr->ident, FM_SKINCHUNKNAME ) ) ) {
#ifdef FM_DBG
_pico_printf( PICO_WARNING, "FM Skin Ident incorrect\n" );
#endif
return PICO_PMV_ERROR_IDENT;
}
// check fm
if ( _pico_little_long( fm.fm_skin_hdr->version ) != FM_SKINCHUNKVER ) {
#ifdef FM_DBG
_pico_printf( PICO_WARNING, "FM Skin Version incorrect\n" );
#endif
return PICO_PMV_ERROR_VERSION;
}
// st
fm.fm_st_hdr = (fm_chunk_header_t *) ( bb + fm_file_pos );
fm_file_pos += sizeof( fm_chunk_header_t ) + fm.fm_st_hdr->size;
#ifdef FM_VERBOSE_DBG
_pico_printf( PICO_VERBOSE, "ST: %s\n", (unsigned char *) fm.fm_st_hdr->ident );
#endif
if ( ( strcmp( fm.fm_st_hdr->ident, FM_STCOORDCHUNKNAME ) ) ) {
#ifdef FM_DBG
_pico_printf( PICO_WARNING, "FM ST Ident incorrect\n" );
#endif
return PICO_PMV_ERROR_IDENT;
}
// check fm
if ( _pico_little_long( fm.fm_st_hdr->version ) != FM_STCOORDCHUNKVER ) {
#ifdef FM_DBG
_pico_printf( PICO_WARNING, "FM ST Version incorrect\n" );
#endif
return PICO_PMV_ERROR_VERSION;
}
// tri
fm.fm_tri_hdr = (fm_chunk_header_t *) ( bb + fm_file_pos );
fm_file_pos += sizeof( fm_chunk_header_t ) + fm.fm_tri_hdr->size;
#ifdef FM_VERBOSE_DBG
_pico_printf( PICO_VERBOSE, "TRI: %s\n", (unsigned char *) fm.fm_tri_hdr->ident );
#endif
if ( ( strcmp( fm.fm_tri_hdr->ident, FM_TRISCHUNKNAME ) ) ) {
#ifdef FM_DBG
_pico_printf( PICO_WARNING, "FM Tri Ident incorrect\n" );
#endif
return PICO_PMV_ERROR_IDENT;
}
// check fm
if ( _pico_little_long( fm.fm_tri_hdr->version ) != FM_TRISCHUNKVER ) {
#ifdef FM_DBG
_pico_printf( PICO_WARNING, "FM Tri Version incorrect\n" );
#endif
return PICO_PMV_ERROR_VERSION;
}
// frame
fm.fm_frame_hdr = (fm_chunk_header_t *) ( bb + fm_file_pos );
fm_file_pos += sizeof( fm_chunk_header_t );
#ifdef FM_VERBOSE_DBG
_pico_printf( PICO_VERBOSE, "FRAME: %s\n", (unsigned char *) fm.fm_frame_hdr->ident );
#endif
if ( ( strcmp( fm.fm_frame_hdr->ident, FM_FRAMESCHUNKNAME ) ) ) {
#ifdef FM_DBG
_pico_printf( PICO_WARNING, "FM Frame Ident incorrect\n" );
#endif
return PICO_PMV_ERROR_IDENT;
}
// check fm
if ( _pico_little_long( fm.fm_frame_hdr->version ) != FM_FRAMESCHUNKVER ) {
#ifdef FM_DBG
_pico_printf( PICO_WARNING, "FM Frame Version incorrect\n" );
#endif
return PICO_PMV_ERROR_VERSION;
}
// file seems to be a valid fm
return PICO_PMV_OK;
}
// _fm_load() loads a Heretic 2 model file.
static picoModel_t *_fm_load( PM_PARAMS_LOAD ){
int i, j, dups, dup_index;
int fm_file_pos;
short tot_numVerts;
index_LUT_t *p_index_LUT, *p_index_LUT2, *p_index_LUT3;
index_DUP_LUT_t *p_index_LUT_DUPS;
fm_vert_normal_t *vert;
char skinname[FM_SKINPATHSIZE];
fm_t fm;
fm_header_t *fm_head;
fm_st_t *texCoord;
fm_xyz_st_t *tri_verts;
fm_xyz_st_t *triangle;
fm_frame_t *frame;
picoByte_t *bb;
picoModel_t *picoModel;
picoSurface_t *picoSurface;
picoShader_t *picoShader;
picoVec3_t xyz, normal;
picoVec2_t st;
picoColor_t color;
// fm loading
_pico_printf( PICO_NORMAL, "Loading \"%s\"", fileName );
bb = (picoByte_t*) buffer;
// Header Header
fm.fm_header_hdr = (fm_chunk_header_t *) bb;
fm_file_pos = sizeof( fm_chunk_header_t ) + fm.fm_header_hdr->size;
if ( ( strcmp( fm.fm_header_hdr->ident, FM_HEADERCHUNKNAME ) ) ) {
_pico_printf( PICO_WARNING, "FM Header Ident incorrect\n" );
return NULL;
}
if ( _pico_little_long( fm.fm_header_hdr->version ) != FM_HEADERCHUNKVER ) {
_pico_printf( PICO_WARNING, "FM Header Version incorrect\n" );
return NULL;
}
// Skin Header
fm.fm_skin_hdr = (fm_chunk_header_t *) ( bb + fm_file_pos );
fm_file_pos += sizeof( fm_chunk_header_t ) + fm.fm_skin_hdr->size;
if ( ( strcmp( fm.fm_skin_hdr->ident, FM_SKINCHUNKNAME ) ) ) {
_pico_printf( PICO_WARNING, "FM Skin Ident incorrect\n" );
return NULL;
}
if ( _pico_little_long( fm.fm_skin_hdr->version ) != FM_SKINCHUNKVER ) {
_pico_printf( PICO_WARNING, "FM Skin Version incorrect\n" );
return NULL;
}
// ST Header
fm.fm_st_hdr = (fm_chunk_header_t *) ( bb + fm_file_pos );
fm_file_pos += sizeof( fm_chunk_header_t ) + fm.fm_st_hdr->size;
if ( ( strcmp( fm.fm_st_hdr->ident, FM_STCOORDCHUNKNAME ) ) ) {
_pico_printf( PICO_WARNING, "FM ST Ident incorrect\n" );
return NULL;
}
if ( _pico_little_long( fm.fm_st_hdr->version ) != FM_STCOORDCHUNKVER ) {
_pico_printf( PICO_WARNING, "FM ST Version incorrect\n" );
return NULL;
}
// Tris Header
fm.fm_tri_hdr = (fm_chunk_header_t *) ( bb + fm_file_pos );
fm_file_pos += sizeof( fm_chunk_header_t ) + fm.fm_tri_hdr->size;
if ( ( strcmp( fm.fm_tri_hdr->ident, FM_TRISCHUNKNAME ) ) ) {
_pico_printf( PICO_WARNING, "FM Tri Ident incorrect\n" );
return NULL;
}
if ( _pico_little_long( fm.fm_tri_hdr->version ) != FM_TRISCHUNKVER ) {
_pico_printf( PICO_WARNING, "FM Tri Version incorrect\n" );
return NULL;
}
// Frame Header
fm.fm_frame_hdr = (fm_chunk_header_t *) ( bb + fm_file_pos );
fm_file_pos += sizeof( fm_chunk_header_t );
if ( ( strcmp( fm.fm_frame_hdr->ident, FM_FRAMESCHUNKNAME ) ) ) {
_pico_printf( PICO_WARNING, "FM Frame Ident incorrect\n" );
return NULL;
}
if ( _pico_little_long( fm.fm_frame_hdr->version ) != FM_FRAMESCHUNKVER ) {
_pico_printf( PICO_WARNING, "FM Frame Version incorrect\n" );
return NULL;
}
// Header
fm_file_pos = sizeof( fm_chunk_header_t );
fm_head = fm.fm_header = (fm_header_t *) ( bb + fm_file_pos );
fm_file_pos += fm.fm_header_hdr->size;
// Skin
fm_file_pos += sizeof( fm_chunk_header_t );
fm.fm_skin = (fm_skinpath_t *) ( bb + fm_file_pos );
fm_file_pos += fm.fm_skin_hdr->size;
// ST
fm_file_pos += sizeof( fm_chunk_header_t );
texCoord = fm.fm_st = (fm_st_t *) ( bb + fm_file_pos );
fm_file_pos += fm.fm_st_hdr->size;
// Tri
fm_file_pos += sizeof( fm_chunk_header_t );
tri_verts = fm.fm_tri = (fm_xyz_st_t *) ( bb + fm_file_pos );
fm_file_pos += fm.fm_tri_hdr->size;
// Frame
fm_file_pos += sizeof( fm_chunk_header_t );
frame = fm.fm_frame = (fm_frame_t *) ( bb + fm_file_pos );
// do frame check
if ( fm_head->numFrames < 1 ) {
_pico_printf( PICO_ERROR, "%s has 0 frames!", fileName );
return NULL;
}
if ( frameNum < 0 || frameNum >= fm_head->numFrames ) {
_pico_printf( PICO_ERROR, "Invalid or out-of-range FM frame specified" );
return NULL;
}
// swap fm
fm_head->skinWidth = _pico_little_long( fm_head->skinWidth );
fm_head->skinHeight = _pico_little_long( fm_head->skinHeight );
fm_head->frameSize = _pico_little_long( fm_head->frameSize );
fm_head->numSkins = _pico_little_long( fm_head->numSkins );
fm_head->numXYZ = _pico_little_long( fm_head->numXYZ );
fm_head->numST = _pico_little_long( fm_head->numST );
fm_head->numTris = _pico_little_long( fm_head->numTris );
fm_head->numGLCmds = _pico_little_long( fm_head->numGLCmds );
fm_head->numFrames = _pico_little_long( fm_head->numFrames );
// swap frame scale and translation
for ( i = 0; i < 3; i++ )
{
frame->header.scale[ i ] = _pico_little_float( frame->header.scale[ i ] );
frame->header.translate[ i ] = _pico_little_float( frame->header.translate[ i ] );
}
// swap triangles
triangle = tri_verts;
for ( i = 0; i < fm_head->numTris; i++, triangle++ )
{
for ( j = 0; j < 3; j++ )
{
triangle->index_xyz[ j ] = _pico_little_short( triangle->index_xyz[ j ] );
triangle->index_st[ j ] = _pico_little_short( triangle->index_st[ j ] );
}
}
// swap st coords
for ( i = 0; i < fm_head->numST; i++ )
{
texCoord->s = _pico_little_short( texCoord[i].s );
texCoord->t = _pico_little_short( texCoord[i].t );
}
// set Skin Name
strncpy( skinname, (char *) fm.fm_skin, FM_SKINPATHSIZE );
#ifdef FM_VERBOSE_DBG
// Print out md2 values
_pico_printf( PICO_VERBOSE,"numSkins->%d numXYZ->%d numST->%d numTris->%d numFrames->%d\nSkin Name \"%s\"\n", fm_head->numSkins, fm_head->numXYZ, fm_head->numST, fm_head->numTris, fm_head->numFrames, &skinname );
#endif
// detox Skin name
_pico_setfext( skinname, "" );
_pico_unixify( skinname );
/* create new pico model */
picoModel = PicoNewModel();
if ( picoModel == NULL ) {
_pico_printf( PICO_ERROR, "Unable to allocate a new model" );
return NULL;
}
/* do model setup */
PicoSetModelFrameNum( picoModel, frameNum );
PicoSetModelNumFrames( picoModel, fm_head->numFrames ); /* sea */
PicoSetModelName( picoModel, fileName );
PicoSetModelFileName( picoModel, fileName );
// allocate new pico surface
picoSurface = PicoNewSurface( picoModel );
if ( picoSurface == NULL ) {
_pico_printf( PICO_ERROR, "Unable to allocate a new model surface" );
PicoFreeModel( picoModel );
return NULL;
}
PicoSetSurfaceType( picoSurface, PICO_TRIANGLES );
PicoSetSurfaceName( picoSurface, frame->header.name );
picoShader = PicoNewShader( picoModel );
if ( picoShader == NULL ) {
_pico_printf( PICO_ERROR, "Unable to allocate a new model shader" );
PicoFreeModel( picoModel );
return NULL;
}
PicoSetShaderName( picoShader, skinname );
// associate current surface with newly created shader
PicoSetSurfaceShader( picoSurface, picoShader );
// Init LUT for Verts
p_index_LUT = (index_LUT_t *)_pico_alloc( sizeof( index_LUT_t ) * fm_head->numXYZ );
for ( i = 0; i < fm_head->numXYZ; i++ )
{
p_index_LUT[i].Vert = -1;
p_index_LUT[i].ST = -1;
p_index_LUT[i].next = NULL;
}
// Fill in Look Up Table, and allocate/fill Linked List from vert array as needed for dup STs per Vert.
tot_numVerts = fm_head->numXYZ;
dups = 0;
triangle = tri_verts;
for ( i = 0; i < fm_head->numTris; i++ )
{
for ( j = 0; j < 3; j++ )
{
if ( p_index_LUT[triangle->index_xyz[j]].ST == -1 ) { // No Main Entry
p_index_LUT[triangle->index_xyz[j]].ST = triangle->index_st[j];
}
else if ( triangle->index_st[j] == p_index_LUT[triangle->index_xyz[j]].ST ) { // Equal to Main Entry
#ifdef FM_VERBOSE_DBG
_pico_printf( PICO_NORMAL, "-> Tri #%d, Vert %d:\t XYZ:%d ST:%d\n", i, j, triangle->index_xyz[j], triangle->index_st[j] );
#endif
continue;
}
else if ( ( p_index_LUT[triangle->index_xyz[j]].next == NULL ) ) { // Not equal to Main entry, and no LL entry
// Add first entry of LL from Main
p_index_LUT2 = (index_LUT_t *)_pico_alloc( sizeof( index_LUT_t ) );
if ( p_index_LUT2 == NULL ) {
_pico_printf( PICO_NORMAL, " Couldn't allocate memory!\n" );
}
p_index_LUT[triangle->index_xyz[j]].next = (index_LUT_t *)p_index_LUT2;
p_index_LUT2->Vert = dups;
p_index_LUT2->ST = triangle->index_st[j];
p_index_LUT2->next = NULL;
#ifdef FM_VERBOSE_DBG
_pico_printf( PICO_NORMAL, " ADDING first LL XYZ:%d DUP:%d ST:%d\n", triangle->index_xyz[j], dups, triangle->index_st[j] );
#endif
triangle->index_xyz[j] = dups + fm_head->numXYZ; // Make change in Tri hunk
dups++;
}
else // Try to find in LL from Main Entry
{
p_index_LUT3 = p_index_LUT2 = p_index_LUT[triangle->index_xyz[j]].next;
while ( ( p_index_LUT2 != NULL ) && ( triangle->index_xyz[j] != p_index_LUT2->Vert ) ) // Walk down LL
{
p_index_LUT3 = p_index_LUT2;
p_index_LUT2 = p_index_LUT2->next;
}
p_index_LUT2 = p_index_LUT3;
if ( triangle->index_st[j] == p_index_LUT2->ST ) { // Found it
triangle->index_xyz[j] = p_index_LUT2->Vert + fm_head->numXYZ; // Make change in Tri hunk
#ifdef FM_VERBOSE_DBG
_pico_printf( PICO_NORMAL, "--> Tri #%d, Vert %d:\t XYZ:%d ST:%d\n", i, j, triangle->index_xyz[j], triangle->index_st[j] );
#endif
continue;
}
if ( p_index_LUT2->next == NULL ) { // Didn't find it. Add entry to LL.
// Add the Entry
p_index_LUT3 = (index_LUT_t *)_pico_alloc( sizeof( index_LUT_t ) );
if ( p_index_LUT3 == NULL ) {
_pico_printf( PICO_NORMAL, " Couldn't allocate memory!\n" );
}
p_index_LUT2->next = (index_LUT_t *)p_index_LUT3;
p_index_LUT3->Vert = dups;
p_index_LUT3->ST = triangle->index_st[j];
p_index_LUT3->next = NULL;
#ifdef FM_VERBOSE_DBG
_pico_printf( PICO_NORMAL, " ADDING additional LL XYZ:%d DUP:%d NewXYZ:%d ST:%d\n", triangle->index_xyz[j], dups, dups + ( fm_head->numXYZ ), triangle->index_st[j] );
#endif
triangle->index_xyz[j] = dups + fm_head->numXYZ; // Make change in Tri hunk
dups++;
}
}
#ifdef FM_VERBOSE_DBG
_pico_printf( PICO_NORMAL, "---> Tri #%d, Vert %d:\t XYZ:%d ST:%d\n", i, j, triangle->index_xyz[j], triangle->index_st[j] );
#endif
}
triangle++;
}
// malloc and build array for Dup STs
p_index_LUT_DUPS = (index_DUP_LUT_t *)_pico_alloc( sizeof( index_DUP_LUT_t ) * dups );
if ( p_index_LUT_DUPS == NULL ) {
_pico_printf( PICO_NORMAL, " Couldn't allocate memory!\n" );
}
dup_index = 0;
for ( i = 0; i < fm_head->numXYZ; i++ )
{
p_index_LUT2 = p_index_LUT[i].next;
while ( p_index_LUT2 != NULL )
{
p_index_LUT_DUPS[p_index_LUT2->Vert].OldVert = i;
p_index_LUT_DUPS[p_index_LUT2->Vert].ST = p_index_LUT2->ST;
dup_index++;
p_index_LUT2 = p_index_LUT2->next;
}
}
#ifdef FM_VERBOSE_DBG
_pico_printf( PICO_NORMAL, " Dups = %d\n", dups );
_pico_printf( PICO_NORMAL, " Dup Index = %d\n", dup_index );
#endif
for ( i = 0; i < fm_head->numXYZ; i++ )
{
#ifdef FM_VERBOSE_DBG
_pico_printf( PICO_NORMAL, "Vert: %4d\t%4d",i, p_index_LUT[i].ST );
#endif
if ( p_index_LUT[i].next != NULL ) {
p_index_LUT2 = p_index_LUT[i].next;
do {
#ifdef FM_VERBOSE_DBG
_pico_printf( PICO_NORMAL, " %4d %4d", p_index_LUT2->Vert, p_index_LUT2->ST );
#endif
p_index_LUT2 = p_index_LUT2->next;
} while ( p_index_LUT2 != NULL );
}
#ifdef FM_VERBOSE_DBG
_pico_printf( PICO_NORMAL, "\n" );
#endif
}
#ifdef FM_VERBOSE_DBG
for ( i = 0; i < dup_index; i++ )
_pico_printf( PICO_NORMAL, " Dup Index #%d OldVert: %d ST: %d\n", i, p_index_LUT_DUPS[i].OldVert, p_index_LUT_DUPS[i].ST );
triangle = tri_verts;
for ( i = 0; i < fm_head->numTris; i++ )
{
for ( j = 0; j < 3; j++ )
_pico_printf( PICO_NORMAL, "Tri #%d, Vert %d:\t XYZ:%d ST:%d\n", i, j, triangle->index_xyz[j], triangle->index_st[j] );
_pico_printf( PICO_NORMAL, "\n" );
triangle++;
}
#endif
// Build Picomodel
triangle = tri_verts;
for ( j = 0; j < fm_head->numTris; j++, triangle++ )
{
PicoSetSurfaceIndex( picoSurface, j * 3, triangle->index_xyz[0] );
PicoSetSurfaceIndex( picoSurface, j * 3 + 1, triangle->index_xyz[1] );
PicoSetSurfaceIndex( picoSurface, j * 3 + 2, triangle->index_xyz[2] );
}
vert = (fm_vert_normal_t*) ( (picoByte_t*) ( frame->verts ) );
for ( i = 0; i < fm_head->numXYZ; i++, vert++ )
{
/* set vertex origin */
xyz[ 0 ] = vert->v[0] * frame->header.scale[0] + frame->header.translate[0];
xyz[ 1 ] = vert->v[1] * frame->header.scale[1] + frame->header.translate[1];
xyz[ 2 ] = vert->v[2] * frame->header.scale[2] + frame->header.translate[2];
PicoSetSurfaceXYZ( picoSurface, i, xyz );
/* set normal */
normal[ 0 ] = fm_normals[vert->lightnormalindex][0];
normal[ 1 ] = fm_normals[vert->lightnormalindex][1];
normal[ 2 ] = fm_normals[vert->lightnormalindex][2];
PicoSetSurfaceNormal( picoSurface, i, normal );
/* set st coords */
st[ 0 ] = ( ( texCoord[p_index_LUT[i].ST].s ) / ( (float)fm_head->skinWidth ) );
st[ 1 ] = ( texCoord[p_index_LUT[i].ST].t / ( (float)fm_head->skinHeight ) );
PicoSetSurfaceST( picoSurface, 0, i, st );
}
if ( dups ) {
for ( i = 0; i < dups; i++ )
{
j = p_index_LUT_DUPS[i].OldVert;
/* set vertex origin */
xyz[ 0 ] = frame->verts[j].v[0] * frame->header.scale[0] + frame->header.translate[0];
xyz[ 1 ] = frame->verts[j].v[1] * frame->header.scale[1] + frame->header.translate[1];
xyz[ 2 ] = frame->verts[j].v[2] * frame->header.scale[2] + frame->header.translate[2];
PicoSetSurfaceXYZ( picoSurface, i + fm_head->numXYZ, xyz );
/* set normal */
normal[ 0 ] = fm_normals[frame->verts[j].lightnormalindex][0];
normal[ 1 ] = fm_normals[frame->verts[j].lightnormalindex][1];
normal[ 2 ] = fm_normals[frame->verts[j].lightnormalindex][2];
PicoSetSurfaceNormal( picoSurface, i + fm_head->numXYZ, normal );
/* set st coords */
st[ 0 ] = ( ( texCoord[p_index_LUT_DUPS[i].ST].s ) / ( (float)fm_head->skinWidth ) );
st[ 1 ] = ( texCoord[p_index_LUT_DUPS[i].ST].t / ( (float)fm_head->skinHeight ) );
PicoSetSurfaceST( picoSurface, 0, i + fm_head->numXYZ, st );
}
}
/* set color */
PicoSetSurfaceColor( picoSurface, 0, 0, color );
// Free up malloc'ed LL entries
for ( i = 0; i < fm_head->numXYZ; i++ )
{
if ( p_index_LUT[i].next != NULL ) {
p_index_LUT2 = p_index_LUT[i].next;
do {
p_index_LUT3 = p_index_LUT2->next;
_pico_free( p_index_LUT2 );
p_index_LUT2 = p_index_LUT3;
dups--;
} while ( p_index_LUT2 != NULL );
}
}
if ( dups ) {
_pico_printf( PICO_WARNING, " Not all LL mallocs freed\n" );
}
// Free malloc'ed LUTs
_pico_free( p_index_LUT );
_pico_free( p_index_LUT_DUPS );
/* return the new pico model */
return picoModel;
}
/* pico file format module definition */
const picoModule_t picoModuleFM =
{
"0.85", /* module version string */
"Heretic 2 FM", /* module display name */
"Nurail", /* author's name */
"2003 Nurail", /* module copyright */
{
"fm", NULL, NULL, NULL /* default extensions to use */
},
_fm_canload, /* validation routine */
_fm_load, /* load routine */
NULL, /* save validation routine */
NULL /* save routine */
};
Reference in a new issue View git blame Copy permalink