src/maingui.cpp

Go to the documentation of this file.

/*
* Copyright (c) 2006-2007 Erin Catto http://www.box2d.org
*
* This software is provided 'as-is', without any express or implied
* warranty.  In no event will the authors be held liable for any damages
* arising from the use of this software.
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
* 3. This notice may not be removed or altered from any source distribution.
*/

/* 
 * Base code for CS 296 Software Systems Lab 
 * Department of Computer Science and Engineering, IIT Bombay
 * Instructor: Parag Chaudhuri
 */

#include<iostream>
#include "render.hpp"
#include "cs296_base.hpp"
#include "callbacks.hpp"
#include <sys/time.h> //Timer Functions

#ifndef __APPLE__
#include "GL/glui.h"
#else
#include "GL/glui.h"
#endif

#include <cstdio>


namespace cs296
{
  extern int32 test_index;
  extern int32 test_selection;
  extern int32 test_count;
  extern cs296::sim_t* entry;
  extern cs296::base_sim_t* test;
  extern cs296::settings_t settings;
  extern const int32 frame_period;
  extern float settings_hz;
  extern int32 width;
  extern int32 height;
  extern int32 main_window;
};

using namespace cs296;


void create_glui_ui(void)
{
  GLUI *glui = GLUI_Master.create_glui_subwindow( main_window, GLUI_SUBWINDOW_BOTTOM );
  
  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_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 );
  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 );
  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 );
}

void average_time(int32 no_of_steps){ 
    // settings_hz from callbacks.cpp  
    float32 step_size=1/settings_hz; 
   
    b2World* world = test->get_world(); 
    
    const b2Profile& world_profile = world->GetProfile(); 
    int32 step_Count=0; 
    
    float32 time_taken_for_step=0.0000;
    float32 time_taken_for_velocity_update=0.0000;
    float32 time_taken_for_collisions=0.0000;
    float32 time_taken_for_position_update=0.0000;
    
    struct timeval start, end;
    gettimeofday(&start,NULL);
    double t1 = 1000*(start.tv_sec) + start.tv_usec/1000.0;
    
    while (step_Count<no_of_steps)
    { 
        // Step function for Simulation in Box2D world.
        world->Step(step_size, settings.velocity_iterations, settings.position_iterations);     
        time_taken_for_step +=world_profile.step;
        time_taken_for_velocity_update += world_profile.solveVelocity;
        time_taken_for_collisions += world_profile.collide;
        time_taken_for_position_update += world_profile.solvePosition;
        step_Count++;
    }
    
    gettimeofday(&end, NULL); 
    double t2 = 1000*(end.tv_sec) + end.tv_usec/1000.0;
    double t= t2 - t1;
    //[Lab07]
    std::cout<<"Total Iterations: "<< no_of_steps<<"\n";
    std::cout<<"Average time per step is "<< time_taken_for_step/no_of_steps<<" ms\n";
    std::cout<<"Average time for collisions is "<<time_taken_for_collisions/no_of_steps<<" ms\n";
    std::cout<<"Average time for velocity updates is "<<time_taken_for_velocity_update/no_of_steps<<" ms\n";
    std::cout<<"Average time for position updates is "<<time_taken_for_position_update/no_of_steps<<" ms\n\n";
    std::cout<<"Total time for loop is "<<t<<" ms"<<std::endl;
    //std::cout <<t/1000
    //<<std::endl;
}


int main(int argc, char** argv)
{
  test_count = 1;
  test_index = 0;
  test_selection = test_index;
  
  entry = sim;
  test = entry->create_fcn();

  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
  glutInitWindowSize(800, 500);

  char title[50];
  sprintf(title, "CS296 Base Code. Running on Box2D %d.%d.%d", b2_version.major, b2_version.minor, b2_version.revision);
  main_window = glutCreateWindow(title);

  GLUI_Master.set_glutReshapeFunc(callbacks_t::resize_cb);  
  GLUI_Master.set_glutKeyboardFunc(callbacks_t::keyboard_cb);
  GLUI_Master.set_glutSpecialFunc(callbacks_t::keyboard_special_cb);
  GLUI_Master.set_glutMouseFunc(callbacks_t::mouse_cb);
  glutDisplayFunc(callbacks_t::display_cb);
  glutMotionFunc(callbacks_t::mouse_motion_cb);
  glutKeyboardUpFunc(callbacks_t::keyboard_up_cb); 
  glutTimerFunc(frame_period, callbacks_t::timer_cb, 0);

  /*
  // Command Line argument for number of iterations
  int no_of_steps = 0;
  if(argc == 1) no_of_steps = 100;   //Default Value
  else no_of_steps = atoi(argv[1]);
  average_time(no_of_steps);
  */
  create_glui_ui();

  glutMainLoop();
  
  return 0;
}