Switching from an OpenGL context to a D3D/DX context (or another context) during Runtime

Question

EDIT: IS there any pre-built libraries to do this for me, that either uses SDL OR runs on Window, Linux, Mac, iOS and Android?

At the moment, I am not sure if the way I am changing contexts is quite a good design, I haven't completely finished it. I'm just really concerned about wasting my time. I am using SDL for Window management, and event handling.

I currently wrap SDL (specifically SDL 2) in classes to manage this. These are my classes and what they do:

Window - Describes a Window
WindowContext - Describes a context for the Window (abstract class)
WindowDelegate - Used to determine when the context has changed, when the window will open/close, etc.
WindowEventListener - Listens to events from the Window (not sure if I should just stick to polling instead of call back functions)

Anyway, here's an example of how it works:

OglWindowContext* context = new OglWindowContext;
// change context's settings
Window window(ipoint2(), idimension2(640, 480), "Test Window", 
              Window::Resizeable, context, &windowListener, 
              NULL /* window delegate */);

while(window.isOpen())
{
    window.processEvents(); // calls back events to the WindowEventListener
    window.draw(); // calls the context's draw method
}

NOTE: ipoint2 is a 2d point

And I can change the context midway by calling:

window.setContext(new Dx9Context); // or whatever context you would like

Is there any easier way, or should I say more efficient way, to do this?

OpenGL and DirectX? It's like mixing tritium and deuterium with a bit of laser. — Mark Garcia, Dec 12 '12 at 06:36
How so? Doesn't most game companies have options to switch what they render with, i.e. OpenGL or D3D. — miguel.martin, Dec 12 '12 at 06:42
This depends on what you want these different renderers to do. In implementations I have done you have a basic VirtualRenderer that GL and DX inherit from and when you switch renderers you unload one and load the other swapping out the VirtualRenderer pointer registered with the window/graphics system/etc — Connor Hollis, Dec 12 '12 at 06:44
Do you happen to know any libraries that will allow me to switch contexts? — miguel.martin, Dec 12 '12 at 09:19
@miguel.martin: I don't think that such libraries exist, or would be very usefull. Switching the renderer API involves more than just creating a new context. And the boilerplate code to open a window and create a context is only a very small fraction of a renderer backend, so people who actually need it (very unlikely, if you're using OpenGL you got more systems covered than with D3D) will implement this themself. — datenwolf, Dec 12 '12 at 10:23

score 1 · Accepted Answer · answered Dec 17 '12 at 10:25

Switching between renderers doesn't make much sense on any other platform that Windows at the moment, so your request for windows, linux, mac, ios and android support sounds strange. Perhaps you're looking for a library that helps you to be portable in general?

To achieve running with one renderer or the other (opengl/d3d), or to achieve portability in general, you need to implement some kind of portability layer.

Basically, you could start by writing two programs: one that draws a rotating cube in OpenGL, and another, completely separate that does the same with D3D. Next, write a third program that combines these, by:

Abstract differing things from the two applications behind a common interface
- Such as, but not limited to, once you get into various platforms:
  - Application control loop
  - Renderer (i.e, graphics output)
  - File I/O
  - User input
  - Audio
  - System services (threads, etc)
Implement the common interfaces on all target platforms
Implement application functionality only through the abstraction interfaces

The D3D and OpenGL on windows can practically be considered separate platforms, but you could pick one or the other during application startup - the choise would probably affect renderer and also the application control loop.

Switching during runtime is also entirely possible, but probably way too much hassle to be worth it.

You may note that SDL actually does a lot of the above.

Switching from an OpenGL context to a D3D/DX context (or another context) during Runtime

1 Answers1