scene.h

Go to the documentation of this file.

#ifndef SCENE_H
#define SCENE_H

#include "GL/glew.h"
#include "abstractscene.h"
#include "ShaderManager.hpp"
#include "ModelLoader.hpp"

#include <QOpenGLShaderProgram>
#include <QOpenGLBuffer>
#include <QOpenGLVertexArrayObject>

class Scene : public AbstractScene
{
public:

    Scene();

    virtual void initialize();
    
    virtual void compileShader();
    
    virtual void update(float t);
    
    virtual void render();
    
    virtual void resize(int width, int height);
    
    void renderAmbientOcclusion();

    virtual void rotateAzimuth(float t);

    virtual void rotatePolar(float t);

    float m_LightAzimuth;
    float m_LightPolar;
    bool m_bContourEnabled;
    bool m_bContourConstant;
    bool m_bAmbientOcclusion;
    bool m_bShadowEnabled;
    float m_fContourDepthFactor;
    float m_fContourWidth;
    float m_fAmbientFactor;
    float m_fDiffuseFactor;
    float m_fSpecularFactor;
    float m_fNearPlane;
    float m_fAmbientIntensity;

public slots:
    
    virtual void setAmbientFactor(float ambientFactor);

    virtual void setDiffuseFactor(float diffuseFactor);

    virtual void setSpecularFactor(float specularFactor);

    virtual void setNearPlane(float nearPlane);

    virtual void setFarPlane(float farPlane);
    
    virtual void setAmbientOcclusion(bool value);

    virtual void setContourEnabled(bool value);

    virtual void setContourConstant(bool value);

    virtual void setDepthFactor(float depthFactor);

    virtual void setContourWidth(float width);

    virtual void setAmbientIntensity(float value);

    virtual void setShadowEnabled(bool value);

    virtual void switchAmbientOcclusionQuality(int quality);

private:

    void drawMolecule();
    
    void drawTest();
    
    bool loadModelFromPath(const std::string absoluteFilePath);
    
    void createSamplingDirections();
    
    void generateFBO();

    void createSamplingViewMatrices();

    void createShadowCamera();

    int m_bAmbientOcclusionQuality;
    int mSamplingDirectionsSize;
    std::vector<glm::vec3> mSamplingDirectionsLow;
    std::vector<glm::vec3> mSamplingDirectionsMedium;
    std::vector<glm::vec3> mSamplingDirectionsHigh;
    std::vector<glm::mat4> mSamplingViewMatrices;
    glm::mat4 mSamplingProjectionMatrix;

    glm::vec3 m_LightDir;

    GLuint m_VBO_AmbientOcclusion;
    GLuint m_Texture_DepthMap;
    GLuint m_Texture_AmbientOcc;

    GLuint m_vao;
    GLuint m_vbo;
    GLuint m_ebo;
    GLuint m_stdId;
    GLuint m_ShaderID_DepthMap;
    GLuint m_ShaderID_AmbOccl;

    ShaderManager *m_pShaderManager;

    bool m_bLoaded;
    ModelLoader *m_pModelLoader;

    glm::mat4 m_projMatrix;
    glm::mat4 m_modelViewMatrix;

    glm::mat4 m_ShadowProjMatrix;
    glm::mat4 m_ShadowViewMatrix;
};

#endif // SCENE_H