1. include "functions.inc"

/*

   0.97, 1.00, 1.00  // white
  0.72, 0.50, 0.27 // ora
 0.55, 0.38, 0.30  // red
 0.44, 0.42, 0.32 // gray

• /

 /*
 #local p_start		=	64/image_width;

1. local p_end_tune = 8/image_width;
2. local p_end_final = 4/image_width;

1. local smooth_eb = 0.50;
2. local smooth_count = 75;

1. local final_eb = 0.1875;
2. local final_count = smooth_count * smooth_eb * smooth_eb / (final_eb * final_eb);

  global_settings {
   radiosity {
     pretrace_start 0.08
     pretrace_end   0.01
     count 500

     nearest_count 10
     error_bound 0.02
     recursion_limit 1

     low_error_factor 0.2
     gray_threshold 0.0
     minimum_reuse 0.015
     brightness 1

     adc_bailout 0.01/2
   }
 }

• /

/* global_settings {

   radiosity {
     pretrace_start 0.08
     pretrace_end   0.04
     count 35

     nearest_count 5
     error_bound 1.8
     recursion_limit 3

     low_error_factor 0.5
     gray_threshold 0.0
     minimum_reuse 0.015
     brightness 1

     adc_bailout 0.01/2
   }
 }

• /

/*

global_settings

{ photons
  { count 20000
    media 100
  }
}
  */

/*

//  #include “rad_def.inc”

global_settings {

  radiosity {
     Rad_Settings(Radiosity_Normal,off,off)
  }

}

 */

/* global_settings{

radiosity {

   pretrace_start p_start      // Use a pretrace_end value close to what you
   pretrace_end   p_end_tune   //  intend to use for your final trace
   
   count final_count                     // Note the very low count!
                               
   nearest_count 20            // 10 will be ok for now
                               
   error_bound final_eb             // Start with 1.0 
   
   recursion_limit 3           // Recursion should be near what you want it to be
                               //  If you aren't sure, start with 3 or 4
      minimum_reuse 0.005   
  
 always_sample off
}

}

*/

default { finish { ambient 0.000000 diffuse 0.9 } }    

camera {

 location  <0,0,-1>*5
 angle 35
 look_at   0

}

light_source {

<-1,0,-1>*1000000

color rgb <1,1,1>*1.5 }

1. declare light1 = texture

{

  pigment {  
  //   wrinkles    
   granite

//scale 0.1

          scale 3
   warp {  
       turbulence 0.4
       }    
     scale 1/3    

     pigment_map { 
   [0 color rgb <0.91, 0.65, 0.45>*4/4 ]
   [0.2 color rgb <0.99, 0.96, 0.85>*1.1 ]
    [1 color rgb <1.00, 0.92, 0.82>*1.4 ]
    }

}

   finish {  ambient .03 diffuse .55 phong .075 phong_size 1.5 specular .025 roughness .01}  

}

