void initGLUI(int window) { GLUI *gluiSide = GLUI_Master.create_glui_subwindow(window, GLUI_SUBWINDOW_RIGHT); gluiSide->set_main_gfx_window(window); gluiSide->add_button("New Curve", NEW_CURVE, gluiHandler); gluiSide->add_button("New Surface", NEW_SURFACE, gluiHandler); surfPanel = gluiSide->add_panel("Surface Parms", GLUI_PANEL_EMBOSSED); GLUI_Spinner *xS = gluiSide->add_spinner_to_panel(surfPanel, "X Pts.", GLUI_SPINNER_INT, &surf_x, SURF_X, gluiHandler); xS->set_int_limits(3, 10); GLUI_Spinner *yS = gluiSide->add_spinner_to_panel(surfPanel, "Y Pts.", GLUI_SPINNER_INT, &surf_y, SURF_Y, gluiHandler); yS->set_int_limits(3, 10); gluiSide->add_button_to_panel(surfPanel, "Ok", SURF_OK, gluiHandler); surfPanel->disable(); gluiSide->add_button("Modify Points", MODIFY, gluiHandler); gluiSide->add_button("Clear Screen", CLEAR, gluiHandler); gluiSide->add_button("Camera Mode", CAMERA, gluiHandler); gluiSide->add_separator(); GLUI_Spinner *uS = gluiSide->add_spinner("U", GLUI_SPINNER_FLOAT, &u, U, gluiHandler); uS->set_float_limits(0.0f, 1.0f); uS->set_speed(50); GLUI_Spinner *vS = gluiSide->add_spinner("V", GLUI_SPINNER_FLOAT, &v, V, gluiHandler); vS->set_float_limits(0.0f, 1.0f); vS->set_speed(50); gluiSide->add_separator(); gluiSide->add_button("Quit", QUIT, gluiHandler); }
int main(int argc, char *argv[]) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); // use double-buffering, RGB glutInitWindowSize(WIN_SIZE, WIN_SIZE); glutInitWindowPosition(50, 50); main_window = glutCreateWindow("3D Cube"); init(); // call our init function glutDisplayFunc(display); // register display function glutReshapeFunc(reshape); // create the control panel, initialize some buttons GLUI *control_panel = GLUI_Master.create_glui("Control box"); new GLUI_StaticText(control_panel, "3D Cube"); new GLUI_Separator(control_panel); new GLUI_Button(control_panel, "Quit", 0, (GLUI_Update_CB) exit); new GLUI_Column(control_panel, true); // Size panel GLUI_Spinner *size = new GLUI_Spinner(control_panel, "SIZE", GLUI_SPINNER_FLOAT, &SIZE, 0, viewer_callback); size->set_float_limits(1.0, 20.0); new GLUI_Column(control_panel, true); // eye position / looking at panel // eye position rollout GLUI_Rollout *eye_pos_rollout = new GLUI_Rollout(control_panel, "Eye Position", false); GLUI_Spinner *x_pos= new GLUI_Spinner(eye_pos_rollout, "X", GLUI_SPINNER_FLOAT, &av, 0, viewer_callback); GLUI_Spinner *y_pos= new GLUI_Spinner(eye_pos_rollout, "Y", GLUI_SPINNER_FLOAT, &bv, 0, viewer_callback); GLUI_Spinner *z_pos= new GLUI_Spinner(eye_pos_rollout, "Z", GLUI_SPINNER_FLOAT, &cv, 0, viewer_callback); // looking at rollout GLUI_Rollout *look_at_rollout = new GLUI_Rollout(control_panel, "Looking At", false); GLUI_Spinner *x_look= new GLUI_Spinner(look_at_rollout, "X", GLUI_SPINNER_FLOAT, &lx, 0, viewer_callback); GLUI_Spinner *y_look= new GLUI_Spinner(look_at_rollout, "Y", GLUI_SPINNER_FLOAT, &ly, 0, viewer_callback); GLUI_Spinner *z_look= new GLUI_Spinner(look_at_rollout, "Z", GLUI_SPINNER_FLOAT, &lz, 0, viewer_callback); new GLUI_Column(control_panel, true); // clipping param panel GLUI_Rollout *clipping_rollout = new GLUI_Rollout(control_panel, "Clipping Parameters plane", false); GLUI_Spinner *dist_hither = new GLUI_Spinner(clipping_rollout, "Distance to Hither plane", GLUI_SPINNER_FLOAT, &H, 0, clipping_callback); dist_hither->set_float_limits(1.0, 20.0, GLUI_LIMIT_CLAMP); GLUI_Spinner *dist_picture = new GLUI_Spinner(clipping_rollout, "Distance to Picture plane", GLUI_SPINNER_FLOAT, &D, 0, clipping_callback); dist_picture->set_float_limits(5.0, 25.0, GLUI_LIMIT_CLAMP); GLUI_Spinner *dist_yon = new GLUI_Spinner(clipping_rollout, "Distance to Yon plane", GLUI_SPINNER_FLOAT, &Y, 0, clipping_callback); dist_yon->set_float_limits(10.0, 30.0, GLUI_LIMIT_CLAMP); // theta spinner GLUI_Spinner *theta_spinner= new GLUI_Spinner(control_panel, "THETA", GLUI_SPINNER_FLOAT, &theta, 0, theta_callback); theta_spinner->set_float_limits(30.0, 75.0, GLUI_LIMIT_CLAMP); control_panel->set_main_gfx_window(main_window); /* call the test function (for... testing) */ //test1(); //GLUI_Master.set_glutIdleFunc(spin); glutMainLoop(); return EXIT_SUCCESS; }
void UpdateDriverValueGUI() { if(cur_driver < 0 || cur_driver >= (int)robot->drivers.size()) return; Vector2 limits = robot->GetDriverLimits(cur_driver); driver_value_spinner->set_float_limits(limits.x,limits.y); driver_value = robot->GetDriverValue(cur_driver); }
bool GLUIRealTimePlannerGUI::Initialize() { if(!BaseT::Initialize()) return false; glui = GLUI_Master.create_glui_subwindow(main_window,GLUI_SUBWINDOW_RIGHT); glui->set_main_gfx_window(main_window); AddControl(glui->add_button("New target"),"new_target"); AddControl(glui->add_checkbox("Draw desired"),"draw_desired"); AddControl(glui->add_checkbox("Draw commanded"),"draw_desired"); AddControl(glui->add_checkbox("Draw UI"),"draw_ui"); AddControl(glui->add_checkbox("Draw path"),"draw_path"); AddControl(glui->add_checkbox("Draw contacts"),"draw_contacts"); GLUI_Spinner* spinner = glui->add_spinner("Collision margin",GLUI_SPINNER_FLOAT); spinner->set_float_limits(0.0,1.0); AddControl(spinner,"collision_margin"); AnyCollection c; bool res=c.read("{type:button_press,button:new_target}"); Assert(res == true); AddCommandRule(c,"new_target",""); res=c.read("{type:widget_value,widget:collision_margin,value:_1}"); Assert(res == true); AddCommandRule(c,"set_collision_margin","_1"); printf("Done initializing...\n"); return true; }
int main(int argc, char **argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glutInitWindowSize(650, 650); glutInitWindowPosition(50, 50); main_window = glutCreateWindow("Ferris Wheel"); glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHTING); glEnable(GL_NORMALIZE); p = gluNewQuadric(); q = gluNewQuadric(); glutReshapeFunc(reshape); glutDisplayFunc(display); init(); glEnable(GL_LIGHT0); setMaterial( &redPlasticMaterials ); currentLighting = &whiteLighting; glLightfv(GL_LIGHT0, GL_AMBIENT, currentLighting->ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, currentLighting->diffuse); glLightfv(GL_LIGHT0, GL_SPECULAR, currentLighting->specular); glLightfv(GL_LIGHT0, GL_POSITION, light0_pos); GLUI *control_panel = GLUI_Master.create_glui( "Controls",0, 50, 700 ); new GLUI_Button(control_panel, "Quit", 0, (GLUI_Update_CB)exit); new GLUI_Column(control_panel, true); GLUI_Rollout *eyePosRollout = new GLUI_Rollout(control_panel, "Camera Position", false); GLUI_Rollout *lookAtRollout = new GLUI_Rollout(control_panel, "Lookat Point", false); GLUI_Spinner *epxSpin = new GLUI_Spinner(eyePosRollout, "Camera X", GLUI_SPINNER_FLOAT, &EyeX, 0, look); GLUI_Spinner *epySpin = new GLUI_Spinner(eyePosRollout, "Camera Y", GLUI_SPINNER_FLOAT, &EyeY, 0, look); GLUI_Spinner *epzSpin = new GLUI_Spinner(eyePosRollout, "Camera Z", GLUI_SPINNER_FLOAT, &EyeZ, 0, look); GLUI_Spinner *laxSpin = new GLUI_Spinner(lookAtRollout, "Lookat X", GLUI_SPINNER_FLOAT, &LookAtX, 0, look); GLUI_Spinner *laySpin = new GLUI_Spinner(lookAtRollout, "Lookat Y", GLUI_SPINNER_FLOAT, &LookAtY, 0, look); GLUI_Spinner *lazSpin = new GLUI_Spinner(lookAtRollout, "Lookat Z", GLUI_SPINNER_FLOAT, &LookAtZ, 0, look); new GLUI_Column(control_panel, true); GLUI_Spinner *speedSpin = new GLUI_Spinner(control_panel, "Rotation Speed", GLUI_SPINNER_FLOAT, &Speed, 0, (GLUI_Update_CB)NULL); speedSpin->set_float_limits(-5.0f, 5.0f, GLUI_LIMIT_CLAMP); GLUI_Spinner *recSpin = new GLUI_Spinner(control_panel, "Recursive Depth", GLUI_SPINNER_INT, &RecursiveDepth, 0, (GLUI_Update_CB)NULL); recSpin->set_int_limits(0, 5, GLUI_LIMIT_CLAMP); control_panel->set_main_gfx_window(main_window); GLUI_Master.set_glutIdleFunc(update); glutMainLoop(); }
void buildInterface(){ myGluiWindow = GLUI_Master.create_glui ("Options", 0, windowX+500, windowY); /*file open options, textbox and buttons*/ myGluiWindow->add_edittext("Input file: ", GLUI_EDITTEXT_TEXT, text, FILE_INPUT, myGluiCallback); myGluiWindow->add_button ("Open", OPEN_BUTTON, myGluiCallback); /*adding new panel*/ GLUI_Panel *myPanel1 = myGluiWindow->add_panel("Object Properties"); /*list box for mesh displaying*/ GLUI_Listbox *myListBox= myGluiWindow->add_listbox_to_panel (myPanel1, "Display Mesh", &listbox_id, DISPLAY_LISTBOX, myGluiCallback); myListBox->add_item (1, "Flat Shaded"); myListBox->add_item (2, "Smooth Shaded"); myListBox->add_item (3, "Wireframe"); myListBox->add_item (4, "Shaded with edges"); /*adding one more panel*/ GLUI_Panel *myPanel2 = myGluiWindow->add_panel("Transformation"); GLUI_Panel *mySubPanel1 = myGluiWindow->add_panel_to_panel(myPanel2, ""); /*translate X, Y*/ GLUI_Translation *myTranslation = myGluiWindow->add_translation_to_panel(mySubPanel1, "Translation XY", GLUI_TRANSLATION_XY, translate_xy, TRANSLATION_XY, myGluiCallback); myTranslation->set_speed(0.005); /*adding a new column (side by side display)*/ myGluiWindow->add_column_to_panel(mySubPanel1, false); /*translate Z*/ GLUI_Translation *myTranslationZ = myGluiWindow->add_translation_to_panel(mySubPanel1, "Translation Z", GLUI_TRANSLATION_Z, &translate_z, TRANSLATION_Z, myGluiCallback); myTranslationZ->set_speed(0.005); /*adding sub panel*/ GLUI_Panel *mySubPanel2 = myGluiWindow->add_panel_to_panel(myPanel2, ""); /*set up rotation*/ myGluiWindow->add_rotation_to_panel(mySubPanel2, "Rotation", rotation_matrix, ROTATION, myGluiCallback); /*adding a new column (side by side display)*/ myGluiWindow->add_column_to_panel(mySubPanel2, false); /*set up zoom (i.e. scale)*/ GLUI_Spinner *mySpinner = myGluiWindow->add_spinner_to_panel (mySubPanel2, "Scale", GLUI_SPINNER_FLOAT, &scale, SCALE_SPINNER, myGluiCallback); mySpinner->set_float_limits (-4.0, 4.0); /*save mesh*/ myGluiWindow->add_edittext("Output file: ", GLUI_EDITTEXT_TEXT, optext, FILE_OUTPUT, myGluiCallback); myGluiWindow->add_button ("Save", SAVE_BUTTON, myGluiCallback); /*add quit button*/ myGluiWindow->add_button ("Quit", QUIT_BUTTON, myGluiCallback); GLUI_Master.set_glutIdleFunc(myIdle); GLUI_Master.set_glutReshapeFunc(myReshape); myGluiWindow->set_main_gfx_window(myWindow); }
//! This function creates all the GLUI gui elements void create_glui_ui(void) { GLUI *glui = GLUI_Master.create_glui_subwindow( main_window, GLUI_SUBWINDOW_RIGHT ); glui->add_statictext("Group 11 Simulation"); new GLUI_Separator(glui); glui->add_statictext("Simulation Timesteps"); GLUI_Spinner* velocityIterationSpinner = glui->add_spinner("Velocity Iterations", GLUI_SPINNER_INT, &settings.velocity_iterations); velocityIterationSpinner->set_int_limits(1, 500); GLUI_Spinner* positionIterationSpinner = glui->add_spinner("Position Iterations", GLUI_SPINNER_INT, &settings.position_iterations); positionIterationSpinner->set_int_limits(0, 100); GLUI_Spinner* hertzSpinner = glui->add_spinner("Sim steps per frame", GLUI_SPINNER_FLOAT, &settings.hz); hertzSpinner->set_float_limits(5.0f, 200.0f); new GLUI_Separator(glui); //new GLUI_Column( glui, false ); glui->add_statictext("Simulation Parameters"); glui->add_checkbox("Warm Starting", &settings.enable_warm_starting); glui->add_checkbox("Time of Impact", &settings.enable_continuous); glui->add_checkbox("Sub-Stepping", &settings.enable_sub_stepping); //new GLUI_Column( glui, false ); new GLUI_Separator(glui); glui->add_statictext("Display Options"); GLUI_Panel* drawPanel = glui->add_panel("Draw"); glui->add_checkbox_to_panel(drawPanel, "Shapes", &settings.draw_shapes); glui->add_checkbox_to_panel(drawPanel, "Joints", &settings.draw_joints); glui->add_checkbox_to_panel(drawPanel, "AABBs", &settings.draw_AABBs); glui->add_checkbox_to_panel(drawPanel, "Statistics", &settings.draw_stats); glui->add_checkbox_to_panel(drawPanel, "Profile", &settings.draw_profile); //new GLUI_Column( glui, false ); new GLUI_Separator(glui); glui->add_button("Pause", 0, callbacks_t::pause_cb); glui->add_button("Single Step", 0, callbacks_t::single_step_cb); glui->add_button("Restart", 0, callbacks_t::restart_cb); glui->add_button("Quit", 0,(GLUI_Update_CB)callbacks_t::exit_cb); glui->set_main_gfx_window( main_window ); new GLUI_Separator(glui); glui->add_statictext("Mayank Meghwanshi"); glui->add_statictext("Divyam Bansal"); glui->add_statictext("Jaswant Kumar"); }
//////////////////// CGlutWin methods //////////////////// void CPCPView::_InitFunc() { _KeepUpdateOn(); ///////////////////////////////////////////// // set up GLUI GLUI *pcGlui = PCGetGluiSubwin(); GLUI_Panel *pcPanel_Line = pcGlui->add_rollout("Line"); GLUI_Panel *pcPanel_Color = pcGlui->add_panel_to_panel(pcPanel_Line, "Color"); static char* pszChannels[] = {"R", "G", "B", "A"}; float *pfColor = &f4Color.x; for(int c = 0; c < sizeof(pszChannels)/sizeof(pszChannels[0]); c++) { GLUI_Spinner* pcSpinner = pcGlui->add_spinner_to_panel(pcPanel_Color, pszChannels[c], GLUI_SPINNER_FLOAT, &pfColor[c]); pcSpinner->set_float_limits(0.0f, 1.0f); } GLUI_Spinner* pcSpinner_Width = pcGlui->add_spinner_to_panel(pcPanel_Line, "Width", GLUI_SPINNER_FLOAT, &fWidth); pcSpinner_Width->set_float_limits(1.0f, 16.0f); cFilter._AddGlui(this, pcGlui, NULL, pcBlockTree->uMaxLevel + 1); }
int main(int argc, char** argv) { entry = g_testEntries + testIndex; test = entry->createFcn(); glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowSize(width, height); char title[32]; sprintf(title, "Box2D Version %d.%d.%d", b2_version.major, b2_version.minor, b2_version.revision); mainWindow = glutCreateWindow(title); //glutSetOption (GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); glutDisplayFunc(SimulationLoop); GLUI_Master.set_glutReshapeFunc(Resize); GLUI_Master.set_glutKeyboardFunc(Keyboard); GLUI_Master.set_glutSpecialFunc(KeyboardSpecial); GLUI_Master.set_glutMouseFunc(Mouse); glutMouseWheelFunc(MouseWheel); glutMotionFunc(MouseMotion); glui = GLUI_Master.create_glui_subwindow( mainWindow, GLUI_SUBWINDOW_RIGHT ); glui->add_statictext("Tests"); GLUI_Listbox* testList = glui->add_listbox("", &testSelection); glui->add_separator(); GLUI_Spinner* iterationSpinner = glui->add_spinner("Iterations", GLUI_SPINNER_INT, &settings.iterationCount); iterationSpinner->set_int_limits(1, 100); GLUI_Spinner* hertzSpinner = glui->add_spinner("Hertz", GLUI_SPINNER_FLOAT, &settings.hz); hertzSpinner->set_float_limits(5.0f, 200.0f); glui->add_checkbox("Position Correction", &settings.enablePositionCorrection); glui->add_checkbox("Warm Starting", &settings.enableWarmStarting); glui->add_checkbox("Time of Impact", &settings.enableTOI); glui->add_separator(); GLUI_Panel* drawPanel = glui->add_panel("Draw"); glui->add_checkbox_to_panel(drawPanel, "Shapes", &settings.drawShapes); glui->add_checkbox_to_panel(drawPanel, "Joints", &settings.drawJoints); glui->add_checkbox_to_panel(drawPanel, "Core Shapes", &settings.drawCoreShapes); glui->add_checkbox_to_panel(drawPanel, "AABBs", &settings.drawAABBs); glui->add_checkbox_to_panel(drawPanel, "OBBs", &settings.drawOBBs); glui->add_checkbox_to_panel(drawPanel, "Pairs", &settings.drawPairs); glui->add_checkbox_to_panel(drawPanel, "Contact Points", &settings.drawContactPoints); glui->add_checkbox_to_panel(drawPanel, "Contact Normals", &settings.drawContactNormals); glui->add_checkbox_to_panel(drawPanel, "Contact Forces", &settings.drawContactForces); glui->add_checkbox_to_panel(drawPanel, "Friction Forces", &settings.drawFrictionForces); glui->add_checkbox_to_panel(drawPanel, "Center of Masses", &settings.drawCOMs); glui->add_checkbox_to_panel(drawPanel, "Statistics", &settings.drawStats); int32 testCount = 0; TestEntry* e = g_testEntries; while (e->createFcn) { testList->add_item(testCount, e->name); ++testCount; ++e; } glui->add_button("Pause", 0, Pause); glui->add_button("Single Step", 0, SingleStep); glui->add_button("Quit", 0,(GLUI_Update_CB)exit); glui->set_main_gfx_window( mainWindow ); // Use a timer to control the frame rate. glutTimerFunc(framePeriod, Timer, 0); glutMainLoop(); return 0; }
void UpdateLinkValueGUI() { Vector2 limits(robot->qMin(cur_link),robot->qMax(cur_link)); link_value_spinner->set_float_limits(limits.x,limits.y); link_value = robot->q(cur_link); }
void glutAndGluiInit(int argc, char* argv[]) { ////////////////////////////////////////// // Initialize GLUT and create window ////////////////////////////////////////// glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowPosition(-1, -1); glutInitWindowSize(640, 480); int main_window = glutCreateWindow("Scenegraph"); glutDisplayFunc(display); GLUI_Master.set_glutReshapeFunc(reshape); ////////////////////////////////////////// // GLUI UI setup ////////////////////////////////////////// // Create the side subwindow GLUI* glui = GLUI_Master.create_glui_subwindow( main_window, GLUI_SUBWINDOW_RIGHT ); glui->set_main_gfx_window( main_window ); ////////// Buttons GLUI_Panel* panel = glui->add_panel("Add Object"); glui->add_button_to_panel(panel, "Cone", CONE_ID, control_cb); glui->add_button_to_panel(panel, "Sphere", SPHERE_ID, control_cb); glui->add_button_to_panel(panel, "Spindle", SPINDLE_ID, control_cb); glui->add_button_to_panel(panel, "Teapot", TEAPOT_ID, control_cb); glui->add_button_to_panel(panel, "Torus", TORUS_ID, control_cb); panel = glui->add_panel("Grouping"); glui->add_button_to_panel(panel, "Add Selected", ADD_ID, control_cb); glui->add_button_to_panel(panel, "Select Next", NEXT_ID, control_cb); glui->add_button_to_panel(panel, "Close Group", CLOSE_ID, control_cb); glui->add_button_to_panel(panel, "Reopen Group", REOPEN_ID, control_cb); panel = glui->add_panel("Other"); glui->add_button_to_panel(panel, "Print Graph", PRINT_ID, control_cb); glui->add_button_to_panel(panel, "Quit", 0, control_cb); ///////////// Create the bottom subwindow GLUI* glui2 = GLUI_Master.create_glui_subwindow( main_window, GLUI_SUBWINDOW_BOTTOM ); glui2->set_main_gfx_window( main_window ); ///////////// View rotation GLUI_Rotation *view_rot = glui2->add_rotation( "View", &root.view_rotate.m[0]); view_rot->set_spin( 1.0 ); glui2->add_column( false ); ///////////// Object Translations GLUI_Translation *trans_x = glui2->add_translation("Xlate X", GLUI_TRANSLATION_X, &root.obj_xlate[0], 0, xformCallback); trans_x->set_speed( .005 ); glui2->add_column( false ); GLUI_Translation *trans_y = glui2->add_translation("Xlate Y", GLUI_TRANSLATION_Y, &root.obj_xlate[1], 0, xformCallback); trans_y->set_speed( .005 ); glui2->add_column( false ); GLUI_Translation *trans_z = glui2->add_translation("Xlate Z", GLUI_TRANSLATION_Z, &root.obj_xlate[2], 0, xformCallback); trans_z->set_speed( .005 ); glui2->add_column( false ); ///////////// Object Rotations GLUI_Translation *r_x = glui2->add_translation("Rotate X", GLUI_TRANSLATION_X, &root.obj_rdelta[0], 0, xformCallback); r_x->set_speed( .005 ); glui2->add_column( false ); GLUI_Translation *r_y = glui2->add_translation("Rotate Y", GLUI_TRANSLATION_X, &root.obj_rdelta[1], 0, xformCallback); r_y->set_speed( .005 ); glui2->add_column( false ); GLUI_Translation *r_z = glui2->add_translation("Rotate Z", GLUI_TRANSLATION_X, &root.obj_rdelta[2], 0, xformCallback); r_z->set_speed( .005 ); glui2->add_column( false ); ////////// Object Scale GLUI_Spinner *xspin = glui2->add_spinner("XScale:", GLUI_SPINNER_FLOAT, &root.obj_scale[0], 0, xformCallback); xspin->set_float_limits( .5f, 4.0 ); xspin->set_alignment( GLUI_ALIGN_RIGHT ); GLUI_Spinner *yspin = glui2->add_spinner("YScale:", GLUI_SPINNER_FLOAT, &root.obj_scale[1], 0, xformCallback); yspin->set_float_limits( .5f, 4.0 ); yspin->set_alignment( GLUI_ALIGN_RIGHT ); GLUI_Spinner *zspin = glui2->add_spinner("ZScale:", GLUI_SPINNER_FLOAT, &root.obj_scale[2], 0, xformCallback); zspin->set_float_limits( .5f, 4.0 ); zspin->set_alignment( GLUI_ALIGN_RIGHT ); }
void createInterface() { GLUI *glui = GLUI_Master.create_glui("RGBD Effects", 0, 1050, 100); //Effect Selection GLUI_Panel *effectSelectionPanel = glui->add_panel("Effect"); GLUI_RadioGroup *effectRadioGroup = glui->add_radiogroup_to_panel(effectSelectionPanel, &selectedEffect, -1, gluiCallback); glui->add_radiobutton_to_group(effectRadioGroup, "Maps"); glui->add_radiobutton_to_group(effectRadioGroup, "Fog"); glui->add_radiobutton_to_group(effectRadioGroup, "Depth of Field"); glui->add_radiobutton_to_group(effectRadioGroup, "Relighting"); glui->add_radiobutton_to_group(effectRadioGroup, "Cartoon Shading"); //Depth range glui->add_statictext(""); GLUI_Panel *depthRangePanel = glui->add_panel("Depth Range"); GLUI_Checkbox *adaptiveDepthRangeCheckBox = glui->add_checkbox_to_panel(depthRangePanel, "Adaptive ", &adaptiveDepthRange, -1, gluiCallback); GLUI_Spinner *nearPlaneSpinner = glui->add_spinner_to_panel(depthRangePanel, "Near Plane ", GLUI_SPINNER_FLOAT, &nearPlane, -1, gluiCallback); nearPlaneSpinner->set_float_limits(10, 2000); GLUI_Spinner *farPlaneSpinner = glui->add_spinner_to_panel(depthRangePanel, "Far Plane ", GLUI_SPINNER_FLOAT, &farPlane, -1, gluiCallback); farPlaneSpinner->set_float_limits(10, 2000); //View maps GLUI_Rollout *mapRollout = glui->add_rollout("Maps", 0); mapRollout->set_w(218); glui->add_statictext_to_panel(mapRollout, "")->set_w(200); GLUI_RadioGroup *mapRadioGroup = glui->add_radiogroup_to_panel(mapRollout, &mapEffect->selectedMap, -1, gluiCallback); glui->add_radiobutton_to_group(mapRadioGroup, "Colour"); glui->add_radiobutton_to_group(mapRadioGroup, "Depth"); glui->add_radiobutton_to_group(mapRadioGroup, "Normals"); GLUI_Panel* mapPreblurPanel = glui->add_panel_to_panel(mapRollout, "Pre-processing"); GLUI_RadioGroup *mapPreblurRadioGroup = glui->add_radiogroup_to_panel(mapPreblurPanel, &mapEffect->selectedPreFilter, -1, gluiCallback); glui->add_radiobutton_to_group(mapPreblurRadioGroup, "None"); glui->add_radiobutton_to_group(mapPreblurRadioGroup, "Blur"); glui->add_radiobutton_to_group(mapPreblurRadioGroup, "Bilateral"); GLUI_Spinner *mapPreblurPassesSpinner = glui->add_spinner_to_panel(mapPreblurPanel, "Filter Passes ", GLUI_SPINNER_INT, &mapEffect->preblurFilterPasses, -1, gluiCallback); mapPreblurPassesSpinner->set_int_limits(0, 10); GLUI_Spinner *mapPreblurKernelSizeSpinner = glui->add_spinner_to_panel(mapPreblurPanel, "Kernel Size ", GLUI_SPINNER_INT, &mapEffect->preblurKernelSize, -1, gluiCallback); mapPreblurKernelSizeSpinner->set_int_limits(1, 100); GLUI_Spinner *mapPreblurSigmaSpinner = glui->add_spinner_to_panel(mapPreblurPanel, "Sample Deviation ", GLUI_SPINNER_FLOAT, &mapEffect->preblurSigma, -1, gluiCallback); mapPreblurSigmaSpinner->set_float_limits(0.001, 0.15); //FOG GLUI_Rollout *fogRollout = glui->add_rollout("Fog", 0); fogRollout->set_w(218); glui->add_statictext_to_panel(fogRollout, "")->set_w(200); GLUI_Spinner *fogDensitySpinner = glui->add_spinner_to_panel(fogRollout, "Density ", GLUI_SPINNER_FLOAT, &fogEffect->fogDensity, -1, gluiCallback); fogDensitySpinner->set_float_limits(0.0, 20.0); GLUI_Spinner *fogAmountSpinner = glui->add_spinner_to_panel(fogRollout, "Amount ", GLUI_SPINNER_FLOAT, &fogEffect->fogAmount, -1, gluiCallback); fogAmountSpinner->set_float_limits(0.0, 1); glui->add_statictext_to_panel(fogRollout, ""); GLUI_Panel* fogPreblurPanel = glui->add_panel_to_panel(fogRollout, "Preblur"); GLUI_Spinner *fogPreblurPassesSpinner = glui->add_spinner_to_panel(fogPreblurPanel, "Filter Passes ", GLUI_SPINNER_INT, &fogEffect->preblurFilterPasses, -1, gluiCallback); fogPreblurPassesSpinner->set_int_limits(0, 10); GLUI_Spinner *fogPreblurKernelSizeSpinner = glui->add_spinner_to_panel(fogPreblurPanel, "Kernel Size ", GLUI_SPINNER_INT, &fogEffect->preblurKernelSize, -1, gluiCallback); fogPreblurKernelSizeSpinner->set_int_limits(1, 100); GLUI_Spinner *fogPreblurSigmaSpinner = glui->add_spinner_to_panel(fogPreblurPanel, "Sample Deviation ", GLUI_SPINNER_FLOAT, &fogEffect->preblurSigma, -1, gluiCallback); fogPreblurSigmaSpinner->set_float_limits(0.001, 0.15); glui->add_statictext_to_panel(fogRollout, ""); GLUI_Panel* fogColourPanel = glui->add_panel_to_panel(fogRollout, "Colour", GLUI_PANEL_EMBOSSED); GLUI_Spinner *fogColourRedSpinner = glui->add_spinner_to_panel(fogColourPanel, "Red ", GLUI_SPINNER_FLOAT, &fogEffect->fogColourRed, -1, gluiCallback); fogColourRedSpinner->set_float_limits(0.0, 1); GLUI_Spinner *fogColourGreenSpinner = glui->add_spinner_to_panel(fogColourPanel, "Green ", GLUI_SPINNER_FLOAT, &fogEffect->fogColourGreen, -1, gluiCallback); fogColourGreenSpinner->set_float_limits(0.0, 1); GLUI_Spinner *fogColourBlueSpinner = glui->add_spinner_to_panel(fogColourPanel, "Blue ", GLUI_SPINNER_FLOAT, &fogEffect->fogColourBlue, -1, gluiCallback); fogColourBlueSpinner->set_float_limits(0.0, 1); //DEPTH OF FIELD GLUI_Rollout *DOFRollout = glui->add_rollout("Depth of Field", 0); DOFRollout->set_w(218); glui->add_statictext_to_panel(DOFRollout, "")->set_w(200); GLUI_Spinner *distributionSigmaSpinner = glui->add_spinner_to_panel(DOFRollout, "Sample Deviation ", GLUI_SPINNER_FLOAT, &dofEffect->distributionSigma, -1, gluiCallback); distributionSigmaSpinner->set_float_limits(0.001, 0.15); GLUI_Spinner *sampleRadiusSpinner = glui->add_spinner_to_panel(DOFRollout, "Sample Radius ", GLUI_SPINNER_INT, &dofEffect->sampleRadius, -1, gluiCallback); sampleRadiusSpinner->set_int_limits(1, 40); GLUI_Spinner *lensDiameterSpinner = glui->add_spinner_to_panel(DOFRollout, "Aperture Size ", GLUI_SPINNER_FLOAT, &dofEffect->lensDiameter, -1, gluiCallback); lensDiameterSpinner->set_float_limits(0.001, 1); GLUI_Spinner *focalLengthSpinner = glui->add_spinner_to_panel(DOFRollout, "Focal Length ", GLUI_SPINNER_FLOAT, &dofEffect->focalLength, -1, gluiCallback); focalLengthSpinner->set_float_limits(0.001, 1); GLUI_Spinner *focalDepthSpinner = glui->add_spinner_to_panel(DOFRollout, "Focal Depth ", GLUI_SPINNER_FLOAT, &dofEffect->focalPlaneDepth, -1, gluiCallback); focalDepthSpinner->set_float_limits(0.0, 1); glui->add_statictext_to_panel(DOFRollout, ""); GLUI_Panel* DOFPreblurPanel = glui->add_panel_to_panel(DOFRollout, "Preblur"); GLUI_Spinner *DOFPreblurPassesSpinner = glui->add_spinner_to_panel(DOFPreblurPanel, "Filter Passes ", GLUI_SPINNER_INT, &dofEffect->preblurFilterPasses, -1, gluiCallback); DOFPreblurPassesSpinner->set_int_limits(0, 10); GLUI_Spinner *DOFPreblurKernelSizeSpinner = glui->add_spinner_to_panel(DOFPreblurPanel, "Kernel Size ", GLUI_SPINNER_INT, &dofEffect->preblurKernelSize, -1, gluiCallback); DOFPreblurKernelSizeSpinner->set_int_limits(1, 100); GLUI_Spinner *DOFPreblurSigmaSpinner = glui->add_spinner_to_panel(DOFPreblurPanel, "Sample Deviation ", GLUI_SPINNER_FLOAT, &dofEffect->preblurSigma, -1, gluiCallback); DOFPreblurSigmaSpinner->set_float_limits(0.001, 0.15); //Relighting GLUI_Rollout *relightingRollout = glui->add_rollout("Relighting", 0); relightingRollout->set_w(218); glui->add_statictext_to_panel(relightingRollout, "")->set_w(200); glui->add_rotation_to_panel(relightingRollout, "Light Direction", relightingEffect->lightDirection, -1, gluiCallback); GLUI_Panel* relightingPreblurPanel = glui->add_panel_to_panel(relightingRollout, "Pre-processing"); GLUI_RadioGroup *relightingPreblurRadioGroup = glui->add_radiogroup_to_panel(relightingPreblurPanel, &relightingEffect->selectedPreFilter, -1, gluiCallback); glui->add_radiobutton_to_group(relightingPreblurRadioGroup, "None"); glui->add_radiobutton_to_group(relightingPreblurRadioGroup, "Blur"); glui->add_radiobutton_to_group(relightingPreblurRadioGroup, "Bilateral"); GLUI_Spinner *relightingPreblurPassesSpinner = glui->add_spinner_to_panel(relightingPreblurPanel, "Filter Passes ", GLUI_SPINNER_INT, &relightingEffect->preblurFilterPasses, -1, gluiCallback); relightingPreblurPassesSpinner->set_int_limits(0, 10); GLUI_Spinner *relightingPreblurKernelSizeSpinner = glui->add_spinner_to_panel(relightingPreblurPanel, "Kernel Size ", GLUI_SPINNER_INT, &relightingEffect->preblurKernelSize, -1, gluiCallback); relightingPreblurKernelSizeSpinner->set_int_limits(1, 100); GLUI_Spinner *relightingPreblurSigmaSpinner = glui->add_spinner_to_panel(relightingPreblurPanel, "Sample Deviation ", GLUI_SPINNER_FLOAT, &relightingEffect->preblurSigma, -1, gluiCallback); relightingPreblurSigmaSpinner->set_float_limits(0.001, 0.15); GLUI_Rollout* materialRollout = glui->add_rollout_to_panel(relightingRollout, "Material", 0, GLUI_PANEL_EMBOSSED); GLUI_Panel* materialAmbientPanel = glui->add_panel_to_panel(materialRollout, "Ambient", GLUI_PANEL_EMBOSSED); GLUI_Spinner *materialAmbientRedSpinner = glui->add_spinner_to_panel(materialAmbientPanel, "Red ", GLUI_SPINNER_FLOAT, &relightingEffect->materialAmbient[0], -1, gluiCallback); materialAmbientRedSpinner->set_float_limits(0.0, 1); GLUI_Spinner *materialAmbientGreenSpinner = glui->add_spinner_to_panel(materialAmbientPanel, "Green ", GLUI_SPINNER_FLOAT, &relightingEffect->materialAmbient[1], -1, gluiCallback); materialAmbientGreenSpinner->set_float_limits(0.0, 1); GLUI_Spinner *materialAmbientBlueSpinner = glui->add_spinner_to_panel(materialAmbientPanel, "Blue ", GLUI_SPINNER_FLOAT, &relightingEffect->materialAmbient[2], -1, gluiCallback); materialAmbientBlueSpinner->set_float_limits(0.0, 1); GLUI_Panel* materialDiffusePanel = glui->add_panel_to_panel(materialRollout, "Diffuse", GLUI_PANEL_EMBOSSED); GLUI_Spinner *materialDiffuseRedSpinner = glui->add_spinner_to_panel(materialDiffusePanel, "Red ", GLUI_SPINNER_FLOAT, &relightingEffect->materialDiffuse[0], -1, gluiCallback); materialDiffuseRedSpinner->set_float_limits(0.0, 1); GLUI_Spinner *materialDiffuseGreenSpinner = glui->add_spinner_to_panel(materialDiffusePanel, "Green ", GLUI_SPINNER_FLOAT, &relightingEffect->materialDiffuse[1], -1, gluiCallback); materialDiffuseGreenSpinner->set_float_limits(0.0, 1); GLUI_Spinner *materialDiffuseBlueSpinner = glui->add_spinner_to_panel(materialDiffusePanel, "Blue ", GLUI_SPINNER_FLOAT, &relightingEffect->materialDiffuse[2], -1, gluiCallback); materialDiffuseBlueSpinner->set_float_limits(0.0, 1); GLUI_Panel* materialSpecularPanel = glui->add_panel_to_panel(materialRollout, "Specular", GLUI_PANEL_EMBOSSED); GLUI_Spinner *materialSpecularRedSpinner = glui->add_spinner_to_panel(materialSpecularPanel, "Red ", GLUI_SPINNER_FLOAT, &relightingEffect->materialSpecular[0], -1, gluiCallback); materialSpecularRedSpinner->set_float_limits(0.0, 1); GLUI_Spinner *materialSpecularGreenSpinner = glui->add_spinner_to_panel(materialSpecularPanel, "Green ", GLUI_SPINNER_FLOAT, &relightingEffect->materialSpecular[1], -1, gluiCallback); materialSpecularGreenSpinner->set_float_limits(0.0, 1); GLUI_Spinner *materialSpecularBlueSpinner = glui->add_spinner_to_panel(materialSpecularPanel, "Blue ", GLUI_SPINNER_FLOAT, &relightingEffect->materialSpecular[2], -1, gluiCallback); materialSpecularBlueSpinner->set_float_limits(0.0, 1); GLUI_Rollout* lightRollout = glui->add_rollout_to_panel(relightingRollout, "Light", 0, GLUI_PANEL_EMBOSSED); GLUI_Panel* lightAmbientPanel = glui->add_panel_to_panel(lightRollout, "Ambient", GLUI_PANEL_EMBOSSED); GLUI_Spinner *lightAmbientRedSpinner = glui->add_spinner_to_panel(lightAmbientPanel, "Red ", GLUI_SPINNER_FLOAT, &relightingEffect->lightAmbient[0], -1, gluiCallback); lightAmbientRedSpinner->set_float_limits(0.0, 1); GLUI_Spinner *lightAmbientGreenSpinner = glui->add_spinner_to_panel(lightAmbientPanel, "Green ", GLUI_SPINNER_FLOAT, &relightingEffect->lightAmbient[1], -1, gluiCallback); lightAmbientGreenSpinner->set_float_limits(0.0, 1); GLUI_Spinner *lightAmbientBlueSpinner = glui->add_spinner_to_panel(lightAmbientPanel, "Blue ", GLUI_SPINNER_FLOAT, &relightingEffect->lightAmbient[2], -1, gluiCallback); lightAmbientBlueSpinner->set_float_limits(0.0, 1); GLUI_Panel* lightDiffusePanel = glui->add_panel_to_panel(lightRollout, "Diffuse", GLUI_PANEL_EMBOSSED); GLUI_Spinner *lightDiffuseRedSpinner = glui->add_spinner_to_panel(lightDiffusePanel, "Red ", GLUI_SPINNER_FLOAT, &relightingEffect->lightDiffuse[0], -1, gluiCallback); lightDiffuseRedSpinner->set_float_limits(0.0, 1); GLUI_Spinner *lightDiffuseGreenSpinner = glui->add_spinner_to_panel(lightDiffusePanel, "Green ", GLUI_SPINNER_FLOAT, &relightingEffect->lightDiffuse[1], -1, gluiCallback); lightDiffuseGreenSpinner->set_float_limits(0.0, 1); GLUI_Spinner *lightDiffuseBlueSpinner = glui->add_spinner_to_panel(lightDiffusePanel, "Blue ", GLUI_SPINNER_FLOAT, &relightingEffect->lightDiffuse[2], -1, gluiCallback); lightDiffuseBlueSpinner->set_float_limits(0.0, 1); GLUI_Panel* lightSpecularPanel = glui->add_panel_to_panel(lightRollout, "Specular", GLUI_PANEL_EMBOSSED); GLUI_Spinner *lightSpecularRedSpinner = glui->add_spinner_to_panel(lightSpecularPanel, "Red ", GLUI_SPINNER_FLOAT, &relightingEffect->lightSpecular[0], -1, gluiCallback); lightSpecularRedSpinner->set_float_limits(0.0, 1); GLUI_Spinner *lightSpecularGreenSpinner = glui->add_spinner_to_panel(lightSpecularPanel, "Green ", GLUI_SPINNER_FLOAT, &relightingEffect->lightSpecular[1], -1, gluiCallback); lightSpecularGreenSpinner->set_float_limits(0.0, 1); GLUI_Spinner *lightSpecularBlueSpinner = glui->add_spinner_to_panel(lightSpecularPanel, "Blue ", GLUI_SPINNER_FLOAT, &relightingEffect->lightSpecular[2], -1, gluiCallback); lightSpecularBlueSpinner->set_float_limits(0.0, 1); glui->add_statictext_to_panel(relightingRollout, ""); GLUI_Spinner *specularPowerSpinner = glui->add_spinner_to_panel(relightingRollout, "Shininess ", GLUI_SPINNER_FLOAT, &relightingEffect->shininess, -1, gluiCallback); specularPowerSpinner->set_float_limits(0.0, 50); //CARTOON SHADING GLUI_Rollout *cartoonRollout = glui->add_rollout("Cartoon Shading", 0); cartoonRollout->set_w(218); glui->add_statictext_to_panel(cartoonRollout, "")->set_w(200); GLUI_Panel *filteringPanel = glui->add_panel_to_panel(cartoonRollout, "Filtering"); glui->add_statictext_to_panel(filteringPanel, ""); GLUI_RadioGroup *filteringMethodRadioGroup = glui->add_radiogroup_to_panel(filteringPanel, &cartoonEffect->filteringMethod, -1, gluiCallback); glui->add_radiobutton_to_group(filteringMethodRadioGroup, "None"); glui->add_radiobutton_to_group(filteringMethodRadioGroup, "Bilateral"); glui->add_radiobutton_to_group(filteringMethodRadioGroup, "Kuwahara"); glui->add_statictext_to_panel(filteringPanel, ""); glui->add_checkbox_to_panel(filteringPanel, "Quantize Colours", &cartoonEffect->quantize, -1, gluiCallback); //Bilateral. glui->add_statictext_to_panel(filteringPanel, ""); GLUI_Rollout* bilateralRollout = glui->add_rollout_to_panel(filteringPanel, "Bilateral", 0, GLUI_PANEL_EMBOSSED); GLUI_Spinner *bilateralFilterPassesSpinner = glui->add_spinner_to_panel(bilateralRollout, "Filter Passes ", GLUI_SPINNER_INT, &cartoonEffect->bilateralFilterPasses, -1, gluiCallback); bilateralFilterPassesSpinner->set_int_limits(1, 10); GLUI_Spinner *bilateralKernelSizeSpinner = glui->add_spinner_to_panel(bilateralRollout, "Kernel Size ", GLUI_SPINNER_INT, &cartoonEffect->bilateralKernelSize, -1, gluiCallback); bilateralKernelSizeSpinner->set_int_limits(1, 100); GLUI_Spinner *bilateralSigmaSpinner = glui->add_spinner_to_panel(bilateralRollout, "Sample Deviation ", GLUI_SPINNER_FLOAT, &cartoonEffect->bilateralSigma, -1, gluiCallback); bilateralSigmaSpinner->set_float_limits(0.001, 0.15); //Kuwahara. GLUI_Rollout* kuwaharaRollout = glui->add_rollout_to_panel(filteringPanel, "Kuwahara", 0, GLUI_PANEL_EMBOSSED); GLUI_Spinner *kuwaharaFilterPassesSpinner = glui->add_spinner_to_panel(kuwaharaRollout, "Filter Passes ", GLUI_SPINNER_INT, &cartoonEffect->kuwaharaFilterPasses, -1, gluiCallback); kuwaharaFilterPassesSpinner->set_int_limits(1, 10); GLUI_Spinner *kuwaharaKernelSizeSpinner = glui->add_spinner_to_panel(kuwaharaRollout, "Kernel Size ", GLUI_SPINNER_INT, &cartoonEffect->kuwaharaKernelSize, -1, gluiCallback); kuwaharaKernelSizeSpinner->set_int_limits(1, 100); //Edge glui->add_statictext_to_panel(cartoonRollout, ""); GLUI_Panel *edgeDetectionPanel = glui->add_panel_to_panel(cartoonRollout, "Edge Detection"); glui->add_statictext_to_panel(edgeDetectionPanel, ""); GLUI_RadioGroup *edgeMethodRadioGroup = glui->add_radiogroup_to_panel(edgeDetectionPanel, &cartoonEffect->edgeMethod, -1, gluiCallback); glui->add_radiobutton_to_group(edgeMethodRadioGroup, "None"); glui->add_radiobutton_to_group(edgeMethodRadioGroup, "Depth Discontinuity"); glui->add_radiobutton_to_group(edgeMethodRadioGroup, "Sobel Depth"); glui->add_radiobutton_to_group(edgeMethodRadioGroup, "Sobel Colour"); glui->add_statictext_to_panel(edgeDetectionPanel, ""); GLUI_Spinner *edgeThresholdSpinner = glui->add_spinner_to_panel(edgeDetectionPanel, "Threshold ", GLUI_SPINNER_FLOAT, &cartoonEffect->edgeThreshold, -1, gluiCallback); edgeThresholdSpinner->set_float_limits(0.0, 2.0); //glui->add_button("Quit", 0, (GLUI_Update_CB) exit); /** Tell GLUI window which other window to recognize as the main gfx window **/ glui->set_main_gfx_window(window); //GLUI_Master.set_glutIdleFunc(NULL); }
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; }
int main(int argc, char* argv[]) { atexit(onExit); /****************************************/ /* Initialize GLUT and create window */ /****************************************/ glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE); glutInitWindowPosition(50, 50); glutInitWindowSize(500, 500); main_window = glutCreateWindow("COMP 175 Assignment 4"); glutDisplayFunc(myGlutDisplay); glutReshapeFunc(myGlutReshape); /****************************************/ /* Here's the GLUI code */ /****************************************/ GLUI* glui = GLUI_Master.create_glui("GLUI"); filenameTextField = new GLUI_EditText( glui, "Filename:", filenamePath); filenameTextField->set_w(300); GLUI_Spinner* recursionWidget = new GLUI_Spinner(glui, "Recursion:", &recursion); recursionWidget->set_float_limits(0, 10); //fix me glui->add_button("Load", 0, callback_load); glui->add_button("Start!", 0, callback_start); glui->add_checkbox("Isect Only", &isectOnly); GLUI_Panel *camera_panel = glui->add_panel("Camera"); (new GLUI_Spinner(camera_panel, "RotateV:", &camRotV)) ->set_int_limits(-179, 179); (new GLUI_Spinner(camera_panel, "RotateU:", &camRotU)) ->set_int_limits(-179, 179); (new GLUI_Spinner(camera_panel, "RotateW:", &camRotW)) ->set_int_limits(-179, 179); (new GLUI_Spinner(camera_panel, "Angle:", &viewAngle)) ->set_int_limits(1, 179); glui->add_column_to_panel(camera_panel, true); GLUI_Spinner* eyex_widget = glui->add_spinner_to_panel(camera_panel, "EyeX:", GLUI_SPINNER_FLOAT, &eyeX); eyex_widget->set_float_limits(-10, 10); GLUI_Spinner* eyey_widget = glui->add_spinner_to_panel(camera_panel, "EyeY:", GLUI_SPINNER_FLOAT, &eyeY); eyey_widget->set_float_limits(-10, 10); GLUI_Spinner* eyez_widget = glui->add_spinner_to_panel(camera_panel, "EyeZ:", GLUI_SPINNER_FLOAT, &eyeZ); eyez_widget->set_float_limits(-10, 10); GLUI_Spinner* lookx_widget = glui->add_spinner_to_panel(camera_panel, "LookX:", GLUI_SPINNER_FLOAT, &lookX); lookx_widget->set_float_limits(-10, 10); GLUI_Spinner* looky_widget = glui->add_spinner_to_panel(camera_panel, "LookY:", GLUI_SPINNER_FLOAT, &lookY); looky_widget->set_float_limits(-10, 10); GLUI_Spinner* lookz_widget = glui->add_spinner_to_panel(camera_panel, "LookZ:", GLUI_SPINNER_FLOAT, &lookZ); lookz_widget->set_float_limits(-10, 10); glui->add_button("Quit", 0, (GLUI_Update_CB)exit); glui->set_main_gfx_window(main_window); /* We register the idle callback with GLUI, *not* with GLUT */ GLUI_Master.set_glutIdleFunc(myGlutIdle); glutMainLoop(); return EXIT_SUCCESS; }
int main(int argc, char **argv) { /* setup OpenGL */ glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize(INITIAL_WIDTH, INITIAL_HEIGHT); glutInitWindowPosition(50, 50); main_window = glutCreateWindow( "2DCube" ); init(); glutDisplayFunc(display); glutReshapeFunc(myReshape); /* setup user controls */ GLUI *control_panel = GLUI_Master.create_glui( "Controls"); new GLUI_StaticText( control_panel, "2DCube Controls" ); new GLUI_Separator(control_panel); new GLUI_Button(control_panel, "Quit", 0, (GLUI_Update_CB)exit); new GLUI_Column(control_panel, true); GLUI_Spinner *spinner = new GLUI_Spinner(control_panel, "Size:", GLUI_SPINNER_FLOAT, &CubeSize); spinner->set_float_limits(2.0f, 8.0f, GLUI_LIMIT_CLAMP); new GLUI_Column(control_panel, true); GLUI_Rollout *eyePosRollout = new GLUI_Rollout(control_panel, "Eye Position", false); GLUI_Spinner *epX = new GLUI_Spinner(eyePosRollout, "X", GLUI_SPINNER_FLOAT, &EyePosX, 0, computeViewerAngle); GLUI_Spinner *epY = new GLUI_Spinner(eyePosRollout, "Y", GLUI_SPINNER_FLOAT, &EyePosY, 0, computeViewerAngle); GLUI_Spinner *epZ = new GLUI_Spinner(eyePosRollout, "Z", GLUI_SPINNER_FLOAT, &EyePosZ, 0, computeViewerAngle); epX->set_float_limits(-100.0f, 100.0f, GLUI_LIMIT_WRAP); epY->set_float_limits(-100.0f, 100.0f, GLUI_LIMIT_WRAP); epZ->set_float_limits(-100.0f, 100.0f, GLUI_LIMIT_WRAP); epX->set_float_val(EyePosX); epY->set_float_val(EyePosY); epZ->set_float_val(EyePosZ); GLUI_Rollout *lookAtRollout = new GLUI_Rollout(control_panel, "Looking At", false); GLUI_Spinner *laX = new GLUI_Spinner(lookAtRollout, "X", GLUI_SPINNER_FLOAT, &LookAtX, 0, computeViewerAngle); GLUI_Spinner *laY = new GLUI_Spinner(lookAtRollout, "Y", GLUI_SPINNER_FLOAT, &LookAtY, 0, computeViewerAngle); GLUI_Spinner *laZ = new GLUI_Spinner(lookAtRollout, "Z", GLUI_SPINNER_FLOAT, &LookAtZ, 0, computeViewerAngle); laX->set_float_limits(-100.0f, 100.0f, GLUI_LIMIT_WRAP); laY->set_float_limits(-100.0f, 100.0f, GLUI_LIMIT_WRAP); laZ->set_float_limits(-100.0f, 100.0f, GLUI_LIMIT_WRAP); laX->set_float_val(LookAtX); laY->set_float_val(LookAtY); laZ->set_float_val(LookAtZ); new GLUI_Column(control_panel, true); GLUI_Rollout *clippingRollout = new GLUI_Rollout(control_panel, "Clipping Parameters", false); GLUI_Spinner *hitherDistRollout = new GLUI_Spinner(clippingRollout, "Hither", GLUI_SPINNER_FLOAT, &HitherPlaneDist, 0, computePerspectiveMatrix); GLUI_Spinner *yonDistRollout = new GLUI_Spinner(clippingRollout, "Yon", GLUI_SPINNER_FLOAT, &YonPlaneDist, 0, computePerspectiveMatrix); GLUI_Spinner *viewDistRollout = new GLUI_Spinner(clippingRollout, "View", GLUI_SPINNER_FLOAT, &ViewPlaneDist, 0, refreshWindowAndPerspective); hitherDistRollout->set_float_limits(0.0f, 5.0f, GLUI_LIMIT_CLAMP); viewDistRollout->set_float_limits(5.0f, 10.0f, GLUI_LIMIT_CLAMP); yonDistRollout->set_float_limits(10.0f, 100.0f, GLUI_LIMIT_CLAMP); GLUI_Spinner *thetaSpinner = new GLUI_Spinner(control_panel, "Theta", GLUI_SPINNER_FLOAT, &Theta, 0, computeWindowMatrix); thetaSpinner->set_float_limits(0.0f, 360.0f, GLUI_LIMIT_WRAP); thetaSpinner->set_float_val(Theta); control_panel->set_main_gfx_window(main_window); glutMainLoop(); return EXIT_SUCCESS; }
//------------------------------------------------------------------------- // Setup GLUI stuff. //------------------------------------------------------------------------- void setupGLUI () { // Set idle function GLUI_Master.set_glutIdleFunc (idle); // Create GLUI window glui_window = GLUI_Master.create_glui ("Options", 0, window_x - 235, window_y); //--------------------------------------------------------------------- // 'Object Properties' Panel //--------------------------------------------------------------------- // Add the 'Object Properties' Panel to the GLUI window GLUI_Panel *op_panel = glui_window->add_panel ("Object Properties"); // Add the Draw Check box to the 'Object Properties' Panel glui_window->add_checkbox_to_panel (op_panel, "Draw", &draw ); // Add the Wireframe Check box to the 'Object Properties' Panel glui_window->add_checkbox_to_panel (op_panel, "Wireframe", &wireframe ); // Add a separator glui_window->add_separator_to_panel (op_panel); // Add the Color listbox to the 'Object Properties' Panel GLUI_Listbox *color_listbox = glui_window->add_listbox_to_panel (op_panel, "Color", &listbox_item_id, COLOR_LISTBOX, glui_callback); // Add the items to the listbox color_listbox->add_item (1, "Black"); color_listbox->add_item (2, "Blue"); color_listbox->add_item (3, "Cyan"); color_listbox->add_item (4, "Dark Grey"); color_listbox->add_item (5, "Grey"); color_listbox->add_item (6, "Green"); color_listbox->add_item (7, "Light Grey"); color_listbox->add_item (8, "Magenta"); color_listbox->add_item (9, "Orange"); color_listbox->add_item (10, "Pink"); color_listbox->add_item (11, "Red"); color_listbox->add_item (12, "White"); color_listbox->add_item (13, "Yellow"); // Select the White Color by default color_listbox->set_int_val (12); //--------------------------------------------------------------------- // 'Object Type' Panel //--------------------------------------------------------------------- // Add the 'Object Type' Panel to the GLUI window GLUI_Rollout *ot_rollout = glui_window->add_rollout ("Object Type"); // Create radio button group GLUI_RadioGroup *ot_group = glui_window->add_radiogroup_to_panel (ot_rollout, &radiogroup_item_id, OBJECTYPE_RADIOGROUP, glui_callback); // Add the radio buttons to the radio group glui_window->add_radiobutton_to_group( ot_group, "Cube" ); glui_window->add_radiobutton_to_group( ot_group, "Sphere" ); glui_window->add_radiobutton_to_group( ot_group, "Cone" ); glui_window->add_radiobutton_to_group( ot_group, "Torus" ); glui_window->add_radiobutton_to_group( ot_group, "Dodecahedron" ); glui_window->add_radiobutton_to_group( ot_group, "Octahedron" ); glui_window->add_radiobutton_to_group( ot_group, "Tetrahedron" ); glui_window->add_radiobutton_to_group( ot_group, "Icosahedron" ); glui_window->add_radiobutton_to_group( ot_group, "Teapot" ); //--------------------------------------------------------------------- // 'Transformation' Panel //--------------------------------------------------------------------- // Add the 'Transformation' Panel to the GLUI window GLUI_Panel *transformation_panel = glui_window->add_panel ("Transformation"); // Create transformation panel 1 that will contain the Translation controls GLUI_Panel *transformation_panel1 = glui_window->add_panel_to_panel (transformation_panel, ""); // Add the xy translation control GLUI_Translation *translation_xy = glui_window->add_translation_to_panel (transformation_panel1, "Translation XY", GLUI_TRANSLATION_XY, translate_xy, TRANSLATION_XY, glui_callback ); // Set the translation speed translation_xy->set_speed( 0.005 ); // Add column, but don't draw it glui_window->add_column_to_panel (transformation_panel1, false); // Add the z translation control GLUI_Translation *translation_z = glui_window->add_translation_to_panel (transformation_panel1, "Translation Z", GLUI_TRANSLATION_Z, &translate_z, TRANSLATION_Z, glui_callback ); // Set the translation speed translation_z->set_speed( 0.005 ); // Create transformation panel 2 that will contain the rotation and spinner controls GLUI_Panel *transformation_panel2 = glui_window->add_panel_to_panel (transformation_panel, ""); // Add the rotation control glui_window->add_rotation_to_panel (transformation_panel2, "Rotation", rotation_matrix, ROTATION, glui_callback); // Add separator glui_window->add_separator_to_panel (transformation_panel2); // Add the scale spinner GLUI_Spinner *spinner = glui_window->add_spinner_to_panel (transformation_panel2, "Scale", GLUI_SPINNER_FLOAT, &scale, SCALE_SPINNER, glui_callback); // Set the limits for the spinner spinner->set_float_limits ( -4.0, 4.0 ); //--------------------------------------------------------------------- // 'Quit' Button //--------------------------------------------------------------------- // Add the Quit Button glui_window->add_button ("Quit", QUIT_BUTTON, glui_callback); // Let the GLUI window know where its main graphics window is glui_window->set_main_gfx_window( main_window ); }
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; }
GLUI_Spinner* createColorSpinner(GLUI_Panel* pan, const char* label, float* pointer) { GLUI_Spinner* spinner = new GLUI_Spinner(pan, label, pointer); spinner->set_float_limits(0, 1); return spinner; }
int main(int argc, char** argv) { simulatorPageCount = 0; while (g_testEntries[simulatorPageCount].createFcn != NULL) { ++simulatorPageCount; } simulatorPageIndex = b2Clamp(simulatorPageIndex, 0, simulatorPageCount-1); simulatorPageSelection = simulatorPageIndex; entry = g_testEntries + simulatorPageIndex; simulatorPage = entry->createFcn(); glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowSize(width, height); char title[32]; sprintf(title, "Simulert plankesorteringsanlegg"); mainWindow = glutCreateWindow(title); //glutSetOption (GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); glutDisplayFunc(SimulationLoop); GLUI_Master.set_glutReshapeFunc(Resize); GLUI_Master.set_glutKeyboardFunc(Keyboard); GLUI_Master.set_glutSpecialFunc(KeyboardSpecial); GLUI_Master.set_glutMouseFunc(Mouse); #ifdef FREEGLUT glutMouseWheelFunc(MouseWheel); #endif glutMotionFunc(MouseMotion); glutKeyboardUpFunc(KeyboardUp); glui = GLUI_Master.create_glui_subwindow( mainWindow, GLUI_SUBWINDOW_RIGHT ); glui->add_statictext("Tests"); GLUI_Listbox* testList = glui->add_listbox("", &simulatorPageSelection); glui->add_separator(); GLUI_Spinner* velocityIterationSpinner = glui->add_spinner("Vel Iters", GLUI_SPINNER_INT, &settings.velocityIterations); velocityIterationSpinner->set_int_limits(1, 500); GLUI_Spinner* positionIterationSpinner = glui->add_spinner("Pos Iters", GLUI_SPINNER_INT, &settings.positionIterations); positionIterationSpinner->set_int_limits(0, 100); GLUI_Spinner* hertzSpinner = glui->add_spinner("Hertz", GLUI_SPINNER_FLOAT, &settingsHz); hertzSpinner->set_float_limits(5.0f, 200.0f); glui->add_checkbox("Warm Starting", &settings.enableWarmStarting); glui->add_checkbox("Time of Impact", &settings.enableContinuous); glui->add_checkbox("Sub-Stepping", &settings.enableSubStepping); //glui->add_separator(); GLUI_Panel* drawPanel = glui->add_panel("Draw"); glui->add_checkbox_to_panel(drawPanel, "Shapes", &settings.drawShapes); glui->add_checkbox_to_panel(drawPanel, "Joints", &settings.drawJoints); glui->add_checkbox_to_panel(drawPanel, "AABBs", &settings.drawAABBs); glui->add_checkbox_to_panel(drawPanel, "Pairs", &settings.drawPairs); glui->add_checkbox_to_panel(drawPanel, "Contact Points", &settings.drawContactPoints); glui->add_checkbox_to_panel(drawPanel, "Contact Normals", &settings.drawContactNormals); glui->add_checkbox_to_panel(drawPanel, "Contact Forces", &settings.drawContactForces); glui->add_checkbox_to_panel(drawPanel, "Friction Forces", &settings.drawFrictionForces); glui->add_checkbox_to_panel(drawPanel, "Center of Masses", &settings.drawCOMs); glui->add_checkbox_to_panel(drawPanel, "Statistics", &settings.drawStats); glui->add_checkbox_to_panel(drawPanel, "Profile", &settings.drawProfile); int32 testCount = 0; SimulatorPageEntry* e = g_testEntries; while (e->createFcn) { testList->add_item(testCount, e->name); ++testCount; ++e; } glui->add_button("Pause", 0, Pause); glui->add_button("Single Step", 0, SingleStep); glui->add_button("Restart", 0, Restart); glui->add_button("Quit", 0,(GLUI_Update_CB)Exit); glui->add_separator(); glui->add_edittext( "Serialport:", GLUI_EDITTEXT_TEXT, serialport ); glui->add_button("Set serialport", 0, (GLUI_Update_CB)SetSerialport); glui->set_main_gfx_window( mainWindow ); // Use a timer to control the frame rate. glutTimerFunc(framePeriod, Timer, 0); glutMainLoop(); return 0; }
void CFlowEntropyViewerWin::_InitFunc() { CDvrWin2::_InitFunc(); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); _DisableVerticalSync(); _DisplayFpsOn(); // the FPS will be displayed _KeepUpdateOn(); // the frame will be keep updating _KeepUpdateOn(); CClipVolume::_InitFunc(); /////////////////////////////////////////////////////////////////// pidRayIntegral = CSetShadersByString( NULL , #include "ray_integral.frag.h" ); assert( pidRayIntegral ); /////////////////////////////////////////////////////////////////// pidImportanceCulling = HCreateProgramHandle(); _AddShaderProgram( pidImportanceCulling, GL_VERTEX_SHADER_ARB, #include "line_illumination.vert.h" ); _AddShaderProgram( pidImportanceCulling, GL_FRAGMENT_SHADER_ARB, #include "importance_culling.frag.h" ); _AddShaderProgram( pidImportanceCulling, GL_GEOMETRY_SHADER_EXT, #include "line_drawing.geom.h" ); glProgramParameteriEXT(pidImportanceCulling, GL_GEOMETRY_INPUT_TYPE_EXT, GL_LINES); glProgramParameteriEXT(pidImportanceCulling, GL_GEOMETRY_OUTPUT_TYPE_EXT, GL_LINE_STRIP); glProgramParameteriEXT(pidImportanceCulling, GL_GEOMETRY_VERTICES_OUT_EXT, 2 * 9); _LinkPrograms(pidImportanceCulling); assert( pidImportanceCulling ); /////////////////////////////////////////////////////////////////// pidImportanceFilling = CSetShadersByString( NULL , #include "importance_filling.frag.h" ); assert( pidImportanceFilling ); /////////////////////////////////////////////////////////////////// // set up UI GLUI *pcGlui = PCGetGluiWin(); GLUI_Spinner *pcSpinner_NrOfSlices = PCGetGluiWin()->add_spinner("#Slices", GLUI_SPINNER_INT, &iNrOfSlices); pcSpinner_NrOfSlices->set_int_limits(1, 4096); // create a spinner to control the brightness gain GLUI_Spinner *pcSpinner_ThicknessGain = PCGetGluiWin()->add_spinner("Thickness Gain", GLUI_SPINNER_FLOAT, &fThicknessGain); pcSpinner_ThicknessGain->set_float_limits(0.0f, 4096.0f); GLUI_Panel *pcPanel_ClippingPlane = PCGetGluiWin()->add_rollout("Clipping Plane"); { GLUI_Panel *pcPanel_Outside = PCGetGluiWin()->add_panel_to_panel(pcPanel_ClippingPlane, "Outside"); { GLUI_Spinner *pcSpinner_Threshold = PCGetGluiWin()->add_spinner_to_panel(pcPanel_Outside, "Threshold", GLUI_SPINNER_FLOAT, &cClippingPlaneOutsideProp.fThreshold); pcSpinner_Threshold->set_float_limits(0.0f, 1.0f); PCGetGluiWin()->add_checkbox_to_panel(pcPanel_Outside, "mono?", &cClippingPlaneOutsideProp.ibMonoColor); GLUI_Spinner *pcSpinner; pcSpinner = PCGetGluiWin()->add_spinner_to_panel(pcPanel_Outside, "R", GLUI_SPINNER_FLOAT, &cClippingPlaneOutsideProp.v4Color.x); pcSpinner->set_float_limits(0.0, 1.0); pcSpinner = PCGetGluiWin()->add_spinner_to_panel(pcPanel_Outside, "G", GLUI_SPINNER_FLOAT, &cClippingPlaneOutsideProp.v4Color.y); pcSpinner->set_float_limits(0.0, 1.0); pcSpinner = PCGetGluiWin()->add_spinner_to_panel(pcPanel_Outside, "B", GLUI_SPINNER_FLOAT, &cClippingPlaneOutsideProp.v4Color.z); pcSpinner->set_float_limits(0.0, 1.0); pcSpinner = PCGetGluiWin()->add_spinner_to_panel(pcPanel_Outside, "A", GLUI_SPINNER_FLOAT, &cClippingPlaneOutsideProp.v4Color.w); pcSpinner->set_float_limits(0.0, 1.0); } PCGetGluiWin()->add_column_to_panel(pcPanel_ClippingPlane); GLUI_Panel *pcPanel_Inside = PCGetGluiWin()->add_panel_to_panel(pcPanel_ClippingPlane, "Inside"); { GLUI_Spinner *pcSpinner_Threshold = PCGetGluiWin()->add_spinner_to_panel(pcPanel_Inside, "Threshold", GLUI_SPINNER_FLOAT, &cClippingPlaneInsideProp.fThreshold); pcSpinner_Threshold->set_float_limits(0.0f, 1.0f); PCGetGluiWin()->add_checkbox_to_panel(pcPanel_Inside, "mono?", &cClippingPlaneInsideProp.ibMonoColor); GLUI_Spinner *pcSpinner; pcSpinner = PCGetGluiWin()->add_spinner_to_panel(pcPanel_Inside, "R", GLUI_SPINNER_FLOAT, &cClippingPlaneInsideProp.v4Color.x); pcSpinner->set_float_limits(0.0, 1.0); pcSpinner = PCGetGluiWin()->add_spinner_to_panel(pcPanel_Inside, "G", GLUI_SPINNER_FLOAT, &cClippingPlaneInsideProp.v4Color.y); pcSpinner->set_float_limits(0.0, 1.0); pcSpinner = PCGetGluiWin()->add_spinner_to_panel(pcPanel_Inside, "B", GLUI_SPINNER_FLOAT, &cClippingPlaneInsideProp.v4Color.z); pcSpinner->set_float_limits(0.0, 1.0); pcSpinner = PCGetGluiWin()->add_spinner_to_panel(pcPanel_Inside, "A", GLUI_SPINNER_FLOAT, &cClippingPlaneInsideProp.v4Color.w); pcSpinner->set_float_limits(0.0, 1.0); } } GLUI_Panel *pcPanel_RenderMode = PCGetGluiWin()->add_rollout("Render Mode"); GLUI_RadioGroup *pcRadioGroup_RenderMode = PCGetGluiWin()->add_radiogroup_to_panel(pcPanel_RenderMode, &iRenderMode); PCGetGluiWin()->add_radiobutton_to_group(pcRadioGroup_RenderMode, "None"); PCGetGluiWin()->add_radiobutton_to_group(pcRadioGroup_RenderMode, "Entropy Field"); PCGetGluiWin()->add_radiobutton_to_group(pcRadioGroup_RenderMode, "Streamlines w/ Importance Culling"); PCGetGluiWin()->add_radiobutton_to_group(pcRadioGroup_RenderMode, "Streamlines in Slabs"); GLUI_Panel *pcPanel_Shading = PCGetGluiWin()->add_rollout("Shading"); PCGetGluiWin()->add_checkbox_to_panel(pcPanel_Shading, "mono?", &ibIsColorMono); PCGetGluiWin()->add_checkbox_to_panel(pcPanel_Shading, "lighting?", &ibIsLightingEnabled); PCGetGluiWin()->add_checkbox_to_panel(pcPanel_Shading, "halo?", &ibIsHaloEnabled); cMaterial._AddGlui(PCGetGluiWin(), pcPanel_Shading); GLUI_Panel *pcPanel_Slabs = PCGetGluiWin()->add_rollout("Slab"); PCGetGluiWin()->add_spinner_to_panel(pcPanel_Slabs, "Min Slab", GLUI_SPINNER_INT, &iMinSlab); PCGetGluiWin()->add_spinner_to_panel(pcPanel_Slabs, "#Slabs", GLUI_SPINNER_INT, &iNrOfSlabsToRender); GLUI_Spinner *pcSpinner_OcclusionSaturation = PCGetGluiWin()->add_spinner_to_panel(pcPanel_Slabs, "Occlusion Saturation ", GLUI_SPINNER_FLOAT, &fOcclusionSaturation ); pcSpinner_OcclusionSaturation->set_float_limits(0.0f, 1.0f); GLUI_Spinner *pcSpinner_MaxLengthToNeighbors = PCGetGluiWin()->add_spinner_to_panel(pcPanel_Slabs, "Max. Dist.", GLUI_SPINNER_INT, &iMaxDistanceToNeighbors_screen); pcSpinner_MaxLengthToNeighbors->set_int_limits(0, 5); }
/** Sets up the GLUI window. */ void InitGlui() { //User Input Section GLUI_Panel *UserInput; GLUI_Rollout *UserInputRollout; //GLUI_Rollout * ReadInFileRollout; //Visualization Settings: GLUI_Panel *settings; //Transformation Settings: GLUI_Panel * transformationPanel; GLUI_Rollout * TransformationRollout; GLUI_Rotation *rotation; GLUI_Translation *trans, *scale; //Color Options Settings: GLUI_Rollout * ColorOptions; GLUI_Spinner * backgroundColorSpinnerR; GLUI_Spinner * backgroundColorSpinnerG; GLUI_Spinner * backgroundColorSpinnerB; GLUI_Spinner * boxColorSpinner; //Graphics Options Settings: GLUI_Panel * graphicsOptions; //Graphics Rollouts: GLUI_Panel * CustomSettings; GLUI_Rollout * ArrowSettings; GLUI_Rollout * AnimationSettings; GLUI_Rollout * IsosurfaceSettings; GLUI_Rollout * PointsSettings; GLUI_Rollout * StreamlineSettings; GLUI_Rollout * VectorBlobSettings; GLUI_Rollout * CuttingPlaneSettings; //ObjFileSettings: //GLUI_Panel * ObjFileSettings; //Arrow Settings: GLUI_Spinner * spinArrowLength; GLUI_Spinner * spinNumPoints; GLUI_Spinner * spinMinVector; GLUI_Spinner * spinMaxVector; //GLUI_Spinner * alphaVector; //Isosurface Settings GLUI_Spinner * spinIsoValue; GLUI_Spinner * spinNumContours; GLUI_Spinner * spinIsoResolution; //GLUI_Spinner * spinZPlaneVal; //Streamline Controls: GLUI_Spinner * spinNumStreamlines; //Probe Controls: //GLUI_Panel * probePanel; GLUI_Spinner * ProbeX; GLUI_Spinner * ProbeY; GLUI_Spinner * ProbeZ; //Vector Sheet Controls: //GLUI_Spinner * VectorBlobTime; GLUI_Spinner * VectorBlobXLoc; GLUI_Spinner * VectorBlobYLoc; GLUI_Spinner * VectorBlobZLoc; GLUI_Spinner * VectorBlobXVec; GLUI_Spinner * VectorBlobYVec; GLUI_Spinner * VectorBlobZVec; //Cutting Plane Controls: //GLUI_Spinner * VectorBlobTime; GLUI_Spinner * CuttingPlaneXLoc; GLUI_Spinner * CuttingPlaneYLoc; GLUI_Spinner * CuttingPlaneZLoc; GLUI_Spinner * CuttingPlaneXVec; GLUI_Spinner * CuttingPlaneYVec; GLUI_Spinner * CuttingPlaneZVec; GLUI_Spinner * Tolerence; GLUI_Spinner * ContDist; //dot point animation controls: GLUI_Spinner * dotPointColorSpinnerR; GLUI_Spinner * dotPointColorSpinnerG; //GLUI_Spinner * dotPointColorSpinnerB; //Strings for Sliders: //char tempstr[128]; //char xstr[128]; //char ystr[128]; //char zstr[128]; //char radstr[128]; //char gradstr[128]; //char vecstr[128]; // setup the glui window: glutInitWindowPosition(Framework::instance()->INIT_WINDOW_SIZE + 50, 0); TestGlui = GLUI_Master.create_glui((char *)Framework::instance()->GLUITITLE); TestGlui->add_statictext((char *)Framework::instance()->GLUITITLE); //Here is Where the User Defined UserInputRollout = TestGlui->add_rollout("User Input Options"); UserInput = TestGlui->add_panel_to_panel(UserInputRollout, "User Input Options"); TestGlui->add_checkbox_to_panel(UserInput, "Use Prism Space Definer", &Framework::instance()->usePrism); TestGlui->add_checkbox_to_panel(UserInput, "Use Point Grid", &Framework::instance()->useGrid); Framework::instance()->spaceEditText = TestGlui->add_edittext_to_panel(UserInput, "Space Definer Equation:", GLUI_EDITTEXT_TEXT, Framework::instance()->SpaceDefinerString); Framework::instance()->spaceEditText->set_w(400); Framework::instance()->vectorEditText = TestGlui->add_edittext_to_panel(UserInput,"Vector Definer Equation:", GLUI_EDITTEXT_TEXT, Framework::instance()->VectorDefinerString); Framework::instance()->vectorEditText->set_w(400); GLUI_Panel* buttons = TestGlui->add_panel_to_panel(UserInput, ""); TestGlui->add_column_to_panel(buttons, 0); TestGlui->add_button_to_panel(buttons, "Reset", 0, ((GLUI_Update_CB)MyButtons)); TestGlui->add_column_to_panel(buttons, 0); TestGlui->add_button_to_panel(buttons, "Render", 1, ((GLUI_Update_CB)MyButtons)); TestGlui->add_column_to_panel(buttons, 0); TestGlui->add_button_to_panel(buttons, "Get File", 3, ((GLUI_Update_CB)MyButtons)); //Visualization Settings: TestGlui->add_separator(); settings = TestGlui->add_panel("Visual Settings"); TestGlui->add_column_to_panel(settings, 0); TestGlui->add_checkbox_to_panel(settings, "Axes", &Framework::instance()->AxesOn); TestGlui->add_column_to_panel(settings, 0); TestGlui->add_checkbox_to_panel(settings, "Box", &Framework::instance()->BoxOn); TestGlui->add_column_to_panel(settings,0); TestGlui->add_checkbox_to_panel(settings, "Perspective", &Framework::instance()->WhichProjection); TestGlui->add_column_to_panel(settings, 0); TestGlui->add_checkbox_to_panel(settings, "Intensity Depth Cue", &Framework::instance()->DepthCueOn); //Transformation Settings: TransformationRollout = TestGlui->add_rollout("Transformation", 1); transformationPanel = TestGlui->add_panel_to_panel(TransformationRollout, "Object Transformation"); TestGlui->add_column_to_panel(transformationPanel, 0); rotation = TestGlui->add_rotation_to_panel(transformationPanel, "Rotation", (float *)Framework::instance()->RotMatrix); rotation->set_spin(1.0); rotation->reset(); TestGlui->add_column_to_panel(transformationPanel, 0); scale = TestGlui->add_translation_to_panel(transformationPanel, "Scale", GLUI_TRANSLATION_Y, &Framework::instance()->Scale2); scale->set_speed(0.005f); TestGlui->add_column_to_panel(transformationPanel, 0); trans = TestGlui->add_translation_to_panel(transformationPanel, "Trans XY", GLUI_TRANSLATION_XY, &Framework::instance()->TransXYZ[0]); trans->set_speed(0.05f); TestGlui->add_column_to_panel(transformationPanel, 0); trans = TestGlui->add_translation_to_panel(transformationPanel, "Trans Z", GLUI_TRANSLATION_Z, &Framework::instance()->TransXYZ[2]); trans->set_speed(0.05f); //Color Settings Rollout: TestGlui->add_separator(); ColorOptions = TestGlui->add_rollout("Color Settings", 0); TestGlui->add_checkbox_to_panel(ColorOptions, "Alternate Color Scheme", &Framework::instance()->ColorAlternate, 1, CheckboxCallback); TestGlui->add_separator(); backgroundColorSpinnerR = TestGlui->add_spinner_to_panel(ColorOptions, "Background Color R", GLUI_SPINNER_FLOAT, &Framework::instance()->backgroundColorR); backgroundColorSpinnerR->set_float_limits(0.0, 1.0); backgroundColorSpinnerR ->set_speed(0.05); backgroundColorSpinnerG = TestGlui->add_spinner_to_panel(ColorOptions, "Background Color G", GLUI_SPINNER_FLOAT, &Framework::instance()->backgroundColorG); backgroundColorSpinnerG->set_float_limits(0.0, 1.0); backgroundColorSpinnerG->set_speed(0.05); backgroundColorSpinnerB = TestGlui->add_spinner_to_panel(ColorOptions, "Background Color B", GLUI_SPINNER_FLOAT, &Framework::instance()->backgroundColorB); backgroundColorSpinnerB->set_float_limits(0.0, 1.0); backgroundColorSpinnerB->set_speed(0.05); boxColorSpinner = TestGlui->add_spinner_to_panel(ColorOptions, "Box And Axes Color", GLUI_SPINNER_FLOAT, &Framework::instance()->boxColor); boxColorSpinner->set_float_limits(0.0, 1.0); boxColorSpinner->set_speed(0.05); //Graphics Options Panel: graphicsOptions = TestGlui->add_panel("Grahics Options"); TestGlui->add_column_to_panel(graphicsOptions, 0); TestGlui->add_checkbox_to_panel(graphicsOptions, "Use Arrows", &Framework::instance()->useArrows); TestGlui->add_checkbox_to_panel(graphicsOptions, "Use Animation", &Framework::instance()->useAnimation); TestGlui->add_checkbox_to_panel(graphicsOptions, "Use CuttingPlane", &Framework::instance()->useCuttingPlane); TestGlui->add_column_to_panel(graphicsOptions, 0); TestGlui->add_checkbox_to_panel(graphicsOptions, "Use Isosurfaces", &Framework::instance()->useIsosurfaces); TestGlui->add_checkbox_to_panel(graphicsOptions, "Use Points", &Framework::instance()->usePoints); TestGlui->add_checkbox_to_panel(graphicsOptions, "Use Streamlines", &Framework::instance()->useStreamlines); TestGlui->add_column_to_panel(graphicsOptions, 0); TestGlui->add_checkbox_to_panel(graphicsOptions, "Use VectorBlob", &Framework::instance()->useVectorBlob, 1, SpinnerCallback); TestGlui->add_checkbox_to_panel(graphicsOptions, "Use VectorSheet", &Framework::instance()->useVectorSheet); CustomSettings = TestGlui->add_panel("", 0); ArrowSettings = TestGlui->add_rollout_to_panel(CustomSettings, "Arrow Settings", 0); ArrowSettings->set_w(200); AnimationSettings = TestGlui->add_rollout_to_panel(CustomSettings, "Animation Settings", 0); AnimationSettings->set_w(200); IsosurfaceSettings = TestGlui->add_rollout_to_panel(CustomSettings, "Isosurface Settings", 0); IsosurfaceSettings->set_w(200); PointsSettings = TestGlui->add_rollout_to_panel(CustomSettings, "Points Settings", 0); PointsSettings->set_w(200); StreamlineSettings = TestGlui->add_rollout_to_panel(CustomSettings, "Streamline Settings", 0); StreamlineSettings->set_w(200); VectorBlobSettings = TestGlui->add_rollout_to_panel(CustomSettings, "Vector Blob Settings", 0); VectorBlobSettings ->set_w(200); CuttingPlaneSettings = TestGlui->add_rollout_to_panel(CustomSettings, "Cutting Plane Settings", 0); CuttingPlaneSettings->set_w(200); //Arrow Settings: //TRadLowHigh[0] = VecTest[0]; //TRadLowHigh[1] = VecTest[1]; /* printf("Before Sliders are initialize, Value of RadLowHigh[0] is %f, RadLowHigh[1] is %f, VecTest[0] is %f, VecTest[1] is %f\n", TRadLowHigh[0], TRadLowHigh[1], VecTest[0], VecTest[1]); TRadSlider = TestGlui->add_slider_to_panel(ArrowSettings, true, GLUI_HSLIDER_FLOAT, VecTest, RADID, MySliders); TRadSlider->set_float_limits(TRADIUSMIN, TRADIUSMAX); TRadSlider->set_w(250); // good slider width sprintf(radstr, TRADIUSFORMAT, TRadLowHigh[0], TRadLowHigh[1]); TRadLabel = TestGlui->add_statictext_to_panel(ArrowSettings, radstr); printf("After Sliders are initialized, Value of RadLowHigh[0] is %f, RadLowHigh[1] is %f, VecTest[0] is %f, VecTest[1] is %f\n", TRadLowHigh[0], TRadLowHigh[1], VecTest[0], VecTest[1]); */ spinArrowLength = TestGlui->add_spinner_to_panel(ArrowSettings, "Arrow Size", GLUI_SPINNER_FLOAT, &Framework::instance()->ArrowLength); spinArrowLength ->set_float_limits(0.0, 15.0); spinArrowLength ->set_speed(0.1); Framework::instance()->spinVecMin = Framework::instance()->GetVectorMin(); Framework::instance()->spinVecMax = Framework::instance()->GetVectorMax(); spinMinVector = TestGlui->add_spinner_to_panel(ArrowSettings, "Vector Magnitude Min", GLUI_SPINNER_FLOAT, &Framework::instance()->spinVecMin); spinMinVector->set_float_limits(0.0, 1000.0); spinMinVector->set_speed(0.05); spinMaxVector = TestGlui->add_spinner_to_panel(ArrowSettings, "Vector Magnitude Max", GLUI_SPINNER_FLOAT, &Framework::instance()->spinVecMax); spinMaxVector->set_float_limits(0.0, 1000.0); spinMaxVector->set_speed(0.05); /* alphaVector = TestGlui->add_spinner_to_panel(ArrowSettings, "Arrow Alpha", GLUI_SPINNER_FLOAT, &Framework::instance()->vecAlphaVal); alphaVector->set_float_limits(0.0, 1.0); alphaVector->set_speed(0.05); */ //Streamline & Probe Settings: spinNumStreamlines = TestGlui->add_spinner_to_panel(StreamlineSettings, "Cubed Number of Streamlines", GLUI_SPINNER_INT, &Framework::instance()->NumStreamlines, 0, SpinnerCallback); spinNumStreamlines -> set_float_limits(1, 10); spinNumStreamlines -> set_speed(0.1); TestGlui->add_checkbox_to_panel(StreamlineSettings, "Use Probe", &Framework::instance()->useProbe); ProbeX = TestGlui->add_spinner_to_panel(StreamlineSettings, "XProbeValue", GLUI_SPINNER_FLOAT, &Framework::instance()->ProbeXVal); ProbeX->set_float_limits(-1.0, 1.0); ProbeX->set_speed(0.1); ProbeY = TestGlui->add_spinner_to_panel(StreamlineSettings, "YProbeValue", GLUI_SPINNER_FLOAT, &Framework::instance()->ProbeYVal); ProbeY->set_float_limits(-1.0, 1.0); ProbeY->set_speed(0.1); ProbeZ = TestGlui->add_spinner_to_panel(StreamlineSettings, "ZProbeValue", GLUI_SPINNER_FLOAT, &Framework::instance()->ProbeZVal); ProbeZ->set_float_limits(-1.0, 1.0); ProbeZ->set_speed(0.1); //Point Settings: TestGlui->add_checkbox_to_panel(PointsSettings, "Use Jitter", &Framework::instance()->useJitter); //Isosurface Settings: spinNumContours = TestGlui->add_spinner_to_panel(IsosurfaceSettings, "NumContours", GLUI_SPINNER_INT, &Framework::instance()->numContours, 3, SpinnerCallback); spinNumContours->set_int_limits(1, 30); spinNumContours->set_speed(0.5); float tempMin = Framework::instance()->GetVectorMin(); float tempMax = Framework::instance()->GetVectorMax(); printf("IsoMin is %f, IsoMax is %f\n", tempMin, tempMax); spinIsoValue = TestGlui->add_spinner_to_panel(IsosurfaceSettings, "IsoValue", GLUI_SPINNER_FLOAT, &Framework::instance()->IsosurfacesVal, 3, SpinnerCallback); spinIsoValue->set_float_limits(tempMin, tempMax); spinIsoValue->set_speed(0.5); spinIsoResolution = TestGlui->add_spinner_to_panel(IsosurfaceSettings, "IsoResolution", GLUI_SPINNER_INT, &Framework::instance()->IsoResolution, 3, SpinnerCallback); spinIsoResolution->set_int_limits(10, 100); spinIsoResolution->set_speed(0.1); //VectorBlob Settings: VectorBlobTime = TestGlui->add_spinner_to_panel(VectorBlobSettings, "Time Value", GLUI_SPINNER_INT, &Framework::instance()->VectorBlobTimeVal, 2, SpinnerCallback); VectorBlobTime->set_int_limits(0, 100); VectorBlobTime->set_speed(0.5); VectorBlobXLoc = TestGlui->add_spinner_to_panel(VectorBlobSettings, "XVectorBlobLocation", GLUI_SPINNER_FLOAT, &Framework::instance()->VectorBlobXLoc, 1, SpinnerCallback); VectorBlobXLoc->set_float_limits(-1.0, 1.0); VectorBlobXLoc->set_speed(0.2); VectorBlobYLoc = TestGlui->add_spinner_to_panel(VectorBlobSettings, "YVectorBlobLocation", GLUI_SPINNER_FLOAT, &Framework::instance()->VectorBlobYLoc, 1, SpinnerCallback); VectorBlobYLoc->set_float_limits(-1.0, 1.0); VectorBlobYLoc->set_speed(0.2); VectorBlobZLoc = TestGlui->add_spinner_to_panel(VectorBlobSettings, "ZVectorBlobLocation", GLUI_SPINNER_FLOAT, &Framework::instance()->VectorBlobZLoc, 1, SpinnerCallback); VectorBlobZLoc->set_float_limits(-1.0, 1.0); VectorBlobZLoc->set_speed(0.2); VectorBlobXVec = TestGlui->add_spinner_to_panel(VectorBlobSettings, "XVectorBlobVector", GLUI_SPINNER_FLOAT, &Framework::instance()->VectorBlobXVec, 1, SpinnerCallback); VectorBlobXVec->set_float_limits(-1.0, 1.0); VectorBlobXVec->set_speed(0.2); VectorBlobYVec = TestGlui->add_spinner_to_panel(VectorBlobSettings, "YVectorBlobVector", GLUI_SPINNER_FLOAT, &Framework::instance()->VectorBlobYVec, 1, SpinnerCallback); VectorBlobYVec->set_float_limits(-1.0, 1.0); VectorBlobYVec->set_speed(0.2); VectorBlobZVec = TestGlui->add_spinner_to_panel(VectorBlobSettings, "ZVectorBlobVector", GLUI_SPINNER_FLOAT, &Framework::instance()->VectorBlobZVec, 1, SpinnerCallback); VectorBlobZVec->set_float_limits(-1.0, 1.0); VectorBlobZVec->set_speed(0.2); //Cutting Plane Settings: CuttingPlaneXLoc = TestGlui->add_spinner_to_panel(CuttingPlaneSettings, "XCuttingPlaneLocation", GLUI_SPINNER_FLOAT, &Framework::instance()->CuttingPlaneXLoc); CuttingPlaneXLoc->set_float_limits(-1.0, 1.0); CuttingPlaneXLoc->set_speed(0.2); CuttingPlaneYLoc = TestGlui->add_spinner_to_panel(CuttingPlaneSettings, "YCuttingPlaneLocation", GLUI_SPINNER_FLOAT, &Framework::instance()->CuttingPlaneYLoc); CuttingPlaneYLoc->set_float_limits(-1.0, 1.0); CuttingPlaneYLoc->set_speed(0.2); CuttingPlaneZLoc = TestGlui->add_spinner_to_panel(CuttingPlaneSettings, "ZCuttingPlaneLocation", GLUI_SPINNER_FLOAT, &Framework::instance()->CuttingPlaneZLoc); CuttingPlaneZLoc->set_float_limits(-1.0, 1.0); CuttingPlaneZLoc->set_speed(0.2); CuttingPlaneXVec = TestGlui->add_spinner_to_panel(CuttingPlaneSettings, "XCuttingPlaneVector", GLUI_SPINNER_FLOAT, &Framework::instance()->CuttingPlaneXVec); CuttingPlaneXVec->set_float_limits(-1.0, 1.0); CuttingPlaneXVec->set_speed(0.2); CuttingPlaneYVec = TestGlui->add_spinner_to_panel(CuttingPlaneSettings, "YCuttingPlaneVector", GLUI_SPINNER_FLOAT, &Framework::instance()->CuttingPlaneYVec); CuttingPlaneYVec->set_float_limits(-1.0, 1.0); CuttingPlaneYVec->set_speed(0.2); CuttingPlaneZVec = TestGlui->add_spinner_to_panel(CuttingPlaneSettings, "ZCuttingPlaneVector", GLUI_SPINNER_FLOAT, &Framework::instance()->CuttingPlaneZVec); CuttingPlaneZVec->set_float_limits(-1.0, 1.0); CuttingPlaneZVec->set_speed(0.2); TestGlui->add_checkbox_to_panel(CuttingPlaneSettings, "Use Contour", &Framework::instance()->ContourOn,0, CheckboxCallback); TestGlui ->add_checkbox_to_panel(CuttingPlaneSettings, "Use MineCraft Setting", &Framework::instance()->MineCraftOn, 0, CheckboxCallback); Tolerence = TestGlui->add_spinner_to_panel(CuttingPlaneSettings, "Tolerence", GLUI_SPINNER_FLOAT, &Framework::instance()->Tolerence); Tolerence->set_float_limits(0., 5.0); Tolerence->set_speed(0.04); ContDist = TestGlui->add_spinner_to_panel(CuttingPlaneSettings, "Distance", GLUI_SPINNER_FLOAT, &Framework::instance()->ContDist); ContDist->set_float_limits(0., 5.0); ContDist->set_speed(0.04); //animation items spinNumPoints = TestGlui->add_spinner_to_panel(AnimationSettings, "Animation NumPoints", GLUI_SPINNER_INT, &Framework::instance()->NumPoints); spinNumPoints->set_int_limits(5, 1000); spinNumPoints->set_speed(0.5); TestGlui->add_checkbox_to_panel(AnimationSettings, "Color As Velocity", &Framework::instance()->colorAsVelocity); TestGlui->add_checkbox_to_panel(AnimationSettings, "TracePath", &Framework::instance()->traceDotPath);//for turning off and on trace path. dotPointColorSpinnerR = TestGlui->add_spinner_to_panel(AnimationSettings, "Dot Time Interval", GLUI_SPINNER_FLOAT, &Framework::instance()->timestep); dotPointColorSpinnerR->set_float_limits(0.0, 1.0); dotPointColorSpinnerR->set_speed(0.05); dotPointColorSpinnerG = TestGlui->add_spinner_to_panel(AnimationSettings, "Dot Sample Length", GLUI_SPINNER_FLOAT, &Framework::instance()->dotPointColorG); dotPointColorSpinnerG->set_float_limits(0.0, 100.0); dotPointColorSpinnerG->set_speed(1); //dotPointColorSpinnerB = TestGlui->add_spinner_to_panel(AnimationSettings, "Dot Color B", GLUI_SPINNER_FLOAT, &Framework::instance()->dotPointColorB); //dotPointColorSpinnerB->set_float_limits(0.0, 1.0); //dotPointColorSpinnerB->set_speed(0.05); //Final Setup for Glui - making it the main window TestGlui->set_main_gfx_window(Framework::instance()->MainWindow); // set the graphics window's idle function if needed: GLUI_Master.set_glutIdleFunc(NULL); }
int main(int argc, char** argv) { //#define CHECK_FPU_EXCEPTIONS 1 #ifdef CHECK_FPU_EXCEPTIONS int cw = _control87(0, 0); // Set the exception masks off, turn exceptions on cw &= ~(EM_ZERODIVIDE | EM_INVALID); printf("control87 = %#x\n", cw); // Set the control word _control87(cw, MCW_EM); #endif //CHECK_FPU_EXCEPTIONS setDefaultSettings(); int bulletVersion = btGetVersion(); printf("Bullet version %d\n",bulletVersion); glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE |GLUT_DEPTH | GLUT_STENCIL); glutInitWindowSize(width, height); mainWindow = glutCreateWindow("http://bulletphysics.com"); #ifdef BT_USE_FREEGLUT glutSetOption (GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); #endif entry = g_demoEntries + testIndex; demo = CreatDemo(entry); glutDisplayFunc(SimulationLoop); GLUI_Master.set_glutReshapeFunc(Resize); GLUI_Master.set_glutKeyboardFunc(Keyboard); GLUI_Master.set_glutSpecialFunc(KeyboardSpecial); GLUI_Master.set_glutSpecialUpFunc(KeyboardSpecialUp); GLUI_Master.set_glutMouseFunc(Mouse); glutMotionFunc(MouseMotion); glui = GLUI_Master.create_glui_subwindow( mainWindow, GLUI_SUBWINDOW_RIGHT ); glui->add_statictext("Tests"); GLUI_Listbox* testList = glui->add_listbox("", &testSelection); glui->add_button("Next Scene", 0,(GLUI_Update_CB)NextScene); glui->add_separator(); GLUI_Spinner* iterationSpinner = glui->add_spinner("Iterations", GLUI_SPINNER_INT, &iterationCount); iterationSpinner->set_int_limits(1, 250); /* GLUI_Spinner* hertzSpinner = glui->add_spinner("Hertz", GLUI_SPINNER_FLOAT, &hz); hertzSpinner->set_float_limits(5.0f, 200.0f); */ glui->add_checkbox("DisableDeactivation", &gDebugNoDeactivation); glui->add_checkbox("Split Impulse", &gUseSplitImpulse); GLUI_Spinner* spinner = 0; spinner = glui->add_spinner("ERP", GLUI_SPINNER_FLOAT, &gErp); // spinner->set_float_limits(0.f,1.f); // spinner = glui->add_spinner("ERP2", GLUI_SPINNER_FLOAT, &gErp2); spinner->set_float_limits(0.f,1.f); spinner = glui->add_spinner("Slop", GLUI_SPINNER_FLOAT, &gSlop); spinner->set_float_limits(0.f,1.f); // spinner = glui->add_spinner("WSP", GLUI_SPINNER_FLOAT,&gWarmStartingParameter); // spinner->set_float_limits (0.f,1.0); glui->add_checkbox("Warmstarting", &gUseWarmstarting); glui->add_checkbox("Randomize Constraints", &gRandomizeConstraints); glui->add_button("Reset Defaults", 0,(GLUI_Update_CB)setDefaultSettingsAndSync); glui->add_separator(); GLUI_Panel* drawPanel = glui->add_panel("Debug Draw"); glui->add_checkbox_to_panel(drawPanel, "AABBs", &gDrawAabb); glui->add_checkbox_to_panel(drawPanel, "Wireframe", &gWireFrame); glui->add_checkbox_to_panel(drawPanel, "Contacts", &gDebugContacts); glui->add_checkbox_to_panel(drawPanel, "Textures", &gDrawTextures); glui->add_checkbox_to_panel(drawPanel, "Shadows", &gDrawShadows); glui->add_checkbox_to_panel(drawPanel, "Clusters", &gDrawClusters); int testCount = 0; btDemoEntry* e = g_demoEntries; while (e->createFcn) { testList->add_item(testCount, e->name); ++testCount; ++e; } glui->add_separator(); glui->add_button("Toggle Pause", 0,(GLUI_Update_CB)TogglePause); glui->add_button("Single Step", 0,(GLUI_Update_CB)SingleSimulationStep); glui->add_button("Reset Scene", 0,(GLUI_Update_CB)ResetScene); glui->add_button("Restart Scene", 0,(GLUI_Update_CB)RestartScene); glui->add_separator(); // glui->add_button("Exit", 0,(GLUI_Update_CB)exit); glui->set_main_gfx_window( mainWindow ); // Use a timer to control the frame rate. glutTimerFunc(framePeriod, Timer, 0); glutMainLoop(); return 0; }
int main(int argc, char** argv) { using namespace TestMain; testCount = 0; while (g_testEntries[testCount].createFcn != NULL) { ++testCount; } testIndex = b2Clamp(testIndex, 0, testCount-1); testSelection = testIndex; entry = g_testEntries + testIndex; if (entry && entry->createFcn) { test = entry->createFcn(); testSelection = testIndex; testIndex = -1; } glutInit(&argc, argv); glutInitContextVersion(2, 0); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowSize(width, height); char title[32]; sprintf(title, "Box2D Version %d.%d.%d", b2_version.major, b2_version.minor, b2_version.revision); mainWindow = glutCreateWindow(title); //glutSetOption (GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); glutDisplayFunc(SimulationLoop); #if ENABLE_GLUI GLUI_Master.set_glutReshapeFunc(Resize); GLUI_Master.set_glutKeyboardFunc(Keyboard); GLUI_Master.set_glutSpecialFunc(KeyboardSpecial); GLUI_Master.set_glutMouseFunc(Mouse); #else { glutReshapeFunc(Resize); glutKeyboardFunc(Keyboard); glutSpecialUpFunc(KeyboardSpecial); glutMouseFunc(Mouse); } #endif // ENABLE_GLUI #ifdef FREEGLUT glutMouseWheelFunc(MouseWheel); #endif glutMotionFunc(MouseMotion); glutKeyboardUpFunc(KeyboardUp); #if ENABLE_GLUI glui = GLUI_Master.create_glui_subwindow( mainWindow, GLUI_SUBWINDOW_RIGHT ); glui->add_statictext("Tests"); GLUI_Listbox* testList = glui->add_listbox("", &testSelection); glui->add_separator(); GLUI_Spinner* velocityIterationSpinner = glui->add_spinner("Vel Iters", GLUI_SPINNER_INT, &settings.velocityIterations); velocityIterationSpinner->set_int_limits(1, 500); GLUI_Spinner* positionIterationSpinner = glui->add_spinner("Pos Iters", GLUI_SPINNER_INT, &settings.positionIterations); positionIterationSpinner->set_int_limits(0, 100); GLUI_Spinner* particleIterationSpinner = glui->add_spinner("Pcl Iters", GLUI_SPINNER_INT, &settings.particleIterations); particleIterationSpinner->set_int_limits(1, 100); GLUI_Spinner* hertzSpinner = glui->add_spinner("Hertz", GLUI_SPINNER_FLOAT, &settingsHz); hertzSpinner->set_float_limits(5.0f, 200.0f); glui->add_checkbox("Sleep", &settings.enableSleep); glui->add_checkbox("Warm Starting", &settings.enableWarmStarting); glui->add_checkbox("Time of Impact", &settings.enableContinuous); glui->add_checkbox("Sub-Stepping", &settings.enableSubStepping); glui->add_checkbox("Strict Particle/Body Contacts", &settings.strictContacts); //glui->add_separator(); GLUI_Panel* drawPanel = glui->add_panel("Draw"); glui->add_checkbox_to_panel(drawPanel, "Shapes", &settings.drawShapes); glui->add_checkbox_to_panel(drawPanel, "Particles", &settings.drawParticles); glui->add_checkbox_to_panel(drawPanel, "Joints", &settings.drawJoints); glui->add_checkbox_to_panel(drawPanel, "AABBs", &settings.drawAABBs); glui->add_checkbox_to_panel(drawPanel, "Contact Points", &settings.drawContactPoints); glui->add_checkbox_to_panel(drawPanel, "Contact Normals", &settings.drawContactNormals); glui->add_checkbox_to_panel(drawPanel, "Contact Impulses", &settings.drawContactImpulse); glui->add_checkbox_to_panel(drawPanel, "Friction Impulses", &settings.drawFrictionImpulse); glui->add_checkbox_to_panel(drawPanel, "Center of Masses", &settings.drawCOMs); glui->add_checkbox_to_panel(drawPanel, "Statistics", &settings.drawStats); glui->add_checkbox_to_panel(drawPanel, "Profile", &settings.drawProfile); int32 testCount = 0; TestEntry* e = g_testEntries; while (e->createFcn) { testList->add_item(testCount, e->name); ++testCount; ++e; } glui->add_button("Pause", 0, Pause); glui->add_button("Single Step", 0, SingleStep); glui->add_button("Restart", 0, Restart); glui->add_button("Quit", 0,(GLUI_Update_CB)Exit); glui->set_main_gfx_window( mainWindow ); #endif // ENABLE_GLUI // Configure the fullscreen UI's viewport parameters. fullscreenUI.SetViewParameters(&settings.viewCenter, &extents); // Use a timer to control the frame rate. glutTimerFunc(framePeriod, Timer, 0); glutMainLoop(); return 0; }
int main(int argc, char** argv) { testCount = 0; while (g_testEntries[testCount].createFcn != NULL) { ++testCount; } testIndex = b2Clamp(testIndex, 0, testCount-1); testSelection = testIndex; entry = g_testEntries + testIndex; test = entry->createFcn(); glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE); glutInitWindowSize(width, height); char title[32]; sprintf(title, "Box2D Version %d.%d.%d", b2_version.major, b2_version.minor, b2_version.revision); mainWindow = glutCreateWindow(title); //glutSetOption (GLUT_ACTION_ON_WINDOW_CLOSE, GLUT_ACTION_GLUTMAINLOOP_RETURNS); glutDisplayFunc(SimulationLoop); /* int theConnection=0; theConnection=setup_rlglue_network(); runEnvironmentEventLoop(theConnection);*/ GLUI_Master.set_glutReshapeFunc(Resize); GLUI_Master.set_glutKeyboardFunc(Keyboard); GLUI_Master.set_glutSpecialFunc(KeyboardSpecial); GLUI_Master.set_glutMouseFunc(Mouse); #ifdef FREEGLUT glutMouseWheelFunc(MouseWheel); #endif glutMotionFunc(MouseMotion); glui = GLUI_Master.create_glui_subwindow( mainWindow, GLUI_SUBWINDOW_RIGHT ); glui->add_statictext("Tests"); GLUI_Listbox* testList = glui->add_listbox("", &testSelection); glui->add_separator(); GLUI_Spinner* velocityIterationSpinner = glui->add_spinner("Vel Iters", GLUI_SPINNER_INT, &settings.velocityIterations); velocityIterationSpinner->set_int_limits(1, 500); GLUI_Spinner* positionIterationSpinner = glui->add_spinner("Pos Iters", GLUI_SPINNER_INT, &settings.positionIterations); positionIterationSpinner->set_int_limits(0, 100); GLUI_Spinner* hertzSpinner = glui->add_spinner("Hertz", GLUI_SPINNER_FLOAT, &settingsHz); hertzSpinner->set_float_limits(5.0f, 200.0f); glui->add_checkbox("Warm Starting", &settings.enableWarmStarting); glui->add_checkbox("Time of Impact", &settings.enableContinuous); //glui->add_separator(); GLUI_Panel* drawPanel = glui->add_panel("Draw"); glui->add_checkbox_to_panel(drawPanel, "Shapes", &settings.drawShapes); glui->add_checkbox_to_panel(drawPanel, "Joints", &settings.drawJoints); glui->add_checkbox_to_panel(drawPanel, "AABBs", &settings.drawAABBs); glui->add_checkbox_to_panel(drawPanel, "Pairs", &settings.drawPairs); glui->add_checkbox_to_panel(drawPanel, "Contact Points", &settings.drawContactPoints); glui->add_checkbox_to_panel(drawPanel, "Contact Normals", &settings.drawContactNormals); glui->add_checkbox_to_panel(drawPanel, "Contact Forces", &settings.drawContactForces); glui->add_checkbox_to_panel(drawPanel, "Friction Forces", &settings.drawFrictionForces); glui->add_checkbox_to_panel(drawPanel, "Center of Masses", &settings.drawCOMs); glui->add_checkbox_to_panel(drawPanel, "Statistics", &settings.drawStats); int32 testCount = 0; TestEntry* e = g_testEntries; while (e->createFcn) { testList->add_item(testCount, e->name); ++testCount; ++e; } glui->add_button("Pause", 0, Pause); glui->add_button("Single Step", 0, SingleStep); glui->add_button("Restart", 0, Restart); glui->add_button("Quit", 0,(GLUI_Update_CB)exit); glui->set_main_gfx_window( mainWindow ); // Use a timer to control the frame rate. glutTimerFunc(framePeriod, Timer, 0); //////////////////////////////////////////////////////////////////////////////////////////// /*const char *task_spec; printf("\nThis is a RL Test program(Start)\n"); task_spec = RL_init(); printf("\nTASK SPEC : %s\n",task_spec); printf("Starting offline demo\n----------------------------\nWill alternate learning for 25 episodes, then freeze policy and evaluate for 10 episodes.\n\n"); printf("After Episode\tMean Return\tStandard Deviation\n-------------------------------------------------------------------------\n"); oa = RL_start(); RL_agent_message("load_policy results.dat"); RL_agent_message("freeze learning");*/ const char* task_spec; task_spec = env_init(); agent_init(task_spec); //////////////////////////////////////////////////////////////////////////////////////////// /* agent_message("load_policy results.dat"); agent_message("freeze learning");*/ glutMainLoop(); return 0; }