RTVolumeRendering/Source/MainWindow.cpp

Go to the documentation of this file.

#include "MainWindow.h"
#include "Error.h"
#include <wx/busyinfo.h>
#include <sstream>

const float MAX_FPS = 60.0f;
const float MAX_FRAMETIME = 1000.0f / MAX_FPS;

const int ID_DRAWCUBE_CHECKBOX      = wxID_HIGHEST + 1;
const int ID_DRAWOUTLINE_CHECKBOX   = wxID_HIGHEST + 2;
const int ID_DRAWPLANES_CHECKBOX    = wxID_HIGHEST + 3;
const int ID_USETEX_CHECKBOX        = wxID_HIGHEST + 4;
const int ID_DETACHCAMERA_CHECKBOX  = wxID_HIGHEST + 5;
const int ID_REALTIME_CHECKBOX      = wxID_HIGHEST + 6;
const int ID_PLANES_SLIDER          = wxID_HIGHEST + 7;
const int ID_LOAD_DATASET_BUTTON    = wxID_HIGHEST + 8;
const int ID_BG_COLORBOX_PANEL      = wxID_HIGHEST + 9;
const int ID_CUBE_COLORBOX_PANEL    = wxID_HIGHEST + 10;
const int ID_OUTLINE_COLORBOX_PANEL = wxID_HIGHEST + 11;
const int ID_PLANE_COLORBOX_PANEL   = wxID_HIGHEST + 12;
const int ID_LIGHT_COLORBOX_PANEL   = wxID_HIGHEST + 13;
const int ID_SET_LIGHTDIR_BUTTON    = wxID_HIGHEST + 14;
const int ID_RESET_LIGHTDIR_BUTTON  = wxID_HIGHEST + 15;
const int ID_RESOLUTION_PULLDOWN    = wxID_HIGHEST + 16;

const long MAINWINDOW_STYLE = wxMINIMIZE_BOX | wxMAXIMIZE_BOX | wxSYSTEM_MENU | wxCAPTION | wxCLOSE_BOX | wxCLIP_CHILDREN;

// Tool tip text
const wxString FPS_TOOLTIP                                      = wxT("The frames per second of the volume renderer (fixd at 60fps).");
const wxString RESOLUTION_PULLDOWN_TOOLTIP      = wxT("Select the resolution of the volume renderer.");
const wxString DRAW_CUBE_TOOLTIP                        = wxT("Enable/Diable drawing the faces of the bonding cube.");
const wxString DRAW_CUBEOUTLINE_TOOLTIP         = wxT("Enable/Diable drawing the outline of the bonding cube.");
const wxString DRAW_PLANES_TOOLTIP                      = wxT("Enable/Diable drawing the volume slicing planes.");
const wxString USE_TEXTURE_TOOLTIP                      = wxT("Enable/Diable display of the loaded data set.");
const wxString DETACH_CAMERA_TOOLTIP            = wxT("Detach/Attach slicing planes to the viewing direction of the camera.");
const wxString REALTIME_TOOLTIP                         = wxT("Disable to only render the volume data set when something changes.");
const wxString BG_COLOR_TOOLTIP                         = wxT("Set the background color of the volume renderer.");
const wxString CUBE_COLOR_TOOLTIP                       = wxT("Set the color of the bounding cube faces.");
const wxString CUBEOUTLINE_COLOR_TOOLTIP        = wxT("Set the color of the bounding cube outline.");
const wxString PLANE_COLOR_TOOLTIP                      = wxT("Set the color of the slicing planes.");
const wxString LIGHT_COLOR_TOOLTIP                      = wxT("Set the color of the directional light used by the volume renderer.");
const wxString XDIR_TOOLTIP                                     = wxT("Set the x component of the light direction vector.");
const wxString YDIR_TOOLTIP                                     = wxT("Set the y component of the light direction vector.");
const wxString ZDIR_TOOLTIP                                     = wxT("Set the z component of the light direction vector.");
const wxString LIGHT_RESET_TOOLTIP                      = wxT("Resets the light direction to its default setting.");
const wxString LIGHT_SET_TOOLTIP                        = wxT("Sets the light direction.");
const wxString PLANE_SLIDER_TOOLTIP                     = wxT("Sets the number of slicing planes.");
const wxString LOAD_DATASET_TOOLTIP                     = wxT("Loads a data set.");

