/********************************************************************
Sierpinski Zufall
Plugin für Cinema Version 8.0
(c) Jürgen Meier (www.3d-meier.de)
Version : 1.00
30.09.2004
*********************************************************************/

// Globale Variablen und Konstanten
   // Plugin ID Nummer
      const var cPluginID = 1016495;
   // Pluginname
      const var cPlugName = "Sierpinski Zufall";
   // Pluginhilfstext
      const var cPlugHelp = "Erzeugt das Sierpinski Dreieck";
   // Breite des Menütextes
      var Breite=200;
   // Maximalwerte
      var cMaxFloat=10000000000;
      var cMaxInt=100000000;
   // Objektvariable
      var para;
   // Dialogvariable
      var gDial;

   // Variablen für die Berechnung
      var i,j;           // Indizes für die Schleifen
      var zz;            // Zähler
      var SP;            // Anzahl Punkte des Polygonobjektes
      var SQ;            // Anzahl Quadrate des Polygonobjektes
      var x,y,z;         // Koordinaten eines Punktes
      var N=10000;       // Anzahl Punkte
      var Zufall;        // Zufallszahl
      var Aktuell;       // Aktueller Punkt
      var Neu;           // Neuer Punkt
      var Eck;           // Auswahl des n-Ecks
      var Dx,Dy;         // Punktgröße
      var D=0.5;         // Punktgröße

   // Variablen für das Polygonobjekt
      var vObj,
      vSP,               // Anzahl der Punkte
      vPointAry,         // Array für die Punkte
      vSQ,               // Anzahl der Polygone
      vPolyAry;          // Array für die Polygone

   // Variablen für die verschiedenen n-Ecke
      var Dreieck,Viereck,Fuenfeck,Sechseck,Siebeneck,Achteck,Neuneck;


// ******************************************************************
// Funktion zum Objekt aktivieren (c) h.g.seib
// ******************************************************************
   fSetActiveObject(vDoc,vObj)
   {

   // Aktives Objekt ermitteln
      var vAObj = GetActiveObject(vDoc);
   // Active object Bit bzw. Flag setzen
      if (vAObj) vAObj->DelBit(BIT_AOBJ);
          vObj->SetBit(BIT_AOBJ);
   // Änderung im Dokument bekanngeben (neues Objekt selektiert)
      GeEventAdd(NEW_ACTIVE_OBJECT);
   }


// ******************************************************************
// Funktion zur Erzeugung des Dreiecks
// ******************************************************************
   fDreieck(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Sierpinski Dreieck");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Dreieck erzeugen
      Dreieck = new(array,3);
      Dreieck[0]=vector(0,600,0);
      Dreieck[1]=vector(-519.615,-300,0);
      Dreieck[2]=vector(519.615,-300,0);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=int(random->Get01() * 3);
           // Neuen Punkt berechnen
              Neu=(Aktuell + Dreieck[Zufall])/2;
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
           // Punkt aktualisieren
              Aktuell=Neu;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }

// ******************************************************************
// Funktion zur Erzeugung des Vierecks
// ******************************************************************
   fViereck(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Viereck");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Fünfeck erzeugen
      Fuenfeck = new(array,4);
      Fuenfeck[0]=vector(424.264,-424.264,0);
      Fuenfeck[1]=vector(424.264,424.264,0);
      Fuenfeck[2]=vector(-424.264,424.264,0);
      Fuenfeck[3]=vector(-424.264,-424.264,0);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=int(random->Get01() * 4);
           // Neuen Punkt berechnen
              Neu=(Aktuell + Fuenfeck[Zufall])/2;
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
           // Punkt aktualisieren
              Aktuell=Neu;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }


