root/GtkRadiant/trunk/libs/picomodel/picomodel.c

/* -----------------------------------------------------------------------------

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.

----------------------------------------------------------------------------- */



/* marker */
#define PICOMODEL_C



/* dependencies */
#include "picointernal.h"



/*
PicoInit()
initializes the picomodel library
*/

int PicoInit( void )
{
        /* successfully initialized -sea */
        return 1;
}



/*
PicoShutdown()
shuts the pico model library down
*/

void PicoShutdown( void )
{
        /* do something interesting here in the future */
        return;
}



/*
PicoError()
returns last picomodel error code (see PME_* defines)
*/

int PicoError( void )
{
        /* todo: do something here */
        return 0;
}



/*
PicoSetMallocFunc()
sets the ptr to the malloc function
*/

void PicoSetMallocFunc( void *(*func)( size_t ) )
{
        if( func != NULL )
                _pico_ptr_malloc = func;
}



/*
PicoSetFreeFunc()
sets the ptr to the free function
*/

void PicoSetFreeFunc( void (*func)( void* ) )
{
        if( func != NULL )
                _pico_ptr_free = func;
}



/*
PicoSetLoadFileFunc()
sets the ptr to the file load function
*/

void PicoSetLoadFileFunc( void (*func)( char*, unsigned char**, int* ) )
{
        if( func != NULL )
                _pico_ptr_load_file = func;
}



/*
PicoSetFreeFileFunc()
sets the ptr to the free function
*/

void PicoSetFreeFileFunc( void (*func)( void* ) )
{
        if( func != NULL )
                _pico_ptr_free_file = func;
}



/*
PicoSetPrintFunc()
sets the ptr to the print function
*/

void PicoSetPrintFunc( void (*func)( int, const char* ) )
{
        if( func != NULL )
                _pico_ptr_print = func;
}



/*
PicoLoadModel()
the meat and potatoes function
*/

picoModel_t     *PicoLoadModel( char *fileName, int frameNum )
{
        const picoModule_t      **modules, *pm;
        picoModel_t                     *model;
        picoByte_t                      *buffer;
        int                                     bufSize;
        char                            *modelFileName, *remapFileName;


        /* init */
        model = NULL;

        /* make sure we've got a file name */
        if( fileName == NULL )
        {
                _pico_printf( PICO_ERROR, "PicoLoadModel: No filename given (fileName == NULL)" );
                return NULL;
        }

        /* load file data (buffer is allocated by host app) */
        _pico_load_file( fileName, &buffer, &bufSize );
        if( bufSize < 0 )
        {
                _pico_printf( PICO_ERROR, "PicoLoadModel: Failed loading model %s", fileName );
                return NULL;
        }

        /* get ptr to list of supported modules */
        modules = PicoModuleList( NULL );

        /* run it through the various loader functions and try */
        /* to find a loader that fits the given file data */
        for( ; *modules != NULL; modules++ )
        {
                /* get module */
                pm = *modules;

                /* sanity check */
                if( pm == NULL)
                        break;

                /* module must be able to load */
                if( pm->canload == NULL || pm->load == NULL )
                        continue;

                /* see whether this module can load the model file or not */
                if( pm->canload( fileName, buffer, bufSize ) == PICO_PMV_OK )
                {
                        /* use loader provided by module to read the model data */
                        model = pm->load( fileName, frameNum, buffer, bufSize );
                        if( model == NULL )
                        {
                                _pico_free_file( buffer );
                                return NULL;
                        }

                        /* assign pointer to file format module */
                        model->module = pm;

                        /* get model file name */
                        modelFileName = PicoGetModelFileName( model );

                        /* apply model remappings from <model>.remap */
                        if( strlen( modelFileName ) )
                        {
                                /* alloc copy of model file name */
                                remapFileName = _pico_alloc( strlen( modelFileName ) + 20 );
                                if( remapFileName != NULL )
                                {
                                        /* copy model file name and change extension */
                                        strcpy( remapFileName, modelFileName );
                                        _pico_setfext( remapFileName, "remap" );

                                        /* try to remap model; we don't handle the result */
                                        PicoRemapModel( model, remapFileName );

                                        /* free the remap file name string */
                                        _pico_free( remapFileName );
                                }
                        }

                        /* model was loaded, so break out of loop */
                        break;
                }
        }

        /* free memory used by file buffer */
        if( buffer)
                _pico_free_file( buffer );

        /* return */
        return model;
}