BEGIN_EVENT_TABLE(MainWindow, wxFrame)
        EVT_IDLE(MainWindow::OnIdle)
        EVT_SIZE(MainWindow::OnReSize)
        EVT_COMMAND_SCROLL(ID_PLANES_SLIDER, MainWindow::OnPlanesSliderScroll)
        EVT_COMBOBOX(ID_RESOLUTION_PULLDOWN, MainWindow::OnResolutionSelection)
        EVT_CHECKBOX(ID_DRAWCUBE_CHECKBOX, MainWindow::OnDrawCubeClick)
        EVT_CHECKBOX(ID_DRAWOUTLINE_CHECKBOX, MainWindow::OnDrawOutlineClick)
        EVT_CHECKBOX(ID_DRAWPLANES_CHECKBOX, MainWindow::OnDrawPlanesClick)
        EVT_CHECKBOX(ID_USETEX_CHECKBOX, MainWindow::OnUseTexClick)
        EVT_CHECKBOX(ID_DETACHCAMERA_CHECKBOX, MainWindow::OnDetachCameraClick)
        EVT_CHECKBOX(ID_REALTIME_CHECKBOX, MainWindow::OnRealTimeClick)
        EVT_BUTTON(ID_SET_LIGHTDIR_BUTTON, MainWindow::OnSetLightDirButtonClick)
        EVT_BUTTON(ID_RESET_LIGHTDIR_BUTTON, MainWindow::OnResetLightDirButtonClick)
        EVT_BUTTON(ID_LOAD_DATASET_BUTTON, MainWindow::OnLoadDataSetButtonClick)
END_EVENT_TABLE()

