RTVolumeRendering/Source/RTVolumeRenderer.cpp

Go to the documentation of this file.

#include <sstream>
#include "Error.h"
#include "Matrix.h"
#include "RTVolumeRenderer.h"

extern const char *volVertexShaderSource;
extern const char *volPixelShaderSource;

#include "../Shaders/vol.vs" /* Stores the volume vertex shader source into const char *volVertexShaderSource; */
#include "../Shaders/vol.ps" /* Stores the volume pixel shader source into const char *volPixelShaderSource; */

// The paramaters for creating a perspecive projection
const float PROJ_NEAR = 1.0f;
const float PROJ_FAR = 100.0f;

const float ROTATION_MULTIPLIER = 0.5f; // speeds up/slowes down the camera rotation speed.
const float ZOOM_MULTIPLIER = 25.0f; // speeds up/slowes down the zoom speed.

const float DELAY_DRAW_AMOUNT = 0.5f;

static int glOptions[] = { WX_GL_RGBA, WX_GL_DOUBLEBUFFER, WX_GL_DEPTH_SIZE, 32, 0 };

BEGIN_EVENT_TABLE(RTVolumeRenderer, wxGLCanvas)
        EVT_MOTION    (RTVolumeRenderer::MouseMove)
        EVT_LEFT_UP   (RTVolumeRenderer::MouseLeftUp)
        EVT_LEFT_DOWN (RTVolumeRenderer::MouseLeftDown)
        EVT_MOUSEWHEEL(RTVolumeRenderer::MouseWheel)
        EVT_KEY_DOWN  (RTVolumeRenderer::KeyDown)
END_EVENT_TABLE()

//----------------------------------------------------------
RTVolumeRenderer::RTVolumeRenderer(wxWindow *parent, int w, int h)
: 
wxGLCanvas(parent, wxID_ANY, wxDefaultPosition, wxSize(w, h), 0, wxT("Volume Renderer"), glOptions),
drawCube(false),
drawOutline(true),
drawPlanes(true),
useTexture(false),
redraw(true),
viewChanged(true),
quickRendering(false),
attachPlanesToView(true),
delayDrawTimer(0.0f),
mouseDown(false),
lastMouseX(0),
lastMouseY(0),
dt(0.0f),
width(w),
height(h)
{       
        Show(true);
        SetCurrent();
        
        InitOpenGL();
        ResizeRenderer(w, h);
        
        cube.Init();
        
        camera.SetMinRadius(1.0f);

        shader.LoadFromMemory(volVertexShaderSource, volPixelShaderSource);
        
        shader.SetTexture(0, "volTex");
        shader.SetTexture(1, "transferFunc");

        SetLightDirection(Vector3f(0.0f, 0.0f, 1.0f));
        SetLightDiffuseColor(Colors::White);
        
        shader.SetVector(0.1f, 0.1f, 0.1f, "Ambient");

        CubeDef c;
        c.c = Point3f(0.0f, 0.0f, 0.0f);
        c.dim = 2.0f;
        frame = CreateFrame(c);
}

//----------------------------------------------------------
void RTVolumeRenderer::ResizeRenderer(int w, int h)
{
        width = w;
        height = h;
        
        SetMinSize(wxSize(w, h));
        SetMaxSize(wxSize(w, h));
        SetSize(w, h);
        
        glViewport(0, 0, (float)width, (float)height);
        
        Matrixf proj;
        proj.MakePerspective((float)width, (float)height, PROJ_NEAR, PROJ_FAR);
        
        float glMat[16];
        proj.GetOpenGLMatrix(glMat);
        
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glMultMatrixf(glMat);
        
        redraw = true;
}

//----------------------------------------------------------
void RTVolumeRenderer::InitOpenGL()
{
        // Checks for the needed opengl extensions
        GLenum err = glewInit();
        if(err != GLEW_OK)
        {
                std::stringstream s;
                s << "Glew could not be initialized: " << glewGetErrorString(err);
                
                ErrorAndExit(s.str().c_str(), 1);
        }
        
        if(!GLEW_VERSION_2_0)
        {
                std::stringstream s;
                s << "OpenGL 2.0 support is required to run this program.\n";
                
                ErrorAndExit(s.str().c_str(), 1);
        }
        
        glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
        
        float glMat[16];
        camera.GetViewMatrix().GetOpenGLMatrix(glMat);
        
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        glMultMatrixf(glMat);

        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        
        glEnable(GL_TEXTURE_3D);
}

//----------------------------------------------------------
void RTVolumeRenderer::SetLightDirection(const Vector3f &dir)
{
        shader.SetVector(dir.x, dir.y, dir.z, "LDir");
        redraw = true;
}
        
//----------------------------------------------------------
void RTVolumeRenderer::SetLightDiffuseColor(const Color4f &c)
{
        shader.SetVector(c.r, c.g, c.b, "LDiffuse");
        redraw = true;
}

//----------------------------------------------------------
void RTVolumeRenderer::ShouldDrawCube(bool yn) 
{ 
        drawCube = yn;
        redraw = true;
}

//----------------------------------------------------------
void RTVolumeRenderer::ShouldDrawCubeOutline(bool yn) 
{ 
        drawOutline = yn; 
        redraw = true;
}

//----------------------------------------------------------
void RTVolumeRenderer::ShouldDrawPlanes(bool yn) 
{ 
        drawPlanes = yn;
        redraw = true;
}

