A few weeks ago I almost made a similiar suggestion for a different reason.  I
didn't post it for some reason, not sure why though.

I was going to comment that a point primitive would be a very useful object
for use in meshes and bicubic patches.  We really need something there that
can accept transformations.

This was to compliment a new way of tranforming object; bones.  A bone would
have a start (pivot point) and an end point.  Objects attached to the bone
would inherit it's transformations.  A bone would typically be declared at the
beginning of a scene, then used multiple times on point primitives.

If this sounds stupid, think about this - you have 1000 points that change
rotation and position 100 times over the course of an animation.  They all
rotate and translate the same way, but you need to do specify the same
tranforms for each one, meaning the scene file must contain a million
transformations!

I suppose the same thing could be handled using strings, but I think this is a
lot easier.  It certainly would be nice if there was a way for some quality
animations programs had an easy route to converting to the POV-Ray format.

I'll admit that I haven't thought it all through yet, but you seem to have a
similiar idea, so I thought I'd just throw this one out there.

-Mike

Mikael Carneholm wrote:

> One thing I've been thinking of that could make some things easier (for
> beginners as well as for advanced users) is a new object type: a point
> object.
>
> syntax is POINT{[POINT IDENTIFIER][POINT LOCATION]}
>
> ..where the point identifier is used to name the object for future
> reference.
>
> "Why?" some might say - well here's an example:
>
> I made a demo scene for my smoke generation macro, consisting of a
> rotating cube with 8 smoke sources (one in each corner). This is how it
> could have been done (if there was such an object):
>
> union{
>   RoundedCubeObject
>   point{point1,<1,1,1>}
>   point{point2,<1,1,-1>}
>   point{point3,<-1,1,-1>}
>   point{point4,<-1,1,1>}
>   point{point5,<1,-1,1>}
>   point{point6,<1,-1,-1>}
>   point{point7,<-1,-1,-1>}
>   point{point8,<-1,-1,1>}
>   rotate <clock*360,clock*360,clock*360> // affects the point objects as
> well
> }
>
> With a little OO thrown in, it would then be possible to do this:
>
> #declare obj_pos=point1.location;
> #include "SmokeGen.inc"
>
> #declare obj_pos=point2.location;
> #include "SmokeGen.inc"
>
> --
>
> #declare obj_pos=point8.location;
> #include "SmokeGen.inc"
>
> This way, you don't have to deal with math(which I believe keeps some
> users from using POV today).
>
> Instead, I had to make a vector array where the vectors are redeclared
> using a rotation identifier and also use vrotate() (which I don't mind
> using but beginners might have a hard time using). Quite messy.
>
> Comments?
>
> - Mikael.
>
> -----------------------------------------------------------------
> Mikael Carneholm
> Dep. of Computer Science

>
> http://www.studenter.hb.se/~arch
> E-mail: sa9### [at] idautbhbse
>
>   ------------------------------------------------------------------------
>
>   Mikael Carneholm <sa9### [at] idautbhbse>
>   Student

>   IDA
>
>   Mikael Carneholm
>   Student            <sa9### [at] idautbhbse>

>   IDA
>                      Netscape Conference Address
>                      Netscape Conference DLS Server
>   Additional Information:
>   Last Name   Carneholm
>   First Name  Mikael
>   Version     2.1

Post a reply to this message