1. declare dark1= texture {

     pigment {

 //  gradient y  

    //   function {y+f_wrinkles(0,y,0)*0.5+f_granite(0,y/4,0)*0.1}
      wrinkles    

scale 0.1

// frequency 10

  // sine_wave    
 //   scallop_wave

 /*  
   turbulence 0.05
   omega 0.1
   lambda 0.1

• /

     scale 5
   warp {  
       turbulence 0.5
       }    
   
 scale 1/5
        scale 50
   warp {  
       turbulence 0.5
       }    
   
 scale 1/50  

   pigment_map {
       [0 color rgb <1.00, 0.92, 0.82>*1.4  ]
        [0.2 color rgb <0.63, 0.49, 0.40>*1.3  ]
       [0.95  color rgb <0.91, 0.65, 0.45>*1.3  ] 
            [1  color rgb <0.44, 0.42, 0.32 >*1.3  ] 
    }         
    
    }

   finish {  ambient .00 diffuse .55 phong .075 phong_size 1.5 specular .025 roughness .01}

}

#declare tex1= texture {
  
  function{       sin(y)+ f_wrinkles(0,y*3,0)+f_granite(0,y/2,0)*0.1   }  // OK OK

// function{ (1/sqrt(2*pi))*(exp(-(y*y*1.75)/2))/2 }

//   function{  (1/sqrt(2*pi))*(exp(-(y*y*1.75)/2))/2 +    f_granite(0,y/3,0)/4+ f_wrinkles(0,y*10,0)/4  }  // ok   
//  function{    sin(abs(y/2)) +  2.5*   1/sqrt(2*pi)*exp(-(y*y*1.75)/2)    } // normal distribution

//       function{       sin(y/6)+ f_wrinkles(0,y*3,0)+f_granite(0,y/2,0)*0.1   }  // OK OK

  //      function{    sin(y)+    asin( f_wrinkles(x/100,y,z/100) )   }  // ok  
     //     function{      f_granite(0,y/3,0)/2+ f_wrinkles(0,y*10,0)/2  }  // ok    

// function { (log(sin(y))) } // og

 //  function{ min(log((1/y*1)/3),1 )*min(log(-(1/y*1)/3),1 )  }   // quite og 
//     function{        sin( f_wrinkles(0, sin(y*3),0) )   }  // OK OK 
   //    function{        asin( f_wrinkles(0,y,0) )*0.8+f_granite(0,y,0)*0.2   }  // OK OK 

// function{ tan(y*0.7/3) }

   //   function{      y-0.5+ f_wrinkles(0,y/2,0)+f_granite(0,y/4,0)*0.1   }  // OK OK
     //    function{        asin( f_wrinkles(0,sin(y)*2,0) )   }  // OK OK
   //   function {0.5+y+f_wrinkles(0,y,0)*0.4+f_granite(0,y/4,0)*0.1}
        

//function {((cos(y*5/1)+1)/2)*0.9+f_wrinkles(x/30,y,0)/20 }

    //  function {((sin(y*3)/2)+0.5)}

 //      gradient y 

// function {0.5-sin(y)-f_wrinkles(x,y,z)*0.1 -f_wrinkles(x,y,z)*0.03 }

//  gradient y
     
          sine_wave
   //  scallop_wave
     
//        scale 5
     //  turbulence .1

//scale 1/5

      frequency 1
       
     scale 5
   warp {  
       turbulence 0.4
       }    
     scale 1/5
        scale 10
   warp {  
       turbulence 0.3
       }    
     scale 1/10  
          scale 30
   warp {  
       turbulence 0.5
       }    
     scale 1/30    
       scale 100
   warp {  
       turbulence 0.5
       }    
     scale 1/100
        

         scale 1

       texture_map { 
      [0 dark1 ]
        [1 light1  ] 
       //        [1 dark1 ]
       }
        

/*

       texture_map {
 // [0 light1  ] 
      [0.0 dark1 ]

        [1 light1  ]
       }
 */                          
 //  scale <.2,1,.2> rotate 15*y translate -.05*y
                
           
                                            
// warp {black_hole <.5,-.2,-.8>,.32 falloff 2 strength 6 turbulence <1,1,1>/2 inverse }
                                                                       
   //  warp {black_hole <.5,-.5,.8>,.25 falloff 5 strength 3.2 turbulence 0 inverse }                                                                    
       warp {black_hole <.5,-.5,-.8>,.25 falloff 1.5 strength 6 turbulence <0.2, 0.2,0.2>*4 inverse }                                                                    

      scale y/2

}

//background{rgb .1}

// giant planet

1. declare giantplanet1=sphere {0,1

      texture {
    
       tex1
      }      

   photons { target reflection on }

}

#declare giantplanet2=sphere {0,1.001
      texture {

       pigment { 
              gradient y

// sine_wave

 scallop_wave

    pigment_map {
    [0 color rgbt <1.0,0.8, 1,0.8> ]
    [1 color rgbt <1,0,0.8, 1,0.8> ]

          }

       }

      }      

}

#declare atm_thickness1 = 0.075;

1. declare atm_color1 = rgb <pow(460/650, 4), pow(460/555, 4), 1>;
2. declare atm_amount1=5;
3. declare atm_samples1=5;

1. declare atm1= object

  { 
  
   difference {  

  sphere {0, 1.0001+atm_thickness1 } 
      sphere {0, 1.0001 } 
              }

   hollow no_shadow
  

    pigment {

    rgbt 1 
     }   
     
  //   finish { 
   //  reflection 0
   //  }
    interior
    { media  {    

           method 3
    intervals 3
    samples atm_samples1

      // emission 0.1 
        absorption 0
      //  scattering { 4 color atm_amount1*atm_color1/atm_thickness1    }
      //   scattering { 4 color atm_amount1*<0.4,0.6,0.8>/atm_thickness1    }  
                scattering { 5 color atm_amount1*<0.5,0.7,1>/atm_thickness1  eccentricity 0.56  }
        density
        { 
          function {   1*exp(-8*(sqrt(x*x+(y)*(y)+z*z)- 1 - 0.00001)/atm_thickness1) }

       //spherical density_map
        //  { [0.00 rgb 0.0]  
        //      [0.1 rgb White*0.1] 
        //     [1 rgb White]
        //  }
 
      }
        
      }
      
      
    }

       scale 1

  }          
  

1. declare gee1=union {

object { giantplanet1} // atmo simu filter

object { giantplanet2}

object {atm1}

}

object {gee1

//rotate y*45 //rotate x*40

}