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

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


   // Parameter des Sphericon
      var uMin = -100.0;
      var uMax = 100.0;
      var vMin;
      var vMax;
      var f = 1;
      var Nu05 = 12;
      var Nu;
      var Nv = 24;

   // Variablen für die Berechnung
      var i,j;           // Indizes für die Schleifen
      var h;             // Hilfsvariable
      var zz;            // Zähler
      var du;            // Segmentbreite u
      var dv;            // Segmentbreite v
      var SP;            // Anzahl Punkte des Polygonobjektes
      var SQ;            // Anzahl Quadrate des Polygonobjektes
      var x,y,z;         // Koordinaten eines Punktes
      var u,v;           // Parameter für die Fläche
      var P1,P2,P3,P4;   // Punkte für ein Quadrat

   // 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




// ******************************************************************
// Funktion F(x)
// ******************************************************************
F(x)
{
if (x<0) return x+100;
   else {
     return -x+100;
   }

}



// ******************************************************************
// 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 Berechnung der parametrischen Fläche
// ******************************************************************
   fPara(vDoc)
   {
      var vVarChanged,vBackupTags;
   // Neues Polygonobjekt erzeugen
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName(cObjName);
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);

   // Parameter des Polygonobjektes berechnen
      Nu=2*Nu05;
      // Anzahl Punkte des Polygonobjektes
         SP=(Nu-1)*(Nv+1)+2+(Nu-1)*(Nv-1);
      // Anzahl Quadrate des Polygonobjektes
         SQ=2*Nu*(Nv+1);

   // 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);

   // Segmentbreiten berechnen
      vMin = 0.0;
      vMax = -3.1415;
      du=(uMax-uMin)/Nu;
      dv=(vMax-vMin)/Nv;

   // Punkte setzen (linker Kegel)
      // Zähler zurücksetzen
         zz=0;
      // Parameterbereich durchlaufen
         for (i=1;i<Nu;i++)

         {
             for (j=0;j<=Nv;j++)
             {
                 // Berechnung der Parameter
                    u=uMin+i*du;
                    v=vMin+j*dv;
                 // Berechnung der Koordinaten
                    y= u;
                    x= F(u)*sin(v);
                    z= F(u)*cos(v);
                 // Punkt speichern
                    para->SetPoint(zz,vector(x*f,y*f,z*f));
                 // Zähler erhöhen
                    zz=zz+1;
             }
         }
      // Nordpol setzen
                 // Punkt speichern
                    para->SetPoint(zz,vector(0,f*100,0));
                 // Zähler erhöhen
                    zz=zz+1;
      // Südpol setzen
                 // Punkt speichern
                    para->SetPoint(zz,vector(0,-f*100,0));
                 // Zähler erhöhen
                    zz=zz+1;


   // Punkte setzen (rechter Kegel)
      // Segmentbreiten berechnen
         vMin = 0.0;
         vMax = 3.1415;
         du=(uMax-uMin)/Nu;
         dv=(vMax-vMin)/Nv;
      // Parameterbereich durchlaufen
         for (i=1;i<Nu;i++)

         {
             for (j=1;j<Nv;j++)
             {
                 // Berechnung der Parameter
                    u=uMin+i*du;
                    v=vMin+j*dv;
                 // Berechnung der Koordinaten
                    z= u;
                    x= F(u)*sin(v);
                    y= F(u)*cos(v);
                 // Punkt speichern
                    para->SetPoint(zz,vector(x*f,y*f,z*f));
                 // Zähler erhöhen
                    zz=zz+1;
             }
         }


   // Polygone setzen (linker Kegel)
      // Zähler zurücksetzen
         zz=0;
      // Schleife
         for (j=0;j<Nv;j++)
         {
             for (i=0;i<Nu-2;i++)
             {
                 // Punkte für ein Quadrat definieren
                    P1=i*(Nv+1)+j;
                    P2=i*(Nv+1)+j+1;
                    P3=(i+1)*(Nv+1)+j+1;
                    P4=(i+1)*(Nv+1)+j;
                 // Quadrat speichern
                    para->SetPolygon(zz,P4,P3,P2,P1);
                 // Zähler erhöhen
                    zz=zz+1;
             }
         }

   // Südpol schliessen (Dreiecke setzen)
      // Schleife
         for (j=0;j<Nv;j++)
         {
             // Punkte für ein Dreieck definieren
                P1=j;
                P2=j+1;
                P3=(Nu-1)*(Nv+1)+1;
             // Dreieck speichern
                para->SetPolygon(zz,P1,P2,P3,P3);
             // Zähler erhöhen
                zz=zz+1;
         }

   // Südpol schliessen (Dreiecke setzen)
      // Schleife
         for (j=0;j<Nv;j++)
         {
             // Punkte für ein Dreieck definieren
                P1=(Nu-2)*(Nv+1)+j;
                P2=(Nu-2)*(Nv+1)+j+1;
                P3= (Nu-1)*(Nv+1);
             // Dreieck speichern
                para->SetPolygon(zz,P1,P2,P3,P3);
             // Zähler erhöhen
                zz=zz+1;
         }

   // Polygone setzen (rechter Kegel)
      // Schleife
         for (j=0;j<Nv-2;j++)
         {
             for (i=0;i<Nu-2;i++)
             {
                 // Punkt Offset
                    h=(Nu-1)*(Nv+1)+2;
                 // Punkte für ein Quadrat definieren
                    P1=h+i*(Nv-1)+j;
                    P2=h+i*(Nv-1)+j+1;
                    P3=h+(i+1)*(Nv-1)+j+1;
                    P4=h+(i+1)*(Nv-1)+j;
                 // Quadrat speichern
                    para->SetPolygon(zz,P4,P3,P2,P1);
                 // Zähler erhöhen
                    zz=zz+1;
             }
         }


   // Pol 1 schliessen (Dreiecke setzen)
      // Punkt Offset
         h=(Nu-1)*(Nv+1)+2;
      // Schleife
         for (j=0;j<Nv-2;j++)
         {
             // Punkte für ein Dreieck definieren
                P1=h+j;
                P2=h+j+1;
                P3=Nu05*(Nv+1)-1;
             // Dreieck speichern
                para->SetPolygon(zz,P1,P2,P3,P3);
             // Zähler erhöhen
                zz=zz+1;
         }
      // vorletztes Dreieck
             // Punkte für ein Dreieck definieren
                P1=h;
                P2=(Nu05+1)*(Nv+1)-1;
                P3=Nu05*(Nv+1)-1;
             // Dreieck speichern
                para->SetPolygon(zz,P3,P2,P1,P1);
             // Zähler erhöhen
                zz=zz+1;
      // letztes Dreieck
             // Punkte für ein Dreieck definieren
                P1=h+Nv-2;
                P2=(Nu05-1)*(Nv+1)-1;
                P3=Nu05*(Nv+1)-1;
             // Dreieck speichern
                para->SetPolygon(zz,P3,P2,P1,P1);
             // Zähler erhöhen
                zz=zz+1;

   // Pol 2 schliessen (Dreiecke setzen)
      // Punkt Offset
         h=SP-Nv+1;
      // Schleife
         for (j=0;j<Nv-2;j++)
         {
             // Punkte für ein Dreieck definieren
                P1=h+j;
                P2=h+j+1;
                P3=(Nu05-1)*(Nv+1);
             // Dreieck speichern
                para->SetPolygon(zz,P3,P2,P1,P1);
             // Zähler erhöhen
                zz=zz+1;
         }
      // vorletztes Dreieck
             // Punkte für ein Dreieck definieren
                P1=h;
                P2=Nu05*(Nv+1);
                P3=(Nu05-1)*(Nv+1);
             // Dreieck speichern
                para->SetPolygon(zz,P1,P2,P3,P3);
             // Zähler erhöhen
                zz=zz+1;
      // letztes Dreieck
             // Punkte für ein Dreieck definieren
                P1=SP-1;
                P2=(Nu05-2)*(Nv+1);
                P3=(Nu05-1)*(Nv+1);
             // Dreieck speichern
                para->SetPolygon(zz,P3,P2,P1,P1);
             // Zähler erhöhen
                zz=zz+1;


   // Naht schliessen Teil 1 (Polygone setzen)
      // Schleife
             for (i=0;i<Nu05-2;i++)
             {
                 // Punkte für ein Quadrat definieren
                    P1=i*(Nv+1);
                    P2=(i+1)*(Nv+1);
                    P4=SP-1-(Nu05-2-i)*(Nv-1);
                    P3=SP-1-(Nu05-2-i-1)*(Nv-1);
                 // Quadrat speichern
                    para->SetPolygon(zz,P4,P3,P2,P1);
                 // Zähler erhöhen
                    zz=zz+1;
             }

   // Naht schliessen Teil 2 (Polygone setzen)
      // Schleife
             for (i=0;i<Nu05-2;i++)
             {
                 // Punkte für ein Quadrat definieren
                    P1=Nv+i*(Nv+1);
                    P2=Nv+(i+1)*(Nv+1);
                    P4=SP-1-(Nu05+i)*(Nv-1);
                    P3= SP-1-(Nu05+i+1)*(Nv-1);
                 // Quadrat speichern
                    para->SetPolygon(zz,P1,P2,P3,P4);
                 // Zähler erhöhen
                    zz=zz+1;
             }

   // Südpol schliessen (Polygone setzen)
                 // Punkte für ein Quadrat definieren
                    P1=0;
                    P2=(Nu-1)*(Nv+1)+1;
                    P3=SP-1-(Nu05-1)*(Nv-1);
                    P4=SP-1-(Nu05-2)*(Nv-1);
                 // Quadrat speichern
                    para->SetPolygon(zz,P1,P2,P3,P4);
                 // Zähler erhöhen
                    zz=zz+1;
                 // Punkte für ein Quadrat definieren
                    P1=SP-1-Nu05*(Nv-1);
                    P2= SP-1-(Nu05-1)*(Nv-1);
                    P3=(Nu-1)*(Nv+1)+1;
                    P4=Nv;
                 // Quadrat speichern
                    para->SetPolygon(zz,P1,P2,P3,P4);
                 // Zähler erhöhen
                    zz=zz+1;

   // Naht schliessen Teil 3 (Polygone setzen)
      // Schleife
             for (i=0;i<Nu05-2;i++)
             {
                 // Punkte für ein Quadrat definieren
                    P1=(Nu05+i)*(Nv+1);
                    P2=(Nu05+i+1)*(Nv+1);
                    P3=SP-(i+2)*(Nv-1);
                    P4=SP-(i+1)*(Nv-1);
                 // Quadrat speichern
                    para->SetPolygon(zz,P4,P3,P2,P1);
                 // Zähler erhöhen
                    zz=zz+1;
             }

   // Naht schliessen Teil 4 (Polygone setzen)
      // Schleife
             for (i=0;i<Nu05-2;i++)
             {
                 // Punkt Offset
                    h=(Nu-1)*(Nv+1)+2;
                 // Punkte für ein Quadrat definieren
                    P1=(Nu05+i+1)*(Nv+1)-1;
                    P2=(Nu05+i+2)*(Nv+1)-1;
                    P4=h+i*(Nv-1);
                    P3=h+(i+1)*(Nv-1);
                 // Quadrat speichern
                    para->SetPolygon(zz,P1,P2,P3,P4);
                 // Zähler erhöhen
                    zz=zz+1;
             }

   // Nordpol schliessen (Polygone setzen)
                 // Punkte für ein Quadrat definieren
                    P1=(Nu-1)*(Nv+1)-1;
                    P2=(Nu-1)*(Nv+1);
                    P3=SP-Nu05*(Nv-1);
                    P4=SP-(Nu05+1)*(Nv-1);
                 // Quadrat speichern
                    para->SetPolygon(zz,P1,P2,P3,P4);
                 // Zähler erhöhen
                    zz=zz+1;
                 // Punkte für ein Quadrat definieren
                    P1=SP-(Nu05-1)*(Nv-1);
                    P2=SP-Nu05*(Nv-1);
                    P3=(Nu-1)*(Nv+1);
                    P4=(Nu-2)*(Nv+1);
                 // Quadrat speichern
                    para->SetPolygon(zz,P1,P2,P3,P4);

   // 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);
   // Gruppe für die Parameter der Iteration
      AddGroupBeginV(1002,BFH_CENTER,2,"",0);
      {
         AddStaticText(0,BFH_LEFT,Breite,0," Skalierungsfaktor",0);
         AddEditNumber(2502,BFH_LEFT,100,0);
         AddStaticText(0,BFH_LEFT,Breite,0," Nu/2",0);
         AddEditNumber(2503,BFH_LEFT,100,0);
         AddStaticText(0,BFH_LEFT,Breite,0," Nv",0);
         AddEditNumber(2504,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");
      return TRUE;
   }

// ******************************************************************
// Deklaration der Methode Init
   MyDialog::Init()
   {
   // Startwerte setzen
      SetFloat(2502,f,-cMaxFloat,cMaxFloat,0);
      SetInt(2503,Nu05,0,cMaxInt,0);
      SetInt(2504,Nv,0,cMaxInt,0);
      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;
                         fPara(vDoc);
                      }
        case 2502 : f=GetFloat(2502);
        case 2503 : Nu05=GetInt(2503);
        case 2504 : Nv=GetInt(2504);
      }
      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);
}