"St." <dot### [at] dotcom> wrote:
> "Bill Pragnell" <bil### [at] hotmailcom> wrote in message
> news:web.43ba7abd7585287e731f01d10@news.povray.org...
>
> > Who wants to guess how long it took to render?
>
>      .099 zillion hours?  ;)

Actually, the very first guess of 108 minutes is closest - almost dead-on.
15 minutes of that is parse time, however! If I turn radiosity off, it only
takes about 25 minutes. This nicely illustrates how fast meshes can be
rendered: yes folks, 'tis 100% triangles!

There's been quite a lot of comment on the darkness of the scene. I wanted
it dark, but maybe not quite this dark - I rendered it on my iBook, which
has a very bright screen compared to my office PC (perhaps I should turn it
down a bit...). As mentioned above, this image does use radiosity, and I
can just dimly make out detail in the shadowed areas on my monitor.

Up/down - I can easily add a railing below(?) the steps as well, but I'm
concerned that it might make the image too busy. I'll try it and see what
it looks like. Next job: people.

Right, I'd better get knotted ;)

Bill

Post a reply to this message

"Ross" <rli### [at] everestkcnet> wrote:
> excellent! i really like the lighting, but I think the background could be
> more interesting.

Yeah, sorry. I never know what to do with backgrounds on disembodied
constructs like this... I don't want to make it too busy 'cos it distracts
from the foreground, so I just end up with something plain but non-uniform.

Any ideas?

Post a reply to this message

"Bill Pragnell" <bil### [at] hotmailcom> wrote in message
news:web.43bbb41b8e10781731f01d10@news.povray.org...
> "Ross" <rli### [at] everestkcnet> wrote:
> > excellent! i really like the lighting, but I think the background could
be
> > more interesting.
>
> Yeah, sorry. I never know what to do with backgrounds on disembodied
> constructs like this... I don't want to make it too busy 'cos it distracts
> from the foreground, so I just end up with something plain but
non-uniform.
>
> Any ideas?
>

The only idea I had was to have it lying on a table as though you just
constructed it as a toy model. but then you may not get the great dramatic
lighting that you currently have.

Post a reply to this message

On Tue, 03 Jan 2006 08:23:09 -0500, Bill Pragnell wrote:

> Seasonal salutations to you all.
> 
> Following on from my tentative trefoil knot last year, here is a more recent
> and complete version. It still lacks people, and may well be altered
> somewhat in the field of texturing, but it looks pretty damn dramatic I
> reckon.
> 
> Who wants to guess how long it took to render?
> 
> Bill

I see no evidence of radiousity, so I guess 30 minutes
to an hour?

Amazing pic.  I like the colored lighting.

How the heck do you make this shape in POV-Ray?
My attempts at this have been ... lame  ;)

-- 
to all the companies who wait until a large user base becomes
dependant on their freeware, then shafting said happy campers with
mandatory payment for continued usage. I spit on your grave.

Post a reply to this message

povray <pov### [at] almostbestwebnet> wrote:
> I see no evidence of radiousity, so I guess 30 minutes
> to an hour?
There was radiosity, just very dim. As mentioned, ~25 minutes with radiosity
turned off.

> How the heck do you make this shape in POV-Ray?
It's a parametric curve:
x=sin(a)+2sin(2a)
y=sin(3a)
z=cos(a)-2cos(2a)
0 > a > 2pi

Which is the easy bit. I wrote a macro to evenly space objects in distance
rather than angle, and some macros from transforms.inc are used to align
them with the path. Each brick is an individual mesh object, selected at
random from an array of 10 with different textures. The same goes for the
steps. The handrail is a series of meshes, one per step, which are basically
square prisms...

I can post the code if anybody wants, although I've not finished tinkering
with it yet...!

Bill

Post a reply to this message

In response to the darkness, here's a "daylight" version.

Post a reply to this message

Attachments:
Download 'trefoil_day.jpg' (297 KB)

Preview of image 'trefoil_day.jpg'

"Bill Pragnell" <bil### [at] hotmailcom> schreef in bericht
news:web.43bcf5a68e10781731f01d10@news.povray.org...
> In response to the darkness, here's a "daylight" version.
>
Terrific! Although I prefer the dark version.

It must be a terrible experience for those people condemned to walk these
stairs! I get somewhat light in the head! :-)

Thomas

Post a reply to this message

