ReadModels< T > Class Template Reference

#include <TAPsReadModels.hpp>

List of all members.

Static Public Member Functions
static bool	ReadFile (const char *fileName, OpenGL::MultiMeshModelWithMBV< T > *const prModel, TAPs::Enum::ModelType eModelType=TAPs::Enum::MODEL_TYPE_XPOLYGONAL)
static bool	ReadFile (const char *fileName, OpenGL::MultiMeshModel< T > *const prModel, TAPs::Enum::ModelType eModelType=TAPs::Enum::MODEL_TYPE_XPOLYGONAL)
static bool	ReadFile (const char *fileName, OpenGL::OpenGLModel< T > *const prModel)
static bool	readFile (const char *fileName, OpenGL::MultiMeshModelWithMBV< T > *const prModel, TAPs::Enum::ModelType eModelType=TAPs::Enum::MODEL_TYPE_XPOLYGONAL)
static bool	readFile (const char *fileName, OpenGL::MultiMeshModel< T > *const prModel, TAPs::Enum::ModelType eModelType=TAPs::Enum::MODEL_TYPE_XPOLYGONAL)
static bool	readFile (const char *fileName, OpenGL::OpenGLModel< T > *const prModel)

---

Detailed Description

template<typename T>
class ReadModels< T >

Definition at line 123 of file TAPsReadModels.hpp.

---

Member Function Documentation

template<typename T>

static bool ReadModels< T >::ReadFile	(	const char *	fileName,
		OpenGL::MultiMeshModelWithMBV< T > *const	prModel,
		TAPs::Enum::ModelType	eModelType = TAPs::Enum::MODEL_TYPE_XPOLYGONAL
	)			[inline, static]

Definition at line 147 of file TAPsReadModels.hpp.

        { return readFile( fileName, prModel, eModelType ); }

template<typename T>

static bool ReadModels< T >::ReadFile	(	const char *	fileName,
		OpenGL::MultiMeshModel< T > *const	prModel,
		TAPs::Enum::ModelType	eModelType = TAPs::Enum::MODEL_TYPE_XPOLYGONAL
	)			[inline, static]

Definition at line 144 of file TAPsReadModels.hpp.

        { return readFile( fileName, prModel, eModelType ); }

template<typename T>

static bool ReadModels< T >::ReadFile	(	const char *	fileName,
		OpenGL::OpenGLModel< T > *const	prModel
	)			[inline, static]

Definition at line 142 of file TAPsReadModels.hpp.

        { return readFile( fileName, prModel ); }

template<typename T>

bool ReadModels< T >::readFile	(	const char *	fileName,
		OpenGL::MultiMeshModelWithMBV< T > *const	prModel,
		TAPs::Enum::ModelType	eModelType = TAPs::Enum::MODEL_TYPE_XPOLYGONAL
	)			[inline, static]

Definition at line 428 of file TAPsReadModels.cpp.

{
    //----------------------------------------------------------------
    // 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;
}

template<typename T>

bool ReadModels< T >::readFile	(	const char *	fileName,
		OpenGL::MultiMeshModel< T > *const	prModel,
		TAPs::Enum::ModelType	eModelType = TAPs::Enum::MODEL_TYPE_XPOLYGONAL
	)			[inline, static]

Definition at line 359 of file TAPsReadModels.cpp.

{
    //----------------------------------------------------------------
    // 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;
}

template<typename T>

BEGIN_NAMESPACE_TAPs bool ReadModels< T >::readFile	(	const char *	fileName,
		OpenGL::OpenGLModel< T > *const	prModel
	)			[inline, static]

Read an input file

I/P: fileName is the input file to be read.

O/P: prModel is the return pointer to the created model and the created model will have the same type as prModel.

Create a Model Object from an input file (support a variety of formats).

Definition at line 23 of file TAPsReadModels.cpp.

{
    //----------------------------------------------------------------
    // 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 );
    //----------------------------------------------------------------
    // 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 )
        {
            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;
}

---

The documentation for this class was generated from the following files:

• G:/spunak_xp/Works/TAPs/Include/TAPs/OpenGLModelFromFile/TAPsReadModels.hpp
• G:/spunak_xp/Works/TAPs/Include/TAPs/OpenGLModelFromFile/TAPsReadModels.cpp