#include <Gl/glut.h>
#include <math.h>
#include <stdio.h>
#include <iostream.h>
#include <conio.h>
long gx,gy,gb,gh,gd, dx,dy,db,dh, cx,cy,cr, ccx, ccy, ccr;  // globale Variablen
void zeichne();
//------------------------------------------------------------------------------
class GeoObjekt                                                    //Basisklasse
{protected:  long x, y;
 public:                       
   GeoObjekt(long a=0, long b=0) { x=a;  y=b; cout<<" KG "; }
   void Print(void) { cout<< "GeoObjekt ("<< x<< ", "<< y<< ")"<< endl;};
   long putout_x(){ return x;}
   long putout_y(){ return y;}
}; //---------------------------------------------------------------------------
class Circle : public GeoObjekt              //wenn public, kann man g:=c machen
{ protected: long d;
  public:
   Circle( long a=0, long b=0, long c=1)   //Konstr.
   {  x=a; y=b; d=c; }
   void Print(void)
   {  cout << "Kreis ("<<x<<", "<<y<<" : "<<d<<")"<<endl;
   }
   long putout_d(){ return d;}
}; //---------------------------------------------------------------------------
class Rect: public GeoObjekt
{protected:
   long w,h;
 public:
   Rect(long a, long b, long c=1, long d=1)   //Konstr.
   {  x=a; y=b; w=c; h=d; }
   void Print(void)
   {  cout << "Rechteck ("<<x<<", "<<y<<" : "<<w<<" * "<<h<<")"<<endl;
   }
   long putout_b(){ return w;}
   long putout_h(){ return h;}
}; //----------------------------------------------------------------------main-
int main( int argc, char **argv)
{  GeoObjekt g(1,2);    Circle c(3,3,4);     Rect r(1,1,4,4);  cout<<endl;
   g.Print();           c.Print();           r.Print();        cout<<endl<<endl;
   GeoObjekt gg(2,3);   Circle cc(5,5,6);    Rect rr(5,5,3,6);  cout<<endl;
   gg.Print();          cc.Print();          rr.Print();    //         getche();
// Quadrat= r
   gx= r.putout_x();   gy= r.putout_y();   gb= r.putout_b();   gh= r.putout_h();
// Rechteck= rr
   dx=rr.putout_x();   dy=rr.putout_y();   db=rr.putout_b();   dh=rr.putout_h();
// Kreis= c
   cx= c.putout_x();   cy= c.putout_y();   cr= c.putout_d()/2;
// Kreis= cc
   ccx= cc.putout_x();   ccy= cc.putout_y();   ccr= cc.putout_d()/2;
   
  glutInit(&argc, argv);                    /* OpenGL und GLUT initialisieren */
  glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);                         /* immer */
                                  /* single=einfaches Fenster, rgb=Farbschema */

  glutInitWindowSize(350, 350);                     /* Fenster anlegen, immer */
  glutCreateWindow("Funktion");                    /* Fenster erzeugen, immer */

  glMatrixMode(GL_PROJECTION);                       /* Weltkoordinatensystem */
  gluOrtho2D(0., 20., 20., 0.);                 /* li, re, ob, unt Grenze */

  glutDisplayFunc( zeichne);                  /* Ereignishändler registrieren */
                                   /* zeichne enthält alle Zeichenanweisungen */

  glutMainLoop();     /* GLUT-Hauptschleife zur Ereignisverarbeitung aufrufen */
  return 0; 
}//-------------------------------------------------------------------------main

void zeichne()                                             /* Zeichenfunktion */
{ GLfloat x, y;
  glClearColor(1.0,1.0,1.0,1.0);                     /* Fensterinhalt löschen */
  glClear(GL_COLOR_BUFFER_BIT);                  /* Zeichenposition festlegen */
  glBegin(GL_LINE_LOOP);               /* begin warten auf Daten */
       glColor3f( 0.0,0.0,0.0);    /* Farbe setzen */
       glVertex2f( gx,    gy);         /* Position im Raum */
       glVertex2f( gx+gb, gy);         // Quadrat
       glVertex2f( gx+gb, gy+gh);
       glVertex2f( gx,    gy+gh);                         
  glEnd();
  glBegin(GL_LINE_LOOP);               // 2. Rechteck
       glVertex2f( dx,    dy);
       glVertex2f( dx+db, dy);
       glVertex2f( dx+db, dy+dh);
       glVertex2f( dx,    dy+dh);                         
  glEnd();
  glBegin(GL_LINE_STRIP);                       // unterer Halbkreis
     for( x=cx-cr; x<=cx+cr;x+=0.1)
     {  y= cy+sqrt( cr*cr-(x-cx)*(x-cx) );
        glVertex2f( x, y);
     }                        
  glEnd(); 
  glBegin(GL_LINE_STRIP);                   // oberer Halbkreis
     for( x=cx-cr; x<=cx+cr;x+=0.1)
     {  y= cy- sqrt( cr*cr-(x-cx)*(x-cx) );
        glVertex2f( x, y);
     }                       // arbeitet
  glEnd();
  glBegin(GL_LINE_STRIP);                       // 2. unterer Halbkreis
     for( x=ccx-ccr; x<=ccx+ccr;x+=0.1)
     {  y= ccy+sqrt( ccr*ccr-(x-ccx)*(x-ccx) );
        glVertex2f( x, y);
     }                        
  glEnd(); 
  glBegin(GL_LINE_STRIP);                   // 2. oberer Halbkreis
     for( x=ccx-ccr; x<=ccx+ccr;x+=0.1)
     {  y= ccy- sqrt( ccr*ccr-(x-ccx)*(x-ccx) );
        glVertex2f( x, y);
     }                       // arbeitet
  glEnd();
  glFlush();     /* damit sie tatsächlich erscheinen */
}//=============================================================================
/* GL-POINTS  GL-LINES  GL-LINE-STRIP  GL-LINE-LOOP
  GL-POLYGON  GL-QUADS  GLQUAD-STRIP  GL-TRIANGLES   */
