Eigene Dateien/Vis/src/VVolumeRenderer.h

Go to the documentation of this file.

#pragma once

#ifndef __v_volume_renderer_h
#define __v_volume_renderer_h

#include "VRenderer.h"
#include "VCamera.h"
#include "VFramebufferObject.h"
#include "VProgram.h"
#include "VPlane.h"
#include "VImage.h"

enum RenderMode
{
        MIP = 0,                
        DVR_FTB,                        
        DVR_BTF,                        
        COMB,
        CURVATURE
};

enum LightMode
{       
        PHONG = 0,                      
        TOON,                   
        METAL,                  
};

enum PlanePosition
{
        LEFT_RIGHT = 0,
        RIGHT_LEFT,
        BOTTOM_TOP,
        TOP_BOTTOM,
        FRONT_BACK,
        BACK_FRONT,
};

struct ClipSet
{
        bool XNEG_STATE;
        bool XPOS_STATE;
        bool YNEG_STATE;
        bool YPOS_STATE;
        bool ZNEG_STATE;
        bool ZPOS_STATE;

        float XNEG_VALUE;
        float YNEG_VALUE;
        float ZNEG_VALUE;
        float XPOS_VALUE;
        float YPOS_VALUE;
        float ZPOS_VALUE;

};

__interface ShaderWrapper
{
        void set();

        void clean();
        
};


class VVolumeRenderer : public VRenderer
{
public:

        VVolumeRenderer();

        VVolumeRenderer(VVolume * volume);

        ~VVolumeRenderer()
        {
                m_Raycast = 0;
                delete m_Raycast;

                //m_NoiseTex = 0;
                delete m_NoiseTex;
                delete m_ToonTex;
                delete m_MetalTex;
        }

        void draw();

        void drawFrontFaces();

        void drawFrontFacesToSmallQuad();

        void drawBackFaces();

        void drawBackFacesToSmallQuad();

        void processInput(guiInput input);

        void processSetPosition(float angle, VVector axis, VVector position, float scale);

        void processGuiInput(float dist, VVector pos, VVector view, VVector up, VVector lookAt);

        void setTransferFunctionHandle(unsigned int handle)
        {
                m_TransferFunctionHandle = handle;
        }

        void setTransferFunction2DHandle(unsigned int handle)
        {
                m_TransferFunction2DHandle = handle;
        }

        void setVolume(VVolume * volume)
        {
                m_Volume = volume;
                
                maxSize = (m_Volume->getDimX() < m_Volume->getDimY()) ? (float)m_Volume->getDimY() : (float)m_Volume->getDimX();
                maxSize = (maxSize < m_Volume->getDimZ()) ? (float)m_Volume->getDimZ() : maxSize;
                xsize = (float)(m_Volume->getDimX())/(float)(2*maxSize);
                ysize = (float)(m_Volume->getDimY())/(float)(2*maxSize);
                zsize = (float)(m_Volume->getDimZ())/(float)(2*maxSize);

                float xneg = m_ClipPlanes[LEFT_RIGHT];
                float xpos = m_ClipPlanes[RIGHT_LEFT];

                float yneg = m_ClipPlanes[BOTTOM_TOP];
                float ypos = m_ClipPlanes[TOP_BOTTOM];

                float zneg = m_ClipPlanes[FRONT_BACK];
                float zpos = m_ClipPlanes[BACK_FRONT];

                m_ClipPlaneObj[LEFT_RIGHT] = VPlane(VVector(-1.0f, 0.0f, 0.0f), VVector((-xsize) +  (xneg * xsize/0.5f), 0.0f, 0.0f));
                m_ClipPlaneObj[RIGHT_LEFT] = VPlane(VVector(1.0f, 0.0f, 0.0f), VVector(xsize - ((1.0f - xpos) * xsize/0.5f), 0.0f, 0.0f));

                m_ClipPlaneObj[BOTTOM_TOP] = VPlane(VVector(0.0f, -1.0f, 0.0f), VVector(0.0f, (-ysize) +  (yneg * ysize/0.5f), 0.0f));
                m_ClipPlaneObj[TOP_BOTTOM] = VPlane(VVector(0.0f, 1.0f, 0.0f), VVector(0.0f, ysize - ((1.0f - ypos) * ysize/0.5f), 0.0f));

                m_ClipPlaneObj[FRONT_BACK] = VPlane(VVector(0.0f, 0.0f, -1.0f), VVector(0.0f, 0.0f, (-zsize) +  (zneg * zsize/0.5f)));
                m_ClipPlaneObj[BACK_FRONT] = VPlane(VVector(0.0f, 0.0f, 1.0f), VVector(0.0f, 0.0f, zsize - ((1.0f - zpos) * zsize/0.5f)));

                m_Tex2WorldSpace.clearMatrix();
                //m_Tex2WorldSpace.scale(VVector(2.0f, 2.0f, 2.0f));
                m_Tex2WorldSpace.translate(VVector(-0.5f, -0.5f, -0.5f));

                VVector test = m_Tex2WorldSpace.homogenTransform(VVector(1.0f, 1.0f, 1.0f));
                //m_Tex2WorldSpace.scale(VVector(0.5f + xsize, 0.5f + ysize, 0.5f + zsize));
                //m_Tex2WorldSpace.translate(VVector(-1.0f, -1.0f, -1.0f));
                //m_Tex2WorldSpace.scale(VVector(xsize, ysize, zsize));
                

                m_updateDL = true;
        }

