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)
 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_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();

        virtual ~GLC_3dxmlToWorld();



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

        GLC_3DRep create3DrepFrom3dxmlRep(const QString&);

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



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



private:
        void loadManifest();

        void clear();

        void goToRepId(const QString&);

        void gotToPolygonalRepType();

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

        void loadProductStructure();

        void loadReference3D();

        void loadInstance3D();

        void loadReferenceRep();

        void loadInstanceRep();

        void loadExternalRef3D();

        GLC_StructReference* createReferenceRep(QString id, GLC_3DRep* pRep);

        GLC_Matrix4x4 loadMatrix(const QString&);

        void createUnfoldedTree();

        void checkForXmlError(const QString&);

        void loadLOD(GLC_Mesh*);

        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*);

        void setRepresentationFileName(GLC_3DRep* pRep);

        inline QXmlStreamReader::TokenType readNext();

        inline bool goToElement(QXmlStreamReader* pReader, const QString& element);

        // Return the content of an element
        inline QString getContent(QXmlStreamReader* pReader, const QString& element);

        inline QString readAttribute(QXmlStreamReader* pReader, const QString& attribute);

        inline bool endElementNotReached(QXmlStreamReader* pReader, const QString& element);

        inline bool startElementNotReached(QXmlStreamReader* pReader, const QString& element);

        inline void goToEndElement(QXmlStreamReader* pReader, const QString& element);

        void checkFileValidity(QIODevice* pIODevice);


// Private members
private:
        QXmlStreamReader* m_pStreamReader;

        QString m_FileName;

        QuaZip* m_p3dxmlArchive;

        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_SetOfAttachedFileName;

        QString m_CurrentFileName;

        QDateTime m_CurrentDateTime;

        QHash<unsigned int, OccurenceAttrib*> m_OccurenceAttrib;

        bool m_GetExternalRef3DName;

        static QMutex m_ZipMutex;

        QList<QByteArray> m_ByteArrayList;

};

QXmlStreamReader::TokenType GLC_3dxmlToWorld::readNext()
{
        QXmlStreamReader::TokenType token= m_pStreamReader->readNext();
        if (QXmlStreamReader::PrematureEndOfDocumentError == m_pStreamReader->error())
        {
                //qDebug() << "QXmlStreamReader::PrematureEndOfDocumentError == m_pStreamReader->error()";
                if (!m_ByteArrayList.isEmpty())
                {
                        m_pStreamReader->addData(m_ByteArrayList.takeFirst());
                        return readNext();
                }
        }
        return token;
}

bool GLC_3dxmlToWorld::goToElement(QXmlStreamReader* pReader, const QString& element)
{
        while(!pReader->atEnd() && !pReader->hasError() && !(pReader->isStartElement() && (pReader->name() == element)))
        {
                readNext();
        }
        return !pReader->atEnd() && !pReader->hasError();
}

QString GLC_3dxmlToWorld::getContent(QXmlStreamReader* pReader, const QString& element)
{
        QString content;
        while(endElementNotReached(pReader, element))
        {
                readNext();
                if (pReader->isCharacters() && !pReader->text().isEmpty())
                {
                        content+= pReader->text().toString();
                }
        }

        return content.trimmed();
}

QString GLC_3dxmlToWorld::readAttribute(QXmlStreamReader* pReader, const QString& attribute)
{
        return pReader->attributes().value(attribute).toString();
}

bool GLC_3dxmlToWorld::endElementNotReached(QXmlStreamReader* pReader, const QString& element)
{
        return !pReader->atEnd() && !pReader->hasError() && !(pReader->isEndElement() && (pReader->name() == element));
}

bool GLC_3dxmlToWorld::startElementNotReached(QXmlStreamReader* pReader, const QString& element)
{
        return !pReader->atEnd() && !pReader->hasError() && !(pReader->isStartElement() && (pReader->name() == element));
}

void GLC_3dxmlToWorld::goToEndElement(QXmlStreamReader* pReader, const QString& element)
{
        while(endElementNotReached(pReader, element))
        {
                readNext();
        }
}


#endif /* GLC_3DXMLTOWORLD_H_ */