//----------------------------------------------------------
void RTVolumeRenderer::UseVolumeTexture(bool yn) 
{
        useTexture = yn;
        redraw = true;
}

//----------------------------------------------------------
void RTVolumeRenderer::SetPlanes(int n) 
{
        cube.SetNumberOfPlanes(n);
        redraw = true;
}

//----------------------------------------------------------
void RTVolumeRenderer::SetBackgroundColor(const Color4f &c)
{
        glClearColor(c.r, c.g, c.b, 0.0f);
        redraw = true;
}

//----------------------------------------------------------
void RTVolumeRenderer::SetCubeColor(const Color4f &c) 
{ 
        cube.SetCubeColor(c); 
        redraw = true;
}

//----------------------------------------------------------
void RTVolumeRenderer::SetOutlineColor(const Color4f &c) 
{ 
        cube.SetOutlineColor(c);
        redraw = true;
}

//----------------------------------------------------------
void RTVolumeRenderer::SetPlaneColor(const Color4f &c) 
{ 
        cube.SetPlaneColor(c); 
        redraw = true;
}

//----------------------------------------------------------
void RTVolumeRenderer::Clear()
{
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}

//----------------------------------------------------------
bool RTVolumeRenderer::LoadVolumeDataSet(const char *name, const char *path, VTInfo &info)
{
        redraw = true;
        return volTex.Load(name, path, &info);
}

//----------------------------------------------------------
void RTVolumeRenderer::MouseMove(wxMouseEvent &m)
{
        if(m.ButtonIsDown(wxMOUSE_BTN_LEFT))
        {
                float dx = (lastMouseX - m.m_x) * dt * ROTATION_MULTIPLIER;
                float dy = (lastMouseY - m.m_y) * dt * ROTATION_MULTIPLIER;
                
                camera.RotateUp(dy);
                camera.RotateRight(dx);
                
                lastMouseX = m.m_x;
                lastMouseY = m.m_y;
                
                viewChanged = true;
                redraw = true;
        }
}

//----------------------------------------------------------
void RTVolumeRenderer::MouseLeftUp(wxMouseEvent &m)
{
        mouseDown = false;
        redraw = true;
}

//----------------------------------------------------------
void RTVolumeRenderer::MouseLeftDown(wxMouseEvent &m)
{
        lastMouseX = m.m_x;
        lastMouseY = m.m_y;
        
        mouseDown = true;
        redraw = true;

        // calls skip so the wxWindow can gain focus
        m.Skip();
}

//----------------------------------------------------------
void RTVolumeRenderer::MouseWheel(wxMouseEvent &m)
{
        float amt = m.GetWheelRotation() / (float)m.GetWheelDelta();
        camera.Zoom(dt*amt*ZOOM_MULTIPLIER);
        
        delayDrawTimer = DELAY_DRAW_AMOUNT;
        redraw = true;
}

//----------------------------------------------------------
void RTVolumeRenderer::TransferPlotChanged(TransferFunctionPlot *plot)
{
        plot->UpdateTexture(&transferFunc);
        redraw = true;
}

//----------------------------------------------------------
void RTVolumeRenderer::KeyDown(wxKeyEvent &k)
{
        int key = k.GetKeyCode();
        switch(key)
        {
                case 'A':
                        camera.RotateRight(-10.0f * dt * ROTATION_MULTIPLIER);
                        break;
                        
                case 'D':
                        camera.RotateRight(10.0f * dt * ROTATION_MULTIPLIER);
                        break;
                
                case 'W':
                        camera.RotateUp(-10.0f * dt * ROTATION_MULTIPLIER);
                        break;
                        
                case 'S':
                        camera.RotateUp(10.0f * dt * ROTATION_MULTIPLIER);
                        break;
                        
                case 'Z':
                        camera.Zoom(dt * ZOOM_MULTIPLIER);
                        break;
                        
                case 'X':
                        camera.Zoom(-dt * ZOOM_MULTIPLIER);
                        break;
                
                default:
                        return;
        };
        
        delayDrawTimer = DELAY_DRAW_AMOUNT;
        
        viewChanged = true;
        redraw = true;
}

//----------------------------------------------------------
void RTVolumeRenderer::Draw()
{
        float glMat[16];
        camera.GetViewMatrix().GetOpenGLMatrix(glMat);
        
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        glMultMatrixf(glMat);
        
        if(quickRendering)
        {
                if(!redraw)
                        return;
                
                if(mouseDown || delayDrawTimer > 0.0f)
                {
                        delayDrawTimer = std::max(0.0f, delayDrawTimer - dt);
                        
                        Clear();
                
                        if(drawCube)
                                cube.Draw();
                        cube.DrawOutline();
                
                        SwapBuffers();
                        return;
                }
        }
        
        Clear();
        
        if(attachPlanesToView && viewChanged)
        {
                cube.SetViewDirection(camera.ViewDirection());
                viewChanged = false;
        }
        
        if(drawPlanes)
        {
                if(useTexture)
                {
                        volTex.Bind(0);
                        transferFunc.Bind(1);
                        shader.Attach();
                        cube.DrawPlanes();
                        shader.Detach();
                        transferFunc.UnBind();
                        volTex.UnBind();
                }
                else
                {
                        cube.DrawPlanes();
                }
        }
        
        if(drawCube)
                cube.Draw();
        if(drawOutline)
                cube.DrawOutline();
        
        SwapBuffers();
        
        redraw = false;
}

---