        VVector getCameraSideVector()
        {
                VMatrix viewm = m_Camera.getViewMatrix();

                return VVector(viewm[0], viewm[4], viewm[8]);
        }

        VVector getCameraUpVector()
        {
                VMatrix viewm = m_Camera.getViewMatrix();

                return VVector(viewm[1], viewm[5], viewm[9]);
        }
        
        VImage* getNoiseTexHandle()
        {
                return m_NoiseTex;
        }

        VImage* getToonTexHandle()
        {
                return m_ToonTex;
        }

        VImage* getMetalTexHandle()
        {
                return m_MetalTex;
        }

        void resize(int width, int height);

        void resetProxyGeometry()
        {
                generateProxyGeometryDisplayList();
        }

        void setRenderMode(RenderMode rm);

        void setShadows(bool b)
        {
                m_shadows = b;
                setRenderMode(m_renderMode);
        }

        void setContours(bool b)
        {
                m_contours = b;
                setRenderMode(m_renderMode);
        }

        void setThresholdL(float t)
        {
                m_thresholdL = t;
        }

        void setThresholdH(float t)
        {
                m_thresholdH = t;
        }

        void setLightMode(LightMode rm)
        {
                m_lightMode = rm;
                setRenderMode(m_renderMode);
        }

        void setClipPlane(PlanePosition plane, float value)
        {
                m_ClipPlanes[plane] = value;
                
                float xneg = m_ClipPlanes[LEFT_RIGHT];
                float xpos = m_ClipPlanes[RIGHT_LEFT];
                float yneg = m_ClipPlanes[BOTTOM_TOP];
                float ypos = m_ClipPlanes[TOP_BOTTOM];
                float zneg = m_ClipPlanes[FRONT_BACK];
                float zpos = m_ClipPlanes[BACK_FRONT];

                switch(plane)
                {
                case LEFT_RIGHT:
                        m_ClipPlaneObj[LEFT_RIGHT] = VPlane(VVector(-1.0f, 0.0f, 0.0f), VVector((-xsize) +  (xneg * xsize/0.5f), 0.0f, 0.0f));
                        break;
                case RIGHT_LEFT:
                        m_ClipPlaneObj[RIGHT_LEFT] = VPlane(VVector(1.0f, 0.0f, 0.0f), VVector(xsize - ((1.0f - xpos) * xsize/0.5f), 0.0f, 0.0f));
                        break;
                case BOTTOM_TOP:
                        m_ClipPlaneObj[BOTTOM_TOP] = VPlane(VVector(0.0f, -1.0f, 0.0f), VVector(0.0f, (-ysize) +  (yneg * ysize/0.5f), 0.0f));
                        break;
                case TOP_BOTTOM:
                        m_ClipPlaneObj[TOP_BOTTOM] = VPlane(VVector(0.0f, 1.0f, 0.0f), VVector(0.0f, ysize - ((1.0f - ypos) * ysize/0.5f), 0.0f));
                        break;
                case FRONT_BACK:
                        m_ClipPlaneObj[FRONT_BACK] = VPlane(VVector(0.0f, 0.0f, -1.0f), VVector(0.0f, 0.0f, (-zsize) +  (zneg * zsize/0.5f)));
                        break;
                case BACK_FRONT:
                        m_ClipPlaneObj[BACK_FRONT] = VPlane(VVector(0.0f, 0.0f, 1.0f), VVector(0.0f, 0.0f, zsize - ((1.0f - zpos) * zsize/0.5f)));
                        break;
                }
                m_updateDL = true;
        }