//----------------------------------------------------------
MainWindow::MainWindow(const wxString &name) 
: 
wxFrame(NULL, wxID_ANY, name, wxDefaultPosition, wxSize(MIN_WIDTH, MIN_HEIGHT), MAINWINDOW_STYLE),
timer(0.0f),
fps(0.0f),
counter(0),
lightDirection(0.0f, 0.0f, 1.0f)
{
        // fills out about information
        aboutInfo.SetName(wxT("RT Volume Rendering"));
        aboutInfo.AddDeveloper(wxT("Joe Forte"));
        aboutInfo.SetDescription(wxT("The RT Volume Rendering program provides a Real-Time texture based approch for rendering volume data."));
        aboutInfo.SetVersion(wxT("v1.0"));

#ifdef _WIN32
        
                SetIcon( wxIcon(wxT("icon.ico"), wxBITMAP_TYPE_ICO) );
#else
        #ifndef APPLE_APPLICATION_BUNDLE
        
                SetIcon( wxIcon(wxT("icon.png")) );

        #endif
#endif
        
// MacOSX has a differant menu bar style then other OSes
#ifdef __APPLE__
        
        // Constructs the menu bar
        wxMenuBar *menuBar = new wxMenuBar;
        wxMenu *helpMenu = new wxMenu;

        helpMenu->Append(wxApp::s_macAboutMenuItemId, wxT("About..."), wxT("Presents information about this application."));

        Connect(wxID_CLOSE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(MainWindow::OnQuit));
        Connect(wxApp::s_macAboutMenuItemId, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(MainWindow::OnAbout));

        menuBar->Append(helpMenu, wxApp::s_macHelpMenuTitleName);

        SetMenuBar(menuBar);

#else
        
        // Constructs the menu bar
        wxMenuBar *menuBar = new wxMenuBar;
        wxMenu *fileMenu = new wxMenu;
        wxMenu *helpMenu = new wxMenu;
        
        fileMenu->Append(wxID_CLOSE, wxT("Exit"), wxT("Exits the Volume Rendering Application"));
        helpMenu->Append(wxID_ABOUT, wxT("About"), wxT("Presents information about this application."));
        
        Connect(wxID_CLOSE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(MainWindow::OnQuit));
        Connect(wxID_ABOUT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(MainWindow::OnAbout));
        
        menuBar->Append(fileMenu, wxT("File"));
        menuBar->Append(helpMenu, wxT("Help"));
        
        SetMenuBar(menuBar);
        
#endif

        SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_MENUBAR));

        // The window and its parent must be 'shown' before an opengl context can be made current
        Show(true);

        renderer = new RTVolumeRenderer(this, 640, 480);
        
        // Creates the window layout
        topLevel = new wxBoxSizer(wxHORIZONTAL);
        wxSizer *vertical = new wxBoxSizer(wxVERTICAL);
        topLevel->Add(vertical, 1, wxEXPAND, 5);
        vertical->Add(renderer, 0, wxALL | wxALIGN_CENTER, 5);
        
        wxSizer *sideBar = new wxBoxSizer(wxVERTICAL);
        topLevel->Add(sideBar);

        // draw options box
        wxStaticBoxSizer *drawOptionsSizer = new wxStaticBoxSizer(new wxStaticBox(this, wxID_ANY, wxT("Runtime Settings")), wxVERTICAL);
        sideBar->Add(drawOptionsSizer, 0, wxALL, 5);
        
        // fps box
        fpsDisplay = new wxStaticText(this, wxID_ANY, wxT("FPS: 00.0000"));
        fpsDisplay->SetToolTip(FPS_TOOLTIP);
        drawOptionsSizer->Add(fpsDisplay, 0, wxBOTTOM, 5);      

        // Resolution box
        wxArrayString activePlotStrings;
        activePlotStrings.Add(wxT("320x240"));
        activePlotStrings.Add(wxT("640x480"));
        activePlotStrings.Add(wxT("800x600"));
        activePlotStrings.Add(wxT("1024x768"));
        
        wxComboBox *activePlot = new wxComboBox(this, 
                                                                                    ID_RESOLUTION_PULLDOWN, 
                                                                                    wxT("Resolution"), 
                                                                                    wxDefaultPosition, 
                                                                                    wxDefaultSize, 
                                                                                    activePlotStrings,
                                                                                    wxCB_DROPDOWN | wxCB_READONLY);
        activePlot->Select(1);
        activePlot->SetToolTip(RESOLUTION_PULLDOWN_TOOLTIP);
        
        wxSizer *resSizer = new wxBoxSizer(wxHORIZONTAL);
        resSizer->Add(new wxStaticText(this, wxID_ANY, wxT("Resolution: ")), 0, wxALIGN_CENTER | wxBOTTOM, 4);
        resSizer->Add(activePlot);
        drawOptionsSizer->Add(resSizer, 0, wxBOTTOM, 5);
        
        // Draw check boxes
        wxGridSizer *drawGridSizer = new wxGridSizer(2, 2, 0, 0);
        drawOptionsSizer->Add(drawGridSizer, 0, wxALIGN_CENTER);

        wxCheckBox *drawCubes = new wxCheckBox(this, ID_DRAWCUBE_CHECKBOX, wxT("Draw Cube"));
        wxCheckBox *drawOutline = new wxCheckBox(this, ID_DRAWOUTLINE_CHECKBOX, wxT("Draw Outline"));
        wxCheckBox *drawPlanes = new wxCheckBox(this, ID_DRAWPLANES_CHECKBOX, wxT("Draw Planes"));
        wxCheckBox *useTex = new wxCheckBox(this, ID_USETEX_CHECKBOX, wxT("Use Texture"));
        wxCheckBox *detachCamera = new wxCheckBox(this, ID_DETACHCAMERA_CHECKBOX, wxT("Detach Camera"));
        wxCheckBox *realTime = new wxCheckBox(this, ID_REALTIME_CHECKBOX, wxT("Real-Time"));
        drawOutline->SetValue(true);
        drawPlanes->SetValue(true);
        realTime->SetValue(true);

        drawCubes->SetToolTip(DRAW_CUBE_TOOLTIP);
        drawOutline->SetToolTip(DRAW_CUBEOUTLINE_TOOLTIP);
        drawPlanes->SetToolTip(DRAW_PLANES_TOOLTIP);
        useTex->SetToolTip(USE_TEXTURE_TOOLTIP);
        detachCamera->SetToolTip(DETACH_CAMERA_TOOLTIP);
        realTime->SetToolTip(REALTIME_TOOLTIP);
                
        drawGridSizer->Add(drawCubes);
        drawGridSizer->Add(drawOutline);
        drawGridSizer->Add(drawPlanes);
        drawGridSizer->Add(useTex);
        drawGridSizer->Add(detachCamera);
        drawGridSizer->Add(realTime);
        drawGridSizer->AddSpacer(0);
        drawGridSizer->AddSpacer(0);
        
        drawGridSizer->Add(new wxStaticText(this, wxID_ANY, wxT("Backgound Color   ")), 0, wxALIGN_RIGHT);
        bgColorBox = new ColorBox(this, ID_BG_COLORBOX_PANEL, Color4f(0.0f, 0.0f, 0.0f));
        bgColorBox->SetListner(this);
        bgColorBox->SetToolTip(BG_COLOR_TOOLTIP);
        drawGridSizer->Add(bgColorBox);
        
        drawGridSizer->Add(new wxStaticText(this, wxID_ANY, wxT("Cube Color   ")), 0, wxALIGN_RIGHT);
        cubeColorBox = new ColorBox(this, ID_CUBE_COLORBOX_PANEL, Color4f(0.0f, 0.0f, 1.0f));
        cubeColorBox->SetListner(this);
        cubeColorBox->SetToolTip(CUBE_COLOR_TOOLTIP);
        drawGridSizer->Add(cubeColorBox);
        
        drawGridSizer->Add(new wxStaticText(this, wxID_ANY, wxT("Outline Color   ")), 0, wxALIGN_RIGHT);
        outlineColorBox = new ColorBox(this, ID_OUTLINE_COLORBOX_PANEL, Color4f(0.0f, 0.0f, 1.0f));
        outlineColorBox->SetListner(this);
        outlineColorBox->SetToolTip(CUBEOUTLINE_COLOR_TOOLTIP);
        drawGridSizer->Add(outlineColorBox);
        
        drawGridSizer->Add(new wxStaticText(this, wxID_ANY, wxT("Plane Color   ")), 0, wxALIGN_RIGHT);
        planeColorBox = new ColorBox(this, ID_PLANE_COLORBOX_PANEL, Color4f(0.5f, 0.5f, 0.5f));
        planeColorBox->SetListner(this);
        planeColorBox->SetToolTip(PLANE_COLOR_TOOLTIP);
        drawGridSizer->Add(planeColorBox);

        drawGridSizer->Add(new wxStaticText(this, wxID_ANY, wxT("Light Color   ")), 0, wxALIGN_RIGHT);
        lightColorBox = new ColorBox(this, ID_LIGHT_COLORBOX_PANEL, Color4f(1.0f, 1.0f, 1.0f));
        lightColorBox->SetListner(this);
        lightColorBox->SetToolTip(LIGHT_COLOR_TOOLTIP);
        drawGridSizer->Add(lightColorBox);
        
        drawOptionsSizer->AddSpacer(10);
        drawOptionsSizer->Add(new wxStaticText(this, wxID_ANY, wxT("Light Direction")), 0, wxALIGN_CENTER | wxBOTTOM, 5);

        xDir = new wxTextCtrl(this, wxID_ANY, wxT("0.0"), wxDefaultPosition, wxSize(60, -1));
        yDir = new wxTextCtrl(this, wxID_ANY, wxT("0.0"), wxDefaultPosition, wxSize(60, -1));
        zDir = new wxTextCtrl(this, wxID_ANY, wxT("1.0"), wxDefaultPosition, wxSize(60, -1));

        xDir->SetToolTip(XDIR_TOOLTIP);
        yDir->SetToolTip(YDIR_TOOLTIP);
        zDir->SetToolTip(ZDIR_TOOLTIP);

        wxSizer *dirBox = new wxBoxSizer(wxHORIZONTAL);
        dirBox->Add(new wxStaticText(this, wxID_ANY, wxT("X:")), 0, wxALIGN_CENTER_VERTICAL);
        dirBox->Add(xDir);
        dirBox->AddSpacer(10);
        dirBox->Add(new wxStaticText(this, wxID_ANY, wxT("Y:")), 0, wxALIGN_CENTER_VERTICAL);
        dirBox->Add(yDir);
        dirBox->AddSpacer(10);
        dirBox->Add(new wxStaticText(this, wxID_ANY, wxT("Z:")), 0, wxALIGN_CENTER_VERTICAL);
        dirBox->Add(zDir);
        drawOptionsSizer->Add(dirBox, 0, wxALIGN_CENTER);

        wxButton *lightReset = new wxButton(this, ID_RESET_LIGHTDIR_BUTTON, wxT("Reset"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT);
        lightReset->SetToolTip(LIGHT_RESET_TOOLTIP);

        wxSizer *lightButtons = new wxBoxSizer(wxHORIZONTAL);
        lightButtons->Add(lightReset);
        lightButtons->AddSpacer(5);

        wxButton *lightSet = new wxButton(this, ID_SET_LIGHTDIR_BUTTON, wxT("Set"), wxDefaultPosition, wxDefaultSize, wxBU_EXACTFIT);
        lightSet->SetToolTip(LIGHT_SET_TOOLTIP);

        lightButtons->Add(lightSet);
        drawOptionsSizer->Add(lightButtons, 0, wxALIGN_CENTER | wxTOP, 4);

        drawOptionsSizer->AddSpacer(10);
        drawOptionsSizer->Add(new wxStaticText(this, wxID_ANY, wxT("Planes")), 0, wxALIGN_CENTER);
        
        wxSlider *planeSlider = new wxSlider(this, 
                                                                                 ID_PLANES_SLIDER, 
                                                                                 1, 1, MAX_PLANES, 
                                                                                 wxDefaultPosition, 
                                                                                 wxSize(230, -1), 
                                                                                 wxSL_HORIZONTAL | wxSL_AUTOTICKS | wxSL_LABELS);
        planeSlider->SetToolTip(PLANE_SLIDER_TOOLTIP);
        drawOptionsSizer->Add(planeSlider, 0, wxALIGN_CENTER);

        // volume texture box
        drawOptionsSizer->AddSpacer(10);
        drawOptionsSizer->Add(new wxStaticText(this, wxID_ANY, wxT("Data Set")), 0, wxALIGN_CENTER);
        volTexName = new wxStaticText(this, wxID_ANY, wxT("(none)"));
        volTexSize = new wxStaticText(this, wxID_ANY, wxT("0x0x0"));
        drawOptionsSizer->Add(volTexName, 0, wxALIGN_CENTER);
        drawOptionsSizer->Add(volTexSize, 0, wxALIGN_CENTER);
        drawOptionsSizer->AddSpacer(10);

        wxButton *loadDataset = new wxButton(this, ID_LOAD_DATASET_BUTTON, wxT("Load..."));
        loadDataset->SetToolTip(LOAD_DATASET_TOOLTIP);
        drawOptionsSizer->Add(loadDataset, 0, wxALIGN_CENTER);

        // Sets up the tranfer function widgets
        transFunc = new TransferFunctionWidget(this);
        transFunc->SetListner(renderer);
        vertical->Add(transFunc, 0, wxBOTTOM | wxALIGN_CENTER, 5);
        
        SetSizerAndFit(topLevel);
        Layout();
        Center();
        
        currTime = wxGetLocalTimeMillis();
        lastTime = currTime;
}