"Bill Pragnell" <bil### [at] hotmailcom> wrote in message
news:web.43bcf1ff8e10781731f01d10@news.povray.org...
>
> I can post the code if anybody wants, although I've not finished tinkering
> with it yet...!
>

Please, I'd love to play with it.

Post a reply to this message

"Gail Shaw" <gsh### [at] sentechsacom> wrote:
> "Bill Pragnell" <bil### [at] hotmailcom> wrote in message
> news:web.43bcf1ff8e10781731f01d10@news.povray.org...
> > I can post the code if anybody wants, although I've not finished tinkering
> > with it yet...!
> Please, I'd love to play with it.

Right, here's the whole thing so far. It's the complete scene, which is
obviously more complicated than single object placement. I've included the
brick macro I used as well (not smoothed, sadly). It's a bit involved, and
some of the numbers in the stair set-up are critical to the start/finish
meeting each other neatly, but hopefully you get the idea. If you have any
problems with any of it feel free to email me or post a query.
Here goes... :)

#include "colors.inc"
#include "shapes.inc"
#include "math.inc"
#include "transforms.inc"

camera {
  location <0, 26, 0.05>
  up <0, 1, 0>
  right <4/3, 0, 0>
  direction <0, 0, FoV_30>
  look_at <0, 0, -0.5> }

light_source { <-70, 50, -100> color rgb 2*<0.25,0.75,1> }
light_source { <100, 0, 0> color rgb 2*<1,0.25,0> }

// rectangle mesh macro
#macro Rect(p1, p2, p3, p4)
  triangle { p1, p2, p3 }
  triangle { p1, p3, p4 }
#end

