kicad/3d-viewer/3d_read_mesh.cpp

/////////////////////////////////////////////////////////////////////////////

// Name:        3d_read_mesh.cpp
/////////////////////////////////////////////////////////////////////////////


#ifdef __GNUG__
#pragma implementation
#pragma interface
#endif

#include "fctsys.h"

#include "common.h"
#include "macros.h"


#include "3d_struct.h"
#include "3d_viewer.h"


/***********************************/
int Struct3D_Master:: ReadData()
/************************************/
{
    char     line[1024], * text;
    wxString fullfilename;
    FILE*    file;
    int      LineNum = 0;

    if( m_Shape3DName.IsEmpty() )
    {
        return 1;
    }

    if( wxIsAbsolutePath( m_Shape3DName ) )
        fullfilename.Empty();
    else
        fullfilename = g_RealLibDirBuffer + LIB3D_PATH;
    fullfilename += m_Shape3DName;
#if defined (__WINDOWS__)
    fullfilename.Replace( UNIX_STRING_DIR_SEP, WIN_STRING_DIR_SEP );
#else
#if defined (__UNIX__)
    fullfilename.Replace( WIN_STRING_DIR_SEP, UNIX_STRING_DIR_SEP );
#endif
#endif

    file = wxFopen( fullfilename, wxT( "rt" ) );
    if( file == NULL )
    {
        return -1;
    }

    // Switch the locale to standard C (needed to print floating point numbers like 1.3)
    setlocale( LC_NUMERIC, "C" );
    while( GetLine( file, line, &LineNum, 512 ) )
    {
        text = strtok( line, " \t\n\r" );
        if( stricmp( text, "DEF" ) == 0 )
        {
            while( GetLine( file, line, &LineNum, 512 ) )
            {
                text = strtok( line, " \t\n\r" );
                if( text == NULL )
                    continue;
                if( *text == '}' )
                    break;
                if( stricmp( text, "children" ) == 0 )
                {
                    ReadChildren( file, &LineNum );
                }
            }
        }
    }

    fclose( file );
    setlocale( LC_NUMERIC, "" );      // revert to the current  locale
    return 0;
}


/*********************************************************/
int Struct3D_Master:: ReadMaterial( FILE* file, int* LineNum )
/*********************************************************/

/*
 *  analyse la description du type:
 *      material DEF yellow Material {
 *        diffuseColor 1.00000 1.00000 0.00000e+0
 *        emissiveColor 0.00000e+0 0.00000e+0 0.00000e+0
 *        specularColor 1.00000 1.00000 1.00000
 *        ambientIntensity 1.00000
 *        transparency 0.00000e+0
 *        shininess 1.00000
 *      }
 *  ou du type:
 *      material USE yellow
 */
{
    char          line[512], * text, * command;
    wxString      mat_name;
    S3D_Material* material = NULL;

    // Lecture de la commande:
    command  = strtok( NULL, " \t\n\r" );
    text     = strtok( NULL, " \t\n\r" );
    mat_name = CONV_FROM_UTF8( text );
    if( stricmp( command, "USE" ) == 0 )
    {
        for( material = m_Materials; material != NULL;
             material = (S3D_Material*) material->Pnext )
        {
            if( material->m_Name == mat_name )
            {
                material->SetMaterial();
                return 1;
            }
        }

        printf( "ReadMaterial error: material not found\n" );
        return 0;
    }

    if( stricmp( command, "DEF" ) == 0 )
    {
        material = new S3D_Material( this, mat_name );

        material->Pnext = m_Materials;
        m_Materials = material;
        while( GetLine( file, line, LineNum, 512 ) )
        {
            text = strtok( line, " \t\n\r" );
            if( text == NULL )
                continue;
            if( text[0] == '}' )
            {
                material->SetMaterial();
                return 0;
            }
            if( stricmp( text, "diffuseColor" ) == 0 )
            {
                text = strtok( NULL, " \t\n\r" );
                material->m_DiffuseColor.x = atof( text );
                text = strtok( NULL, " \t\n\r" );
                material->m_DiffuseColor.y = atof( text );
                text = strtok( NULL, " \t\n\r" );
                material->m_DiffuseColor.z = atof( text );
            }
            else if( stricmp( text, "emissiveColor" ) == 0 )
            {
                text = strtok( NULL, " \t\n\r" );
                material->m_EmissiveColor.x = atof( text );
                text = strtok( NULL, " \t\n\r" );
                material->m_EmissiveColor.y = atof( text );
                text = strtok( NULL, " \t\n\r" );
                material->m_EmissiveColor.z = atof( text );
            }
            else if( strnicmp( text, "specularColor", 13 ) == 0 )
            {
                text = strtok( NULL, " \t\n\r" );
                material->m_SpecularColor.x = atof( text );
                text = strtok( NULL, " \t\n\r" );
                material->m_SpecularColor.y = atof( text );
                text = strtok( NULL, " \t\n\r" );
                material->m_SpecularColor.z = atof( text );
            }
            else if( strnicmp( text, "ambientIntensity", 16 ) == 0 )
            {
                text = strtok( NULL, " \t\n\r" );
                material->m_AmbientIntensity = atof( text );
            }
            else if( strnicmp( text, "transparency", 12 ) == 0 )
            {
                text = strtok( NULL, " \t\n\r" );
                material->m_Transparency = atof( text );
            }
            else if( strnicmp( text, "shininess", 9 ) == 0 )
            {
                text = strtok( NULL, " \t\n\r" );
                material->m_Shininess = atof( text );
            }
        }
    }
    return -1;
}


