// PoVRay 3.7 Scene File " ... .pov"
// author:  ...
// date:    ...
//--------------------------------------------------------------------------
#version 3.7; /*
global_settings{ assumed_gamma 1.0 }
#default{ finish{ ambient 0.1 diffuse 0.9 }} 
//--------------------------------------------------------------------------
#include "colors.inc"
#include "textures.inc"
#include "glass.inc"
#include "metals.inc"
#include "golds.inc"
#include "stones.inc"
#include "woods.inc"
#include "shapes.inc"
#include "shapes2.inc"
#include "functions.inc"
#include "math.inc"
#include "transforms.inc"
//--------------------------------------------------------------------------
// camera ------------------------------------------------------------------
#declare Camera_0 = camera {perspective angle 75               // front view
                            location  <0.0 , 1.0 ,-3.0>
                            right     x*image_width/image_height
                            look_at   <0.0 , 1.0 , 0.0>}
#declare Camera_1 = camera { angle 90   // diagonal view
                            location  <2.0 , 2.5 ,-3.0>
                            right     x*image_width/image_height
                            look_at   <0.0 , 1.0 , 0.0>}
#declare Camera_2 = camera { angle 90  //right side view
                            location  <3.0 , 1.0 , 0.0>
                            right     x*image_width/image_height
                            look_at   <0.0 , 1.0 , 0.0>}
#declare Camera_3 = camera {angle 90        // top view
                            location  <0.0 , 3.0 ,-0.001>
                            right     x*image_width/image_height
                            look_at   <0.0 , 1.0 , 0.0>}
camera{Camera_0}
// sun ----------------------------------------------------------------------
light_source{< 3000,3000,-3000> color White}
// sky ----------------------------------------------------------------------
sky_sphere { pigment { gradient <0,1,0>
                       color_map { [0.00 rgb <0.6,0.7,1.0>]
                                   [0.35 rgb <0.1,0.0,0.8>]
                                   [0.65 rgb <0.1,0.0,0.8>]
                                   [1.00 rgb <0.6,0.7,1.0>] 
                                 } 
                       scale 2         
                     } // end of pigment
           } //end of skysphere
// ground -------------------------------------------------------------------
plane{ <0,1,0>, 0 
       texture{ pigment{ checker color rgb<1,1,1>*1.2 color rgb<0.25,0.15,0.1>*0}
              //normal { bumps 0.75 scale 0.025}
                finish { phong 0.1}
              } // end of texture
     } // end of plane
//---------------------------------------------------------------------------
//---------------------------- objects in scene ----------------------------
//---------------------------------------------------------------------------

#declare Object=
// sample sphere
sphere { <0,0,0>, 1.00 
         texture { Polished_Chrome
                   //pigment{ color Red } // rgb< 1, 0.0, 0.0>}
                   //finish { phong 1 reflection {0.40 metallic 0.5}}
                 } // end of texture 

          scale<1,1,1>  rotate<0,0,0>  translate<0,1.35,.5>  
       }  // end of sphere ----------------------------------- 

//object{Object}

                 */
/////////////////////////////////////////////////////////////////////////////////   



//-------------------Dripping Macro------------------------------------------------//

