glc_worldto3dxml.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_WORLDTO3DXML_H_
#define GLC_WORLDTO3DXML_H_
#include <QObject>
#include <QXmlStreamWriter>

#include "../sceneGraph/glc_world.h"
#include "../glc_config.h"
#include <QReadWriteLock>

class QuaZip;
class QuaZipFile;
class QFile;
class GLC_Mesh;



class GLC_LIB_EXPORT GLC_WorldTo3dxml : public QObject
{
        Q_OBJECT

public:
        enum ExportType
        {
                Compressed3dxml,
                Exploded3dxml,
                StructureOnly
        };


public:
        GLC_WorldTo3dxml(const GLC_World& world, bool threaded= true);
        virtual ~GLC_WorldTo3dxml();



public:
        bool exportTo3dxml(const QString& filename, GLC_WorldTo3dxml::ExportType exportType, bool exportMaterial= true);

        bool exportReferenceTo3DRep(const GLC_3DRep* p3DRep, const QString& fullFileName);

        inline void setGeneratorName(const QString& generator)
        {m_Generator= generator;}

        void setInterupt(QReadWriteLock* pReadWriteLock, bool* pInterupt);



private:

        void writeHeader();

        void writeReference3D(const GLC_StructReference* pRef);

        void writeReferenceRep(const GLC_3DRep* p3DRep);

        void writeInstance3D(const GLC_StructInstance* pInstance, unsigned int parentId);

        void writeInstanceRep(const GLC_3DRep* p3DRep, unsigned int parentId);

        void setStreamWriterToFile(const QString& fileName);

        void addManifest();

        void exportAssemblyStructure();

        void exportAssemblyFromOccurence(const GLC_StructOccurence* pOccurence);

        QString matrixString(const GLC_Matrix4x4& matrix);

        void write3DRep(const GLC_3DRep* pRep, const QString& fileName);

        QString representationFileName(const GLC_3DRep* pRep);

        void writeGeometry(const GLC_Mesh* pMesh);

        void writeGeometryFace(const GLC_Mesh* pMesh, int lod, GLC_uint materialId);

        void writeSurfaceAttributes(const GLC_Material* pMaterial);

        void writeEdges(const GLC_Mesh* pMesh);

        void writeLineAttributes(const QColor& color);

        void writeMaterial(const GLC_Material* pMaterial);

        void writeMaterialAttributtes(const QString& name, const QString& type, const QString& value);

        QString colorToString(const QColor& color);

        void writeCatRepImageFile(const QList<GLC_Material*>& materialList);

        void writeCATRepresentationImage(const GLC_Material* pMat, unsigned int id);

        void writeAllMaterialRelatedFilesIn3dxml();

        void writeImageFileIn3dxml(const QList<GLC_Material*>& materialList);

        void writeCatMaterialRef(const QList<GLC_Material*>& materialList);

        void writeMaterialToCatMaterialRef(const GLC_Material* pMat, unsigned int* id);

        void addImageTextureTo3dxml(const QImage& image, const QString& fileName);

        QString xmlFileName(QString fileName);

        void writeExtensionAttributes(GLC_Attributes* pAttributes);

        void writeOccurenceDefaultViewProperty(const GLC_StructOccurence* pOccurence);

        bool continu();

        QString symplifyName(QString name);

        QList<unsigned int> instancePath(const GLC_StructOccurence* pOccurence);


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

        /* Private members */
private:
        GLC_World m_World;

        ExportType m_ExportType;

        QString m_FileName;

        QXmlStreamWriter* m_pOutStream;

        QString m_Generator;

        unsigned int m_CurrentId;

        QuaZip* m_p3dxmlArchive;

        QuaZipFile* m_pCurrentZipFile;

        QFile* m_pCurrentFile;

        QString m_AbsolutePath;

        QHash<const GLC_StructReference*, unsigned int> m_ReferenceToIdHash;

        QHash<const GLC_StructInstance*, unsigned int> m_InstanceToIdHash;

        QHash<const GLC_3DRep*, unsigned int> m_ReferenceRepToIdHash;

        QHash<const GLC_3DRep*, QString> m_ReferenceRepTo3dxmlFileName;

        QSet<unsigned int> m_InstanceRep;

        QHash<GLC_uint, QString> m_MaterialIdToMaterialName;

        QHash<GLC_uint, unsigned int> m_MaterialIdToMaterialId;

        QHash<GLC_uint, QString> m_MaterialIdToTexture3dxmlName;

        QHash<GLC_uint, unsigned int> m_MaterialIdTo3dxmlImageId;

        bool m_ExportMaterial;

        QSet<QString> m_3dxmlFileSet;

        unsigned int m_FileNameIncrement;

        QList<const GLC_StructOccurence*> m_ListOfOverLoadedOccurence;

        QReadWriteLock* m_pReadWriteLock;

        bool* m_pIsInterupted;

        bool m_IsThreaded;

};

#endif /* GLC_WORLDTO3DXML_H_ */