/**********************************************************/
int Struct3D_Master::ReadChildren( FILE* file, int* LineNum )
/***********************************************************/
{
    char line[1024], * text;

    while( GetLine( file, line, LineNum, 512 ) )
    {
        text = strtok( line, " \t\n\r" );
        if( *text == ']' )
            return 0;
        if( *text == ',' )
            continue;

        if( stricmp( text, "Shape" ) == 0 )
        {
            ReadShape( file, LineNum );
        }
        else
        {
            printf( "ReadChildren error line %d <%s> \n", *LineNum, text );
            break;
        }
    }

    return 1;
}


/********************************************************/
int Struct3D_Master::ReadShape( FILE* file, int* LineNum )
/********************************************************/
{
    char line[1024], * text;
    int  err = 1;

    while( GetLine( file, line, LineNum, 512 ) )
    {
        text = strtok( line, " \t\n\r" );
        if( *text == '}' )
        {
            err = 0;
            break;
        }

        if( stricmp( text, "appearance" ) == 0 )
        {
            ReadAppearance( file, LineNum );
        }
        else if( stricmp( text, "geometry" ) == 0 )
        {
            ReadGeometry( file, LineNum );
        }
        else
        {
            printf( "ReadShape error line %d <%s> \n", *LineNum, text );
            break;
        }
    }

    return err;
}


/*************************************************************/
int Struct3D_Master::ReadAppearance( FILE* file, int* LineNum )
/*************************************************************/
{
    char line[1024], * text;
    int  err = 1;

    while( GetLine( file, line, LineNum, 512 ) )
    {
        text = strtok( line, " \t\n\r" );
        if( *text == '}' )
        {
            err = 0; break;
        }

        if( stricmp( text, "material" ) == 0 )
        {
            ReadMaterial( file, LineNum );
        }
        else
        {
            printf( "ReadAppearance error line %d <%s> \n", *LineNum, text );
            break;
        }
    }

    return err;
}


#define BUFSIZE 2000

/************************************************************************************/
double* ReadCoordsList( FILE* file, char* text_buffer, int* bufsize, int* LineNum )
/************************************************************************************/

/* Read a coordinate liste like:
 *      coord Coordinate { point [
 *        -5.24489 6.57640e-3 -9.42129e-2,
 *        -5.11821 6.57421e-3 0.542654,
 *        -3.45868 0.256565 1.32000 ] }
 *  or:
 *  normal Normal { vector [
 *        0.995171 -6.08102e-6 9.81541e-2,
 *        0.923880 -4.09802e-6 0.382683,
 *        0.707107 -9.38186e-7 0.707107]
 *      }
 * 
 *  Return the coordinate list
 *  text_buffer contains the first line of this node :
 *     "coord Coordinate { point ["
 */
{
    double*      data_list = NULL;
    unsigned int ii = 0, jj = 0, nn = BUFSIZE;
    char*        text;
    bool         HasData   = FALSE;
    bool         StartData = FALSE;
    bool         EndData   = FALSE;
    bool         EndNode   = FALSE;
    char         string_num[512];

    text = text_buffer;
    while( !EndNode )
    {
        if( *text == 0 )  // Needs data !
        {
            text = text_buffer;
            GetLine( file, text_buffer, LineNum, 512 );
        }

        while( !EndNode && *text )
        {
            switch( *text )
            {
            case '[':
                StartData = TRUE;
                jj = 0; string_num[jj] = 0;
                data_list = (double*) MyZMalloc( nn * sizeof(double) );
                break;

            case '}':
                EndNode = TRUE;
                break;

            case ']':
            case '\t':
            case ' ':
            case ',':
                jj = 0;
                if( !StartData || !HasData )
                    break;
                data_list[ii]  = atof( string_num );
                string_num[jj] = 0;
                ii++;
                if( ii >= nn )
                {
                    nn *= 2;
                    data_list = (double*) realloc( data_list, ( nn * sizeof(double) ) );
                }
                HasData = FALSE;
                if( *text == ']' )
                {
                    StartData = FALSE;
                    EndData   = TRUE;
                }
                break;

            default:
                if( !StartData )
                    break;
                if( jj >= sizeof(string_num) )
                    break;
                string_num[jj] = *text;
                jj++; string_num[jj] = 0;
                HasData = TRUE;
                break;
            }

            text++;
        }
    }

    if( data_list )
        data_list = (double*) realloc( data_list, ( ii * sizeof(double) ) );
    if( bufsize )
        *bufsize = ii;
    return data_list;
}


