View previous topic :: View next topic |
Author |
Message |
aldacron
Joined: 05 May 2004 Posts: 1322 Location: Seoul, South Korea
|
Posted: Wed Mar 25, 2009 1:11 am Post subject: How to use DerelictGL in Derelict2 |
|
|
NOTE: Updated for OpenGL 4.0
Until I get some proper documentation into the repo, here's a quick guide on using DerelictGL in Derelict2.
Here's some example source to get you started:
Code: |
private
{
import tango.io.Stdout;
import derelict.opengl.gl;
import derelict.sdl.sdl;
import derelict.util.compat;
}
void main()
{
DerelictSDL.load();
DerelictGL.load();
// initialize SDL
if(SDL_Init(SDL_INIT_VIDEO) < 0)
{
throw new Exception("Failed to initialize SDL: " ~ toDString(SDL_GetError()));
}
scope(exit)
{
if(SDL_Quit !is null)
SDL_Quit();
}
// set the minimum desired OpenGL parameters
SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, 16);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 0);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
// create the SDL window
if(SDL_SetVideoMode(800, 600, 0, SDL_OPENGL) == null)
{
throw new Exception("Failed to set video mode: " ~ toDString(SDL_GetError()));
}
// HERE IS WHERE THINGS ARE DIFFERENT
// load the maximum avaliable version of OpenGL
// With the addition of OpenGL 3.0 support, the following
// code will still work, but there is an alternative method (see below)
DerelictGL.loadExtendedVersions();
DerelictGL.loadExtensions();
string[] loaded = DerelictGL.loadedExtensionNames;
string[] notLoaded = DerelictGL.notLoadedExtensionNames;
Stdout("Loaded extensions:").newline;
foreach(n; loaded)
Stdout.formatln("\t{}", n);
Stdout("Not loaded extensions:").newline;
foreach(n; notLoaded)
Stdout.formatln("\t{}", n);
}
|
For the most part, the code here is the same as it would be in Derelict 1. The difference is in how OpenGL versions greater than 1.1 and the extensions are loaded.
The function DerelictGL.loadExtendendVersions(GLVersion min = GLVersion.GL11) takes an optional arg that specifies which version of OpenGL you require. If that version is unsupported by the driver (as reported by glGetString(GL_VERSION), a DerelictException will be thrown. If the driver reports it is supported, but any of the functions from that vesion and lower fail to load, a SymbolLoadException will be thrown. An attempt will be made to load any higher versions the driver supports, but no exceptions will be thrown if they fail to load. The default behavior when no args are passed (as in the example above) is the same as passing GLVersion.GL11, i.e., it will attempt to load the highest version available and no exceptions will be thrown on failure.
To determine the highest version available for you to use after calling loadExtendedVersions, you can call DerelictGL.maxVersion.
The extension loading framework is greatly streamlined from Derelict 1. No longer are there separate modules for each extension. They are now contained within two files only: exttypes.d and extfuncs.d. Both modules are publicly imported in glext.d, so you can import just that to use them. You also don't need to import any of these three modules to load the extensions. Previously, extension loaders were registered with static module constructors. You could import only the extension modules you needed, or import them all, including all of the static constructors, with glext. No more.
To load the extensions, you need just the main derelict.opengl.gl module. A single call to DerelictGL.loadExtensions will load every OpenGL extension that Derelict supports. You can then query two methods to see if a function is supported or loaded: DerelictGL.isExtensionSupported(string extName) tests if the driver supports an extension. DerelictGL.isExtensionLoaded(string extName) will tell you whether or not an extension is currently loaded. If this returns false, you can test the return of isExtensionSupported to determine if the extension is loaded because it is unsupported or because it failed.
There are also two new methods which can be useful for debugging or logging (they've helped me find a couple of bugs in the extension loader itself already). DerelictGL.loadedExtensionNames and DerelictGL.notLoadedExtensionNames both return an array of extension name strings. In the case of the former, it is all loaded extensions. In the case of the latter, it is all extensions which are not loaded, appended with "(Unsupported)" if the driver does not support it, or "(Load Failed") if the driver reports it as supported but it failed to load. Currently, there is no mechanism for determining at runtime if DerelictGL has support for an extension. I don't anticipate that there will be either. The documentation will list all supported extensions.
OpenGL 4.0 Update
DerelictGL now includes support for OpenGL 3.0, 3.1, 3,2, 3,3 and 4.0. As part of these additions, I have made some minor changes and additions to the interface.
First, DerelictGL.loadExtendedVersions is now an alias to DerelictGL.loadClassicVersions. The behavior remains the same, but I changed the name to highlight it's functionality. This method will only load OpenGL versions up to 2.1. In order to load versions 3.0 and higher, you will need to call DerelictGL.loadModernVersions.
You will still need to create a context before loading the classic versions (thanks to Windows), and technically you should try to create a 3.0+ context to load the modern versions. However, the modern versions will load fine with a standard context (you'll need a 3.0+ context to use them, though). How you create the context is on you. You can find the relevant Windows API functions in wgl.d and the WGL_ARB extensions in glext.d for Windows. For other platforms, you're on your own. Eventually, Derelict will contain bindings for SFML2 and SDL2(1.3), which both support OpenGL 3.0+ context creation.
In addition to the new GLVersion.GL30/GL31/GL32/GL33/GL40 enum values, there are two more you may find useful: GLVersion.MaxClassic and GLVersion.MaxModern. These indicate the maximum classic and modern versions that Derelict supports. Currently, they are set to GL21 and GL40 respectively. _________________ The One With D | The One With Aldacron | D Bits |
|
Back to top |
|
|
ryutenchi
Joined: 09 Dec 2010 Posts: 8
|
Posted: Thu Dec 09, 2010 3:52 pm Post subject: |
|
|
So I tried your code, only changing the use of Tango and added a few debug writelns. Compiled fine. DLed the latest 1.2 sdl.dll (1.2.14). It was crashing on the loadModernVersion(GLVersion.GL30), but not on loadExtendedVersion. I'm testing on ATI FirePro V4800 with the latest drivers. Any help? I can test on a Mac book pro and an ubuntu desktop with an ATI 5770 later tonight, but kinda stuck at the moment.
thanks
Update:
Ok added some try tracing and figured out that it's crashing out on line (599) of gl.d where it tries to bind "glMinSampleShading". :
Code: | Opengl DLL crashed out: derelict.util.exception.SymbolLoadException: Failed to load symbol glMinSampleShading from shared library opengl32.dll |
|
|
Back to top |
|
|
aldacron
Joined: 05 May 2004 Posts: 1322 Location: Seoul, South Korea
|
|
Back to top |
|
|
aldacron
Joined: 05 May 2004 Posts: 1322 Location: Seoul, South Korea
|
Posted: Sun Dec 12, 2010 2:42 am Post subject: |
|
|
Well, actually there's not much I can do to about it. That's an OpenGL 4.0 function, and I don't have drivers that support 4.0. I'm curious to know if anyone else sees this with an Nvidia card as well. _________________ The One With D | The One With Aldacron | D Bits |
|
Back to top |
|
|
Stanley Pancakes
Joined: 26 Dec 2009 Posts: 18
|
Posted: Tue Dec 28, 2010 11:57 pm Post subject: |
|
|
Nope, not on Linux with GeForce GTS 450. Though I'm curious about that error message, because I wouldn't expect this function to be in opengl32.dll anyway.
[EDIT: I'll try to dig this up later today at work on Windows with ATI card with 4.0 drivers].
What I've also noticed is that a couple of 3.0 functions don't get loaded by loadModernVersions(): glMapBufferRange and glFlushMappedBufferRange.
They are declared in extfuncs.d and there is a function load_GL_ARB_map_buffer_range() in extloader.d, but it isn't called by the loader.
I would've thought that for extension functions those should get ARB suffix (which they currently don't have), and that the core 3.0 functions without suffix should be loaded by main GL loader via loadModernVersions(). What do you think? |
|
Back to top |
|
|
|
|
You cannot post new topics in this forum You cannot reply to topics in this forum You cannot edit your posts in this forum You cannot delete your posts in this forum You cannot vote in polls in this forum
|
Powered by phpBB © 2001, 2005 phpBB Group
|