        void setLightDir(VVector dir)
        {
                m_LightDir[0] = dir.getX();
                m_LightDir[1] = dir.getY();
                m_LightDir[2] = dir.getZ();
        }

        float signum(float n)
        {
                if (n < 0.0f) return -1.0f;
                if (n > 0.0f) return 1.0f;
                return 0.0f;
        }

        void setClearColor(float * color)
        {
                m_ClearColor[0] = color[0];
                m_ClearColor[1] = color[1];
                m_ClearColor[2] = color[2];
        }

        void initContourTexture();

        void loadProgram()
        {
                m_WorldPosProgram = VProgram(VVertexShader("shader/worldpos_vertex.glsl"), VFragmentShader("shader/worldpos_fragment.glsl"));
                
                m_WorldWorldProgram = VProgram(VVertexShader("shader/worldpos_world_vertex.glsl"), VFragmentShader("shader/worldpos_fragment.glsl"));
                
                m_RayCasterMIP = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_mip.glsl"));
                m_RayCasterMIPtf = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_miptf.glsl"));
                m_RayCasterMIPtf2d = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_miptf.glsl"));

                m_RayCasterDVR = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvr.glsl"));
                m_RayCasterDVRtf = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrtf.glsl"));
                m_RayCasterDVRtf2d = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrtf2d.glsl"));

                m_RayCasterDVR_BTF      = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrbtf.glsl"));
                m_RayCasterDVR_BTFtf = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrbtftf.glsl"));
                m_RayCasterDVR_BTFtf2d = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrbtftf2d.glsl"));

                m_RayCasterCOMB_Phong                           = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrphong.glsl"));
                m_RayCasterCOMB_PhongCont                       = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrphongcont.glsl"));
                m_RayCasterCOMB_PhongContourShadow      = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrphongcontshadow.glsl"));
                m_RayCasterCOMB_PhongShadow                     = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrphongshadow.glsl"));

                m_RayCasterCOMB_Phongt2f                                = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrphongt2f.glsl"));
                m_RayCasterCOMB_PhongContt2f                    = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrphongcontt2f.glsl"));
                m_RayCasterCOMB_PhongContourShadowt2f   = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrphongcontshadowt2f.glsl"));
                m_RayCasterCOMB_PhongShadowt2f                  = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrphongshadowt2f.glsl"));
                
                
                m_RayCasterCOMB_Toon                            = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrtoon.glsl"));
                m_RayCasterCOMB_ToonCont                        = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrtooncont.glsl"));
                m_RayCasterCOMB_ToonContourShadow       = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrtooncontshadow.glsl"));
                m_RayCasterCOMB_ToonShadow                      = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrtoonshadow.glsl"));

                m_RayCasterCOMB_Toon2f                          = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrtoon2f.glsl"));
                m_RayCasterCOMB_ToonCont2f                      = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrtooncont2f.glsl"));
                m_RayCasterCOMB_ToonContourShadow2f     = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrtooncontshadow2f.glsl"));
                m_RayCasterCOMB_ToonShadow2f            = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrtoonshadow2f.glsl"));
                
                m_RayCasterCOMB_Metal                           = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrmetal.glsl"));
                m_RayCasterCOMB_MetalCont                       = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrmetalcont.glsl"));
                m_RayCasterCOMB_MetalContourShadow      = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrmetalcontshadow.glsl"));
                m_RayCasterCOMB_MetalShadow                     = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrmetalshadow.glsl"));


                m_RayCasterCOMB_Metal2f                         = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrmetal2f.glsl"));
                m_RayCasterCOMB_MetalCont2f                     = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrmetalcont2f.glsl"));
                m_RayCasterCOMB_MetalContourShadow2f    = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrmetalcontshadow2f.glsl"));
                m_RayCasterCOMB_MetalShadow2f           = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_dvrmetalshadow2f.glsl"));

                m_RayCasterCOMB_Curvature       = VProgram(VVertexShader("shader/raycaster_vertex.glsl"), VFragmentShader("shader/raycaster_fragment_curvature.glsl"));

                m_ProgramLoaded = true;
        }

        void activate_tf(int v)
        {
                m_tf_activated = v;
                setRenderMode(m_renderMode);
        }

        bool getProgramLoaded()
        {
                return m_ProgramLoaded;
        }

        void setOrthoMode(bool m_orth, int width = 0, int height = 0);

        void setShaderWrapperMIP();

        void setShaderWrapperMIPtf();

        void setShaderWrapperMIPtf2d();