/***********************************************************/
int Struct3D_Master::ReadGeometry( FILE* file, int* LineNum )
/***********************************************************/
{
    char    line[1024], buffer[1024], * text;
    int     err    = 1;
    int     nn     = BUFSIZE;
    double* points = NULL;
    int*    index  = NULL;

    while( GetLine( file, line, LineNum, 512 ) )
    {
        strcpy( buffer, line );
        text = strtok( buffer, " \t\n\r" );
        if( *text == '}' )
        {
            err = 0; break;
        }

        if( stricmp( text, "normalPerVertex" ) == 0 )
        {
            text = strtok( NULL, " ,\t\n\r" );
            if( stricmp( text, "TRUE" ) == 0 )
            {
            }
            else
            {
            }
            continue;
        }

        if( stricmp( text, "colorPerVertex" ) == 0 )
        {
            text = strtok( NULL, " ,\t\n\r" );
            if( stricmp( text, "TRUE" ) == 0 )
            {
            }
            else
            {
            }
            continue;
        }

        if( stricmp( text, "normal" ) == 0 )
        {
            int     coord_number;
            double* buf_points = ReadCoordsList( file, line, &coord_number, LineNum );
            continue;
            free( buf_points );
            continue;
        }
        if( stricmp( text, "normalIndex" ) == 0 )
        {
            while( GetLine( file, line, LineNum, 512 ) )
            {
                text = strtok( line, " ,\t\n\r" );
                while( text )
                {
                    if( *text == ']' )
                        break;
                    text = strtok( NULL, " ,\t\n\r" );
                }

                if( text && (*text == ']') )
                    break;
            }

            continue;
        }

        if( stricmp( text, "color" ) == 0 )
        {
            int     coord_number;
            double* buf_points = ReadCoordsList( file, line, &coord_number, LineNum );
            continue;
            free( buf_points );
            continue;
        }
        if( stricmp( text, "colorIndex" ) == 0 )
        {
            while( GetLine( file, line, LineNum, 512 ) )
            {
                text = strtok( line, " ,\t\n\r" );
                while( text )
                {
                    if( *text == ']' )
                        break;
                    text = strtok( NULL, " ,\t\n\r" );
                }

                if( text && (*text == ']') )
                    break;
            }

            continue;
        }

        if( stricmp( text, "coord" ) == 0 )
        {
            int coord_number;
            points = ReadCoordsList( file, line, &coord_number, LineNum );
        }
        else if( stricmp( text, "coordIndex" ) == 0 )
        {
            index = (int*) MyMalloc( nn * sizeof(int) );
            S3D_Vertex* coords =
                (S3D_Vertex*) MyMalloc( nn * sizeof(S3D_Vertex) );
            while( GetLine( file, line, LineNum, 512 ) )
            {
                int coord_count = 0, jj;
                text = strtok( line, " ,\t\n\r" );
                while( text )
                {
                    if( *text == ']' )
                        break;
                    jj = atoi( text );
                    if( jj < 0 )
                    {
                        S3D_Vertex* curr_coord = coords;
                        for( jj = 0; jj < coord_count; jj++ )
                        {
                            int kk = index[jj] * 3;
                            curr_coord->x = points[kk];
                            curr_coord->y = points[kk + 1];
                            curr_coord->z = points[kk + 2];
                            curr_coord++;
                        }

                        Set_Object_Coords( coords, coord_count );
                        Set_Object_Data( coords, coord_count );
                        coord_count = 0;
                    }
                    else
                    {
                        index[coord_count++] = jj;
                    }
                    text = strtok( NULL, " ,\t\n\r" );
                }

                if( text && (*text == ']') )
                    break;
            }

            free( index );
            free( coords );
        }
        else
        {
            printf( "ReadGeometry error line %d <%s> \n", *LineNum, text );
            break;
        }
    }

    if( points )
        free( points );

    return err;
}


/*********************************************************/
int Struct3D_Shape:: ReadData( FILE* file, int* LineNum )
/*********************************************************/
{
    char line[512];

    while( GetLine( file, line, LineNum, 512 ) )
    {
    }

    return -1;
}