/********************************************************************
BuckyPolygon
(c) Jürgen Meier (J.Meier@Dialup.Nacamar.de)
Version : 1.00
08.12.2000
*********************************************************************/


Function (doc)
{


// Punkte des Buckyballs definieren
   var P0  = vector(-20.150 , -29.442 ,  92.197);
   var P1  = vector( 20.278 , -29.442 ,  92.197);
   var P2  = vector( 32.771 ,   9.008 ,  92.197);
   var P3  = vector(  0.063 ,  32.770 ,  92.197);
   var P4  = vector(-32.633 ,   9.008 ,  92.197);
   var P5  = vector(-63.466 ,  19.058 ,  72.057);
   var P6  = vector(-39.261 , -55.758 ,  72.092);
   var P7  = vector( 39.397 , -55.758 ,  72.092);
   var P8  = vector( 63.708 ,  19.040 ,  72.116);
   var P9  = vector(  0.063 ,  65.299 ,  72.092);
   var P10 = vector( 72.073 , -45.131 ,  50.901);
   var P11 = vector( 83.923 ,  -8.744 ,  50.831);
   var P12 = vector( 63.708 ,  53.449 ,  50.855);
   var P13 = vector( 32.771 ,  75.926 ,  50.855);
   var P14 = vector(-32.633 ,  75.926 ,  50.855);
   var P15 = vector(-63.540 ,  53.449 ,  50.820);
   var P16 = vector(-83.778 ,  -8.763 ,  50.855);
   var P17 = vector(-71.959 , -45.131 ,  50.855);
   var P18 = vector(-19.056 , -83.581 ,  50.855);
   var P19 = vector( 19.154 , -83.581 ,  50.809);
   var P20 = vector(-39.261 , -90.149 ,  16.473);
   var P21 = vector(-71.959 , -66.385 ,  16.473);
   var P22 = vector( 39.427 , -90.149 ,  16.462);
   var P23 = vector( 72.136 , -66.385 ,  16.519);
   var P24 = vector( 96.414 ,   8.431 ,  16.462);
   var P25 = vector( 83.923 ,  46.882 ,  16.483);
   var P26 = vector( 20.278 ,  93.120 ,  16.473);
   var P27 = vector(-20.150 ,  93.120 ,  16.473);
   var P28 = vector(-83.875 ,  46.882 ,  16.508);
   var P29 = vector(-96.261 ,   8.431 ,  16.473);
   var P30 = vector(-20.150 , -96.362 , -16.060);
   var P31 = vector( 20.278 , -96.362 , -16.060);
   var P32 = vector( 83.923 , -50.121 , -16.060);
   var P33 = vector( 96.414 , -11.671 , -16.060);
   var P34 = vector( 72.103 ,  63.145 , -16.060);
   var P35 = vector( 39.397 ,  86.909 , -16.060);
   var P36 = vector(-71.959 ,  63.145 , -16.060);
   var P37 = vector(-39.261 ,  86.909 , -16.060);
   var P38 = vector(-83.778 , -50.121 , -16.060);
   var P39 = vector(-96.212 , -11.671 , -16.031);
   var P40 = vector( 32.771 , -79.165 , -50.489);
   var P41 = vector( 63.708 , -56.688 , -50.450);
   var P42 = vector(-63.563 , -56.688 , -50.470);
   var P43 = vector(-32.633 , -79.166 , -50.470);
   var P44 = vector(-83.790 ,   5.523 , -50.463);
   var P45 = vector(-71.959 ,  41.891 , -50.470);
   var P46 = vector(-19.056 ,  80.342 , -50.470);
   var P47 = vector( 19.184 ,  80.342 , -50.470);
   var P48 = vector( 83.923 ,   5.523 , -50.470);
   var P49 = vector( 72.103 ,  41.891 , -50.470);
   var P50 = vector(  0.065 , -68.539 , -71.707);
   var P51 = vector(-63.612 , -22.300 , -71.735);
   var P52 = vector(-39.261 ,  52.518 , -71.707);
   var P53 = vector( 39.397 ,  52.518 , -71.707);
   var P54 = vector( 63.708 , -22.298 , -71.707);
   var P55 = vector(-20.150 ,  26.202 , -91.787);
   var P56 = vector( 20.278 ,  26.202 , -91.858);
   var P57 = vector( 32.771 , -12.248 , -91.812);
   var P58 = vector(  0.065 , -36.009 , -91.812);
   var P59 = vector(-32.633 , -12.248 , -91.766);


// Leeres Objekt für den Buckyball erzeugen
   var bucky=doc->NewPolygonObject("BuckyPolygon",NULL,NULL,0,0,0,0);

// Leeres Objekt für die Fünfecke erzeugen
   var fuenf=doc->NewPolygonObject("Fünfecke",NULL,NULL,0,0,0,0);
// Objekt fuenf in Objekt bucky verschieben
   doc->MoveObject(fuenf,bucky,NULL);


  // Objekt für das Fünfeck 1 erzeugen
     var f1=doc->NewPolygonObject("Fünfeck 1",NULL,NULL,5,6,1,1);
     f1->SetPoint(0, P34);
     f1->SetPoint(1, P35);
     f1->SetPoint(2, P47);
     f1->SetPoint(3, P49);
     f1->SetPoint(4, P53);
     f1->SetEdge( 0, 0 , 1);
     f1->SetEdge( 1, 0 , 3);
     f1->SetEdge( 2, 3 , 4);
     f1->SetEdge( 3, 4 , 2);
     f1->SetEdge( 4, 2 , 1);
     f1->SetEdge( 5, 2 , 3);
     f1->SetTriangle( 0, 2, 3, 4);
     f1->SetQuadrangle(0, 3 , 2 , 1 , 0);
  // Update
     f1->UpdateObject();
  // Objekt f1 in Objekt fuenf verschieben
     doc->MoveObject(f1,fuenf,NULL);

  // Objekt für das Fünfeck 2 erzeugen
     var f2=doc->NewPolygonObject("Fünfeck 2",NULL,NULL,5,6,1,1);
     f2->SetPoint(0, P55);
     f2->SetPoint(1, P56);
     f2->SetPoint(2, P57);
     f2->SetPoint(3, P58);
     f2->SetPoint(4, P59);
     f2->SetEdge( 0, 0 , 1);
     f2->SetEdge( 1, 1 , 2);
     f2->SetEdge( 2, 2 , 3);
     f2->SetEdge( 3, 3 , 4);
     f2->SetEdge( 4, 4 , 0);
     f2->SetEdge( 5, 0 , 2);
     f2->SetTriangle( 0, 3, 1, 2);
     f2->SetQuadrangle(0, 1 , 3 , 4 , 0);
     f2->UpdateObject();
     doc->MoveObject(f2,fuenf,NULL);

  // Objekt für das Fünfeck 3 erzeugen
     var f3=doc->NewPolygonObject("Fünfeck 3",NULL,NULL,5,6,1,1);
     f3->SetPoint(0, P36);
     f3->SetPoint(1, P37);
     f3->SetPoint(2, P45);
     f3->SetPoint(3, P46);
     f3->SetPoint(4, P52);
     f3->SetEdge( 0, 0 , 1);
     f3->SetEdge( 1, 1 , 3);
     f3->SetEdge( 2, 3 , 4);
     f3->SetEdge( 3, 4 , 2);
     f3->SetEdge( 4, 2 , 0);
     f3->SetEdge( 5, 2 , 3);
     f3->SetTriangle(0, 3, 0, 1);
     f3->SetQuadrangle(0, 0 , 3 , 4 , 2);
     f3->UpdateObject();
     doc->MoveObject(f3,fuenf,NULL);

  // Objekt für das Fünfeck 4 erzeugen
     var f4=doc->NewPolygonObject("Fünfeck 4",NULL,NULL,5,6,1,1);
     f4->SetPoint(0,  P5);
     f4->SetPoint(1, P15);
     f4->SetPoint(2, P16);
     f4->SetPoint(3, P28);
     f4->SetPoint(4, P29);
     f4->SetEdge( 0, 2 , 0);
     f4->SetEdge( 1, 0 , 1);
     f4->SetEdge( 2, 1 , 3);
     f4->SetEdge( 3, 3 , 4);
     f4->SetEdge( 4, 4 , 2);
     f4->SetEdge( 5, 4 , 1);
     f4->SetTriangle( 0, 0, 4, 2);
     f4->SetQuadrangle(0, 4 , 0 , 1 , 3);
     f4->UpdateObject();
     doc->MoveObject(f4,fuenf,NULL);

  // Objekt für das Fünfeck 5 erzeugen
     var f5=doc->NewPolygonObject("Fünfeck 5",NULL,NULL,5,6,1,1);
     f5->SetPoint(0,  P6);
     f5->SetPoint(1, P17);
     f5->SetPoint(2, P18);
     f5->SetPoint(3, P20);
     f5->SetPoint(4, P21);
     f5->SetEdge( 0, 2 , 0);
     f5->SetEdge( 1, 0 , 1);
     f5->SetEdge( 2, 1 , 4);
     f5->SetEdge( 3, 4 , 3);
     f5->SetEdge( 4, 3 , 2);
     f5->SetEdge( 5, 3 , 1);
     f5->SetTriangle( 0, 0, 3, 2);
     f5->SetQuadrangle(0, 3 , 0 , 1 , 4);
     f5->UpdateObject();
     doc->MoveObject(f5,fuenf,NULL);

  // Objekt für das Fünfeck 6 erzeugen
     var f6=doc->NewPolygonObject("Fünfeck 6",NULL,NULL,5,6,1,1);
     f6->SetPoint(0,  P7);
     f6->SetPoint(1, P10);
     f6->SetPoint(2, P19);
     f6->SetPoint(3, P22);
     f6->SetPoint(4, P23);
     f6->SetEdge( 0, 1 , 0);
     f6->SetEdge( 1, 0 , 2);
     f6->SetEdge( 2, 2 , 3);
     f6->SetEdge( 3, 3 , 4);
     f6->SetEdge( 4, 4 , 1);
     f6->SetEdge( 5, 1 , 2);
     f6->SetTriangle(0, 2, 1, 0);
     f6->SetQuadrangle(0, 1 , 2 , 3 , 4);
     f6->UpdateObject();
     doc->MoveObject(f6,fuenf,NULL);

  // Objekt für das Fünfeck 7 erzeugen
     var f7=doc->NewPolygonObject("Fünfeck 7",NULL,NULL,5,6,1,1);
     f7->SetPoint(0, P32);
     f7->SetPoint(1, P33);
     f7->SetPoint(2, P41);
     f7->SetPoint(3, P48);
     f7->SetPoint(4, P54);
     f7->SetEdge( 0, 3 , 1);
     f7->SetEdge( 1, 1 , 0);
     f7->SetEdge( 2, 0 , 2);
     f7->SetEdge( 3, 2 , 4);
     f7->SetEdge( 4, 4 , 3);
     f7->SetEdge( 5, 4 , 0);
     f7->SetTriangle( 0, 4, 0, 2);
     f7->SetQuadrangle(0, 0 , 4 , 3 , 1);
     f7->UpdateObject();
     doc->MoveObject(f7,fuenf,NULL);

  // Objekt für das Fünfeck 8 erzeugen
     var f8=doc->NewPolygonObject("Fünfeck 8",NULL,NULL,5,6,1,1);
     f8->SetPoint(0, P38);
     f8->SetPoint(1, P39);
     f8->SetPoint(2, P42);
     f8->SetPoint(3, P44);
     f8->SetPoint(4, P51);
     f8->SetEdge( 0, 2 , 0);
     f8->SetEdge( 1, 0 , 1);
     f8->SetEdge( 2, 1 , 3);
     f8->SetEdge( 3, 3 , 4);
     f8->SetEdge( 4, 4 , 2);
     f8->SetEdge( 5, 2 , 1);
     f8->SetTriangle(0, 1, 2, 0);
     f8->SetQuadrangle(0, 2 , 1 , 3 , 4);
     f8->UpdateObject();
     doc->MoveObject(f8,fuenf,NULL);

  // Objekt für das Fünfeck 9 erzeugen
     var f9=doc->NewPolygonObject("Fünfeck 9",NULL,NULL,5,6,1,1);
     f9->SetPoint(0, P0);
     f9->SetPoint(1, P1);
     f9->SetPoint(2, P2);
     f9->SetPoint(3, P3);
     f9->SetPoint(4, P4);
     f9->SetEdge( 0, 0 , 1);
     f9->SetEdge( 1, 1 , 2);
     f9->SetEdge( 2, 2 , 3);
     f9->SetEdge( 3, 3 , 4);
     f9->SetEdge( 4, 4 , 0);
     f9->SetEdge( 5, 0 , 2);
     f9->SetTriangle(0, 2, 0, 1);
     f9->SetQuadrangle(0, 0 , 2 , 3 , 4);
     f9->UpdateObject();
     doc->MoveObject(f9,fuenf,NULL);

  // Objekt für das Fünfeck 10 erzeugen
     var f10=doc->NewPolygonObject("Fünfeck 10",NULL,NULL,5,6,1,1);
     f10->SetPoint(0, P8);
     f10->SetPoint(1, P11);
     f10->SetPoint(2, P12);
     f10->SetPoint(3, P24);
     f10->SetPoint(4, P25);
     f10->SetEdge( 0, 2 , 0);
     f10->SetEdge( 1, 0 , 1);
     f10->SetEdge( 2, 1 , 3);
     f10->SetEdge( 3, 3 , 4);
     f10->SetEdge( 4, 4 , 2);
     f10->SetEdge( 5, 1 , 2);
     f10->SetTriangle(0, 1, 2,  0);
     f10->SetQuadrangle(0, 2 , 1 , 3 , 4);
     f10->UpdateObject();
     doc->MoveObject(f10,fuenf,NULL);

  // Objekt für das Fünfeck 11 erzeugen
     var f11=doc->NewPolygonObject("Fünfeck 11",NULL,NULL,5,6,1,1);
     f11->SetPoint(0, P9);
     f11->SetPoint(1, P13);
     f11->SetPoint(2, P14);
     f11->SetPoint(3, P26);
     f11->SetPoint(4, P27);
     f11->SetEdge( 0, 0 , 1);
     f11->SetEdge( 1, 1 , 3);
     f11->SetEdge( 2, 3 , 4);
     f11->SetEdge( 3, 4 , 2);
     f11->SetEdge( 4, 2 , 0);
     f11->SetEdge( 5, 1 , 27);
     f11->SetTriangle(0, 4, 1, 3);
     f11->SetQuadrangle(0, 1 , 4 , 2 , 0);
     f11->UpdateObject();
     doc->MoveObject(f11,fuenf,NULL);

  // Objekt für das Fünfeck 12 erzeugen
     var f12=doc->NewPolygonObject("Fünfeck 12",NULL,NULL,5,6,1,1);
     f12->SetPoint(0, P30);
     f12->SetPoint(1, P31);
     f12->SetPoint(2, P40);
     f12->SetPoint(3, P43);
     f12->SetPoint(4, P50);
     f12->SetEdge( 0, 2 , 1);
     f12->SetEdge( 1, 1 , 0);
     f12->SetEdge( 2, 0 , 3);
     f12->SetEdge( 3, 3 , 4);
     f12->SetEdge( 4, 4 , 2);
     f12->SetEdge( 5, 0 , 2);
     f12->SetTriangle(0, 3, 1, 0);
     f12->SetQuadrangle(0, 1 , 3 , 4 , 2);
     f12->UpdateObject();
     doc->MoveObject(f12,fuenf,NULL);


// Leeres Objekt für die Sechsecke erzeugen
   var sechs=doc->NewPolygonObject("Sechsecke",NULL,NULL,0,0,0,0);
// Objekt sechs in Objekt bucky verschieben
   doc->MoveObject(sechs,bucky,NULL);


  // Objekt für das Sechseck 1 erzeugen
     var s1=doc->NewPolygonObject("Sechseck 1",NULL,NULL,6,7,0,2);
     s1->SetPoint(0, P48);
     s1->SetPoint(1, P49);
     s1->SetPoint(2, P53);
     s1->SetPoint(3, P54);
     s1->SetPoint(4, P56);
     s1->SetPoint(5, P57);
     s1->SetEdge(0, 1 , 0);
     s1->SetEdge(1, 0 , 3);
     s1->SetEdge(2, 3 , 5);
     s1->SetEdge(3, 5 , 4);
     s1->SetEdge(4, 4 , 2);
     s1->SetEdge(5, 2 , 1);
     s1->SetEdge(6, 1 , 5);
     s1->SetQuadrangle(0, 1 , 0 , 3 , 5);
     s1->SetQuadrangle(1, 5 , 4 , 2 , 1);
     s1->UpdateObject();
     doc->MoveObject(s1,sechs,NULL);

  // Objekt für das Sechseck 2 erzeugen
     var s2=doc->NewPolygonObject("Sechseck 2",NULL,NULL,6,7,0,2);
     s2->SetPoint(0, P24);
     s2->SetPoint(1, P25);
     s2->SetPoint(2, P33);
     s2->SetPoint(3, P34);
     s2->SetPoint(4, P48);
     s2->SetPoint(5, P49);
     s2->SetEdge(0, 1 , 0);
     s2->SetEdge(1, 0 , 2);
     s2->SetEdge(2, 2 , 4);
     s2->SetEdge(3, 4 , 5);
     s2->SetEdge(4, 5 , 3);
     s2->SetEdge(5, 3 , 1);
     s2->SetEdge(6, 1 , 4);
     s2->SetQuadrangle(0, 1 , 0 , 2 , 4);
     s2->SetQuadrangle(1, 4 , 5 , 3 , 1);
     s2->UpdateObject();
     doc->MoveObject(s2,sechs,NULL);

// Objekt für das Sechseck 3 erzeugen
     var s3=doc->NewPolygonObject("Sechseck 3",NULL,NULL,6,7,0,2);
     s3->SetPoint(0, P46);
     s3->SetPoint(1, P47);
     s3->SetPoint(2, P52);
     s3->SetPoint(3, P53);
     s3->SetPoint(4, P55);
     s3->SetPoint(5, P56);
     s3->SetEdge(0, 0 , 1);
     s3->SetEdge(1, 1 , 3);
     s3->SetEdge(2, 3 , 5);
     s3->SetEdge(3, 5 , 4);
     s3->SetEdge(4, 4 , 2);
     s3->SetEdge(5, 2 , 0);
     s3->SetEdge(6, 4 , 1);
     s3->SetQuadrangle(0, 1 , 3 , 5 , 4);
     s3->SetQuadrangle(1, 4 , 2 , 0 , 1);
     s3->UpdateObject();
     doc->MoveObject(s3,sechs,NULL);

// Objekt für das Sechseck 4 erzeugen
     var s4=doc->NewPolygonObject("Sechseck 4",NULL,NULL,6,7,0,2);
     s4->SetPoint(0, P12);
     s4->SetPoint(1, P13);
     s4->SetPoint(2, P25);
     s4->SetPoint(3, P26);
     s4->SetPoint(4, P34);
     s4->SetPoint(5, P35);
     s4->SetEdge(0, 1 , 0);
     s4->SetEdge(1, 0 , 2);
     s4->SetEdge(2, 2 , 4);
     s4->SetEdge(3, 4 , 5);
     s4->SetEdge(4, 5 , 3);
     s4->SetEdge(5, 3 , 1);
     s4->SetEdge(6, 2 , 3);
     s4->SetQuadrangle(0, 2 , 4 , 5 , 3);
     s4->SetQuadrangle(1, 3 , 1 , 0 , 2);
     s4->UpdateObject();
     doc->MoveObject(s4,sechs,NULL);

  // Objekt für das Sechseck 5 erzeugen
     var s5=doc->NewPolygonObject("Sechseck 5",NULL,NULL,6,7,0,2);
     s5->SetPoint(0, P10);
     s5->SetPoint(1, P11);
     s5->SetPoint(2, P23);
     s5->SetPoint(3, P24);
     s5->SetPoint(4, P32);
     s5->SetPoint(5, P33);
     s5->SetEdge(0, 1 , 0);
     s5->SetEdge(1, 0 , 2);
     s5->SetEdge(2, 2 , 4);
     s5->SetEdge(3, 4 , 5);
     s5->SetEdge(4, 5 , 3);
     s5->SetEdge(5, 3 , 1);
     s5->SetEdge(6, 0 , 5);
     s5->SetQuadrangle(0, 5 , 3 , 1 , 0);
     s5->SetQuadrangle(1, 0 , 2 , 4 , 5);
     s5->UpdateObject();
     doc->MoveObject(s5,sechs,NULL);

  // Objekt für das Sechseck 6 erzeugen
     var s6=doc->NewPolygonObject("Sechseck 6",NULL,NULL,6,7,0,2);
     s6->SetPoint(0, P2);
     s6->SetPoint(1, P3);
     s6->SetPoint(2, P8);
     s6->SetPoint(3, P9);
     s6->SetPoint(4, P12);
     s6->SetPoint(5, P13);
     s6->SetEdge(0, 0 , 2);
     s6->SetEdge(1, 2 , 4);
     s6->SetEdge(2, 4 , 5);
     s6->SetEdge(3, 5 , 9);
     s6->SetEdge(4, 3 , 1);
     s6->SetEdge(5, 1 , 0);
     s6->SetEdge(6, 1 , 4);
     s6->SetQuadrangle(0, 4 , 5 , 3 , 1);
     s6->SetQuadrangle(1, 1 , 0 , 2 , 4);
     s6->UpdateObject();
     doc->MoveObject(s6,sechs,NULL);

  // Objekt für das Sechseck 7 erzeugen
     var s7=doc->NewPolygonObject("Sechseck 7",NULL,NULL,6,7,0,2);
     s7->SetPoint(0, P1);
     s7->SetPoint(1, P2);
     s7->SetPoint(2, P7);
     s7->SetPoint(3, P8);
     s7->SetPoint(4, P10);
     s7->SetPoint(5, P11);
     s7->SetEdge(0, 4 , 5);
     s7->SetEdge(1, 5 , 3);
     s7->SetEdge(2, 3 , 1);
     s7->SetEdge(3, 1 , 0);
     s7->SetEdge(4, 0 , 2);
     s7->SetEdge(5, 2 , 4);
     s7->SetEdge(6, 0 , 5);
     s7->SetQuadrangle(0, 5 , 3 , 1 , 0);
     s7->SetQuadrangle(1, 0 , 2 , 4 , 5);
     s7->UpdateObject();
     doc->MoveObject(s7,sechs,NULL);

  // Objekt für das Sechseck 8 erzeugen
     var s8=doc->NewPolygonObject("Sechseck 8",NULL,NULL,6,7,0,2);
     s8->SetPoint(0, P3);
     s8->SetPoint(1, P4);
     s8->SetPoint(2, P5);
     s8->SetPoint(3, P9);
     s8->SetPoint(4, P14);
     s8->SetPoint(5, P15);
     s8->SetEdge(0, 1 , 0);
     s8->SetEdge(1, 0 , 3);
     s8->SetEdge(2, 3 , 4);
     s8->SetEdge(3, 4 , 5);
     s8->SetEdge(4, 5 , 2);
     s8->SetEdge(5, 2 , 1);
     s8->SetEdge(6, 0 , 5);
     s8->SetQuadrangle(0, 0 , 3 , 4 , 5);
     s8->SetQuadrangle(1, 5 , 2 , 1 , 0);
     s8->UpdateObject();
     doc->MoveObject(s8,sechs,NULL);

  // Objekt für das Sechseck 9 erzeugen
     var s9=doc->NewPolygonObject("Sechseck 9",NULL,NULL,6,7,0,2);
     s9->SetPoint(0, P0);
     s9->SetPoint(1, P1);
     s9->SetPoint(2, P6);
     s9->SetPoint(3, P7);
     s9->SetPoint(4, P18);
     s9->SetPoint(5, P19);
     s9->SetEdge(0, 5 , 3);
     s9->SetEdge(1, 3 , 1);
     s9->SetEdge(2, 1 , 0);
     s9->SetEdge(3, 0 , 2);
     s9->SetEdge(4, 2 , 4);
     s9->SetEdge(5, 4 , 5);
     s9->SetEdge(6, 0 , 5);
     s9->SetQuadrangle(0, 5 , 3 , 1 , 0);
     s9->SetQuadrangle(1, 0 , 2 , 4 , 5);
     s9->UpdateObject();
     doc->MoveObject(s9,sechs,NULL);

  // Objekt für das Sechseck 10 erzeugen
     var s10=doc->NewPolygonObject("Sechseck 10",NULL,NULL,6,7,0,2);
     s10->SetPoint(0, P0);
     s10->SetPoint(1, P4);
     s10->SetPoint(2, P5);
     s10->SetPoint(3, P6);
     s10->SetPoint(4, P16);
     s10->SetPoint(5, P17);
     s10->SetEdge(0, 0 , 1);
     s10->SetEdge(1, 1 , 2);
     s10->SetEdge(2, 2 , 4);
     s10->SetEdge(3, 4 , 5);
     s10->SetEdge(4, 5 , 3);
     s10->SetEdge(5, 3 , 0);
     s10->SetEdge(6, 0 , 4);
     s10->SetQuadrangle(0, 0 , 1 , 2 , 4);
     s10->SetQuadrangle(1, 4 , 5 , 3 , 0);
     s10->UpdateObject();
     doc->MoveObject(s10,sechs,NULL);

  // Objekt für das Sechseck 11 erzeugen
     var s11=doc->NewPolygonObject("Sechseck 11",NULL,NULL,6,7,0,2);
     s11->SetPoint(0, P16);
     s11->SetPoint(1, P17);
     s11->SetPoint(2, P21);
     s11->SetPoint(3, P29);
     s11->SetPoint(4, P38);
     s11->SetPoint(5, P39);
     s11->SetEdge(0, 1 , 0);
     s11->SetEdge(1, 0 , 3);
     s11->SetEdge(2, 3 , 5);
     s11->SetEdge(3, 5 , 4);
     s11->SetEdge(4, 4 , 2);
     s11->SetEdge(5, 2 , 1);
     s11->SetEdge(6, 1 , 5);
     s11->SetQuadrangle(0, 1 , 0 , 3 , 5);
     s11->SetQuadrangle(1, 5 , 4 , 2 , 1);
     s11->UpdateObject();
     doc->MoveObject(s11,sechs,NULL);

  // Objekt für das Sechseck 12 erzeugen
     var s12=doc->NewPolygonObject("Sechseck 12",NULL,NULL,6,7,0,2);
     s12->SetPoint(0, P28);
     s12->SetPoint(1, P29);
     s12->SetPoint(2, P36);
     s12->SetPoint(3, P39);
     s12->SetPoint(4, P44);
     s12->SetPoint(5, P45);
     s12->SetEdge(0, 0 , 2);
     s12->SetEdge(1, 2 , 5);
     s12->SetEdge(2, 5 , 4);
     s12->SetEdge(3, 4 , 3);
     s12->SetEdge(4, 3 , 1);
     s12->SetEdge(5, 1 , 0);
     s12->SetEdge(6, 1 , 5);
     s12->SetQuadrangle(0, 5 , 4 , 3 , 1);
     s12->SetQuadrangle(1, 1 , 0 , 2 , 5);
     s12->UpdateObject();
     doc->MoveObject(s12,sechs,NULL);

  // Objekt für das Sechseck 13 erzeugen
     var s13=doc->NewPolygonObject("Sechseck 13",NULL,NULL,6,7,0,2);
     s13->SetPoint(0, P20);
     s13->SetPoint(1, P21);
     s13->SetPoint(2, P30);
     s13->SetPoint(3, P38);
     s13->SetPoint(4, P42);
     s13->SetPoint(5, P43);
     s13->SetEdge(0, 2 , 0);
     s13->SetEdge(1, 0 , 1);
     s13->SetEdge(2, 1 , 3);
     s13->SetEdge(3, 3 , 4);
     s13->SetEdge(4, 4 , 5);
     s13->SetEdge(5, 5 , 2);
     s13->SetEdge(6, 2 , 3);
     s13->SetQuadrangle(0, 2 , 0 , 1 , 3);
     s13->SetQuadrangle(1, 3 , 4 , 5 , 2);
     s13->UpdateObject();
     doc->MoveObject(s13,sechs,NULL);

  // Objekt für das Sechseck 14 erzeugen
     var s14=doc->NewPolygonObject("Sechseck 14",NULL,NULL,6,7,0,2);

     s14->SetPoint(0, P44);
     s14->SetPoint(1, P45);
     s14->SetPoint(2, P51);
     s14->SetPoint(3, P52);
     s14->SetPoint(4, P55);
     s14->SetPoint(5, P59);
     s14->SetEdge(0, 0 , 1);
     s14->SetEdge(1, 1 , 3);
     s14->SetEdge(2, 3 , 4);
     s14->SetEdge(3, 4 , 5);
     s14->SetEdge(4, 5 , 2);
     s14->SetEdge(5, 2 , 0);
     s14->SetEdge(6, 0 , 4);
     s14->SetQuadrangle(0, 0 , 1 , 3 , 4);
     s14->SetQuadrangle(1, 4 , 5 , 2 , 0);
     s14->UpdateObject();
     doc->MoveObject(s14,sechs,NULL);

  // Objekt für das Sechseck 15 erzeugen
     var s15=doc->NewPolygonObject("Sechseck 15",NULL,NULL,6,7,0,2);
     s15->SetPoint(0, P42);
     s15->SetPoint(1, P43);
     s15->SetPoint(2, P50);
     s15->SetPoint(3, P51);
     s15->SetPoint(4, P58);
     s15->SetPoint(5, P59);
     s15->SetEdge(0, 2 , 1);
     s15->SetEdge(1, 1 , 0);
     s15->SetEdge(2, 0 , 3);
     s15->SetEdge(3, 3 , 5);
     s15->SetEdge(4, 5 , 4);
     s15->SetEdge(5, 4 , 2);
     s15->SetEdge(6, 1 , 5);
     s15->SetQuadrangle(0, 1 , 0 , 3 , 5);
     s15->SetQuadrangle(1, 5 , 4 , 2 , 1);
     s15->UpdateObject();
     doc->MoveObject(s15,sechs,NULL);

  // Objekt für das Sechseck 16 erzeugen
     var s16=doc->NewPolygonObject("Sechseck 16",NULL,NULL,6,7,0,2);
     s16->SetPoint(0, P40);
     s16->SetPoint(1, P41);
     s16->SetPoint(2, P50);
     s16->SetPoint(3, P54);
     s16->SetPoint(4, P57);
     s16->SetPoint(5, P58);
     s16->SetEdge(0, 3 , 1);
     s16->SetEdge(1, 1 , 0);
     s16->SetEdge(2, 0 , 2);
     s16->SetEdge(3, 2 , 5);
     s16->SetEdge(4, 5 , 4);
     s16->SetEdge(5, 4 , 3);
     s16->SetEdge(6, 2 , 3);
     s16->SetQuadrangle(0, 2 , 5 , 4 , 3);
     s16->SetQuadrangle(1, 3 , 1 , 0 , 2);
     s16->UpdateObject();
     doc->MoveObject(s16,sechs,NULL);

  // Objekt für das Sechseck 17 erzeugen
     var s17=doc->NewPolygonObject("Sechseck 17",NULL,NULL,6,7,0,2);
     s17->SetPoint(0, P26);
     s17->SetPoint(1, P27);
     s17->SetPoint(2, P35);
     s17->SetPoint(3, P37);
     s17->SetPoint(4, P46);
     s17->SetPoint(5, P47);
     s17->SetEdge(0, 1 , 0);
     s17->SetEdge(1, 0 , 2);
     s17->SetEdge(2, 2 , 5);
     s17->SetEdge(3, 5 , 4);
     s17->SetEdge(4, 4 , 3);
     s17->SetEdge(5, 3 , 1);
     s17->SetEdge(6, 0 , 4);
     s17->SetQuadrangle(0, 0 , 2 , 5 , 4);
     s17->SetQuadrangle(1, 4 , 3 , 1 , 0);
     s17->UpdateObject();
     doc->MoveObject(s17,sechs,NULL);

  // Objekt für das Sechseck 18 erzeugen
     var s18=doc->NewPolygonObject("Sechseck 18",NULL,NULL,6,7,0,2);
     s18->SetPoint(0, P14);
     s18->SetPoint(1, P15);
     s18->SetPoint(2, P27);
     s18->SetPoint(3, P28);
     s18->SetPoint(4, P36);
     s18->SetPoint(5, P37);
     s18->SetEdge(0, 1 , 0);
     s18->SetEdge(1, 0 , 2);
     s18->SetEdge(2, 2 , 5);
     s18->SetEdge(3, 5 , 4);
     s18->SetEdge(4, 4 , 3);
     s18->SetEdge(5, 3 , 1);
     s18->SetEdge(6, 0 , 4);
     s18->SetQuadrangle(0, 0 , 2 , 5 , 4);
     s18->SetQuadrangle(1, 4 , 3 , 1 , 0);
     s18->UpdateObject();
     doc->MoveObject(s18,sechs,NULL);

  // Objekt für das Sechseck 19 erzeugen
     var s19=doc->NewPolygonObject("Sechseck 19",NULL,NULL,6,7,0,2);
     s19->SetPoint(0, P22);
     s19->SetPoint(1, P23);
     s19->SetPoint(2, P31);
     s19->SetPoint(3, P32);
     s19->SetPoint(4, P40);
     s19->SetPoint(5, P41);
     s19->SetEdge(0, 3 , 1);
     s19->SetEdge(1, 1 , 0);
     s19->SetEdge(2, 0 , 2);
     s19->SetEdge(3, 2 , 4);
     s19->SetEdge(4, 4 , 5);
     s19->SetEdge(5, 5 , 3);
     s19->SetEdge(6, 0 , 5);
     s19->SetQuadrangle(0, 0 , 2 , 4 , 5);
     s19->SetQuadrangle(1, 5 , 3 , 1 , 0);
     s19->UpdateObject();
     doc->MoveObject(s19,sechs,NULL);

// Objekt für das Sechseck 20 erzeugen
     var s20=doc->NewPolygonObject("Sechseck 20",NULL,NULL,6,7,0,2);
     s20->SetPoint(0, P18);
     s20->SetPoint(1, P19);
     s20->SetPoint(2, P20);
     s20->SetPoint(3, P22);
     s20->SetPoint(4, P30);
     s20->SetPoint(5, P31);
     s20->SetEdge(0, 3 , 1);
     s20->SetEdge(1, 1 , 0);
     s20->SetEdge(2, 0 , 2);
     s20->SetEdge(3, 2 , 4);
     s20->SetEdge(4, 4 , 5);
     s20->SetEdge(5, 5 , 3);
     s20->SetEdge(6, 0 , 5);
     s20->SetQuadrangle(0, 5 , 3 , 1 , 0);
     s20->SetQuadrangle(1, 0 , 2 , 4 , 5);
     s20->UpdateObject();
     doc->MoveObject(s20,sechs,NULL);


// Objekt aktivieren
   doc->ActivateObject(bucky);


// Refresh
   doc->SendMessage(DOCUMENT_CHANGED);


}

main()

{


RegisterMenuHook("BuckyPolygon","Function");

}