renderwindow.h

#ifndef RENDERWINDOW_H
#define RENDERWINDOW_H

#include <QWindow>
#include <QtOpenGL>
#include <QOpenGLFunctions_3_2_Core>
#include <QTimer>

#include "Volume.h"
#include "cannyedge.h"

#include "TransferWidget.hpp"

#include "Tools.h"

class RenderWindow : public QWindow
{
    Q_OBJECT

public:

    RenderWindow(QScreen *screen = 0);

    ~RenderWindow();

    void initialize();

    void update();

    void render();

    void updateAndRender();

    void resize(int width, int height);

    void setVolumeData(const std::string & strFilename);

    void setTransferfunction(const vector<TransferWidget::TransferFeature> &features);

    void initializeMatrices();
    void initializeSettings();

    enum RenderType
    {
        RENDER_SLICE = 0,       
        RENDER_VOLUME           
    };

    enum ProjectionType
    {
        ORTHOGONAL = 0,         
        PERSPECTIVE             
    };

    enum VolumeCompositionMode
    {
        FRONT_TO_BACK = true,   
        BACK_TO_FRONT = false   
    };

    enum VolumeRenderMode
    {
        COMPOSITION = 0,        
        AVERAGING,              
        MAXIMUM_INTENSITY_PROJECTION    
    };

public slots:
    void onMessageLogged( QOpenGLDebugMessage message );
    void onTimeout();
    void updateSlice(int _value);
    void setSliceDirection(int _dir);
    void setRenderType(int _renderType);
    void setIsPerspectiveProjection(bool _perspectiveProjection);
    void setRenderShaded(bool _renderShaded);
    void setVolumeStepSize(double _stepSize);
    void setVolumeRenderMode(int _volumeRenderMode);
    void setVolumeCompositionMode(bool _compositingMode);
    void setRenderCannyEdges(bool _showCannyEdges);
    void setRenderJunctions(bool _showJunctions);
    void setRenderXJunctions(bool _showXJunctions);
    void setUseBlurredTF(bool _useBlurredTF);
    void calculateDepthEnergy();

signals:
    void depthOrderChanged(float);

private:
    void prepareShaders();
    void prepareTextures();
    void prepareFramebuffers();
    void prepareQuadVertexArrayObject();
    void prepareCubeVertexArrayObject();

    void updateSlice();
    void updateVolume();
    void renderSlice();
    void renderVolume();
    void renderCubeFrontfaces();
    void renderCubeBackfaces();

    void renderTextureToScreen(GLuint texture, bool clearScreen = true);
    void renderTextureRectToScreen(GLuint texture, bool clearScreen = true);
    void renderQImageToScreen(const QImage &image, bool clearScreen = true);

    CannyEdge *cannyEdgeDetector;

    QOpenGLContext *v_context;

    QOpenGLFunctions_3_2_Core *v_funcs;

    QOpenGLShaderProgram *v_sliceShader;
    QOpenGLShaderProgram *v_cubeShader;
    QOpenGLShaderProgram *v_rayShader;
    QOpenGLShaderProgram *v_imageRectShader;
    QOpenGLShaderProgram *v_imageShader;
    
    QOpenGLFramebufferObject *v_frontFB;
    QOpenGLFramebufferObject *v_backFB;
    QOpenGLFramebufferObject *v_screenRectFB;
    
    QOpenGLVertexArrayObject v_quad;
    QOpenGLVertexArrayObject v_cube;

    QOpenGLDebugLogger *m_logger;

    float *verticesFullscreenQuad;

    GLuint v_transferfunctionTex;
    GLuint v_tmpTex;
    QImage junctionImage;
    QImage xJunctionImage;
    
    QMatrix4x4 vMatrixSlice;
    float sliceNumber;
    int sliceDirection;
    GLuint v_sliceTex;

    Volume *volumeData;
    QMatrix4x4 pMatrixVolume;
    QMatrix4x4 vMatrixVolume;
    QMatrix4x4 mMatrixVolume;
    VolumeRenderMode volumeRenderMode;
    VolumeCompositionMode volumeCompositionMode;
    float volumeStepsize;
    bool volumeShadedRendering;
    bool showCannyEdges;
    bool showJunctions;
    bool showXJunctions;
    bool useBluredTF;

    QMatrix4x4 mvpMatrixScreenRect;

    RenderType renderType;
    ProjectionType projectionType;

    float alphaView;
    float betaView;
    float distanceView;
    float inclinationView;
    float azimuthView;
    QVector3D viewPosVolume;
    QPoint lastMousePos;
    bool isMouseMoving;

    float depthOrdering;

    float *copyTransferfunctionValues;
    float sigmaTF;
    int filterSizeTF;

protected:
    void mousePressEvent(QMouseEvent *event);
    void mouseMoveEvent(QMouseEvent *event);
    void mouseReleaseEvent(QMouseEvent *event);
    void wheelEvent(QWheelEvent *event);
};

#endif // RENDERWINDOW_H