glc_objtoworld.h

Go to the documentation of this file.

/****************************************************************************

 This file is part of the GLC-lib library.
 Copyright (C) 2005-2008 Laurent Ribon (laumaya@users.sourceforge.net)
 Version 2.0.0 Beta 1, packaged on April 2010.

 http://glc-lib.sourceforge.net

 GLC-lib is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 GLC-lib is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with GLC-lib; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

*****************************************************************************/


#ifndef GLC_OBJTOWORLD_H_
#define GLC_OBJTOWORLD_H_

#include <QFile>
#include <QString>
#include <QObject>
#include <QHash>
#include <QVector>
#include <QStringList>

#include "../maths/glc_vector3d.h"
#include "../maths/glc_vector2df.h"
#include "../maths/glc_vector3df.h"
#include "../geometry/glc_mesh.h"

#include "../glc_config.h"

enum FaceType
{
        notSet,
        coordinate,
        coordinateAndTexture,
        coordinateAndNormal,
        coordinateAndTextureAndNormal
};

class GLC_World;
class GLC_ObjMtlLoader;
class QGLContext;



class GLC_LIB_EXPORT GLC_ObjToWorld : public QObject
{
        Q_OBJECT

public:
        // OBJ Vertice (Position index, Normal index and TexCoord index)
        struct ObjVertice
        {
                ObjVertice()
                : m_Values(3)
                {
                        m_Values[0]= 0;
                        m_Values[1]= 0;
                        m_Values[2]= 0;
                }
                ObjVertice(int v1, int v2, int v3)
                : m_Values(3)
                {
                        m_Values[0]= v1;
                        m_Values[1]= v2;
                        m_Values[2]= v3;
                }

                QVector<int> m_Values;
        };

        // Material assignement
        struct MatOffsetSize
        {
                MatOffsetSize()
                : m_Offset(0)
                , m_size(0)
                {}
                int m_Offset;
                int m_size;
        };

        // Current OBJ Mesh
        struct CurrentObjMesh
        {
                CurrentObjMesh(const QString materialName)
                : m_pMesh(new GLC_Mesh())
                , m_Positions()
                , m_Normals()
                , m_Texels()
                , m_Index()
                , m_pLastOffsetSize(new MatOffsetSize())
                , m_Materials()
                , m_NextFreeIndex(0)
                , m_ObjVerticeIndexMap()
                {
                        m_Materials.insert(materialName, m_pLastOffsetSize);
                }
                ~CurrentObjMesh()
                {
                        QHash<QString, MatOffsetSize*>::iterator i= m_Materials.begin();
                        while (m_Materials.constEnd() != i)
                        {
                                delete i.value();
                                ++i;
                        }
                }
                GLC_Mesh* m_pMesh;
                QList<float> m_Positions;
                QList<float> m_Normals;
                QList<float> m_Texels;
                IndexList m_Index;
                // Pointer to the last matOffsetSize
                MatOffsetSize* m_pLastOffsetSize;
                // QHash containing material id and associated offset and size
                QHash<QString, MatOffsetSize*> m_Materials;
                int m_NextFreeIndex;
                QHash<ObjVertice, GLuint> m_ObjVerticeIndexMap;
        };




public:
        GLC_ObjToWorld(const QGLContext*);
        virtual ~GLC_ObjToWorld();



public:
        GLC_World* CreateWorldFromObj(QFile &file);

        inline QStringList listOfAttachedFileName() const{return m_ListOfAttachedFileName;}

// Private services functions
private:
        QString getMtlLibFileName(QString);

        void scanLigne(QString &);

        void changeGroup(QString);

        QList<float> extract3dVect(QString &);

        QList<float> extract2dVect(QString &);

        void extractFaceIndex(QString &);

        void setCurrentMaterial(QString &line);

        void extractVertexIndex(QString ligne, int &Coordinate, int &Normal, int &TextureCoordinate);

        void setObjType(QString &);

        GLC_Vector3df computeNormal(GLuint, GLuint, GLuint);

        void clear();

        void mergeLines(QString*, QTextStream*);

        void addCurrentObjMeshToWorld();



// Qt Signals
        signals:
        void currentQuantum(int);

// Private members
private:
        GLC_World* m_pWorld;

        QString m_FileName;

        const QGLContext* m_pQGLContext;

        GLC_ObjMtlLoader* m_pMtlLoader;

        int m_CurrentLineNumber;

        CurrentObjMesh* m_pCurrentObjMesh;

        FaceType m_FaceType;

        QHash<QString, int> m_CurrentMeshMaterials;

        QString m_CurrentMaterialName;

        QStringList m_ListOfAttachedFileName;

        QList<float> m_Positions;

        QList<float> m_Normals;

        QList<float> m_Texels;
};

// To use ObjVertice as a QHash key
inline bool operator==(const GLC_ObjToWorld::ObjVertice& vertice1, const GLC_ObjToWorld::ObjVertice& vertice2)
{ return (vertice1.m_Values == vertice2.m_Values);}

inline uint qHash(const GLC_ObjToWorld::ObjVertice& vertice)
{ return qHash(QString::number(vertice.m_Values.at(0)) + QString::number(vertice.m_Values.at(1)) + QString::number(vertice.m_Values.at(2)));}


#endif /*GLC_OBJTOWORLD_H_*/