        void setShaderWrapperDVR();

        void setShaderWrapperDVRtf();

        void setShaderWrapperDVRtf2d();

        void setShaderWrapperDVRbtf();

        void setShaderWrapperDVRbtftf();

        void setShaderWrapperDVRbtftf2d();

        void setShaderWrapperDVRCombPhong();

        void setShaderWrapperDVRCombPhongCont();

        void setShaderWrapperDVRCombPhongShadow();

        void setShaderWrapperDVRCombPhongContShadow();

        void setShaderWrapperDVRCombPhongt2f();

        void setShaderWrapperDVRCombPhongContt2f();

        void setShaderWrapperDVRCombPhongShadowt2f();

        void setShaderWrapperDVRCombPhongContShadowt2f();

        void setShaderWrapperDVRCombToon();

        void setShaderWrapperDVRCombToonCont();

        void setShaderWrapperDVRCombToonShadow();

        void setShaderWrapperDVRCombToonContShadow();

        void setShaderWrapperDVRCombToon2f();

        void setShaderWrapperDVRCombToonCont2f();

        void setShaderWrapperDVRCombToonShadow2f();

        void setShaderWrapperDVRCombToonContShadow2f();

        void setShaderWrapperDVRCombMetal();

        void setShaderWrapperDVRCombMetalCont();

        void setShaderWrapperDVRCombMetalShadow();

        void setShaderWrapperDVRCombMetalContShadow();

        void setShaderWrapperDVRCombMetal2f();

        void setShaderWrapperDVRCombMetalCont2f();

        void setShaderWrapperDVRCombMetalShadow2f();

        void setShaderWrapperDVRCombMetalContShadow2f();

        void setShaderWrapperCurvature();


        void clearShaderWrapperMIP();

        void clearShaderWrapperMIPtf();

        void clearShaderWrapperMIPtf2d();

        void clearShaderWrapperDVR();

        void clearShaderWrapperDVRtf();

        void clearShaderWrapperDVRtf2d();

        void clearShaderWrapperDVRbtf();

        void clearShaderWrapperDVRbtftf();

        void clearShaderWrapperDVRbtftf2d();

        void clearShaderWrapperDVRCombPhong();

        void clearShaderWrapperDVRCombPhongCont();

        void clearShaderWrapperDVRCombPhongShadow();

        void clearShaderWrapperDVRCombPhongContShadow();

        void clearShaderWrapperDVRCombPhongt2f();

        void clearShaderWrapperDVRCombPhongContt2f();

        void clearShaderWrapperDVRCombPhongShadowt2f();

        void clearShaderWrapperDVRCombPhongContShadowt2f();

        void clearShaderWrapperDVRCombToon();   

        void clearShaderWrapperDVRCombToonCont();

        void clearShaderWrapperDVRCombToonShadow();

        void clearShaderWrapperDVRCombToonContShadow();

        void clearShaderWrapperDVRCombToon2f(); 

        void clearShaderWrapperDVRCombToonCont2f();

        void clearShaderWrapperDVRCombToonShadow2f();

        void clearShaderWrapperDVRCombToonContShadow2f();

        void clearShaderWrapperDVRCombMetal();

        void clearShaderWrapperDVRCombMetalCont();

        void clearShaderWrapperDVRCombMetalShadow();

        void clearShaderWrapperDVRCombMetalContShadow();

        void clearShaderWrapperDVRCombMetal2f();

        void clearShaderWrapperDVRCombMetalCont2f();

        void clearShaderWrapperDVRCombMetalShadow2f();

        void clearShaderWrapperDVRCombMetalContShadow2f();

        void clearShaderWrapperCurvature();

private:


        class ShaderWrapperMIP: public ShaderWrapper
        {
                public:
                        VVolumeRenderer *vrendererptr;                          
                        ShaderWrapperMIP(VVolumeRenderer *vrptr)
                        {
                                vrendererptr = vrptr;
                        }
                                
                         void ShaderWrapper::set()
                        {
                                vrendererptr->setShaderWrapperMIP();
                        }

                         void ShaderWrapper::clean()
                         {
                                 vrendererptr->clearShaderWrapperMIP();
                         }

                        ~ShaderWrapperMIP()
                        {
                                //shaderprogram = 0;
                                vrendererptr = 0;
                                delete vrendererptr;
                        }
        };

        class ShaderWrapperMIPtf: public ShaderWrapper
        {
                public:
                        VVolumeRenderer *vrendererptr;                          
                        ShaderWrapperMIPtf(VVolumeRenderer *vrptr)
                        {
                                vrendererptr = vrptr;
                        }
                        
