"Jim Charter" <jrc### [at] msncom> schreef in bericht 
news:47be32fb@news.povray.org...
> Hi Thomas, glad to see you are back on this.  I couldn't resist playing
> around a bit because I thought the antique ruins an interesting subject
> and also I wanted to throw one more idea into your toolkit.
> I wanted to play with a method for applying texture which would vary
> with the surface.  As you know, one of the usual ways used is the slope
> pattern, another is to use methods that share the same pattern for both
> distorting a surface (either perturbing the normals or actual
> isosurface), and texturing the surface.  Another method I wanted to try
> was to use the average of a number of object patterns based on the
> object being textured.  Here I used a cylinder of diameter less than
> that of the column and averaged a number of scale changes to create some
> grunge in the column flutes.  I used your lichen pattern for the grunge
> just because it was handy.  I hope this wasn't too presumptuous on my 
> part.
>

This is looking very good Jim! Especially the grunge which is a natural 
feature you will see often in flutes. I see a weekend of experimentation 
before me to get familiar with your's and Kirk's techniques. Especially the 
cylindrical pattern looks interesting to me.

Thanks for thinking along with me! :-)

Thomas

Post a reply to this message

Thomas de Groot wrote:

> Thanks for thinking along with me! :-)
> 
Cool.

I see that you are right, in this case the 'cylindrical' pattern
can probably be used to do the same thing.

What I actually used and wanted to point out to you was the 'object'
pattern, within which I used a cylinder shape.

Anyway here is the code abbreviated.  There still may be ways in
which the approach gives more control.



//define the 'object' pattern
//here it is a cylinder, often I
//the object I am texturing itself
#local Pigment_Object =
pigment {
   average
   pigment_map {
   #local I=0;#while(I<30)
     [1
       object {
         cylinder {-.45*y,
		.45*y,
		.80 		//a little smaller
                         	//than the Column_Barrel

           scale x*.9    	//skew it a bit

           scale 1+.3*rand(S)    //randomize through the
                                 //iterations
         }
         pigment { rgb 0 }  //outside
         pigment { rgb 1 }  //inside
       }
     ]
   #local I=I+1;#end
   }
   turbulence .1
};


#local Grunge =
texture {
   pigment {
     pigment_pattern { Pigment_Object }
     pigment_map {
       [0 rgbt 1]
       [1 P_Lichen]
     }
   }
};

//stack up some Column_Barrels
#local A=0;#while(A<5)

   object{
     Column_Barrel

     texture{T_Marble translate y*rand(S)}

     //take advantage of the transparent areas of the
     //texture to layer some random translations
     #local I=0;#while(I<15)
       texture{
         Grunge
         translate y*(1-2*rand(S))
       }
     #local I=I+1;#end

     rotate y*rand(S) //one degree random rotation
     rotate y*(int(rand(S)*2)*24) //two flutes of
                                  //random rotation

   }

#local A=A+1;#end

Post a reply to this message

"Kirk Andrews" <kir### [at] tektonartcom> schreef in bericht 
news:web.47bda203d1c20822af0d79570@news.povray.org...

> Also, I really think you need to use some isosurfaces to difference out 
> broken
> chunks of your columns.  I think that would add a lot of realism to the 
> scene.
>

As a first possibility, I have explored the use of isosurfaces for the whole 
column segment. As can be expected, for rendering a whole field of columns 
this way, render time is going to be preposterously long, even although the 
segments look good. Try this code and play with the max_gradient as you need 
to increase that to obtain smooth results:

//start code
#declare f_cyl = function {pow(x,2) + pow(y,2) + pow(z,2) - 1}
#declare f_flute = function {f_cyl(x*10-10, 0, z*10)}
// a square hole on top and bottom of the column segment:
#declare f_hole = function {max((y*y-1),(x*x-1),(z*z-1)) }

#declare f_rough = function{f_wrinkles(x*.4, y*.4, z*.4)}

#declare Angle = 15;
#declare Flutes = 0;

isosurface {
function {max(f_cyl(x, 0, z),
              -f_hole(y,x*8,z*8),
              -f_hole(y-10,x*8,z*8)
              #if (Flutes)
              ,
              -f_flute(x, 0, z),
              #while (Angle<345)
                -f_flute(x*cos(radians(Angle)) - z*sin(radians(Angle)), 0, 
x*sin(radians(Angle)) + z*cos(radians(Angle))),
                #local Angle = Angle+15;
              #end //of Angle
              #local Angle = Angle+15;
              -f_flute(x*cos(radians(Angle)) - z*sin(radians(Angle)), 0, 
x*sin(radians(Angle)) + z*cos(radians(Angle)))
              #end //of flutes
          )
          + f_rough(x, y, z)*0.3
         }
  max_gradient 10.0
  contained_by {box {<-1, 0, -1>, < 1, 1, 1>}}
  accuracy 1e-3
  rotate <0,0,0>
}
//end code

Thomas

Post a reply to this message