// rough rounded box mesh macro
#macro RoundedBox_M(xs, ys, zs, r)
  #local rb = r*(1 - sin(radians(45)));
  mesh {
  // near face
  Rect( <-xs+r, -ys+r, -zs>, <-xs+r, ys-r, -zs>, <xs-r, ys-r, -zs>, <xs-r,
-ys+r, -zs> )
  // near top horizontal curve
  Rect( <-xs+r, ys-r, -zs>, <-xs+r, ys-rb, -zs+rb>, <xs-r, ys-rb, -zs+rb>,
<xs-r, ys-r, -zs> )
  Rect( <-xs+r, ys-rb, -zs+rb>, <-xs+r, ys, -zs+r>, <xs-r, ys, -zs+r>,
<xs-r, ys-rb, -zs+rb> )
  // near bottom horizontal curve
  Rect( <-xs+r, -ys+rb, -zs+rb>, <-xs+r, -ys+r, -zs>, <xs-r, -ys+r, -zs>,
<xs-r, -ys+rb, -zs+rb> )
  Rect( <-xs+r, -ys, -zs+r>, <-xs+r, -ys+rb, -zs+rb>, <xs-r, -ys+rb,
-zs+rb>, <xs-r, -ys, -zs+r> )
  // near left vertical curve
  Rect( <-xs+r, -ys+r, -zs>, <-xs+rb, -ys+r, -zs+rb>, <-xs+rb, ys-r,
-zs+rb>, <-xs+r, ys-r, -zs> )
  Rect( <-xs+rb, -ys+r, -zs+rb>, <-xs, -ys+r, -zs+r>, <-xs, ys-r, -zs+r>,
<-xs+rb, ys-r, -zs+rb> )
  // near right vertical curve
  Rect( <xs-r, -ys+r, -zs>, <xs-rb, -ys+r, -zs+rb>, <xs-rb, ys-r, -zs+rb>,
<xs-r, ys-r, -zs> )
  Rect( <xs-rb, -ys+r, -zs+rb>, <xs, -ys+r, -zs+r>, <xs, ys-r, -zs+r>,
<xs-rb, ys-r, -zs+rb> )
  // top face
  Rect( <-xs+r, ys, -zs+r>, <-xs+r, ys, zs-r>, <xs-r, ys, zs-r>, <xs-r, ys,
-zs+r> )
  // left top long curve
  Rect( <-xs+r, ys, -zs+r>, <-xs+rb, ys-rb, -zs+r>, <-xs+rb, ys-rb, zs-r>,
<-xs+r, ys, zs-r> )
  Rect( <-xs+rb, ys-rb, -zs+r>, <-xs, ys-r, -zs+r>, <-xs, ys-r, zs-r>,
<-xs+rb, ys-rb, zs-r> )
  // right top long curve
  Rect( <xs-r, ys, -zs+r>, <xs-r, ys, zs-r>, <xs-rb, ys-rb, zs-r>, <xs-rb,
ys-rb, -zs+r> )
  Rect( <xs-rb, ys-rb, -zs+r>, <xs-rb, ys-rb, zs-r>, <xs, ys-r, zs-r>, <xs,
ys-r, -zs+r> )
  // left bottom long curve
  Rect( <-xs, -ys+r, -zs+r>, <-xs+rb, -ys+rb, -zs+r>, <-xs+rb, -ys+rb,
zs-r>, <-xs, -ys+r, zs-r> )
  Rect( <-xs+rb, -ys+rb, -zs+r>, <-xs+r, -ys, -zs+r>, <-xs+r, -ys, zs-r>,
<-xs+rb, -ys+rb, zs-r> )
  // right bottom long curve
  Rect( <xs, -ys+r, -zs+r>, <xs, -ys+r, zs-r>, <xs-rb, -ys+rb, zs-r>,
<xs-rb, -ys+rb, -zs+r> )
  Rect( <xs-rb, -ys+rb, -zs+r>, <xs-rb, -ys+rb, zs-r>, <xs-r, -ys, zs-r>,
<xs-r, -ys, -zs+r> )
  // bottom face
  Rect( <-xs+r, -ys, -zs+r>, <xs-r, -ys, -zs+r>, <xs-r, -ys, zs-r>, <-xs+r,
-ys, zs-r> )
  // left face
  Rect( <-xs, ys-r, -zs+r>, <-xs, -ys+r, -zs+r>, <-xs, -ys+r, zs-r>, <-xs,
ys-r, zs-r> )
  // right face
  Rect( <xs, ys-r, -zs+r>, <xs, ys-r, zs-r>, <xs, -ys+r, zs-r>, <xs, -ys+r,
-zs+r> )
  // back face
  Rect( <-xs+r, -ys+r, zs>, <xs-r, -ys+r, zs>, <xs-r, ys-r, zs>, <-xs+r,
ys-r, zs> )
  // back top horizontal curve
  Rect( <-xs+r, ys-r, zs>, <xs-r, ys-r, zs>, <xs-r, ys-rb, zs-rb>, <-xs+r,
ys-rb, zs-rb> )
  Rect( <-xs+r, ys-rb, zs-rb>, <xs-r, ys-rb, zs-rb>, <xs-r, ys, zs-r>,
<-xs+r, ys, zs-r> )
  // back bottom horizontal curve
  Rect( <-xs+r, -ys+r, zs>, <-xs+r, -ys+rb, zs-rb>, <xs-r, -ys+rb, zs-rb>,
<xs-r, -ys+r, zs> )
  Rect( <-xs+r, -ys+rb, zs-rb>, <-xs+r, -ys, zs-r>, <xs-r, -ys, zs-r>,
<xs-r, -ys+rb, zs-rb> )
  // back left vertical curve
  Rect( <-xs+r, ys-r, zs>, <-xs+rb, ys-r, zs-rb>, <-xs+rb, -ys+r, zs-rb>,
<-xs+r, -ys+r, zs> )
  Rect( <-xs+rb, ys-r, zs-rb>, <-xs, ys-r, zs-r>, <-xs, -ys+r, zs-r>,
<-xs+rb, -ys+r, zs-rb> )
  // back right vertical curve
  Rect( <xs-r, ys-r, zs>, <xs-r, -ys+r, zs>, <xs-rb, -ys+r, zs-rb>, <xs-rb,
ys-r, zs-rb> )
  Rect( <xs-rb, ys-r, zs-rb>, <xs-rb, -ys+r, zs-rb>, <xs, -ys+r, zs-r>, <xs,
ys-r, zs-r> )
  // near top left corner
  triangle { <-xs+r, ys, -zs+r>, <-xs+r, ys-rb, -zs+rb>, <-xs+rb, ys-rb,
-zs+r> }
  triangle { <-xs+r, ys-rb, -zs+rb>, <-xs+r, ys-r, -zs>, <-xs+rb, ys-r,
-zs+rb> }
  triangle { <-xs+rb, ys-rb, -zs+r>, <-xs+rb, ys-r, -zs+rb>, <-xs, ys-r,
-zs+r> }
  triangle { <-xs+r, ys-rb, -zs+rb>, <-xs+rb, ys-r, -zs+rb>, <-xs+rb, ys-rb,
-zs+r> }
  // near top right corner
  triangle { <xs-r, ys, -zs+r>, <xs-rb, ys-rb, -zs+r>, <xs-r, ys-rb, -zs+rb>
}
  triangle { <xs-r, ys-rb, -zs+rb>, <xs-rb, ys-r, -zs+rb>, <xs-r, ys-r, -zs>
}
  triangle { <xs-rb, ys-rb, -zs+r>, <xs, ys-r, -zs+r>, <xs-rb, ys-r, -zs+rb>
}
  triangle { <xs-rb, ys-rb, -zs+r>, <xs-rb, ys-r, -zs+rb>, <xs-r, ys-rb,
-zs+rb> }
  // near bottom left corner
  triangle { <-xs+r, -ys+r, -zs>, <-xs+r, -ys+rb, -zs+rb>, <-xs+rb, -ys+r,
-zs+rb> }
  triangle { <-xs+rb, -ys+r, -zs+rb>, <-xs+rb, -ys+rb, -zs+r>, <-xs, -ys+r,
-zs+r> }
  triangle { <-xs+rb, -ys+rb, -zs+r>, <-xs+r, -ys+rb, -zs+rb>, <-xs+r, -ys,
-zs+r> }
  triangle { <-xs+rb, -ys+rb, -zs+r>, <-xs+rb, -ys+r, -zs+rb>, <-xs+r,
-ys+rb, -zs+rb> }
  // near bottom right corner
  triangle { <xs-r, -ys+r, -zs>, <xs-rb, -ys+r, -zs+rb>, <xs-r, -ys+rb,
-zs+rb> }
  triangle { <xs, -ys+r, -zs+r>, <xs-rb, -ys+r, -zs+rb>, <xs-rb, -ys+rb,
-zs+r> }
  triangle { <xs-r, -ys, -zs+r>, <xs-r, -ys+rb, -zs+rb>, <xs-rb, -ys+rb,
-zs+r> }
  triangle { <xs-r, -ys+rb, -zs+rb>, <xs-rb, -ys+r, -zs+rb>, <xs-rb, -ys+rb,
-zs+r> }
  // far top left corner
  triangle { <-xs+r, ys, zs-r>, <-xs+rb, ys-rb, zs-r>, <-xs+r, ys-rb, zs-rb>
}
  triangle { <-xs, ys-r, zs-r>, <-xs+rb, ys-r, zs-rb>, <-xs+rb, ys-rb, zs-r>
}
  triangle { <-xs+r, ys-r, zs>, <-xs+rb, ys-r, zs-rb>, <-xs+r, ys-rb, zs-rb>
}
  triangle { <-xs+rb, ys-r, zs-rb>, <-xs+rb, ys-rb, zs-r>, <-xs+r, ys-rb,
zs-rb> }
  // far top right corner
  triangle { <xs-r, ys, zs-r>, <xs-r, ys-rb, zs-rb>, <xs-rb, ys-rb, zs-r> }
  triangle { <xs-r, ys-r, zs>, <xs-rb, ys-r, zs-rb>, <xs-r, ys-rb, zs-rb> }
  triangle { <xs, ys-r, zs-r>, <xs-rb, ys-r, zs-rb>, <xs-rb, ys-rb, zs-r> }
  triangle { <xs-rb, ys-r, zs-rb>, <xs-rb, ys-rb, zs-r>, <xs-r, ys-rb,
zs-rb> }
  // far bottom left corner
  triangle { <-xs+r, -ys+r, zs>, <-xs+rb, -ys+r, zs-rb>, <-xs+r, -ys+rb,
zs-rb> }
  triangle { <-xs+r, -ys, zs-r>, <-xs+r, -ys+rb, zs-rb>, <-xs+rb, -ys+rb,
zs-r> }
  triangle { <-xs, -ys+r, zs-r>, <-xs+rb, -ys+rb, zs-r>, <-xs+rb, -ys+r,
zs-rb> }
  triangle { <-xs+rb, -ys+rb, zs-r>, <-xs+r, -ys+rb, zs-rb>, <-xs+rb, -ys+r,
zs-rb> }
  // far bottom right corner
  triangle { <xs-r, -ys, zs-r>, <xs-rb, -ys+rb, zs-r>, <xs-r, -ys+rb, zs-rb>
}
  triangle { <xs, -ys+r, zs-r>, <xs-rb, -ys+r, zs-rb>, <xs-rb, -ys+rb, zs-r>
}
  triangle { <xs-r, -ys+r, zs>, <xs-r, -ys+rb, zs-rb>, <xs-rb, -ys+r, zs-rb>
}
  triangle { <xs-r, -ys+rb, zs-rb>, <xs-rb, -ys+rb, zs-r>, <xs-rb, -ys+r,
zs-rb> } }
#end

