Geometry.h

Go to the documentation of this file.

#pragma once

#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>
#include <assimp/mesh.h>

#include <QVector>
#include <QVector2D>
#include <QVector3D>
#include <QMatrix4x4>
#include <QOpenGLFunctions>
#include <QThread>

#include "Trackable.h"


class SceneDestroyer : 
    public QThread
{
public:
    SceneDestroyer(Assimp::Importer* importer) : importer(importer){}
    ~SceneDestroyer(void){}
    
protected:
    Assimp::Importer* importer;
    void run(){
        importer->FreeScene();
    }
};


struct ColorSetInfo{
    QString name;                   
    QMap<QString, QString> legend;  
};


class Geometry : 
    public Trackable
{

    Q_OBJECT

public:
    Geometry(QString name, QString filename, QVector<ColorSetInfo> colorSetInfos, bool renderOnProjector=true);
    ~Geometry(void);
    
    //setters
    void setInherentTransform(Similarity inherentTransform){this->inherentTransform = inherentTransform;}

    //getters
    QString getName(){return name;}                                 
    QString getFilename(bool wholePath);                            
    bool isValid(){return valid;}                                   
    bool isRenderedOnProjector(){return renderOnProjector;}         
    int getActiveColorSet(){return activeColorSet;}                 
    QMatrix4x4 getModelMatrix();                                    
    Similarity getInherentTransform(){return inherentTransform;}    
    QVector<QVector4D>* getPositions(){return &positions;}          
    QVector<QVector3D>* getNormals(){return &normals;}              
    QVector<QVector2D>* getUvs(){return &uvs;}                      
    QVector<GLuint>* getIndices(){return &indices;}                 
    QVector<QVector4D>* getVertexColors(int layer);                 
    QVector<ColorSetInfo>* getColorSetInfos(){return &colorSetInfos;}
    bool hasNormals(){return !normals.isEmpty();}                   
    bool hasUvs(){return !uvs.isEmpty();}                           
    bool hasVertexColors(){return !vertexColors.isEmpty();}         
    int numVertices(){return positions.size();}                     
    int numIndices(){return indices.size();}                        
    int numColorSets(){return vertexColors.size();}                 
protected:
    QString name;                                           
    QString filename;                                       
    Assimp::Importer importer;                              
    SceneDestroyer *sd;                                     
    bool valid;                                             
    bool renderOnProjector;                                 
    QVector<QVector4D> positions;                           
    QVector<QVector3D> normals;                             
    QVector<QVector2D> uvs;                                 
    QVector<GLuint> indices;                                
    QVector<QVector<QVector4D>> vertexColors;               
    QVector<ColorSetInfo> colorSetInfos;                    
    Similarity inherentTransform;                           
    int activeColorSet;                                     
    void freeAssimpScene(){importer.FreeScene();}           
public slots:
    void scale(float factor);                               
    void setScale(float absScale);                          
    void setTranslation(float x, float y, float z);         
    void setRotation(QQuaternion rotation);                 
    void setRotation(float x, float y, float z);            
    void setActiveColorSet(int layer);                      
};