int main(int argc, char* argv[])
{
/****************************************/
/* Initialize GLUT and create window */
/****************************************/
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowPosition(80, 80);
glutInitWindowSize(windowWidth, windowHeight);
int main_window = glutCreateWindow("Rendering Test");
glewInit();
glutDisplayFunc(myGlutDisplay);
glutMotionFunc(myGlutMotion);
glutReshapeFunc(myGlutReshape);
glutPassiveMotionFunc(myGlutPassiveMotion);
glutMouseWheelFunc(myGlutMouseWheel);
glutMouseFunc(myGlutMouse);
glutKeyboardFunc(myGlutKeyboard);
glEnable(GL_DEPTH_TEST);
/****************************************/
/* Here's the GLSL code */
/****************************************/
geomFb.AddExtraDrawTexture(GL_RGBA32F, GL_RGBA, GL_FLOAT, GL_NEAREST, GL_CLAMP_TO_EDGE);
geomFb.AddExtraDrawTexture(GL_RGBA32F, GL_RGBA, GL_FLOAT, GL_NEAREST, GL_CLAMP_TO_EDGE);
glClampColor(GL_CLAMP_READ_COLOR, GL_FALSE);
glClampColor(GL_CLAMP_VERTEX_COLOR, GL_FALSE);
glClampColor(GL_CLAMP_FRAGMENT_COLOR, GL_FALSE);
/****************************************/
/* Loading Data */
/****************************************/
ssaoPass.Build();
blurPass.Build();
lightingPass.Build();
#ifdef TRACK
trackBall.SetRotationMatrix(MyMatrixf::RotateMatrix(90, 1, 0, 0));
trackBall.ScaleMultiply(1.3);
MyTracks tractData;
MyBitmap bitmap;
bitmap.Open("..\\SSAO\\data\\diverging.bmp");
gTex = MyTexture::MakeGLTexture(&bitmap);
//tractData.Read("data\\normal_s3.data");
tractData.Read("C:\\Users\\GuohaoZhang\\Dropbox\\data\\normal_s4.tensorinfo");
tractData.AppendTrackColor("C:\\Users\\GuohaoZhang\\Dropbox\\data\\normal_s4_boy.data");
tractData.Save("C:\\Users\\GuohaoZhang\\Dropbox\\data\\normal_s4_tensorboy.trk");
return 1;
tractData.Read("C:\\Users\\GuohaoZhang\\Dropbox\\data\\normal_s3_tensorboy_RevZ.trk");
//tractData.Read("data\\normal_s5.tensorinfo");
//tractData.Read("data\\normal_s5_2pt.tensorinfo");
//tractData.Read("data\\cFile.tensorinfo");
//tractData.Read("C:\\Users\\GuohaoZhang\\Desktop\\tmpdata\\dti.trk");
//tractData.Read("C:\\Users\\GuohaoZhang\\Desktop\\tmpdata\\ACR.trk");
//tractData.Read("dti_20_0995.data");
track.SetTracts(&tractData);
track.SetTexture(gTex);
//track.SetShape(MyTractVisBase::TRACK_SHAPE_LINE);
track.SetShape(MyTractVisBase::TrackShape(trackShape + 1));
track.ComputeGeometry();
track.LoadShader();
track.LoadGeometry();
trackLine.SetTracts(&tractData);
trackLine.SetShape(MyTractVisBase::TRACK_SHAPE_LINE);
trackLine.ComputeGeometry();
trackLine.LoadShader();
trackLine.LoadGeometry();
track.SetToInfluence(tractEncoding);
MyVec3f center = track.GetTracts()->GetBoundingBox().GetCenter();
cout << "Center: " << center[0] << ", " << center[1] << ", " << center[2] << endl;
#endif
#ifdef MESH
gTex = MakeTexture("2dir_128.bmp");
meshPrecision = 0.01;
//mesh.Read("data\\lh.trans.pial.obj");
mesh.Read("data\\lh.pial.DK.fusiform_trans.obj");
//mesh.Read("lh.pial.obj");
//mesh.Read("data\\lh.trans.pial.obj");
//MyMesh mesh2;
//mesh2.Read("data\\rh.trans.pial.obj");
//mesh.Merge(mesh2);
mesh.MergeVertices(meshPrecision);
mesh.GenPerVertexNormal();
//mesh.Write("data\\rh.trans_wnormal.pial.obj");
mesh.CompileShader();
mesh.mTexture = gTex;
mesh.Build();
//glEnable(GL_BLEND);
//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
#endif
/****************************************/
/* Here's the GLUI code */
/****************************************/
printf("GLUI version: %3.2f\n", GLUI_Master.get_version());
GLUI_Master.set_glutDisplayFunc(myGlutDisplay);
GLUI_Master.set_glutReshapeFunc(myGlutReshape);
GLUI_Master.set_glutKeyboardFunc(myGlutKeyboard);
GLUI_Master.set_glutSpecialFunc(NULL);
GLUI_Master.set_glutMouseFunc(myGlutMouse);
glui = GLUI_Master.create_glui_subwindow(main_window,
GLUI_SUBWINDOW_RIGHT);
glui->set_main_gfx_window(main_window);
// add panels for parameter tunning
panel[0] = new GLUI_Panel(glui, "Rendering Mode");
GLUI_Spinner* dsrSpinner = new GLUI_Spinner(
panel[0], "DSR Index", GLUI_SPINNER_INT,
&dsrIndex, -1, changeDsr);
dsrSpinner->set_int_limits(1, 4);
GLUI_RadioGroup* radioGroup = new GLUI_RadioGroup(panel[0],
&renderIdx, 0, switchRenderMode);
new GLUI_RadioButton(radioGroup, "Geometry Pass");
new GLUI_RadioButton(radioGroup, "SSAO Pass");
new GLUI_RadioButton(radioGroup, "Blur Pass");
new GLUI_RadioButton(radioGroup, "Lighting Pass");
new GLUI_Button(panel[0], "Reset All", -1, resetRenderingParameters);
new GLUI_Button(panel[0], "Reset Shaders", -1, resetShaders);
// geometry pass
panel[1] = new GLUI_Panel(glui, "Geometry Pass");
new GLUI_Button(panel[1], "Reset", 0, resetRenderingParameters);
new GLUI_Checkbox(panel[1], "Cull Backface",
&cullface, -1, changeCullface);
new GLUI_Checkbox(panel[1], "Draw Tracts",
&bdrawTracks, -1, reRender);
new GLUI_Checkbox(panel[1], "Draw Axes",
&bdrawAxes, -1, reRender);
#ifdef MESH
GLUI_Spinner* meshPrecisionSpinner = new GLUI_Spinner
(panel[1], "Mesh Detail", GLUI_SPINNER_FLOAT,
&meshPrecision, -1, changeMeshPrecision);
meshPrecisionSpinner->set_float_limits(0.01, 10);
#endif
#ifdef TRACK
GLUI_RadioGroup* shapeRadioGroup = new GLUI_RadioGroup(panel[1],
&trackShape, 0, changeTrackShape);
new GLUI_RadioButton(shapeRadioGroup, "Line");
new GLUI_RadioButton(shapeRadioGroup, "Tube");
new GLUI_RadioButton(shapeRadioGroup, "Superquadric");
GLUI_RadioGroup* encodingRadioGroup = new GLUI_RadioGroup(panel[1],
&tractEncoding, 0, changeTractEncoding);
new GLUI_RadioButton(encodingRadioGroup, "Boy's");
new GLUI_RadioButton(encodingRadioGroup, "Color");
new GLUI_RadioButton(encodingRadioGroup, "Size");
new GLUI_RadioButton(encodingRadioGroup, "Texture");
tubeParameterPanel = new GLUI_Panel(panel[1], "Tube Parameters");
new GLUI_StaticText(tubeParameterPanel, "Tube Radius");
GLUI_Scrollbar* tubeRadiusSlider = new GLUI_Scrollbar
(tubeParameterPanel, "Tube Radius", GLUI_SCROLL_HORIZONTAL,
&(track.mTrackRadius), -1, reRender);
tubeRadiusSlider->set_float_limits(0, 1);
GLUI_Spinner* boxOpacitySpinner = new GLUI_Spinner(
tubeParameterPanel, "Opacity Index", GLUI_SPINNER_INT,
&boxOpacityIndex, -1, reRender);
boxOpacitySpinner->set_int_limits(0, 2);
GLUI_Spinner* trackFaceSpinner = new GLUI_Spinner(
tubeParameterPanel, "Number Faces", GLUI_SPINNER_INT,
&trackFaces, -1, changeTrackShape);
trackFaceSpinner->set_int_limits(2, 20);
trackFaceSpinner->set_int_val(track.GetNumberFaces());
#endif
// ssao pass
panel[2] = new GLUI_Panel(glui, "SSAO Pass");
new GLUI_Button(panel[2], "Reset", 1, resetRenderingParameters);
new GLUI_StaticText(panel[2], "Sample Radius");
GLUI_Scrollbar* sampleRadiusSlider = new GLUI_Scrollbar
(panel[2], "Sample Radius", GLUI_SCROLL_HORIZONTAL,
&(ssaoPass.mSampleRadius), -1, reRender);
sampleRadiusSlider->set_float_limits(0, 100);
new GLUI_StaticText(panel[2], "Occlusion Power");
GLUI_Scrollbar* occulusioPowerSlider = new GLUI_Scrollbar
(panel[2], "Occlusion Power", GLUI_SCROLL_HORIZONTAL,
&(ssaoPass.mOcclusionPower), -1, reRender);
occulusioPowerSlider->set_float_limits(0, 4);
// blur pass
panel[3] = new GLUI_Panel(glui, "Blur Pass");
new GLUI_Button(panel[3], "Reset", 2, resetRenderingParameters);
GLUI_Spinner* blurRadiusSpinner = new GLUI_Spinner
(panel[3], "Blur Radius (Pixel)", GLUI_SPINNER_INT,
&(blurPass.mBlurRadius), -1, reRender);
blurRadiusSpinner->set_int_limits(0, 20);
// lighting pass
lightingPass.mAmbient = 0.4;
lightingPass.mDiffuse = 0.6;
lightingPass.mSpecular = 0;
lightingPass.mUseSsao = 1;
panel[4] = new GLUI_Panel(glui, "Lighting Pass");
new GLUI_Button(panel[4], "Reset", 3, resetRenderingParameters);
new GLUI_Checkbox(panel[4], "Normalize Intensity",
&lightComponentRatioControl, -1, changeLightComponent);
new GLUI_Checkbox(panel[4], "Use SSAO",
&lightingPass.mUseSsao, -1, changeLightComponent);
new GLUI_StaticText(panel[4], "Light Intensity");
GLUI_Scrollbar* lightIntensitySlider = new GLUI_Scrollbar
(panel[4], "Light Intensity", GLUI_SCROLL_HORIZONTAL,
&(lightingPass.mLightItensity), -1, reRender);
lightIntensitySlider->set_float_limits(0, 10);
new GLUI_StaticText(panel[4], "Ambient");
lightComponentSlider[0] = new GLUI_Scrollbar
(panel[4], "Ambient", GLUI_SCROLL_HORIZONTAL,
&(lightingPass.mAmbient), 0, changeLightComponent);
lightComponentSlider[0]->set_float_limits(0, 1);
new GLUI_StaticText(panel[4], "Diffuse");
lightComponentSlider[1] = new GLUI_Scrollbar
(panel[4], "Diffuse", GLUI_SCROLL_HORIZONTAL,
&(lightingPass.mDiffuse), 1, changeLightComponent);
lightComponentSlider[1]->set_float_limits(0, 1);
new GLUI_StaticText(panel[4], "Specular");
lightComponentSlider[2] = new GLUI_Scrollbar
(panel[4], "Specular", GLUI_SCROLL_HORIZONTAL,
&(lightingPass.mSpecular), 2, changeLightComponent);
lightComponentSlider[2]->set_float_limits(0, 1);
new GLUI_StaticText(panel[4], "Shininess");
GLUI_Scrollbar* shininessSlider = new GLUI_Scrollbar
(panel[4], "Shininess", GLUI_SCROLL_HORIZONTAL,
&(lightingPass.mShininess), -1, changeLightComponent);
shininessSlider->set_float_limits(0, 128);
// set init state right
switchRenderMode(renderIdx);
glutMainLoop();
return EXIT_SUCCESS;
}
void UpdateDriverSpinnerGUI()
{
driver_spinner->set_int_val(cur_driver);
//driver_spinner->set_int_val(cur_driver);
UpdateDriverInfoGUI();
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowPosition(50, 50);
glutInitWindowSize(WIN_WIDTH, WIN_HEIGHT);
main_window = glutCreateWindow("OBJ Loader");
glutDisplayFunc(myGlutDisplay);
glutReshapeFunc(myGlutReshape);
glutMouseFunc(myGlutMouse);
glutMotionFunc(myGlutMotion);
initScene();
Objects.push_back(Object());
glui = GLUI_Master.create_glui("OBJ Loader GUI", 0, 600, 50);
GLUI_Panel *objPanel = glui->add_panel("");
GLUI_Panel *objPanel2 = glui->add_panel_to_panel(objPanel, "", 0);
objFileNameTextField = glui->add_edittext_to_panel(objPanel2, "Filename:",GLUI_EDITTEXT_TEXT,NULL,OBJ_TEXTFIELD,textCB);
objFileNameTextField->set_text("cow");
glui->add_button_to_panel(objPanel2, "Load", LOAD_BUTTON, buttonCB);
glui->add_button_to_panel(objPanel2, "Screenshot (or it didn't happen)", SCREENSHOT, buttonCB);
glui->add_column_to_panel(objPanel, 0);
GLUI_Panel *projPanel = glui->add_panel_to_panel(objPanel, "", 0);
GLUI_RadioGroup *projGroup = glui->add_radiogroup_to_panel(projPanel, (int*) &projType, -1, projCB);
glui->add_radiobutton_to_group(projGroup, "Orthographic");
glui->add_radiobutton_to_group(projGroup, "Perspective");
projGroup->set_int_val(ORTHO);
GLUI_Spinner *fovSpinner = glui->add_spinner_to_panel(projPanel, "FOV", GLUI_SPINNER_INT, &fov, FOV, projCB);
fovSpinner->set_int_limits(FOVMIN, FOVMAX);
fovSpinner->set_int_val(30);
glui->add_column_to_panel(projPanel, 0);
GLUI_Translation *scale = glui->add_translation_to_panel(projPanel, "Scale", GLUI_TRANSLATION_Y , &scaleFactor, -1, (GLUI_Update_CB) projCB);
scale->set_speed(0.005f);
GLUI_Panel *lightingPanel = glui->add_panel("", 0);
GLUI_Panel *objMaterialPanel = glui->add_panel_to_panel(lightingPanel, "Object material");
GLUI_Panel *objDiffusePanel = glui->add_panel_to_panel(objMaterialPanel, "Diffuse");
GLUI_Spinner *kdRedValue = glui->add_spinner_to_panel(objDiffusePanel, "Red", GLUI_SPINNER_FLOAT, &objectMat.diffuse[0], 0, colorCB);
kdRedValue->set_float_limits(0.f, 1.f);
kdRedValue->set_float_val(1.f);
GLUI_Spinner *kdGreenValue = glui->add_spinner_to_panel(objDiffusePanel, "Green", GLUI_SPINNER_FLOAT, &objectMat.diffuse[1], 0, colorCB);
kdGreenValue->set_float_limits(0.f, 1.f);
kdGreenValue->set_float_val(1.f);
GLUI_Spinner *kdBlueValue = glui->add_spinner_to_panel(objDiffusePanel, "Blue", GLUI_SPINNER_FLOAT, &objectMat.diffuse[2], 0, colorCB);
kdBlueValue->set_float_limits(0.f, 1.f);
kdBlueValue->set_float_val(1.f);
GLUI_Panel *objAmbientPanel = glui->add_panel_to_panel(objMaterialPanel, "Ambient");
GLUI_Spinner *kaRedValue = glui->add_spinner_to_panel(objAmbientPanel, "Red", GLUI_SPINNER_FLOAT, &objectMat.ambient[0], 0, colorCB);
kaRedValue->set_float_limits(0.f, 1.f);
kaRedValue->set_float_val(1.f);
GLUI_Spinner *kaGreenValue = glui->add_spinner_to_panel(objAmbientPanel, "Green", GLUI_SPINNER_FLOAT, &objectMat.ambient[1], 0, colorCB);
kaGreenValue->set_float_limits(0.f, 1.f);
kaGreenValue->set_float_val(1.f);
GLUI_Spinner *kaBlueValue = glui->add_spinner_to_panel(objAmbientPanel, "Blue", GLUI_SPINNER_FLOAT, &objectMat.ambient[2], 0, colorCB);
kaBlueValue->set_float_limits(0.f, 1.f);
kaBlueValue->set_float_val(1.f);
GLUI_Panel *objSpecularPanel = glui->add_panel_to_panel(objMaterialPanel, "Specular");
GLUI_Spinner *ksRedValue = glui->add_spinner_to_panel(objSpecularPanel, "Red", GLUI_SPINNER_FLOAT, &objectMat.specular[0], 0, colorCB);
ksRedValue->set_float_limits(0.f, 1.f);
ksRedValue->set_float_val(1.f);
GLUI_Spinner *ksGreenValue = glui->add_spinner_to_panel(objSpecularPanel, "Green", GLUI_SPINNER_FLOAT, &objectMat.specular[1], 0, colorCB);
ksGreenValue->set_float_limits(0.f, 1.f);
ksGreenValue->set_float_val(1.f);
GLUI_Spinner *ksBlueValue = glui->add_spinner_to_panel(objSpecularPanel, "Blue", GLUI_SPINNER_FLOAT, &objectMat.specular[2], 0, colorCB);
ksBlueValue->set_float_limits(0.f, 1.f);
ksBlueValue->set_float_val(1.f);
glui->add_column_to_panel(lightingPanel,0);
GLUI_Panel *lightPanel = glui->add_panel_to_panel(lightingPanel, "Light source");
GLUI_Panel *lightDiffusePanel = glui->add_panel_to_panel(lightPanel, "Diffuse");
GLUI_Spinner *ldRedValue = glui->add_spinner_to_panel(lightDiffusePanel, "Red", GLUI_SPINNER_FLOAT, &lightCoeffs.diffuse[0], -1, colorCB);
ldRedValue->set_float_limits(0.f, 1.f);
ldRedValue->set_float_val(1.f);
GLUI_Spinner *ldGreenValue = glui->add_spinner_to_panel(lightDiffusePanel, "Green", GLUI_SPINNER_FLOAT, &lightCoeffs.diffuse[1], -1, colorCB);
ldGreenValue->set_float_limits(0.f, 1.f);
ldGreenValue->set_float_val(1.f);
GLUI_Spinner *ldBlueValue = glui->add_spinner_to_panel(lightDiffusePanel, "Blue", GLUI_SPINNER_FLOAT, &lightCoeffs.diffuse[2], -1, colorCB);
ldBlueValue->set_float_limits(0.f, 1.f);
ldBlueValue->set_float_val(1.f);
GLUI_Panel *lightAmbientPanel = glui->add_panel_to_panel(lightPanel, "Ambient");
GLUI_Spinner *laRedValue = glui->add_spinner_to_panel(lightAmbientPanel, "Red", GLUI_SPINNER_FLOAT, &lightCoeffs.ambient[0], -1, colorCB);
laRedValue->set_float_limits(0.f, 1.f);
laRedValue->set_float_val(1.f);
GLUI_Spinner *laGreenValue = glui->add_spinner_to_panel(lightAmbientPanel, "Green", GLUI_SPINNER_FLOAT, &lightCoeffs.ambient[1], -1, colorCB);
laGreenValue->set_float_limits(0.f, 1.f);
laGreenValue->set_float_val(1.f);
GLUI_Spinner *laBlueValue = glui->add_spinner_to_panel(lightAmbientPanel, "Blue", GLUI_SPINNER_FLOAT, &lightCoeffs.ambient[2], -1, colorCB);
laBlueValue->set_float_limits(0.f, 1.f);
laBlueValue->set_float_val(1.f);
GLUI_Panel *lightSpecularPanel = glui->add_panel_to_panel(lightPanel, "Specular");
GLUI_Spinner *lsRedValue = glui->add_spinner_to_panel(lightSpecularPanel, "Red", GLUI_SPINNER_FLOAT, &lightCoeffs.specular[0], -1, colorCB);
lsRedValue->set_float_limits(0.f, 1.f);
lsRedValue->set_float_val(1.f);
GLUI_Spinner *lsGreenValue = glui->add_spinner_to_panel(lightSpecularPanel, "Green", GLUI_SPINNER_FLOAT, &lightCoeffs.specular[1], -1, colorCB);
lsGreenValue->set_float_limits(0.f, 1.f);
lsGreenValue->set_float_val(1.f);
GLUI_Spinner *lsBlueValue = glui->add_spinner_to_panel(lightSpecularPanel, "Blue", GLUI_SPINNER_FLOAT, &lightCoeffs.specular[2], -1, colorCB);
lsBlueValue->set_float_limits(0.f, 1.f);
lsBlueValue->set_float_val(1.f);
GLUI_Panel *texturingPanel = glui->add_panel("Texturing");
GLUI_Listbox *textureListbox = glui->add_listbox_to_panel(texturingPanel, "Texture", (int*)&texture, -1, textureCB);
textureListbox->add_item(NOTEXTURE, "No texture");
textureListbox->add_item(OSU, "OSU");
textureListbox->add_item(EARTH, "EARTH");
textureListbox->add_item(WOOD, "WOOD");
textureListbox->set_int_val(NOTEXTURE);
GLUI_Panel *texFiltersPanel = glui->add_panel_to_panel(texturingPanel, "", 0);
GLUI_Panel *minFilterPanel = glui->add_panel_to_panel(texFiltersPanel, "Minifying filter", 1);
GLUI_RadioGroup *minFilterGroup = glui->add_radiogroup_to_panel(minFilterPanel, (int*) &texMinFilter, -1, textureCB);
glui->add_radiobutton_to_group(minFilterGroup, "Linear");
glui->add_radiobutton_to_group(minFilterGroup, "Nearest");
minFilterGroup->set_int_val(LINEAR);
GLUI_Panel *magFilterPanel = glui->add_panel_to_panel(texFiltersPanel, "Magnifying filter", 1);
GLUI_RadioGroup *magFilterGroup = glui->add_radiogroup_to_panel(magFilterPanel, (int*) &texMagFilter, -1, textureCB);
glui->add_radiobutton_to_group(magFilterGroup, "Linear");
glui->add_radiobutton_to_group(magFilterGroup, "Nearest");
magFilterGroup->set_int_val(LINEAR);
glui->add_column_to_panel(texFiltersPanel, 0);
GLUI_Panel *texWrapSPanel = glui->add_panel_to_panel(texFiltersPanel, "Wrapping S", 1);
GLUI_RadioGroup *texWrapSGroup = glui->add_radiogroup_to_panel(texWrapSPanel, (int*) &texWrap_S, -1, textureCB);
glui->add_radiobutton_to_group(texWrapSGroup, "Repeat");
glui->add_radiobutton_to_group(texWrapSGroup, "Clamp to edge");
texWrapSGroup->set_int_val(CLAMPTOEDGE);
GLUI_Panel *texWrapTPanel = glui->add_panel_to_panel(texFiltersPanel, "Wrapping T", 1);
GLUI_RadioGroup *texWrapTGroup = glui->add_radiogroup_to_panel(texWrapTPanel, (int*) &texWrap_T, -1, textureCB);
glui->add_radiobutton_to_group(texWrapTGroup, "Repeat");
glui->add_radiobutton_to_group(texWrapTGroup, "Clamp to edge");
texWrapTGroup->set_int_val(CLAMPTOEDGE);
GLUI_Listbox *texEnvListbox = glui->add_listbox_to_panel(texturingPanel, "Environment", (int*)&texEnv, -1, textureCB);
texEnvListbox->add_item(REPLACE, "GL_REPLACE");
texEnvListbox->add_item(MODULATE, "GL_MODULATE");
texEnvListbox->add_item(DECAL, "GL_DECAL");
texEnvListbox->add_item(BLEND, "GL_BLEND");
texEnvListbox->set_int_val(MODULATE);
GLUI_Listbox *texGenListbox = glui->add_listbox_to_panel(texturingPanel, "UV Generation", (int*)&texGen, -1, textureCB);
texGenListbox->add_item(OBJECT, "Object Linear");
texGenListbox->add_item(EYE, "Eye Linear");
texGenListbox->add_item(SPHERE, "Sphere Map");
texGenListbox->set_int_val(OBJECT);
GLUI_Panel *shadingPanel = glui->add_panel("Shading");
GLUI_RadioGroup *shadingGroup = glui->add_radiogroup_to_panel(shadingPanel, (int*) &shadingModel, -1, shadingCB);
glui->add_radiobutton_to_group(shadingGroup, "Flat");
glui->add_radiobutton_to_group(shadingGroup, "Smooth");
shadingGroup->set_int_val(SMOOTH);
GLUI_Listbox *shaderListbox = glui->add_listbox_to_panel(shadingPanel, "Shader", (int*)&shader, -1, shadingCB);
shaderListbox->add_item(NOSHADER, "Fixed function");
shaderListbox->add_item(PASS_THROUGH, "Pass through");
shaderListbox->add_item(DIFFUSE, "Lambert illumination");
shaderListbox->add_item(PHONG, "Phong illumination");
shaderListbox->add_item(TOON, "Toon shading");
shaderListbox->add_item(PROCEDURAL, "Procedural texture");
shaderListbox->set_int_val(PASS_THROUGH);
glui->set_main_gfx_window(main_window);
// We register the idle callback with GLUI, *not* with GLUT
GLUI_Master.set_glutIdleFunc(NULL);
glui->sync_live();
glutMainLoop();
return EXIT_SUCCESS;
}
void UpdateLinkSpinnerGUI()
{
link_spinner->set_int_val(cur_link);
UpdateLinkInfoGUI();
//driver_spinner->set_int_val(cur_driver);
}