#macro Dripping (Object, DropPos, Material, MaxLength, MinThickness, MaxThickness, Norm, Seed, Squiglyness, Threshold)

    #local TopStart=max_extent(Object) ;
    #local BottomEnd=min_extent(Object) ;  
    
    #local TopEnd=<BottomEnd.x,TopStart.y,BottomEnd.z>;
    #local BottomStart=<TopStart.x,BottomEnd.y,TopStart.z>;      
    #local FrontStart=<TopStart.x,TopStart.y,BottomEnd.z>;
    #local FrontEnd=BottomEnd;
    #local BackStart=TopStart;
    #local BackEnd=<BottomEnd.x,BottomEnd.y,TopStart.z>; 
    #local LeftStart=<BottomEnd.x,TopStart.y,TopStart.z>;
    #local LeftEnd=BottomEnd  ;
    #local RightStart=TopStart;
    #local RightEnd=<TopStart.x,BottomEnd.y,BottomEnd.z>;  
    #local ObjectMid=BottomEnd+(.5*(TopStart-BottomEnd)); 
    #local TopMid=<ObjectMid.x,TopStart.y,ObjectMid.z>;
    #local BottomMid=<ObjectMid.x,BottomEnd.y,ObjectMid.z>;  
    #local FrontMid=<ObjectMid.x,ObjectMid.y,BottomEnd.z>;  
    #local BackMid=<ObjectMid.x,ObjectMid.y,TopStart.z>;  
    #local LeftMid=<BottomEnd.x,ObjectMid.y,ObjectMid.z>;   
    #local RightMid=<TopStart.x,ObjectMid.y,ObjectMid.z>;    
    
    #local Count=0; 
    
    #local JumpX=MinThickness;
    #local JumpZ=MinThickness;
    #local JumpY=MinThickness; 
    #local Jump=MinThickness; 
    
    #local XCount=0;  
    #local YCount=0;
    #local ZCount=0; 
    
    #local Thickness=MaxThickness;
    
    #local Gravity=<0,-1,0>; 
    
            #local DropAngle=  (ObjectMid-DropPos);
                //
             //union{
            blob{threshold Threshold //2 //.1 
                 sphere {0,.1,1 scale  Thickness Axial_Scale_Trans(Norm, .5) translate DropPos } 

             #while(Count<MaxLength)
                     // Threshold .1 and Thickness*.7 // or //   Threshold 2 and Thickness*.5
                 #local Jump= Thickness*.5;//(MinThickness*1) + (Thickness/(Count+1)) ;
                 #local JumpX=Jump*.5*(Squiglyness+((1-Squiglyness)*(abs(Norm.y)>abs(Norm.x))*(abs(Norm.y)-abs(Norm.x))));
                 #local JumpZ=Jump*.5*(Squiglyness+((1-Squiglyness)*(abs(Norm.y)>abs(Norm.z))*(abs(Norm.y)-abs(Norm.z))));
                 #local JumpY=Jump*(1-abs(Norm.y));
                  
                 #local DropAngle=  vnormalize(ObjectMid-DropPos);  
                 #local ScanPos=DropPos+(Norm*<Jump,0,Jump>)-(y*JumpY) 
                                + (x*2*JumpX*(-.5+rand(Seed))) 
                                + (z*2*JumpZ*(-.5+rand(Seed)));
                 #local Thickness=MinThickness+((Thickness-MinThickness)*(1-((Count+1)/(MaxLength+1))));  
                 #local Norm=<0,0,0>;    
                 #local DropAngle= (ObjectMid-DropPos)*<1,0,1>; 
                 #local DropPos=  trace(Object, ScanPos,DropAngle,Norm);
                 // Rem: if Norm~<0,-1,0> then drip off ??
                 sphere {0, 1,1 scale Thickness Axial_Scale_Trans(Norm, .5) translate DropPos }// pigment{rgb <1/Count,Count-1,Count*.1>}}
                 
                 #if ((Norm.y<-.5-.5*(rand(Seed)))*(Count>(MaxLength*.6)))  // icicle
                      #while (Count<(MaxLength-1))
                          #local JumpY=Jump*(1-abs(Norm.y));
                          #local Thickness=(MinThickness/2)+((Thickness-(MinThickness/2))*(1-((Count+1)/(MaxLength+1))));
                          #local DropPos=DropPos-(y*JumpY);
                          sphere {0, 1,1 scale Thickness Axial_Scale_Trans(Norm, .5) translate DropPos }// pigment{rgb <1/Count,Count-1,Count*.1>}}
                     
                          #local Count=Count+1;  
                      #end
                 #end
                 
                 #local Count=Count+1;
             #end  
             sphere {0, 1,1 scale <Thickness,MaxThickness,Thickness> translate DropPos-(y*MaxThickness) }// pigment{rgb <1/Count,Count-1,Count*.1>}}
                
             material{Material}
            }// blob
             
             

#end // macro Dripping  
///////////////////////////////////////

                                                                                     
                                                                                       
//---------------------------------------------------------------------------------

//******************************************************************************////

//-------------------Drip Macro------------------------------------------------//

