How can I evaluate and visualize code instead of running it


#1

I am using a tree and traversing down a tree to generate opengl code
How could I easily list the opengl code that I am generating, instead
of running it?

def applytransform
GL.PushMatrix();
GL.Translate(@Translation);
GL.Translate(
@jointP);
if @parent != nil
GL.Translate(@parentjointP);
end
GL.Rotate(
@rotation);
GL.Translate(*@jointP.minus);
end

def traversetree
GL.Clear(GL::COLOR_BUFFER_BIT);
GL.PushMatrix();
applytransform
@children.each {|childnode| childnode.traversetree}
drawprimitive
GL.PopMatrix();
GLUT.SwapBuffers();
end


#2

“anne001” removed_email_address@domain.invalid schrieb im Newsbeitrag
news:removed_email_address@domain.invalid…

end
GL.PopMatrix();
GLUT.SwapBuffers();
end

I’d refactor the traversal out of the code and encapsulate actions on
tree
nodes in blocks or a specific visitor class. In your case a specific
class
might be better because you seem to need entry and exit code. Something
like:


def traversetree(visitor)
visitor.entry[self]
@children.each {|childnode| childnode.traversetree(visitor)}
visitor.exit[self]
end

GLVisitor = Struct.new(:entry, :exit)

code_runner = GLVisitor.new( lambda do |n|
GL.Clear(GL::COLOR_BUFFER_BIT)
GL.PushMatrix()
n.applytransform
end,
lambda do |n|
n.drawprimitive
GL.PopMatrix();
GLUT.SwapBuffers();
end)

code_lister = GLVisitor.new( lambda …

HTH

Kind regards

robert

#3

Thank you Robert. I can see that it would be cleaner to
separate the code from the traversing of the code. And I
see how you did it.

But I don’t see how it helps, how does “code_lister” list what is in
"code_runner? "

anne


#4

Hi,

From: “anne001” removed_email_address@domain.invalid

end
GL.PopMatrix();
GLUT.SwapBuffers();
end

Maybe one possibility:

require ‘opengl’

RealGL = GL

class LoggingGL
class << self
def method_missing(meth, *args)
puts “#{meth}(#{args.join(’, ')})”
RealGL.send(meth, *args) # remove this line if you don’t want to
really call GL
end
def const_missing(const)
RealGL.const_get(const)
end
end
end

GL = LoggingGL

#####################################

The above will turn this:

GL.MatrixMode(GL::PROJECTION)
GL.LoadIdentity
GL.Scaled(1.5, 1.2, 1.0)

Into the following output:

MatrixMode(5889)
LoadIdentity()
Scaled(1.5, 1.2, 1.0)

Hope this helps,

Bill


#5

Thank you very much Bill K. for your response.

The Key is that you are swapping what GL means. If I say
GL=LoggingGL
suddenly, I am no longer calling on OpenGL, I am calling on methods in
loggingGL

I tried it as it, as it is very easy to tag this little code to modify
the fx. The glut fx
was not modified, and it opened a window with the strangest mix of
text/image.
I could fix that by redirecting glut I think.

This will work very well. Thank you for thinking of this scheme and
taking the time to
write it all out so it works right away

thank you

Anne


#6

2006/2/21, anne001 removed_email_address@domain.invalid:

Thank you Robert. I can see that it would be cleaner to
separate the code from the traversing of the code. And I
see how you did it.

But I don’t see how it helps, how does “code_lister” list what is in
"code_runner? "

You’ll have to separate the generation code from the invocation code.
That way you can reuse the generation code in the lister and simply
print it instead of invoking it.

I don’t know GL so take this advice with a grain of salt.
It was a general advice about separating concerns
properly.

HTH

robert