Greetings Advanced Users !

  I have a scene rendering that has been going now for 24 hours. It has
several levels of recursion and has deeply nested CSG operations. To
decrease the rendering time I added manual bounding to the differencing
objects. This gave me a decent increase of rendering time at 1 level of
recursion when I was testing to see if manual bounding would help.

  However since I bumped the recursion level up to a depth of 5 my
render time has decreased to a point of being unacceptable and I am
likely to stop my current session and just give up on it. I calculate
at it's current rendering rate of 4 hours per line with 412 lines to
go it will take 69 days to finish. My question then is should I turn
automatic bounding off when manual bounding has been used in the scene
file or will the manual bounding simply override any automatic bounding
that would normally occur ?

  In my current bounding scheme I have the objects that are subtracting
from the original shape bounded individually and I have also bounded the
shape that is being differenced. Another question would be is when to bound
a shape in an operation for optimum performance. There are often several
ways of adding bounding and I am not sure when or where it should be
applied. Will manual bounding at the wrong place hurt the process when
a certain number of csg operations if reached as opposed to being an aid
in a simple operation ?
 I would be more than happy to post the source for anyone willing to look
at it but it is a bit lengthy to add to this post without first seeing an
interest in it.

A skeleton example of the bounding scheme I am currently using is:

// the cutting objects
#declare Diff_shape =

intersection {
      object { obj1 }
      object { obj2 }
  bounded_by {
      object { obj3 }
             }
// bound the cutting shape
#declare Diff_Shape_bound = object { Diff_Shape }

// The shape being cut
#declare Diff_Obj = object { obj4 }

// A bounding shape for the shape being cut
#declare Diff_Obj_Bound = object { Diff_Obj }

Then I have a complicated recursive while loop to difference the Diff_obj.

// The differencing operation
#declare Final_Shape =
difference {
Loop stuff
    object { Diff_Obj }
     union {
    object { Diff_Shape }
bounded_by {
    object { Diff_Shape_bound }
           }
#end loop stuff      }

// And finaly bound the entire object after the difference operation.
    object { Final_Shape
bounded_by {
    object { Diff_Obj_Bound }
           }

Is this complicating things overly much ? It really seemed to help when I used
lower recursion depths but when going higher it has basicaly stalled out.

-- 
Ken Tyler

See my 700+ Povray and 3D Rendering and Raytracing Links at:
http://home.pacbell.net/tylereng/index.html

Post a reply to this message