                        void ShaderWrapper::set()
                        {
                                vrendererptr->setShaderWrapperMIPtf();
                        }
                        
                        void ShaderWrapper::clean()
                         {
                                 vrendererptr->clearShaderWrapperMIPtf();
                         }

                        ~ShaderWrapperMIPtf()
                        {
                                //shaderprogram = 0;
                                vrendererptr = 0;
                                delete vrendererptr;
                        }
        };

        class ShaderWrapperMIPtf2d: public ShaderWrapper
        {
                public:
                        VVolumeRenderer *vrendererptr;                          
                        ShaderWrapperMIPtf2d(VVolumeRenderer *vrptr)
                        {
                                vrendererptr = vrptr;
                        }
                        
                        void ShaderWrapper::set()
                        {
                                vrendererptr->setShaderWrapperMIPtf2d();
                        }
                        
                        void ShaderWrapper::clean()
                         {
                                 vrendererptr->clearShaderWrapperMIPtf2d();
                         }

                        ~ShaderWrapperMIPtf2d()
                        {
                                //shaderprogram = 0;
                                vrendererptr = 0;
                                delete vrendererptr;
                        }
        };

        class ShaderWrapperDVR: public ShaderWrapper
        {
                public:
                        VVolumeRenderer *vrendererptr;                          
                        ShaderWrapperDVR(VVolumeRenderer *vrptr)
                        {
                                vrendererptr = vrptr;
                        }
                        
                        void ShaderWrapper::set()
                        {
                                vrendererptr->setShaderWrapperDVR();
                        }
                        
                        void ShaderWrapper::clean()
                        {
                         vrendererptr->clearShaderWrapperDVR();
                        }
                        
                        ~ShaderWrapperDVR()
                        {
                                //shaderprogram = 0;
                                vrendererptr = 0;
                                delete vrendererptr;
                        }
        };

        class ShaderWrapperDVRtf: public ShaderWrapper
        {
                public:
                        VVolumeRenderer *vrendererptr;                          
                        ShaderWrapperDVRtf(VVolumeRenderer *vrptr)
                        {
                                vrendererptr = vrptr;
                        }
                        
                        void ShaderWrapper::set()
                        {
                                vrendererptr->setShaderWrapperDVRtf();
                        }
                        
                        void ShaderWrapper::clean()
                        {
                         vrendererptr->clearShaderWrapperDVRtf();
                        }

                        ~ShaderWrapperDVRtf()
                        {
                                //shaderprogram = 0;
                                vrendererptr = 0;
                                delete vrendererptr;
                        }
        };

        class ShaderWrapperDVRtf2d: public ShaderWrapper
        {
                public:
                        VVolumeRenderer *vrendererptr;                          
                        ShaderWrapperDVRtf2d(VVolumeRenderer *vrptr)
                        {
                                vrendererptr = vrptr;
                        }
                        
                        void ShaderWrapper::set()
                        {
                                vrendererptr->setShaderWrapperDVRtf2d();
                        }
                        
                        void ShaderWrapper::clean()
                        {
                         vrendererptr->clearShaderWrapperDVRtf2d();
                        }

                        ~ShaderWrapperDVRtf2d()
                        {
                                //shaderprogram = 0;
                                vrendererptr = 0;
                                delete vrendererptr;
                        }
        };

        class ShaderWrapperDVRbtf: public ShaderWrapper
        {
                public:
                        VVolumeRenderer *vrendererptr;                          
                        ShaderWrapperDVRbtf(VVolumeRenderer *vrptr)
                        {
                                vrendererptr = vrptr;
                        }
                        
                        void ShaderWrapper::set()
                        {
                                vrendererptr->setShaderWrapperDVRbtf();
                        }
                        
                        void ShaderWrapper::clean()
                        {
                         vrendererptr->clearShaderWrapperDVRbtf();
                        }
                        
                        ~ShaderWrapperDVRbtf()
                        {
                                //shaderprogram = 0;
                                vrendererptr = 0;
                                delete vrendererptr;
                        }
        };

        class ShaderWrapperDVRbtftf: public ShaderWrapper
        {
                public:
                        VVolumeRenderer *vrendererptr;                          
                        ShaderWrapperDVRbtftf(VVolumeRenderer *vrptr)
                        {
                                vrendererptr = vrptr;
                        }
                        
