/********************************************************************
Zylinder-Zylinder Verschneidung IIa
Plugin für Cinema Version 8.0
(c) Jürgen Meier (www.3d-meier.de)
Version : 1.01
13.03.2004
*********************************************************************/

// Globale Variablen und Konstanten
   // Plugin ID Nummer
      const var cPluginID = 1015642;
   // Pluginname
      const var cPlugName = "Zyl-Zyl IIa";
   // Pluginhilfstext
      const var cPlugHelp = "Erzeugt eine Zylinder-Zylinder Verschneidung";
   // Objektname
      const var cObjName = "Zyl-Zyl IIa";
   // Index
      var i;
   // Koordinaten der Punkte
      var x,y,z;
   // Konstanten
      var R1=50;             // Radius 1
      var R2=30;             // Radius 2
      var a=35;
      var DR1=5;             // Delta Radius 1
      var DR2=5;             // Delta Radius 2
   // Index für die Auswahl des Obkjektes
      var OIndex;
   // Index für die Phasenverschiebung
      var PIndex;
   // Anzahl Punkte
      var N=48;
   // Breite des Menütextes
      var Breite=150;
   // Maximalwerte
      var cMaxFloat=1000000;
      var cMaxInt=100000000;
   // Objektvariable
      var qObj;
      var para;
   // Dialogvariable
      var gDial;
   // Parameter
      var t,dt;
   // Hilfsvariable
      var h;

   // 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
      var SP;            // Anzahl Punkte des Polygonobjektes
      var SQ;            // Anzahl Quadrate des Polygonobjektes
      var zz;            // Zähler
      var P1,P2,P3,P4;   // Punkte für ein Quadrat




// ******************************************************************
// 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 des Zylinder-Zylinder Verschneidung IIA
// ******************************************************************
   fPoly1(vDoc)
   {
      var vVarChanged,vBackupTags;
   // Neues Polygonobjekt erzeugen
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName(cObjName+" 1");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);
   // Parameter des Polygonobjektes berechnen
      // Anzahl Punkte des Polygonobjektes
         SP=N;

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

   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);
   // Startwerte übergeben
      dt=2*PI/N;
   // Phasenverschiebung berücksichtigen
      if (PIndex == 1) t=PI/N;
                       else t=0;
   // Punkte setzen
      // Zähler zurücksetzen
         zz=0;
      // Parameterbereich durchlaufen
         for (i=0;i<=N;i++)

         {
                 // Berechnung der Parameter
                    t=t+dt;
                 // Berechnung der Koordinaten
                    x = R2*cos(t);
                    h=a+R2*sin(t);
                    y = a+R2*sin(t);
                    z = sqrt(R1*R1-h*h);
                 // Punkte setzen
                    if (R1*R1-h*h>0.01) {
                       para->SetPoint(zz,vector(x,y,z));
                       // Zähler erhöhen
                          zz=zz+1;
                    }
         }

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

// ******************************************************************
// Funktion zur Berechnung des Zylinder-Zylinder Verschneidung IIA
// ******************************************************************
   fPoly2(vDoc)
   {
      var vVarChanged,vBackupTags;
   // Neues Polygonobjekt erzeugen
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName(cObjName+" 1");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);
   // Parameter des Polygonobjektes berechnen
      // Anzahl Punkte des Polygonobjektes
         SP=N;
   // 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;
      }

   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);
   // Startwerte übergeben
      dt=2*PI/N;
   // Phasenverschiebung berücksichtigen
      if (PIndex == 1) t=PI/N;
                       else t=0;
   // Punkte setzen
      // Zähler zurücksetzen
         zz=0;
      // Parameterbereich durchlaufen
         for (i=0;i<=N;i++)

         {
                 // Berechnung der Parameter
                    t=t+dt;
                 // Berechnung der Koordinaten
                    x = R2*cos(t);
                    h=a+R2*sin(t);
                    y = a+R2*sin(t);
                    z = -sqrt(R1*R1-h*h);
                 // Punkte setzen
                    if (R1*R1-h*h>0.01) {
                       para->SetPoint(zz,vector(x,y,z));
                       // Zähler erhöhen
                          zz=zz+1;
                    }
         }

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

// ******************************************************************
// Funktion zur Berechnung des Zylinder-Zylinder Verschneidung IIA
// ******************************************************************
   fPoly3(vDoc)
   {
      var vVarChanged,vBackupTags;
   // Neues Polygonobjekt erzeugen
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName(cObjName+" 1");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);
   // Parameter des Polygonobjektes berechnen
      // Anzahl Punkte des Polygonobjektes
         SP=N;

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

   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);
   // Startwerte übergeben
      dt=2*PI/N;
   // Phasenverschiebung berücksichtigen
      if (PIndex == 1) t=PI/N;
                       else t=0;
   // Punkte setzen
      // Zähler zurücksetzen
         zz=0;
      // Parameterbereich durchlaufen
         for (i=0;i<=N;i++)

         {
                 // Berechnung der Parameter
                    t=t+dt;
                 // Berechnung der Koordinaten
                    h=R1*sin(t)-a;
                    x = sqrt(R2*R2-h*h);
                    y = R1*sin(t);
                    z = R1*cos(t);
                 // Punkte setzen
                    if (R1*R1-h*h>0.01) {
                       para->SetPoint(zz,vector(x,y,z));
                       // Zähler erhöhen
                          zz=zz+1;
                    }
         }

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


