| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /* GATE PROJECT LICENSE: | ||
| 2 | +----------------------------------------------------------------------------+ | ||
| 3 | | Copyright(c) 2018-2026, Stefan Meislinger | | ||
| 4 | | All rights reserved. | | ||
| 5 | | | | ||
| 6 | | Redistribution and use in source and binary forms, with or without | | ||
| 7 | | modification, are permitted provided that the following conditions are met:| | ||
| 8 | | | | ||
| 9 | | 1. Redistributions of source code must retain the above copyright notice, | | ||
| 10 | | this list of conditions and the following disclaimer. | | ||
| 11 | | 2. Redistributions in binary form must reproduce the above copyright | | ||
| 12 | | notice, this list of conditions and the following disclaimer in the | | ||
| 13 | | documentation and/or other materials provided with the distribution. | | ||
| 14 | | | | ||
| 15 | | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"| | ||
| 16 | | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | | ||
| 17 | | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | | ||
| 18 | | ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE | | ||
| 19 | | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | | ||
| 20 | | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | | ||
| 21 | | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | | ||
| 22 | | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | | ||
| 23 | | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | | ||
| 24 | | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF | | ||
| 25 | | THE POSSIBILITY OF SUCH DAMAGE. | | ||
| 26 | +----------------------------------------------------------------------------+ | ||
| 27 | */ | ||
| 28 | #ifndef GATE_GRAPHICS_PLATFORM_OPENGL_APIS_H_INCLUDED | ||
| 29 | #define GATE_GRAPHICS_PLATFORM_OPENGL_APIS_H_INCLUDED | ||
| 30 | |||
| 31 | #include "gate/gatetypes.h" | ||
| 32 | #include "gate/libraries.h" | ||
| 33 | #include "gate/results.h" | ||
| 34 | #include "gate/platforms.h" | ||
| 35 | |||
| 36 | #if defined(GATE_SYS_ANDROID) | ||
| 37 | # include <GLES/gl.h> | ||
| 38 | # define GATE_OPENGL_NO_DBL 1 | ||
| 39 | #elif defined(GATE_SYS_WINCE) | ||
| 40 | # include <GLES/gl.h> | ||
| 41 | # define GATE_OPENGL_NO_DBL 1 | ||
| 42 | #elif defined(GATE_SYS_DARWIN) | ||
| 43 | # include <OpenGL/gl.h> | ||
| 44 | #elif defined(GATE_SYS_WASM) | ||
| 45 | # include <GL/gl.h> | ||
| 46 | # if defined(GATE_GRAPHICS_OPENGL2_SUPPORT) | ||
| 47 | # include <GLES2/gl2.h> | ||
| 48 | # endif | ||
| 49 | # define GATE_OPENGL_APIS_DIRECT_BINDING 1 | ||
| 50 | //# define GATE_OPENGL_NO_DBL 1 | ||
| 51 | #else | ||
| 52 | # include <GL/gl.h> | ||
| 53 | # if defined(GATE_GRAPHICS_OPENGL2_SUPPORT) | ||
| 54 | # if defined(GATE_SYS_WIN) | ||
| 55 | # include "GL/glext.h" | ||
| 56 | # else | ||
| 57 | # include <GLES2/gl2.h> | ||
| 58 | # endif | ||
| 59 | # endif | ||
| 60 | #endif | ||
| 61 | |||
| 62 | #if defined(GATE_SYS_WIN) | ||
| 63 | # define OGLAPI WINAPI | ||
| 64 | # define OPENGL_LIBNAME "opengl32.dll" | ||
| 65 | # define OPENGL_LIBNAME_ALT "opengl32.dll" | ||
| 66 | #elif defined(GATE_SYS_ANDROID) | ||
| 67 | # define OGLAPI | ||
| 68 | # define OPENGL_LIBNAME "libGLESv1_CM.so" | ||
| 69 | # define OPENGL_LIBNAME_ALT "libGL.so.1.2" | ||
| 70 | #elif defined(GATE_SYS_DARWIN) | ||
| 71 | # define OGLAPI | ||
| 72 | # define OPENGL_LIBNAME "/System/Library/Frameworks/OpenGL.framework/OpenGL" | ||
| 73 | # define OPENGL_LIBNAME_ALT "/System/Library/Frameworks/OpenGL.framework/OpenGL" | ||
| 74 | #elif defined(GATE_SYS_WASM) | ||
| 75 | # ifdef GL_APIENTRY | ||
| 76 | # define OGLAPI GL_APIENTRY | ||
| 77 | # else | ||
| 78 | # define OGLAPI GLAPIENTRY | ||
| 79 | # endif | ||
| 80 | #else | ||
| 81 | # define OGLAPI | ||
| 82 | # define OPENGL_LIBNAME "libGL.so" | ||
| 83 | # define OPENGL_LIBNAME_ALT "libGL.so.1" | ||
| 84 | #endif | ||
| 85 | |||
| 86 | typedef struct gate_gl_api_functions_class | ||
| 87 | { | ||
| 88 | #if !defined(GATE_GRAPHICS_NO_LEGACY_OPENGL) | ||
| 89 | //void (OGLAPI *glAccum) (GLenum op, GLfloat value); | ||
| 90 | void (OGLAPI* glAlphaFunc) (GLenum func, GLclampf ref); | ||
| 91 | //GLboolean(OGLAPI *glAreTexturesResident)(GLsizei n, const GLuint *textures, GLboolean *residences); | ||
| 92 | //void (OGLAPI *glArrayElement) (GLint i); | ||
| 93 | //void (OGLAPI *glBegin) (GLenum mode); | ||
| 94 | //void (OGLAPI *glBitmap) (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap); | ||
| 95 | //void (OGLAPI *glCallList) (GLuint list); | ||
| 96 | //void (OGLAPI *glCallLists) (GLsizei n, GLenum type, const GLvoid *lists); | ||
| 97 | //void (OGLAPI *glClearAccum) (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); | ||
| 98 | //void (OGLAPI *glClearIndex) (GLfloat c); | ||
| 99 | #if defined(GATE_OPENGL_NO_DBL) | ||
| 100 | void (OGLAPI* glClipPlane) (GLenum plane, const GLfloat* equation); | ||
| 101 | #else | ||
| 102 | void (OGLAPI* glClipPlane) (GLenum plane, const GLdouble* equation); | ||
| 103 | #endif | ||
| 104 | //void (OGLAPI *glColor3b) (GLbyte red, GLbyte green, GLbyte blue); | ||
| 105 | //void (OGLAPI *glColor3bv) (const GLbyte *v); | ||
| 106 | //void (OGLAPI *glColor3d) (GLdouble red, GLdouble green, GLdouble blue); | ||
| 107 | //void (OGLAPI *glColor3dv) (const GLdouble *v); | ||
| 108 | //void (OGLAPI *glColor3f) (GLfloat red, GLfloat green, GLfloat blue); | ||
| 109 | //void (OGLAPI *glColor3fv) (const GLfloat *v); | ||
| 110 | //void (OGLAPI *glColor3i) (GLint red, GLint green, GLint blue); | ||
| 111 | //void (OGLAPI *glColor3iv) (const GLint *v); | ||
| 112 | //void (OGLAPI *glColor3s) (GLshort red, GLshort green, GLshort blue); | ||
| 113 | //void (OGLAPI *glColor3sv) (const GLshort *v); | ||
| 114 | //void (OGLAPI *glColor3ub) (GLubyte red, GLubyte green, GLubyte blue); | ||
| 115 | //void (OGLAPI *glColor3ubv) (const GLubyte *v); | ||
| 116 | //void (OGLAPI *glColor3ui) (GLuint red, GLuint green, GLuint blue); | ||
| 117 | //void (OGLAPI *glColor3uiv) (const GLuint *v); | ||
| 118 | //void (OGLAPI *glColor3us) (GLushort red, GLushort green, GLushort blue); | ||
| 119 | //void (OGLAPI *glColor3usv) (const GLushort *v); | ||
| 120 | //void (OGLAPI *glColor4b) (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); | ||
| 121 | //void (OGLAPI *glColor4bv) (const GLbyte *v); | ||
| 122 | //void (OGLAPI *glColor4d) (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); | ||
| 123 | //void (OGLAPI *glColor4dv) (const GLdouble *v); | ||
| 124 | void (OGLAPI* glColor4f) (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); | ||
| 125 | //void (OGLAPI *glColor4fv) (const GLfloat *v); | ||
| 126 | //void (OGLAPI *glColor4i) (GLint red, GLint green, GLint blue, GLint alpha); | ||
| 127 | //void (OGLAPI *glColor4iv) (const GLint *v); | ||
| 128 | //void (OGLAPI *glColor4s) (GLshort red, GLshort green, GLshort blue, GLshort alpha); | ||
| 129 | //void (OGLAPI *glColor4sv) (const GLshort *v); | ||
| 130 | void (OGLAPI* glColor4ub) (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); | ||
| 131 | //void (OGLAPI *glColor4ubv) (const GLubyte *v); | ||
| 132 | //void (OGLAPI *glColor4ui) (GLuint red, GLuint green, GLuint blue, GLuint alpha); | ||
| 133 | //void (OGLAPI *glColor4uiv) (const GLuint *v); | ||
| 134 | //void (OGLAPI *glColor4us) (GLushort red, GLushort green, GLushort blue, GLushort alpha); | ||
| 135 | //void (OGLAPI *glColor4usv) (const GLushort *v); | ||
| 136 | //void (OGLAPI *glColorMaterial)(GLenum face, GLenum mode); | ||
| 137 | void (OGLAPI* glColorPointer) (GLint size, GLenum type, GLsizei stride, const GLvoid* pointer); | ||
| 138 | //void (OGLAPI *glCopyPixels) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); | ||
| 139 | //void (OGLAPI *glCopyTexImage1D) (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); | ||
| 140 | //void (OGLAPI *glCopyTexSubImage1D) (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); | ||
| 141 | //void (OGLAPI *glDeleteLists) (GLuint list, GLsizei range); | ||
| 142 | void (OGLAPI* glDisableClientState) (GLenum array); | ||
| 143 | //void (OGLAPI *glDrawBuffer) (GLenum mode); | ||
| 144 | //void (OGLAPI *glDrawPixels) (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); | ||
| 145 | //void (OGLAPI *glEdgeFlag) (GLboolean flag); | ||
| 146 | //void (OGLAPI *glEdgeFlagPointer)(GLsizei stride, const GLvoid *pointer); | ||
| 147 | //void (OGLAPI *glEdgeFlagv) (const GLboolean *flag); | ||
| 148 | void (OGLAPI* glEnableClientState) (GLenum array); | ||
| 149 | //void (OGLAPI *glEnd) (void); | ||
| 150 | //void (OGLAPI *glEndList) (void); | ||
| 151 | //void (OGLAPI *glEvalCoord1d) (GLdouble u); | ||
| 152 | //void (OGLAPI *glEvalCoord1dv) (const GLdouble *u); | ||
| 153 | //void (OGLAPI *glEvalCoord1f) (GLfloat u); | ||
| 154 | //void (OGLAPI *glEvalCoord1fv) (const GLfloat *u); | ||
| 155 | //void (OGLAPI *glEvalCoord2d) (GLdouble u, GLdouble v); | ||
| 156 | //void (OGLAPI *glEvalCoord2dv) (const GLdouble *u); | ||
| 157 | //void (OGLAPI *glEvalCoord2f) (GLfloat u, GLfloat v); | ||
| 158 | //void (OGLAPI *glEvalCoord2fv) (const GLfloat *u); | ||
| 159 | //void (OGLAPI *glEvalMesh1) (GLenum mode, GLint i1, GLint i2); | ||
| 160 | //void (OGLAPI *glEvalMesh2) (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); | ||
| 161 | //void (OGLAPI *glEvalPoint1) (GLint i); | ||
| 162 | //void (OGLAPI *glEvalPoint2) (GLint i, GLint j); | ||
| 163 | //void (OGLAPI *glFeedbackBuffer) (GLsizei size, GLenum type, GLfloat *buffer); | ||
| 164 | void (OGLAPI* glFogf) (GLenum pname, GLfloat param); | ||
| 165 | void (OGLAPI* glFogfv) (GLenum pname, const GLfloat* params); | ||
| 166 | //void (OGLAPI *glFogi) (GLenum pname, GLint param); | ||
| 167 | //void (OGLAPI *glFogiv) (GLenum pname, const GLint *params); | ||
| 168 | #if defined(GATE_OPENGL_NO_DBL) | ||
| 169 | void (OGLAPI* glFrustum) (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); | ||
| 170 | #else | ||
| 171 | void (OGLAPI* glFrustum) (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); | ||
| 172 | #endif | ||
| 173 | //GLuint(OGLAPI *glGenLists) (GLsizei range); | ||
| 174 | //void (OGLAPI *glGetLightiv) (GLenum light, GLenum pname, GLint *params); | ||
| 175 | //void (OGLAPI *glGetMapdv) (GLenum target, GLenum query, GLdouble *v); | ||
| 176 | //void (OGLAPI *glGetMapfv) (GLenum target, GLenum query, GLfloat *v); | ||
| 177 | //void (OGLAPI *glGetMapiv) (GLenum target, GLenum query, GLint *v); | ||
| 178 | #if !defined(GATE_COMPILER_EMSCRIPTEN) | ||
| 179 | void (OGLAPI* glGetMaterialfv) (GLenum face, GLenum pname, GLfloat* params); | ||
| 180 | #endif | ||
| 181 | //void (OGLAPI *glGetMaterialiv)(GLenum face, GLenum pname, GLint *params); | ||
| 182 | //void (OGLAPI *glGetPixelMapfv)(GLenum map, GLfloat *values); | ||
| 183 | //void (OGLAPI *glGetPixelMapuiv)(GLenum map, GLuint *values); | ||
| 184 | //void (OGLAPI *glGetPixelMapusv)(GLenum map, GLushort *values); | ||
| 185 | void (OGLAPI* glGetPointerv) (GLenum pname, GLvoid** params); | ||
| 186 | //void (OGLAPI *glGetPolygonStipple) (GLubyte *mask); | ||
| 187 | void (OGLAPI* glGetTexEnvfv) (GLenum target, GLenum pname, GLfloat* params); | ||
| 188 | //void (OGLAPI *glGetTexGendv) (GLenum coord, GLenum pname, GLdouble *params); | ||
| 189 | //void (OGLAPI *glGetTexGenfv) (GLenum coord, GLenum pname, GLfloat *params); | ||
| 190 | //void (OGLAPI *glGetTexGeniv) (GLenum coord, GLenum pname, GLint *params); | ||
| 191 | //void (OGLAPI *glGetTexImage) (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels); | ||
| 192 | //void (OGLAPI *glGetTexLevelParameterfv) (GLenum target, GLint level, GLenum pname, GLfloat *params); | ||
| 193 | //void (OGLAPI *glGetTexLevelParameteriv) (GLenum target, GLint level, GLenum pname, GLint *params); | ||
| 194 | //void (OGLAPI *glIndexMask) (GLuint mask); | ||
| 195 | //void (OGLAPI *glIndexPointer) (GLenum type, GLsizei stride, const GLvoid *pointer); | ||
| 196 | //void (OGLAPI *glIndexd) (GLdouble c); | ||
| 197 | //void (OGLAPI *glIndexdv) (const GLdouble *c); | ||
| 198 | //void (OGLAPI *glIndexf) (GLfloat c); | ||
| 199 | //void (OGLAPI *glIndexfv) (const GLfloat *c); | ||
| 200 | //void (OGLAPI *glIndexi) (GLint c); | ||
| 201 | //void (OGLAPI *glIndexiv) (const GLint *c); | ||
| 202 | //void (OGLAPI *glIndexs) (GLshort c); | ||
| 203 | //void (OGLAPI *glIndexsv) (const GLshort *c); | ||
| 204 | //void (OGLAPI *glIndexub) (GLubyte c); | ||
| 205 | //void (OGLAPI *glIndexubv) (const GLubyte *c); | ||
| 206 | //void (OGLAPI *glInitNames) (void); | ||
| 207 | //void (OGLAPI *glInterleavedArrays) (GLenum format, GLsizei stride, const GLvoid *pointer); | ||
| 208 | //GLboolean(OGLAPI *glIsList) (GLuint list); | ||
| 209 | void (OGLAPI* glLightModelf) (GLenum pname, GLfloat param); | ||
| 210 | void (OGLAPI* glLightModelfv) (GLenum pname, const GLfloat* params); | ||
| 211 | //void (OGLAPI *glLightModeli) (GLenum pname, GLint param); | ||
| 212 | //void (OGLAPI *glLightModeliv) (GLenum pname, const GLint *params); | ||
| 213 | #if !defined(GATE_COMPILER_EMSCRIPTEN) | ||
| 214 | void (OGLAPI* glLightf) (GLenum light, GLenum pname, GLfloat param); | ||
| 215 | #endif | ||
| 216 | void (OGLAPI* glLightfv) (GLenum light, GLenum pname, const GLfloat* params); | ||
| 217 | //void (OGLAPI *glLighti) (GLenum light, GLenum pname, GLint param); | ||
| 218 | //void (OGLAPI *glLightiv) (GLenum light, GLenum pname, const GLint *params); | ||
| 219 | //void (OGLAPI *glLineStipple) (GLint factor, GLushort pattern); | ||
| 220 | //void (OGLAPI *glListBase) (GLuint base); | ||
| 221 | //void (OGLAPI *glLoadMatrixd) (const GLdouble *m); | ||
| 222 | void (OGLAPI* glLoadMatrixf) (const GLfloat* m); | ||
| 223 | //void (OGLAPI *glLoadName) (GLuint name); | ||
| 224 | //void (OGLAPI* glLogicOp) (GLenum opcode); | ||
| 225 | //void (OGLAPI *glMap1d) (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points); | ||
| 226 | //void (OGLAPI *glMap1f) (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points); | ||
| 227 | //void (OGLAPI *glMap2d) (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points); | ||
| 228 | //void (OGLAPI *glMap2f) (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points); | ||
| 229 | //void (OGLAPI *glMapGrid1d) (GLint un, GLdouble u1, GLdouble u2); | ||
| 230 | //void (OGLAPI *glMapGrid1f) (GLint un, GLfloat u1, GLfloat u2); | ||
| 231 | //void (OGLAPI *glMapGrid2d) (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); | ||
| 232 | //void (OGLAPI *glMapGrid2f) (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); | ||
| 233 | #if defined(GATE_OPENGL_NO_DBL) | ||
| 234 | //void (OGLAPI* glGetClipPlane) (GLenum pname, GLfloat eqn[4]); | ||
| 235 | #else | ||
| 236 | //void (OGLAPI* glGetClipPlane) (GLenum plane, GLdouble* equation); | ||
| 237 | #endif | ||
| 238 | //void (OGLAPI *glGetDoublev) (GLenum pname, GLdouble *params); | ||
| 239 | #if !defined(GATE_COMPILER_EMSCRIPTEN) | ||
| 240 | void (OGLAPI* glGetLightfv) (GLenum light, GLenum pname, GLfloat* params); | ||
| 241 | #endif | ||
| 242 | void (OGLAPI* glGetTexEnviv) (GLenum target, GLenum pname, GLint* params); | ||
| 243 | #if !defined(GATE_COMPILER_EMSCRIPTEN) | ||
| 244 | void (OGLAPI* glMaterialf) (GLenum face, GLenum pname, GLfloat param); | ||
| 245 | #endif | ||
| 246 | void (OGLAPI* glMaterialfv) (GLenum face, GLenum pname, const GLfloat* params); | ||
| 247 | //void (OGLAPI *glMateriali) (GLenum face, GLenum pname, GLint param); | ||
| 248 | //void (OGLAPI *glMaterialiv) (GLenum face, GLenum pname, const GLint *params); | ||
| 249 | //void (OGLAPI *glMultMatrixd) (const GLdouble *m); | ||
| 250 | void (OGLAPI* glMultMatrixf) (const GLfloat* m); | ||
| 251 | //void (OGLAPI *glNewList) (GLuint list, GLenum mode); | ||
| 252 | //void (OGLAPI *glNormal3b) (GLbyte nx, GLbyte ny, GLbyte nz); | ||
| 253 | //void (OGLAPI *glNormal3bv) (const GLbyte *v); | ||
| 254 | //void (OGLAPI *glNormal3d) (GLdouble nx, GLdouble ny, GLdouble nz); | ||
| 255 | //void (OGLAPI *glNormal3dv) (const GLdouble *v); | ||
| 256 | void (OGLAPI* glNormal3f) (GLfloat nx, GLfloat ny, GLfloat nz); | ||
| 257 | //void (OGLAPI *glNormal3fv) (const GLfloat *v); | ||
| 258 | //void (OGLAPI *glNormal3i) (GLint nx, GLint ny, GLint nz); | ||
| 259 | //void (OGLAPI *glNormal3iv) (const GLint *v); | ||
| 260 | //void (OGLAPI *glNormal3s) (GLshort nx, GLshort ny, GLshort nz); | ||
| 261 | //void (OGLAPI *glNormal3sv) (const GLshort *v); | ||
| 262 | void (OGLAPI* glNormalPointer) (GLenum type, GLsizei stride, const GLvoid* pointer); | ||
| 263 | #if defined(GATE_OPENGL_NO_DBL) | ||
| 264 | void (OGLAPI* glOrtho) (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar); | ||
| 265 | #else | ||
| 266 | void (OGLAPI* glOrtho) (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); | ||
| 267 | #endif | ||
| 268 | //void (OGLAPI *glPassThrough) (GLfloat token); | ||
| 269 | //void (OGLAPI *glPixelMapfv) (GLenum map, GLsizei mapsize, const GLfloat *values); | ||
| 270 | //void (OGLAPI *glPixelMapuiv) (GLenum map, GLsizei mapsize, const GLuint *values); | ||
| 271 | //void (OGLAPI *glPixelMapusv) (GLenum map, GLsizei mapsize, const GLushort *values); | ||
| 272 | //void (OGLAPI *glPixelStoref) (GLenum pname, GLfloat param); | ||
| 273 | //void (OGLAPI *glPixelTransferf) (GLenum pname, GLfloat param); | ||
| 274 | //void (OGLAPI *glPixelTransferi) (GLenum pname, GLint param); | ||
| 275 | //void (OGLAPI *glPixelZoom) (GLfloat xfactor, GLfloat yfactor); | ||
| 276 | void (OGLAPI* glPointSize) (GLfloat size); | ||
| 277 | //void (OGLAPI *glPolygonMode) (GLenum face, GLenum mode); | ||
| 278 | //void (OGLAPI *glPolygonStipple) (const GLubyte *mask); | ||
| 279 | //void (OGLAPI *glPopAttrib) (void); | ||
| 280 | //void (OGLAPI *glPopClientAttrib)(void); | ||
| 281 | void (OGLAPI* glPopMatrix) (void); | ||
| 282 | //void (OGLAPI *glPopName) (void); | ||
| 283 | //void (OGLAPI *glPrioritizeTextures) (GLsizei n, const GLuint *textures, const GLclampf *priorities); | ||
| 284 | //void (OGLAPI *glPushAttrib) (GLbitfield mask); | ||
| 285 | //void (OGLAPI *glPushClientAttrib)(GLbitfield mask); | ||
| 286 | void (OGLAPI* glPushMatrix) (void); | ||
| 287 | //void (OGLAPI *glPushName) (GLuint name); | ||
| 288 | //void (OGLAPI *glRasterPos2d) (GLdouble x, GLdouble y); | ||
| 289 | //void (OGLAPI *glRasterPos2dv) (const GLdouble *v); | ||
| 290 | //void (OGLAPI *glRasterPos2f) (GLfloat x, GLfloat y); | ||
| 291 | //void (OGLAPI *glRasterPos2fv) (const GLfloat *v); | ||
| 292 | //void (OGLAPI *glRasterPos2i) (GLint x, GLint y); | ||
| 293 | //void (OGLAPI *glRasterPos2iv) (const GLint *v); | ||
| 294 | //void (OGLAPI *glRasterPos2s) (GLshort x, GLshort y); | ||
| 295 | //void (OGLAPI *glRasterPos2sv) (const GLshort *v); | ||
| 296 | //void (OGLAPI *glRasterPos3d) (GLdouble x, GLdouble y, GLdouble z); | ||
| 297 | //void (OGLAPI *glRasterPos3dv) (const GLdouble *v); | ||
| 298 | //void (OGLAPI *glRasterPos3f) (GLfloat x, GLfloat y, GLfloat z); | ||
| 299 | //void (OGLAPI *glRasterPos3fv) (const GLfloat *v); | ||
| 300 | //void (OGLAPI *glRasterPos3i) (GLint x, GLint y, GLint z); | ||
| 301 | //void (OGLAPI *glRasterPos3iv) (const GLint *v); | ||
| 302 | //void (OGLAPI *glRasterPos3s) (GLshort x, GLshort y, GLshort z); | ||
| 303 | //void (OGLAPI *glRasterPos3sv) (const GLshort *v); | ||
| 304 | //void (OGLAPI *glRasterPos4d) (GLdouble x, GLdouble y, GLdouble z, GLdouble w); | ||
| 305 | //void (OGLAPI *glRasterPos4dv) (const GLdouble *v); | ||
| 306 | //void (OGLAPI *glRasterPos4f) (GLfloat x, GLfloat y, GLfloat z, GLfloat w); | ||
| 307 | //void (OGLAPI *glRasterPos4fv) (const GLfloat *v); | ||
| 308 | //void (OGLAPI *glRasterPos4i) (GLint x, GLint y, GLint z, GLint w); | ||
| 309 | //void (OGLAPI *glRasterPos4iv) (const GLint *v); | ||
| 310 | //void (OGLAPI *glRasterPos4s) (GLshort x, GLshort y, GLshort z, GLshort w); | ||
| 311 | //void (OGLAPI *glRasterPos4sv) (const GLshort *v); | ||
| 312 | //void (OGLAPI *glReadBuffer) (GLenum mode); | ||
| 313 | //void (OGLAPI *glRectd) (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); | ||
| 314 | //void (OGLAPI *glRectdv) (const GLdouble *v1, const GLdouble *v2); | ||
| 315 | //void (OGLAPI *glRectf) (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); | ||
| 316 | //void (OGLAPI *glRectfv) (const GLfloat *v1, const GLfloat *v2); | ||
| 317 | //void (OGLAPI *glRecti) (GLint x1, GLint y1, GLint x2, GLint y2); | ||
| 318 | //void (OGLAPI *glRectiv) (const GLint *v1, const GLint *v2); | ||
| 319 | //void (OGLAPI *glRects) (GLshort x1, GLshort y1, GLshort x2, GLshort y2); | ||
| 320 | //void (OGLAPI *glRectsv) (const GLshort *v1, const GLshort *v2); | ||
| 321 | //GLint(OGLAPI *glRenderMode) (GLenum mode); | ||
| 322 | //void (OGLAPI *glRotated) (GLdouble angle, GLdouble x, GLdouble y, GLdouble z); | ||
| 323 | void (OGLAPI* glRotatef) (GLfloat angle, GLfloat x, GLfloat y, GLfloat z); | ||
| 324 | //void (OGLAPI *glScaled) (GLdouble x, GLdouble y, GLdouble z); | ||
| 325 | void (OGLAPI* glScalef) (GLfloat x, GLfloat y, GLfloat z); | ||
| 326 | //void (OGLAPI *glSelectBuffer) (GLsizei size, GLuint *buffer); | ||
| 327 | void (OGLAPI* glShadeModel) (GLenum mode); | ||
| 328 | //void (OGLAPI *glTexCoord1d) (GLdouble s); | ||
| 329 | //void (OGLAPI *glTexCoord1dv) (const GLdouble *v); | ||
| 330 | //void (OGLAPI *glTexCoord1f) (GLfloat s); | ||
| 331 | //void (OGLAPI *glTexCoord1fv) (const GLfloat *v); | ||
| 332 | //void (OGLAPI *glTexCoord1i) (GLint s); | ||
| 333 | //void (OGLAPI *glTexCoord1iv) (const GLint *v); | ||
| 334 | //void (OGLAPI *glTexCoord1s) (GLshort s); | ||
| 335 | //void (OGLAPI *glTexCoord1sv) (const GLshort *v); | ||
| 336 | //void (OGLAPI *glTexCoord2d) (GLdouble s, GLdouble t); | ||
| 337 | //void (OGLAPI *glTexCoord2dv) (const GLdouble *v); | ||
| 338 | //void (OGLAPI *glTexCoord2f) (GLfloat s, GLfloat t); | ||
| 339 | //void (OGLAPI *glTexCoord2fv) (const GLfloat *v); | ||
| 340 | //void (OGLAPI *glTexCoord2i) (GLint s, GLint t); | ||
| 341 | //void (OGLAPI *glTexCoord2iv) (const GLint *v); | ||
| 342 | //void (OGLAPI *glTexCoord2s) (GLshort s, GLshort t); | ||
| 343 | //void (OGLAPI *glTexCoord2sv) (const GLshort *v); | ||
| 344 | //void (OGLAPI *glTexCoord3d) (GLdouble s, GLdouble t, GLdouble r); | ||
| 345 | //void (OGLAPI *glTexCoord3dv) (const GLdouble *v); | ||
| 346 | //void (OGLAPI *glTexCoord3f) (GLfloat s, GLfloat t, GLfloat r); | ||
| 347 | //void (OGLAPI *glTexCoord3fv) (const GLfloat *v); | ||
| 348 | //void (OGLAPI *glTexCoord3i) (GLint s, GLint t, GLint r); | ||
| 349 | //void (OGLAPI *glTexCoord3iv) (const GLint *v); | ||
| 350 | //void (OGLAPI *glTexCoord3s) (GLshort s, GLshort t, GLshort r); | ||
| 351 | //void (OGLAPI *glTexCoord3sv) (const GLshort *v); | ||
| 352 | //void (OGLAPI *glTexCoord4d) (GLdouble s, GLdouble t, GLdouble r, GLdouble q); | ||
| 353 | //void (OGLAPI *glTexCoord4dv) (const GLdouble *v); | ||
| 354 | //void (OGLAPI *glTexCoord4f) (GLfloat s, GLfloat t, GLfloat r, GLfloat q); | ||
| 355 | //void (OGLAPI *glTexCoord4fv) (const GLfloat *v); | ||
| 356 | //void (OGLAPI *glTexCoord4i) (GLint s, GLint t, GLint r, GLint q); | ||
| 357 | //void (OGLAPI *glTexCoord4iv) (const GLint *v); | ||
| 358 | //void (OGLAPI *glTexCoord4s) (GLshort s, GLshort t, GLshort r, GLshort q); | ||
| 359 | //void (OGLAPI *glTexCoord4sv) (const GLshort *v); | ||
| 360 | void (OGLAPI* glTexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer); | ||
| 361 | void (OGLAPI* glTexEnvf) (GLenum target, GLenum pname, GLfloat param); | ||
| 362 | void (OGLAPI* glTexEnvfv) (GLenum target, GLenum pname, const GLfloat* params); | ||
| 363 | void (OGLAPI* glTexEnvi) (GLenum target, GLenum pname, GLint param); | ||
| 364 | #if !defined(GATE_COMPILER_EMSCRIPTEN) | ||
| 365 | void (OGLAPI* glTexEnviv) (GLenum target, GLenum pname, const GLint* params); | ||
| 366 | #endif | ||
| 367 | //void (OGLAPI *glTexGend) (GLenum coord, GLenum pname, GLdouble param); | ||
| 368 | //void (OGLAPI *glTexGendv) (GLenum coord, GLenum pname, const GLdouble *params); | ||
| 369 | //void (OGLAPI *glTexGenf) (GLenum coord, GLenum pname, GLfloat param); | ||
| 370 | //void (OGLAPI *glTexGenfv) (GLenum coord, GLenum pname, const GLfloat *params); | ||
| 371 | //void (OGLAPI *glTexGeni) (GLenum coord, GLenum pname, GLint param); | ||
| 372 | //void (OGLAPI *glTexGeniv) (GLenum coord, GLenum pname, const GLint *params); | ||
| 373 | //void (OGLAPI *glTexImage1D) (GLenum target, GLint level, GLint internalformat, GLsizei width, | ||
| 374 | //void (OGLAPI *glTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels); | ||
| 375 | //void (OGLAPI *glTranslated) (GLdouble x, GLdouble y, GLdouble z); | ||
| 376 | void (OGLAPI* glTranslatef) (GLfloat x, GLfloat y, GLfloat z); | ||
| 377 | //void (OGLAPI *glVertex2d) (GLdouble x, GLdouble y); | ||
| 378 | //void (OGLAPI *glVertex2dv) (const GLdouble *v); | ||
| 379 | //void (OGLAPI *glVertex2f) (GLfloat x, GLfloat y); | ||
| 380 | //void (OGLAPI *glVertex2fv) (const GLfloat *v); | ||
| 381 | //void (OGLAPI *glVertex2i) (GLint x, GLint y); | ||
| 382 | //void (OGLAPI *glVertex2iv) (const GLint *v); | ||
| 383 | //void (OGLAPI *glVertex2s) (GLshort x, GLshort y); | ||
| 384 | //void (OGLAPI *glVertex2sv) (const GLshort *v); | ||
| 385 | //void (OGLAPI *glVertex3d) (GLdouble x, GLdouble y, GLdouble z); | ||
| 386 | //void (OGLAPI *glVertex3dv) (const GLdouble *v); | ||
| 387 | //void (OGLAPI *glVertex3f) (GLfloat x, GLfloat y, GLfloat z); | ||
| 388 | //void (OGLAPI *glVertex3fv) (const GLfloat *v); | ||
| 389 | //void (OGLAPI *glVertex3i) (GLint x, GLint y, GLint z); | ||
| 390 | //void (OGLAPI *glVertex3iv) (const GLint *v); | ||
| 391 | //void (OGLAPI *glVertex3s) (GLshort x, GLshort y, GLshort z); | ||
| 392 | //void (OGLAPI *glVertex3sv) (const GLshort *v); | ||
| 393 | //void (OGLAPI *glVertex4d) (GLdouble x, GLdouble y, GLdouble z, GLdouble w); | ||
| 394 | //void (OGLAPI *glVertex4dv) (const GLdouble *v); | ||
| 395 | //void (OGLAPI *glVertex4f) (GLfloat x, GLfloat y, GLfloat z, GLfloat w); | ||
| 396 | //void (OGLAPI *glVertex4fv) (const GLfloat *v); | ||
| 397 | //void (OGLAPI *glVertex4i) (GLint x, GLint y, GLint z, GLint w); | ||
| 398 | //void (OGLAPI *glVertex4iv) (const GLint *v); | ||
| 399 | //void (OGLAPI *glVertex4s) (GLshort x, GLshort y, GLshort z, GLshort w); | ||
| 400 | //void (OGLAPI *glVertex4sv) (const GLshort *v); | ||
| 401 | |||
| 402 | #endif /* !defined(GATE_GRAPHICS_NO_LEGACY_OPENGL) */ | ||
| 403 | |||
| 404 | void (OGLAPI* glBindTexture) (GLenum target, GLuint texture); | ||
| 405 | void (OGLAPI* glBlendFunc) (GLenum sfactor, GLenum dfactor); | ||
| 406 | void (OGLAPI* glClear) (GLbitfield mask); | ||
| 407 | void (OGLAPI* glClearColor) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); | ||
| 408 | #if defined(GATE_OPENGL_NO_DBL) | ||
| 409 | void (OGLAPI* glClearDepth) (GLclampf depth); | ||
| 410 | #else | ||
| 411 | void (OGLAPI* glClearDepth) (GLclampd depth); | ||
| 412 | #endif | ||
| 413 | void (OGLAPI* glClearStencil) (GLint s); | ||
| 414 | void (OGLAPI* glColorMask) (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); | ||
| 415 | void (OGLAPI* glCopyTexImage2D) (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); | ||
| 416 | void (OGLAPI* glCopyTexSubImage2D) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); | ||
| 417 | void (OGLAPI* glCullFace) (GLenum mode); | ||
| 418 | void (OGLAPI* glDeleteTextures) (GLsizei n, const GLuint* textures); | ||
| 419 | void (OGLAPI* glDepthFunc) (GLenum func); | ||
| 420 | void (OGLAPI* glDepthMask) (GLboolean flag); | ||
| 421 | #if defined(GATE_OPENGL_NO_DBL) | ||
| 422 | void (OGLAPI* glDepthRange) (GLclampf zNear, GLclampf zFar); | ||
| 423 | #else | ||
| 424 | void (OGLAPI* glDepthRange) (GLclampd zNear, GLclampd zFar); | ||
| 425 | #endif | ||
| 426 | void (OGLAPI* glDisable) (GLenum cap); | ||
| 427 | void (OGLAPI* glDrawArrays) (GLenum mode, GLint first, GLsizei count); | ||
| 428 | void (OGLAPI* glDrawElements) (GLenum mode, GLsizei count, GLenum type, const GLvoid* indices); | ||
| 429 | void (OGLAPI* glEnable) (GLenum cap); | ||
| 430 | void (OGLAPI* glFinish) (void); | ||
| 431 | void (OGLAPI* glFlush) (void); | ||
| 432 | void (OGLAPI* glFrontFace) (GLenum mode); | ||
| 433 | void (OGLAPI* glGenTextures) (GLsizei n, GLuint* textures); | ||
| 434 | void (OGLAPI* glGetBooleanv) (GLenum pname, GLboolean* params); | ||
| 435 | GLenum(OGLAPI* glGetError) (void); | ||
| 436 | void (OGLAPI* glGetFloatv) (GLenum pname, GLfloat* params); | ||
| 437 | void (OGLAPI* glGetIntegerv) (GLenum pname, GLint* params); | ||
| 438 | GLubyte const* (OGLAPI* glGetString) (GLenum name); | ||
| 439 | void (OGLAPI* glGetTexParameterfv) (GLenum target, GLenum pname, GLfloat* params); | ||
| 440 | void (OGLAPI* glGetTexParameteriv) (GLenum target, GLenum pname, GLint* params); | ||
| 441 | void (OGLAPI* glHint) (GLenum target, GLenum mode); | ||
| 442 | GLboolean(OGLAPI* glIsEnabled) (GLenum cap); | ||
| 443 | GLboolean(OGLAPI* glIsTexture) (GLuint texture); | ||
| 444 | void (OGLAPI* glLineWidth) (GLfloat width); | ||
| 445 | void (OGLAPI* glLoadIdentity) (void); | ||
| 446 | void (OGLAPI* glMatrixMode) (GLenum mode); | ||
| 447 | void (OGLAPI* glPixelStorei) (GLenum pname, GLint param); | ||
| 448 | void (OGLAPI* glPolygonOffset) (GLfloat factor, GLfloat units); | ||
| 449 | void (OGLAPI* glReadPixels) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels); | ||
| 450 | void (OGLAPI* glScissor) (GLint x, GLint y, GLsizei width, GLsizei height); | ||
| 451 | void (OGLAPI* glStencilFunc) (GLenum func, GLint ref, GLuint mask); | ||
| 452 | void (OGLAPI* glStencilMask) (GLuint mask); | ||
| 453 | void (OGLAPI* glStencilOp) (GLenum fail, GLenum zfail, GLenum zpass); | ||
| 454 | void (OGLAPI* glTexImage2D) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels); | ||
| 455 | void (OGLAPI* glTexParameterf) (GLenum target, GLenum pname, GLfloat param); | ||
| 456 | void (OGLAPI* glTexParameterfv) (GLenum target, GLenum pname, const GLfloat* params); | ||
| 457 | void (OGLAPI* glTexParameteri) (GLenum target, GLenum pname, GLint param); | ||
| 458 | void (OGLAPI* glTexParameteriv) (GLenum target, GLenum pname, const GLint* params); | ||
| 459 | void (OGLAPI* glTexSubImage2D) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels); | ||
| 460 | void (OGLAPI* glVertexPointer) (GLint size, GLenum type, GLsizei stride, const GLvoid* pointer); | ||
| 461 | void (OGLAPI* glViewport) (GLint x, GLint y, GLsizei width, GLsizei height); | ||
| 462 | |||
| 463 | } gate_gl_api_functions_t; | ||
| 464 | |||
| 465 | |||
| 466 | static gate_gl_api_functions_t gate_gl_api = GATE_INIT_EMPTY; | ||
| 467 | |||
| 468 | #if defined(GATE_OPENGL_APIS_DIRECT_BINDING) | ||
| 469 | # define LOAD_NATIVE_GL_FUNCTION(func_name, func_ptr_address) *func_ptr_address = & func_name | ||
| 470 | #else | ||
| 471 | # define LOAD_NATIVE_GL_FUNCTION(func_name, func_ptr_address) gate_library_get_function_name(opengl_lib_handle, #func_name, func_ptr_address) | ||
| 472 | #endif | ||
| 473 | |||
| 474 | ✗ | static void load_native_gl_functions(gate_library_t opengl_lib_handle, gate_gl_api_functions_t* ptr_code) | |
| 475 | { | ||
| 476 | ✗ | gate_gl_api_functions_t code = GATE_INIT_EMPTY; | |
| 477 | |||
| 478 | #if !defined(GATE_GRAPHICS_NO_LEGACY_OPENGL) | ||
| 479 | //LOAD_NATIVE_GL_FUNCTION(glAccum, &code.glAccum); | ||
| 480 | ✗ | LOAD_NATIVE_GL_FUNCTION(glAlphaFunc, &code.glAlphaFunc); | |
| 481 | //LOAD_NATIVE_GL_FUNCTION(glAreTexturesResident, &code.glAreTexturesResident); | ||
| 482 | //LOAD_NATIVE_GL_FUNCTION(glArrayElement, &code.glArrayElement); | ||
| 483 | //LOAD_NATIVE_GL_FUNCTION(glBegin, &code.glBegin); | ||
| 484 | //LOAD_NATIVE_GL_FUNCTION(glBitmap, &code.glBitmap); | ||
| 485 | //LOAD_NATIVE_GL_FUNCTION(glCallList, &code.glCallList); | ||
| 486 | //LOAD_NATIVE_GL_FUNCTION(glCallLists, &code.glCallLists); | ||
| 487 | //LOAD_NATIVE_GL_FUNCTION(glClearAccum, &code.glClearAccum); | ||
| 488 | #if defined(GATE_OPENGL_NO_DBL) | ||
| 489 | LOAD_NATIVE_GL_FUNCTION(glClipPlanef, &code.glClipPlane); | ||
| 490 | #else | ||
| 491 | ✗ | LOAD_NATIVE_GL_FUNCTION(glClipPlane, &code.glClipPlane); | |
| 492 | #endif | ||
| 493 | //LOAD_NATIVE_GL_FUNCTION(glClearIndex, &code.glClearIndex); | ||
| 494 | //LOAD_NATIVE_GL_FUNCTION(glColor3b, &code.glColor3b); | ||
| 495 | //LOAD_NATIVE_GL_FUNCTION(glColor3bv, &code.glColor3bv); | ||
| 496 | //LOAD_NATIVE_GL_FUNCTION(glColor3d, &code.glColor3d); | ||
| 497 | //LOAD_NATIVE_GL_FUNCTION(glColor3dv, &code.glColor3dv); | ||
| 498 | //LOAD_NATIVE_GL_FUNCTION(glColor3f, &code.glColor3f); | ||
| 499 | //LOAD_NATIVE_GL_FUNCTION(glColor3fv, &code.glColor3fv); | ||
| 500 | //LOAD_NATIVE_GL_FUNCTION(glColor3i, &code.glColor3i); | ||
| 501 | //LOAD_NATIVE_GL_FUNCTION(glColor3iv, &code.glColor3iv); | ||
| 502 | //LOAD_NATIVE_GL_FUNCTION(glColor3s, &code.glColor3s); | ||
| 503 | //LOAD_NATIVE_GL_FUNCTION(glColor3sv, &code.glColor3sv); | ||
| 504 | //LOAD_NATIVE_GL_FUNCTION(glColor3ub, &code.glColor3ub); | ||
| 505 | //LOAD_NATIVE_GL_FUNCTION(glColor3ubv, &code.glColor3ubv); | ||
| 506 | //LOAD_NATIVE_GL_FUNCTION(glColor3ui, &code.glColor3ui); | ||
| 507 | //LOAD_NATIVE_GL_FUNCTION(glColor3uiv, &code.glColor3uiv); | ||
| 508 | //LOAD_NATIVE_GL_FUNCTION(glColor3us, &code.glColor3us); | ||
| 509 | //LOAD_NATIVE_GL_FUNCTION(glColor3usv, &code.glColor3usv); | ||
| 510 | //LOAD_NATIVE_GL_FUNCTION(glColor4b, &code.glColor4b); | ||
| 511 | //LOAD_NATIVE_GL_FUNCTION(glColor4bv, &code.glColor4bv); | ||
| 512 | //LOAD_NATIVE_GL_FUNCTION(glColor4d, &code.glColor4d); | ||
| 513 | //LOAD_NATIVE_GL_FUNCTION(glColor4dv, &code.glColor4dv); | ||
| 514 | ✗ | LOAD_NATIVE_GL_FUNCTION(glColor4f, &code.glColor4f); | |
| 515 | //LOAD_NATIVE_GL_FUNCTION(glColor4fv, &code.glColor4fv); | ||
| 516 | //LOAD_NATIVE_GL_FUNCTION(glColor4i, &code.glColor4i); | ||
| 517 | //LOAD_NATIVE_GL_FUNCTION(glColor4iv, &code.glColor4iv); | ||
| 518 | //LOAD_NATIVE_GL_FUNCTION(glColor4s, &code.glColor4s); | ||
| 519 | //LOAD_NATIVE_GL_FUNCTION(glColor4sv, &code.glColor4sv); | ||
| 520 | ✗ | LOAD_NATIVE_GL_FUNCTION(glColor4ub, &code.glColor4ub); | |
| 521 | //LOAD_NATIVE_GL_FUNCTION(glColor4ubv, &code.glColor4ubv); | ||
| 522 | //LOAD_NATIVE_GL_FUNCTION(glColor4ui, &code.glColor4ui); | ||
| 523 | //LOAD_NATIVE_GL_FUNCTION(glColor4uiv, &code.glColor4uiv); | ||
| 524 | //LOAD_NATIVE_GL_FUNCTION(glColor4us, &code.glColor4us); | ||
| 525 | //LOAD_NATIVE_GL_FUNCTION(glColor4usv, &code.glColor4usv); | ||
| 526 | //LOAD_NATIVE_GL_FUNCTION(glColorMaterial, &code.glColorMaterial); | ||
| 527 | ✗ | LOAD_NATIVE_GL_FUNCTION(glColorPointer, &code.glColorPointer); | |
| 528 | //LOAD_NATIVE_GL_FUNCTION(glCopyPixels, &code.glCopyPixels); | ||
| 529 | //LOAD_NATIVE_GL_FUNCTION(glCopyTexImage1D, &code.glCopyTexImage1D); | ||
| 530 | //LOAD_NATIVE_GL_FUNCTION(glCopyTexSubImage1D, &code.glCopyTexSubImage1D); | ||
| 531 | //LOAD_NATIVE_GL_FUNCTION(glDeleteLists, &code.glDeleteLists); | ||
| 532 | ✗ | LOAD_NATIVE_GL_FUNCTION(glDisableClientState, &code.glDisableClientState); | |
| 533 | //LOAD_NATIVE_GL_FUNCTION(glDrawBuffer, &code.glDrawBuffer); | ||
| 534 | //LOAD_NATIVE_GL_FUNCTION(glDrawPixels, &code.glDrawPixels); | ||
| 535 | //LOAD_NATIVE_GL_FUNCTION(glEdgeFlag, &code.glEdgeFlag); | ||
| 536 | //LOAD_NATIVE_GL_FUNCTION(glEdgeFlagPointer, &code.glEdgeFlagPointer); | ||
| 537 | //LOAD_NATIVE_GL_FUNCTION(glEdgeFlagv, &code.glEdgeFlagv); | ||
| 538 | ✗ | LOAD_NATIVE_GL_FUNCTION(glEnableClientState, &code.glEnableClientState); | |
| 539 | //LOAD_NATIVE_GL_FUNCTION(glEnd, &code.glEnd); | ||
| 540 | //LOAD_NATIVE_GL_FUNCTION(glEndList, &code.glEndList); | ||
| 541 | //LOAD_NATIVE_GL_FUNCTION(glEvalCoord1d, &code.glEvalCoord1d); | ||
| 542 | //LOAD_NATIVE_GL_FUNCTION(glEvalCoord1dv, &code.glEvalCoord1dv); | ||
| 543 | //LOAD_NATIVE_GL_FUNCTION(glEvalCoord1f, &code.glEvalCoord1f); | ||
| 544 | //LOAD_NATIVE_GL_FUNCTION(glEvalCoord1fv, &code.glEvalCoord1fv); | ||
| 545 | //LOAD_NATIVE_GL_FUNCTION(glEvalCoord2d, &code.glEvalCoord2d); | ||
| 546 | //LOAD_NATIVE_GL_FUNCTION(glEvalCoord2dv, &code.glEvalCoord2dv); | ||
| 547 | //LOAD_NATIVE_GL_FUNCTION(glEvalCoord2f, &code.glEvalCoord2f); | ||
| 548 | //LOAD_NATIVE_GL_FUNCTION(glEvalCoord2fv, &code.glEvalCoord2fv); | ||
| 549 | //LOAD_NATIVE_GL_FUNCTION(glEvalMesh1, &code.glEvalMesh1); | ||
| 550 | //LOAD_NATIVE_GL_FUNCTION(glEvalMesh2, &code.glEvalMesh2); | ||
| 551 | //LOAD_NATIVE_GL_FUNCTION(glEvalPoint1, &code.glEvalPoint1); | ||
| 552 | //LOAD_NATIVE_GL_FUNCTION(glEvalPoint2, &code.glEvalPoint2); | ||
| 553 | //LOAD_NATIVE_GL_FUNCTION(glFeedbackBuffer, &code.glFeedbackBuffer); | ||
| 554 | ✗ | LOAD_NATIVE_GL_FUNCTION(glFogf, &code.glFogf); | |
| 555 | ✗ | LOAD_NATIVE_GL_FUNCTION(glFogfv, &code.glFogfv); | |
| 556 | //LOAD_NATIVE_GL_FUNCTION(glFogi, &code.glFogi); | ||
| 557 | //LOAD_NATIVE_GL_FUNCTION(glFogiv, &code.glFogiv); | ||
| 558 | #if defined(GATE_OPENGL_NO_DBL) | ||
| 559 | LOAD_NATIVE_GL_FUNCTION(glFrustumf, &code.glFrustum); | ||
| 560 | #else | ||
| 561 | ✗ | LOAD_NATIVE_GL_FUNCTION(glFrustum, &code.glFrustum); | |
| 562 | #endif | ||
| 563 | //LOAD_NATIVE_GL_FUNCTION(glGenLists, &code.glGenLists); | ||
| 564 | #if defined(GATE_OPENGL_NO_DBL) | ||
| 565 | //LOAD_NATIVE_GL_FUNCTION(glGetClipPlanef, &code.glGetClipPlane); | ||
| 566 | #else | ||
| 567 | //LOAD_NATIVE_GL_FUNCTION(glGetClipPlane, &code.glGetClipPlane); | ||
| 568 | #endif | ||
| 569 | //LOAD_NATIVE_GL_FUNCTION(glGetDoublev, &code.glGetDoublev); | ||
| 570 | #if !defined(GATE_COMPILER_EMSCRIPTEN) | ||
| 571 | ✗ | LOAD_NATIVE_GL_FUNCTION(glGetLightfv, &code.glGetLightfv); | |
| 572 | #endif | ||
| 573 | //LOAD_NATIVE_GL_FUNCTION(glGetLightiv, &code.glGetLightiv); | ||
| 574 | //LOAD_NATIVE_GL_FUNCTION(glGetMapdv, &code.glGetMapdv); | ||
| 575 | //LOAD_NATIVE_GL_FUNCTION(glGetMapfv, &code.glGetMapfv); | ||
| 576 | //LOAD_NATIVE_GL_FUNCTION(glGetMapiv, &code.glGetMapiv); | ||
| 577 | #if !defined(GATE_COMPILER_EMSCRIPTEN) | ||
| 578 | ✗ | LOAD_NATIVE_GL_FUNCTION(glGetMaterialfv, &code.glGetMaterialfv); | |
| 579 | #endif | ||
| 580 | //LOAD_NATIVE_GL_FUNCTION(glGetMaterialiv, &code.glGetMaterialiv); | ||
| 581 | //LOAD_NATIVE_GL_FUNCTION(glGetPixelMapfv, &code.glGetPixelMapfv); | ||
| 582 | //LOAD_NATIVE_GL_FUNCTION(glGetPixelMapuiv, &code.glGetPixelMapuiv); | ||
| 583 | //LOAD_NATIVE_GL_FUNCTION(glGetPixelMapusv, &code.glGetPixelMapusv); | ||
| 584 | ✗ | LOAD_NATIVE_GL_FUNCTION(glGetPointerv, &code.glGetPointerv); | |
| 585 | //LOAD_NATIVE_GL_FUNCTION(glGetPolygonStipple, &code.glGetPolygonStipple); | ||
| 586 | ✗ | LOAD_NATIVE_GL_FUNCTION(glGetTexEnvfv, &code.glGetTexEnvfv); | |
| 587 | ✗ | LOAD_NATIVE_GL_FUNCTION(glGetTexEnviv, &code.glGetTexEnviv); | |
| 588 | //LOAD_NATIVE_GL_FUNCTION(glGetTexGendv, &code.glGetTexGendv); | ||
| 589 | //LOAD_NATIVE_GL_FUNCTION(glGetTexGenfv, &code.glGetTexGenfv); | ||
| 590 | //LOAD_NATIVE_GL_FUNCTION(glGetTexGeniv, &code.glGetTexGeniv); | ||
| 591 | //LOAD_NATIVE_GL_FUNCTION(glGetTexImage, &code.glGetTexImage); | ||
| 592 | //LOAD_NATIVE_GL_FUNCTION(glGetTexLevelParameterfv, &code.glGetTexLevelParameterfv); | ||
| 593 | //LOAD_NATIVE_GL_FUNCTION(glGetTexLevelParameteriv, &code.glGetTexLevelParameteriv); | ||
| 594 | //LOAD_NATIVE_GL_FUNCTION(glIndexMask, &code.glIndexMask); | ||
| 595 | //LOAD_NATIVE_GL_FUNCTION(glIndexPointer, &code.glIndexPointer); | ||
| 596 | //LOAD_NATIVE_GL_FUNCTION(glIndexd, &code.glIndexd); | ||
| 597 | //LOAD_NATIVE_GL_FUNCTION(glIndexdv, &code.glIndexdv); | ||
| 598 | //LOAD_NATIVE_GL_FUNCTION(glIndexf, &code.glIndexf); | ||
| 599 | //LOAD_NATIVE_GL_FUNCTION(glIndexfv, &code.glIndexfv); | ||
| 600 | //LOAD_NATIVE_GL_FUNCTION(glIndexi, &code.glIndexi); | ||
| 601 | //LOAD_NATIVE_GL_FUNCTION(glIndexiv, &code.glIndexiv); | ||
| 602 | //LOAD_NATIVE_GL_FUNCTION(glIndexs, &code.glIndexs); | ||
| 603 | //LOAD_NATIVE_GL_FUNCTION(glIndexsv, &code.glIndexsv); | ||
| 604 | //LOAD_NATIVE_GL_FUNCTION(glIndexub, &code.glIndexub); | ||
| 605 | //LOAD_NATIVE_GL_FUNCTION(glIndexubv, &code.glIndexubv); | ||
| 606 | //LOAD_NATIVE_GL_FUNCTION(glInitNames, &code.glInitNames); | ||
| 607 | //LOAD_NATIVE_GL_FUNCTION(glInterleavedArrays, &code.glInterleavedArrays); | ||
| 608 | //LOAD_NATIVE_GL_FUNCTION(glIsList, &code.glIsList); | ||
| 609 | ✗ | LOAD_NATIVE_GL_FUNCTION(glLightModelf, &code.glLightModelf); | |
| 610 | ✗ | LOAD_NATIVE_GL_FUNCTION(glLightModelfv, &code.glLightModelfv); | |
| 611 | //LOAD_NATIVE_GL_FUNCTION(glLightModeli, &code.glLightModeli); | ||
| 612 | //LOAD_NATIVE_GL_FUNCTION(glLightModeliv, &code.glLightModeliv); | ||
| 613 | #if !defined(GATE_COMPILER_EMSCRIPTEN) | ||
| 614 | ✗ | LOAD_NATIVE_GL_FUNCTION(glLightf, &code.glLightf); | |
| 615 | #endif | ||
| 616 | ✗ | LOAD_NATIVE_GL_FUNCTION(glLightfv, &code.glLightfv); | |
| 617 | //LOAD_NATIVE_GL_FUNCTION(glLighti, &code.glLighti); | ||
| 618 | //LOAD_NATIVE_GL_FUNCTION(glLightiv, &code.glLightiv); | ||
| 619 | //LOAD_NATIVE_GL_FUNCTION(glLineStipple, &code.glLineStipple); | ||
| 620 | //LOAD_NATIVE_GL_FUNCTION(glListBase, &code.glListBase); | ||
| 621 | //LOAD_NATIVE_GL_FUNCTION(glLoadMatrixd, &code.glLoadMatrixd); | ||
| 622 | ✗ | LOAD_NATIVE_GL_FUNCTION(glLoadMatrixf, &code.glLoadMatrixf); | |
| 623 | //LOAD_NATIVE_GL_FUNCTION(glLoadName, &code.glLoadName); | ||
| 624 | //LOAD_NATIVE_GL_FUNCTION(glLogicOp, &code.glLogicOp); | ||
| 625 | //LOAD_NATIVE_GL_FUNCTION(glMap1d, &code.glMap1d); | ||
| 626 | //LOAD_NATIVE_GL_FUNCTION(glMap1f, &code.glMap1f); | ||
| 627 | //LOAD_NATIVE_GL_FUNCTION(glMap2d, &code.glMap2d); | ||
| 628 | //LOAD_NATIVE_GL_FUNCTION(glMap2f, &code.glMap2f); | ||
| 629 | //LOAD_NATIVE_GL_FUNCTION(glMapGrid1d, &code.glMapGrid1d); | ||
| 630 | //LOAD_NATIVE_GL_FUNCTION(glMapGrid1f, &code.glMapGrid1f); | ||
| 631 | //LOAD_NATIVE_GL_FUNCTION(glMapGrid2d, &code.glMapGrid2d); | ||
| 632 | //LOAD_NATIVE_GL_FUNCTION(glMapGrid2f, &code.glMapGrid2f); | ||
| 633 | #if !defined(GATE_COMPILER_EMSCRIPTEN) | ||
| 634 | ✗ | LOAD_NATIVE_GL_FUNCTION(glMaterialf, &code.glMaterialf); | |
| 635 | #endif | ||
| 636 | ✗ | LOAD_NATIVE_GL_FUNCTION(glMaterialfv, &code.glMaterialfv); | |
| 637 | //LOAD_NATIVE_GL_FUNCTION(glMateriali, &code.glMateriali); | ||
| 638 | //LOAD_NATIVE_GL_FUNCTION(glMaterialiv, &code.glMaterialiv); | ||
| 639 | //LOAD_NATIVE_GL_FUNCTION(glMultMatrixd, &code.glMultMatrixd); | ||
| 640 | ✗ | LOAD_NATIVE_GL_FUNCTION(glMultMatrixf, &code.glMultMatrixf); | |
| 641 | //LOAD_NATIVE_GL_FUNCTION(glNewList, &code.glNewList); | ||
| 642 | //LOAD_NATIVE_GL_FUNCTION(glNormal3b, &code.glNormal3b); | ||
| 643 | //LOAD_NATIVE_GL_FUNCTION(glNormal3bv, &code.glNormal3bv); | ||
| 644 | //LOAD_NATIVE_GL_FUNCTION(glNormal3d, &code.glNormal3d); | ||
| 645 | //LOAD_NATIVE_GL_FUNCTION(glNormal3dv, &code.glNormal3dv); | ||
| 646 | ✗ | LOAD_NATIVE_GL_FUNCTION(glNormal3f, &code.glNormal3f); | |
| 647 | //LOAD_NATIVE_GL_FUNCTION(glNormal3fv, &code.glNormal3fv); | ||
| 648 | //LOAD_NATIVE_GL_FUNCTION(glNormal3i, &code.glNormal3i); | ||
| 649 | //LOAD_NATIVE_GL_FUNCTION(glNormal3iv, &code.glNormal3iv); | ||
| 650 | //LOAD_NATIVE_GL_FUNCTION(glNormal3s, &code.glNormal3s); | ||
| 651 | //LOAD_NATIVE_GL_FUNCTION(glNormal3sv, &code.glNormal3sv); | ||
| 652 | ✗ | LOAD_NATIVE_GL_FUNCTION(glNormalPointer, &code.glNormalPointer); | |
| 653 | #if defined(GATE_OPENGL_NO_DBL) | ||
| 654 | LOAD_NATIVE_GL_FUNCTION(glOrthof, &code.glOrtho); | ||
| 655 | #else | ||
| 656 | ✗ | LOAD_NATIVE_GL_FUNCTION(glOrtho, &code.glOrtho); | |
| 657 | #endif | ||
| 658 | //LOAD_NATIVE_GL_FUNCTION(glPassThrough, &code.glPassThrough); | ||
| 659 | //LOAD_NATIVE_GL_FUNCTION(glPixelMapfv, &code.glPixelMapfv); | ||
| 660 | //LOAD_NATIVE_GL_FUNCTION(glPixelMapuiv, &code.glPixelMapuiv); | ||
| 661 | //LOAD_NATIVE_GL_FUNCTION(glPixelMapusv, &code.glPixelMapusv); | ||
| 662 | //LOAD_NATIVE_GL_FUNCTION(glPixelStoref, &code.glPixelStoref); | ||
| 663 | //LOAD_NATIVE_GL_FUNCTION(glPixelTransferf, &code.glPixelTransferf); | ||
| 664 | //LOAD_NATIVE_GL_FUNCTION(glPixelTransferi, &code.glPixelTransferi); | ||
| 665 | //LOAD_NATIVE_GL_FUNCTION(glPixelZoom, &code.glPixelZoom); | ||
| 666 | ✗ | LOAD_NATIVE_GL_FUNCTION(glPointSize, &code.glPointSize); | |
| 667 | //LOAD_NATIVE_GL_FUNCTION(glPolygonMode, &code.glPolygonMode); | ||
| 668 | //LOAD_NATIVE_GL_FUNCTION(glPolygonStipple, &code.glPolygonStipple); | ||
| 669 | //LOAD_NATIVE_GL_FUNCTION(glPopAttrib, &code.glPopAttrib); | ||
| 670 | //LOAD_NATIVE_GL_FUNCTION(glPopClientAttrib, &code.glPopClientAttrib); | ||
| 671 | ✗ | LOAD_NATIVE_GL_FUNCTION(glPopMatrix, &code.glPopMatrix); | |
| 672 | //LOAD_NATIVE_GL_FUNCTION(glPopName, &code.glPopName); | ||
| 673 | //LOAD_NATIVE_GL_FUNCTION(glPrioritizeTextures, &code.glPrioritizeTextures); | ||
| 674 | //LOAD_NATIVE_GL_FUNCTION(glPushAttrib, &code.glPushAttrib); | ||
| 675 | //LOAD_NATIVE_GL_FUNCTION(glPushClientAttrib, &code.glPushClientAttrib); | ||
| 676 | ✗ | LOAD_NATIVE_GL_FUNCTION(glPushMatrix, &code.glPushMatrix); | |
| 677 | //LOAD_NATIVE_GL_FUNCTION(glPushName, &code.glPushName); | ||
| 678 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos2d, &code.glRasterPos2d); | ||
| 679 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos2dv, &code.glRasterPos2dv); | ||
| 680 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos2f, &code.glRasterPos2f); | ||
| 681 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos2fv, &code.glRasterPos2fv); | ||
| 682 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos2i, &code.glRasterPos2i); | ||
| 683 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos2iv, &code.glRasterPos2iv); | ||
| 684 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos2s, &code.glRasterPos2s); | ||
| 685 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos2sv, &code.glRasterPos2sv); | ||
| 686 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos3d, &code.glRasterPos3d); | ||
| 687 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos3dv, &code.glRasterPos3dv); | ||
| 688 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos3f, &code.glRasterPos3f); | ||
| 689 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos3fv, &code.glRasterPos3fv); | ||
| 690 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos3i, &code.glRasterPos3i); | ||
| 691 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos3iv, &code.glRasterPos3iv); | ||
| 692 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos3s, &code.glRasterPos3s); | ||
| 693 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos3sv, &code.glRasterPos3sv); | ||
| 694 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos4d, &code.glRasterPos4d); | ||
| 695 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos4dv, &code.glRasterPos4dv); | ||
| 696 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos4f, &code.glRasterPos4f); | ||
| 697 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos4fv, &code.glRasterPos4fv); | ||
| 698 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos4i, &code.glRasterPos4i); | ||
| 699 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos4iv, &code.glRasterPos4iv); | ||
| 700 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos4s, &code.glRasterPos4s); | ||
| 701 | //LOAD_NATIVE_GL_FUNCTION(glRasterPos4sv, &code.glRasterPos4sv); | ||
| 702 | //LOAD_NATIVE_GL_FUNCTION(glReadBuffer, &code.glReadBuffer); | ||
| 703 | //LOAD_NATIVE_GL_FUNCTION(glRectd, &code.glRectd); | ||
| 704 | //LOAD_NATIVE_GL_FUNCTION(glRectdv, &code.glRectdv); | ||
| 705 | //LOAD_NATIVE_GL_FUNCTION(glRectf, &code.glRectf); | ||
| 706 | //LOAD_NATIVE_GL_FUNCTION(glRectfv, &code.glRectfv); | ||
| 707 | //LOAD_NATIVE_GL_FUNCTION(glRecti, &code.glRecti); | ||
| 708 | //LOAD_NATIVE_GL_FUNCTION(glRectiv, &code.glRectiv); | ||
| 709 | //LOAD_NATIVE_GL_FUNCTION(glRects, &code.glRects); | ||
| 710 | //LOAD_NATIVE_GL_FUNCTION(glRectsv, &code.glRectsv); | ||
| 711 | //LOAD_NATIVE_GL_FUNCTION(glRenderMode, &code.glRenderMode); | ||
| 712 | //LOAD_NATIVE_GL_FUNCTION(glRotated, &code.glRotated); | ||
| 713 | ✗ | LOAD_NATIVE_GL_FUNCTION(glRotatef, &code.glRotatef); | |
| 714 | //LOAD_NATIVE_GL_FUNCTION(glScaled, &code.glScaled); | ||
| 715 | ✗ | LOAD_NATIVE_GL_FUNCTION(glScalef, &code.glScalef); | |
| 716 | //LOAD_NATIVE_GL_FUNCTION(glSelectBuffer, &code.glSelectBuffer); | ||
| 717 | ✗ | LOAD_NATIVE_GL_FUNCTION(glShadeModel, &code.glShadeModel); | |
| 718 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord1d, &code.glTexCoord1d); | ||
| 719 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord1dv, &code.glTexCoord1dv); | ||
| 720 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord1f, &code.glTexCoord1f); | ||
| 721 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord1fv, &code.glTexCoord1fv); | ||
| 722 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord1i, &code.glTexCoord1i); | ||
| 723 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord1iv, &code.glTexCoord1iv); | ||
| 724 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord1s, &code.glTexCoord1s); | ||
| 725 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord1sv, &code.glTexCoord1sv); | ||
| 726 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord2d, &code.glTexCoord2d); | ||
| 727 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord2dv, &code.glTexCoord2dv); | ||
| 728 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord2f, &code.glTexCoord2f); | ||
| 729 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord2fv, &code.glTexCoord2fv); | ||
| 730 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord2i, &code.glTexCoord2i); | ||
| 731 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord2iv, &code.glTexCoord2iv); | ||
| 732 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord2s, &code.glTexCoord2s); | ||
| 733 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord2sv, &code.glTexCoord2sv); | ||
| 734 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord3d, &code.glTexCoord3d); | ||
| 735 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord3dv, &code.glTexCoord3dv); | ||
| 736 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord3f, &code.glTexCoord3f); | ||
| 737 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord3fv, &code.glTexCoord3fv); | ||
| 738 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord3i, &code.glTexCoord3i); | ||
| 739 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord3iv, &code.glTexCoord3iv); | ||
| 740 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord3s, &code.glTexCoord3s); | ||
| 741 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord3sv, &code.glTexCoord3sv); | ||
| 742 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord4d, &code.glTexCoord4d); | ||
| 743 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord4dv, &code.glTexCoord4dv); | ||
| 744 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord4f, &code.glTexCoord4f); | ||
| 745 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord4fv, &code.glTexCoord4fv); | ||
| 746 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord4i, &code.glTexCoord4i); | ||
| 747 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord4iv, &code.glTexCoord4iv); | ||
| 748 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord4s, &code.glTexCoord4s); | ||
| 749 | //LOAD_NATIVE_GL_FUNCTION(glTexCoord4sv, &code.glTexCoord4sv); | ||
| 750 | ✗ | LOAD_NATIVE_GL_FUNCTION(glTexCoordPointer, &code.glTexCoordPointer); | |
| 751 | ✗ | LOAD_NATIVE_GL_FUNCTION(glTexEnvf, &code.glTexEnvf); | |
| 752 | ✗ | LOAD_NATIVE_GL_FUNCTION(glTexEnvfv, &code.glTexEnvfv); | |
| 753 | ✗ | LOAD_NATIVE_GL_FUNCTION(glTexEnvi, &code.glTexEnvi); | |
| 754 | #if !defined(GATE_COMPILER_EMSCRIPTEN) | ||
| 755 | ✗ | LOAD_NATIVE_GL_FUNCTION(glTexEnviv, &code.glTexEnviv); | |
| 756 | #endif | ||
| 757 | //LOAD_NATIVE_GL_FUNCTION(glTexGend, &code.glTexGend); | ||
| 758 | //LOAD_NATIVE_GL_FUNCTION(glTexGendv, &code.glTexGendv); | ||
| 759 | //LOAD_NATIVE_GL_FUNCTION(glTexGenf, &code.glTexGenf); | ||
| 760 | //LOAD_NATIVE_GL_FUNCTION(glTexGenfv, &code.glTexGenfv); | ||
| 761 | //LOAD_NATIVE_GL_FUNCTION(glTexGeni, &code.glTexGeni); | ||
| 762 | //LOAD_NATIVE_GL_FUNCTION(glTexGeniv, &code.glTexGeniv); | ||
| 763 | //LOAD_NATIVE_GL_FUNCTION(glTexImage1D, &code.glTexImage1D); | ||
| 764 | //LOAD_NATIVE_GL_FUNCTION(glTexSubImage1D, &code.glTexSubImage1D); | ||
| 765 | //LOAD_NATIVE_GL_FUNCTION(glTranslated, &code.glTranslated); | ||
| 766 | ✗ | LOAD_NATIVE_GL_FUNCTION(glTranslatef, &code.glTranslatef); | |
| 767 | //LOAD_NATIVE_GL_FUNCTION(glVertex2d, &code.glVertex2d); | ||
| 768 | //LOAD_NATIVE_GL_FUNCTION(glVertex2dv, &code.glVertex2dv); | ||
| 769 | //LOAD_NATIVE_GL_FUNCTION(glVertex2f, &code.glVertex2f); | ||
| 770 | //LOAD_NATIVE_GL_FUNCTION(glVertex2fv, &code.glVertex2fv); | ||
| 771 | //LOAD_NATIVE_GL_FUNCTION(glVertex2i, &code.glVertex2i); | ||
| 772 | //LOAD_NATIVE_GL_FUNCTION(glVertex2iv, &code.glVertex2iv); | ||
| 773 | //LOAD_NATIVE_GL_FUNCTION(glVertex2s, &code.glVertex2s); | ||
| 774 | //LOAD_NATIVE_GL_FUNCTION(glVertex2sv, &code.glVertex2sv); | ||
| 775 | //LOAD_NATIVE_GL_FUNCTION(glVertex3d, &code.glVertex3d); | ||
| 776 | //LOAD_NATIVE_GL_FUNCTION(glVertex3dv, &code.glVertex3dv); | ||
| 777 | //LOAD_NATIVE_GL_FUNCTION(glVertex3f, &code.glVertex3f); | ||
| 778 | //LOAD_NATIVE_GL_FUNCTION(glVertex3fv, &code.glVertex3fv); | ||
| 779 | //LOAD_NATIVE_GL_FUNCTION(glVertex3i, &code.glVertex3i); | ||
| 780 | //LOAD_NATIVE_GL_FUNCTION(glVertex3iv, &code.glVertex3iv); | ||
| 781 | //LOAD_NATIVE_GL_FUNCTION(glVertex3s, &code.glVertex3s); | ||
| 782 | //LOAD_NATIVE_GL_FUNCTION(glVertex3sv, &code.glVertex3sv); | ||
| 783 | //LOAD_NATIVE_GL_FUNCTION(glVertex4d, &code.glVertex4d); | ||
| 784 | //LOAD_NATIVE_GL_FUNCTION(glVertex4dv, &code.glVertex4dv); | ||
| 785 | //LOAD_NATIVE_GL_FUNCTION(glVertex4f, &code.glVertex4f); | ||
| 786 | //LOAD_NATIVE_GL_FUNCTION(glVertex4fv, &code.glVertex4fv); | ||
| 787 | //LOAD_NATIVE_GL_FUNCTION(glVertex4i, &code.glVertex4i); | ||
| 788 | //LOAD_NATIVE_GL_FUNCTION(glVertex4iv, &code.glVertex4iv); | ||
| 789 | //LOAD_NATIVE_GL_FUNCTION(glVertex4s, &code.glVertex4s); | ||
| 790 | //LOAD_NATIVE_GL_FUNCTION(glVertex4sv, &code.glVertex4sv); | ||
| 791 | |||
| 792 | #endif /* !defined(GATE_GRAPHICS_NO_LEGACY_OPENGL) */ | ||
| 793 | |||
| 794 | ✗ | LOAD_NATIVE_GL_FUNCTION(glBindTexture, &code.glBindTexture); | |
| 795 | ✗ | LOAD_NATIVE_GL_FUNCTION(glBlendFunc, &code.glBlendFunc); | |
| 796 | ✗ | LOAD_NATIVE_GL_FUNCTION(glClear, &code.glClear); | |
| 797 | ✗ | LOAD_NATIVE_GL_FUNCTION(glClearColor, &code.glClearColor); | |
| 798 | #if defined(GATE_OPENGL_NO_DBL) | ||
| 799 | LOAD_NATIVE_GL_FUNCTION(glClearDepthf, &code.glClearDepth); | ||
| 800 | #else | ||
| 801 | ✗ | LOAD_NATIVE_GL_FUNCTION(glClearDepth, &code.glClearDepth); | |
| 802 | #endif | ||
| 803 | ✗ | LOAD_NATIVE_GL_FUNCTION(glClearStencil, &code.glClearStencil); | |
| 804 | ✗ | LOAD_NATIVE_GL_FUNCTION(glColorMask, &code.glColorMask); | |
| 805 | ✗ | LOAD_NATIVE_GL_FUNCTION(glCopyTexImage2D, &code.glCopyTexImage2D); | |
| 806 | ✗ | LOAD_NATIVE_GL_FUNCTION(glCopyTexSubImage2D, &code.glCopyTexSubImage2D); | |
| 807 | ✗ | LOAD_NATIVE_GL_FUNCTION(glCullFace, &code.glCullFace); | |
| 808 | ✗ | LOAD_NATIVE_GL_FUNCTION(glDeleteTextures, &code.glDeleteTextures); | |
| 809 | ✗ | LOAD_NATIVE_GL_FUNCTION(glDepthFunc, &code.glDepthFunc); | |
| 810 | ✗ | LOAD_NATIVE_GL_FUNCTION(glDepthMask, &code.glDepthMask); | |
| 811 | #if defined(GATE_OPENGL_NO_DBL) | ||
| 812 | LOAD_NATIVE_GL_FUNCTION(glDepthRangef, &code.glDepthRange); | ||
| 813 | #else | ||
| 814 | ✗ | LOAD_NATIVE_GL_FUNCTION(glDepthRange, &code.glDepthRange); | |
| 815 | #endif | ||
| 816 | ✗ | LOAD_NATIVE_GL_FUNCTION(glDisable, &code.glDisable); | |
| 817 | ✗ | LOAD_NATIVE_GL_FUNCTION(glDrawArrays, &code.glDrawArrays); | |
| 818 | ✗ | LOAD_NATIVE_GL_FUNCTION(glDrawElements, &code.glDrawElements); | |
| 819 | ✗ | LOAD_NATIVE_GL_FUNCTION(glEnable, &code.glEnable); | |
| 820 | ✗ | LOAD_NATIVE_GL_FUNCTION(glFinish, &code.glFinish); | |
| 821 | ✗ | LOAD_NATIVE_GL_FUNCTION(glFlush, &code.glFlush); | |
| 822 | ✗ | LOAD_NATIVE_GL_FUNCTION(glFrontFace, &code.glFrontFace); | |
| 823 | ✗ | LOAD_NATIVE_GL_FUNCTION(glGenTextures, &code.glGenTextures); | |
| 824 | ✗ | LOAD_NATIVE_GL_FUNCTION(glGetBooleanv, &code.glGetBooleanv); | |
| 825 | ✗ | LOAD_NATIVE_GL_FUNCTION(glGetError, &code.glGetError); | |
| 826 | ✗ | LOAD_NATIVE_GL_FUNCTION(glGetFloatv, &code.glGetFloatv); | |
| 827 | ✗ | LOAD_NATIVE_GL_FUNCTION(glGetIntegerv, &code.glGetIntegerv); | |
| 828 | ✗ | LOAD_NATIVE_GL_FUNCTION(glGetString, &code.glGetString); | |
| 829 | ✗ | LOAD_NATIVE_GL_FUNCTION(glGetTexParameterfv, &code.glGetTexParameterfv); | |
| 830 | ✗ | LOAD_NATIVE_GL_FUNCTION(glGetTexParameteriv, &code.glGetTexParameteriv); | |
| 831 | ✗ | LOAD_NATIVE_GL_FUNCTION(glHint, &code.glHint); | |
| 832 | ✗ | LOAD_NATIVE_GL_FUNCTION(glIsEnabled, &code.glIsEnabled); | |
| 833 | ✗ | LOAD_NATIVE_GL_FUNCTION(glIsTexture, &code.glIsTexture); | |
| 834 | ✗ | LOAD_NATIVE_GL_FUNCTION(glLineWidth, &code.glLineWidth); | |
| 835 | ✗ | LOAD_NATIVE_GL_FUNCTION(glLoadIdentity, &code.glLoadIdentity); | |
| 836 | ✗ | LOAD_NATIVE_GL_FUNCTION(glMatrixMode, &code.glMatrixMode); | |
| 837 | ✗ | LOAD_NATIVE_GL_FUNCTION(glPixelStorei, &code.glPixelStorei); | |
| 838 | ✗ | LOAD_NATIVE_GL_FUNCTION(glPolygonOffset, &code.glPolygonOffset); | |
| 839 | ✗ | LOAD_NATIVE_GL_FUNCTION(glReadPixels, &code.glReadPixels); | |
| 840 | ✗ | LOAD_NATIVE_GL_FUNCTION(glScissor, &code.glScissor); | |
| 841 | ✗ | LOAD_NATIVE_GL_FUNCTION(glStencilFunc, &code.glStencilFunc); | |
| 842 | ✗ | LOAD_NATIVE_GL_FUNCTION(glStencilMask, &code.glStencilMask); | |
| 843 | ✗ | LOAD_NATIVE_GL_FUNCTION(glStencilOp, &code.glStencilOp); | |
| 844 | ✗ | LOAD_NATIVE_GL_FUNCTION(glTexImage2D, &code.glTexImage2D); | |
| 845 | ✗ | LOAD_NATIVE_GL_FUNCTION(glTexParameterf, &code.glTexParameterf); | |
| 846 | ✗ | LOAD_NATIVE_GL_FUNCTION(glTexParameterfv, &code.glTexParameterfv); | |
| 847 | ✗ | LOAD_NATIVE_GL_FUNCTION(glTexParameteri, &code.glTexParameteri); | |
| 848 | ✗ | LOAD_NATIVE_GL_FUNCTION(glTexParameteriv, &code.glTexParameteriv); | |
| 849 | ✗ | LOAD_NATIVE_GL_FUNCTION(glTexSubImage2D, &code.glTexSubImage2D); | |
| 850 | ✗ | LOAD_NATIVE_GL_FUNCTION(glVertexPointer, &code.glVertexPointer); | |
| 851 | ✗ | LOAD_NATIVE_GL_FUNCTION(glViewport, &code.glViewport); | |
| 852 | |||
| 853 | ✗ | gate_mem_copy(ptr_code, &code, sizeof(gate_gl_api_functions_t)); | |
| 854 | ✗ | } | |
| 855 | |||
| 856 | ✗ | static gate_result_t gate_gl_api_load_functions(void) | |
| 857 | { | ||
| 858 | static volatile bool opengl_lib_loaded = false; | ||
| 859 | static gate_library_t opengl_lib_handle = NULL; | ||
| 860 | ✗ | gate_result_t ret = GATE_RESULT_FAILED; | |
| 861 | |||
| 862 | ✗ | if (opengl_lib_loaded) | |
| 863 | { | ||
| 864 | ✗ | ret = GATE_RESULT_OK; | |
| 865 | } | ||
| 866 | else | ||
| 867 | { | ||
| 868 | do | ||
| 869 | { | ||
| 870 | #if !defined(GATE_OPENGL_APIS_DIRECT_BINDING) | ||
| 871 | static gate_string_t const opengl_lib_name = GATE_STRING_INIT_STATIC(OPENGL_LIBNAME); | ||
| 872 | static gate_string_t const opengl_lib_name_alt = GATE_STRING_INIT_STATIC(OPENGL_LIBNAME_ALT); | ||
| 873 | ✗ | ret = gate_library_open(&opengl_lib_name, &opengl_lib_handle, GATE_LIBRARY_FLAG_DEFAULT); | |
| 874 | ✗ | if (GATE_FAILED(ret)) | |
| 875 | { | ||
| 876 | ✗ | ret = gate_library_open(&opengl_lib_name_alt, &opengl_lib_handle, GATE_LIBRARY_FLAG_DEFAULT); | |
| 877 | } | ||
| 878 | ✗ | GATE_BREAK_IF_FAILED(ret); | |
| 879 | #endif | ||
| 880 | |||
| 881 | ✗ | load_native_gl_functions(opengl_lib_handle, &gate_gl_api); | |
| 882 | |||
| 883 | ✗ | opengl_lib_loaded = true; | |
| 884 | ✗ | ret = GATE_RESULT_OK; | |
| 885 | } while (0); | ||
| 886 | } | ||
| 887 | ✗ | return ret; | |
| 888 | } | ||
| 889 | |||
| 890 | |||
| 891 | |||
| 892 | #if defined(GATE_GRAPHICS_OPENGL2_SUPPORT) | ||
| 893 | |||
| 894 | typedef struct gate_gl2_api_functions_class | ||
| 895 | { | ||
| 896 | GLuint (OGLAPI *glCreateShader) (GLenum type); | ||
| 897 | void (OGLAPI *glShaderSource) (GLuint shader, GLsizei count, const GLchar * const * string, const GLint * length); | ||
| 898 | void (OGLAPI *glCompileShader) (GLuint shader); | ||
| 899 | void (OGLAPI *glGetShaderiv) (GLuint shader, GLenum pname, GLint * params); | ||
| 900 | void (OGLAPI *glGetShaderInfoLog) (GLuint shader, GLsizei maxLength, GLsizei * length, GLchar * infoLog); | ||
| 901 | void (OGLAPI *glDeleteShader) (GLuint shader); | ||
| 902 | |||
| 903 | |||
| 904 | GLuint (OGLAPI *glCreateProgram) (void); | ||
| 905 | void (OGLAPI *glLinkProgram) (GLuint program); | ||
| 906 | void (OGLAPI *glGetProgramiv) (GLuint program, GLenum pname, GLint * params); | ||
| 907 | void (OGLAPI *glGetProgramInfoLog) (GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog); | ||
| 908 | void (OGLAPI *glUseProgram) (GLuint program); | ||
| 909 | void (OGLAPI *glAttachShader) (GLuint program, GLuint shader); | ||
| 910 | void (OGLAPI *glDeleteProgram) (GLuint program); | ||
| 911 | void (OGLAPI *glBindAttribLocation) (GLuint program, GLuint index, const GLchar * name); | ||
| 912 | GLint (OGLAPI *glGetAttribLocation) (GLuint program, const GLchar * name); | ||
| 913 | GLint (OGLAPI *glGetUniformLocation) (GLuint program, const GLchar * name); | ||
| 914 | |||
| 915 | void (OGLAPI *glGenBuffers) (GLsizei n, GLuint * buffers); | ||
| 916 | void (OGLAPI *glDeleteBuffers) (GLsizei n, const GLuint * buffers); | ||
| 917 | void (OGLAPI *glBindBuffer) (GLenum target, GLuint buffer); | ||
| 918 | void (OGLAPI *glBufferData) (GLenum target, GLsizeiptr size, const void * data, GLenum usage); | ||
| 919 | //void (OGLAPI *glNamedBufferData) (GLuint buffer, GLsizeiptr size, const void * data, GLenum usage); | ||
| 920 | void (OGLAPI *glVertexAttribPointer) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer); | ||
| 921 | void (OGLAPI *glEnableVertexAttribArray) (GLuint index); | ||
| 922 | void (OGLAPI *glDisableVertexAttribArray)(GLuint index); | ||
| 923 | void (OGLAPI *glActiveTexture) (GLenum texture); | ||
| 924 | |||
| 925 | void (OGLAPI *glUniform1f)(GLint location, GLfloat v0); | ||
| 926 | void (OGLAPI *glUniform2f)(GLint location, GLfloat v0, GLfloat v1); | ||
| 927 | void (OGLAPI *glUniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); | ||
| 928 | void (OGLAPI *glUniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); | ||
| 929 | void (OGLAPI *glUniform1fv)(GLint location,GLsizei count,const GLfloat *value); | ||
| 930 | void (OGLAPI *glUniform2fv)(GLint location,GLsizei count,const GLfloat *value); | ||
| 931 | void (OGLAPI *glUniform3fv)(GLint location,GLsizei count,const GLfloat *value); | ||
| 932 | void (OGLAPI *glUniform4fv)(GLint location,GLsizei count,const GLfloat *value); | ||
| 933 | void (OGLAPI *glUniform1i)(GLint location, GLint v0); | ||
| 934 | void (OGLAPI *glUniform2i)(GLint location, GLint v0, GLint v1); | ||
| 935 | void (OGLAPI *glUniform3i)(GLint location, GLint v0, GLint v1, GLint v2); | ||
| 936 | void (OGLAPI *glUniform4i)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); | ||
| 937 | void (OGLAPI *glUniform1iv)(GLint location, GLsizei count, const GLint *value); | ||
| 938 | void (OGLAPI *glUniform2iv)(GLint location, GLsizei count, const GLint *value); | ||
| 939 | void (OGLAPI *glUniform3iv)(GLint location, GLsizei count, const GLint *value); | ||
| 940 | void (OGLAPI *glUniform4iv)(GLint location, GLsizei count, const GLint *value); | ||
| 941 | void (OGLAPI *glUniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); | ||
| 942 | void (OGLAPI *glUniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); | ||
| 943 | void (OGLAPI *glUniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); | ||
| 944 | |||
| 945 | } gate_gl2_api_functions_t; | ||
| 946 | |||
| 947 | static gate_gl2_api_functions_t gate_gl2_api = GATE_INIT_EMPTY; | ||
| 948 | |||
| 949 | #if defined(GATE_OPENGL_APIS_DIRECT_BINDING) | ||
| 950 | # define LOAD_NATIVE_GL2_FUNCTION(func_name, func_ptr_address) *func_ptr_address = & func_name | ||
| 951 | #else | ||
| 952 | # if defined(GATE_SYS_WIN) | ||
| 953 | static gate_result_t gate_wgl_get_function_name(gate_library_t opengl_lib_handle, char const* funcname, void* ptrfunc) | ||
| 954 | { | ||
| 955 | static PROC(WINAPI* func_wglGetProcAddress)(LPCSTR); | ||
| 956 | PROC loaded_proc = NULL; | ||
| 957 | if (func_wglGetProcAddress == NULL) | ||
| 958 | { | ||
| 959 | gate_result_t result = gate_library_get_function_name(opengl_lib_handle, "wglGetProcAddress", &func_wglGetProcAddress); | ||
| 960 | GATE_RETURN_IF_FAILED(result); | ||
| 961 | } | ||
| 962 | |||
| 963 | loaded_proc = func_wglGetProcAddress(funcname); | ||
| 964 | if (loaded_proc == NULL) | ||
| 965 | { | ||
| 966 | return GATE_RESULT_NOTAVAILABLE; | ||
| 967 | } | ||
| 968 | else | ||
| 969 | { | ||
| 970 | PROC* ptr_proc = (PROC*)ptrfunc; | ||
| 971 | *ptr_proc = loaded_proc; | ||
| 972 | return GATE_RESULT_OK; | ||
| 973 | } | ||
| 974 | } | ||
| 975 | |||
| 976 | # define LOAD_NATIVE_GL2_FUNCTION(func_name, func_ptr_address) gate_wgl_get_function_name(opengl_lib_handle, #func_name, func_ptr_address) | ||
| 977 | # else | ||
| 978 | # define LOAD_NATIVE_GL2_FUNCTION(func_name, func_ptr_address) gate_library_get_function_name(opengl_lib_handle, #func_name, func_ptr_address) | ||
| 979 | # endif | ||
| 980 | #endif | ||
| 981 | |||
| 982 | static void load_native_gl2_functions(gate_library_t opengl_lib_handle, gate_gl2_api_functions_t* ptr_code) | ||
| 983 | { | ||
| 984 | gate_gl2_api_functions_t code = GATE_INIT_EMPTY; | ||
| 985 | |||
| 986 | //LOAD_NATIVE_GL_FUNCTION(glAccum, &code.glAccum); | ||
| 987 | LOAD_NATIVE_GL2_FUNCTION(glCreateShader, &code.glCreateShader); | ||
| 988 | LOAD_NATIVE_GL2_FUNCTION(glShaderSource, &code.glShaderSource); | ||
| 989 | LOAD_NATIVE_GL2_FUNCTION(glCompileShader, &code.glCompileShader); | ||
| 990 | LOAD_NATIVE_GL2_FUNCTION(glGetShaderiv, &code.glGetShaderiv); | ||
| 991 | LOAD_NATIVE_GL2_FUNCTION(glGetShaderInfoLog, &code.glGetShaderInfoLog); | ||
| 992 | LOAD_NATIVE_GL2_FUNCTION(glDeleteShader, &code.glDeleteShader); | ||
| 993 | |||
| 994 | LOAD_NATIVE_GL2_FUNCTION(glCreateProgram, &code.glCreateProgram); | ||
| 995 | LOAD_NATIVE_GL2_FUNCTION(glLinkProgram, &code.glLinkProgram); | ||
| 996 | LOAD_NATIVE_GL2_FUNCTION(glGetProgramiv, &code.glGetProgramiv); | ||
| 997 | LOAD_NATIVE_GL2_FUNCTION(glGetProgramInfoLog, &code.glGetProgramInfoLog); | ||
| 998 | LOAD_NATIVE_GL2_FUNCTION(glUseProgram, &code.glUseProgram); | ||
| 999 | LOAD_NATIVE_GL2_FUNCTION(glAttachShader, &code.glAttachShader); | ||
| 1000 | LOAD_NATIVE_GL2_FUNCTION(glDeleteProgram, &code.glDeleteProgram); | ||
| 1001 | LOAD_NATIVE_GL2_FUNCTION(glBindAttribLocation, &code.glBindAttribLocation); | ||
| 1002 | LOAD_NATIVE_GL2_FUNCTION(glGetAttribLocation, &code.glGetAttribLocation); | ||
| 1003 | LOAD_NATIVE_GL2_FUNCTION(glGetUniformLocation, &code.glGetUniformLocation); | ||
| 1004 | |||
| 1005 | |||
| 1006 | LOAD_NATIVE_GL2_FUNCTION(glGenBuffers, &code.glGenBuffers); | ||
| 1007 | LOAD_NATIVE_GL2_FUNCTION(glDeleteBuffers, &code.glDeleteBuffers); | ||
| 1008 | LOAD_NATIVE_GL2_FUNCTION(glBindBuffer, &code.glBindBuffer); | ||
| 1009 | LOAD_NATIVE_GL2_FUNCTION(glBufferData, &code.glBufferData); | ||
| 1010 | //LOAD_NATIVE_GL2_FUNCTION(glNamedBufferData, &code.glNamedBufferData); | ||
| 1011 | LOAD_NATIVE_GL2_FUNCTION(glVertexAttribPointer, &code.glVertexAttribPointer); | ||
| 1012 | LOAD_NATIVE_GL2_FUNCTION(glEnableVertexAttribArray, &code.glEnableVertexAttribArray); | ||
| 1013 | LOAD_NATIVE_GL2_FUNCTION(glDisableVertexAttribArray, &code.glDisableVertexAttribArray); | ||
| 1014 | LOAD_NATIVE_GL2_FUNCTION(glActiveTexture, &code.glActiveTexture); | ||
| 1015 | |||
| 1016 | LOAD_NATIVE_GL2_FUNCTION(glUniform1f, &code.glUniform1f); | ||
| 1017 | LOAD_NATIVE_GL2_FUNCTION(glUniform2f, &code.glUniform2f); | ||
| 1018 | LOAD_NATIVE_GL2_FUNCTION(glUniform3f, &code.glUniform3f); | ||
| 1019 | LOAD_NATIVE_GL2_FUNCTION(glUniform4f, &code.glUniform4f); | ||
| 1020 | LOAD_NATIVE_GL2_FUNCTION(glUniform1fv, &code.glUniform1fv); | ||
| 1021 | LOAD_NATIVE_GL2_FUNCTION(glUniform2fv, &code.glUniform2fv); | ||
| 1022 | LOAD_NATIVE_GL2_FUNCTION(glUniform3fv, &code.glUniform3fv); | ||
| 1023 | LOAD_NATIVE_GL2_FUNCTION(glUniform4fv, &code.glUniform4fv); | ||
| 1024 | LOAD_NATIVE_GL2_FUNCTION(glUniform1i, &code.glUniform1i); | ||
| 1025 | LOAD_NATIVE_GL2_FUNCTION(glUniform2i, &code.glUniform2i); | ||
| 1026 | LOAD_NATIVE_GL2_FUNCTION(glUniform3i, &code.glUniform3i); | ||
| 1027 | LOAD_NATIVE_GL2_FUNCTION(glUniform4i, &code.glUniform4i); | ||
| 1028 | LOAD_NATIVE_GL2_FUNCTION(glUniform1iv, &code.glUniform1iv); | ||
| 1029 | LOAD_NATIVE_GL2_FUNCTION(glUniform2iv, &code.glUniform2iv); | ||
| 1030 | LOAD_NATIVE_GL2_FUNCTION(glUniform3iv, &code.glUniform3iv); | ||
| 1031 | LOAD_NATIVE_GL2_FUNCTION(glUniform4iv, &code.glUniform4iv); | ||
| 1032 | LOAD_NATIVE_GL2_FUNCTION(glUniformMatrix2fv, &code.glUniformMatrix2fv); | ||
| 1033 | LOAD_NATIVE_GL2_FUNCTION(glUniformMatrix3fv, &code.glUniformMatrix3fv); | ||
| 1034 | LOAD_NATIVE_GL2_FUNCTION(glUniformMatrix4fv, &code.glUniformMatrix4fv); | ||
| 1035 | |||
| 1036 | gate_mem_copy(ptr_code, &code, sizeof(gate_gl2_api_functions_t)); | ||
| 1037 | } | ||
| 1038 | |||
| 1039 | |||
| 1040 | static gate_result_t gate_gl2_api_load_functions(void) | ||
| 1041 | { | ||
| 1042 | static volatile bool opengl2_lib_loaded = false; | ||
| 1043 | static gate_library_t opengl2_lib_handle = NULL; | ||
| 1044 | gate_result_t ret = GATE_RESULT_FAILED; | ||
| 1045 | |||
| 1046 | if (opengl2_lib_loaded) | ||
| 1047 | { | ||
| 1048 | ret = GATE_RESULT_OK; | ||
| 1049 | } | ||
| 1050 | else | ||
| 1051 | { | ||
| 1052 | do | ||
| 1053 | { | ||
| 1054 | #if !defined(GATE_OPENGL_APIS_DIRECT_BINDING) | ||
| 1055 | static gate_string_t const opengl2_lib_name = GATE_STRING_INIT_STATIC(OPENGL_LIBNAME); | ||
| 1056 | static gate_string_t const opengl2_lib_name_alt = GATE_STRING_INIT_STATIC(OPENGL_LIBNAME_ALT); | ||
| 1057 | ret = gate_library_open(&opengl2_lib_name, &opengl2_lib_handle, GATE_LIBRARY_FLAG_DEFAULT); | ||
| 1058 | if (GATE_FAILED(ret)) | ||
| 1059 | { | ||
| 1060 | ret = gate_library_open(&opengl2_lib_name_alt, &opengl2_lib_handle, GATE_LIBRARY_FLAG_DEFAULT); | ||
| 1061 | } | ||
| 1062 | GATE_BREAK_IF_FAILED(ret); | ||
| 1063 | #endif | ||
| 1064 | |||
| 1065 | load_native_gl2_functions(opengl2_lib_handle, &gate_gl2_api); | ||
| 1066 | |||
| 1067 | opengl2_lib_loaded = true; | ||
| 1068 | ret = GATE_RESULT_OK; | ||
| 1069 | } while (0); | ||
| 1070 | } | ||
| 1071 | return ret; | ||
| 1072 | } | ||
| 1073 | |||
| 1074 | #endif /* GATE_GRAPHICS_OPENGL2_SUPPORT */ | ||
| 1075 | |||
| 1076 | |||
| 1077 | #endif /* GATE_GRAPHICS_PLATFORM_OPENGL_APIS_H_INCLUDED */ | ||
| 1078 |