                        void ShaderWrapper::set()
                        {
                                vrendererptr->setShaderWrapperDVRbtftf();
                        }
                        
                        void ShaderWrapper::clean()
                        {
                         vrendererptr->clearShaderWrapperDVRbtftf();
                        }
                        ~ShaderWrapperDVRbtftf()
                        {
                                //shaderprogram = 0;
                                vrendererptr = 0;
                                delete vrendererptr;
                        }
        };

        class ShaderWrapperDVRbtftf2d: public ShaderWrapper
        {
                public:
                        VVolumeRenderer *vrendererptr;                          
                        ShaderWrapperDVRbtftf2d(VVolumeRenderer *vrptr)
                        {
                                vrendererptr = vrptr;
                        }
                        
                        void ShaderWrapper::set()
                        {
                                vrendererptr->setShaderWrapperDVRbtftf2d();
                        }
                        
                        void ShaderWrapper::clean()
                        {
                         vrendererptr->clearShaderWrapperDVRbtftf2d();
                        }

                        ~ShaderWrapperDVRbtftf2d()
                        {
                                //shaderprogram = 0;
                                vrendererptr = 0;
                                delete vrendererptr;
                        }
        };


        class ShaderWrapperDVRCombPhong: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombPhong(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombPhong();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombPhong();
                }

                ~ShaderWrapperDVRCombPhong()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombPhongCont: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombPhongCont(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombPhongCont();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombPhongCont();
                }

                ~ShaderWrapperDVRCombPhongCont()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombPhongShadow: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombPhongShadow(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombPhongShadow();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombPhongShadow();
                }