//----------------------------------------------------------
MainWindow::~MainWindow() {}

//----------------------------------------------------------
void MainWindow::OnQuit(wxCommandEvent &e)
{
        Close(true);
}

//----------------------------------------------------------
void MainWindow::OnAbout(wxCommandEvent &e)
{
        wxAboutBox(aboutInfo);
}

//----------------------------------------------------------
void MainWindow::OnReSize(wxSizeEvent &e) {}

//----------------------------------------------------------
void MainWindow::OnDrawCubeClick(wxCommandEvent &e)
{
        renderer->ShouldDrawCube(e.IsChecked());
}

//----------------------------------------------------------
void MainWindow::OnDrawOutlineClick(wxCommandEvent &e)
{
        renderer->ShouldDrawCubeOutline(e.IsChecked());
}

//----------------------------------------------------------
void MainWindow::OnDrawPlanesClick(wxCommandEvent &e)
{
        renderer->ShouldDrawPlanes(e.IsChecked());
}

//----------------------------------------------------------
void MainWindow::OnUseTexClick(wxCommandEvent &e)
{
        renderer->UseVolumeTexture(e.IsChecked());
}

//----------------------------------------------------------
void MainWindow::OnDetachCameraClick(wxCommandEvent &e)
{
        renderer->ToggleCameraAttachment();
}

