00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include <boost/bind.hpp>
00024 #include <boost/filesystem/path.hpp>
00025 #include <boost/filesystem/operations.hpp>
00026 #include <boost/thread.hpp>
00027 #include <boost/cast.hpp>
00028
00029 #include <sstream>
00030 #include <clocale>
00031
00032 #include "lux.h"
00033 #include "api.h"
00034 #include "error.h"
00035
00036 #include "wx/app.h"
00037 #include "wx/filedlg.h"
00038 #include "wx/filename.h"
00039 #include "wx/dcbuffer.h"
00040 #include "wx/splash.h"
00041 #include "wx/clipbrd.h"
00042 #include <boost/date_time/posix_time/posix_time.hpp>
00043
00044 #include "wxluxgui.h"
00045 #include "wxglviewer.h"
00046 #include "wximages.h"
00047
00048 using namespace lux;
00049
00050
00051
00053
00054 #define FLOAT_SLIDER_RES 512.f
00055
00056 #define TM_REINHARD_YWA_RANGE 1.0f
00057 #define TM_REINHARD_PRESCALE_RANGE 8.0f
00058 #define TM_REINHARD_POSTSCALE_RANGE 8.0f
00059 #define TM_REINHARD_BURN_RANGE 12.0f
00060
00061 #define TM_LINEAR_EXPOSURE_LOG_MIN -3.f
00062 #define TM_LINEAR_EXPOSURE_LOG_MAX 2.f
00063 #define TM_LINEAR_SENSITIVITY_RANGE 1000.0f
00064 #define TM_LINEAR_FSTOP_RANGE 64.0f
00065 #define TM_LINEAR_GAMMA_RANGE 5.0f
00066
00067 #define TM_CONTRAST_YWA_LOG_MIN -4.f
00068 #define TM_CONTRAST_YWA_LOG_MAX 4.f
00069
00070 #define TORGB_XWHITE_RANGE 1.0f
00071 #define TORGB_YWHITE_RANGE 1.0f
00072 #define TORGB_XRED_RANGE 1.0f
00073 #define TORGB_YRED_RANGE 1.0f
00074 #define TORGB_XGREEN_RANGE 1.0f
00075 #define TORGB_YGREEN_RANGE 1.0f
00076 #define TORGB_XBLUE_RANGE 1.0f
00077 #define TORGB_YBLUE_RANGE 1.0f
00078
00079 #define TORGB_GAMMA_RANGE 5.0f
00080
00081 #define BLOOMRADIUS_RANGE 1.0f
00082 #define BLOOMWEIGHT_RANGE 1.0f
00083
00084 #define VIGNETTING_SCALE_RANGE 1.0f
00085 #define ABERRATION_AMOUNT_RANGE 1.0f
00086 #define ABERRATION_AMOUNT_FACTOR 0.01f
00087
00088 #define GLARE_AMOUNT_RANGE 0.3f
00089 #define GLARE_RADIUS_RANGE 0.2f
00090 #define GLARE_BLADES_MIN 3
00091 #define GLARE_BLADES_MAX 100
00092
00093 #define GREYC_AMPLITUDE_RANGE 200.0f
00094 #define GREYC_SHARPNESS_RANGE 2.0f
00095 #define GREYC_ANISOTROPY_RANGE 1.0f
00096 #define GREYC_ALPHA_RANGE 12.0f
00097 #define GREYC_SIGMA_RANGE 12.0f
00098 #define GREYC_GAUSSPREC_RANGE 12.0f
00099 #define GREYC_DL_RANGE 1.0f
00100 #define GREYC_DA_RANGE 90.0f
00101 #define GREYC_NB_ITER_RANGE 16.0f
00102
00103 #define CHIU_RADIUS_MIN 1
00104 #define CHIU_RADIUS_MAX 9
00105
00106 #define LG_SCALE_LOG_MIN -4.f
00107 #define LG_SCALE_LOG_MAX 4.f
00108 #define LG_TEMPERATURE_MIN 1000.f
00109 #define LG_TEMPERATURE_MAX 10000.f
00110
00112
00113 DEFINE_LOCAL_EVENT_TYPE(lux::wxEVT_LUX_ERROR)
00114 #if defined(__WXOSX_COCOA__) // wx 2.9 and later //
00115 wxDEFINE_EVENT(EVT_LUX_PARSEERROR, wxCommandEvent);
00116 wxDEFINE_EVENT(EVT_LUX_FINISHED, wxCommandEvent);
00117 wxDEFINE_EVENT(EVT_LUX_TONEMAPPED, wxCommandEvent);
00118 wxDEFINE_EVENT(EVT_LUX_FLMLOADERROR, wxCommandEvent);
00119 wxDEFINE_EVENT(EVT_LUX_SAVEDFLM, wxCommandEvent);
00120 #else
00121 DEFINE_LOCAL_EVENT_TYPE(lux::wxEVT_LUX_PARSEERROR)
00122 DEFINE_LOCAL_EVENT_TYPE(lux::wxEVT_LUX_FINISHED)
00123 DEFINE_LOCAL_EVENT_TYPE(lux::wxEVT_LUX_TONEMAPPED)
00124 DEFINE_LOCAL_EVENT_TYPE(lux::wxEVT_LUX_FLMLOADERROR)
00125 DEFINE_LOCAL_EVENT_TYPE(lux::wxEVT_LUX_SAVEDFLM)
00126 #endif
00127
00128 BEGIN_EVENT_TABLE(LuxGui, wxFrame)
00129 EVT_LUX_ERROR (wxID_ANY, LuxGui::OnError)
00130 EVT_LUX_VIEWER_SELECTION (wxID_ANY, LuxGui::OnSelection)
00131 EVT_TIMER (wxID_ANY, LuxGui::OnTimer)
00132 #if defined(__WXOSX_COCOA__)
00133 EVT_COMMAND (wxID_ANY, EVT_LUX_TONEMAPPED, LuxGui::OnCommand)
00134 EVT_COMMAND (wxID_ANY, EVT_LUX_PARSEERROR, LuxGui::OnCommand)
00135 EVT_COMMAND (wxID_ANY, EVT_LUX_FINISHED, LuxGui::OnCommand)
00136 EVT_COMMAND (wxID_ANY, EVT_LUX_FLMLOADERROR, LuxGui::OnCommand)
00137 EVT_COMMAND (wxID_ANY, EVT_LUX_SAVEDFLM, LuxGui::OnCommand)
00138 #else
00139 EVT_COMMAND (wxID_ANY, lux::wxEVT_LUX_TONEMAPPED, LuxGui::OnCommand)
00140 EVT_COMMAND (wxID_ANY, lux::wxEVT_LUX_PARSEERROR, LuxGui::OnCommand)
00141 EVT_COMMAND (wxID_ANY, lux::wxEVT_LUX_FINISHED, LuxGui::OnCommand)
00142 EVT_COMMAND (wxID_ANY, lux::wxEVT_LUX_FLMLOADERROR, LuxGui::OnCommand)
00143 EVT_COMMAND (wxID_ANY, lux::wxEVT_LUX_SAVEDFLM, LuxGui::OnCommand)
00144 #endif
00145
00146 #if defined (__WXMSW__) || defined (__WXGTK__)
00147 EVT_ICONIZE (LuxGui::OnIconize)
00148 #endif
00149 END_EVENT_TABLE()
00150
00151 #if defined(__WXOSX_COCOA__) // wx 2.9 and later //
00152 #define wxEVT_LUX_TONEMAPPED EVT_LUX_TONEMAPPED
00153 #define wxEVT_LUX_PARSEERROR EVT_LUX_PARSEERROR
00154 #define wxEVT_LUX_FINISHED EVT_LUX_FINISHED
00155 #define wxEVT_LUX_FLMLOADERROR EVT_LUX_FLMLOADERROR
00156 #define wxEVT_LUX_SAVEDFLM EVT_LUX_SAVEDFLM
00157 #endif
00158
00159
00160 bool copyLog2Console = false;
00161
00162 LuxGui::LuxGui(wxWindow* parent, bool opengl, bool copylog2console) :
00163 LuxMainFrame(parent), m_opengl(opengl), m_copyLog2Console(copylog2console), m_showWarningDialog(true) {
00164
00165 LoadImages();
00166
00167
00168 m_HistogramWindow = new LuxHistogramWindow(m_Tab_Control_HistogramPanel, wxID_ANY);
00169 m_Tab_Control_HistogramPanel->GetSizer()->GetItem(1)->GetSizer()->Add(m_HistogramWindow, 1, wxEXPAND);
00170 m_Tab_Control_HistogramPanel->Layout();
00171
00172
00173 m_Tab_Control_ColorSpacePanel->Hide();
00174 m_Tab_Control_GammaPanel->Hide();
00175 m_Tab_Control_HistogramPanel->Hide();
00176 m_Tab_Control_NoiseReductionPanel->Hide();
00177
00178 m_Tonemap->GetSizer()->Layout();
00179 m_Tonemap->GetSizer()->FitInside(m_Tonemap);
00180
00181
00182 if(m_opengl)
00183 m_renderOutput = new LuxGLViewer(m_renderPage);
00184 else
00185 m_renderOutput = new LuxOutputWin(m_renderPage);
00186
00187 m_renderPage->GetSizer()->GetItem( 1 )->GetSizer()->GetItem( 1 )->GetSizer()->Add( m_renderOutput->GetWindow(), 1, wxALL | wxEXPAND, 5 );
00188 m_renderPage->Layout();
00189
00190 m_renderOutput->SetLogoData(luxlogo_png, sizeof(luxlogo_png));
00191
00192
00193
00194 SetSize(GetSize());
00195 m_renderOutput->GetWindow()->Update();
00196
00197
00198 m_renderTimer = new wxTimer(this, ID_RENDERUPDATE);
00199 m_statsTimer = new wxTimer(this, ID_STATSUPDATE);
00200 m_loadTimer = new wxTimer(this, ID_LOADUPDATE);
00201 m_saveTimer = new wxTimer(this, ID_SAVEUPDATE);
00202 m_netTimer = new wxTimer(this, ID_NETUPDATE);
00203
00204 m_numThreads = 0;
00205 m_engineThread = NULL;
00206 m_updateThread = NULL;
00207 m_flmloadThread = NULL;
00208 m_flmsaveThread = NULL;
00209
00210
00211 copyLog2Console = m_copyLog2Console;
00212 luxErrorHandler(&LuxGuiErrorHandler);
00213
00214 ChangeRenderState(WAITING);
00215 m_guiWindowState = SHOWN;
00216
00217 m_serverUpdateSpin->SetValue( luxGetNetworkServerUpdateInterval() );
00218 m_auinotebook->SetSelection( 0 );
00219
00220 m_Lenseffects_enabled = true;
00221 m_Gamma_enabled = true;
00222 m_Noisereduction_enabled = true;
00223
00224 m_auto_tonemap = false;
00225 ResetToneMapping();
00226 m_auto_tonemap = true;
00227 ResetLightGroups();
00228
00229 wxTextValidator vt( wxFILTER_NUMERIC );
00230
00231 m_TM_Reinhard_prescaleText->SetValidator( vt );
00232 m_TM_Reinhard_postscaleText->SetValidator( vt );
00233 m_TM_Reinhard_burnText->SetValidator( vt );
00234
00235 m_TM_Linear_sensitivityText->SetValidator( vt );
00236 m_TM_Linear_exposureText->SetValidator( vt );
00237 m_TM_Linear_fstopText->SetValidator( vt );
00238 m_TM_Linear_gammaText->SetValidator( vt );
00239
00240 m_TM_contrast_ywaText->SetValidator( vt );
00241
00242 m_TORGB_xwhiteText->SetValidator( vt );
00243 m_TORGB_ywhiteText->SetValidator( vt );
00244 m_TORGB_xredText->SetValidator( vt );
00245 m_TORGB_yredText->SetValidator( vt );
00246 m_TORGB_xgreenText->SetValidator( vt );
00247 m_TORGB_ygreenText->SetValidator( vt );
00248 m_TORGB_xblueText->SetValidator( vt );
00249 m_TORGB_yblueText->SetValidator( vt );
00250
00251 m_TORGB_gammaText->SetValidator( vt );
00252
00253 m_bloomradiusText->SetValidator( vt );
00254 m_bloomweightText->SetValidator( vt );
00255
00256 m_vignettingamountText->SetValidator( vt );
00257 m_aberrationamountText->SetValidator( vt );
00258
00259 m_greyc_iterationsText->SetValidator( vt );
00260 m_greyc_amplitudeText->SetValidator( vt );
00261 m_greyc_gaussprecText->SetValidator( vt );
00262 m_greyc_alphaText->SetValidator( vt );
00263 m_greyc_sigmaText->SetValidator( vt );
00264 m_greyc_sharpnessText->SetValidator( vt );
00265 m_greyc_anisoText->SetValidator( vt );
00266 m_greyc_spatialText->SetValidator( vt );
00267 m_greyc_angularText->SetValidator( vt );
00268 }
00269
00270 LuxGui::~LuxGui() {
00271 delete m_engineThread;
00272 delete m_updateThread;
00273 delete m_flmloadThread;
00274 delete m_flmsaveThread;
00275 delete m_renderTimer;
00276 delete m_statsTimer;
00277 delete m_loadTimer;
00278 delete m_saveTimer;
00279 delete m_netTimer;
00280
00281 for( std::vector<LuxLightGroupPanel*>::iterator it = m_LightGroupPanels.begin(); it != m_LightGroupPanels.end(); it++) {
00282 LuxLightGroupPanel *currPanel = *it;
00283 m_LightGroupsSizer->Detach(currPanel);
00284 delete currPanel;
00285 }
00286 m_LightGroupPanels.clear();
00287 }
00288
00289 void LuxGui::ChangeRenderState(LuxGuiRenderState state) {
00290 switch(state) {
00291 case WAITING:
00292
00293 m_render->Enable(ID_RESUMEITEM, false);
00294 m_render->Enable(ID_PAUSEITEM, false);
00295 m_render->Enable(ID_STOPITEM, false);
00296 m_view->Enable(ID_RENDER_COPY, false);
00297 m_renderToolBar->EnableTool(ID_RESUMETOOL, false);
00298 m_renderToolBar->EnableTool(ID_PAUSETOOL, false);
00299 m_renderToolBar->EnableTool(ID_STOPTOOL, false);
00300 m_renderToolBar->EnableTool(ID_RENDER_COPY, false);
00301 m_viewerToolBar->Disable();
00302 m_renderOutput->SetMode(LOGO_VIEW);
00303 break;
00304 case RENDERING:
00305
00306 m_render->Enable(ID_RESUMEITEM, false);
00307 m_render->Enable(ID_PAUSEITEM, true);
00308 m_render->Enable(ID_STOPITEM, true);
00309 m_view->Enable(ID_RENDER_COPY, true);
00310 m_renderToolBar->EnableTool(ID_RESUMETOOL, false);
00311 m_renderToolBar->EnableTool(ID_PAUSETOOL, true);
00312 m_renderToolBar->EnableTool(ID_STOPTOOL, true);
00313 m_renderToolBar->EnableTool(ID_RENDER_COPY, true);
00314 m_viewerToolBar->Enable();
00315 m_renderOutput->SetMode(RENDER_VIEW);
00316 break;
00317 case STOPPING:
00318
00319 m_render->Enable(ID_RESUMEITEM, false);
00320 m_render->Enable(ID_PAUSEITEM, false);
00321 m_render->Enable(ID_STOPITEM, false);
00322 m_view->Enable(ID_RENDER_COPY, true);
00323 m_renderToolBar->EnableTool(ID_RESUMETOOL, false);
00324 m_renderToolBar->EnableTool(ID_PAUSETOOL, false);
00325 m_renderToolBar->EnableTool(ID_STOPTOOL, false);
00326 m_renderToolBar->EnableTool(ID_RENDER_COPY, true);
00327 break;
00328 case STOPPED:
00329
00330 m_render->Enable(ID_RESUMEITEM, true);
00331 m_render->Enable(ID_PAUSEITEM, false);
00332 m_render->Enable(ID_STOPITEM, false);
00333 m_view->Enable(ID_RENDER_COPY, true);
00334 m_renderToolBar->EnableTool(ID_RESUMETOOL, true);
00335 m_renderToolBar->EnableTool(ID_PAUSETOOL, false);
00336 m_renderToolBar->EnableTool(ID_STOPTOOL, false);
00337 m_renderToolBar->EnableTool(ID_RENDER_COPY, true);
00338 break;
00339 case PAUSED:
00340
00341 m_render->Enable(ID_RESUMEITEM, true);
00342 m_render->Enable(ID_PAUSEITEM, false);
00343 m_render->Enable(ID_STOPITEM, true);
00344 m_view->Enable(ID_RENDER_COPY, true);
00345 m_renderToolBar->EnableTool(ID_RESUMETOOL, true);
00346 m_renderToolBar->EnableTool(ID_PAUSETOOL, false);
00347 m_renderToolBar->EnableTool(ID_STOPTOOL, true);
00348 m_renderToolBar->EnableTool(ID_RENDER_COPY, true);
00349 break;
00350 case FINISHED:
00351
00352 m_render->Enable(ID_RESUMEITEM, false);
00353 m_render->Enable(ID_PAUSEITEM, false);
00354 m_render->Enable(ID_STOPITEM, false);
00355 m_view->Enable(ID_RENDER_COPY, true);
00356 m_renderToolBar->EnableTool(ID_RESUMETOOL, false);
00357 m_renderToolBar->EnableTool(ID_PAUSETOOL, false);
00358 m_renderToolBar->EnableTool(ID_STOPTOOL, false);
00359 m_renderToolBar->EnableTool(ID_RENDER_COPY, true);
00360 break;
00361 case TONEMAPPING:
00362
00363 m_render->Enable(ID_RESUMEITEM, false);
00364 m_render->Enable(ID_PAUSEITEM, false);
00365 m_render->Enable(ID_STOPITEM, false);
00366 m_view->Enable(ID_RENDER_COPY, true);
00367 m_renderToolBar->EnableTool(ID_RESUMETOOL, false);
00368 m_renderToolBar->EnableTool(ID_PAUSETOOL, false);
00369 m_renderToolBar->EnableTool(ID_STOPTOOL, false);
00370 m_renderToolBar->EnableTool(ID_RENDER_COPY, true);
00371 m_viewerToolBar->Enable();
00372 m_renderOutput->SetMode(RENDER_VIEW);
00373 break;
00374 case PARSING:
00375 default:
00376
00377 break;
00378 }
00379 m_guiRenderState = state;
00380 }
00381
00382 void LuxGui::LoadImages() {
00383 wxImage::AddHandler(new wxPNGHandler());
00384
00385
00386 #ifndef __WXMSW__
00387 wxIcon appIcon;
00388 appIcon.CopyFromBitmap(wxMEMORY_BITMAP(luxicon_png));
00389 SetIcon(appIcon);
00390 #else
00391 SetIcon( wxIcon("WXDEFAULT_FRAME", wxBITMAP_TYPE_ICO_RESOURCE ));
00392 #endif
00393
00394
00395
00396 wxToolBarToolBase *rendertool = m_renderToolBar->RemoveTool(ID_RESUMETOOL);
00397 rendertool->SetNormalBitmap(wxMEMORY_BITMAP(resume_png));
00398 m_renderToolBar->InsertTool(0, rendertool);
00399 m_renderToolBar->Realize();
00400
00401
00402 wxToolBarToolBase *pausetool = m_renderToolBar->RemoveTool(ID_PAUSETOOL);
00403 pausetool->SetNormalBitmap(wxMEMORY_BITMAP(pause_png));
00404 m_renderToolBar->InsertTool(1, pausetool);
00405 m_renderToolBar->Realize();
00406
00407
00408 wxToolBarToolBase *stoptool = m_renderToolBar->RemoveTool(ID_STOPTOOL);
00409 stoptool->SetNormalBitmap(wxMEMORY_BITMAP(stop_png));
00410 m_renderToolBar->InsertTool(2, stoptool);
00411 m_renderToolBar->Realize();
00412
00413
00414 wxToolBarToolBase *addtheadtool = m_renderToolBar->RemoveTool(ID_ADD_THREAD);
00415 addtheadtool->SetNormalBitmap(wxMEMORY_BITMAP(plus_png));
00416 m_renderToolBar->InsertTool(5, addtheadtool);
00417 m_renderToolBar->Realize();
00418
00419
00420 wxToolBarToolBase *remtheadtool = m_renderToolBar->RemoveTool(ID_REMOVE_THREAD);
00421 remtheadtool->SetNormalBitmap(wxMEMORY_BITMAP(minus_png));
00422 m_renderToolBar->InsertTool(6, remtheadtool);
00423 m_renderToolBar->Realize();
00424
00425
00426 wxToolBarToolBase *copytool = m_renderToolBar->RemoveTool(ID_RENDER_COPY);
00427 copytool->SetNormalBitmap(wxMEMORY_BITMAP(edit_copy_png));
00428 m_renderToolBar->InsertTool(8, copytool);
00429 m_renderToolBar->Realize();
00430
00432
00433
00434 wxToolBarToolBase *addServertool = m_networkToolBar->RemoveTool(ID_ADD_SERVER);
00435 addServertool->SetNormalBitmap(wxMEMORY_BITMAP(plus_png));
00436 m_networkToolBar->InsertTool(2, addServertool);
00437 wxToolBarToolBase *removeServertool = m_networkToolBar->RemoveTool(ID_REMOVE_SERVER);
00438 removeServertool->SetNormalBitmap(wxMEMORY_BITMAP(minus_png));
00439 m_networkToolBar->InsertTool(3, removeServertool);
00440 m_networkToolBar->Realize();
00441
00443
00444
00445 wxToolBarToolBase *pantool = m_viewerToolBar->RemoveTool(ID_PANTOOL);
00446 pantool->SetNormalBitmap(wxMEMORY_BITMAP(pan_png));
00447 m_viewerToolBar->InsertTool(0, pantool);
00448 m_viewerToolBar->Realize();
00449
00450
00451 wxToolBarToolBase *zoomtool = m_viewerToolBar->RemoveTool(ID_ZOOMTOOL);
00452 zoomtool->SetNormalBitmap(wxMEMORY_BITMAP(zoom_png));
00453 m_viewerToolBar->InsertTool(1, zoomtool);
00454 m_viewerToolBar->Realize();
00455
00456
00457 wxToolBarToolBase *refinetool = m_viewerToolBar->RemoveTool(ID_REFINETOOL);
00458 refinetool->SetNormalBitmap(wxMEMORY_BITMAP(radiofocus_png));
00459 m_viewerToolBar->InsertTool(2, refinetool);
00460 m_viewerToolBar->Realize();
00461
00462 wxMenuItem *renderitem = m_render->Remove(ID_RESUMEITEM);
00463 renderitem->SetBitmap(wxMEMORY_BITMAP(resume_png));
00464 m_render->Insert(0,renderitem);
00465
00466 wxMenuItem *pauseitem = m_render->Remove(ID_PAUSEITEM);
00467 pauseitem->SetBitmap(wxMEMORY_BITMAP(pause_png));
00468 m_render->Insert(1,pauseitem);
00469
00470 wxMenuItem *stopitem = m_render->Remove(ID_STOPITEM);
00471 stopitem->SetBitmap(wxMEMORY_BITMAP(stop_png));
00472 m_render->Insert(2,stopitem);
00473
00474 m_auinotebook->SetPageBitmap(0, wxMEMORY_BITMAP(render_png));
00475 m_auinotebook->SetPageBitmap(1, wxMEMORY_BITMAP(info_png));
00476 m_auinotebook->SetPageBitmap(2, wxMEMORY_BITMAP(network_png));
00477 m_auinotebook->SetPageBitmap(3, wxMEMORY_BITMAP(output_png));
00478
00479 m_outputNotebook->SetPageBitmap(0, wxMEMORY_BITMAP(n_lightgroup_png));
00480 m_outputNotebook->SetPageBitmap(1, wxMEMORY_BITMAP(n_tonemap_png));
00481
00482
00483
00484 m_tonemapBitmap->SetBitmap(wxMEMORY_BITMAP(tab_tonemap_png));
00485 m_histogramBitmap->SetBitmap(wxMEMORY_BITMAP(tab_histogram_png));
00486 m_bloomBitmap->SetBitmap(wxMEMORY_BITMAP(tab_lenseffects_png));
00487 m_colorspaceBitmap->SetBitmap(wxMEMORY_BITMAP(tab_colorspace_png));
00488 m_gammaBitmap->SetBitmap(wxMEMORY_BITMAP(tab_gamma_png));
00489 m_NoiseReductionBitmap->SetBitmap(wxMEMORY_BITMAP(tab_noisereduction_png));
00490
00491 m_splashbmp = wxMEMORY_BITMAP(splash_png);
00492
00493
00494 m_Tab_ToneMapIcon->SetBitmap(wxMEMORY_BITMAP(arrowdownactive_png));
00495 m_Tab_ToneMapToggleIcon->SetBitmap(wxMEMORY_BITMAP(powericon_png));
00496
00497 m_Tab_LensEffectsIcon->SetBitmap(wxMEMORY_BITMAP(arrowdownactive_png));
00498 m_Tab_LensEffectsToggleIcon->SetBitmap(wxMEMORY_BITMAP(powericon_png));
00499
00500 m_Tab_ColorSpaceIcon->SetBitmap(wxMEMORY_BITMAP(arrowleft_png));
00501 m_Tab_ColorSpaceToggleIcon->SetBitmap(wxMEMORY_BITMAP(powericon_png));
00502
00503 m_Tab_GammaIcon->SetBitmap(wxMEMORY_BITMAP(arrowleft_png));
00504 m_Tab_GammaToggleIcon->SetBitmap(wxMEMORY_BITMAP(powericon_png));
00505
00506 m_Tab_HistogramIcon->SetBitmap(wxMEMORY_BITMAP(arrowleft_png));
00507 m_Tab_HistogramToggleIcon->SetBitmap(wxMEMORY_BITMAP(powericon_png));
00508
00509 m_Tab_NoiseReductionIcon->SetBitmap(wxMEMORY_BITMAP(arrowleft_png));
00510 m_Tab_NoiseReductionToggleIcon->SetBitmap(wxMEMORY_BITMAP(powericon_png));
00511 }
00512
00513 void UpdateParam(luxComponent comp, luxComponentParameters param, double value, int index = 0) {
00514 if(luxStatistics("sceneIsReady") || luxStatistics("filmIsReady")) {
00515
00516
00517
00518 luxSetParameterValue(comp, param, value, index);
00519 }
00520 }
00521
00522 void UpdateParam(luxComponent comp, luxComponentParameters param, const char* value, int index = 0) {
00523 if(luxStatistics("sceneIsReady") || luxStatistics("filmIsReady")) {
00524
00525
00526
00527 luxSetStringParameterValue(comp, param, value, index);
00528 }
00529 }
00530
00531 double RetrieveParam(bool useDefault, luxComponent comp, luxComponentParameters param, int index = 0) {
00532 if(useDefault)
00533 return luxGetDefaultParameterValue(comp, param, index);
00534 else
00535 return luxGetParameterValue(comp, param, index);
00536 }
00537
00538 void LuxGui::OnMenu(wxCommandEvent& event) {
00539 switch (event.GetId()) {
00540 case ID_RESUMEITEM:
00541 case ID_RESUMETOOL:
00542 if(m_guiRenderState != RENDERING && m_guiRenderState != TONEMAPPING) {
00543 UpdateNetworkTree();
00544
00545
00546 m_renderOutput->Reload();
00547 m_HistogramWindow->Update();
00548
00549
00550 if (!m_renderTimer->IsRunning())
00551 m_renderTimer->Start(1000*luxStatistics("displayInterval"), wxTIMER_CONTINUOUS);
00552 if (!m_statsTimer->IsRunning())
00553 m_statsTimer->Start(1000, wxTIMER_CONTINUOUS);
00554 if (!m_netTimer->IsRunning())
00555 m_netTimer->Start(1000, wxTIMER_CONTINUOUS);
00556
00557 if(m_guiRenderState == PAUSED || m_guiRenderState == STOPPED)
00558 luxStart();
00559 if(m_guiRenderState == STOPPED)
00560 luxSetHaltSamplePerPixel(-1, false, false);
00561 ChangeRenderState(RENDERING);
00562 }
00563 break;
00564 case ID_PAUSEITEM:
00565 case ID_PAUSETOOL:
00566 if(m_guiRenderState != PAUSED && m_guiRenderState != TONEMAPPING) {
00567
00568
00569 if (luxGetServerCount() < 1) {
00570
00571 m_renderTimer->Stop();
00572 m_statsTimer->Stop();
00573 }
00574
00575 if(m_guiRenderState == RENDERING)
00576 luxPause();
00577 ChangeRenderState(PAUSED);
00578 }
00579 break;
00580 case ID_STOPITEM:
00581 case ID_STOPTOOL:
00582 if ((m_guiRenderState == RENDERING || m_guiRenderState == PAUSED) && m_guiRenderState != TONEMAPPING) {
00583
00584 m_renderTimer->Stop();
00585
00586 luxSetHaltSamplePerPixel(1, true, true);
00587 m_statusBar->SetStatusText(wxT("Waiting for render threads to stop."), 0);
00588 ChangeRenderState(STOPPING);
00589 }
00590 break;
00591 case ID_FULL_SCREEN:
00592 if ( !IsFullScreen() )
00593 {
00594 m_renderToolBar->Show( false );
00595 m_viewerToolBar->Show( false );
00596 m_outputNotebook->Show( false );
00597 ShowFullScreen( true );
00598 }
00599 else
00600 {
00601 ShowFullScreen( false );
00602
00603 if (m_view->IsChecked( ID_TOOL_BAR ) )
00604 {
00605 m_renderToolBar->Show( true );
00606 m_viewerToolBar->Show( true );
00607 }
00608 if (m_view->IsChecked( ID_SIDE_PANE ) )
00609 {
00610 m_outputNotebook->Show( true );
00611 }
00612 }
00613 Layout();
00614 m_renderPage->Layout();
00615 break;
00616 case ID_TOOL_BAR:
00617 if ( m_renderToolBar->IsShown() )
00618 {
00619 m_renderToolBar->Show( false );
00620 m_viewerToolBar->Show( false );
00621 }
00622 else
00623 {
00624 m_renderToolBar->Show( true );
00625 m_viewerToolBar->Show( true );
00626 }
00627 m_renderPage->Layout();
00628 break;
00629 case ID_STATUS_BAR:
00630 if ( m_statusBar->IsShown() )
00631 {
00632 m_statusBar->Show( false );
00633 }
00634 else
00635 {
00636 m_statusBar->Show( true );
00637 }
00638 Layout();
00639 break;
00640 case ID_SIDE_PANE:
00641 if ( m_outputNotebook->IsShown() )
00642 {
00643 m_outputNotebook->Show( false );
00644 m_view->Check( ID_SIDE_PANE, false );
00645 }
00646 else
00647 {
00648 m_outputNotebook->Show( true );
00649 m_view->Check( ID_SIDE_PANE, true );
00650 }
00651 m_renderPage->Layout();
00652 break;
00653 case ID_VIEWER_RULERS_DISABLED:
00654 case ID_VIEWER_RULERS_PIXELS:
00655 case ID_VIEWER_RULERS_NORMALIZED:
00656 m_renderOutput->SetRulersEnabled( !m_view->IsChecked(ID_VIEWER_RULERS_DISABLED), m_view->IsChecked(ID_VIEWER_RULERS_NORMALIZED) );
00657 break;
00658 case ID_RENDER_COPY:
00659 if ( m_guiRenderState != WAITING &&
00660 wxTheClipboard->Open() )
00661 {
00662 m_statusBar->SetStatusText(wxT("Copying..."), 0);
00663
00664 wxTheClipboard->SetData( new wxBitmapDataObject( *(new wxBitmap( *(new wxImage( luxStatistics("filmXres"), luxStatistics("filmYres"), luxFramebuffer()))))));
00665 wxTheClipboard->Close();
00666
00667 m_statusBar->SetStatusText(wxT(""), 0);
00668 }
00669 break;
00670 case ID_CLEAR_LOG:
00671 m_logTextCtrl->Clear();
00672 break;
00673 case ID_ADD_THREAD:
00674 if ( m_numThreads < 16 ) SetRenderThreads( m_numThreads + 1 );
00675 break;
00676 case ID_REMOVE_THREAD:
00677 if ( m_numThreads > 1 ) SetRenderThreads( m_numThreads - 1 );
00678 break;
00679 case ID_ADD_SERVER:
00680 AddServer();
00681 break;
00682 case ID_REMOVE_SERVER:
00683 RemoveServer();
00684 break;
00685 case ID_TM_RESET:
00686 ResetToneMapping();
00687 break;
00688 case wxID_ABOUT:
00689 new wxSplashScreen(m_splashbmp, wxSPLASH_CENTRE_ON_PARENT, 0, this, -1);
00690 break;
00691 case wxID_EXIT:
00692 Close(false);
00693 break;
00694 case ID_PAN_MODE:
00695 m_viewerToolBar->ToggleTool( ID_PANTOOL, true );
00696 m_renderOutput->SetMode(PANZOOM);
00697 break;
00698 case ID_PANTOOL:
00699 m_renderOutput->SetMode(PANZOOM);
00700 break;
00701 case ID_ZOOM_MODE:
00702 m_viewerToolBar->ToggleTool( ID_ZOOMTOOL, true );
00703 m_renderOutput->SetMode(SELECTION);
00704 break;
00705 case ID_ZOOMTOOL:
00706 case ID_REFINETOOL:
00707 m_renderOutput->SetMode(SELECTION);
00708 break;
00709 case ID_TM_APPLY:
00710 {
00711
00712 ApplyTonemapping();
00713 }
00714 break;
00715 case ID_AUTO_TONEMAP:
00716 {
00717
00718 if(m_auto_tonemapCheckBox->IsChecked())
00719 m_auto_tonemap = true;
00720 else
00721 m_auto_tonemap = false;
00722 }
00723 break;
00724 case ID_TM_KERNELCHOICE:
00725 {
00726
00727 int choice = event.GetInt();
00728 SetTonemapKernel(choice);
00729 }
00730 break;
00731 case ID_TORGB_COLORSPACECHOICE:
00732 {
00733
00734 int choice = event.GetInt();
00735 SetColorSpacePreset(choice);
00736 }
00737 break;
00738 case ID_TORGB_WHITEPOINTCHOICE:
00739 {
00740
00741 int choice = event.GetInt();
00742 SetWhitepointPreset(choice);
00743 }
00744 break;
00745 case ID_COMPUTEBLOOMLAYER:
00746 {
00747
00748 UpdateParam(LUX_FILM, LUX_FILM_UPDATEBLOOMLAYER, 1.0f);
00749 m_deletebloomlayer->Enable(true);
00750 m_bloomweightSlider->Enable(true);
00751 m_bloomweightText->Enable(true);
00752 ApplyTonemapping(true);
00753 }
00754 break;
00755 case ID_DELETEBLOOMLAYER:
00756 {
00757
00758 UpdateParam(LUX_FILM, LUX_FILM_DELETEBLOOMLAYER, 1.0f);
00759 m_deletebloomlayer->Enable(false);
00760 m_bloomweightSlider->Enable(false);
00761 m_bloomweightText->Enable(false);
00762 ApplyTonemapping(true);
00763 }
00764 break;
00765
00766 case ID_VIGNETTING_ENABLED:
00767 {
00768 if(m_vignettingenabledCheckBox->IsChecked())
00769 m_Vignetting_Enabled = true;
00770 else
00771 m_Vignetting_Enabled = false;
00772 UpdateParam(LUX_FILM, LUX_FILM_VIGNETTING_ENABLED, m_Vignetting_Enabled);
00773 if(m_auto_tonemap) ApplyTonemapping();
00774 }
00775 break;
00776
00777 case ID_ABERRATION_ENABLED:
00778 {
00779 if(m_aberrationEnabled->IsChecked())
00780 m_Aberration_enabled = true;
00781 else
00782 m_Aberration_enabled = false;
00783 UpdateParam(LUX_FILM, LUX_FILM_ABERRATION_ENABLED, m_Aberration_enabled);
00784 if(m_auto_tonemap) ApplyTonemapping();
00785 }
00786 break;
00787
00788 case ID_COMPUTEGLARELAYER:
00789 {
00790
00791 UpdateParam(LUX_FILM, LUX_FILM_UPDATEGLARELAYER, 1.0);
00792 m_deleteglarelayer->Enable(true);
00793 m_glareamountSlider->Enable(true);
00794 m_glareamountText->Enable(true);
00795 ApplyTonemapping(true);
00796 }
00797 break;
00798
00799 case ID_DELETEGLARELAYER:
00800 {
00801
00802 UpdateParam(LUX_FILM, LUX_FILM_DELETEGLARELAYER, 1.0f);
00803 m_deleteglarelayer->Enable(false);
00804 m_glareamountSlider->Enable(false);
00805 m_glareamountText->Enable(false);
00806 ApplyTonemapping(true);
00807 }
00808 break;
00809
00810
00811 case ID_GREYC_ENABLED:
00812 {
00813 if(m_greyc_EnabledCheckBox->IsChecked())
00814 m_GREYC_enabled = true;
00815 else
00816 m_GREYC_enabled = false;
00817 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_ENABLED, m_GREYC_enabled);
00818 if(m_auto_tonemap) ApplyTonemapping();
00819 }
00820 break;
00821
00822 case ID_GREYC_FASTAPPROX:
00823 {
00824 if(m_greyc_fastapproxCheckBox->IsChecked())
00825 m_GREYC_fast_approx = true;
00826 else
00827 m_GREYC_fast_approx = false;
00828 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_FASTAPPROX, m_GREYC_fast_approx);
00829 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
00830 }
00831 break;
00832
00833 case ID_GREYC_INTERPOLATIONCHOICE:
00834 {
00835
00836 m_GREYC_interp = event.GetInt();
00837 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_INTERP, m_GREYC_interp);
00838 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
00839 }
00840 break;
00841
00842 case ID_CHIU_ENABLED:
00843 {
00844 if(m_chiu_enableCheckBox->IsChecked())
00845 m_Chiu_enabled = true;
00846 else
00847 m_Chiu_enabled = false;
00848 UpdateParam(LUX_FILM, LUX_FILM_NOISE_CHIU_ENABLED, m_Chiu_enabled);
00849 if(m_auto_tonemap) ApplyTonemapping();
00850 }
00851 break;
00852
00853 case ID_CHIU_INCLUDECENTER:
00854 {
00855 if(m_chiu_includecenterCheckBox->IsChecked())
00856 m_Chiu_includecenter = true;
00857 else
00858 m_Chiu_includecenter = false;
00859 UpdateParam(LUX_FILM, LUX_FILM_NOISE_CHIU_INCLUDECENTER, m_Chiu_includecenter);
00860 if(m_auto_tonemap && m_Chiu_enabled) ApplyTonemapping();
00861 }
00862 break;
00863
00864 case ID_HISTOGRAM_CHANNEL:
00865 {
00866 switch( event.GetInt() ){
00867 case 0: m_HistogramWindow->SetOption(LUX_HISTOGRAM_RGB_ADD); break;
00868 case 1: m_HistogramWindow->SetOption(LUX_HISTOGRAM_RGB); break;
00869 case 2: m_HistogramWindow->SetOption(LUX_HISTOGRAM_RED); break;
00870 case 3: m_HistogramWindow->SetOption(LUX_HISTOGRAM_GREEN); break;
00871 case 4: m_HistogramWindow->SetOption(LUX_HISTOGRAM_BLUE); break;
00872 case 5: m_HistogramWindow->SetOption(LUX_HISTOGRAM_VALUE); break;
00873 }
00874 m_HistogramWindow->Update();
00875 }
00876 break;
00877 case ID_HISTOGRAM_LOG:
00878 {
00879 if(event.IsChecked())
00880 m_HistogramWindow->SetOption(LUX_HISTOGRAM_LOG);
00881 else
00882 m_HistogramWindow->ClearOption(LUX_HISTOGRAM_LOG);
00883 m_HistogramWindow->Update();
00884 }
00885 break;
00886 default:
00887 break;
00888 }
00889 m_HistogramWindow->SetEnabled(m_HistogramWindow->IsShownOnScreen());
00890 }
00891
00892 void LuxGui::OnMouse(wxMouseEvent &event) {
00893 switch (event.GetId()) {
00894
00895 case ID_TAB_HISTOGRAM:
00896 {
00897 if( m_Tab_Control_HistogramPanel->IsShown() ){
00898 m_Tab_Control_HistogramPanel->Hide();
00899 m_Tab_HistogramIcon->SetBitmap(wxMEMORY_BITMAP(arrowleft_png));
00900 m_HistogramWindow->SetEnabled(false);
00901 }else{
00902 ApplyTonemapping();
00903 m_Tab_Control_HistogramPanel->Show(true);
00904 m_Tab_HistogramIcon->SetBitmap(wxMEMORY_BITMAP(arrowdownactive_png));
00905 m_HistogramWindow->SetEnabled(true);
00906 }
00907 m_HistogramPanel->GetSizer()->Layout();
00908 m_Tonemap->GetSizer()->Layout();
00909 m_Tonemap->GetSizer()->FitInside(m_Tonemap);
00910 m_Tonemap->Refresh();
00911 }
00912 break;
00913 case ID_TAB_TONEMAP:
00914 {
00915 if( m_Tab_Control_ToneMapPanel->IsShown() ){
00916 m_Tab_Control_ToneMapPanel->Hide();
00917 m_Tab_ToneMapIcon->SetBitmap(wxMEMORY_BITMAP(arrowleft_png));
00918 }else{
00919 m_Tab_Control_ToneMapPanel->Show(true);
00920 m_Tab_ToneMapIcon->SetBitmap(wxMEMORY_BITMAP(arrowdownactive_png));
00921 }
00922 m_TonemapOptionsPanel->GetSizer()->Layout();
00923 m_Tonemap->GetSizer()->Layout();
00924 m_Tonemap->GetSizer()->FitInside(m_Tonemap);
00925 m_Tonemap->Refresh();
00926 }
00927 break;
00928 case ID_TAB_LENSEFFECTS:
00929 {
00930 if( m_Tab_Control_LensEffectsPanel->IsShown() ){
00931 m_Tab_Control_LensEffectsPanel->Hide();
00932 m_Tab_LensEffectsIcon->SetBitmap(wxMEMORY_BITMAP(arrowleft_png));
00933 }else{
00934 m_Tab_Control_LensEffectsPanel->Show(true);
00935 m_Tab_LensEffectsIcon->SetBitmap(wxMEMORY_BITMAP(arrowdownactive_png));
00936 }
00937 m_BloomOptionsPanel->GetSizer()->Layout();
00938 m_Tonemap->GetSizer()->Layout();
00939 m_Tonemap->GetSizer()->FitInside(m_Tonemap);
00940 m_Tonemap->Refresh();
00941 }
00942 break;
00943 case ID_TAB_LENSEFFECTS_TOGGLE:
00944 {
00945 if( m_Lenseffects_enabled ){
00946 m_Lenseffects_enabled = false;
00947 m_Tab_LensEffectsToggleIcon->SetBitmap(wxMEMORY_BITMAP(powerofficon_png));
00948 }else{
00949 m_Lenseffects_enabled = true;
00950 m_Tab_LensEffectsToggleIcon->SetBitmap(wxMEMORY_BITMAP(powericon_png));
00951 }
00952 m_LensEffectsAuiNotebook->Enable(m_Lenseffects_enabled);
00953 UpdateParam(LUX_FILM, LUX_FILM_VIGNETTING_ENABLED, m_Vignetting_Enabled && m_Lenseffects_enabled);
00954 UpdateParam(LUX_FILM, LUX_FILM_ABERRATION_ENABLED, m_Aberration_enabled && m_Lenseffects_enabled);
00955 UpdateParam(LUX_FILM, LUX_FILM_GLARE_AMOUNT, m_Lenseffects_enabled ? m_Glare_amount : 0.0);
00956 UpdateParam(LUX_FILM, LUX_FILM_BLOOMWEIGHT, m_Lenseffects_enabled ? m_bloomweight : 0.0);
00957 if (!m_Lenseffects_enabled)
00958
00959 UpdateParam(LUX_FILM, LUX_FILM_UPDATEBLOOMLAYER, 0.0);
00960
00961 if(m_auto_tonemap) ApplyTonemapping();
00962 break;
00963 }
00964 case ID_TAB_COLORSPACE:
00965 {
00966 if( m_Tab_Control_ColorSpacePanel->IsShown() ){
00967 m_Tab_Control_ColorSpacePanel->Hide();
00968 m_Tab_ColorSpaceIcon->SetBitmap(wxMEMORY_BITMAP(arrowleft_png));
00969 }else{
00970 m_Tab_Control_ColorSpacePanel->Show(true);
00971 m_Tab_ColorSpaceIcon->SetBitmap(wxMEMORY_BITMAP(arrowdownactive_png));
00972 }
00973 m_ColorSpaceOptionsPanel->GetSizer()->Layout();
00974 m_Tonemap->GetSizer()->Layout();
00975 m_Tonemap->GetSizer()->FitInside(m_Tonemap);
00976 m_Tonemap->Refresh();
00977 }
00978 break;
00979 case ID_TAB_GAMMA:
00980 {
00981 if( m_Tab_Control_GammaPanel->IsShown() ){
00982 m_Tab_Control_GammaPanel->Hide();
00983 m_Tab_GammaIcon->SetBitmap(wxMEMORY_BITMAP(arrowleft_png));
00984 }else{
00985 m_Tab_Control_GammaPanel->Show(true);
00986 m_Tab_GammaIcon->SetBitmap(wxMEMORY_BITMAP(arrowdownactive_png));
00987 }
00988 m_GammaOptionsPanel->GetSizer()->Layout();
00989 m_Tonemap->GetSizer()->Layout();
00990 m_Tonemap->GetSizer()->FitInside(m_Tonemap);
00991 m_Tonemap->Refresh();
00992 }
00993 break;
00994 case ID_TAB_GAMMA_TOGGLE:
00995 {
00996 if( m_Gamma_enabled ){
00997 m_Gamma_enabled = false;
00998 m_Tab_GammaToggleIcon->SetBitmap(wxMEMORY_BITMAP(powerofficon_png));
00999 }else{
01000 m_Gamma_enabled = true;
01001 m_Tab_GammaToggleIcon->SetBitmap(wxMEMORY_BITMAP(powericon_png));
01002 }
01003 m_TORGB_gammaSlider->Enable(m_Gamma_enabled);
01004 m_TORGB_gammaText->Enable(m_Gamma_enabled);
01005 UpdateParam(LUX_FILM, LUX_FILM_TORGB_GAMMA, (m_Gamma_enabled ? m_TORGB_gamma : 1.0));
01006 if(m_auto_tonemap) ApplyTonemapping();
01007 break;
01008 }
01009 case ID_TAB_NOISEREDUCTION:
01010 {
01011 if( m_Tab_Control_NoiseReductionPanel->IsShown() ){
01012 m_Tab_Control_NoiseReductionPanel->Hide();
01013 m_Tab_NoiseReductionIcon->SetBitmap(wxMEMORY_BITMAP(arrowleft_png));
01014 }else{
01015 m_Tab_Control_NoiseReductionPanel->Show(true);
01016 m_Tab_NoiseReductionIcon->SetBitmap(wxMEMORY_BITMAP(arrowdownactive_png));
01017 }
01018 m_NoiseOptionsPanel->GetSizer()->Layout();
01019 m_Tonemap->GetSizer()->Layout();
01020 m_Tonemap->GetSizer()->FitInside(m_Tonemap);
01021 m_Tonemap->Refresh();
01022 }
01023 break;
01024 case ID_TAB_NOISEREDUCTION_TOGGLE:
01025 {
01026 if( m_Noisereduction_enabled ){
01027 m_Noisereduction_enabled = false;
01028 m_Tab_NoiseReductionToggleIcon->SetBitmap(wxMEMORY_BITMAP(powerofficon_png));
01029 }else{
01030 m_Noisereduction_enabled = true;
01031 m_Tab_NoiseReductionToggleIcon->SetBitmap(wxMEMORY_BITMAP(powericon_png));
01032 }
01033 m_NoiseReductionAuiNotebook->Enable(m_Noisereduction_enabled);
01034 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_ENABLED, m_GREYC_enabled && m_Noisereduction_enabled);
01035 UpdateParam(LUX_FILM, LUX_FILM_NOISE_CHIU_ENABLED, m_Chiu_enabled && m_Noisereduction_enabled);
01036 if(m_auto_tonemap) ApplyTonemapping();
01037 break;
01038 }
01039 default:
01040 break;
01041 }
01042 }
01043
01045
01046 void LuxGui::ApplyTonemapping(bool withlayercomputation) {
01047 if(m_updateThread == NULL && ( luxStatistics("sceneIsReady") || luxStatistics("filmIsReady") ) &&
01048 (m_guiWindowState == SHOWN || m_guiRenderState == FINISHED)) {
01049 if(!withlayercomputation) {
01050 luxError(LUX_NOERROR, LUX_INFO, "GUI: Updating framebuffer...");
01051 m_statusBar->SetStatusText(wxT("Tonemapping..."), 0);
01052 } else {
01053 luxError(LUX_NOERROR, LUX_INFO, "GUI: Updating framebuffer/Computing Lens Effect Layer(s)...");
01054 m_statusBar->SetStatusText(wxT("Computing Lens Effect Layer(s) & Tonemapping..."), 0);
01055 }
01056 m_updateThread = new boost::thread(boost::bind(&LuxGui::UpdateThread, this));
01057 }
01058 }
01059
01060 void LuxGui::OnText(wxCommandEvent& event) {
01061 if ( event.GetEventType() != wxEVT_COMMAND_TEXT_ENTER ) return;
01062
01063 switch (event.GetId()) {
01064
01065 case ID_TM_REINHARD_PRESCALE_TEXT:
01066 if( m_TM_Reinhard_prescaleText->IsModified() )
01067 {
01068 wxString st = m_TM_Reinhard_prescaleText->GetValue();
01069 st.ToDouble( &m_TM_reinhard_prescale );
01070
01071 if ( m_TM_reinhard_prescale > TM_REINHARD_PRESCALE_RANGE ) m_TM_reinhard_prescale = TM_REINHARD_PRESCALE_RANGE;
01072 else if ( m_TM_reinhard_prescale < 0.f ) m_TM_reinhard_prescale = 0.f;
01073
01074 st = wxString::Format( _("%.02f"), m_TM_reinhard_prescale );
01075 m_TM_Reinhard_prescaleText->SetValue( st );
01076 int val = (int)(( FLOAT_SLIDER_RES / TM_REINHARD_PRESCALE_RANGE ) * (m_TM_reinhard_prescale));
01077 m_TM_Reinhard_prescaleSlider->SetValue( val );
01078 UpdateParam(LUX_FILM, LUX_FILM_TM_REINHARD_PRESCALE, m_TM_reinhard_prescale);
01079 if(m_auto_tonemap) ApplyTonemapping();
01080 }
01081 break;
01082 case ID_TM_REINHARD_POSTSCALE_TEXT:
01083 if ( m_TM_Reinhard_postscaleText->IsModified() )
01084 {
01085 wxString st = m_TM_Reinhard_postscaleText->GetValue();
01086 st.ToDouble( &m_TM_reinhard_postscale );
01087
01088 if ( m_TM_reinhard_postscale > TM_REINHARD_POSTSCALE_RANGE ) m_TM_reinhard_postscale = TM_REINHARD_POSTSCALE_RANGE;
01089 else if ( m_TM_reinhard_postscale < 0.f ) m_TM_reinhard_postscale = 0.f;
01090
01091 st = wxString::Format( _("%.02f"), m_TM_reinhard_postscale );
01092 m_TM_Reinhard_postscaleText->SetValue( st );
01093 int val = (int)(( FLOAT_SLIDER_RES / TM_REINHARD_POSTSCALE_RANGE ) * (m_TM_reinhard_postscale));
01094 m_TM_Reinhard_postscaleSlider->SetValue( val );
01095 UpdateParam(LUX_FILM, LUX_FILM_TM_REINHARD_POSTSCALE, m_TM_reinhard_postscale);
01096 if(m_auto_tonemap) ApplyTonemapping();
01097 }
01098 break;
01099 case ID_TM_REINHARD_BURN_TEXT:
01100 if ( m_TM_Reinhard_burnText->IsModified() )
01101 {
01102 wxString st = m_TM_Reinhard_burnText->GetValue();
01103 st.ToDouble( &m_TM_reinhard_burn );
01104
01105 if ( m_TM_reinhard_burn > TM_REINHARD_BURN_RANGE ) m_TM_reinhard_burn = TM_REINHARD_BURN_RANGE;
01106 else if ( m_TM_reinhard_burn < 0 ) m_TM_reinhard_burn = 0;
01107
01108 st = wxString::Format( _("%.02f"), m_TM_reinhard_burn );
01109 m_TM_Reinhard_burnText->SetValue( st );
01110 int val = (int)(( FLOAT_SLIDER_RES / TM_REINHARD_BURN_RANGE ) * (m_TM_reinhard_burn));
01111 m_TM_Reinhard_burnSlider->SetValue( val );
01112 UpdateParam(LUX_FILM, LUX_FILM_TM_REINHARD_BURN, m_TM_reinhard_burn);
01113 if(m_auto_tonemap) ApplyTonemapping();
01114 }
01115 break;
01116
01117
01118 case ID_TM_LINEAR_SENSITIVITY_TEXT:
01119 if ( m_TM_Linear_sensitivityText->IsModified() )
01120 {
01121 wxString st = m_TM_Linear_sensitivityText->GetValue();
01122 st.ToDouble( &m_TM_linear_sensitivity );
01123
01124 if ( m_TM_linear_sensitivity > TM_LINEAR_SENSITIVITY_RANGE ) m_TM_linear_sensitivity = TM_LINEAR_SENSITIVITY_RANGE;
01125 else if ( m_TM_linear_sensitivity < 0 ) m_TM_linear_sensitivity = 0;
01126
01127 st = wxString::Format( _("%.02f"), m_TM_linear_sensitivity );
01128 m_TM_Linear_sensitivityText->SetValue( st );
01129 int val = (int)(( FLOAT_SLIDER_RES / TM_LINEAR_SENSITIVITY_RANGE ) * (m_TM_linear_sensitivity));
01130 m_TM_Linear_sensitivitySlider->SetValue( val );
01131 UpdateParam(LUX_FILM, LUX_FILM_TM_LINEAR_SENSITIVITY, m_TM_linear_sensitivity);
01132 if(m_auto_tonemap) ApplyTonemapping();
01133 }
01134 break;
01135 case ID_TM_LINEAR_EXPOSURE_TEXT:
01136 if ( m_TM_Linear_exposureText->IsModified() )
01137 {
01138 wxString st = m_TM_Linear_exposureText->GetValue();
01139 st.ToDouble( &m_TM_linear_exposure );
01140
01141 if ( m_TM_linear_exposure > powf(10.f, TM_LINEAR_EXPOSURE_LOG_MAX) )
01142 m_TM_linear_exposure = powf(10.f, TM_LINEAR_EXPOSURE_LOG_MAX);
01143 else if ( m_TM_linear_exposure < powf(10.f, TM_LINEAR_EXPOSURE_LOG_MIN) )
01144 m_TM_linear_exposure = powf(10.f, TM_LINEAR_EXPOSURE_LOG_MIN);
01145
01146 st = wxString::Format( _("%.02f"), m_TM_linear_exposure );
01147 m_TM_Linear_exposureText->SetValue( st );
01148 m_TM_Linear_exposureSlider->SetValue( ValueToLogSliderVal(m_TM_linear_exposure,
01149 TM_LINEAR_EXPOSURE_LOG_MIN, TM_LINEAR_EXPOSURE_LOG_MAX) );
01150 UpdateParam(LUX_FILM, LUX_FILM_TM_LINEAR_EXPOSURE, m_TM_linear_exposure);
01151 if(m_auto_tonemap) ApplyTonemapping();
01152 }
01153 break;
01154 case ID_TM_LINEAR_FSTOP_TEXT:
01155 if ( m_TM_Linear_fstopText->IsModified() )
01156 {
01157 wxString st = m_TM_Linear_fstopText->GetValue();
01158 st.ToDouble( &m_TM_linear_fstop );
01159
01160 if ( m_TM_linear_fstop > TM_LINEAR_FSTOP_RANGE ) m_TM_linear_fstop = TM_LINEAR_FSTOP_RANGE;
01161 else if ( m_TM_linear_fstop < 0 ) m_TM_linear_fstop = 0;
01162
01163 st = wxString::Format( _("%.02f"), m_TM_linear_fstop );
01164 m_TM_Linear_fstopText->SetValue( st );
01165 int val = (int)(( FLOAT_SLIDER_RES / TM_LINEAR_FSTOP_RANGE ) * (m_TM_linear_fstop));
01166 m_TM_Linear_fstopSlider->SetValue( val );
01167 UpdateParam(LUX_FILM, LUX_FILM_TM_LINEAR_FSTOP, m_TM_linear_fstop);
01168 if(m_auto_tonemap) ApplyTonemapping();
01169 }
01170 break;
01171 case ID_TM_LINEAR_GAMMA_TEXT:
01172 if ( m_TM_Linear_gammaText->IsModified() )
01173 {
01174 wxString st = m_TM_Linear_gammaText->GetValue();
01175 st.ToDouble( &m_TM_linear_gamma );
01176
01177 if ( m_TM_linear_gamma > TM_LINEAR_GAMMA_RANGE ) m_TM_linear_gamma = TM_LINEAR_GAMMA_RANGE;
01178 else if ( m_TM_linear_gamma < 0 ) m_TM_linear_gamma = 0;
01179
01180 st = wxString::Format( _("%.02f"), m_TM_linear_gamma );
01181 m_TM_Linear_gammaText->SetValue( st );
01182 int val = (int)(( FLOAT_SLIDER_RES / TM_LINEAR_GAMMA_RANGE ) * (m_TM_linear_gamma));
01183 m_TM_Linear_gammaSlider->SetValue( val );
01184 UpdateParam(LUX_FILM, LUX_FILM_TM_LINEAR_GAMMA, m_TM_linear_gamma);
01185 if(m_auto_tonemap) ApplyTonemapping();
01186 }
01187 break;
01188
01189
01190 case ID_TM_CONTRAST_YWA_TEXT:
01191 if ( m_TM_contrast_ywaText->IsModified() )
01192 {
01193 wxString st = m_TM_contrast_ywaText->GetValue();
01194 st.ToDouble( &m_TM_contrast_ywa );
01195
01196 if ( m_TM_contrast_ywa > powf(10.f, TM_CONTRAST_YWA_LOG_MAX) )
01197 m_TM_contrast_ywa = powf(10.f, TM_CONTRAST_YWA_LOG_MAX);
01198 else if ( m_TM_contrast_ywa < powf(10.f, TM_CONTRAST_YWA_LOG_MIN) )
01199 m_TM_contrast_ywa = powf(10.f, TM_CONTRAST_YWA_LOG_MIN);
01200
01201 st = wxString::Format( _("%.02f"), m_TM_contrast_ywa );
01202 m_TM_contrast_ywaText->SetValue( st );
01203 m_TM_contrast_ywaSlider->SetValue( ValueToLogSliderVal(m_TM_contrast_ywa,
01204 TM_CONTRAST_YWA_LOG_MIN, TM_CONTRAST_YWA_LOG_MAX) );
01205 UpdateParam(LUX_FILM, LUX_FILM_TM_CONTRAST_YWA, m_TM_contrast_ywa);
01206 if(m_auto_tonemap) ApplyTonemapping();
01207 }
01208 break;
01209
01210
01211
01212 case ID_TORGB_XWHITE_TEXT:
01213 if ( m_TORGB_xwhiteText->IsModified() )
01214 {
01215 wxString st = m_TORGB_xwhiteText->GetValue();
01216 st.ToDouble( &m_TORGB_xwhite );
01217
01218 if ( m_TORGB_xwhite > TORGB_XWHITE_RANGE ) m_TORGB_xwhite = TORGB_XWHITE_RANGE;
01219 else if ( m_TORGB_xwhite < 0 ) m_TORGB_xwhite = 0;
01220
01221 st = wxString::Format( _("%.02f"), m_TORGB_xwhite );
01222 m_TORGB_xwhiteText->SetValue( st );
01223 int val = (int)(( FLOAT_SLIDER_RES / TORGB_XWHITE_RANGE ) * (m_TORGB_xwhite));
01224 m_TORGB_xwhiteSlider->SetValue( val );
01225 UpdateParam(LUX_FILM, LUX_FILM_TORGB_X_WHITE, m_TORGB_xwhite);
01226 if(m_auto_tonemap) ApplyTonemapping();
01227 }
01228 break;
01229 case ID_TORGB_YWHITE_TEXT:
01230 if ( m_TORGB_ywhiteText->IsModified() )
01231 {
01232 wxString st = m_TORGB_ywhiteText->GetValue();
01233 st.ToDouble( &m_TORGB_ywhite );
01234
01235 if ( m_TORGB_ywhite > TORGB_YWHITE_RANGE ) m_TORGB_ywhite = TORGB_YWHITE_RANGE;
01236 else if ( m_TORGB_ywhite < 0 ) m_TORGB_ywhite = 0;
01237
01238 st = wxString::Format( _("%.02f"), m_TORGB_ywhite );
01239 m_TORGB_ywhiteText->SetValue( st );
01240 int val = (int)(( FLOAT_SLIDER_RES / TORGB_YWHITE_RANGE ) * (m_TORGB_ywhite));
01241 m_TORGB_ywhiteSlider->SetValue( val );
01242 UpdateParam(LUX_FILM, LUX_FILM_TORGB_Y_WHITE, m_TORGB_ywhite);
01243 if(m_auto_tonemap) ApplyTonemapping();
01244 }
01245 break;
01246 case ID_TORGB_XRED_TEXT:
01247 if ( m_TORGB_xredText->IsModified() )
01248 {
01249 wxString st = m_TORGB_xredText->GetValue();
01250 st.ToDouble( &m_TORGB_xred );
01251
01252 if ( m_TORGB_xred > TORGB_XRED_RANGE ) m_TORGB_xred = TORGB_XRED_RANGE;
01253 else if ( m_TORGB_xred < 0 ) m_TORGB_xred = 0;
01254
01255 st = wxString::Format( _("%.02f"), m_TORGB_xred );
01256 m_TORGB_xredText->SetValue( st );
01257 int val = (int)(( FLOAT_SLIDER_RES / TORGB_XRED_RANGE ) * (m_TORGB_xred));
01258 m_TORGB_xredSlider->SetValue( val );
01259 UpdateParam(LUX_FILM, LUX_FILM_TORGB_X_RED, m_TORGB_xred);
01260 if(m_auto_tonemap) ApplyTonemapping();
01261 }
01262 break;
01263 case ID_TORGB_YRED_TEXT:
01264 if ( m_TORGB_yredText->IsModified() )
01265 {
01266 wxString st = m_TORGB_yredText->GetValue();
01267 st.ToDouble( &m_TORGB_yred );
01268
01269 if ( m_TORGB_yred > TORGB_YRED_RANGE ) m_TORGB_yred = TORGB_YRED_RANGE;
01270 else if ( m_TORGB_yred < 0 ) m_TORGB_yred = 0;
01271
01272 st = wxString::Format( _("%.02f"), m_TORGB_yred );
01273 m_TORGB_yredText->SetValue( st );
01274 int val = (int)(( FLOAT_SLIDER_RES / TORGB_YRED_RANGE ) * (m_TORGB_yred));
01275 m_TORGB_yredSlider->SetValue( val );
01276 UpdateParam(LUX_FILM, LUX_FILM_TORGB_Y_RED, m_TORGB_yred);
01277 if(m_auto_tonemap) ApplyTonemapping();
01278 }
01279 break;
01280 case ID_TORGB_XGREEN_TEXT:
01281 if ( m_TORGB_xgreenText->IsModified() )
01282 {
01283 wxString st = m_TORGB_xgreenText->GetValue();
01284 st.ToDouble( &m_TORGB_xgreen );
01285
01286 if ( m_TORGB_xgreen > TORGB_XGREEN_RANGE ) m_TORGB_xgreen = TORGB_XGREEN_RANGE;
01287 else if ( m_TORGB_xgreen < 0 ) m_TORGB_xgreen = 0;
01288
01289 st = wxString::Format( _("%.02f"), m_TORGB_xgreen );
01290 m_TORGB_xgreenText->SetValue( st );
01291 int val = (int)(( FLOAT_SLIDER_RES / TORGB_XGREEN_RANGE ) * (m_TORGB_xgreen));
01292 m_TORGB_xgreenSlider->SetValue( val );
01293 UpdateParam(LUX_FILM, LUX_FILM_TORGB_X_GREEN, m_TORGB_xgreen);
01294 if(m_auto_tonemap) ApplyTonemapping();
01295 }
01296 break;
01297 case ID_TORGB_YGREEN_TEXT:
01298 if ( m_TORGB_ygreenText->IsModified() )
01299 {
01300 wxString st = m_TORGB_ygreenText->GetValue();
01301 st.ToDouble( &m_TORGB_ygreen );
01302
01303 if ( m_TORGB_ygreen > TORGB_YGREEN_RANGE ) m_TORGB_ygreen = TORGB_YGREEN_RANGE;
01304 else if ( m_TORGB_ygreen < 0 ) m_TORGB_ygreen = 0;
01305
01306 st = wxString::Format( _("%.02f"), m_TORGB_ygreen );
01307 m_TORGB_ygreenText->SetValue( st );
01308 int val = (int)(( FLOAT_SLIDER_RES / TORGB_YGREEN_RANGE ) * (m_TORGB_ygreen));
01309 m_TORGB_ygreenSlider->SetValue( val );
01310 UpdateParam(LUX_FILM, LUX_FILM_TORGB_Y_GREEN, m_TORGB_ygreen);
01311 if(m_auto_tonemap) ApplyTonemapping();
01312 }
01313 break;
01314 case ID_TORGB_XBLUE_TEXT:
01315 if ( m_TORGB_xblueText->IsModified() )
01316 {
01317 wxString st = m_TORGB_xblueText->GetValue();
01318 st.ToDouble( &m_TORGB_xblue );
01319
01320 if ( m_TORGB_xblue > TORGB_XBLUE_RANGE ) m_TORGB_xblue = TORGB_XBLUE_RANGE;
01321 else if ( m_TORGB_xblue < 0 ) m_TORGB_xblue = 0;
01322
01323 st = wxString::Format( _("%.02f"), m_TORGB_xblue );
01324 m_TORGB_xblueText->SetValue( st );
01325 int val = (int)(( FLOAT_SLIDER_RES / TORGB_XBLUE_RANGE ) * (m_TORGB_xblue));
01326 m_TORGB_xblueSlider->SetValue( val );
01327 UpdateParam(LUX_FILM, LUX_FILM_TORGB_X_BLUE, m_TORGB_xblue);
01328 if(m_auto_tonemap) ApplyTonemapping();
01329 }
01330 break;
01331 case ID_TORGB_YBLUE_TEXT:
01332 if ( m_TORGB_yblueText->IsModified() )
01333 {
01334 wxString st = m_TORGB_yblueText->GetValue();
01335 st.ToDouble( &m_TORGB_yblue );
01336
01337 if ( m_TORGB_yblue > TORGB_YBLUE_RANGE ) m_TORGB_yblue = TORGB_YBLUE_RANGE;
01338 else if ( m_TORGB_yblue < 0 ) m_TORGB_yblue = 0;
01339
01340 st = wxString::Format( _("%.02f"), m_TORGB_yblue );
01341 m_TORGB_yblueText->SetValue( st );
01342 int val = (int)(( FLOAT_SLIDER_RES / TORGB_YBLUE_RANGE ) * (m_TORGB_yblue));
01343 m_TORGB_yblueSlider->SetValue( val );
01344 UpdateParam(LUX_FILM, LUX_FILM_TORGB_Y_BLUE, m_TORGB_yblue);
01345 if(m_auto_tonemap) ApplyTonemapping();
01346 }
01347 break;
01348
01349
01350 case ID_TORGB_GAMMA_TEXT:
01351 if ( m_TORGB_gammaText->IsModified() )
01352 {
01353 wxString st = m_TORGB_gammaText->GetValue();
01354 st.ToDouble( &m_TORGB_gamma );
01355
01356 if ( m_TORGB_gamma > TORGB_GAMMA_RANGE ) m_TORGB_gamma = TORGB_GAMMA_RANGE;
01357 else if ( m_TORGB_gamma < 0 ) m_TORGB_gamma = 0;
01358
01359 st = wxString::Format( _("%.02f"), m_TORGB_gamma );
01360 m_TORGB_gammaText->SetValue( st );
01361 int val = (int)(( FLOAT_SLIDER_RES / TORGB_GAMMA_RANGE ) * (m_TORGB_gamma));
01362 m_TORGB_gammaSlider->SetValue( val );
01363 UpdateParam(LUX_FILM, LUX_FILM_TORGB_GAMMA, m_TORGB_gamma);
01364 if(m_auto_tonemap) ApplyTonemapping();
01365 }
01366 break;
01367
01368
01369 case ID_BLOOMRADIUS_TEXT:
01370 if ( m_bloomradiusText->IsModified() )
01371 {
01372 wxString st = m_bloomradiusText->GetValue();
01373 st.ToDouble( &m_bloomradius );
01374
01375 if ( m_bloomradius > BLOOMRADIUS_RANGE ) m_bloomradius = BLOOMRADIUS_RANGE;
01376 else if ( m_bloomradius < 0 ) m_bloomradius = 0;
01377
01378 st = wxString::Format( _("%.02f"), m_bloomradius );
01379 m_bloomradiusText->SetValue( st );
01380 int val = (int)(( FLOAT_SLIDER_RES / BLOOMRADIUS_RANGE ) * (m_bloomradius));
01381 m_bloomradiusSlider->SetValue( val );
01382 UpdateParam(LUX_FILM, LUX_FILM_BLOOMRADIUS, m_bloomradius);
01383 }
01384 break;
01385 case ID_BLOOMWEIGHT_TEXT:
01386 if ( m_bloomweightText->IsModified() )
01387 {
01388 wxString st = m_bloomweightText->GetValue();
01389 st.ToDouble( &m_bloomweight );
01390
01391 if ( m_bloomweight > BLOOMWEIGHT_RANGE ) m_bloomweight = BLOOMWEIGHT_RANGE;
01392 else if ( m_bloomweight < 0 ) m_bloomweight = 0;
01393
01394 st = wxString::Format( _("%.02f"), m_bloomweight );
01395 m_bloomweightText->SetValue( st );
01396 int val = (int)(( FLOAT_SLIDER_RES / BLOOMWEIGHT_RANGE ) * (m_bloomweight));
01397 m_bloomweightSlider->SetValue( val );
01398 UpdateParam(LUX_FILM, LUX_FILM_BLOOMWEIGHT, m_bloomweight);
01399 if(m_auto_tonemap) ApplyTonemapping();
01400 }
01401 break;
01402
01403
01404 case ID_VIGNETTINGAMOUNT_TEXT:
01405 if ( m_vignettingamountText->IsModified() )
01406 {
01407 wxString st = m_vignettingamountText->GetValue();
01408 st.ToDouble( &m_Vignetting_Scale );
01409
01410 if ( m_Vignetting_Scale > VIGNETTING_SCALE_RANGE ) m_Vignetting_Scale = VIGNETTING_SCALE_RANGE;
01411 else if ( VIGNETTING_SCALE_RANGE < -VIGNETTING_SCALE_RANGE ) m_Vignetting_Scale = -VIGNETTING_SCALE_RANGE;
01412
01413 st = wxString::Format( _("%.02f"), m_Vignetting_Scale );
01414 m_vignettingamountText->SetValue( st );
01415 int val;
01416 if ( m_Vignetting_Scale >= 0.f )
01417 val = (int) (FLOAT_SLIDER_RES/2) + (( (FLOAT_SLIDER_RES/2) / VIGNETTING_SCALE_RANGE ) * (m_Vignetting_Scale));
01418 else {
01419 val = (int)(( FLOAT_SLIDER_RES/2 * VIGNETTING_SCALE_RANGE ) * (1.f - fabsf(m_Vignetting_Scale)));
01420 }
01421 m_vignettingamountSlider->SetValue( val );
01422 UpdateParam(LUX_FILM, LUX_FILM_VIGNETTING_SCALE, m_Vignetting_Scale);
01423 if(m_auto_tonemap) ApplyTonemapping();
01424 }
01425 break;
01426
01427
01428 case ID_ABERRATIONAMOUNT_TEXT:
01429 if ( m_aberrationamountText->IsModified() )
01430 {
01431 wxString st = m_aberrationamountText->GetValue();
01432 st.ToDouble( &m_Aberration_amount );
01433
01434 if ( m_Aberration_amount > ABERRATION_AMOUNT_RANGE )
01435 m_Aberration_amount = ABERRATION_AMOUNT_RANGE;
01436 else if ( m_Aberration_amount < 0 )
01437 m_Aberration_amount = 0;
01438
01439 st = wxString::Format( _("%.02f"), m_Aberration_amount );
01440 m_aberrationamountText->SetValue( st );
01441 int val = (int) (( FLOAT_SLIDER_RES / ABERRATION_AMOUNT_RANGE ) * (m_Aberration_amount));
01442 m_aberrationamountSlider->SetValue( val );
01443 UpdateParam(LUX_FILM, LUX_FILM_ABERRATION_AMOUNT, ABERRATION_AMOUNT_FACTOR * m_Aberration_amount);
01444 if(m_auto_tonemap && m_Aberration_enabled) ApplyTonemapping();
01445 }
01446 break;
01447
01448
01449 case ID_GLAREAMOUNT_TEXT:
01450 if ( m_glareamountText->IsModified() )
01451 {
01452 wxString st = m_glareamountText->GetValue();
01453 st.ToDouble( &m_Glare_amount );
01454
01455 if ( m_Glare_amount > GLARE_AMOUNT_RANGE )
01456 m_Glare_amount = GLARE_AMOUNT_RANGE;
01457 else if ( m_Glare_amount < 0 )
01458 m_Glare_amount = 0;
01459
01460 st = wxString::Format( _("%.02f"), m_Glare_amount );
01461 m_glareamountText->SetValue( st );
01462 int val = (int) (( FLOAT_SLIDER_RES / GLARE_AMOUNT_RANGE ) * (m_Glare_amount));
01463 m_glareamountSlider->SetValue( val );
01464 UpdateParam(LUX_FILM, LUX_FILM_GLARE_AMOUNT, m_Glare_amount);
01465 if(m_auto_tonemap) ApplyTonemapping();
01466 }
01467 break;
01468 case ID_GLARERADIUS_TEXT:
01469 if ( m_glareradiusText->IsModified() )
01470 {
01471 wxString st = m_glareradiusText->GetValue();
01472 st.ToDouble( &m_Glare_radius );
01473
01474 if ( m_Glare_radius > GLARE_RADIUS_RANGE )
01475 m_Glare_radius = GLARE_RADIUS_RANGE;
01476 else if ( m_Glare_radius < 0 )
01477 m_Glare_radius = 0;
01478
01479 st = wxString::Format( _("%.02f"), m_Glare_radius );
01480 m_glareradiusText->SetValue( st );
01481 int val = (int) (( FLOAT_SLIDER_RES / GLARE_RADIUS_RANGE ) * (m_Glare_radius));
01482 m_glareradiusSlider->SetValue( val );
01483 UpdateParam(LUX_FILM, LUX_FILM_GLARE_RADIUS, m_Glare_radius);
01484 }
01485 break;
01486
01487
01488 case ID_GREYC_ITERATIONS_TEXT:
01489 if ( m_greyc_iterationsText->IsModified() )
01490 {
01491 wxString st = m_greyc_iterationsText->GetValue();
01492 st.ToDouble( &m_GREYC_nb_iter );
01493
01494 if ( m_GREYC_nb_iter > GREYC_NB_ITER_RANGE ) m_GREYC_nb_iter = GREYC_NB_ITER_RANGE;
01495 else if ( m_GREYC_nb_iter < 1 ) m_GREYC_nb_iter = 1;
01496
01497 st = wxString::Format( _("%.02f"), m_GREYC_nb_iter );
01498 m_greyc_iterationsText->SetValue( st );
01499 int val = (int) m_GREYC_nb_iter;
01500 m_greyc_iterationsSlider->SetValue( val );
01501 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_NBITER, m_GREYC_nb_iter);
01502 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
01503 }
01504 break;
01505 case ID_GREYC_AMPLITUDE_TEXT:
01506 if ( m_greyc_amplitudeText->IsModified() )
01507 {
01508 wxString st = m_greyc_amplitudeText->GetValue();
01509 st.ToDouble( &m_GREYC_amplitude );
01510
01511 if ( m_GREYC_amplitude > GREYC_AMPLITUDE_RANGE ) m_GREYC_amplitude = GREYC_AMPLITUDE_RANGE;
01512 else if ( m_GREYC_amplitude < 0 ) m_GREYC_amplitude = 0;
01513
01514 st = wxString::Format( _("%.02f"), m_GREYC_amplitude );
01515 m_greyc_amplitudeText->SetValue( st );
01516 int val = (int)(( FLOAT_SLIDER_RES / GREYC_AMPLITUDE_RANGE ) * (m_GREYC_amplitude));
01517 m_greyc_amplitudeSlider->SetValue( val );
01518 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_AMPLITUDE, m_GREYC_amplitude);
01519 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
01520 }
01521 break;
01522 case ID_GREYC_GAUSSPREC_TEXT:
01523 if ( m_greyc_gaussprecText->IsModified() )
01524 {
01525 wxString st = m_greyc_gaussprecText->GetValue();
01526 st.ToDouble( &m_GREYC_gauss_prec );
01527
01528 if ( m_GREYC_gauss_prec > GREYC_GAUSSPREC_RANGE ) m_GREYC_gauss_prec = GREYC_GAUSSPREC_RANGE;
01529 else if ( m_GREYC_gauss_prec < 0 ) m_GREYC_gauss_prec = 0;
01530
01531 st = wxString::Format( _("%.02f"), m_GREYC_gauss_prec );
01532 m_greyc_gaussprecText->SetValue( st );
01533 int val = (int)(( FLOAT_SLIDER_RES / GREYC_GAUSSPREC_RANGE ) * (m_GREYC_gauss_prec));
01534 m_greyc_gausprecSlider->SetValue( val );
01535 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_GAUSSPREC, m_GREYC_gauss_prec);
01536 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
01537 }
01538 break;
01539 case ID_GREYC_ALPHA_TEXT:
01540 if ( m_greyc_alphaText->IsModified() )
01541 {
01542 wxString st = m_greyc_alphaText->GetValue();
01543 st.ToDouble( &m_GREYC_alpha );
01544
01545 if ( m_GREYC_alpha > GREYC_ALPHA_RANGE ) m_GREYC_alpha = GREYC_ALPHA_RANGE;
01546 else if ( m_GREYC_alpha < 0 ) m_GREYC_alpha = 0;
01547
01548 st = wxString::Format( _("%.02f"), m_GREYC_alpha );
01549 m_greyc_alphaText->SetValue( st );
01550 int val = (int)(( FLOAT_SLIDER_RES / GREYC_ALPHA_RANGE ) * (m_GREYC_alpha));
01551 m_greyc_alphaSlider->SetValue( val );
01552 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_ALPHA, m_GREYC_alpha);
01553 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
01554 }
01555 break;
01556 case ID_GREYC_SIGMA_TEXT:
01557 if ( m_greyc_sigmaText->IsModified() )
01558 {
01559 wxString st = m_greyc_sigmaText->GetValue();
01560 st.ToDouble( &m_GREYC_sigma );
01561
01562 if ( m_GREYC_sigma > GREYC_SIGMA_RANGE ) m_GREYC_sigma = GREYC_SIGMA_RANGE;
01563 else if ( m_GREYC_sigma < 0 ) m_GREYC_sigma = 0;
01564
01565 st = wxString::Format( _("%.02f"), m_GREYC_sigma );
01566 m_greyc_sigmaText->SetValue( st );
01567 int val = (int)(( FLOAT_SLIDER_RES / GREYC_SIGMA_RANGE ) * (m_GREYC_sigma));
01568 m_greyc_sigmaSlider->SetValue( val );
01569 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_SIGMA, m_GREYC_sigma);
01570 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
01571 }
01572 break;
01573 case ID_GREYC_SHARPNESS_TEXT:
01574 if ( m_greyc_sharpnessText->IsModified() )
01575 {
01576 wxString st = m_greyc_sharpnessText->GetValue();
01577 st.ToDouble( &m_GREYC_sharpness );
01578
01579 if ( m_GREYC_sharpness > GREYC_SHARPNESS_RANGE ) m_GREYC_sharpness = GREYC_SHARPNESS_RANGE;
01580 else if ( m_GREYC_sharpness < 0 ) m_GREYC_sharpness = 0;
01581
01582 st = wxString::Format( _("%.02f"), m_GREYC_sharpness );
01583 m_greyc_sharpnessText->SetValue( st );
01584 int val = (int)(( FLOAT_SLIDER_RES / GREYC_SHARPNESS_RANGE ) * (m_GREYC_sharpness));
01585 m_greyc_sharpnessSlider->SetValue( val );
01586 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_SHARPNESS, m_GREYC_sharpness);
01587 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
01588 }
01589 break;
01590 case ID_GREYC_ANISO_TEXT:
01591 if ( m_greyc_anisoText->IsModified() )
01592 {
01593 wxString st = m_greyc_anisoText->GetValue();
01594 st.ToDouble( &m_GREYC_anisotropy );
01595
01596 if ( m_GREYC_anisotropy > GREYC_ANISOTROPY_RANGE ) m_GREYC_anisotropy = GREYC_ANISOTROPY_RANGE;
01597 else if ( m_GREYC_anisotropy < 0 ) m_GREYC_anisotropy = 0;
01598
01599 st = wxString::Format( _("%.02f"), m_GREYC_anisotropy );
01600 m_greyc_anisoText->SetValue( st );
01601 int val = (int)(( FLOAT_SLIDER_RES / GREYC_ANISOTROPY_RANGE ) * (m_GREYC_anisotropy));
01602 m_greyc_anisoSlider->SetValue( val );
01603 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_ANISOTROPY, m_GREYC_anisotropy);
01604 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
01605 }
01606 break;
01607 case ID_GREYC_SPATIAL_TEXT:
01608 if ( m_greyc_spatialText->IsModified() )
01609 {
01610 wxString st = m_greyc_spatialText->GetValue();
01611 st.ToDouble( &m_GREYC_dl );
01612
01613 if ( m_GREYC_dl > GREYC_DL_RANGE ) m_GREYC_dl = GREYC_DL_RANGE;
01614 else if ( m_GREYC_dl < 0 ) m_GREYC_dl = 0;
01615
01616 st = wxString::Format( _("%.02f"), m_GREYC_dl );
01617 m_greyc_spatialText->SetValue( st );
01618 int val = (int)(( FLOAT_SLIDER_RES / GREYC_DL_RANGE ) * (m_GREYC_dl));
01619 m_greyc_spatialSlider->SetValue( val );
01620 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_DL, m_GREYC_dl);
01621 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
01622 }
01623 break;
01624 case ID_GREYC_ANGULAR_TEXT:
01625 if ( m_greyc_angularText->IsModified() )
01626 {
01627 wxString st = m_greyc_angularText->GetValue();
01628 st.ToDouble( &m_GREYC_da );
01629
01630 if ( m_GREYC_da > GREYC_DA_RANGE ) m_GREYC_da = GREYC_DA_RANGE;
01631 else if ( m_GREYC_da < 0 ) m_GREYC_da = 0;
01632
01633 st = wxString::Format( _("%.02f"), m_GREYC_da );
01634 m_greyc_angularText->SetValue( st );
01635 int val = (int)(( FLOAT_SLIDER_RES / GREYC_DA_RANGE ) * (m_GREYC_da));
01636 m_greyc_angularSlider->SetValue( val );
01637 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_DA, m_GREYC_da);
01638 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
01639 }
01640 break;
01641 case ID_CHIU_RADIUS_TEXT:
01642 if ( m_chiu_radiusText->IsModified() )
01643 {
01644 wxString st = m_chiu_radiusText->GetValue();
01645 st.ToDouble( &m_Chiu_radius );
01646
01647 if ( m_Chiu_radius > CHIU_RADIUS_MAX ) m_Chiu_radius = CHIU_RADIUS_MAX;
01648 else if ( m_Chiu_radius < CHIU_RADIUS_MIN ) m_Chiu_radius = CHIU_RADIUS_MIN;
01649
01650 st = wxString::Format( _("%.02f"), m_Chiu_radius );
01651 m_chiu_radiusText->SetValue( st );
01652 int val = (int)(( FLOAT_SLIDER_RES / (CHIU_RADIUS_MAX - CHIU_RADIUS_MIN) ) * (m_Chiu_radius - CHIU_RADIUS_MIN) );
01653 m_chiu_radiusSlider->SetValue( val );
01654 UpdateParam(LUX_FILM, LUX_FILM_NOISE_CHIU_RADIUS, m_Chiu_radius);
01655 if(m_auto_tonemap && m_Chiu_enabled) ApplyTonemapping();
01656 }
01657 break;
01658 case ID_SERVER_TEXT:
01659 AddServer();
01660 break;
01661 default:
01662 break;
01663 }
01664 }
01665
01666 void LuxGui::OnCheckBox(wxCommandEvent& event)
01667 {
01668
01669 }
01670
01671 void LuxGui::OnColourChanged(wxColourPickerEvent &event)
01672 {
01673 }
01674
01675 void LuxGui::OnScroll( wxScrollEvent& event ){
01676 switch (event.GetId()) {
01677
01678 case ID_TM_REINHARD_PRESCALE:
01679 {
01680 m_TM_reinhard_prescale = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / TM_REINHARD_PRESCALE_RANGE );
01681 wxString st = wxString::Format( _("%.02f"), m_TM_reinhard_prescale );
01682 m_TM_Reinhard_prescaleText->SetValue( st );
01683 UpdateParam(LUX_FILM, LUX_FILM_TM_REINHARD_PRESCALE, m_TM_reinhard_prescale);
01684 if(m_auto_tonemap) ApplyTonemapping();
01685 }
01686 break;
01687 case ID_TM_REINHARD_POSTSCALE:
01688 {
01689 m_TM_reinhard_postscale = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / TM_REINHARD_POSTSCALE_RANGE );
01690 wxString st = wxString::Format( _("%.02f"), m_TM_reinhard_postscale );
01691 m_TM_Reinhard_postscaleText->SetValue( st );
01692 UpdateParam(LUX_FILM, LUX_FILM_TM_REINHARD_POSTSCALE, m_TM_reinhard_postscale);
01693 if(m_auto_tonemap) ApplyTonemapping();
01694 }
01695 break;
01696 case ID_TM_REINHARD_BURN:
01697 {
01698 m_TM_reinhard_burn = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / TM_REINHARD_BURN_RANGE );
01699 wxString st = wxString::Format( _("%.02f"), m_TM_reinhard_burn );
01700 m_TM_Reinhard_burnText->SetValue( st );
01701 UpdateParam(LUX_FILM, LUX_FILM_TM_REINHARD_BURN, m_TM_reinhard_burn);
01702 if(m_auto_tonemap) ApplyTonemapping();
01703 }
01704 break;
01705
01706
01707 case ID_TM_LINEAR_SENSITIVITY:
01708 {
01709 m_TM_linear_sensitivity = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / TM_LINEAR_SENSITIVITY_RANGE );
01710 wxString st = wxString::Format( _("%.02f"), m_TM_linear_sensitivity );
01711 m_TM_Linear_sensitivityText->SetValue( st );
01712 UpdateParam(LUX_FILM, LUX_FILM_TM_LINEAR_SENSITIVITY, m_TM_linear_sensitivity);
01713 if(m_auto_tonemap) ApplyTonemapping();
01714 }
01715 break;
01716 case ID_TM_LINEAR_EXPOSURE:
01717 {
01718 m_TM_linear_exposure = LogSliderValToValue(event.GetPosition(), TM_LINEAR_EXPOSURE_LOG_MIN, TM_LINEAR_EXPOSURE_LOG_MAX);
01719 wxString st = wxString::Format( _("%.02f"), m_TM_linear_exposure );
01720 m_TM_Linear_exposureText->SetValue( st );
01721 UpdateParam(LUX_FILM, LUX_FILM_TM_LINEAR_EXPOSURE, m_TM_linear_exposure);
01722 if(m_auto_tonemap) ApplyTonemapping();
01723 }
01724 break;
01725 case ID_TM_LINEAR_FSTOP:
01726 {
01727 m_TM_linear_fstop = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / TM_LINEAR_FSTOP_RANGE );
01728 wxString st = wxString::Format( _("%.02f"), m_TM_linear_fstop );
01729 m_TM_Linear_fstopText->SetValue( st );
01730 UpdateParam(LUX_FILM, LUX_FILM_TM_LINEAR_FSTOP, m_TM_linear_fstop);
01731 if(m_auto_tonemap) ApplyTonemapping();
01732 }
01733 break;
01734 case ID_TM_LINEAR_GAMMA:
01735 {
01736 m_TM_linear_gamma = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / TM_LINEAR_GAMMA_RANGE );
01737 wxString st = wxString::Format( _("%.02f"), m_TM_linear_gamma );
01738 m_TM_Linear_gammaText->SetValue( st );
01739 UpdateParam(LUX_FILM, LUX_FILM_TM_LINEAR_GAMMA, m_TM_linear_gamma);
01740 if(m_auto_tonemap) ApplyTonemapping();
01741 }
01742 break;
01743
01744
01745 case ID_TM_CONTRAST_YWA:
01746 {
01747 m_TM_contrast_ywa = LogSliderValToValue(event.GetPosition(), TM_CONTRAST_YWA_LOG_MIN, TM_CONTRAST_YWA_LOG_MAX);
01748 wxString st = wxString::Format( _("%.02f"), m_TM_contrast_ywa );
01749 m_TM_contrast_ywaText->SetValue( st );
01750 UpdateParam(LUX_FILM, LUX_FILM_TM_CONTRAST_YWA, m_TM_contrast_ywa);
01751 if(m_auto_tonemap) ApplyTonemapping();
01752 }
01753 break;
01754
01755
01756 case ID_TORGB_XWHITE:
01757 {
01758 m_TORGB_xwhite = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / TORGB_XWHITE_RANGE );
01759 wxString st = wxString::Format( _("%.02f"), m_TORGB_xwhite );
01760 m_TORGB_xwhiteText->SetValue( st );
01761 UpdateParam(LUX_FILM, LUX_FILM_TORGB_X_WHITE, m_TORGB_xwhite);
01762 if(m_auto_tonemap) ApplyTonemapping();
01763 }
01764 break;
01765 case ID_TORGB_YWHITE:
01766 {
01767 m_TORGB_ywhite = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / TORGB_YWHITE_RANGE );
01768 wxString st = wxString::Format( _("%.02f"), m_TORGB_ywhite );
01769 m_TORGB_ywhiteText->SetValue( st );
01770 UpdateParam(LUX_FILM, LUX_FILM_TORGB_Y_WHITE, m_TORGB_ywhite);
01771 if(m_auto_tonemap) ApplyTonemapping();
01772 }
01773 break;
01774 case ID_TORGB_XRED:
01775 {
01776 m_TORGB_xred = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / TORGB_XRED_RANGE );
01777 wxString st = wxString::Format( _("%.02f"), m_TORGB_xred );
01778 m_TORGB_xredText->SetValue( st );
01779 UpdateParam(LUX_FILM, LUX_FILM_TORGB_X_RED, m_TORGB_xred);
01780 if(m_auto_tonemap) ApplyTonemapping();
01781 }
01782 break;
01783 case ID_TORGB_YRED:
01784 {
01785 m_TORGB_yred = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / TORGB_YRED_RANGE );
01786 wxString st = wxString::Format( _("%.02f"), m_TORGB_yred );
01787 m_TORGB_yredText->SetValue( st );
01788 UpdateParam(LUX_FILM, LUX_FILM_TORGB_Y_RED, m_TORGB_yred);
01789 if(m_auto_tonemap) ApplyTonemapping();
01790 }
01791 break;
01792 case ID_TORGB_XGREEN:
01793 {
01794 m_TORGB_xgreen = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / TORGB_XGREEN_RANGE );
01795 wxString st = wxString::Format( _("%.02f"), m_TORGB_xgreen );
01796 m_TORGB_xgreenText->SetValue( st );
01797 UpdateParam(LUX_FILM, LUX_FILM_TORGB_X_GREEN, m_TORGB_xgreen);
01798 if(m_auto_tonemap) ApplyTonemapping();
01799 }
01800 break;
01801 case ID_TORGB_YGREEN:
01802 {
01803 m_TORGB_ygreen = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / TORGB_YGREEN_RANGE );
01804 wxString st = wxString::Format( _("%.02f"), m_TORGB_ygreen );
01805 m_TORGB_ygreenText->SetValue( st );
01806 UpdateParam(LUX_FILM, LUX_FILM_TORGB_Y_GREEN, m_TORGB_ygreen);
01807 if(m_auto_tonemap) ApplyTonemapping();
01808 }
01809 break;
01810 case ID_TORGB_XBLUE:
01811 {
01812 m_TORGB_xblue = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / TORGB_XBLUE_RANGE );
01813 wxString st = wxString::Format( _("%.02f"), m_TORGB_xblue );
01814 m_TORGB_xblueText->SetValue( st );
01815 UpdateParam(LUX_FILM, LUX_FILM_TORGB_X_BLUE, m_TORGB_xblue);
01816 if(m_auto_tonemap) ApplyTonemapping();
01817 }
01818 break;
01819 case ID_TORGB_YBLUE:
01820 {
01821 m_TORGB_yblue = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / TORGB_YBLUE_RANGE );
01822 wxString st = wxString::Format( _("%.02f"), m_TORGB_yblue );
01823 m_TORGB_yblueText->SetValue( st );
01824 UpdateParam(LUX_FILM, LUX_FILM_TORGB_Y_BLUE, m_TORGB_yblue);
01825 if(m_auto_tonemap) ApplyTonemapping();
01826 }
01827 break;
01828 case ID_TORGB_GAMMA:
01829 {
01830 m_TORGB_gamma = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / TORGB_GAMMA_RANGE );
01831 wxString st = wxString::Format( _("%.02f"), m_TORGB_gamma );
01832 m_TORGB_gammaText->SetValue( st );
01833 UpdateParam(LUX_FILM, LUX_FILM_TORGB_GAMMA, m_TORGB_gamma);
01834 if(m_auto_tonemap) ApplyTonemapping();
01835 }
01836 break;
01837
01838
01839 case ID_BLOOMRADIUS:
01840 {
01841 m_bloomradius = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / BLOOMRADIUS_RANGE );
01842 wxString st = wxString::Format( _("%.02f"), m_bloomradius );
01843 m_bloomradiusText->SetValue( st );
01844 UpdateParam(LUX_FILM, LUX_FILM_BLOOMRADIUS, m_bloomradius);
01845 }
01846 break;
01847 case ID_BLOOMWEIGHT:
01848 {
01849 m_bloomweight = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / BLOOMWEIGHT_RANGE );
01850 wxString st = wxString::Format( _("%.02f"), m_bloomweight );
01851 m_bloomweightText->SetValue( st );
01852 UpdateParam(LUX_FILM, LUX_FILM_BLOOMWEIGHT, m_bloomweight);
01853 if(m_auto_tonemap) ApplyTonemapping();
01854 }
01855 break;
01856
01857
01858 case ID_VIGNETTINGAMOUNT:
01859 {
01860 double pos = (double)event.GetPosition() / FLOAT_SLIDER_RES;
01861 pos -= 0.5f;
01862 pos *= VIGNETTING_SCALE_RANGE * 2.f;
01863 m_Vignetting_Scale = pos;
01864 wxString st = wxString::Format( _("%.02f"), m_Vignetting_Scale );
01865 m_vignettingamountText->SetValue( st );
01866 UpdateParam(LUX_FILM, LUX_FILM_VIGNETTING_SCALE, m_Vignetting_Scale);
01867 if(m_auto_tonemap) ApplyTonemapping();
01868 }
01869 break;
01870
01871
01872 case ID_ABERRATIONAMOUNT:
01873 {
01874 double pos = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / ABERRATION_AMOUNT_RANGE );
01875 m_Aberration_amount = pos;
01876 wxString st = wxString::Format( _("%.02f"), m_Aberration_amount );
01877 m_aberrationamountText->SetValue( st );
01878 UpdateParam(LUX_FILM, LUX_FILM_ABERRATION_AMOUNT, ABERRATION_AMOUNT_FACTOR * m_Aberration_amount);
01879 if(m_auto_tonemap && m_Aberration_enabled) ApplyTonemapping();
01880 }
01881 break;
01882
01883
01884 case ID_GLAREAMOUNT:
01885 {
01886 double pos = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / GLARE_AMOUNT_RANGE );
01887 m_Glare_amount = pos;
01888 wxString st = wxString::Format( _("%.02f"), m_Glare_amount );
01889 m_glareamountText->SetValue( st );
01890 UpdateParam(LUX_FILM, LUX_FILM_GLARE_AMOUNT, m_Glare_amount);
01891 if(m_auto_tonemap) ApplyTonemapping();
01892 }
01893 break;
01894 case ID_GLARERADIUS:
01895 {
01896 double pos = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / GLARE_RADIUS_RANGE );
01897 m_Glare_radius = pos;
01898 wxString st = wxString::Format( _("%.02f"), m_Glare_radius );
01899 m_glareradiusText->SetValue( st );
01900 UpdateParam(LUX_FILM, LUX_FILM_GLARE_RADIUS, m_Glare_radius);
01901 if(m_auto_tonemap) ApplyTonemapping();
01902 }
01903 break;
01904
01905
01906 case ID_GREYC_ITERATIONS:
01907 {
01908 m_GREYC_nb_iter = (double)event.GetPosition();
01909 wxString st = wxString::Format( _("%.02f"), m_GREYC_nb_iter );
01910 m_greyc_iterationsText->SetValue( st );
01911 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_NBITER, m_GREYC_nb_iter);
01912 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
01913
01914 }
01915 break;
01916 case ID_GREYC_AMPLITUDE:
01917 {
01918 m_GREYC_amplitude = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / GREYC_AMPLITUDE_RANGE );
01919 wxString st = wxString::Format( _("%.02f"), m_GREYC_amplitude );
01920 m_greyc_amplitudeText->SetValue( st );
01921 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_AMPLITUDE, m_GREYC_amplitude);
01922 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
01923
01924 }
01925 break;
01926 case ID_GREYC_GAUSSPREC:
01927 {
01928 m_GREYC_gauss_prec = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / GREYC_GAUSSPREC_RANGE );
01929 wxString st = wxString::Format( _("%.02f"), m_GREYC_gauss_prec );
01930 m_greyc_gaussprecText->SetValue( st );
01931 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_GAUSSPREC, m_GREYC_gauss_prec);
01932 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
01933
01934 }
01935 break;
01936 case ID_GREYC_ALPHA:
01937 {
01938 m_GREYC_alpha = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / GREYC_ALPHA_RANGE );
01939 wxString st = wxString::Format( _("%.02f"), m_GREYC_alpha );
01940 m_greyc_alphaText->SetValue( st );
01941 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_ALPHA, m_GREYC_alpha);
01942 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
01943
01944 }
01945 break;
01946 case ID_GREYC_SIGMA:
01947 {
01948 m_GREYC_sigma = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / GREYC_SIGMA_RANGE );
01949 wxString st = wxString::Format( _("%.02f"), m_GREYC_sigma );
01950 m_greyc_sigmaText->SetValue( st );
01951 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_SIGMA, m_GREYC_sigma);
01952 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
01953
01954 }
01955 break;
01956 case ID_GREYC_SHARPNESS:
01957 {
01958 m_GREYC_sharpness = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / GREYC_SHARPNESS_RANGE );
01959 wxString st = wxString::Format( _("%.02f"), m_GREYC_sharpness );
01960 m_greyc_sharpnessText->SetValue( st );
01961 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_SHARPNESS, m_GREYC_sharpness);
01962 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
01963
01964 }
01965 break;
01966 case ID_GREYC_ANISO:
01967 {
01968 m_GREYC_anisotropy = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / GREYC_ANISOTROPY_RANGE );
01969 wxString st = wxString::Format( _("%.02f"), m_GREYC_anisotropy );
01970 m_greyc_anisoText->SetValue( st );
01971 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_ANISOTROPY, m_GREYC_anisotropy);
01972 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
01973
01974 }
01975 break;
01976 case ID_GREYC_SPATIAL:
01977 {
01978 m_GREYC_dl = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / GREYC_DL_RANGE );
01979 wxString st = wxString::Format( _("%.02f"), m_GREYC_dl );
01980 m_greyc_spatialText->SetValue( st );
01981 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_DL, m_GREYC_dl);
01982 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
01983
01984 }
01985 break;
01986 case ID_GREYC_ANGULAR:
01987 {
01988 m_GREYC_da = (double)event.GetPosition() / ( FLOAT_SLIDER_RES / GREYC_DA_RANGE );
01989 wxString st = wxString::Format( _("%.02f"), m_GREYC_da );
01990 m_greyc_angularText->SetValue( st );
01991 UpdateParam(LUX_FILM, LUX_FILM_NOISE_GREYC_DA, m_GREYC_da);
01992 if(m_auto_tonemap && m_GREYC_enabled) ApplyTonemapping();
01993
01994 }
01995 break;
01996
01997 case ID_CHIU_RADIUS:
01998 {
01999 m_Chiu_radius = (double)event.GetPosition() / (FLOAT_SLIDER_RES / (CHIU_RADIUS_MAX - CHIU_RADIUS_MIN)) + CHIU_RADIUS_MIN;
02000 wxString st = wxString::Format( _("%.02f"), m_Chiu_radius );
02001 m_chiu_radiusText->SetValue( st );
02002 UpdateParam(LUX_FILM, LUX_FILM_NOISE_CHIU_RADIUS, m_Chiu_radius);
02003 if(m_auto_tonemap && m_Chiu_enabled) ApplyTonemapping();
02004
02005 }
02006 break;
02007 default:
02008 break;
02009 }
02010 }
02011
02012 void LuxGui::OnFocus( wxFocusEvent& event ){
02013
02014 if( event.GetEventType() != wxEVT_KILL_FOCUS ) return;
02015
02016 switch (event.GetId()) {
02017
02018 case ID_TM_REINHARD_PRESCALE_TEXT:
02019 m_TM_Reinhard_prescaleText->SetValue( wxString::Format( _("%.02f"), m_TM_reinhard_prescale ) );
02020 break;
02021 case ID_TM_REINHARD_POSTSCALE_TEXT:
02022 m_TM_Reinhard_postscaleText->SetValue( wxString::Format( _("%.02f"), m_TM_reinhard_postscale ) );
02023 break;
02024 case ID_TM_REINHARD_BURN_TEXT:
02025 m_TM_Reinhard_burnText->SetValue( wxString::Format( _("%.02f"), m_TM_reinhard_burn ) );
02026 break;
02027
02028 case ID_TM_LINEAR_SENSITIVITY_TEXT:
02029 m_TM_Linear_sensitivityText->SetValue( wxString::Format( _("%.02f"), m_TM_linear_sensitivity ) );
02030 break;
02031 case ID_TM_LINEAR_EXPOSURE_TEXT:
02032 m_TM_Linear_exposureText->SetValue( wxString::Format( _("%.02f"), m_TM_linear_exposure ) );
02033 break;
02034 case ID_TM_LINEAR_FSTOP_TEXT:
02035 m_TM_Linear_fstopText->SetValue( wxString::Format( _("%.02f"), m_TM_linear_fstop ) );
02036 break;
02037 case ID_TM_LINEAR_GAMMA_TEXT:
02038 m_TM_Linear_gammaText->SetValue( wxString::Format( _("%.02f"), m_TM_linear_gamma ) );
02039 break;
02040
02041 case ID_TM_CONTRAST_YWA_TEXT:
02042 m_TM_contrast_ywaText->SetValue( wxString::Format( _("%.02f"), m_TM_contrast_ywa ) );
02043 break;
02044
02045 case ID_TORGB_XWHITE_TEXT:
02046 m_TORGB_xwhiteText->SetValue( wxString::Format( _("%.02f"), m_TORGB_xwhite ) );
02047 break;
02048 case ID_TORGB_YWHITE_TEXT:
02049 m_TORGB_ywhiteText->SetValue( wxString::Format( _("%.02f"), m_TORGB_ywhite ) );
02050 break;
02051 case ID_TORGB_XRED_TEXT:
02052 m_TORGB_xredText->SetValue( wxString::Format( _("%.02f"), m_TORGB_xred ) );
02053 break;
02054 case ID_TORGB_YRED_TEXT:
02055 m_TORGB_yredText->SetValue( wxString::Format( _("%.02f"), m_TORGB_yred ) );
02056 break;
02057 case ID_TORGB_XGREEN_TEXT:
02058 m_TORGB_xgreenText->SetValue( wxString::Format( _("%.02f"), m_TORGB_xgreen ) );
02059 break;
02060 case ID_TORGB_YGREEN_TEXT:
02061 m_TORGB_ygreenText->SetValue( wxString::Format( _("%.02f"), m_TORGB_ygreen ) );
02062 break;
02063 case ID_TORGB_XBLUE_TEXT:
02064 m_TORGB_xblueText->SetValue( wxString::Format( _("%.02f"), m_TORGB_xblue ) );
02065 break;
02066 case ID_TORGB_YBLUE_TEXT:
02067 m_TORGB_yblueText->SetValue( wxString::Format( _("%.02f"), m_TORGB_yblue ) );
02068 break;
02069 case ID_TORGB_GAMMA_TEXT:
02070 m_TORGB_gammaText->SetValue( wxString::Format( _("%.02f"), m_TORGB_gamma ) );
02071 break;
02072
02073 case ID_BLOOMRADIUS_TEXT:
02074 m_bloomradiusText->SetValue( wxString::Format( _("%.02f"), m_bloomradius ) );
02075 break;
02076 case ID_BLOOMWEIGHT_TEXT:
02077 m_bloomweightText->SetValue( wxString::Format( _("%.02f"), m_bloomweight ) );
02078 break;
02079
02080 case ID_VIGNETTINGAMOUNT_TEXT:
02081 m_vignettingamountText->SetValue( wxString::Format( _("%.02f"), m_Vignetting_Scale ) );
02082 break;
02083
02084 case ID_ABERRATIONAMOUNT_TEXT:
02085 m_aberrationamountText->SetValue( wxString::Format( _("%.02f"), m_Aberration_amount ) );
02086 break;
02087
02088 case ID_GLAREAMOUNT_TEXT:
02089 m_glareamountText->SetValue( wxString::Format( _("%.02f"), m_Glare_amount ) );
02090 break;
02091 case ID_GLARERADIUS_TEXT:
02092 m_glareradiusText->SetValue( wxString::Format( _("%.02f"), m_Glare_radius ) );
02093 break;
02094
02095 case ID_GREYC_ITERATIONS_TEXT:
02096 m_greyc_iterationsText->SetValue( wxString::Format( _("%.02f"), m_GREYC_nb_iter ) );
02097 break;
02098 case ID_GREYC_AMPLITUDE_TEXT:
02099 m_greyc_amplitudeText->SetValue( wxString::Format( _("%.02f"), m_GREYC_amplitude ) );
02100 break;
02101 case ID_GREYC_GAUSSPREC_TEXT:
02102 m_greyc_gaussprecText->SetValue( wxString::Format( _("%.02f"), m_GREYC_gauss_prec ) );
02103 break;
02104 case ID_GREYC_ALPHA_TEXT:
02105 m_greyc_alphaText->SetValue( wxString::Format( _("%.02f"), m_GREYC_alpha ) );
02106 break;
02107 case ID_GREYC_SIGMA_TEXT:
02108 m_greyc_sigmaText->SetValue( wxString::Format( _("%.02f"), m_GREYC_sigma ) );
02109 break;
02110 case ID_GREYC_SHARPNESS_TEXT:
02111 m_greyc_sharpnessText->SetValue( wxString::Format( _("%.02f"), m_GREYC_sharpness ) );
02112 break;
02113 case ID_GREYC_ANISO_TEXT:
02114 m_greyc_anisoText->SetValue( wxString::Format( _("%.02f"), m_GREYC_anisotropy ) );
02115 break;
02116 case ID_GREYC_SPATIAL_TEXT:
02117 m_greyc_spatialText->SetValue( wxString::Format( _("%.02f"), m_GREYC_dl ) );
02118 break;
02119 case ID_GREYC_ANGULAR_TEXT:
02120 m_greyc_angularText->SetValue( wxString::Format( _("%.02f"), m_GREYC_da ) );
02121 break;
02122 case ID_CHIU_RADIUS_TEXT:
02123 m_chiu_radiusText->SetValue( wxString::Format( _("%0.2f"), m_Chiu_radius ) );
02124 break;
02125 default:
02126 break;
02127 }
02128
02129 }
02130
02131 void LuxGui::SetTonemapKernel(int choice) {
02132 m_TM_kernelChoice->SetSelection(choice);
02133 UpdateParam(LUX_FILM, LUX_FILM_TM_TONEMAPKERNEL, choice);
02134 m_TM_kernel = choice;
02135 switch (choice) {
02136 case 0: {
02137
02138 m_TonemapReinhardOptionsPanel->Show();
02139 m_TonemapLinearOptionsPanel->Hide();
02140 m_TonemapContrastOptionsPanel->Hide(); }
02141 break;
02142 case 1: {
02143
02144 m_TonemapReinhardOptionsPanel->Hide();
02145 m_TonemapLinearOptionsPanel->Show();
02146 m_TonemapContrastOptionsPanel->Hide(); }
02147 break;
02148 case 2: {
02149
02150 m_TonemapReinhardOptionsPanel->Hide();
02151 m_TonemapLinearOptionsPanel->Hide();
02152 m_TonemapContrastOptionsPanel->Show(); }
02153 break;
02154 case 3: {
02155
02156 m_TonemapReinhardOptionsPanel->Hide();
02157 m_TonemapLinearOptionsPanel->Hide();
02158 m_TonemapContrastOptionsPanel->Hide(); }
02159 break;
02160 default:
02161 break;
02162 }
02163 m_Tonemap->GetSizer()->Layout();
02164 m_Tonemap->GetSizer()->FitInside(m_Tonemap);
02165 Refresh();
02166 if(m_auto_tonemap) ApplyTonemapping();
02167 }
02168
02169 void LuxGui::SetColorSpacePreset(int choice) {
02170 m_TORGB_colorspaceChoice->SetSelection(choice);
02171 m_TORGB_whitepointChoice->SetSelection(0);
02172 switch (choice) {
02173 case 0: {
02174
02175 m_TORGB_xwhite = 0.314275f; m_TORGB_ywhite = 0.329411f;
02176 m_TORGB_xred = 0.63f; m_TORGB_yred = 0.34f;
02177 m_TORGB_xgreen = 0.31f; m_TORGB_ygreen = 0.595f;
02178 m_TORGB_xblue = 0.155f; m_TORGB_yblue = 0.07f; }
02179 break;
02180 case 1: {
02181
02182 m_TORGB_xwhite = 0.346f; m_TORGB_ywhite = 0.359f;
02183 m_TORGB_xred = 0.7347f; m_TORGB_yred = 0.2653f;
02184 m_TORGB_xgreen = 0.1596f; m_TORGB_ygreen = 0.8404f;
02185 m_TORGB_xblue = 0.0366f; m_TORGB_yblue = 0.0001f; }
02186 break;
02187 case 2: {
02188
02189 m_TORGB_xwhite = 0.313f; m_TORGB_ywhite = 0.329f;
02190 m_TORGB_xred = 0.64f; m_TORGB_yred = 0.34f;
02191 m_TORGB_xgreen = 0.21f; m_TORGB_ygreen = 0.71f;
02192 m_TORGB_xblue = 0.15f; m_TORGB_yblue = 0.06f; }
02193 break;
02194 case 3: {
02195
02196 m_TORGB_xwhite = 0.313f; m_TORGB_ywhite = 0.329f;
02197 m_TORGB_xred = 0.625f; m_TORGB_yred = 0.34f;
02198 m_TORGB_xgreen = 0.28f; m_TORGB_ygreen = 0.595f;
02199 m_TORGB_xblue = 0.155f; m_TORGB_yblue = 0.07f; }
02200 break;
02201 case 4: {
02202
02203 m_TORGB_xwhite = 0.310f; m_TORGB_ywhite = 0.316f;
02204 m_TORGB_xred = 0.67f; m_TORGB_yred = 0.33f;
02205 m_TORGB_xgreen = 0.21f; m_TORGB_ygreen = 0.71f;
02206 m_TORGB_xblue = 0.14f; m_TORGB_yblue = 0.08f; }
02207 break;
02208 case 5: {
02209
02210 m_TORGB_xwhite = 0.313f; m_TORGB_ywhite = 0.329f;
02211 m_TORGB_xred = 0.63f; m_TORGB_yred = 0.34f;
02212 m_TORGB_xgreen = 0.31f; m_TORGB_ygreen = 0.595f;
02213 m_TORGB_xblue = 0.155f; m_TORGB_yblue = 0.07f; }
02214 break;
02215 case 6: {
02216
02217 m_TORGB_xwhite = 0.313f; m_TORGB_ywhite = 0.329f;
02218 m_TORGB_xred = 0.64f; m_TORGB_yred = 0.33f;
02219 m_TORGB_xgreen = 0.29f; m_TORGB_ygreen = 0.60f;
02220 m_TORGB_xblue = 0.15f; m_TORGB_yblue = 0.06f; }
02221 break;
02222 case 7: {
02223
02224 m_TORGB_xwhite = 0.333f; m_TORGB_ywhite = 0.333f;
02225 m_TORGB_xred = 0.7347f; m_TORGB_yred = 0.2653f;
02226 m_TORGB_xgreen = 0.2738f; m_TORGB_ygreen = 0.7174f;
02227 m_TORGB_xblue = 0.1666f; m_TORGB_yblue = 0.0089f; }
02228 break;
02229 default:
02230 break;
02231 }
02232
02233
02234 UpdateParam(LUX_FILM, LUX_FILM_TORGB_X_WHITE, m_TORGB_xwhite);
02235 UpdateParam(LUX_FILM, LUX_FILM_TORGB_Y_WHITE, m_TORGB_ywhite);
02236 UpdateParam(LUX_FILM, LUX_FILM_TORGB_X_RED, m_TORGB_xred);
02237 UpdateParam(LUX_FILM, LUX_FILM_TORGB_Y_RED, m_TORGB_yred);
02238 UpdateParam(LUX_FILM, LUX_FILM_TORGB_X_GREEN, m_TORGB_xgreen);
02239 UpdateParam(LUX_FILM, LUX_FILM_TORGB_Y_GREEN, m_TORGB_ygreen);
02240 UpdateParam(LUX_FILM, LUX_FILM_TORGB_X_BLUE, m_TORGB_xblue);
02241 UpdateParam(LUX_FILM, LUX_FILM_TORGB_Y_BLUE, m_TORGB_yblue);
02242
02243 UpdateTonemapWidgetValues();
02244 Refresh();
02245 if(m_auto_tonemap) ApplyTonemapping();
02246 }
02247
02248 void LuxGui::SetWhitepointPreset(int choice) {
02249 m_TORGB_whitepointChoice->SetSelection(choice);
02250
02251
02252 if (choice < 1)
02253 return;
02254
02255
02256 float x = 1;
02257 float y = 1;
02258 float z = 1;
02259 switch (choice - 1) {
02260 case 0:
02261 {
02262
02263 x = 1.09850;
02264 y = 1.00000;
02265 z = 0.35585;
02266 }
02267 break;
02268 case 1:
02269 {
02270
02271 x = 0.99072;
02272 y = 1.00000;
02273 z = 0.85223;
02274 }
02275 break;
02276 case 2:
02277 {
02278
02279 x = 0.98074;
02280 y = 1.00000;
02281 z = 1.18232;
02282 }
02283 break;
02284 case 3:
02285 {
02286
02287 x = 0.96422;
02288 y = 1.00000;
02289 z = 0.82521;
02290 }
02291 break;
02292 case 4:
02293 {
02294
02295 x = 0.95682;
02296 y = 1.00000;
02297 z = 0.92149;
02298 }
02299 break;
02300 case 5:
02301 {
02302
02303 x = 0.95047;
02304 y = 1.00000;
02305 z = 1.08883;
02306 }
02307 break;
02308 case 6:
02309 {
02310
02311 x = 0.94972;
02312 y = 1.00000;
02313 z = 1.22638;
02314 }
02315 break;
02316 case 7:
02317 {
02318
02319 x = 1.00000;
02320 y = 1.00000;
02321 z = 1.00000;
02322 }
02323 break;
02324 case 8:
02325 {
02326
02327 x = 0.99186;
02328 y = 1.00000;
02329 z = 0.67393;
02330 }
02331 break;
02332 case 9:
02333 {
02334
02335 x = 0.95041;
02336 y = 1.00000;
02337 z = 1.08747;
02338 }
02339 break;
02340 case 10:
02341 {
02342
02343 x = 1.00962;
02344 y = 1.00000;
02345 z = 0.64350;
02346 }
02347 break;
02348 default:
02349 break;
02350 }
02351
02352 m_TORGB_xwhite = x / (x+y+z);
02353 m_TORGB_ywhite = y / (x+y+z);
02354
02355
02356 UpdateParam(LUX_FILM, LUX_FILM_TORGB_X_WHITE, m_TORGB_xwhite);
02357 UpdateParam(LUX_FILM, LUX_FILM_TORGB_Y_WHITE, m_TORGB_ywhite);
02358
02359 UpdateTonemapWidgetValues();
02360 Refresh();
02361 if(m_auto_tonemap) ApplyTonemapping();
02362 }
02363
02364 void LuxGui::ResetToneMapping(){
02365 if(luxStatistics("sceneIsReady") || luxStatistics("filmIsReady")) {
02366 ResetToneMappingFromFilm( true );
02367 return;
02368 }
02369
02370 m_TM_kernel = 0;
02371
02372 m_TM_reinhard_prescale = 1.0;
02373 m_TM_reinhard_postscale = 1.0;
02374 m_TM_reinhard_burn = 6.0;
02375
02376 m_TM_linear_exposure = 1.0f;
02377 m_TM_linear_sensitivity = 50.0f;
02378 m_TM_linear_fstop = 2.8;
02379 m_TM_linear_gamma = 1.0;
02380
02381 m_TM_contrast_ywa = 0.1;
02382
02383 m_bloomradius = 0.07f;
02384 m_bloomweight = 0.25f;
02385
02386 m_Vignetting_Enabled = false;
02387 m_Vignetting_Scale = 0.4;
02388
02389 m_Aberration_enabled = false;
02390 m_Aberration_amount = 0.5;
02391
02392 m_Glare_amount = 0.03f;
02393 m_Glare_radius = 0.03f;
02394 m_Glare_blades = 3;
02395
02396 m_TORGB_xwhite = 0.314275f;
02397 m_TORGB_ywhite = 0.329411f;
02398 m_TORGB_xred = 0.63f;
02399 m_TORGB_yred = 0.34f;
02400 m_TORGB_xgreen = 0.31f;
02401 m_TORGB_ygreen = 0.595f;
02402 m_TORGB_xblue = 0.155f;
02403 m_TORGB_yblue = 0.07f;
02404 m_TORGB_gamma = 2.2f;
02405
02406 m_GREYC_enabled = false;
02407 m_GREYC_fast_approx = true;
02408 m_GREYC_amplitude = 40.0;
02409 m_GREYC_sharpness = 0.8;
02410 m_GREYC_anisotropy = 0.2;
02411 m_GREYC_alpha = 0.8;
02412 m_GREYC_sigma = 1.1;
02413 m_GREYC_gauss_prec = 2.0;
02414 m_GREYC_dl = 0.8;
02415 m_GREYC_da = 30.0;
02416 m_GREYC_nb_iter = 1;
02417 m_GREYC_interp = 0;
02418
02419 m_Chiu_enabled = false;
02420 m_Chiu_includecenter = false;
02421 m_Chiu_radius = 3;
02422
02423 UpdateTonemapWidgetValues();
02424 m_outputNotebook->Enable( false );
02425 Refresh();
02426 }
02427
02428 void LuxGui::UpdatedTonemapParam() {
02429 if(m_auto_tonemap) ApplyTonemapping();
02430 }
02431
02432 void LuxGui::UpdateTonemapWidgetValues() {
02433
02434 SetTonemapKernel(m_TM_kernel);
02435
02436
02437 m_TM_Reinhard_prescaleSlider->SetValue( (int)((FLOAT_SLIDER_RES / TM_REINHARD_PRESCALE_RANGE) * m_TM_reinhard_prescale) );
02438 wxString st = wxString::Format( _("%.02f"), m_TM_reinhard_prescale );
02439 m_TM_Reinhard_prescaleText->SetValue(st);
02440
02441 m_TM_Reinhard_postscaleSlider->SetValue( (int)((FLOAT_SLIDER_RES / TM_REINHARD_POSTSCALE_RANGE) * (m_TM_reinhard_postscale)));
02442 st = wxString::Format( _("%.02f"), m_TM_reinhard_postscale );
02443 m_TM_Reinhard_postscaleText->SetValue(st);
02444
02445 m_TM_Reinhard_burnSlider->SetValue( (int)((FLOAT_SLIDER_RES / TM_REINHARD_BURN_RANGE) * m_TM_reinhard_burn));
02446 st = wxString::Format( _("%.02f"), m_TM_reinhard_burn );
02447 m_TM_Reinhard_burnText->SetValue(st);
02448
02449
02450 m_TM_Linear_exposureSlider->SetValue( ValueToLogSliderVal(m_TM_linear_exposure,
02451 TM_LINEAR_EXPOSURE_LOG_MIN, TM_LINEAR_EXPOSURE_LOG_MAX) );
02452 st = wxString::Format( _("%.02f"), m_TM_linear_exposure );
02453 m_TM_Linear_exposureText->SetValue(st);
02454
02455 m_TM_Linear_sensitivitySlider->SetValue( (int)((FLOAT_SLIDER_RES / TM_LINEAR_SENSITIVITY_RANGE) * m_TM_linear_sensitivity) );
02456 st = wxString::Format( _("%.02f"), m_TM_linear_sensitivity );
02457 m_TM_Linear_sensitivityText->SetValue(st);
02458
02459 m_TM_Linear_fstopSlider->SetValue( (int)((FLOAT_SLIDER_RES / TM_LINEAR_FSTOP_RANGE) * (m_TM_linear_fstop)));
02460 st = wxString::Format( _("%.02f"), m_TM_linear_fstop );
02461 m_TM_Linear_fstopText->SetValue(st);
02462
02463 m_TM_Linear_gammaSlider->SetValue( (int)((FLOAT_SLIDER_RES / TM_LINEAR_GAMMA_RANGE) * m_TM_linear_gamma));
02464 st = wxString::Format( _("%.02f"), m_TM_linear_gamma );
02465 m_TM_Linear_gammaText->SetValue(st);
02466
02467
02468 m_TM_contrast_ywaSlider->SetValue( ValueToLogSliderVal(m_TM_contrast_ywa,
02469 TM_CONTRAST_YWA_LOG_MIN, TM_CONTRAST_YWA_LOG_MAX) );
02470 st = wxString::Format( _("%.02f"), m_TM_contrast_ywa );
02471 m_TM_contrast_ywaText->SetValue(st);
02472
02473
02474 m_TORGB_xwhiteSlider->SetValue( (int)((FLOAT_SLIDER_RES / TORGB_XWHITE_RANGE) * m_TORGB_xwhite));
02475 st = wxString::Format( _("%.02f"), m_TORGB_xwhite );
02476 m_TORGB_xwhiteText->SetValue(st);
02477 m_TORGB_ywhiteSlider->SetValue( (int)((FLOAT_SLIDER_RES / TORGB_YWHITE_RANGE) * m_TORGB_ywhite));
02478 st = wxString::Format( _("%.02f"), m_TORGB_ywhite );
02479 m_TORGB_ywhiteText->SetValue(st);
02480
02481 m_TORGB_xredSlider->SetValue( (int)((FLOAT_SLIDER_RES / TORGB_XRED_RANGE) * m_TORGB_xred));
02482 st = wxString::Format( _("%.02f"), m_TORGB_xred );
02483 m_TORGB_xredText->SetValue(st);
02484 m_TORGB_yredSlider->SetValue( (int)((FLOAT_SLIDER_RES / TORGB_YRED_RANGE) * m_TORGB_yred));
02485 st = wxString::Format( _("%.02f"), m_TORGB_yred );
02486 m_TORGB_yredText->SetValue(st);
02487
02488 m_TORGB_xgreenSlider->SetValue( (int)((FLOAT_SLIDER_RES / TORGB_XGREEN_RANGE) * m_TORGB_xgreen));
02489 st = wxString::Format( _("%.02f"), m_TORGB_xgreen );
02490 m_TORGB_xgreenText->SetValue(st);
02491 m_TORGB_ygreenSlider->SetValue( (int)((FLOAT_SLIDER_RES / TORGB_YGREEN_RANGE) * m_TORGB_ygreen));
02492 st = wxString::Format( _("%.02f"), m_TORGB_ygreen );
02493 m_TORGB_ygreenText->SetValue(st);
02494
02495 m_TORGB_xblueSlider->SetValue( (int)((FLOAT_SLIDER_RES / TORGB_XBLUE_RANGE) * m_TORGB_xblue));
02496 st = wxString::Format( _("%.02f"), m_TORGB_xblue );
02497 m_TORGB_xblueText->SetValue(st);
02498 m_TORGB_yblueSlider->SetValue( (int)((FLOAT_SLIDER_RES / TORGB_YBLUE_RANGE) * m_TORGB_yblue));
02499 st = wxString::Format( _("%.02f"), m_TORGB_yblue );
02500 m_TORGB_yblueText->SetValue(st);
02501
02502 m_TORGB_gammaSlider->SetValue( (int)((FLOAT_SLIDER_RES / TORGB_GAMMA_RANGE) * m_TORGB_gamma));
02503 st = wxString::Format( _("%.02f"), m_TORGB_gamma );
02504 m_TORGB_gammaText->SetValue(st);
02505
02506
02507 m_bloomradiusSlider->SetValue( (int)((FLOAT_SLIDER_RES / BLOOMRADIUS_RANGE) * m_bloomradius));
02508 st = wxString::Format( _("%.02f"), m_bloomradius );
02509 m_bloomradiusText->SetValue(st);
02510
02511 m_bloomweightSlider->SetValue( (int)((FLOAT_SLIDER_RES / BLOOMWEIGHT_RANGE) * m_bloomweight));
02512 st = wxString::Format( _("%.02f"), m_bloomweight );
02513 m_bloomweightText->SetValue(st);
02514
02515
02516 m_greyc_iterationsSlider->SetValue( (int) m_GREYC_nb_iter );
02517 st = wxString::Format( _("%.02f"), m_GREYC_nb_iter );
02518 m_greyc_iterationsText->SetValue(st);
02519
02520 m_greyc_amplitudeSlider->SetValue( (int)((FLOAT_SLIDER_RES / GREYC_AMPLITUDE_RANGE) * m_GREYC_amplitude));
02521 st = wxString::Format( _("%.02f"), m_GREYC_amplitude );
02522 m_greyc_amplitudeText->SetValue(st);
02523
02524 m_greyc_gausprecSlider->SetValue( (int)((FLOAT_SLIDER_RES / GREYC_GAUSSPREC_RANGE) * m_GREYC_gauss_prec));
02525 st = wxString::Format( _("%.02f"), m_GREYC_gauss_prec );
02526 m_greyc_gaussprecText->SetValue(st);
02527
02528 m_greyc_alphaSlider->SetValue( (int)((FLOAT_SLIDER_RES / GREYC_ALPHA_RANGE) * m_GREYC_alpha));
02529 st = wxString::Format( _("%.02f"), m_GREYC_alpha );
02530 m_greyc_alphaText->SetValue(st);
02531
02532 m_greyc_sigmaSlider->SetValue( (int)((FLOAT_SLIDER_RES / GREYC_SIGMA_RANGE) * m_GREYC_sigma));
02533 st = wxString::Format( _("%.02f"), m_GREYC_sigma );
02534 m_greyc_sigmaText->SetValue(st);
02535
02536 m_greyc_sharpnessSlider->SetValue( (int)((FLOAT_SLIDER_RES / GREYC_SHARPNESS_RANGE) * m_GREYC_sharpness));
02537 st = wxString::Format( _("%.02f"), m_GREYC_sharpness );
02538 m_greyc_sharpnessText->SetValue(st);
02539
02540 m_greyc_anisoSlider->SetValue( (int)((FLOAT_SLIDER_RES / GREYC_ANISOTROPY_RANGE) * m_GREYC_anisotropy));
02541 st = wxString::Format( _("%.02f"), m_GREYC_anisotropy );
02542 m_greyc_anisoText->SetValue(st);
02543
02544 m_greyc_spatialSlider->SetValue( (int)((FLOAT_SLIDER_RES / GREYC_DL_RANGE) * m_GREYC_dl));
02545 st = wxString::Format( _("%.02f"), m_GREYC_dl );
02546 m_greyc_spatialText->SetValue(st);
02547
02548 m_greyc_angularSlider->SetValue( (int)((FLOAT_SLIDER_RES / GREYC_DA_RANGE) * m_GREYC_da));
02549 st = wxString::Format( _("%.02f"), m_GREYC_da );
02550 m_greyc_angularText->SetValue(st);
02551
02552 m_GREYCinterpolationChoice->SetSelection( m_GREYC_interp );
02553
02554 m_greyc_EnabledCheckBox->SetValue( m_GREYC_enabled );
02555 m_greyc_fastapproxCheckBox->SetValue( m_GREYC_fast_approx );
02556
02557 m_chiu_enableCheckBox->SetValue( m_Chiu_enabled );
02558 m_chiu_includecenterCheckBox->SetValue( m_Chiu_includecenter );
02559
02560 m_chiu_radiusSlider->SetValue( (int)((FLOAT_SLIDER_RES / (CHIU_RADIUS_MAX-CHIU_RADIUS_MIN)) * (m_Chiu_radius-CHIU_RADIUS_MIN)) );
02561 st = wxString::Format( _("%.02f"), m_Chiu_radius );
02562 m_chiu_radiusText->SetValue(st);
02563
02564
02565 m_HistogramWindow->SetEnabled(m_Tab_Control_HistogramPanel->IsShown());
02566
02567 Refresh();
02568 }
02569
02570 void LuxGui::ResetToneMappingFromFilm( bool useDefaults ){
02571
02572 double t;
02573
02574 m_TM_kernel = (int) RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_TM_TONEMAPKERNEL);
02575
02576 m_TM_reinhard_prescale = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_TM_REINHARD_PRESCALE);
02577 m_TM_reinhard_postscale = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_TM_REINHARD_POSTSCALE);
02578 m_TM_reinhard_burn = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_TM_REINHARD_BURN);
02579
02580 m_TM_linear_exposure = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_TM_LINEAR_EXPOSURE);
02581 m_TM_linear_sensitivity = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_TM_LINEAR_SENSITIVITY);
02582 m_TM_linear_fstop = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_TM_LINEAR_FSTOP);
02583 m_TM_linear_gamma = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_TM_LINEAR_GAMMA);
02584
02585 m_TM_contrast_ywa = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_TM_CONTRAST_YWA);
02586
02587 m_TORGB_xwhite = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_TORGB_X_WHITE);
02588 m_TORGB_ywhite = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_TORGB_Y_WHITE);
02589 m_TORGB_xred = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_TORGB_X_RED);
02590 m_TORGB_yred = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_TORGB_Y_RED);
02591 m_TORGB_xgreen = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_TORGB_X_GREEN);
02592 m_TORGB_ygreen = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_TORGB_Y_GREEN);
02593 m_TORGB_xblue = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_TORGB_X_BLUE);
02594 m_TORGB_yblue = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_TORGB_Y_BLUE);
02595 m_TORGB_gamma = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_TORGB_GAMMA);
02596
02597 m_bloomradius = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_BLOOMRADIUS);
02598 m_bloomweight = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_BLOOMWEIGHT);
02599
02600 t = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_VIGNETTING_ENABLED);
02601 m_Vignetting_Enabled = t != 0.0;
02602 m_Vignetting_Scale = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_VIGNETTING_SCALE);
02603
02604 t = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_ABERRATION_ENABLED);
02605 m_Aberration_enabled = t != 0.0;
02606 m_Aberration_amount = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_ABERRATION_AMOUNT);
02607
02608
02609 m_Glare_amount = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_GLARE_AMOUNT);
02610 m_Glare_radius = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_GLARE_RADIUS);
02611 m_Glare_blades = (int)RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_GLARE_BLADES);
02612
02613 t = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_NOISE_GREYC_ENABLED);
02614 if(t != 0.0) m_GREYC_enabled = true;
02615 else m_GREYC_enabled = false;
02616 t = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_NOISE_GREYC_FASTAPPROX);
02617 if(t != 0.0) m_GREYC_fast_approx = true;
02618 else m_GREYC_fast_approx = false;
02619
02620 m_GREYC_amplitude = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_NOISE_GREYC_AMPLITUDE);
02621 m_GREYC_sharpness = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_NOISE_GREYC_SHARPNESS);
02622 m_GREYC_anisotropy = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_NOISE_GREYC_ANISOTROPY);
02623 m_GREYC_alpha = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_NOISE_GREYC_ALPHA);
02624 m_GREYC_sigma = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_NOISE_GREYC_SIGMA);
02625 m_GREYC_gauss_prec = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_NOISE_GREYC_GAUSSPREC);
02626 m_GREYC_dl = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_NOISE_GREYC_DL);
02627 m_GREYC_da = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_NOISE_GREYC_DA);
02628 m_GREYC_nb_iter = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_NOISE_GREYC_NBITER);
02629 m_GREYC_interp = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_NOISE_GREYC_INTERP);
02630
02631 t = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_NOISE_CHIU_ENABLED);
02632 m_Chiu_enabled = t != 0.0;
02633 t = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_NOISE_CHIU_INCLUDECENTER);
02634 m_Chiu_includecenter = t != 0.0;
02635 m_Chiu_radius = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_NOISE_CHIU_RADIUS);
02636
02637 luxSetParameterValue(LUX_FILM, LUX_FILM_TM_REINHARD_PRESCALE, m_TM_reinhard_prescale);
02638 luxSetParameterValue(LUX_FILM, LUX_FILM_TM_REINHARD_POSTSCALE, m_TM_reinhard_postscale);
02639 luxSetParameterValue(LUX_FILM, LUX_FILM_TM_REINHARD_BURN, m_TM_reinhard_burn);
02640
02641 luxSetParameterValue(LUX_FILM, LUX_FILM_TM_LINEAR_EXPOSURE, m_TM_linear_exposure);
02642 luxSetParameterValue(LUX_FILM, LUX_FILM_TM_LINEAR_SENSITIVITY, m_TM_linear_sensitivity);
02643 luxSetParameterValue(LUX_FILM, LUX_FILM_TM_LINEAR_FSTOP, m_TM_linear_fstop);
02644 luxSetParameterValue(LUX_FILM, LUX_FILM_TM_LINEAR_GAMMA, m_TM_linear_gamma);
02645
02646 luxSetParameterValue(LUX_FILM, LUX_FILM_TM_CONTRAST_YWA, m_TM_contrast_ywa);
02647
02648 luxSetParameterValue(LUX_FILM, LUX_FILM_TORGB_X_WHITE, m_TORGB_xwhite);
02649 luxSetParameterValue(LUX_FILM, LUX_FILM_TORGB_Y_WHITE, m_TORGB_ywhite);
02650 luxSetParameterValue(LUX_FILM, LUX_FILM_TORGB_X_RED, m_TORGB_xred);
02651 luxSetParameterValue(LUX_FILM, LUX_FILM_TORGB_Y_RED, m_TORGB_yred);
02652 luxSetParameterValue(LUX_FILM, LUX_FILM_TORGB_X_GREEN, m_TORGB_xgreen);
02653 luxSetParameterValue(LUX_FILM, LUX_FILM_TORGB_Y_GREEN, m_TORGB_ygreen);
02654 luxSetParameterValue(LUX_FILM, LUX_FILM_TORGB_X_BLUE, m_TORGB_xblue);
02655 luxSetParameterValue(LUX_FILM, LUX_FILM_TORGB_Y_BLUE, m_TORGB_yblue);
02656 luxSetParameterValue(LUX_FILM, LUX_FILM_TORGB_GAMMA, m_TORGB_gamma);
02657
02658 luxSetParameterValue(LUX_FILM, LUX_FILM_BLOOMRADIUS, m_bloomradius);
02659 luxSetParameterValue(LUX_FILM, LUX_FILM_BLOOMWEIGHT, m_bloomweight);
02660
02661 luxSetParameterValue(LUX_FILM, LUX_FILM_VIGNETTING_ENABLED, m_Vignetting_Enabled);
02662 luxSetParameterValue(LUX_FILM, LUX_FILM_VIGNETTING_SCALE, m_Vignetting_Scale);
02663
02664 luxSetParameterValue(LUX_FILM, LUX_FILM_ABERRATION_ENABLED, m_Aberration_enabled);
02665 luxSetParameterValue(LUX_FILM, LUX_FILM_ABERRATION_AMOUNT, m_Aberration_amount);
02666
02667 luxSetParameterValue(LUX_FILM, LUX_FILM_GLARE_AMOUNT, m_Glare_amount);
02668 luxSetParameterValue(LUX_FILM, LUX_FILM_GLARE_RADIUS, m_Glare_radius);
02669 luxSetParameterValue(LUX_FILM, LUX_FILM_GLARE_BLADES, m_Glare_blades);
02670
02671 luxSetParameterValue(LUX_FILM, LUX_FILM_NOISE_GREYC_ENABLED, m_GREYC_enabled);
02672 luxSetParameterValue(LUX_FILM, LUX_FILM_NOISE_GREYC_FASTAPPROX, m_GREYC_fast_approx);
02673 luxSetParameterValue(LUX_FILM, LUX_FILM_NOISE_GREYC_AMPLITUDE, m_GREYC_amplitude);
02674 luxSetParameterValue(LUX_FILM, LUX_FILM_NOISE_GREYC_SHARPNESS, m_GREYC_sharpness);
02675 luxSetParameterValue(LUX_FILM, LUX_FILM_NOISE_GREYC_ANISOTROPY, m_GREYC_anisotropy);
02676 luxSetParameterValue(LUX_FILM, LUX_FILM_NOISE_GREYC_ALPHA, m_GREYC_alpha);
02677 luxSetParameterValue(LUX_FILM, LUX_FILM_NOISE_GREYC_SIGMA, m_GREYC_sigma);
02678 luxSetParameterValue(LUX_FILM, LUX_FILM_NOISE_GREYC_GAUSSPREC, m_GREYC_gauss_prec);
02679 luxSetParameterValue(LUX_FILM, LUX_FILM_NOISE_GREYC_DL, m_GREYC_dl);
02680 luxSetParameterValue(LUX_FILM, LUX_FILM_NOISE_GREYC_DA, m_GREYC_da);
02681 luxSetParameterValue(LUX_FILM, LUX_FILM_NOISE_GREYC_NBITER, m_GREYC_nb_iter);
02682 luxSetParameterValue(LUX_FILM, LUX_FILM_NOISE_GREYC_INTERP, m_GREYC_interp);
02683
02684 luxSetParameterValue(LUX_FILM, LUX_FILM_NOISE_CHIU_ENABLED, m_Chiu_enabled);
02685 luxSetParameterValue(LUX_FILM, LUX_FILM_NOISE_CHIU_INCLUDECENTER, m_Chiu_includecenter);
02686 luxSetParameterValue(LUX_FILM, LUX_FILM_NOISE_CHIU_RADIUS, m_Chiu_radius);
02687
02688 UpdateTonemapWidgetValues();
02689 if(m_auto_tonemap) ApplyTonemapping();
02690 }
02691
02692 void LuxGui::UpdateLightGroupWidgetValues() {
02693 for( std::vector<LuxLightGroupPanel*>::iterator it = m_LightGroupPanels.begin(); it != m_LightGroupPanels.end(); it++) {
02694 (*it)->UpdateWidgetValues();
02695 }
02696 Refresh();
02697 }
02698 void LuxGui::ResetLightGroups( void ) {
02699 if(luxStatistics("sceneIsReady") || luxStatistics("filmIsReady")) {
02700 ResetLightGroupsFromFilm( true );
02701 return;
02702 }
02703
02704
02705 for( std::vector<LuxLightGroupPanel*>::iterator it = m_LightGroupPanels.begin(); it != m_LightGroupPanels.end(); it++) {
02706 LuxLightGroupPanel *currPanel = *it;
02707 m_LightGroupsSizer->Detach(currPanel);
02708 delete currPanel;
02709 }
02710 m_LightGroupPanels.clear();
02711
02712
02713 m_LightGroups->Layout();
02714 }
02715 void LuxGui::ResetLightGroupsFromFilm( bool useDefaults ) {
02716
02717 for( std::vector<LuxLightGroupPanel*>::iterator it = m_LightGroupPanels.begin(); it != m_LightGroupPanels.end(); it++) {
02718 LuxLightGroupPanel *currPanel = *it;
02719 m_LightGroupsSizer->Detach(currPanel);
02720 delete currPanel;
02721 }
02722 m_LightGroupPanels.clear();
02723
02724
02725 int numLightGroups = (int)luxGetParameterValue(LUX_FILM, LUX_FILM_LG_COUNT);
02726 for(int i = 0; i < numLightGroups; i++) {
02727 LuxLightGroupPanel *currPanel = new LuxLightGroupPanel(
02728 this, m_LightGroups
02729 );
02730 currPanel->SetIndex(i);
02731 currPanel->ResetValuesFromFilm( useDefaults );
02732 m_LightGroupsSizer->Add(currPanel, 0, wxEXPAND | wxALL, 1);
02733 m_LightGroupPanels.push_back(currPanel);
02734 }
02735
02736
02737 UpdateLightGroupWidgetValues();
02738 m_LightGroups->Layout();
02739 }
02740
02741 int LuxGui::ValueToLogSliderVal(float value, const float logLowerBound, const float logUpperBound) {
02742
02743 if (value <= 0)
02744 return 0;
02745
02746 float logvalue = Clamp<float>(log10f(value), logLowerBound, logUpperBound);
02747
02748 const int val = static_cast<int>((logvalue - logLowerBound) /
02749 (logUpperBound - logLowerBound) * FLOAT_SLIDER_RES);
02750 return val;
02751 }
02752
02753 float LuxGui::LogSliderValToValue(int sliderval, const float logLowerBound, const float logUpperBound) {
02754
02755 float logvalue = (float)sliderval * (logUpperBound - logLowerBound) /
02756 FLOAT_SLIDER_RES + logLowerBound;
02757
02758 return powf(10.f, logvalue);
02759 }
02760
02761
02763
02764
02765 LuxGui::LuxLightGroupPanel::LuxLightGroupPanel(
02766 LuxGui *gui,
02767 wxWindow* parent,
02768 wxWindowID id,
02769 const wxPoint& pos,
02770 const wxSize& size,
02771 long style )
02772 : LightGroupPanel(parent, id, pos, size, style), m_Gui(gui)
02773 {
02774 m_lightgroupBitmap->SetBitmap(wxMEMORY_BITMAP(tab_lightgroup_png));
02775 m_Tab_LightGroupIcon->SetBitmap(wxMEMORY_BITMAP(arrowdownactive_png));
02776 m_Tab_LightGroupToggleIcon->SetBitmap(wxMEMORY_BITMAP(powericon_png));
02777 m_BarBlackBodyStaticBitmap->SetBitmap(wxMEMORY_BITMAP(bar_blackbody_png));
02778 m_Index = -1;
02779 ResetValues();
02780 }
02781
02782 int LuxGui::LuxLightGroupPanel::GetIndex() const {
02783 return m_Index;
02784 }
02785
02786 void LuxGui::LuxLightGroupPanel::SetIndex( int index ) {
02787 m_Index = index;
02788 if(index > 2){
02789 m_Tab_Control_LightGroupPanel->Hide();
02790 m_Tab_LightGroupIcon->SetBitmap(wxMEMORY_BITMAP(arrowleft_png));
02791 }
02792 }
02793
02794 void LuxGui::LuxLightGroupPanel::UpdateWidgetValues() {
02795 if(m_LG_enable) m_Tab_LightGroupToggleIcon->SetBitmap(wxMEMORY_BITMAP(powericon_png));
02796 else m_Tab_LightGroupToggleIcon->SetBitmap(wxMEMORY_BITMAP(powerofficon_png));
02797 SetWidgetsEnabled(m_LG_enable);
02798 wxString st;
02799 m_LG_scaleSlider->SetValue(ScaleToSliderVal(m_LG_scale));
02800 st = wxString::Format(_("%.04f"), m_LG_scale);
02801 m_LG_scaleText->SetValue(st);
02802 float val = ((m_LG_temperature - LG_TEMPERATURE_MIN)
02803 / (LG_TEMPERATURE_MAX - LG_TEMPERATURE_MIN)) * FLOAT_SLIDER_RES;
02804 m_LG_temperatureSlider->SetValue(val);
02805 st = wxString::Format(_("%.02f"), m_LG_temperature);
02806 m_LG_temperatureText->SetValue(st);
02807 wxColour colour(Clamp(int(m_LG_scaleRed * 255.0), 0, 255),
02808 Clamp(int(m_LG_scaleGreen * 255.0), 0, 255),
02809 Clamp(int(m_LG_scaleBlue * 255.0), 0, 255));
02810 m_LG_rgbPicker->SetColour(colour);
02811 }
02812 void LuxGui::LuxLightGroupPanel::ResetValues() {
02813 m_LG_enable = true;
02814 m_LG_scale = 1.f;
02815 m_LG_temperature_enabled = false;
02816 m_LG_temperature = 6500.f;
02817 m_LG_rgb_enabled = false;
02818 m_LG_scaleRed = 1.f;
02819 m_LG_scaleGreen = 1.f;
02820 m_LG_scaleBlue = 1.f;
02821 m_LG_scaleX = 1.f;
02822 m_LG_scaleY = 1.f;
02823 }
02824 void LuxGui::LuxLightGroupPanel::ResetValuesFromFilm( bool useDefaults ) {
02825 char tmpStr[256];
02826 luxGetStringParameterValue(LUX_FILM, LUX_FILM_LG_NAME, &tmpStr[0], 256, m_Index);
02827 m_LG_name->SetLabel(wxString::FromAscii(tmpStr));
02828 m_LG_enable = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_LG_ENABLE, m_Index) != 0.f;
02829 m_LG_scale = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_LG_SCALE, m_Index);
02830 double t = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_LG_TEMPERATURE, m_Index);
02831 m_LG_temperature_enabled = t != 0.0;
02832 m_LG_temperature = m_LG_temperature_enabled ? t : m_LG_temperature;
02833 double r = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_LG_SCALE_RED, m_Index);
02834 double g = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_LG_SCALE_GREEN, m_Index);
02835 double b = RetrieveParam( useDefaults, LUX_FILM, LUX_FILM_LG_SCALE_BLUE, m_Index);
02836 m_LG_rgb_enabled = (r != 1.0) && (g != 1.0) && (b != 1.0);
02837 if (m_LG_rgb_enabled) {
02838 m_LG_scaleRed = r;
02839 m_LG_scaleGreen = g;
02840 m_LG_scaleBlue = b;
02841 }
02842
02843 luxSetParameterValue(LUX_FILM, LUX_FILM_LG_ENABLE, m_LG_enable, m_Index);
02844 luxSetParameterValue(LUX_FILM, LUX_FILM_LG_SCALE, m_LG_scale, m_Index);
02845 luxSetParameterValue(LUX_FILM, LUX_FILM_LG_SCALE_RED, (m_LG_rgb_enabled ? m_LG_scaleRed : 1.0), m_Index);
02846 luxSetParameterValue(LUX_FILM, LUX_FILM_LG_SCALE_GREEN, (m_LG_rgb_enabled ? m_LG_scaleGreen : 1.0), m_Index);
02847 luxSetParameterValue(LUX_FILM, LUX_FILM_LG_SCALE_BLUE, (m_LG_rgb_enabled ? m_LG_scaleBlue : 1.0), m_Index);
02848 luxSetParameterValue(LUX_FILM, LUX_FILM_LG_TEMPERATURE, (m_LG_temperature_enabled ? m_LG_temperature : 0.0), m_Index);
02849 }
02850
02851
02852 void LuxGui::LuxLightGroupPanel::OnMouse(wxMouseEvent &event) {
02853 switch (event.GetId()) {
02854
02855 case ID_TAB_LG:
02856 {
02857 if( m_Tab_Control_LightGroupPanel->IsShown() ){
02858 m_Tab_Control_LightGroupPanel->Hide();
02859 m_Tab_LightGroupIcon->SetBitmap(wxMEMORY_BITMAP(arrowleft_png));
02860 }else{
02861 m_Tab_Control_LightGroupPanel->Show(true);
02862 m_Tab_LightGroupIcon->SetBitmap(wxMEMORY_BITMAP(arrowdownactive_png));
02863 }
02864 m_LG_MainSizer->Layout();
02865 m_Gui->m_LightGroupsSizer->Layout();
02866 m_Gui->m_LightGroups->GetSizer()->FitInside(m_Gui->m_LightGroups);
02867 m_Gui->m_LightGroups->Layout();
02868 Refresh();
02869 m_Gui->Refresh();
02870 }
02871 break;
02872 case ID_TAB_LG_TOGGLE:
02873 {
02874 if( m_LG_enable ){
02875 m_LG_enable = false;
02876 m_Tab_LightGroupToggleIcon->SetBitmap(wxMEMORY_BITMAP(powerofficon_png));
02877 }else{
02878 m_LG_enable = true;
02879 m_Tab_LightGroupToggleIcon->SetBitmap(wxMEMORY_BITMAP(powericon_png));
02880 }
02881 luxSetParameterValue(LUX_FILM, LUX_FILM_LG_ENABLE, m_LG_enable, m_Index);
02882 SetWidgetsEnabled(m_LG_enable);
02883 m_Gui->UpdatedTonemapParam();
02884 Refresh();
02885 }
02886 break;
02887 default:
02888 break;
02889 }
02890 }
02891
02892 void LuxGui::LuxLightGroupPanel::OnText(wxCommandEvent& event) {
02893 if ( event.GetEventType() != wxEVT_COMMAND_TEXT_ENTER ) return;
02894
02895 switch(event.GetId()) {
02896 case ID_LG_SCALE_TEXT:
02897 if (m_LG_scaleText->IsModified()) {
02898 wxString st = m_LG_scaleText->GetValue();
02899 st.ToDouble(&m_LG_scale);
02900 if (m_LG_scale > powf(10.f, LG_SCALE_LOG_MAX))
02901 m_LG_scale = powf(10.f, LG_SCALE_LOG_MAX);
02902 else if (m_LG_scale < 0.f)
02903 m_LG_scale = 0.f;
02904 st = wxString::Format(_("%.04f"), m_LG_scale);
02905 m_LG_scaleText->SetValue(st);
02906 m_LG_scaleSlider->SetValue(ScaleToSliderVal(m_LG_scale));
02907 UpdateParam(LUX_FILM, LUX_FILM_LG_SCALE, m_LG_scale, m_Index);
02908 m_Gui->UpdatedTonemapParam();
02909 }
02910 break;
02911 case ID_LG_TEMPERATURE_TEXT:
02912 if (m_LG_temperatureText->IsModified()) {
02913 wxString st = m_LG_temperatureText->GetValue();
02914 st.ToDouble(&m_LG_temperature);
02915 if (m_LG_temperature > LG_TEMPERATURE_MAX)
02916 m_LG_temperature = LG_TEMPERATURE_MAX;
02917 else if (m_LG_temperature < LG_TEMPERATURE_MIN)
02918 m_LG_temperature = LG_TEMPERATURE_MIN;
02919 st = wxString::Format(_("%.02f"), m_LG_temperature);
02920 m_LG_temperatureText->SetValue(st);
02921 float val = ((m_LG_temperature - LG_TEMPERATURE_MIN)
02922 / (LG_TEMPERATURE_MAX - LG_TEMPERATURE_MIN)) * FLOAT_SLIDER_RES;
02923 m_LG_temperatureSlider->SetValue(val);
02924 UpdateParam(LUX_FILM, LUX_FILM_LG_TEMPERATURE, (m_LG_temperature_enabled ? m_LG_temperature : 0.0), m_Index);
02925 if (m_LG_temperature_enabled)
02926 m_Gui->UpdatedTonemapParam();
02927 }
02928 break;
02929 default:
02930 break;
02931 }
02932 }
02933
02934 void LuxGui::LuxLightGroupPanel::OnCheckBox(wxCommandEvent& event)
02935 {
02936 if (event.GetEventType() != wxEVT_COMMAND_CHECKBOX_CLICKED)
02937 return;
02938
02939 switch (event.GetId()) {
02940 case ID_LG_RGB_ENABLED:
02941 {
02942 if(m_LG_rgbEnabled->IsChecked())
02943 m_LG_rgb_enabled = true;
02944 else
02945 m_LG_rgb_enabled = false;
02946
02947 UpdateParam(LUX_FILM, LUX_FILM_LG_SCALE_RED, (m_LG_rgb_enabled ? m_LG_scaleRed : 1.0), m_Index);
02948 UpdateParam(LUX_FILM, LUX_FILM_LG_SCALE_GREEN, (m_LG_rgb_enabled ? m_LG_scaleGreen : 1.0), m_Index);
02949 UpdateParam(LUX_FILM, LUX_FILM_LG_SCALE_BLUE, (m_LG_rgb_enabled ? m_LG_scaleBlue : 1.0), m_Index);
02950
02951 m_LG_rgbPicker->Enable(m_LG_rgb_enabled);
02952
02953 m_Gui->UpdatedTonemapParam();
02954 }
02955 break;
02956 case ID_LG_TEMPERATURE_ENABLED:
02957 {
02958 if(m_LG_temperatureEnabled->IsChecked())
02959 m_LG_temperature_enabled = true;
02960 else
02961 m_LG_temperature_enabled = false;
02962
02963 m_LG_temperatureSlider->Enable(m_LG_temperature_enabled);
02964 m_LG_temperatureText->Enable(m_LG_temperature_enabled);
02965
02966 UpdateParam(LUX_FILM, LUX_FILM_LG_TEMPERATURE, (m_LG_temperature_enabled ? m_LG_temperature : 0.0), m_Index);
02967 m_Gui->UpdatedTonemapParam();
02968 }
02969 break;
02970
02971
02972
02973
02974
02975
02976
02977 default:
02978 break;
02979 }
02980 }
02981
02982 void LuxGui::LuxLightGroupPanel::OnColourChanged(wxColourPickerEvent &event)
02983 {
02984 switch (event.GetId()) {
02985 case ID_LG_RGBCOLOR:
02986 m_LG_scaleRed = event.GetColour().Red() / 255.0;
02987 m_LG_scaleGreen = event.GetColour().Green() / 255.0;
02988 m_LG_scaleBlue = event.GetColour().Blue() / 255.0;
02989 UpdateParam(LUX_FILM, LUX_FILM_LG_SCALE_RED, (m_LG_rgb_enabled ? m_LG_scaleRed : 1.0), m_Index);
02990 UpdateParam(LUX_FILM, LUX_FILM_LG_SCALE_GREEN, (m_LG_rgb_enabled ? m_LG_scaleGreen : 1.0), m_Index);
02991 UpdateParam(LUX_FILM, LUX_FILM_LG_SCALE_BLUE, (m_LG_rgb_enabled ? m_LG_scaleBlue : 1.0), m_Index);
02992 if (m_LG_rgb_enabled)
02993 m_Gui->UpdatedTonemapParam();
02994 break;
02995 default:
02996 break;
02997 }
02998 }
02999
03000 void LuxGui::LuxLightGroupPanel::OnScroll(wxScrollEvent& event) {
03001 switch(event.GetId()) {
03002 case ID_LG_SCALE:
03003 {
03004 m_LG_scale = SliderValToScale(event.GetPosition());
03005 wxString st = wxString::Format(_("%.04f"), m_LG_scale);
03006 m_LG_scaleText->SetValue(st);
03007 UpdateParam(LUX_FILM, LUX_FILM_LG_SCALE, m_LG_scale, m_Index);
03008 m_Gui->UpdatedTonemapParam();
03009 break;
03010 }
03011 case ID_LG_TEMPERATURE:
03012 {
03013 m_LG_temperature = ((((float) event.GetPosition()) / FLOAT_SLIDER_RES)
03014 * (LG_TEMPERATURE_MAX - LG_TEMPERATURE_MIN)) + LG_TEMPERATURE_MIN;
03015 wxString st = wxString::Format(_("%.02f"), m_LG_temperature);
03016 m_LG_temperatureText->SetValue(st);
03017 UpdateParam(LUX_FILM, LUX_FILM_LG_TEMPERATURE, (m_LG_temperature_enabled ? m_LG_temperature : 0.0), m_Index);
03018 if (m_LG_temperature_enabled)
03019 m_Gui->UpdatedTonemapParam();
03020 break;
03021 }
03022 default:
03023 break;
03024 }
03025 }
03026
03027 void LuxGui::LuxLightGroupPanel::SetWidgetsEnabled(bool enabled) {
03028 m_LG_scaleSlider->Enable(enabled);
03029 m_LG_scaleText->Enable(enabled);
03030 m_LG_rgbEnabled->Enable(enabled);
03031 m_LG_rgbPicker->Enable(enabled && m_LG_rgb_enabled);
03032 m_LG_temperatureEnabled->Enable(enabled);
03033 m_LG_temperatureSlider->Enable(enabled && m_LG_temperature_enabled);
03034 m_LG_temperatureText->Enable(enabled && m_LG_temperature_enabled);
03035 }
03036
03037 int LuxGui::LuxLightGroupPanel::ScaleToSliderVal(float scale) {
03038
03039 if (scale <= 0)
03040 return 0;
03041
03042 float logscale = Clamp<float>(log10f(scale), LG_SCALE_LOG_MIN, LG_SCALE_LOG_MAX);
03043
03044 const int val = static_cast<int>((logscale - LG_SCALE_LOG_MIN) /
03045 (LG_SCALE_LOG_MAX - LG_SCALE_LOG_MIN) * FLOAT_SLIDER_RES);
03046 return val;
03047 }
03048
03049 float LuxGui::LuxLightGroupPanel::SliderValToScale(int sliderval) {
03050
03051 float logscale = (float)sliderval * (LG_SCALE_LOG_MAX - LG_SCALE_LOG_MIN) /
03052 FLOAT_SLIDER_RES + LG_SCALE_LOG_MIN;
03053
03054 return powf(10.f, logscale);
03055 }
03056
03057
03059
03060
03061 LuxGui::ImageWindow::ImageWindow(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, const wxString& name)
03062 : wxWindow(parent, id, pos, size, style, name)
03063 {
03064 this->Connect(wxEVT_PAINT, wxPaintEventHandler(LuxGui::ImageWindow::OnPaint));
03065 this->Connect(wxEVT_ERASE_BACKGROUND, wxEraseEventHandler(LuxGui::ImageWindow::OnEraseBackground));
03066 m_bitmap = NULL;
03067 }
03068
03069 LuxGui::ImageWindow::~ImageWindow(){
03070 this->Disconnect(wxEVT_PAINT, wxPaintEventHandler(LuxGui::ImageWindow::OnPaint));
03071 this->Disconnect(wxEVT_ERASE_BACKGROUND, wxEraseEventHandler(LuxGui::ImageWindow::OnEraseBackground));
03072 if(m_bitmap!=NULL) delete m_bitmap;
03073 }
03074 void LuxGui::ImageWindow::SetImage(const wxImage& img){
03075 if(m_bitmap!=NULL) delete m_bitmap;
03076 m_bitmap = new wxBitmap(img);
03077 Refresh();
03078 }
03079
03080 void LuxGui::ImageWindow::OnPaint(wxPaintEvent& event){
03081 wxPaintDC dc(this);
03082 if(m_bitmap!=NULL) dc.DrawBitmap(*m_bitmap, 0, 0, false);
03083 }
03084
03085 void LuxGui::ImageWindow::OnEraseBackground(wxEraseEvent& event){
03086
03087 }
03088
03089
03091
03092
03093 LuxGui::LuxHistogramWindow::LuxHistogramWindow(wxWindow *parent, wxWindowID id, const wxPoint& pos)
03094 : ImageWindow(parent, id, pos, wxSize(200,100))
03095 {
03096 this->Connect(wxEVT_SIZE, wxSizeEventHandler(LuxGui::LuxHistogramWindow::OnSize));
03097 wxImage tmp_img(200, 100, true);
03098 SetImage(tmp_img);
03099 m_Options=LUX_HISTOGRAM_RGB_ADD;
03100 m_IsEnabled=false;
03101 }
03102
03103 LuxGui::LuxHistogramWindow::~LuxHistogramWindow(){
03104 this->Disconnect(wxEVT_SIZE, wxSizeEventHandler(LuxGui::LuxHistogramWindow::OnSize));
03105 }
03106
03107 void LuxGui::LuxHistogramWindow::Update(){
03108 if(!IsShownOnScreen() || !m_IsEnabled) return;
03109 wxSize size=GetSize();
03110 wxImage img(size.GetWidth(), size.GetHeight(), true);
03111 if(luxStatistics("sceneIsReady") || luxStatistics("filmIsReady")) luxGetHistogramImage(img.GetData(), size.GetWidth(), size.GetHeight(), m_Options);
03112 SetImage(img);
03113 }
03114
03115 void LuxGui::LuxHistogramWindow::SetOption(int option){
03116 switch(option){
03117 case LUX_HISTOGRAM_RGB:
03118 case LUX_HISTOGRAM_RGB_ADD:
03119 case LUX_HISTOGRAM_RED:
03120 case LUX_HISTOGRAM_GREEN:
03121 case LUX_HISTOGRAM_BLUE:
03122 case LUX_HISTOGRAM_VALUE:
03123 {
03124 m_Options &= ~(LUX_HISTOGRAM_RGB|LUX_HISTOGRAM_RGB_ADD|LUX_HISTOGRAM_RED|LUX_HISTOGRAM_GREEN|LUX_HISTOGRAM_BLUE|LUX_HISTOGRAM_VALUE);
03125 m_Options |= option;
03126 } break;
03127 case LUX_HISTOGRAM_LOG:
03128 {
03129 m_Options |= LUX_HISTOGRAM_LOG;
03130 } break;
03131 default: break;
03132 }
03133 }
03134
03135 void LuxGui::LuxHistogramWindow::SetEnabled(bool enabled){
03136 m_IsEnabled=enabled;
03137 UpdateParam(LUX_FILM, LUX_FILM_HISTOGRAM_ENABLED, enabled);
03138 }
03139
03140 void LuxGui::LuxHistogramWindow::ClearOption(int option){
03141 m_Options &= ~option;
03142 }
03143
03144 void LuxGui::LuxHistogramWindow::OnSize(wxSizeEvent& event){
03145 wxSize size=this->GetContainingSizer()->GetSize();
03146 SetSize(size);
03147 Update();
03148 }
03149
03150
03152
03153
03154 void LuxGui::UpdateNetworkTree( void )
03155 {
03156 m_serverUpdateSpin->SetValue( luxGetNetworkServerUpdateInterval() );
03157 wxTreeItemId idSelected = m_networkTreeCtrl->GetSelection();
03158 luxTreeData *pSelectedData = (luxTreeData *)m_networkTreeCtrl->GetItemData(idSelected);
03159 wxString sidSelected;
03160 if (pSelectedData)
03161 sidSelected = pSelectedData->m_SlaveID;
03162
03163 m_networkTreeCtrl->DeleteAllItems();
03164
03165 wxTreeItemId idRootNode = m_networkTreeCtrl->AddRoot( _("Master") );
03166
03167 int nServers = luxGetServerCount();
03168 RenderingServerInfo *pInfoList = new RenderingServerInfo[nServers];
03169 nServers = luxGetRenderingServersStatus( pInfoList, nServers );
03170
03171 wxString sTemp;
03172 wxTreeItemId idTempNode;
03173
03174 double sampDiv = luxStatistics("filmXres") * luxStatistics("filmYres");
03175
03176 for( int n1 = 0; n1 < nServers; n1++ )
03177 {
03178 luxTreeData *pTempData = new luxTreeData;
03179
03180 pTempData->m_SlaveFile = m_CurrentFile;
03181
03182 pTempData->m_SlaveName = wxString::FromUTF8(pInfoList[n1].name);
03183 pTempData->m_SlavePort = wxString::FromUTF8(pInfoList[n1].port);
03184 pTempData->m_SlaveID = wxString::FromUTF8(pInfoList[n1].sid);
03185
03186 pTempData->m_secsSinceLastContact = pInfoList[n1].secsSinceLastContact;
03187 pTempData->m_numberOfSamplesReceived = pInfoList[n1].numberOfSamplesReceived;
03188
03189 sTemp = wxString::Format( _("Slave: %s - Port: %s - ID: %s - Samples Per Pixel: %lf"),
03190 pTempData->m_SlaveName.c_str(),
03191 pTempData->m_SlavePort.c_str(),
03192 pTempData->m_SlaveID.c_str(),
03193 ( pInfoList[n1].numberOfSamplesReceived / sampDiv ) );
03194
03195 idTempNode = m_networkTreeCtrl->AppendItem( idRootNode, sTemp, -1, -1, pTempData );
03196 m_networkTreeCtrl->AppendItem( idTempNode, m_CurrentFile );
03197 if (pTempData->m_SlaveID == sidSelected)
03198 m_networkTreeCtrl->SelectItem(idTempNode);
03199 }
03200
03201 m_networkTreeCtrl->ExpandAll();
03202 delete[] pInfoList;
03203 }
03204
03205 void LuxGui::OnTreeSelChanged( wxTreeEvent& event )
03206 {
03207 wxTreeItemId idTreeNode = event.GetItem();
03208
03209 luxTreeData *pNodeData = (luxTreeData *)m_networkTreeCtrl->GetItemData( idTreeNode );
03210
03211 if ( pNodeData != NULL )
03212 {
03213 m_serverTextCtrl->SetValue( wxString::Format(_("%s:%s"), pNodeData->m_SlaveName.c_str(), pNodeData->m_SlavePort.c_str()));
03214 }
03215 }
03216
03217 void LuxGui::AddServer( void )
03218 {
03219 wxString sServer( m_serverTextCtrl->GetValue() );
03220
03221 if ( !sServer.empty() )
03222 {
03223 luxAddServer( sServer.char_str() );
03224
03225 UpdateNetworkTree();
03226 }
03227 }
03228
03229 void LuxGui::RemoveServer( void )
03230 {
03231 wxString sServer( m_serverTextCtrl->GetValue() );
03232
03233 if ( !sServer.empty() )
03234 {
03235 luxRemoveServer( sServer.char_str() );
03236
03237 UpdateNetworkTree();
03238 }
03239 }
03240
03241
03242 void LuxGui::OnSpin( wxSpinEvent& event )
03243 {
03244 switch (event.GetId()) {
03245 case ID_SERVER_UPDATE_INT:
03246 {
03247 luxSetNetworkServerUpdateInterval( event.GetPosition() );
03248 }
03249 case ID_GLAREBLADES:
03250 {
03251 m_Glare_blades = m_glarebladesSpin->GetValue();
03252
03253 if ( m_Glare_blades > GLARE_BLADES_MAX )
03254 m_Glare_blades = GLARE_BLADES_MAX;
03255 else if ( m_Glare_blades < GLARE_BLADES_MIN )
03256 m_Glare_blades = GLARE_BLADES_MIN;
03257
03258 UpdateParam(LUX_FILM, LUX_FILM_GLARE_BLADES, m_Glare_blades);
03259 }
03260 break;
03261 default:
03262 break;
03263 }
03264 }
03265
03266 void LuxGui::OnSpinText(wxCommandEvent& event) {
03267 switch (event.GetId()) {
03268 case ID_GLAREBLADES:
03269 {
03270 m_Glare_blades = m_glarebladesSpin->GetValue();
03271
03272 if ( m_Glare_blades > GLARE_BLADES_MAX )
03273 m_Glare_blades = GLARE_BLADES_MAX;
03274 else if ( m_Glare_blades < GLARE_BLADES_MIN )
03275 m_Glare_blades = GLARE_BLADES_MIN;
03276
03277 UpdateParam(LUX_FILM, LUX_FILM_GLARE_BLADES, m_Glare_blades);
03278 }
03279 break;
03280 default:
03281 break;
03282 }
03283 }
03284
03285
03286
03288
03289 bool LuxGui::CanStopRendering() {
03290 if(m_guiRenderState == RENDERING) {
03291
03292 if(wxMessageBox(wxT("Do you want to stop the current render and start a new one?"), wxT("Current file is still rendering"), wxYES_NO | wxICON_QUESTION, this) == wxNO)
03293 return false;
03294 }
03295 return true;
03296 }
03297
03298
03299 void LuxGui::StopRendering() {
03300 m_statusBar->SetStatusText(wxT(""), 0);
03301
03302 if(m_guiRenderState != WAITING) {
03303 if(m_flmloadThread)
03304 m_flmloadThread->join();
03305 delete m_flmloadThread;
03306 m_flmloadThread = NULL;
03307 if(m_flmsaveThread)
03308 m_flmsaveThread->join();
03309 delete m_flmsaveThread;
03310 m_flmsaveThread = NULL;
03311 if(m_guiRenderState != FINISHED && m_guiRenderState != TONEMAPPING) {
03312 if(m_updateThread)
03313 m_updateThread->join();
03314 delete m_updateThread;
03315 m_updateThread = NULL;
03316 luxExit();
03317 if(m_engineThread)
03318 m_engineThread->join();
03319 delete m_engineThread;
03320 m_engineThread = NULL;
03321 }
03322 luxError(LUX_NOERROR, LUX_INFO, "Freeing resources.");
03323 luxCleanup();
03324 ChangeRenderState(WAITING);
03325 m_renderOutput->Reset();
03326 }
03327 }
03328
03329 void LuxGui::OnOpen(wxCommandEvent& event) {
03330 if(!CanStopRendering())
03331 return;
03332
03333 wxFileDialog filedlg(this,
03334 _("Choose a scene file to open"),
03335 wxEmptyString,
03336 wxEmptyString,
03337 _("LuxRender scene files (*.lxs)|*.lxs|All files (*.*)|*.*"),
03338 wxFD_OPEN | wxFD_FILE_MUST_EXIST);
03339
03340 if(filedlg.ShowModal() == wxID_OK) {
03341 StopRendering();
03342 RenderScenefile(filedlg.GetPath());
03343 }
03344 }
03345
03346 void LuxGui::OnResumeFLM(wxCommandEvent &event) {
03347 if(!CanStopRendering())
03348 return;
03349
03350 wxFileDialog filedlg1(this,
03351 _("Choose a scene file to open"),
03352 wxEmptyString,
03353 wxEmptyString,
03354 _("LuxRender scene files (*.lxs)|*.lxs|All files (*.*)|*.*"),
03355 wxFD_OPEN | wxFD_FILE_MUST_EXIST);
03356
03357 if(filedlg1.ShowModal() != wxID_OK)
03358 return;
03359
03360 wxFileDialog filedlg2(this,
03361 _("Choose an FLM file to open"),
03362 wxEmptyString,
03363 wxEmptyString,
03364 _("LuxRender FLM files (*.flm)|*.flm|All files (*.*)|*.*"),
03365 wxFD_OPEN | wxFD_FILE_MUST_EXIST);
03366
03367 if(filedlg2.ShowModal() != wxID_OK)
03368 return;
03369
03370 StopRendering();
03371 RenderScenefile(filedlg1.GetPath(), filedlg2.GetPath());
03372 }
03373
03374 void LuxGui::OnLoadFLM(wxCommandEvent &event) {
03375 if(!CanStopRendering())
03376 return;
03377
03378 wxFileDialog filedlg(this,
03379 _("Choose an FLM file to open"),
03380 wxEmptyString,
03381 wxEmptyString,
03382 _("LuxRender FLM files (*.flm)|*.flm|All files (*.*)|*.*"),
03383 wxFD_OPEN | wxFD_FILE_MUST_EXIST);
03384
03385 if(filedlg.ShowModal() == wxID_OK) {
03386 StopRendering();
03387
03388 wxString filename = filedlg.GetPath();
03389 wxFileName fn(filename);
03390 SetTitle(wxT("LuxRender - ")+fn.GetName());
03391
03392
03393 m_progDialog = new wxProgressDialog(wxT("Loading FLM..."), wxT(""), 100, NULL, wxSTAY_ON_TOP);
03394 m_progDialog->Pulse();
03395 m_loadTimer->Start(1000, wxTIMER_CONTINUOUS);
03396
03397 delete m_flmloadThread;
03398 m_flmloadThread = new boost::thread(boost::bind(&LuxGui::FlmLoadThread, this, filename));
03399 }
03400 }
03401 void LuxGui::OnSaveFLM(wxCommandEvent &event) {
03402 if( !luxStatistics("sceneIsReady") && !luxStatistics("filmIsReady") )
03403 return;
03404 if( m_guiRenderState == WAITING )
03405 return;
03406
03407 wxFileDialog filedlg(this,
03408 _("Choose an FLM file to save to"),
03409 wxEmptyString,
03410 wxEmptyString,
03411 _("LuxRender FLM files (*.flm)|*.flm|All files (*.*)|*.*"),
03412 wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
03413
03414 if(filedlg.ShowModal() == wxID_OK) {
03415 wxString filename = filedlg.GetPath();
03416
03417 m_progDialog = new wxProgressDialog(wxT("Saving FLM..."), wxT(""), 100, NULL, wxSTAY_ON_TOP);
03418 m_progDialog->Pulse();
03419 m_saveTimer->Start(1000, wxTIMER_CONTINUOUS);
03420
03421 delete m_flmsaveThread;
03422 m_flmsaveThread = new boost::thread(boost::bind(&LuxGui::FlmSaveThread, this, filename));
03423 }
03424 }
03425
03426 void LuxGui::OnExit(wxCloseEvent& event) {
03427 m_renderTimer->Stop();
03428 m_statsTimer->Stop();
03429 m_loadTimer->Stop();
03430 m_saveTimer->Stop();
03431 m_netTimer->Stop();
03432
03433
03434 if(m_guiRenderState != WAITING) {
03435 if(m_flmloadThread)
03436 m_flmloadThread->join();
03437 delete m_flmloadThread;
03438 m_flmloadThread = NULL;
03439 if(m_flmsaveThread)
03440 m_flmsaveThread->join();
03441 delete m_flmsaveThread;
03442 m_flmsaveThread = NULL;
03443 if(m_guiRenderState == PARSING && m_progDialog) {
03444
03445 m_progDialog->Destroy();
03446 delete m_progDialog;
03447 m_progDialog = NULL;
03448 }
03449 if(m_guiRenderState != FINISHED && m_guiRenderState != TONEMAPPING) {
03450 if(m_updateThread)
03451 m_updateThread->join();
03452 delete m_updateThread;
03453 m_updateThread = NULL;
03454 luxExit();
03455 if(m_engineThread)
03456 m_engineThread->join();
03457 delete m_engineThread;
03458 m_engineThread = NULL;
03459 }
03460 luxError(LUX_NOERROR, LUX_INFO, "Freeing resources.");
03461 luxCleanup();
03462 }
03463
03464 Destroy();
03465 }
03466
03467 void LuxGui::OnError(wxLuxErrorEvent &event) {
03468 static const wxColour debugColour = wxColour(0, 0, 0);
03469 static const wxColour infoColour = wxColour(0, 255, 0);
03470 static const wxColour warningColour = wxColour(255, 128, 0);
03471 static const wxColour errorColour = wxColour(255, 0, 0);
03472 static const wxColour severeColour = wxColour(255, 0, 0);
03473
03474 std::stringstream ss("");
03475 ss << '[' << boost::posix_time::second_clock::local_time() << ' ';
03476 int severity = event.GetError()->GetSeverity();
03477 switch (severity) {
03478 case LUX_DEBUG:
03479 ss << "Debug: ";
03480 m_logTextCtrl->SetDefaultStyle(debugColour);
03481 break;
03482 case LUX_INFO:
03483 ss << "Info: ";
03484 m_logTextCtrl->SetDefaultStyle(infoColour);
03485 break;
03486 case LUX_WARNING:
03487 ss << "Warning: ";
03488 m_logTextCtrl->SetDefaultStyle(warningColour);
03489 break;
03490 case LUX_ERROR:
03491 ss << "Error: ";
03492 m_logTextCtrl->SetDefaultStyle(errorColour);
03493 break;
03494 case LUX_SEVERE:
03495 ss << "Severe error: ";
03496 m_logTextCtrl->SetDefaultStyle(severeColour);
03497 break;
03498 default:
03499 m_logTextCtrl->SetDefaultStyle(infoColour);
03500 }
03501 ss << event.GetError()->GetCode() << "] ";
03502
03503 m_logTextCtrl->AppendText(wxString::FromAscii(ss.str().c_str()));
03504
03505 m_logTextCtrl->SetDefaultStyle(*wxBLACK);
03506 ss.str("");
03507 ss << event.GetError()->GetMessage() << std::endl;
03508 m_logTextCtrl->AppendText(wxString::FromAscii(ss.str().c_str()));
03509 m_logTextCtrl->ShowPosition(m_logTextCtrl->GetLastPosition());
03510
03511
03512 if (m_showWarningDialog && severity > LUX_INFO) {
03513 m_showWarningDialog = false;
03514 wxMessageBox(wxT("There was an abnormal condition reported. Please, check the Log tab for more information."),
03515 wxT("LuxRender Notification"),
03516 wxOK | (severity == LUX_WARNING ? wxICON_EXCLAMATION : wxICON_ERROR), this);
03517 }
03518 }
03519
03520 void LuxGui::OnTimer(wxTimerEvent& event) {
03521 switch (event.GetId()) {
03522 case ID_RENDERUPDATE:
03523 if(m_updateThread == NULL && (luxStatistics("sceneIsReady") || luxStatistics("filmIsReady")) &&
03524 (m_guiWindowState == SHOWN || m_guiRenderState == FINISHED)) {
03525 luxError(LUX_NOERROR, LUX_INFO, "GUI: Updating framebuffer...");
03526 m_statusBar->SetStatusText(wxT("Tonemapping..."), 0);
03527 m_updateThread = new boost::thread(boost::bind(&LuxGui::UpdateThread, this));
03528 }
03529 break;
03530 case ID_STATSUPDATE:
03531 if(luxStatistics("sceneIsReady") || luxStatistics("filmIsReady")) {
03532 UpdateStatistics();
03533 if(m_guiRenderState == STOPPING && m_samplesSec == 0.0) {
03534
03535 luxError(LUX_NOERROR, LUX_INFO, "GUI: Updating framebuffer...");
03536 m_statusBar->SetStatusText(wxT("Tonemapping..."), 0);
03537 delete m_updateThread;
03538 m_updateThread = new boost::thread(boost::bind(&LuxGui::UpdateThread, this));
03539 m_statsTimer->Stop();
03540 luxPause();
03541 luxError(LUX_NOERROR, LUX_INFO, "Rendering stopped by user.");
03542 ChangeRenderState(STOPPED);
03543 }
03544 }
03545 break;
03546 case ID_LOADUPDATE:
03547 if (!m_progDialog)
03548 break;
03549 m_progDialog->Pulse();
03550 if(luxStatistics("sceneIsReady") || m_guiRenderState == FINISHED) {
03551 m_progDialog->Destroy();
03552 delete m_progDialog;
03553 m_progDialog = NULL;
03554 m_loadTimer->Stop();
03555
03556 if(luxStatistics("sceneIsReady")) {
03557
03558
03559 int curThreads = 1;
03560 while(curThreads < m_numThreads) {
03561 luxAddThread();
03562 curThreads++;
03563 }
03564
03565
03566 wxCommandEvent startEvent(wxEVT_COMMAND_MENU_SELECTED, ID_RESUMEITEM);
03567 GetEventHandler()->AddPendingEvent(startEvent);
03568
03569
03570 m_outputNotebook->Enable( true );
03571 ResetToneMappingFromFilm( false );
03572 ResetLightGroupsFromFilm( false );
03573 Refresh();
03574 }
03575 } else if( luxStatistics("filmIsReady") ) {
03576 m_progDialog->Destroy();
03577 delete m_progDialog;
03578 m_progDialog = NULL;
03579 m_loadTimer->Stop();
03580
03581 if(m_flmloadThread) {
03582 m_flmloadThread->join();
03583 delete m_flmloadThread;
03584 m_flmloadThread = NULL;
03585 }
03586
03587 ChangeRenderState(TONEMAPPING);
03588
03589
03590 m_outputNotebook->Enable( true );
03591 ResetToneMappingFromFilm( false );
03592 ResetLightGroupsFromFilm( false );
03593
03594 luxUpdateFramebuffer();
03595 m_renderOutput->Reload();
03596
03597 UpdateStatistics();
03598
03599 Refresh();
03600 }
03601 break;
03602 case ID_SAVEUPDATE:
03603 if (!m_progDialog)
03604 break;
03605 m_progDialog->Pulse();
03606 break;
03607 case ID_NETUPDATE:
03608 UpdateNetworkTree();
03609 break;
03610 }
03611 }
03612
03613 void LuxGui::OnCommand(wxCommandEvent &event) {
03614 if(event.GetEventType() == wxEVT_LUX_TONEMAPPED) {
03615
03616 if (m_updateThread)
03617 m_updateThread->join();
03618 delete m_updateThread;
03619 m_updateThread = NULL;
03620 m_statusBar->SetStatusText(wxT(""), 0);
03621 m_renderOutput->Reload();
03622 m_HistogramWindow->Update();
03623
03624 } else if(event.GetEventType() == wxEVT_LUX_PARSEERROR) {
03625 m_progDialog->Destroy();
03626 delete m_progDialog;
03627 m_progDialog = NULL;
03628 m_loadTimer->Stop();
03629
03630 wxMessageBox(wxT("Scene file parse error.\nSee log for details."), wxT("Error"), wxOK | wxICON_ERROR, this);
03631 ChangeRenderState(FINISHED);
03632 } else if(event.GetEventType() == wxEVT_LUX_FLMLOADERROR) {
03633 wxMessageBox(wxT("FLM load error.\nSee log for details."), wxT("Error"), wxOK | wxICON_ERROR, this);
03634 if(m_flmloadThread) {
03635 m_flmloadThread->join();
03636 delete m_flmloadThread;
03637 m_flmloadThread = NULL;
03638 }
03639 ChangeRenderState(WAITING);
03640 } else if(event.GetEventType() == wxEVT_LUX_FINISHED && m_guiRenderState == RENDERING) {
03641
03642
03643 ChangeRenderState(FINISHED);
03644
03645 m_renderTimer->Stop();
03646 #ifdef __WXOSX_COCOA__
03647 wxTimerEvent rendUpdEvent(*m_renderTimer);
03648 rendUpdEvent.SetId(ID_RENDERUPDATE);
03649 #else
03650 wxTimerEvent rendUpdEvent(ID_RENDERUPDATE, GetId());
03651 #endif
03652 GetEventHandler()->AddPendingEvent(rendUpdEvent);
03653 m_statsTimer->Stop();
03654 #ifdef __WXOSX_COCOA__
03655 wxTimerEvent statUpdEvent(*m_renderTimer);
03656 rendUpdEvent.SetId(ID_RENDERUPDATE);
03657 #else
03658 wxTimerEvent statUpdEvent(ID_STATSUPDATE, GetId());
03659 #endif
03660 GetEventHandler()->AddPendingEvent(statUpdEvent);
03661 } else if( event.GetEventType() == wxEVT_LUX_SAVEDFLM ) {
03662 m_progDialog->Destroy();
03663 delete m_progDialog;
03664 m_progDialog = NULL;
03665 m_saveTimer->Stop();
03666
03667 if (m_flmsaveThread)
03668 m_flmsaveThread->join();
03669 delete m_flmsaveThread;
03670 m_flmsaveThread = NULL;
03671 }
03672 }
03673
03674 #if defined (__WXMSW__) || defined (__WXGTK__)
03675 void lux::LuxGui::OnIconize( wxIconizeEvent& event )
03676 {
03677 if(!event.Iconized())
03678 m_guiWindowState = SHOWN;
03679 else
03680 m_guiWindowState = HIDDEN;
03681 }
03682 #endif
03683
03684 void LuxGui::RenderScenefile(wxString sceneFilename, wxString flmFilename) {
03685
03686 boost::filesystem::path fullPath(boost::filesystem::initial_path());
03687 fullPath = boost::filesystem::system_complete(boost::filesystem::path(flmFilename.fn_str(), boost::filesystem::native));
03688
03689
03690 luxOverrideResumeFLM(fullPath.string().c_str());
03691
03692
03693 RenderScenefile(sceneFilename);
03694 }
03695
03696 void LuxGui::RenderScenefile(wxString filename) {
03697 wxFileName fn(filename);
03698 SetTitle(wxT("LuxRender - ")+fn.GetName());
03699
03700
03701 m_CurrentFile = filename;
03702
03703 ChangeRenderState(PARSING);
03704
03705
03706
03707 m_progDialog = new wxProgressDialog(wxT("Loading scene..."), wxT(""), 100, NULL, wxSTAY_ON_TOP);
03708 m_progDialog->Pulse();
03709 m_loadTimer->Start(1000, wxTIMER_CONTINUOUS);
03710
03711
03712 m_showWarningDialog = true;
03713
03714
03715 delete m_engineThread;
03716 m_engineThread = new boost::thread(boost::bind(&LuxGui::EngineThread, this, filename));
03717 }
03718
03719 void LuxGui::OnSelection(wxViewerEvent& event) {
03720 if(m_viewerToolBar->GetToolState(ID_ZOOMTOOL) == true) {
03721
03722 m_renderOutput->SetZoom(event.GetSelection().get());
03723 m_renderOutput->SetSelection(NULL);
03724 } else if(m_viewerToolBar->GetToolState(ID_REFINETOOL) == true) {
03725
03726 m_renderOutput->SetHighlight(event.GetSelection().get());
03727 m_renderOutput->SetSelection(NULL);
03728
03729 }
03730 }
03731
03732 void LuxGui::EngineThread(wxString filename) {
03733 boost::filesystem::path fullPath(boost::filesystem::initial_path());
03734 fullPath = boost::filesystem::system_complete(boost::filesystem::path(filename.fn_str(), boost::filesystem::native));
03735
03736 if (chdir(fullPath.branch_path().string().c_str()) == -1) {
03737
03738 std::stringstream ss("");
03739 ss << "Unable to change directory to: '" <<
03740 fullPath.branch_path().string().c_str() << "'";
03741 luxError(LUX_SYSTEM, LUX_ERROR, ss.str().c_str());
03742 }
03743
03744
03745 srand(time(NULL));
03746
03747
03748 if (filename == wxString::FromAscii("-"))
03749 ParseFile(filename.fn_str());
03750 else
03751 ParseFile(fullPath.leaf().c_str());
03752
03753 if (luxStatistics("terminated"))
03754 return;
03755
03756 if(!luxStatistics("sceneIsReady")) {
03757 wxCommandEvent errorEvent(wxEVT_LUX_PARSEERROR, GetId());
03758 GetEventHandler()->AddPendingEvent(errorEvent);
03759
03760 luxWait();
03761 } else {
03762 luxWait();
03763
03764 luxError(LUX_NOERROR, LUX_INFO, "Rendering done.");
03765 wxCommandEvent endEvent(wxEVT_LUX_FINISHED, GetId());
03766 GetEventHandler()->AddPendingEvent(endEvent);
03767 }
03768 }
03769
03770 void LuxGui::UpdateThread() {
03771 luxUpdateFramebuffer();
03772
03773 wxCommandEvent endEvent(wxEVT_LUX_TONEMAPPED, GetId());
03774 GetEventHandler()->AddPendingEvent(endEvent);
03775 }
03776
03777 void LuxGui::FlmLoadThread(wxString filename) {
03778 luxLoadFLM(filename.fn_str());
03779 if(!luxStatistics("filmIsReady")) {
03780 wxCommandEvent errorEvent(wxEVT_LUX_FLMLOADERROR, GetId());
03781 GetEventHandler()->AddPendingEvent(errorEvent);
03782 }
03783 }
03784
03785 void LuxGui::FlmSaveThread(wxString filename) {
03786 luxSaveFLM(filename.fn_str());
03787 wxCommandEvent savedEvent(wxEVT_LUX_SAVEDFLM, GetId());
03788 GetEventHandler()->AddPendingEvent(savedEvent);
03789 }
03790
03791 void LuxGui::SetRenderThreads(int num) {
03792 if(luxStatistics("sceneIsReady")) {
03793 if(num > m_numThreads) {
03794 for(; num > m_numThreads; m_numThreads++)
03795 luxAddThread();
03796 } else {
03797 for(; num < m_numThreads; m_numThreads--)
03798 luxRemoveThread();
03799 }
03800 } else {
03801 m_numThreads = num;
03802 }
03803
03804 m_ThreadText->SetLabel( wxString::Format( _("Threads: %02d "), m_numThreads ) );
03805 }
03806
03807 void LuxGui::UpdateStatistics() {
03808 m_samplesSec = luxStatistics("samplesSec");
03809 int samplesSec = Floor2Int(m_samplesSec);
03810 int samplesTotSec = Floor2Int(luxStatistics("samplesTotSec"));
03811 int secElapsed = Floor2Int(luxStatistics("secElapsed"));
03812 double samplesPx = luxStatistics("samplesPx");
03813 int efficiency = Floor2Int(luxStatistics("efficiency"));
03814 int EV = luxStatistics("filmEV");
03815
03816 int secs = (secElapsed) % 60;
03817 int mins = (secElapsed / 60) % 60;
03818 int hours = (secElapsed / 3600);
03819
03820 wxString stats;
03821 stats.Printf(wxT("%02d:%02d:%02d - %d S/s - %d TotS/s - %.2f S/px - %i%% eff - EV = %d"),
03822 hours, mins, secs, samplesSec, samplesTotSec, samplesPx, efficiency, EV);
03823 m_statusBar->SetStatusText(stats, 1);
03824 }
03825
03826
03827
03828 BEGIN_EVENT_TABLE(LuxOutputWin, wxWindow)
03829 #ifndef __WXOSX_COCOA__
03830 EVT_PAINT (LuxOutputWin::OnPaint)
03831 #endif
03832 END_EVENT_TABLE()
03833
03834 LuxOutputWin::LuxOutputWin(wxWindow *parent)
03835 : wxScrolledWindow(parent, wxID_ANY, wxDefaultPosition, wxSize(-1, -1)), wxViewerBase() {
03836 }
03837
03838 wxWindow* LuxOutputWin::GetWindow() {
03839 return this;
03840 }
03841
03842 void LuxOutputWin::Reload() {
03843 Refresh();
03844 }
03845
03846 void LuxOutputWin::OnDraw(wxDC &dc) {
03847 if (luxStatistics("sceneIsReady") || luxStatistics("filmIsReady")) {
03848 int w = luxStatistics("filmXres"), h = luxStatistics("filmYres");
03849 SetVirtualSize(w, h);
03850 SetScrollRate(1,1);
03851 unsigned char* fb = luxFramebuffer();
03852 dc.DrawBitmap(wxBitmap(wxImage(w, h, fb, true)), 0, 0, false);
03853 }
03854 }
03855
03856
03857
03858 void lux::LuxGuiErrorHandler(int code, int severity, const char *msg) {
03859
03860 if (copyLog2Console)
03861 luxErrorPrint(code, severity, msg);
03862
03863 boost::shared_ptr<LuxError> error(new LuxError(code, severity, msg));
03864 wxLuxErrorEvent errorEvent(error, wxEVT_LUX_ERROR);
03865 wxTheApp->GetTopWindow()->GetEventHandler()->AddPendingEvent(errorEvent);
03866 }