#macro Knot_Pos(a)
  (<sin(a) + 2*sin(2*a), sin(3*a), cos(a) - 2*cos(2*a)>)
#end

// find knot length
#declare b = 0;
#declare db = 2*pi/10000;
#declare dist = 0;
#while (b <= 2*pi)
  #declare dpos1 = Knot_Pos(b);
  #declare dpos2 = Knot_Pos(b+db);
  #declare dist = dist + vlength(dpos2-dpos1);
  #declare b = b + db;
#end
#declare length = dist;

// set up brick array
#declare arraysize = 10;
#declare dlength = length/500;
#declare r1 = seed(1);
#declare ba = array[arraysize];
#declare c = 0;
#while (c < arraysize)
  #declare ba[c] = object {
    RoundedBox_M(0.03, dlength/2, 0.01, 0.005)
    pigment { color rgb rand(r1)*0.6+0.4 }
    finish { ambient 0 }
    normal { granite 0.2 scale rand(r1)*0.2 } }
  #declare c = c + 1;
#end

// brickknot
#declare nbricks = 50;
#declare b = 0;
#declare dbi = 0.0001;
#declare dist = 0;
#declare ob = b;
#declare ang = 0;
#declare dang = 360/nbricks;
#declare ap = 0;
#while (b <= 2*pi)
  #declare dpos1 = Knot_Pos(b);
  #declare dpos2 = Knot_Pos(b+dbi);
  #declare dist = dist + vlength(dpos2-dpos1);
  #if (dist >= dlength)
    #declare nb = b;
    #declare dir = Knot_Pos(nb) - Knot_Pos(ob);
    #declare midpos = Knot_Pos(ob + (nb-ob)/2);
    #declare axis = VPerp_To_Plane(dir,y);
    #declare rot = VRotationD(y,dir,axis);
    #while (ap < nbricks)
      object {
        ba[rand(r1)*arraysize]
        rotate <0, rand(r1)*10-5, 0>
        translate <0, 0, -0.5>
        rotate <0, ang, 0>
        Axis_Rotate_Trans(axis, rot)
        translate midpos }
      #declare ap = ap + 1;
      #declare ang = ang + dang;
    #end
    #declare dist = 0;
    #declare ob = nb;
    #declare ap = 0;
    // bet you can't guess what the next line does!
    #declare ang = ang + ((cos(3*b)+1)/2)*dang/2;
  #end
  #declare b = b + dbi;