//----------------------------------------------------------
void MainWindow::OnRealTimeClick(wxCommandEvent &e)
{
        realTime = e.IsChecked();
        renderer->SetQuickMovmentRendering(!realTime);
        transFunc->DelayRealtimeUpdate(!realTime);
}

//----------------------------------------------------------
void MainWindow::OnDrawTimer(wxTimerEvent &e)
{
}

//----------------------------------------------------------
void MainWindow::OnPlanesSliderScroll(wxScrollEvent &e)
{
        renderer->SetPlanes(e.GetPosition());
}

//----------------------------------------------------------
void MainWindow::OnResolutionSelection(wxCommandEvent &e)
{
        int sel = e.GetSelection();
        switch(sel)
        {
                case 0: // 320x240
                        renderer->ResizeRenderer(320, 240);
                        break;
                case 1: // 640x480
                        renderer->ResizeRenderer(640, 480);
                        break;
                case 2: // 800x600
                        renderer->ResizeRenderer(800, 600);
                        break;
                case 3: // 1024x768
                        renderer->ResizeRenderer(1024, 768);
                        break;
        };
        
        Fit();
        Layout();
        Fit();
        Refresh();
}

//----------------------------------------------------------
void MainWindow::OnSetLightDirButtonClick(wxCommandEvent &e)
{
        double x = 0.0;
        double y = 0.0;
        double z = 0.0;

        if(!xDir->GetLineText(0).ToDouble(&x))
        {
                x = 0.0;
        }

        if(!yDir->GetLineText(0).ToDouble(&y))
        {
                y = 0.0;
        }

        if(!zDir->GetLineText(0).ToDouble(&z))
        {
                z = 0.0;
        }

        Vector3f dir((float)x, (float)y, (float)z);
        float len = dir.Length();

        if(len == 0.0f)
        {
                dir = lightDirection;
        }
        else
        {
                lightDirection = dir / len;
                renderer->SetLightDirection(lightDirection);
        }

        wxString nx, ny, nz;
        nx << lightDirection.x;
        ny << lightDirection.y;
        nz << lightDirection.z;
        
        xDir->SetValue(nx);
        yDir->SetValue(ny);
        zDir->SetValue(nz);
}

