void InitGlui(void)
{
GLUI_Panel *panel;
GLUI_RadioGroup *group;
GLUI_Rotation *rot;
GLUI_Translation *trans, *scale;
Glui = GLUI_Master.create_glui( (char *) GLUITITLE, 0, 0, 0);
Glui->add_statictext( (char *) GLUITITLE );
Glui->add_separator();
panel = Glui->add_panel("Shape & Motion");
group = Glui->add_radiogroup_to_panel( panel, &WhichShape, 0 );
Glui->add_radiobutton_to_group( group, "Y" );
Glui->add_radiobutton_to_group( group, "Double Y" );
panel = Glui->add_panel("Method");
group = Glui->add_radiogroup_to_panel( panel, &WhichMethod, 0 );
Glui->add_radiobutton_to_group( group, "Jacobian Transpose" );
Glui->add_radiobutton_to_group( group, "Pure Pseudoinverse" );
Glui->add_radiobutton_to_group( group, "Damped Least Squares" );
Glui->add_radiobutton_to_group( group, "Selectively Damped Least Squares" );
Glui->add_radiobutton_to_group( group, "Compare" );
panel = Glui->add_panel("Options");
//Glui->add_checkbox_to_panel( panel, "Joint Limits", &JointLimitsOn, 0, NULL);
//Glui->add_checkbox_to_panel( panel, "Rest Position", &RestPositionOn, 0, NULL);
Glui->add_checkbox_to_panel( panel, "Jacobian Targets", &UseJacobianTargets, 0);
panel = Glui->add_panel("View");
Glui->add_checkbox_to_panel( panel, "Eigen Vectors", &EigenVectorsOn, 0);
Glui->add_checkbox_to_panel( panel, "Axes", &AxesOn, 0);
Glui->add_checkbox_to_panel( panel, "Perspective", &WhichProjection, 0);
Glui->add_checkbox_to_panel( panel, "Rotation Axes", &RotAxesOn, 0);
panel = Glui->add_panel( "Object Transformation" );
rot = Glui->add_rotation_to_panel( panel, "Rotation", (float *) RotMatrix, 0);
rot->set_spin( 1.0 );
Glui->add_column_to_panel( panel, FALSE );
scale = Glui->add_translation_to_panel( panel, "Scale", GLUI_TRANSLATION_Y , &Scale2, 0);
scale->set_speed( 0.01f );
Glui->add_column_to_panel( panel, FALSE );
trans = Glui->add_translation_to_panel( panel, "Trans XY", GLUI_TRANSLATION_XY, &TransXYZ[0], 0);
trans->set_speed( 0.1f );
Glui->add_column_to_panel( panel, FALSE );
trans = Glui->add_translation_to_panel( panel, "Trans Z", GLUI_TRANSLATION_Z , &TransXYZ[2], 0);
trans->set_speed( 0.1f );
panel = Glui->add_panel( "", FALSE );
Glui->add_button_to_panel( panel, "Run Test", RUNTEST, (GLUI_Update_CB) Buttons );
Glui->add_column_to_panel( panel, FALSE );
Glui->add_button_to_panel( panel, "Reset", RESET, (GLUI_Update_CB) Buttons );
Glui->add_button_to_panel( panel, "Quit", QUIT, (GLUI_Update_CB) Buttons );
Glui->set_main_gfx_window( GrWindow );
GLUI_Master.set_glutIdleFunc( NULL );
}
GLUI_Rotation *GLUI::add_rotation_to_panel( GLUI_Panel *panel,
char *name, float *value_ptr,
int id,
GLUI_Update_CB callback )
{
GLUI_Rotation *control;
control = new GLUI_Rotation;
if ( control ) {
control->set_ptr_val( value_ptr );
control->user_id = id;
control->set_name( name );
control->callback = callback;
add_control( panel, control );
control->init_live();
/*** Init the live 4x4 matrix. This is different than the standard
live variable behavior, since the original value of the 4x4 matrix
is ignored and reset to Identity ***/
if ( value_ptr != NULL ) {
int i, j, index;
for( i=0; i<4; i++ ) {
for( j=0; j<4; j++ ) {
index = i*4+j;
if ( i==j )
value_ptr[index] = 1.0;
else
value_ptr[index] = 0.0;
}
}
}
/*init_ball(); */
return control;
}
else {
return NULL;
}
}
void
InitGlui( )
{
glutInitWindowPosition( INIT_WINDOW_SIZE + 50, 0 );
Glui = GLUI_Master.create_glui( (char *) GLUITITLE );
Glui->add_statictext( (char *) GLUITITLE );
Glui->add_separator( );
Glui->add_checkbox( "Axes", &AxesOn );
Glui->add_checkbox( "Perspective", &WhichProjection );
Glui->add_checkbox( "Show Performance", &ShowPerformance );
GLUI_Panel *panel = Glui->add_panel( "Object Transformation" );
GLUI_Rotation *rot = Glui->add_rotation_to_panel( panel, "Rotation", (float *) RotMatrix );
rot->set_spin( 1.0 );
Glui->add_column_to_panel( panel, GLUIFALSE );
GLUI_Translation *scale = Glui->add_translation_to_panel( panel, "Scale", GLUI_TRANSLATION_Y , &Scale2 );
scale->set_speed( 0.01f );
Glui->add_column_to_panel( panel, FALSE );
GLUI_Translation *trans = Glui->add_translation_to_panel( panel, "Trans XY", GLUI_TRANSLATION_XY, &TransXYZ[0] );
trans->set_speed( 1.1f );
Glui->add_column_to_panel( panel, FALSE );
trans = Glui->add_translation_to_panel( panel, "Trans Z", GLUI_TRANSLATION_Z , &TransXYZ[2] );
trans->set_speed( 1.1f );
panel = Glui->add_panel( "", FALSE );
Glui->add_button_to_panel( panel, "Reset", RESET, (GLUI_Update_CB) Buttons );
Glui->add_column_to_panel( panel, FALSE );
Glui->add_button_to_panel( panel, "Go !", GO, (GLUI_Update_CB) Buttons );
Glui->add_column_to_panel( panel, FALSE );
Glui->add_button_to_panel( panel, "Quit", QUIT, (GLUI_Update_CB) Buttons );
Glui->set_main_gfx_window( MainWindow );
GLUI_Master.set_glutIdleFunc( NULL );
}
void GfxGLWindowGLUI::addRotate( const String& name, ControlID id, PanelID pid )
{
Imp::FullControlID fid = _imp->makeFullControlID( *this, id );
GLUI_Rotation* rot;
if ( pid != PANEL_NONE ) {
rot = _imp->_glui->add_rotation_to_panel(
&_imp->getPanel( pid ),
const_cast<char*>( name.c_str() ), // FIXME: stupid GLUI!
NULL,
fid,
controlCB
);
}
else {
rot = _imp->_glui->add_rotation(
const_cast<char*>( name.c_str() ), // FIXME: stupid GLUI!
NULL,
fid,
controlCB
);
}
rot->reset();
_imp->addControl( rot, id );
}
void
InitGlui( void )
{
GLUI_Panel *panel;
GLUI_RadioGroup *group;
GLUI_Rotation *rot;
GLUI_Translation *trans, *scale;
// setup the glui window:
glutInitWindowPosition( INIT_WINDOW_SIZE + 50, 0 );
Glui = GLUI_Master.create_glui( (char *) GLUITITLE );
Glui->add_statictext( (char *) GLUITITLE );
Glui->add_separator( );
Glui->add_checkbox( "Axes", &AxesOn );
Glui->add_checkbox( "Perspective", &WhichProjection );
Glui->add_checkbox( "Intensity Depth Cue", &DepthCueOn );
panel = Glui->add_panel( "Axes Color" );
group = Glui->add_radiogroup_to_panel( panel, &WhichColor );
Glui->add_radiobutton_to_group( group, "Red" );
Glui->add_radiobutton_to_group( group, "Yellow" );
Glui->add_radiobutton_to_group( group, "Green" );
Glui->add_radiobutton_to_group( group, "Cyan" );
Glui->add_radiobutton_to_group( group, "Blue" );
Glui->add_radiobutton_to_group( group, "Magenta" );
Glui->add_radiobutton_to_group( group, "White" );
Glui->add_radiobutton_to_group( group, "Black" );
panel = Glui->add_panel( "Object Transformation" );
rot = Glui->add_rotation_to_panel( panel, "Rotation", (float *) RotMatrix );
// allow the object to be spun via the glui rotation widget:
rot->set_spin( 1.0 );
Glui->add_column_to_panel( panel, GLUIFALSE );
scale = Glui->add_translation_to_panel( panel, "Scale", GLUI_TRANSLATION_Y , &Scale2 );
scale->set_speed( 0.005f );
Glui->add_column_to_panel( panel, GLUIFALSE );
trans = Glui->add_translation_to_panel( panel, "Trans XY", GLUI_TRANSLATION_XY, &TransXYZ[0] );
trans->set_speed( 0.05f );
Glui->add_column_to_panel( panel, GLUIFALSE );
trans = Glui->add_translation_to_panel( panel, "Trans Z", GLUI_TRANSLATION_Z , &TransXYZ[2] );
trans->set_speed( 0.05f );
Glui->add_checkbox( "Debug", &DebugOn );
panel = Glui->add_panel( "", GLUIFALSE );
Glui->add_button_to_panel( panel, "Reset", RESET, (GLUI_Update_CB) Buttons );
Glui->add_column_to_panel( panel, GLUIFALSE );
Glui->add_button_to_panel( panel, "Quit", QUIT, (GLUI_Update_CB) Buttons );
// tell glui what graphics window it needs to post a redisplay to:
Glui->set_main_gfx_window( MainWindow );
// set the graphics window's idle function if needed:
GLUI_Master.set_glutIdleFunc( NULL );
}
/**
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
InitGlui( )
{
GLUI_Panel *panel;
GLUI_RadioGroup *group;
GLUI_Rotation *rot;
GLUI_Translation *trans, *scale;
// setup the glui window:
glutInitWindowPosition( INIT_WINDOW_SIZE + 50, 0 );
Glui = GLUI_Master.create_glui( (char *) GLUITITLE );
Glui->add_statictext( (char *) GLUITITLE );
Glui->add_separator( );
Glui->add_checkbox( "Axes", &AxesOn );
Glui->add_checkbox( "Perspective", &WhichProjection );
Glui->add_checkbox( "Intensity Depth Cue", &DepthCueOn );
//panel = Glui->add_panel( "Axes Color" );
// group = Glui->add_radiogroup_to_panel( panel, &WhichColor );
// Glui->add_radiobutton_to_group( group, "Red" );
// Glui->add_radiobutton_to_group( group, "Yellow" );
// Glui->add_radiobutton_to_group( group, "Green" );
// Glui->add_radiobutton_to_group( group, "Cyan" );
// Glui->add_radiobutton_to_group( group, "Blue" );
// Glui->add_radiobutton_to_group( group, "Magenta" );
// Glui->add_radiobutton_to_group( group, "White" );
// Glui->add_radiobutton_to_group( group, "Black" );
//add sliders for proj3
char str[128];
XSlider = Glui->add_slider(true, GLUI_HSLIDER_FLOAT, XLowHigh,
X_ID, (GLUI_Update_CB)Sliders);
XSlider->set_float_limits(-1.f, 1.f);
XSlider->set_w(200); // good slider width
sprintf(str, XFORMAT, XLowHigh[0], XLowHigh[1]);
XLabel = Glui->add_statictext(str);
YSlider = Glui->add_slider(true, GLUI_HSLIDER_FLOAT, YLowHigh,
Y_ID, (GLUI_Update_CB)Sliders);
YSlider->set_float_limits(-1., 1.);
YSlider->set_w(200); // good slider width
sprintf(str, YFORMAT, YLowHigh[0], YLowHigh[1]);
YLabel = Glui->add_statictext(str);
ZSlider = Glui->add_slider(true, GLUI_HSLIDER_FLOAT, ZLowHigh,
Z_ID, (GLUI_Update_CB)Sliders);
ZSlider->set_float_limits(-1., 1.);
ZSlider->set_w(200); // good slider width
sprintf(str, ZFORMAT, ZLowHigh[0], ZLowHigh[1]);
ZLabel = Glui->add_statictext(str);
RadSlider = Glui->add_slider(true, GLUI_HSLIDER_FLOAT, RadLowHigh,
RAD_ID, (GLUI_Update_CB)Sliders);
RadSlider->set_float_limits(.0, sqrt(3.));
RadSlider->set_w(200); // good slider width
sprintf(str, RadFORMAT, RadLowHigh[0], RadLowHigh[1]);
RadLabel = Glui->add_statictext(str);
GradSlider = Glui->add_slider(true, GLUI_HSLIDER_FLOAT, GradLowHigh,
GRAD_ID, (GLUI_Update_CB)Sliders);
GradSlider->set_float_limits(.0, 300.);
GradSlider->set_w(200); // good slider width
sprintf(str, GradFORMAT, GradLowHigh[0], GradLowHigh[1]);
GradLabel = Glui->add_statictext(str);
TempSlider = Glui->add_slider(true, GLUI_HSLIDER_FLOAT, TempLowHigh,
TEMP_ID, (GLUI_Update_CB)Sliders);
TempSlider->set_float_limits(TEMPMIN, TEMPMAX);
TempSlider->set_w(200); // good slider width
sprintf(str, TempFORMAT, TempLowHigh[0], TempLowHigh[1]);
TempLabel = Glui->add_statictext(str);
//spinner point size;
GLUI_Spinner *pointsize_spinner = Glui->add_spinner("PointSize",
GLUI_SPINNER_FLOAT,
&PointSize, NULL,
(GLUI_Update_CB) SetPointSize);
pointsize_spinner->set_float_limits(1., 10., GLUI_LIMIT_CLAMP);
panel = Glui->add_panel( "Object Transformation" );
rot = Glui->add_rotation_to_panel( panel, "Rotation", (float *) RotMatrix );
// allow the object to be spun via the glui rotation widget:
rot->set_spin( 1.0 );
Glui->add_column_to_panel( panel, GLUIFALSE );
scale = Glui->add_translation_to_panel( panel, "Scale", GLUI_TRANSLATION_Y , &Scale2 );
scale->set_speed( 0.005f );
Glui->add_column_to_panel( panel, GLUIFALSE );
trans = Glui->add_translation_to_panel( panel, "Trans XY", GLUI_TRANSLATION_XY, &TransXYZ[0] );
trans->set_speed( 0.05f );
Glui->add_column_to_panel( panel, GLUIFALSE );
trans = Glui->add_translation_to_panel( panel, "Trans Z", GLUI_TRANSLATION_Z , &TransXYZ[2] );
trans->set_speed( 0.05f );
Glui->add_checkbox( "Debug", &DebugOn );
panel = Glui->add_panel( "", GLUIFALSE );
Glui->add_button_to_panel( panel, "Reset", RESET, (GLUI_Update_CB) Buttons );
Glui->add_column_to_panel( panel, GLUIFALSE );
Glui->add_button_to_panel( panel, "Quit", QUIT, (GLUI_Update_CB) Buttons );
// tell glui what graphics window it needs to post a redisplay to:
Glui->set_main_gfx_window( MainWindow );
// set the graphics window's idle function if needed:
GLUI_Master.set_glutIdleFunc( NULL );
}