#end

// set up stair array
#declare arraysize = 10;
#declare dlength = length/1051;
#declare sa = array[arraysize];
#declare c = 0;
#declare col = MediumWood;
#while (c < arraysize)
  #declare sa[c] = object {
    RoundedBox_M(0.65, dlength/2, 0.05, 0.005)
    pigment { color rgb col*(rand(r1)*0.6+0.4) }
    finish { ambient 0 }
    normal { granite 0.2 scale <rand(r1)*0.5+0.5, 0.1, 0.1> } }
  #declare c = c + 1;
#end

// handrail post
#declare Post = mesh {
  Rect( <-0.005, 0, -0.005>, <-0.005, 0.12, -0.005>, <0.005, 0.12, -0.005>,
<0.005, 0, -0.005> )
  Rect( <0.005, 0, -0.005>, <0.005, 0.12, -0.005>, <0.005, 0.12, 0.005>,
<0.005, 0, 0.005> )
  Rect( <0.005, 0, 0.005>, <0.005, 0.12, 0.005>, <-0.005, 0.12, 0.005>,
<-0.005, 0, 0.005> )
  Rect( <-0.005, 0, 0.005>, <-0.005, 0.12, 0.005>, <-0.005, 0.12, -0.005>,
<-0.005, 0, -0.005> )
  pigment { color Gray40 }
  finish { ambient 0 } }

