MainWindow::MainWindow(Scene *scene, QWidget *parent) :
QMainWindow(parent),
ui_(new Ui::MainWindow),
scene_(scene)
{
ui_->setupUi(this);
gl_widget_ = new GLWidget(scene_);
ui_->opengl_box->layout()->addWidget(gl_widget_);
// connect(gl_widget_,SIGNAL(Changed()),this,SLOT(SceneChanged()));
outer_view_widget_ = new OuterViewWidget(scene_);
ui_->outerview_box->layout()->addWidget(outer_view_widget_);
connect(outer_view_widget_,SIGNAL(Changed()),this,SLOT(SceneChanged()));
ray_tracing_widget_ = new RayTracingWidget(scene_);
ui_->raytracing_box->layout()->addWidget(ray_tracing_widget_);
connect(ray_tracing_widget_,SIGNAL(Changed()),this,SLOT(SceneChanged()));
connect(ui_->recursion_spinBox,SIGNAL(valueChanged(int)),ray_tracing_widget_,SLOT(RayTracingLevel(int)));
const int default_fov_slider = ((100*(kDefaultFov-kMinFov))/(kMaxFov-kMinFov));
ui_->fov_slider->setValue(default_fov_slider);
const int default_near_slider = ((100*(kDefaultNear-kMinNear))/(kMaxNear-kMinNear));
ui_->near_slider->setValue(default_near_slider);
const int default_far_slider = ((100*(kDefaultFar-kMinFar))/(kMaxFar-kMinFar));
ui_->far_slider->setValue(default_far_slider);
connect(ui_->fov_slider,SIGNAL(valueChanged(int)),this,SLOT(SetFov(int)));
connect(ui_->near_slider,SIGNAL(valueChanged(int)),this,SLOT(SetNear(int)));
connect(ui_->far_slider,SIGNAL(valueChanged(int)),this,SLOT(SetFar(int)));
connect(ui_->light_check,SIGNAL(toggled(bool)),this,SLOT(SetLight(bool)));
connect(ui_->track_ray_check,SIGNAL(toggled(bool)),this,SLOT(SetTrackRay(bool)));
SetTrackRay(ui_->track_ray_check->isChecked());
connect(ui_->fast_render_check,SIGNAL(toggled(bool)),ray_tracing_widget_,SLOT(ToggleFastRenderOnly(bool)));
ray_tracing_widget_->ToggleFastRenderOnly(ui_->fast_render_check->isChecked());
// connect(ui_->image_size_comboBox,SIGNAL(currentIndexChanged(int)),ray_tracing_widget_,SLOT(SelectImageSize(int)));
// ray_tracing_widget_->SelectImageSize(ui_->image_size_comboBox->currentIndex());
connect(ui_->scene_comboBox,SIGNAL(currentIndexChanged(int)),this,SLOT(LoadScene(int)));
// connect(ui_->load1_pushButton,SIGNAL(clicked()),this,SLOT(LoadScene1()));
// connect(ui_->load2_pushButton_2,SIGNAL(clicked()),this,SLOT(LoadScene2()));
// connect(gl_widget_,SIGNAL(Moving(bool)),ray_tracing_widget_,SLOT(SetMoving(bool)));
connect(gl_widget_,SIGNAL(MouseMoved(QMouseEvent*)),ray_tracing_widget_,SLOT(MouseMoved(QMouseEvent*)));
connect(gl_widget_,SIGNAL(MousePressed(QMouseEvent*)),ray_tracing_widget_,SLOT(MousePressed(QMouseEvent*)));
connect(gl_widget_,SIGNAL(MouseReleased(QMouseEvent*)),ray_tracing_widget_,SLOT(MouseReleased(QMouseEvent*)));
connect(gl_widget_,SIGNAL(Wheel(QWheelEvent*)),ray_tracing_widget_,SLOT(Wheel(QWheelEvent*)));
connect(ui_->render_button,SIGNAL(clicked()),this,SLOT(FinalRender()));
SceneChanged();
}
void MainWindow::LoadScene(int s)
{
scene_->clearScene();
switch(s){
case 1:
scene_->loadDefaultScene1();
break;
case 2:
scene_->loadDefaultScene2();
break;
default:
scene_->loadScene(ui_->scene_comboBox->currentText());
break;
}
SceneChanged();
}
/*========================================================================*/
ObjectCallback *ObjectCallbackDefine(PyMOLGlobals * G, ObjectCallback * obj,
PyObject * pobj, int state)
{
#ifdef _PYMOL_NOPY
return NULL;
#else
ObjectCallback *I = NULL;
if(!obj) {
I = ObjectCallbackNew(G);
} else {
I = obj;
}
if(state < 0)
state = I->NState;
if(I->NState <= state) {
VLACheck(I->State, ObjectCallbackState, state);
I->NState = state + 1;
}
if(I->State[state].PObj) {
Py_DECREF(I->State[state].PObj);
}
I->State[state].is_callable = PyCallable_Check(pobj);
I->State[state].PObj = pobj;
Py_INCREF(pobj);
if(I->NState <= state)
I->NState = state + 1;
if(I) {
ObjectCallbackRecomputeExtent(I);
}
SceneChanged(G);
SceneCountFrames(G);
return (I);
#endif
}
void MainWindow::SetTrackRay(const bool value)
{
scene_->track_one_ray = value;
SceneChanged();
}
void MainWindow::SetLight(const bool value)
{
scene_->calculate_advanced_light = value;
SceneChanged();
}
void MainWindow::SetFar(const int value)
{
scene_->far_plane_z = ((kMaxFar-kMinFar)*(float(value)/100.0f))+kMinFar;
scene_->calcFrustum();
SceneChanged();
}
void MainWindow::SetFov(const int value)
{
scene_->fov = ((kMaxFov-kMinFov)*(float(value)/100.0f))+kMinFov;
scene_->calcFrustum();
SceneChanged();
}
