SimpleSceneGL.cpp

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003, 2004    (see file CONTACTS for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

/** Jan Woetzel */
#include "SimpleSceneGL.hh"
#include <Gui/GeometryGL.hh>

#ifndef BIAS_HAVE_GLUT
#  error Please recompile BIAS with USE_GLUT to compile this example.
#endif // BIAS_HAVE_GLUT
#define GLUT_BUILDING_LIB
#include <GL/glut.h>

using namespace std;
using namespace BIAS;

/// JW
class SimpleSceneGLData {
public:
  SimpleSceneGLData() : dplist(0) {};
  int dplist;
};


//
// pure GL implementation
//


void InitGeometry(int &dplist)
{
  // init once: 
  static bool initDone = false;
  if (!initDone) {
    // do init 
    CHECK_GL_ERROR;
    // example for an OpenGL display list
    dplist = glGenLists(1); // identifier 
    glNewList(dplist, GL_COMPILE);  // or: GL_COMPILE_AND_EXECUTE
    {
      // light source proeprties for enabled lighting:  
      // specified pos by w=1, direction by w=0:
      GLfloat light_position0[] = { 10.0f, 10.0, 10.0f, 0.0f }; // w=0: direction
      GLfloat light_maincolor0[] = { 1.0f, 1.0, 1.0f, 1.0f };
      GLfloat light_ambientcolor0[] = { 0.4f, 0.2f, 0.2f, 1.0f };

      // GL create light 0
      glLightfv(GL_LIGHT0, GL_POSITION, light_position0);
      glLightfv(GL_LIGHT0, GL_DIFFUSE, light_maincolor0);
      glLightfv(GL_LIGHT0, GL_SPECULAR, light_maincolor0);
      glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambientcolor0);

      glEnable(GL_LIGHT0);
      glEnable(GL_LIGHTING);    // may be switched on/off for every object
      glEnable(GL_DEPTH_TEST);  // depth buffer occlusions of objects

      // material properties for enabled lighting: 
      GLfloat paintcolor0[] = { 0.9, 0.2, 0.5, 1.0 };
      GLfloat specularcolor0[] = { 1.0, 1.0, 1.0, 1.0 };
      GLfloat shininess0[] = { 70. };   // 1..128, large values make smaller specular highlights

      GLfloat paintcolor1[] = { 0.3, 0.9, 0.4, 1.0 };
      GLfloat paintcolor2[] = { 0.1, 0.2, 0.9, 1.0 };

      glMatrixMode(GL_MODELVIEW);
      glPushMatrix();

      //// activate material properties: 
      glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specularcolor0);
      glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, shininess0);
      glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
        paintcolor0);
      glColor3f(paintcolor0[0], paintcolor0[1], paintcolor0[2]);

      // draw geometry
      BIAS::Vector3 < float >dtea(-0.5, -0.2, 0);
      // position of the scene "modeling" matrix
      glTranslatef(dtea[0], dtea[1], dtea[2]);
      // glutteapot has strange vertex ordering for historical reasons
      glFrontFace(GL_CW);
      glutSolidTeapot(0.6);
      glFrontFace(GL_CCW);

      glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
        paintcolor1);
      glColor3f(paintcolor1[0], paintcolor1[1], paintcolor1[2]);

      glTranslatef(-2 * dtea[0], -2 * dtea[1], -2 * dtea[2]);
      glFrontFace(GL_CW);
      glutSolidTeapot(0.3);
      glFrontFace(GL_CCW);
      glTranslatef(dtea[0], dtea[1], dtea[2]);
      // back on origin

      // activate material properties: 
      glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,
        paintcolor2);
      glColor3f(paintcolor2[0], paintcolor2[1], paintcolor2[2]);

      glTranslatef(0, 0, -2);
      glutSolidSphere(0.8, 30, 60);
      glTranslatef(0, 0, 2);    // back to origin

      glTranslatef(1, 0, -3);
      glutSolidSphere(0.5, 50, 100);
      glTranslatef(-1, 0, 3);   // back to origin


      glTranslatef(0, 2, 0);
      glutSolidCube(0.7);
      glTranslatef(0, -2, 0);

      glTranslatef(0, -1, 0);
      glutSolidIcosahedron();
      glTranslatef(0, 1, 0);

      glTranslatef(0, -2.2, 0);
      glutSolidTetrahedron();
      glTranslatef(0, 2.2, 0);

      glPopMatrix();
    }
    glEndList();


    CHECK_GL_ERROR;
    initDone = true;
  };
}

/*
 *
 * this is your main entry Display routine 
 *
 */
void SimpleSceneGL::Display()
{
  if (this->pc == NULL)
    return;

  BIASASSERT(this->pc != NULL);

  static SimpleSceneGLData data;
  InitGeometry(data.dplist);
  CHECK_GL_ERROR;
  pc->DisplayClear();
  pc->DisplayCameraView();
  pc->DisplayRenderMode();

  //glutSolidCube(0.7);return;

  //pc->p_font->InitFont("Arial");

  CHECK_GL_ERROR;
  {
    //glPushAttrib(GL_CULL_FACE|GL_LIGHT0|GL_LIGHTING|GL_DEPTH_TEST );

    glColor3f(1.0, 0.5, 0.2);

    if (glIsList(data.dplist) == GL_TRUE) {
      // animation: rotate the scene (not the camera) by using global time as angle:
      // thus light and camera stay in the same place 
      {
        const float cycletime = 10.0;   // approx. sec for a full cycle
        const float angleM = fmodf(float
          (2.0 * 360.0 / cycletime *
          OpenGLCanvasBase::time),
          2.0 * 360.0);
        if (angleM <= 360.0) {
          glRotatef(angleM, 0.0, 1.0, 0.0);
        } else {
          glRotatef(angleM - 360.0, 1.0, 0.0, 0.0);
        }
      }

      //// interpolate between vertices
      //glShadeModel(GL_SMOOTH); 
      glCallList(data.dplist);

      // no interpolation between vertices
      //glTranslatef(0.3,0.2,0.2);
      //glShadeModel(GL_FLAT); 
      //glCallList(dplist);

    } else {
      BIASERR("invalid display list dplist=" << data.dplist);
    }

    pc->DisplayCoordCross();

    glColor3f(1.0f, 1.0f, 0.5f);
    //pc->p_font->PrintNormCoords("Hallo", 0.3, 0.2);

    //glPopAttrib();
  }
}