glc_colladatoworld.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)
 http://glc-lib.sourceforge.net

 GLC-lib is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 3 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 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser 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_COLLADATOWORLD_H_
#define GLC_COLLADATOWORLD_H_

#include <QObject>
#include <QString>
#include <QFile>
#include <QXmlStreamReader>
#include <QHash>
#include <QColor>

#include "../shading/glc_material.h"
#include "../geometry/glc_mesh.h"
#include "../sceneGraph/glc_structoccurence.h"

#include "../glc_config.h"

class GLC_World;
class QGLContext;



class GLC_LIB_EXPORT GLC_ColladaToWorld : public QObject
{
private:
        Q_OBJECT

        // The 3 supported semantic
        enum Semantic
        { // Values are very important !
                VERTEX= 0,
                NORMAL= 1,
                TEXCOORD= 2
        };

        // input data info
        struct InputData
        {
                int m_Offset;
                QString m_Source;
                Semantic m_Semantic;
        };
public:
        // Collada Vertice (Position index, Normal index and TexCoord index)
        struct ColladaVertice
        {
                ColladaVertice()
                : m_Values(3)
                {
                        m_Values[0]= 0;
                        m_Values[1]= 0;
                        m_Values[2]= 0;
                }

                QVector<int> m_Values;
        };
private:

        // Material assignement
        struct MatOffsetSize
        {
                int m_Offset;
                int m_size;
        };

        // Accessor a source data (bulk)
        struct Accessor
        {
                Accessor()
                : m_Count(0)
                , m_Offset(0)
                , m_Stride(1)
                {}
                unsigned int m_Count;
                unsigned int m_Offset;
                unsigned int m_Stride;
        };

        // The loading mesh info
        struct MeshInfo
        {
                MeshInfo()
                : m_pMesh(NULL)
                , m_Datas(3)
                , m_Mapping()
                , m_Index()
                , m_FreeIndex(0)
                {}

                ~MeshInfo() {delete m_pMesh;}
                // Mesh of the mesh info
                GLC_Mesh* m_pMesh;
                // Bulk data vector (Position, normal, texel)
                QVector<QList<float> > m_Datas;
                // Mapping between collada vertice and index
                QHash<ColladaVertice, GLuint> m_Mapping;
                // Triangle index
                IndexList m_Index;
                // Next index Position
                GLuint m_FreeIndex;
                // QHash containing material id and associated offset and size
                QHash<QString, MatOffsetSize> m_Materials;
        };

        // The collada Node
        struct ColladaNode
        {
                ColladaNode(const QString id, ColladaNode* pParent)
                : m_Id(id)
                , m_Matrix()
                , m_InstanceGeometryIDs()
                , m_InstanceOffNodeIds()
                , m_ChildNodes()
                , m_pParent(pParent)
                {}
                // Destrucot not needed
                // The node id
                QString m_Id;
                // Position matrix
                GLC_Matrix4x4 m_Matrix;
                // Instance geometry id
                QList<QString> m_InstanceGeometryIDs;
                // Instance off another node
                QList<QString> m_InstanceOffNodeIds;
                // Child Node
                QList<ColladaNode*> m_ChildNodes;
                // Parent Node
                ColladaNode* m_pParent;
        };

        typedef QHash<const QString, GLC_Material*> MaterialHash;
        typedef QHash<const QString, QList<float> > BulkDataHash;
        typedef QHash<const QString, Accessor> DataAccessorHash;


public:
        GLC_ColladaToWorld();

        virtual ~GLC_ColladaToWorld();



public:
        GLC_World* CreateWorldFromCollada(QFile &);

        inline QStringList listOfAttachedFileName() const
        {return m_ListOfAttachedFileName.toList();}


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



private:
        void goToElement(const QString&);

        void goToEndElement(const QString&);

        // Return the content of an element
        QString getContent(const QString&);

        QString readAttribute(const QString&, bool required= false);

        void checkForXmlError(const QString&);

        void throwException(const QString&);

        void clear();

        void loadLibraryImage();

        void loadImage();

        void loadLibraryMaterials();

        void loadMaterial();

        void loadLibraryEffects();

        void loadEffect();

        void loadProfileCommon();

        void loadNewParam();

        void loadSurface(const QString&);

        void loadSampler2D(const QString&);

        void loadTechnique();

        void loadMaterialTechnique(const QString&);

        void loadCommonColorOrTexture(const QString&);

        void loadTransparent();

        void loadTransparency(const QString&);

        void loadShininess(const QString&);

        QColor readXmlColor();

        void loadLibraryGeometries();

        void loadGeometry();

        void loadMesh();

        void loadVertexBulkData();

        void loadTechniqueCommon();

        void loadAccessor();

        void loadVertices();

        void loadPolylist();

        void loadPolygons();

        void addPolylistToCurrentMesh(const QList<InputData>&, const QList<int>&, const QList<int>&, const QString&);

        void computeNormalOfCurrentPrimitiveOfCurrentMesh(int offset);

        void loadTriangles();

        void addTrianglesToCurrentMesh(const QList<InputData>&, const QList<int>&, const QString&);

        void loadLibraryNodes();

        void loadLibraryContollers();

        void loadVisualScenes();

        void loadInstanceGeometry(ColladaNode*);

        void loadInstanceNode(ColladaNode*);

        void loadInstanceController(ColladaNode*);

        void loadController();

        ColladaNode* loadNode(ColladaNode*);

        void translateNode(ColladaNode*);

        void scaleNode(ColladaNode*);

        void rotateNode(ColladaNode*);

        void composeMatrixNode(ColladaNode*);

        void loadScene();

        void linkTexturesToMaterials();

        void createMesh();

        void createSceneGraph();

        GLC_StructOccurence* createOccurenceFromNode(ColladaNode*);

        void updateProgressBar();




// Private members
private:
        GLC_World* m_pWorld;

        QXmlStreamReader* m_pStreamReader;

        QString m_FileName;

        QFile* m_pFile;

        QHash<QString, QString> m_ImageFileHash;

        QHash<QString, QString> m_MaterialLibHash;

        QHash<QString, QString> m_SurfaceImageHash;

        QHash<QString, QString> m_Sampler2DSurfaceHash;

        MaterialHash m_MaterialEffectHash;

        GLC_Material* m_pCurrentMaterial;

        MaterialHash m_TextureToMaterialHash;

        BulkDataHash m_BulkDataHash;

        DataAccessorHash m_DataAccessorHash;

        QHash<QString, QString> m_VerticesSourceHash;

        MeshInfo* m_pMeshInfo;

        QHash<const QString, MeshInfo*> m_GeometryHash;

        QHash<const QString, ColladaNode*> m_ColladaNodeHash;

        QList<ColladaNode*> m_TopLevelColladaNode;

        QHash<const QString, QString> m_MaterialInstanceMap;

        QHash<const QString, GLC_3DRep*> m_3DRepHash;

        QHash<const QString, GLC_StructInstance*> m_StructInstanceHash;

        QString m_CurrentId;

        qint64 m_FileSize;

        int m_CurrentOffset;

        QSet<QString> m_ListOfAttachedFileName;

        bool m_TransparentIsRgbZero;

};

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

inline uint qHash(const GLC_ColladaToWorld::ColladaVertice& 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_COLLADATOWORLD_H_ */