                ~ShaderWrapperDVRCombPhongShadow()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombPhongContShadow: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombPhongContShadow(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }

                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombPhongContShadow();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombPhongContShadow();
                }

                ~ShaderWrapperDVRCombPhongContShadow()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };



        class ShaderWrapperDVRCombPhongt2f: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombPhongt2f(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombPhongt2f();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombPhongt2f();
                }

                ~ShaderWrapperDVRCombPhongt2f()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombPhongContt2f: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombPhongContt2f(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombPhongContt2f();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombPhongContt2f();
                }

                ~ShaderWrapperDVRCombPhongContt2f()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombPhongShadowt2f: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombPhongShadowt2f(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombPhongShadowt2f();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombPhongShadowt2f();
                }

                ~ShaderWrapperDVRCombPhongShadowt2f()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombPhongContShadowt2f: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombPhongContShadowt2f(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombPhongContShadowt2f();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombPhongContShadowt2f();
                }

                ~ShaderWrapperDVRCombPhongContShadowt2f()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombToon: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombToon(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombToon();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombToon();
                }

                ~ShaderWrapperDVRCombToon()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombToonCont: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombToonCont(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombToonCont();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombToonCont();
                }

                ~ShaderWrapperDVRCombToonCont()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombToonShadow: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombToonShadow(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombToonShadow();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombToonShadow();
                }

                ~ShaderWrapperDVRCombToonShadow()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombToonContShadow: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombToonContShadow(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }

                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombToonContShadow();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombToonContShadow();
                }

                ~ShaderWrapperDVRCombToonContShadow()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombToon2f: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombToon2f(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombToon2f();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombToon2f();
                }

                ~ShaderWrapperDVRCombToon2f()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombToonCont2f: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombToonCont2f(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombToonCont2f();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombToonCont2f();
                }

                ~ShaderWrapperDVRCombToonCont2f()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombToonShadow2f: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombToonShadow2f(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombToonShadow2f();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombToonShadow2f();
                }

                ~ShaderWrapperDVRCombToonShadow2f()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombToonContShadow2f: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombToonContShadow2f(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombToonContShadow2f();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombToonContShadow2f();
                }

                ~ShaderWrapperDVRCombToonContShadow2f()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };


        class ShaderWrapperDVRCombMetal: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombMetal(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombMetal();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombMetal();
                }

                ~ShaderWrapperDVRCombMetal()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombMetalCont: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombMetalCont(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombMetalCont();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombMetalCont();
                }

                ~ShaderWrapperDVRCombMetalCont()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombMetalShadow: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombMetalShadow(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombMetalShadow();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombMetalShadow();
                }

                ~ShaderWrapperDVRCombMetalShadow()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombMetalContShadow: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombMetalContShadow(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombMetalContShadow();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombMetalContShadow();
                }

                ~ShaderWrapperDVRCombMetalContShadow()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombMetal2f: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombMetal2f(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombMetal2f();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombMetal2f();
                }

                ~ShaderWrapperDVRCombMetal2f()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombMetalCont2f: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombMetalCont2f(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombMetalCont2f();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombMetalCont2f();
                }

                ~ShaderWrapperDVRCombMetalCont2f()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombMetalShadow2f: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombMetalShadow2f(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombMetalShadow2f();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombMetalShadow2f();
                }

                ~ShaderWrapperDVRCombMetalShadow2f()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        class ShaderWrapperDVRCombMetalContShadow2f: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperDVRCombMetalContShadow2f(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperDVRCombMetalContShadow2f();
                }
                
                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperDVRCombMetalContShadow2f();
                }

                ~ShaderWrapperDVRCombMetalContShadow2f()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };


        class ShaderWrapperCurvature: public ShaderWrapper
        {
        public:
                VVolumeRenderer *vrendererptr;                          
                ShaderWrapperCurvature(VVolumeRenderer *vrptr)
                {
                        vrendererptr = vrptr;
                }
                
                void ShaderWrapper::set()
                {
                        vrendererptr->setShaderWrapperCurvature();
                }

                void ShaderWrapper::clean()
                {
                        vrendererptr->clearShaderWrapperCurvature();
                }

                ~ShaderWrapperCurvature()
                {
                        //shaderprogram = 0;
                        vrendererptr = 0;
                        delete vrendererptr;
                }
        };

        void generateProxyGeometryDisplayList();

        bool m_ProgramLoaded;                                   
        unsigned int m_TransferFunctionHandle;  
        unsigned int m_TransferFunction2DHandle;

        VCamera m_Camera;                                               
        VFramebufferObject * m_FrontFaceTexture;        
        VFramebufferObject * m_BackFaceTexture; 
        VFramebufferObject * m_WorldFrontFaceTexture;   
        VFramebufferObject * m_WorldBackFaceTexture;    
        unsigned int m_ProxyGeometryDisplayListHandle;  
        VProgram m_WorldPosProgram;                                     
        VProgram m_WorldWorldProgram;                           
        VProgram m_RayCasterMIP;                                                
        VProgram m_RayCasterMIPtf;                                              
        VProgram m_RayCasterMIPtf2d;                                            
        VProgram m_RayCasterDVRtf;                                              
        VProgram m_RayCasterDVR;                                                
        VProgram m_RayCasterDVRtf2d;                                    
        VProgram m_RayCasterDVR_BTF;                                    
        VProgram m_RayCasterDVR_BTFtf;                                  
        VProgram m_RayCasterDVR_BTFtf2d;                                        
        VProgram m_RayCasterCOMB_Phong;                                         
        VProgram m_RayCasterCOMB_PhongCont;                                                     
        VProgram m_RayCasterCOMB_PhongContourShadow;                                                    
        VProgram m_RayCasterCOMB_PhongShadow;                                           
        VProgram m_RayCasterCOMB_Phongt2f;                                                      
        VProgram m_RayCasterCOMB_PhongContt2f;                                          
        VProgram m_RayCasterCOMB_PhongContourShadowt2f;                                         
        VProgram m_RayCasterCOMB_PhongShadowt2f;                                                
        VProgram m_RayCasterCOMB_Toon;                                                  
        VProgram m_RayCasterCOMB_ToonCont;                                                                      
        VProgram m_RayCasterCOMB_ToonContourShadow;                                                             
        VProgram m_RayCasterCOMB_ToonShadow;                                                    
        VProgram m_RayCasterCOMB_Toon2f;                                                        
        VProgram m_RayCasterCOMB_ToonCont2f;                                                    
        VProgram m_RayCasterCOMB_ToonContourShadow2f;                                                   
        VProgram m_RayCasterCOMB_ToonShadow2f;                                                  
        VProgram m_RayCasterCOMB_Metal;                                                                 
        VProgram m_RayCasterCOMB_MetalCont;                                                                     
        VProgram m_RayCasterCOMB_MetalContourShadow;                                                                    
        VProgram m_RayCasterCOMB_MetalShadow;                                                                   
        VProgram m_RayCasterCOMB_Metal2f;                                                                       
        VProgram m_RayCasterCOMB_MetalCont2f;                                                                   
        VProgram m_RayCasterCOMB_MetalContourShadow2f;                                                                  
        VProgram m_RayCasterCOMB_MetalShadow2f;                                                                 
        VProgram m_RayCasterCOMB_Curvature;                                                                     
        ShaderWrapper *m_Raycast;                                                                               
        ShaderWrapperMIP swmip;                                                                                 
        ShaderWrapperMIPtf swmiptf;                                                                                     
        ShaderWrapperMIPtf2d swmiptf2d;                                                                                 
        ShaderWrapperDVR swdvr;                                                                                 
        ShaderWrapperDVRtf swdvrtf;                                                                                     
        ShaderWrapperDVRtf2d swdvrtf2d;                                                                                 
        ShaderWrapperDVRbtf swdvrbtf;                                                                                   
        ShaderWrapperDVRbtftf swdvrbtftf;                                                                                       
        ShaderWrapperDVRbtftf2d swdvrbtftf2d;                                                                                   
        ShaderWrapperDVRCombPhong swdvrcombphong;                                                                                       
        ShaderWrapperDVRCombPhongCont swdvrcombphongcont;                                                                                       
        ShaderWrapperDVRCombPhongShadow swdvrcombphongshadow;                                                                                   
        ShaderWrapperDVRCombPhongContShadow swdvrcombphongcontshadow;                                                                                   
        ShaderWrapperDVRCombPhongt2f swdvrcombphongt2f;                                                                                 
        ShaderWrapperDVRCombPhongContt2f swdvrcombphongcontt2f;                                                                                 
        ShaderWrapperDVRCombPhongShadowt2f swdvrcombphongshadowt2f;                                                                                     
        ShaderWrapperDVRCombPhongContShadowt2f swdvrcombphongcontshadowt2f;                                                                                     
        ShaderWrapperDVRCombToon swdvrcombtoon;                                                                                 
        ShaderWrapperDVRCombToonCont swdvrcombtooncont;                                                                                 
        ShaderWrapperDVRCombToonShadow swdvrcombtoonshadow;                                                                                     
        ShaderWrapperDVRCombToonContShadow swdvrcombtooncontshadow;                                                                                     
        ShaderWrapperDVRCombToon2f swdvrcombtoon2f;                                                                                     
        ShaderWrapperDVRCombToonCont2f swdvrcombtooncont2f;                                                                                     
        ShaderWrapperDVRCombToonShadow2f swdvrcombtoonshadow2f;                                                                                 
        ShaderWrapperDVRCombToonContShadow2f swdvrcombtooncontshadow2f;                                                                                 
        ShaderWrapperDVRCombMetal swdvrcombmetal;                                                                                       
        ShaderWrapperDVRCombMetalCont swdvrcombmetalcont;                                                                                       
        ShaderWrapperDVRCombMetalShadow swdvrcombmetalshadow;                                                                                   
        ShaderWrapperDVRCombMetalContShadow swdvrcombmetalcontshadow;                                                                                   
        ShaderWrapperDVRCombMetal2f swdvrcombmetal2f;                                                                                   
        ShaderWrapperDVRCombMetalCont2f swdvrcombmetalcont2f;                                                                                   
        ShaderWrapperDVRCombMetalShadow2f swdvrcombmetalshadow2f;                                                                                       
        ShaderWrapperDVRCombMetalContShadow2f swdvrcombmetalcontshadow2f;                                                                                       
        ShaderWrapperCurvature swcurvature;                                                                                     
        float m_VolumeSize[4];                                                                  
        bool m_updateDL;                                                                                
        int m_tf_activated;                                                                             
        RenderMode m_renderMode;                                                                
        float m_thresholdH;                                                                             
        float m_thresholdL;                                                                             
        LightMode m_lightMode;                                                                  
        ClipSet m_ClipperSettings;                                                              
        bool m_shadows;                                                                                 
        bool m_contours;                                                                                
        VQuaternion m_RotationX;                                                                
        VQuaternion m_RotationY;                                                                
        float m_ClipPlanes[6];                                                                  
        VPlane m_ClipPlaneObj[6];                                                               
        float m_ClearColor[3];                                                                  
        float m_LightDir[3];                                                                    
        VMatrix m_Tex2WorldSpace;                                                               
        unsigned int m_ContourHandle;                                                   
        float maxSize;                                                                                  
        float xsize;                                                                                    
        float ysize;                                                                                    
        float zsize;                                                                                    
        VImage *m_NoiseTex;                                                                             
        VImage *m_ToonTex;                                                                              
        VImage *m_MetalTex;                                                                             
};

#endif //__v_slice_renderer_h

---