>> Thanks to all the people who answered my previous message. But I have
>> to be more specific: I'm looking for a model to render without any
>> trick. I want all the triangles described individually in memory,
>> without sharing of indentical objetcs. My goal is to test a parallel
>> renderer that is developed in my lab. So, I need to know how many
>> triangle is a really big model? Is our renderer able to raytrace a
>> model that isn't raytracable with other renderers? Additionally, if
>> one of you could give me such a big model, it will be really helpful
>> (under NDA if necessary).
> It really is mostly about memory. If your model fits in the CPU's cache,
> it is small. If it fits in main memory, you might think it could be called
> big. If it is many times the size of main memory, then it should rightly be
> called "big".
> If a triangle is specified by three three-tuples of single precision.
> floating point, each triangle is 36 bytes. That means you get about
> 28 million of them to the gigabyte. Most vertices of course will be
> shared in dense triangle meshes, so you'll probably get a few more per
> gigabyte, but in any realistic renderer you'll have color and texture
> coordinate overheads per vertex as well, so perhaps it isn't a bad
I spent a fair amount of time some years ago trying to optimize a
ray-tracer for minimal memory use. Using all the tricks I was able to come
up with, I was able to get it down to a total of 40 bytes per triangle.
This includes *all* overhead, including that triangle's share of ray
acceleration data structure size, etc--in other words:
total memory use of ray-tracer / total number of triangles ~= 40.
The key things to do to make this happen included sharing
vertices/normals/texture coordinates, as Mark noted above, and using
Michael Deering's technique for encoding normal vectors in a small number
of bits. Obviously surface shaders and transformations weren't stored
per-triangle, but per collection-of-triangles that had the same
shader/transformation. Finally, rather than using 3 ints to store vertex
indices, I used chars, shorts, or ints, depending on how many vertices
there were in a collection of triangles.
The resulting ray-tracer rendered a scene with 46 million triangles in
about 300MB of memory, and one with 9.6 million triangles in 50MB, without
using any instancing/shared geometry. Obviously not all of those
primitives were ever in memory at once--they key was to develop some
techniques so that the renderer didn't need to have the whole scene in
memory at once. See the following for all of the details...
In a cruel and evil world, being cynical can allow you to get some
entertainment out of it. --Daniel Waters