/* ----------------------------------------------------------------------------
models
---------------------------------------------------------------------------- */

/*
PicoNewModel()
creates a new pico model
*/

picoModel_t *PicoNewModel( void )
{
        picoModel_t     *model;

        /* allocate */
        model = _pico_alloc( sizeof(picoModel_t) );
        if( model == NULL )
                return NULL;

        /* clear */
        memset( model,0,sizeof(picoModel_t) );

        /* model set up */
        _pico_zero_bounds( model->mins,model->maxs );

        /* set initial frame count to 1 -sea */
        model->numFrames = 1;

        /* return ptr to new model */
        return model;
}



/*
PicoFreeModel()
frees a model and all associated data
*/

void PicoFreeModel( picoModel_t *model )
{
        int                             i;


        /* sanity check */
        if( model == NULL )
                return;

        /* free bits */
        if( model->name )
                _pico_free( model->name );

        /* free shaders */
        for( i = 0; i < model->numShaders; i++ )
                PicoFreeShader( model->shader[ i ] );
        free( model->shader );

        /* free surfaces */
        for( i = 0; i < model->numSurfaces; i++ )
                PicoFreeSurface( model->surface[ i ] );
        free( model->surface );

        /* free the model */
        _pico_free( model );
}



/*
PicoAdjustModel()
adjusts a models's memory allocations to handle the requested sizes.
will always grow, never shrink
*/

int PicoAdjustModel( picoModel_t *model, int numShaders, int numSurfaces )
{
        /* dummy check */
        if( model == NULL )
                return 0;

        /* bare minimums */
        /* sea: null surface/shader fix (1s=>0s) */
        if( numShaders < 0 )
                numShaders = 0;
        if( numSurfaces < 0 )
                numSurfaces = 0;

        /* additional shaders? */
        while( numShaders > model->maxShaders )
        {
                model->maxShaders += PICO_GROW_SHADERS;
                if( !_pico_realloc( (void *) &model->shader, model->numShaders * sizeof( *model->shader ), model->maxShaders * sizeof( *model->shader ) ) )
                        return 0;
        }

        /* set shader count to higher */
        if( numShaders > model->numShaders )
                model->numShaders = numShaders;

        /* additional surfaces? */
        while( numSurfaces > model->maxSurfaces )
        {
                model->maxSurfaces += PICO_GROW_SURFACES;
                if( !_pico_realloc( (void *) &model->surface, model->numSurfaces * sizeof( *model->surface ), model->maxSurfaces * sizeof( *model->surface ) ) )
                        return 0;
        }

        /* set shader count to higher */
        if( numSurfaces > model->numSurfaces )
                model->numSurfaces = numSurfaces;

        /* return ok */
        return 1;
}



/* ----------------------------------------------------------------------------
shaders
---------------------------------------------------------------------------- */

/*
PicoNewShader()
creates a new pico shader and returns its index. -sea
*/

picoShader_t *PicoNewShader( picoModel_t *model )
{
        picoShader_t    *shader;


        /* allocate and clear */
        shader = _pico_alloc( sizeof(picoShader_t) );
        if( shader == NULL )
                return NULL;
        memset( shader, 0, sizeof(picoShader_t) );

        /* attach it to the model */
        if( model != NULL )
        {
                /* adjust model */
                if( !PicoAdjustModel( model, model->numShaders + 1, 0 ) )
                {
                        _pico_free( shader );
                        return NULL;
                }
                /* attach */
                model->shader[ model->numShaders - 1 ] = shader;
                shader->model = model;
        }
        /* setup default shader colors */
        _pico_set_color( shader->ambientColor,0,0,0,0 );
        _pico_set_color( shader->diffuseColor,255,255,255,1 );
        _pico_set_color( shader->specularColor,0,0,0,0 );

        /* no need to do this, but i do it anyway */
        shader->transparency = 0;
        shader->shininess = 0;

        /* return the newly created shader */
        return shader;
}



