/// <summary>
/// Bind OpenGL delegates.
/// </summary>
/// <param name="context">The Emotion graphics context.</param>
public static void BindAPI(GraphicsContext context)
{
// Bind minimal API to query version, and do it.
BindAPIFunction("glGetError", Version100, null, context);
BindAPIFunction("glGetString", Version100, null, context);
BindAPIFunction("glGetIntegerv", Version100, null, context);
BindAPIFunction("glGetFloatv", Version100, null, context);
CurrentVersion = QueryContextVersionInternal();
// Obtain current OpenGL Shading Language version
string glslVersion = null;
switch (CurrentVersion.Api)
{
case KhronosVersion.API_GL:
if (CurrentVersion >= Version200 || CurrentExtensions.ShadingLanguage100_ARB)
{
glslVersion = GetString(StringName.ShadingLanguageVersion);
}
break;
case KhronosVersion.API_GLES2:
glslVersion = GetString(StringName.ShadingLanguageVersion);
break;
}
if (glslVersion != null)
{
CurrentShadingVersion = GlslVersion.Parse(glslVersion, CurrentVersion.Api);
}
// Query OpenGL extensions (current OpenGL implementation, CurrentCaps)
if (CurrentVersion.Major >= 3)
{
BindAPIFunction("glGetStringi", Version300, null, context); // Try to get extensions indexed.
}
CurrentExtensions = new Extensions();
CurrentExtensions.Query();
// Query OpenGL limits
CurrentLimits = Limits.Query(CurrentVersion, CurrentExtensions);
// Bind all functions.
foreach (FieldInfo fi in _functionContext.Delegates)
{
BindAPIFunction(fi, CurrentVersion, CurrentExtensions, context);
}
}
/// <summary>
/// Bind the OpenGL delegates for the API corresponding to the current OpenGL context.
/// </summary>
/// <param name="procLoadFunction">The function OpenGL functions will be loaded through. Should be provided by your context creator.</param>
public static void BindAPI(Func <string, IntPtr> procLoadFunction)
{
// Set the function loading function.
KhronosApi.ProcLoadFunction = procLoadFunction;
// Get version.
BindAPI(QueryContextVersionCore(), CurrentExtensions);
// Query OpenGL informations
string glVersion = GetString(StringName.Version);
_CurrentVersion = KhronosVersion.Parse(glVersion);
// Query OpenGL extensions (current OpenGL implementation, CurrentCaps)
_CurrentExtensions = new Extensions();
_CurrentExtensions.Query();
// Query OpenGL limits
_CurrentLimits = Limits.Query(CurrentVersion, _CurrentExtensions);
// Obtain current OpenGL Shading Language version
string glslVersion = null;
switch (_CurrentVersion.Api)
{
case KhronosVersion.ApiGl:
if (_CurrentVersion >= Version_200 || _CurrentExtensions.ShadingLanguage100_ARB)
{
glslVersion = GetString(StringName.ShadingLanguageVersion);
}
break;
case KhronosVersion.ApiGles2:
glslVersion = GetString(StringName.ShadingLanguageVersion);
break;
}
if (glslVersion != null)
{
_CurrentShadingVersion = GlslVersion.Parse(glslVersion, _CurrentVersion.Api);
}
// Vendor/Render information
_Vendor = GetString(StringName.Vendor);
_Renderer = GetString(StringName.Renderer);
}
/// <summary>
/// Bind the OpenGL delegates for the API corresponding to the current OpenGL context.
/// </summary>
/// <param name="procLoadFunction">
/// The function OpenGL functions will be loaded through. Should be provided by your context creator.
/// </param>
public static void BindAPI(Func <string, IntPtr> procLoadFunction)
{
// Set the function loading function.
ProcLoadFunction = procLoadFunction;
// Get version.
CurrentVersion = QueryContextVersion();
BindAPI <Gl>(CurrentVersion, CurrentExtensions);
// Query OpenGL extensions (current OpenGL implementation, CurrentCaps)
CurrentExtensions = new Extensions();
CurrentExtensions.Query();
// Query OpenGL limits
CurrentLimits = Limits.Query(CurrentVersion, CurrentExtensions);
// Obtain current OpenGL Shading Language version
string glslVersion = null;
switch (CurrentVersion.Api)
{
case KhronosVersion.API_GL:
if (CurrentVersion >= Version200 || CurrentExtensions.ShadingLanguage100_ARB)
{
glslVersion = GetString(StringName.ShadingLanguageVersion);
}
break;
case KhronosVersion.API_GLES2:
glslVersion = GetString(StringName.ShadingLanguageVersion);
break;
}
if (glslVersion != null)
{
CurrentShadingVersion = GlslVersion.Parse(glslVersion, CurrentVersion.Api);
}
// Vendor/Render information
CurrentVendor = GetString(StringName.Vendor);
CurrentRenderer = GetString(StringName.Renderer);
}
/// <summary>
/// Initialize OpenGL namespace static environment. This method shall be called before any other classes methods.
/// </summary>
public static void Initialize()
{
if (_Initialized == true)
{
return; // Already initialized
}
_Initialized = true;
#if !NETSTANDARD1_1
// Optional initialization
string envGlInit = Environment.GetEnvironmentVariable("OPENGL_NET_INIT");
if (envGlInit != null && envGlInit == "NO")
{
return;
}
#endif
// Environment options
LogComment("OpenGL.Net is initializing");
// Loader function OS API GL API
// ------------------------------------------------------
// Supported platform: Windows
// wglGetProcAddress WGL GL
// wglGetProcAddress WGL GLES2+ (with WGL_create_context_es(2)?_profile_EXT)
// eglGetProcAddress EGL(Angle) GLES2+
// ------------------------------------------------------
// Supported platform: Linux
// glXGetProcAddress GLX GL
// glXGetProcAddress GLX GLES2+ (with GLX_create_context_es(2)?_profile_EXT)
// eglGetProcAddress EGL GLES2+
// ------------------------------------------------------
// Supported platform: Android
// eglGetProcAddress EGL GL
// eglGetProcAddress EGL GLES2+
try {
#if !MONODROID
// Determine whether use EGL as device context backend
if (Egl.IsAvailable)
{
switch (Platform.CurrentPlatformId)
{
case Platform.Id.Linux:
if (Glx.IsAvailable == false)
{
Egl.IsRequired = true;
}
break;
}
}
#endif
// Create native window for getting preliminary information on desktop systems
// This instance will be used for creating contexts without explictly specify a window
_NativeWindow = DeviceContext.CreateHiddenWindow();
// Create device context
using (DeviceContext windowDevice = DeviceContext.Create()) {
// Create basic OpenGL context
IntPtr renderContext = windowDevice.CreateSimpleContext();
if (renderContext == IntPtr.Zero)
{
throw new NotImplementedException("unable to create a simple context");
}
// Make contect current
if (windowDevice.MakeCurrent(renderContext) == false)
{
throw new InvalidOperationException("unable to make current", windowDevice.GetPlatformException());
}
#if !MONODROID
// Reload platform function pointers, if required
if (Egl.IsRequired == false)
{
switch (Platform.CurrentPlatformId)
{
case Platform.Id.WindowsNT:
Wgl.BindAPI();
break;
}
}
#endif
// Query OpenGL informations
string glVersion = GetString(StringName.Version);
_CurrentVersion = KhronosVersion.Parse(glVersion);
// Query OpenGL extensions (current OpenGL implementation, CurrentCaps)
_CurrentExtensions = new Extensions();
_CurrentExtensions.Query();
// Query platform extensions
windowDevice.QueryPlatformExtensions();
// Query OpenGL limits
_CurrentLimits = Limits.Query(Gl.CurrentVersion, _CurrentExtensions);
// Obtain current OpenGL Shading Language version
string glslVersion = null;
switch (_CurrentVersion.Api)
{
case KhronosVersion.ApiGl:
if (_CurrentVersion >= Version_200 || _CurrentExtensions.ShadingLanguage100_ARB)
{
glslVersion = GetString(StringName.ShadingLanguageVersion);
}
break;
case KhronosVersion.ApiGles2:
glslVersion = GetString(StringName.ShadingLanguageVersion);
break;
}
if (glslVersion != null)
{
_CurrentShadingVersion = GlslVersion.Parse(glslVersion, _CurrentVersion.Api);
}
// Vendor/Render information
_Vendor = GetString(StringName.Vendor);
_Renderer = GetString(StringName.Renderer);
if (EnvDebug || EnvExperimental)
{
Debug.Assert(CurrentVersion != null && CurrentExtensions != null);
CheckExtensionCommands <Gl>(CurrentVersion, CurrentExtensions, EnvExperimental);
}
// Before deletion, make uncurrent
windowDevice.MakeCurrent(IntPtr.Zero);
// Detroy context
if (windowDevice.DeleteContext(renderContext) == false)
{
throw new InvalidOperationException("unable to delete OpenGL context");
}
}
LogComment("OpenGL.Net has been initialized");
} catch (Exception excepton) {
_InitializationException = excepton;
LogComment("Unable to initialize OpenGL.Net: {0}", _InitializationException.ToString());
}
}
/// <summary>
/// Initialize OpenGL namespace static environment. This method shall be called before any other classes methods.
/// </summary>
public static void Initialize()
{
if (_Initialized == true)
{
return; // Already initialized
}
_Initialized = true;
#if DEBUG
string envGlInit = Environment.GetEnvironmentVariable("GL_INIT");
if (envGlInit != null && envGlInit == "NO")
{
return;
}
#endif
LogComment("OpenGL.Net is initializing");
// Loader function OS API GL API
// ------------------------------------------------------
// Supported platform: Windows
// wglGetProcAddress WGL GL
// wglGetProcAddress WGL GLES2+ (with WGL_create_context_es(2)?_profile_EXT)
// eglGetProcAddress EGL(Angle) GLES2+
// ------------------------------------------------------
// Supported platform: Linux
// glXGetProcAddress GLX GL
// glXGetProcAddress GLX GLES2+ (with GLX_create_context_es(2)?_profile_EXT)
// ------------------------------------------------------
// Supported platform: Android
// eglGetProcAddress EGL GL
// eglGetProcAddress EGL GLES2+
try {
// Create native window for getting preliminary information on desktop systems
// This instance will be used for creating contexts without explictly specify a window
_NativeWindow = DeviceContext.CreateHiddenWindow();
// Create device context
using (DeviceContext windowDevice = DeviceContext.Create()) {
// Create basic OpenGL context
IntPtr renderContext = windowDevice.CreateSimpleContext();
if (renderContext == IntPtr.Zero)
{
throw new NotImplementedException("unable to create a simple context");
}
// Make contect current
if (windowDevice.MakeCurrent(renderContext) == false)
{
throw new InvalidOperationException("unable to make current", windowDevice.GetPlatformException());
}
// Query OpenGL informations
string glVersion = GetString(StringName.Version);
_CurrentVersion = KhronosVersion.Parse(glVersion);
// Obtain current OpenGL Shading Language version
switch (_CurrentVersion.Api)
{
case KhronosVersion.ApiGl:
case KhronosVersion.ApiGles2:
string glslVersion = GetString(StringName.ShadingLanguageVersion);
_CurrentShadingVersion = GlslVersion.Parse(glslVersion);
break;
}
// Vendor/Render information
_Vendor = GetString(StringName.Vendor);
_Renderer = GetString(StringName.Renderer);
// Query OpenGL extensions (current OpenGL implementation, CurrentCaps)
_CurrentExtensions = new Extensions();
_CurrentExtensions.Query();
// Query OpenGL limits
_CurrentLimits = Limits.Query(_CurrentExtensions);
// Query platform extensions
windowDevice.QueryPlatformExtensions();
// Before deletion, make uncurrent
windowDevice.MakeCurrent(IntPtr.Zero);
// Detroy context
if (windowDevice.DeleteContext(renderContext) == false)
{
throw new InvalidOperationException("unable to delete OpenGL context");
}
}
LogComment("OpenGL.Net has been initialized");
} catch (Exception excepton) {
LogComment("Unable to initialize OpenGL.Net: {0}", excepton.ToString());
}
}
/// <summary>
/// Static constructor.
/// </summary>
static Gl()
{
// Cache imports & delegates
_Delegates = GetDelegateList(typeof(Gl));
_ImportMap = GetImportMap(typeof(Gl));
// Load procedures (OpenGL desktop by default) @todo Really necessary?
LoadProcDelegates(_ImportMap, _Delegates);
// Create common hidden window
_HiddenWindow = new System.Windows.Forms.Form();
// Create device context
_HiddenWindowDevice = DeviceContextFactory.Create(_HiddenWindow);
_HiddenWindowDevice.IncRef();
// Create basic OpenGL context
IntPtr renderContext;
if (_HiddenWindowDevice is WindowsDeviceContext)
{
renderContext = CreateWinSimpleContext(_HiddenWindowDevice);
}
else if (_HiddenWindowDevice is XServerDeviceContext)
{
renderContext = CreateX11SimpleContext(_HiddenWindowDevice);
}
else if (_HiddenWindowDevice is NativeDeviceContext)
{
renderContext = CreateEglSimpleContext(_HiddenWindowDevice);
}
else
{
throw new NotImplementedException(String.Format("{0} is not a supported device context", _HiddenWindowDevice.GetType()));
}
// Query OpenGL informations
if (_HiddenWindowDevice.MakeCurrent(renderContext) == false)
{
throw new InvalidOperationException("unable to make current");
}
// Obtain current OpenGL implementation
string glVersion = Gl.GetString(StringName.Version);
_CurrentVersion = KhronosVersion.Parse(glVersion);
// Obtain current OpenGL Shading Language version
string glslVersion = Gl.GetString(StringName.ShadingLanguageVersion);
_CurrentShadingVersion = GlslVersion.Parse(glslVersion);
// Query OpenGL extensions (current OpenGL implementation, CurrentCaps)
_CurrentExtensions = new Extensions();
_CurrentExtensions.Query();
// Query OpenGL limits
_CurrentLimits = Limits.Query(_CurrentExtensions);
if (_HiddenWindowDevice is WindowsDeviceContext)
{
Wgl._CurrentExtensions = new Wgl.Extensions();
Wgl._CurrentExtensions.Query((WindowsDeviceContext)_HiddenWindowDevice);
}
else if (_HiddenWindowDevice is XServerDeviceContext)
{
Glx._CurrentExtensions = new Glx.Extensions();
Glx._CurrentExtensions.Query((XServerDeviceContext)_HiddenWindowDevice);
}
else if (_HiddenWindowDevice is NativeDeviceContext)
{
Egl._CurrentExtensions = new Egl.Extensions();
Egl._CurrentExtensions.Query((NativeDeviceContext)_HiddenWindowDevice);
}
// Before deletion, make uncurrent
_HiddenWindowDevice.MakeCurrent(IntPtr.Zero);
// Detroy context
if (_HiddenWindowDevice.DeleteContext(renderContext) == false)
{
throw new InvalidOperationException("unable to delete OpenGL context");
}
}