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); // 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 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);
}
// Initialize GLUI and the user interface
void initGlui()
{
GLUI_Master.set_glutIdleFunc(NULL);
// Create GLUI window
glui = GLUI_Master.create_glui("Glui Window", 0, Win[0]+10, 0);
/*
* Add spinners and checkboxes for each degree of freedom.
* The checkboxes determine whether or not that part should rotate
* when the "animate" checkbox is on.
*
*/
addFloatSpinner("Leg 1", &leg1Rotation, 0.1, LIMB_MIN, LIMB_MAX);
glui->add_checkbox("Animate Leg 1", &animateLeg1, 0, doNothing);
addFloatSpinner("Leg 2", &leg2Rotation, 0.1, LIMB_MIN, LIMB_MAX);
glui->add_checkbox("Animate Leg 2", &animateLeg2, 0, doNothing);
addFloatSpinner("Foot 1", &foot1Rotation, 0.1, FOOT_MIN, FOOT_MAX);
glui->add_checkbox("Animate Foot 1", &animateFoot1, 0, doNothing);
addFloatSpinner("Foot 2", &foot2Rotation, 0.1, FOOT_MIN, FOOT_MAX);
glui->add_checkbox("Animate Foot 2", &animateFoot2, 0, doNothing);
addFloatSpinner("Arm", &armRotation, 0.1, LIMB_MIN, LIMB_MAX);
glui->add_checkbox("Animate Arm", &animateArm, 0, doNothing);
addFloatSpinner("Head", &headRotation, 0.1, HEAD_MIN, HEAD_MAX);
glui->add_checkbox("Animate Head", &animateHead, 0, doNothing);
/*
* The beak spinner is an int value of the distance
* between the top and bottom beaks
*
* The beak is also controlled by a checkbox
*/
GLUI_Spinner *beakSpinner
= glui->add_spinner("Beak", GLUI_SPINNER_INT, &beakDistance);
beakSpinner->set_speed(1);
beakSpinner->set_int_limits(BEAK_MIN, BEAK_MAX, GLUI_LIMIT_CLAMP);
glui->add_checkbox("Animate Beak", &animateBeak, 0, doNothing);
// Add button to specify animation mode
glui->add_separator();
glui->add_checkbox("Animate Parts", &animate_mode, 0, animateButton);
glui->add_checkbox("Play Animation", &animation_mode, 0, animationButton);
// Add "Quit" button
glui->add_separator();
glui->add_button("Quit", 0, quitButton);
// Set the main window to be the "active" window
glui->set_main_gfx_window(windowID);
}
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);
}
GLUI_Spinner *GLUI::
add_spinner_to_panel( GLUI_Panel *panel, char *name,
int data_type, void *data,
int id, GLUI_Update_CB callback)
{
GLUI_Spinner *control;
int text_type;
control = new GLUI_Spinner;
if ( NOT strcmp( name, "Spinner Test" ))
id=id;
if ( control ) {
if ( data_type == GLUI_SPINNER_INT ) {
text_type = GLUI_EDITTEXT_INT;
/* control->live_type = GLUI_LIVE_INT; */
}
else if ( data_type == GLUI_SPINNER_FLOAT ) {
text_type = GLUI_EDITTEXT_FLOAT;
/* control->live_type = GLUI_LIVE_FLOAT; */
}
else {
return NULL; /* Did not pass in a valid data type */
}
GLUI_EditText *edittext =
add_edittext_to_panel( (GLUI_Panel*) control, name, text_type, data,
id, callback );
if ( edittext ) {
control->set_name( name );
control->edittext = edittext; /* Link the edittext to the spinner */
/* control->ptr_val = data; */
control->user_id = id;
control->data_type = data_type;
control->callback = callback;
edittext->spinner = control; /* Link the spinner to the edittext */
add_control( panel, control );
return control;
}
else {
return NULL;
}
}
else {
return NULL;
}
}
void spinner_edittext_callback( int id )
{
GLUI_Spinner *spinner;
putchar( '.' ); flushout;
spinner = (GLUI_Spinner*) id;
if ( NOT spinner )
return;
spinner->do_callbacks();
}
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);
}
//////////////////// 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);
}
//! 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");
}
int main(int argc, char* argv[])
{
/****************************************/
/* Initialize GLUT and create window */
/****************************************/
glutInit(&argc, argv);
glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH );
glutInitWindowPosition( 50, 50 );
glutInitWindowSize( 800, 600 );
main_window = glutCreateWindow( "GLUI Example 5" );
glutDisplayFunc( myGlutDisplay );
GLUI_Master.set_glutReshapeFunc( myGlutReshape );
GLUI_Master.set_glutKeyboardFunc( myGlutKeyboard );
GLUI_Master.set_glutSpecialFunc( NULL );
GLUI_Master.set_glutMouseFunc( myGlutMouse );
glutMotionFunc( myGlutMotion );
/****************************************/
/* Set up OpenGL lights */
/****************************************/
glEnable(GL_LIGHTING);
glEnable( GL_NORMALIZE );
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_AMBIENT, light0_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
glEnable(GL_LIGHT1);
glLightfv(GL_LIGHT1, GL_AMBIENT, light1_ambient);
glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_diffuse);
glLightfv(GL_LIGHT1, GL_POSITION, light1_position);
/****************************************/
/* Enable z-buferring */
/****************************************/
glEnable(GL_DEPTH_TEST);
/****************************************/
/* Here's the GLUI code */
/****************************************/
printf( "GLUI version: %3.2f\n", GLUI_Master.get_version() );
/*** Create the side subwindow ***/
glui = GLUI_Master.create_glui_subwindow( main_window,
GLUI_SUBWINDOW_RIGHT );
obj_panel = new GLUI_Rollout(glui, "Properties", false );
/***** Control for object params *****/
new GLUI_Checkbox( obj_panel, "Wireframe", &wireframe, 1, control_cb );
GLUI_Spinner *spinner =
new GLUI_Spinner( obj_panel, "Segments:", &segments);
spinner->set_int_limits( 3, 60 );
spinner->set_alignment( GLUI_ALIGN_RIGHT );
GLUI_Spinner *scale_spinner =
new GLUI_Spinner( obj_panel, "Scale:", &scale);
scale_spinner->set_float_limits( .2f, 4.0 );
scale_spinner->set_alignment( GLUI_ALIGN_RIGHT );
/******** Add some controls for lights ********/
GLUI_Rollout *roll_lights = new GLUI_Rollout(glui, "Lights", false );
GLUI_Panel *light0 = new GLUI_Panel( roll_lights, "Light 1" );
GLUI_Panel *light1 = new GLUI_Panel( roll_lights, "Light 2" );
new GLUI_Checkbox( light0, "Enabled", &light0_enabled,
LIGHT0_ENABLED_ID, control_cb );
light0_spinner =
new GLUI_Spinner( light0, "Intensity:",
&light0_intensity, LIGHT0_INTENSITY_ID,
control_cb );
light0_spinner->set_float_limits( 0.0, 1.0 );
GLUI_Scrollbar *sb;
sb = new GLUI_Scrollbar( light0, "Red",GLUI_SCROLL_HORIZONTAL,
&light0_diffuse[0],LIGHT0_INTENSITY_ID,control_cb);
sb->set_float_limits(0,1);
sb = new GLUI_Scrollbar( light0, "Green",GLUI_SCROLL_HORIZONTAL,
&light0_diffuse[1],LIGHT0_INTENSITY_ID,control_cb);
sb->set_float_limits(0,1);
sb = new GLUI_Scrollbar( light0, "Blue",GLUI_SCROLL_HORIZONTAL,
&light0_diffuse[2],LIGHT0_INTENSITY_ID,control_cb);
sb->set_float_limits(0,1);
new GLUI_Checkbox( light1, "Enabled", &light1_enabled,
LIGHT1_ENABLED_ID, control_cb );
light1_spinner =
new GLUI_Spinner( light1, "Intensity:",
&light1_intensity, LIGHT1_INTENSITY_ID,
control_cb );
light1_spinner->set_float_limits( 0.0, 1.0 );
sb = new GLUI_Scrollbar( light1, "Red",GLUI_SCROLL_HORIZONTAL,
&light1_diffuse[0],LIGHT1_INTENSITY_ID,control_cb);
sb->set_float_limits(0,1);
sb = new GLUI_Scrollbar( light1, "Green",GLUI_SCROLL_HORIZONTAL,
&light1_diffuse[1],LIGHT1_INTENSITY_ID,control_cb);
sb->set_float_limits(0,1);
sb = new GLUI_Scrollbar( light1, "Blue",GLUI_SCROLL_HORIZONTAL,
&light1_diffuse[2],LIGHT1_INTENSITY_ID,control_cb);
sb->set_float_limits(0,1);
/*** Add another rollout ***/
GLUI_Rollout *options = new GLUI_Rollout(glui, "Options", true );
new GLUI_Checkbox( options, "Draw sphere", &show_sphere );
new GLUI_Checkbox( options, "Draw torus", &show_torus );
new GLUI_Checkbox( options, "Draw axes", &show_axes );
new GLUI_Checkbox( options, "Draw text", &show_text );
/**** Add listbox ****/
new GLUI_StaticText( glui, "" );
GLUI_Listbox *list = new GLUI_Listbox( glui, "Text:", &curr_string );
int i;
for( i=0; i<4; i++ )
list->add_item( i, string_list[i] );
new GLUI_StaticText( glui, "" );
/*** Disable/Enable buttons ***/
new GLUI_Button( glui, "Disable movement", DISABLE_ID, control_cb );
new GLUI_Button( glui, "Enable movement", ENABLE_ID, control_cb );
new GLUI_Button( glui, "Hide", HIDE_ID, control_cb );
new GLUI_Button( glui, "Show", SHOW_ID, control_cb );
new GLUI_StaticText( glui, "" );
/****** A 'quit' button *****/
new GLUI_Button( glui, "Quit", 0,(GLUI_Update_CB)exit );
/**** Link windows to GLUI, and register idle callback ******/
glui->set_main_gfx_window( main_window );
/*** Create the bottom subwindow ***/
glui2 = GLUI_Master.create_glui_subwindow( main_window,
GLUI_SUBWINDOW_BOTTOM );
glui2->set_main_gfx_window( main_window );
GLUI_Rotation *view_rot = new GLUI_Rotation(glui2, "Objects", view_rotate );
view_rot->set_spin( 1.0 );
new GLUI_Column( glui2, false );
GLUI_Rotation *sph_rot = new GLUI_Rotation(glui2, "Sphere", sphere_rotate );
sph_rot->set_spin( .98 );
new GLUI_Column( glui2, false );
GLUI_Rotation *tor_rot = new GLUI_Rotation(glui2, "Torus", torus_rotate );
tor_rot->set_spin( .98 );
new GLUI_Column( glui2, false );
GLUI_Rotation *lights_rot = new GLUI_Rotation(glui2, "Blue Light", lights_rotation );
lights_rot->set_spin( .82 );
new GLUI_Column( glui2, false );
GLUI_Translation *trans_xy =
new GLUI_Translation(glui2, "Objects XY", GLUI_TRANSLATION_XY, obj_pos );
trans_xy->set_speed( .005 );
new GLUI_Column( glui2, false );
GLUI_Translation *trans_x =
new GLUI_Translation(glui2, "Objects X", GLUI_TRANSLATION_X, obj_pos );
trans_x->set_speed( .005 );
new GLUI_Column( glui2, false );
GLUI_Translation *trans_y =
new GLUI_Translation( glui2, "Objects Y", GLUI_TRANSLATION_Y, &obj_pos[1] );
trans_y->set_speed( .005 );
new GLUI_Column( glui2, false );
GLUI_Translation *trans_z =
new GLUI_Translation( glui2, "Objects Z", GLUI_TRANSLATION_Z, &obj_pos[2] );
trans_z->set_speed( .005 );
#if 0
/**** We register the idle callback with GLUI, *not* with GLUT ****/
GLUI_Master.set_glutIdleFunc( myGlutIdle );
#endif
/**** Regular GLUT main loop ****/
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)
{
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 Interface::initGUI()
{
GLUI_Panel *geral =addPanel("Opcoes", 1);
addColumnToPanel(geral);
GLUI_Panel *luzesPanel = addPanelToPanel(geral,"Luzes", 1);
for(unsigned int i=0;i<((ANFScene *) scene)->parser.lights.size();i++){
string str=((ANFScene *) scene)->parser.lights[i]->id;
char * writable = new char[str.size() + 1];
copy(str.begin(), str.end(), writable);
writable[str.size()] = '\0';
if(((ANFScene *) scene)->parser.lights[i]->enabled==true){
addCheckboxToPanel(luzesPanel,writable,NULL,i)->set_int_val(1);
}
else{
addCheckboxToPanel(luzesPanel,writable,NULL,i)->set_int_val(0);
}
delete[] writable;
}
addColumnToPanel(geral);
GLUI_Panel *camerasPanel = addPanelToPanel(geral,"Camaras", 1);
GLUI_RadioGroup *cameraList = addRadioGroupToPanel(camerasPanel,&(((ANFScene *) scene)->parser.activeCam));
for(unsigned int i=0;i<((ANFScene *) scene)->parser.cameras.size();i++){
string str=((ANFScene *) scene)->parser.cameras[i]->id;
char * writable = new char[str.size() + 1];
copy(str.begin(), str.end(), writable);
writable[str.size()] = '\0';
if(i == ((ANFScene *) scene)->parser.activeCam)
addRadioButtonToGroup(cameraList, writable)->set_int_val(1);
else
addRadioButtonToGroup(cameraList, writable);
delete[] writable;
}
addRadioButtonToGroup(cameraList, "Default");
addColumnToPanel(geral);
GLUI_Panel *drawPanel = addPanelToPanel(geral,"Draw Mode", 1);
GLUI_RadioGroup *drawList = addRadioGroupToPanel(drawPanel,&(((ANFScene *) scene)->parser.globals->drawing.mode));
addRadioButtonToGroup(drawList, "Fill");
addRadioButtonToGroup(drawList, "Line");
addRadioButtonToGroup(drawList, "Point");
addColumnToPanel(geral);
GLUI_Panel *windPanel = addPanelToPanel(geral,"Wind Value", 1);
GLUI_Spinner *spinner = addSpinnerToPanel(windPanel, "windScale",GLUI_SPINNER_INT,&(((ANFScene *) scene)->parser.wind),9);
spinner->set_speed(0.5);
spinner->set_int_limits(0,10,GLUI_LIMIT_WRAP);
GLUI_Panel *varPanel= addPanelToPanel(geral,"Animations", 1);
addButtonToPanel(varPanel, "Reset", 8);
}
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 );
}
/**
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);
}
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);
}
void
CTfUi::_InitFunc()
{
assert(pcTransFunc);
// move the File panel to above the Edit panel
// add new control for accessing TF as files
GLUI_Rollout* pcFilePanel = PCGetGluiSubwin()->add_rollout("File", false);
pcEditText_Dir = PCGetGluiSubwin()->add_edittext_to_panel(pcFilePanel, "Dir", GLUI_EDITTEXT_TEXT, szDir, IAddWid(FILE_DIR), &CGlutWin::_GluiCB_static);
pcEditText_Filename = PCGetGluiSubwin()->add_edittext_to_panel(pcFilePanel, "Filename", GLUI_EDITTEXT_TEXT, szFilename, IAddWid(FILE_FILENAME), &CGlutWin::_GluiCB_static);
PCGetGluiSubwin()->add_button_to_panel(pcFilePanel, "Save", IAddWid(FILE_SAVE), &CGlutWin::_GluiCB_static);
PCGetGluiSubwin()->add_button_to_panel(pcFilePanel, "Open", IAddWid(FILE_OPEN), &CGlutWin::_GluiCB_static);
// by default, use current director and *.* as the filename
char szDir[1024+1];
#if defined(WIN32)
GetCurrentDirectoryA((DWORD)sizeof(szDir), szDir);
#else
getcwd(szDir, sizeof(szDir));
#endif
_SetDir(szDir);
_SetFilename("*.*");
// add a panel to group the radio group and buttons
GLUI_Rollout* pcEditPanel = PCGetGluiSubwin()->add_rollout("Edit");
GLUI_Panel *pcChannelPanel = PCGetGluiSubwin()->add_panel_to_panel(pcEditPanel, "Channel");
GLUI_RadioGroup *pcRadioGroup_Channel = PCGetGluiSubwin()->add_radiogroup_to_panel(pcChannelPanel, &iEditingChannel);
PCGetGluiSubwin()->add_radiobutton_to_group(pcRadioGroup_Channel, "R");
PCGetGluiSubwin()->add_radiobutton_to_group(pcRadioGroup_Channel, "G");
PCGetGluiSubwin()->add_radiobutton_to_group(pcRadioGroup_Channel, "B");
PCGetGluiSubwin()->add_radiobutton_to_group(pcRadioGroup_Channel, "A");
pcRadioGroup_Channel->set_int_val(iEditingChannel);
PCGetGluiSubwin()->add_button_to_panel(pcEditPanel, "Redo", IAddWid(EDIT_REDO), &CGlutWin::_GluiCB_static);
PCGetGluiSubwin()->add_button_to_panel(pcEditPanel, "Undo", IAddWid(EDIT_UNDO), &CGlutWin::_GluiCB_static);
PCGetGluiSubwin()->add_button_to_panel(pcEditPanel, "Clear", IAddWid(EDIT_CLEAR), &CGlutWin::_GluiCB_static);
PCGetGluiSubwin()->add_button_to_panel(pcEditPanel, "Delete", IAddWid(EDIT_DELETE), &CGlutWin::_GluiCB_static);
GLUI_Rollout* pcTfPanel = PCGetGluiSubwin()->add_rollout("TF Setting", false);
GLUI_Panel* pcPanel;
GLUI_Spinner *pcSpinner;
pcPanel = PCGetGluiSubwin()->add_panel_to_panel(pcTfPanel, "Data Value");
pcSpinner = PCGetGluiSubwin()->add_spinner_to_panel(pcPanel, "Min (Significand)", GLUI_SPINNER_FLOAT, &cHistogramMin.fSignificand);
pcSpinner->disable();
pcSpinner = PCGetGluiSubwin()->add_spinner_to_panel(pcPanel, "Min (Exponent)", GLUI_SPINNER_FLOAT, &cHistogramMin.fExponent);
pcSpinner->disable();
pcSpinner = PCGetGluiSubwin()->add_spinner_to_panel(pcPanel, "Max (Significand)", GLUI_SPINNER_FLOAT, &cHistogramMax.fSignificand);
pcSpinner->disable();
pcSpinner = PCGetGluiSubwin()->add_spinner_to_panel(pcPanel, "Max (Exponent)", GLUI_SPINNER_FLOAT, &cHistogramMax.fExponent);
pcSpinner->disable();
pcPanel = PCGetGluiSubwin()->add_panel_to_panel(pcTfPanel, "TF Domain");
PCGetGluiSubwin()->add_spinner_to_panel(pcPanel, "Min (Significand)", GLUI_SPINNER_FLOAT, &pcTransFunc->cDomainMin.fSignificand);
PCGetGluiSubwin()->add_spinner_to_panel(pcPanel, "Min (Exponent)", GLUI_SPINNER_FLOAT, &pcTransFunc->cDomainMin.fExponent);
PCGetGluiSubwin()->add_spinner_to_panel(pcPanel, "Max (Significand)", GLUI_SPINNER_FLOAT, &pcTransFunc->cDomainMax.fSignificand);
PCGetGluiSubwin()->add_spinner_to_panel(pcPanel, "Max (Exponent)", GLUI_SPINNER_FLOAT, &pcTransFunc->cDomainMax.fExponent);
// move the File panel to above the Edit panel
PCGetGluiSubwin()->add_button("Update", IAddWid(EDIT_UPDATE), &CGlutWin::_GluiCB_static);
PCGetGluiSubwin()->add_button("Exit", IAddWid(EDIT_EXIT), &CGlutWin::_GluiCB_static);
// specify a default window size for the TF editor
_Reshape(512, 384);
}
int main(int argc, char** argv)
{
/* standard GLUT initialization */
glutInit(&argc,argv);
// Set up model Window
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); /* default, not needed */
glutInitWindowSize(W_MODEL, H_MODEL);
glutInitWindowPosition(X_MODEL, Y_MODEL);
modelWindow = glutCreateWindow("Mimicry"); /* window title */
glClearColor(0.5, 0.5, 0.5, 1);
glutDisplayFunc(displayModel);
glutReshapeFunc(reshapeModel);
glutIdleFunc(0);
// Set up statistics Window
/*
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize(W_STATS, H_STATS);
glutInitWindowPosition(X_STATS, Y_STATS);
statsWindow = glutCreateWindow("Statistics");
glClearColor(0, 0, 0, 1);
glutDisplayFunc(displayStats);
glutReshapeFunc(reshapeStats);
*/
glutKeyboardFunc(keyboard);
// GLUI initialization
glui = GLUI_Master.create_glui("Controls", 0, X_GLUI, Y_GLUI);
// Initialization panel
GLUI_Panel *initializationPanel = glui->add_panel("Initialization");
ctlGeneBankName = glui->add_edittext_to_panel(initializationPanel, "File ", GLUI_EDITTEXT_TEXT);
ctlGeneBankName->set_w(150);
ctlGeneBankName->enable();
ctlGeneBankName->set_text("initialconfig.xml");
glui->add_column_to_panel(initializationPanel, true);
ctlStart = glui->add_button_to_panel(initializationPanel, "Start", START, control);
ctlStop = glui->add_button_to_panel(initializationPanel, "Stop", STOP, control);
ctlStop->disable();
ctlPause = glui->add_button_to_panel(initializationPanel, "Pause/Continue", PAUSE, control);
ctlPause->disable();
// Run-time controls panel
GLUI_Panel *runtimePanel = glui->add_panel("Runtime Parameters");
// Prey Runtime configuration panel
GLUI_Panel *preyConfigPanel = glui->add_panel_to_panel(runtimePanel, "Prey Configuration");
GLUI_Spinner *preySize = glui->add_spinner_to_panel(
preyConfigPanel,
"Prey Size",
GLUI_SPINNER_INT,
&System::PREY_SIZE,
PREY_SIZE,
control);
preySize->set_int_limits(1, 5);
GLUI_Panel *preyReprodConfigPanel = glui->add_panel_to_panel(preyConfigPanel, "Reproduction");
GLUI_Spinner *preyReproductionAgeLimit = glui->add_spinner_to_panel(
preyReprodConfigPanel,
"Age Limit",
GLUI_SPINNER_INT,
&System::PREY_REPRODUCTION_AGE_LIMIT,
PREY_REPRODUCTION_AGE_LIMIT,
control);
preyReproductionAgeLimit->set_int_limits(100, 10000);
GLUI_Spinner *preyReproductionInterval = glui->add_spinner_to_panel(
preyReprodConfigPanel,
"Interval",
GLUI_SPINNER_INT,
&System::PREY_REPRODUCTION_INTERVAL,
PREY_REPRODUCTION_INTERVAL,
control);
preyReproductionInterval->set_int_limits(100, 10000);
GLUI_Panel *preyMutationRatePanel = glui->add_panel_to_panel(preyConfigPanel, "Mutation Rate");
GLUI_Spinner *patternMutationRate = glui->add_spinner_to_panel(
preyMutationRatePanel,
"Pattern",
GLUI_SPINNER_FLOAT,
&System::PATTERN_MUTATION_RATE,
PATTERN_MUTATION_RATE,
control);
patternMutationRate->set_int_limits(0.01, 1.0);
GLUI_Spinner *preyGenomeMutationRate = glui->add_spinner_to_panel(
preyMutationRatePanel,
"Genome",
GLUI_SPINNER_FLOAT,
&System::PREY_GENOME_MUTATION_RATE,
PREY_GENOME_MUTATION_RATE,
control);
preyGenomeMutationRate->set_int_limits(0.01, 1.0);
GLUI_Spinner *preyDemiseAge = glui->add_spinner_to_panel(
preyConfigPanel,
"Demise Age",
GLUI_SPINNER_INT,
&System::PREY_DEMISE_AGE,
PREY_DEMISE_AGE,
control);
preyDemiseAge->set_int_limits(100, 10000);
glui->add_column_to_panel(runtimePanel, true);
// Predator Runtime configuration panel
GLUI_Panel *predatorConfigPanel = glui->add_panel_to_panel(runtimePanel, "Predator Configuration");
GLUI_Panel *predatorReprodConfigPanel = glui->add_panel_to_panel(predatorConfigPanel, "Reproduction");
GLUI_Spinner *predatorReproductionAgeLimit = glui->add_spinner_to_panel(
predatorReprodConfigPanel,
"Age Limit",
GLUI_SPINNER_INT,
&System::PREDATOR_REPRODUCTION_AGE_LIMIT,
PREDATOR_REPRODUCTION_AGE_LIMIT,
control);
predatorReproductionAgeLimit->set_int_limits(100, 10000);
GLUI_Spinner *predatorReproductionInterval = glui->add_spinner_to_panel(
predatorReprodConfigPanel,
"Interval",
GLUI_SPINNER_INT,
&System::PREDATOR_REPRODUCTION_INTERVAL,
PREDATOR_REPRODUCTION_INTERVAL,
control);
predatorReproductionInterval->set_int_limits(100, 10000);
GLUI_Panel *hopfieldNetworkConfg = glui->add_panel_to_panel(predatorConfigPanel, "Memory Configurations");
GLUI_Spinner *predatorMinMemorySize = glui->add_spinner_to_panel(
hopfieldNetworkConfg,
"Minimum",
GLUI_SPINNER_INT,
&System::MIN_MEMORY_SIZE,
MIN_MEMORY_SIZE,
control);
predatorMinMemorySize->set_int_limits(1, 20);
GLUI_Spinner *predatorMaxMemorySize = glui->add_spinner_to_panel(
hopfieldNetworkConfg,
"Maximum",
GLUI_SPINNER_INT,
&System::MAX_MEMORY_SIZE,
MAX_MEMORY_SIZE,
control);
predatorMaxMemorySize->set_int_limits(2, 20);
GLUI_Spinner *predatorGenomeMutationRate = glui->add_spinner_to_panel(
predatorConfigPanel,
"Mutation Rate",
GLUI_SPINNER_FLOAT,
&System::PREDATOR_GENOME_MUTATION_RATE,
PREDATOR_GENOME_MUTATION_RATE,
control);
predatorGenomeMutationRate->set_int_limits(0.01, 1.0);
GLUI_Spinner *predatorDemiseAge = glui->add_spinner_to_panel(
predatorConfigPanel,
"Demise Age",
GLUI_SPINNER_INT,
&System::PREDATOR_DEMISE_AGE,
PREDATOR_DEMISE_AGE,
control);
predatorDemiseAge->set_int_limits(100, 10000);
glui->add_column(true);
// Model view panel
GLUI_Panel *modelViewPanel = glui->add_panel("Model view");
ctlRot = glui->add_rotation_to_panel(modelViewPanel, "Orientation", gluiRotation);
//glui->add_column_to_panel(modelViewPanel, true);
GLUI_Translation *ctlTranslateXY = glui->add_translation_to_panel(
modelViewPanel,
"XY position",
GLUI_TRANSLATION_XY,
gluiPosition);
//glui->add_column_to_panel(modelViewPanel, true);
GLUI_Translation *ctlTranslateZ = glui->add_translation_to_panel(
modelViewPanel,
"Zoom",
GLUI_TRANSLATION_Z,
&gluiPosition[2],
ZOOM, control);
glui->add_separator_to_panel(modelViewPanel);
glui->add_button_to_panel(modelViewPanel, "Reset view", RESET, control);
glui->add_checkbox_to_panel(modelViewPanel, "Update model", &updateModel);
glui->add_checkbox_to_panel(modelViewPanel, "Update statistics", &updateStats);
// Run-time controls panel
GLUI_Panel *controlsPanel = glui->add_panel("Runtime Controls");
// View Selection panel
GLUI_Panel *viewSelectionPanel = glui->add_panel_to_panel(controlsPanel, "View Selection");
glui->add_checkbox_to_panel(viewSelectionPanel, "Outline", &System::showOutline);
glui->add_checkbox_to_panel(viewSelectionPanel, "View Cells", &System::showCells);
// Reports panel
GLUI_Panel *reportPanel = glui->add_panel_to_panel(controlsPanel, "Reports");
glui->add_button_to_panel(reportPanel, "Rings", RING_REPORT, control);
ctlTranslateXY->set_speed(0.1);
ctlTranslateZ->set_speed(0.1);
/* display callback invoked when window opened */
glutMainLoop(); /* enter event loop */
return 0;
}
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[])
{
/****************************************/
/* 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;
}
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)
{
//#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;
}
virtual bool Initialize()
{
cur_link=0;
cur_driver=0;
link_value = 0;
driver_value = 0;
draw_geom = 1;
draw_bbs = 0;
draw_com = 0;
draw_frame = 0;
draw_expanded = 0;
draw_self_collision_tests = 0;
hoverLink=hoverWidget=-1;
hoverPt.setZero();
pose_ik = 0;
if(!RobotViewProgram::Initialize()) return false;
self_colliding.resize(robot->links.size(),false);
UpdateConfig();
/*
//TEST: robot-to-robot IK test. only works for AL5Dx2
IKGoal test;
test.link = 8;
test.destLink = 16;
test.localPosition.set(0,0,0.05);
test.endPosition.set(0,0,0.05);
//test.SetFixedPosition(test.endPosition);
Matrix3 R;
R.setRotateZ(120);
test.SetFixedRotation(R);
vector<IKGoal> problem(1,test);
int iters=100;
bool res=SolveIK(*robot,problem,1e-3,iters);
printf("Solved IK: %d, %d iters, error %g\n",(int)res,iters,RobotIKError(*robot,test));
UpdateConfig();
*/
//setup GUI
glui = GLUI_Master.create_glui_subwindow(main_window,GLUI_SUBWINDOW_RIGHT);
glui->set_main_gfx_window(main_window);
GLUI_Panel* panel = glui->add_panel("Link controls");
link_spinner = glui->add_spinner_to_panel(panel,"Index",GLUI_SPINNER_INT,&cur_link,LINK_SPINNER_ID,ControlFunc);
link_spinner->set_int_limits(0,robot->links.size()-1,GLUI_LIMIT_WRAP);
link_listbox = glui->add_listbox_to_panel(panel,"Name",&cur_link,LINK_LISTBOX_ID,ControlFunc);
for(size_t i=0;i<robot->links.size();i++) {
char buf[256];
strcpy(buf,robot->linkNames[i].c_str());
link_listbox->add_item(i,buf);
}
link_value_spinner = glui->add_spinner_to_panel(panel,"Angle",GLUI_SPINNER_FLOAT,&link_value,LINK_VALUE_SPINNER_ID,ControlFunc);
link_info = glui->add_statictext_to_panel(panel,"Info");
UpdateLinkValueGUI();
UpdateLinkInfoGUI();
panel = glui->add_panel("Driver controls");
glui->add_checkbox_to_panel(panel,"Pose by IK",&pose_ik);
driver_spinner = glui->add_spinner_to_panel(panel,"Index",GLUI_SPINNER_INT,&cur_driver,DRIVER_SPINNER_ID,ControlFunc);
driver_spinner->set_int_limits(0,(int)robot->drivers.size()-1,GLUI_LIMIT_WRAP);
driver_listbox = glui->add_listbox_to_panel(panel,"Name",&cur_driver,DRIVER_LISTBOX_ID,ControlFunc);
for(size_t i=0;i<robot->drivers.size();i++) {
char buf[256];
strcpy(buf,robot->driverNames[i].c_str());
driver_listbox->add_item(i,buf);
}
driver_value_spinner = glui->add_spinner_to_panel(panel,"Angle",GLUI_SPINNER_FLOAT,&driver_value,DRIVER_VALUE_SPINNER_ID,ControlFunc);
driver_info = glui->add_statictext_to_panel(panel,"Info");
glui->add_checkbox("Draw geometry",&draw_geom);
glui->add_checkbox("Draw COM",&draw_com);
glui->add_checkbox("Draw frame",&draw_frame);
glui->add_checkbox("Draw bboxes",&draw_bbs);
glui->add_checkbox("Draw expanded",&draw_expanded,DRAW_EXPANDED_CHECKBOX_ID,ControlFunc);
glui->add_checkbox("Draw collision tests",&draw_self_collision_tests);
UpdateDriverValueGUI();
UpdateDriverInfoGUI();
return true;
}
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) {
/* 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;
}
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;
}
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;
}
void UpdateDriverSpinnerGUI()
{
driver_spinner->set_int_val(cur_driver);
//driver_spinner->set_int_val(cur_driver);
UpdateDriverInfoGUI();
}
