#declare No_Lights=
finish
{
   ambient 1
   diffuse 0
}


plane
{
   y, 0
   texture
   {
      pigment
      {
         color rgb 1
      }
      finish { No_Lights }
   }
}
   
#declare n=50; // Anzahl der Würfel

#declare xsize=5; // Breite des (rechteckigen) Platzierungsfeldes
#declare zsize=5; // Länge des Platzierungsfeldes

#if (xsize > zsize)           // Ermittlung der längeren Seite des Platzierungsfeldes
  #declare high=xsize;
  #else #declare high=zsize;
#end

#declare offsx=-2; // x-Koordinate der südwestlichen Ecke des Platzierungsbereiches
#declare offsy=0;  // y-Koordinate der südwestlichen Ecke des Platzierungsbereiches
#declare offsz=3;  // z-Koordinate der südwestlichen Ecke des Platzierungsbereiches

#declare maxerr=50; // Anzahl der maximal erlaubten Koordinatenzuweisungs-Versuche pro Objekt
                    // (Überschreitung führt zum Programmende, auch wenn nicht alle Objekte
                    // platziert wurden)

#declare a=0; // Zählervariable für Würfel

#declare p=seed(400); // Ausgangswert für Zufallszahlengenerierung


#declare objs=array[n][4] // Array für Würfel-Ecken
#declare objs_s=array[n] // Array für Würfel-Größen
   
#declare s_min=0.2; // kleinste erlaubte Würfelgröße
#declare s_max=0.4;  // größte erlaubte Würfelgröße
#declare s_scope=s_max-s_min; // Größe des Würfelgrößen-Bereichs
 

#declare w=(xsize+zsize)/200; // Breite des Rahmens für den Platzierungsbereich

#declare offst=<offsx, offsy, offsz>;
                         
union
{
  box { offst-<w/2, 0, w/2>, offst+<w/2, 0.01, zsize+w/2> }
  box { offst+<-w/2, 0, zsize-w/2>, offst+<xsize+w/2, 0.01, zsize+w/2> }
  box { offst-<w/2, 0, w/2>, offst+<xsize+w/2, 0.01, w/2> }
  box { offst+<xsize-w/2, 0, -w/2>, offst+<xsize+w/2, 0.01, zsize+w/2> }
  texture
  {
     pigment { color rgb <0, 0, 1> }
     finish { No_Lights } 
  }
} 
                     // Kollisions-Flag: 0 = keine Kollision, 1 = Kollision
                     // wird mit 1 initialisiert, damit Schleife zur Koordinatenzuweisung
                     // wenigstens einmal durchlaufen werden kann
                     // (in PoV-Ray gibt es KEINE "fußgesteuerten" do...while-Schleifen!)

#declare c=0; // Zähler für Zuweisungsversuche; wird um 1 erhöht, wenn Versuch erfolglos   
#while (a<n & c<maxerr)   
  #declare cflag=1;                 
  #if (a=0)
    #declare eflag=1;
    #declare try=0;
    #while (eflag=1)
      #declare objs_s[a]=s_min+rand(p)*s_scope;
      #declare objs[a][0]=offsx+rand(p)*xsize; // Definition der linken unteren vorderen Ecke, x-Wert
      #declare objs[a][1]=offsz+rand(p)*zsize; // Definition der linken unteren vorderen Ecke, z-Wert
      #declare objs[a][2]=objs[a][0]+objs_s[a];
      #declare objs[a][3]=objs[a][1]+objs_s[a];
      #if (objs[a][2]<=offsx+xsize & objs[a][3]<=offsz+zsize)
        #declare eflag=0;
      #end 
      #declare try=try+1;
      #warning concat(str(try, 1, 0), ". Platzierungsversuch fuer ersten Wuerfel!")
    #end 
    #else
      #declare cflag=1;
      #while (cflag=1)
        #declare eflag=1;
        #declare try=0;
        #while (eflag=1)
          #declare objs_s[a]=s_min+rand(p)*s_scope;
          #declare objs[a][0]=offsx+rand(p)*xsize; // Definition der linken unteren vorderen Ecke, x-Wert
          #declare objs[a][1]=offsz+rand(p)*zsize; // Definition der linken unteren vorderen Ecke, z-Wert
          #declare objs[a][2]=objs[a][0]+objs_s[a];
          #declare objs[a][3]=objs[a][1]+objs_s[a];
          #if (objs[a][2]<=offsx+xsize & objs[a][3]<=offsz+zsize)
            #declare eflag=0;
          #end 
          #declare try=try+1;
          #warning concat(str(try, 1, 0), ". Platzierungsversuch fuer ", str(a+1, 1, 0), ". Wuerfel!")
        #end 
        // #declare cflag2=1; 
        #declare b=0; // interne Zählervariable für die Testschleife
        #while (b<a & cflag=1)
           #if   ((((objs[b][0]<objs[a][0]) & (objs[a][0]<objs[b][2])) & ((objs[b][1]<objs[a][1])  & (objs[a][1]<objs[b][3])))
               | (((objs[b][0]<objs[a][2]) & (objs[a][2]<objs[b][2])) & ((objs[b][1]<objs[a][3]) & (objs[a][3]<objs[b][3]))))
              #warning "Error! Cubes overlapping!"            
                #declare c=c+1;                  // Abbruchkriterium: falls der Abstand des aktuellen
               // #declare cflag2=1;               // Koordinatentripels zu irgendeinem bereits gesetzten 
           #else
              #declare cflag=0;
              #declare c=0;
           #end                                // Tripel kleiner ist als die Summe der Radien des jeweiligen Kugelpaars, 
           #declare b=b+1;                     // wird Testschleife abgebrochen und anderer Tripelwert
        #end                                   // zugewiesen
/*        #if (cflag2=0)                         // Falls cflag2 nach durchlaufener Testschleife immer
          #declare cflag=0;                   // noch 0 ist, wird cflag ebenfalls auf 0 gesetzt und
        #end */                                   // das nächste Tripel im Array kann zugewiesen werden
      #end 
    #end 
  #warning "Wuerfel gesetzt!"
  #declare a=a+1;      
#end  

#declare n=a; // Falls die Koordinatenzuweisungs-Routine wegen Überfüllung vorzeitig abgebrochen werden
                // mußte, wird n für die Platzierung der tatsächlichen Objekte entsprechend begrenzt,
                // um Fehlermeldung beim Zugriff auf in diesem Fall nicht initialisierte Array-Elemente
                // zu vermeiden
#declare a=0;

#while (a<n)
   box
   {
      <objs[a][0], 0, objs[a][1]>, <objs[a][2], objs_s[a], objs[a][3]> 
      texture
      {
         pigment { color rgb <rand(p), rand(p), rand(p)> }
         finish { No_Lights }
      }
   }
   #declare a=a+1;
#end 
    
camera
{
   orthographic
   location offst+<xsize/2, high*2, zsize/2>
   look_at offst+<xsize/2, 0, zsize/2>    
   
   angle 40
}