// ******************************************************************
// Funktion zur Erzeugung des Fünfecks
// ******************************************************************
   fFuenfeck(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Fünfeck");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Fünfeck erzeugen
      Fuenfeck = new(array,5);
      Fuenfeck[0]=vector(570.634,185.41,0);
      Fuenfeck[1]=vector(0,600,0);
      Fuenfeck[2]=vector(-570.634,185.41,0);
      Fuenfeck[3]=vector(-352.671,-485.41,0);
      Fuenfeck[4]=vector(352.671,-485.41,0);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=int(random->Get01() * 5);
           // Neuen Punkt berechnen
              Neu=(Aktuell + Fuenfeck[Zufall])/2;
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
           // Punkt aktualisieren
              Aktuell=Neu;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }


// ******************************************************************
// Funktion zur Erzeugung des Sechsecks
// ******************************************************************
   fSechseck(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Sechseck");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Sechseck erzeugen
      Sechseck = new(array,6);
      Sechseck[0]=vector(600,0,0);
      Sechseck[1]=vector(300,519.615,0);
      Sechseck[2]=vector(-300,519.615,0);
      Sechseck[3]=vector(-600,0,0);
      Sechseck[4]=vector(-300,-519.615,0 );
      Sechseck[5]=vector(300,-519.615,0);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=int(random->Get01() * 6);
           // Neuen Punkt berechnen
              Neu=(Aktuell + Sechseck[Zufall])/2;
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
           // Punkt aktualisieren
              Aktuell=Neu;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }


// ******************************************************************
// Funktion zur Erzeugung des Siebenecks
// ******************************************************************
   fSiebeneck(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Siebeneck");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Siebeneck erzeugen
      Siebeneck = new(array,7);
      Siebeneck[0]=vector(584.957,-133.511,0);
      Siebeneck[1]=vector(469.098,374.095,0);
      Siebeneck[2]=vector(0,600,0);
      Siebeneck[3]=vector(-469.1,374.093,0);
      Siebeneck[4]=vector(-584.956,-133.514,0);
      Siebeneck[5]=vector(-260.329,-540.582,0);
      Siebeneck[6]=vector(260.332,-540.581,0);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=int(random->Get01() * 7);
           // Neuen Punkt berechnen
              Neu=(Aktuell + Siebeneck[Zufall])/2;
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
           // Punkt aktualisieren
              Aktuell=Neu;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }


// ******************************************************************
// Funktion zur Erzeugung des Achtecks
// ******************************************************************
   fAchteck(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Achteck");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Achteck erzeugen
      Achteck = new(array,8);
      Achteck[0]=vector(554.328,-229.61,0);
      Achteck[1]=vector(554.328,229.61,0);
      Achteck[2]=vector(229.61,554.328,0);
      Achteck[3]=vector(-229.61,554.328,0);
      Achteck[4]=vector(-554.328,229.61,0);
      Achteck[5]=vector(-554.328,-229.61,0 );
      Achteck[6]=vector(-229.61,-554.328,0);
      Achteck[7]=vector(229.61,-554.328,0);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=int(random->Get01() * 8);
           // Neuen Punkt berechnen
              Neu=(Aktuell + Achteck[Zufall])/2;
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
           // Punkt aktualisieren
              Aktuell=Neu;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }


