PMG

class ACCamera_3D {
// --------------- Camera 3D

  virtual void apply_projection () = 0;
  virtual void apply_viewport () = 0;
  virtual void apply_viewer () = 0;

};


#ifdef _WIN32

class CCamera_OGL : public ACCamera_3D {
// --------------- Camera OGL

public:

  CCamera_OGL ()
  {
    type_view = 0;
    eye.cpy( 0.0f, 0.0f, 1.0f);
    center.cpy( 0.0f, 0.0f, 0.0f);
    up.cpy(0.0f, 1.0f, 0.0f);

    type_projection = 1;
    fovy = 52.0f;
    aspect = 1.0f;
    zNear = 1.0f;
    zFar = 1000.0f;
  }


  void look_at_view ( SVector3f * eye_, SVector3f * center_, SVector3f * up_ )
  {
    type_view = 0;
    eye.cpy(eye_);
    center.cpy(center_);
    up.cpy(up_);
  }

  void  pilot_view ( SVector3f * plane_, float roll_, float pitch_, float heading_ )
  {
    type_view = 1;
    plane.cpy(plane_);
    roll = roll_;
    pitch = pitch_;
    heading = heading_;
  }

  void orbit_view ( float distance_, float twist_, float elevation_, float azimuth_ )
  {
    type_view = 2;
    distance = distance_;
    twist = twist_;
    elevation = elevation_;
    azimuth = azimuth_;
  }

  void ortho_projection (  float left_, float right_, float bottom_, float top_, float zNear_, float zFar_ )
  {
    type_projection = 0;
    left = left_;
    right = right_;
    bottom = bottom_;
    top = top_;
    zNear = zNear_;
    zFar = zFar_;
  }

  void perspective_projection ( float fovy_, float zNear_, float zFar_ )
  {
    type_projection = 1;
    fovy = fovy_;
    aspect = float(win.w) / float(win.h);
    zNear_p = zNear_;
    zFar_p = zFar_;
  }

  void assign_viewport ( bool yes_scissor_, uint_t x, uint_t y, uint_t w, uint_t h )
  {
    if ( h == 0 ) h = 1;
    if ( w == 0 ) w = 1;
    win.cpy( x, y, w, h);
    yes_scissor = yes_scissor_;

    if ( type_projection==0 ) {
      left = (float)x;
      right = (float)(x+w-1);
      bottom = (float)y;
      top = (float)(y+h-1);
    }

  }

  virtual void apply_projection ();
  virtual void apply_viewport ();
  virtual void apply_viewer ();

  virtual void apply ();

  int get_type_view () { return type_view; }
  int get_type_projection () { return type_projection; }

protected:

  int type_view, type_projection;

  SVector3f eye, center, up;

  SVector3f plane;
  float roll, pitch, heading;

  float distance, twist, elevation, azimuth;

  float left, right, bottom, top, zNear, zFar;

  float fovy, aspect, zNear_p, zFar_p;

  SVector4ui win;
  bool yes_scissor;

};

void CCamera_OGL:: apply_viewer ()
{
  switch ( type_view ) {
  case 0:
    gluLookAt(eye.x,eye.y,eye.z, center.x,center.y,center.z, up.x,up.y,up.z );
    break;
  case 1:
    glRotatef (roll, 0.0f, 0.0f, 1.0f);
    glRotatef (pitch, 0.0f, 1.0f, 0.0f);
    glRotatef (heading, 1.0f, 0.0f, 0.0f);
    glTranslatef (-plane.x, plane.y, plane.z );
    break;
  case 2:
    glTranslatef (0.0f, 0.0f, -distance );
    glRotatef (-twist, 0.0f, 0.0f, 1.0f);
    glRotatef (-elevation, 0.0f, 1.0f, 0.0f);
    glRotatef (azimuth, 1.0f, 0.0f, 0.0f);
    break;
  }
}

void CCamera_OGL:: apply_projection ()
{
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  switch ( type_projection ) {
  case 0:
    glOrtho(left, right, bottom, top, zNear, zFar);
    break;
  case 1:
    gluPerspective(fovy, aspect, zNear_p, zFar_p);
    break;
  }
  glMatrixMode(GL_MODELVIEW);
}


void CCamera_OGL:: apply_viewport ()
{
  if ( yes_scissor ) {
    glEnable(GL_SCISSOR_TEST);
    glScissor((GLint)win.x, (GLint)win.y, (GLsizei)win.w, (GLsizei)win.h );
  }
  else
    glDisable(GL_SCISSOR_TEST);
  glViewport( (GLint)win.x, (GLint)win.y, (GLsizei)win.w, (GLsizei)win.h);
}


void CCamera_OGL:: apply ()
{
  apply_viewport();
  apply_projection();
  glMatrixMode(GL_MODELVIEW);   
  glLoadIdentity();
  apply_viewer();
}