render_povray/templates_pov/wallstucco.pov

   1 // This work is licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported License.
   2 // To view a copy of this license, visit http://creativecommons.org/licenses/by-sa/3.0/ or send a
   3 // letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.
   4
   5 // Persistence Of Vision Ray Tracer Scene Description File
   6 // Desc: Brick wall & Stucco
   7 // Date: 2000/03/14
   8 // Updated: 2001/07/26
   9 // Auth: Ingo Janssen
  10 // Updated: 2013/02/15 for 3.7
  11 //
  12 // -w320 -h240
  13 // -w800 -h600 +a0.3
  14 //
  15
  16 #version 3.7;
  17 global_settings { assumed_gamma 1.0
  18                   noise_generator 1 } // change to 2 or 3.
  19
  20 light_source {
  21    < 500, 500,500>
  22    rgb 1
  23 }
  24
  25 camera {
  26    location  <0.2, 0.0,-25.0>
  27    look_at   <0.0, 0.0,  0.0>
  28    right x*image_width/image_height // keep proportions with any aspect ratio
  29    angle 65
  30 }
  31
  32 //====== Doing the Stucco ======
  33
  34 #declare L2=0.55; //clock;  //Set amount of decay of stucco, higher value is more decay. animate
  35 #declare PWrink= pigment { //Mortar
  36    wrinkles
  37    scale 0.25
  38    colour_map {
  39       [0, rgb 0.5]
  40       [L2, rgb 0.96]
  41    }
  42 }
  43 #declare Stucco= pigment {    //Stucco
  44    granite
  45    scale 0.05
  46    colour_map {
  47       [0, rgb 0.96]
  48       [1, rgb 1]
  49    }
  50 }
  51
  52 #declare StuMor= pigment {       //Stucco & Mortar
  53    pigment_pattern{
  54       wrinkles
  55       scale 0.25
  56    }
  57    pigment_map {
  58       [L2, PWrink]
  59       [L2, Stucco]
  60    }
  61 }
  62
  63 #declare HF_Stucco=height_field {  //Turn it into a hightfield
  64    function 500, 500{               //500,500 for test higher is better, but watch the memory
  65       pigment{StuMor }
  66    }
  67    translate -0.5
  68    rotate -90*x
  69    scale <20,20,2>
  70    pigment {                         //Use the mortar to colour up the stucco
  71       pigment_pattern {
  72          wrinkles
  73          scale 0.25
  74       }
  75       color_map {
  76          [L2, rgb 0.5]
  77          [L2, rgb <1,1,0.95>]
  78       }
  79       warp {planar z, 0}
  80       translate <-0.5, -0.5, 0>
  81       rotate <180,0,0>
  82       scale <20,20,2>
  83    }
  84 }
  85
  86 //====== Lay some Bricks ======
  87
  88 //Size           : dimension of the brick in a vector x, y, z
  89 //Mortar         : width of the joint.
  90 //Turbulence etc : control the stone deformation.
  91 #macro BrickWall(Size, Mortar, Turbulence, Octaves, Lambda, Omega)
  92
  93    #local Brick= pigment {
  94       boxed                                // one single brick ...
  95       scale <Size.x/2,Size.y/2,Size.z/2>
  96       translate <Size.x/2+Mortar,Size.y/2+Mortar,0>
  97       warp {repeat x*(Size.x+Mortar)}      // ... repeated over and over again.
  98       warp {repeat y*(2*(Size.y+Mortar))}
  99    }
 100
 101    #declare FBrickWall= function {
 102       pigment {
 103          pigment_pattern {
 104             gradient y
 105             warp {repeat y}
 106             scale <1,2*(Size.y+Mortar),1>
 107          }
 108          pigment_map {
 109             [0.5, Brick
 110                   warp {                  // deforming the bricks ...
 111                      turbulence Turbulence
 112                      octaves Octaves
 113                      lambda Lambda
 114                      omega Omega
 115                   }
 116                   translate <0,-(Mortar/2),0>
 117             ]
 118             [0.5, Brick                  // ... row by row.
 119                   warp {
 120                      turbulence Turbulence
 121                      octaves Octaves
 122                      lambda Lambda
 123                      omega Omega
 124                   }
 125                   translate <(Size.x/2)+Mortar,(Size.y+(Mortar/2)),0>
 126             ]
 127          }
 128       }
 129    }
 130 #end
 131
 132 #declare Wall=pigment {
 133    BrickWall(<4,1,1>,0.2,<0.05,0.1,0>,6,0.5,0.5)
 134    function{FBrickWall(x,y,z).gray}
 135    pigment_map {                    // give some structure to the joint ...
 136       [0, granite
 137           scale 0.1
 138           colour_map {
 139             [0, rgb 0][1, rgb 0.3]
 140           }
 141       ]
 142       [0.05, crackle                // ... and the bricks.
 143              scale <3,1,1>
 144              turbulence 0.5
 145              colour_map {
 146                [0, rgb 0.34][1, rgb 0.5]
 147              }
 148       ]
 149    }
 150    scale 0.04
 151 }
 152
 153 #declare HF_Wall=height_field {      // Build the wall
 154    function 500, 500 {   //500,500, for test, higher is better & slower. Watch the memory use.
 155       pigment{Wall}
 156    }
 157    smooth
 158    translate -0.5
 159    rotate <-90,0,0>
 160    scale <33,33,1>
 161    pigment {
 162       Wall
 163       pigment_map {
 164          [0, rgb 0.6]
 165          [0.05, wrinkles
 166                 turbulence 0.3
 167                 scale <2,0.3,1>
 168                 colour_map {
 169                   [0.0, rgb <0.5,0.3,0.25>]
 170                   [0.15, rgb <0.5,0.3,0.25>/1.3]
 171                   [0.3, rgb <0.5,0.3,0.25>]
 172                   [0.6, rgb <0.6,0.3,0.25>/1.6]
 173                   [0.8, rgb <0.5,0.3,0.25>]
 174                   [1.0, rgb <0.5,0.3,0.35>/2]
 175                }
 176          ]
 177       }
 178       translate <-0.5, -0.5, 0>
 179       rotate -90*x
 180       warp {planar y, 0}
 181       scale <33,33,1>
 182    }
 183 }
 184
 185 object {HF_Stucco}
 186 object {HF_Wall  translate <0,0,-0.8>}