I'm curious how a system like Radiance could be fit into a set of C++
classes. There must be a way, and I'm not saying it's a bad idea,
but the general toolbox approach is standardized on a (preferably
small) set of stream data formats. I guess you would try to hook the
output of one object into the input of another, or something like
that. It seems feasible, at least in principle.
That was basically my thinking; the C++ streambuf template is a wonderful thing; one might even be able to get away with using the istrstream and ostrstream classes in many cases, preserving the existing model with very little effort. The second thought was to (in places where operations can be serialized) copy globals to class instance variables, thereby encapsulating the existing app in the class. This clearly won't work in all cases, but it might work in enough to be worth using.
Just a quick comment on your idea of implementing a mini-shell within
Radiance's scene description language -- I assume you mean this to
take care of the "!command" lines in the input, correct? In any
case, you should not underestimate the difficulties in converting
even a small number of command-line tools into library calls, as the
general assumption of separate process spaces means the use of i/o
and globals is a big mess to clean up. Personally, I can't imagine
it being worth the effort, as there would be no real gain in
functionality, and worse maintenance headaches down the line.
If it turns out to be possible, I think there would be a substantial gain in the speed of reading of scene description files because of a reduction in process creation, especially on Windows, where processes are heavyweight. Even on Unix, creating two processes for a common operation like xform seems to me a lot of overhead, especially when one of those processes is a large modern shell. I agree it would be harder to maintain--memory leaks and unbounded pointers are a pain in a large app--but not that much harder; large applications do this all the time, these days. Hopefully, it could be done with a minimum of changes to existing code. I would like to try, at least, provided I can find the time.
Taking a system like Radiance, which is based on the Unix toolbox model, and
turning it into a set of library routines, is not a weekend task. Do
you know of any examples of systems that have been successfully
converted in this way? I'd be interested to hear of any.
No, that I don't--anyone else? But it seems to me that this is at least a plausible approach, and one that preserves most of the existing code and model. I very much like the Unix toolbox model. Unfortunately, the current widely used UI technologies are hostile to that model and I would like to adapt Radiance to work with those technologies.
Anyone else have thoughts on this?
Please!
Randolph