// ******************************************************************
// Funktion zur Erzeugung des Neunecks
// ******************************************************************
   fNeuneck(vDoc)
   {
   // Neues Polygonobjekt erzeugen
      var vVarChanged,vBackupTags;
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName("Neuneck");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes
      // Anzahl Quadrate des Polygonobjektes
         SQ=N;
      // Anzahl Punkte des Polygonobjektes
         SP=4*SQ;

   // Anzahl Punkte festlegen
      vPointAry = new(array, SP);
      para->SetPoints(vPointAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SP);
      if (!para->Message(MSG_POINTS_CHANGED, vVarChanged))
      {vBackupTags->Restore();
         return NULL;
      }

   // Anzahl Polygone festlegen
      vPolyAry = new(array, SQ*4);
      para->SetPolygons(vPolyAry);
      vBackupTags->Init(para);
      vVarChanged->Init(0, SQ);
      if (!para->Message(MSG_POLYGONS_CHANGED, vVarChanged))
      { vBackupTags->Restore();
         return NULL;
      }
   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);

   // Zufallszahl initialisieren
      var random = new(Random);
      random->Init(8374946);

   // Achteck erzeugen
      Neuneck = new(array,9);
      Neuneck[0]=vector(590.885,104.189,0);
      Neuneck[1]=vector(385.673,459.627,0);
      Neuneck[2]=vector(0,600,0);
      Neuneck[3]=vector(-385.673,459.627,0);
      Neuneck[4]=vector(-590.885,104.189,0);
      Neuneck[5]=vector(-519.615,-300,0);
      Neuneck[6]=vector(-205.212,-563.815,0);
      Neuneck[7]=vector(205.212,-563.815,0);
      Neuneck[8]=vector(519.615,-300,0);

   // Punktgröße
      Dx= vector(D,0,0);
      Dy= vector(0,D,0);

   // Punkte setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
           // Zufallszahl ermitteln
              Zufall=int(random->Get01() * 9);
           // Neuen Punkt berechnen
              Neu=(Aktuell + Neuneck[Zufall])/2;
           // Punkte setzten
              para->SetPoint(zz,Neu-Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx-Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu+Dx+Dy);
              zz=zz+1;
              para->SetPoint(zz,Neu-Dx+Dy);
              zz=zz+1;
           // Punkt aktualisieren
              Aktuell=Neu;
          }

   // Polygone setzen
      zz=0;
      for (i=0;i<SQ;i++)
          {
            para->SetPolygon(zz,i*4+0,i*4+1,i*4+2,i*4+3);
            zz=zz+1;
          }

   // Objekt aktivieren
      fSetActiveObject(vDoc,para);
      GeEventAdd(DOCUMENT_CHANGED);
      para->Message(MSG_UPDATE);
    return TRUE;
   }


// ******************************************************************
// Ableitung der Klasse MyDialog von GeDialog
// ******************************************************************
class MyDialog : GeDialog
{
   public:
      MyDialog();
      CreateLayout();
      Init();
      CoreMessage(vID,vMSG);
      Command(vID,vMSG);
}
// ******************************************************************
// Deklaration des Konstruktors
   MyDialog::MyDialog()
   {
   // Konstruktor der parent class aufrufen
      super(cPluginID);
   }

// ******************************************************************
// Deklaration der Methode CreateLayout
   MyDialog::CreateLayout()
   {     
   // Plugintitel setzen
      SetTitle(cPlugName);
   // Auswahl des n-Ecks
      AddComboBox(9000,BFH_LEFT,300,0);
      AddItem(9000,9010,"Dreieck");
      AddItem(9000,9011,"Viereck");
      AddItem(9000,9012,"Fünfeck");
      AddItem(9000,9013,"Sechseck");
      AddItem(9000,9014,"Siebeneck");
      AddItem(9000,9015,"Achteck");
      AddItem(9000,9016,"Neuneck");
   // Waagerechte Trennlinie
      AddSeparatorH(0);
   // Gruppe für die Parameter der Berechnung
      AddGroupBeginV(1002,BFH_CENTER,2,"",0);
      {
         AddStaticText(0,BFH_LEFT,Breite,0," Anzahl Punkte",0);
         AddEditNumber(2000,BFH_LEFT,100,0);
         AddStaticText(0,BFH_LEFT,Breite,0," Punktgröße",0);
         AddEditNumber(2001,BFH_LEFT,100,0);
      }
      // Vertikal orientierte Gruppe schliessen
         AddGroupEnd();
   // Waagerechte Trennlinie
      AddSeparatorH(0);
   // Button für den Start der Berechnung
      AddButton (3000,BFH_CENTER,200,0,"Start");
   // Waagerechte Trennlinie
      AddSeparatorH(0);
   // Impressum
      AddStaticText(0,BFH_CENTER,Breite,0," (c) 2004 Jürgen Meier",0);
      AddStaticText(0,BFH_CENTER,Breite,0," www.3d-meier.de",0);
      return TRUE;
   }

