1539 lines
94 KiB
C#
1539 lines
94 KiB
C#
//-----------------------------------------------------------------------
|
|
// -----------------------------------------------------------------------
|
|
// file="glApiManager.Load"
|
|
// Project: StgSharp
|
|
// AuthorGroup: Nitload
|
|
// Copyright (c) Nitload. All rights reserved.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in all
|
|
// copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
// SOFTWARE.
|
|
//
|
|
// -----------------------------------------------------------------------
|
|
// -----------------------------------------------------------------------
|
|
using StgSharp.HighPerformance;
|
|
using System;
|
|
|
|
namespace StgSharp.Graphics.OpenGL
|
|
{
|
|
public static partial class glManager
|
|
{
|
|
|
|
internal static unsafe bool LoadGLcore10(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core10)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 1.0 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glBlendFunc = (delegate*<uint, uint, void>)load("glBlendFunc"u8);
|
|
contextPtr->glClear = (delegate*<uint, void>)load("glClear"u8);
|
|
contextPtr->glClearColor = (delegate*<float, float, float, float, void>)load("glClearColor"u8);
|
|
contextPtr->glClearDepth = (delegate*<double, void>)load("glClearDepth"u8);
|
|
contextPtr->glClearStencil = (delegate*<int, void>)load("glClearStencil"u8);
|
|
contextPtr->glColorMask = (delegate*<bool, bool, bool, bool, void>)load("glColorMask"u8);
|
|
contextPtr->glCullFace = (delegate*<uint, void>)load("glCullFace"u8);
|
|
contextPtr->glDepthFunc = (delegate*<uint, void>)load("glDepthFunc"u8);
|
|
contextPtr->glDepthMask = (delegate*<bool, void>)load("glDepthMask"u8);
|
|
contextPtr->glDepthRange = (delegate*<double, double, void>)load("glDepthRange"u8);
|
|
contextPtr->glDisable = (delegate*<uint, void>)load("glDisable"u8);
|
|
contextPtr->glDrawBuffer = (delegate*<uint, void>)load("glDrawBuffer"u8);
|
|
contextPtr->glEnable = (delegate*<uint, void>)load("glEnable"u8);
|
|
contextPtr->glFinish = (delegate*<void>)load("glFinish"u8);
|
|
contextPtr->glFlush = (delegate*<void>)load("glFlush"u8);
|
|
contextPtr->glFrontFace = (delegate*<uint, void>)load("glFrontFace"u8);
|
|
contextPtr->glGetBooleanv = (delegate*<uint, bool*, void>)load("glGetBooleanv"u8);
|
|
contextPtr->glGetDoublev = (delegate*<uint, double*, void>)load("glGetDoublev"u8);
|
|
contextPtr->glGetError = (delegate*<uint>)load("glGetError"u8);
|
|
contextPtr->glGetFloatv = (delegate*<uint, float*, void>)load("glGetFloatv"u8);
|
|
contextPtr->glGetIntegerv = (delegate*<uint, int*, void>)load("glGetIntegerv"u8);
|
|
contextPtr->glGetString = (delegate*<uint, IntPtr>)load("glGetString"u8);
|
|
contextPtr->glGetTexImage = (delegate*<uint, int, uint, uint, void*, void>)load("glGetTexImage"u8);
|
|
contextPtr->glGetTexLevelParameterfv = (delegate*<uint, int, uint, float*, void>)load("glGetTexLevelParameterfv"u8);
|
|
contextPtr->glGetTexLevelParameteriv = (delegate*<uint, int, uint, int*, void>)load("glGetTexLevelParameteriv"u8);
|
|
contextPtr->glGetTexParameterfv = (delegate*<uint, uint, float*, void>)load("glGetTexParameterfv"u8);
|
|
contextPtr->glGetTexParameteriv = (delegate*<uint, uint, int*, void>)load("glGetTexParameteriv"u8);
|
|
contextPtr->glHint = (delegate*<uint, uint, void>)load("glHint"u8);
|
|
contextPtr->glIsEnabled = (delegate*<uint, bool>)load("glIsEnabled"u8);
|
|
contextPtr->glLineWidth = (delegate*<float, void>)load("glLineWidth"u8);
|
|
contextPtr->glLogicOp = (delegate*<uint, void>)load("glLogicOp"u8);
|
|
contextPtr->glPixelStoref = (delegate*<uint, float, void>)load("glPixelStoref"u8);
|
|
contextPtr->glPixelStorei = (delegate*<uint, int, void>)load("glPixelStorei"u8);
|
|
contextPtr->glPointSize = (delegate*<float, void>)load("glPointSize"u8);
|
|
contextPtr->glPolygonMode = (delegate*<uint, uint, void>)load("glPolygonMode"u8);
|
|
contextPtr->glReadBuffer = (delegate*<uint, void>)load("glReadBuffer"u8);
|
|
contextPtr->glReadPixels = (delegate*<int, int, int, int, uint, uint, void*, void>)load("glReadPixels"u8);
|
|
contextPtr->glScissor = (delegate*<int, int, uint, uint, void>)load("glScissor"u8);
|
|
contextPtr->glStencilFunc = (delegate*<uint, int, uint, void>)load("glStencilFunc"u8);
|
|
contextPtr->glStencilMask = (delegate*<uint, void>)load("glStencilMask"u8);
|
|
contextPtr->glStencilOp = (delegate*<uint, uint, uint, void>)load("glStencilOp"u8);
|
|
contextPtr->glTexImage1D = (delegate*<uint, int, int, uint, int, uint, uint, void*, void>)load("glTexImage1D"u8);
|
|
contextPtr->glTexImage2D = (delegate*<uint, int, uint, uint, uint, int, uint, uint, void*, void>)load("glTexImage2D"u8);
|
|
contextPtr->glTexParameterf = (delegate*<uint, uint, float, void>)load("glTexParameterf"u8);
|
|
contextPtr->glTexParameterfv = (delegate*<uint, uint, float*, void>)load("glTexParameterfv"u8);
|
|
contextPtr->glTexParameteri = (delegate*<uint, uint, int, void>)load("glTexParameteri"u8);
|
|
contextPtr->glTexParameteriv = (delegate*<uint, uint, int*, void>)load("glTexParameteriv"u8);
|
|
contextPtr->glViewport = (delegate*<int, int, uint, uint, void>)load("glViewport"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 1.0 APIs");
|
|
return true;
|
|
}
|
|
|
|
internal static unsafe bool LoadGLcore11(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core11)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 1.1 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glBindTexture = (delegate*<uint, uint, void>)load("glBindTexture"u8);
|
|
contextPtr->glCopyTexImage1D = (delegate*<uint, int, uint, int, int, uint, int, void>)load(
|
|
"glCopyTexImage1D"u8);
|
|
contextPtr->glCopyTexImage2D = (delegate*<uint, int, uint, int, int, uint, uint, int, void>)load(
|
|
"glCopyTexImage2D"u8);
|
|
contextPtr->glCopyTexSubImage1D = (delegate*<uint, int, int, int, int, uint, void>)load(
|
|
"glCopyTexSubImage1D"u8);
|
|
contextPtr->glCopyTexSubImage2D = (delegate*<uint, int, int, int, int, int, uint, uint, void>)load(
|
|
"glCopyTexSubImage2D"u8);
|
|
contextPtr->glDeleteTextures = (delegate*<uint, uint*, void>)load(
|
|
"glDeleteTextures"u8);
|
|
contextPtr->glDrawArrays = (delegate*<uint, int, uint, void>)load("glDrawArrays"u8);
|
|
contextPtr->glDrawElements = (delegate*<uint, uint, uint, void*, void>)load(
|
|
"glDrawElements"u8);
|
|
contextPtr->glGenTextures = (delegate*<int, uint*, void>)load("glGenTextures"u8);
|
|
contextPtr->glGetPointerv = (delegate*<uint, void**, void>)load("glGetPointerv"u8);
|
|
contextPtr->glIsTexture = (delegate*<uint, bool>)load("glIsTexture"u8);
|
|
contextPtr->glPolygonOffset = (delegate*<float, float, void>)load("glPolygonOffset"u8);
|
|
contextPtr->glTexSubImage1D = (delegate*<uint, int, int, uint, uint, uint, void*, void>)load(
|
|
"glTexSubImage1D"u8);
|
|
contextPtr->glTexSubImage2D = (delegate*<uint, int, int, int, uint, uint, uint, uint, void*, void>)load(
|
|
"glTexSubImage2D"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 1.1 APIs");
|
|
return true;
|
|
}
|
|
|
|
internal static unsafe bool LoadGLcore12(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core12)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 1.2 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glCopyTexSubImage3D = (delegate*<uint, int, int, int, int, int, int, uint, uint, void>)load(
|
|
"glCopyTexSubImage3D"u8);
|
|
contextPtr->glDrawRangeElements = (delegate*<uint, uint, uint, uint, uint, void*, void>)load(
|
|
"glDrawRangeElements"u8);
|
|
contextPtr->glTexImage3D = (delegate*<uint, int, int, uint, uint, uint, int, uint, uint, void*, void>)load(
|
|
"glTexImage3D"u8);
|
|
contextPtr->glTexSubImage3D = (delegate*<uint, int, int, int, int, uint, uint, uint, uint, uint, void*, void>)load(
|
|
"glTexSubImage3D"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 1.2 APIs");
|
|
return true;
|
|
}
|
|
|
|
internal static unsafe bool LoadGLcore13(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core13)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 1.3 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glActiveTexture = (delegate*<uint, void>)load("glActiveTexture"u8);
|
|
contextPtr->glCompressedTexImage1D = (delegate*<uint, int, uint, uint, int, uint, void*, void>)load(
|
|
"glCompressedTexImage1D"u8);
|
|
contextPtr->glCompressedTexImage2D = (delegate*<uint, int, uint, uint, uint, int, uint, void*, void>)load(
|
|
"glCompressedTexImage2D"u8);
|
|
contextPtr->glCompressedTexImage3D = (delegate*<uint, int, uint, uint, uint, uint, int, uint, void*, void>)load(
|
|
"glCompressedTexImage3D"u8);
|
|
contextPtr->glCompressedTexSubImage1D = (delegate*<uint, int, int, uint, uint, uint, void*, void>)load(
|
|
"glCompressedTexSubImage1D"u8);
|
|
contextPtr->glCompressedTexSubImage2D = (delegate*<uint, int, int, int, uint, uint, uint, uint, void*, void>)load(
|
|
"glCompressedTexSubImage2D"u8);
|
|
contextPtr->glCompressedTexSubImage3D = (delegate*<uint, int, int, int, int, uint, uint, uint, uint, uint, void*, void>)load(
|
|
"glCompressedTexSubImage3D"u8);
|
|
contextPtr->glGetCompressedTexImage = (delegate*<uint, int, void*, void>)load(
|
|
"glGetCompressedTexImage"u8);
|
|
contextPtr->glSampleCoverage = (delegate*<float, bool, void>)load(
|
|
"glSampleCoverage"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 1.3 APIs");
|
|
return true;
|
|
}
|
|
|
|
internal static unsafe bool LoadGLcore14(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core14)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 1.4 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glBlendColor = (delegate*<float, float, float, float, void>)load(
|
|
"glBlendColor"u8);
|
|
contextPtr->glBlendEquation = (delegate*<uint, void>)load("glBlendEquation"u8);
|
|
contextPtr->glBlendFuncSeparate = (delegate*<uint, uint, uint, uint, void>)load(
|
|
"glBlendFuncSeparate"u8);
|
|
contextPtr->glMultiDrawArrays = (delegate*<uint, int*, uint*, uint, void>)load(
|
|
"glMultiDrawArrays"u8);
|
|
contextPtr->glMultiDrawElements = (delegate*<uint, uint*, uint, void*, void**, uint, void>)load(
|
|
"glMultiDrawElements"u8);
|
|
contextPtr->glPointParameterf = (delegate*<uint, float, void>)load(
|
|
"glPointParameterf"u8);
|
|
contextPtr->glPointParameterfv = (delegate*<uint, float*, void>)load(
|
|
"glPointParameterfv"u8);
|
|
contextPtr->glPointParameteri = (delegate*<uint, int, void>)load(
|
|
"glPointParameteri"u8);
|
|
contextPtr->glPointParameteriv = (delegate*<uint, int*, void>)load(
|
|
"glPointParameteriv"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 1.4 APIs");
|
|
return true;
|
|
}
|
|
|
|
internal static unsafe bool LoadGLcore15(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core15)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 1.5 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glBeginQuery = (delegate*<uint, uint, void>)load("glBeginQuery"u8);
|
|
contextPtr->glBindBuffer = (delegate*<uint, uint, void>)load("glBindBuffer"u8);
|
|
contextPtr->glBufferData = (delegate*<uint, IntPtr, IntPtr, uint, void>)load(
|
|
"glBufferData"u8);
|
|
contextPtr->glBufferSubData = (delegate*<uint, IntPtr, UIntPtr, void*, void>)load(
|
|
"glBufferSubData"u8);
|
|
contextPtr->glDeleteBuffers = (delegate*<int, uint*, void>)load("glDeleteBuffers"u8);
|
|
contextPtr->glDeleteQueries = (delegate*<uint, uint*, void>)load("glDeleteQueries"u8);
|
|
contextPtr->glEndQuery = (delegate*<uint, void>)load("glEndQuery"u8);
|
|
contextPtr->glGenBuffers = (delegate*<int, uint*, void>)load("glGenBuffers"u8);
|
|
contextPtr->glGenQueries = (delegate*<uint, uint*, void>)load("glGenQueries"u8);
|
|
contextPtr->glGetBufferParameteriv = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetBufferParameteriv"u8);
|
|
contextPtr->glGetBufferPointerv = (delegate*<uint, uint, void**, void>)load(
|
|
"glGetBufferPointerv"u8);
|
|
contextPtr->glGetBufferSubData = (delegate*<uint, IntPtr, UIntPtr, void*, void>)load(
|
|
"glGetBufferSubData"u8);
|
|
contextPtr->glGetQueryObjectiv = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetQueryObjectiv"u8);
|
|
contextPtr->glGetQueryObjectuiv = (delegate*<uint, uint, uint*, void>)load(
|
|
"glGetQueryObjectuiv"u8);
|
|
contextPtr->glGetQueryiv = (delegate*<uint, uint, int*, void>)load("glGetQueryiv"u8);
|
|
contextPtr->glIsBuffer = (delegate*<uint, bool>)load("glIsBuffer"u8);
|
|
contextPtr->glIsQuery = (delegate*<uint, bool>)load("glIsQuery"u8);
|
|
contextPtr->glMapBuffer = (delegate*<uint, uint, void*>)load("glMapBuffer"u8);
|
|
contextPtr->glUnmapBuffer = (delegate*<uint, bool>)load("glUnmapBuffer"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 1.5 APIs");
|
|
return true;
|
|
}
|
|
|
|
internal static unsafe bool LoadGLcore20(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core20)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 2.0 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glAttachShader = (delegate*<uint, uint, void>)load("glAttachShader"u8);
|
|
contextPtr->glBindAttribLocation = (delegate*<uint, uint, byte*, void>)load(
|
|
"glBindAttribLocation"u8);
|
|
contextPtr->glBlendEquationSeparate = (delegate*<uint, uint, void>)load(
|
|
"glBlendEquationSeparate"u8);
|
|
contextPtr->glCompileShader = (delegate*<uint, void>)load("glCompileShader"u8);
|
|
contextPtr->glCreateProgram = (delegate*<uint>)load("glCreateProgram"u8);
|
|
contextPtr->glCreateShader = (delegate*<uint, uint>)load("glCreateShader"u8);
|
|
contextPtr->glDeleteProgram = (delegate*<uint, void>)load("glDeleteProgram"u8);
|
|
contextPtr->glDeleteShader = (delegate*<uint, void>)load("glDeleteShader"u8);
|
|
contextPtr->glDetachShader = (delegate*<uint, uint, void>)load("glDetachShader"u8);
|
|
contextPtr->glDisableVertexAttribArray = (delegate*<uint, void>)load(
|
|
"glDisableVertexAttribArray"u8);
|
|
contextPtr->glDrawBuffers = (delegate*<uint, uint*, void>)load("glDrawBuffers"u8);
|
|
contextPtr->glEnableVertexAttribArray = (delegate*<uint, void>)load(
|
|
"glEnableVertexAttribArray"u8);
|
|
contextPtr->glGetActiveAttrib = (delegate*<uint, uint, uint, uint*, int*, uint*, byte*, void>)load(
|
|
"glGetActiveAttrib"u8);
|
|
contextPtr->glGetActiveUniform = (delegate*<uint, uint, uint, uint*, int*, uint*, byte*, void>)load(
|
|
"glGetActiveUniform"u8);
|
|
contextPtr->glGetAttachedShaders = (delegate*<uint, uint, uint*, uint*, void>)load(
|
|
"glGetAttachedShaders"u8);
|
|
contextPtr->glGetAttribLocation = (delegate*<uint, byte*, int>)load(
|
|
"glGetAttribLocation"u8);
|
|
contextPtr->glGetProgramInfoLog = (delegate*<uint, uint, uint*, byte*, void>)load(
|
|
"glGetProgramInfoLog"u8);
|
|
contextPtr->glGetProgramiv = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetProgramiv"u8);
|
|
contextPtr->glGetShaderInfoLog = (delegate*<uint, uint, uint*, byte*, void>)load(
|
|
"glGetShaderInfoLog"u8);
|
|
contextPtr->glGetShaderSource = (delegate*<uint, uint, uint*, byte*, void>)load(
|
|
"glGetShaderSource"u8);
|
|
contextPtr->glGetShaderiv = (delegate*<uint, uint, int*, void>)load("glGetShaderiv"u8);
|
|
contextPtr->glGetUniformLocation = (delegate*<uint, byte*, int>)load(
|
|
"glGetUniformLocation"u8);
|
|
contextPtr->glGetUniformfv = (delegate*<uint, int, float*, void>)load(
|
|
"glGetUniformfv"u8);
|
|
contextPtr->glGetUniformiv = (delegate*<uint, int, int*, void>)load(
|
|
"glGetUniformiv"u8);
|
|
contextPtr->glGetVertexAttribPointerv = (delegate*<uint, uint, void**, void>)load(
|
|
"glGetVertexAttribPointerv"u8);
|
|
contextPtr->glGetVertexAttribdv = (delegate*<uint, uint, double*, void>)load(
|
|
"glGetVertexAttribdv"u8);
|
|
contextPtr->glGetVertexAttribfv = (delegate*<uint, uint, float*, void>)load(
|
|
"glGetVertexAttribfv"u8);
|
|
contextPtr->glGetVertexAttribiv = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetVertexAttribiv"u8);
|
|
contextPtr->glIsProgram = (delegate*<uint, bool>)load("glIsProgram"u8);
|
|
contextPtr->glIsShader = (delegate*<uint, bool>)load("glIsShader"u8);
|
|
contextPtr->glLinkProgram = (delegate*<uint, void>)load("glLinkProgram"u8);
|
|
contextPtr->glShaderSource = (delegate* unmanaged[Stdcall]<uint, uint, byte**, void*, void>)load(
|
|
"glShaderSource"u8);
|
|
contextPtr->glStencilFuncSeparate = (delegate*<uint, uint, int, uint, void>)load(
|
|
"glStencilFuncSeparate"u8);
|
|
contextPtr->glStencilMaskSeparate = (delegate*<uint, uint, void>)load(
|
|
"glStencilMaskSeparate"u8);
|
|
contextPtr->glStencilOpSeparate = (delegate*<uint, uint, uint, uint, void>)load(
|
|
"glStencilOpSeparate"u8);
|
|
contextPtr->glUniform1f = (delegate*<int, float, void>)load("glUniform1f"u8);
|
|
contextPtr->glUniform1fv = (delegate*<int, uint, M128*, void>)load("glUniform1fv"u8);
|
|
contextPtr->glUniform1i = (delegate*<int, int, void>)load("glUniform1i"u8);
|
|
contextPtr->glUniform1iv = (delegate*<int, uint, int*, void>)load("glUniform1iv"u8);
|
|
contextPtr->glUniform2f = (delegate*<int, float, float, void>)load("glUniform2f"u8);
|
|
contextPtr->glUniform2fv = (delegate*<int, uint, float*, void>)load("glUniform2fv"u8);
|
|
contextPtr->glUniform2i = (delegate*<int, int, int, void>)load("glUniform2i"u8);
|
|
contextPtr->glUniform2iv = (delegate*<int, uint, int*, void>)load("glUniform2iv"u8);
|
|
contextPtr->glUniform3f = (delegate*<int, float, float, float, void>)load(
|
|
"glUniform3f"u8);
|
|
contextPtr->glUniform3fv = (delegate*<int, uint, float*, void>)load("glUniform3fv"u8);
|
|
contextPtr->glUniform3i = (delegate*<int, int, int, int, void>)load("glUniform3i"u8);
|
|
contextPtr->glUniform3iv = (delegate*<int, uint, int*, void>)load("glUniform3iv"u8);
|
|
contextPtr->glUniform4f = (delegate*<int, float, float, float, float, void>)load(
|
|
"glUniform4f"u8);
|
|
contextPtr->glUniform4fv = (delegate*<int, uint, float*, void>)load("glUniform4fv"u8);
|
|
contextPtr->glUniform4i = (delegate*<int, int, int, int, int, void>)load(
|
|
"glUniform4i"u8);
|
|
contextPtr->glUniform4iv = (delegate*<int, uint, int*, void>)load("glUniform4iv"u8);
|
|
contextPtr->glUniformMatrix2fv = (delegate*<int, uint, bool, float*, void>)load(
|
|
"glUniformMatrix2fv"u8);
|
|
contextPtr->glUniformMatrix3fv = (delegate*<int, uint, bool, float*, void>)load(
|
|
"glUniformMatrix3fv"u8);
|
|
contextPtr->glUniformMatrix4fv = (delegate*<int, uint, bool, float*, void>)load(
|
|
"glUniformMatrix4fv"u8);
|
|
contextPtr->glUseProgram = (delegate*<uint, void>)load("glUseProgram"u8);
|
|
contextPtr->glValidateProgram = (delegate*<uint, void>)load("glValidateProgram"u8);
|
|
contextPtr->glVertexAttrib1d = (delegate*<uint, double, void>)load(
|
|
"glVertexAttrib1d"u8);
|
|
contextPtr->glVertexAttrib1dv = (delegate*<uint, double*, void>)load(
|
|
"glVertexAttrib1dv"u8);
|
|
contextPtr->glVertexAttrib1f = (delegate*<uint, float, void>)load(
|
|
"glVertexAttrib1f"u8);
|
|
contextPtr->glVertexAttrib1fv = (delegate*<uint, float*, void>)load(
|
|
"glVertexAttrib1fv"u8);
|
|
contextPtr->glVertexAttrib1s = (delegate*<uint, short, void>)load(
|
|
"glVertexAttrib1s"u8);
|
|
contextPtr->glVertexAttrib1sv = (delegate*<uint, short*, void>)load(
|
|
"glVertexAttrib1sv"u8);
|
|
contextPtr->glVertexAttrib2d = (delegate*<uint, double, double, void>)load(
|
|
"glVertexAttrib2d"u8);
|
|
contextPtr->glVertexAttrib2dv = (delegate*<uint, double*, void>)load(
|
|
"glVertexAttrib2dv"u8);
|
|
contextPtr->glVertexAttrib2f = (delegate*<uint, float, float, void>)load(
|
|
"glVertexAttrib2f"u8);
|
|
contextPtr->glVertexAttrib2fv = (delegate*<uint, float*, void>)load(
|
|
"glVertexAttrib2fv"u8);
|
|
contextPtr->glVertexAttrib2s = (delegate*<uint, short, short, void>)load(
|
|
"glVertexAttrib2s"u8);
|
|
contextPtr->glVertexAttrib2sv = (delegate*<uint, short*, void>)load(
|
|
"glVertexAttrib2sv"u8);
|
|
contextPtr->glVertexAttrib3d = (delegate*<uint, double, double, double, void>)load(
|
|
"glVertexAttrib3d"u8);
|
|
contextPtr->glVertexAttrib3dv = (delegate*<uint, double*, void>)load(
|
|
"glVertexAttrib3dv"u8);
|
|
contextPtr->glVertexAttrib3f = (delegate*<uint, float, float, float, void>)load(
|
|
"glVertexAttrib3f"u8);
|
|
contextPtr->glVertexAttrib3fv = (delegate*<uint, float*, void>)load(
|
|
"glVertexAttrib3fv"u8);
|
|
contextPtr->glVertexAttrib3s = (delegate*<uint, short, short, short, void>)load(
|
|
"glVertexAttrib3s"u8);
|
|
contextPtr->glVertexAttrib3sv = (delegate*<uint, short*, void>)load(
|
|
"glVertexAttrib3sv"u8);
|
|
contextPtr->glVertexAttrib4Nbv = (delegate*<uint, sbyte*, void>)load(
|
|
"glVertexAttrib4Nbv"u8);
|
|
contextPtr->glVertexAttrib4Niv = (delegate*<uint, int*, void>)load(
|
|
"glVertexAttrib4Niv"u8);
|
|
contextPtr->glVertexAttrib4Nsv = (delegate*<uint, short*, void>)load(
|
|
"glVertexAttrib4Nsv"u8);
|
|
contextPtr->glVertexAttrib4Nub = (delegate*<uint, byte, byte, byte, byte, void>)load(
|
|
"glVertexAttrib4Nub"u8);
|
|
contextPtr->glVertexAttrib4Nubv = (delegate*<uint, byte*, void>)load(
|
|
"glVertexAttrib4Nubv"u8);
|
|
contextPtr->glVertexAttrib4Nuiv = (delegate*<uint, uint*, void>)load(
|
|
"glVertexAttrib4Nuiv"u8);
|
|
contextPtr->glVertexAttrib4Nusv = (delegate*<uint, ushort*, void>)load(
|
|
"glVertexAttrib4Nusv"u8);
|
|
contextPtr->glVertexAttrib4bv = (delegate*<uint, sbyte*, void>)load(
|
|
"glVertexAttrib4bv"u8);
|
|
contextPtr->glVertexAttrib4d = (delegate*<uint, double, double, double, double, void>)load(
|
|
"glVertexAttrib4d"u8);
|
|
contextPtr->glVertexAttrib4dv = (delegate*<uint, double*, void>)load(
|
|
"glVertexAttrib4dv"u8);
|
|
contextPtr->glVertexAttrib4f = (delegate*<uint, float, float, float, float, void>)load(
|
|
"glVertexAttrib4f"u8);
|
|
contextPtr->glVertexAttrib4fv = (delegate*<uint, float*, void>)load(
|
|
"glVertexAttrib4fv"u8);
|
|
contextPtr->glVertexAttrib4iv = (delegate*<uint, int*, void>)load(
|
|
"glVertexAttrib4iv"u8);
|
|
contextPtr->glVertexAttrib4s = (delegate*<uint, short, short, short, short, void>)load(
|
|
"glVertexAttrib4s"u8);
|
|
contextPtr->glVertexAttrib4sv = (delegate*<uint, short*, void>)load(
|
|
"glVertexAttrib4sv"u8);
|
|
contextPtr->glVertexAttrib4ubv = (delegate*<uint, byte*, void>)load(
|
|
"glVertexAttrib4ubv"u8);
|
|
contextPtr->glVertexAttrib4uiv = (delegate*<uint, uint*, void>)load(
|
|
"glVertexAttrib4uiv"u8);
|
|
contextPtr->glVertexAttrib4usv = (delegate*<uint, ushort*, void>)load(
|
|
"glVertexAttrib4usv"u8);
|
|
contextPtr->glVertexAttribPointer = (delegate*<uint, int, uint, int, uint, void*, void>)load(
|
|
"glVertexAttribPointer"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 2.0 APIs");
|
|
return true;
|
|
}
|
|
|
|
internal static unsafe bool LoadGLcore21(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core21)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 2.1 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glUniformMatrix2x3fv = (delegate*<int, uint, bool, float*, void>)load(
|
|
"glUniformMatrix2x3fv"u8);
|
|
contextPtr->glUniformMatrix2x4fv = (delegate*<int, uint, bool, float*, void>)load(
|
|
"glUniformMatrix2x4fv"u8);
|
|
contextPtr->glUniformMatrix3x2fv = (delegate*<int, uint, bool, float*, void>)load(
|
|
"glUniformMatrix3x2fv"u8);
|
|
contextPtr->glUniformMatrix3x4fv = (delegate*<int, uint, bool, float*, void>)load(
|
|
"glUniformMatrix3x4fv"u8);
|
|
contextPtr->glUniformMatrix4x2fv = (delegate*<int, uint, bool, float*, void>)load(
|
|
"glUniformMatrix4x2fv"u8);
|
|
contextPtr->glUniformMatrix4x3fv = (delegate*<int, uint, bool, float*, void>)load(
|
|
"glUniformMatrix4x3fv"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 2.1 APIs");
|
|
return true;
|
|
}
|
|
|
|
internal static unsafe bool LoadGLcore30(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core30)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 3.0 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glBeginConditionalRender = (delegate*<uint, uint, void>)load(
|
|
"glBeginConditionalRender"u8);
|
|
contextPtr->glBeginTransformFeedback = (delegate*<uint, void>)load(
|
|
"glBeginTransformFeedback"u8);
|
|
contextPtr->glBindBufferBase = (delegate*<uint, uint, uint, void>)load(
|
|
"glBindBufferBase"u8);
|
|
contextPtr->glBindBufferRange = (delegate*<uint, uint, uint, IntPtr, UIntPtr, void>)load(
|
|
"glBindBufferRange"u8);
|
|
contextPtr->glBindFragDataLocation = (delegate*<uint, uint, byte*, void>)load(
|
|
"glBindFragDataLocation"u8);
|
|
contextPtr->glBindFramebuffer = (delegate*<uint, uint, void>)load(
|
|
"glBindFramebuffer"u8);
|
|
contextPtr->glBindRenderbuffer = (delegate*<uint, uint, void>)load(
|
|
"glBindRenderbuffer"u8);
|
|
contextPtr->glBindVertexArray = (delegate*<uint, void>)load("glBindVertexArray"u8);
|
|
contextPtr->glBlitFramebuffer = (delegate*<int, int, int, int, int, int, int, int, uint, uint, void>)load(
|
|
"glBlitFramebuffer"u8);
|
|
contextPtr->glCheckFramebufferStatus = (delegate*<uint, uint>)load(
|
|
"glCheckFramebufferStatus"u8);
|
|
contextPtr->glClampColor = (delegate*<uint, uint, void>)load("glClampColor"u8);
|
|
contextPtr->glClearBufferfi = (delegate*<uint, int, float, int, void>)load(
|
|
"glClearBufferfi"u8);
|
|
contextPtr->glClearBufferfv = (delegate*<uint, int, float*, void>)load(
|
|
"glClearBufferfv"u8);
|
|
contextPtr->glClearBufferiv = (delegate*<uint, int, int*, void>)load(
|
|
"glClearBufferiv"u8);
|
|
contextPtr->glClearBufferuiv = (delegate*<uint, int, uint*, void>)load(
|
|
"glClearBufferuiv"u8);
|
|
contextPtr->glColorMaski = (delegate*<uint, bool, bool, bool, bool, void>)load(
|
|
"glColorMaski"u8);
|
|
contextPtr->glDeleteFramebuffers = (delegate*<uint, uint*, void>)load(
|
|
"glDeleteFramebuffers"u8);
|
|
contextPtr->glDeleteRenderbuffers = (delegate*<uint, uint*, void>)load(
|
|
"glDeleteRenderbuffers"u8);
|
|
contextPtr->glDeleteVertexArrays = (delegate*<int, uint*, void>)load(
|
|
"glDeleteVertexArrays"u8);
|
|
contextPtr->glDisablei = (delegate*<uint, uint, void>)load("glDisablei"u8);
|
|
contextPtr->glEnablei = (delegate*<uint, uint, void>)load("glEnablei"u8);
|
|
contextPtr->glEndConditionalRender = (delegate*<void>)load("glEndConditionalRender"u8);
|
|
contextPtr->glEndTransformFeedback = (delegate*<void>)load("glEndTransformFeedback"u8);
|
|
contextPtr->glFlushMappedBufferRange = (delegate*<uint, IntPtr, UIntPtr, void>)load(
|
|
"glFlushMappedBufferRange"u8);
|
|
contextPtr->glFramebufferRenderbuffer = (delegate*<uint, uint, uint, uint, void>)load(
|
|
"glFramebufferRenderbuffer"u8);
|
|
contextPtr->glFramebufferTexture1D = (delegate*<uint, uint, uint, uint, int, void>)load(
|
|
"glFramebufferTexture1D"u8);
|
|
contextPtr->glFramebufferTexture2D = (delegate*<uint, uint, uint, uint, int, void>)load(
|
|
"glFramebufferTexture2D"u8);
|
|
contextPtr->glFramebufferTexture3D = (delegate*<uint, uint, uint, uint, int, int, void>)load(
|
|
"glFramebufferTexture3D"u8);
|
|
contextPtr->glFramebufferTextureLayer = (delegate*<uint, uint, uint, int, int, void>)load(
|
|
"glFramebufferTextureLayer"u8);
|
|
contextPtr->glGenFramebuffers = (delegate*<uint, uint*, void>)load(
|
|
"glGenFramebuffers"u8);
|
|
contextPtr->glGenRenderbuffers = (delegate*<int, uint*, void>)load(
|
|
"glGenRenderbuffers"u8);
|
|
contextPtr->glGenVertexArrays = (delegate*<int, uint*, void>)load(
|
|
"glGenVertexArrays"u8);
|
|
contextPtr->glGenerateMipmap = (delegate*<uint, void>)load("glGenerateMipmap"u8);
|
|
contextPtr->glGetBooleani_v = (delegate*<uint, uint, bool*, void>)load(
|
|
"glGetBooleani_v"u8);
|
|
contextPtr->glGetFragDataLocation = (delegate*<uint, byte*, int>)load(
|
|
"glGetFragDataLocation"u8);
|
|
contextPtr->glGetFramebufferAttachmentParameteriv = (delegate*<uint, uint, uint, int*, void>)load(
|
|
"glGetFramebufferAttachmentParameteriv"u8);
|
|
contextPtr->glGetIntegeri_v = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetIntegeri_v"u8);
|
|
contextPtr->glGetRenderbufferParameteriv = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetRenderbufferParameteriv"u8);
|
|
contextPtr->glGetStringi = (delegate*<uint, uint, byte*>)load("glGetStringi"u8);
|
|
contextPtr->glGetTexParameterIiv = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetTexParameterIiv"u8);
|
|
contextPtr->glGetTexParameterIuiv = (delegate*<uint, uint, uint*, void>)load(
|
|
"glGetTexParameterIuiv"u8);
|
|
contextPtr->glGetTransformFeedbackVarying = (delegate*<uint, uint, uint, uint*, uint*, uint*, byte*, void>)load(
|
|
"glGetTransformFeedbackVarying"u8);
|
|
contextPtr->glGetUniformuiv = (delegate*<uint, int, uint*, void>)load(
|
|
"glGetUniformuiv"u8);
|
|
contextPtr->glGetVertexAttribIiv = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetVertexAttribIiv"u8);
|
|
contextPtr->glGetVertexAttribIuiv = (delegate*<uint, uint, uint*, void>)load(
|
|
"glGetVertexAttribIuiv"u8);
|
|
contextPtr->glIsEnabledi = (delegate*<uint, uint, bool>)load("glIsEnabledi"u8);
|
|
contextPtr->glIsFramebuffer = (delegate*<uint, bool>)load("glIsFramebuffer"u8);
|
|
contextPtr->glIsRenderbuffer = (delegate*<uint, bool>)load("glIsRenderbuffer"u8);
|
|
contextPtr->glIsVertexArray = (delegate*<uint, bool>)load("glIsVertexArray"u8);
|
|
contextPtr->glMapBufferRange = (delegate*<uint, IntPtr, UIntPtr, uint, void*>)load(
|
|
"glMapBufferRange"u8);
|
|
contextPtr->glRenderbufferStorage = (delegate*<uint, uint, int, int, void>)load(
|
|
"glRenderbufferStorage"u8);
|
|
contextPtr->glRenderbufferStorageMultisample = (delegate*<uint, uint, uint, uint, uint, void>)load(
|
|
"glRenderbufferStorageMultisample"u8);
|
|
contextPtr->glTexParameterIiv = (delegate*<uint, uint, int*, void>)load(
|
|
"glTexParameterIiv"u8);
|
|
contextPtr->glTexParameterIuiv = (delegate*<uint, uint, uint*, void>)load(
|
|
"glTexParameterIuiv"u8);
|
|
contextPtr->glTransformFeedbackVaryings = (delegate*<uint, uint, byte*, byte*, uint, void>)load(
|
|
"glTransformFeedbackVaryings"u8);
|
|
contextPtr->glUniform1ui = (delegate*<int, uint, void>)load("glUniform1ui"u8);
|
|
contextPtr->glUniform1uiv = (delegate*<int, uint, uint*, void>)load("glUniform1uiv"u8);
|
|
contextPtr->glUniform2ui = (delegate*<int, uint, uint, void>)load("glUniform2ui"u8);
|
|
contextPtr->glUniform2uiv = (delegate*<int, uint, uint*, void>)load("glUniform2uiv"u8);
|
|
contextPtr->glUniform3ui = (delegate*<int, uint, uint, uint, void>)load(
|
|
"glUniform3ui"u8);
|
|
contextPtr->glUniform3uiv = (delegate*<int, uint, uint*, void>)load("glUniform3uiv"u8);
|
|
contextPtr->glUniform4ui = (delegate*<int, uint, uint, uint, uint, void>)load(
|
|
"glUniform4ui"u8);
|
|
contextPtr->glUniform4uiv = (delegate*<int, uint, uint*, void>)load("glUniform4uiv"u8);
|
|
contextPtr->glVertexAttribI1i = (delegate*<uint, int, void>)load(
|
|
"glVertexAttribI1i"u8);
|
|
contextPtr->glVertexAttribI1iv = (delegate*<uint, int*, void>)load(
|
|
"glVertexAttribI1iv"u8);
|
|
contextPtr->glVertexAttribI1ui = (delegate*<uint, uint, void>)load(
|
|
"glVertexAttribI1ui"u8);
|
|
contextPtr->glVertexAttribI1uiv = (delegate*<uint, uint*, void>)load(
|
|
"glVertexAttribI1uiv"u8);
|
|
contextPtr->glVertexAttribI2i = (delegate*<uint, int, int, void>)load(
|
|
"glVertexAttribI2i"u8);
|
|
contextPtr->glVertexAttribI2iv = (delegate*<uint, int*, void>)load(
|
|
"glVertexAttribI2iv"u8);
|
|
contextPtr->glVertexAttribI2ui = (delegate*<uint, uint, uint, void>)load(
|
|
"glVertexAttribI2ui"u8);
|
|
contextPtr->glVertexAttribI2uiv = (delegate*<uint, uint*, void>)load(
|
|
"glVertexAttribI2uiv"u8);
|
|
contextPtr->glVertexAttribI3i = (delegate*<uint, int, int, int, void>)load(
|
|
"glVertexAttribI3i"u8);
|
|
contextPtr->glVertexAttribI3iv = (delegate*<uint, int*, void>)load(
|
|
"glVertexAttribI3iv"u8);
|
|
contextPtr->glVertexAttribI3ui = (delegate*<uint, uint, uint, uint, void>)load(
|
|
"glVertexAttribI3ui"u8);
|
|
contextPtr->glVertexAttribI3uiv = (delegate*<uint, uint*, void>)load(
|
|
"glVertexAttribI3uiv"u8);
|
|
contextPtr->glVertexAttribI4bv = (delegate*<uint, sbyte*, void>)load(
|
|
"glVertexAttribI4bv"u8);
|
|
contextPtr->glVertexAttribI4i = (delegate*<uint, int, int, int, int, void>)load(
|
|
"glVertexAttribI4i"u8);
|
|
contextPtr->glVertexAttribI4iv = (delegate*<uint, int*, void>)load(
|
|
"glVertexAttribI4iv"u8);
|
|
contextPtr->glVertexAttribI4sv = (delegate*<uint, short*, void>)load(
|
|
"glVertexAttribI4sv"u8);
|
|
contextPtr->glVertexAttribI4ubv = (delegate*<uint, byte*, void>)load(
|
|
"glVertexAttribI4ubv"u8);
|
|
contextPtr->glVertexAttribI4ui = (delegate*<uint, uint, uint, uint, uint, void>)load(
|
|
"glVertexAttribI4ui"u8);
|
|
contextPtr->glVertexAttribI4uiv = (delegate*<uint, uint*, void>)load(
|
|
"glVertexAttribI4uiv"u8);
|
|
contextPtr->glVertexAttribI4usv = (delegate*<uint, ushort*, void>)load(
|
|
"glVertexAttribI4usv"u8);
|
|
contextPtr->glVertexAttribIPointer = (delegate*<uint, int, uint, uint, void*, void>)load(
|
|
"glVertexAttribIPointer"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 3.0 APIs");
|
|
return true;
|
|
}
|
|
|
|
internal static unsafe bool LoadGLcore31(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core31)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 3.1 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glBindBufferBase = (delegate*<uint, uint, uint, void>)load(
|
|
"glBindBufferBase"u8);
|
|
contextPtr->glBindBufferRange = (delegate*<uint, uint, uint, IntPtr, UIntPtr, void>)load(
|
|
"glBindBufferRange"u8);
|
|
contextPtr->glCopyBufferSubData = (delegate*<uint, uint, IntPtr, IntPtr, UIntPtr, void>)load(
|
|
"glCopyBufferSubData"u8);
|
|
contextPtr->glDrawArraysInstanced = (delegate*<uint, int, uint, uint, void>)load(
|
|
"glDrawArraysInstanced"u8);
|
|
contextPtr->glDrawElementsInstanced = (delegate*<uint, uint, uint, void*, uint, void>)load(
|
|
"glDrawElementsInstanced"u8);
|
|
contextPtr->glGetActiveUniformBlockName = (delegate*<uint, uint, uint, uint*, byte*, void>)load(
|
|
"glGetActiveUniformBlockName"u8);
|
|
contextPtr->glGetActiveUniformBlockiv = (delegate*<uint, uint, uint, int*, void>)load(
|
|
"glGetActiveUniformBlockiv"u8);
|
|
contextPtr->glGetActiveUniformName = (delegate*<uint, uint, uint, uint*, byte*, void>)load(
|
|
"glGetActiveUniformName"u8);
|
|
contextPtr->glGetActiveUniformsiv = (delegate*<uint, uint, uint*, uint, int*, void>)load(
|
|
"glGetActiveUniformsiv"u8);
|
|
contextPtr->glGetIntegeri_v = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetIntegeri_v"u8);
|
|
contextPtr->glGetUniformBlockIndex = (delegate*<uint, byte*, uint>)load(
|
|
"glGetUniformBlockIndex"u8);
|
|
contextPtr->glGetUniformIndices = (delegate*<uint, uint, byte*, char**, uint*, void>)load(
|
|
"glGetUniformIndices"u8);
|
|
contextPtr->glPrimitiveRestartIndex = (delegate*<uint, void>)load(
|
|
"glPrimitiveRestartIndex"u8);
|
|
contextPtr->glTexBuffer = (delegate*<uint, uint, uint, void>)load("glTexBuffer"u8);
|
|
contextPtr->glUniformBlockBinding = (delegate*<uint, uint, uint, void>)load(
|
|
"glUniformBlockBinding"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 3.1 APIs");
|
|
return true;
|
|
}
|
|
|
|
internal static unsafe bool LoadGLcore32(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core32)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 3.2 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glClientWaitSync = (delegate*<GLsync, uint, ulong, uint>)load(
|
|
"glClientWaitSync"u8);
|
|
contextPtr->glDeleteSync = (delegate*<GLsync, void>)load("glDeleteSync"u8);
|
|
contextPtr->glDrawElementsBaseVertex = (delegate*<uint, uint, uint, void*, int, void>)load(
|
|
"glDrawElementsBaseVertex"u8);
|
|
contextPtr->glDrawElementsInstancedBaseVertex = (delegate*<uint, uint, uint, void*, uint, int, void>)load(
|
|
"glDrawElementsInstancedBaseVertex"u8);
|
|
contextPtr->glDrawRangeElementsBaseVertex = (delegate*<uint, uint, uint, uint, uint, void*, int, void>)load(
|
|
"glDrawRangeElementsBaseVertex"u8);
|
|
contextPtr->glFenceSync = (delegate*<uint, uint, GLsync>)load("glFenceSync"u8);
|
|
contextPtr->glFramebufferTexture = (delegate*<uint, uint, uint, int, void>)load(
|
|
"glFramebufferTexture"u8);
|
|
contextPtr->glGetBufferParameteri64v = (delegate*<uint, uint, long*, void>)load(
|
|
"glGetBufferParameteri64v"u8);
|
|
contextPtr->glGetInteger64i_v = (delegate*<uint, uint, long*, void>)load(
|
|
"glGetInteger64i_v"u8);
|
|
contextPtr->glGetInteger64v = (delegate*<uint, long*, void>)load("glGetInteger64v"u8);
|
|
contextPtr->glGetMultisamplefv = (delegate*<uint, uint, float*, void>)load(
|
|
"glGetMultisamplefv"u8);
|
|
contextPtr->glGetSynciv = (delegate*<GLsync, uint, uint, uint*, int*, void>)load(
|
|
"glGetSynciv"u8);
|
|
contextPtr->glIsSync = (delegate*<GLsync, bool>)load("glIsSync"u8);
|
|
contextPtr->glMultiDrawElementsBaseVertex = (delegate*<uint, uint*, uint, void*, void**, uint, int*, void>)load(
|
|
"glMultiDrawElementsBaseVertex"u8);
|
|
contextPtr->glProvokingVertex = (delegate*<uint, void>)load("glProvokingVertex"u8);
|
|
contextPtr->glSampleMaski = (delegate*<uint, uint, void>)load("glSampleMaski"u8);
|
|
contextPtr->glTexImage2DMultisample = (delegate*<uint, uint, uint, uint, uint, bool, void>)load(
|
|
"glTexImage2DMultisample"u8);
|
|
contextPtr->glTexImage3DMultisample = (delegate*<uint, uint, uint, uint, uint, uint, bool, void>)load(
|
|
"glTexImage3DMultisample"u8);
|
|
contextPtr->glWaitSync = (delegate*<GLsync, uint, ulong, void>)load("glWaitSync"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 3.2 APIs");
|
|
return true;
|
|
}
|
|
|
|
internal static unsafe bool LoadGLcore33(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core33)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 3.3 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glBindFragDataLocationIndexed = (delegate*<uint, uint, uint, byte*, void>)load(
|
|
"glBindFragDataLocationIndexed"u8);
|
|
contextPtr->glBindSampler = (delegate*<uint, uint, void>)load("glBindSampler"u8);
|
|
contextPtr->glDeleteSamplers = (delegate*<uint, uint*, void>)load(
|
|
"glDeleteSamplers"u8);
|
|
contextPtr->glGenSamplers = (delegate*<uint, uint*, void>)load("glGenSamplers"u8);
|
|
contextPtr->glGetFragDataIndex = (delegate*<uint, byte*, int>)load(
|
|
"glGetFragDataIndex"u8);
|
|
contextPtr->glGetQueryObjecti64v = (delegate*<uint, uint, long*, void>)load(
|
|
"glGetQueryObjecti64v"u8);
|
|
contextPtr->glGetQueryObjectui64v = (delegate*<uint, uint, ulong*, void>)load(
|
|
"glGetQueryObjectui64v"u8);
|
|
contextPtr->glGetSamplerParameterIiv = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetSamplerParameterIiv"u8);
|
|
contextPtr->glGetSamplerParameterIuiv = (delegate*<uint, uint, uint*, void>)load(
|
|
"glGetSamplerParameterIuiv"u8);
|
|
contextPtr->glGetSamplerParameterfv = (delegate*<uint, uint, float*, void>)load(
|
|
"glGetSamplerParameterfv"u8);
|
|
contextPtr->glGetSamplerParameteriv = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetSamplerParameteriv"u8);
|
|
contextPtr->glIsSampler = (delegate*<uint, bool>)load("glIsSampler"u8);
|
|
contextPtr->glQueryCounter = (delegate*<uint, uint, void>)load("glQueryCounter"u8);
|
|
contextPtr->glSamplerParameterIiv = (delegate*<uint, uint, int*, void>)load(
|
|
"glSamplerParameterIiv"u8);
|
|
contextPtr->glSamplerParameterIuiv = (delegate*<uint, uint, uint*, void>)load(
|
|
"glSamplerParameterIuiv"u8);
|
|
contextPtr->glSamplerParameterf = (delegate*<uint, uint, float, void>)load(
|
|
"glSamplerParameterf"u8);
|
|
contextPtr->glSamplerParameterfv = (delegate*<uint, uint, float*, void>)load(
|
|
"glSamplerParameterfv"u8);
|
|
contextPtr->glSamplerParameteri = (delegate*<uint, uint, int, void>)load(
|
|
"glSamplerParameteri"u8);
|
|
contextPtr->glSamplerParameteriv = (delegate*<uint, uint, int*, void>)load(
|
|
"glSamplerParameteriv"u8);
|
|
contextPtr->glVertexAttribDivisor = (delegate*<uint, uint, void>)load(
|
|
"glVertexAttribDivisor"u8);
|
|
contextPtr->glVertexAttribP1ui = (delegate*<uint, uint, bool, uint, void>)load(
|
|
"glVertexAttribP1ui"u8);
|
|
contextPtr->glVertexAttribP1uiv = (delegate*<uint, uint, bool, uint*, void>)load(
|
|
"glVertexAttribP1uiv"u8);
|
|
contextPtr->glVertexAttribP2ui = (delegate*<uint, uint, bool, uint, void>)load(
|
|
"glVertexAttribP2ui"u8);
|
|
contextPtr->glVertexAttribP2uiv = (delegate*<uint, uint, bool, uint*, void>)load(
|
|
"glVertexAttribP2uiv"u8);
|
|
contextPtr->glVertexAttribP3ui = (delegate*<uint, uint, bool, uint, void>)load(
|
|
"glVertexAttribP3ui"u8);
|
|
contextPtr->glVertexAttribP3uiv = (delegate*<uint, uint, bool, uint*, void>)load(
|
|
"glVertexAttribP3uiv"u8);
|
|
contextPtr->glVertexAttribP4ui = (delegate*<uint, uint, bool, uint, void>)load(
|
|
"glVertexAttribP4ui"u8);
|
|
contextPtr->glVertexAttribP4uiv = (delegate*<uint, uint, bool, uint*, void>)load(
|
|
"glVertexAttribP4uiv"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 3.3 APIs");
|
|
return true;
|
|
}
|
|
|
|
internal static unsafe bool LoadGLcore40(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core40)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 4.0 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glBeginQueryIndexed = (delegate*<uint, uint, uint, void>)load(
|
|
"glBeginQueryIndexed"u8);
|
|
contextPtr->glBindTransformFeedback = (delegate*<uint, uint, void>)load(
|
|
"glBindTransformFeedback"u8);
|
|
contextPtr->glBlendEquationSeparatei = (delegate*<uint, uint, uint, void>)load(
|
|
"glBlendEquationSeparatei"u8);
|
|
contextPtr->glBlendEquationi = (delegate*<uint, uint, void>)load("glBlendEquationi"u8);
|
|
contextPtr->glBlendFuncSeparatei = (delegate*<uint, uint, uint, uint, uint, void>)load(
|
|
"glBlendFuncSeparatei"u8);
|
|
contextPtr->glBlendFunci = (delegate*<uint, uint, uint, void>)load("glBlendFunci"u8);
|
|
contextPtr->glDeleteTransformFeedbacks = (delegate*<uint, uint*, void>)load(
|
|
"glDeleteTransformFeedbacks"u8);
|
|
contextPtr->glDrawArraysIndirect = (delegate*<uint, void*, void>)load(
|
|
"glDrawArraysIndirect"u8);
|
|
contextPtr->glDrawElementsIndirect = (delegate*<uint, uint, void*, void>)load(
|
|
"glDrawElementsIndirect"u8);
|
|
contextPtr->glDrawTransformFeedback = (delegate*<uint, uint, void>)load(
|
|
"glDrawTransformFeedback"u8);
|
|
contextPtr->glDrawTransformFeedbackStream = (delegate*<uint, uint, uint, void>)load(
|
|
"glDrawTransformFeedbackStream"u8);
|
|
contextPtr->glEndQueryIndexed = (delegate*<uint, uint, void>)load(
|
|
"glEndQueryIndexed"u8);
|
|
contextPtr->glGenTransformFeedbacks = (delegate*<uint, uint*, void>)load(
|
|
"glGenTransformFeedbacks"u8);
|
|
contextPtr->glGetActiveSubroutineName = (delegate*<uint, uint, uint, uint, uint*, byte*, void>)load(
|
|
"glGetActiveSubroutineName"u8);
|
|
contextPtr->glGetActiveSubroutineUniformName = (delegate*<uint, uint, uint, uint, uint*, byte*, void>)load(
|
|
"glGetActiveSubroutineUniformName"u8);
|
|
contextPtr->glGetActiveSubroutineUniformiv = (delegate*<uint, uint, uint, uint, int*, void>)load(
|
|
"glGetActiveSubroutineUniformiv"u8);
|
|
contextPtr->glGetProgramStageiv = (delegate*<uint, uint, uint, int*, void>)load(
|
|
"glGetProgramStageiv"u8);
|
|
contextPtr->glGetQueryIndexediv = (delegate*<uint, uint, uint, int*, void>)load(
|
|
"glGetQueryIndexediv"u8);
|
|
contextPtr->glGetSubroutineIndex = (delegate*<uint, uint, byte*, uint>)load(
|
|
"glGetSubroutineIndex"u8);
|
|
contextPtr->glGetSubroutineUniformLocation = (delegate*<uint, uint, byte*, int>)load(
|
|
"glGetSubroutineUniformLocation"u8);
|
|
contextPtr->glGetUniformSubroutineuiv = (delegate*<uint, int, uint*, void>)load(
|
|
"glGetUniformSubroutineuiv"u8);
|
|
contextPtr->glGetUniformdv = (delegate*<uint, int, double*, void>)load(
|
|
"glGetUniformdv"u8);
|
|
contextPtr->glIsTransformFeedback = (delegate*<uint, bool>)load(
|
|
"glIsTransformFeedback"u8);
|
|
contextPtr->glMinSampleShading = (delegate*<float, void>)load("glMinSampleShading"u8);
|
|
contextPtr->glPatchParameterfv = (delegate*<uint, float*, void>)load(
|
|
"glPatchParameterfv"u8);
|
|
contextPtr->glPatchParameteri = (delegate*<uint, int, void>)load(
|
|
"glPatchParameteri"u8);
|
|
contextPtr->glPauseTransformFeedback = (delegate*<void>)load(
|
|
"glPauseTransformFeedback"u8);
|
|
contextPtr->glResumeTransformFeedback = (delegate*<void>)load(
|
|
"glResumeTransformFeedback"u8);
|
|
contextPtr->glUniform1d = (delegate*<int, double, void>)load("glUniform1d"u8);
|
|
contextPtr->glUniform1dv = (delegate*<int, uint, double*, void>)load("glUniform1dv"u8);
|
|
contextPtr->glUniform2d = (delegate*<int, double, double, void>)load("glUniform2d"u8);
|
|
contextPtr->glUniform2dv = (delegate*<int, uint, double*, void>)load("glUniform2dv"u8);
|
|
contextPtr->glUniform3d = (delegate*<int, double, double, double, void>)load(
|
|
"glUniform3d"u8);
|
|
contextPtr->glUniform3dv = (delegate*<int, uint, double*, void>)load("glUniform3dv"u8);
|
|
contextPtr->glUniform4d = (delegate*<int, double, double, double, double, void>)load(
|
|
"glUniform4d"u8);
|
|
contextPtr->glUniform4dv = (delegate*<int, uint, double*, void>)load("glUniform4dv"u8);
|
|
contextPtr->glUniformMatrix2dv = (delegate*<int, uint, bool, double*, void>)load(
|
|
"glUniformMatrix2dv"u8);
|
|
contextPtr->glUniformMatrix2x3dv = (delegate*<int, uint, bool, double*, void>)load(
|
|
"glUniformMatrix2x3dv"u8);
|
|
contextPtr->glUniformMatrix2x4dv = (delegate*<int, uint, bool, double*, void>)load(
|
|
"glUniformMatrix2x4dv"u8);
|
|
contextPtr->glUniformMatrix3dv = (delegate*<int, uint, bool, double*, void>)load(
|
|
"glUniformMatrix3dv"u8);
|
|
contextPtr->glUniformMatrix3x2dv = (delegate*<int, uint, bool, double*, void>)load(
|
|
"glUniformMatrix3x2dv"u8);
|
|
contextPtr->glUniformMatrix3x4dv = (delegate*<int, uint, bool, double*, void>)load(
|
|
"glUniformMatrix3x4dv"u8);
|
|
contextPtr->glUniformMatrix4dv = (delegate*<int, uint, bool, double*, void>)load(
|
|
"glUniformMatrix4dv"u8);
|
|
contextPtr->glUniformMatrix4x2dv = (delegate*<int, uint, bool, double*, void>)load(
|
|
"glUniformMatrix4x2dv"u8);
|
|
contextPtr->glUniformMatrix4x3dv = (delegate*<int, uint, bool, double*, void>)load(
|
|
"glUniformMatrix4x3dv"u8);
|
|
contextPtr->glUniformSubroutinesuiv = (delegate*<uint, uint, uint*, void>)load(
|
|
"glUniformSubroutinesuiv"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 4.0 APIs");
|
|
return true;
|
|
}
|
|
|
|
internal static unsafe bool LoadGLcore41(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core41)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 4.1 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glActiveShaderProgram = (delegate*<uint, uint, void>)load(
|
|
"glActiveShaderProgram"u8);
|
|
contextPtr->glBindProgramPipeline = (delegate*<uint, void>)load(
|
|
"glBindProgramPipeline"u8);
|
|
contextPtr->glClearDepthf = (delegate*<float, void>)load("glClearDepthf"u8);
|
|
contextPtr->glCreateShaderProgramv = (delegate*<uint, uint, byte*, uint>)load(
|
|
"glCreateShaderProgramv"u8);
|
|
contextPtr->glDeleteProgramPipelines = (delegate*<uint, uint*, void>)load(
|
|
"glDeleteProgramPipelines"u8);
|
|
contextPtr->glDepthRangeArrayv = (delegate*<uint, uint, double*, void>)load(
|
|
"glDepthRangeArrayv"u8);
|
|
contextPtr->glDepthRangeIndexed = (delegate*<uint, double, double, void>)load(
|
|
"glDepthRangeIndexed"u8);
|
|
contextPtr->glDepthRangef = (delegate*<float, float, void>)load("glDepthRangef"u8);
|
|
contextPtr->glGenProgramPipelines = (delegate*<uint, uint*, void>)load(
|
|
"glGenProgramPipelines"u8);
|
|
contextPtr->glGetDoublei_v = (delegate*<uint, uint, double*, void>)load(
|
|
"glGetDoublei_v"u8);
|
|
contextPtr->glGetFloati_v = (delegate*<uint, uint, float*, void>)load(
|
|
"glGetFloati_v"u8);
|
|
contextPtr->glGetProgramBinary = (delegate*<uint, uint, uint*, uint*, void*, void>)load(
|
|
"glGetProgramBinary"u8);
|
|
contextPtr->glGetProgramPipelineInfoLog = (delegate*<uint, uint, uint*, byte*, void>)load(
|
|
"glGetProgramPipelineInfoLog"u8);
|
|
contextPtr->glGetProgramPipelineiv = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetProgramPipelineiv"u8);
|
|
contextPtr->glGetShaderPrecisionFormat = (delegate*<uint, uint, int*, int*, void>)load(
|
|
"glGetShaderPrecisionFormat"u8);
|
|
contextPtr->glGetVertexAttribLdv = (delegate*<uint, uint, double*, void>)load(
|
|
"glGetVertexAttribLdv"u8);
|
|
contextPtr->glIsProgramPipeline = (delegate*<uint, bool>)load("glIsProgramPipeline"u8);
|
|
contextPtr->glProgramBinary = (delegate*<uint, uint, void*, uint, void>)load(
|
|
"glProgramBinary"u8);
|
|
contextPtr->glProgramParameteri = (delegate*<uint, uint, int, void>)load(
|
|
"glProgramParameteri"u8);
|
|
contextPtr->glProgramUniform1d = (delegate*<uint, int, double, void>)load(
|
|
"glProgramUniform1d"u8);
|
|
contextPtr->glProgramUniform1dv = (delegate*<uint, int, uint, double*, void>)load(
|
|
"glProgramUniform1dv"u8);
|
|
contextPtr->glProgramUniform1f = (delegate*<uint, int, float, void>)load(
|
|
"glProgramUniform1f"u8);
|
|
contextPtr->glProgramUniform1fv = (delegate*<uint, int, uint, float*, void>)load(
|
|
"glProgramUniform1fv"u8);
|
|
contextPtr->glProgramUniform1i = (delegate*<uint, int, int, void>)load(
|
|
"glProgramUniform1i"u8);
|
|
contextPtr->glProgramUniform1iv = (delegate*<uint, int, uint, int*, void>)load(
|
|
"glProgramUniform1iv"u8);
|
|
contextPtr->glProgramUniform1ui = (delegate*<uint, int, uint, void>)load(
|
|
"glProgramUniform1ui"u8);
|
|
contextPtr->glProgramUniform1uiv = (delegate*<uint, int, uint, uint*, void>)load(
|
|
"glProgramUniform1uiv"u8);
|
|
contextPtr->glProgramUniform2d = (delegate*<uint, int, double, double, void>)load(
|
|
"glProgramUniform2d"u8);
|
|
contextPtr->glProgramUniform2dv = (delegate*<uint, int, uint, double*, void>)load(
|
|
"glProgramUniform2dv"u8);
|
|
contextPtr->glProgramUniform2f = (delegate*<uint, int, float, float, void>)load(
|
|
"glProgramUniform2f"u8);
|
|
contextPtr->glProgramUniform2fv = (delegate*<uint, int, uint, float*, void>)load(
|
|
"glProgramUniform2fv"u8);
|
|
contextPtr->glProgramUniform2i = (delegate*<uint, int, int, int, void>)load(
|
|
"glProgramUniform2i"u8);
|
|
contextPtr->glProgramUniform2iv = (delegate*<uint, int, uint, int*, void>)load(
|
|
"glProgramUniform2iv"u8);
|
|
contextPtr->glProgramUniform2ui = (delegate*<uint, int, uint, uint, void>)load(
|
|
"glProgramUniform2ui"u8);
|
|
contextPtr->glProgramUniform2uiv = (delegate*<uint, int, uint, uint*, void>)load(
|
|
"glProgramUniform2uiv"u8);
|
|
contextPtr->glProgramUniform3d = (delegate*<uint, int, double, double, double, void>)load(
|
|
"glProgramUniform3d"u8);
|
|
contextPtr->glProgramUniform3dv = (delegate*<uint, int, uint, double*, void>)load(
|
|
"glProgramUniform3dv"u8);
|
|
contextPtr->glProgramUniform3f = (delegate*<uint, int, float, float, float, void>)load(
|
|
"glProgramUniform3f"u8);
|
|
contextPtr->glProgramUniform3fv = (delegate*<uint, int, uint, float*, void>)load(
|
|
"glProgramUniform3fv"u8);
|
|
contextPtr->glProgramUniform3i = (delegate*<uint, int, int, int, int, void>)load(
|
|
"glProgramUniform3i"u8);
|
|
contextPtr->glProgramUniform3iv = (delegate*<uint, int, uint, int*, void>)load(
|
|
"glProgramUniform3iv"u8);
|
|
contextPtr->glProgramUniform3ui = (delegate*<uint, int, uint, uint, uint, void>)load(
|
|
"glProgramUniform3ui"u8);
|
|
contextPtr->glProgramUniform3uiv = (delegate*<uint, int, uint, uint*, void>)load(
|
|
"glProgramUniform3uiv"u8);
|
|
contextPtr->glProgramUniform4d = (delegate*<uint, int, double, double, double, double, void>)load(
|
|
"glProgramUniform4d"u8);
|
|
contextPtr->glProgramUniform4dv = (delegate*<uint, int, uint, double*, void>)load(
|
|
"glProgramUniform4dv"u8);
|
|
contextPtr->glProgramUniform4f = (delegate*<uint, int, float, float, float, float, void>)load(
|
|
"glProgramUniform4f"u8);
|
|
contextPtr->glProgramUniform4fv = (delegate*<uint, int, uint, float*, void>)load(
|
|
"glProgramUniform4fv"u8);
|
|
contextPtr->glProgramUniform4i = (delegate*<uint, int, int, int, int, int, void>)load(
|
|
"glProgramUniform4i"u8);
|
|
contextPtr->glProgramUniform4iv = (delegate*<uint, int, uint, int*, void>)load(
|
|
"glProgramUniform4iv"u8);
|
|
contextPtr->glProgramUniform4ui = (delegate*<uint, int, uint, uint, uint, uint, void>)load(
|
|
"glProgramUniform4ui"u8);
|
|
contextPtr->glProgramUniform4uiv = (delegate*<uint, int, uint, uint*, void>)load(
|
|
"glProgramUniform4uiv"u8);
|
|
contextPtr->glProgramUniformMatrix2dv = (delegate*<uint, int, uint, bool, double*, void>)load(
|
|
"glProgramUniformMatrix2dv"u8);
|
|
contextPtr->glProgramUniformMatrix2fv = (delegate*<uint, int, uint, bool, float*, void>)load(
|
|
"glProgramUniformMatrix2fv"u8);
|
|
contextPtr->glProgramUniformMatrix2x3dv = (delegate*<uint, int, uint, bool, double*, void>)load(
|
|
"glProgramUniformMatrix2x3dv"u8);
|
|
contextPtr->glProgramUniformMatrix2x3fv = (delegate*<uint, int, uint, bool, float*, void>)load(
|
|
"glProgramUniformMatrix2x3fv"u8);
|
|
contextPtr->glProgramUniformMatrix2x4dv = (delegate*<uint, int, uint, bool, double*, void>)load(
|
|
"glProgramUniformMatrix2x4dv"u8);
|
|
contextPtr->glProgramUniformMatrix2x4fv = (delegate*<uint, int, uint, bool, float*, void>)load(
|
|
"glProgramUniformMatrix2x4fv"u8);
|
|
contextPtr->glProgramUniformMatrix3dv = (delegate*<uint, int, uint, bool, double*, void>)load(
|
|
"glProgramUniformMatrix3dv"u8);
|
|
contextPtr->glProgramUniformMatrix3fv = (delegate*<uint, int, uint, bool, float*, void>)load(
|
|
"glProgramUniformMatrix3fv"u8);
|
|
contextPtr->glProgramUniformMatrix3x2dv = (delegate*<uint, int, uint, bool, double*, void>)load(
|
|
"glProgramUniformMatrix3x2dv"u8);
|
|
contextPtr->glProgramUniformMatrix3x2fv = (delegate*<uint, int, uint, bool, float*, void>)load(
|
|
"glProgramUniformMatrix3x2fv"u8);
|
|
contextPtr->glProgramUniformMatrix3x4dv = (delegate*<uint, int, uint, bool, double*, void>)load(
|
|
"glProgramUniformMatrix3x4dv"u8);
|
|
contextPtr->glProgramUniformMatrix3x4fv = (delegate*<uint, int, uint, bool, float*, void>)load(
|
|
"glProgramUniformMatrix3x4fv"u8);
|
|
contextPtr->glProgramUniformMatrix4dv = (delegate*<uint, int, uint, bool, double*, void>)load(
|
|
"glProgramUniformMatrix4dv"u8);
|
|
contextPtr->glProgramUniformMatrix4fv = (delegate*<uint, int, uint, bool, float*, void>)load(
|
|
"glProgramUniformMatrix4fv"u8);
|
|
contextPtr->glProgramUniformMatrix4x2dv = (delegate*<uint, int, uint, bool, double*, void>)load(
|
|
"glProgramUniformMatrix4x2dv"u8);
|
|
contextPtr->glProgramUniformMatrix4x2fv = (delegate*<uint, int, uint, bool, float*, void>)load(
|
|
"glProgramUniformMatrix4x2fv"u8);
|
|
contextPtr->glProgramUniformMatrix4x3dv = (delegate*<uint, int, uint, bool, double*, void>)load(
|
|
"glProgramUniformMatrix4x3dv"u8);
|
|
contextPtr->glProgramUniformMatrix4x3fv = (delegate*<uint, int, uint, bool, float*, void>)load(
|
|
"glProgramUniformMatrix4x3fv"u8);
|
|
contextPtr->glReleaseShaderCompiler = (delegate*<void>)load(
|
|
"glReleaseShaderCompiler"u8);
|
|
contextPtr->glScissorArrayv = (delegate*<uint, uint, int*, void>)load(
|
|
"glScissorArrayv"u8);
|
|
contextPtr->glScissorIndexed = (delegate*<uint, int, int, uint, uint, void>)load(
|
|
"glScissorIndexed"u8);
|
|
contextPtr->glScissorIndexedv = (delegate*<uint, int*, void>)load(
|
|
"glScissorIndexedv"u8);
|
|
contextPtr->glShaderBinary = (delegate*<uint, uint*, uint, void*, uint, void>)load(
|
|
"glShaderBinary"u8);
|
|
contextPtr->glUseProgramStages = (delegate*<uint, uint, uint, void>)load(
|
|
"glUseProgramStages"u8);
|
|
contextPtr->glValidateProgramPipeline = (delegate*<uint, void>)load(
|
|
"glValidateProgramPipeline"u8);
|
|
contextPtr->glVertexAttribL1d = (delegate*<uint, double, void>)load(
|
|
"glVertexAttribL1d"u8);
|
|
contextPtr->glVertexAttribL1dv = (delegate*<uint, double*, void>)load(
|
|
"glVertexAttribL1dv"u8);
|
|
contextPtr->glVertexAttribL2d = (delegate*<uint, double, double, void>)load(
|
|
"glVertexAttribL2d"u8);
|
|
contextPtr->glVertexAttribL2dv = (delegate*<uint, double*, void>)load(
|
|
"glVertexAttribL2dv"u8);
|
|
contextPtr->glVertexAttribL3d = (delegate*<uint, double, double, double, void>)load(
|
|
"glVertexAttribL3d"u8);
|
|
contextPtr->glVertexAttribL3dv = (delegate*<uint, double*, void>)load(
|
|
"glVertexAttribL3dv"u8);
|
|
contextPtr->glVertexAttribL4d = (delegate*<uint, double, double, double, double, void>)load(
|
|
"glVertexAttribL4d"u8);
|
|
contextPtr->glVertexAttribL4dv = (delegate*<uint, double*, void>)load(
|
|
"glVertexAttribL4dv"u8);
|
|
contextPtr->glVertexAttribLPointer = (delegate*<uint, int, uint, uint, void*, void>)load(
|
|
"glVertexAttribLPointer"u8);
|
|
contextPtr->glViewportArrayv = (delegate*<uint, uint, float*, void>)load(
|
|
"glViewportArrayv"u8);
|
|
contextPtr->glViewportIndexedf = (delegate*<uint, float, float, float, float, void>)load(
|
|
"glViewportIndexedf"u8);
|
|
contextPtr->glViewportIndexedfv = (delegate*<uint, float*, void>)load(
|
|
"glViewportIndexedfv"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 4.1 APIs");
|
|
return true;
|
|
}
|
|
|
|
internal static unsafe bool LoadGLcore42(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core42)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 4.2 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glBindImageTexture = (delegate*<uint, uint, int, bool, int, uint, uint, void>)load(
|
|
"glBindImageTexture"u8);
|
|
contextPtr->glDrawArraysInstancedBaseInstance = (delegate*<uint, int, uint, uint, uint, void>)load(
|
|
"glDrawArraysInstancedBaseInstance"u8);
|
|
contextPtr->glDrawElementsInstancedBaseInstance = (delegate*<uint, uint, uint, void*, uint, uint, void>)load(
|
|
"glDrawElementsInstancedBaseInstance"u8);
|
|
contextPtr->glDrawElementsInstancedBaseVertexBaseInstance = (delegate*<uint, uint, uint, void*, uint, int, uint, void>)load(
|
|
"glDrawElementsInstancedBaseVertexBaseInstance"u8);
|
|
contextPtr->glDrawTransformFeedbackInstanced = (delegate*<uint, uint, uint, void>)load(
|
|
"glDrawTransformFeedbackInstanced"u8);
|
|
contextPtr->glDrawTransformFeedbackStreamInstanced = (delegate*<uint, uint, uint, uint, void>)load(
|
|
"glDrawTransformFeedbackStreamInstanced"u8);
|
|
contextPtr->glGetActiveAtomicCounterBufferiv = (delegate*<uint, uint, uint, int*, void>)load(
|
|
"glGetActiveAtomicCounterBufferiv"u8);
|
|
contextPtr->glGetInternalformativ = (delegate*<uint, uint, uint, uint, int*, void>)load(
|
|
"glGetInternalformativ"u8);
|
|
contextPtr->glMemoryBarrier = (delegate*<uint, void>)load("glMemoryBarrier"u8);
|
|
contextPtr->glTexStorage1D = (delegate*<uint, uint, uint, uint, void>)load(
|
|
"glTexStorage1D"u8);
|
|
contextPtr->glTexStorage2D = (delegate*<uint, uint, uint, uint, uint, void>)load(
|
|
"glTexStorage2D"u8);
|
|
contextPtr->glTexStorage3D = (delegate*<uint, uint, uint, uint, uint, uint, void>)load(
|
|
"glTexStorage3D"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 4.2 APIs");
|
|
return true;
|
|
}
|
|
|
|
internal static unsafe bool LoadGLcore43(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core43)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 4.3 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glBindVertexBuffer = (delegate*<uint, uint, IntPtr, uint, void>)load(
|
|
"glBindVertexBuffer"u8);
|
|
contextPtr->glClearBufferData = (delegate*<uint, uint, uint, uint, void*, void>)load(
|
|
"glClearBufferData"u8);
|
|
contextPtr->glClearBufferSubData = (delegate*<uint, uint, IntPtr, UIntPtr, uint, uint, void*, void>)load(
|
|
"glClearBufferSubData"u8);
|
|
contextPtr->glCopyImageSubData = (delegate*<uint, uint, int, int, int, int, uint, uint, int, int, int, int, uint, uint, uint, void>)load(
|
|
"glCopyImageSubData"u8);
|
|
contextPtr->glDebugMessageCallback = (delegate*<GLDEBUGPROC, void*, void>)load(
|
|
"glDebugMessageCallback"u8);
|
|
contextPtr->glDebugMessageControl = (delegate*<uint, uint, uint, uint, uint*, bool, void>)load(
|
|
"glDebugMessageControl"u8);
|
|
contextPtr->glDebugMessageInsert = (delegate*<uint, uint, uint, uint, uint, byte*, void>)load(
|
|
"glDebugMessageInsert"u8);
|
|
contextPtr->glDispatchCompute = (delegate*<uint, uint, uint, void>)load(
|
|
"glDispatchCompute"u8);
|
|
contextPtr->glDispatchComputeIndirect = (delegate*<IntPtr, void>)load(
|
|
"glDispatchComputeIndirect"u8);
|
|
contextPtr->glFramebufferParameteri = (delegate*<uint, uint, int, void>)load(
|
|
"glFramebufferParameteri"u8);
|
|
contextPtr->glGetDebugMessageLog = (delegate*<uint, uint, uint*, uint*, uint*, uint*, uint*, byte*, uint>)load(
|
|
"glGetDebugMessageLog"u8);
|
|
contextPtr->glGetFramebufferParameteriv = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetFramebufferParameteriv"u8);
|
|
contextPtr->glGetInternalformati64v = (delegate*<uint, uint, uint, uint, long*, void>)load(
|
|
"glGetInternalformati64v"u8);
|
|
contextPtr->glGetObjectLabel = (delegate*<uint, uint, uint, uint*, byte*, void>)load(
|
|
"glGetObjectLabel"u8);
|
|
contextPtr->glGetObjectPtrLabel = (delegate*<void*, uint, uint*, byte*, void>)load(
|
|
"glGetObjectPtrLabel"u8);
|
|
contextPtr->glGetPointerv = (delegate*<uint, void**, void>)load("glGetPointerv"u8);
|
|
contextPtr->glGetProgramInterfaceiv = (delegate*<uint, uint, uint, int*, void>)load(
|
|
"glGetProgramInterfaceiv"u8);
|
|
contextPtr->glGetProgramResourceIndex = (delegate*<uint, uint, byte*, uint>)load(
|
|
"glGetProgramResourceIndex"u8);
|
|
contextPtr->glGetProgramResourceLocation = (delegate*<uint, uint, byte*, int>)load(
|
|
"glGetProgramResourceLocation"u8);
|
|
contextPtr->glGetProgramResourceLocationIndex = (delegate*<uint, uint, byte*, int>)load(
|
|
"glGetProgramResourceLocationIndex"u8);
|
|
contextPtr->glGetProgramResourceName = (delegate*<uint, uint, uint, uint, uint*, byte*, void>)load(
|
|
"glGetProgramResourceName"u8);
|
|
contextPtr->glGetProgramResourceiv = (delegate*<uint, uint, uint, uint, uint*, uint, uint*, int*, void>)load(
|
|
"glGetProgramResourceiv"u8);
|
|
contextPtr->glInvalidateBufferData = (delegate*<uint, void>)load(
|
|
"glInvalidateBufferData"u8);
|
|
contextPtr->glInvalidateBufferSubData = (delegate*<uint, IntPtr, UIntPtr, void>)load(
|
|
"glInvalidateBufferSubData"u8);
|
|
contextPtr->glInvalidateFramebuffer = (delegate*<uint, uint, uint*, void>)load(
|
|
"glInvalidateFramebuffer"u8);
|
|
contextPtr->glInvalidateSubFramebuffer = (delegate*<uint, uint, uint*, int, int, uint, uint, void>)load(
|
|
"glInvalidateSubFramebuffer"u8);
|
|
contextPtr->glInvalidateTexImage = (delegate*<uint, int, void>)load(
|
|
"glInvalidateTexImage"u8);
|
|
contextPtr->glInvalidateTexSubImage = (delegate*<uint, int, int, int, int, uint, uint, uint, void>)load(
|
|
"glInvalidateTexSubImage"u8);
|
|
contextPtr->glMultiDrawArraysIndirect = (delegate*<uint, void*, uint, uint, void>)load(
|
|
"glMultiDrawArraysIndirect"u8);
|
|
contextPtr->glMultiDrawElementsIndirect = (delegate*<uint, uint, void*, uint, uint, void>)load(
|
|
"glMultiDrawElementsIndirect"u8);
|
|
contextPtr->glObjectLabel = (delegate*<uint, uint, uint, byte*, void>)load(
|
|
"glObjectLabel"u8);
|
|
contextPtr->glObjectPtrLabel = (delegate*<void*, uint, byte*, void>)load(
|
|
"glObjectPtrLabel"u8);
|
|
contextPtr->glPopDebugGroup = (delegate*<void>)load("glPopDebugGroup"u8);
|
|
contextPtr->glPushDebugGroup = (delegate*<uint, uint, uint, byte*, void>)load(
|
|
"glPushDebugGroup"u8);
|
|
contextPtr->glShaderStorageBlockBinding = (delegate*<uint, uint, uint, void>)load(
|
|
"glShaderStorageBlockBinding"u8);
|
|
contextPtr->glTexBufferRange = (delegate*<uint, uint, uint, IntPtr, UIntPtr, void>)load(
|
|
"glTexBufferRange"u8);
|
|
contextPtr->glTexStorage2DMultisample = (delegate*<uint, uint, uint, uint, uint, bool, void>)load(
|
|
"glTexStorage2DMultisample"u8);
|
|
contextPtr->glTexStorage3DMultisample = (delegate*<uint, uint, uint, uint, uint, uint, bool, void>)load(
|
|
"glTexStorage3DMultisample"u8);
|
|
contextPtr->glTextureView = (delegate*<uint, uint, uint, uint, uint, uint, uint, uint, void>)load(
|
|
"glTextureView"u8);
|
|
contextPtr->glVertexAttribBinding = (delegate*<uint, uint, void>)load(
|
|
"glVertexAttribBinding"u8);
|
|
contextPtr->glVertexAttribFormat = (delegate*<uint, int, uint, bool, uint, void>)load(
|
|
"glVertexAttribFormat"u8);
|
|
contextPtr->glVertexAttribIFormat = (delegate*<uint, int, uint, uint, void>)load(
|
|
"glVertexAttribIFormat"u8);
|
|
contextPtr->glClearBufferData = (delegate*<uint, uint, uint, uint, void*, void>)load(
|
|
"glClearBufferData"u8);
|
|
contextPtr->glVertexBindingDivisor = (delegate*<uint, uint, void>)load(
|
|
"glVertexBindingDivisor"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 4.3 APIs");
|
|
return true;
|
|
}
|
|
|
|
internal static unsafe bool LoadGLcore44(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core44)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 4.4 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glBindBuffersBase = (delegate*<uint, uint, uint, uint*, void>)load(
|
|
"glBindBuffersBase"u8);
|
|
contextPtr->glBindBuffersRange = (delegate*<uint, uint, uint, uint*, IntPtr*, UIntPtr*, void>)load(
|
|
"glBindBuffersRange"u8);
|
|
contextPtr->glBindImageTextures = (delegate*<uint, uint, uint*, void>)load(
|
|
"glBindImageTextures"u8);
|
|
contextPtr->glBindSamplers = (delegate*<uint, uint, uint*, void>)load(
|
|
"glBindSamplers"u8);
|
|
contextPtr->glBindTextures = (delegate*<uint, uint, uint*, void>)load(
|
|
"glBindTextures"u8);
|
|
contextPtr->glBindVertexBuffers = (delegate*<uint, uint, uint*, IntPtr*, uint*, void>)load(
|
|
"glBindVertexBuffers"u8);
|
|
contextPtr->glBufferStorage = (delegate*<uint, UIntPtr, void*, uint, void>)load(
|
|
"glBufferStorage"u8);
|
|
contextPtr->glClearTexImage = (delegate*<uint, int, uint, uint, void*, void>)load(
|
|
"glClearTexImage"u8);
|
|
contextPtr->glClearTexSubImage = (delegate*<uint, int, int, int, int, uint, uint, uint, uint, uint, void*, void>)load(
|
|
"glClearTexSubImage"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 4.4 APIs");
|
|
return true;
|
|
}
|
|
|
|
internal static unsafe bool LoadGLcore45(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core45)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 4.5 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glBindTextureUnit = (delegate*<uint, uint, void>)load(
|
|
"glBindTextureUnit"u8);
|
|
contextPtr->glBlitNamedFramebuffer = (delegate*<uint, uint, int, int, int, int, int, int, int, int, uint, uint, void>)load(
|
|
"glBlitNamedFramebuffer"u8);
|
|
contextPtr->glCheckNamedFramebufferStatus = (delegate*<uint, uint, uint>)load(
|
|
"glCheckNamedFramebufferStatus"u8);
|
|
contextPtr->glClearNamedBufferData = (delegate*<uint, uint, uint, uint, void*, void>)load(
|
|
"glClearNamedBufferData"u8);
|
|
contextPtr->glClearNamedBufferSubData = (delegate*<uint, uint, IntPtr, UIntPtr, uint, uint, void*, void>)load(
|
|
"glClearNamedBufferSubData"u8);
|
|
contextPtr->glClearNamedFramebufferfi = (delegate*<uint, uint, int, float, int, void>)load(
|
|
"glClearNamedFramebufferfi"u8);
|
|
contextPtr->glClearNamedFramebufferfv = (delegate*<uint, uint, int, float*, void>)load(
|
|
"glClearNamedFramebufferfv"u8);
|
|
contextPtr->glClearNamedFramebufferiv = (delegate*<uint, uint, int, int*, void>)load(
|
|
"glClearNamedFramebufferiv"u8);
|
|
contextPtr->glClearNamedFramebufferuiv = (delegate*<uint, uint, int, uint*, void>)load(
|
|
"glClearNamedFramebufferuiv"u8);
|
|
contextPtr->glClipControl = (delegate*<uint, uint, void>)load("glClipControl"u8);
|
|
contextPtr->glCompressedTextureSubImage1D = (delegate*<uint, int, int, uint, uint, uint, void*, void>)load(
|
|
"glCompressedTextureSubImage1D"u8);
|
|
contextPtr->glCompressedTextureSubImage2D = (delegate*<uint, int, int, int, uint, uint, uint, uint, void*, void>)load(
|
|
"glCompressedTextureSubImage2D"u8);
|
|
contextPtr->glCompressedTextureSubImage3D = (delegate*<uint, int, int, int, int, uint, uint, uint, uint, uint, void*, void>)load(
|
|
"glCompressedTextureSubImage3D"u8);
|
|
contextPtr->glCopyNamedBufferSubData = (delegate*<uint, uint, IntPtr, IntPtr, UIntPtr, void>)load(
|
|
"glCopyNamedBufferSubData"u8);
|
|
contextPtr->glCopyTextureSubImage1D = (delegate*<uint, int, int, int, int, uint, void>)load(
|
|
"glCopyTextureSubImage1D"u8);
|
|
contextPtr->glCopyTextureSubImage2D = (delegate*<uint, int, int, int, int, int, uint, uint, void>)load(
|
|
"glCopyTextureSubImage2D"u8);
|
|
contextPtr->glCopyTextureSubImage3D = (delegate*<uint, int, int, int, int, int, int, uint, uint, void>)load(
|
|
"glCopyTextureSubImage3D"u8);
|
|
contextPtr->glCreateBuffers = (delegate*<uint, uint*, void>)load("glCreateBuffers"u8);
|
|
contextPtr->glCreateFramebuffers = (delegate*<uint, uint*, void>)load(
|
|
"glCreateFramebuffers"u8);
|
|
contextPtr->glCreateProgramPipelines = (delegate*<uint, uint*, void>)load(
|
|
"glCreateProgramPipelines"u8);
|
|
contextPtr->glCreateQueries = (delegate*<uint, uint, uint*, void>)load(
|
|
"glCreateQueries"u8);
|
|
contextPtr->glCreateRenderbuffers = (delegate*<uint, uint*, void>)load(
|
|
"glCreateRenderbuffers"u8);
|
|
contextPtr->glCreateSamplers = (delegate*<uint, uint*, void>)load(
|
|
"glCreateSamplers"u8);
|
|
contextPtr->glCreateTextures = (delegate*<uint, uint, uint*, void>)load(
|
|
"glCreateTextures"u8);
|
|
contextPtr->glCreateTransformFeedbacks = (delegate*<uint, uint*, void>)load(
|
|
"glCreateTransformFeedbacks"u8);
|
|
contextPtr->glCreateVertexArrays = (delegate*<uint, uint*, void>)load(
|
|
"glCreateVertexArrays"u8);
|
|
contextPtr->glDisableVertexArrayAttrib = (delegate*<uint, uint, void>)load(
|
|
"glDisableVertexArrayAttrib"u8);
|
|
contextPtr->glEnableVertexArrayAttrib = (delegate*<uint, uint, void>)load(
|
|
"glEnableVertexArrayAttrib"u8);
|
|
contextPtr->glFlushMappedNamedBufferRange = (delegate*<uint, IntPtr, UIntPtr, void>)load(
|
|
"glFlushMappedNamedBufferRange"u8);
|
|
contextPtr->glGenerateTextureMipmap = (delegate*<uint, void>)load(
|
|
"glGenerateTextureMipmap"u8);
|
|
contextPtr->glGetCompressedTextureImage = (delegate*<uint, int, uint, void*, void>)load(
|
|
"glGetCompressedTextureImage"u8);
|
|
contextPtr->glGetCompressedTextureSubImage = (delegate*<uint, int, int, int, int, uint, uint, uint, uint, void*, void>)load(
|
|
"glGetCompressedTextureSubImage"u8);
|
|
contextPtr->glGetGraphicsResetStatus = (delegate*<uint>)load(
|
|
"glGetGraphicsResetStatus"u8);
|
|
contextPtr->glGetNamedBufferParameteri64v = (delegate*<uint, uint, long*, void>)load(
|
|
"glGetNamedBufferParameteri64v"u8);
|
|
contextPtr->glGetNamedBufferParameteriv = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetNamedBufferParameteriv"u8);
|
|
contextPtr->glGetNamedBufferPointerv = (delegate*<uint, uint, void**, void>)load(
|
|
"glGetNamedBufferPointerv"u8);
|
|
contextPtr->glGetNamedBufferSubData = (delegate*<uint, IntPtr, UIntPtr, void*, void>)load(
|
|
"glGetNamedBufferSubData"u8);
|
|
contextPtr->glGetNamedFramebufferAttachmentParameteriv = (delegate*<uint, uint, uint, int*, void>)load(
|
|
"glGetNamedFramebufferAttachmentParameteriv"u8);
|
|
contextPtr->glGetNamedFramebufferParameteriv = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetNamedFramebufferParameteriv"u8);
|
|
contextPtr->glGetNamedRenderbufferParameteriv = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetNamedRenderbufferParameteriv"u8);
|
|
contextPtr->glGetQueryBufferObjecti64v = (delegate*<uint, uint, uint, IntPtr, void>)load(
|
|
"glGetQueryBufferObjecti64v"u8);
|
|
contextPtr->glGetQueryBufferObjectiv = (delegate*<uint, uint, uint, IntPtr, void>)load(
|
|
"glGetQueryBufferObjectiv"u8);
|
|
contextPtr->glGetQueryBufferObjectui64v = (delegate*<uint, uint, uint, IntPtr, void>)load(
|
|
"glGetQueryBufferObjectui64v"u8);
|
|
contextPtr->glGetQueryBufferObjectuiv = (delegate*<uint, uint, uint, IntPtr, void>)load(
|
|
"glGetQueryBufferObjectuiv"u8);
|
|
contextPtr->glGetTextureImage = (delegate*<uint, int, uint, uint, uint, void*, void>)load(
|
|
"glGetTextureImage"u8);
|
|
contextPtr->glGetTextureLevelParameterfv = (delegate*<uint, int, uint, float*, void>)load(
|
|
"glGetTextureLevelParameterfv"u8);
|
|
contextPtr->glGetTextureLevelParameteriv = (delegate*<uint, int, uint, int*, void>)load(
|
|
"glGetTextureLevelParameteriv"u8);
|
|
contextPtr->glGetTextureParameterIiv = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetTextureParameterIiv"u8);
|
|
contextPtr->glGetTextureParameterIuiv = (delegate*<uint, uint, uint*, void>)load(
|
|
"glGetTextureParameterIuiv"u8);
|
|
contextPtr->glGetTextureParameterfv = (delegate*<uint, uint, float*, void>)load(
|
|
"glGetTextureParameterfv"u8);
|
|
contextPtr->glGetTextureParameteriv = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetTextureParameteriv"u8);
|
|
contextPtr->glGetTextureSubImage = (delegate*<uint, int, int, int, int, uint, uint, uint, uint, uint, uint, void*, void>)load(
|
|
"glGetTextureSubImage"u8);
|
|
contextPtr->glGetTransformFeedbacki64_v = (delegate*<uint, uint, uint, long*, void>)load(
|
|
"glGetTransformFeedbacki64_v"u8);
|
|
contextPtr->glGetTransformFeedbacki_v = (delegate*<uint, uint, uint, int*, void>)load(
|
|
"glGetTransformFeedbacki_v"u8);
|
|
contextPtr->glGetTransformFeedbackiv = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetTransformFeedbackiv"u8);
|
|
contextPtr->glGetVertexArrayIndexed64iv = (delegate*<uint, uint, uint, long*, void>)load(
|
|
"glGetVertexArrayIndexed64iv"u8);
|
|
contextPtr->glGetVertexArrayIndexediv = (delegate*<uint, uint, uint, int*, void>)load(
|
|
"glGetVertexArrayIndexediv"u8);
|
|
contextPtr->glGetVertexArrayiv = (delegate*<uint, uint, int*, void>)load(
|
|
"glGetVertexArrayiv"u8);
|
|
contextPtr->glGetnCompressedTexImage = (delegate*<uint, int, uint, void*, void>)load(
|
|
"glGetnCompressedTexImage"u8);
|
|
contextPtr->glGetnTexImage = (delegate*<uint, int, uint, uint, uint, void*, void>)load(
|
|
"glGetnTexImage"u8);
|
|
contextPtr->glGetnUniformdv = (delegate*<uint, int, uint, double*, void>)load(
|
|
"glGetnUniformdv"u8);
|
|
contextPtr->glGetnUniformfv = (delegate*<uint, int, uint, float*, void>)load(
|
|
"glGetnUniformfv"u8);
|
|
contextPtr->glGetnUniformiv = (delegate*<uint, int, uint, int*, void>)load(
|
|
"glGetnUniformiv"u8);
|
|
contextPtr->glGetnUniformuiv = (delegate*<uint, int, uint, uint*, void>)load(
|
|
"glGetnUniformuiv"u8);
|
|
contextPtr->glInvalidateNamedFramebufferData = (delegate*<uint, uint, uint*, void>)load(
|
|
"glInvalidateNamedFramebufferData"u8);
|
|
contextPtr->glInvalidateNamedFramebufferSubData = (delegate*<uint, uint, uint*, int, int, uint, uint, void>)load(
|
|
"glInvalidateNamedFramebufferSubData"u8);
|
|
contextPtr->glMapNamedBuffer = (delegate*<uint, uint, void*>)load(
|
|
"glMapNamedBuffer"u8);
|
|
contextPtr->glMapNamedBufferRange = (delegate*<uint, IntPtr, UIntPtr, uint, void*>)load(
|
|
"glMapNamedBufferRange"u8);
|
|
contextPtr->glMemoryBarrierByRegion = (delegate*<uint, void>)load(
|
|
"glMemoryBarrierByRegion"u8);
|
|
contextPtr->glNamedBufferData = (delegate*<uint, UIntPtr, void*, uint, void>)load(
|
|
"glNamedBufferData"u8);
|
|
contextPtr->glNamedBufferStorage = (delegate*<uint, UIntPtr, void*, uint, void>)load(
|
|
"glNamedBufferStorage"u8);
|
|
contextPtr->glNamedBufferSubData = (delegate*<uint, IntPtr, UIntPtr, void*, void>)load(
|
|
"glNamedBufferSubData"u8);
|
|
contextPtr->glNamedFramebufferDrawBuffer = (delegate*<uint, uint, void>)load(
|
|
"glNamedFramebufferDrawBuffer"u8);
|
|
contextPtr->glNamedFramebufferDrawBuffers = (delegate*<uint, uint, uint*, void>)load(
|
|
"glNamedFramebufferDrawBuffers"u8);
|
|
contextPtr->glNamedFramebufferParameteri = (delegate*<uint, uint, int, void>)load(
|
|
"glNamedFramebufferParameteri"u8);
|
|
contextPtr->glNamedFramebufferReadBuffer = (delegate*<uint, uint, void>)load(
|
|
"glNamedFramebufferReadBuffer"u8);
|
|
contextPtr->glNamedFramebufferRenderbuffer = (delegate*<uint, uint, uint, uint, void>)load(
|
|
"glNamedFramebufferRenderbuffer"u8);
|
|
contextPtr->glNamedFramebufferTexture = (delegate*<uint, uint, uint, int, void>)load(
|
|
"glNamedFramebufferTexture"u8);
|
|
contextPtr->glNamedFramebufferTextureLayer = (delegate*<uint, uint, uint, int, int, void>)load(
|
|
"glNamedFramebufferTextureLayer"u8);
|
|
contextPtr->glNamedRenderbufferStorage = (delegate*<uint, uint, uint, uint, void>)load(
|
|
"glNamedRenderbufferStorage"u8);
|
|
contextPtr->glNamedRenderbufferStorageMultisample = (delegate*<uint, uint, uint, uint, uint, void>)load(
|
|
"glNamedRenderbufferStorageMultisample"u8);
|
|
contextPtr->glReadnPixels = (delegate*<int, int, int, int, uint, uint, uint, void*, void>)load(
|
|
"glReadnPixels"u8);
|
|
contextPtr->glTextureBarrier = (delegate*<void>)load("glTextureBarrier"u8);
|
|
contextPtr->glTextureBuffer = (delegate*<uint, uint, uint, void>)load(
|
|
"glTextureBuffer"u8);
|
|
contextPtr->glTextureBufferRange = (delegate*<uint, uint, uint, IntPtr, UIntPtr, void>)load(
|
|
"glTextureBufferRange"u8);
|
|
contextPtr->glTextureParameterIiv = (delegate*<uint, uint, int*, void>)load(
|
|
"glTextureParameterIiv"u8);
|
|
contextPtr->glTextureParameterIuiv = (delegate*<uint, uint, uint*, void>)load(
|
|
"glTextureParameterIuiv"u8);
|
|
contextPtr->glTextureParameterf = (delegate*<uint, uint, float, void>)load(
|
|
"glTextureParameterf"u8);
|
|
contextPtr->glTextureParameterfv = (delegate*<uint, uint, float*, void>)load(
|
|
"glTextureParameterfv"u8);
|
|
contextPtr->glTextureParameteri = (delegate*<uint, uint, int, void>)load(
|
|
"glTextureParameteri"u8);
|
|
contextPtr->glTextureParameteriv = (delegate*<uint, uint, int*, void>)load(
|
|
"glTextureParameteriv"u8);
|
|
contextPtr->glTextureStorage1D = (delegate*<uint, uint, uint, uint, void>)load(
|
|
"glTextureStorage1D"u8);
|
|
contextPtr->glTextureStorage2D = (delegate*<uint, uint, uint, uint, uint, void>)load(
|
|
"glTextureStorage2D"u8);
|
|
contextPtr->glTextureStorage2DMultisample = (delegate*<uint, uint, uint, uint, uint, bool, void>)load(
|
|
"glTextureStorage2DMultisample"u8);
|
|
contextPtr->glTextureStorage3D = (delegate*<uint, uint, uint, uint, uint, uint, void>)load(
|
|
"glTextureStorage3D"u8);
|
|
contextPtr->glTextureStorage3DMultisample = (delegate*<uint, uint, uint, uint, uint, uint, bool, void>)load(
|
|
"glTextureStorage3DMultisample"u8);
|
|
contextPtr->glTextureSubImage1D = (delegate*<uint, int, int, uint, uint, uint, void*, void>)load(
|
|
"glTextureSubImage1D"u8);
|
|
contextPtr->glTextureSubImage2D = (delegate*<uint, int, int, int, uint, uint, uint, uint, void*, void>)load(
|
|
"glTextureSubImage2D"u8);
|
|
contextPtr->glTextureSubImage3D = (delegate*<uint, int, int, int, int, uint, uint, uint, uint, uint, void*, void>)load(
|
|
"glTextureSubImage3D"u8);
|
|
contextPtr->glTransformFeedbackBufferBase = (delegate*<uint, uint, uint, void>)load(
|
|
"glTransformFeedbackBufferBase"u8);
|
|
contextPtr->glTransformFeedbackBufferRange = (delegate*<uint, uint, uint, IntPtr, UIntPtr, void>)load(
|
|
"glTransformFeedbackBufferRange"u8);
|
|
contextPtr->glUnmapNamedBuffer = (delegate*<uint, bool>)load("glUnmapNamedBuffer"u8);
|
|
contextPtr->glVertexArrayAttribBinding = (delegate*<uint, uint, uint, void>)load(
|
|
"glVertexArrayAttribBinding"u8);
|
|
contextPtr->glVertexArrayAttribFormat = (delegate*<uint, uint, int, uint, bool, uint, void>)load(
|
|
"glVertexArrayAttribFormat"u8);
|
|
contextPtr->glVertexArrayAttribIFormat = (delegate*<uint, uint, int, uint, uint, void>)load(
|
|
"glVertexArrayAttribIFormat"u8);
|
|
contextPtr->glVertexArrayAttribLFormat = (delegate*<uint, uint, int, uint, uint, void>)load(
|
|
"glVertexArrayAttribLFormat"u8);
|
|
contextPtr->glVertexArrayBindingDivisor = (delegate*<uint, uint, uint, void>)load(
|
|
"glVertexArrayBindingDivisor"u8);
|
|
contextPtr->glVertexArrayElementBuffer = (delegate*<uint, uint, void>)load(
|
|
"glVertexArrayElementBuffer"u8);
|
|
contextPtr->glVertexArrayVertexBuffer = (delegate*<uint, uint, uint, IntPtr, uint, void>)load(
|
|
"glVertexArrayVertexBuffer"u8);
|
|
contextPtr->glVertexArrayVertexBuffers = (delegate*<uint, uint, uint, uint*, IntPtr*, uint*, void>)load(
|
|
"glVertexArrayVertexBuffers"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 4.5 APIs");
|
|
return true;
|
|
}
|
|
|
|
internal static unsafe bool LoadGLcore46(OpenglContext* contextPtr, delegate*<ReadOnlySpan<byte>, IntPtr> load)
|
|
{
|
|
if (!core46)
|
|
{
|
|
DefaultLog.InternalAppendLog("The core version 4.6 is not supported.");
|
|
return false;
|
|
}
|
|
|
|
#region load
|
|
|
|
contextPtr->glMultiDrawArraysIndirectCount = (delegate*<uint, void*, IntPtr, uint, uint, void>)load(
|
|
"glMultiDrawArraysIndirectCount"u8);
|
|
contextPtr->glMultiDrawElementsIndirectCount = (delegate*<uint, uint, void*, IntPtr, uint, uint, void>)load(
|
|
"glMultiDrawElementsIndirectCount"u8);
|
|
contextPtr->glPolygonOffsetClamp = (delegate*<float, float, float, void>)load(
|
|
"glPolygonOffsetClamp"u8);
|
|
contextPtr->glSpecializeShader = (delegate*<uint, byte*, uint, uint*, uint*, void>)load(
|
|
"glSpecializeShader"u8);
|
|
|
|
#endregion load
|
|
|
|
DefaultLog.InternalAppendLog("Successfully load all OpenGL 4.6 APIs");
|
|
return true;
|
|
}
|
|
|
|
}
|
|
}
|