/*
PicoFreeShader()
frees a shader and all associated data -sea
*/

void PicoFreeShader( picoShader_t *shader )
{
        /* dummy check */
        if( shader == NULL )
                return;

        /* free bits */
        if( shader->name )
                _pico_free( shader->name );
        if( shader->mapName )
                _pico_free( shader->mapName );

        /* free the shader */
        _pico_free( shader );
}



/*
PicoFindShader()
finds a named shader in a model
*/

picoShader_t *PicoFindShader( picoModel_t *model, char *name, int caseSensitive )
{
        int             i;


        /* sanity checks */
        if( model == NULL || name == NULL )     /* sea: null name fix */
                return NULL;

        /* walk list */
        for( i = 0; i < model->numShaders; i++ )
        {
                /* skip null shaders or shaders with null names */
                if( model->shader[ i ] == NULL ||
                        model->shader[ i ]->name == NULL )
                        continue;

                /* compare the shader name with name we're looking for */
                if( caseSensitive )
                {
                        if( !strcmp( name, model->shader[ i ]->name ) )
                                return model->shader[ i ];
                }
                else if( !_pico_stricmp( name, model->shader[ i ]->name ) )
                                return model->shader[ i ];
        }

        /* named shader not found */
        return NULL;
}



/* ----------------------------------------------------------------------------
surfaces
---------------------------------------------------------------------------- */

/*
PicoNewSurface()
creates a new pico surface
*/

picoSurface_t *PicoNewSurface( picoModel_t *model )
{
        picoSurface_t   *surface;
        char surfaceName[64];

        /* allocate and clear */
        surface = _pico_alloc( sizeof( *surface ) );
        if( surface == NULL )
                return NULL;
        memset( surface, 0, sizeof( *surface ) );

        /* attach it to the model */
        if( model != NULL )
        {
                /* adjust model */
                if( !PicoAdjustModel( model, 0, model->numSurfaces + 1 ) )
                {
                        _pico_free( surface );
                        return NULL;
                }

                /* attach */
                model->surface[ model->numSurfaces - 1 ] = surface;
                surface->model = model;

                /* set default name */
                sprintf( surfaceName, "Unnamed_%d", model->numSurfaces );
                PicoSetSurfaceName( surface, surfaceName );
        }

        /* return */
        return surface;
}



/*
PicoFreeSurface()
frees a surface and all associated data
*/
void PicoFreeSurface( picoSurface_t *surface )
{
        int             i;


        /* dummy check */
        if( surface == NULL )
                return;

        /* free bits */
        _pico_free( surface->xyz );
        _pico_free( surface->normal );
        _pico_free( surface->index );
        _pico_free( surface->faceNormal );

        /* free arrays */
        for( i = 0; i < surface->numSTArrays; i++ )
                _pico_free( surface->st[ i ] );
        free( surface->st );
        for( i = 0; i < surface->numColorArrays; i++ )
                _pico_free( surface->color[ i ] );
        free( surface->color );

        /* free the surface */
        _pico_free( surface );
}



/*
PicoAdjustSurface()
adjusts a surface's memory allocations to handle the requested sizes.
will always grow, never shrink
*/