// ******************************************************************
// Deklaration der Methode Init
   MyDialog::Init()
   {
   // Startwerte setzen
      SetInt(2000,N,1,cMaxInt,1);
      SetFloat(2001,D,0,cMaxFloat,0);
   // Startpunkt
      Aktuell= vector(0,0,0);
   // n_Eck auswählen
      SetItem(9000,9010);
      return TRUE;
   }

// ******************************************************************
// Deklaration der Methode CoreMessage
   MyDialog::CoreMessage(vID,vMSG)
   {
      switch (vID)
         {
            case NEW_DOCUMENT:
            case DOCUMENT_CHANGED:
            case NEW_ACTIVE_OBJECT:
            case ACTIVE_OBJECT_CHANGED:
            return TRUE;
            break;
         }
      return FALSE;
   }

// ******************************************************************
// Deklaration der Methode Command
   MyDialog::Command(vID,vMSG)
   {
      var vDoc;
   //
      StopAllThreads();
      switch (vID)
      {
        case 3000 : // Start Button gedrückt
                      {
                         vDoc = GetActiveDocument();
                         if (!vDoc) return FALSE;

                         switch (Eck)
                         {
                            case 0 : { fDreieck(vDoc);   break; }
                            case 1 : { fViereck(vDoc);   break; }
                            case 2 : { fFuenfeck(vDoc);  break; }
                            case 3 : { fSechseck(vDoc);  break; }
                            case 4 : { fSiebeneck(vDoc); break; }
                            case 5 : { fAchteck(vDoc);   break; }
                            case 6 : { fNeuneck(vDoc);   break; }
                         }
                      }

        case 9000 : {
                       if (GetItem(9000)==9010) { Eck=0; }
                       if (GetItem(9000)==9011) { Eck=1; }
                       if (GetItem(9000)==9012) { Eck=2; }
                       if (GetItem(9000)==9013) { Eck=3; }
                       if (GetItem(9000)==9014) { Eck=4; }
                       if (GetItem(9000)==9015) { Eck=5; }
                       if (GetItem(9000)==9016) { Eck=6; }
                    }

        case 2000 : N=GetInt(2000);
        case 2001 : D=GetFloat(2001);

      }
      return TRUE;
   }


// ******************************************************************
// Ableitung der Klasse MyMenuPlugin von MenuPlugin
// ******************************************************************
   class MyMenuPlugin : MenuPlugin
   {  public:
          MyMenuPlugin();
          GetID();
          GetName();
          GetHelp();
          Execute(doc);
          RestoreLayout(secret);
   }
// ******************************************************************
// Deklaration des Konstruktors
   MyMenuPlugin::MyMenuPlugin()
   { 
      super();
   }

// ******************************************************************
// Deklaration der Methode GetID
   MyMenuPlugin::GetID()
   {
      return cPluginID;
   }

// ******************************************************************
// Deklaration der Methode GetName
   MyMenuPlugin::GetName()
   {
       return cPlugName;
   }

// ******************************************************************
// Deklaration der Methode GetHelp
   MyMenuPlugin::GetHelp()
   {
       return cPlugHelp;
   }

// ******************************************************************
// Deklaration der Methode Execute
   MyMenuPlugin::Execute(doc)
   {
      if (!gDial)
         gDial=new(MyDialog);
     gDial->Open(TRUE,-1,-1);
   }
// ******************************************************************
// Deklaration der Methode RestoreLayout
   MyMenuPlugin::RestoreLayout(secret)
   {
      if (!gDial)
         gDial=new(MyDialog);
      gDial->RestoreLayout(secret);
   }

// ******************************************************************
main()
{
   Register(MyMenuPlugin);
}