Multi-context rendering

[Noeda]

I'm going to leave this issue here to track a problem with a way caramia (and OpenGLRaw) handle multiple OpenGL contexts.

The way things work now that all OpenGL functions are stored in top-level IORefs and when a function is called, it is fetched from IORef and called.

This works most of the time and with most drivers but some drivers report different function pointers when a new OpenGL context is set up (I've been told some drivers on Windows do this). So this is relevant for having multiple contexts active at the same time and also programs that may set up one context, tear it down, set up another one etc. in the same process (one application type that may do this is automated testing programs).

The second type of application (that doesn't use multiple contexts at the same time) can be dealt with by forcing the load of new function pointers whenever flextInit is called. The FlextGL module does this but the way of calling the function has a peculiar usage of unsafePerformIO in a normal IO action that might not actually end up using the reloaded function pointer.

Right now I don't think this is a serious problem because most applications just want one context in their lifetime as a process. I think safe multi-context might be difficult to implement without thread-local storage unless we want to abandon purely IO interface (I don't).

[abbradar]

My thoughts on the matter:

1. For the case of applications re-creating context (if it would matter) we can try reading IORefs each time the call is made. I don't know how big would be the overhead -- this is a subject to measurement.
2. For applications using multi-threaded rendering (disclaimer: I actually had no experience in OpenGL or accelerated graphics prior to encounter with caramia, so I don't know how/if this is used) I think the best method would be to create C wrapper which would use native thread_local variables. We wouldn't achieve something like this in pure IO otherwise (as you mentioned), particularly cleaning up storage when the thread is killed.

I see a potential way of implementing safe multi-context with only IO actually (had an idea while writing this), though overhead might be big -- we would store a Map or a Hashtable in each IORef and get a function by ThreadId each time. In withContext we would add function pointers for the new thread and run in a finally which would clean them up.