glc_3dxmltoworld.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_3DXMLTOWORLD_H_
#define GLC_3DXMLTOWORLD_H_

#include <QFile>
#include <QObject>
#include <QXmlStreamReader>
#include <QHash>
#include <QSet>
#include <QDateTime>
#include "../maths/glc_matrix4x4.h"
#include "../sceneGraph/glc_3dviewinstance.h"

#include "glc_config.h"

class GLC_World;
class QGLContext;
class QuaZip;
class QuaZipFile;
class GLC_StructReference;
class GLC_StructInstance;
class GLC_Mesh;



class GLC_LIB_EXPORT GLC_3dxmlToWorld : public QObject
{
        Q_OBJECT


        struct AssyLink
        {
                unsigned int m_ParentRefId;
                GLC_StructInstance* m_pChildInstance;
                unsigned int m_InstanceId;
                inline bool operator < (const AssyLink& l) const
                {return m_InstanceId < l.m_InstanceId;}
        };

        struct RepLink
        {
                unsigned int m_ReferenceId;
                unsigned int  m_RepId;
        };

        struct MaterialRef
        {
                QString m_Id;
                QString m_Name;
                QString m_AssociatedFile;
        };


        struct OccurenceAttrib
        {
                inline OccurenceAttrib()
                : m_IsVisible(true)
                , m_pRenderProperties(NULL)
                {}
                inline ~OccurenceAttrib()
                {delete m_pRenderProperties;}

                bool m_IsVisible;
                GLC_RenderProperties* m_pRenderProperties;
        };

        typedef QHash<unsigned int, GLC_StructReference*> ReferenceHash;
        typedef QHash<GLC_StructInstance*, unsigned int> InstanceOfHash;
        typedef QHash<GLC_StructInstance*, QString> InstanceOfExtRefHash;
        typedef QSet<const QString> SetOfExtRef;
        typedef QList<AssyLink> AssyLinkList;
        typedef QList<RepLink> RepLinkList;
        typedef QHash<const QString, GLC_StructReference*> ExternalReferenceHash;
        typedef QHash<const QString, GLC_Material*> MaterialHash;
        typedef QHash<const unsigned int, QString> ReferenceRepHash;



public:
        GLC_3dxmlToWorld(const QGLContext*);

        virtual ~GLC_3dxmlToWorld();



public:
        GLC_World* createWorldFrom3dxml(QFile &, bool StructureOnly);

        GLC_3DRep create3DrepFrom3dxmlRep(const QString&);

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



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



private:
        void loadManifest();

        void clear();

        void goToElement(const QString&);

        void goToRepId(const QString&);

        void gotToPolygonalRepType();

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

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

        void loadProductStructure();

        void loadReference3D();

        void loadInstance3D();

        void loadReferenceRep();

        void loadInstanceRep();

        void loadExternalRef3D();

        GLC_StructReference* createReferenceRep(QString id= QString());

        GLC_Matrix4x4 loadMatrix(const QString&);

        void createUnfoldedTree();

        void checkForXmlError(const QString&);

        void loadLOD(GLC_Mesh*);

        inline bool endElementNotReached(const QString& element)
        {return !m_pStreamReader->atEnd() && !(m_pStreamReader->isEndElement() && (m_pStreamReader->name() == element));}

        inline bool startElementNotReached(const QString& element)
        {return !m_pStreamReader->atEnd() && !(m_pStreamReader->isStartElement() && (m_pStreamReader->name() == element));}

        void loadFace(GLC_Mesh*, const int lod, double accuracy);

        void loadPolyline(GLC_Mesh*);

        void clearMaterialHash();

        GLC_Material* loadSurfaceAttributes();

        GLC_Material* getMaterial();

        bool setStreamReaderToFile(QString, bool test= false);

        void loadGraphicsProperties();

        void loadDefaultViewProperty();

        void loadLocalRepresentations();

        void loadExternRepresentations();

        GLC_3DRep loadCurrentExtRep();

        void loadCatMaterialRef();

        void loadMaterialDef(const MaterialRef&);

        void loadCatRepImage();

        GLC_Texture* loadTexture(QString);

        void factorizeMaterial(GLC_3DRep*);


// Private members
private:
        const QGLContext* m_pQGLContext;

        QXmlStreamReader* m_pStreamReader;

        QString m_FileName;

        QuaZip* m_p3dxmlArchive;

        QuaZipFile* m_p3dxmlFile;

        QFile* m_pCurrentFile;

        QString m_RootName;

        GLC_World* m_pWorld;

        ReferenceHash m_ReferenceHash;

        AssyLinkList m_AssyLinkList;

        InstanceOfHash m_InstanceOf;

        SetOfExtRef m_SetOfExtRef;

        InstanceOfExtRefHash m_InstanceOfExtRefHash;

        ExternalReferenceHash m_ExternalReferenceHash;

        MaterialHash m_MaterialHash;

        bool m_IsInArchive;

        ReferenceRepHash m_ReferenceRepHash;

        RepLinkList m_LocalRepLinkList;

        RepLinkList m_ExternRepLinkList;

        SetOfExtRef m_SetOfExtRep;

        GLC_Material* m_pCurrentMaterial;

        QHash<QString, QString> m_TextureImagesHash;

        bool m_LoadStructureOnly;

        QSet<QString> m_ListOfAttachedFileName;

        QString m_CurrentFileName;

        QDateTime m_CurrentDateTime;

        QHash<unsigned int, OccurenceAttrib*> m_OccurenceAttrib;


};

#endif /* GLC_3DXMLTOWORLD_H_ */