// ******************************************************************
// Funktion zur Berechnung des Zylinder-Zylinder Verschneidung IIA
// ******************************************************************
   fPoly4(vDoc)
   {
      var vVarChanged,vBackupTags;
   // Neues Polygonobjekt erzeugen
      para=new(PolygonObject);
      if (!para) return NULL;
      para->SetName(cObjName+" 1");
      vDoc->StartUndo();
      vDoc->AddUndo(UNDO_OBJECT_NEW,para);
      vDoc->EndUndo();
      vVarChanged = new(VariableChanged);
      vBackupTags = new(BackupTags);
   // Parameter des Polygonobjektes berechnen
      // Anzahl Punkte des Polygonobjektes
         SP=N;

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

   // Objekt in die Objekthirarchie einfügen
      vDoc->InsertObject(para,NULL,NULL);
      GeEventAdd(DOCUMENT_CHANGED);
   // Startwerte übergeben
      dt=2*PI/N;
   // Phasenverschiebung berücksichtigen
      if (PIndex == 1) t=PI/N;
                       else t=0;
   // Punkte setzen
      // Zähler zurücksetzen
         zz=0;
      // Parameterbereich durchlaufen
         for (i=0;i<=N;i++)

         {
                 // Berechnung der Parameter
                    t=t+dt;
                 // Berechnung der Koordinaten
                    h=R1*sin(t)-a;
                    x = -sqrt(R2*R2-h*h);
                    y = R1*sin(t);
                    z = R1*cos(t);
                 // Punkte setzen
                    if (R1*R1-h*h>0.01) {
                       para->SetPoint(zz,vector(x,y,z));
                       // Zähler erhöhen
                          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);
   // Gruppe für die Konstanten
      AddGroupBeginV(1000,BFH_CENTER,2,"",0);
      {
         AddStaticText(0,BFH_LEFT,Breite,0," Radius R1",0);
         AddEditNumber(2000,BFH_LEFT,100,0);
         AddStaticText(0,BFH_LEFT,Breite,0," Radius R2",0);
         AddEditNumber(2001,BFH_LEFT,100,0);
         AddStaticText(0,BFH_LEFT,Breite,0," Offset a",0);
         AddEditNumber(2005,BFH_LEFT,100,0);
      }
      // Vertikal orientierte Gruppe schliessen
         AddGroupEnd();
   // Waagerechte Trennlinie
      AddSeparatorH(0);
   // Auswahl der Objekte
      AddRadioGroupH(5000,BFH_LEFT,3);
      AddItem(5000,6000,"Parameter Zylinder 1 ");
      AddItem(5000,6001,"Parameter Zylinder 2 ");
   // Waagerechte Trennlinie
      AddSeparatorH(0);
   // Phasenverschiebung
      AddCheckbox(7000,BFH_LEFT,200,0,"Phasenverschiebung");
   // Gruppe für die Parameter der Iteration
      AddGroupBeginV(1002,BFH_CENTER,2,"",0);
      {
         AddStaticText(0,BFH_LEFT,Breite,0," Anzahl N",0);
         AddEditNumber(2004,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(2000,R1,-cMaxFloat,cMaxFloat,0);
      SetFloat(2001,R2,-cMaxFloat,cMaxFloat,0);
      SetInt(2004,N,0,cMaxInt,0);
      SetFloat(2005,a,-cMaxFloat,cMaxFloat,0);
      SetItem(5000,6000);
      SetCheckbox(7000,TRUE);
      PIndex=1;
      OIndex=1;
      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 (OIndex)
                       {
                       case 1 : {
                                  fPoly3(vDoc);
                                  fPoly4(vDoc);
                                  break;
                                }
                       case 2 : {
                                  fPoly1(vDoc);
                                  fPoly2(vDoc);
                                  break;
                                }
                       }
                    }
      case 2000 : R1=GetFloat(2000);
      case 2001 : R2=GetFloat(2001);
      case 2004 : N=GetInt(2004);
      case 2005 : a=GetFloat(2005);
      case 5000 : {
                    if (GetItem(5000)==6000) OIndex=1;
                    if (GetItem(5000)==6001) OIndex=2;
                    // println(OIndex);
                       break;
                     }
      case 7000 : {
                    if (GetCheckbox(7000)) PIndex=1;
                                      else PIndex=2;
                    //println(PIndex);
                       break;
                     }
      }
      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);
}