int PicoAdjustSurface( picoSurface_t *surface, int numVertexes, int numSTArrays, int numColorArrays, int numIndexes, int numFaceNormals )
{
        int             i;


        /* dummy check */
        if( surface == NULL )
                return 0;

        /* bare minimums */
        if( numVertexes < 1 )
                numVertexes = 1;
        if( numSTArrays < 1 )
                numSTArrays = 1;
        if( numColorArrays < 1 )
                numColorArrays = 1;
        if( numIndexes < 1 )
                numIndexes = 1;

        /* additional vertexes? */
        while( numVertexes > surface->maxVertexes ) /* fix */
        {
                surface->maxVertexes += PICO_GROW_VERTEXES;
                if( !_pico_realloc( (void *) &surface->xyz, surface->numVertexes * sizeof( *surface->xyz ), surface->maxVertexes * sizeof( *surface->xyz ) ) )
                        return 0;
                if( !_pico_realloc( (void *) &surface->normal, surface->numVertexes * sizeof( *surface->normal ), surface->maxVertexes * sizeof( *surface->normal ) ) )
                        return 0;
                for( i = 0; i < surface->numSTArrays; i++ )
                        if( !_pico_realloc( (void*) &surface->st[ i ], surface->numVertexes * sizeof( *surface->st[ i ] ), surface->maxVertexes * sizeof( *surface->st[ i ] ) ) )
                        return 0;
                for( i = 0; i < surface->numColorArrays; i++ )
                        if( !_pico_realloc( (void*) &surface->color[ i ], surface->numVertexes * sizeof( *surface->color[ i ] ), surface->maxVertexes * sizeof( *surface->color[ i ] ) ) )
                        return 0;
        }

        /* set vertex count to higher */
        if( numVertexes > surface->numVertexes )
                surface->numVertexes = numVertexes;

        /* additional st arrays? */
        while( numSTArrays > surface->maxSTArrays ) /* fix */
        {
                surface->maxSTArrays += PICO_GROW_ARRAYS;
                if( !_pico_realloc( (void*) &surface->st, surface->numSTArrays * sizeof( *surface->st ), surface->maxSTArrays * sizeof( *surface->st ) ) )
                        return 0;
                while( surface->numSTArrays < numSTArrays )
                {
                        surface->st[ surface->numSTArrays ] = _pico_alloc( surface->maxVertexes * sizeof( *surface->st[ 0 ] ) );
                        memset( surface->st[ surface->numSTArrays ], 0, surface->maxVertexes * sizeof( *surface->st[ 0 ] ) );
                        surface->numSTArrays++;
                }
        }

        /* additional color arrays? */
        while( numColorArrays > surface->maxColorArrays ) /* fix */
        {
                surface->maxColorArrays += PICO_GROW_ARRAYS;
                if( !_pico_realloc( (void*) &surface->color, surface->numColorArrays * sizeof( *surface->color ), surface->maxColorArrays * sizeof( *surface->color ) ) )
                        return 0;
                while( surface->numColorArrays < numColorArrays )
                {
                        surface->color[ surface->numColorArrays ] = _pico_alloc( surface->maxVertexes * sizeof( *surface->color[ 0 ] ) );
                        memset( surface->color[ surface->numColorArrays ], 0, surface->maxVertexes * sizeof( *surface->color[ 0 ] ) );
                        surface->numColorArrays++;
                }
        }

        /* additional indexes? */
        while( numIndexes > surface->maxIndexes ) /* fix */
        {
                surface->maxIndexes += PICO_GROW_INDEXES;
                if( !_pico_realloc( (void*) &surface->index, surface->numIndexes * sizeof( *surface->index ), surface->maxIndexes * sizeof( *surface->index ) ) )
                        return 0;
        }

        /* set index count to higher */
        if( numIndexes > surface->numIndexes )
                surface->numIndexes = numIndexes;

        /* additional face normals? */
        while( numFaceNormals > surface->maxFaceNormals ) /* fix */
        {
                surface->maxFaceNormals += PICO_GROW_FACES;
                if( !_pico_realloc( (void *) &surface->faceNormal, surface->numFaceNormals * sizeof( *surface->faceNormal ), surface->maxFaceNormals * sizeof( *surface->faceNormal ) ) )
                        return 0;
        }

        /* set face normal count to higher */
        if( numFaceNormals > surface->numFaceNormals )
                surface->numFaceNormals = numFaceNormals;

        /* return ok */
        return 1;
}


/* PicoFindSurface:
 *   Finds first matching named surface in a model.
 */
