J:/Caro/C++_Coding/HierarchicalEdgeBundle/HierarchicalEdgeBundle/header/RenderImplementation.h

Go to the documentation of this file.

#pragma once
#include "Renderer.h"
#include "Shader.h"
#include "FBO.h"
#include "Camera.h"
#include "Light.h"
#include "View.h"
#include "Image.h"

#include <glew.h>
#include <QGLWidget>
#include <QtOpenGL>
#include <QColor>
#include <QGLContext>
#include <QGLFormat>

class RenderImplementation :    public Renderer
{
public:
        RenderImplementation(void);
        ~RenderImplementation(void);

        void Initialize();
        void CreateObjects(View** view);
        void DrawObjects(Camera* camera, Light* light);

        void DrawGrid();
        void DrawVertices();
        void DrawAllVertices();
        void DrawSelectedVertex(VertexPtr v);
        void DrawNotSelectedVertices(VertexPtr v);
        void DrawRelationEdges();
        void DrawHierarchyEdges();
        void DrawHierarchyEdges(bool noshadow);
        void DrawScreenAlignedQuad(int tex, int tex2, int tex3, int tex4, int tex5,int tex6,int tex7);

        void BeginCamera();
        void BeginCamera(Camera* cam);
        void EndCamera();
        void BeginTextures(int tex, int tex2, int tex3, int tex4, int tex5,int tex6,int tex7);
        void EndTextures();     

        Camera* camera;

public:
        //FONT
        void LoadFont();
        void UnloadFont();
        void DrawFont(GLint x, GLint y, std::string string, int set,float scale);       // Where The Printing Happens
        void DrawHUD(int time);
        Matrix GetModelViewMatrix();
        Matrix GetProjectionMatrix();

public:
        void Picking(int curserX, int curserY);

        virtual void UpdateSphereColor(vec3 color, float alpha);
        virtual void UpdateHierarchyEdgeColor(vec3 color, float alpha);
        void UpdateHierarchyEdgeColorAt(vec3 color, float alpha, unsigned int actView);
        void UpdateHierarchyEdgeColorSelectionAt(vec3 color, float alpha, vec3 sele_color, float sele_alpha, unsigned int at);
        void UpdateRelationEdgeColor(vec3 color, float alpha, vec3 sele_color, float sele_alpha, unsigned int at);
        virtual void UpdateRelationEdgeColor(vec3 color, float alpha, vec3 endcolor, float endalpha);
        virtual void UpdateSelectionColor(vec3 color, float alpha);
private:
        void DrawVerticesPass(Matrix lightmatrix);
        void DrawRelationEdgePass();
        void DrawRelationEdgePassMethod1();
        void DrawRelationEdgePassMethod2();
        void DrawRelationEdgePassMethod3();
        void DrawShadowPass(Matrix& m);
        void DrawShadow(Matrix lightmatrix);
        void DrawResult();
        void UpdateLight();
        void UpdateSelection();

        int rendermode;
        
        Camera* cam_shadow;     

        //Shader
        ShaderObj* shaderobj_shadow;
        Shader* shadowshader;

        Shader* lightingshader;
        ShaderObj* shaderobj_lighting;

        ShaderObj* shaderobj;
        Shader* lightningshader;

        Shader* initweightingshader;    
        ShaderObj* shaderobj_weighting;

        ShaderObj* shaderobj_finalweighting;
        Shader* finalweightingshader;

        ShaderObj* shaderobj_blending;
        Shader* initblendingshader;

        Shader* initsumshader;
        ShaderObj* shaderobj_sum;
        Shader* finalsumshader;
        ShaderObj* shaderobj_finalsum;

        //FBO
        FBO* fbo_opacity;
        FBO* fbo_transparency;
        FBO* fbo_transparency2;
        FBO* fbo_shadow;

        GLuint tex_font;
        GLuint dl_font;

};