//----------------------------------------------------------
void MainWindow::OnResetLightDirButtonClick(wxCommandEvent &e)
{
        lightDirection = Vector3f(0.0f, 0.0f, 1.0f);

        wxString nx, ny, nz;
        nx << lightDirection.x;
        ny << lightDirection.y;
        nz << lightDirection.z;
        
        xDir->SetValue(nx);
        yDir->SetValue(ny);
        zDir->SetValue(nz);

        renderer->SetLightDirection(lightDirection);
}

//----------------------------------------------------------
void MainWindow::ColorChanged(const ColorBox *cbox)
{
        if(cbox == bgColorBox)
                renderer->SetBackgroundColor(cbox->color);
        else if(cbox == cubeColorBox)
                renderer->SetCubeColor(cbox->color);
        else if(cbox == outlineColorBox)
                renderer->SetOutlineColor(cbox->color);
        else if(cbox == planeColorBox)
                renderer->SetPlaneColor(cbox->color);
        else if(cbox == lightColorBox)
                renderer->SetLightDiffuseColor(cbox->color);
}

//----------------------------------------------------------
void MainWindow::OnLoadDataSetButtonClick(wxCommandEvent &e)
{
        wxFileDialog dialog(this, 
                                                wxT("Load Data Set"), 
                                                wxT("./DataSets"), 
                                                wxEmptyString, 
                                                wxT("Volume Texture File (*.vt)|*.vt"),
                                                wxOPEN | wxFILE_MUST_EXIST);
        
        if(dialog.ShowModal() == wxID_OK)
        {
                wxWindowDisabler disableAll;
                
                wxString msg = "Loading ";
                msg += dialog.GetFilename();
                msg += "...";
                
                wxBusyInfo info(msg, this);
                
                wxString path = dialog.GetPath();
                wxString filename = dialog.GetFilename();
                
                path.Remove(path.Length() - filename.Length());
                
                VTInfo volInfo;
                if( !renderer->LoadVolumeDataSet(filename.c_str(), path.c_str(), volInfo) )
                        return;

                unsigned int histogram[256];
                renderer->CopyHistogram(histogram, 256);
                transFunc->SetHistogram(histogram);
                
                wxString s;
                s << volInfo.width << "x" << volInfo.height << "x" << volInfo.depth;
                volTexSize->SetLabel(s);
                
                volTexName->SetLabel(dialog.GetFilename());
                Layout();
        }
}

//----------------------------------------------------------
void MainWindow::OnIdle(wxIdleEvent &e)
{
        currTime = wxGetLocalTimeMillis();
        wxLongLong diff = currTime - lastTime;

        if(diff < MAX_FRAMETIME)
        {
                wxMilliSleep(MAX_FRAMETIME - diff.ToLong());
                currTime = wxGetLocalTimeMillis();
                diff = currTime - lastTime;
        }

        // frame time in seconds
        float dt = (float)(diff.ToDouble() / 1000.0);
        lastTime = currTime;

        counter++;
        timer += dt;
        if(timer >= 1.0f)
        {
                fps = counter / timer;
                counter = 0;
                timer = 0.0f;
                
                std::stringstream s;
                s << "FPS: " << fps;
                fpsDisplay->SetLabel(s.str().c_str());
        }
        
        if(!realTime)
                renderer->SetFrameTime(MAX_FRAMETIME / 1000.0f);
        else
                renderer->SetFrameTime(dt);

        Draw();
                
        e.RequestMore();
}

//----------------------------------------------------------
void MainWindow::Update(float dt)
{
}

//----------------------------------------------------------
void MainWindow::Draw()
{
        renderer->Draw();
}

---