picoSurface_t *PicoFindSurface(
        picoModel_t *model, char *name, int caseSensitive )
{
        int             i;

        /* sanity check */
        if( model == NULL || name == NULL )
                return NULL;

        /* walk list */
        for( i = 0; i < model->numSurfaces; i++ )
        {
                /* skip null surfaces or surfaces with null names */
                if( model->surface[ i ] == NULL ||
                        model->surface[ i ]->name == NULL )
                        continue;

                /* compare the surface name with name we're looking for */
                if (caseSensitive) {
                        if( !strcmp(name,model->surface[ i ]->name) )
                                return model->surface[ i ];
                } else {
                        if( !_pico_stricmp(name,model->surface[ i ]->name) )
                                return model->surface[ i ];
                }
        }
        /* named surface not found */
        return NULL;
}



/*----------------------------------------------------------------------------
  PicoSet*() Setter Functions
----------------------------------------------------------------------------*/

void PicoSetModelName( picoModel_t *model, char *name )
{
        if( model == NULL || name == NULL )
                return;
        if( model->name != NULL )
                _pico_free( model->name );

        model->name = _pico_clone_alloc( name,-1 );
}



void PicoSetModelFileName( picoModel_t *model, char *fileName )
{
        if( model == NULL || fileName == NULL )
                return;
        if( model->fileName != NULL )
                _pico_free( model->fileName );

        model->fileName = _pico_clone_alloc( fileName,-1 );
}



void PicoSetModelFrameNum( picoModel_t *model, int frameNum )
{
        if( model == NULL )
                return;
        model->frameNum = frameNum;
}



void PicoSetModelNumFrames( picoModel_t *model, int numFrames )
{
        if( model == NULL )
                return;
        model->numFrames = numFrames;
}



void PicoSetModelData( picoModel_t *model, void *data )
{
        if( model == NULL )
                return;
        model->data = data;
}



void PicoSetShaderName( picoShader_t *shader, char *name )
{
        if( shader == NULL || name == NULL )
                return;
        if( shader->name != NULL )
                _pico_free( shader->name );

        shader->name = _pico_clone_alloc( name,-1 );
}



void PicoSetShaderMapName( picoShader_t *shader, char *mapName )
{
        if( shader == NULL || mapName == NULL )
                return;
        if( shader->mapName != NULL )
                _pico_free( shader->mapName );

        shader->mapName = _pico_clone_alloc( mapName,-1 );
}



void PicoSetShaderAmbientColor( picoShader_t *shader, picoColor_t color )
{
        if( shader == NULL || color == NULL )
                return;
        shader->ambientColor[ 0 ] = color[ 0 ];
        shader->ambientColor[ 1 ] = color[ 1 ];
        shader->ambientColor[ 2 ] = color[ 2 ];
        shader->ambientColor[ 3 ] = color[ 3 ];
}



void PicoSetShaderDiffuseColor( picoShader_t *shader, picoColor_t color )
{
        if( shader == NULL || color == NULL )
                return;
        shader->diffuseColor[ 0 ] = color[ 0 ];
        shader->diffuseColor[ 1 ] = color[ 1 ];
        shader->diffuseColor[ 2 ] = color[ 2 ];
        shader->diffuseColor[ 3 ] = color[ 3 ];
}



void PicoSetShaderSpecularColor( picoShader_t *shader, picoColor_t color )
{
        if( shader == NULL || color == NULL )
                return;
        shader->specularColor[ 0 ] = color[ 0 ];
        shader->specularColor[ 1 ] = color[ 1 ];
        shader->specularColor[ 2 ] = color[ 2 ];
        shader->specularColor[ 3 ] = color[ 3 ];
}



void PicoSetShaderTransparency( picoShader_t *shader, float value )
{
        if( shader == NULL )
                return;
        shader->transparency = value;

        /* cap to 0..1 range */
        if (shader->transparency < 0.0)
                shader->transparency = 0.0;
        if (shader->transparency > 1.0)
                shader->transparency = 1.0;
}



