TAPsReadModels.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsReadModels.cpp
******************************************************************************/
/******************************************************************************
SUKITTI PUNAK   (11/11/2004)
UPDATE          (04/29/2007)
******************************************************************************/
#include "TAPsReadModels.hpp"
// Using Inclusion Model (i.e. definitions are included in declarations)
//                       (this name.cpp is included in name.hpp)
// Each friend is defined directly inside its declaration.

BEGIN_NAMESPACE_TAPs
//=============================================================================
// CLASS: ReadModels ***********************************************************
//-----------------------------------------------------------------------------
// Read an input file
template <typename T>
bool ReadModels<T>::readFile( const char *fileName, 
                        OpenGL::OpenGLModel<T> * const prModel )
{
    //----------------------------------------------------------------
    // Find the format of the file
    char * name   = new char[ strlen( fileName )+1 ];
    char * format = new char[ strlen( fileName )+1 ];
    strcpy( name, fileName );
    char *token = strtok( name, "." );
    do {
        strcpy( format, token );
        token = strtok( '\0', "." );
    } while ( token );
    //----------------------------------------------------------------
    // If model is not created yet!
    if ( !prModel ) {
        std::cout << "The model must be created first!" << std::endl;
        return false;
    }
    //----------------------------------------------------------------
    // ADD NEW MODEL TYPE HERE and AT Every Process .file format
    // Check Model Type
    OpenGL::OpenGLPNTriangleModel<T> * prOpenGLPNTriangleModel = 
        dynamic_cast< OpenGL::OpenGLPNTriangleModel<T> * > ( prModel );
    OpenGL::OpenGLPNTriangleVolPresModel<T> * prOpenGLPNTriangleVolPresModel = 
        dynamic_cast< OpenGL::OpenGLPNTriangleVolPresModel<T> * > ( prModel );
    OpenGL::OpenGLVolPresPolygonalModel<T> * prOpenGLVolPresPolygonalModel = 
        dynamic_cast< OpenGL::OpenGLVolPresPolygonalModel<T> * > ( prModel );
    OpenGL::OpenGLVolPresTriModel<T> * prOpenGLVolPresTriModel = 
        dynamic_cast< OpenGL::OpenGLVolPresTriModel<T> * > ( prModel );
    OpenGL::OpenGLXTrigonalModel<T> * prOpenGLXTrigonalModel = 
        dynamic_cast< OpenGL::OpenGLXTrigonalModel<T> * > ( prModel );
    OpenGL::OpenGLXPolygonalModel<T> * prOpenGLXPolygonalModel = 
        dynamic_cast< OpenGL::OpenGLXPolygonalModel<T> * > ( prModel );
    OpenGL::OpenGLTrigonalModel<T> * prOpenGLTrigonalModel = 
        dynamic_cast< OpenGL::OpenGLTrigonalModel<T> * > ( prModel );
    OpenGL::OpenGLPolygonalModel<T> * prOpenGLPolygonalModel = 
        dynamic_cast< OpenGL::OpenGLPolygonalModel<T> * > ( prModel );
    OpenGL::OpenGLHalfEdgeModel<T> * prOpenGLHalfEdgeModel = 
        dynamic_cast< OpenGL::OpenGLHalfEdgeModel<T> * > ( prModel );
    OpenGL::OpenGLSpringHalfEdgeModel<T> * prOpenGLSpringHalfEdgeModel = 
        dynamic_cast< OpenGL::OpenGLSpringHalfEdgeModel<T> * > ( prModel );
    OpenGL::OpenGLHalfEdgeTrigonalModel<T> * prOpenGLHalfEdgeTrigonalModel = 
        dynamic_cast< OpenGL::OpenGLHalfEdgeTrigonalModel<T> * > ( prModel );
    OpenGL::OpenGLHETriMeshOneModelMultiParts<T> * prOpenGLHETriMeshOneModelMultiParts = 
        dynamic_cast< OpenGL::OpenGLHETriMeshOneModelMultiParts<T> * > ( prModel );
    //-------------------------------------------
    // 3D Volume Model
    OpenGL::OpenGL3DModel<T> * prOpenGL3DModel = 
        dynamic_cast< OpenGL::OpenGL3DModel<T> * > ( prModel );
    //----------------------------------------------------------------

    //std::cout << "format: << " << format << "\n";

    // Process .TAPs format
    if ( strcmp( format, "TAPs" ) == 0 ) {
        if ( prOpenGLPNTriangleModel
          || prOpenGLPNTriangleVolPresModel
          || prOpenGLVolPresPolygonalModel 
          || prOpenGLVolPresTriModel 
          || prOpenGLXTrigonalModel 
          || prOpenGLXPolygonalModel )
        {
            OpenGL::XPolygonalModel<T> * prXPolygonalModel = dynamic_cast< OpenGL::XPolygonalModel<T> * >( prModel );
            if ( !ReadTAPs<T>::readFile( fileName, prXPolygonalModel ) ) {
                std::cout << "TAPsReadModels: ReadTAPs<T>::readFile Fn returns false!" << std::endl;
                return false;
            }
        }
        else if ( prOpenGLTrigonalModel
               || prOpenGLPolygonalModel ) 
        {
            OpenGL::PolygonalModel<T> * prPolygonalModel = dynamic_cast< OpenGL::PolygonalModel<T> * >( prModel );
            if ( !ReadTAPs<T>::readFile( fileName, prPolygonalModel ) ) {
                std::cout << "TAPsReadModels: ReadTAPs<T>::readFile Fn returns false!" << std::endl;
                return false;
            }
        }
        //else if ( prOpenGLHalfEdgeModel )
        //{
        //  OpenGL::HalfEdgeModel<T> * prHalfEdgeModel = dynamic_cast< OpenGL::HalfEdgeModel<T> * >( prModel );
        //  if ( !ReadTAPs<T>::readFile( fileName, prHalfEdgeModel ) ) {
        //      std::cout << "TAPsReadModels: ReadTAPs<T>::readFile Fn returns false!" << std::endl;
        //      return false;
        //  }
        //}
        else {
            return false;
        }
    }
    //----------------------------------------------------------------
    // Process .obj format
    else if ( strcmp( format, "obj" ) == 0 ) {
        if ( prOpenGLPNTriangleModel
          || prOpenGLPNTriangleVolPresModel
          || prOpenGLVolPresPolygonalModel 
          || prOpenGLVolPresTriModel 
          || prOpenGLXTrigonalModel 
          || prOpenGLXPolygonalModel )
        {
            OpenGL::XPolygonalModel<T> * prXPolygonalModel = dynamic_cast< OpenGL::XPolygonalModel<T> * >( prModel );
            if ( !ReadObj<T>::ReadFile( fileName, prXPolygonalModel ) ) {
                std::cout << "TAPsReadModels: ReadObj<T>::ReadFile Fn returns false!" << std::endl;
                return false;
            }
        }
        else if ( prOpenGLTrigonalModel
               || prOpenGLPolygonalModel ) 
        {
            OpenGL::PolygonalModel<T> * prPolygonalModel = dynamic_cast< OpenGL::PolygonalModel<T> * >( prModel );
            if ( !ReadObj<T>::ReadFile( fileName, prPolygonalModel ) ) {
                std::cout << "TAPsReadModels: ReadObj<T>::ReadFile Fn returns false!" << std::endl;
                return false;
            }
        }
        else if ( prOpenGLHalfEdgeModel 
               || prOpenGLSpringHalfEdgeModel
               || prOpenGLHalfEdgeTrigonalModel
               || prOpenGLHETriMeshOneModelMultiParts )
        {
            OpenGL::HalfEdgeModel<T> * prHalfEdgeModel = dynamic_cast< OpenGL::HalfEdgeModel<T> * >( prModel );
            if ( !ReadObj<T>::ReadFile( fileName, prHalfEdgeModel ) ) {
                std::cout << "TAPsReadModels: ReadObj<T>::ReadFile Fn returns false!" << std::endl;
                return false;
            }
        }
        else {
            return false;
        }
    }
    //----------------------------------------------------------------
    // Process .10 format
    else if ( strcmp( format, "10" ) == 0 ) {
        if ( prOpenGLPNTriangleModel
          || prOpenGLPNTriangleVolPresModel
          || prOpenGLVolPresPolygonalModel 
          || prOpenGLVolPresTriModel 
          || prOpenGLXTrigonalModel 
          || prOpenGLXPolygonalModel ) 
        {
            OpenGL::XPolygonalModel<T> * prXPolygonalModel = dynamic_cast< OpenGL::XPolygonalModel<T> * >( prModel );
            if ( !ReadDot10<T>::readFile( fileName, prXPolygonalModel ) ) {
                std::cout << "TAPsReadModels: ReadDot10<T>::readFile Fn returns false!" << std::endl;
                return false;
            }
        }
        else if ( prOpenGLTrigonalModel
               || prOpenGLPolygonalModel ) 
        {
            OpenGL::PolygonalModel<T> * prPolygonalModel = dynamic_cast< OpenGL::PolygonalModel<T> * >( prModel );
            if ( !ReadDot10<T>::readFile( fileName, prPolygonalModel ) ) {
                std::cout << "TAPsReadModels: ReadDot10<T>::readFile Fn returns false!" << std::endl;
                return false;
            }
        }
        //else if ( prOpenGLHalfEdgeModel )
        //{
        //  OpenGL::HalfEdgeModel<T> * prHalfEdgeModel = dynamic_cast< OpenGL::HalfEdgeModel<T> * >( prModel );
        //  if ( !ReadDot10<T>::readFile( fileName, prHalfEdgeModel ) ) {
        //      std::cout << "TAPsReadModels: ReadDot10<T>::readFile Fn returns false!" << std::endl;
        //      return false;
        //  }
        //}
        else {
            return false;
        }
    }
    //----------------------------------------------------------------
    // Process .ASC format
    else if ( strcmp( format, "ASC" ) == 0 ) {
        if ( prOpenGLPNTriangleModel
          || prOpenGLPNTriangleVolPresModel
          || prOpenGLVolPresPolygonalModel 
          || prOpenGLVolPresTriModel
          || prOpenGLXTrigonalModel
          || prOpenGLXPolygonalModel
        ) {
            OpenGL::XPolygonalModel<T> * prXPolygonalModel = dynamic_cast< OpenGL::XPolygonalModel<T> * >( prModel );
            if ( !Read3dsMaxASC<T>::readFile( fileName, prXPolygonalModel ) ) {
                std::cout << "TAPsReadModels: Read3dsMaxASC<T>::readFile Fn returns false!" << std::endl;
                return false;
            }
        }
        else if ( prOpenGLTrigonalModel
               || prOpenGLPolygonalModel
        ) {
            OpenGL::PolygonalModel<T> * prPolygonalModel = dynamic_cast< OpenGL::PolygonalModel<T> * >( prModel );
            if ( !Read3dsMaxASC<T>::readFile( fileName, prPolygonalModel ) ) {
                std::cout << "TAPsReadModels: Read3dsMaxASC<T>::readFile Fn returns false!" << std::endl;
                return false;
            }
        }
        else if ( prOpenGLHalfEdgeModel
               || prOpenGLSpringHalfEdgeModel
               || prOpenGLHalfEdgeTrigonalModel
               || prOpenGLHETriMeshOneModelMultiParts
        ) {
            OpenGL::HalfEdgeModel<T> * prHalfEdgeModel = dynamic_cast< OpenGL::HalfEdgeModel<T> * >( prModel );
            if ( !Read3dsMaxASC<T>::readFile( fileName, prHalfEdgeModel ) ) {
                std::cout << "TAPsReadModels: Read3dsMaxASC<T>::readFile Fn returns false!" << std::endl;
                return false;
            }
        }
        else {
            return false;
        }
    }
    //----------------------------------------------------------------
    // Process .ASE format
    else if ( strcmp( format, "ASE" ) == 0 ) {
        if ( prOpenGLPNTriangleModel
          || prOpenGLPNTriangleVolPresModel
          || prOpenGLVolPresPolygonalModel
          || prOpenGLVolPresTriModel
          || prOpenGLXTrigonalModel
          || prOpenGLXPolygonalModel
        ) {
            OpenGL::XPolygonalModel<T> * prXPolygonalModel = dynamic_cast< OpenGL::XPolygonalModel<T> * >( prModel );
            if ( !Read3dsMaxASE<T>::readFile( fileName, prXPolygonalModel ) ) {
                std::cout << "TAPsReadModels: Read3dsMaxASE<T>::readFile Fn returns false!" << std::endl;
                return false;
            }
        }
        else if ( prOpenGLTrigonalModel
               || prOpenGLPolygonalModel
        ) {
            OpenGL::PolygonalModel<T> * prPolygonalModel = dynamic_cast< OpenGL::PolygonalModel<T> * >( prModel );
            if ( !Read3dsMaxASE<T>::readFile( fileName, prPolygonalModel ) ) {
                std::cout << "TAPsReadModels: Read3dsMaxASE<T>::readFile Fn returns false!" << std::endl;
                return false;
            }
        }
        else if ( prOpenGLHalfEdgeModel
               || prOpenGLSpringHalfEdgeModel
               || prOpenGLHalfEdgeTrigonalModel
               || prOpenGLHETriMeshOneModelMultiParts
        ) {
            OpenGL::HalfEdgeModel<T> * prHalfEdgeModel = dynamic_cast< OpenGL::HalfEdgeModel<T> * >( prModel );
            if ( !Read3dsMaxASE<T>::readFile( fileName, prHalfEdgeModel ) ) {
                std::cout << "TAPsReadModels: Read3dsMaxASE<T>::readFile Fn returns false!" << std::endl;
                return false;
            }
        }
        else {
            return false;
        }
    }
    //----------------------------------------------------------------
    // Process .ply format
    else if ( strcmp( format, "ply" ) == 0 ) {
        if ( prOpenGLPNTriangleModel
          || prOpenGLPNTriangleVolPresModel
          || prOpenGLVolPresPolygonalModel 
          || prOpenGLVolPresTriModel 
          || prOpenGLXTrigonalModel 
          || prOpenGLXPolygonalModel ) 
        {
            OpenGL::XPolygonalModel<T> * prXPolygonalModel = dynamic_cast< OpenGL::XPolygonalModel<T> * >( prModel );
            if ( !ReadPly<T>::readFile( fileName, prXPolygonalModel ) ) {
                std::cout << "TAPsReadModels: ReadPly<T>::readFile Fn returns false!" << std::endl;
                return false;
            }
        }
        else if ( prOpenGLTrigonalModel
               || prOpenGLPolygonalModel ) 
        {
            OpenGL::PolygonalModel<T> * prPolygonalModel = dynamic_cast< OpenGL::PolygonalModel<T> * >( prModel );
            if ( !ReadPly<T>::readFile( fileName, prPolygonalModel ) ) {
                std::cout << "TAPsReadModels: ReadPly<T>::readFile Fn returns false!" << std::endl;
                return false;
            }
        }
        //else if ( prOpenGLHalfEdgeModel )
        //{
        //  OpenGL::HalfEdgeModel<T> * prHalfEdgeModel = dynamic_cast< OpenGL::HalfEdgeModel<T> * >( prModel );
        //  if ( !ReadPly<T>::readFile( fileName, prHalfEdgeModel ) ) {
        //      std::cout << "TAPsReadModels: ReadPly<T>::readFile Fn returns false!" << std::endl;
        //      return false;
        //  }
        //}
        else {
            return false;
        }
    }
    //----------------------------------------------------------------
    // Process .off format
    else if ( strcmp( format, "off" ) == 0 ) {
        if ( prOpenGLPNTriangleModel
          || prOpenGLPNTriangleVolPresModel
          || prOpenGLVolPresPolygonalModel 
          || prOpenGLVolPresTriModel 
          || prOpenGLXTrigonalModel 
          || prOpenGLXPolygonalModel ) 
        {
            OpenGL::XPolygonalModel<T> * prXPolygonalModel = dynamic_cast< OpenGL::XPolygonalModel<T> * >( prModel );
            if ( !ReadOff<T>::readFile( fileName, prXPolygonalModel ) ) {
                std::cout << "TAPsReadModels: ReadOff<T>::readFile Fn returns false!" << std::endl;
                return false;
            }
        }
        else if ( prOpenGLTrigonalModel
               || prOpenGLPolygonalModel ) 
        {
            OpenGL::PolygonalModel<T> * prPolygonalModel = dynamic_cast< OpenGL::PolygonalModel<T> * >( prModel );
            if ( !ReadOff<T>::readFile( fileName, prPolygonalModel ) ) {
                std::cout << "TAPsReadModels: ReadOff<T>::readFile Fn returns false!" << std::endl;
                return false;
            }
        }
        //else if ( prOpenGLHalfEdgeModel )
        //{
        //  OpenGL::HalfEdgeModel<T> * prHalfEdgeModel = dynamic_cast< OpenGL::HalfEdgeModel<T> * >( prModel );
        //  if ( !ReadOff<T>::readFile( fileName, prHalfEdgeModel ) ) {
        //      std::cout << "TAPsReadModels: ReadOff<T>::readFile Fn returns false!" << std::endl;
        //      return false;
        //  }
        //}
        else {
            return false;
        }
    }
    //----------------------------------------------------------------
    // The format of the file is not supported.
    else {
        std::cout << "The input file (." << format << ") is not supported!" << std::endl;
        return false;
    }
    //----------------------------------------------------------------
    delete [] name;
    delete [] format;
    //----------------------------------------------------------------
    std::cout << typeid( prModel ).name() << std::endl;     // Display Model Type Pointer
    std::cout << typeid( *prModel ).name() << std::endl;    // Display Model Type
    //================================================================
    // MODEL INITIALIZATION
    prModel->Initialize();
    //================================================================
    return true;
}
//-----------------------------------------------------------------------------
// Read an input file
template <typename T>
bool ReadModels<T>::readFile( const char *fileName, 
                        OpenGL::MultiMeshModel<T> * const prModel, 
                        TAPs::Enum::ModelType eModelType )
{
    //----------------------------------------------------------------
    // Find the format of the file
    char * name   = new char[ strlen( fileName )+1 ];
    char * format = new char[ strlen( fileName )+1 ];
    strcpy( name, fileName );
    char *token = strtok( name, "." );
    do {
        strcpy( format, token );
        token = strtok( '\0', "." );
    } while ( token );
    //----------------------------------------------------------------
    // If model is not created yet!
    if ( !prModel ) {
        std::cout << "The model must be created first!" << std::endl;
        return false;
    }
    //----------------------------------------------------------------
    // Process .TAPs format
    if ( strcmp( format, "TAPs" ) == 0 ) {
    }
    //----------------------------------------------------------------
    // Process .10 format
    else if ( strcmp( format, "10" ) == 0 ) {
    }
    //----------------------------------------------------------------
    // Process .ASC format
    else if ( strcmp( format, "ASC" ) == 0 ) {
    }
    //----------------------------------------------------------------
    // Process .ASE format
    else if ( strcmp( format, "ASE" ) == 0 ) {
        if ( !Read3dsMaxASE<T>::readFile( fileName, prModel, eModelType ) ) {
            std::cout << "TAPsReadModels: Read3dsMaxASE<T>::readFile Fn returns false!" << std::endl;
            return false;
        }
    }
    //----------------------------------------------------------------
    // Process .ply format
    else if ( strcmp( format, "ply" ) == 0 ) {
    }
    //----------------------------------------------------------------
    // Process .off format
    else if ( strcmp( format, "off" ) == 0 ) {
    }
    //----------------------------------------------------------------
    // The format of the file is not supported.
    else {
        std::cout << "The input file (." << format << ") is not supported!" << std::endl;
        return false;
    }
    //----------------------------------------------------------------
    delete [] name;
    delete [] format;
    //----------------------------------------------------------------
    std::cout << typeid( prModel ).name() << std::endl;     // Display Model Type Pointer
    std::cout << typeid( *prModel ).name() << std::endl;    // Display Model Type
    //================================================================
    // MODEL INITIALIZATION
    prModel->Initialize();
    //================================================================
    return true;
}
//-----------------------------------------------------------------------------
// Read an input file
template <typename T>
bool ReadModels<T>::readFile( const char *fileName, 
                        OpenGL::MultiMeshModelWithMBV<T> * const prModel, 
                        TAPs::Enum::ModelType eModelType )
{
    //----------------------------------------------------------------
    // Find the format of the file
    char *name = new char[ strlen( fileName )+1 ];
    char *format = new char[64];
    strcpy( name, fileName );
    char *token = strtok( name, "." );
    do {
        strcpy( format, token );
        token = strtok( '\0', "." );
    } while ( token );
    //----------------------------------------------------------------
    // If model is not created yet!
    if ( !prModel ) {
        std::cout << "The model must be created first!" << std::endl;
        return false;
    }
    //----------------------------------------------------------------
    // Process .TAPs format
    if ( strcmp( format, "TAPs" ) == 0 ) {
    }
    //----------------------------------------------------------------
    // Process .10 format
    else if ( strcmp( format, "10" ) == 0 ) {
    }
    //----------------------------------------------------------------
    // Process .ASC format
    else if ( strcmp( format, "ASC" ) == 0 ) {
    }
    //----------------------------------------------------------------
    // Process .ASE format
    else if ( strcmp( format, "ASE" ) == 0 ) {
        //-------------------------------------------------
        // Multi Mesh Model
        if ( !Read3dsMaxASE<T>::readFile( fileName, prModel->GetMultiMeshModel(), eModelType ) ) {
            std::cout << "TAPsReadModels: Read3dsMaxASE<T>::readFile Fn (for MultiMeshWithMBV - Multi Mesh Model Part) returns false!" << std::endl;
            return false;
        }
        char extensionName[] = "MBV";
        char MBVfile[128];
        //-------------------------------------------------
        // Multi Bounding Volume
        TAPs::Fn::UsefulFn::ChangeFileNameExtension( MBVfile, fileName, extensionName );
        if ( !ReadTAPsMBV<T>::ReadFile( MBVfile, prModel->GetMultiBoundingVolume() ) ) {
            std::cout << "TAPsReadModels: Read3dsMaxASE<T>::readFile Fn (for MultiMeshWithMBV - Multi Bounding Volume Part) returns false!" << std::endl;
            return false;
        }
    }
    //----------------------------------------------------------------
    // Process .ply format
    else if ( strcmp( format, "ply" ) == 0 ) {
    }
    //----------------------------------------------------------------
    // Process .off format
    else if ( strcmp( format, "off" ) == 0 ) {
    }
    //----------------------------------------------------------------
    // The format of the file is not supported.
    else {
        std::cout << "The input file (." << format << ") is not supported!" << std::endl;
        return false;
    }
    //----------------------------------------------------------------
    std::cout << typeid( prModel ).name() << std::endl;     // Display Model Type Pointer
    std::cout << typeid( *prModel ).name() << std::endl;    // Display Model Type
    //================================================================
    // MODEL INITIALIZATION
    prModel->Initialize();
    //================================================================
    return true;
}
//-----------------------------------------------------------------------------
// Read an input file
template <typename T>
bool ReadModels<T>::readFile( 
    const char *fileName, 
    std::vector< OpenGL::OpenGLHETriMeshOneModelMultiParts<T> * > & modelList 
)
{
    //----------------------------------------------------------------
    // Find the format of the file
    char * name   = new char[ strlen( fileName )+1 ];
    char * format = new char[ strlen( fileName )+1 ];
    strcpy( name, fileName );
    char *token = strtok( name, "." );
    do {
        strcpy( format, token );
        token = strtok( '\0', "." );
    } while ( token );
    //----------------------------------------------------------------
    // Process .TAPs format
    if ( strcmp( format, "TAPs" ) == 0 ) {
    }
    //----------------------------------------------------------------
    // Process .10 format
    else if ( strcmp( format, "10" ) == 0 ) {
    }
    //----------------------------------------------------------------
    // Process .ASC format
    else if ( strcmp( format, "ASC" ) == 0 ) {
    }
    //----------------------------------------------------------------
    // Process .ASE format
    else if ( strcmp( format, "ASE" ) == 0 ) {
        if ( !Read3dsMaxASE<T>::readFile( fileName, modelList ) ) {
            std::cout << "TAPsReadModels: Read3dsMaxASE<T>::readFile Fn returns false!" << std::endl;
            return false;
        }
    }
    //----------------------------------------------------------------
    // Process .ply format
    else if ( strcmp( format, "ply" ) == 0 ) {
    }
    //----------------------------------------------------------------
    // Process .off format
    else if ( strcmp( format, "off" ) == 0 ) {
    }
    //----------------------------------------------------------------
    // The format of the file is not supported.
    else {
        std::cout << "The input file (." << format << ") is not supported!" << std::endl;
        return false;
    }
    //----------------------------------------------------------------
    delete [] name;
    delete [] format;
    //----------------------------------------------------------------
    std::cout << typeid( modelList ).name() << std::endl;   // Display Model Type Pointer
    //================================================================
    return true;
}
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs
//-----------------------------------------------------------------------------
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8