RayCasting.h

#pragma once
#include "RendererOpenGL.h"
#include "VertexGeometry.h"
#include "Primitives.h"
#include "Shader.h"
#include "ParticleSystemCuda.h"
#include "CudaTexture.h"

#include "GLM/gtx.hpp"
#include "GLM/gtc.hpp"
#include "GLM/gtx/type_ptr.hpp"

class RayCasting
{

public:
        RayCasting();
        ~RayCasting();

        void init();
        void resize(int width, int height);
        void render(float elapsedTime);

        void setVolumeTextureHandle(GLuint tex);
        void setTransferTextureHandle(GLuint tex);
        void RayCasting::setTransferTexture2DHandle(GLuint tex);
        void setTransferTextureParticleHandle(GLuint tex);
        void setTransferFunction(bool active);
        void setVolumeSize(float width, float height, float depth);
        void setTextureLoaded(bool loaded);
        void setLight(bool active);
        void setPhong(bool active);
        void setMip(bool active);
        void setAverage(bool active);
        void setCompositing(bool active);
        void setAdaptive(bool active);
        void setStepSize(double step);
        void setXClipping(float x);
        void setYClipping(float y);
        void setZClipping(float z);

        void setPCDTextureHandle(GLuint tex);

        void SetIsoValue(float val);

protected:

private:
        int screenWidth;
        int screenHeight;

        bool textureLoaded;

        float volumeWidth;
        float volumeHeight;
        float volumeDepth;
        GLuint volumeTextureHandle;
        GLuint pcdTextureHandle;

        GLuint transferTextureHandle;
        GLuint transferTextureHandle2D;
        GLuint tfParticleHandle;

        bool transferFunction;
        bool light;
        bool phong;
        bool mip;
        bool average;
        bool adaptive;
        double step;

        glm::vec4* quadVertices;

        float xClipping;
        float yClipping;
        float zClipping;

        void bindRayCastingTextures();
        void unbindRayCastingTextures();

        //for test only!!
        Shader* texturShader;

public:
        View* m_volumeBricks_front;
        View* m_volumeBricks_back;
//_________________
private:
        VertexGeometry* m_particle_geo;
        RendererOpenGL* m_renderer;

        ParticleSystemCuda* m_particle_cuda;

        FBO::FBOPtr fbo_back;
        FBO::FBOPtr fbo_front;
        FBO::FBOPtr fbo_hdr;
        View* m_bb_front;
        View* m_bb_back;
        View* m_raycasting;
        View* m_raycasting2D;
        View* m_mip;
        View* m_averaging;
        View* m_particle;
        View* m_hdr;
        View* m_cp_back;
        View* m_cp_front;
        View* m_cp2_back;
        View* m_cp2_front;
        
        View* m_contour;
        View* m_exposure;

        Camera* cam;

        unsigned int bspile_weights;
        unsigned int bspile_dev_weights;
public:
        VertexGeometry* m_plane_tmp;

public:
        int m_type;

        //COPY VOM CUDA SDK UM ZU TESTEN, OB DIE VOLUMENDATEN BENÜZT WERDEN KÖNNEN!!!
        void initPixelBuffer();
        void renderCuda();
        void display();
        float invViewMatrix[12];
        int width;
        int height;
        GLuint pbo;     // OpenGL pixel buffer object
        GLuint tex;     // OpenGL texture object
        struct cudaGraphicsResource *cuda_pbo_resource; // CUDA Graphics Resource (to transfer PBO)

        void AfterLoadingOfVolume(int width, int height, int depth);

        CudaTexture<float4,3>* m_volumen;
        CudaTexture<float4,2>* m_texture;

        CudaTexture<float4,2>* m_hg;
        CudaTexture<float4,2>* m_hg_dev;

        CudaTexture<float4,3>* m_pcd;
};