void PicoSetShaderShininess( picoShader_t *shader, float value )
{
        if( shader == NULL )
                return;
        shader->shininess = value;

        /* cap to 0..127 range */
        if (shader->shininess < 0.0)
                shader->shininess = 0.0;
        if (shader->shininess > 127.0)
                shader->shininess = 127.0;
}



void PicoSetSurfaceData( picoSurface_t *surface, void *data )
{
        if( surface == NULL )
                return;
        surface->data = data;
}



void PicoSetSurfaceType( picoSurface_t *surface, picoSurfaceType_t type )
{
        if( surface == NULL )
                return;
        surface->type = type;
}



void PicoSetSurfaceName( picoSurface_t *surface, char *name )
{
        if( surface == NULL || name == NULL )
                return;
        if( surface->name != NULL )
                _pico_free( surface->name );

        surface->name = _pico_clone_alloc( name,-1 );
}



void PicoSetSurfaceShader( picoSurface_t *surface, picoShader_t *shader )
{
        if( surface == NULL )
                return;
        surface->shader = shader;
}



void PicoSetSurfaceXYZ( picoSurface_t *surface, int num, picoVec3_t xyz )
{
        if( surface == NULL || num < 0 || xyz == NULL )
                return;
        if( !PicoAdjustSurface( surface, num + 1, 0, 0, 0, 0 ) )
                return;
        _pico_copy_vec( xyz, surface->xyz[ num ] );
        if( surface->model != NULL )
                _pico_expand_bounds( xyz, surface->model->mins, surface->model->maxs );
}



void PicoSetSurfaceNormal( picoSurface_t *surface, int num, picoVec3_t normal )
{
        if( surface == NULL || num < 0 || normal == NULL )
                return;
        if( !PicoAdjustSurface( surface, num + 1, 0, 0, 0, 0 ) )
                return;
        _pico_copy_vec( normal, surface->normal[ num ] );
}



void PicoSetSurfaceST( picoSurface_t *surface, int array, int num, picoVec2_t st )
{
        if( surface == NULL || num < 0 || st == NULL )
                return;
        if( !PicoAdjustSurface( surface, num + 1, array + 1, 0, 0, 0 ) )
                return;
        surface->st[ array ][ num ][ 0 ] = st[ 0 ];
        surface->st[ array ][ num ][ 1 ] = st[ 1 ];
}



void PicoSetSurfaceColor( picoSurface_t *surface, int array, int num, picoColor_t color )
{
        if( surface == NULL || num < 0 || color == NULL )
                return;
        if( !PicoAdjustSurface( surface, num + 1, 0, array + 1, 0, 0 ) )
                return;
        surface->color[ array ][ num ][ 0 ] = color[ 0 ];
        surface->color[ array ][ num ][ 1 ] = color[ 1 ];
        surface->color[ array ][ num ][ 2 ] = color[ 2 ];
        surface->color[ array ][ num ][ 3 ] = color[ 3 ];
}



void PicoSetSurfaceIndex( picoSurface_t *surface, int num, picoIndex_t index )
{
        if( surface == NULL || num < 0 )
                return;
        if( !PicoAdjustSurface( surface, 0, 0, 0, num + 1, 0 ) )
                return;
        surface->index[ num ] = index;
}



void PicoSetSurfaceIndexes( picoSurface_t *surface, int num, picoIndex_t *index, int count )
{
        if( num < 0 || index == NULL || count < 1 )
                return;
        if( !PicoAdjustSurface( surface, 0, 0, 0, num + count, 0 ) )
                return;
        memcpy( &surface->index[ num ], index, count * sizeof( surface->index[ num ] ) );
}



void PicoSetFaceNormal( picoSurface_t *surface, int num, picoVec3_t normal )
{
        if( surface == NULL || num < 0 || normal == NULL )
                return;
        if( !PicoAdjustSurface( surface, 0, 0, 0, 0, num + 1 ) )
                return;
        _pico_copy_vec( normal, surface->faceNormal[ num ] );
}