Patrick Elliott <sel### [at] rraznet> wrote:
> b) you 
> have to reset it back to the very first state it had **prior** to any 
> transforms, then reapply **all** of them.
> the later is just 
> absolutely stupid, since you might as well not even bother applying any 
> transforms to the original object(s), until you need, just before you 
> render it.

  Then the vast majority of renderers and rendering languages (eg. OpenGL)
are "absolutely stupid" because that's exactly what they do. That's exactly
what POV-Ray does currently as well.

  At each frame they reset the transformation matrix to the unit matrix
and then apply all the (possibly modified) transformations to it. That's
standard procedure, and it's by far the simplest and easiest way of
doing it. You don't necessarily need any data container to store all
the individual transformations because the individual transformations
are in the code you write (this is often the case eg. with OpenGL).

  (Sure, you can do it in other ways too in OpenGL, but resetting the
transformation matrix and applying all the transformations to it at
each frame is a common standard way of doing things. It's simple, easy
and fast, and it doesn't require any more memory than the code itself.)

  I simply can't understand why you think this is such a "stupid" idea.
It's a very simple and working idea. It keeps things simple, it doesn't
require any memory and it's easy to implement.

> Neither of them help your case, since they both require 
> somehow "tracking" what you did to the original, or storing all your 
> transforms, including the first state, in some other array.

  No, it doesn't. Writing an OpenGL application doesn't require you to
"track" all the transformations you have applied to every single object.
When you want to render a new frame in OpenGL, you simply reset the
transformation matrix and apply the same transformations to it (with
possibly modified values). That's it.
  The new SDL doesn't need to be any different from this.

  You don't seem to grasp the idea that all the transformations are
already "stored" in the very code that applies those transformations.
You don't need to store them anywhere else. Simply re-apply the same
transformations at each frame, and there you are.

> That just leaves the absurd claim that you can somehow 
> reset a matrix to a usable state without keeping a big array with "all" 
> of the transforms in it

  The current POV-Ray manages to do it. Most OpenGL applications manage
to do it. Most other renderers manage to do it.

  Just because you can't understand how they manage to do it doesn't mean
it's not possible and easy.

-- 
                                                          - Warp

Post a reply to this message