main.cpp

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
                                                                                   
#ifdef WIN32
#  include <windows.h>
#else
#  include <unistd.h>
#endif
#include <math.h>
                                                                                   
#ifdef FREEGLUT_IS_PRESENT
#  include <GL/freeglut.h>
#else
#  ifdef __APPLE__
#    include <GLUT/glut.h>
#  else
#    include <GL/glut.h>
#  endif
#endif

#include <signal.h>
#include <GL/gl.h>
#include <GL/glut.h>
#include <GL/glu.h>
#include <plib/ssg.h>

#include <plib/pu.h>

#include "common_gui_funcs.h"
#include "core.h"

#include "configuration.h"
#include "userData.h"
#include "core.h"

#define str(s) #s

// the graphic scene, to be given to a number of sub-objects
ssgRoot* scene = NULL;
 
//sceneManager* sman = NULL
 
int display_width;
int display_height;

int game_state;

puMenuBar* main_menu = NULL;
bool in_game_menu    = false;

puGroup* total_menu = NULL;
puGroup* overlay_menu = NULL;

configuration* config = NULL;
userData* loc_player = NULL;
GameCore* loc_core = NULL;

sgVec3* cam_target      = NULL;
float   view_distance   = 10.0f;
float   view_x_angle    = 0.0f;
float   view_z_angle    = 10.0f;
static sgVec2  nmouse;
int win_handle = -1;

enum {
  MOVE_CAM,
  IN_GAME
};
 
int input_mode          = IN_GAME;

void get_camera_data(int i) {
  sgVec3* d;
  d = config->get_campos(i);
  view_distance = *d[0];
  view_x_angle = *d[1];
  view_z_angle = *d[2];
}

void update_motion ()
{
}
 
void mouse_motionfn (int x, int y) {
  nmouse[0] = ((double)x / display_width ) - 0.5f;
  nmouse[1] = ((double)y / display_height ) - 0.5f;
}

void keyfn ( unsigned char k, int, int )
{
  if (puKeyboard(k + PU_KEY_GLUT_SPECIAL_OFFSET, PU_DOWN )) // some ui element took it
    return;

  int modifier = glutGetModifiers();

  switch(k) {
    case 27:
      fprintf(stderr, "ESC key pressed\n");
      break;
                                                                                   
    case GLUT_KEY_F1:
      if (modifier == GLUT_ACTIVE_SHIFT)
        config->set_campos(0, view_distance, view_x_angle, view_z_angle);
      else
        get_camera_data(0);
      break;
    case GLUT_KEY_F2:
      if (modifier == GLUT_ACTIVE_SHIFT)
        config->set_campos(1, view_distance, view_x_angle, view_z_angle);
      else
        get_camera_data(1);
      break;
    case GLUT_KEY_F3:
      if (modifier == GLUT_ACTIVE_SHIFT)
        config->set_campos(2, view_distance, view_x_angle, view_z_angle);
      else
        get_camera_data(2);
      break;
    case GLUT_KEY_F4:
      if (modifier == GLUT_ACTIVE_SHIFT)
        config->set_campos(3, view_distance, view_x_angle, view_z_angle);
      else
        get_camera_data(3);
      break;
                                                                                   
    case '\t':
      if (in_game_menu) {
        main_menu -> hide();
        in_game_menu = false;
      }
      else {
        in_game_menu = true;
         main_menu-> reveal();
      }
      break;
  }
}

void displayfn ()
{
  update_motion () ;
                                                                                   
  glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
  glClear  ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ) ;
                                                                                   
                                                                                   
  ssgCullAndDraw ( scene ) ;
                                                                                   
  puDisplay();
                                                                                   
  glutPostRedisplay () ;
  glutSwapBuffers () ;
}

void mousefn (int button, int state, int x, int y)
{
  if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
  {
                                                                                   
  }
}
      
void init_graphics_once(int argc, char** argv) {
  ssgModelPath(MODEL_PATH);
  ssgTexturePath(TEXTURE_PATH);
 
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
  if (config->get_fullscreen()) {
    glutGameModeString(config->get_game_mode_string());
    if (glutGameModeGet(GLUT_GAME_MODE_POSSIBLE) != -1) {
      glutEnterGameMode();
    }
    else {
      fprintf(stderr, "glut returned error while opening configured fullscreen mode\n");
      glutInitWindowSize(config->get_window_width(), config->get_window_height());
      win_handle = glutCreateWindow(WINDOW_TITLE);
    }
  }
  else {
    glutInitWindowSize(config->get_window_width(), config->get_window_height());
    win_handle = glutCreateWindow(WINDOW_TITLE);
  }
  display_height = config->get_window_height();
  display_width = config->get_window_width();
  ssgInit();
  puInit();                                                                          _register_glutfuncs_menuonly();
  glEnable(GL_DEPTH_TEST);
  glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  glClear      ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) ;
}


class wrapper {
  public:
    wrapper();
    ~wrapper();
    void go();
  private:
    GameCore* core;
    configuration* cfg;
};

wrapper::wrapper () {
#ifdef CONFIG_FILE
  cfg = new configuration(str(CONFIG_FILE));
#else
  cfg = new configuration(NULL);
#endif
  config = cfg;
}

wrapper::~wrapper() {
  fprintf(stderr, "got a SIGINT, stopping...\n");
  fprintf(stderr, ">deleting scene\n");
  delete scene;
  fprintf(stderr, ">deleting game core\n");
  delete core;
  fprintf(stderr, ">deleting config\n");
  delete cfg;
}

void wrapper::go() {
  core = new GameCore(scene);
  loc_core = core;
}

wrapper* foo = NULL;

void sig_catcher(int sig) {
  delete foo;
  exit(0);
}

int main ( int argc , char ** argv )
{
  foo = new wrapper();
  signal(SIGINT, sig_catcher);
  init_graphics_once (argc, argv) ;
  foo->go();
  glutMainLoop  () ;
  exit( 0 );
}

---