| >Good question. If everyone is convinced that context-independent
| >pointers can be supported with acceptable cost (for driver development
| >and for execution at runtime), then we're done; we can take the
| >details offline. If there's a sizeable group of people who are not
| >convinced, then we need to keep going a while longer.
|
| My concern is not whether or not we can implement a context-independent
| dispatch with minimal overhead, since I'm fairly sure we have the
| collective brainpower to accomplish this. My concern is more with the fact
| that we need to devote energy to minimizing the performance impact, and
| must concoct an elaborate and potentially error prone scheme to accomplish
| this, and that context independence isn't a large enough win to justify
| this distraction.
|
| Further, I am interested in a scheme which can work cross-platform, and it
| has already been demonstrated that context independence cannot (reasonably)
| be achieved on Windows.
If the goal is to make applications be more cross platform, then that
is laudible. If the goal is to make OpenGL implementations more
cross platform, then that is considerably lower priority in my opinion.
There is an opportunity to do a good job on Linux. The fact that
a poor job has been done on Windows shouldn't be given too much sway.
I doubt anyone familar with Windows APIs would seriously argue this point.
|
| On a related note, Allen pointed out yesterday that my sample
| application-level per-context data structure which contains such things as
| the per-context extension pointers is not accessible from a general purpose
| rendering library. While this is true, I must point out that (and I think
| Steve Baker mentioned this first) the library itself needs to know whether
| or not an extension is supported before it can call a context-independent
| function pointer, and therefore is required to maintain similar per-context
| state. I still don't see how context independent pointers solves this
| problem, and if we cannot solve the whole problem its fruitless, nay, even
| misleading, to solve half of it.
The goal was to avoid bloating layered library context wrappers with copies of
function pointers and to avoid having to either copy the function pointers
into per-thread state in the layered library or always call through the
context-specific function pointer. The device independent function pointers
solve this problem and avoids having layered libraries and applications
writing function pointer management code. This is considered by many
to be a good tradeoff relative to trying to make the lives of OpenGL
libraries implementors easier.
|
| Perhaps, Allen, its time we go to lunch and work this out. Anyone else for
| a cheesesteak? =)
I'm interested in food, or arguing the point, although I much more in
favour of just moving on.
-db
