Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 5564 | serge | 1 | /* |
| 2 | * Copyright © 2012 Intel Corporation |
||
| 3 | * |
||
| 4 | * Permission is hereby granted, free of charge, to any person obtaining a |
||
| 5 | * copy of this software and associated documentation files (the "Software"), |
||
| 6 | * to deal in the Software without restriction, including without limitation |
||
| 7 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||
| 8 | * and/or sell copies of the Software, and to permit persons to whom the |
||
| 9 | * Software is furnished to do so, subject to the following conditions: |
||
| 10 | * |
||
| 11 | * The above copyright notice and this permission notice (including the next |
||
| 12 | * paragraph) shall be included in all copies or substantial portions of the |
||
| 13 | * Software. |
||
| 14 | * |
||
| 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||
| 16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||
| 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||
| 18 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||
| 19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
||
| 20 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||
| 21 | * DEALINGS IN THE SOFTWARE. |
||
| 22 | */ |
||
| 23 | |||
| 24 | #include |
||
| 25 | #include "../mesa/main/glheader.h" |
||
| 26 | |||
| 27 | extern "C" { |
||
| 28 | #include "glapi/glapi.h" |
||
| 29 | #include "glapi/glapitable.h" |
||
| 30 | } |
||
| 31 | |||
| 32 | struct name_offset { |
||
| 33 | const char *name; |
||
| 34 | int offset; |
||
| 35 | }; |
||
| 36 | |||
| 37 | extern const struct name_offset linux_gl_abi[]; |
||
| 38 | extern const struct name_offset known_dispatch[]; |
||
| 39 | |||
| 40 | TEST(GetProcAddress, ABIOffsetByName) |
||
| 41 | { |
||
| 42 | /* 408 functions have had their locations in the dispatch table set since |
||
| 43 | * the dawn of time. Verify that all of these functions are at the correct |
||
| 44 | * locations. |
||
| 45 | */ |
||
| 46 | for (unsigned i = 0; linux_gl_abi[i].name != NULL; i++) { |
||
| 47 | EXPECT_EQ(linux_gl_abi[i].offset, |
||
| 48 | _glapi_get_proc_offset(linux_gl_abi[i].name)) |
||
| 49 | << "function name: " << linux_gl_abi[i].name; |
||
| 50 | } |
||
| 51 | } |
||
| 52 | |||
| 53 | TEST(GetProcAddress, ABINameByOffset) |
||
| 54 | { |
||
| 55 | /* 408 functions have had their locations in the dispatch table set since |
||
| 56 | * the dawn of time. Verify that all of these functions are at the correct |
||
| 57 | * locations. |
||
| 58 | */ |
||
| 59 | for (unsigned i = 0; linux_gl_abi[i].name != NULL; i++) { |
||
| 60 | EXPECT_STREQ(linux_gl_abi[i].name, |
||
| 61 | _glapi_get_proc_name(linux_gl_abi[i].offset)) |
||
| 62 | << "function offset: " << linux_gl_abi[i].offset; |
||
| 63 | } |
||
| 64 | } |
||
| 65 | |||
| 66 | TEST(GetProcAddress, TableBigEnoughForABI) |
||
| 67 | { |
||
| 68 | const unsigned table_entries = sizeof(struct _glapi_table) / sizeof(void *); |
||
| 69 | |||
| 70 | EXPECT_GE(table_entries, 408u); |
||
| 71 | } |
||
| 72 | |||
| 73 | TEST(GetProcAddress, TableDidntShrink) |
||
| 74 | { |
||
| 75 | const unsigned table_entries = sizeof(struct _glapi_table) / sizeof(void *); |
||
| 76 | |||
| 77 | /* The dispatch table is not expected to shrink. At GIT commit b45052b the |
||
| 78 | * table had 978 entries. Changes that intentionally reduce the size of |
||
| 79 | * the table are very rare. In those cases, the expected value should be |
||
| 80 | * updated to reflect the change. |
||
| 81 | * |
||
| 82 | * Changes that accidentally reduce the size of the table are bugs, and |
||
| 83 | * they should be fixed. |
||
| 84 | * |
||
| 85 | * 6 entries were removed when GL_SGIS_pixel_texture was removed from the |
||
| 86 | * dispatch table. |
||
| 87 | * |
||
| 88 | * 1 entry was removed when GL_SGIX_pixel_texture was removed from the |
||
| 89 | * dispatch table. |
||
| 90 | * |
||
| 91 | * 2 entries were removed when GL_APPLE_texture_range was removed from the |
||
| 92 | * dispatch table. |
||
| 93 | * |
||
| 94 | * 13 entries were removed when GL_NV_register_combiners was removed from |
||
| 95 | * the dispatch table. |
||
| 96 | * |
||
| 97 | * 7 entries were removed when GL_NV_fence was removed from the dispatch |
||
| 98 | * table. |
||
| 99 | * |
||
| 100 | * 2 entries were removed when GL_NV_vertex_array_range was removed from |
||
| 101 | * the dispatch table. |
||
| 102 | */ |
||
| 103 | EXPECT_GE(table_entries, 978u - 6u - 1u - 2u - 13u - 7u - 2u); |
||
| 104 | } |
||
| 105 | |||
| 106 | TEST(GetProcAddress, QueriedDispatchSizeBigEnough) |
||
| 107 | { |
||
| 108 | const unsigned table_entries = sizeof(struct _glapi_table) / sizeof(void *); |
||
| 109 | |||
| 110 | /* _glapi_get_dispatch_table_size returns the size of the extended dispatch |
||
| 111 | * table. This is the size of the static table with some extra entries for |
||
| 112 | * drivers to use for extensions that the core does not know about. |
||
| 113 | */ |
||
| 114 | EXPECT_LT(table_entries, _glapi_get_dispatch_table_size()); |
||
| 115 | } |
||
| 116 | |||
| 117 | TEST(GetProcAddress, KnownDispatchOffsetsAreConsistent) |
||
| 118 | { |
||
| 119 | /* Verify that the queried dispatch offset for every known function is |
||
| 120 | * consistent with its location in the static dispatch table. |
||
| 121 | * |
||
| 122 | * There is some redundancy between this test and ABIOffsetByName. That's |
||
| 123 | * okay. The offsets in ABIOffsetByName comdirectly from the ABI |
||
| 124 | * definition. The offsets in this test come from locations in a structure |
||
| 125 | * definition generated by scripts. |
||
| 126 | */ |
||
| 127 | for (unsigned i = 0; known_dispatch[i].name != NULL; i++) { |
||
| 128 | EXPECT_EQ(known_dispatch[i].offset, |
||
| 129 | _glapi_get_proc_offset(known_dispatch[i].name)) |
||
| 130 | << "function name: " << known_dispatch[i].name; |
||
| 131 | } |
||
| 132 | } |
||
| 133 | |||
| 134 | TEST(GetProcAddress, KnownDispatchNamesAreConsistent) |
||
| 135 | { |
||
| 136 | /* Verify that the queried dispatch name for every known function is |
||
| 137 | * consistent with its location in the static dispatch table. |
||
| 138 | * |
||
| 139 | * There is some redundancy between this test and ABINameByOffset. That's |
||
| 140 | * okay. The offsets in ABIOffsetByName comdirectly from the ABI |
||
| 141 | * definition. The offsets in this test come from locations in a structure |
||
| 142 | * definition generated by scripts. |
||
| 143 | */ |
||
| 144 | for (unsigned i = 0; known_dispatch[i].name != NULL; i++) { |
||
| 145 | EXPECT_STREQ(known_dispatch[i].name, |
||
| 146 | _glapi_get_proc_name(known_dispatch[i].offset)) |
||
| 147 | << "function offset: " << known_dispatch[i].offset; |
||
| 148 | } |
||
| 149 | } |
||
| 150 | |||
| 151 | const struct name_offset linux_gl_abi[] = { |
||
| 152 | { "glNewList", 0 }, |
||
| 153 | { "glEndList", 1 }, |
||
| 154 | { "glCallList", 2 }, |
||
| 155 | { "glCallLists", 3 }, |
||
| 156 | { "glDeleteLists", 4 }, |
||
| 157 | { "glGenLists", 5 }, |
||
| 158 | { "glListBase", 6 }, |
||
| 159 | { "glBegin", 7 }, |
||
| 160 | { "glBitmap", 8 }, |
||
| 161 | { "glColor3b", 9 }, |
||
| 162 | { "glColor3bv", 10 }, |
||
| 163 | { "glColor3d", 11 }, |
||
| 164 | { "glColor3dv", 12 }, |
||
| 165 | { "glColor3f", 13 }, |
||
| 166 | { "glColor3fv", 14 }, |
||
| 167 | { "glColor3i", 15 }, |
||
| 168 | { "glColor3iv", 16 }, |
||
| 169 | { "glColor3s", 17 }, |
||
| 170 | { "glColor3sv", 18 }, |
||
| 171 | { "glColor3ub", 19 }, |
||
| 172 | { "glColor3ubv", 20 }, |
||
| 173 | { "glColor3ui", 21 }, |
||
| 174 | { "glColor3uiv", 22 }, |
||
| 175 | { "glColor3us", 23 }, |
||
| 176 | { "glColor3usv", 24 }, |
||
| 177 | { "glColor4b", 25 }, |
||
| 178 | { "glColor4bv", 26 }, |
||
| 179 | { "glColor4d", 27 }, |
||
| 180 | { "glColor4dv", 28 }, |
||
| 181 | { "glColor4f", 29 }, |
||
| 182 | { "glColor4fv", 30 }, |
||
| 183 | { "glColor4i", 31 }, |
||
| 184 | { "glColor4iv", 32 }, |
||
| 185 | { "glColor4s", 33 }, |
||
| 186 | { "glColor4sv", 34 }, |
||
| 187 | { "glColor4ub", 35 }, |
||
| 188 | { "glColor4ubv", 36 }, |
||
| 189 | { "glColor4ui", 37 }, |
||
| 190 | { "glColor4uiv", 38 }, |
||
| 191 | { "glColor4us", 39 }, |
||
| 192 | { "glColor4usv", 40 }, |
||
| 193 | { "glEdgeFlag", 41 }, |
||
| 194 | { "glEdgeFlagv", 42 }, |
||
| 195 | { "glEnd", 43 }, |
||
| 196 | { "glIndexd", 44 }, |
||
| 197 | { "glIndexdv", 45 }, |
||
| 198 | { "glIndexf", 46 }, |
||
| 199 | { "glIndexfv", 47 }, |
||
| 200 | { "glIndexi", 48 }, |
||
| 201 | { "glIndexiv", 49 }, |
||
| 202 | { "glIndexs", 50 }, |
||
| 203 | { "glIndexsv", 51 }, |
||
| 204 | { "glNormal3b", 52 }, |
||
| 205 | { "glNormal3bv", 53 }, |
||
| 206 | { "glNormal3d", 54 }, |
||
| 207 | { "glNormal3dv", 55 }, |
||
| 208 | { "glNormal3f", 56 }, |
||
| 209 | { "glNormal3fv", 57 }, |
||
| 210 | { "glNormal3i", 58 }, |
||
| 211 | { "glNormal3iv", 59 }, |
||
| 212 | { "glNormal3s", 60 }, |
||
| 213 | { "glNormal3sv", 61 }, |
||
| 214 | { "glRasterPos2d", 62 }, |
||
| 215 | { "glRasterPos2dv", 63 }, |
||
| 216 | { "glRasterPos2f", 64 }, |
||
| 217 | { "glRasterPos2fv", 65 }, |
||
| 218 | { "glRasterPos2i", 66 }, |
||
| 219 | { "glRasterPos2iv", 67 }, |
||
| 220 | { "glRasterPos2s", 68 }, |
||
| 221 | { "glRasterPos2sv", 69 }, |
||
| 222 | { "glRasterPos3d", 70 }, |
||
| 223 | { "glRasterPos3dv", 71 }, |
||
| 224 | { "glRasterPos3f", 72 }, |
||
| 225 | { "glRasterPos3fv", 73 }, |
||
| 226 | { "glRasterPos3i", 74 }, |
||
| 227 | { "glRasterPos3iv", 75 }, |
||
| 228 | { "glRasterPos3s", 76 }, |
||
| 229 | { "glRasterPos3sv", 77 }, |
||
| 230 | { "glRasterPos4d", 78 }, |
||
| 231 | { "glRasterPos4dv", 79 }, |
||
| 232 | { "glRasterPos4f", 80 }, |
||
| 233 | { "glRasterPos4fv", 81 }, |
||
| 234 | { "glRasterPos4i", 82 }, |
||
| 235 | { "glRasterPos4iv", 83 }, |
||
| 236 | { "glRasterPos4s", 84 }, |
||
| 237 | { "glRasterPos4sv", 85 }, |
||
| 238 | { "glRectd", 86 }, |
||
| 239 | { "glRectdv", 87 }, |
||
| 240 | { "glRectf", 88 }, |
||
| 241 | { "glRectfv", 89 }, |
||
| 242 | { "glRecti", 90 }, |
||
| 243 | { "glRectiv", 91 }, |
||
| 244 | { "glRects", 92 }, |
||
| 245 | { "glRectsv", 93 }, |
||
| 246 | { "glTexCoord1d", 94 }, |
||
| 247 | { "glTexCoord1dv", 95 }, |
||
| 248 | { "glTexCoord1f", 96 }, |
||
| 249 | { "glTexCoord1fv", 97 }, |
||
| 250 | { "glTexCoord1i", 98 }, |
||
| 251 | { "glTexCoord1iv", 99 }, |
||
| 252 | { "glTexCoord1s", 100 }, |
||
| 253 | { "glTexCoord1sv", 101 }, |
||
| 254 | { "glTexCoord2d", 102 }, |
||
| 255 | { "glTexCoord2dv", 103 }, |
||
| 256 | { "glTexCoord2f", 104 }, |
||
| 257 | { "glTexCoord2fv", 105 }, |
||
| 258 | { "glTexCoord2i", 106 }, |
||
| 259 | { "glTexCoord2iv", 107 }, |
||
| 260 | { "glTexCoord2s", 108 }, |
||
| 261 | { "glTexCoord2sv", 109 }, |
||
| 262 | { "glTexCoord3d", 110 }, |
||
| 263 | { "glTexCoord3dv", 111 }, |
||
| 264 | { "glTexCoord3f", 112 }, |
||
| 265 | { "glTexCoord3fv", 113 }, |
||
| 266 | { "glTexCoord3i", 114 }, |
||
| 267 | { "glTexCoord3iv", 115 }, |
||
| 268 | { "glTexCoord3s", 116 }, |
||
| 269 | { "glTexCoord3sv", 117 }, |
||
| 270 | { "glTexCoord4d", 118 }, |
||
| 271 | { "glTexCoord4dv", 119 }, |
||
| 272 | { "glTexCoord4f", 120 }, |
||
| 273 | { "glTexCoord4fv", 121 }, |
||
| 274 | { "glTexCoord4i", 122 }, |
||
| 275 | { "glTexCoord4iv", 123 }, |
||
| 276 | { "glTexCoord4s", 124 }, |
||
| 277 | { "glTexCoord4sv", 125 }, |
||
| 278 | { "glVertex2d", 126 }, |
||
| 279 | { "glVertex2dv", 127 }, |
||
| 280 | { "glVertex2f", 128 }, |
||
| 281 | { "glVertex2fv", 129 }, |
||
| 282 | { "glVertex2i", 130 }, |
||
| 283 | { "glVertex2iv", 131 }, |
||
| 284 | { "glVertex2s", 132 }, |
||
| 285 | { "glVertex2sv", 133 }, |
||
| 286 | { "glVertex3d", 134 }, |
||
| 287 | { "glVertex3dv", 135 }, |
||
| 288 | { "glVertex3f", 136 }, |
||
| 289 | { "glVertex3fv", 137 }, |
||
| 290 | { "glVertex3i", 138 }, |
||
| 291 | { "glVertex3iv", 139 }, |
||
| 292 | { "glVertex3s", 140 }, |
||
| 293 | { "glVertex3sv", 141 }, |
||
| 294 | { "glVertex4d", 142 }, |
||
| 295 | { "glVertex4dv", 143 }, |
||
| 296 | { "glVertex4f", 144 }, |
||
| 297 | { "glVertex4fv", 145 }, |
||
| 298 | { "glVertex4i", 146 }, |
||
| 299 | { "glVertex4iv", 147 }, |
||
| 300 | { "glVertex4s", 148 }, |
||
| 301 | { "glVertex4sv", 149 }, |
||
| 302 | { "glClipPlane", 150 }, |
||
| 303 | { "glColorMaterial", 151 }, |
||
| 304 | { "glCullFace", 152 }, |
||
| 305 | { "glFogf", 153 }, |
||
| 306 | { "glFogfv", 154 }, |
||
| 307 | { "glFogi", 155 }, |
||
| 308 | { "glFogiv", 156 }, |
||
| 309 | { "glFrontFace", 157 }, |
||
| 310 | { "glHint", 158 }, |
||
| 311 | { "glLightf", 159 }, |
||
| 312 | { "glLightfv", 160 }, |
||
| 313 | { "glLighti", 161 }, |
||
| 314 | { "glLightiv", 162 }, |
||
| 315 | { "glLightModelf", 163 }, |
||
| 316 | { "glLightModelfv", 164 }, |
||
| 317 | { "glLightModeli", 165 }, |
||
| 318 | { "glLightModeliv", 166 }, |
||
| 319 | { "glLineStipple", 167 }, |
||
| 320 | { "glLineWidth", 168 }, |
||
| 321 | { "glMaterialf", 169 }, |
||
| 322 | { "glMaterialfv", 170 }, |
||
| 323 | { "glMateriali", 171 }, |
||
| 324 | { "glMaterialiv", 172 }, |
||
| 325 | { "glPointSize", 173 }, |
||
| 326 | { "glPolygonMode", 174 }, |
||
| 327 | { "glPolygonStipple", 175 }, |
||
| 328 | { "glScissor", 176 }, |
||
| 329 | { "glShadeModel", 177 }, |
||
| 330 | { "glTexParameterf", 178 }, |
||
| 331 | { "glTexParameterfv", 179 }, |
||
| 332 | { "glTexParameteri", 180 }, |
||
| 333 | { "glTexParameteriv", 181 }, |
||
| 334 | { "glTexImage1D", 182 }, |
||
| 335 | { "glTexImage2D", 183 }, |
||
| 336 | { "glTexEnvf", 184 }, |
||
| 337 | { "glTexEnvfv", 185 }, |
||
| 338 | { "glTexEnvi", 186 }, |
||
| 339 | { "glTexEnviv", 187 }, |
||
| 340 | { "glTexGend", 188 }, |
||
| 341 | { "glTexGendv", 189 }, |
||
| 342 | { "glTexGenf", 190 }, |
||
| 343 | { "glTexGenfv", 191 }, |
||
| 344 | { "glTexGeni", 192 }, |
||
| 345 | { "glTexGeniv", 193 }, |
||
| 346 | { "glFeedbackBuffer", 194 }, |
||
| 347 | { "glSelectBuffer", 195 }, |
||
| 348 | { "glRenderMode", 196 }, |
||
| 349 | { "glInitNames", 197 }, |
||
| 350 | { "glLoadName", 198 }, |
||
| 351 | { "glPassThrough", 199 }, |
||
| 352 | { "glPopName", 200 }, |
||
| 353 | { "glPushName", 201 }, |
||
| 354 | { "glDrawBuffer", 202 }, |
||
| 355 | { "glClear", 203 }, |
||
| 356 | { "glClearAccum", 204 }, |
||
| 357 | { "glClearIndex", 205 }, |
||
| 358 | { "glClearColor", 206 }, |
||
| 359 | { "glClearStencil", 207 }, |
||
| 360 | { "glClearDepth", 208 }, |
||
| 361 | { "glStencilMask", 209 }, |
||
| 362 | { "glColorMask", 210 }, |
||
| 363 | { "glDepthMask", 211 }, |
||
| 364 | { "glIndexMask", 212 }, |
||
| 365 | { "glAccum", 213 }, |
||
| 366 | { "glDisable", 214 }, |
||
| 367 | { "glEnable", 215 }, |
||
| 368 | { "glFinish", 216 }, |
||
| 369 | { "glFlush", 217 }, |
||
| 370 | { "glPopAttrib", 218 }, |
||
| 371 | { "glPushAttrib", 219 }, |
||
| 372 | { "glMap1d", 220 }, |
||
| 373 | { "glMap1f", 221 }, |
||
| 374 | { "glMap2d", 222 }, |
||
| 375 | { "glMap2f", 223 }, |
||
| 376 | { "glMapGrid1d", 224 }, |
||
| 377 | { "glMapGrid1f", 225 }, |
||
| 378 | { "glMapGrid2d", 226 }, |
||
| 379 | { "glMapGrid2f", 227 }, |
||
| 380 | { "glEvalCoord1d", 228 }, |
||
| 381 | { "glEvalCoord1dv", 229 }, |
||
| 382 | { "glEvalCoord1f", 230 }, |
||
| 383 | { "glEvalCoord1fv", 231 }, |
||
| 384 | { "glEvalCoord2d", 232 }, |
||
| 385 | { "glEvalCoord2dv", 233 }, |
||
| 386 | { "glEvalCoord2f", 234 }, |
||
| 387 | { "glEvalCoord2fv", 235 }, |
||
| 388 | { "glEvalMesh1", 236 }, |
||
| 389 | { "glEvalPoint1", 237 }, |
||
| 390 | { "glEvalMesh2", 238 }, |
||
| 391 | { "glEvalPoint2", 239 }, |
||
| 392 | { "glAlphaFunc", 240 }, |
||
| 393 | { "glBlendFunc", 241 }, |
||
| 394 | { "glLogicOp", 242 }, |
||
| 395 | { "glStencilFunc", 243 }, |
||
| 396 | { "glStencilOp", 244 }, |
||
| 397 | { "glDepthFunc", 245 }, |
||
| 398 | { "glPixelZoom", 246 }, |
||
| 399 | { "glPixelTransferf", 247 }, |
||
| 400 | { "glPixelTransferi", 248 }, |
||
| 401 | { "glPixelStoref", 249 }, |
||
| 402 | { "glPixelStorei", 250 }, |
||
| 403 | { "glPixelMapfv", 251 }, |
||
| 404 | { "glPixelMapuiv", 252 }, |
||
| 405 | { "glPixelMapusv", 253 }, |
||
| 406 | { "glReadBuffer", 254 }, |
||
| 407 | { "glCopyPixels", 255 }, |
||
| 408 | { "glReadPixels", 256 }, |
||
| 409 | { "glDrawPixels", 257 }, |
||
| 410 | { "glGetBooleanv", 258 }, |
||
| 411 | { "glGetClipPlane", 259 }, |
||
| 412 | { "glGetDoublev", 260 }, |
||
| 413 | { "glGetError", 261 }, |
||
| 414 | { "glGetFloatv", 262 }, |
||
| 415 | { "glGetIntegerv", 263 }, |
||
| 416 | { "glGetLightfv", 264 }, |
||
| 417 | { "glGetLightiv", 265 }, |
||
| 418 | { "glGetMapdv", 266 }, |
||
| 419 | { "glGetMapfv", 267 }, |
||
| 420 | { "glGetMapiv", 268 }, |
||
| 421 | { "glGetMaterialfv", 269 }, |
||
| 422 | { "glGetMaterialiv", 270 }, |
||
| 423 | { "glGetPixelMapfv", 271 }, |
||
| 424 | { "glGetPixelMapuiv", 272 }, |
||
| 425 | { "glGetPixelMapusv", 273 }, |
||
| 426 | { "glGetPolygonStipple", 274 }, |
||
| 427 | { "glGetString", 275 }, |
||
| 428 | { "glGetTexEnvfv", 276 }, |
||
| 429 | { "glGetTexEnviv", 277 }, |
||
| 430 | { "glGetTexGendv", 278 }, |
||
| 431 | { "glGetTexGenfv", 279 }, |
||
| 432 | { "glGetTexGeniv", 280 }, |
||
| 433 | { "glGetTexImage", 281 }, |
||
| 434 | { "glGetTexParameterfv", 282 }, |
||
| 435 | { "glGetTexParameteriv", 283 }, |
||
| 436 | { "glGetTexLevelParameterfv", 284 }, |
||
| 437 | { "glGetTexLevelParameteriv", 285 }, |
||
| 438 | { "glIsEnabled", 286 }, |
||
| 439 | { "glIsList", 287 }, |
||
| 440 | { "glDepthRange", 288 }, |
||
| 441 | { "glFrustum", 289 }, |
||
| 442 | { "glLoadIdentity", 290 }, |
||
| 443 | { "glLoadMatrixf", 291 }, |
||
| 444 | { "glLoadMatrixd", 292 }, |
||
| 445 | { "glMatrixMode", 293 }, |
||
| 446 | { "glMultMatrixf", 294 }, |
||
| 447 | { "glMultMatrixd", 295 }, |
||
| 448 | { "glOrtho", 296 }, |
||
| 449 | { "glPopMatrix", 297 }, |
||
| 450 | { "glPushMatrix", 298 }, |
||
| 451 | { "glRotated", 299 }, |
||
| 452 | { "glRotatef", 300 }, |
||
| 453 | { "glScaled", 301 }, |
||
| 454 | { "glScalef", 302 }, |
||
| 455 | { "glTranslated", 303 }, |
||
| 456 | { "glTranslatef", 304 }, |
||
| 457 | { "glViewport", 305 }, |
||
| 458 | { "glArrayElement", 306 }, |
||
| 459 | { "glColorPointer", 308 }, |
||
| 460 | { "glDisableClientState", 309 }, |
||
| 461 | { "glDrawArrays", 310 }, |
||
| 462 | { "glDrawElements", 311 }, |
||
| 463 | { "glEdgeFlagPointer", 312 }, |
||
| 464 | { "glEnableClientState", 313 }, |
||
| 465 | { "glGetPointerv", 329 }, |
||
| 466 | { "glIndexPointer", 314 }, |
||
| 467 | { "glInterleavedArrays", 317 }, |
||
| 468 | { "glNormalPointer", 318 }, |
||
| 469 | { "glTexCoordPointer", 320 }, |
||
| 470 | { "glVertexPointer", 321 }, |
||
| 471 | { "glPolygonOffset", 319 }, |
||
| 472 | { "glCopyTexImage1D", 323 }, |
||
| 473 | { "glCopyTexImage2D", 324 }, |
||
| 474 | { "glCopyTexSubImage1D", 325 }, |
||
| 475 | { "glCopyTexSubImage2D", 326 }, |
||
| 476 | { "glTexSubImage1D", 332 }, |
||
| 477 | { "glTexSubImage2D", 333 }, |
||
| 478 | { "glAreTexturesResident", 322 }, |
||
| 479 | { "glBindTexture", 307 }, |
||
| 480 | { "glDeleteTextures", 327 }, |
||
| 481 | { "glGenTextures", 328 }, |
||
| 482 | { "glIsTexture", 330 }, |
||
| 483 | { "glPrioritizeTextures", 331 }, |
||
| 484 | { "glIndexub", 315 }, |
||
| 485 | { "glIndexubv", 316 }, |
||
| 486 | { "glPopClientAttrib", 334 }, |
||
| 487 | { "glPushClientAttrib", 335 }, |
||
| 488 | { "glBlendColor", 336 }, |
||
| 489 | { "glBlendEquation", 337 }, |
||
| 490 | { "glDrawRangeElements", 338 }, |
||
| 491 | { "glColorTable", 339 }, |
||
| 492 | { "glColorTableParameterfv", 340 }, |
||
| 493 | { "glColorTableParameteriv", 341 }, |
||
| 494 | { "glCopyColorTable", 342 }, |
||
| 495 | { "glGetColorTable", 343 }, |
||
| 496 | { "glGetColorTableParameterfv", 344 }, |
||
| 497 | { "glGetColorTableParameteriv", 345 }, |
||
| 498 | { "glColorSubTable", 346 }, |
||
| 499 | { "glCopyColorSubTable", 347 }, |
||
| 500 | { "glConvolutionFilter1D", 348 }, |
||
| 501 | { "glConvolutionFilter2D", 349 }, |
||
| 502 | { "glConvolutionParameterf", 350 }, |
||
| 503 | { "glConvolutionParameterfv", 351 }, |
||
| 504 | { "glConvolutionParameteri", 352 }, |
||
| 505 | { "glConvolutionParameteriv", 353 }, |
||
| 506 | { "glCopyConvolutionFilter1D", 354 }, |
||
| 507 | { "glCopyConvolutionFilter2D", 355 }, |
||
| 508 | { "glGetConvolutionFilter", 356 }, |
||
| 509 | { "glGetConvolutionParameterfv", 357 }, |
||
| 510 | { "glGetConvolutionParameteriv", 358 }, |
||
| 511 | { "glGetSeparableFilter", 359 }, |
||
| 512 | { "glSeparableFilter2D", 360 }, |
||
| 513 | { "glGetHistogram", 361 }, |
||
| 514 | { "glGetHistogramParameterfv", 362 }, |
||
| 515 | { "glGetHistogramParameteriv", 363 }, |
||
| 516 | { "glGetMinmax", 364 }, |
||
| 517 | { "glGetMinmaxParameterfv", 365 }, |
||
| 518 | { "glGetMinmaxParameteriv", 366 }, |
||
| 519 | { "glHistogram", 367 }, |
||
| 520 | { "glMinmax", 368 }, |
||
| 521 | { "glResetHistogram", 369 }, |
||
| 522 | { "glResetMinmax", 370 }, |
||
| 523 | { "glTexImage3D", 371 }, |
||
| 524 | { "glTexSubImage3D", 372 }, |
||
| 525 | { "glCopyTexSubImage3D", 373 }, |
||
| 526 | { "glActiveTexture", 374 }, |
||
| 527 | { "glClientActiveTexture", 375 }, |
||
| 528 | { "glMultiTexCoord1d", 376 }, |
||
| 529 | { "glMultiTexCoord1dv", 377 }, |
||
| 530 | { "glMultiTexCoord1fARB", 378 }, |
||
| 531 | { "glMultiTexCoord1fvARB", 379 }, |
||
| 532 | { "glMultiTexCoord1i", 380 }, |
||
| 533 | { "glMultiTexCoord1iv", 381 }, |
||
| 534 | { "glMultiTexCoord1s", 382 }, |
||
| 535 | { "glMultiTexCoord1sv", 383 }, |
||
| 536 | { "glMultiTexCoord2d", 384 }, |
||
| 537 | { "glMultiTexCoord2dv", 385 }, |
||
| 538 | { "glMultiTexCoord2fARB", 386 }, |
||
| 539 | { "glMultiTexCoord2fvARB", 387 }, |
||
| 540 | { "glMultiTexCoord2i", 388 }, |
||
| 541 | { "glMultiTexCoord2iv", 389 }, |
||
| 542 | { "glMultiTexCoord2s", 390 }, |
||
| 543 | { "glMultiTexCoord2sv", 391 }, |
||
| 544 | { "glMultiTexCoord3d", 392 }, |
||
| 545 | { "glMultiTexCoord3dv", 393 }, |
||
| 546 | { "glMultiTexCoord3fARB", 394 }, |
||
| 547 | { "glMultiTexCoord3fvARB", 395 }, |
||
| 548 | { "glMultiTexCoord3i", 396 }, |
||
| 549 | { "glMultiTexCoord3iv", 397 }, |
||
| 550 | { "glMultiTexCoord3s", 398 }, |
||
| 551 | { "glMultiTexCoord3sv", 399 }, |
||
| 552 | { "glMultiTexCoord4d", 400 }, |
||
| 553 | { "glMultiTexCoord4dv", 401 }, |
||
| 554 | { "glMultiTexCoord4fARB", 402 }, |
||
| 555 | { "glMultiTexCoord4fvARB", 403 }, |
||
| 556 | { "glMultiTexCoord4i", 404 }, |
||
| 557 | { "glMultiTexCoord4iv", 405 }, |
||
| 558 | { "glMultiTexCoord4s", 406 }, |
||
| 559 | { "glMultiTexCoord4sv", 407 }, |
||
| 560 | { NULL, 0 } |
||
| 561 | }; |
||
| 562 | |||
| 563 | #define _O(f) ((intptr_t) & (((struct _glapi_table *) 0)->f)) / sizeof(void *) |
||
| 564 | |||
| 565 | const struct name_offset known_dispatch[] = { |
||
| 566 | { "glNewList", _O(NewList) }, |
||
| 567 | { "glEndList", _O(EndList) }, |
||
| 568 | { "glCallList", _O(CallList) }, |
||
| 569 | { "glCallLists", _O(CallLists) }, |
||
| 570 | { "glDeleteLists", _O(DeleteLists) }, |
||
| 571 | { "glGenLists", _O(GenLists) }, |
||
| 572 | { "glListBase", _O(ListBase) }, |
||
| 573 | { "glBegin", _O(Begin) }, |
||
| 574 | { "glBitmap", _O(Bitmap) }, |
||
| 575 | { "glColor3b", _O(Color3b) }, |
||
| 576 | { "glColor3bv", _O(Color3bv) }, |
||
| 577 | { "glColor3d", _O(Color3d) }, |
||
| 578 | { "glColor3dv", _O(Color3dv) }, |
||
| 579 | { "glColor3f", _O(Color3f) }, |
||
| 580 | { "glColor3fv", _O(Color3fv) }, |
||
| 581 | { "glColor3i", _O(Color3i) }, |
||
| 582 | { "glColor3iv", _O(Color3iv) }, |
||
| 583 | { "glColor3s", _O(Color3s) }, |
||
| 584 | { "glColor3sv", _O(Color3sv) }, |
||
| 585 | { "glColor3ub", _O(Color3ub) }, |
||
| 586 | { "glColor3ubv", _O(Color3ubv) }, |
||
| 587 | { "glColor3ui", _O(Color3ui) }, |
||
| 588 | { "glColor3uiv", _O(Color3uiv) }, |
||
| 589 | { "glColor3us", _O(Color3us) }, |
||
| 590 | { "glColor3usv", _O(Color3usv) }, |
||
| 591 | { "glColor4b", _O(Color4b) }, |
||
| 592 | { "glColor4bv", _O(Color4bv) }, |
||
| 593 | { "glColor4d", _O(Color4d) }, |
||
| 594 | { "glColor4dv", _O(Color4dv) }, |
||
| 595 | { "glColor4f", _O(Color4f) }, |
||
| 596 | { "glColor4fv", _O(Color4fv) }, |
||
| 597 | { "glColor4i", _O(Color4i) }, |
||
| 598 | { "glColor4iv", _O(Color4iv) }, |
||
| 599 | { "glColor4s", _O(Color4s) }, |
||
| 600 | { "glColor4sv", _O(Color4sv) }, |
||
| 601 | { "glColor4ub", _O(Color4ub) }, |
||
| 602 | { "glColor4ubv", _O(Color4ubv) }, |
||
| 603 | { "glColor4ui", _O(Color4ui) }, |
||
| 604 | { "glColor4uiv", _O(Color4uiv) }, |
||
| 605 | { "glColor4us", _O(Color4us) }, |
||
| 606 | { "glColor4usv", _O(Color4usv) }, |
||
| 607 | { "glEdgeFlag", _O(EdgeFlag) }, |
||
| 608 | { "glEdgeFlagv", _O(EdgeFlagv) }, |
||
| 609 | { "glEnd", _O(End) }, |
||
| 610 | { "glIndexd", _O(Indexd) }, |
||
| 611 | { "glIndexdv", _O(Indexdv) }, |
||
| 612 | { "glIndexf", _O(Indexf) }, |
||
| 613 | { "glIndexfv", _O(Indexfv) }, |
||
| 614 | { "glIndexi", _O(Indexi) }, |
||
| 615 | { "glIndexiv", _O(Indexiv) }, |
||
| 616 | { "glIndexs", _O(Indexs) }, |
||
| 617 | { "glIndexsv", _O(Indexsv) }, |
||
| 618 | { "glNormal3b", _O(Normal3b) }, |
||
| 619 | { "glNormal3bv", _O(Normal3bv) }, |
||
| 620 | { "glNormal3d", _O(Normal3d) }, |
||
| 621 | { "glNormal3dv", _O(Normal3dv) }, |
||
| 622 | { "glNormal3f", _O(Normal3f) }, |
||
| 623 | { "glNormal3fv", _O(Normal3fv) }, |
||
| 624 | { "glNormal3i", _O(Normal3i) }, |
||
| 625 | { "glNormal3iv", _O(Normal3iv) }, |
||
| 626 | { "glNormal3s", _O(Normal3s) }, |
||
| 627 | { "glNormal3sv", _O(Normal3sv) }, |
||
| 628 | { "glRasterPos2d", _O(RasterPos2d) }, |
||
| 629 | { "glRasterPos2dv", _O(RasterPos2dv) }, |
||
| 630 | { "glRasterPos2f", _O(RasterPos2f) }, |
||
| 631 | { "glRasterPos2fv", _O(RasterPos2fv) }, |
||
| 632 | { "glRasterPos2i", _O(RasterPos2i) }, |
||
| 633 | { "glRasterPos2iv", _O(RasterPos2iv) }, |
||
| 634 | { "glRasterPos2s", _O(RasterPos2s) }, |
||
| 635 | { "glRasterPos2sv", _O(RasterPos2sv) }, |
||
| 636 | { "glRasterPos3d", _O(RasterPos3d) }, |
||
| 637 | { "glRasterPos3dv", _O(RasterPos3dv) }, |
||
| 638 | { "glRasterPos3f", _O(RasterPos3f) }, |
||
| 639 | { "glRasterPos3fv", _O(RasterPos3fv) }, |
||
| 640 | { "glRasterPos3i", _O(RasterPos3i) }, |
||
| 641 | { "glRasterPos3iv", _O(RasterPos3iv) }, |
||
| 642 | { "glRasterPos3s", _O(RasterPos3s) }, |
||
| 643 | { "glRasterPos3sv", _O(RasterPos3sv) }, |
||
| 644 | { "glRasterPos4d", _O(RasterPos4d) }, |
||
| 645 | { "glRasterPos4dv", _O(RasterPos4dv) }, |
||
| 646 | { "glRasterPos4f", _O(RasterPos4f) }, |
||
| 647 | { "glRasterPos4fv", _O(RasterPos4fv) }, |
||
| 648 | { "glRasterPos4i", _O(RasterPos4i) }, |
||
| 649 | { "glRasterPos4iv", _O(RasterPos4iv) }, |
||
| 650 | { "glRasterPos4s", _O(RasterPos4s) }, |
||
| 651 | { "glRasterPos4sv", _O(RasterPos4sv) }, |
||
| 652 | { "glRectd", _O(Rectd) }, |
||
| 653 | { "glRectdv", _O(Rectdv) }, |
||
| 654 | { "glRectf", _O(Rectf) }, |
||
| 655 | { "glRectfv", _O(Rectfv) }, |
||
| 656 | { "glRecti", _O(Recti) }, |
||
| 657 | { "glRectiv", _O(Rectiv) }, |
||
| 658 | { "glRects", _O(Rects) }, |
||
| 659 | { "glRectsv", _O(Rectsv) }, |
||
| 660 | { "glTexCoord1d", _O(TexCoord1d) }, |
||
| 661 | { "glTexCoord1dv", _O(TexCoord1dv) }, |
||
| 662 | { "glTexCoord1f", _O(TexCoord1f) }, |
||
| 663 | { "glTexCoord1fv", _O(TexCoord1fv) }, |
||
| 664 | { "glTexCoord1i", _O(TexCoord1i) }, |
||
| 665 | { "glTexCoord1iv", _O(TexCoord1iv) }, |
||
| 666 | { "glTexCoord1s", _O(TexCoord1s) }, |
||
| 667 | { "glTexCoord1sv", _O(TexCoord1sv) }, |
||
| 668 | { "glTexCoord2d", _O(TexCoord2d) }, |
||
| 669 | { "glTexCoord2dv", _O(TexCoord2dv) }, |
||
| 670 | { "glTexCoord2f", _O(TexCoord2f) }, |
||
| 671 | { "glTexCoord2fv", _O(TexCoord2fv) }, |
||
| 672 | { "glTexCoord2i", _O(TexCoord2i) }, |
||
| 673 | { "glTexCoord2iv", _O(TexCoord2iv) }, |
||
| 674 | { "glTexCoord2s", _O(TexCoord2s) }, |
||
| 675 | { "glTexCoord2sv", _O(TexCoord2sv) }, |
||
| 676 | { "glTexCoord3d", _O(TexCoord3d) }, |
||
| 677 | { "glTexCoord3dv", _O(TexCoord3dv) }, |
||
| 678 | { "glTexCoord3f", _O(TexCoord3f) }, |
||
| 679 | { "glTexCoord3fv", _O(TexCoord3fv) }, |
||
| 680 | { "glTexCoord3i", _O(TexCoord3i) }, |
||
| 681 | { "glTexCoord3iv", _O(TexCoord3iv) }, |
||
| 682 | { "glTexCoord3s", _O(TexCoord3s) }, |
||
| 683 | { "glTexCoord3sv", _O(TexCoord3sv) }, |
||
| 684 | { "glTexCoord4d", _O(TexCoord4d) }, |
||
| 685 | { "glTexCoord4dv", _O(TexCoord4dv) }, |
||
| 686 | { "glTexCoord4f", _O(TexCoord4f) }, |
||
| 687 | { "glTexCoord4fv", _O(TexCoord4fv) }, |
||
| 688 | { "glTexCoord4i", _O(TexCoord4i) }, |
||
| 689 | { "glTexCoord4iv", _O(TexCoord4iv) }, |
||
| 690 | { "glTexCoord4s", _O(TexCoord4s) }, |
||
| 691 | { "glTexCoord4sv", _O(TexCoord4sv) }, |
||
| 692 | { "glVertex2d", _O(Vertex2d) }, |
||
| 693 | { "glVertex2dv", _O(Vertex2dv) }, |
||
| 694 | { "glVertex2f", _O(Vertex2f) }, |
||
| 695 | { "glVertex2fv", _O(Vertex2fv) }, |
||
| 696 | { "glVertex2i", _O(Vertex2i) }, |
||
| 697 | { "glVertex2iv", _O(Vertex2iv) }, |
||
| 698 | { "glVertex2s", _O(Vertex2s) }, |
||
| 699 | { "glVertex2sv", _O(Vertex2sv) }, |
||
| 700 | { "glVertex3d", _O(Vertex3d) }, |
||
| 701 | { "glVertex3dv", _O(Vertex3dv) }, |
||
| 702 | { "glVertex3f", _O(Vertex3f) }, |
||
| 703 | { "glVertex3fv", _O(Vertex3fv) }, |
||
| 704 | { "glVertex3i", _O(Vertex3i) }, |
||
| 705 | { "glVertex3iv", _O(Vertex3iv) }, |
||
| 706 | { "glVertex3s", _O(Vertex3s) }, |
||
| 707 | { "glVertex3sv", _O(Vertex3sv) }, |
||
| 708 | { "glVertex4d", _O(Vertex4d) }, |
||
| 709 | { "glVertex4dv", _O(Vertex4dv) }, |
||
| 710 | { "glVertex4f", _O(Vertex4f) }, |
||
| 711 | { "glVertex4fv", _O(Vertex4fv) }, |
||
| 712 | { "glVertex4i", _O(Vertex4i) }, |
||
| 713 | { "glVertex4iv", _O(Vertex4iv) }, |
||
| 714 | { "glVertex4s", _O(Vertex4s) }, |
||
| 715 | { "glVertex4sv", _O(Vertex4sv) }, |
||
| 716 | { "glClipPlane", _O(ClipPlane) }, |
||
| 717 | { "glColorMaterial", _O(ColorMaterial) }, |
||
| 718 | { "glCullFace", _O(CullFace) }, |
||
| 719 | { "glFogf", _O(Fogf) }, |
||
| 720 | { "glFogfv", _O(Fogfv) }, |
||
| 721 | { "glFogi", _O(Fogi) }, |
||
| 722 | { "glFogiv", _O(Fogiv) }, |
||
| 723 | { "glFrontFace", _O(FrontFace) }, |
||
| 724 | { "glHint", _O(Hint) }, |
||
| 725 | { "glLightf", _O(Lightf) }, |
||
| 726 | { "glLightfv", _O(Lightfv) }, |
||
| 727 | { "glLighti", _O(Lighti) }, |
||
| 728 | { "glLightiv", _O(Lightiv) }, |
||
| 729 | { "glLightModelf", _O(LightModelf) }, |
||
| 730 | { "glLightModelfv", _O(LightModelfv) }, |
||
| 731 | { "glLightModeli", _O(LightModeli) }, |
||
| 732 | { "glLightModeliv", _O(LightModeliv) }, |
||
| 733 | { "glLineStipple", _O(LineStipple) }, |
||
| 734 | { "glLineWidth", _O(LineWidth) }, |
||
| 735 | { "glMaterialf", _O(Materialf) }, |
||
| 736 | { "glMaterialfv", _O(Materialfv) }, |
||
| 737 | { "glMateriali", _O(Materiali) }, |
||
| 738 | { "glMaterialiv", _O(Materialiv) }, |
||
| 739 | { "glPointSize", _O(PointSize) }, |
||
| 740 | { "glPolygonMode", _O(PolygonMode) }, |
||
| 741 | { "glPolygonStipple", _O(PolygonStipple) }, |
||
| 742 | { "glScissor", _O(Scissor) }, |
||
| 743 | { "glShadeModel", _O(ShadeModel) }, |
||
| 744 | { "glTexParameterf", _O(TexParameterf) }, |
||
| 745 | { "glTexParameterfv", _O(TexParameterfv) }, |
||
| 746 | { "glTexParameteri", _O(TexParameteri) }, |
||
| 747 | { "glTexParameteriv", _O(TexParameteriv) }, |
||
| 748 | { "glTexImage1D", _O(TexImage1D) }, |
||
| 749 | { "glTexImage2D", _O(TexImage2D) }, |
||
| 750 | { "glTexEnvf", _O(TexEnvf) }, |
||
| 751 | { "glTexEnvfv", _O(TexEnvfv) }, |
||
| 752 | { "glTexEnvi", _O(TexEnvi) }, |
||
| 753 | { "glTexEnviv", _O(TexEnviv) }, |
||
| 754 | { "glTexGend", _O(TexGend) }, |
||
| 755 | { "glTexGendv", _O(TexGendv) }, |
||
| 756 | { "glTexGenf", _O(TexGenf) }, |
||
| 757 | { "glTexGenfv", _O(TexGenfv) }, |
||
| 758 | { "glTexGeni", _O(TexGeni) }, |
||
| 759 | { "glTexGeniv", _O(TexGeniv) }, |
||
| 760 | { "glFeedbackBuffer", _O(FeedbackBuffer) }, |
||
| 761 | { "glSelectBuffer", _O(SelectBuffer) }, |
||
| 762 | { "glRenderMode", _O(RenderMode) }, |
||
| 763 | { "glInitNames", _O(InitNames) }, |
||
| 764 | { "glLoadName", _O(LoadName) }, |
||
| 765 | { "glPassThrough", _O(PassThrough) }, |
||
| 766 | { "glPopName", _O(PopName) }, |
||
| 767 | { "glPushName", _O(PushName) }, |
||
| 768 | { "glDrawBuffer", _O(DrawBuffer) }, |
||
| 769 | { "glClear", _O(Clear) }, |
||
| 770 | { "glClearAccum", _O(ClearAccum) }, |
||
| 771 | { "glClearIndex", _O(ClearIndex) }, |
||
| 772 | { "glClearColor", _O(ClearColor) }, |
||
| 773 | { "glClearStencil", _O(ClearStencil) }, |
||
| 774 | { "glClearDepth", _O(ClearDepth) }, |
||
| 775 | { "glStencilMask", _O(StencilMask) }, |
||
| 776 | { "glColorMask", _O(ColorMask) }, |
||
| 777 | { "glDepthMask", _O(DepthMask) }, |
||
| 778 | { "glIndexMask", _O(IndexMask) }, |
||
| 779 | { "glAccum", _O(Accum) }, |
||
| 780 | { "glDisable", _O(Disable) }, |
||
| 781 | { "glEnable", _O(Enable) }, |
||
| 782 | { "glFinish", _O(Finish) }, |
||
| 783 | { "glFlush", _O(Flush) }, |
||
| 784 | { "glPopAttrib", _O(PopAttrib) }, |
||
| 785 | { "glPushAttrib", _O(PushAttrib) }, |
||
| 786 | { "glMap1d", _O(Map1d) }, |
||
| 787 | { "glMap1f", _O(Map1f) }, |
||
| 788 | { "glMap2d", _O(Map2d) }, |
||
| 789 | { "glMap2f", _O(Map2f) }, |
||
| 790 | { "glMapGrid1d", _O(MapGrid1d) }, |
||
| 791 | { "glMapGrid1f", _O(MapGrid1f) }, |
||
| 792 | { "glMapGrid2d", _O(MapGrid2d) }, |
||
| 793 | { "glMapGrid2f", _O(MapGrid2f) }, |
||
| 794 | { "glEvalCoord1d", _O(EvalCoord1d) }, |
||
| 795 | { "glEvalCoord1dv", _O(EvalCoord1dv) }, |
||
| 796 | { "glEvalCoord1f", _O(EvalCoord1f) }, |
||
| 797 | { "glEvalCoord1fv", _O(EvalCoord1fv) }, |
||
| 798 | { "glEvalCoord2d", _O(EvalCoord2d) }, |
||
| 799 | { "glEvalCoord2dv", _O(EvalCoord2dv) }, |
||
| 800 | { "glEvalCoord2f", _O(EvalCoord2f) }, |
||
| 801 | { "glEvalCoord2fv", _O(EvalCoord2fv) }, |
||
| 802 | { "glEvalMesh1", _O(EvalMesh1) }, |
||
| 803 | { "glEvalPoint1", _O(EvalPoint1) }, |
||
| 804 | { "glEvalMesh2", _O(EvalMesh2) }, |
||
| 805 | { "glEvalPoint2", _O(EvalPoint2) }, |
||
| 806 | { "glAlphaFunc", _O(AlphaFunc) }, |
||
| 807 | { "glBlendFunc", _O(BlendFunc) }, |
||
| 808 | { "glLogicOp", _O(LogicOp) }, |
||
| 809 | { "glStencilFunc", _O(StencilFunc) }, |
||
| 810 | { "glStencilOp", _O(StencilOp) }, |
||
| 811 | { "glDepthFunc", _O(DepthFunc) }, |
||
| 812 | { "glPixelZoom", _O(PixelZoom) }, |
||
| 813 | { "glPixelTransferf", _O(PixelTransferf) }, |
||
| 814 | { "glPixelTransferi", _O(PixelTransferi) }, |
||
| 815 | { "glPixelStoref", _O(PixelStoref) }, |
||
| 816 | { "glPixelStorei", _O(PixelStorei) }, |
||
| 817 | { "glPixelMapfv", _O(PixelMapfv) }, |
||
| 818 | { "glPixelMapuiv", _O(PixelMapuiv) }, |
||
| 819 | { "glPixelMapusv", _O(PixelMapusv) }, |
||
| 820 | { "glReadBuffer", _O(ReadBuffer) }, |
||
| 821 | { "glCopyPixels", _O(CopyPixels) }, |
||
| 822 | { "glReadPixels", _O(ReadPixels) }, |
||
| 823 | { "glDrawPixels", _O(DrawPixels) }, |
||
| 824 | { "glGetBooleanv", _O(GetBooleanv) }, |
||
| 825 | { "glGetClipPlane", _O(GetClipPlane) }, |
||
| 826 | { "glGetDoublev", _O(GetDoublev) }, |
||
| 827 | { "glGetError", _O(GetError) }, |
||
| 828 | { "glGetFloatv", _O(GetFloatv) }, |
||
| 829 | { "glGetIntegerv", _O(GetIntegerv) }, |
||
| 830 | { "glGetLightfv", _O(GetLightfv) }, |
||
| 831 | { "glGetLightiv", _O(GetLightiv) }, |
||
| 832 | { "glGetMapdv", _O(GetMapdv) }, |
||
| 833 | { "glGetMapfv", _O(GetMapfv) }, |
||
| 834 | { "glGetMapiv", _O(GetMapiv) }, |
||
| 835 | { "glGetMaterialfv", _O(GetMaterialfv) }, |
||
| 836 | { "glGetMaterialiv", _O(GetMaterialiv) }, |
||
| 837 | { "glGetPixelMapfv", _O(GetPixelMapfv) }, |
||
| 838 | { "glGetPixelMapuiv", _O(GetPixelMapuiv) }, |
||
| 839 | { "glGetPixelMapusv", _O(GetPixelMapusv) }, |
||
| 840 | { "glGetPolygonStipple", _O(GetPolygonStipple) }, |
||
| 841 | { "glGetString", _O(GetString) }, |
||
| 842 | { "glGetTexEnvfv", _O(GetTexEnvfv) }, |
||
| 843 | { "glGetTexEnviv", _O(GetTexEnviv) }, |
||
| 844 | { "glGetTexGendv", _O(GetTexGendv) }, |
||
| 845 | { "glGetTexGenfv", _O(GetTexGenfv) }, |
||
| 846 | { "glGetTexGeniv", _O(GetTexGeniv) }, |
||
| 847 | { "glGetTexImage", _O(GetTexImage) }, |
||
| 848 | { "glGetTexParameterfv", _O(GetTexParameterfv) }, |
||
| 849 | { "glGetTexParameteriv", _O(GetTexParameteriv) }, |
||
| 850 | { "glGetTexLevelParameterfv", _O(GetTexLevelParameterfv) }, |
||
| 851 | { "glGetTexLevelParameteriv", _O(GetTexLevelParameteriv) }, |
||
| 852 | { "glIsEnabled", _O(IsEnabled) }, |
||
| 853 | { "glIsList", _O(IsList) }, |
||
| 854 | { "glDepthRange", _O(DepthRange) }, |
||
| 855 | { "glFrustum", _O(Frustum) }, |
||
| 856 | { "glLoadIdentity", _O(LoadIdentity) }, |
||
| 857 | { "glLoadMatrixf", _O(LoadMatrixf) }, |
||
| 858 | { "glLoadMatrixd", _O(LoadMatrixd) }, |
||
| 859 | { "glMatrixMode", _O(MatrixMode) }, |
||
| 860 | { "glMultMatrixf", _O(MultMatrixf) }, |
||
| 861 | { "glMultMatrixd", _O(MultMatrixd) }, |
||
| 862 | { "glOrtho", _O(Ortho) }, |
||
| 863 | { "glPopMatrix", _O(PopMatrix) }, |
||
| 864 | { "glPushMatrix", _O(PushMatrix) }, |
||
| 865 | { "glRotated", _O(Rotated) }, |
||
| 866 | { "glRotatef", _O(Rotatef) }, |
||
| 867 | { "glScaled", _O(Scaled) }, |
||
| 868 | { "glScalef", _O(Scalef) }, |
||
| 869 | { "glTranslated", _O(Translated) }, |
||
| 870 | { "glTranslatef", _O(Translatef) }, |
||
| 871 | { "glViewport", _O(Viewport) }, |
||
| 872 | { "glArrayElement", _O(ArrayElement) }, |
||
| 873 | { "glBindTexture", _O(BindTexture) }, |
||
| 874 | { "glColorPointer", _O(ColorPointer) }, |
||
| 875 | { "glDisableClientState", _O(DisableClientState) }, |
||
| 876 | { "glDrawArrays", _O(DrawArrays) }, |
||
| 877 | { "glDrawElements", _O(DrawElements) }, |
||
| 878 | { "glEdgeFlagPointer", _O(EdgeFlagPointer) }, |
||
| 879 | { "glEnableClientState", _O(EnableClientState) }, |
||
| 880 | { "glIndexPointer", _O(IndexPointer) }, |
||
| 881 | { "glIndexub", _O(Indexub) }, |
||
| 882 | { "glIndexubv", _O(Indexubv) }, |
||
| 883 | { "glInterleavedArrays", _O(InterleavedArrays) }, |
||
| 884 | { "glNormalPointer", _O(NormalPointer) }, |
||
| 885 | { "glPolygonOffset", _O(PolygonOffset) }, |
||
| 886 | { "glTexCoordPointer", _O(TexCoordPointer) }, |
||
| 887 | { "glVertexPointer", _O(VertexPointer) }, |
||
| 888 | { "glAreTexturesResident", _O(AreTexturesResident) }, |
||
| 889 | { "glCopyTexImage1D", _O(CopyTexImage1D) }, |
||
| 890 | { "glCopyTexImage2D", _O(CopyTexImage2D) }, |
||
| 891 | { "glCopyTexSubImage1D", _O(CopyTexSubImage1D) }, |
||
| 892 | { "glCopyTexSubImage2D", _O(CopyTexSubImage2D) }, |
||
| 893 | { "glDeleteTextures", _O(DeleteTextures) }, |
||
| 894 | { "glGenTextures", _O(GenTextures) }, |
||
| 895 | { "glGetPointerv", _O(GetPointerv) }, |
||
| 896 | { "glIsTexture", _O(IsTexture) }, |
||
| 897 | { "glPrioritizeTextures", _O(PrioritizeTextures) }, |
||
| 898 | { "glTexSubImage1D", _O(TexSubImage1D) }, |
||
| 899 | { "glTexSubImage2D", _O(TexSubImage2D) }, |
||
| 900 | { "glPopClientAttrib", _O(PopClientAttrib) }, |
||
| 901 | { "glPushClientAttrib", _O(PushClientAttrib) }, |
||
| 902 | { "glBlendColor", _O(BlendColor) }, |
||
| 903 | { "glBlendEquation", _O(BlendEquation) }, |
||
| 904 | { "glDrawRangeElements", _O(DrawRangeElements) }, |
||
| 905 | { "glColorTable", _O(ColorTable) }, |
||
| 906 | { "glColorTableParameterfv", _O(ColorTableParameterfv) }, |
||
| 907 | { "glColorTableParameteriv", _O(ColorTableParameteriv) }, |
||
| 908 | { "glCopyColorTable", _O(CopyColorTable) }, |
||
| 909 | { "glGetColorTable", _O(GetColorTable) }, |
||
| 910 | { "glGetColorTableParameterfv", _O(GetColorTableParameterfv) }, |
||
| 911 | { "glGetColorTableParameteriv", _O(GetColorTableParameteriv) }, |
||
| 912 | { "glColorSubTable", _O(ColorSubTable) }, |
||
| 913 | { "glCopyColorSubTable", _O(CopyColorSubTable) }, |
||
| 914 | { "glConvolutionFilter1D", _O(ConvolutionFilter1D) }, |
||
| 915 | { "glConvolutionFilter2D", _O(ConvolutionFilter2D) }, |
||
| 916 | { "glConvolutionParameterf", _O(ConvolutionParameterf) }, |
||
| 917 | { "glConvolutionParameterfv", _O(ConvolutionParameterfv) }, |
||
| 918 | { "glConvolutionParameteri", _O(ConvolutionParameteri) }, |
||
| 919 | { "glConvolutionParameteriv", _O(ConvolutionParameteriv) }, |
||
| 920 | { "glCopyConvolutionFilter1D", _O(CopyConvolutionFilter1D) }, |
||
| 921 | { "glCopyConvolutionFilter2D", _O(CopyConvolutionFilter2D) }, |
||
| 922 | { "glGetConvolutionFilter", _O(GetConvolutionFilter) }, |
||
| 923 | { "glGetConvolutionParameterfv", _O(GetConvolutionParameterfv) }, |
||
| 924 | { "glGetConvolutionParameteriv", _O(GetConvolutionParameteriv) }, |
||
| 925 | { "glGetSeparableFilter", _O(GetSeparableFilter) }, |
||
| 926 | { "glSeparableFilter2D", _O(SeparableFilter2D) }, |
||
| 927 | { "glGetHistogram", _O(GetHistogram) }, |
||
| 928 | { "glGetHistogramParameterfv", _O(GetHistogramParameterfv) }, |
||
| 929 | { "glGetHistogramParameteriv", _O(GetHistogramParameteriv) }, |
||
| 930 | { "glGetMinmax", _O(GetMinmax) }, |
||
| 931 | { "glGetMinmaxParameterfv", _O(GetMinmaxParameterfv) }, |
||
| 932 | { "glGetMinmaxParameteriv", _O(GetMinmaxParameteriv) }, |
||
| 933 | { "glHistogram", _O(Histogram) }, |
||
| 934 | { "glMinmax", _O(Minmax) }, |
||
| 935 | { "glResetHistogram", _O(ResetHistogram) }, |
||
| 936 | { "glResetMinmax", _O(ResetMinmax) }, |
||
| 937 | { "glTexImage3D", _O(TexImage3D) }, |
||
| 938 | { "glTexSubImage3D", _O(TexSubImage3D) }, |
||
| 939 | { "glCopyTexSubImage3D", _O(CopyTexSubImage3D) }, |
||
| 940 | { "glActiveTexture", _O(ActiveTexture) }, |
||
| 941 | { "glClientActiveTexture", _O(ClientActiveTexture) }, |
||
| 942 | { "glMultiTexCoord1d", _O(MultiTexCoord1d) }, |
||
| 943 | { "glMultiTexCoord1dv", _O(MultiTexCoord1dv) }, |
||
| 944 | { "glMultiTexCoord1fARB", _O(MultiTexCoord1fARB) }, |
||
| 945 | { "glMultiTexCoord1fvARB", _O(MultiTexCoord1fvARB) }, |
||
| 946 | { "glMultiTexCoord1i", _O(MultiTexCoord1i) }, |
||
| 947 | { "glMultiTexCoord1iv", _O(MultiTexCoord1iv) }, |
||
| 948 | { "glMultiTexCoord1s", _O(MultiTexCoord1s) }, |
||
| 949 | { "glMultiTexCoord1sv", _O(MultiTexCoord1sv) }, |
||
| 950 | { "glMultiTexCoord2d", _O(MultiTexCoord2d) }, |
||
| 951 | { "glMultiTexCoord2dv", _O(MultiTexCoord2dv) }, |
||
| 952 | { "glMultiTexCoord2fARB", _O(MultiTexCoord2fARB) }, |
||
| 953 | { "glMultiTexCoord2fvARB", _O(MultiTexCoord2fvARB) }, |
||
| 954 | { "glMultiTexCoord2i", _O(MultiTexCoord2i) }, |
||
| 955 | { "glMultiTexCoord2iv", _O(MultiTexCoord2iv) }, |
||
| 956 | { "glMultiTexCoord2s", _O(MultiTexCoord2s) }, |
||
| 957 | { "glMultiTexCoord2sv", _O(MultiTexCoord2sv) }, |
||
| 958 | { "glMultiTexCoord3d", _O(MultiTexCoord3d) }, |
||
| 959 | { "glMultiTexCoord3dv", _O(MultiTexCoord3dv) }, |
||
| 960 | { "glMultiTexCoord3fARB", _O(MultiTexCoord3fARB) }, |
||
| 961 | { "glMultiTexCoord3fvARB", _O(MultiTexCoord3fvARB) }, |
||
| 962 | { "glMultiTexCoord3i", _O(MultiTexCoord3i) }, |
||
| 963 | { "glMultiTexCoord3iv", _O(MultiTexCoord3iv) }, |
||
| 964 | { "glMultiTexCoord3s", _O(MultiTexCoord3s) }, |
||
| 965 | { "glMultiTexCoord3sv", _O(MultiTexCoord3sv) }, |
||
| 966 | { "glMultiTexCoord4d", _O(MultiTexCoord4d) }, |
||
| 967 | { "glMultiTexCoord4dv", _O(MultiTexCoord4dv) }, |
||
| 968 | { "glMultiTexCoord4fARB", _O(MultiTexCoord4fARB) }, |
||
| 969 | { "glMultiTexCoord4fvARB", _O(MultiTexCoord4fvARB) }, |
||
| 970 | { "glMultiTexCoord4i", _O(MultiTexCoord4i) }, |
||
| 971 | { "glMultiTexCoord4iv", _O(MultiTexCoord4iv) }, |
||
| 972 | { "glMultiTexCoord4s", _O(MultiTexCoord4s) }, |
||
| 973 | { "glMultiTexCoord4sv", _O(MultiTexCoord4sv) }, |
||
| 974 | { "glAttachShader", _O(AttachShader) }, |
||
| 975 | { "glCreateProgram", _O(CreateProgram) }, |
||
| 976 | { "glCreateShader", _O(CreateShader) }, |
||
| 977 | { "glDeleteProgram", _O(DeleteProgram) }, |
||
| 978 | { "glDeleteShader", _O(DeleteShader) }, |
||
| 979 | { "glDetachShader", _O(DetachShader) }, |
||
| 980 | { "glGetAttachedShaders", _O(GetAttachedShaders) }, |
||
| 981 | { "glGetProgramInfoLog", _O(GetProgramInfoLog) }, |
||
| 982 | { "glGetProgramiv", _O(GetProgramiv) }, |
||
| 983 | { "glGetShaderInfoLog", _O(GetShaderInfoLog) }, |
||
| 984 | { "glGetShaderiv", _O(GetShaderiv) }, |
||
| 985 | { "glIsProgram", _O(IsProgram) }, |
||
| 986 | { "glIsShader", _O(IsShader) }, |
||
| 987 | { "glStencilFuncSeparate", _O(StencilFuncSeparate) }, |
||
| 988 | { "glStencilMaskSeparate", _O(StencilMaskSeparate) }, |
||
| 989 | { "glStencilOpSeparate", _O(StencilOpSeparate) }, |
||
| 990 | { "glUniformMatrix2x3fv", _O(UniformMatrix2x3fv) }, |
||
| 991 | { "glUniformMatrix2x4fv", _O(UniformMatrix2x4fv) }, |
||
| 992 | { "glUniformMatrix3x2fv", _O(UniformMatrix3x2fv) }, |
||
| 993 | { "glUniformMatrix3x4fv", _O(UniformMatrix3x4fv) }, |
||
| 994 | { "glUniformMatrix4x2fv", _O(UniformMatrix4x2fv) }, |
||
| 995 | { "glUniformMatrix4x3fv", _O(UniformMatrix4x3fv) }, |
||
| 996 | { "glClearBufferfi", _O(ClearBufferfi) }, |
||
| 997 | { "glClearBufferfv", _O(ClearBufferfv) }, |
||
| 998 | { "glClearBufferiv", _O(ClearBufferiv) }, |
||
| 999 | { "glClearBufferuiv", _O(ClearBufferuiv) }, |
||
| 1000 | { "glGetStringi", _O(GetStringi) }, |
||
| 1001 | { "glFramebufferTexture", _O(FramebufferTexture) }, |
||
| 1002 | { "glGetBufferParameteri64v", _O(GetBufferParameteri64v) }, |
||
| 1003 | { "glGetInteger64i_v", _O(GetInteger64i_v) }, |
||
| 1004 | { "glLoadTransposeMatrixd", _O(LoadTransposeMatrixd) }, |
||
| 1005 | { "glLoadTransposeMatrixf", _O(LoadTransposeMatrixf) }, |
||
| 1006 | { "glMultTransposeMatrixd", _O(MultTransposeMatrixd) }, |
||
| 1007 | { "glMultTransposeMatrixf", _O(MultTransposeMatrixf) }, |
||
| 1008 | { "glSampleCoverage", _O(SampleCoverage) }, |
||
| 1009 | { "glCompressedTexImage1D", _O(CompressedTexImage1D) }, |
||
| 1010 | { "glCompressedTexImage2D", _O(CompressedTexImage2D) }, |
||
| 1011 | { "glCompressedTexImage3D", _O(CompressedTexImage3D) }, |
||
| 1012 | { "glCompressedTexSubImage1D", _O(CompressedTexSubImage1D) }, |
||
| 1013 | { "glCompressedTexSubImage2D", _O(CompressedTexSubImage2D) }, |
||
| 1014 | { "glCompressedTexSubImage3D", _O(CompressedTexSubImage3D) }, |
||
| 1015 | { "glGetCompressedTexImage", _O(GetCompressedTexImage) }, |
||
| 1016 | { "glDisableVertexAttribArray", _O(DisableVertexAttribArray) }, |
||
| 1017 | { "glEnableVertexAttribArray", _O(EnableVertexAttribArray) }, |
||
| 1018 | { "glGetProgramEnvParameterdvARB", _O(GetProgramEnvParameterdvARB) }, |
||
| 1019 | { "glGetProgramEnvParameterfvARB", _O(GetProgramEnvParameterfvARB) }, |
||
| 1020 | { "glGetProgramLocalParameterdvARB", _O(GetProgramLocalParameterdvARB) }, |
||
| 1021 | { "glGetProgramLocalParameterfvARB", _O(GetProgramLocalParameterfvARB) }, |
||
| 1022 | { "glGetProgramStringARB", _O(GetProgramStringARB) }, |
||
| 1023 | { "glGetProgramivARB", _O(GetProgramivARB) }, |
||
| 1024 | { "glGetVertexAttribdv", _O(GetVertexAttribdv) }, |
||
| 1025 | { "glGetVertexAttribfv", _O(GetVertexAttribfv) }, |
||
| 1026 | { "glGetVertexAttribiv", _O(GetVertexAttribiv) }, |
||
| 1027 | { "glProgramEnvParameter4dARB", _O(ProgramEnvParameter4dARB) }, |
||
| 1028 | { "glProgramEnvParameter4dvARB", _O(ProgramEnvParameter4dvARB) }, |
||
| 1029 | { "glProgramEnvParameter4fARB", _O(ProgramEnvParameter4fARB) }, |
||
| 1030 | { "glProgramEnvParameter4fvARB", _O(ProgramEnvParameter4fvARB) }, |
||
| 1031 | { "glProgramLocalParameter4dARB", _O(ProgramLocalParameter4dARB) }, |
||
| 1032 | { "glProgramLocalParameter4dvARB", _O(ProgramLocalParameter4dvARB) }, |
||
| 1033 | { "glProgramLocalParameter4fARB", _O(ProgramLocalParameter4fARB) }, |
||
| 1034 | { "glProgramLocalParameter4fvARB", _O(ProgramLocalParameter4fvARB) }, |
||
| 1035 | { "glProgramStringARB", _O(ProgramStringARB) }, |
||
| 1036 | { "glVertexAttrib1d", _O(VertexAttrib1d) }, |
||
| 1037 | { "glVertexAttrib1dv", _O(VertexAttrib1dv) }, |
||
| 1038 | { "glVertexAttrib1fARB", _O(VertexAttrib1fARB) }, |
||
| 1039 | { "glVertexAttrib1fvARB", _O(VertexAttrib1fvARB) }, |
||
| 1040 | { "glVertexAttrib1s", _O(VertexAttrib1s) }, |
||
| 1041 | { "glVertexAttrib1sv", _O(VertexAttrib1sv) }, |
||
| 1042 | { "glVertexAttrib2d", _O(VertexAttrib2d) }, |
||
| 1043 | { "glVertexAttrib2dv", _O(VertexAttrib2dv) }, |
||
| 1044 | { "glVertexAttrib2fARB", _O(VertexAttrib2fARB) }, |
||
| 1045 | { "glVertexAttrib2fvARB", _O(VertexAttrib2fvARB) }, |
||
| 1046 | { "glVertexAttrib2s", _O(VertexAttrib2s) }, |
||
| 1047 | { "glVertexAttrib2sv", _O(VertexAttrib2sv) }, |
||
| 1048 | { "glVertexAttrib3d", _O(VertexAttrib3d) }, |
||
| 1049 | { "glVertexAttrib3dv", _O(VertexAttrib3dv) }, |
||
| 1050 | { "glVertexAttrib3fARB", _O(VertexAttrib3fARB) }, |
||
| 1051 | { "glVertexAttrib3fvARB", _O(VertexAttrib3fvARB) }, |
||
| 1052 | { "glVertexAttrib3s", _O(VertexAttrib3s) }, |
||
| 1053 | { "glVertexAttrib3sv", _O(VertexAttrib3sv) }, |
||
| 1054 | { "glVertexAttrib4Nbv", _O(VertexAttrib4Nbv) }, |
||
| 1055 | { "glVertexAttrib4Niv", _O(VertexAttrib4Niv) }, |
||
| 1056 | { "glVertexAttrib4Nsv", _O(VertexAttrib4Nsv) }, |
||
| 1057 | { "glVertexAttrib4Nub", _O(VertexAttrib4Nub) }, |
||
| 1058 | { "glVertexAttrib4Nubv", _O(VertexAttrib4Nubv) }, |
||
| 1059 | { "glVertexAttrib4Nuiv", _O(VertexAttrib4Nuiv) }, |
||
| 1060 | { "glVertexAttrib4Nusv", _O(VertexAttrib4Nusv) }, |
||
| 1061 | { "glVertexAttrib4bv", _O(VertexAttrib4bv) }, |
||
| 1062 | { "glVertexAttrib4d", _O(VertexAttrib4d) }, |
||
| 1063 | { "glVertexAttrib4dv", _O(VertexAttrib4dv) }, |
||
| 1064 | { "glVertexAttrib4fARB", _O(VertexAttrib4fARB) }, |
||
| 1065 | { "glVertexAttrib4fvARB", _O(VertexAttrib4fvARB) }, |
||
| 1066 | { "glVertexAttrib4iv", _O(VertexAttrib4iv) }, |
||
| 1067 | { "glVertexAttrib4s", _O(VertexAttrib4s) }, |
||
| 1068 | { "glVertexAttrib4sv", _O(VertexAttrib4sv) }, |
||
| 1069 | { "glVertexAttrib4ubv", _O(VertexAttrib4ubv) }, |
||
| 1070 | { "glVertexAttrib4uiv", _O(VertexAttrib4uiv) }, |
||
| 1071 | { "glVertexAttrib4usv", _O(VertexAttrib4usv) }, |
||
| 1072 | { "glVertexAttribPointer", _O(VertexAttribPointer) }, |
||
| 1073 | { "glBindBuffer", _O(BindBuffer) }, |
||
| 1074 | { "glBufferData", _O(BufferData) }, |
||
| 1075 | { "glBufferSubData", _O(BufferSubData) }, |
||
| 1076 | { "glDeleteBuffers", _O(DeleteBuffers) }, |
||
| 1077 | { "glGenBuffers", _O(GenBuffers) }, |
||
| 1078 | { "glGetBufferParameteriv", _O(GetBufferParameteriv) }, |
||
| 1079 | { "glGetBufferPointerv", _O(GetBufferPointerv) }, |
||
| 1080 | { "glGetBufferSubData", _O(GetBufferSubData) }, |
||
| 1081 | { "glIsBuffer", _O(IsBuffer) }, |
||
| 1082 | { "glMapBuffer", _O(MapBuffer) }, |
||
| 1083 | { "glUnmapBuffer", _O(UnmapBuffer) }, |
||
| 1084 | { "glBeginQuery", _O(BeginQuery) }, |
||
| 1085 | { "glDeleteQueries", _O(DeleteQueries) }, |
||
| 1086 | { "glEndQuery", _O(EndQuery) }, |
||
| 1087 | { "glGenQueries", _O(GenQueries) }, |
||
| 1088 | { "glGetQueryObjectiv", _O(GetQueryObjectiv) }, |
||
| 1089 | { "glGetQueryObjectuiv", _O(GetQueryObjectuiv) }, |
||
| 1090 | { "glGetQueryiv", _O(GetQueryiv) }, |
||
| 1091 | { "glIsQuery", _O(IsQuery) }, |
||
| 1092 | { "glAttachObjectARB", _O(AttachObjectARB) }, |
||
| 1093 | { "glCompileShader", _O(CompileShader) }, |
||
| 1094 | { "glCreateProgramObjectARB", _O(CreateProgramObjectARB) }, |
||
| 1095 | { "glCreateShaderObjectARB", _O(CreateShaderObjectARB) }, |
||
| 1096 | { "glDeleteObjectARB", _O(DeleteObjectARB) }, |
||
| 1097 | { "glDetachObjectARB", _O(DetachObjectARB) }, |
||
| 1098 | { "glGetActiveUniform", _O(GetActiveUniform) }, |
||
| 1099 | { "glGetAttachedObjectsARB", _O(GetAttachedObjectsARB) }, |
||
| 1100 | { "glGetHandleARB", _O(GetHandleARB) }, |
||
| 1101 | { "glGetInfoLogARB", _O(GetInfoLogARB) }, |
||
| 1102 | { "glGetObjectParameterfvARB", _O(GetObjectParameterfvARB) }, |
||
| 1103 | { "glGetObjectParameterivARB", _O(GetObjectParameterivARB) }, |
||
| 1104 | { "glGetShaderSource", _O(GetShaderSource) }, |
||
| 1105 | { "glGetUniformLocation", _O(GetUniformLocation) }, |
||
| 1106 | { "glGetUniformfv", _O(GetUniformfv) }, |
||
| 1107 | { "glGetUniformiv", _O(GetUniformiv) }, |
||
| 1108 | { "glLinkProgram", _O(LinkProgram) }, |
||
| 1109 | { "glShaderSource", _O(ShaderSource) }, |
||
| 1110 | { "glUniform1f", _O(Uniform1f) }, |
||
| 1111 | { "glUniform1fv", _O(Uniform1fv) }, |
||
| 1112 | { "glUniform1i", _O(Uniform1i) }, |
||
| 1113 | { "glUniform1iv", _O(Uniform1iv) }, |
||
| 1114 | { "glUniform2f", _O(Uniform2f) }, |
||
| 1115 | { "glUniform2fv", _O(Uniform2fv) }, |
||
| 1116 | { "glUniform2i", _O(Uniform2i) }, |
||
| 1117 | { "glUniform2iv", _O(Uniform2iv) }, |
||
| 1118 | { "glUniform3f", _O(Uniform3f) }, |
||
| 1119 | { "glUniform3fv", _O(Uniform3fv) }, |
||
| 1120 | { "glUniform3i", _O(Uniform3i) }, |
||
| 1121 | { "glUniform3iv", _O(Uniform3iv) }, |
||
| 1122 | { "glUniform4f", _O(Uniform4f) }, |
||
| 1123 | { "glUniform4fv", _O(Uniform4fv) }, |
||
| 1124 | { "glUniform4i", _O(Uniform4i) }, |
||
| 1125 | { "glUniform4iv", _O(Uniform4iv) }, |
||
| 1126 | { "glUniformMatrix2fv", _O(UniformMatrix2fv) }, |
||
| 1127 | { "glUniformMatrix3fv", _O(UniformMatrix3fv) }, |
||
| 1128 | { "glUniformMatrix4fv", _O(UniformMatrix4fv) }, |
||
| 1129 | { "glUseProgram", _O(UseProgram) }, |
||
| 1130 | { "glValidateProgram", _O(ValidateProgram) }, |
||
| 1131 | { "glBindAttribLocation", _O(BindAttribLocation) }, |
||
| 1132 | { "glGetActiveAttrib", _O(GetActiveAttrib) }, |
||
| 1133 | { "glGetAttribLocation", _O(GetAttribLocation) }, |
||
| 1134 | { "glDrawBuffers", _O(DrawBuffers) }, |
||
| 1135 | { "glClampColor", _O(ClampColor) }, |
||
| 1136 | { "glDrawArraysInstancedARB", _O(DrawArraysInstancedARB) }, |
||
| 1137 | { "glDrawElementsInstancedARB", _O(DrawElementsInstancedARB) }, |
||
| 1138 | { "glRenderbufferStorageMultisample", _O(RenderbufferStorageMultisample) }, |
||
| 1139 | { "glFramebufferTexture", _O(FramebufferTexture) }, |
||
| 1140 | { "glProgramParameteri", _O(ProgramParameteri) }, |
||
| 1141 | { "glVertexAttribDivisor", _O(VertexAttribDivisor) }, |
||
| 1142 | { "glFlushMappedBufferRange", _O(FlushMappedBufferRange) }, |
||
| 1143 | { "glMapBufferRange", _O(MapBufferRange) }, |
||
| 1144 | { "glTexBuffer", _O(TexBuffer) }, |
||
| 1145 | { "glBindVertexArray", _O(BindVertexArray) }, |
||
| 1146 | { "glGenVertexArrays", _O(GenVertexArrays) }, |
||
| 1147 | { "glCopyBufferSubData", _O(CopyBufferSubData) }, |
||
| 1148 | { "glClientWaitSync", _O(ClientWaitSync) }, |
||
| 1149 | { "glDeleteSync", _O(DeleteSync) }, |
||
| 1150 | { "glFenceSync", _O(FenceSync) }, |
||
| 1151 | { "glGetInteger64v", _O(GetInteger64v) }, |
||
| 1152 | { "glGetSynciv", _O(GetSynciv) }, |
||
| 1153 | { "glIsSync", _O(IsSync) }, |
||
| 1154 | { "glWaitSync", _O(WaitSync) }, |
||
| 1155 | { "glDrawElementsBaseVertex", _O(DrawElementsBaseVertex) }, |
||
| 1156 | { "glDrawElementsInstancedBaseVertex", _O(DrawElementsInstancedBaseVertex) }, |
||
| 1157 | { "glDrawRangeElementsBaseVertex", _O(DrawRangeElementsBaseVertex) }, |
||
| 1158 | { "glMultiDrawElementsBaseVertex", _O(MultiDrawElementsBaseVertex) }, |
||
| 1159 | { "glBlendEquationSeparateiARB", _O(BlendEquationSeparateiARB) }, |
||
| 1160 | { "glBlendEquationiARB", _O(BlendEquationiARB) }, |
||
| 1161 | { "glBlendFuncSeparateiARB", _O(BlendFuncSeparateiARB) }, |
||
| 1162 | { "glBlendFunciARB", _O(BlendFunciARB) }, |
||
| 1163 | { "glBindFragDataLocationIndexed", _O(BindFragDataLocationIndexed) }, |
||
| 1164 | { "glGetFragDataIndex", _O(GetFragDataIndex) }, |
||
| 1165 | { "glBindSampler", _O(BindSampler) }, |
||
| 1166 | { "glDeleteSamplers", _O(DeleteSamplers) }, |
||
| 1167 | { "glGenSamplers", _O(GenSamplers) }, |
||
| 1168 | { "glGetSamplerParameterIiv", _O(GetSamplerParameterIiv) }, |
||
| 1169 | { "glGetSamplerParameterIuiv", _O(GetSamplerParameterIuiv) }, |
||
| 1170 | { "glGetSamplerParameterfv", _O(GetSamplerParameterfv) }, |
||
| 1171 | { "glGetSamplerParameteriv", _O(GetSamplerParameteriv) }, |
||
| 1172 | { "glIsSampler", _O(IsSampler) }, |
||
| 1173 | { "glSamplerParameterIiv", _O(SamplerParameterIiv) }, |
||
| 1174 | { "glSamplerParameterIuiv", _O(SamplerParameterIuiv) }, |
||
| 1175 | { "glSamplerParameterf", _O(SamplerParameterf) }, |
||
| 1176 | { "glSamplerParameterfv", _O(SamplerParameterfv) }, |
||
| 1177 | { "glSamplerParameteri", _O(SamplerParameteri) }, |
||
| 1178 | { "glSamplerParameteriv", _O(SamplerParameteriv) }, |
||
| 1179 | { "glColorP3ui", _O(ColorP3ui) }, |
||
| 1180 | { "glColorP3uiv", _O(ColorP3uiv) }, |
||
| 1181 | { "glColorP4ui", _O(ColorP4ui) }, |
||
| 1182 | { "glColorP4uiv", _O(ColorP4uiv) }, |
||
| 1183 | { "glMultiTexCoordP1ui", _O(MultiTexCoordP1ui) }, |
||
| 1184 | { "glMultiTexCoordP1uiv", _O(MultiTexCoordP1uiv) }, |
||
| 1185 | { "glMultiTexCoordP2ui", _O(MultiTexCoordP2ui) }, |
||
| 1186 | { "glMultiTexCoordP2uiv", _O(MultiTexCoordP2uiv) }, |
||
| 1187 | { "glMultiTexCoordP3ui", _O(MultiTexCoordP3ui) }, |
||
| 1188 | { "glMultiTexCoordP3uiv", _O(MultiTexCoordP3uiv) }, |
||
| 1189 | { "glMultiTexCoordP4ui", _O(MultiTexCoordP4ui) }, |
||
| 1190 | { "glMultiTexCoordP4uiv", _O(MultiTexCoordP4uiv) }, |
||
| 1191 | { "glNormalP3ui", _O(NormalP3ui) }, |
||
| 1192 | { "glNormalP3uiv", _O(NormalP3uiv) }, |
||
| 1193 | { "glSecondaryColorP3ui", _O(SecondaryColorP3ui) }, |
||
| 1194 | { "glSecondaryColorP3uiv", _O(SecondaryColorP3uiv) }, |
||
| 1195 | { "glTexCoordP1ui", _O(TexCoordP1ui) }, |
||
| 1196 | { "glTexCoordP1uiv", _O(TexCoordP1uiv) }, |
||
| 1197 | { "glTexCoordP2ui", _O(TexCoordP2ui) }, |
||
| 1198 | { "glTexCoordP2uiv", _O(TexCoordP2uiv) }, |
||
| 1199 | { "glTexCoordP3ui", _O(TexCoordP3ui) }, |
||
| 1200 | { "glTexCoordP3uiv", _O(TexCoordP3uiv) }, |
||
| 1201 | { "glTexCoordP4ui", _O(TexCoordP4ui) }, |
||
| 1202 | { "glTexCoordP4uiv", _O(TexCoordP4uiv) }, |
||
| 1203 | { "glVertexAttribP1ui", _O(VertexAttribP1ui) }, |
||
| 1204 | { "glVertexAttribP1uiv", _O(VertexAttribP1uiv) }, |
||
| 1205 | { "glVertexAttribP2ui", _O(VertexAttribP2ui) }, |
||
| 1206 | { "glVertexAttribP2uiv", _O(VertexAttribP2uiv) }, |
||
| 1207 | { "glVertexAttribP3ui", _O(VertexAttribP3ui) }, |
||
| 1208 | { "glVertexAttribP3uiv", _O(VertexAttribP3uiv) }, |
||
| 1209 | { "glVertexAttribP4ui", _O(VertexAttribP4ui) }, |
||
| 1210 | { "glVertexAttribP4uiv", _O(VertexAttribP4uiv) }, |
||
| 1211 | { "glVertexP2ui", _O(VertexP2ui) }, |
||
| 1212 | { "glVertexP2uiv", _O(VertexP2uiv) }, |
||
| 1213 | { "glVertexP3ui", _O(VertexP3ui) }, |
||
| 1214 | { "glVertexP3uiv", _O(VertexP3uiv) }, |
||
| 1215 | { "glVertexP4ui", _O(VertexP4ui) }, |
||
| 1216 | { "glVertexP4uiv", _O(VertexP4uiv) }, |
||
| 1217 | { "glBindTransformFeedback", _O(BindTransformFeedback) }, |
||
| 1218 | { "glDeleteTransformFeedbacks", _O(DeleteTransformFeedbacks) }, |
||
| 1219 | { "glDrawTransformFeedback", _O(DrawTransformFeedback) }, |
||
| 1220 | { "glGenTransformFeedbacks", _O(GenTransformFeedbacks) }, |
||
| 1221 | { "glIsTransformFeedback", _O(IsTransformFeedback) }, |
||
| 1222 | { "glPauseTransformFeedback", _O(PauseTransformFeedback) }, |
||
| 1223 | { "glResumeTransformFeedback", _O(ResumeTransformFeedback) }, |
||
| 1224 | { "glClearDepthf", _O(ClearDepthf) }, |
||
| 1225 | { "glDepthRangef", _O(DepthRangef) }, |
||
| 1226 | { "glGetShaderPrecisionFormat", _O(GetShaderPrecisionFormat) }, |
||
| 1227 | { "glReleaseShaderCompiler", _O(ReleaseShaderCompiler) }, |
||
| 1228 | { "glShaderBinary", _O(ShaderBinary) }, |
||
| 1229 | { "glDebugMessageCallback", _O(DebugMessageCallback) }, |
||
| 1230 | { "glDebugMessageControl", _O(DebugMessageControl) }, |
||
| 1231 | { "glDebugMessageInsert", _O(DebugMessageInsert) }, |
||
| 1232 | { "glGetDebugMessageLog", _O(GetDebugMessageLog) }, |
||
| 1233 | { "glPushDebugGroup", _O(PushDebugGroup) }, |
||
| 1234 | { "glPopDebugGroup", _O(PopDebugGroup) }, |
||
| 1235 | { "glGetObjectLabel", _O(GetObjectLabel) }, |
||
| 1236 | { "glGetObjectPtrLabel", _O(GetObjectPtrLabel) }, |
||
| 1237 | { "glObjectLabel", _O(ObjectLabel) }, |
||
| 1238 | { "glObjectPtrLabel", _O(ObjectPtrLabel) }, |
||
| 1239 | { "glGetGraphicsResetStatusARB", _O(GetGraphicsResetStatusARB) }, |
||
| 1240 | { "glGetnColorTableARB", _O(GetnColorTableARB) }, |
||
| 1241 | { "glGetnCompressedTexImageARB", _O(GetnCompressedTexImageARB) }, |
||
| 1242 | { "glGetnConvolutionFilterARB", _O(GetnConvolutionFilterARB) }, |
||
| 1243 | { "glGetnHistogramARB", _O(GetnHistogramARB) }, |
||
| 1244 | { "glGetnMapdvARB", _O(GetnMapdvARB) }, |
||
| 1245 | { "glGetnMapfvARB", _O(GetnMapfvARB) }, |
||
| 1246 | { "glGetnMapivARB", _O(GetnMapivARB) }, |
||
| 1247 | { "glGetnMinmaxARB", _O(GetnMinmaxARB) }, |
||
| 1248 | { "glGetnPixelMapfvARB", _O(GetnPixelMapfvARB) }, |
||
| 1249 | { "glGetnPixelMapuivARB", _O(GetnPixelMapuivARB) }, |
||
| 1250 | { "glGetnPixelMapusvARB", _O(GetnPixelMapusvARB) }, |
||
| 1251 | { "glGetnPolygonStippleARB", _O(GetnPolygonStippleARB) }, |
||
| 1252 | { "glGetnSeparableFilterARB", _O(GetnSeparableFilterARB) }, |
||
| 1253 | { "glGetnTexImageARB", _O(GetnTexImageARB) }, |
||
| 1254 | { "glGetnUniformdvARB", _O(GetnUniformdvARB) }, |
||
| 1255 | { "glGetnUniformfvARB", _O(GetnUniformfvARB) }, |
||
| 1256 | { "glGetnUniformivARB", _O(GetnUniformivARB) }, |
||
| 1257 | { "glGetnUniformuivARB", _O(GetnUniformuivARB) }, |
||
| 1258 | { "glReadnPixelsARB", _O(ReadnPixelsARB) }, |
||
| 1259 | { "glTexStorage1D", _O(TexStorage1D) }, |
||
| 1260 | { "glTexStorage2D", _O(TexStorage2D) }, |
||
| 1261 | { "glTexStorage3D", _O(TexStorage3D) }, |
||
| 1262 | { "glTextureStorage1DEXT", _O(TextureStorage1DEXT) }, |
||
| 1263 | { "glTextureStorage2DEXT", _O(TextureStorage2DEXT) }, |
||
| 1264 | { "glTextureStorage3DEXT", _O(TextureStorage3DEXT) }, |
||
| 1265 | { "glPolygonOffsetEXT", _O(PolygonOffsetEXT) }, |
||
| 1266 | { "glSampleMaskSGIS", _O(SampleMaskSGIS) }, |
||
| 1267 | { "glSamplePatternSGIS", _O(SamplePatternSGIS) }, |
||
| 1268 | { "glColorPointerEXT", _O(ColorPointerEXT) }, |
||
| 1269 | { "glEdgeFlagPointerEXT", _O(EdgeFlagPointerEXT) }, |
||
| 1270 | { "glIndexPointerEXT", _O(IndexPointerEXT) }, |
||
| 1271 | { "glNormalPointerEXT", _O(NormalPointerEXT) }, |
||
| 1272 | { "glTexCoordPointerEXT", _O(TexCoordPointerEXT) }, |
||
| 1273 | { "glVertexPointerEXT", _O(VertexPointerEXT) }, |
||
| 1274 | { "glPointParameterf", _O(PointParameterf) }, |
||
| 1275 | { "glPointParameterfv", _O(PointParameterfv) }, |
||
| 1276 | { "glLockArraysEXT", _O(LockArraysEXT) }, |
||
| 1277 | { "glUnlockArraysEXT", _O(UnlockArraysEXT) }, |
||
| 1278 | { "glSecondaryColor3b", _O(SecondaryColor3b) }, |
||
| 1279 | { "glSecondaryColor3bv", _O(SecondaryColor3bv) }, |
||
| 1280 | { "glSecondaryColor3d", _O(SecondaryColor3d) }, |
||
| 1281 | { "glSecondaryColor3dv", _O(SecondaryColor3dv) }, |
||
| 1282 | { "glSecondaryColor3fEXT", _O(SecondaryColor3fEXT) }, |
||
| 1283 | { "glSecondaryColor3fvEXT", _O(SecondaryColor3fvEXT) }, |
||
| 1284 | { "glSecondaryColor3i", _O(SecondaryColor3i) }, |
||
| 1285 | { "glSecondaryColor3iv", _O(SecondaryColor3iv) }, |
||
| 1286 | { "glSecondaryColor3s", _O(SecondaryColor3s) }, |
||
| 1287 | { "glSecondaryColor3sv", _O(SecondaryColor3sv) }, |
||
| 1288 | { "glSecondaryColor3ub", _O(SecondaryColor3ub) }, |
||
| 1289 | { "glSecondaryColor3ubv", _O(SecondaryColor3ubv) }, |
||
| 1290 | { "glSecondaryColor3ui", _O(SecondaryColor3ui) }, |
||
| 1291 | { "glSecondaryColor3uiv", _O(SecondaryColor3uiv) }, |
||
| 1292 | { "glSecondaryColor3us", _O(SecondaryColor3us) }, |
||
| 1293 | { "glSecondaryColor3usv", _O(SecondaryColor3usv) }, |
||
| 1294 | { "glSecondaryColorPointer", _O(SecondaryColorPointer) }, |
||
| 1295 | { "glMultiDrawArrays", _O(MultiDrawArrays) }, |
||
| 1296 | { "glMultiDrawElementsEXT", _O(MultiDrawElementsEXT) }, |
||
| 1297 | { "glFogCoordPointer", _O(FogCoordPointer) }, |
||
| 1298 | { "glFogCoordd", _O(FogCoordd) }, |
||
| 1299 | { "glFogCoorddv", _O(FogCoorddv) }, |
||
| 1300 | { "glFogCoordfEXT", _O(FogCoordfEXT) }, |
||
| 1301 | { "glFogCoordfvEXT", _O(FogCoordfvEXT) }, |
||
| 1302 | { "glBlendFuncSeparate", _O(BlendFuncSeparate) }, |
||
| 1303 | { "glResizeBuffersMESA", _O(ResizeBuffersMESA) }, |
||
| 1304 | { "glWindowPos2d", _O(WindowPos2d) }, |
||
| 1305 | { "glWindowPos2dv", _O(WindowPos2dv) }, |
||
| 1306 | { "glWindowPos2f", _O(WindowPos2f) }, |
||
| 1307 | { "glWindowPos2fv", _O(WindowPos2fv) }, |
||
| 1308 | { "glWindowPos2i", _O(WindowPos2i) }, |
||
| 1309 | { "glWindowPos2iv", _O(WindowPos2iv) }, |
||
| 1310 | { "glWindowPos2s", _O(WindowPos2s) }, |
||
| 1311 | { "glWindowPos2sv", _O(WindowPos2sv) }, |
||
| 1312 | { "glWindowPos3d", _O(WindowPos3d) }, |
||
| 1313 | { "glWindowPos3dv", _O(WindowPos3dv) }, |
||
| 1314 | { "glWindowPos3f", _O(WindowPos3f) }, |
||
| 1315 | { "glWindowPos3fv", _O(WindowPos3fv) }, |
||
| 1316 | { "glWindowPos3i", _O(WindowPos3i) }, |
||
| 1317 | { "glWindowPos3iv", _O(WindowPos3iv) }, |
||
| 1318 | { "glWindowPos3s", _O(WindowPos3s) }, |
||
| 1319 | { "glWindowPos3sv", _O(WindowPos3sv) }, |
||
| 1320 | { "glWindowPos4dMESA", _O(WindowPos4dMESA) }, |
||
| 1321 | { "glWindowPos4dvMESA", _O(WindowPos4dvMESA) }, |
||
| 1322 | { "glWindowPos4fMESA", _O(WindowPos4fMESA) }, |
||
| 1323 | { "glWindowPos4fvMESA", _O(WindowPos4fvMESA) }, |
||
| 1324 | { "glWindowPos4iMESA", _O(WindowPos4iMESA) }, |
||
| 1325 | { "glWindowPos4ivMESA", _O(WindowPos4ivMESA) }, |
||
| 1326 | { "glWindowPos4sMESA", _O(WindowPos4sMESA) }, |
||
| 1327 | { "glWindowPos4svMESA", _O(WindowPos4svMESA) }, |
||
| 1328 | { "glMultiModeDrawArraysIBM", _O(MultiModeDrawArraysIBM) }, |
||
| 1329 | { "glMultiModeDrawElementsIBM", _O(MultiModeDrawElementsIBM) }, |
||
| 1330 | { "glAreProgramsResidentNV", _O(AreProgramsResidentNV) }, |
||
| 1331 | { "glBindProgramARB", _O(BindProgramARB) }, |
||
| 1332 | { "glDeleteProgramsARB", _O(DeleteProgramsARB) }, |
||
| 1333 | { "glExecuteProgramNV", _O(ExecuteProgramNV) }, |
||
| 1334 | { "glGenProgramsARB", _O(GenProgramsARB) }, |
||
| 1335 | { "glGetProgramParameterdvNV", _O(GetProgramParameterdvNV) }, |
||
| 1336 | { "glGetProgramParameterfvNV", _O(GetProgramParameterfvNV) }, |
||
| 1337 | { "glGetProgramStringNV", _O(GetProgramStringNV) }, |
||
| 1338 | { "glGetProgramivNV", _O(GetProgramivNV) }, |
||
| 1339 | { "glGetTrackMatrixivNV", _O(GetTrackMatrixivNV) }, |
||
| 1340 | { "glGetVertexAttribPointerv", _O(GetVertexAttribPointerv) }, |
||
| 1341 | { "glGetVertexAttribdvNV", _O(GetVertexAttribdvNV) }, |
||
| 1342 | { "glGetVertexAttribfvNV", _O(GetVertexAttribfvNV) }, |
||
| 1343 | { "glGetVertexAttribivNV", _O(GetVertexAttribivNV) }, |
||
| 1344 | { "glIsProgram", _O(IsProgram) }, |
||
| 1345 | { "glLoadProgramNV", _O(LoadProgramNV) }, |
||
| 1346 | { "glProgramParameters4dvNV", _O(ProgramParameters4dvNV) }, |
||
| 1347 | { "glProgramParameters4fvNV", _O(ProgramParameters4fvNV) }, |
||
| 1348 | { "glRequestResidentProgramsNV", _O(RequestResidentProgramsNV) }, |
||
| 1349 | { "glTrackMatrixNV", _O(TrackMatrixNV) }, |
||
| 1350 | { "glVertexAttrib1dNV", _O(VertexAttrib1dNV) }, |
||
| 1351 | { "glVertexAttrib1dvNV", _O(VertexAttrib1dvNV) }, |
||
| 1352 | { "glVertexAttrib1fNV", _O(VertexAttrib1fNV) }, |
||
| 1353 | { "glVertexAttrib1fvNV", _O(VertexAttrib1fvNV) }, |
||
| 1354 | { "glVertexAttrib1sNV", _O(VertexAttrib1sNV) }, |
||
| 1355 | { "glVertexAttrib1svNV", _O(VertexAttrib1svNV) }, |
||
| 1356 | { "glVertexAttrib2dNV", _O(VertexAttrib2dNV) }, |
||
| 1357 | { "glVertexAttrib2dvNV", _O(VertexAttrib2dvNV) }, |
||
| 1358 | { "glVertexAttrib2fNV", _O(VertexAttrib2fNV) }, |
||
| 1359 | { "glVertexAttrib2fvNV", _O(VertexAttrib2fvNV) }, |
||
| 1360 | { "glVertexAttrib2sNV", _O(VertexAttrib2sNV) }, |
||
| 1361 | { "glVertexAttrib2svNV", _O(VertexAttrib2svNV) }, |
||
| 1362 | { "glVertexAttrib3dNV", _O(VertexAttrib3dNV) }, |
||
| 1363 | { "glVertexAttrib3dvNV", _O(VertexAttrib3dvNV) }, |
||
| 1364 | { "glVertexAttrib3fNV", _O(VertexAttrib3fNV) }, |
||
| 1365 | { "glVertexAttrib3fvNV", _O(VertexAttrib3fvNV) }, |
||
| 1366 | { "glVertexAttrib3sNV", _O(VertexAttrib3sNV) }, |
||
| 1367 | { "glVertexAttrib3svNV", _O(VertexAttrib3svNV) }, |
||
| 1368 | { "glVertexAttrib4dNV", _O(VertexAttrib4dNV) }, |
||
| 1369 | { "glVertexAttrib4dvNV", _O(VertexAttrib4dvNV) }, |
||
| 1370 | { "glVertexAttrib4fNV", _O(VertexAttrib4fNV) }, |
||
| 1371 | { "glVertexAttrib4fvNV", _O(VertexAttrib4fvNV) }, |
||
| 1372 | { "glVertexAttrib4sNV", _O(VertexAttrib4sNV) }, |
||
| 1373 | { "glVertexAttrib4svNV", _O(VertexAttrib4svNV) }, |
||
| 1374 | { "glVertexAttrib4ubNV", _O(VertexAttrib4ubNV) }, |
||
| 1375 | { "glVertexAttrib4ubvNV", _O(VertexAttrib4ubvNV) }, |
||
| 1376 | { "glVertexAttribPointerNV", _O(VertexAttribPointerNV) }, |
||
| 1377 | { "glVertexAttribs1dvNV", _O(VertexAttribs1dvNV) }, |
||
| 1378 | { "glVertexAttribs1fvNV", _O(VertexAttribs1fvNV) }, |
||
| 1379 | { "glVertexAttribs1svNV", _O(VertexAttribs1svNV) }, |
||
| 1380 | { "glVertexAttribs2dvNV", _O(VertexAttribs2dvNV) }, |
||
| 1381 | { "glVertexAttribs2fvNV", _O(VertexAttribs2fvNV) }, |
||
| 1382 | { "glVertexAttribs2svNV", _O(VertexAttribs2svNV) }, |
||
| 1383 | { "glVertexAttribs3dvNV", _O(VertexAttribs3dvNV) }, |
||
| 1384 | { "glVertexAttribs3fvNV", _O(VertexAttribs3fvNV) }, |
||
| 1385 | { "glVertexAttribs3svNV", _O(VertexAttribs3svNV) }, |
||
| 1386 | { "glVertexAttribs4dvNV", _O(VertexAttribs4dvNV) }, |
||
| 1387 | { "glVertexAttribs4fvNV", _O(VertexAttribs4fvNV) }, |
||
| 1388 | { "glVertexAttribs4svNV", _O(VertexAttribs4svNV) }, |
||
| 1389 | { "glVertexAttribs4ubvNV", _O(VertexAttribs4ubvNV) }, |
||
| 1390 | { "glAlphaFragmentOp1ATI", _O(AlphaFragmentOp1ATI) }, |
||
| 1391 | { "glAlphaFragmentOp2ATI", _O(AlphaFragmentOp2ATI) }, |
||
| 1392 | { "glAlphaFragmentOp3ATI", _O(AlphaFragmentOp3ATI) }, |
||
| 1393 | { "glBeginFragmentShaderATI", _O(BeginFragmentShaderATI) }, |
||
| 1394 | { "glBindFragmentShaderATI", _O(BindFragmentShaderATI) }, |
||
| 1395 | { "glColorFragmentOp1ATI", _O(ColorFragmentOp1ATI) }, |
||
| 1396 | { "glColorFragmentOp2ATI", _O(ColorFragmentOp2ATI) }, |
||
| 1397 | { "glColorFragmentOp3ATI", _O(ColorFragmentOp3ATI) }, |
||
| 1398 | { "glDeleteFragmentShaderATI", _O(DeleteFragmentShaderATI) }, |
||
| 1399 | { "glEndFragmentShaderATI", _O(EndFragmentShaderATI) }, |
||
| 1400 | { "glGenFragmentShadersATI", _O(GenFragmentShadersATI) }, |
||
| 1401 | { "glPassTexCoordATI", _O(PassTexCoordATI) }, |
||
| 1402 | { "glSampleMapATI", _O(SampleMapATI) }, |
||
| 1403 | { "glSetFragmentShaderConstantATI", _O(SetFragmentShaderConstantATI) }, |
||
| 1404 | { "glPointParameteri", _O(PointParameteri) }, |
||
| 1405 | { "glPointParameteriv", _O(PointParameteriv) }, |
||
| 1406 | { "glActiveStencilFaceEXT", _O(ActiveStencilFaceEXT) }, |
||
| 1407 | { "glBindVertexArrayAPPLE", _O(BindVertexArrayAPPLE) }, |
||
| 1408 | { "glDeleteVertexArrays", _O(DeleteVertexArrays) }, |
||
| 1409 | { "glGenVertexArraysAPPLE", _O(GenVertexArraysAPPLE) }, |
||
| 1410 | { "glIsVertexArray", _O(IsVertexArray) }, |
||
| 1411 | { "glGetProgramNamedParameterdvNV", _O(GetProgramNamedParameterdvNV) }, |
||
| 1412 | { "glGetProgramNamedParameterfvNV", _O(GetProgramNamedParameterfvNV) }, |
||
| 1413 | { "glProgramNamedParameter4dNV", _O(ProgramNamedParameter4dNV) }, |
||
| 1414 | { "glProgramNamedParameter4dvNV", _O(ProgramNamedParameter4dvNV) }, |
||
| 1415 | { "glProgramNamedParameter4fNV", _O(ProgramNamedParameter4fNV) }, |
||
| 1416 | { "glProgramNamedParameter4fvNV", _O(ProgramNamedParameter4fvNV) }, |
||
| 1417 | { "glPrimitiveRestartIndex", _O(PrimitiveRestartIndex) }, |
||
| 1418 | { "glPrimitiveRestartNV", _O(PrimitiveRestartNV) }, |
||
| 1419 | { "glDepthBoundsEXT", _O(DepthBoundsEXT) }, |
||
| 1420 | { "glBlendEquationSeparate", _O(BlendEquationSeparate) }, |
||
| 1421 | { "glBindFramebuffer", _O(BindFramebuffer) }, |
||
| 1422 | { "glBindRenderbuffer", _O(BindRenderbuffer) }, |
||
| 1423 | { "glCheckFramebufferStatus", _O(CheckFramebufferStatus) }, |
||
| 1424 | { "glDeleteFramebuffers", _O(DeleteFramebuffers) }, |
||
| 1425 | { "glDeleteRenderbuffers", _O(DeleteRenderbuffers) }, |
||
| 1426 | { "glFramebufferRenderbuffer", _O(FramebufferRenderbuffer) }, |
||
| 1427 | { "glFramebufferTexture1D", _O(FramebufferTexture1D) }, |
||
| 1428 | { "glFramebufferTexture2D", _O(FramebufferTexture2D) }, |
||
| 1429 | { "glFramebufferTexture3D", _O(FramebufferTexture3D) }, |
||
| 1430 | { "glGenFramebuffers", _O(GenFramebuffers) }, |
||
| 1431 | { "glGenRenderbuffers", _O(GenRenderbuffers) }, |
||
| 1432 | { "glGenerateMipmap", _O(GenerateMipmap) }, |
||
| 1433 | { "glGetFramebufferAttachmentParameteriv", _O(GetFramebufferAttachmentParameteriv) }, |
||
| 1434 | { "glGetRenderbufferParameteriv", _O(GetRenderbufferParameteriv) }, |
||
| 1435 | { "glIsFramebuffer", _O(IsFramebuffer) }, |
||
| 1436 | { "glIsRenderbuffer", _O(IsRenderbuffer) }, |
||
| 1437 | { "glRenderbufferStorage", _O(RenderbufferStorage) }, |
||
| 1438 | { "glBlitFramebuffer", _O(BlitFramebuffer) }, |
||
| 1439 | { "glBufferParameteriAPPLE", _O(BufferParameteriAPPLE) }, |
||
| 1440 | { "glFlushMappedBufferRangeAPPLE", _O(FlushMappedBufferRangeAPPLE) }, |
||
| 1441 | { "glBindFragDataLocation", _O(BindFragDataLocation) }, |
||
| 1442 | { "glGetFragDataLocation", _O(GetFragDataLocation) }, |
||
| 1443 | { "glGetUniformuiv", _O(GetUniformuiv) }, |
||
| 1444 | { "glGetVertexAttribIiv", _O(GetVertexAttribIiv) }, |
||
| 1445 | { "glGetVertexAttribIuiv", _O(GetVertexAttribIuiv) }, |
||
| 1446 | { "glUniform1ui", _O(Uniform1ui) }, |
||
| 1447 | { "glUniform1uiv", _O(Uniform1uiv) }, |
||
| 1448 | { "glUniform2ui", _O(Uniform2ui) }, |
||
| 1449 | { "glUniform2uiv", _O(Uniform2uiv) }, |
||
| 1450 | { "glUniform3ui", _O(Uniform3ui) }, |
||
| 1451 | { "glUniform3uiv", _O(Uniform3uiv) }, |
||
| 1452 | { "glUniform4ui", _O(Uniform4ui) }, |
||
| 1453 | { "glUniform4uiv", _O(Uniform4uiv) }, |
||
| 1454 | { "glVertexAttribI1iEXT", _O(VertexAttribI1iEXT) }, |
||
| 1455 | { "glVertexAttribI1iv", _O(VertexAttribI1iv) }, |
||
| 1456 | { "glVertexAttribI1uiEXT", _O(VertexAttribI1uiEXT) }, |
||
| 1457 | { "glVertexAttribI1uiv", _O(VertexAttribI1uiv) }, |
||
| 1458 | { "glVertexAttribI2iEXT", _O(VertexAttribI2iEXT) }, |
||
| 1459 | { "glVertexAttribI2ivEXT", _O(VertexAttribI2ivEXT) }, |
||
| 1460 | { "glVertexAttribI2uiEXT", _O(VertexAttribI2uiEXT) }, |
||
| 1461 | { "glVertexAttribI2uivEXT", _O(VertexAttribI2uivEXT) }, |
||
| 1462 | { "glVertexAttribI3iEXT", _O(VertexAttribI3iEXT) }, |
||
| 1463 | { "glVertexAttribI3ivEXT", _O(VertexAttribI3ivEXT) }, |
||
| 1464 | { "glVertexAttribI3uiEXT", _O(VertexAttribI3uiEXT) }, |
||
| 1465 | { "glVertexAttribI3uivEXT", _O(VertexAttribI3uivEXT) }, |
||
| 1466 | { "glVertexAttribI4bv", _O(VertexAttribI4bv) }, |
||
| 1467 | { "glVertexAttribI4iEXT", _O(VertexAttribI4iEXT) }, |
||
| 1468 | { "glVertexAttribI4ivEXT", _O(VertexAttribI4ivEXT) }, |
||
| 1469 | { "glVertexAttribI4sv", _O(VertexAttribI4sv) }, |
||
| 1470 | { "glVertexAttribI4ubv", _O(VertexAttribI4ubv) }, |
||
| 1471 | { "glVertexAttribI4uiEXT", _O(VertexAttribI4uiEXT) }, |
||
| 1472 | { "glVertexAttribI4uivEXT", _O(VertexAttribI4uivEXT) }, |
||
| 1473 | { "glVertexAttribI4usv", _O(VertexAttribI4usv) }, |
||
| 1474 | { "glVertexAttribIPointer", _O(VertexAttribIPointer) }, |
||
| 1475 | { "glFramebufferTextureLayer", _O(FramebufferTextureLayer) }, |
||
| 1476 | { "glColorMaski", _O(ColorMaski) }, |
||
| 1477 | { "glDisablei", _O(Disablei) }, |
||
| 1478 | { "glEnablei", _O(Enablei) }, |
||
| 1479 | { "glGetBooleani_v", _O(GetBooleani_v) }, |
||
| 1480 | { "glGetIntegeri_v", _O(GetIntegeri_v) }, |
||
| 1481 | { "glIsEnabledi", _O(IsEnabledi) }, |
||
| 1482 | { "glClearColorIiEXT", _O(ClearColorIiEXT) }, |
||
| 1483 | { "glClearColorIuiEXT", _O(ClearColorIuiEXT) }, |
||
| 1484 | { "glGetTexParameterIiv", _O(GetTexParameterIiv) }, |
||
| 1485 | { "glGetTexParameterIuiv", _O(GetTexParameterIuiv) }, |
||
| 1486 | { "glTexParameterIiv", _O(TexParameterIiv) }, |
||
| 1487 | { "glTexParameterIuiv", _O(TexParameterIuiv) }, |
||
| 1488 | { "glBeginConditionalRender", _O(BeginConditionalRender) }, |
||
| 1489 | { "glEndConditionalRender", _O(EndConditionalRender) }, |
||
| 1490 | { "glBeginTransformFeedback", _O(BeginTransformFeedback) }, |
||
| 1491 | { "glBindBufferBase", _O(BindBufferBase) }, |
||
| 1492 | { "glBindBufferOffsetEXT", _O(BindBufferOffsetEXT) }, |
||
| 1493 | { "glBindBufferRange", _O(BindBufferRange) }, |
||
| 1494 | { "glEndTransformFeedback", _O(EndTransformFeedback) }, |
||
| 1495 | { "glGetTransformFeedbackVarying", _O(GetTransformFeedbackVarying) }, |
||
| 1496 | { "glTransformFeedbackVaryings", _O(TransformFeedbackVaryings) }, |
||
| 1497 | { "glProvokingVertex", _O(ProvokingVertex) }, |
||
| 1498 | { "glGetObjectParameterivAPPLE", _O(GetObjectParameterivAPPLE) }, |
||
| 1499 | { "glObjectPurgeableAPPLE", _O(ObjectPurgeableAPPLE) }, |
||
| 1500 | { "glObjectUnpurgeableAPPLE", _O(ObjectUnpurgeableAPPLE) }, |
||
| 1501 | { "glActiveProgramEXT", _O(ActiveProgramEXT) }, |
||
| 1502 | { "glCreateShaderProgramEXT", _O(CreateShaderProgramEXT) }, |
||
| 1503 | { "glUseShaderProgramEXT", _O(UseShaderProgramEXT) }, |
||
| 1504 | { "glTextureBarrierNV", _O(TextureBarrierNV) }, |
||
| 1505 | { "glStencilFuncSeparateATI", _O(StencilFuncSeparateATI) }, |
||
| 1506 | { "glProgramEnvParameters4fvEXT", _O(ProgramEnvParameters4fvEXT) }, |
||
| 1507 | { "glProgramLocalParameters4fvEXT", _O(ProgramLocalParameters4fvEXT) }, |
||
| 1508 | { "glGetQueryObjecti64v", _O(GetQueryObjecti64v) }, |
||
| 1509 | { "glGetQueryObjectui64v", _O(GetQueryObjectui64v) }, |
||
| 1510 | { "glEGLImageTargetRenderbufferStorageOES", _O(EGLImageTargetRenderbufferStorageOES) }, |
||
| 1511 | { "glEGLImageTargetTexture2DOES", _O(EGLImageTargetTexture2DOES) }, |
||
| 1512 | { NULL, 0 } |
||
| 1513 | }; |
||
| 1514 | |||
| 1515 | #ifdef GLX_INDIRECT_RENDERING |
||
| 1516 | extern "C" { |
||
| 1517 | GLAPI GLboolean GLAPIENTRY |
||
| 1518 | glAreTexturesResidentEXT(GLsizei n, const GLuint *textures, |
||
| 1519 | GLboolean *residences) |
||
| 1520 | { |
||
| 1521 | (void) n; |
||
| 1522 | (void) textures; |
||
| 1523 | (void) residences; |
||
| 1524 | return GL_FALSE; |
||
| 1525 | } |
||
| 1526 | |||
| 1527 | GLAPI void GLAPIENTRY |
||
| 1528 | glDeleteTexturesEXT(GLsizei n, const GLuint *textures) |
||
| 1529 | { |
||
| 1530 | (void) n; |
||
| 1531 | (void) textures; |
||
| 1532 | } |
||
| 1533 | |||
| 1534 | GLAPI void GLAPIENTRY |
||
| 1535 | glGenTexturesEXT(GLsizei n, GLuint *textures) |
||
| 1536 | { |
||
| 1537 | (void) n; |
||
| 1538 | (void) textures; |
||
| 1539 | } |
||
| 1540 | |||
| 1541 | GLAPI GLboolean GLAPIENTRY |
||
| 1542 | glIsTextureEXT(GLuint texture) |
||
| 1543 | { |
||
| 1544 | (void) texture; |
||
| 1545 | return GL_FALSE; |
||
| 1546 | } |
||
| 1547 | |||
| 1548 | GLAPI void GLAPIENTRY |
||
| 1549 | glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid *table) |
||
| 1550 | { |
||
| 1551 | (void) target; |
||
| 1552 | (void) format; |
||
| 1553 | (void) type; |
||
| 1554 | (void) table; |
||
| 1555 | } |
||
| 1556 | |||
| 1557 | GLAPI void GLAPIENTRY |
||
| 1558 | glGetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat *params) |
||
| 1559 | { |
||
| 1560 | (void) target; |
||
| 1561 | (void) pname; |
||
| 1562 | (void) params; |
||
| 1563 | } |
||
| 1564 | |||
| 1565 | GLAPI void GLAPIENTRY |
||
| 1566 | glGetColorTableParameterivEXT(GLenum target, GLenum pname, GLint *params) |
||
| 1567 | { |
||
| 1568 | (void) target; |
||
| 1569 | (void) pname; |
||
| 1570 | (void) params; |
||
| 1571 | } |
||
| 1572 | |||
| 1573 | void GLAPIENTRY |
||
| 1574 | gl_dispatch_stub_356(GLenum target, GLenum format, GLenum type, GLvoid * image) |
||
| 1575 | { |
||
| 1576 | (void) target; |
||
| 1577 | (void) format; |
||
| 1578 | (void) type; |
||
| 1579 | (void) image; |
||
| 1580 | } |
||
| 1581 | |||
| 1582 | void GLAPIENTRY |
||
| 1583 | gl_dispatch_stub_357(GLenum target, GLenum pname, GLfloat * params) |
||
| 1584 | { |
||
| 1585 | (void) target; |
||
| 1586 | (void) pname; |
||
| 1587 | (void) params; |
||
| 1588 | } |
||
| 1589 | |||
| 1590 | void GLAPIENTRY |
||
| 1591 | gl_dispatch_stub_358(GLenum target, GLenum pname, GLint * params) |
||
| 1592 | { |
||
| 1593 | (void) target; |
||
| 1594 | (void) pname; |
||
| 1595 | (void) params; |
||
| 1596 | } |
||
| 1597 | |||
| 1598 | void GLAPIENTRY |
||
| 1599 | gl_dispatch_stub_359(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span) |
||
| 1600 | { |
||
| 1601 | (void) target; |
||
| 1602 | (void) format; |
||
| 1603 | (void) type; |
||
| 1604 | (void) row; |
||
| 1605 | (void) column; |
||
| 1606 | (void) span; |
||
| 1607 | } |
||
| 1608 | |||
| 1609 | void GLAPIENTRY |
||
| 1610 | gl_dispatch_stub_361(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values) |
||
| 1611 | { |
||
| 1612 | (void) target; |
||
| 1613 | (void) reset; |
||
| 1614 | (void) format; |
||
| 1615 | (void) type; |
||
| 1616 | (void) values; |
||
| 1617 | } |
||
| 1618 | |||
| 1619 | void GLAPIENTRY |
||
| 1620 | gl_dispatch_stub_362(GLenum target, GLenum pname, GLfloat * params) |
||
| 1621 | { |
||
| 1622 | (void) target; |
||
| 1623 | (void) pname; |
||
| 1624 | (void) params; |
||
| 1625 | } |
||
| 1626 | |||
| 1627 | void GLAPIENTRY |
||
| 1628 | gl_dispatch_stub_363(GLenum target, GLenum pname, GLint * params) |
||
| 1629 | { |
||
| 1630 | (void) target; |
||
| 1631 | (void) pname; |
||
| 1632 | (void) params; |
||
| 1633 | } |
||
| 1634 | |||
| 1635 | void GLAPIENTRY |
||
| 1636 | gl_dispatch_stub_364(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values) |
||
| 1637 | { |
||
| 1638 | (void) target; |
||
| 1639 | (void) reset; |
||
| 1640 | (void) format; |
||
| 1641 | (void) type; |
||
| 1642 | (void) values; |
||
| 1643 | } |
||
| 1644 | |||
| 1645 | void GLAPIENTRY |
||
| 1646 | gl_dispatch_stub_365(GLenum target, GLenum pname, GLfloat * params) |
||
| 1647 | { |
||
| 1648 | (void) target; |
||
| 1649 | (void) pname; |
||
| 1650 | (void) params; |
||
| 1651 | } |
||
| 1652 | |||
| 1653 | void GLAPIENTRY |
||
| 1654 | gl_dispatch_stub_366(GLenum target, GLenum pname, GLint * params) |
||
| 1655 | { |
||
| 1656 | (void) target; |
||
| 1657 | (void) pname; |
||
| 1658 | (void) params; |
||
| 1659 | } |
||
| 1660 | |||
| 1661 | } |
||
| 1662 | #endif |