// handrail cross-sections
#declare pos1_1 = <-0.64, 0.115, 0>;
#declare pos1_2 = <-0.64, 0.125, 0>;
#declare pos1_3 = <-0.62, 0.125, 0>;
#declare pos1_4 = <-0.62, 0.115, 0>;
#declare pos2_1 = <0.62, 0.115, 0>;
#declare pos2_2 = <0.62, 0.125, 0>;
#declare pos2_3 = <0.64, 0.125, 0>;
#declare pos2_4 = <0.64, 0.115, 0>;

// stairs
#declare b = 0;
#declare dbi = 0.00001;
#declare dist = 0;
#declare cdist = 0;
#declare ob = b;
#declare ang = 0;
#declare dang = 360/75;
#declare totalsteps = 0;
#while (cdist <= length+dlength)
  #declare dpos1 = Knot_Pos(b);
  #declare dpos2 = Knot_Pos(b+dbi);
  #declare dist = dist + vlength(dpos2-dpos1);
  #if (dist >= dlength)
    // calculate knot path location
    #declare nb = b;
    #declare dir = Knot_Pos(nb) - Knot_Pos(ob);
    #declare midpos = Knot_Pos(ob + (nb-ob)/2);
    #declare axis = VPerp_To_Plane(dir,y);
    #declare rot = VRotationD(y,dir,axis);
    #if (totalsteps > 0)
      #declare tran_old = tran;
    #end
    #declare tran = transform {
      rotate <0, ang, 0>
      Axis_Rotate_Trans(axis, rot)
      translate midpos }
    #if (totalsteps = 0)
      #declare tran_old = tran;
    #end
    // place stair
    object {
      sa[rand(r1)*arraysize]
      transform { tran } }
    // place handrail post
    #if (mod(totalsteps,3) = 0)
      object {
        Post
        translate <-0.63, 0, 0>
        transform { tran } }
      object {
        Post
        translate <0.63, 0, 0>
        transform { tran } }
    #end
    // grow handrails
    #declare oldpos1 = vtransform(pos1_1, tran_old);
    #declare oldpos2 = vtransform(pos1_2, tran_old);
    #declare oldpos3 = vtransform(pos1_3, tran_old);
    #declare oldpos4 = vtransform(pos1_4, tran_old);
    #declare newpos1 = vtransform(pos1_1, tran);
    #declare newpos2 = vtransform(pos1_2, tran);
    #declare newpos3 = vtransform(pos1_3, tran);
    #declare newpos4 = vtransform(pos1_4, tran);
    mesh {
      Rect(oldpos1, oldpos2, newpos2, newpos1)
      Rect(oldpos2, oldpos3, newpos3, newpos2)
      Rect(oldpos3, oldpos4, newpos4, newpos3)
      Rect(oldpos4, oldpos1, newpos1, newpos4)
      pigment { color DarkWood }
      finish { ambient 0 } }
    #declare oldpos1 = vtransform(pos2_1, tran_old);
    #declare oldpos2 = vtransform(pos2_2, tran_old);
    #declare oldpos3 = vtransform(pos2_3, tran_old);
    #declare oldpos4 = vtransform(pos2_4, tran_old);
    #declare newpos1 = vtransform(pos2_1, tran);
    #declare newpos2 = vtransform(pos2_2, tran);
    #declare newpos3 = vtransform(pos2_3, tran);
    #declare newpos4 = vtransform(pos2_4, tran);
    mesh {
      Rect(oldpos1, oldpos2, newpos2, newpos1)
      Rect(oldpos2, oldpos3, newpos3, newpos2)
      Rect(oldpos3, oldpos4, newpos4, newpos3)
      Rect(oldpos4, oldpos1, newpos1, newpos4)
      pigment { color DarkWood }
      finish { ambient 0 } }
    // increment counters
    #declare ang = ang + dang;
    #declare cdist = cdist + dist;
    #declare dist = 0;
    #declare ob = nb;
    #declare totalsteps = totalsteps + 1;
  #end
  #declare b = b + dbi;
#end

Post a reply to this message

On Thu, 05 Jan 2006 05:17:42 -0500, Bill Pragnell wrote:

>> How the heck do you make this shape in POV-Ray?
> It's a parametric curve:
> x=sin(a)+2sin(2a)
> y=sin(3a)
> z=cos(a)-2cos(2a)
> 0 > a > 2pi
> 

Woa.  Cool.  Thanks  :D



-- 
to all the companies who wait until a large user base becomes
dependant on their freeware, then shafting said happy campers with
mandatory payment for continued usage. I spit on your grave.

Post a reply to this message