main.cpp

Go to the documentation of this file.

#include "opengl.hpp"

#include "math.hpp"
#include <iostream>
using namespace std;

#include "ui_View.hpp"
#include "ui_Bin.hpp"
#include "ui_CrossSplitter.hpp"
#include "ui_Frame.hpp"
#include "ui_App.hpp"
#include "ui_fonts.hpp"
#include "ui_SceneView.hpp"
#include "ui_SceneEditor.hpp"

#include "scene_FunctionMixer.hpp"

// --- application -----------------------------------------------------------

#include "options.hpp"

options_config gConfig;
Frame* pFrame;
Scene* pScene;
SceneEditor* pSceneEditor;
FunctionMixer* pFunctionMixer;

void init(int windowId)
{
  pScene = new Scene();
  pFunctionMixer = new FunctionMixer();
  pFunctionMixer->setElevationGrid(new ElevationGrid(gConfig.mSize[0],gConfig.mSize[1],gConfig.mXLimits,gConfig.mYLimits));
  // pFunctionMixer->setPointSize(0.75);
  pFunctionMixer->setPointSize(0.5);
  // pFunctionMixer->setXSD(10.0);
  // pFunctionMixer->setYSD(10.0);
  pScene->addNode(pFunctionMixer);
  
  pFrame = new Frame(windowId);

  // specifies currently the cross split color
  pFrame->setBGColor( Vec3d(0.25,0.25,0.25) );

  pSceneEditor = new SceneEditor(pScene);
  pSceneEditor->setViewSize( 60.0 );
  pSceneEditor->setFocusPoint(Point3d(50.0,50.0,20.0));

  pFrame->setChildView( pSceneEditor );
}


#include "io_fmix.hpp"

void load(const char* filename)
{
  std::ifstream ifs;
  ifs.open(filename,std::ios::in);
  if ( ifs.is_open() )
  {
    cout << "loading model from file '" << filename << "' ...";
    io_fmix::load(ifs, *pFunctionMixer );
    ifs.close();
    cout << "done.\n";
  }
  else
  {
    cerr << "error: unable to open file '" << filename << "' for reading.\n";
  }
}

void save(const char* filename)
{
  std::ofstream ofs;
  ofs.open(filename,std::ios::out);
  if ( ofs.is_open() )
  {
    cout << "saving model to file '" << filename << "' ... ";
    io_fmix::save(ofs, *pFunctionMixer );
    ofs.close();
    cout << "done.\n";
  }
  else
  {
    cerr << "error: unable to open file '" << filename << "' for writing.\n";
  }
}

#include "dialog.hpp"

void load()
{
  std::string fn;
  if ( dialog_load(fn) ) 
  {
    load(fn.c_str());
  }
}

void save()
{
  std::string fn;
  if ( dialog_save(fn) ) 
  {
    save(fn.c_str());
  }
}

void moveLocal(const Vec3d& direction)
{
  pSceneEditor->moveLocal(direction);
}

void clear()
{
  if ( dialog_yesno("Do you want to clear ALL hotspots?") )
  {
    pFunctionMixer->clear();
  }
}

bool gLayerStateRuler = true;

void toggle(int layerid)
{
  if (layerid == 4)
  {
    gLayerStateRuler = !gLayerStateRuler;
    pSceneEditor->setRulersVisible( gLayerStateRuler );
  }
  else
    pFunctionMixer->toggleLayer(layerid);
}

void remove_hotspot()
{
  pFunctionMixer->removeSelected();
}

void help()
{
  static const char* help_text =
    "Keys:\n"
    "F1\tthis page\n"
    "W\tmove camera forward\n"
    "S\tmove camera backward\n"
    "A\tmove camera left\n"
    "D\tmove camera right\n"
    "R\tmove camera up\n"
    "F\tmove camera down\n"
    "SHIFT-S\tsave function mix\n"
    "SHIFT-L\tload function mix\n"
    "SHIFT-C\tnew function mix\n"
    "DELETE\tremove selected function\n"
    "1\ttoggle normals layer\n"
    "2\ttoggle grid layer\n"
    "3\ttoggle control point layer\n"
    "4\ttoggle surface layer\n"
    "5\ttoggle rulers\n"
  ;

  dialog_ok(help_text);
}

void quit()
{
  exit(0);
}

void keyboard(unsigned char ch, int x, int y)
{
  if ( (ch >= '1') && (ch <= '9') )
  {
    int layer( ch - '1' );
    toggle(layer);
  }
  else
  {
    switch(ch)
    {
    case 'w': moveLocal(Vec3d( 0, 0,-1)); break;  
    case 's': moveLocal(Vec3d( 0, 0, 1)); break;  
    case 'a': moveLocal(Vec3d(-1, 0, 0)); break;
    case 'd': moveLocal(Vec3d( 1, 0, 0)); break;
    case 'r': moveLocal(Vec3d( 0, 1, 0)); break;
    case 'f': moveLocal(Vec3d( 0,-1, 0)); break;
    case 'S': save(); break;
    case 'L': load(); break;
    case 'C': clear(); break;
    case 127: remove_hotspot(); break;
    case  27: quit(); break;
    }
  }
}

void keyboard2(int ch, int x, int y)
{
  switch(ch)
  {
  case GLUT_KEY_F1: help(); break;
  }
}


void gl_check_error()
{
#if !(defined NDEBUG)
  GLenum err = glGetError();
  if (err != GL_NO_ERROR)
  {
    std::cerr << "GL Error: " << gluErrorString(err) << "\n";
  }
#endif
}

// global window height
int gH;
// filter mouse y value 
// begins at left/top in native windowing system
// but begins at left/bottom in OpenGL window system
inline int filter_y(int y)
{
  return gH - y;
}

void display()
{
  pFrame->display();
  gl_check_error();
  glutSwapBuffers();
  glutPostRedisplay();
}

void reshape(int w, int h)
{ 
  gH = h;
  pFrame->reshape(w,h);
}

void mouse(int button, int state, int x, int y)
{
  y = filter_y(y);
  pFrame->mouse(button,state,x,y);
}

void motion(int x, int y)
{
  y = filter_y(y);
  pFrame->motion(x,y);
}

int main(int argc, char* argv[])
{
  options_parser options(argc, argv);  
  options.parse_all(gConfig);
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE);  
  const int width = 800;
  const int height = 600;
  const int screenWidth = glutGet(GLUT_SCREEN_WIDTH);
  const int screenHeight = glutGet(GLUT_SCREEN_HEIGHT);
  glutInitWindowPosition( ( screenWidth - width ) / 2, (screenHeight - height ) / 2);
  glutInitWindowSize(width,height);
  int windowId = glutCreateWindow("F-Shake 3D (Version 0.0.1) - Press F1 for help");
  glutSetWindow(windowId);
  init(windowId);
  glutDisplayFunc(display);
  glutReshapeFunc(reshape);
  glutMouseFunc(mouse);
  glutMotionFunc(motion);
  glutKeyboardFunc(keyboard);
  glutSpecialFunc(keyboard2);
  glutMainLoop();
  
  return 0; 
}