#macro Drips (Object, Material, MaxDrops, MaxLength, MinThickness, MaxThickness, Merge, Seed, Squiglyness, PosXYZ, NegXYZ, Threshold)

    #local TopStart=max_extent(Object) ;
    #local BottomEnd=min_extent(Object) ;  
    
    #local ObjectSize=(TopStart-BottomEnd);
    
    #local TopEnd=<BottomEnd.x,TopStart.y,BottomEnd.z>;
    #local BottomStart=<TopStart.x,BottomEnd.y,TopStart.z>;      
    #local FrontStart=<TopStart.x,TopStart.y,BottomEnd.z>;
    #local FrontEnd=BottomEnd;
    #local BackStart=TopStart;
    #local BackEnd=<BottomEnd.x,BottomEnd.y,TopStart.z>; 
    #local LeftStart=<BottomEnd.x,TopStart.y,TopStart.z>;
    #local LeftEnd=BottomEnd  ;
    #local RightStart=TopStart;
    #local RightEnd=<TopStart.x,BottomEnd.y,BottomEnd.z>;  
    #local ObjectMid=BottomEnd+(.5*(TopStart-BottomEnd)); 
    #local TopMid=<ObjectMid.x,TopStart.y,ObjectMid.z>;
    #local BottomMid=<ObjectMid.x,BottomEnd.y,ObjectMid.z>;  
    #local FrontMid=<ObjectMid.x,ObjectMid.y,BottomEnd.z>;  
    #local BackMid=<ObjectMid.x,ObjectMid.y,TopStart.z>;  
    #local LeftMid=<BottomEnd.x,ObjectMid.y,ObjectMid.z>;   
    #local RightMid=<TopStart.x,ObjectMid.y,ObjectMid.z>;    
                             
    #local Count=0; 
    #local DropPos=<0,0,0>;  
    #local EdgeMax=int( sqrt(MaxDrops));  
    
    #local JumpX=(BottomEnd.x-TopStart.x)/EdgeMax;
    #local JumpZ=(BottomEnd.z-TopStart.z)/EdgeMax;
    #local JumpY=(BottomEnd.y-TopStart.y)/EdgeMax; 
    
    #local XCount=0;  
    #local YCount=0;
    #local ZCount=0; 
    
    #local Hit=0;
    #local HitCount=0;
    
    //#local Threshold=.1;
    #local Gravity=<0,-1,0>; 
    // Gravity of dripping
    // add x & z component of Norm and reduce y comp 
    // then trace to <Xmid,-y,zMid> 
    // if (abs(Norm.x))<(abs(Norm.y))>(abs(Norm.z)) then add rand to x and z components according to difference from y component
   
    #if(Merge)
        merge{
    #else    
        union{ 
    #end
    
    
     
    
         // trace(Object, From,<0,-1,0>/*Direction*/,<0,0,0>/*Normal*/);
         #while ((XCount<(EdgeMax*2))*(PosXYZ.y))// From Top /////////////////////////////////////////////////////////////////////////
            
             #while(ZCount<(EdgeMax*2))//scan opposite ends
                 #if(Hit)
                    #local DropPos=TopStart+(y*MinThickness)+ (x*XCount*(rand(Seed)*2* MaxThickness))+(z*ZCount*(rand(Seed)*2* MaxThickness)); 
                 #else
                    #local DropPos=TopStart+(y*MinThickness)+ (x*XCount*(rand(Seed)*2* JumpX))+(z*ZCount*(rand(Seed)*2* JumpZ)); 
                 #end
                 #local DropAngle=  (ObjectMid-DropPos);
                 #local Thickness=MinThickness+(rand(Seed)*(MaxThickness-MinThickness));  
                 #local Norm=<0,0,0>;
                 #local DripPos=  trace(Object, DropPos,DropAngle,Norm); 
                 #if ( (Norm.x = 0)*(Norm.y = 0)*(Norm.z = 0) ) 
                     #local DripPos=  trace(Object, DropPos,-y,Norm); 
                 #end
                  #if ( (Norm.x != 0)*(Norm.y != 0)*(Norm.z != 0) )
                  Dripping (Object, DripPos, Material, MaxLength/2, MinThickness, Thickness*1.5, Norm, Seed, Squiglyness*2, Threshold*.9)
                    #local Hit=1;
                  #else
                    #local Hit=0;
                  #end
                  
                 #local ZCount=ZCount+1;
             #end  
             #local ZCount=0; 
             #local Hit=0;
             
             #while(ZCount<(EdgeMax*2))//scan randomly
                  
                 #if(Hit)
                     #local DropPos=DropPos +(y*MinThickness)+ (<int(-.5+(rand(Seed))),0,int(-.5+(rand(Seed)))>*(2*<MaxThickness,0,MaxThickness>)*(<rand(Seed),0,rand(Seed)>)); 
                 #else
                     #local DropPos=TopEnd +(y*MinThickness)+ (<rand(Seed),0,rand(Seed)>*ObjectSize); 
                 #end 
                 
                 #local DropAngle=  ((BottomEnd +(<rand(Seed),0,rand(Seed)>*ObjectSize))-DropPos); 
                 #local Thickness=MinThickness+(rand(Seed)*(MaxThickness-MinThickness));  
                 #local Norm=<0,0,0>;
                 #local DripPos=  trace(Object, DropPos,DropAngle,Norm); 
                 #if ( (Norm.x = 0)*(Norm.y = 0)*(Norm.z = 0) ) 
                     #local DripPos=  trace(Object, DropPos,-y,Norm); 
                 #end
                  #if ( (Norm.x != 0)*(Norm.y != 0)*(Norm.z != 0) )
                  Dripping (Object, DripPos, Material, MaxLength/2, MinThickness, Thickness*1.5, Norm, Seed, Squiglyness*2, Threshold*.9)
                    #local Hit=1;
                  #else
                    #local Hit=0;
                  #end
                  
                 #local ZCount=ZCount+1;
             #end  
             #local ZCount=0; 
             
             #local XCount=XCount+1;
         #end 
         #local XCount=0;
         #local Hit=0;
         
         #while ((XCount<(EdgeMax/2))*(NegXYZ.y))// From Bottom //////////////////////////////////////////////////////////////////////////
           // blob{threshold 0.6
             #while(ZCount<(EdgeMax*2))  // Scan opposite ends
                 #local DropPos=BottomStart-(y*MinThickness)+ (x*XCount*(rand(Seed)*2* JumpX))+(z*ZCount*(rand(Seed)*2* JumpZ)); 
                 #local DropAngle=  (ObjectMid-DropPos);
                 #local Thickness=MinThickness; //+(rand(Seed)*(MaxThickness-MinThickness));  
                 #local Norm=<0,0,0>;
                 #local DripPos=  trace(Object, DropPos,DropAngle,Norm); 
                 #if ( (Norm.x = 0)*(Norm.y = 0)*(Norm.z = 0) ) 
                     #local DripPos=  trace(Object, DropPos,y,Norm); 
                 #end
                 #if ( (Norm.x != 0)*(Norm.y != 0)*(Norm.z != 0) )
                 Dripping (Object, DripPos, Material, MaxLength, MinThickness, Thickness, Norm, Seed, Squiglyness*.5, Threshold)
                 #end
                 
                 #local ZCount=ZCount+1;
             #end  
             #local ZCount=0;
             #local Hit=0;
             
             #while(ZCount<(EdgeMax*2))//scan randomly
                 
                 #if(Hit)
                     #local DropPos=DropPos -(y*MinThickness)+ (<int(-.5+(rand(Seed))),0,int(-.5+(rand(Seed)))>*(2*MaxThickness)*(<rand(Seed),0,rand(Seed)>)); 
                 #else
                     #local DropPos=BottomEnd -(y*MinThickness)+ (<rand(Seed),0,rand(Seed)>*ObjectSize); 
                 #end
                 #local DropAngle=  ((TopEnd +(<rand(Seed),0,rand(Seed)>*ObjectSize))-DropPos);
                 #local Thickness=MinThickness+(rand(Seed)*(MaxThickness-MinThickness));  
                 #local Norm=<0,0,0>;
                 #local DripPos=  trace(Object, DropPos,DropAngle,Norm); 
                 #if ( (Norm.x = 0)*(Norm.y = 0)*(Norm.z = 0) ) 
                     #local DripPos=  trace(Object, DropPos,y,Norm); 
                 #end
                 #if ( (Norm.x != 0)*(Norm.y != 0)*(Norm.z != 0) )
                 Dripping (Object, DripPos, Material, MaxLength, MinThickness, Thickness, Norm, Seed, Squiglyness*.5, Threshold)
                   #local Hit=1;
                  #else
                    #local Hit=0;
                  #end
                  
                 #local ZCount=ZCount+1;
             #end  
             #local ZCount=0; 
             #local Hit=0;
             
             #local XCount=XCount+1;
         #end 
         #local XCount=0;
         
         
         #while ((XCount<=EdgeMax)*(NegXYZ.z))// From Front ///////////////////////////////////////////////////////////////////////////
            
             #while(YCount<=EdgeMax) // Scan Opposite directions
                 #local DropPos=FrontStart -(z*MinThickness)+ (x*XCount*(rand(Seed)*2* JumpX))+(y*YCount*(rand(Seed)*2* JumpY)); 
                 #local DropAngle=  (ObjectMid-DropPos);
                 #local Thickness=MinThickness+(rand(Seed)*(MaxThickness-MinThickness));  
                 #local Norm=<0,0,0>;
                 #local DripPos=  trace(Object, DropPos,DropAngle,Norm); 
                 #if ( (Norm.x = 0)*(Norm.y = 0)*(Norm.z = 0) ) 
                     #local DripPos=  trace(Object, DropPos,z,Norm); 
                 #end
                 #if ( (Norm.x != 0)*(Norm.y != 0)*(Norm.z != 0) )
                 Dripping (Object, DripPos, Material, MaxLength, MinThickness, Thickness, Norm, Seed, Squiglyness, Threshold)
                   #local Hit=1;
                  #else
                    #local Hit=0;
                  #end
                 
                 #local YCount=YCount+1;
             #end  
             #local YCount=0; 
             #local Hit=0;
             
             #while(YCount<EdgeMax)//scan randomly
                 
                 #if(Hit)
                     #local DropPos=DropPos -(z*MinThickness)+ (<int(-.5+(rand(Seed))),int(-.5+(rand(Seed))),0>*(2*MaxThickness)*(<rand(Seed),rand(Seed),0>)); 
                 #else                                         
                    #local DropPos=FrontEnd -(z*MinThickness)+ (<rand(Seed),rand(Seed),0>*ObjectSize); 
                 #end
                 #local DropAngle=  ((BackEnd +(<rand(Seed),rand(Seed),0>*ObjectSize))-DropPos);
                 #local Thickness=MinThickness+(rand(Seed)*(MaxThickness-MinThickness));  
                 #local Norm=<0,0,0>;
                 #local DripPos=  trace(Object, DropPos,DropAngle,Norm); 
                 #if ( (Norm.x = 0)*(Norm.y = 0)*(Norm.z = 0) ) 
                     #local DripPos=  trace(Object, DropPos,z,Norm); 
                 #end
                 #if ( (Norm.x != 0)*(Norm.y != 0)*(Norm.z != 0) )
                 Dripping (Object, DripPos, Material, MaxLength, MinThickness, Thickness, Norm, Seed, Squiglyness, Threshold)
                   #local Hit=1;
                  #else
                    #local Hit=0;
                  #end
                  
                 #local YCount=YCount+1;
             #end  
             #local YCount=0; 
             #local Hit=0;
             
             
             #local XCount=XCount+1;
         #end 
         #local XCount=0;
         
         
         #while ((XCount<=EdgeMax)*(PosXYZ.z))// From Back /////////////////////////////////////////////////////////////////////////
            
             #while(YCount<=EdgeMax)// Scan opposites
                 #local DropPos=BackStart+(z*MinThickness)+ (x*XCount*(rand(Seed)*2* JumpX))+(y*YCount*(rand(Seed)*2* JumpY)); 
                 #local DropAngle=  (ObjectMid-DropPos);
                 #local Thickness=MinThickness+(rand(Seed)*(MaxThickness-MinThickness));  
                 #local Norm=<0,0,0>;
                 #local DripPos=  trace(Object, DropPos,DropAngle,Norm); 
                 #if ( (Norm.x = 0)*(Norm.y = 0)*(Norm.z = 0) ) 
                     #local DripPos=  trace(Object, DropPos,-z,Norm); 
                 #end
                 #if ( (Norm.x != 0)*(Norm.y != 0)*(Norm.z != 0) )
                 Dripping (Object, DripPos, Material, MaxLength, MinThickness, Thickness, Norm, Seed, Squiglyness, Threshold)
                   #local Hit=1;
                  #else
                    #local Hit=0;
                  #end
                 
                 #local YCount=YCount+1;
             #end  
             #local YCount=0;
             #local Hit=0;
             
             #while(YCount<EdgeMax)//scan randomly
                 
                 #if(Hit)
                     #local DropPos=DropPos +(z*MinThickness)+ (<int(-.5+(rand(Seed))),int(-.5+(rand(Seed))),0>*(2*MaxThickness)*(<rand(Seed),rand(Seed),0>)); 
                 #else
                    #local DropPos=BackEnd +(z*MinThickness)+ (<rand(Seed),rand(Seed),0>*ObjectSize); 
                 #end
                 #local DropAngle=  ((FrontEnd +(<rand(Seed),rand(Seed),0>*ObjectSize))-DropPos);
                 #local Thickness=MinThickness+(rand(Seed)*(MaxThickness-MinThickness));  
                 #local Norm=<0,0,0>;
                 #local DripPos=  trace(Object, DropPos,DropAngle,Norm); 
                 #if ( (Norm.x = 0)*(Norm.y = 0)*(Norm.z = 0) ) 
                     #local DripPos=  trace(Object, DropPos,-z,Norm); 
                 #end
                 #if ( (Norm.x != 0)*(Norm.y != 0)*(Norm.z != 0) )
                 Dripping (Object, DripPos, Material, MaxLength, MinThickness, Thickness, Norm, Seed, Squiglyness, Threshold)
                   #local Hit=1;
                  #else
                    #local Hit=0;
                  #end
                  
                 #local YCount=YCount+1;
             #end  
             #local YCount=0; 
             #local Hit=0;
             
             #local XCount=XCount+1;
         #end 
         #local XCount=0;
         
         
         #while ((ZCount<=EdgeMax)*(NegXYZ.x))// From Left /////////////////////////////////////////////////////////////////////////
           
             #while(YCount<=EdgeMax) // Scan Opposites
                 #local DropPos=LeftStart-(x*MinThickness)+ (z*ZCount*(rand(Seed)*2* JumpZ))+(y*YCount*(rand(Seed)*2* JumpY)); 
                 #local DropAngle=  (ObjectMid-DropPos);
                 #local Thickness=MinThickness+(rand(Seed)*(MaxThickness-MinThickness));  
                 #local Norm=<0,0,0>;
                 #local DripPos=  trace(Object, DropPos,DropAngle,Norm); 
                 #if ( (Norm.x = 0)*(Norm.y = 0)*(Norm.z = 0) ) 
                     #local DripPos=  trace(Object, DropPos,x,Norm); 
                 #end
                 #if ( (Norm.x != 0)*(Norm.y != 0)*(Norm.z != 0) )
                 Dripping (Object, DripPos, Material, MaxLength, MinThickness, Thickness, Norm, Seed, Squiglyness, Threshold)
                   #local Hit=1;
                  #else
                    #local Hit=0;
                  #end
                 
                 #local YCount=YCount+1;
             #end  
             #local YCount=0;  
             #local Hit=0;
             
             #while(YCount<EdgeMax)//scan randomly
                 
                 #if(Hit)
                     #local DropPos=DropPos -(x*MinThickness)+ (<0,int(-.5+(rand(Seed))),int(-.5+(rand(Seed)))>*(2*MaxThickness)*(<0,rand(Seed),rand(Seed)>)); 
                 #else
                    #local DropPos=LeftEnd -(x*MinThickness)+ (<0,rand(Seed),rand(Seed)>*ObjectSize); 
                 #end
                 #local DropAngle=  ((RightEnd +(<0,rand(Seed),rand(Seed)>*ObjectSize))-DropPos);
                 #local Thickness=MinThickness+(rand(Seed)*(MaxThickness-MinThickness));  
                 #local Norm=<0,0,0>;
                 #local DripPos=  trace(Object, DropPos,DropAngle,Norm); 
                 #if ( (Norm.x = 0)*(Norm.y = 0)*(Norm.z = 0) ) 
                     #local DripPos=  trace(Object, DropPos,x,Norm); 
                 #end
                 #if ( (Norm.x != 0)*(Norm.y != 0)*(Norm.z != 0) )
                 Dripping (Object, DripPos, Material, MaxLength, MinThickness, Thickness, Norm, Seed, Squiglyness, Threshold)
                   #local Hit=1;
                  #else
                    #local Hit=0;
                  #end
                  
                 #local YCount=YCount+1;
             #end  
             #local YCount=0; 
             #local Hit=0;
             
             #local ZCount=ZCount+1;
         #end 
         #local ZCount=0;
         
         
         #while ((ZCount<=EdgeMax)*(PosXYZ.x))// From Right ///////////////////////////////////////////////////////////////////////
           
             #while(YCount<=EdgeMax) // Scan Opposites
                 #if(Hit)
                    #local DropPos=RightStart+ (x*MinThickness)+ (z*ZCount*(rand(Seed)*2* MaxThickness))+(y*YCount*(rand(Seed)*2* MaxThickness)); 
                 #else
                    #local DropPos=RightStart+ (x*MinThickness)+ (z*ZCount*(rand(Seed)*2* JumpZ))+(y*YCount*(rand(Seed)*2* JumpY)); 
                 #end
                 #local DropAngle=  (ObjectMid-DropPos);
                 #local Thickness=MinThickness+(rand(Seed)*(MaxThickness-MinThickness));  
                 #local Norm=<0,0,0>;
                 #local DripPos=  trace(Object, DropPos,DropAngle,Norm); 
                 #if ( (Norm.x = 0)*(Norm.y = 0)*(Norm.z = 0) ) 
                     #local DripPos=  trace(Object, DropPos,-x,Norm); 
                 #end
                 #if ( (Norm.x != 0)*(Norm.y != 0)*(Norm.z != 0) )
                 Dripping (Object, DripPos, Material, MaxLength, MinThickness, Thickness, Norm, Seed, Squiglyness, Threshold)
                   #local Hit=1;
                  #else
                    #local Hit=0;
                  #end
                 
                 #local YCount=YCount+1;
             #end  
             #local YCount=0; 
             #local Hit=0;
             
             #while(YCount<EdgeMax)//scan randomly
                   
                 #if(Hit)
                     #local DropPos=DropPos +(x*MinThickness)+ (<0,int(-.5+(rand(Seed))),int(-.5+(rand(Seed)))>*(2*MaxThickness)*(<0,rand(Seed),rand(Seed)>)); 
                 #else
                    #local DropPos=RightEnd +(x*MinThickness)+ (<0,rand(Seed),rand(Seed)>*ObjectSize); 
                 #end
                 #local DropAngle=  ((LeftEnd +(<0,rand(Seed),rand(Seed)>*ObjectSize))-DropPos);
                 #local Thickness=MinThickness+(rand(Seed)*(MaxThickness-MinThickness));  
                 #local Norm=<0,0,0>;
                 #local DripPos=  trace(Object, DropPos,DropAngle,Norm); 
                 #if ( (Norm.x = 0)*(Norm.y = 0)*(Norm.z = 0) ) 
                     #local DripPos=  trace(Object, DropPos,-x,Norm); 
                 #end
                 #if ( (Norm.x != 0)*(Norm.y != 0)*(Norm.z != 0) )
                 Dripping (Object, DripPos, Material, MaxLength, MinThickness, Thickness, Norm, Seed, Squiglyness, Threshold)
                   #local Hit=1;
                  #else
                    #local Hit=0;
                  #end
                  
                 #local YCount=YCount+1;
             #end  
             #local YCount=0; 
             #local Hit=0;
             
             #local ZCount=ZCount+1;
         #end 
         #local ZCount=0;
    }// Union/Merge    

#end // macro   

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//===================================================================================================================================//    

///Test  
/*    
#declare Object= torus { 1.0,0.25 
        texture { pigment{ color rgb<1,0.7,0>}
                  finish { phong 1 reflection { 0.00 metallic 0.50} }
                } // end of texture
        scale .5 rotate<90,45,45> translate<0,1.5,0>
      } // end of torus  -------------------------------              
       

//object{Object}

#declare Material=material{texture{
                                   pigment{rgb<0,1,0>}
                                   finish{metallic .5 phong 1 phong_size 200 brilliance 2}
                                   }
                           };
#declare MaxDrops=50; // uneven numbers work better
#declare MinThickness=.05;
#declare MaxThickness=.1;
#declare Merge=0;
#declare MaxLength=20;
#declare Seed=seed(97531);
#declare Squiglyness=1; 
#declare PosXYZ=<1,1,1>; // Projections to trace eg: <0,1,0> is only from the top
#declare NegXYZ=<1,1,1>;      
#declare Threshold=2;
Drips (Object, Material, MaxDrops, MaxLength, MinThickness, MaxThickness, Merge, Seed, Squiglyness, PosXYZ, NegXYZ, Threshold)  


  */