From d66fa61e097aa801c381d7b00972abb667aee220 Mon Sep 17 00:00:00 2001 From: Alexandre Julliard Date: Wed, 18 Jul 2012 13:07:08 +0200 Subject: [PATCH] opengl32: Call OpenGL extension functions through the TEB function table. --- dlls/opengl32/make_opengl | 42 +- dlls/opengl32/opengl_ext.c | 10333 +++++++++++++++++-------------------------- dlls/opengl32/opengl_ext.h | 1 - dlls/opengl32/wgl.c | 4 +- 4 files changed, 4147 insertions(+), 6233 deletions(-) diff --git a/dlls/opengl32/make_opengl b/dlls/opengl32/make_opengl index c5bc95b065b..9773a4af405 100755 --- a/dlls/opengl32/make_opengl +++ b/dlls/opengl32/make_opengl @@ -225,9 +225,9 @@ sub ConvertVarName($) # # This functions generates the thunk for a given function. # -sub GenerateThunk($$$$) +sub GenerateThunk($$$) { - my ($func_ref, $comment, $prefix, $local_var) = @_; + my ($func_ref, $comment, $prefix) = @_; my $ret = ""; my $call_arg = ""; my $trace_call_arg = ""; @@ -283,11 +283,10 @@ sub GenerateThunk($$$$) } $ret .= 'void ' if (!@{$func_ref->[2]}); $ret .= ") {\n"; - $ret .= " const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;\n" unless $local_var; + $ret .= " const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;\n"; if ($func_ref->[1] ne "void" && $gen_thread_safe) { $ret = "$ret " . ConvertType($func_ref->[1]) . " ret_value;\n"; } - $ret .= $local_var; if ($gen_traces) { $ret = "$ret TRACE(\"($trace_arg)\\n\""; if ($trace_arg ne "") { @@ -301,7 +300,7 @@ sub GenerateThunk($$$$) if ($func_ref->[1] ne "void") { $ret .= "ret_value = "; } - $ret .= "$prefix$func_ref->[0]( $call_arg);\n"; + $ret .= "funcs->$prefix.p_$func_ref->[0]( $call_arg);\n"; $ret .= " LEAVE_GL();\n"; if ($func_ref->[1] ne "void") { $ret .= " return ret_value;\n" @@ -312,7 +311,7 @@ sub GenerateThunk($$$$) if ($func_ref->[1] ne "void") { $ret .= "return "; } - $ret .= "$prefix$func_ref->[0]( $call_arg);\n"; + $ret .= "funcs->$prefix.p_$func_ref->[0]( $call_arg);\n"; } $ret = "$ret}\n"; @@ -809,7 +808,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(opengl); "; foreach (sort keys %norm_functions) { - my $string = GenerateThunk($norm_functions{$_}, 1, "funcs->gl.p_", ""); + my $string = GenerateThunk($norm_functions{$_}, 1, "gl"); print NORM "\n$string" if $string; } @@ -833,7 +832,10 @@ print EXT " /* Auto-generated file... Do not edit ! */ #include \"config.h\" +#include #include \"opengl_ext.h\" +#include \"winternl.h\" +#include \"wine/wgl_driver.h\" #include \"wine/debug.h\" WINE_DEFAULT_DEBUG_CHANNEL(opengl); @@ -842,35 +844,15 @@ WINE_DEFAULT_DEBUG_CHANNEL(opengl); # The thunks themselves.... my $count = keys %ext_functions; -print EXT "enum extensions\n{\n"; -foreach (sort keys %ext_functions) { - my $func_ref = $ext_functions{$_}; - print EXT " EXT_$func_ref->[0],\n"; -} -print EXT " NB_EXTENSIONS\n};\n\n"; -print EXT "const int extension_registry_size = NB_EXTENSIONS;\n"; -print EXT "void *extension_funcs[NB_EXTENSIONS];\n"; +print EXT "const int extension_registry_size = $count;\n"; print EXT "\n/* The thunks themselves....*/"; foreach (sort keys %ext_functions) { - my $func_ref = $ext_functions{$_}; - my $local_var = " " . ConvertType($func_ref->[1]) . " (*$ext_prefix$func_ref->[0])( "; - for (my $i = 0; $i < @{$func_ref->[2]}; $i++) { - my $type = ConvertType($func_ref->[2]->[$i]->[0]); - $local_var .= "$type"; - if ($i+1 < @{$func_ref->[2]}) { - $local_var .= ", "; - } else { - $local_var .= " "; - } - } - $local_var .= 'void ' if (!@{$func_ref->[2]}); - $local_var .= ") = extension_funcs[EXT_$func_ref->[0]];\n"; - print EXT "\nstatic ", GenerateThunk($ext_functions{$_}, 0, $ext_prefix, $local_var); + print EXT "\nstatic ", GenerateThunk($ext_functions{$_}, 0, "ext"); } # Then the table giving the string <-> function correspondence */ print EXT "\n\n/* The table giving the correspondence between names and functions */\n"; -print EXT "const OpenGL_extension extension_registry[NB_EXTENSIONS] = {\n"; +print EXT "const OpenGL_extension extension_registry[$count] = {\n"; my $i = 0; foreach (sort keys %ext_functions) { my $func_ref = $ext_functions{$_}; diff --git a/dlls/opengl32/opengl_ext.c b/dlls/opengl32/opengl_ext.c index 257ea082086..2e8b49b6717 100644 --- a/dlls/opengl32/opengl_ext.c +++ b/dlls/opengl32/opengl_ext.c @@ -2,14471 +2,12404 @@ /* Auto-generated file... Do not edit ! */ #include "config.h" +#include #include "opengl_ext.h" +#include "winternl.h" +#include "wine/wgl_driver.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(opengl); -enum extensions -{ - EXT_glActiveProgramEXT, - EXT_glActiveShaderProgram, - EXT_glActiveStencilFaceEXT, - EXT_glActiveTexture, - EXT_glActiveTextureARB, - EXT_glActiveVaryingNV, - EXT_glAlphaFragmentOp1ATI, - EXT_glAlphaFragmentOp2ATI, - EXT_glAlphaFragmentOp3ATI, - EXT_glApplyTextureEXT, - EXT_glAreProgramsResidentNV, - EXT_glAreTexturesResidentEXT, - EXT_glArrayElementEXT, - EXT_glArrayObjectATI, - EXT_glAsyncMarkerSGIX, - EXT_glAttachObjectARB, - EXT_glAttachShader, - EXT_glBeginConditionalRender, - EXT_glBeginConditionalRenderNV, - EXT_glBeginFragmentShaderATI, - EXT_glBeginOcclusionQueryNV, - EXT_glBeginPerfMonitorAMD, - EXT_glBeginQuery, - EXT_glBeginQueryARB, - EXT_glBeginQueryIndexed, - EXT_glBeginTransformFeedback, - EXT_glBeginTransformFeedbackEXT, - EXT_glBeginTransformFeedbackNV, - EXT_glBeginVertexShaderEXT, - EXT_glBeginVideoCaptureNV, - EXT_glBindAttribLocation, - EXT_glBindAttribLocationARB, - EXT_glBindBuffer, - EXT_glBindBufferARB, - EXT_glBindBufferBase, - EXT_glBindBufferBaseEXT, - EXT_glBindBufferBaseNV, - EXT_glBindBufferOffsetEXT, - EXT_glBindBufferOffsetNV, - EXT_glBindBufferRange, - EXT_glBindBufferRangeEXT, - EXT_glBindBufferRangeNV, - EXT_glBindFragDataLocation, - EXT_glBindFragDataLocationEXT, - EXT_glBindFragDataLocationIndexed, - EXT_glBindFragmentShaderATI, - EXT_glBindFramebuffer, - EXT_glBindFramebufferEXT, - EXT_glBindImageTexture, - EXT_glBindImageTextureEXT, - EXT_glBindLightParameterEXT, - EXT_glBindMaterialParameterEXT, - EXT_glBindMultiTextureEXT, - EXT_glBindParameterEXT, - EXT_glBindProgramARB, - EXT_glBindProgramNV, - EXT_glBindProgramPipeline, - EXT_glBindRenderbuffer, - EXT_glBindRenderbufferEXT, - EXT_glBindSampler, - EXT_glBindTexGenParameterEXT, - EXT_glBindTextureEXT, - EXT_glBindTextureUnitParameterEXT, - EXT_glBindTransformFeedback, - EXT_glBindTransformFeedbackNV, - EXT_glBindVertexArray, - EXT_glBindVertexArrayAPPLE, - EXT_glBindVertexShaderEXT, - EXT_glBindVideoCaptureStreamBufferNV, - EXT_glBindVideoCaptureStreamTextureNV, - EXT_glBinormal3bEXT, - EXT_glBinormal3bvEXT, - EXT_glBinormal3dEXT, - EXT_glBinormal3dvEXT, - EXT_glBinormal3fEXT, - EXT_glBinormal3fvEXT, - EXT_glBinormal3iEXT, - EXT_glBinormal3ivEXT, - EXT_glBinormal3sEXT, - EXT_glBinormal3svEXT, - EXT_glBinormalPointerEXT, - EXT_glBlendColor, - EXT_glBlendColorEXT, - EXT_glBlendEquation, - EXT_glBlendEquationEXT, - EXT_glBlendEquationIndexedAMD, - EXT_glBlendEquationSeparate, - EXT_glBlendEquationSeparateEXT, - EXT_glBlendEquationSeparateIndexedAMD, - EXT_glBlendEquationSeparatei, - EXT_glBlendEquationSeparateiARB, - EXT_glBlendEquationi, - EXT_glBlendEquationiARB, - EXT_glBlendFuncIndexedAMD, - EXT_glBlendFuncSeparate, - EXT_glBlendFuncSeparateEXT, - EXT_glBlendFuncSeparateINGR, - EXT_glBlendFuncSeparateIndexedAMD, - EXT_glBlendFuncSeparatei, - EXT_glBlendFuncSeparateiARB, - EXT_glBlendFunci, - EXT_glBlendFunciARB, - EXT_glBlitFramebuffer, - EXT_glBlitFramebufferEXT, - EXT_glBufferAddressRangeNV, - EXT_glBufferData, - EXT_glBufferDataARB, - EXT_glBufferParameteriAPPLE, - EXT_glBufferRegionEnabled, - EXT_glBufferSubData, - EXT_glBufferSubDataARB, - EXT_glCheckFramebufferStatus, - EXT_glCheckFramebufferStatusEXT, - EXT_glCheckNamedFramebufferStatusEXT, - EXT_glClampColor, - EXT_glClampColorARB, - EXT_glClearBufferfi, - EXT_glClearBufferfv, - EXT_glClearBufferiv, - EXT_glClearBufferuiv, - EXT_glClearColorIiEXT, - EXT_glClearColorIuiEXT, - EXT_glClearDepthdNV, - EXT_glClearDepthf, - EXT_glClientActiveTexture, - EXT_glClientActiveTextureARB, - EXT_glClientActiveVertexStreamATI, - EXT_glClientAttribDefaultEXT, - EXT_glClientWaitSync, - EXT_glColor3fVertex3fSUN, - EXT_glColor3fVertex3fvSUN, - EXT_glColor3hNV, - EXT_glColor3hvNV, - EXT_glColor4fNormal3fVertex3fSUN, - EXT_glColor4fNormal3fVertex3fvSUN, - EXT_glColor4hNV, - EXT_glColor4hvNV, - EXT_glColor4ubVertex2fSUN, - EXT_glColor4ubVertex2fvSUN, - EXT_glColor4ubVertex3fSUN, - EXT_glColor4ubVertex3fvSUN, - EXT_glColorFormatNV, - EXT_glColorFragmentOp1ATI, - EXT_glColorFragmentOp2ATI, - EXT_glColorFragmentOp3ATI, - EXT_glColorMaskIndexedEXT, - EXT_glColorMaski, - EXT_glColorP3ui, - EXT_glColorP3uiv, - EXT_glColorP4ui, - EXT_glColorP4uiv, - EXT_glColorPointerEXT, - EXT_glColorPointerListIBM, - EXT_glColorPointervINTEL, - EXT_glColorSubTable, - EXT_glColorSubTableEXT, - EXT_glColorTable, - EXT_glColorTableEXT, - EXT_glColorTableParameterfv, - EXT_glColorTableParameterfvSGI, - EXT_glColorTableParameteriv, - EXT_glColorTableParameterivSGI, - EXT_glColorTableSGI, - EXT_glCombinerInputNV, - EXT_glCombinerOutputNV, - EXT_glCombinerParameterfNV, - EXT_glCombinerParameterfvNV, - EXT_glCombinerParameteriNV, - EXT_glCombinerParameterivNV, - EXT_glCombinerStageParameterfvNV, - EXT_glCompileShader, - EXT_glCompileShaderARB, - EXT_glCompileShaderIncludeARB, - EXT_glCompressedMultiTexImage1DEXT, - EXT_glCompressedMultiTexImage2DEXT, - EXT_glCompressedMultiTexImage3DEXT, - EXT_glCompressedMultiTexSubImage1DEXT, - EXT_glCompressedMultiTexSubImage2DEXT, - EXT_glCompressedMultiTexSubImage3DEXT, - EXT_glCompressedTexImage1D, - EXT_glCompressedTexImage1DARB, - EXT_glCompressedTexImage2D, - EXT_glCompressedTexImage2DARB, - EXT_glCompressedTexImage3D, - EXT_glCompressedTexImage3DARB, - EXT_glCompressedTexSubImage1D, - EXT_glCompressedTexSubImage1DARB, - EXT_glCompressedTexSubImage2D, - EXT_glCompressedTexSubImage2DARB, - EXT_glCompressedTexSubImage3D, - EXT_glCompressedTexSubImage3DARB, - EXT_glCompressedTextureImage1DEXT, - EXT_glCompressedTextureImage2DEXT, - EXT_glCompressedTextureImage3DEXT, - EXT_glCompressedTextureSubImage1DEXT, - EXT_glCompressedTextureSubImage2DEXT, - EXT_glCompressedTextureSubImage3DEXT, - EXT_glConvolutionFilter1D, - EXT_glConvolutionFilter1DEXT, - EXT_glConvolutionFilter2D, - EXT_glConvolutionFilter2DEXT, - EXT_glConvolutionParameterf, - EXT_glConvolutionParameterfEXT, - EXT_glConvolutionParameterfv, - EXT_glConvolutionParameterfvEXT, - EXT_glConvolutionParameteri, - EXT_glConvolutionParameteriEXT, - EXT_glConvolutionParameteriv, - EXT_glConvolutionParameterivEXT, - EXT_glCopyBufferSubData, - EXT_glCopyColorSubTable, - EXT_glCopyColorSubTableEXT, - EXT_glCopyColorTable, - EXT_glCopyColorTableSGI, - EXT_glCopyConvolutionFilter1D, - EXT_glCopyConvolutionFilter1DEXT, - EXT_glCopyConvolutionFilter2D, - EXT_glCopyConvolutionFilter2DEXT, - EXT_glCopyImageSubDataNV, - EXT_glCopyMultiTexImage1DEXT, - EXT_glCopyMultiTexImage2DEXT, - EXT_glCopyMultiTexSubImage1DEXT, - EXT_glCopyMultiTexSubImage2DEXT, - EXT_glCopyMultiTexSubImage3DEXT, - EXT_glCopyPathNV, - EXT_glCopyTexImage1DEXT, - EXT_glCopyTexImage2DEXT, - EXT_glCopyTexSubImage1DEXT, - EXT_glCopyTexSubImage2DEXT, - EXT_glCopyTexSubImage3D, - EXT_glCopyTexSubImage3DEXT, - EXT_glCopyTextureImage1DEXT, - EXT_glCopyTextureImage2DEXT, - EXT_glCopyTextureSubImage1DEXT, - EXT_glCopyTextureSubImage2DEXT, - EXT_glCopyTextureSubImage3DEXT, - EXT_glCoverFillPathInstancedNV, - EXT_glCoverFillPathNV, - EXT_glCoverStrokePathInstancedNV, - EXT_glCoverStrokePathNV, - EXT_glCreateProgram, - EXT_glCreateProgramObjectARB, - EXT_glCreateShader, - EXT_glCreateShaderObjectARB, - EXT_glCreateShaderProgramEXT, - EXT_glCreateShaderProgramv, - EXT_glCreateSyncFromCLeventARB, - EXT_glCullParameterdvEXT, - EXT_glCullParameterfvEXT, - EXT_glCurrentPaletteMatrixARB, - EXT_glDebugMessageCallbackAMD, - EXT_glDebugMessageCallbackARB, - EXT_glDebugMessageControlARB, - EXT_glDebugMessageEnableAMD, - EXT_glDebugMessageInsertAMD, - EXT_glDebugMessageInsertARB, - EXT_glDeformSGIX, - EXT_glDeformationMap3dSGIX, - EXT_glDeformationMap3fSGIX, - EXT_glDeleteAsyncMarkersSGIX, - EXT_glDeleteBufferRegion, - EXT_glDeleteBuffers, - EXT_glDeleteBuffersARB, - EXT_glDeleteFencesAPPLE, - EXT_glDeleteFencesNV, - EXT_glDeleteFragmentShaderATI, - EXT_glDeleteFramebuffers, - EXT_glDeleteFramebuffersEXT, - EXT_glDeleteNamedStringARB, - EXT_glDeleteNamesAMD, - EXT_glDeleteObjectARB, - EXT_glDeleteObjectBufferATI, - EXT_glDeleteOcclusionQueriesNV, - EXT_glDeletePathsNV, - EXT_glDeletePerfMonitorsAMD, - EXT_glDeleteProgram, - EXT_glDeleteProgramPipelines, - EXT_glDeleteProgramsARB, - EXT_glDeleteProgramsNV, - EXT_glDeleteQueries, - EXT_glDeleteQueriesARB, - EXT_glDeleteRenderbuffers, - EXT_glDeleteRenderbuffersEXT, - EXT_glDeleteSamplers, - EXT_glDeleteShader, - EXT_glDeleteSync, - EXT_glDeleteTexturesEXT, - EXT_glDeleteTransformFeedbacks, - EXT_glDeleteTransformFeedbacksNV, - EXT_glDeleteVertexArrays, - EXT_glDeleteVertexArraysAPPLE, - EXT_glDeleteVertexShaderEXT, - EXT_glDepthBoundsEXT, - EXT_glDepthBoundsdNV, - EXT_glDepthRangeArrayv, - EXT_glDepthRangeIndexed, - EXT_glDepthRangedNV, - EXT_glDepthRangef, - EXT_glDetachObjectARB, - EXT_glDetachShader, - EXT_glDetailTexFuncSGIS, - EXT_glDisableClientStateIndexedEXT, - EXT_glDisableIndexedEXT, - EXT_glDisableVariantClientStateEXT, - EXT_glDisableVertexAttribAPPLE, - EXT_glDisableVertexAttribArray, - EXT_glDisableVertexAttribArrayARB, - EXT_glDisablei, - EXT_glDrawArraysEXT, - EXT_glDrawArraysIndirect, - EXT_glDrawArraysInstanced, - EXT_glDrawArraysInstancedARB, - EXT_glDrawArraysInstancedBaseInstance, - EXT_glDrawArraysInstancedEXT, - EXT_glDrawBufferRegion, - EXT_glDrawBuffers, - EXT_glDrawBuffersARB, - EXT_glDrawBuffersATI, - EXT_glDrawElementArrayAPPLE, - EXT_glDrawElementArrayATI, - EXT_glDrawElementsBaseVertex, - EXT_glDrawElementsIndirect, - EXT_glDrawElementsInstanced, - EXT_glDrawElementsInstancedARB, - EXT_glDrawElementsInstancedBaseInstance, - EXT_glDrawElementsInstancedBaseVertex, - EXT_glDrawElementsInstancedBaseVertexBaseInstance, - EXT_glDrawElementsInstancedEXT, - EXT_glDrawMeshArraysSUN, - EXT_glDrawRangeElementArrayAPPLE, - EXT_glDrawRangeElementArrayATI, - EXT_glDrawRangeElements, - EXT_glDrawRangeElementsBaseVertex, - EXT_glDrawRangeElementsEXT, - EXT_glDrawTransformFeedback, - EXT_glDrawTransformFeedbackInstanced, - EXT_glDrawTransformFeedbackNV, - EXT_glDrawTransformFeedbackStream, - EXT_glDrawTransformFeedbackStreamInstanced, - EXT_glEdgeFlagFormatNV, - EXT_glEdgeFlagPointerEXT, - EXT_glEdgeFlagPointerListIBM, - EXT_glElementPointerAPPLE, - EXT_glElementPointerATI, - EXT_glEnableClientStateIndexedEXT, - EXT_glEnableIndexedEXT, - EXT_glEnableVariantClientStateEXT, - EXT_glEnableVertexAttribAPPLE, - EXT_glEnableVertexAttribArray, - EXT_glEnableVertexAttribArrayARB, - EXT_glEnablei, - EXT_glEndConditionalRender, - EXT_glEndConditionalRenderNV, - EXT_glEndFragmentShaderATI, - EXT_glEndOcclusionQueryNV, - EXT_glEndPerfMonitorAMD, - EXT_glEndQuery, - EXT_glEndQueryARB, - EXT_glEndQueryIndexed, - EXT_glEndTransformFeedback, - EXT_glEndTransformFeedbackEXT, - EXT_glEndTransformFeedbackNV, - EXT_glEndVertexShaderEXT, - EXT_glEndVideoCaptureNV, - EXT_glEvalMapsNV, - EXT_glExecuteProgramNV, - EXT_glExtractComponentEXT, - EXT_glFenceSync, - EXT_glFinalCombinerInputNV, - EXT_glFinishAsyncSGIX, - EXT_glFinishFenceAPPLE, - EXT_glFinishFenceNV, - EXT_glFinishObjectAPPLE, - EXT_glFinishTextureSUNX, - EXT_glFlushMappedBufferRange, - EXT_glFlushMappedBufferRangeAPPLE, - EXT_glFlushMappedNamedBufferRangeEXT, - EXT_glFlushPixelDataRangeNV, - EXT_glFlushRasterSGIX, - EXT_glFlushVertexArrayRangeAPPLE, - EXT_glFlushVertexArrayRangeNV, - EXT_glFogCoordFormatNV, - EXT_glFogCoordPointer, - EXT_glFogCoordPointerEXT, - EXT_glFogCoordPointerListIBM, - EXT_glFogCoordd, - EXT_glFogCoorddEXT, - EXT_glFogCoorddv, - EXT_glFogCoorddvEXT, - EXT_glFogCoordf, - EXT_glFogCoordfEXT, - EXT_glFogCoordfv, - EXT_glFogCoordfvEXT, - EXT_glFogCoordhNV, - EXT_glFogCoordhvNV, - EXT_glFogFuncSGIS, - EXT_glFragmentColorMaterialSGIX, - EXT_glFragmentLightModelfSGIX, - EXT_glFragmentLightModelfvSGIX, - EXT_glFragmentLightModeliSGIX, - EXT_glFragmentLightModelivSGIX, - EXT_glFragmentLightfSGIX, - EXT_glFragmentLightfvSGIX, - EXT_glFragmentLightiSGIX, - EXT_glFragmentLightivSGIX, - EXT_glFragmentMaterialfSGIX, - EXT_glFragmentMaterialfvSGIX, - EXT_glFragmentMaterialiSGIX, - EXT_glFragmentMaterialivSGIX, - EXT_glFrameTerminatorGREMEDY, - EXT_glFrameZoomSGIX, - EXT_glFramebufferDrawBufferEXT, - EXT_glFramebufferDrawBuffersEXT, - EXT_glFramebufferReadBufferEXT, - EXT_glFramebufferRenderbuffer, - EXT_glFramebufferRenderbufferEXT, - EXT_glFramebufferTexture, - EXT_glFramebufferTexture1D, - EXT_glFramebufferTexture1DEXT, - EXT_glFramebufferTexture2D, - EXT_glFramebufferTexture2DEXT, - EXT_glFramebufferTexture3D, - EXT_glFramebufferTexture3DEXT, - EXT_glFramebufferTextureARB, - EXT_glFramebufferTextureEXT, - EXT_glFramebufferTextureFaceARB, - EXT_glFramebufferTextureFaceEXT, - EXT_glFramebufferTextureLayer, - EXT_glFramebufferTextureLayerARB, - EXT_glFramebufferTextureLayerEXT, - EXT_glFreeObjectBufferATI, - EXT_glGenAsyncMarkersSGIX, - EXT_glGenBuffers, - EXT_glGenBuffersARB, - EXT_glGenFencesAPPLE, - EXT_glGenFencesNV, - EXT_glGenFragmentShadersATI, - EXT_glGenFramebuffers, - EXT_glGenFramebuffersEXT, - EXT_glGenNamesAMD, - EXT_glGenOcclusionQueriesNV, - EXT_glGenPathsNV, - EXT_glGenPerfMonitorsAMD, - EXT_glGenProgramPipelines, - EXT_glGenProgramsARB, - EXT_glGenProgramsNV, - EXT_glGenQueries, - EXT_glGenQueriesARB, - EXT_glGenRenderbuffers, - EXT_glGenRenderbuffersEXT, - EXT_glGenSamplers, - EXT_glGenSymbolsEXT, - EXT_glGenTexturesEXT, - EXT_glGenTransformFeedbacks, - EXT_glGenTransformFeedbacksNV, - EXT_glGenVertexArrays, - EXT_glGenVertexArraysAPPLE, - EXT_glGenVertexShadersEXT, - EXT_glGenerateMipmap, - EXT_glGenerateMipmapEXT, - EXT_glGenerateMultiTexMipmapEXT, - EXT_glGenerateTextureMipmapEXT, - EXT_glGetActiveAtomicCounterBufferiv, - EXT_glGetActiveAttrib, - EXT_glGetActiveAttribARB, - EXT_glGetActiveSubroutineName, - EXT_glGetActiveSubroutineUniformName, - EXT_glGetActiveSubroutineUniformiv, - EXT_glGetActiveUniform, - EXT_glGetActiveUniformARB, - EXT_glGetActiveUniformBlockName, - EXT_glGetActiveUniformBlockiv, - EXT_glGetActiveUniformName, - EXT_glGetActiveUniformsiv, - EXT_glGetActiveVaryingNV, - EXT_glGetArrayObjectfvATI, - EXT_glGetArrayObjectivATI, - EXT_glGetAttachedObjectsARB, - EXT_glGetAttachedShaders, - EXT_glGetAttribLocation, - EXT_glGetAttribLocationARB, - EXT_glGetBooleanIndexedvEXT, - EXT_glGetBooleani_v, - EXT_glGetBufferParameteri64v, - EXT_glGetBufferParameteriv, - EXT_glGetBufferParameterivARB, - EXT_glGetBufferParameterui64vNV, - EXT_glGetBufferPointerv, - EXT_glGetBufferPointervARB, - EXT_glGetBufferSubData, - EXT_glGetBufferSubDataARB, - EXT_glGetColorTable, - EXT_glGetColorTableEXT, - EXT_glGetColorTableParameterfv, - EXT_glGetColorTableParameterfvEXT, - EXT_glGetColorTableParameterfvSGI, - EXT_glGetColorTableParameteriv, - EXT_glGetColorTableParameterivEXT, - EXT_glGetColorTableParameterivSGI, - EXT_glGetColorTableSGI, - EXT_glGetCombinerInputParameterfvNV, - EXT_glGetCombinerInputParameterivNV, - EXT_glGetCombinerOutputParameterfvNV, - EXT_glGetCombinerOutputParameterivNV, - EXT_glGetCombinerStageParameterfvNV, - EXT_glGetCompressedMultiTexImageEXT, - EXT_glGetCompressedTexImage, - EXT_glGetCompressedTexImageARB, - EXT_glGetCompressedTextureImageEXT, - EXT_glGetConvolutionFilter, - EXT_glGetConvolutionFilterEXT, - EXT_glGetConvolutionParameterfv, - EXT_glGetConvolutionParameterfvEXT, - EXT_glGetConvolutionParameteriv, - EXT_glGetConvolutionParameterivEXT, - EXT_glGetDebugMessageLogAMD, - EXT_glGetDebugMessageLogARB, - EXT_glGetDetailTexFuncSGIS, - EXT_glGetDoubleIndexedvEXT, - EXT_glGetDoublei_v, - EXT_glGetFenceivNV, - EXT_glGetFinalCombinerInputParameterfvNV, - EXT_glGetFinalCombinerInputParameterivNV, - EXT_glGetFloatIndexedvEXT, - EXT_glGetFloati_v, - EXT_glGetFogFuncSGIS, - EXT_glGetFragDataIndex, - EXT_glGetFragDataLocation, - EXT_glGetFragDataLocationEXT, - EXT_glGetFragmentLightfvSGIX, - EXT_glGetFragmentLightivSGIX, - EXT_glGetFragmentMaterialfvSGIX, - EXT_glGetFragmentMaterialivSGIX, - EXT_glGetFramebufferAttachmentParameteriv, - EXT_glGetFramebufferAttachmentParameterivEXT, - EXT_glGetFramebufferParameterivEXT, - EXT_glGetGraphicsResetStatusARB, - EXT_glGetHandleARB, - EXT_glGetHistogram, - EXT_glGetHistogramEXT, - EXT_glGetHistogramParameterfv, - EXT_glGetHistogramParameterfvEXT, - EXT_glGetHistogramParameteriv, - EXT_glGetHistogramParameterivEXT, - EXT_glGetImageHandleNV, - EXT_glGetImageTransformParameterfvHP, - EXT_glGetImageTransformParameterivHP, - EXT_glGetInfoLogARB, - EXT_glGetInstrumentsSGIX, - EXT_glGetInteger64i_v, - EXT_glGetInteger64v, - EXT_glGetIntegerIndexedvEXT, - EXT_glGetIntegeri_v, - EXT_glGetIntegerui64i_vNV, - EXT_glGetIntegerui64vNV, - EXT_glGetInternalformativ, - EXT_glGetInvariantBooleanvEXT, - EXT_glGetInvariantFloatvEXT, - EXT_glGetInvariantIntegervEXT, - EXT_glGetListParameterfvSGIX, - EXT_glGetListParameterivSGIX, - EXT_glGetLocalConstantBooleanvEXT, - EXT_glGetLocalConstantFloatvEXT, - EXT_glGetLocalConstantIntegervEXT, - EXT_glGetMapAttribParameterfvNV, - EXT_glGetMapAttribParameterivNV, - EXT_glGetMapControlPointsNV, - EXT_glGetMapParameterfvNV, - EXT_glGetMapParameterivNV, - EXT_glGetMinmax, - EXT_glGetMinmaxEXT, - EXT_glGetMinmaxParameterfv, - EXT_glGetMinmaxParameterfvEXT, - EXT_glGetMinmaxParameteriv, - EXT_glGetMinmaxParameterivEXT, - EXT_glGetMultiTexEnvfvEXT, - EXT_glGetMultiTexEnvivEXT, - EXT_glGetMultiTexGendvEXT, - EXT_glGetMultiTexGenfvEXT, - EXT_glGetMultiTexGenivEXT, - EXT_glGetMultiTexImageEXT, - EXT_glGetMultiTexLevelParameterfvEXT, - EXT_glGetMultiTexLevelParameterivEXT, - EXT_glGetMultiTexParameterIivEXT, - EXT_glGetMultiTexParameterIuivEXT, - EXT_glGetMultiTexParameterfvEXT, - EXT_glGetMultiTexParameterivEXT, - EXT_glGetMultisamplefv, - EXT_glGetMultisamplefvNV, - EXT_glGetNamedBufferParameterivEXT, - EXT_glGetNamedBufferParameterui64vNV, - EXT_glGetNamedBufferPointervEXT, - EXT_glGetNamedBufferSubDataEXT, - EXT_glGetNamedFramebufferAttachmentParameterivEXT, - EXT_glGetNamedProgramLocalParameterIivEXT, - EXT_glGetNamedProgramLocalParameterIuivEXT, - EXT_glGetNamedProgramLocalParameterdvEXT, - EXT_glGetNamedProgramLocalParameterfvEXT, - EXT_glGetNamedProgramStringEXT, - EXT_glGetNamedProgramivEXT, - EXT_glGetNamedRenderbufferParameterivEXT, - EXT_glGetNamedStringARB, - EXT_glGetNamedStringivARB, - EXT_glGetObjectBufferfvATI, - EXT_glGetObjectBufferivATI, - EXT_glGetObjectParameterfvARB, - EXT_glGetObjectParameterivAPPLE, - EXT_glGetObjectParameterivARB, - EXT_glGetOcclusionQueryivNV, - EXT_glGetOcclusionQueryuivNV, - EXT_glGetPathColorGenfvNV, - EXT_glGetPathColorGenivNV, - EXT_glGetPathCommandsNV, - EXT_glGetPathCoordsNV, - EXT_glGetPathDashArrayNV, - EXT_glGetPathLengthNV, - EXT_glGetPathMetricRangeNV, - EXT_glGetPathMetricsNV, - EXT_glGetPathParameterfvNV, - EXT_glGetPathParameterivNV, - EXT_glGetPathSpacingNV, - EXT_glGetPathTexGenfvNV, - EXT_glGetPathTexGenivNV, - EXT_glGetPerfMonitorCounterDataAMD, - EXT_glGetPerfMonitorCounterInfoAMD, - EXT_glGetPerfMonitorCounterStringAMD, - EXT_glGetPerfMonitorCountersAMD, - EXT_glGetPerfMonitorGroupStringAMD, - EXT_glGetPerfMonitorGroupsAMD, - EXT_glGetPixelTexGenParameterfvSGIS, - EXT_glGetPixelTexGenParameterivSGIS, - EXT_glGetPointerIndexedvEXT, - EXT_glGetPointervEXT, - EXT_glGetProgramBinary, - EXT_glGetProgramEnvParameterIivNV, - EXT_glGetProgramEnvParameterIuivNV, - EXT_glGetProgramEnvParameterdvARB, - EXT_glGetProgramEnvParameterfvARB, - EXT_glGetProgramInfoLog, - EXT_glGetProgramLocalParameterIivNV, - EXT_glGetProgramLocalParameterIuivNV, - EXT_glGetProgramLocalParameterdvARB, - EXT_glGetProgramLocalParameterfvARB, - EXT_glGetProgramNamedParameterdvNV, - EXT_glGetProgramNamedParameterfvNV, - EXT_glGetProgramParameterdvNV, - EXT_glGetProgramParameterfvNV, - EXT_glGetProgramPipelineInfoLog, - EXT_glGetProgramPipelineiv, - EXT_glGetProgramStageiv, - EXT_glGetProgramStringARB, - EXT_glGetProgramStringNV, - EXT_glGetProgramSubroutineParameteruivNV, - EXT_glGetProgramiv, - EXT_glGetProgramivARB, - EXT_glGetProgramivNV, - EXT_glGetQueryIndexediv, - EXT_glGetQueryObjecti64v, - EXT_glGetQueryObjecti64vEXT, - EXT_glGetQueryObjectiv, - EXT_glGetQueryObjectivARB, - EXT_glGetQueryObjectui64v, - EXT_glGetQueryObjectui64vEXT, - EXT_glGetQueryObjectuiv, - EXT_glGetQueryObjectuivARB, - EXT_glGetQueryiv, - EXT_glGetQueryivARB, - EXT_glGetRenderbufferParameteriv, - EXT_glGetRenderbufferParameterivEXT, - EXT_glGetSamplerParameterIiv, - EXT_glGetSamplerParameterIuiv, - EXT_glGetSamplerParameterfv, - EXT_glGetSamplerParameteriv, - EXT_glGetSeparableFilter, - EXT_glGetSeparableFilterEXT, - EXT_glGetShaderInfoLog, - EXT_glGetShaderPrecisionFormat, - EXT_glGetShaderSource, - EXT_glGetShaderSourceARB, - EXT_glGetShaderiv, - EXT_glGetSharpenTexFuncSGIS, - EXT_glGetStringi, - EXT_glGetSubroutineIndex, - EXT_glGetSubroutineUniformLocation, - EXT_glGetSynciv, - EXT_glGetTexBumpParameterfvATI, - EXT_glGetTexBumpParameterivATI, - EXT_glGetTexFilterFuncSGIS, - EXT_glGetTexParameterIiv, - EXT_glGetTexParameterIivEXT, - EXT_glGetTexParameterIuiv, - EXT_glGetTexParameterIuivEXT, - EXT_glGetTexParameterPointervAPPLE, - EXT_glGetTextureHandleNV, - EXT_glGetTextureImageEXT, - EXT_glGetTextureLevelParameterfvEXT, - EXT_glGetTextureLevelParameterivEXT, - EXT_glGetTextureParameterIivEXT, - EXT_glGetTextureParameterIuivEXT, - EXT_glGetTextureParameterfvEXT, - EXT_glGetTextureParameterivEXT, - EXT_glGetTextureSamplerHandleNV, - EXT_glGetTrackMatrixivNV, - EXT_glGetTransformFeedbackVarying, - EXT_glGetTransformFeedbackVaryingEXT, - EXT_glGetTransformFeedbackVaryingNV, - EXT_glGetUniformBlockIndex, - EXT_glGetUniformBufferSizeEXT, - EXT_glGetUniformIndices, - EXT_glGetUniformLocation, - EXT_glGetUniformLocationARB, - EXT_glGetUniformOffsetEXT, - EXT_glGetUniformSubroutineuiv, - EXT_glGetUniformdv, - EXT_glGetUniformfv, - EXT_glGetUniformfvARB, - EXT_glGetUniformi64vNV, - EXT_glGetUniformiv, - EXT_glGetUniformivARB, - EXT_glGetUniformui64vNV, - EXT_glGetUniformuiv, - EXT_glGetUniformuivEXT, - EXT_glGetVariantArrayObjectfvATI, - EXT_glGetVariantArrayObjectivATI, - EXT_glGetVariantBooleanvEXT, - EXT_glGetVariantFloatvEXT, - EXT_glGetVariantIntegervEXT, - EXT_glGetVariantPointervEXT, - EXT_glGetVaryingLocationNV, - EXT_glGetVertexAttribArrayObjectfvATI, - EXT_glGetVertexAttribArrayObjectivATI, - EXT_glGetVertexAttribIiv, - EXT_glGetVertexAttribIivEXT, - EXT_glGetVertexAttribIuiv, - EXT_glGetVertexAttribIuivEXT, - EXT_glGetVertexAttribLdv, - EXT_glGetVertexAttribLdvEXT, - EXT_glGetVertexAttribLi64vNV, - EXT_glGetVertexAttribLui64vNV, - EXT_glGetVertexAttribPointerv, - EXT_glGetVertexAttribPointervARB, - EXT_glGetVertexAttribPointervNV, - EXT_glGetVertexAttribdv, - EXT_glGetVertexAttribdvARB, - EXT_glGetVertexAttribdvNV, - EXT_glGetVertexAttribfv, - EXT_glGetVertexAttribfvARB, - EXT_glGetVertexAttribfvNV, - EXT_glGetVertexAttribiv, - EXT_glGetVertexAttribivARB, - EXT_glGetVertexAttribivNV, - EXT_glGetVideoCaptureStreamdvNV, - EXT_glGetVideoCaptureStreamfvNV, - EXT_glGetVideoCaptureStreamivNV, - EXT_glGetVideoCaptureivNV, - EXT_glGetVideoi64vNV, - EXT_glGetVideoivNV, - EXT_glGetVideoui64vNV, - EXT_glGetVideouivNV, - EXT_glGetnColorTableARB, - EXT_glGetnCompressedTexImageARB, - EXT_glGetnConvolutionFilterARB, - EXT_glGetnHistogramARB, - EXT_glGetnMapdvARB, - EXT_glGetnMapfvARB, - EXT_glGetnMapivARB, - EXT_glGetnMinmaxARB, - EXT_glGetnPixelMapfvARB, - EXT_glGetnPixelMapuivARB, - EXT_glGetnPixelMapusvARB, - EXT_glGetnPolygonStippleARB, - EXT_glGetnSeparableFilterARB, - EXT_glGetnTexImageARB, - EXT_glGetnUniformdvARB, - EXT_glGetnUniformfvARB, - EXT_glGetnUniformivARB, - EXT_glGetnUniformuivARB, - EXT_glGlobalAlphaFactorbSUN, - EXT_glGlobalAlphaFactordSUN, - EXT_glGlobalAlphaFactorfSUN, - EXT_glGlobalAlphaFactoriSUN, - EXT_glGlobalAlphaFactorsSUN, - EXT_glGlobalAlphaFactorubSUN, - EXT_glGlobalAlphaFactoruiSUN, - EXT_glGlobalAlphaFactorusSUN, - EXT_glHintPGI, - EXT_glHistogram, - EXT_glHistogramEXT, - EXT_glIglooInterfaceSGIX, - EXT_glImageTransformParameterfHP, - EXT_glImageTransformParameterfvHP, - EXT_glImageTransformParameteriHP, - EXT_glImageTransformParameterivHP, - EXT_glImportSyncEXT, - EXT_glIndexFormatNV, - EXT_glIndexFuncEXT, - EXT_glIndexMaterialEXT, - EXT_glIndexPointerEXT, - EXT_glIndexPointerListIBM, - EXT_glInsertComponentEXT, - EXT_glInstrumentsBufferSGIX, - EXT_glInterpolatePathsNV, - EXT_glIsAsyncMarkerSGIX, - EXT_glIsBuffer, - EXT_glIsBufferARB, - EXT_glIsBufferResidentNV, - EXT_glIsEnabledIndexedEXT, - EXT_glIsEnabledi, - EXT_glIsFenceAPPLE, - EXT_glIsFenceNV, - EXT_glIsFramebuffer, - EXT_glIsFramebufferEXT, - EXT_glIsImageHandleResidentNV, - EXT_glIsNameAMD, - EXT_glIsNamedBufferResidentNV, - EXT_glIsNamedStringARB, - EXT_glIsObjectBufferATI, - EXT_glIsOcclusionQueryNV, - EXT_glIsPathNV, - EXT_glIsPointInFillPathNV, - EXT_glIsPointInStrokePathNV, - EXT_glIsProgram, - EXT_glIsProgramARB, - EXT_glIsProgramNV, - EXT_glIsProgramPipeline, - EXT_glIsQuery, - EXT_glIsQueryARB, - EXT_glIsRenderbuffer, - EXT_glIsRenderbufferEXT, - EXT_glIsSampler, - EXT_glIsShader, - EXT_glIsSync, - EXT_glIsTextureEXT, - EXT_glIsTextureHandleResidentNV, - EXT_glIsTransformFeedback, - EXT_glIsTransformFeedbackNV, - EXT_glIsVariantEnabledEXT, - EXT_glIsVertexArray, - EXT_glIsVertexArrayAPPLE, - EXT_glIsVertexAttribEnabledAPPLE, - EXT_glLightEnviSGIX, - EXT_glLinkProgram, - EXT_glLinkProgramARB, - EXT_glListParameterfSGIX, - EXT_glListParameterfvSGIX, - EXT_glListParameteriSGIX, - EXT_glListParameterivSGIX, - EXT_glLoadIdentityDeformationMapSGIX, - EXT_glLoadProgramNV, - EXT_glLoadTransposeMatrixd, - EXT_glLoadTransposeMatrixdARB, - EXT_glLoadTransposeMatrixf, - EXT_glLoadTransposeMatrixfARB, - EXT_glLockArraysEXT, - EXT_glMTexCoord2fSGIS, - EXT_glMTexCoord2fvSGIS, - EXT_glMakeBufferNonResidentNV, - EXT_glMakeBufferResidentNV, - EXT_glMakeImageHandleNonResidentNV, - EXT_glMakeImageHandleResidentNV, - EXT_glMakeNamedBufferNonResidentNV, - EXT_glMakeNamedBufferResidentNV, - EXT_glMakeTextureHandleNonResidentNV, - EXT_glMakeTextureHandleResidentNV, - EXT_glMapBuffer, - EXT_glMapBufferARB, - EXT_glMapBufferRange, - EXT_glMapControlPointsNV, - EXT_glMapNamedBufferEXT, - EXT_glMapNamedBufferRangeEXT, - EXT_glMapObjectBufferATI, - EXT_glMapParameterfvNV, - EXT_glMapParameterivNV, - EXT_glMapVertexAttrib1dAPPLE, - EXT_glMapVertexAttrib1fAPPLE, - EXT_glMapVertexAttrib2dAPPLE, - EXT_glMapVertexAttrib2fAPPLE, - EXT_glMatrixFrustumEXT, - EXT_glMatrixIndexPointerARB, - EXT_glMatrixIndexubvARB, - EXT_glMatrixIndexuivARB, - EXT_glMatrixIndexusvARB, - EXT_glMatrixLoadIdentityEXT, - EXT_glMatrixLoadTransposedEXT, - EXT_glMatrixLoadTransposefEXT, - EXT_glMatrixLoaddEXT, - EXT_glMatrixLoadfEXT, - EXT_glMatrixMultTransposedEXT, - EXT_glMatrixMultTransposefEXT, - EXT_glMatrixMultdEXT, - EXT_glMatrixMultfEXT, - EXT_glMatrixOrthoEXT, - EXT_glMatrixPopEXT, - EXT_glMatrixPushEXT, - EXT_glMatrixRotatedEXT, - EXT_glMatrixRotatefEXT, - EXT_glMatrixScaledEXT, - EXT_glMatrixScalefEXT, - EXT_glMatrixTranslatedEXT, - EXT_glMatrixTranslatefEXT, - EXT_glMemoryBarrier, - EXT_glMemoryBarrierEXT, - EXT_glMinSampleShading, - EXT_glMinSampleShadingARB, - EXT_glMinmax, - EXT_glMinmaxEXT, - EXT_glMultTransposeMatrixd, - EXT_glMultTransposeMatrixdARB, - EXT_glMultTransposeMatrixf, - EXT_glMultTransposeMatrixfARB, - EXT_glMultiDrawArrays, - EXT_glMultiDrawArraysEXT, - EXT_glMultiDrawArraysIndirectAMD, - EXT_glMultiDrawElementArrayAPPLE, - EXT_glMultiDrawElements, - EXT_glMultiDrawElementsBaseVertex, - EXT_glMultiDrawElementsEXT, - EXT_glMultiDrawElementsIndirectAMD, - EXT_glMultiDrawRangeElementArrayAPPLE, - EXT_glMultiModeDrawArraysIBM, - EXT_glMultiModeDrawElementsIBM, - EXT_glMultiTexBufferEXT, - EXT_glMultiTexCoord1d, - EXT_glMultiTexCoord1dARB, - EXT_glMultiTexCoord1dSGIS, - EXT_glMultiTexCoord1dv, - EXT_glMultiTexCoord1dvARB, - EXT_glMultiTexCoord1dvSGIS, - EXT_glMultiTexCoord1f, - EXT_glMultiTexCoord1fARB, - EXT_glMultiTexCoord1fSGIS, - EXT_glMultiTexCoord1fv, - EXT_glMultiTexCoord1fvARB, - EXT_glMultiTexCoord1fvSGIS, - EXT_glMultiTexCoord1hNV, - EXT_glMultiTexCoord1hvNV, - EXT_glMultiTexCoord1i, - EXT_glMultiTexCoord1iARB, - EXT_glMultiTexCoord1iSGIS, - EXT_glMultiTexCoord1iv, - EXT_glMultiTexCoord1ivARB, - EXT_glMultiTexCoord1ivSGIS, - EXT_glMultiTexCoord1s, - EXT_glMultiTexCoord1sARB, - EXT_glMultiTexCoord1sSGIS, - EXT_glMultiTexCoord1sv, - EXT_glMultiTexCoord1svARB, - EXT_glMultiTexCoord1svSGIS, - EXT_glMultiTexCoord2d, - EXT_glMultiTexCoord2dARB, - EXT_glMultiTexCoord2dSGIS, - EXT_glMultiTexCoord2dv, - EXT_glMultiTexCoord2dvARB, - EXT_glMultiTexCoord2dvSGIS, - EXT_glMultiTexCoord2f, - EXT_glMultiTexCoord2fARB, - EXT_glMultiTexCoord2fSGIS, - EXT_glMultiTexCoord2fv, - EXT_glMultiTexCoord2fvARB, - EXT_glMultiTexCoord2fvSGIS, - EXT_glMultiTexCoord2hNV, - EXT_glMultiTexCoord2hvNV, - EXT_glMultiTexCoord2i, - EXT_glMultiTexCoord2iARB, - EXT_glMultiTexCoord2iSGIS, - EXT_glMultiTexCoord2iv, - EXT_glMultiTexCoord2ivARB, - EXT_glMultiTexCoord2ivSGIS, - EXT_glMultiTexCoord2s, - EXT_glMultiTexCoord2sARB, - EXT_glMultiTexCoord2sSGIS, - EXT_glMultiTexCoord2sv, - EXT_glMultiTexCoord2svARB, - EXT_glMultiTexCoord2svSGIS, - EXT_glMultiTexCoord3d, - EXT_glMultiTexCoord3dARB, - EXT_glMultiTexCoord3dSGIS, - EXT_glMultiTexCoord3dv, - EXT_glMultiTexCoord3dvARB, - EXT_glMultiTexCoord3dvSGIS, - EXT_glMultiTexCoord3f, - EXT_glMultiTexCoord3fARB, - EXT_glMultiTexCoord3fSGIS, - EXT_glMultiTexCoord3fv, - EXT_glMultiTexCoord3fvARB, - EXT_glMultiTexCoord3fvSGIS, - EXT_glMultiTexCoord3hNV, - EXT_glMultiTexCoord3hvNV, - EXT_glMultiTexCoord3i, - EXT_glMultiTexCoord3iARB, - EXT_glMultiTexCoord3iSGIS, - EXT_glMultiTexCoord3iv, - EXT_glMultiTexCoord3ivARB, - EXT_glMultiTexCoord3ivSGIS, - EXT_glMultiTexCoord3s, - EXT_glMultiTexCoord3sARB, - EXT_glMultiTexCoord3sSGIS, - EXT_glMultiTexCoord3sv, - EXT_glMultiTexCoord3svARB, - EXT_glMultiTexCoord3svSGIS, - EXT_glMultiTexCoord4d, - EXT_glMultiTexCoord4dARB, - EXT_glMultiTexCoord4dSGIS, - EXT_glMultiTexCoord4dv, - EXT_glMultiTexCoord4dvARB, - EXT_glMultiTexCoord4dvSGIS, - EXT_glMultiTexCoord4f, - EXT_glMultiTexCoord4fARB, - EXT_glMultiTexCoord4fSGIS, - EXT_glMultiTexCoord4fv, - EXT_glMultiTexCoord4fvARB, - EXT_glMultiTexCoord4fvSGIS, - EXT_glMultiTexCoord4hNV, - EXT_glMultiTexCoord4hvNV, - EXT_glMultiTexCoord4i, - EXT_glMultiTexCoord4iARB, - EXT_glMultiTexCoord4iSGIS, - EXT_glMultiTexCoord4iv, - EXT_glMultiTexCoord4ivARB, - EXT_glMultiTexCoord4ivSGIS, - EXT_glMultiTexCoord4s, - EXT_glMultiTexCoord4sARB, - EXT_glMultiTexCoord4sSGIS, - EXT_glMultiTexCoord4sv, - EXT_glMultiTexCoord4svARB, - EXT_glMultiTexCoord4svSGIS, - EXT_glMultiTexCoordP1ui, - EXT_glMultiTexCoordP1uiv, - EXT_glMultiTexCoordP2ui, - EXT_glMultiTexCoordP2uiv, - EXT_glMultiTexCoordP3ui, - EXT_glMultiTexCoordP3uiv, - EXT_glMultiTexCoordP4ui, - EXT_glMultiTexCoordP4uiv, - EXT_glMultiTexCoordPointerEXT, - EXT_glMultiTexCoordPointerSGIS, - EXT_glMultiTexEnvfEXT, - EXT_glMultiTexEnvfvEXT, - EXT_glMultiTexEnviEXT, - EXT_glMultiTexEnvivEXT, - EXT_glMultiTexGendEXT, - EXT_glMultiTexGendvEXT, - EXT_glMultiTexGenfEXT, - EXT_glMultiTexGenfvEXT, - EXT_glMultiTexGeniEXT, - EXT_glMultiTexGenivEXT, - EXT_glMultiTexImage1DEXT, - EXT_glMultiTexImage2DEXT, - EXT_glMultiTexImage3DEXT, - EXT_glMultiTexParameterIivEXT, - EXT_glMultiTexParameterIuivEXT, - EXT_glMultiTexParameterfEXT, - EXT_glMultiTexParameterfvEXT, - EXT_glMultiTexParameteriEXT, - EXT_glMultiTexParameterivEXT, - EXT_glMultiTexRenderbufferEXT, - EXT_glMultiTexSubImage1DEXT, - EXT_glMultiTexSubImage2DEXT, - EXT_glMultiTexSubImage3DEXT, - EXT_glNamedBufferDataEXT, - EXT_glNamedBufferSubDataEXT, - EXT_glNamedCopyBufferSubDataEXT, - EXT_glNamedFramebufferRenderbufferEXT, - EXT_glNamedFramebufferTexture1DEXT, - EXT_glNamedFramebufferTexture2DEXT, - EXT_glNamedFramebufferTexture3DEXT, - EXT_glNamedFramebufferTextureEXT, - EXT_glNamedFramebufferTextureFaceEXT, - EXT_glNamedFramebufferTextureLayerEXT, - EXT_glNamedProgramLocalParameter4dEXT, - EXT_glNamedProgramLocalParameter4dvEXT, - EXT_glNamedProgramLocalParameter4fEXT, - EXT_glNamedProgramLocalParameter4fvEXT, - EXT_glNamedProgramLocalParameterI4iEXT, - EXT_glNamedProgramLocalParameterI4ivEXT, - EXT_glNamedProgramLocalParameterI4uiEXT, - EXT_glNamedProgramLocalParameterI4uivEXT, - EXT_glNamedProgramLocalParameters4fvEXT, - EXT_glNamedProgramLocalParametersI4ivEXT, - EXT_glNamedProgramLocalParametersI4uivEXT, - EXT_glNamedProgramStringEXT, - EXT_glNamedRenderbufferStorageEXT, - EXT_glNamedRenderbufferStorageMultisampleCoverageEXT, - EXT_glNamedRenderbufferStorageMultisampleEXT, - EXT_glNamedStringARB, - EXT_glNewBufferRegion, - EXT_glNewObjectBufferATI, - EXT_glNormal3fVertex3fSUN, - EXT_glNormal3fVertex3fvSUN, - EXT_glNormal3hNV, - EXT_glNormal3hvNV, - EXT_glNormalFormatNV, - EXT_glNormalP3ui, - EXT_glNormalP3uiv, - EXT_glNormalPointerEXT, - EXT_glNormalPointerListIBM, - EXT_glNormalPointervINTEL, - EXT_glNormalStream3bATI, - EXT_glNormalStream3bvATI, - EXT_glNormalStream3dATI, - EXT_glNormalStream3dvATI, - EXT_glNormalStream3fATI, - EXT_glNormalStream3fvATI, - EXT_glNormalStream3iATI, - EXT_glNormalStream3ivATI, - EXT_glNormalStream3sATI, - EXT_glNormalStream3svATI, - EXT_glObjectPurgeableAPPLE, - EXT_glObjectUnpurgeableAPPLE, - EXT_glPNTrianglesfATI, - EXT_glPNTrianglesiATI, - EXT_glPassTexCoordATI, - EXT_glPatchParameterfv, - EXT_glPatchParameteri, - EXT_glPathColorGenNV, - EXT_glPathCommandsNV, - EXT_glPathCoordsNV, - EXT_glPathCoverDepthFuncNV, - EXT_glPathDashArrayNV, - EXT_glPathFogGenNV, - EXT_glPathGlyphRangeNV, - EXT_glPathGlyphsNV, - EXT_glPathParameterfNV, - EXT_glPathParameterfvNV, - EXT_glPathParameteriNV, - EXT_glPathParameterivNV, - EXT_glPathStencilDepthOffsetNV, - EXT_glPathStencilFuncNV, - EXT_glPathStringNV, - EXT_glPathSubCommandsNV, - EXT_glPathSubCoordsNV, - EXT_glPathTexGenNV, - EXT_glPauseTransformFeedback, - EXT_glPauseTransformFeedbackNV, - EXT_glPixelDataRangeNV, - EXT_glPixelTexGenParameterfSGIS, - EXT_glPixelTexGenParameterfvSGIS, - EXT_glPixelTexGenParameteriSGIS, - EXT_glPixelTexGenParameterivSGIS, - EXT_glPixelTexGenSGIX, - EXT_glPixelTransformParameterfEXT, - EXT_glPixelTransformParameterfvEXT, - EXT_glPixelTransformParameteriEXT, - EXT_glPixelTransformParameterivEXT, - EXT_glPointAlongPathNV, - EXT_glPointParameterf, - EXT_glPointParameterfARB, - EXT_glPointParameterfEXT, - EXT_glPointParameterfSGIS, - EXT_glPointParameterfv, - EXT_glPointParameterfvARB, - EXT_glPointParameterfvEXT, - EXT_glPointParameterfvSGIS, - EXT_glPointParameteri, - EXT_glPointParameteriNV, - EXT_glPointParameteriv, - EXT_glPointParameterivNV, - EXT_glPollAsyncSGIX, - EXT_glPollInstrumentsSGIX, - EXT_glPolygonOffsetEXT, - EXT_glPresentFrameDualFillNV, - EXT_glPresentFrameKeyedNV, - EXT_glPrimitiveRestartIndex, - EXT_glPrimitiveRestartIndexNV, - EXT_glPrimitiveRestartNV, - EXT_glPrioritizeTexturesEXT, - EXT_glProgramBinary, - EXT_glProgramBufferParametersIivNV, - EXT_glProgramBufferParametersIuivNV, - EXT_glProgramBufferParametersfvNV, - EXT_glProgramEnvParameter4dARB, - EXT_glProgramEnvParameter4dvARB, - EXT_glProgramEnvParameter4fARB, - EXT_glProgramEnvParameter4fvARB, - EXT_glProgramEnvParameterI4iNV, - EXT_glProgramEnvParameterI4ivNV, - EXT_glProgramEnvParameterI4uiNV, - EXT_glProgramEnvParameterI4uivNV, - EXT_glProgramEnvParameters4fvEXT, - EXT_glProgramEnvParametersI4ivNV, - EXT_glProgramEnvParametersI4uivNV, - EXT_glProgramLocalParameter4dARB, - EXT_glProgramLocalParameter4dvARB, - EXT_glProgramLocalParameter4fARB, - EXT_glProgramLocalParameter4fvARB, - EXT_glProgramLocalParameterI4iNV, - EXT_glProgramLocalParameterI4ivNV, - EXT_glProgramLocalParameterI4uiNV, - EXT_glProgramLocalParameterI4uivNV, - EXT_glProgramLocalParameters4fvEXT, - EXT_glProgramLocalParametersI4ivNV, - EXT_glProgramLocalParametersI4uivNV, - EXT_glProgramNamedParameter4dNV, - EXT_glProgramNamedParameter4dvNV, - EXT_glProgramNamedParameter4fNV, - EXT_glProgramNamedParameter4fvNV, - EXT_glProgramParameter4dNV, - EXT_glProgramParameter4dvNV, - EXT_glProgramParameter4fNV, - EXT_glProgramParameter4fvNV, - EXT_glProgramParameteri, - EXT_glProgramParameteriARB, - EXT_glProgramParameteriEXT, - EXT_glProgramParameters4dvNV, - EXT_glProgramParameters4fvNV, - EXT_glProgramStringARB, - EXT_glProgramSubroutineParametersuivNV, - EXT_glProgramUniform1d, - EXT_glProgramUniform1dEXT, - EXT_glProgramUniform1dv, - EXT_glProgramUniform1dvEXT, - EXT_glProgramUniform1f, - EXT_glProgramUniform1fEXT, - EXT_glProgramUniform1fv, - EXT_glProgramUniform1fvEXT, - EXT_glProgramUniform1i, - EXT_glProgramUniform1i64NV, - EXT_glProgramUniform1i64vNV, - EXT_glProgramUniform1iEXT, - EXT_glProgramUniform1iv, - EXT_glProgramUniform1ivEXT, - EXT_glProgramUniform1ui, - EXT_glProgramUniform1ui64NV, - EXT_glProgramUniform1ui64vNV, - EXT_glProgramUniform1uiEXT, - EXT_glProgramUniform1uiv, - EXT_glProgramUniform1uivEXT, - EXT_glProgramUniform2d, - EXT_glProgramUniform2dEXT, - EXT_glProgramUniform2dv, - EXT_glProgramUniform2dvEXT, - EXT_glProgramUniform2f, - EXT_glProgramUniform2fEXT, - EXT_glProgramUniform2fv, - EXT_glProgramUniform2fvEXT, - EXT_glProgramUniform2i, - EXT_glProgramUniform2i64NV, - EXT_glProgramUniform2i64vNV, - EXT_glProgramUniform2iEXT, - EXT_glProgramUniform2iv, - EXT_glProgramUniform2ivEXT, - EXT_glProgramUniform2ui, - EXT_glProgramUniform2ui64NV, - EXT_glProgramUniform2ui64vNV, - EXT_glProgramUniform2uiEXT, - EXT_glProgramUniform2uiv, - EXT_glProgramUniform2uivEXT, - EXT_glProgramUniform3d, - EXT_glProgramUniform3dEXT, - EXT_glProgramUniform3dv, - EXT_glProgramUniform3dvEXT, - EXT_glProgramUniform3f, - EXT_glProgramUniform3fEXT, - EXT_glProgramUniform3fv, - EXT_glProgramUniform3fvEXT, - EXT_glProgramUniform3i, - EXT_glProgramUniform3i64NV, - EXT_glProgramUniform3i64vNV, - EXT_glProgramUniform3iEXT, - EXT_glProgramUniform3iv, - EXT_glProgramUniform3ivEXT, - EXT_glProgramUniform3ui, - EXT_glProgramUniform3ui64NV, - EXT_glProgramUniform3ui64vNV, - EXT_glProgramUniform3uiEXT, - EXT_glProgramUniform3uiv, - EXT_glProgramUniform3uivEXT, - EXT_glProgramUniform4d, - EXT_glProgramUniform4dEXT, - EXT_glProgramUniform4dv, - EXT_glProgramUniform4dvEXT, - EXT_glProgramUniform4f, - EXT_glProgramUniform4fEXT, - EXT_glProgramUniform4fv, - EXT_glProgramUniform4fvEXT, - EXT_glProgramUniform4i, - EXT_glProgramUniform4i64NV, - EXT_glProgramUniform4i64vNV, - EXT_glProgramUniform4iEXT, - EXT_glProgramUniform4iv, - EXT_glProgramUniform4ivEXT, - EXT_glProgramUniform4ui, - EXT_glProgramUniform4ui64NV, - EXT_glProgramUniform4ui64vNV, - EXT_glProgramUniform4uiEXT, - EXT_glProgramUniform4uiv, - EXT_glProgramUniform4uivEXT, - EXT_glProgramUniformHandleui64NV, - EXT_glProgramUniformHandleui64vNV, - EXT_glProgramUniformMatrix2dv, - EXT_glProgramUniformMatrix2dvEXT, - EXT_glProgramUniformMatrix2fv, - EXT_glProgramUniformMatrix2fvEXT, - EXT_glProgramUniformMatrix2x3dv, - EXT_glProgramUniformMatrix2x3dvEXT, - EXT_glProgramUniformMatrix2x3fv, - EXT_glProgramUniformMatrix2x3fvEXT, - EXT_glProgramUniformMatrix2x4dv, - EXT_glProgramUniformMatrix2x4dvEXT, - EXT_glProgramUniformMatrix2x4fv, - EXT_glProgramUniformMatrix2x4fvEXT, - EXT_glProgramUniformMatrix3dv, - EXT_glProgramUniformMatrix3dvEXT, - EXT_glProgramUniformMatrix3fv, - EXT_glProgramUniformMatrix3fvEXT, - EXT_glProgramUniformMatrix3x2dv, - EXT_glProgramUniformMatrix3x2dvEXT, - EXT_glProgramUniformMatrix3x2fv, - EXT_glProgramUniformMatrix3x2fvEXT, - EXT_glProgramUniformMatrix3x4dv, - EXT_glProgramUniformMatrix3x4dvEXT, - EXT_glProgramUniformMatrix3x4fv, - EXT_glProgramUniformMatrix3x4fvEXT, - EXT_glProgramUniformMatrix4dv, - EXT_glProgramUniformMatrix4dvEXT, - EXT_glProgramUniformMatrix4fv, - EXT_glProgramUniformMatrix4fvEXT, - EXT_glProgramUniformMatrix4x2dv, - EXT_glProgramUniformMatrix4x2dvEXT, - EXT_glProgramUniformMatrix4x2fv, - EXT_glProgramUniformMatrix4x2fvEXT, - EXT_glProgramUniformMatrix4x3dv, - EXT_glProgramUniformMatrix4x3dvEXT, - EXT_glProgramUniformMatrix4x3fv, - EXT_glProgramUniformMatrix4x3fvEXT, - EXT_glProgramUniformui64NV, - EXT_glProgramUniformui64vNV, - EXT_glProgramVertexLimitNV, - EXT_glProvokingVertex, - EXT_glProvokingVertexEXT, - EXT_glPushClientAttribDefaultEXT, - EXT_glQueryCounter, - EXT_glReadBufferRegion, - EXT_glReadInstrumentsSGIX, - EXT_glReadnPixelsARB, - EXT_glReferencePlaneSGIX, - EXT_glReleaseShaderCompiler, - EXT_glRenderbufferStorage, - EXT_glRenderbufferStorageEXT, - EXT_glRenderbufferStorageMultisample, - EXT_glRenderbufferStorageMultisampleCoverageNV, - EXT_glRenderbufferStorageMultisampleEXT, - EXT_glReplacementCodePointerSUN, - EXT_glReplacementCodeubSUN, - EXT_glReplacementCodeubvSUN, - EXT_glReplacementCodeuiColor3fVertex3fSUN, - EXT_glReplacementCodeuiColor3fVertex3fvSUN, - EXT_glReplacementCodeuiColor4fNormal3fVertex3fSUN, - EXT_glReplacementCodeuiColor4fNormal3fVertex3fvSUN, - EXT_glReplacementCodeuiColor4ubVertex3fSUN, - EXT_glReplacementCodeuiColor4ubVertex3fvSUN, - EXT_glReplacementCodeuiNormal3fVertex3fSUN, - EXT_glReplacementCodeuiNormal3fVertex3fvSUN, - EXT_glReplacementCodeuiSUN, - EXT_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN, - EXT_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN, - EXT_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN, - EXT_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN, - EXT_glReplacementCodeuiTexCoord2fVertex3fSUN, - EXT_glReplacementCodeuiTexCoord2fVertex3fvSUN, - EXT_glReplacementCodeuiVertex3fSUN, - EXT_glReplacementCodeuiVertex3fvSUN, - EXT_glReplacementCodeuivSUN, - EXT_glReplacementCodeusSUN, - EXT_glReplacementCodeusvSUN, - EXT_glRequestResidentProgramsNV, - EXT_glResetHistogram, - EXT_glResetHistogramEXT, - EXT_glResetMinmax, - EXT_glResetMinmaxEXT, - EXT_glResizeBuffersMESA, - EXT_glResumeTransformFeedback, - EXT_glResumeTransformFeedbackNV, - EXT_glSampleCoverage, - EXT_glSampleCoverageARB, - EXT_glSampleMapATI, - EXT_glSampleMaskEXT, - EXT_glSampleMaskIndexedNV, - EXT_glSampleMaskSGIS, - EXT_glSampleMaski, - EXT_glSamplePatternEXT, - EXT_glSamplePatternSGIS, - EXT_glSamplerParameterIiv, - EXT_glSamplerParameterIuiv, - EXT_glSamplerParameterf, - EXT_glSamplerParameterfv, - EXT_glSamplerParameteri, - EXT_glSamplerParameteriv, - EXT_glScissorArrayv, - EXT_glScissorIndexed, - EXT_glScissorIndexedv, - EXT_glSecondaryColor3b, - EXT_glSecondaryColor3bEXT, - EXT_glSecondaryColor3bv, - EXT_glSecondaryColor3bvEXT, - EXT_glSecondaryColor3d, - EXT_glSecondaryColor3dEXT, - EXT_glSecondaryColor3dv, - EXT_glSecondaryColor3dvEXT, - EXT_glSecondaryColor3f, - EXT_glSecondaryColor3fEXT, - EXT_glSecondaryColor3fv, - EXT_glSecondaryColor3fvEXT, - EXT_glSecondaryColor3hNV, - EXT_glSecondaryColor3hvNV, - EXT_glSecondaryColor3i, - EXT_glSecondaryColor3iEXT, - EXT_glSecondaryColor3iv, - EXT_glSecondaryColor3ivEXT, - EXT_glSecondaryColor3s, - EXT_glSecondaryColor3sEXT, - EXT_glSecondaryColor3sv, - EXT_glSecondaryColor3svEXT, - EXT_glSecondaryColor3ub, - EXT_glSecondaryColor3ubEXT, - EXT_glSecondaryColor3ubv, - EXT_glSecondaryColor3ubvEXT, - EXT_glSecondaryColor3ui, - EXT_glSecondaryColor3uiEXT, - EXT_glSecondaryColor3uiv, - EXT_glSecondaryColor3uivEXT, - EXT_glSecondaryColor3us, - EXT_glSecondaryColor3usEXT, - EXT_glSecondaryColor3usv, - EXT_glSecondaryColor3usvEXT, - EXT_glSecondaryColorFormatNV, - EXT_glSecondaryColorP3ui, - EXT_glSecondaryColorP3uiv, - EXT_glSecondaryColorPointer, - EXT_glSecondaryColorPointerEXT, - EXT_glSecondaryColorPointerListIBM, - EXT_glSelectPerfMonitorCountersAMD, - EXT_glSelectTextureCoordSetSGIS, - EXT_glSelectTextureSGIS, - EXT_glSeparableFilter2D, - EXT_glSeparableFilter2DEXT, - EXT_glSetFenceAPPLE, - EXT_glSetFenceNV, - EXT_glSetFragmentShaderConstantATI, - EXT_glSetInvariantEXT, - EXT_glSetLocalConstantEXT, - EXT_glSetMultisamplefvAMD, - EXT_glShaderBinary, - EXT_glShaderOp1EXT, - EXT_glShaderOp2EXT, - EXT_glShaderOp3EXT, - EXT_glShaderSource, - EXT_glShaderSourceARB, - EXT_glSharpenTexFuncSGIS, - EXT_glSpriteParameterfSGIX, - EXT_glSpriteParameterfvSGIX, - EXT_glSpriteParameteriSGIX, - EXT_glSpriteParameterivSGIX, - EXT_glStartInstrumentsSGIX, - EXT_glStencilClearTagEXT, - EXT_glStencilFillPathInstancedNV, - EXT_glStencilFillPathNV, - EXT_glStencilFuncSeparate, - EXT_glStencilFuncSeparateATI, - EXT_glStencilMaskSeparate, - EXT_glStencilOpSeparate, - EXT_glStencilOpSeparateATI, - EXT_glStencilOpValueAMD, - EXT_glStencilStrokePathInstancedNV, - EXT_glStencilStrokePathNV, - EXT_glStopInstrumentsSGIX, - EXT_glStringMarkerGREMEDY, - EXT_glSwizzleEXT, - EXT_glTagSampleBufferSGIX, - EXT_glTangent3bEXT, - EXT_glTangent3bvEXT, - EXT_glTangent3dEXT, - EXT_glTangent3dvEXT, - EXT_glTangent3fEXT, - EXT_glTangent3fvEXT, - EXT_glTangent3iEXT, - EXT_glTangent3ivEXT, - EXT_glTangent3sEXT, - EXT_glTangent3svEXT, - EXT_glTangentPointerEXT, - EXT_glTbufferMask3DFX, - EXT_glTessellationFactorAMD, - EXT_glTessellationModeAMD, - EXT_glTestFenceAPPLE, - EXT_glTestFenceNV, - EXT_glTestObjectAPPLE, - EXT_glTexBuffer, - EXT_glTexBufferARB, - EXT_glTexBufferEXT, - EXT_glTexBumpParameterfvATI, - EXT_glTexBumpParameterivATI, - EXT_glTexCoord1hNV, - EXT_glTexCoord1hvNV, - EXT_glTexCoord2fColor3fVertex3fSUN, - EXT_glTexCoord2fColor3fVertex3fvSUN, - EXT_glTexCoord2fColor4fNormal3fVertex3fSUN, - EXT_glTexCoord2fColor4fNormal3fVertex3fvSUN, - EXT_glTexCoord2fColor4ubVertex3fSUN, - EXT_glTexCoord2fColor4ubVertex3fvSUN, - EXT_glTexCoord2fNormal3fVertex3fSUN, - EXT_glTexCoord2fNormal3fVertex3fvSUN, - EXT_glTexCoord2fVertex3fSUN, - EXT_glTexCoord2fVertex3fvSUN, - EXT_glTexCoord2hNV, - EXT_glTexCoord2hvNV, - EXT_glTexCoord3hNV, - EXT_glTexCoord3hvNV, - EXT_glTexCoord4fColor4fNormal3fVertex4fSUN, - EXT_glTexCoord4fColor4fNormal3fVertex4fvSUN, - EXT_glTexCoord4fVertex4fSUN, - EXT_glTexCoord4fVertex4fvSUN, - EXT_glTexCoord4hNV, - EXT_glTexCoord4hvNV, - EXT_glTexCoordFormatNV, - EXT_glTexCoordP1ui, - EXT_glTexCoordP1uiv, - EXT_glTexCoordP2ui, - EXT_glTexCoordP2uiv, - EXT_glTexCoordP3ui, - EXT_glTexCoordP3uiv, - EXT_glTexCoordP4ui, - EXT_glTexCoordP4uiv, - EXT_glTexCoordPointerEXT, - EXT_glTexCoordPointerListIBM, - EXT_glTexCoordPointervINTEL, - EXT_glTexFilterFuncSGIS, - EXT_glTexImage2DMultisample, - EXT_glTexImage2DMultisampleCoverageNV, - EXT_glTexImage3D, - EXT_glTexImage3DEXT, - EXT_glTexImage3DMultisample, - EXT_glTexImage3DMultisampleCoverageNV, - EXT_glTexImage4DSGIS, - EXT_glTexParameterIiv, - EXT_glTexParameterIivEXT, - EXT_glTexParameterIuiv, - EXT_glTexParameterIuivEXT, - EXT_glTexRenderbufferNV, - EXT_glTexStorage1D, - EXT_glTexStorage2D, - EXT_glTexStorage3D, - EXT_glTexSubImage1DEXT, - EXT_glTexSubImage2DEXT, - EXT_glTexSubImage3D, - EXT_glTexSubImage3DEXT, - EXT_glTexSubImage4DSGIS, - EXT_glTextureBarrierNV, - EXT_glTextureBufferEXT, - EXT_glTextureColorMaskSGIS, - EXT_glTextureImage1DEXT, - EXT_glTextureImage2DEXT, - EXT_glTextureImage2DMultisampleCoverageNV, - EXT_glTextureImage2DMultisampleNV, - EXT_glTextureImage3DEXT, - EXT_glTextureImage3DMultisampleCoverageNV, - EXT_glTextureImage3DMultisampleNV, - EXT_glTextureLightEXT, - EXT_glTextureMaterialEXT, - EXT_glTextureNormalEXT, - EXT_glTextureParameterIivEXT, - EXT_glTextureParameterIuivEXT, - EXT_glTextureParameterfEXT, - EXT_glTextureParameterfvEXT, - EXT_glTextureParameteriEXT, - EXT_glTextureParameterivEXT, - EXT_glTextureRangeAPPLE, - EXT_glTextureRenderbufferEXT, - EXT_glTextureStorage1DEXT, - EXT_glTextureStorage2DEXT, - EXT_glTextureStorage3DEXT, - EXT_glTextureSubImage1DEXT, - EXT_glTextureSubImage2DEXT, - EXT_glTextureSubImage3DEXT, - EXT_glTrackMatrixNV, - EXT_glTransformFeedbackAttribsNV, - EXT_glTransformFeedbackStreamAttribsNV, - EXT_glTransformFeedbackVaryings, - EXT_glTransformFeedbackVaryingsEXT, - EXT_glTransformFeedbackVaryingsNV, - EXT_glTransformPathNV, - EXT_glUniform1d, - EXT_glUniform1dv, - EXT_glUniform1f, - EXT_glUniform1fARB, - EXT_glUniform1fv, - EXT_glUniform1fvARB, - EXT_glUniform1i, - EXT_glUniform1i64NV, - EXT_glUniform1i64vNV, - EXT_glUniform1iARB, - EXT_glUniform1iv, - EXT_glUniform1ivARB, - EXT_glUniform1ui, - EXT_glUniform1ui64NV, - EXT_glUniform1ui64vNV, - EXT_glUniform1uiEXT, - EXT_glUniform1uiv, - EXT_glUniform1uivEXT, - EXT_glUniform2d, - EXT_glUniform2dv, - EXT_glUniform2f, - EXT_glUniform2fARB, - EXT_glUniform2fv, - EXT_glUniform2fvARB, - EXT_glUniform2i, - EXT_glUniform2i64NV, - EXT_glUniform2i64vNV, - EXT_glUniform2iARB, - EXT_glUniform2iv, - EXT_glUniform2ivARB, - EXT_glUniform2ui, - EXT_glUniform2ui64NV, - EXT_glUniform2ui64vNV, - EXT_glUniform2uiEXT, - EXT_glUniform2uiv, - EXT_glUniform2uivEXT, - EXT_glUniform3d, - EXT_glUniform3dv, - EXT_glUniform3f, - EXT_glUniform3fARB, - EXT_glUniform3fv, - EXT_glUniform3fvARB, - EXT_glUniform3i, - EXT_glUniform3i64NV, - EXT_glUniform3i64vNV, - EXT_glUniform3iARB, - EXT_glUniform3iv, - EXT_glUniform3ivARB, - EXT_glUniform3ui, - EXT_glUniform3ui64NV, - EXT_glUniform3ui64vNV, - EXT_glUniform3uiEXT, - EXT_glUniform3uiv, - EXT_glUniform3uivEXT, - EXT_glUniform4d, - EXT_glUniform4dv, - EXT_glUniform4f, - EXT_glUniform4fARB, - EXT_glUniform4fv, - EXT_glUniform4fvARB, - EXT_glUniform4i, - EXT_glUniform4i64NV, - EXT_glUniform4i64vNV, - EXT_glUniform4iARB, - EXT_glUniform4iv, - EXT_glUniform4ivARB, - EXT_glUniform4ui, - EXT_glUniform4ui64NV, - EXT_glUniform4ui64vNV, - EXT_glUniform4uiEXT, - EXT_glUniform4uiv, - EXT_glUniform4uivEXT, - EXT_glUniformBlockBinding, - EXT_glUniformBufferEXT, - EXT_glUniformHandleui64NV, - EXT_glUniformHandleui64vNV, - EXT_glUniformMatrix2dv, - EXT_glUniformMatrix2fv, - EXT_glUniformMatrix2fvARB, - EXT_glUniformMatrix2x3dv, - EXT_glUniformMatrix2x3fv, - EXT_glUniformMatrix2x4dv, - EXT_glUniformMatrix2x4fv, - EXT_glUniformMatrix3dv, - EXT_glUniformMatrix3fv, - EXT_glUniformMatrix3fvARB, - EXT_glUniformMatrix3x2dv, - EXT_glUniformMatrix3x2fv, - EXT_glUniformMatrix3x4dv, - EXT_glUniformMatrix3x4fv, - EXT_glUniformMatrix4dv, - EXT_glUniformMatrix4fv, - EXT_glUniformMatrix4fvARB, - EXT_glUniformMatrix4x2dv, - EXT_glUniformMatrix4x2fv, - EXT_glUniformMatrix4x3dv, - EXT_glUniformMatrix4x3fv, - EXT_glUniformSubroutinesuiv, - EXT_glUniformui64NV, - EXT_glUniformui64vNV, - EXT_glUnlockArraysEXT, - EXT_glUnmapBuffer, - EXT_glUnmapBufferARB, - EXT_glUnmapNamedBufferEXT, - EXT_glUnmapObjectBufferATI, - EXT_glUpdateObjectBufferATI, - EXT_glUseProgram, - EXT_glUseProgramObjectARB, - EXT_glUseProgramStages, - EXT_glUseShaderProgramEXT, - EXT_glVDPAUFiniNV, - EXT_glVDPAUGetSurfaceivNV, - EXT_glVDPAUInitNV, - EXT_glVDPAUIsSurfaceNV, - EXT_glVDPAUMapSurfacesNV, - EXT_glVDPAURegisterOutputSurfaceNV, - EXT_glVDPAURegisterVideoSurfaceNV, - EXT_glVDPAUSurfaceAccessNV, - EXT_glVDPAUUnmapSurfacesNV, - EXT_glVDPAUUnregisterSurfaceNV, - EXT_glValidateProgram, - EXT_glValidateProgramARB, - EXT_glValidateProgramPipeline, - EXT_glVariantArrayObjectATI, - EXT_glVariantPointerEXT, - EXT_glVariantbvEXT, - EXT_glVariantdvEXT, - EXT_glVariantfvEXT, - EXT_glVariantivEXT, - EXT_glVariantsvEXT, - EXT_glVariantubvEXT, - EXT_glVariantuivEXT, - EXT_glVariantusvEXT, - EXT_glVertex2hNV, - EXT_glVertex2hvNV, - EXT_glVertex3hNV, - EXT_glVertex3hvNV, - EXT_glVertex4hNV, - EXT_glVertex4hvNV, - EXT_glVertexArrayParameteriAPPLE, - EXT_glVertexArrayRangeAPPLE, - EXT_glVertexArrayRangeNV, - EXT_glVertexArrayVertexAttribLOffsetEXT, - EXT_glVertexAttrib1d, - EXT_glVertexAttrib1dARB, - EXT_glVertexAttrib1dNV, - EXT_glVertexAttrib1dv, - EXT_glVertexAttrib1dvARB, - EXT_glVertexAttrib1dvNV, - EXT_glVertexAttrib1f, - EXT_glVertexAttrib1fARB, - EXT_glVertexAttrib1fNV, - EXT_glVertexAttrib1fv, - EXT_glVertexAttrib1fvARB, - EXT_glVertexAttrib1fvNV, - EXT_glVertexAttrib1hNV, - EXT_glVertexAttrib1hvNV, - EXT_glVertexAttrib1s, - EXT_glVertexAttrib1sARB, - EXT_glVertexAttrib1sNV, - EXT_glVertexAttrib1sv, - EXT_glVertexAttrib1svARB, - EXT_glVertexAttrib1svNV, - EXT_glVertexAttrib2d, - EXT_glVertexAttrib2dARB, - EXT_glVertexAttrib2dNV, - EXT_glVertexAttrib2dv, - EXT_glVertexAttrib2dvARB, - EXT_glVertexAttrib2dvNV, - EXT_glVertexAttrib2f, - EXT_glVertexAttrib2fARB, - EXT_glVertexAttrib2fNV, - EXT_glVertexAttrib2fv, - EXT_glVertexAttrib2fvARB, - EXT_glVertexAttrib2fvNV, - EXT_glVertexAttrib2hNV, - EXT_glVertexAttrib2hvNV, - EXT_glVertexAttrib2s, - EXT_glVertexAttrib2sARB, - EXT_glVertexAttrib2sNV, - EXT_glVertexAttrib2sv, - EXT_glVertexAttrib2svARB, - EXT_glVertexAttrib2svNV, - EXT_glVertexAttrib3d, - EXT_glVertexAttrib3dARB, - EXT_glVertexAttrib3dNV, - EXT_glVertexAttrib3dv, - EXT_glVertexAttrib3dvARB, - EXT_glVertexAttrib3dvNV, - EXT_glVertexAttrib3f, - EXT_glVertexAttrib3fARB, - EXT_glVertexAttrib3fNV, - EXT_glVertexAttrib3fv, - EXT_glVertexAttrib3fvARB, - EXT_glVertexAttrib3fvNV, - EXT_glVertexAttrib3hNV, - EXT_glVertexAttrib3hvNV, - EXT_glVertexAttrib3s, - EXT_glVertexAttrib3sARB, - EXT_glVertexAttrib3sNV, - EXT_glVertexAttrib3sv, - EXT_glVertexAttrib3svARB, - EXT_glVertexAttrib3svNV, - EXT_glVertexAttrib4Nbv, - EXT_glVertexAttrib4NbvARB, - EXT_glVertexAttrib4Niv, - EXT_glVertexAttrib4NivARB, - EXT_glVertexAttrib4Nsv, - EXT_glVertexAttrib4NsvARB, - EXT_glVertexAttrib4Nub, - EXT_glVertexAttrib4NubARB, - EXT_glVertexAttrib4Nubv, - EXT_glVertexAttrib4NubvARB, - EXT_glVertexAttrib4Nuiv, - EXT_glVertexAttrib4NuivARB, - EXT_glVertexAttrib4Nusv, - EXT_glVertexAttrib4NusvARB, - EXT_glVertexAttrib4bv, - EXT_glVertexAttrib4bvARB, - EXT_glVertexAttrib4d, - EXT_glVertexAttrib4dARB, - EXT_glVertexAttrib4dNV, - EXT_glVertexAttrib4dv, - EXT_glVertexAttrib4dvARB, - EXT_glVertexAttrib4dvNV, - EXT_glVertexAttrib4f, - EXT_glVertexAttrib4fARB, - EXT_glVertexAttrib4fNV, - EXT_glVertexAttrib4fv, - EXT_glVertexAttrib4fvARB, - EXT_glVertexAttrib4fvNV, - EXT_glVertexAttrib4hNV, - EXT_glVertexAttrib4hvNV, - EXT_glVertexAttrib4iv, - EXT_glVertexAttrib4ivARB, - EXT_glVertexAttrib4s, - EXT_glVertexAttrib4sARB, - EXT_glVertexAttrib4sNV, - EXT_glVertexAttrib4sv, - EXT_glVertexAttrib4svARB, - EXT_glVertexAttrib4svNV, - EXT_glVertexAttrib4ubNV, - EXT_glVertexAttrib4ubv, - EXT_glVertexAttrib4ubvARB, - EXT_glVertexAttrib4ubvNV, - EXT_glVertexAttrib4uiv, - EXT_glVertexAttrib4uivARB, - EXT_glVertexAttrib4usv, - EXT_glVertexAttrib4usvARB, - EXT_glVertexAttribArrayObjectATI, - EXT_glVertexAttribDivisor, - EXT_glVertexAttribDivisorARB, - EXT_glVertexAttribFormatNV, - EXT_glVertexAttribI1i, - EXT_glVertexAttribI1iEXT, - EXT_glVertexAttribI1iv, - EXT_glVertexAttribI1ivEXT, - EXT_glVertexAttribI1ui, - EXT_glVertexAttribI1uiEXT, - EXT_glVertexAttribI1uiv, - EXT_glVertexAttribI1uivEXT, - EXT_glVertexAttribI2i, - EXT_glVertexAttribI2iEXT, - EXT_glVertexAttribI2iv, - EXT_glVertexAttribI2ivEXT, - EXT_glVertexAttribI2ui, - EXT_glVertexAttribI2uiEXT, - EXT_glVertexAttribI2uiv, - EXT_glVertexAttribI2uivEXT, - EXT_glVertexAttribI3i, - EXT_glVertexAttribI3iEXT, - EXT_glVertexAttribI3iv, - EXT_glVertexAttribI3ivEXT, - EXT_glVertexAttribI3ui, - EXT_glVertexAttribI3uiEXT, - EXT_glVertexAttribI3uiv, - EXT_glVertexAttribI3uivEXT, - EXT_glVertexAttribI4bv, - EXT_glVertexAttribI4bvEXT, - EXT_glVertexAttribI4i, - EXT_glVertexAttribI4iEXT, - EXT_glVertexAttribI4iv, - EXT_glVertexAttribI4ivEXT, - EXT_glVertexAttribI4sv, - EXT_glVertexAttribI4svEXT, - EXT_glVertexAttribI4ubv, - EXT_glVertexAttribI4ubvEXT, - EXT_glVertexAttribI4ui, - EXT_glVertexAttribI4uiEXT, - EXT_glVertexAttribI4uiv, - EXT_glVertexAttribI4uivEXT, - EXT_glVertexAttribI4usv, - EXT_glVertexAttribI4usvEXT, - EXT_glVertexAttribIFormatNV, - EXT_glVertexAttribIPointer, - EXT_glVertexAttribIPointerEXT, - EXT_glVertexAttribL1d, - EXT_glVertexAttribL1dEXT, - EXT_glVertexAttribL1dv, - EXT_glVertexAttribL1dvEXT, - EXT_glVertexAttribL1i64NV, - EXT_glVertexAttribL1i64vNV, - EXT_glVertexAttribL1ui64NV, - EXT_glVertexAttribL1ui64vNV, - EXT_glVertexAttribL2d, - EXT_glVertexAttribL2dEXT, - EXT_glVertexAttribL2dv, - EXT_glVertexAttribL2dvEXT, - EXT_glVertexAttribL2i64NV, - EXT_glVertexAttribL2i64vNV, - EXT_glVertexAttribL2ui64NV, - EXT_glVertexAttribL2ui64vNV, - EXT_glVertexAttribL3d, - EXT_glVertexAttribL3dEXT, - EXT_glVertexAttribL3dv, - EXT_glVertexAttribL3dvEXT, - EXT_glVertexAttribL3i64NV, - EXT_glVertexAttribL3i64vNV, - EXT_glVertexAttribL3ui64NV, - EXT_glVertexAttribL3ui64vNV, - EXT_glVertexAttribL4d, - EXT_glVertexAttribL4dEXT, - EXT_glVertexAttribL4dv, - EXT_glVertexAttribL4dvEXT, - EXT_glVertexAttribL4i64NV, - EXT_glVertexAttribL4i64vNV, - EXT_glVertexAttribL4ui64NV, - EXT_glVertexAttribL4ui64vNV, - EXT_glVertexAttribLFormatNV, - EXT_glVertexAttribLPointer, - EXT_glVertexAttribLPointerEXT, - EXT_glVertexAttribP1ui, - EXT_glVertexAttribP1uiv, - EXT_glVertexAttribP2ui, - EXT_glVertexAttribP2uiv, - EXT_glVertexAttribP3ui, - EXT_glVertexAttribP3uiv, - EXT_glVertexAttribP4ui, - EXT_glVertexAttribP4uiv, - EXT_glVertexAttribPointer, - EXT_glVertexAttribPointerARB, - EXT_glVertexAttribPointerNV, - EXT_glVertexAttribs1dvNV, - EXT_glVertexAttribs1fvNV, - EXT_glVertexAttribs1hvNV, - EXT_glVertexAttribs1svNV, - EXT_glVertexAttribs2dvNV, - EXT_glVertexAttribs2fvNV, - EXT_glVertexAttribs2hvNV, - EXT_glVertexAttribs2svNV, - EXT_glVertexAttribs3dvNV, - EXT_glVertexAttribs3fvNV, - EXT_glVertexAttribs3hvNV, - EXT_glVertexAttribs3svNV, - EXT_glVertexAttribs4dvNV, - EXT_glVertexAttribs4fvNV, - EXT_glVertexAttribs4hvNV, - EXT_glVertexAttribs4svNV, - EXT_glVertexAttribs4ubvNV, - EXT_glVertexBlendARB, - EXT_glVertexBlendEnvfATI, - EXT_glVertexBlendEnviATI, - EXT_glVertexFormatNV, - EXT_glVertexP2ui, - EXT_glVertexP2uiv, - EXT_glVertexP3ui, - EXT_glVertexP3uiv, - EXT_glVertexP4ui, - EXT_glVertexP4uiv, - EXT_glVertexPointerEXT, - EXT_glVertexPointerListIBM, - EXT_glVertexPointervINTEL, - EXT_glVertexStream1dATI, - EXT_glVertexStream1dvATI, - EXT_glVertexStream1fATI, - EXT_glVertexStream1fvATI, - EXT_glVertexStream1iATI, - EXT_glVertexStream1ivATI, - EXT_glVertexStream1sATI, - EXT_glVertexStream1svATI, - EXT_glVertexStream2dATI, - EXT_glVertexStream2dvATI, - EXT_glVertexStream2fATI, - EXT_glVertexStream2fvATI, - EXT_glVertexStream2iATI, - EXT_glVertexStream2ivATI, - EXT_glVertexStream2sATI, - EXT_glVertexStream2svATI, - EXT_glVertexStream3dATI, - EXT_glVertexStream3dvATI, - EXT_glVertexStream3fATI, - EXT_glVertexStream3fvATI, - EXT_glVertexStream3iATI, - EXT_glVertexStream3ivATI, - EXT_glVertexStream3sATI, - EXT_glVertexStream3svATI, - EXT_glVertexStream4dATI, - EXT_glVertexStream4dvATI, - EXT_glVertexStream4fATI, - EXT_glVertexStream4fvATI, - EXT_glVertexStream4iATI, - EXT_glVertexStream4ivATI, - EXT_glVertexStream4sATI, - EXT_glVertexStream4svATI, - EXT_glVertexWeightPointerEXT, - EXT_glVertexWeightfEXT, - EXT_glVertexWeightfvEXT, - EXT_glVertexWeighthNV, - EXT_glVertexWeighthvNV, - EXT_glVideoCaptureNV, - EXT_glVideoCaptureStreamParameterdvNV, - EXT_glVideoCaptureStreamParameterfvNV, - EXT_glVideoCaptureStreamParameterivNV, - EXT_glViewportArrayv, - EXT_glViewportIndexedf, - EXT_glViewportIndexedfv, - EXT_glWaitSync, - EXT_glWeightPathsNV, - EXT_glWeightPointerARB, - EXT_glWeightbvARB, - EXT_glWeightdvARB, - EXT_glWeightfvARB, - EXT_glWeightivARB, - EXT_glWeightsvARB, - EXT_glWeightubvARB, - EXT_glWeightuivARB, - EXT_glWeightusvARB, - EXT_glWindowPos2d, - EXT_glWindowPos2dARB, - EXT_glWindowPos2dMESA, - EXT_glWindowPos2dv, - EXT_glWindowPos2dvARB, - EXT_glWindowPos2dvMESA, - EXT_glWindowPos2f, - EXT_glWindowPos2fARB, - EXT_glWindowPos2fMESA, - EXT_glWindowPos2fv, - EXT_glWindowPos2fvARB, - EXT_glWindowPos2fvMESA, - EXT_glWindowPos2i, - EXT_glWindowPos2iARB, - EXT_glWindowPos2iMESA, - EXT_glWindowPos2iv, - EXT_glWindowPos2ivARB, - EXT_glWindowPos2ivMESA, - EXT_glWindowPos2s, - EXT_glWindowPos2sARB, - EXT_glWindowPos2sMESA, - EXT_glWindowPos2sv, - EXT_glWindowPos2svARB, - EXT_glWindowPos2svMESA, - EXT_glWindowPos3d, - EXT_glWindowPos3dARB, - EXT_glWindowPos3dMESA, - EXT_glWindowPos3dv, - EXT_glWindowPos3dvARB, - EXT_glWindowPos3dvMESA, - EXT_glWindowPos3f, - EXT_glWindowPos3fARB, - EXT_glWindowPos3fMESA, - EXT_glWindowPos3fv, - EXT_glWindowPos3fvARB, - EXT_glWindowPos3fvMESA, - EXT_glWindowPos3i, - EXT_glWindowPos3iARB, - EXT_glWindowPos3iMESA, - EXT_glWindowPos3iv, - EXT_glWindowPos3ivARB, - EXT_glWindowPos3ivMESA, - EXT_glWindowPos3s, - EXT_glWindowPos3sARB, - EXT_glWindowPos3sMESA, - EXT_glWindowPos3sv, - EXT_glWindowPos3svARB, - EXT_glWindowPos3svMESA, - EXT_glWindowPos4dMESA, - EXT_glWindowPos4dvMESA, - EXT_glWindowPos4fMESA, - EXT_glWindowPos4fvMESA, - EXT_glWindowPos4iMESA, - EXT_glWindowPos4ivMESA, - EXT_glWindowPos4sMESA, - EXT_glWindowPos4svMESA, - EXT_glWriteMaskEXT, - NB_EXTENSIONS -}; - -const int extension_registry_size = NB_EXTENSIONS; -void *extension_funcs[NB_EXTENSIONS]; +const int extension_registry_size = 2064; /* The thunks themselves....*/ static void WINAPI wine_glActiveProgramEXT( GLuint program ) { - void (*func_glActiveProgramEXT)( GLuint ) = extension_funcs[EXT_glActiveProgramEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", program ); - func_glActiveProgramEXT( program ); + funcs->ext.p_glActiveProgramEXT( program ); } static void WINAPI wine_glActiveShaderProgram( GLuint pipeline, GLuint program ) { - void (*func_glActiveShaderProgram)( GLuint, GLuint ) = extension_funcs[EXT_glActiveShaderProgram]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", pipeline, program ); - func_glActiveShaderProgram( pipeline, program ); + funcs->ext.p_glActiveShaderProgram( pipeline, program ); } static void WINAPI wine_glActiveStencilFaceEXT( GLenum face ) { - void (*func_glActiveStencilFaceEXT)( GLenum ) = extension_funcs[EXT_glActiveStencilFaceEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", face ); - func_glActiveStencilFaceEXT( face ); + funcs->ext.p_glActiveStencilFaceEXT( face ); } static void WINAPI wine_glActiveTexture( GLenum texture ) { - void (*func_glActiveTexture)( GLenum ) = extension_funcs[EXT_glActiveTexture]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", texture ); - func_glActiveTexture( texture ); + funcs->ext.p_glActiveTexture( texture ); } static void WINAPI wine_glActiveTextureARB( GLenum texture ) { - void (*func_glActiveTextureARB)( GLenum ) = extension_funcs[EXT_glActiveTextureARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", texture ); - func_glActiveTextureARB( texture ); + funcs->ext.p_glActiveTextureARB( texture ); } static void WINAPI wine_glActiveVaryingNV( GLuint program, char* name ) { - void (*func_glActiveVaryingNV)( GLuint, char* ) = extension_funcs[EXT_glActiveVaryingNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", program, name ); - func_glActiveVaryingNV( program, name ); + funcs->ext.p_glActiveVaryingNV( program, name ); } static void WINAPI wine_glAlphaFragmentOp1ATI( GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod ) { - void (*func_glAlphaFragmentOp1ATI)( GLenum, GLuint, GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glAlphaFragmentOp1ATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", op, dst, dstMod, arg1, arg1Rep, arg1Mod ); - func_glAlphaFragmentOp1ATI( op, dst, dstMod, arg1, arg1Rep, arg1Mod ); + funcs->ext.p_glAlphaFragmentOp1ATI( op, dst, dstMod, arg1, arg1Rep, arg1Mod ); } static void WINAPI wine_glAlphaFragmentOp2ATI( GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod ) { - void (*func_glAlphaFragmentOp2ATI)( GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glAlphaFragmentOp2ATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod ); - func_glAlphaFragmentOp2ATI( op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod ); + funcs->ext.p_glAlphaFragmentOp2ATI( op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod ); } static void WINAPI wine_glAlphaFragmentOp3ATI( GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod ) { - void (*func_glAlphaFragmentOp3ATI)( GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glAlphaFragmentOp3ATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod ); - func_glAlphaFragmentOp3ATI( op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod ); + funcs->ext.p_glAlphaFragmentOp3ATI( op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod ); } static void WINAPI wine_glApplyTextureEXT( GLenum mode ) { - void (*func_glApplyTextureEXT)( GLenum ) = extension_funcs[EXT_glApplyTextureEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", mode ); - func_glApplyTextureEXT( mode ); + funcs->ext.p_glApplyTextureEXT( mode ); } static GLboolean WINAPI wine_glAreProgramsResidentNV( GLsizei n, GLuint* programs, GLboolean* residences ) { - GLboolean (*func_glAreProgramsResidentNV)( GLsizei, GLuint*, GLboolean* ) = extension_funcs[EXT_glAreProgramsResidentNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %p)\n", n, programs, residences ); - return func_glAreProgramsResidentNV( n, programs, residences ); + return funcs->ext.p_glAreProgramsResidentNV( n, programs, residences ); } static GLboolean WINAPI wine_glAreTexturesResidentEXT( GLsizei n, GLuint* textures, GLboolean* residences ) { - GLboolean (*func_glAreTexturesResidentEXT)( GLsizei, GLuint*, GLboolean* ) = extension_funcs[EXT_glAreTexturesResidentEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %p)\n", n, textures, residences ); - return func_glAreTexturesResidentEXT( n, textures, residences ); + return funcs->ext.p_glAreTexturesResidentEXT( n, textures, residences ); } static void WINAPI wine_glArrayElementEXT( GLint i ) { - void (*func_glArrayElementEXT)( GLint ) = extension_funcs[EXT_glArrayElementEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", i ); - func_glArrayElementEXT( i ); + funcs->ext.p_glArrayElementEXT( i ); } static void WINAPI wine_glArrayObjectATI( GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset ) { - void (*func_glArrayObjectATI)( GLenum, GLint, GLenum, GLsizei, GLuint, GLuint ) = extension_funcs[EXT_glArrayObjectATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", array, size, type, stride, buffer, offset ); - func_glArrayObjectATI( array, size, type, stride, buffer, offset ); + funcs->ext.p_glArrayObjectATI( array, size, type, stride, buffer, offset ); } static void WINAPI wine_glAsyncMarkerSGIX( GLuint marker ) { - void (*func_glAsyncMarkerSGIX)( GLuint ) = extension_funcs[EXT_glAsyncMarkerSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", marker ); - func_glAsyncMarkerSGIX( marker ); + funcs->ext.p_glAsyncMarkerSGIX( marker ); } static void WINAPI wine_glAttachObjectARB( unsigned int containerObj, unsigned int obj ) { - void (*func_glAttachObjectARB)( unsigned int, unsigned int ) = extension_funcs[EXT_glAttachObjectARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", containerObj, obj ); - func_glAttachObjectARB( containerObj, obj ); + funcs->ext.p_glAttachObjectARB( containerObj, obj ); } static void WINAPI wine_glAttachShader( GLuint program, GLuint shader ) { - void (*func_glAttachShader)( GLuint, GLuint ) = extension_funcs[EXT_glAttachShader]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", program, shader ); - func_glAttachShader( program, shader ); + funcs->ext.p_glAttachShader( program, shader ); } static void WINAPI wine_glBeginConditionalRender( GLuint id, GLenum mode ) { - void (*func_glBeginConditionalRender)( GLuint, GLenum ) = extension_funcs[EXT_glBeginConditionalRender]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", id, mode ); - func_glBeginConditionalRender( id, mode ); + funcs->ext.p_glBeginConditionalRender( id, mode ); } static void WINAPI wine_glBeginConditionalRenderNV( GLuint id, GLenum mode ) { - void (*func_glBeginConditionalRenderNV)( GLuint, GLenum ) = extension_funcs[EXT_glBeginConditionalRenderNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", id, mode ); - func_glBeginConditionalRenderNV( id, mode ); + funcs->ext.p_glBeginConditionalRenderNV( id, mode ); } static void WINAPI wine_glBeginFragmentShaderATI( void ) { - void (*func_glBeginFragmentShaderATI)( void ) = extension_funcs[EXT_glBeginFragmentShaderATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glBeginFragmentShaderATI( ); + funcs->ext.p_glBeginFragmentShaderATI( ); } static void WINAPI wine_glBeginOcclusionQueryNV( GLuint id ) { - void (*func_glBeginOcclusionQueryNV)( GLuint ) = extension_funcs[EXT_glBeginOcclusionQueryNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", id ); - func_glBeginOcclusionQueryNV( id ); + funcs->ext.p_glBeginOcclusionQueryNV( id ); } static void WINAPI wine_glBeginPerfMonitorAMD( GLuint monitor ) { - void (*func_glBeginPerfMonitorAMD)( GLuint ) = extension_funcs[EXT_glBeginPerfMonitorAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", monitor ); - func_glBeginPerfMonitorAMD( monitor ); + funcs->ext.p_glBeginPerfMonitorAMD( monitor ); } static void WINAPI wine_glBeginQuery( GLenum target, GLuint id ) { - void (*func_glBeginQuery)( GLenum, GLuint ) = extension_funcs[EXT_glBeginQuery]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, id ); - func_glBeginQuery( target, id ); + funcs->ext.p_glBeginQuery( target, id ); } static void WINAPI wine_glBeginQueryARB( GLenum target, GLuint id ) { - void (*func_glBeginQueryARB)( GLenum, GLuint ) = extension_funcs[EXT_glBeginQueryARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, id ); - func_glBeginQueryARB( target, id ); + funcs->ext.p_glBeginQueryARB( target, id ); } static void WINAPI wine_glBeginQueryIndexed( GLenum target, GLuint index, GLuint id ) { - void (*func_glBeginQueryIndexed)( GLenum, GLuint, GLuint ) = extension_funcs[EXT_glBeginQueryIndexed]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, index, id ); - func_glBeginQueryIndexed( target, index, id ); + funcs->ext.p_glBeginQueryIndexed( target, index, id ); } static void WINAPI wine_glBeginTransformFeedback( GLenum primitiveMode ) { - void (*func_glBeginTransformFeedback)( GLenum ) = extension_funcs[EXT_glBeginTransformFeedback]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", primitiveMode ); - func_glBeginTransformFeedback( primitiveMode ); + funcs->ext.p_glBeginTransformFeedback( primitiveMode ); } static void WINAPI wine_glBeginTransformFeedbackEXT( GLenum primitiveMode ) { - void (*func_glBeginTransformFeedbackEXT)( GLenum ) = extension_funcs[EXT_glBeginTransformFeedbackEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", primitiveMode ); - func_glBeginTransformFeedbackEXT( primitiveMode ); + funcs->ext.p_glBeginTransformFeedbackEXT( primitiveMode ); } static void WINAPI wine_glBeginTransformFeedbackNV( GLenum primitiveMode ) { - void (*func_glBeginTransformFeedbackNV)( GLenum ) = extension_funcs[EXT_glBeginTransformFeedbackNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", primitiveMode ); - func_glBeginTransformFeedbackNV( primitiveMode ); + funcs->ext.p_glBeginTransformFeedbackNV( primitiveMode ); } static void WINAPI wine_glBeginVertexShaderEXT( void ) { - void (*func_glBeginVertexShaderEXT)( void ) = extension_funcs[EXT_glBeginVertexShaderEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glBeginVertexShaderEXT( ); + funcs->ext.p_glBeginVertexShaderEXT( ); } static void WINAPI wine_glBeginVideoCaptureNV( GLuint video_capture_slot ) { - void (*func_glBeginVideoCaptureNV)( GLuint ) = extension_funcs[EXT_glBeginVideoCaptureNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", video_capture_slot ); - func_glBeginVideoCaptureNV( video_capture_slot ); + funcs->ext.p_glBeginVideoCaptureNV( video_capture_slot ); } static void WINAPI wine_glBindAttribLocation( GLuint program, GLuint index, char* name ) { - void (*func_glBindAttribLocation)( GLuint, GLuint, char* ) = extension_funcs[EXT_glBindAttribLocation]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", program, index, name ); - func_glBindAttribLocation( program, index, name ); + funcs->ext.p_glBindAttribLocation( program, index, name ); } static void WINAPI wine_glBindAttribLocationARB( unsigned int programObj, GLuint index, char* name ) { - void (*func_glBindAttribLocationARB)( unsigned int, GLuint, char* ) = extension_funcs[EXT_glBindAttribLocationARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", programObj, index, name ); - func_glBindAttribLocationARB( programObj, index, name ); + funcs->ext.p_glBindAttribLocationARB( programObj, index, name ); } static void WINAPI wine_glBindBuffer( GLenum target, GLuint buffer ) { - void (*func_glBindBuffer)( GLenum, GLuint ) = extension_funcs[EXT_glBindBuffer]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, buffer ); - func_glBindBuffer( target, buffer ); + funcs->ext.p_glBindBuffer( target, buffer ); } static void WINAPI wine_glBindBufferARB( GLenum target, GLuint buffer ) { - void (*func_glBindBufferARB)( GLenum, GLuint ) = extension_funcs[EXT_glBindBufferARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, buffer ); - func_glBindBufferARB( target, buffer ); + funcs->ext.p_glBindBufferARB( target, buffer ); } static void WINAPI wine_glBindBufferBase( GLenum target, GLuint index, GLuint buffer ) { - void (*func_glBindBufferBase)( GLenum, GLuint, GLuint ) = extension_funcs[EXT_glBindBufferBase]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, index, buffer ); - func_glBindBufferBase( target, index, buffer ); + funcs->ext.p_glBindBufferBase( target, index, buffer ); } static void WINAPI wine_glBindBufferBaseEXT( GLenum target, GLuint index, GLuint buffer ) { - void (*func_glBindBufferBaseEXT)( GLenum, GLuint, GLuint ) = extension_funcs[EXT_glBindBufferBaseEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, index, buffer ); - func_glBindBufferBaseEXT( target, index, buffer ); + funcs->ext.p_glBindBufferBaseEXT( target, index, buffer ); } static void WINAPI wine_glBindBufferBaseNV( GLenum target, GLuint index, GLuint buffer ) { - void (*func_glBindBufferBaseNV)( GLenum, GLuint, GLuint ) = extension_funcs[EXT_glBindBufferBaseNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, index, buffer ); - func_glBindBufferBaseNV( target, index, buffer ); + funcs->ext.p_glBindBufferBaseNV( target, index, buffer ); } static void WINAPI wine_glBindBufferOffsetEXT( GLenum target, GLuint index, GLuint buffer, INT_PTR offset ) { - void (*func_glBindBufferOffsetEXT)( GLenum, GLuint, GLuint, INT_PTR ) = extension_funcs[EXT_glBindBufferOffsetEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %ld)\n", target, index, buffer, offset ); - func_glBindBufferOffsetEXT( target, index, buffer, offset ); + funcs->ext.p_glBindBufferOffsetEXT( target, index, buffer, offset ); } static void WINAPI wine_glBindBufferOffsetNV( GLenum target, GLuint index, GLuint buffer, INT_PTR offset ) { - void (*func_glBindBufferOffsetNV)( GLenum, GLuint, GLuint, INT_PTR ) = extension_funcs[EXT_glBindBufferOffsetNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %ld)\n", target, index, buffer, offset ); - func_glBindBufferOffsetNV( target, index, buffer, offset ); + funcs->ext.p_glBindBufferOffsetNV( target, index, buffer, offset ); } static void WINAPI wine_glBindBufferRange( GLenum target, GLuint index, GLuint buffer, INT_PTR offset, INT_PTR size ) { - void (*func_glBindBufferRange)( GLenum, GLuint, GLuint, INT_PTR, INT_PTR ) = extension_funcs[EXT_glBindBufferRange]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %ld, %ld)\n", target, index, buffer, offset, size ); - func_glBindBufferRange( target, index, buffer, offset, size ); + funcs->ext.p_glBindBufferRange( target, index, buffer, offset, size ); } static void WINAPI wine_glBindBufferRangeEXT( GLenum target, GLuint index, GLuint buffer, INT_PTR offset, INT_PTR size ) { - void (*func_glBindBufferRangeEXT)( GLenum, GLuint, GLuint, INT_PTR, INT_PTR ) = extension_funcs[EXT_glBindBufferRangeEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %ld, %ld)\n", target, index, buffer, offset, size ); - func_glBindBufferRangeEXT( target, index, buffer, offset, size ); + funcs->ext.p_glBindBufferRangeEXT( target, index, buffer, offset, size ); } static void WINAPI wine_glBindBufferRangeNV( GLenum target, GLuint index, GLuint buffer, INT_PTR offset, INT_PTR size ) { - void (*func_glBindBufferRangeNV)( GLenum, GLuint, GLuint, INT_PTR, INT_PTR ) = extension_funcs[EXT_glBindBufferRangeNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %ld, %ld)\n", target, index, buffer, offset, size ); - func_glBindBufferRangeNV( target, index, buffer, offset, size ); + funcs->ext.p_glBindBufferRangeNV( target, index, buffer, offset, size ); } static void WINAPI wine_glBindFragDataLocation( GLuint program, GLuint color, char* name ) { - void (*func_glBindFragDataLocation)( GLuint, GLuint, char* ) = extension_funcs[EXT_glBindFragDataLocation]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", program, color, name ); - func_glBindFragDataLocation( program, color, name ); + funcs->ext.p_glBindFragDataLocation( program, color, name ); } static void WINAPI wine_glBindFragDataLocationEXT( GLuint program, GLuint color, char* name ) { - void (*func_glBindFragDataLocationEXT)( GLuint, GLuint, char* ) = extension_funcs[EXT_glBindFragDataLocationEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", program, color, name ); - func_glBindFragDataLocationEXT( program, color, name ); + funcs->ext.p_glBindFragDataLocationEXT( program, color, name ); } static void WINAPI wine_glBindFragDataLocationIndexed( GLuint program, GLuint colorNumber, GLuint index, char* name ) { - void (*func_glBindFragDataLocationIndexed)( GLuint, GLuint, GLuint, char* ) = extension_funcs[EXT_glBindFragDataLocationIndexed]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, colorNumber, index, name ); - func_glBindFragDataLocationIndexed( program, colorNumber, index, name ); + funcs->ext.p_glBindFragDataLocationIndexed( program, colorNumber, index, name ); } static void WINAPI wine_glBindFragmentShaderATI( GLuint id ) { - void (*func_glBindFragmentShaderATI)( GLuint ) = extension_funcs[EXT_glBindFragmentShaderATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", id ); - func_glBindFragmentShaderATI( id ); + funcs->ext.p_glBindFragmentShaderATI( id ); } static void WINAPI wine_glBindFramebuffer( GLenum target, GLuint framebuffer ) { - void (*func_glBindFramebuffer)( GLenum, GLuint ) = extension_funcs[EXT_glBindFramebuffer]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, framebuffer ); - func_glBindFramebuffer( target, framebuffer ); + funcs->ext.p_glBindFramebuffer( target, framebuffer ); } static void WINAPI wine_glBindFramebufferEXT( GLenum target, GLuint framebuffer ) { - void (*func_glBindFramebufferEXT)( GLenum, GLuint ) = extension_funcs[EXT_glBindFramebufferEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, framebuffer ); - func_glBindFramebufferEXT( target, framebuffer ); + funcs->ext.p_glBindFramebufferEXT( target, framebuffer ); } static void WINAPI wine_glBindImageTexture( GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format ) { - void (*func_glBindImageTexture)( GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLenum ) = extension_funcs[EXT_glBindImageTexture]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", unit, texture, level, layered, layer, access, format ); - func_glBindImageTexture( unit, texture, level, layered, layer, access, format ); + funcs->ext.p_glBindImageTexture( unit, texture, level, layered, layer, access, format ); } static void WINAPI wine_glBindImageTextureEXT( GLuint index, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLint format ) { - void (*func_glBindImageTextureEXT)( GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLint ) = extension_funcs[EXT_glBindImageTextureEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", index, texture, level, layered, layer, access, format ); - func_glBindImageTextureEXT( index, texture, level, layered, layer, access, format ); + funcs->ext.p_glBindImageTextureEXT( index, texture, level, layered, layer, access, format ); } static GLuint WINAPI wine_glBindLightParameterEXT( GLenum light, GLenum value ) { - GLuint (*func_glBindLightParameterEXT)( GLenum, GLenum ) = extension_funcs[EXT_glBindLightParameterEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", light, value ); - return func_glBindLightParameterEXT( light, value ); + return funcs->ext.p_glBindLightParameterEXT( light, value ); } static GLuint WINAPI wine_glBindMaterialParameterEXT( GLenum face, GLenum value ) { - GLuint (*func_glBindMaterialParameterEXT)( GLenum, GLenum ) = extension_funcs[EXT_glBindMaterialParameterEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", face, value ); - return func_glBindMaterialParameterEXT( face, value ); + return funcs->ext.p_glBindMaterialParameterEXT( face, value ); } static void WINAPI wine_glBindMultiTextureEXT( GLenum texunit, GLenum target, GLuint texture ) { - void (*func_glBindMultiTextureEXT)( GLenum, GLenum, GLuint ) = extension_funcs[EXT_glBindMultiTextureEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", texunit, target, texture ); - func_glBindMultiTextureEXT( texunit, target, texture ); + funcs->ext.p_glBindMultiTextureEXT( texunit, target, texture ); } static GLuint WINAPI wine_glBindParameterEXT( GLenum value ) { - GLuint (*func_glBindParameterEXT)( GLenum ) = extension_funcs[EXT_glBindParameterEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", value ); - return func_glBindParameterEXT( value ); + return funcs->ext.p_glBindParameterEXT( value ); } static void WINAPI wine_glBindProgramARB( GLenum target, GLuint program ) { - void (*func_glBindProgramARB)( GLenum, GLuint ) = extension_funcs[EXT_glBindProgramARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, program ); - func_glBindProgramARB( target, program ); + funcs->ext.p_glBindProgramARB( target, program ); } static void WINAPI wine_glBindProgramNV( GLenum target, GLuint id ) { - void (*func_glBindProgramNV)( GLenum, GLuint ) = extension_funcs[EXT_glBindProgramNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, id ); - func_glBindProgramNV( target, id ); + funcs->ext.p_glBindProgramNV( target, id ); } static void WINAPI wine_glBindProgramPipeline( GLuint pipeline ) { - void (*func_glBindProgramPipeline)( GLuint ) = extension_funcs[EXT_glBindProgramPipeline]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", pipeline ); - func_glBindProgramPipeline( pipeline ); + funcs->ext.p_glBindProgramPipeline( pipeline ); } static void WINAPI wine_glBindRenderbuffer( GLenum target, GLuint renderbuffer ) { - void (*func_glBindRenderbuffer)( GLenum, GLuint ) = extension_funcs[EXT_glBindRenderbuffer]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, renderbuffer ); - func_glBindRenderbuffer( target, renderbuffer ); + funcs->ext.p_glBindRenderbuffer( target, renderbuffer ); } static void WINAPI wine_glBindRenderbufferEXT( GLenum target, GLuint renderbuffer ) { - void (*func_glBindRenderbufferEXT)( GLenum, GLuint ) = extension_funcs[EXT_glBindRenderbufferEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, renderbuffer ); - func_glBindRenderbufferEXT( target, renderbuffer ); + funcs->ext.p_glBindRenderbufferEXT( target, renderbuffer ); } static void WINAPI wine_glBindSampler( GLuint unit, GLuint sampler ) { - void (*func_glBindSampler)( GLuint, GLuint ) = extension_funcs[EXT_glBindSampler]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", unit, sampler ); - func_glBindSampler( unit, sampler ); + funcs->ext.p_glBindSampler( unit, sampler ); } static GLuint WINAPI wine_glBindTexGenParameterEXT( GLenum unit, GLenum coord, GLenum value ) { - GLuint (*func_glBindTexGenParameterEXT)( GLenum, GLenum, GLenum ) = extension_funcs[EXT_glBindTexGenParameterEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", unit, coord, value ); - return func_glBindTexGenParameterEXT( unit, coord, value ); + return funcs->ext.p_glBindTexGenParameterEXT( unit, coord, value ); } static void WINAPI wine_glBindTextureEXT( GLenum target, GLuint texture ) { - void (*func_glBindTextureEXT)( GLenum, GLuint ) = extension_funcs[EXT_glBindTextureEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, texture ); - func_glBindTextureEXT( target, texture ); + funcs->ext.p_glBindTextureEXT( target, texture ); } static GLuint WINAPI wine_glBindTextureUnitParameterEXT( GLenum unit, GLenum value ) { - GLuint (*func_glBindTextureUnitParameterEXT)( GLenum, GLenum ) = extension_funcs[EXT_glBindTextureUnitParameterEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", unit, value ); - return func_glBindTextureUnitParameterEXT( unit, value ); + return funcs->ext.p_glBindTextureUnitParameterEXT( unit, value ); } static void WINAPI wine_glBindTransformFeedback( GLenum target, GLuint id ) { - void (*func_glBindTransformFeedback)( GLenum, GLuint ) = extension_funcs[EXT_glBindTransformFeedback]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, id ); - func_glBindTransformFeedback( target, id ); + funcs->ext.p_glBindTransformFeedback( target, id ); } static void WINAPI wine_glBindTransformFeedbackNV( GLenum target, GLuint id ) { - void (*func_glBindTransformFeedbackNV)( GLenum, GLuint ) = extension_funcs[EXT_glBindTransformFeedbackNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, id ); - func_glBindTransformFeedbackNV( target, id ); + funcs->ext.p_glBindTransformFeedbackNV( target, id ); } static void WINAPI wine_glBindVertexArray( GLuint array ) { - void (*func_glBindVertexArray)( GLuint ) = extension_funcs[EXT_glBindVertexArray]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", array ); - func_glBindVertexArray( array ); + funcs->ext.p_glBindVertexArray( array ); } static void WINAPI wine_glBindVertexArrayAPPLE( GLuint array ) { - void (*func_glBindVertexArrayAPPLE)( GLuint ) = extension_funcs[EXT_glBindVertexArrayAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", array ); - func_glBindVertexArrayAPPLE( array ); + funcs->ext.p_glBindVertexArrayAPPLE( array ); } static void WINAPI wine_glBindVertexShaderEXT( GLuint id ) { - void (*func_glBindVertexShaderEXT)( GLuint ) = extension_funcs[EXT_glBindVertexShaderEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", id ); - func_glBindVertexShaderEXT( id ); + funcs->ext.p_glBindVertexShaderEXT( id ); } static void WINAPI wine_glBindVideoCaptureStreamBufferNV( GLuint video_capture_slot, GLuint stream, GLenum frame_region, INT_PTR offset ) { - void (*func_glBindVideoCaptureStreamBufferNV)( GLuint, GLuint, GLenum, INT_PTR ) = extension_funcs[EXT_glBindVideoCaptureStreamBufferNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %ld)\n", video_capture_slot, stream, frame_region, offset ); - func_glBindVideoCaptureStreamBufferNV( video_capture_slot, stream, frame_region, offset ); + funcs->ext.p_glBindVideoCaptureStreamBufferNV( video_capture_slot, stream, frame_region, offset ); } static void WINAPI wine_glBindVideoCaptureStreamTextureNV( GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLenum target, GLuint texture ) { - void (*func_glBindVideoCaptureStreamTextureNV)( GLuint, GLuint, GLenum, GLenum, GLuint ) = extension_funcs[EXT_glBindVideoCaptureStreamTextureNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", video_capture_slot, stream, frame_region, target, texture ); - func_glBindVideoCaptureStreamTextureNV( video_capture_slot, stream, frame_region, target, texture ); + funcs->ext.p_glBindVideoCaptureStreamTextureNV( video_capture_slot, stream, frame_region, target, texture ); } static void WINAPI wine_glBinormal3bEXT( GLbyte bx, GLbyte by, GLbyte bz ) { - void (*func_glBinormal3bEXT)( GLbyte, GLbyte, GLbyte ) = extension_funcs[EXT_glBinormal3bEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", bx, by, bz ); - func_glBinormal3bEXT( bx, by, bz ); + funcs->ext.p_glBinormal3bEXT( bx, by, bz ); } static void WINAPI wine_glBinormal3bvEXT( GLbyte* v ) { - void (*func_glBinormal3bvEXT)( GLbyte* ) = extension_funcs[EXT_glBinormal3bvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glBinormal3bvEXT( v ); + funcs->ext.p_glBinormal3bvEXT( v ); } static void WINAPI wine_glBinormal3dEXT( GLdouble bx, GLdouble by, GLdouble bz ) { - void (*func_glBinormal3dEXT)( GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glBinormal3dEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f)\n", bx, by, bz ); - func_glBinormal3dEXT( bx, by, bz ); + funcs->ext.p_glBinormal3dEXT( bx, by, bz ); } static void WINAPI wine_glBinormal3dvEXT( GLdouble* v ) { - void (*func_glBinormal3dvEXT)( GLdouble* ) = extension_funcs[EXT_glBinormal3dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glBinormal3dvEXT( v ); + funcs->ext.p_glBinormal3dvEXT( v ); } static void WINAPI wine_glBinormal3fEXT( GLfloat bx, GLfloat by, GLfloat bz ) { - void (*func_glBinormal3fEXT)( GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glBinormal3fEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f)\n", bx, by, bz ); - func_glBinormal3fEXT( bx, by, bz ); + funcs->ext.p_glBinormal3fEXT( bx, by, bz ); } static void WINAPI wine_glBinormal3fvEXT( GLfloat* v ) { - void (*func_glBinormal3fvEXT)( GLfloat* ) = extension_funcs[EXT_glBinormal3fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glBinormal3fvEXT( v ); + funcs->ext.p_glBinormal3fvEXT( v ); } static void WINAPI wine_glBinormal3iEXT( GLint bx, GLint by, GLint bz ) { - void (*func_glBinormal3iEXT)( GLint, GLint, GLint ) = extension_funcs[EXT_glBinormal3iEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", bx, by, bz ); - func_glBinormal3iEXT( bx, by, bz ); + funcs->ext.p_glBinormal3iEXT( bx, by, bz ); } static void WINAPI wine_glBinormal3ivEXT( GLint* v ) { - void (*func_glBinormal3ivEXT)( GLint* ) = extension_funcs[EXT_glBinormal3ivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glBinormal3ivEXT( v ); + funcs->ext.p_glBinormal3ivEXT( v ); } static void WINAPI wine_glBinormal3sEXT( GLshort bx, GLshort by, GLshort bz ) { - void (*func_glBinormal3sEXT)( GLshort, GLshort, GLshort ) = extension_funcs[EXT_glBinormal3sEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", bx, by, bz ); - func_glBinormal3sEXT( bx, by, bz ); + funcs->ext.p_glBinormal3sEXT( bx, by, bz ); } static void WINAPI wine_glBinormal3svEXT( GLshort* v ) { - void (*func_glBinormal3svEXT)( GLshort* ) = extension_funcs[EXT_glBinormal3svEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glBinormal3svEXT( v ); + funcs->ext.p_glBinormal3svEXT( v ); } static void WINAPI wine_glBinormalPointerEXT( GLenum type, GLsizei stride, GLvoid* pointer ) { - void (*func_glBinormalPointerEXT)( GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glBinormalPointerEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", type, stride, pointer ); - func_glBinormalPointerEXT( type, stride, pointer ); + funcs->ext.p_glBinormalPointerEXT( type, stride, pointer ); } static void WINAPI wine_glBlendColor( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) { - void (*func_glBlendColor)( GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glBlendColor]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f, %f)\n", red, green, blue, alpha ); - func_glBlendColor( red, green, blue, alpha ); + funcs->ext.p_glBlendColor( red, green, blue, alpha ); } static void WINAPI wine_glBlendColorEXT( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) { - void (*func_glBlendColorEXT)( GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glBlendColorEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f, %f)\n", red, green, blue, alpha ); - func_glBlendColorEXT( red, green, blue, alpha ); + funcs->ext.p_glBlendColorEXT( red, green, blue, alpha ); } static void WINAPI wine_glBlendEquation( GLenum mode ) { - void (*func_glBlendEquation)( GLenum ) = extension_funcs[EXT_glBlendEquation]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", mode ); - func_glBlendEquation( mode ); + funcs->ext.p_glBlendEquation( mode ); } static void WINAPI wine_glBlendEquationEXT( GLenum mode ) { - void (*func_glBlendEquationEXT)( GLenum ) = extension_funcs[EXT_glBlendEquationEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", mode ); - func_glBlendEquationEXT( mode ); + funcs->ext.p_glBlendEquationEXT( mode ); } static void WINAPI wine_glBlendEquationIndexedAMD( GLuint buf, GLenum mode ) { - void (*func_glBlendEquationIndexedAMD)( GLuint, GLenum ) = extension_funcs[EXT_glBlendEquationIndexedAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", buf, mode ); - func_glBlendEquationIndexedAMD( buf, mode ); + funcs->ext.p_glBlendEquationIndexedAMD( buf, mode ); } static void WINAPI wine_glBlendEquationSeparate( GLenum modeRGB, GLenum modeAlpha ) { - void (*func_glBlendEquationSeparate)( GLenum, GLenum ) = extension_funcs[EXT_glBlendEquationSeparate]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", modeRGB, modeAlpha ); - func_glBlendEquationSeparate( modeRGB, modeAlpha ); + funcs->ext.p_glBlendEquationSeparate( modeRGB, modeAlpha ); } static void WINAPI wine_glBlendEquationSeparateEXT( GLenum modeRGB, GLenum modeAlpha ) { - void (*func_glBlendEquationSeparateEXT)( GLenum, GLenum ) = extension_funcs[EXT_glBlendEquationSeparateEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", modeRGB, modeAlpha ); - func_glBlendEquationSeparateEXT( modeRGB, modeAlpha ); + funcs->ext.p_glBlendEquationSeparateEXT( modeRGB, modeAlpha ); } static void WINAPI wine_glBlendEquationSeparateIndexedAMD( GLuint buf, GLenum modeRGB, GLenum modeAlpha ) { - void (*func_glBlendEquationSeparateIndexedAMD)( GLuint, GLenum, GLenum ) = extension_funcs[EXT_glBlendEquationSeparateIndexedAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", buf, modeRGB, modeAlpha ); - func_glBlendEquationSeparateIndexedAMD( buf, modeRGB, modeAlpha ); + funcs->ext.p_glBlendEquationSeparateIndexedAMD( buf, modeRGB, modeAlpha ); } static void WINAPI wine_glBlendEquationSeparatei( GLuint buf, GLenum modeRGB, GLenum modeAlpha ) { - void (*func_glBlendEquationSeparatei)( GLuint, GLenum, GLenum ) = extension_funcs[EXT_glBlendEquationSeparatei]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", buf, modeRGB, modeAlpha ); - func_glBlendEquationSeparatei( buf, modeRGB, modeAlpha ); + funcs->ext.p_glBlendEquationSeparatei( buf, modeRGB, modeAlpha ); } static void WINAPI wine_glBlendEquationSeparateiARB( GLuint buf, GLenum modeRGB, GLenum modeAlpha ) { - void (*func_glBlendEquationSeparateiARB)( GLuint, GLenum, GLenum ) = extension_funcs[EXT_glBlendEquationSeparateiARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", buf, modeRGB, modeAlpha ); - func_glBlendEquationSeparateiARB( buf, modeRGB, modeAlpha ); + funcs->ext.p_glBlendEquationSeparateiARB( buf, modeRGB, modeAlpha ); } static void WINAPI wine_glBlendEquationi( GLuint buf, GLenum mode ) { - void (*func_glBlendEquationi)( GLuint, GLenum ) = extension_funcs[EXT_glBlendEquationi]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", buf, mode ); - func_glBlendEquationi( buf, mode ); + funcs->ext.p_glBlendEquationi( buf, mode ); } static void WINAPI wine_glBlendEquationiARB( GLuint buf, GLenum mode ) { - void (*func_glBlendEquationiARB)( GLuint, GLenum ) = extension_funcs[EXT_glBlendEquationiARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", buf, mode ); - func_glBlendEquationiARB( buf, mode ); + funcs->ext.p_glBlendEquationiARB( buf, mode ); } static void WINAPI wine_glBlendFuncIndexedAMD( GLuint buf, GLenum src, GLenum dst ) { - void (*func_glBlendFuncIndexedAMD)( GLuint, GLenum, GLenum ) = extension_funcs[EXT_glBlendFuncIndexedAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", buf, src, dst ); - func_glBlendFuncIndexedAMD( buf, src, dst ); + funcs->ext.p_glBlendFuncIndexedAMD( buf, src, dst ); } static void WINAPI wine_glBlendFuncSeparate( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha ) { - void (*func_glBlendFuncSeparate)( GLenum, GLenum, GLenum, GLenum ) = extension_funcs[EXT_glBlendFuncSeparate]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha ); - func_glBlendFuncSeparate( sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha ); + funcs->ext.p_glBlendFuncSeparate( sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha ); } static void WINAPI wine_glBlendFuncSeparateEXT( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha ) { - void (*func_glBlendFuncSeparateEXT)( GLenum, GLenum, GLenum, GLenum ) = extension_funcs[EXT_glBlendFuncSeparateEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha ); - func_glBlendFuncSeparateEXT( sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha ); + funcs->ext.p_glBlendFuncSeparateEXT( sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha ); } static void WINAPI wine_glBlendFuncSeparateINGR( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha ) { - void (*func_glBlendFuncSeparateINGR)( GLenum, GLenum, GLenum, GLenum ) = extension_funcs[EXT_glBlendFuncSeparateINGR]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha ); - func_glBlendFuncSeparateINGR( sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha ); + funcs->ext.p_glBlendFuncSeparateINGR( sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha ); } static void WINAPI wine_glBlendFuncSeparateIndexedAMD( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) { - void (*func_glBlendFuncSeparateIndexedAMD)( GLuint, GLenum, GLenum, GLenum, GLenum ) = extension_funcs[EXT_glBlendFuncSeparateIndexedAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", buf, srcRGB, dstRGB, srcAlpha, dstAlpha ); - func_glBlendFuncSeparateIndexedAMD( buf, srcRGB, dstRGB, srcAlpha, dstAlpha ); + funcs->ext.p_glBlendFuncSeparateIndexedAMD( buf, srcRGB, dstRGB, srcAlpha, dstAlpha ); } static void WINAPI wine_glBlendFuncSeparatei( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) { - void (*func_glBlendFuncSeparatei)( GLuint, GLenum, GLenum, GLenum, GLenum ) = extension_funcs[EXT_glBlendFuncSeparatei]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", buf, srcRGB, dstRGB, srcAlpha, dstAlpha ); - func_glBlendFuncSeparatei( buf, srcRGB, dstRGB, srcAlpha, dstAlpha ); + funcs->ext.p_glBlendFuncSeparatei( buf, srcRGB, dstRGB, srcAlpha, dstAlpha ); } static void WINAPI wine_glBlendFuncSeparateiARB( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) { - void (*func_glBlendFuncSeparateiARB)( GLuint, GLenum, GLenum, GLenum, GLenum ) = extension_funcs[EXT_glBlendFuncSeparateiARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", buf, srcRGB, dstRGB, srcAlpha, dstAlpha ); - func_glBlendFuncSeparateiARB( buf, srcRGB, dstRGB, srcAlpha, dstAlpha ); + funcs->ext.p_glBlendFuncSeparateiARB( buf, srcRGB, dstRGB, srcAlpha, dstAlpha ); } static void WINAPI wine_glBlendFunci( GLuint buf, GLenum src, GLenum dst ) { - void (*func_glBlendFunci)( GLuint, GLenum, GLenum ) = extension_funcs[EXT_glBlendFunci]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", buf, src, dst ); - func_glBlendFunci( buf, src, dst ); + funcs->ext.p_glBlendFunci( buf, src, dst ); } static void WINAPI wine_glBlendFunciARB( GLuint buf, GLenum src, GLenum dst ) { - void (*func_glBlendFunciARB)( GLuint, GLenum, GLenum ) = extension_funcs[EXT_glBlendFunciARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", buf, src, dst ); - func_glBlendFunciARB( buf, src, dst ); + funcs->ext.p_glBlendFunciARB( buf, src, dst ); } static void WINAPI wine_glBlitFramebuffer( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter ) { - void (*func_glBlitFramebuffer)( GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum ) = extension_funcs[EXT_glBlitFramebuffer]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter ); - func_glBlitFramebuffer( srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter ); + funcs->ext.p_glBlitFramebuffer( srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter ); } static void WINAPI wine_glBlitFramebufferEXT( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter ) { - void (*func_glBlitFramebufferEXT)( GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum ) = extension_funcs[EXT_glBlitFramebufferEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter ); - func_glBlitFramebufferEXT( srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter ); + funcs->ext.p_glBlitFramebufferEXT( srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter ); } static void WINAPI wine_glBufferAddressRangeNV( GLenum pname, GLuint index, UINT64 address, INT_PTR length ) { - void (*func_glBufferAddressRangeNV)( GLenum, GLuint, UINT64, INT_PTR ) = extension_funcs[EXT_glBufferAddressRangeNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %s, %ld)\n", pname, index, wine_dbgstr_longlong(address), length ); - func_glBufferAddressRangeNV( pname, index, address, length ); + funcs->ext.p_glBufferAddressRangeNV( pname, index, address, length ); } static void WINAPI wine_glBufferData( GLenum target, INT_PTR size, GLvoid* data, GLenum usage ) { - void (*func_glBufferData)( GLenum, INT_PTR, GLvoid*, GLenum ) = extension_funcs[EXT_glBufferData]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %ld, %p, %d)\n", target, size, data, usage ); - func_glBufferData( target, size, data, usage ); + funcs->ext.p_glBufferData( target, size, data, usage ); } static void WINAPI wine_glBufferDataARB( GLenum target, INT_PTR size, GLvoid* data, GLenum usage ) { - void (*func_glBufferDataARB)( GLenum, INT_PTR, GLvoid*, GLenum ) = extension_funcs[EXT_glBufferDataARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %ld, %p, %d)\n", target, size, data, usage ); - func_glBufferDataARB( target, size, data, usage ); + funcs->ext.p_glBufferDataARB( target, size, data, usage ); } static void WINAPI wine_glBufferParameteriAPPLE( GLenum target, GLenum pname, GLint param ) { - void (*func_glBufferParameteriAPPLE)( GLenum, GLenum, GLint ) = extension_funcs[EXT_glBufferParameteriAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, pname, param ); - func_glBufferParameteriAPPLE( target, pname, param ); + funcs->ext.p_glBufferParameteriAPPLE( target, pname, param ); } static GLuint WINAPI wine_glBufferRegionEnabled( void ) { - GLuint (*func_glBufferRegionEnabled)( void ) = extension_funcs[EXT_glBufferRegionEnabled]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - return func_glBufferRegionEnabled( ); + return funcs->ext.p_glBufferRegionEnabled( ); } static void WINAPI wine_glBufferSubData( GLenum target, INT_PTR offset, INT_PTR size, GLvoid* data ) { - void (*func_glBufferSubData)( GLenum, INT_PTR, INT_PTR, GLvoid* ) = extension_funcs[EXT_glBufferSubData]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %ld, %ld, %p)\n", target, offset, size, data ); - func_glBufferSubData( target, offset, size, data ); + funcs->ext.p_glBufferSubData( target, offset, size, data ); } static void WINAPI wine_glBufferSubDataARB( GLenum target, INT_PTR offset, INT_PTR size, GLvoid* data ) { - void (*func_glBufferSubDataARB)( GLenum, INT_PTR, INT_PTR, GLvoid* ) = extension_funcs[EXT_glBufferSubDataARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %ld, %ld, %p)\n", target, offset, size, data ); - func_glBufferSubDataARB( target, offset, size, data ); + funcs->ext.p_glBufferSubDataARB( target, offset, size, data ); } static GLenum WINAPI wine_glCheckFramebufferStatus( GLenum target ) { - GLenum (*func_glCheckFramebufferStatus)( GLenum ) = extension_funcs[EXT_glCheckFramebufferStatus]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", target ); - return func_glCheckFramebufferStatus( target ); + return funcs->ext.p_glCheckFramebufferStatus( target ); } static GLenum WINAPI wine_glCheckFramebufferStatusEXT( GLenum target ) { - GLenum (*func_glCheckFramebufferStatusEXT)( GLenum ) = extension_funcs[EXT_glCheckFramebufferStatusEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", target ); - return func_glCheckFramebufferStatusEXT( target ); + return funcs->ext.p_glCheckFramebufferStatusEXT( target ); } static GLenum WINAPI wine_glCheckNamedFramebufferStatusEXT( GLuint framebuffer, GLenum target ) { - GLenum (*func_glCheckNamedFramebufferStatusEXT)( GLuint, GLenum ) = extension_funcs[EXT_glCheckNamedFramebufferStatusEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", framebuffer, target ); - return func_glCheckNamedFramebufferStatusEXT( framebuffer, target ); + return funcs->ext.p_glCheckNamedFramebufferStatusEXT( framebuffer, target ); } static void WINAPI wine_glClampColor( GLenum target, GLenum clamp ) { - void (*func_glClampColor)( GLenum, GLenum ) = extension_funcs[EXT_glClampColor]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, clamp ); - func_glClampColor( target, clamp ); + funcs->ext.p_glClampColor( target, clamp ); } static void WINAPI wine_glClampColorARB( GLenum target, GLenum clamp ) { - void (*func_glClampColorARB)( GLenum, GLenum ) = extension_funcs[EXT_glClampColorARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, clamp ); - func_glClampColorARB( target, clamp ); + funcs->ext.p_glClampColorARB( target, clamp ); } static void WINAPI wine_glClearBufferfi( GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil ) { - void (*func_glClearBufferfi)( GLenum, GLint, GLfloat, GLint ) = extension_funcs[EXT_glClearBufferfi]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %d)\n", buffer, drawbuffer, depth, stencil ); - func_glClearBufferfi( buffer, drawbuffer, depth, stencil ); + funcs->ext.p_glClearBufferfi( buffer, drawbuffer, depth, stencil ); } static void WINAPI wine_glClearBufferfv( GLenum buffer, GLint drawbuffer, GLfloat* value ) { - void (*func_glClearBufferfv)( GLenum, GLint, GLfloat* ) = extension_funcs[EXT_glClearBufferfv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", buffer, drawbuffer, value ); - func_glClearBufferfv( buffer, drawbuffer, value ); + funcs->ext.p_glClearBufferfv( buffer, drawbuffer, value ); } static void WINAPI wine_glClearBufferiv( GLenum buffer, GLint drawbuffer, GLint* value ) { - void (*func_glClearBufferiv)( GLenum, GLint, GLint* ) = extension_funcs[EXT_glClearBufferiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", buffer, drawbuffer, value ); - func_glClearBufferiv( buffer, drawbuffer, value ); + funcs->ext.p_glClearBufferiv( buffer, drawbuffer, value ); } static void WINAPI wine_glClearBufferuiv( GLenum buffer, GLint drawbuffer, GLuint* value ) { - void (*func_glClearBufferuiv)( GLenum, GLint, GLuint* ) = extension_funcs[EXT_glClearBufferuiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", buffer, drawbuffer, value ); - func_glClearBufferuiv( buffer, drawbuffer, value ); + funcs->ext.p_glClearBufferuiv( buffer, drawbuffer, value ); } static void WINAPI wine_glClearColorIiEXT( GLint red, GLint green, GLint blue, GLint alpha ) { - void (*func_glClearColorIiEXT)( GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glClearColorIiEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha ); - func_glClearColorIiEXT( red, green, blue, alpha ); + funcs->ext.p_glClearColorIiEXT( red, green, blue, alpha ); } static void WINAPI wine_glClearColorIuiEXT( GLuint red, GLuint green, GLuint blue, GLuint alpha ) { - void (*func_glClearColorIuiEXT)( GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glClearColorIuiEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha ); - func_glClearColorIuiEXT( red, green, blue, alpha ); + funcs->ext.p_glClearColorIuiEXT( red, green, blue, alpha ); } static void WINAPI wine_glClearDepthdNV( GLdouble depth ) { - void (*func_glClearDepthdNV)( GLdouble ) = extension_funcs[EXT_glClearDepthdNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f)\n", depth ); - func_glClearDepthdNV( depth ); + funcs->ext.p_glClearDepthdNV( depth ); } static void WINAPI wine_glClearDepthf( GLfloat d ) { - void (*func_glClearDepthf)( GLfloat ) = extension_funcs[EXT_glClearDepthf]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f)\n", d ); - func_glClearDepthf( d ); + funcs->ext.p_glClearDepthf( d ); } static void WINAPI wine_glClientActiveTexture( GLenum texture ) { - void (*func_glClientActiveTexture)( GLenum ) = extension_funcs[EXT_glClientActiveTexture]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", texture ); - func_glClientActiveTexture( texture ); + funcs->ext.p_glClientActiveTexture( texture ); } static void WINAPI wine_glClientActiveTextureARB( GLenum texture ) { - void (*func_glClientActiveTextureARB)( GLenum ) = extension_funcs[EXT_glClientActiveTextureARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", texture ); - func_glClientActiveTextureARB( texture ); + funcs->ext.p_glClientActiveTextureARB( texture ); } static void WINAPI wine_glClientActiveVertexStreamATI( GLenum stream ) { - void (*func_glClientActiveVertexStreamATI)( GLenum ) = extension_funcs[EXT_glClientActiveVertexStreamATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", stream ); - func_glClientActiveVertexStreamATI( stream ); + funcs->ext.p_glClientActiveVertexStreamATI( stream ); } static void WINAPI wine_glClientAttribDefaultEXT( GLbitfield mask ) { - void (*func_glClientAttribDefaultEXT)( GLbitfield ) = extension_funcs[EXT_glClientAttribDefaultEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", mask ); - func_glClientAttribDefaultEXT( mask ); + funcs->ext.p_glClientAttribDefaultEXT( mask ); } static GLenum WINAPI wine_glClientWaitSync( GLvoid* sync, GLbitfield flags, UINT64 timeout ) { - GLenum (*func_glClientWaitSync)( GLvoid*, GLbitfield, UINT64 ) = extension_funcs[EXT_glClientWaitSync]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %d, %s)\n", sync, flags, wine_dbgstr_longlong(timeout) ); - return func_glClientWaitSync( sync, flags, timeout ); + return funcs->ext.p_glClientWaitSync( sync, flags, timeout ); } static void WINAPI wine_glColor3fVertex3fSUN( GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glColor3fVertex3fSUN)( GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glColor3fVertex3fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f, %f, %f, %f)\n", r, g, b, x, y, z ); - func_glColor3fVertex3fSUN( r, g, b, x, y, z ); + funcs->ext.p_glColor3fVertex3fSUN( r, g, b, x, y, z ); } static void WINAPI wine_glColor3fVertex3fvSUN( GLfloat* c, GLfloat* v ) { - void (*func_glColor3fVertex3fvSUN)( GLfloat*, GLfloat* ) = extension_funcs[EXT_glColor3fVertex3fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p)\n", c, v ); - func_glColor3fVertex3fvSUN( c, v ); + funcs->ext.p_glColor3fVertex3fvSUN( c, v ); } static void WINAPI wine_glColor3hNV( unsigned short red, unsigned short green, unsigned short blue ) { - void (*func_glColor3hNV)( unsigned short, unsigned short, unsigned short ) = extension_funcs[EXT_glColor3hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", red, green, blue ); - func_glColor3hNV( red, green, blue ); + funcs->ext.p_glColor3hNV( red, green, blue ); } static void WINAPI wine_glColor3hvNV( unsigned short* v ) { - void (*func_glColor3hvNV)( unsigned short* ) = extension_funcs[EXT_glColor3hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glColor3hvNV( v ); + funcs->ext.p_glColor3hvNV( v ); } static void WINAPI wine_glColor4fNormal3fVertex3fSUN( GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glColor4fNormal3fVertex3fSUN)( GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glColor4fNormal3fVertex3fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", r, g, b, a, nx, ny, nz, x, y, z ); - func_glColor4fNormal3fVertex3fSUN( r, g, b, a, nx, ny, nz, x, y, z ); + funcs->ext.p_glColor4fNormal3fVertex3fSUN( r, g, b, a, nx, ny, nz, x, y, z ); } static void WINAPI wine_glColor4fNormal3fVertex3fvSUN( GLfloat* c, GLfloat* n, GLfloat* v ) { - void (*func_glColor4fNormal3fVertex3fvSUN)( GLfloat*, GLfloat*, GLfloat* ) = extension_funcs[EXT_glColor4fNormal3fVertex3fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p, %p)\n", c, n, v ); - func_glColor4fNormal3fVertex3fvSUN( c, n, v ); + funcs->ext.p_glColor4fNormal3fVertex3fvSUN( c, n, v ); } static void WINAPI wine_glColor4hNV( unsigned short red, unsigned short green, unsigned short blue, unsigned short alpha ) { - void (*func_glColor4hNV)( unsigned short, unsigned short, unsigned short, unsigned short ) = extension_funcs[EXT_glColor4hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha ); - func_glColor4hNV( red, green, blue, alpha ); + funcs->ext.p_glColor4hNV( red, green, blue, alpha ); } static void WINAPI wine_glColor4hvNV( unsigned short* v ) { - void (*func_glColor4hvNV)( unsigned short* ) = extension_funcs[EXT_glColor4hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glColor4hvNV( v ); + funcs->ext.p_glColor4hvNV( v ); } static void WINAPI wine_glColor4ubVertex2fSUN( GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y ) { - void (*func_glColor4ubVertex2fSUN)( GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat ) = extension_funcs[EXT_glColor4ubVertex2fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %f, %f)\n", r, g, b, a, x, y ); - func_glColor4ubVertex2fSUN( r, g, b, a, x, y ); + funcs->ext.p_glColor4ubVertex2fSUN( r, g, b, a, x, y ); } static void WINAPI wine_glColor4ubVertex2fvSUN( GLubyte* c, GLfloat* v ) { - void (*func_glColor4ubVertex2fvSUN)( GLubyte*, GLfloat* ) = extension_funcs[EXT_glColor4ubVertex2fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p)\n", c, v ); - func_glColor4ubVertex2fvSUN( c, v ); + funcs->ext.p_glColor4ubVertex2fvSUN( c, v ); } static void WINAPI wine_glColor4ubVertex3fSUN( GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glColor4ubVertex3fSUN)( GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glColor4ubVertex3fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %f, %f, %f)\n", r, g, b, a, x, y, z ); - func_glColor4ubVertex3fSUN( r, g, b, a, x, y, z ); + funcs->ext.p_glColor4ubVertex3fSUN( r, g, b, a, x, y, z ); } static void WINAPI wine_glColor4ubVertex3fvSUN( GLubyte* c, GLfloat* v ) { - void (*func_glColor4ubVertex3fvSUN)( GLubyte*, GLfloat* ) = extension_funcs[EXT_glColor4ubVertex3fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p)\n", c, v ); - func_glColor4ubVertex3fvSUN( c, v ); + funcs->ext.p_glColor4ubVertex3fvSUN( c, v ); } static void WINAPI wine_glColorFormatNV( GLint size, GLenum type, GLsizei stride ) { - void (*func_glColorFormatNV)( GLint, GLenum, GLsizei ) = extension_funcs[EXT_glColorFormatNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", size, type, stride ); - func_glColorFormatNV( size, type, stride ); + funcs->ext.p_glColorFormatNV( size, type, stride ); } static void WINAPI wine_glColorFragmentOp1ATI( GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod ) { - void (*func_glColorFragmentOp1ATI)( GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glColorFragmentOp1ATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod ); - func_glColorFragmentOp1ATI( op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod ); + funcs->ext.p_glColorFragmentOp1ATI( op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod ); } static void WINAPI wine_glColorFragmentOp2ATI( GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod ) { - void (*func_glColorFragmentOp2ATI)( GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glColorFragmentOp2ATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod ); - func_glColorFragmentOp2ATI( op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod ); + funcs->ext.p_glColorFragmentOp2ATI( op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod ); } static void WINAPI wine_glColorFragmentOp3ATI( GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod ) { - void (*func_glColorFragmentOp3ATI)( GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glColorFragmentOp3ATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod ); - func_glColorFragmentOp3ATI( op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod ); + funcs->ext.p_glColorFragmentOp3ATI( op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod ); } static void WINAPI wine_glColorMaskIndexedEXT( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a ) { - void (*func_glColorMaskIndexedEXT)( GLuint, GLboolean, GLboolean, GLboolean, GLboolean ) = extension_funcs[EXT_glColorMaskIndexedEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", index, r, g, b, a ); - func_glColorMaskIndexedEXT( index, r, g, b, a ); + funcs->ext.p_glColorMaskIndexedEXT( index, r, g, b, a ); } static void WINAPI wine_glColorMaski( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a ) { - void (*func_glColorMaski)( GLuint, GLboolean, GLboolean, GLboolean, GLboolean ) = extension_funcs[EXT_glColorMaski]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", index, r, g, b, a ); - func_glColorMaski( index, r, g, b, a ); + funcs->ext.p_glColorMaski( index, r, g, b, a ); } static void WINAPI wine_glColorP3ui( GLenum type, GLuint color ) { - void (*func_glColorP3ui)( GLenum, GLuint ) = extension_funcs[EXT_glColorP3ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", type, color ); - func_glColorP3ui( type, color ); + funcs->ext.p_glColorP3ui( type, color ); } static void WINAPI wine_glColorP3uiv( GLenum type, GLuint* color ) { - void (*func_glColorP3uiv)( GLenum, GLuint* ) = extension_funcs[EXT_glColorP3uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", type, color ); - func_glColorP3uiv( type, color ); + funcs->ext.p_glColorP3uiv( type, color ); } static void WINAPI wine_glColorP4ui( GLenum type, GLuint color ) { - void (*func_glColorP4ui)( GLenum, GLuint ) = extension_funcs[EXT_glColorP4ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", type, color ); - func_glColorP4ui( type, color ); + funcs->ext.p_glColorP4ui( type, color ); } static void WINAPI wine_glColorP4uiv( GLenum type, GLuint* color ) { - void (*func_glColorP4uiv)( GLenum, GLuint* ) = extension_funcs[EXT_glColorP4uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", type, color ); - func_glColorP4uiv( type, color ); + funcs->ext.p_glColorP4uiv( type, color ); } static void WINAPI wine_glColorPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, GLvoid* pointer ) { - void (*func_glColorPointerEXT)( GLint, GLenum, GLsizei, GLsizei, GLvoid* ) = extension_funcs[EXT_glColorPointerEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", size, type, stride, count, pointer ); - func_glColorPointerEXT( size, type, stride, count, pointer ); + funcs->ext.p_glColorPointerEXT( size, type, stride, count, pointer ); } static void WINAPI wine_glColorPointerListIBM( GLint size, GLenum type, GLint stride, GLvoid** pointer, GLint ptrstride ) { - void (*func_glColorPointerListIBM)( GLint, GLenum, GLint, GLvoid**, GLint ) = extension_funcs[EXT_glColorPointerListIBM]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %d)\n", size, type, stride, pointer, ptrstride ); - func_glColorPointerListIBM( size, type, stride, pointer, ptrstride ); + funcs->ext.p_glColorPointerListIBM( size, type, stride, pointer, ptrstride ); } static void WINAPI wine_glColorPointervINTEL( GLint size, GLenum type, GLvoid** pointer ) { - void (*func_glColorPointervINTEL)( GLint, GLenum, GLvoid** ) = extension_funcs[EXT_glColorPointervINTEL]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", size, type, pointer ); - func_glColorPointervINTEL( size, type, pointer ); + funcs->ext.p_glColorPointervINTEL( size, type, pointer ); } static void WINAPI wine_glColorSubTable( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, GLvoid* data ) { - void (*func_glColorSubTable)( GLenum, GLsizei, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glColorSubTable]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %p)\n", target, start, count, format, type, data ); - func_glColorSubTable( target, start, count, format, type, data ); + funcs->ext.p_glColorSubTable( target, start, count, format, type, data ); } static void WINAPI wine_glColorSubTableEXT( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, GLvoid* data ) { - void (*func_glColorSubTableEXT)( GLenum, GLsizei, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glColorSubTableEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %p)\n", target, start, count, format, type, data ); - func_glColorSubTableEXT( target, start, count, format, type, data ); + funcs->ext.p_glColorSubTableEXT( target, start, count, format, type, data ); } static void WINAPI wine_glColorTable( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, GLvoid* table ) { - void (*func_glColorTable)( GLenum, GLenum, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glColorTable]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %p)\n", target, internalformat, width, format, type, table ); - func_glColorTable( target, internalformat, width, format, type, table ); + funcs->ext.p_glColorTable( target, internalformat, width, format, type, table ); } static void WINAPI wine_glColorTableEXT( GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, GLvoid* table ) { - void (*func_glColorTableEXT)( GLenum, GLenum, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glColorTableEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %p)\n", target, internalFormat, width, format, type, table ); - func_glColorTableEXT( target, internalFormat, width, format, type, table ); + funcs->ext.p_glColorTableEXT( target, internalFormat, width, format, type, table ); } static void WINAPI wine_glColorTableParameterfv( GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glColorTableParameterfv)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glColorTableParameterfv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glColorTableParameterfv( target, pname, params ); + funcs->ext.p_glColorTableParameterfv( target, pname, params ); } static void WINAPI wine_glColorTableParameterfvSGI( GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glColorTableParameterfvSGI)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glColorTableParameterfvSGI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glColorTableParameterfvSGI( target, pname, params ); + funcs->ext.p_glColorTableParameterfvSGI( target, pname, params ); } static void WINAPI wine_glColorTableParameteriv( GLenum target, GLenum pname, GLint* params ) { - void (*func_glColorTableParameteriv)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glColorTableParameteriv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glColorTableParameteriv( target, pname, params ); + funcs->ext.p_glColorTableParameteriv( target, pname, params ); } static void WINAPI wine_glColorTableParameterivSGI( GLenum target, GLenum pname, GLint* params ) { - void (*func_glColorTableParameterivSGI)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glColorTableParameterivSGI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glColorTableParameterivSGI( target, pname, params ); + funcs->ext.p_glColorTableParameterivSGI( target, pname, params ); } static void WINAPI wine_glColorTableSGI( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, GLvoid* table ) { - void (*func_glColorTableSGI)( GLenum, GLenum, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glColorTableSGI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %p)\n", target, internalformat, width, format, type, table ); - func_glColorTableSGI( target, internalformat, width, format, type, table ); + funcs->ext.p_glColorTableSGI( target, internalformat, width, format, type, table ); } static void WINAPI wine_glCombinerInputNV( GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage ) { - void (*func_glCombinerInputNV)( GLenum, GLenum, GLenum, GLenum, GLenum, GLenum ) = extension_funcs[EXT_glCombinerInputNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", stage, portion, variable, input, mapping, componentUsage ); - func_glCombinerInputNV( stage, portion, variable, input, mapping, componentUsage ); + funcs->ext.p_glCombinerInputNV( stage, portion, variable, input, mapping, componentUsage ); } static void WINAPI wine_glCombinerOutputNV( GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum ) { - void (*func_glCombinerOutputNV)( GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean ) = extension_funcs[EXT_glCombinerOutputNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum ); - func_glCombinerOutputNV( stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum ); + funcs->ext.p_glCombinerOutputNV( stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum ); } static void WINAPI wine_glCombinerParameterfNV( GLenum pname, GLfloat param ) { - void (*func_glCombinerParameterfNV)( GLenum, GLfloat ) = extension_funcs[EXT_glCombinerParameterfNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", pname, param ); - func_glCombinerParameterfNV( pname, param ); + funcs->ext.p_glCombinerParameterfNV( pname, param ); } static void WINAPI wine_glCombinerParameterfvNV( GLenum pname, GLfloat* params ) { - void (*func_glCombinerParameterfvNV)( GLenum, GLfloat* ) = extension_funcs[EXT_glCombinerParameterfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glCombinerParameterfvNV( pname, params ); + funcs->ext.p_glCombinerParameterfvNV( pname, params ); } static void WINAPI wine_glCombinerParameteriNV( GLenum pname, GLint param ) { - void (*func_glCombinerParameteriNV)( GLenum, GLint ) = extension_funcs[EXT_glCombinerParameteriNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", pname, param ); - func_glCombinerParameteriNV( pname, param ); + funcs->ext.p_glCombinerParameteriNV( pname, param ); } static void WINAPI wine_glCombinerParameterivNV( GLenum pname, GLint* params ) { - void (*func_glCombinerParameterivNV)( GLenum, GLint* ) = extension_funcs[EXT_glCombinerParameterivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glCombinerParameterivNV( pname, params ); + funcs->ext.p_glCombinerParameterivNV( pname, params ); } static void WINAPI wine_glCombinerStageParameterfvNV( GLenum stage, GLenum pname, GLfloat* params ) { - void (*func_glCombinerStageParameterfvNV)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glCombinerStageParameterfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", stage, pname, params ); - func_glCombinerStageParameterfvNV( stage, pname, params ); + funcs->ext.p_glCombinerStageParameterfvNV( stage, pname, params ); } static void WINAPI wine_glCompileShader( GLuint shader ) { - void (*func_glCompileShader)( GLuint ) = extension_funcs[EXT_glCompileShader]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", shader ); - func_glCompileShader( shader ); + funcs->ext.p_glCompileShader( shader ); } static void WINAPI wine_glCompileShaderARB( unsigned int shaderObj ) { - void (*func_glCompileShaderARB)( unsigned int ) = extension_funcs[EXT_glCompileShaderARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", shaderObj ); - func_glCompileShaderARB( shaderObj ); + funcs->ext.p_glCompileShaderARB( shaderObj ); } static void WINAPI wine_glCompileShaderIncludeARB( GLuint shader, GLsizei count, char** path, GLint* length ) { - void (*func_glCompileShaderIncludeARB)( GLuint, GLsizei, char**, GLint* ) = extension_funcs[EXT_glCompileShaderIncludeARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", shader, count, path, length ); - func_glCompileShaderIncludeARB( shader, count, path, length ); + funcs->ext.p_glCompileShaderIncludeARB( shader, count, path, length ); } static void WINAPI wine_glCompressedMultiTexImage1DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, GLvoid* bits ) { - void (*func_glCompressedMultiTexImage1DEXT)( GLenum, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedMultiTexImage1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, internalformat, width, border, imageSize, bits ); - func_glCompressedMultiTexImage1DEXT( texunit, target, level, internalformat, width, border, imageSize, bits ); + funcs->ext.p_glCompressedMultiTexImage1DEXT( texunit, target, level, internalformat, width, border, imageSize, bits ); } static void WINAPI wine_glCompressedMultiTexImage2DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, GLvoid* bits ) { - void (*func_glCompressedMultiTexImage2DEXT)( GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedMultiTexImage2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, internalformat, width, height, border, imageSize, bits ); - func_glCompressedMultiTexImage2DEXT( texunit, target, level, internalformat, width, height, border, imageSize, bits ); + funcs->ext.p_glCompressedMultiTexImage2DEXT( texunit, target, level, internalformat, width, height, border, imageSize, bits ); } static void WINAPI wine_glCompressedMultiTexImage3DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, GLvoid* bits ) { - void (*func_glCompressedMultiTexImage3DEXT)( GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedMultiTexImage3DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, internalformat, width, height, depth, border, imageSize, bits ); - func_glCompressedMultiTexImage3DEXT( texunit, target, level, internalformat, width, height, depth, border, imageSize, bits ); + funcs->ext.p_glCompressedMultiTexImage3DEXT( texunit, target, level, internalformat, width, height, depth, border, imageSize, bits ); } static void WINAPI wine_glCompressedMultiTexSubImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, GLvoid* bits ) { - void (*func_glCompressedMultiTexSubImage1DEXT)( GLenum, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedMultiTexSubImage1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, xoffset, width, format, imageSize, bits ); - func_glCompressedMultiTexSubImage1DEXT( texunit, target, level, xoffset, width, format, imageSize, bits ); + funcs->ext.p_glCompressedMultiTexSubImage1DEXT( texunit, target, level, xoffset, width, format, imageSize, bits ); } static void WINAPI wine_glCompressedMultiTexSubImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLvoid* bits ) { - void (*func_glCompressedMultiTexSubImage2DEXT)( GLenum, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedMultiTexSubImage2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits ); - func_glCompressedMultiTexSubImage2DEXT( texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits ); + funcs->ext.p_glCompressedMultiTexSubImage2DEXT( texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits ); } static void WINAPI wine_glCompressedMultiTexSubImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, GLvoid* bits ) { - void (*func_glCompressedMultiTexSubImage3DEXT)( GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedMultiTexSubImage3DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits ); - func_glCompressedMultiTexSubImage3DEXT( texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits ); + funcs->ext.p_glCompressedMultiTexSubImage3DEXT( texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits ); } static void WINAPI wine_glCompressedTexImage1D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, GLvoid* data ) { - void (*func_glCompressedTexImage1D)( GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedTexImage1D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, border, imageSize, data ); - func_glCompressedTexImage1D( target, level, internalformat, width, border, imageSize, data ); + funcs->ext.p_glCompressedTexImage1D( target, level, internalformat, width, border, imageSize, data ); } static void WINAPI wine_glCompressedTexImage1DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, GLvoid* data ) { - void (*func_glCompressedTexImage1DARB)( GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedTexImage1DARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, border, imageSize, data ); - func_glCompressedTexImage1DARB( target, level, internalformat, width, border, imageSize, data ); + funcs->ext.p_glCompressedTexImage1DARB( target, level, internalformat, width, border, imageSize, data ); } static void WINAPI wine_glCompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, GLvoid* data ) { - void (*func_glCompressedTexImage2D)( GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedTexImage2D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, border, imageSize, data ); - func_glCompressedTexImage2D( target, level, internalformat, width, height, border, imageSize, data ); + funcs->ext.p_glCompressedTexImage2D( target, level, internalformat, width, height, border, imageSize, data ); } static void WINAPI wine_glCompressedTexImage2DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, GLvoid* data ) { - void (*func_glCompressedTexImage2DARB)( GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedTexImage2DARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, border, imageSize, data ); - func_glCompressedTexImage2DARB( target, level, internalformat, width, height, border, imageSize, data ); + funcs->ext.p_glCompressedTexImage2DARB( target, level, internalformat, width, height, border, imageSize, data ); } static void WINAPI wine_glCompressedTexImage3D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, GLvoid* data ) { - void (*func_glCompressedTexImage3D)( GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedTexImage3D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, border, imageSize, data ); - func_glCompressedTexImage3D( target, level, internalformat, width, height, depth, border, imageSize, data ); + funcs->ext.p_glCompressedTexImage3D( target, level, internalformat, width, height, depth, border, imageSize, data ); } static void WINAPI wine_glCompressedTexImage3DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, GLvoid* data ) { - void (*func_glCompressedTexImage3DARB)( GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedTexImage3DARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, border, imageSize, data ); - func_glCompressedTexImage3DARB( target, level, internalformat, width, height, depth, border, imageSize, data ); + funcs->ext.p_glCompressedTexImage3DARB( target, level, internalformat, width, height, depth, border, imageSize, data ); } static void WINAPI wine_glCompressedTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, GLvoid* data ) { - void (*func_glCompressedTexSubImage1D)( GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedTexSubImage1D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, width, format, imageSize, data ); - func_glCompressedTexSubImage1D( target, level, xoffset, width, format, imageSize, data ); + funcs->ext.p_glCompressedTexSubImage1D( target, level, xoffset, width, format, imageSize, data ); } static void WINAPI wine_glCompressedTexSubImage1DARB( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, GLvoid* data ) { - void (*func_glCompressedTexSubImage1DARB)( GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedTexSubImage1DARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, width, format, imageSize, data ); - func_glCompressedTexSubImage1DARB( target, level, xoffset, width, format, imageSize, data ); + funcs->ext.p_glCompressedTexSubImage1DARB( target, level, xoffset, width, format, imageSize, data ); } static void WINAPI wine_glCompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLvoid* data ) { - void (*func_glCompressedTexSubImage2D)( GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedTexSubImage2D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, width, height, format, imageSize, data ); - func_glCompressedTexSubImage2D( target, level, xoffset, yoffset, width, height, format, imageSize, data ); + funcs->ext.p_glCompressedTexSubImage2D( target, level, xoffset, yoffset, width, height, format, imageSize, data ); } static void WINAPI wine_glCompressedTexSubImage2DARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLvoid* data ) { - void (*func_glCompressedTexSubImage2DARB)( GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedTexSubImage2DARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, width, height, format, imageSize, data ); - func_glCompressedTexSubImage2DARB( target, level, xoffset, yoffset, width, height, format, imageSize, data ); + funcs->ext.p_glCompressedTexSubImage2DARB( target, level, xoffset, yoffset, width, height, format, imageSize, data ); } static void WINAPI wine_glCompressedTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, GLvoid* data ) { - void (*func_glCompressedTexSubImage3D)( GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedTexSubImage3D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data ); - func_glCompressedTexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data ); + funcs->ext.p_glCompressedTexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data ); } static void WINAPI wine_glCompressedTexSubImage3DARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, GLvoid* data ) { - void (*func_glCompressedTexSubImage3DARB)( GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedTexSubImage3DARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data ); - func_glCompressedTexSubImage3DARB( target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data ); + funcs->ext.p_glCompressedTexSubImage3DARB( target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data ); } static void WINAPI wine_glCompressedTextureImage1DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, GLvoid* bits ) { - void (*func_glCompressedTextureImage1DEXT)( GLuint, GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedTextureImage1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, internalformat, width, border, imageSize, bits ); - func_glCompressedTextureImage1DEXT( texture, target, level, internalformat, width, border, imageSize, bits ); + funcs->ext.p_glCompressedTextureImage1DEXT( texture, target, level, internalformat, width, border, imageSize, bits ); } static void WINAPI wine_glCompressedTextureImage2DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, GLvoid* bits ) { - void (*func_glCompressedTextureImage2DEXT)( GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedTextureImage2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, internalformat, width, height, border, imageSize, bits ); - func_glCompressedTextureImage2DEXT( texture, target, level, internalformat, width, height, border, imageSize, bits ); + funcs->ext.p_glCompressedTextureImage2DEXT( texture, target, level, internalformat, width, height, border, imageSize, bits ); } static void WINAPI wine_glCompressedTextureImage3DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, GLvoid* bits ) { - void (*func_glCompressedTextureImage3DEXT)( GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedTextureImage3DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, internalformat, width, height, depth, border, imageSize, bits ); - func_glCompressedTextureImage3DEXT( texture, target, level, internalformat, width, height, depth, border, imageSize, bits ); + funcs->ext.p_glCompressedTextureImage3DEXT( texture, target, level, internalformat, width, height, depth, border, imageSize, bits ); } static void WINAPI wine_glCompressedTextureSubImage1DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, GLvoid* bits ) { - void (*func_glCompressedTextureSubImage1DEXT)( GLuint, GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedTextureSubImage1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, xoffset, width, format, imageSize, bits ); - func_glCompressedTextureSubImage1DEXT( texture, target, level, xoffset, width, format, imageSize, bits ); + funcs->ext.p_glCompressedTextureSubImage1DEXT( texture, target, level, xoffset, width, format, imageSize, bits ); } static void WINAPI wine_glCompressedTextureSubImage2DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, GLvoid* bits ) { - void (*func_glCompressedTextureSubImage2DEXT)( GLuint, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedTextureSubImage2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits ); - func_glCompressedTextureSubImage2DEXT( texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits ); + funcs->ext.p_glCompressedTextureSubImage2DEXT( texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits ); } static void WINAPI wine_glCompressedTextureSubImage3DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, GLvoid* bits ) { - void (*func_glCompressedTextureSubImage3DEXT)( GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glCompressedTextureSubImage3DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits ); - func_glCompressedTextureSubImage3DEXT( texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits ); + funcs->ext.p_glCompressedTextureSubImage3DEXT( texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits ); } static void WINAPI wine_glConvolutionFilter1D( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, GLvoid* image ) { - void (*func_glConvolutionFilter1D)( GLenum, GLenum, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glConvolutionFilter1D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %p)\n", target, internalformat, width, format, type, image ); - func_glConvolutionFilter1D( target, internalformat, width, format, type, image ); + funcs->ext.p_glConvolutionFilter1D( target, internalformat, width, format, type, image ); } static void WINAPI wine_glConvolutionFilter1DEXT( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, GLvoid* image ) { - void (*func_glConvolutionFilter1DEXT)( GLenum, GLenum, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glConvolutionFilter1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %p)\n", target, internalformat, width, format, type, image ); - func_glConvolutionFilter1DEXT( target, internalformat, width, format, type, image ); + funcs->ext.p_glConvolutionFilter1DEXT( target, internalformat, width, format, type, image ); } static void WINAPI wine_glConvolutionFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* image ) { - void (*func_glConvolutionFilter2D)( GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glConvolutionFilter2D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, internalformat, width, height, format, type, image ); - func_glConvolutionFilter2D( target, internalformat, width, height, format, type, image ); + funcs->ext.p_glConvolutionFilter2D( target, internalformat, width, height, format, type, image ); } static void WINAPI wine_glConvolutionFilter2DEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* image ) { - void (*func_glConvolutionFilter2DEXT)( GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glConvolutionFilter2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, internalformat, width, height, format, type, image ); - func_glConvolutionFilter2DEXT( target, internalformat, width, height, format, type, image ); + funcs->ext.p_glConvolutionFilter2DEXT( target, internalformat, width, height, format, type, image ); } static void WINAPI wine_glConvolutionParameterf( GLenum target, GLenum pname, GLfloat params ) { - void (*func_glConvolutionParameterf)( GLenum, GLenum, GLfloat ) = extension_funcs[EXT_glConvolutionParameterf]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f)\n", target, pname, params ); - func_glConvolutionParameterf( target, pname, params ); + funcs->ext.p_glConvolutionParameterf( target, pname, params ); } static void WINAPI wine_glConvolutionParameterfEXT( GLenum target, GLenum pname, GLfloat params ) { - void (*func_glConvolutionParameterfEXT)( GLenum, GLenum, GLfloat ) = extension_funcs[EXT_glConvolutionParameterfEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f)\n", target, pname, params ); - func_glConvolutionParameterfEXT( target, pname, params ); + funcs->ext.p_glConvolutionParameterfEXT( target, pname, params ); } static void WINAPI wine_glConvolutionParameterfv( GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glConvolutionParameterfv)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glConvolutionParameterfv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glConvolutionParameterfv( target, pname, params ); + funcs->ext.p_glConvolutionParameterfv( target, pname, params ); } static void WINAPI wine_glConvolutionParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glConvolutionParameterfvEXT)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glConvolutionParameterfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glConvolutionParameterfvEXT( target, pname, params ); + funcs->ext.p_glConvolutionParameterfvEXT( target, pname, params ); } static void WINAPI wine_glConvolutionParameteri( GLenum target, GLenum pname, GLint params ) { - void (*func_glConvolutionParameteri)( GLenum, GLenum, GLint ) = extension_funcs[EXT_glConvolutionParameteri]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, pname, params ); - func_glConvolutionParameteri( target, pname, params ); + funcs->ext.p_glConvolutionParameteri( target, pname, params ); } static void WINAPI wine_glConvolutionParameteriEXT( GLenum target, GLenum pname, GLint params ) { - void (*func_glConvolutionParameteriEXT)( GLenum, GLenum, GLint ) = extension_funcs[EXT_glConvolutionParameteriEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, pname, params ); - func_glConvolutionParameteriEXT( target, pname, params ); + funcs->ext.p_glConvolutionParameteriEXT( target, pname, params ); } static void WINAPI wine_glConvolutionParameteriv( GLenum target, GLenum pname, GLint* params ) { - void (*func_glConvolutionParameteriv)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glConvolutionParameteriv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glConvolutionParameteriv( target, pname, params ); + funcs->ext.p_glConvolutionParameteriv( target, pname, params ); } static void WINAPI wine_glConvolutionParameterivEXT( GLenum target, GLenum pname, GLint* params ) { - void (*func_glConvolutionParameterivEXT)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glConvolutionParameterivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glConvolutionParameterivEXT( target, pname, params ); + funcs->ext.p_glConvolutionParameterivEXT( target, pname, params ); } static void WINAPI wine_glCopyBufferSubData( GLenum readTarget, GLenum writeTarget, INT_PTR readOffset, INT_PTR writeOffset, INT_PTR size ) { - void (*func_glCopyBufferSubData)( GLenum, GLenum, INT_PTR, INT_PTR, INT_PTR ) = extension_funcs[EXT_glCopyBufferSubData]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %ld, %ld, %ld)\n", readTarget, writeTarget, readOffset, writeOffset, size ); - func_glCopyBufferSubData( readTarget, writeTarget, readOffset, writeOffset, size ); + funcs->ext.p_glCopyBufferSubData( readTarget, writeTarget, readOffset, writeOffset, size ); } static void WINAPI wine_glCopyColorSubTable( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width ) { - void (*func_glCopyColorSubTable)( GLenum, GLsizei, GLint, GLint, GLsizei ) = extension_funcs[EXT_glCopyColorSubTable]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, start, x, y, width ); - func_glCopyColorSubTable( target, start, x, y, width ); + funcs->ext.p_glCopyColorSubTable( target, start, x, y, width ); } static void WINAPI wine_glCopyColorSubTableEXT( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width ) { - void (*func_glCopyColorSubTableEXT)( GLenum, GLsizei, GLint, GLint, GLsizei ) = extension_funcs[EXT_glCopyColorSubTableEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, start, x, y, width ); - func_glCopyColorSubTableEXT( target, start, x, y, width ); + funcs->ext.p_glCopyColorSubTableEXT( target, start, x, y, width ); } static void WINAPI wine_glCopyColorTable( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width ) { - void (*func_glCopyColorTable)( GLenum, GLenum, GLint, GLint, GLsizei ) = extension_funcs[EXT_glCopyColorTable]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, internalformat, x, y, width ); - func_glCopyColorTable( target, internalformat, x, y, width ); + funcs->ext.p_glCopyColorTable( target, internalformat, x, y, width ); } static void WINAPI wine_glCopyColorTableSGI( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width ) { - void (*func_glCopyColorTableSGI)( GLenum, GLenum, GLint, GLint, GLsizei ) = extension_funcs[EXT_glCopyColorTableSGI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, internalformat, x, y, width ); - func_glCopyColorTableSGI( target, internalformat, x, y, width ); + funcs->ext.p_glCopyColorTableSGI( target, internalformat, x, y, width ); } static void WINAPI wine_glCopyConvolutionFilter1D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width ) { - void (*func_glCopyConvolutionFilter1D)( GLenum, GLenum, GLint, GLint, GLsizei ) = extension_funcs[EXT_glCopyConvolutionFilter1D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, internalformat, x, y, width ); - func_glCopyConvolutionFilter1D( target, internalformat, x, y, width ); + funcs->ext.p_glCopyConvolutionFilter1D( target, internalformat, x, y, width ); } static void WINAPI wine_glCopyConvolutionFilter1DEXT( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width ) { - void (*func_glCopyConvolutionFilter1DEXT)( GLenum, GLenum, GLint, GLint, GLsizei ) = extension_funcs[EXT_glCopyConvolutionFilter1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, internalformat, x, y, width ); - func_glCopyConvolutionFilter1DEXT( target, internalformat, x, y, width ); + funcs->ext.p_glCopyConvolutionFilter1DEXT( target, internalformat, x, y, width ); } static void WINAPI wine_glCopyConvolutionFilter2D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height ) { - void (*func_glCopyConvolutionFilter2D)( GLenum, GLenum, GLint, GLint, GLsizei, GLsizei ) = extension_funcs[EXT_glCopyConvolutionFilter2D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", target, internalformat, x, y, width, height ); - func_glCopyConvolutionFilter2D( target, internalformat, x, y, width, height ); + funcs->ext.p_glCopyConvolutionFilter2D( target, internalformat, x, y, width, height ); } static void WINAPI wine_glCopyConvolutionFilter2DEXT( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height ) { - void (*func_glCopyConvolutionFilter2DEXT)( GLenum, GLenum, GLint, GLint, GLsizei, GLsizei ) = extension_funcs[EXT_glCopyConvolutionFilter2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", target, internalformat, x, y, width, height ); - func_glCopyConvolutionFilter2DEXT( target, internalformat, x, y, width, height ); + funcs->ext.p_glCopyConvolutionFilter2DEXT( target, internalformat, x, y, width, height ); } static void WINAPI wine_glCopyImageSubDataNV( GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth ) { - void (*func_glCopyImageSubDataNV)( GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei ) = extension_funcs[EXT_glCopyImageSubDataNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth ); - func_glCopyImageSubDataNV( srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth ); + funcs->ext.p_glCopyImageSubDataNV( srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth ); } static void WINAPI wine_glCopyMultiTexImage1DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border ) { - void (*func_glCopyMultiTexImage1DEXT)( GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint ) = extension_funcs[EXT_glCopyMultiTexImage1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", texunit, target, level, internalformat, x, y, width, border ); - func_glCopyMultiTexImage1DEXT( texunit, target, level, internalformat, x, y, width, border ); + funcs->ext.p_glCopyMultiTexImage1DEXT( texunit, target, level, internalformat, x, y, width, border ); } static void WINAPI wine_glCopyMultiTexImage2DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) { - void (*func_glCopyMultiTexImage2DEXT)( GLenum, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint ) = extension_funcs[EXT_glCopyMultiTexImage2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texunit, target, level, internalformat, x, y, width, height, border ); - func_glCopyMultiTexImage2DEXT( texunit, target, level, internalformat, x, y, width, height, border ); + funcs->ext.p_glCopyMultiTexImage2DEXT( texunit, target, level, internalformat, x, y, width, height, border ); } static void WINAPI wine_glCopyMultiTexSubImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width ) { - void (*func_glCopyMultiTexSubImage1DEXT)( GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei ) = extension_funcs[EXT_glCopyMultiTexSubImage1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", texunit, target, level, xoffset, x, y, width ); - func_glCopyMultiTexSubImage1DEXT( texunit, target, level, xoffset, x, y, width ); + funcs->ext.p_glCopyMultiTexSubImage1DEXT( texunit, target, level, xoffset, x, y, width ); } static void WINAPI wine_glCopyMultiTexSubImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) { - void (*func_glCopyMultiTexSubImage2DEXT)( GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei ) = extension_funcs[EXT_glCopyMultiTexSubImage2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texunit, target, level, xoffset, yoffset, x, y, width, height ); - func_glCopyMultiTexSubImage2DEXT( texunit, target, level, xoffset, yoffset, x, y, width, height ); + funcs->ext.p_glCopyMultiTexSubImage2DEXT( texunit, target, level, xoffset, yoffset, x, y, width, height ); } static void WINAPI wine_glCopyMultiTexSubImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) { - void (*func_glCopyMultiTexSubImage3DEXT)( GLenum, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei ) = extension_funcs[EXT_glCopyMultiTexSubImage3DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height ); - func_glCopyMultiTexSubImage3DEXT( texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height ); + funcs->ext.p_glCopyMultiTexSubImage3DEXT( texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height ); } static void WINAPI wine_glCopyPathNV( GLuint resultPath, GLuint srcPath ) { - void (*func_glCopyPathNV)( GLuint, GLuint ) = extension_funcs[EXT_glCopyPathNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", resultPath, srcPath ); - func_glCopyPathNV( resultPath, srcPath ); + funcs->ext.p_glCopyPathNV( resultPath, srcPath ); } static void WINAPI wine_glCopyTexImage1DEXT( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border ) { - void (*func_glCopyTexImage1DEXT)( GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint ) = extension_funcs[EXT_glCopyTexImage1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", target, level, internalformat, x, y, width, border ); - func_glCopyTexImage1DEXT( target, level, internalformat, x, y, width, border ); + funcs->ext.p_glCopyTexImage1DEXT( target, level, internalformat, x, y, width, border ); } static void WINAPI wine_glCopyTexImage2DEXT( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) { - void (*func_glCopyTexImage2DEXT)( GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint ) = extension_funcs[EXT_glCopyTexImage2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, internalformat, x, y, width, height, border ); - func_glCopyTexImage2DEXT( target, level, internalformat, x, y, width, height, border ); + funcs->ext.p_glCopyTexImage2DEXT( target, level, internalformat, x, y, width, height, border ); } static void WINAPI wine_glCopyTexSubImage1DEXT( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width ) { - void (*func_glCopyTexSubImage1DEXT)( GLenum, GLint, GLint, GLint, GLint, GLsizei ) = extension_funcs[EXT_glCopyTexSubImage1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", target, level, xoffset, x, y, width ); - func_glCopyTexSubImage1DEXT( target, level, xoffset, x, y, width ); + funcs->ext.p_glCopyTexSubImage1DEXT( target, level, xoffset, x, y, width ); } static void WINAPI wine_glCopyTexSubImage2DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) { - void (*func_glCopyTexSubImage2DEXT)( GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei ) = extension_funcs[EXT_glCopyTexSubImage2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, x, y, width, height ); - func_glCopyTexSubImage2DEXT( target, level, xoffset, yoffset, x, y, width, height ); + funcs->ext.p_glCopyTexSubImage2DEXT( target, level, xoffset, yoffset, x, y, width, height ); } static void WINAPI wine_glCopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) { - void (*func_glCopyTexSubImage3D)( GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei ) = extension_funcs[EXT_glCopyTexSubImage3D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, zoffset, x, y, width, height ); - func_glCopyTexSubImage3D( target, level, xoffset, yoffset, zoffset, x, y, width, height ); + funcs->ext.p_glCopyTexSubImage3D( target, level, xoffset, yoffset, zoffset, x, y, width, height ); } static void WINAPI wine_glCopyTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) { - void (*func_glCopyTexSubImage3DEXT)( GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei ) = extension_funcs[EXT_glCopyTexSubImage3DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, zoffset, x, y, width, height ); - func_glCopyTexSubImage3DEXT( target, level, xoffset, yoffset, zoffset, x, y, width, height ); + funcs->ext.p_glCopyTexSubImage3DEXT( target, level, xoffset, yoffset, zoffset, x, y, width, height ); } static void WINAPI wine_glCopyTextureImage1DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border ) { - void (*func_glCopyTextureImage1DEXT)( GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint ) = extension_funcs[EXT_glCopyTextureImage1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, level, internalformat, x, y, width, border ); - func_glCopyTextureImage1DEXT( texture, target, level, internalformat, x, y, width, border ); + funcs->ext.p_glCopyTextureImage1DEXT( texture, target, level, internalformat, x, y, width, border ); } static void WINAPI wine_glCopyTextureImage2DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) { - void (*func_glCopyTextureImage2DEXT)( GLuint, GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint ) = extension_funcs[EXT_glCopyTextureImage2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, level, internalformat, x, y, width, height, border ); - func_glCopyTextureImage2DEXT( texture, target, level, internalformat, x, y, width, height, border ); + funcs->ext.p_glCopyTextureImage2DEXT( texture, target, level, internalformat, x, y, width, height, border ); } static void WINAPI wine_glCopyTextureSubImage1DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width ) { - void (*func_glCopyTextureSubImage1DEXT)( GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei ) = extension_funcs[EXT_glCopyTextureSubImage1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", texture, target, level, xoffset, x, y, width ); - func_glCopyTextureSubImage1DEXT( texture, target, level, xoffset, x, y, width ); + funcs->ext.p_glCopyTextureSubImage1DEXT( texture, target, level, xoffset, x, y, width ); } static void WINAPI wine_glCopyTextureSubImage2DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) { - void (*func_glCopyTextureSubImage2DEXT)( GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei ) = extension_funcs[EXT_glCopyTextureSubImage2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, level, xoffset, yoffset, x, y, width, height ); - func_glCopyTextureSubImage2DEXT( texture, target, level, xoffset, yoffset, x, y, width, height ); + funcs->ext.p_glCopyTextureSubImage2DEXT( texture, target, level, xoffset, yoffset, x, y, width, height ); } static void WINAPI wine_glCopyTextureSubImage3DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) { - void (*func_glCopyTextureSubImage3DEXT)( GLuint, GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei ) = extension_funcs[EXT_glCopyTextureSubImage3DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, level, xoffset, yoffset, zoffset, x, y, width, height ); - func_glCopyTextureSubImage3DEXT( texture, target, level, xoffset, yoffset, zoffset, x, y, width, height ); + funcs->ext.p_glCopyTextureSubImage3DEXT( texture, target, level, xoffset, yoffset, zoffset, x, y, width, height ); } static void WINAPI wine_glCoverFillPathInstancedNV( GLsizei numPaths, GLenum pathNameType, GLvoid* paths, GLuint pathBase, GLenum coverMode, GLenum transformType, GLfloat* transformValues ) { - void (*func_glCoverFillPathInstancedNV)( GLsizei, GLenum, GLvoid*, GLuint, GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glCoverFillPathInstancedNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %d, %d, %d, %p)\n", numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues ); - func_glCoverFillPathInstancedNV( numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues ); + funcs->ext.p_glCoverFillPathInstancedNV( numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues ); } static void WINAPI wine_glCoverFillPathNV( GLuint path, GLenum coverMode ) { - void (*func_glCoverFillPathNV)( GLuint, GLenum ) = extension_funcs[EXT_glCoverFillPathNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", path, coverMode ); - func_glCoverFillPathNV( path, coverMode ); + funcs->ext.p_glCoverFillPathNV( path, coverMode ); } static void WINAPI wine_glCoverStrokePathInstancedNV( GLsizei numPaths, GLenum pathNameType, GLvoid* paths, GLuint pathBase, GLenum coverMode, GLenum transformType, GLfloat* transformValues ) { - void (*func_glCoverStrokePathInstancedNV)( GLsizei, GLenum, GLvoid*, GLuint, GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glCoverStrokePathInstancedNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %d, %d, %d, %p)\n", numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues ); - func_glCoverStrokePathInstancedNV( numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues ); + funcs->ext.p_glCoverStrokePathInstancedNV( numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues ); } static void WINAPI wine_glCoverStrokePathNV( GLuint path, GLenum coverMode ) { - void (*func_glCoverStrokePathNV)( GLuint, GLenum ) = extension_funcs[EXT_glCoverStrokePathNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", path, coverMode ); - func_glCoverStrokePathNV( path, coverMode ); + funcs->ext.p_glCoverStrokePathNV( path, coverMode ); } static GLuint WINAPI wine_glCreateProgram( void ) { - GLuint (*func_glCreateProgram)( void ) = extension_funcs[EXT_glCreateProgram]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - return func_glCreateProgram( ); + return funcs->ext.p_glCreateProgram( ); } static unsigned int WINAPI wine_glCreateProgramObjectARB( void ) { - unsigned int (*func_glCreateProgramObjectARB)( void ) = extension_funcs[EXT_glCreateProgramObjectARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - return func_glCreateProgramObjectARB( ); + return funcs->ext.p_glCreateProgramObjectARB( ); } static GLuint WINAPI wine_glCreateShader( GLenum type ) { - GLuint (*func_glCreateShader)( GLenum ) = extension_funcs[EXT_glCreateShader]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", type ); - return func_glCreateShader( type ); + return funcs->ext.p_glCreateShader( type ); } static unsigned int WINAPI wine_glCreateShaderObjectARB( GLenum shaderType ) { - unsigned int (*func_glCreateShaderObjectARB)( GLenum ) = extension_funcs[EXT_glCreateShaderObjectARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", shaderType ); - return func_glCreateShaderObjectARB( shaderType ); + return funcs->ext.p_glCreateShaderObjectARB( shaderType ); } static GLuint WINAPI wine_glCreateShaderProgramEXT( GLenum type, char* string ) { - GLuint (*func_glCreateShaderProgramEXT)( GLenum, char* ) = extension_funcs[EXT_glCreateShaderProgramEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", type, string ); - return func_glCreateShaderProgramEXT( type, string ); + return funcs->ext.p_glCreateShaderProgramEXT( type, string ); } static GLuint WINAPI wine_glCreateShaderProgramv( GLenum type, GLsizei count, char* const* strings ) { - GLuint (*func_glCreateShaderProgramv)( GLenum, GLsizei, char* const* ) = extension_funcs[EXT_glCreateShaderProgramv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", type, count, strings ); - return func_glCreateShaderProgramv( type, count, strings ); + return funcs->ext.p_glCreateShaderProgramv( type, count, strings ); } static GLvoid* WINAPI wine_glCreateSyncFromCLeventARB( void * context, void * event, GLbitfield flags ) { - GLvoid* (*func_glCreateSyncFromCLeventARB)( void *, void *, GLbitfield ) = extension_funcs[EXT_glCreateSyncFromCLeventARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p, %d)\n", context, event, flags ); - return func_glCreateSyncFromCLeventARB( context, event, flags ); + return funcs->ext.p_glCreateSyncFromCLeventARB( context, event, flags ); } static void WINAPI wine_glCullParameterdvEXT( GLenum pname, GLdouble* params ) { - void (*func_glCullParameterdvEXT)( GLenum, GLdouble* ) = extension_funcs[EXT_glCullParameterdvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glCullParameterdvEXT( pname, params ); + funcs->ext.p_glCullParameterdvEXT( pname, params ); } static void WINAPI wine_glCullParameterfvEXT( GLenum pname, GLfloat* params ) { - void (*func_glCullParameterfvEXT)( GLenum, GLfloat* ) = extension_funcs[EXT_glCullParameterfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glCullParameterfvEXT( pname, params ); + funcs->ext.p_glCullParameterfvEXT( pname, params ); } static void WINAPI wine_glCurrentPaletteMatrixARB( GLint index ) { - void (*func_glCurrentPaletteMatrixARB)( GLint ) = extension_funcs[EXT_glCurrentPaletteMatrixARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", index ); - func_glCurrentPaletteMatrixARB( index ); + funcs->ext.p_glCurrentPaletteMatrixARB( index ); } static void WINAPI wine_glDebugMessageCallbackAMD( void * callback, GLvoid* userParam ) { - void (*func_glDebugMessageCallbackAMD)( void *, GLvoid* ) = extension_funcs[EXT_glDebugMessageCallbackAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p)\n", callback, userParam ); - func_glDebugMessageCallbackAMD( callback, userParam ); + funcs->ext.p_glDebugMessageCallbackAMD( callback, userParam ); } static void WINAPI wine_glDebugMessageCallbackARB( void * callback, GLvoid* userParam ) { - void (*func_glDebugMessageCallbackARB)( void *, GLvoid* ) = extension_funcs[EXT_glDebugMessageCallbackARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p)\n", callback, userParam ); - func_glDebugMessageCallbackARB( callback, userParam ); + funcs->ext.p_glDebugMessageCallbackARB( callback, userParam ); } static void WINAPI wine_glDebugMessageControlARB( GLenum source, GLenum type, GLenum severity, GLsizei count, GLuint* ids, GLboolean enabled ) { - void (*func_glDebugMessageControlARB)( GLenum, GLenum, GLenum, GLsizei, GLuint*, GLboolean ) = extension_funcs[EXT_glDebugMessageControlARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p, %d)\n", source, type, severity, count, ids, enabled ); - func_glDebugMessageControlARB( source, type, severity, count, ids, enabled ); + funcs->ext.p_glDebugMessageControlARB( source, type, severity, count, ids, enabled ); } static void WINAPI wine_glDebugMessageEnableAMD( GLenum category, GLenum severity, GLsizei count, GLuint* ids, GLboolean enabled ) { - void (*func_glDebugMessageEnableAMD)( GLenum, GLenum, GLsizei, GLuint*, GLboolean ) = extension_funcs[EXT_glDebugMessageEnableAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %d)\n", category, severity, count, ids, enabled ); - func_glDebugMessageEnableAMD( category, severity, count, ids, enabled ); + funcs->ext.p_glDebugMessageEnableAMD( category, severity, count, ids, enabled ); } static void WINAPI wine_glDebugMessageInsertAMD( GLenum category, GLenum severity, GLuint id, GLsizei length, char* buf ) { - void (*func_glDebugMessageInsertAMD)( GLenum, GLenum, GLuint, GLsizei, char* ) = extension_funcs[EXT_glDebugMessageInsertAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", category, severity, id, length, buf ); - func_glDebugMessageInsertAMD( category, severity, id, length, buf ); + funcs->ext.p_glDebugMessageInsertAMD( category, severity, id, length, buf ); } static void WINAPI wine_glDebugMessageInsertARB( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, char* buf ) { - void (*func_glDebugMessageInsertARB)( GLenum, GLenum, GLuint, GLenum, GLsizei, char* ) = extension_funcs[EXT_glDebugMessageInsertARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %p)\n", source, type, id, severity, length, buf ); - func_glDebugMessageInsertARB( source, type, id, severity, length, buf ); + funcs->ext.p_glDebugMessageInsertARB( source, type, id, severity, length, buf ); } static void WINAPI wine_glDeformSGIX( GLbitfield mask ) { - void (*func_glDeformSGIX)( GLbitfield ) = extension_funcs[EXT_glDeformSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", mask ); - func_glDeformSGIX( mask ); + funcs->ext.p_glDeformSGIX( mask ); } static void WINAPI wine_glDeformationMap3dSGIX( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, GLdouble* points ) { - void (*func_glDeformationMap3dSGIX)( GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble* ) = extension_funcs[EXT_glDeformationMap3dSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %d, %d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points ); - func_glDeformationMap3dSGIX( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points ); + funcs->ext.p_glDeformationMap3dSGIX( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points ); } static void WINAPI wine_glDeformationMap3fSGIX( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, GLfloat* points ) { - void (*func_glDeformationMap3fSGIX)( GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat* ) = extension_funcs[EXT_glDeformationMap3fSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %d, %d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points ); - func_glDeformationMap3fSGIX( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points ); + funcs->ext.p_glDeformationMap3fSGIX( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points ); } static void WINAPI wine_glDeleteAsyncMarkersSGIX( GLuint marker, GLsizei range ) { - void (*func_glDeleteAsyncMarkersSGIX)( GLuint, GLsizei ) = extension_funcs[EXT_glDeleteAsyncMarkersSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", marker, range ); - func_glDeleteAsyncMarkersSGIX( marker, range ); + funcs->ext.p_glDeleteAsyncMarkersSGIX( marker, range ); } static void WINAPI wine_glDeleteBufferRegion( GLenum region ) { - void (*func_glDeleteBufferRegion)( GLenum ) = extension_funcs[EXT_glDeleteBufferRegion]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", region ); - func_glDeleteBufferRegion( region ); + funcs->ext.p_glDeleteBufferRegion( region ); } static void WINAPI wine_glDeleteBuffers( GLsizei n, GLuint* buffers ) { - void (*func_glDeleteBuffers)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteBuffers]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, buffers ); - func_glDeleteBuffers( n, buffers ); + funcs->ext.p_glDeleteBuffers( n, buffers ); } static void WINAPI wine_glDeleteBuffersARB( GLsizei n, GLuint* buffers ) { - void (*func_glDeleteBuffersARB)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteBuffersARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, buffers ); - func_glDeleteBuffersARB( n, buffers ); + funcs->ext.p_glDeleteBuffersARB( n, buffers ); } static void WINAPI wine_glDeleteFencesAPPLE( GLsizei n, GLuint* fences ) { - void (*func_glDeleteFencesAPPLE)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteFencesAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, fences ); - func_glDeleteFencesAPPLE( n, fences ); + funcs->ext.p_glDeleteFencesAPPLE( n, fences ); } static void WINAPI wine_glDeleteFencesNV( GLsizei n, GLuint* fences ) { - void (*func_glDeleteFencesNV)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteFencesNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, fences ); - func_glDeleteFencesNV( n, fences ); + funcs->ext.p_glDeleteFencesNV( n, fences ); } static void WINAPI wine_glDeleteFragmentShaderATI( GLuint id ) { - void (*func_glDeleteFragmentShaderATI)( GLuint ) = extension_funcs[EXT_glDeleteFragmentShaderATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", id ); - func_glDeleteFragmentShaderATI( id ); + funcs->ext.p_glDeleteFragmentShaderATI( id ); } static void WINAPI wine_glDeleteFramebuffers( GLsizei n, GLuint* framebuffers ) { - void (*func_glDeleteFramebuffers)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteFramebuffers]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, framebuffers ); - func_glDeleteFramebuffers( n, framebuffers ); + funcs->ext.p_glDeleteFramebuffers( n, framebuffers ); } static void WINAPI wine_glDeleteFramebuffersEXT( GLsizei n, GLuint* framebuffers ) { - void (*func_glDeleteFramebuffersEXT)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteFramebuffersEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, framebuffers ); - func_glDeleteFramebuffersEXT( n, framebuffers ); + funcs->ext.p_glDeleteFramebuffersEXT( n, framebuffers ); } static void WINAPI wine_glDeleteNamedStringARB( GLint namelen, char* name ) { - void (*func_glDeleteNamedStringARB)( GLint, char* ) = extension_funcs[EXT_glDeleteNamedStringARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", namelen, name ); - func_glDeleteNamedStringARB( namelen, name ); + funcs->ext.p_glDeleteNamedStringARB( namelen, name ); } static void WINAPI wine_glDeleteNamesAMD( GLenum identifier, GLuint num, GLuint* names ) { - void (*func_glDeleteNamesAMD)( GLenum, GLuint, GLuint* ) = extension_funcs[EXT_glDeleteNamesAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", identifier, num, names ); - func_glDeleteNamesAMD( identifier, num, names ); + funcs->ext.p_glDeleteNamesAMD( identifier, num, names ); } static void WINAPI wine_glDeleteObjectARB( unsigned int obj ) { - void (*func_glDeleteObjectARB)( unsigned int ) = extension_funcs[EXT_glDeleteObjectARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", obj ); - func_glDeleteObjectARB( obj ); + funcs->ext.p_glDeleteObjectARB( obj ); } static void WINAPI wine_glDeleteObjectBufferATI( GLuint buffer ) { - void (*func_glDeleteObjectBufferATI)( GLuint ) = extension_funcs[EXT_glDeleteObjectBufferATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", buffer ); - func_glDeleteObjectBufferATI( buffer ); + funcs->ext.p_glDeleteObjectBufferATI( buffer ); } static void WINAPI wine_glDeleteOcclusionQueriesNV( GLsizei n, GLuint* ids ) { - void (*func_glDeleteOcclusionQueriesNV)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteOcclusionQueriesNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, ids ); - func_glDeleteOcclusionQueriesNV( n, ids ); + funcs->ext.p_glDeleteOcclusionQueriesNV( n, ids ); } static void WINAPI wine_glDeletePathsNV( GLuint path, GLsizei range ) { - void (*func_glDeletePathsNV)( GLuint, GLsizei ) = extension_funcs[EXT_glDeletePathsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", path, range ); - func_glDeletePathsNV( path, range ); + funcs->ext.p_glDeletePathsNV( path, range ); } static void WINAPI wine_glDeletePerfMonitorsAMD( GLsizei n, GLuint* monitors ) { - void (*func_glDeletePerfMonitorsAMD)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeletePerfMonitorsAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, monitors ); - func_glDeletePerfMonitorsAMD( n, monitors ); + funcs->ext.p_glDeletePerfMonitorsAMD( n, monitors ); } static void WINAPI wine_glDeleteProgram( GLuint program ) { - void (*func_glDeleteProgram)( GLuint ) = extension_funcs[EXT_glDeleteProgram]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", program ); - func_glDeleteProgram( program ); + funcs->ext.p_glDeleteProgram( program ); } static void WINAPI wine_glDeleteProgramPipelines( GLsizei n, GLuint* pipelines ) { - void (*func_glDeleteProgramPipelines)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteProgramPipelines]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, pipelines ); - func_glDeleteProgramPipelines( n, pipelines ); + funcs->ext.p_glDeleteProgramPipelines( n, pipelines ); } static void WINAPI wine_glDeleteProgramsARB( GLsizei n, GLuint* programs ) { - void (*func_glDeleteProgramsARB)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteProgramsARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, programs ); - func_glDeleteProgramsARB( n, programs ); + funcs->ext.p_glDeleteProgramsARB( n, programs ); } static void WINAPI wine_glDeleteProgramsNV( GLsizei n, GLuint* programs ) { - void (*func_glDeleteProgramsNV)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteProgramsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, programs ); - func_glDeleteProgramsNV( n, programs ); + funcs->ext.p_glDeleteProgramsNV( n, programs ); } static void WINAPI wine_glDeleteQueries( GLsizei n, GLuint* ids ) { - void (*func_glDeleteQueries)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteQueries]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, ids ); - func_glDeleteQueries( n, ids ); + funcs->ext.p_glDeleteQueries( n, ids ); } static void WINAPI wine_glDeleteQueriesARB( GLsizei n, GLuint* ids ) { - void (*func_glDeleteQueriesARB)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteQueriesARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, ids ); - func_glDeleteQueriesARB( n, ids ); + funcs->ext.p_glDeleteQueriesARB( n, ids ); } static void WINAPI wine_glDeleteRenderbuffers( GLsizei n, GLuint* renderbuffers ) { - void (*func_glDeleteRenderbuffers)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteRenderbuffers]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, renderbuffers ); - func_glDeleteRenderbuffers( n, renderbuffers ); + funcs->ext.p_glDeleteRenderbuffers( n, renderbuffers ); } static void WINAPI wine_glDeleteRenderbuffersEXT( GLsizei n, GLuint* renderbuffers ) { - void (*func_glDeleteRenderbuffersEXT)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteRenderbuffersEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, renderbuffers ); - func_glDeleteRenderbuffersEXT( n, renderbuffers ); + funcs->ext.p_glDeleteRenderbuffersEXT( n, renderbuffers ); } static void WINAPI wine_glDeleteSamplers( GLsizei count, GLuint* samplers ) { - void (*func_glDeleteSamplers)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteSamplers]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", count, samplers ); - func_glDeleteSamplers( count, samplers ); + funcs->ext.p_glDeleteSamplers( count, samplers ); } static void WINAPI wine_glDeleteShader( GLuint shader ) { - void (*func_glDeleteShader)( GLuint ) = extension_funcs[EXT_glDeleteShader]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", shader ); - func_glDeleteShader( shader ); + funcs->ext.p_glDeleteShader( shader ); } static void WINAPI wine_glDeleteSync( GLvoid* sync ) { - void (*func_glDeleteSync)( GLvoid* ) = extension_funcs[EXT_glDeleteSync]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", sync ); - func_glDeleteSync( sync ); + funcs->ext.p_glDeleteSync( sync ); } static void WINAPI wine_glDeleteTexturesEXT( GLsizei n, GLuint* textures ) { - void (*func_glDeleteTexturesEXT)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteTexturesEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, textures ); - func_glDeleteTexturesEXT( n, textures ); + funcs->ext.p_glDeleteTexturesEXT( n, textures ); } static void WINAPI wine_glDeleteTransformFeedbacks( GLsizei n, GLuint* ids ) { - void (*func_glDeleteTransformFeedbacks)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteTransformFeedbacks]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, ids ); - func_glDeleteTransformFeedbacks( n, ids ); + funcs->ext.p_glDeleteTransformFeedbacks( n, ids ); } static void WINAPI wine_glDeleteTransformFeedbacksNV( GLsizei n, GLuint* ids ) { - void (*func_glDeleteTransformFeedbacksNV)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteTransformFeedbacksNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, ids ); - func_glDeleteTransformFeedbacksNV( n, ids ); + funcs->ext.p_glDeleteTransformFeedbacksNV( n, ids ); } static void WINAPI wine_glDeleteVertexArrays( GLsizei n, GLuint* arrays ) { - void (*func_glDeleteVertexArrays)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteVertexArrays]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, arrays ); - func_glDeleteVertexArrays( n, arrays ); + funcs->ext.p_glDeleteVertexArrays( n, arrays ); } static void WINAPI wine_glDeleteVertexArraysAPPLE( GLsizei n, GLuint* arrays ) { - void (*func_glDeleteVertexArraysAPPLE)( GLsizei, GLuint* ) = extension_funcs[EXT_glDeleteVertexArraysAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, arrays ); - func_glDeleteVertexArraysAPPLE( n, arrays ); + funcs->ext.p_glDeleteVertexArraysAPPLE( n, arrays ); } static void WINAPI wine_glDeleteVertexShaderEXT( GLuint id ) { - void (*func_glDeleteVertexShaderEXT)( GLuint ) = extension_funcs[EXT_glDeleteVertexShaderEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", id ); - func_glDeleteVertexShaderEXT( id ); + funcs->ext.p_glDeleteVertexShaderEXT( id ); } static void WINAPI wine_glDepthBoundsEXT( GLclampd zmin, GLclampd zmax ) { - void (*func_glDepthBoundsEXT)( GLclampd, GLclampd ) = extension_funcs[EXT_glDepthBoundsEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f)\n", zmin, zmax ); - func_glDepthBoundsEXT( zmin, zmax ); + funcs->ext.p_glDepthBoundsEXT( zmin, zmax ); } static void WINAPI wine_glDepthBoundsdNV( GLdouble zmin, GLdouble zmax ) { - void (*func_glDepthBoundsdNV)( GLdouble, GLdouble ) = extension_funcs[EXT_glDepthBoundsdNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f)\n", zmin, zmax ); - func_glDepthBoundsdNV( zmin, zmax ); + funcs->ext.p_glDepthBoundsdNV( zmin, zmax ); } static void WINAPI wine_glDepthRangeArrayv( GLuint first, GLsizei count, GLdouble* v ) { - void (*func_glDepthRangeArrayv)( GLuint, GLsizei, GLdouble* ) = extension_funcs[EXT_glDepthRangeArrayv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", first, count, v ); - func_glDepthRangeArrayv( first, count, v ); + funcs->ext.p_glDepthRangeArrayv( first, count, v ); } static void WINAPI wine_glDepthRangeIndexed( GLuint index, GLdouble n, GLdouble f ) { - void (*func_glDepthRangeIndexed)( GLuint, GLdouble, GLdouble ) = extension_funcs[EXT_glDepthRangeIndexed]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", index, n, f ); - func_glDepthRangeIndexed( index, n, f ); + funcs->ext.p_glDepthRangeIndexed( index, n, f ); } static void WINAPI wine_glDepthRangedNV( GLdouble zNear, GLdouble zFar ) { - void (*func_glDepthRangedNV)( GLdouble, GLdouble ) = extension_funcs[EXT_glDepthRangedNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f)\n", zNear, zFar ); - func_glDepthRangedNV( zNear, zFar ); + funcs->ext.p_glDepthRangedNV( zNear, zFar ); } static void WINAPI wine_glDepthRangef( GLfloat n, GLfloat f ) { - void (*func_glDepthRangef)( GLfloat, GLfloat ) = extension_funcs[EXT_glDepthRangef]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f)\n", n, f ); - func_glDepthRangef( n, f ); + funcs->ext.p_glDepthRangef( n, f ); } static void WINAPI wine_glDetachObjectARB( unsigned int containerObj, unsigned int attachedObj ) { - void (*func_glDetachObjectARB)( unsigned int, unsigned int ) = extension_funcs[EXT_glDetachObjectARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", containerObj, attachedObj ); - func_glDetachObjectARB( containerObj, attachedObj ); + funcs->ext.p_glDetachObjectARB( containerObj, attachedObj ); } static void WINAPI wine_glDetachShader( GLuint program, GLuint shader ) { - void (*func_glDetachShader)( GLuint, GLuint ) = extension_funcs[EXT_glDetachShader]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", program, shader ); - func_glDetachShader( program, shader ); + funcs->ext.p_glDetachShader( program, shader ); } static void WINAPI wine_glDetailTexFuncSGIS( GLenum target, GLsizei n, GLfloat* points ) { - void (*func_glDetailTexFuncSGIS)( GLenum, GLsizei, GLfloat* ) = extension_funcs[EXT_glDetailTexFuncSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, n, points ); - func_glDetailTexFuncSGIS( target, n, points ); + funcs->ext.p_glDetailTexFuncSGIS( target, n, points ); } static void WINAPI wine_glDisableClientStateIndexedEXT( GLenum array, GLuint index ) { - void (*func_glDisableClientStateIndexedEXT)( GLenum, GLuint ) = extension_funcs[EXT_glDisableClientStateIndexedEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", array, index ); - func_glDisableClientStateIndexedEXT( array, index ); + funcs->ext.p_glDisableClientStateIndexedEXT( array, index ); } static void WINAPI wine_glDisableIndexedEXT( GLenum target, GLuint index ) { - void (*func_glDisableIndexedEXT)( GLenum, GLuint ) = extension_funcs[EXT_glDisableIndexedEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, index ); - func_glDisableIndexedEXT( target, index ); + funcs->ext.p_glDisableIndexedEXT( target, index ); } static void WINAPI wine_glDisableVariantClientStateEXT( GLuint id ) { - void (*func_glDisableVariantClientStateEXT)( GLuint ) = extension_funcs[EXT_glDisableVariantClientStateEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", id ); - func_glDisableVariantClientStateEXT( id ); + funcs->ext.p_glDisableVariantClientStateEXT( id ); } static void WINAPI wine_glDisableVertexAttribAPPLE( GLuint index, GLenum pname ) { - void (*func_glDisableVertexAttribAPPLE)( GLuint, GLenum ) = extension_funcs[EXT_glDisableVertexAttribAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", index, pname ); - func_glDisableVertexAttribAPPLE( index, pname ); + funcs->ext.p_glDisableVertexAttribAPPLE( index, pname ); } static void WINAPI wine_glDisableVertexAttribArray( GLuint index ) { - void (*func_glDisableVertexAttribArray)( GLuint ) = extension_funcs[EXT_glDisableVertexAttribArray]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", index ); - func_glDisableVertexAttribArray( index ); + funcs->ext.p_glDisableVertexAttribArray( index ); } static void WINAPI wine_glDisableVertexAttribArrayARB( GLuint index ) { - void (*func_glDisableVertexAttribArrayARB)( GLuint ) = extension_funcs[EXT_glDisableVertexAttribArrayARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", index ); - func_glDisableVertexAttribArrayARB( index ); + funcs->ext.p_glDisableVertexAttribArrayARB( index ); } static void WINAPI wine_glDisablei( GLenum target, GLuint index ) { - void (*func_glDisablei)( GLenum, GLuint ) = extension_funcs[EXT_glDisablei]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, index ); - func_glDisablei( target, index ); + funcs->ext.p_glDisablei( target, index ); } static void WINAPI wine_glDrawArraysEXT( GLenum mode, GLint first, GLsizei count ) { - void (*func_glDrawArraysEXT)( GLenum, GLint, GLsizei ) = extension_funcs[EXT_glDrawArraysEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", mode, first, count ); - func_glDrawArraysEXT( mode, first, count ); + funcs->ext.p_glDrawArraysEXT( mode, first, count ); } static void WINAPI wine_glDrawArraysIndirect( GLenum mode, GLvoid* indirect ) { - void (*func_glDrawArraysIndirect)( GLenum, GLvoid* ) = extension_funcs[EXT_glDrawArraysIndirect]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", mode, indirect ); - func_glDrawArraysIndirect( mode, indirect ); + funcs->ext.p_glDrawArraysIndirect( mode, indirect ); } static void WINAPI wine_glDrawArraysInstanced( GLenum mode, GLint first, GLsizei count, GLsizei primcount ) { - void (*func_glDrawArraysInstanced)( GLenum, GLint, GLsizei, GLsizei ) = extension_funcs[EXT_glDrawArraysInstanced]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", mode, first, count, primcount ); - func_glDrawArraysInstanced( mode, first, count, primcount ); + funcs->ext.p_glDrawArraysInstanced( mode, first, count, primcount ); } static void WINAPI wine_glDrawArraysInstancedARB( GLenum mode, GLint first, GLsizei count, GLsizei primcount ) { - void (*func_glDrawArraysInstancedARB)( GLenum, GLint, GLsizei, GLsizei ) = extension_funcs[EXT_glDrawArraysInstancedARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", mode, first, count, primcount ); - func_glDrawArraysInstancedARB( mode, first, count, primcount ); + funcs->ext.p_glDrawArraysInstancedARB( mode, first, count, primcount ); } static void WINAPI wine_glDrawArraysInstancedBaseInstance( GLenum mode, GLint first, GLsizei count, GLsizei primcount, GLuint baseinstance ) { - void (*func_glDrawArraysInstancedBaseInstance)( GLenum, GLint, GLsizei, GLsizei, GLuint ) = extension_funcs[EXT_glDrawArraysInstancedBaseInstance]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", mode, first, count, primcount, baseinstance ); - func_glDrawArraysInstancedBaseInstance( mode, first, count, primcount, baseinstance ); + funcs->ext.p_glDrawArraysInstancedBaseInstance( mode, first, count, primcount, baseinstance ); } static void WINAPI wine_glDrawArraysInstancedEXT( GLenum mode, GLint start, GLsizei count, GLsizei primcount ) { - void (*func_glDrawArraysInstancedEXT)( GLenum, GLint, GLsizei, GLsizei ) = extension_funcs[EXT_glDrawArraysInstancedEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", mode, start, count, primcount ); - func_glDrawArraysInstancedEXT( mode, start, count, primcount ); + funcs->ext.p_glDrawArraysInstancedEXT( mode, start, count, primcount ); } static void WINAPI wine_glDrawBufferRegion( GLenum region, GLint x, GLint y, GLsizei width, GLsizei height, GLint xDest, GLint yDest ) { - void (*func_glDrawBufferRegion)( GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLint ) = extension_funcs[EXT_glDrawBufferRegion]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", region, x, y, width, height, xDest, yDest ); - func_glDrawBufferRegion( region, x, y, width, height, xDest, yDest ); + funcs->ext.p_glDrawBufferRegion( region, x, y, width, height, xDest, yDest ); } static void WINAPI wine_glDrawBuffers( GLsizei n, GLenum* bufs ) { - void (*func_glDrawBuffers)( GLsizei, GLenum* ) = extension_funcs[EXT_glDrawBuffers]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, bufs ); - func_glDrawBuffers( n, bufs ); + funcs->ext.p_glDrawBuffers( n, bufs ); } static void WINAPI wine_glDrawBuffersARB( GLsizei n, GLenum* bufs ) { - void (*func_glDrawBuffersARB)( GLsizei, GLenum* ) = extension_funcs[EXT_glDrawBuffersARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, bufs ); - func_glDrawBuffersARB( n, bufs ); + funcs->ext.p_glDrawBuffersARB( n, bufs ); } static void WINAPI wine_glDrawBuffersATI( GLsizei n, GLenum* bufs ) { - void (*func_glDrawBuffersATI)( GLsizei, GLenum* ) = extension_funcs[EXT_glDrawBuffersATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, bufs ); - func_glDrawBuffersATI( n, bufs ); + funcs->ext.p_glDrawBuffersATI( n, bufs ); } static void WINAPI wine_glDrawElementArrayAPPLE( GLenum mode, GLint first, GLsizei count ) { - void (*func_glDrawElementArrayAPPLE)( GLenum, GLint, GLsizei ) = extension_funcs[EXT_glDrawElementArrayAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", mode, first, count ); - func_glDrawElementArrayAPPLE( mode, first, count ); + funcs->ext.p_glDrawElementArrayAPPLE( mode, first, count ); } static void WINAPI wine_glDrawElementArrayATI( GLenum mode, GLsizei count ) { - void (*func_glDrawElementArrayATI)( GLenum, GLsizei ) = extension_funcs[EXT_glDrawElementArrayATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", mode, count ); - func_glDrawElementArrayATI( mode, count ); + funcs->ext.p_glDrawElementArrayATI( mode, count ); } static void WINAPI wine_glDrawElementsBaseVertex( GLenum mode, GLsizei count, GLenum type, GLvoid* indices, GLint basevertex ) { - void (*func_glDrawElementsBaseVertex)( GLenum, GLsizei, GLenum, GLvoid*, GLint ) = extension_funcs[EXT_glDrawElementsBaseVertex]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %d)\n", mode, count, type, indices, basevertex ); - func_glDrawElementsBaseVertex( mode, count, type, indices, basevertex ); + funcs->ext.p_glDrawElementsBaseVertex( mode, count, type, indices, basevertex ); } static void WINAPI wine_glDrawElementsIndirect( GLenum mode, GLenum type, GLvoid* indirect ) { - void (*func_glDrawElementsIndirect)( GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glDrawElementsIndirect]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", mode, type, indirect ); - func_glDrawElementsIndirect( mode, type, indirect ); + funcs->ext.p_glDrawElementsIndirect( mode, type, indirect ); } static void WINAPI wine_glDrawElementsInstanced( GLenum mode, GLsizei count, GLenum type, GLvoid* indices, GLsizei primcount ) { - void (*func_glDrawElementsInstanced)( GLenum, GLsizei, GLenum, GLvoid*, GLsizei ) = extension_funcs[EXT_glDrawElementsInstanced]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %d)\n", mode, count, type, indices, primcount ); - func_glDrawElementsInstanced( mode, count, type, indices, primcount ); + funcs->ext.p_glDrawElementsInstanced( mode, count, type, indices, primcount ); } static void WINAPI wine_glDrawElementsInstancedARB( GLenum mode, GLsizei count, GLenum type, GLvoid* indices, GLsizei primcount ) { - void (*func_glDrawElementsInstancedARB)( GLenum, GLsizei, GLenum, GLvoid*, GLsizei ) = extension_funcs[EXT_glDrawElementsInstancedARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %d)\n", mode, count, type, indices, primcount ); - func_glDrawElementsInstancedARB( mode, count, type, indices, primcount ); + funcs->ext.p_glDrawElementsInstancedARB( mode, count, type, indices, primcount ); } static void WINAPI wine_glDrawElementsInstancedBaseInstance( GLenum mode, GLsizei count, GLenum type, void* indices, GLsizei primcount, GLuint baseinstance ) { - void (*func_glDrawElementsInstancedBaseInstance)( GLenum, GLsizei, GLenum, void*, GLsizei, GLuint ) = extension_funcs[EXT_glDrawElementsInstancedBaseInstance]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %d, %d)\n", mode, count, type, indices, primcount, baseinstance ); - func_glDrawElementsInstancedBaseInstance( mode, count, type, indices, primcount, baseinstance ); + funcs->ext.p_glDrawElementsInstancedBaseInstance( mode, count, type, indices, primcount, baseinstance ); } static void WINAPI wine_glDrawElementsInstancedBaseVertex( GLenum mode, GLsizei count, GLenum type, GLvoid* indices, GLsizei primcount, GLint basevertex ) { - void (*func_glDrawElementsInstancedBaseVertex)( GLenum, GLsizei, GLenum, GLvoid*, GLsizei, GLint ) = extension_funcs[EXT_glDrawElementsInstancedBaseVertex]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %d, %d)\n", mode, count, type, indices, primcount, basevertex ); - func_glDrawElementsInstancedBaseVertex( mode, count, type, indices, primcount, basevertex ); + funcs->ext.p_glDrawElementsInstancedBaseVertex( mode, count, type, indices, primcount, basevertex ); } static void WINAPI wine_glDrawElementsInstancedBaseVertexBaseInstance( GLenum mode, GLsizei count, GLenum type, void* indices, GLsizei primcount, GLint basevertex, GLuint baseinstance ) { - void (*func_glDrawElementsInstancedBaseVertexBaseInstance)( GLenum, GLsizei, GLenum, void*, GLsizei, GLint, GLuint ) = extension_funcs[EXT_glDrawElementsInstancedBaseVertexBaseInstance]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %d, %d, %d)\n", mode, count, type, indices, primcount, basevertex, baseinstance ); - func_glDrawElementsInstancedBaseVertexBaseInstance( mode, count, type, indices, primcount, basevertex, baseinstance ); + funcs->ext.p_glDrawElementsInstancedBaseVertexBaseInstance( mode, count, type, indices, primcount, basevertex, baseinstance ); } static void WINAPI wine_glDrawElementsInstancedEXT( GLenum mode, GLsizei count, GLenum type, GLvoid* indices, GLsizei primcount ) { - void (*func_glDrawElementsInstancedEXT)( GLenum, GLsizei, GLenum, GLvoid*, GLsizei ) = extension_funcs[EXT_glDrawElementsInstancedEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %d)\n", mode, count, type, indices, primcount ); - func_glDrawElementsInstancedEXT( mode, count, type, indices, primcount ); + funcs->ext.p_glDrawElementsInstancedEXT( mode, count, type, indices, primcount ); } static void WINAPI wine_glDrawMeshArraysSUN( GLenum mode, GLint first, GLsizei count, GLsizei width ) { - void (*func_glDrawMeshArraysSUN)( GLenum, GLint, GLsizei, GLsizei ) = extension_funcs[EXT_glDrawMeshArraysSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", mode, first, count, width ); - func_glDrawMeshArraysSUN( mode, first, count, width ); + funcs->ext.p_glDrawMeshArraysSUN( mode, first, count, width ); } static void WINAPI wine_glDrawRangeElementArrayAPPLE( GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count ) { - void (*func_glDrawRangeElementArrayAPPLE)( GLenum, GLuint, GLuint, GLint, GLsizei ) = extension_funcs[EXT_glDrawRangeElementArrayAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", mode, start, end, first, count ); - func_glDrawRangeElementArrayAPPLE( mode, start, end, first, count ); + funcs->ext.p_glDrawRangeElementArrayAPPLE( mode, start, end, first, count ); } static void WINAPI wine_glDrawRangeElementArrayATI( GLenum mode, GLuint start, GLuint end, GLsizei count ) { - void (*func_glDrawRangeElementArrayATI)( GLenum, GLuint, GLuint, GLsizei ) = extension_funcs[EXT_glDrawRangeElementArrayATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", mode, start, end, count ); - func_glDrawRangeElementArrayATI( mode, start, end, count ); + funcs->ext.p_glDrawRangeElementArrayATI( mode, start, end, count ); } static void WINAPI wine_glDrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, GLvoid* indices ) { - void (*func_glDrawRangeElements)( GLenum, GLuint, GLuint, GLsizei, GLenum, GLvoid* ) = extension_funcs[EXT_glDrawRangeElements]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %p)\n", mode, start, end, count, type, indices ); - func_glDrawRangeElements( mode, start, end, count, type, indices ); + funcs->ext.p_glDrawRangeElements( mode, start, end, count, type, indices ); } static void WINAPI wine_glDrawRangeElementsBaseVertex( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, GLvoid* indices, GLint basevertex ) { - void (*func_glDrawRangeElementsBaseVertex)( GLenum, GLuint, GLuint, GLsizei, GLenum, GLvoid*, GLint ) = extension_funcs[EXT_glDrawRangeElementsBaseVertex]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %p, %d)\n", mode, start, end, count, type, indices, basevertex ); - func_glDrawRangeElementsBaseVertex( mode, start, end, count, type, indices, basevertex ); + funcs->ext.p_glDrawRangeElementsBaseVertex( mode, start, end, count, type, indices, basevertex ); } static void WINAPI wine_glDrawRangeElementsEXT( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, GLvoid* indices ) { - void (*func_glDrawRangeElementsEXT)( GLenum, GLuint, GLuint, GLsizei, GLenum, GLvoid* ) = extension_funcs[EXT_glDrawRangeElementsEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %p)\n", mode, start, end, count, type, indices ); - func_glDrawRangeElementsEXT( mode, start, end, count, type, indices ); + funcs->ext.p_glDrawRangeElementsEXT( mode, start, end, count, type, indices ); } static void WINAPI wine_glDrawTransformFeedback( GLenum mode, GLuint id ) { - void (*func_glDrawTransformFeedback)( GLenum, GLuint ) = extension_funcs[EXT_glDrawTransformFeedback]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", mode, id ); - func_glDrawTransformFeedback( mode, id ); + funcs->ext.p_glDrawTransformFeedback( mode, id ); } static void WINAPI wine_glDrawTransformFeedbackInstanced( GLenum mode, GLuint id, GLsizei primcount ) { - void (*func_glDrawTransformFeedbackInstanced)( GLenum, GLuint, GLsizei ) = extension_funcs[EXT_glDrawTransformFeedbackInstanced]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", mode, id, primcount ); - func_glDrawTransformFeedbackInstanced( mode, id, primcount ); + funcs->ext.p_glDrawTransformFeedbackInstanced( mode, id, primcount ); } static void WINAPI wine_glDrawTransformFeedbackNV( GLenum mode, GLuint id ) { - void (*func_glDrawTransformFeedbackNV)( GLenum, GLuint ) = extension_funcs[EXT_glDrawTransformFeedbackNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", mode, id ); - func_glDrawTransformFeedbackNV( mode, id ); + funcs->ext.p_glDrawTransformFeedbackNV( mode, id ); } static void WINAPI wine_glDrawTransformFeedbackStream( GLenum mode, GLuint id, GLuint stream ) { - void (*func_glDrawTransformFeedbackStream)( GLenum, GLuint, GLuint ) = extension_funcs[EXT_glDrawTransformFeedbackStream]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", mode, id, stream ); - func_glDrawTransformFeedbackStream( mode, id, stream ); + funcs->ext.p_glDrawTransformFeedbackStream( mode, id, stream ); } static void WINAPI wine_glDrawTransformFeedbackStreamInstanced( GLenum mode, GLuint id, GLuint stream, GLsizei primcount ) { - void (*func_glDrawTransformFeedbackStreamInstanced)( GLenum, GLuint, GLuint, GLsizei ) = extension_funcs[EXT_glDrawTransformFeedbackStreamInstanced]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", mode, id, stream, primcount ); - func_glDrawTransformFeedbackStreamInstanced( mode, id, stream, primcount ); + funcs->ext.p_glDrawTransformFeedbackStreamInstanced( mode, id, stream, primcount ); } static void WINAPI wine_glEdgeFlagFormatNV( GLsizei stride ) { - void (*func_glEdgeFlagFormatNV)( GLsizei ) = extension_funcs[EXT_glEdgeFlagFormatNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", stride ); - func_glEdgeFlagFormatNV( stride ); + funcs->ext.p_glEdgeFlagFormatNV( stride ); } static void WINAPI wine_glEdgeFlagPointerEXT( GLsizei stride, GLsizei count, GLboolean* pointer ) { - void (*func_glEdgeFlagPointerEXT)( GLsizei, GLsizei, GLboolean* ) = extension_funcs[EXT_glEdgeFlagPointerEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", stride, count, pointer ); - func_glEdgeFlagPointerEXT( stride, count, pointer ); + funcs->ext.p_glEdgeFlagPointerEXT( stride, count, pointer ); } static void WINAPI wine_glEdgeFlagPointerListIBM( GLint stride, GLboolean** pointer, GLint ptrstride ) { - void (*func_glEdgeFlagPointerListIBM)( GLint, GLboolean**, GLint ) = extension_funcs[EXT_glEdgeFlagPointerListIBM]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %d)\n", stride, pointer, ptrstride ); - func_glEdgeFlagPointerListIBM( stride, pointer, ptrstride ); + funcs->ext.p_glEdgeFlagPointerListIBM( stride, pointer, ptrstride ); } static void WINAPI wine_glElementPointerAPPLE( GLenum type, GLvoid* pointer ) { - void (*func_glElementPointerAPPLE)( GLenum, GLvoid* ) = extension_funcs[EXT_glElementPointerAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", type, pointer ); - func_glElementPointerAPPLE( type, pointer ); + funcs->ext.p_glElementPointerAPPLE( type, pointer ); } static void WINAPI wine_glElementPointerATI( GLenum type, GLvoid* pointer ) { - void (*func_glElementPointerATI)( GLenum, GLvoid* ) = extension_funcs[EXT_glElementPointerATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", type, pointer ); - func_glElementPointerATI( type, pointer ); + funcs->ext.p_glElementPointerATI( type, pointer ); } static void WINAPI wine_glEnableClientStateIndexedEXT( GLenum array, GLuint index ) { - void (*func_glEnableClientStateIndexedEXT)( GLenum, GLuint ) = extension_funcs[EXT_glEnableClientStateIndexedEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", array, index ); - func_glEnableClientStateIndexedEXT( array, index ); + funcs->ext.p_glEnableClientStateIndexedEXT( array, index ); } static void WINAPI wine_glEnableIndexedEXT( GLenum target, GLuint index ) { - void (*func_glEnableIndexedEXT)( GLenum, GLuint ) = extension_funcs[EXT_glEnableIndexedEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, index ); - func_glEnableIndexedEXT( target, index ); + funcs->ext.p_glEnableIndexedEXT( target, index ); } static void WINAPI wine_glEnableVariantClientStateEXT( GLuint id ) { - void (*func_glEnableVariantClientStateEXT)( GLuint ) = extension_funcs[EXT_glEnableVariantClientStateEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", id ); - func_glEnableVariantClientStateEXT( id ); + funcs->ext.p_glEnableVariantClientStateEXT( id ); } static void WINAPI wine_glEnableVertexAttribAPPLE( GLuint index, GLenum pname ) { - void (*func_glEnableVertexAttribAPPLE)( GLuint, GLenum ) = extension_funcs[EXT_glEnableVertexAttribAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", index, pname ); - func_glEnableVertexAttribAPPLE( index, pname ); + funcs->ext.p_glEnableVertexAttribAPPLE( index, pname ); } static void WINAPI wine_glEnableVertexAttribArray( GLuint index ) { - void (*func_glEnableVertexAttribArray)( GLuint ) = extension_funcs[EXT_glEnableVertexAttribArray]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", index ); - func_glEnableVertexAttribArray( index ); + funcs->ext.p_glEnableVertexAttribArray( index ); } static void WINAPI wine_glEnableVertexAttribArrayARB( GLuint index ) { - void (*func_glEnableVertexAttribArrayARB)( GLuint ) = extension_funcs[EXT_glEnableVertexAttribArrayARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", index ); - func_glEnableVertexAttribArrayARB( index ); + funcs->ext.p_glEnableVertexAttribArrayARB( index ); } static void WINAPI wine_glEnablei( GLenum target, GLuint index ) { - void (*func_glEnablei)( GLenum, GLuint ) = extension_funcs[EXT_glEnablei]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, index ); - func_glEnablei( target, index ); + funcs->ext.p_glEnablei( target, index ); } static void WINAPI wine_glEndConditionalRender( void ) { - void (*func_glEndConditionalRender)( void ) = extension_funcs[EXT_glEndConditionalRender]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glEndConditionalRender( ); + funcs->ext.p_glEndConditionalRender( ); } static void WINAPI wine_glEndConditionalRenderNV( void ) { - void (*func_glEndConditionalRenderNV)( void ) = extension_funcs[EXT_glEndConditionalRenderNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glEndConditionalRenderNV( ); + funcs->ext.p_glEndConditionalRenderNV( ); } static void WINAPI wine_glEndFragmentShaderATI( void ) { - void (*func_glEndFragmentShaderATI)( void ) = extension_funcs[EXT_glEndFragmentShaderATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glEndFragmentShaderATI( ); + funcs->ext.p_glEndFragmentShaderATI( ); } static void WINAPI wine_glEndOcclusionQueryNV( void ) { - void (*func_glEndOcclusionQueryNV)( void ) = extension_funcs[EXT_glEndOcclusionQueryNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glEndOcclusionQueryNV( ); + funcs->ext.p_glEndOcclusionQueryNV( ); } static void WINAPI wine_glEndPerfMonitorAMD( GLuint monitor ) { - void (*func_glEndPerfMonitorAMD)( GLuint ) = extension_funcs[EXT_glEndPerfMonitorAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", monitor ); - func_glEndPerfMonitorAMD( monitor ); + funcs->ext.p_glEndPerfMonitorAMD( monitor ); } static void WINAPI wine_glEndQuery( GLenum target ) { - void (*func_glEndQuery)( GLenum ) = extension_funcs[EXT_glEndQuery]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", target ); - func_glEndQuery( target ); + funcs->ext.p_glEndQuery( target ); } static void WINAPI wine_glEndQueryARB( GLenum target ) { - void (*func_glEndQueryARB)( GLenum ) = extension_funcs[EXT_glEndQueryARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", target ); - func_glEndQueryARB( target ); + funcs->ext.p_glEndQueryARB( target ); } static void WINAPI wine_glEndQueryIndexed( GLenum target, GLuint index ) { - void (*func_glEndQueryIndexed)( GLenum, GLuint ) = extension_funcs[EXT_glEndQueryIndexed]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, index ); - func_glEndQueryIndexed( target, index ); + funcs->ext.p_glEndQueryIndexed( target, index ); } static void WINAPI wine_glEndTransformFeedback( void ) { - void (*func_glEndTransformFeedback)( void ) = extension_funcs[EXT_glEndTransformFeedback]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glEndTransformFeedback( ); + funcs->ext.p_glEndTransformFeedback( ); } static void WINAPI wine_glEndTransformFeedbackEXT( void ) { - void (*func_glEndTransformFeedbackEXT)( void ) = extension_funcs[EXT_glEndTransformFeedbackEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glEndTransformFeedbackEXT( ); + funcs->ext.p_glEndTransformFeedbackEXT( ); } static void WINAPI wine_glEndTransformFeedbackNV( void ) { - void (*func_glEndTransformFeedbackNV)( void ) = extension_funcs[EXT_glEndTransformFeedbackNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glEndTransformFeedbackNV( ); + funcs->ext.p_glEndTransformFeedbackNV( ); } static void WINAPI wine_glEndVertexShaderEXT( void ) { - void (*func_glEndVertexShaderEXT)( void ) = extension_funcs[EXT_glEndVertexShaderEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glEndVertexShaderEXT( ); + funcs->ext.p_glEndVertexShaderEXT( ); } static void WINAPI wine_glEndVideoCaptureNV( GLuint video_capture_slot ) { - void (*func_glEndVideoCaptureNV)( GLuint ) = extension_funcs[EXT_glEndVideoCaptureNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", video_capture_slot ); - func_glEndVideoCaptureNV( video_capture_slot ); + funcs->ext.p_glEndVideoCaptureNV( video_capture_slot ); } static void WINAPI wine_glEvalMapsNV( GLenum target, GLenum mode ) { - void (*func_glEvalMapsNV)( GLenum, GLenum ) = extension_funcs[EXT_glEvalMapsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, mode ); - func_glEvalMapsNV( target, mode ); + funcs->ext.p_glEvalMapsNV( target, mode ); } static void WINAPI wine_glExecuteProgramNV( GLenum target, GLuint id, GLfloat* params ) { - void (*func_glExecuteProgramNV)( GLenum, GLuint, GLfloat* ) = extension_funcs[EXT_glExecuteProgramNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, id, params ); - func_glExecuteProgramNV( target, id, params ); + funcs->ext.p_glExecuteProgramNV( target, id, params ); } static void WINAPI wine_glExtractComponentEXT( GLuint res, GLuint src, GLuint num ) { - void (*func_glExtractComponentEXT)( GLuint, GLuint, GLuint ) = extension_funcs[EXT_glExtractComponentEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", res, src, num ); - func_glExtractComponentEXT( res, src, num ); + funcs->ext.p_glExtractComponentEXT( res, src, num ); } static GLvoid* WINAPI wine_glFenceSync( GLenum condition, GLbitfield flags ) { - GLvoid* (*func_glFenceSync)( GLenum, GLbitfield ) = extension_funcs[EXT_glFenceSync]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", condition, flags ); - return func_glFenceSync( condition, flags ); + return funcs->ext.p_glFenceSync( condition, flags ); } static void WINAPI wine_glFinalCombinerInputNV( GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage ) { - void (*func_glFinalCombinerInputNV)( GLenum, GLenum, GLenum, GLenum ) = extension_funcs[EXT_glFinalCombinerInputNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", variable, input, mapping, componentUsage ); - func_glFinalCombinerInputNV( variable, input, mapping, componentUsage ); + funcs->ext.p_glFinalCombinerInputNV( variable, input, mapping, componentUsage ); } static GLint WINAPI wine_glFinishAsyncSGIX( GLuint* markerp ) { - GLint (*func_glFinishAsyncSGIX)( GLuint* ) = extension_funcs[EXT_glFinishAsyncSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", markerp ); - return func_glFinishAsyncSGIX( markerp ); + return funcs->ext.p_glFinishAsyncSGIX( markerp ); } static void WINAPI wine_glFinishFenceAPPLE( GLuint fence ) { - void (*func_glFinishFenceAPPLE)( GLuint ) = extension_funcs[EXT_glFinishFenceAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", fence ); - func_glFinishFenceAPPLE( fence ); + funcs->ext.p_glFinishFenceAPPLE( fence ); } static void WINAPI wine_glFinishFenceNV( GLuint fence ) { - void (*func_glFinishFenceNV)( GLuint ) = extension_funcs[EXT_glFinishFenceNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", fence ); - func_glFinishFenceNV( fence ); + funcs->ext.p_glFinishFenceNV( fence ); } static void WINAPI wine_glFinishObjectAPPLE( GLenum object, GLint name ) { - void (*func_glFinishObjectAPPLE)( GLenum, GLint ) = extension_funcs[EXT_glFinishObjectAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", object, name ); - func_glFinishObjectAPPLE( object, name ); + funcs->ext.p_glFinishObjectAPPLE( object, name ); } static void WINAPI wine_glFinishTextureSUNX( void ) { - void (*func_glFinishTextureSUNX)( void ) = extension_funcs[EXT_glFinishTextureSUNX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glFinishTextureSUNX( ); + funcs->ext.p_glFinishTextureSUNX( ); } static void WINAPI wine_glFlushMappedBufferRange( GLenum target, INT_PTR offset, INT_PTR length ) { - void (*func_glFlushMappedBufferRange)( GLenum, INT_PTR, INT_PTR ) = extension_funcs[EXT_glFlushMappedBufferRange]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %ld, %ld)\n", target, offset, length ); - func_glFlushMappedBufferRange( target, offset, length ); + funcs->ext.p_glFlushMappedBufferRange( target, offset, length ); } static void WINAPI wine_glFlushMappedBufferRangeAPPLE( GLenum target, INT_PTR offset, INT_PTR size ) { - void (*func_glFlushMappedBufferRangeAPPLE)( GLenum, INT_PTR, INT_PTR ) = extension_funcs[EXT_glFlushMappedBufferRangeAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %ld, %ld)\n", target, offset, size ); - func_glFlushMappedBufferRangeAPPLE( target, offset, size ); + funcs->ext.p_glFlushMappedBufferRangeAPPLE( target, offset, size ); } static void WINAPI wine_glFlushMappedNamedBufferRangeEXT( GLuint buffer, INT_PTR offset, INT_PTR length ) { - void (*func_glFlushMappedNamedBufferRangeEXT)( GLuint, INT_PTR, INT_PTR ) = extension_funcs[EXT_glFlushMappedNamedBufferRangeEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %ld, %ld)\n", buffer, offset, length ); - func_glFlushMappedNamedBufferRangeEXT( buffer, offset, length ); + funcs->ext.p_glFlushMappedNamedBufferRangeEXT( buffer, offset, length ); } static void WINAPI wine_glFlushPixelDataRangeNV( GLenum target ) { - void (*func_glFlushPixelDataRangeNV)( GLenum ) = extension_funcs[EXT_glFlushPixelDataRangeNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", target ); - func_glFlushPixelDataRangeNV( target ); + funcs->ext.p_glFlushPixelDataRangeNV( target ); } static void WINAPI wine_glFlushRasterSGIX( void ) { - void (*func_glFlushRasterSGIX)( void ) = extension_funcs[EXT_glFlushRasterSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glFlushRasterSGIX( ); + funcs->ext.p_glFlushRasterSGIX( ); } static void WINAPI wine_glFlushVertexArrayRangeAPPLE( GLsizei length, GLvoid* pointer ) { - void (*func_glFlushVertexArrayRangeAPPLE)( GLsizei, GLvoid* ) = extension_funcs[EXT_glFlushVertexArrayRangeAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", length, pointer ); - func_glFlushVertexArrayRangeAPPLE( length, pointer ); + funcs->ext.p_glFlushVertexArrayRangeAPPLE( length, pointer ); } static void WINAPI wine_glFlushVertexArrayRangeNV( void ) { - void (*func_glFlushVertexArrayRangeNV)( void ) = extension_funcs[EXT_glFlushVertexArrayRangeNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glFlushVertexArrayRangeNV( ); + funcs->ext.p_glFlushVertexArrayRangeNV( ); } static void WINAPI wine_glFogCoordFormatNV( GLenum type, GLsizei stride ) { - void (*func_glFogCoordFormatNV)( GLenum, GLsizei ) = extension_funcs[EXT_glFogCoordFormatNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", type, stride ); - func_glFogCoordFormatNV( type, stride ); + funcs->ext.p_glFogCoordFormatNV( type, stride ); } static void WINAPI wine_glFogCoordPointer( GLenum type, GLsizei stride, GLvoid* pointer ) { - void (*func_glFogCoordPointer)( GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glFogCoordPointer]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", type, stride, pointer ); - func_glFogCoordPointer( type, stride, pointer ); + funcs->ext.p_glFogCoordPointer( type, stride, pointer ); } static void WINAPI wine_glFogCoordPointerEXT( GLenum type, GLsizei stride, GLvoid* pointer ) { - void (*func_glFogCoordPointerEXT)( GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glFogCoordPointerEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", type, stride, pointer ); - func_glFogCoordPointerEXT( type, stride, pointer ); + funcs->ext.p_glFogCoordPointerEXT( type, stride, pointer ); } static void WINAPI wine_glFogCoordPointerListIBM( GLenum type, GLint stride, GLvoid** pointer, GLint ptrstride ) { - void (*func_glFogCoordPointerListIBM)( GLenum, GLint, GLvoid**, GLint ) = extension_funcs[EXT_glFogCoordPointerListIBM]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %d)\n", type, stride, pointer, ptrstride ); - func_glFogCoordPointerListIBM( type, stride, pointer, ptrstride ); + funcs->ext.p_glFogCoordPointerListIBM( type, stride, pointer, ptrstride ); } static void WINAPI wine_glFogCoordd( GLdouble coord ) { - void (*func_glFogCoordd)( GLdouble ) = extension_funcs[EXT_glFogCoordd]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f)\n", coord ); - func_glFogCoordd( coord ); + funcs->ext.p_glFogCoordd( coord ); } static void WINAPI wine_glFogCoorddEXT( GLdouble coord ) { - void (*func_glFogCoorddEXT)( GLdouble ) = extension_funcs[EXT_glFogCoorddEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f)\n", coord ); - func_glFogCoorddEXT( coord ); + funcs->ext.p_glFogCoorddEXT( coord ); } static void WINAPI wine_glFogCoorddv( GLdouble* coord ) { - void (*func_glFogCoorddv)( GLdouble* ) = extension_funcs[EXT_glFogCoorddv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", coord ); - func_glFogCoorddv( coord ); + funcs->ext.p_glFogCoorddv( coord ); } static void WINAPI wine_glFogCoorddvEXT( GLdouble* coord ) { - void (*func_glFogCoorddvEXT)( GLdouble* ) = extension_funcs[EXT_glFogCoorddvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", coord ); - func_glFogCoorddvEXT( coord ); + funcs->ext.p_glFogCoorddvEXT( coord ); } static void WINAPI wine_glFogCoordf( GLfloat coord ) { - void (*func_glFogCoordf)( GLfloat ) = extension_funcs[EXT_glFogCoordf]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f)\n", coord ); - func_glFogCoordf( coord ); + funcs->ext.p_glFogCoordf( coord ); } static void WINAPI wine_glFogCoordfEXT( GLfloat coord ) { - void (*func_glFogCoordfEXT)( GLfloat ) = extension_funcs[EXT_glFogCoordfEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f)\n", coord ); - func_glFogCoordfEXT( coord ); + funcs->ext.p_glFogCoordfEXT( coord ); } static void WINAPI wine_glFogCoordfv( GLfloat* coord ) { - void (*func_glFogCoordfv)( GLfloat* ) = extension_funcs[EXT_glFogCoordfv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", coord ); - func_glFogCoordfv( coord ); + funcs->ext.p_glFogCoordfv( coord ); } static void WINAPI wine_glFogCoordfvEXT( GLfloat* coord ) { - void (*func_glFogCoordfvEXT)( GLfloat* ) = extension_funcs[EXT_glFogCoordfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", coord ); - func_glFogCoordfvEXT( coord ); + funcs->ext.p_glFogCoordfvEXT( coord ); } static void WINAPI wine_glFogCoordhNV( unsigned short fog ) { - void (*func_glFogCoordhNV)( unsigned short ) = extension_funcs[EXT_glFogCoordhNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", fog ); - func_glFogCoordhNV( fog ); + funcs->ext.p_glFogCoordhNV( fog ); } static void WINAPI wine_glFogCoordhvNV( unsigned short* fog ) { - void (*func_glFogCoordhvNV)( unsigned short* ) = extension_funcs[EXT_glFogCoordhvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", fog ); - func_glFogCoordhvNV( fog ); + funcs->ext.p_glFogCoordhvNV( fog ); } static void WINAPI wine_glFogFuncSGIS( GLsizei n, GLfloat* points ) { - void (*func_glFogFuncSGIS)( GLsizei, GLfloat* ) = extension_funcs[EXT_glFogFuncSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, points ); - func_glFogFuncSGIS( n, points ); + funcs->ext.p_glFogFuncSGIS( n, points ); } static void WINAPI wine_glFragmentColorMaterialSGIX( GLenum face, GLenum mode ) { - void (*func_glFragmentColorMaterialSGIX)( GLenum, GLenum ) = extension_funcs[EXT_glFragmentColorMaterialSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", face, mode ); - func_glFragmentColorMaterialSGIX( face, mode ); + funcs->ext.p_glFragmentColorMaterialSGIX( face, mode ); } static void WINAPI wine_glFragmentLightModelfSGIX( GLenum pname, GLfloat param ) { - void (*func_glFragmentLightModelfSGIX)( GLenum, GLfloat ) = extension_funcs[EXT_glFragmentLightModelfSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", pname, param ); - func_glFragmentLightModelfSGIX( pname, param ); + funcs->ext.p_glFragmentLightModelfSGIX( pname, param ); } static void WINAPI wine_glFragmentLightModelfvSGIX( GLenum pname, GLfloat* params ) { - void (*func_glFragmentLightModelfvSGIX)( GLenum, GLfloat* ) = extension_funcs[EXT_glFragmentLightModelfvSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glFragmentLightModelfvSGIX( pname, params ); + funcs->ext.p_glFragmentLightModelfvSGIX( pname, params ); } static void WINAPI wine_glFragmentLightModeliSGIX( GLenum pname, GLint param ) { - void (*func_glFragmentLightModeliSGIX)( GLenum, GLint ) = extension_funcs[EXT_glFragmentLightModeliSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", pname, param ); - func_glFragmentLightModeliSGIX( pname, param ); + funcs->ext.p_glFragmentLightModeliSGIX( pname, param ); } static void WINAPI wine_glFragmentLightModelivSGIX( GLenum pname, GLint* params ) { - void (*func_glFragmentLightModelivSGIX)( GLenum, GLint* ) = extension_funcs[EXT_glFragmentLightModelivSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glFragmentLightModelivSGIX( pname, params ); + funcs->ext.p_glFragmentLightModelivSGIX( pname, params ); } static void WINAPI wine_glFragmentLightfSGIX( GLenum light, GLenum pname, GLfloat param ) { - void (*func_glFragmentLightfSGIX)( GLenum, GLenum, GLfloat ) = extension_funcs[EXT_glFragmentLightfSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f)\n", light, pname, param ); - func_glFragmentLightfSGIX( light, pname, param ); + funcs->ext.p_glFragmentLightfSGIX( light, pname, param ); } static void WINAPI wine_glFragmentLightfvSGIX( GLenum light, GLenum pname, GLfloat* params ) { - void (*func_glFragmentLightfvSGIX)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glFragmentLightfvSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", light, pname, params ); - func_glFragmentLightfvSGIX( light, pname, params ); + funcs->ext.p_glFragmentLightfvSGIX( light, pname, params ); } static void WINAPI wine_glFragmentLightiSGIX( GLenum light, GLenum pname, GLint param ) { - void (*func_glFragmentLightiSGIX)( GLenum, GLenum, GLint ) = extension_funcs[EXT_glFragmentLightiSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", light, pname, param ); - func_glFragmentLightiSGIX( light, pname, param ); + funcs->ext.p_glFragmentLightiSGIX( light, pname, param ); } static void WINAPI wine_glFragmentLightivSGIX( GLenum light, GLenum pname, GLint* params ) { - void (*func_glFragmentLightivSGIX)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glFragmentLightivSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", light, pname, params ); - func_glFragmentLightivSGIX( light, pname, params ); + funcs->ext.p_glFragmentLightivSGIX( light, pname, params ); } static void WINAPI wine_glFragmentMaterialfSGIX( GLenum face, GLenum pname, GLfloat param ) { - void (*func_glFragmentMaterialfSGIX)( GLenum, GLenum, GLfloat ) = extension_funcs[EXT_glFragmentMaterialfSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f)\n", face, pname, param ); - func_glFragmentMaterialfSGIX( face, pname, param ); + funcs->ext.p_glFragmentMaterialfSGIX( face, pname, param ); } static void WINAPI wine_glFragmentMaterialfvSGIX( GLenum face, GLenum pname, GLfloat* params ) { - void (*func_glFragmentMaterialfvSGIX)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glFragmentMaterialfvSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", face, pname, params ); - func_glFragmentMaterialfvSGIX( face, pname, params ); + funcs->ext.p_glFragmentMaterialfvSGIX( face, pname, params ); } static void WINAPI wine_glFragmentMaterialiSGIX( GLenum face, GLenum pname, GLint param ) { - void (*func_glFragmentMaterialiSGIX)( GLenum, GLenum, GLint ) = extension_funcs[EXT_glFragmentMaterialiSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", face, pname, param ); - func_glFragmentMaterialiSGIX( face, pname, param ); + funcs->ext.p_glFragmentMaterialiSGIX( face, pname, param ); } static void WINAPI wine_glFragmentMaterialivSGIX( GLenum face, GLenum pname, GLint* params ) { - void (*func_glFragmentMaterialivSGIX)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glFragmentMaterialivSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", face, pname, params ); - func_glFragmentMaterialivSGIX( face, pname, params ); + funcs->ext.p_glFragmentMaterialivSGIX( face, pname, params ); } static void WINAPI wine_glFrameTerminatorGREMEDY( void ) { - void (*func_glFrameTerminatorGREMEDY)( void ) = extension_funcs[EXT_glFrameTerminatorGREMEDY]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glFrameTerminatorGREMEDY( ); + funcs->ext.p_glFrameTerminatorGREMEDY( ); } static void WINAPI wine_glFrameZoomSGIX( GLint factor ) { - void (*func_glFrameZoomSGIX)( GLint ) = extension_funcs[EXT_glFrameZoomSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", factor ); - func_glFrameZoomSGIX( factor ); + funcs->ext.p_glFrameZoomSGIX( factor ); } static void WINAPI wine_glFramebufferDrawBufferEXT( GLuint framebuffer, GLenum mode ) { - void (*func_glFramebufferDrawBufferEXT)( GLuint, GLenum ) = extension_funcs[EXT_glFramebufferDrawBufferEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", framebuffer, mode ); - func_glFramebufferDrawBufferEXT( framebuffer, mode ); + funcs->ext.p_glFramebufferDrawBufferEXT( framebuffer, mode ); } static void WINAPI wine_glFramebufferDrawBuffersEXT( GLuint framebuffer, GLsizei n, GLenum* bufs ) { - void (*func_glFramebufferDrawBuffersEXT)( GLuint, GLsizei, GLenum* ) = extension_funcs[EXT_glFramebufferDrawBuffersEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", framebuffer, n, bufs ); - func_glFramebufferDrawBuffersEXT( framebuffer, n, bufs ); + funcs->ext.p_glFramebufferDrawBuffersEXT( framebuffer, n, bufs ); } static void WINAPI wine_glFramebufferReadBufferEXT( GLuint framebuffer, GLenum mode ) { - void (*func_glFramebufferReadBufferEXT)( GLuint, GLenum ) = extension_funcs[EXT_glFramebufferReadBufferEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", framebuffer, mode ); - func_glFramebufferReadBufferEXT( framebuffer, mode ); + funcs->ext.p_glFramebufferReadBufferEXT( framebuffer, mode ); } static void WINAPI wine_glFramebufferRenderbuffer( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) { - void (*func_glFramebufferRenderbuffer)( GLenum, GLenum, GLenum, GLuint ) = extension_funcs[EXT_glFramebufferRenderbuffer]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", target, attachment, renderbuffertarget, renderbuffer ); - func_glFramebufferRenderbuffer( target, attachment, renderbuffertarget, renderbuffer ); + funcs->ext.p_glFramebufferRenderbuffer( target, attachment, renderbuffertarget, renderbuffer ); } static void WINAPI wine_glFramebufferRenderbufferEXT( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) { - void (*func_glFramebufferRenderbufferEXT)( GLenum, GLenum, GLenum, GLuint ) = extension_funcs[EXT_glFramebufferRenderbufferEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", target, attachment, renderbuffertarget, renderbuffer ); - func_glFramebufferRenderbufferEXT( target, attachment, renderbuffertarget, renderbuffer ); + funcs->ext.p_glFramebufferRenderbufferEXT( target, attachment, renderbuffertarget, renderbuffer ); } static void WINAPI wine_glFramebufferTexture( GLenum target, GLenum attachment, GLuint texture, GLint level ) { - void (*func_glFramebufferTexture)( GLenum, GLenum, GLuint, GLint ) = extension_funcs[EXT_glFramebufferTexture]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", target, attachment, texture, level ); - func_glFramebufferTexture( target, attachment, texture, level ); + funcs->ext.p_glFramebufferTexture( target, attachment, texture, level ); } static void WINAPI wine_glFramebufferTexture1D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) { - void (*func_glFramebufferTexture1D)( GLenum, GLenum, GLenum, GLuint, GLint ) = extension_funcs[EXT_glFramebufferTexture1D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, attachment, textarget, texture, level ); - func_glFramebufferTexture1D( target, attachment, textarget, texture, level ); + funcs->ext.p_glFramebufferTexture1D( target, attachment, textarget, texture, level ); } static void WINAPI wine_glFramebufferTexture1DEXT( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) { - void (*func_glFramebufferTexture1DEXT)( GLenum, GLenum, GLenum, GLuint, GLint ) = extension_funcs[EXT_glFramebufferTexture1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, attachment, textarget, texture, level ); - func_glFramebufferTexture1DEXT( target, attachment, textarget, texture, level ); + funcs->ext.p_glFramebufferTexture1DEXT( target, attachment, textarget, texture, level ); } static void WINAPI wine_glFramebufferTexture2D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) { - void (*func_glFramebufferTexture2D)( GLenum, GLenum, GLenum, GLuint, GLint ) = extension_funcs[EXT_glFramebufferTexture2D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, attachment, textarget, texture, level ); - func_glFramebufferTexture2D( target, attachment, textarget, texture, level ); + funcs->ext.p_glFramebufferTexture2D( target, attachment, textarget, texture, level ); } static void WINAPI wine_glFramebufferTexture2DEXT( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) { - void (*func_glFramebufferTexture2DEXT)( GLenum, GLenum, GLenum, GLuint, GLint ) = extension_funcs[EXT_glFramebufferTexture2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, attachment, textarget, texture, level ); - func_glFramebufferTexture2DEXT( target, attachment, textarget, texture, level ); + funcs->ext.p_glFramebufferTexture2DEXT( target, attachment, textarget, texture, level ); } static void WINAPI wine_glFramebufferTexture3D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset ) { - void (*func_glFramebufferTexture3D)( GLenum, GLenum, GLenum, GLuint, GLint, GLint ) = extension_funcs[EXT_glFramebufferTexture3D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", target, attachment, textarget, texture, level, zoffset ); - func_glFramebufferTexture3D( target, attachment, textarget, texture, level, zoffset ); + funcs->ext.p_glFramebufferTexture3D( target, attachment, textarget, texture, level, zoffset ); } static void WINAPI wine_glFramebufferTexture3DEXT( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset ) { - void (*func_glFramebufferTexture3DEXT)( GLenum, GLenum, GLenum, GLuint, GLint, GLint ) = extension_funcs[EXT_glFramebufferTexture3DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", target, attachment, textarget, texture, level, zoffset ); - func_glFramebufferTexture3DEXT( target, attachment, textarget, texture, level, zoffset ); + funcs->ext.p_glFramebufferTexture3DEXT( target, attachment, textarget, texture, level, zoffset ); } static void WINAPI wine_glFramebufferTextureARB( GLenum target, GLenum attachment, GLuint texture, GLint level ) { - void (*func_glFramebufferTextureARB)( GLenum, GLenum, GLuint, GLint ) = extension_funcs[EXT_glFramebufferTextureARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", target, attachment, texture, level ); - func_glFramebufferTextureARB( target, attachment, texture, level ); + funcs->ext.p_glFramebufferTextureARB( target, attachment, texture, level ); } static void WINAPI wine_glFramebufferTextureEXT( GLenum target, GLenum attachment, GLuint texture, GLint level ) { - void (*func_glFramebufferTextureEXT)( GLenum, GLenum, GLuint, GLint ) = extension_funcs[EXT_glFramebufferTextureEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", target, attachment, texture, level ); - func_glFramebufferTextureEXT( target, attachment, texture, level ); + funcs->ext.p_glFramebufferTextureEXT( target, attachment, texture, level ); } static void WINAPI wine_glFramebufferTextureFaceARB( GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face ) { - void (*func_glFramebufferTextureFaceARB)( GLenum, GLenum, GLuint, GLint, GLenum ) = extension_funcs[EXT_glFramebufferTextureFaceARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, attachment, texture, level, face ); - func_glFramebufferTextureFaceARB( target, attachment, texture, level, face ); + funcs->ext.p_glFramebufferTextureFaceARB( target, attachment, texture, level, face ); } static void WINAPI wine_glFramebufferTextureFaceEXT( GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face ) { - void (*func_glFramebufferTextureFaceEXT)( GLenum, GLenum, GLuint, GLint, GLenum ) = extension_funcs[EXT_glFramebufferTextureFaceEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, attachment, texture, level, face ); - func_glFramebufferTextureFaceEXT( target, attachment, texture, level, face ); + funcs->ext.p_glFramebufferTextureFaceEXT( target, attachment, texture, level, face ); } static void WINAPI wine_glFramebufferTextureLayer( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer ) { - void (*func_glFramebufferTextureLayer)( GLenum, GLenum, GLuint, GLint, GLint ) = extension_funcs[EXT_glFramebufferTextureLayer]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, attachment, texture, level, layer ); - func_glFramebufferTextureLayer( target, attachment, texture, level, layer ); + funcs->ext.p_glFramebufferTextureLayer( target, attachment, texture, level, layer ); } static void WINAPI wine_glFramebufferTextureLayerARB( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer ) { - void (*func_glFramebufferTextureLayerARB)( GLenum, GLenum, GLuint, GLint, GLint ) = extension_funcs[EXT_glFramebufferTextureLayerARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, attachment, texture, level, layer ); - func_glFramebufferTextureLayerARB( target, attachment, texture, level, layer ); + funcs->ext.p_glFramebufferTextureLayerARB( target, attachment, texture, level, layer ); } static void WINAPI wine_glFramebufferTextureLayerEXT( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer ) { - void (*func_glFramebufferTextureLayerEXT)( GLenum, GLenum, GLuint, GLint, GLint ) = extension_funcs[EXT_glFramebufferTextureLayerEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, attachment, texture, level, layer ); - func_glFramebufferTextureLayerEXT( target, attachment, texture, level, layer ); + funcs->ext.p_glFramebufferTextureLayerEXT( target, attachment, texture, level, layer ); } static void WINAPI wine_glFreeObjectBufferATI( GLuint buffer ) { - void (*func_glFreeObjectBufferATI)( GLuint ) = extension_funcs[EXT_glFreeObjectBufferATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", buffer ); - func_glFreeObjectBufferATI( buffer ); + funcs->ext.p_glFreeObjectBufferATI( buffer ); } static GLuint WINAPI wine_glGenAsyncMarkersSGIX( GLsizei range ) { - GLuint (*func_glGenAsyncMarkersSGIX)( GLsizei ) = extension_funcs[EXT_glGenAsyncMarkersSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", range ); - return func_glGenAsyncMarkersSGIX( range ); + return funcs->ext.p_glGenAsyncMarkersSGIX( range ); } static void WINAPI wine_glGenBuffers( GLsizei n, GLuint* buffers ) { - void (*func_glGenBuffers)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenBuffers]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, buffers ); - func_glGenBuffers( n, buffers ); + funcs->ext.p_glGenBuffers( n, buffers ); } static void WINAPI wine_glGenBuffersARB( GLsizei n, GLuint* buffers ) { - void (*func_glGenBuffersARB)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenBuffersARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, buffers ); - func_glGenBuffersARB( n, buffers ); + funcs->ext.p_glGenBuffersARB( n, buffers ); } static void WINAPI wine_glGenFencesAPPLE( GLsizei n, GLuint* fences ) { - void (*func_glGenFencesAPPLE)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenFencesAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, fences ); - func_glGenFencesAPPLE( n, fences ); + funcs->ext.p_glGenFencesAPPLE( n, fences ); } static void WINAPI wine_glGenFencesNV( GLsizei n, GLuint* fences ) { - void (*func_glGenFencesNV)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenFencesNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, fences ); - func_glGenFencesNV( n, fences ); + funcs->ext.p_glGenFencesNV( n, fences ); } static GLuint WINAPI wine_glGenFragmentShadersATI( GLuint range ) { - GLuint (*func_glGenFragmentShadersATI)( GLuint ) = extension_funcs[EXT_glGenFragmentShadersATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", range ); - return func_glGenFragmentShadersATI( range ); + return funcs->ext.p_glGenFragmentShadersATI( range ); } static void WINAPI wine_glGenFramebuffers( GLsizei n, GLuint* framebuffers ) { - void (*func_glGenFramebuffers)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenFramebuffers]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, framebuffers ); - func_glGenFramebuffers( n, framebuffers ); + funcs->ext.p_glGenFramebuffers( n, framebuffers ); } static void WINAPI wine_glGenFramebuffersEXT( GLsizei n, GLuint* framebuffers ) { - void (*func_glGenFramebuffersEXT)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenFramebuffersEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, framebuffers ); - func_glGenFramebuffersEXT( n, framebuffers ); + funcs->ext.p_glGenFramebuffersEXT( n, framebuffers ); } static void WINAPI wine_glGenNamesAMD( GLenum identifier, GLuint num, GLuint* names ) { - void (*func_glGenNamesAMD)( GLenum, GLuint, GLuint* ) = extension_funcs[EXT_glGenNamesAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", identifier, num, names ); - func_glGenNamesAMD( identifier, num, names ); + funcs->ext.p_glGenNamesAMD( identifier, num, names ); } static void WINAPI wine_glGenOcclusionQueriesNV( GLsizei n, GLuint* ids ) { - void (*func_glGenOcclusionQueriesNV)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenOcclusionQueriesNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, ids ); - func_glGenOcclusionQueriesNV( n, ids ); + funcs->ext.p_glGenOcclusionQueriesNV( n, ids ); } static GLuint WINAPI wine_glGenPathsNV( GLsizei range ) { - GLuint (*func_glGenPathsNV)( GLsizei ) = extension_funcs[EXT_glGenPathsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", range ); - return func_glGenPathsNV( range ); + return funcs->ext.p_glGenPathsNV( range ); } static void WINAPI wine_glGenPerfMonitorsAMD( GLsizei n, GLuint* monitors ) { - void (*func_glGenPerfMonitorsAMD)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenPerfMonitorsAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, monitors ); - func_glGenPerfMonitorsAMD( n, monitors ); + funcs->ext.p_glGenPerfMonitorsAMD( n, monitors ); } static void WINAPI wine_glGenProgramPipelines( GLsizei n, GLuint* pipelines ) { - void (*func_glGenProgramPipelines)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenProgramPipelines]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, pipelines ); - func_glGenProgramPipelines( n, pipelines ); + funcs->ext.p_glGenProgramPipelines( n, pipelines ); } static void WINAPI wine_glGenProgramsARB( GLsizei n, GLuint* programs ) { - void (*func_glGenProgramsARB)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenProgramsARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, programs ); - func_glGenProgramsARB( n, programs ); + funcs->ext.p_glGenProgramsARB( n, programs ); } static void WINAPI wine_glGenProgramsNV( GLsizei n, GLuint* programs ) { - void (*func_glGenProgramsNV)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenProgramsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, programs ); - func_glGenProgramsNV( n, programs ); + funcs->ext.p_glGenProgramsNV( n, programs ); } static void WINAPI wine_glGenQueries( GLsizei n, GLuint* ids ) { - void (*func_glGenQueries)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenQueries]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, ids ); - func_glGenQueries( n, ids ); + funcs->ext.p_glGenQueries( n, ids ); } static void WINAPI wine_glGenQueriesARB( GLsizei n, GLuint* ids ) { - void (*func_glGenQueriesARB)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenQueriesARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, ids ); - func_glGenQueriesARB( n, ids ); + funcs->ext.p_glGenQueriesARB( n, ids ); } static void WINAPI wine_glGenRenderbuffers( GLsizei n, GLuint* renderbuffers ) { - void (*func_glGenRenderbuffers)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenRenderbuffers]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, renderbuffers ); - func_glGenRenderbuffers( n, renderbuffers ); + funcs->ext.p_glGenRenderbuffers( n, renderbuffers ); } static void WINAPI wine_glGenRenderbuffersEXT( GLsizei n, GLuint* renderbuffers ) { - void (*func_glGenRenderbuffersEXT)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenRenderbuffersEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, renderbuffers ); - func_glGenRenderbuffersEXT( n, renderbuffers ); + funcs->ext.p_glGenRenderbuffersEXT( n, renderbuffers ); } static void WINAPI wine_glGenSamplers( GLsizei count, GLuint* samplers ) { - void (*func_glGenSamplers)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenSamplers]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", count, samplers ); - func_glGenSamplers( count, samplers ); + funcs->ext.p_glGenSamplers( count, samplers ); } static GLuint WINAPI wine_glGenSymbolsEXT( GLenum datatype, GLenum storagetype, GLenum range, GLuint components ) { - GLuint (*func_glGenSymbolsEXT)( GLenum, GLenum, GLenum, GLuint ) = extension_funcs[EXT_glGenSymbolsEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", datatype, storagetype, range, components ); - return func_glGenSymbolsEXT( datatype, storagetype, range, components ); + return funcs->ext.p_glGenSymbolsEXT( datatype, storagetype, range, components ); } static void WINAPI wine_glGenTexturesEXT( GLsizei n, GLuint* textures ) { - void (*func_glGenTexturesEXT)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenTexturesEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, textures ); - func_glGenTexturesEXT( n, textures ); + funcs->ext.p_glGenTexturesEXT( n, textures ); } static void WINAPI wine_glGenTransformFeedbacks( GLsizei n, GLuint* ids ) { - void (*func_glGenTransformFeedbacks)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenTransformFeedbacks]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, ids ); - func_glGenTransformFeedbacks( n, ids ); + funcs->ext.p_glGenTransformFeedbacks( n, ids ); } static void WINAPI wine_glGenTransformFeedbacksNV( GLsizei n, GLuint* ids ) { - void (*func_glGenTransformFeedbacksNV)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenTransformFeedbacksNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, ids ); - func_glGenTransformFeedbacksNV( n, ids ); + funcs->ext.p_glGenTransformFeedbacksNV( n, ids ); } static void WINAPI wine_glGenVertexArrays( GLsizei n, GLuint* arrays ) { - void (*func_glGenVertexArrays)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenVertexArrays]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, arrays ); - func_glGenVertexArrays( n, arrays ); + funcs->ext.p_glGenVertexArrays( n, arrays ); } static void WINAPI wine_glGenVertexArraysAPPLE( GLsizei n, GLuint* arrays ) { - void (*func_glGenVertexArraysAPPLE)( GLsizei, GLuint* ) = extension_funcs[EXT_glGenVertexArraysAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, arrays ); - func_glGenVertexArraysAPPLE( n, arrays ); + funcs->ext.p_glGenVertexArraysAPPLE( n, arrays ); } static GLuint WINAPI wine_glGenVertexShadersEXT( GLuint range ) { - GLuint (*func_glGenVertexShadersEXT)( GLuint ) = extension_funcs[EXT_glGenVertexShadersEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", range ); - return func_glGenVertexShadersEXT( range ); + return funcs->ext.p_glGenVertexShadersEXT( range ); } static void WINAPI wine_glGenerateMipmap( GLenum target ) { - void (*func_glGenerateMipmap)( GLenum ) = extension_funcs[EXT_glGenerateMipmap]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", target ); - func_glGenerateMipmap( target ); + funcs->ext.p_glGenerateMipmap( target ); } static void WINAPI wine_glGenerateMipmapEXT( GLenum target ) { - void (*func_glGenerateMipmapEXT)( GLenum ) = extension_funcs[EXT_glGenerateMipmapEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", target ); - func_glGenerateMipmapEXT( target ); + funcs->ext.p_glGenerateMipmapEXT( target ); } static void WINAPI wine_glGenerateMultiTexMipmapEXT( GLenum texunit, GLenum target ) { - void (*func_glGenerateMultiTexMipmapEXT)( GLenum, GLenum ) = extension_funcs[EXT_glGenerateMultiTexMipmapEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", texunit, target ); - func_glGenerateMultiTexMipmapEXT( texunit, target ); + funcs->ext.p_glGenerateMultiTexMipmapEXT( texunit, target ); } static void WINAPI wine_glGenerateTextureMipmapEXT( GLuint texture, GLenum target ) { - void (*func_glGenerateTextureMipmapEXT)( GLuint, GLenum ) = extension_funcs[EXT_glGenerateTextureMipmapEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", texture, target ); - func_glGenerateTextureMipmapEXT( texture, target ); + funcs->ext.p_glGenerateTextureMipmapEXT( texture, target ); } static void WINAPI wine_glGetActiveAtomicCounterBufferiv( GLuint program, GLuint bufferIndex, GLenum pname, GLint* params ) { - void (*func_glGetActiveAtomicCounterBufferiv)( GLuint, GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetActiveAtomicCounterBufferiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, bufferIndex, pname, params ); - func_glGetActiveAtomicCounterBufferiv( program, bufferIndex, pname, params ); + funcs->ext.p_glGetActiveAtomicCounterBufferiv( program, bufferIndex, pname, params ); } static void WINAPI wine_glGetActiveAttrib( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* type, char* name ) { - void (*func_glGetActiveAttrib)( GLuint, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, char* ) = extension_funcs[EXT_glGetActiveAttrib]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %p, %p, %p)\n", program, index, bufSize, length, size, type, name ); - func_glGetActiveAttrib( program, index, bufSize, length, size, type, name ); + funcs->ext.p_glGetActiveAttrib( program, index, bufSize, length, size, type, name ); } static void WINAPI wine_glGetActiveAttribARB( unsigned int programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, char* name ) { - void (*func_glGetActiveAttribARB)( unsigned int, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, char* ) = extension_funcs[EXT_glGetActiveAttribARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %p, %p, %p)\n", programObj, index, maxLength, length, size, type, name ); - func_glGetActiveAttribARB( programObj, index, maxLength, length, size, type, name ); + funcs->ext.p_glGetActiveAttribARB( programObj, index, maxLength, length, size, type, name ); } static void WINAPI wine_glGetActiveSubroutineName( GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei* length, char* name ) { - void (*func_glGetActiveSubroutineName)( GLuint, GLenum, GLuint, GLsizei, GLsizei*, char* ) = extension_funcs[EXT_glGetActiveSubroutineName]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p, %p)\n", program, shadertype, index, bufsize, length, name ); - func_glGetActiveSubroutineName( program, shadertype, index, bufsize, length, name ); + funcs->ext.p_glGetActiveSubroutineName( program, shadertype, index, bufsize, length, name ); } static void WINAPI wine_glGetActiveSubroutineUniformName( GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei* length, char* name ) { - void (*func_glGetActiveSubroutineUniformName)( GLuint, GLenum, GLuint, GLsizei, GLsizei*, char* ) = extension_funcs[EXT_glGetActiveSubroutineUniformName]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p, %p)\n", program, shadertype, index, bufsize, length, name ); - func_glGetActiveSubroutineUniformName( program, shadertype, index, bufsize, length, name ); + funcs->ext.p_glGetActiveSubroutineUniformName( program, shadertype, index, bufsize, length, name ); } static void WINAPI wine_glGetActiveSubroutineUniformiv( GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values ) { - void (*func_glGetActiveSubroutineUniformiv)( GLuint, GLenum, GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetActiveSubroutineUniformiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, shadertype, index, pname, values ); - func_glGetActiveSubroutineUniformiv( program, shadertype, index, pname, values ); + funcs->ext.p_glGetActiveSubroutineUniformiv( program, shadertype, index, pname, values ); } static void WINAPI wine_glGetActiveUniform( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* type, char* name ) { - void (*func_glGetActiveUniform)( GLuint, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, char* ) = extension_funcs[EXT_glGetActiveUniform]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %p, %p, %p)\n", program, index, bufSize, length, size, type, name ); - func_glGetActiveUniform( program, index, bufSize, length, size, type, name ); + funcs->ext.p_glGetActiveUniform( program, index, bufSize, length, size, type, name ); } static void WINAPI wine_glGetActiveUniformARB( unsigned int programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, char* name ) { - void (*func_glGetActiveUniformARB)( unsigned int, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, char* ) = extension_funcs[EXT_glGetActiveUniformARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %p, %p, %p)\n", programObj, index, maxLength, length, size, type, name ); - func_glGetActiveUniformARB( programObj, index, maxLength, length, size, type, name ); + funcs->ext.p_glGetActiveUniformARB( programObj, index, maxLength, length, size, type, name ); } static void WINAPI wine_glGetActiveUniformBlockName( GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, char* uniformBlockName ) { - void (*func_glGetActiveUniformBlockName)( GLuint, GLuint, GLsizei, GLsizei*, char* ) = extension_funcs[EXT_glGetActiveUniformBlockName]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %p)\n", program, uniformBlockIndex, bufSize, length, uniformBlockName ); - func_glGetActiveUniformBlockName( program, uniformBlockIndex, bufSize, length, uniformBlockName ); + funcs->ext.p_glGetActiveUniformBlockName( program, uniformBlockIndex, bufSize, length, uniformBlockName ); } static void WINAPI wine_glGetActiveUniformBlockiv( GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params ) { - void (*func_glGetActiveUniformBlockiv)( GLuint, GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetActiveUniformBlockiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, uniformBlockIndex, pname, params ); - func_glGetActiveUniformBlockiv( program, uniformBlockIndex, pname, params ); + funcs->ext.p_glGetActiveUniformBlockiv( program, uniformBlockIndex, pname, params ); } static void WINAPI wine_glGetActiveUniformName( GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, char* uniformName ) { - void (*func_glGetActiveUniformName)( GLuint, GLuint, GLsizei, GLsizei*, char* ) = extension_funcs[EXT_glGetActiveUniformName]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %p)\n", program, uniformIndex, bufSize, length, uniformName ); - func_glGetActiveUniformName( program, uniformIndex, bufSize, length, uniformName ); + funcs->ext.p_glGetActiveUniformName( program, uniformIndex, bufSize, length, uniformName ); } static void WINAPI wine_glGetActiveUniformsiv( GLuint program, GLsizei uniformCount, GLuint* uniformIndices, GLenum pname, GLint* params ) { - void (*func_glGetActiveUniformsiv)( GLuint, GLsizei, GLuint*, GLenum, GLint* ) = extension_funcs[EXT_glGetActiveUniformsiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %d, %p)\n", program, uniformCount, uniformIndices, pname, params ); - func_glGetActiveUniformsiv( program, uniformCount, uniformIndices, pname, params ); + funcs->ext.p_glGetActiveUniformsiv( program, uniformCount, uniformIndices, pname, params ); } static void WINAPI wine_glGetActiveVaryingNV( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, char* name ) { - void (*func_glGetActiveVaryingNV)( GLuint, GLuint, GLsizei, GLsizei*, GLsizei*, GLenum*, char* ) = extension_funcs[EXT_glGetActiveVaryingNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %p, %p, %p)\n", program, index, bufSize, length, size, type, name ); - func_glGetActiveVaryingNV( program, index, bufSize, length, size, type, name ); + funcs->ext.p_glGetActiveVaryingNV( program, index, bufSize, length, size, type, name ); } static void WINAPI wine_glGetArrayObjectfvATI( GLenum array, GLenum pname, GLfloat* params ) { - void (*func_glGetArrayObjectfvATI)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetArrayObjectfvATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", array, pname, params ); - func_glGetArrayObjectfvATI( array, pname, params ); + funcs->ext.p_glGetArrayObjectfvATI( array, pname, params ); } static void WINAPI wine_glGetArrayObjectivATI( GLenum array, GLenum pname, GLint* params ) { - void (*func_glGetArrayObjectivATI)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetArrayObjectivATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", array, pname, params ); - func_glGetArrayObjectivATI( array, pname, params ); + funcs->ext.p_glGetArrayObjectivATI( array, pname, params ); } static void WINAPI wine_glGetAttachedObjectsARB( unsigned int containerObj, GLsizei maxCount, GLsizei* count, unsigned int* obj ) { - void (*func_glGetAttachedObjectsARB)( unsigned int, GLsizei, GLsizei*, unsigned int* ) = extension_funcs[EXT_glGetAttachedObjectsARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", containerObj, maxCount, count, obj ); - func_glGetAttachedObjectsARB( containerObj, maxCount, count, obj ); + funcs->ext.p_glGetAttachedObjectsARB( containerObj, maxCount, count, obj ); } static void WINAPI wine_glGetAttachedShaders( GLuint program, GLsizei maxCount, GLsizei* count, GLuint* obj ) { - void (*func_glGetAttachedShaders)( GLuint, GLsizei, GLsizei*, GLuint* ) = extension_funcs[EXT_glGetAttachedShaders]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", program, maxCount, count, obj ); - func_glGetAttachedShaders( program, maxCount, count, obj ); + funcs->ext.p_glGetAttachedShaders( program, maxCount, count, obj ); } static GLint WINAPI wine_glGetAttribLocation( GLuint program, char* name ) { - GLint (*func_glGetAttribLocation)( GLuint, char* ) = extension_funcs[EXT_glGetAttribLocation]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", program, name ); - return func_glGetAttribLocation( program, name ); + return funcs->ext.p_glGetAttribLocation( program, name ); } static GLint WINAPI wine_glGetAttribLocationARB( unsigned int programObj, char* name ) { - GLint (*func_glGetAttribLocationARB)( unsigned int, char* ) = extension_funcs[EXT_glGetAttribLocationARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", programObj, name ); - return func_glGetAttribLocationARB( programObj, name ); + return funcs->ext.p_glGetAttribLocationARB( programObj, name ); } static void WINAPI wine_glGetBooleanIndexedvEXT( GLenum target, GLuint index, GLboolean* data ) { - void (*func_glGetBooleanIndexedvEXT)( GLenum, GLuint, GLboolean* ) = extension_funcs[EXT_glGetBooleanIndexedvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, data ); - func_glGetBooleanIndexedvEXT( target, index, data ); + funcs->ext.p_glGetBooleanIndexedvEXT( target, index, data ); } static void WINAPI wine_glGetBooleani_v( GLenum target, GLuint index, GLboolean* data ) { - void (*func_glGetBooleani_v)( GLenum, GLuint, GLboolean* ) = extension_funcs[EXT_glGetBooleani_v]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, data ); - func_glGetBooleani_v( target, index, data ); + funcs->ext.p_glGetBooleani_v( target, index, data ); } static void WINAPI wine_glGetBufferParameteri64v( GLenum target, GLenum pname, INT64* params ) { - void (*func_glGetBufferParameteri64v)( GLenum, GLenum, INT64* ) = extension_funcs[EXT_glGetBufferParameteri64v]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetBufferParameteri64v( target, pname, params ); + funcs->ext.p_glGetBufferParameteri64v( target, pname, params ); } static void WINAPI wine_glGetBufferParameteriv( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetBufferParameteriv)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetBufferParameteriv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetBufferParameteriv( target, pname, params ); + funcs->ext.p_glGetBufferParameteriv( target, pname, params ); } static void WINAPI wine_glGetBufferParameterivARB( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetBufferParameterivARB)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetBufferParameterivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetBufferParameterivARB( target, pname, params ); + funcs->ext.p_glGetBufferParameterivARB( target, pname, params ); } static void WINAPI wine_glGetBufferParameterui64vNV( GLenum target, GLenum pname, UINT64* params ) { - void (*func_glGetBufferParameterui64vNV)( GLenum, GLenum, UINT64* ) = extension_funcs[EXT_glGetBufferParameterui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetBufferParameterui64vNV( target, pname, params ); + funcs->ext.p_glGetBufferParameterui64vNV( target, pname, params ); } static void WINAPI wine_glGetBufferPointerv( GLenum target, GLenum pname, GLvoid** params ) { - void (*func_glGetBufferPointerv)( GLenum, GLenum, GLvoid** ) = extension_funcs[EXT_glGetBufferPointerv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetBufferPointerv( target, pname, params ); + funcs->ext.p_glGetBufferPointerv( target, pname, params ); } static void WINAPI wine_glGetBufferPointervARB( GLenum target, GLenum pname, GLvoid** params ) { - void (*func_glGetBufferPointervARB)( GLenum, GLenum, GLvoid** ) = extension_funcs[EXT_glGetBufferPointervARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetBufferPointervARB( target, pname, params ); + funcs->ext.p_glGetBufferPointervARB( target, pname, params ); } static void WINAPI wine_glGetBufferSubData( GLenum target, INT_PTR offset, INT_PTR size, GLvoid* data ) { - void (*func_glGetBufferSubData)( GLenum, INT_PTR, INT_PTR, GLvoid* ) = extension_funcs[EXT_glGetBufferSubData]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %ld, %ld, %p)\n", target, offset, size, data ); - func_glGetBufferSubData( target, offset, size, data ); + funcs->ext.p_glGetBufferSubData( target, offset, size, data ); } static void WINAPI wine_glGetBufferSubDataARB( GLenum target, INT_PTR offset, INT_PTR size, GLvoid* data ) { - void (*func_glGetBufferSubDataARB)( GLenum, INT_PTR, INT_PTR, GLvoid* ) = extension_funcs[EXT_glGetBufferSubDataARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %ld, %ld, %p)\n", target, offset, size, data ); - func_glGetBufferSubDataARB( target, offset, size, data ); + funcs->ext.p_glGetBufferSubDataARB( target, offset, size, data ); } static void WINAPI wine_glGetColorTable( GLenum target, GLenum format, GLenum type, GLvoid* table ) { - void (*func_glGetColorTable)( GLenum, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glGetColorTable]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, format, type, table ); - func_glGetColorTable( target, format, type, table ); + funcs->ext.p_glGetColorTable( target, format, type, table ); } static void WINAPI wine_glGetColorTableEXT( GLenum target, GLenum format, GLenum type, GLvoid* data ) { - void (*func_glGetColorTableEXT)( GLenum, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glGetColorTableEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, format, type, data ); - func_glGetColorTableEXT( target, format, type, data ); + funcs->ext.p_glGetColorTableEXT( target, format, type, data ); } static void WINAPI wine_glGetColorTableParameterfv( GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glGetColorTableParameterfv)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetColorTableParameterfv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetColorTableParameterfv( target, pname, params ); + funcs->ext.p_glGetColorTableParameterfv( target, pname, params ); } static void WINAPI wine_glGetColorTableParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glGetColorTableParameterfvEXT)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetColorTableParameterfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetColorTableParameterfvEXT( target, pname, params ); + funcs->ext.p_glGetColorTableParameterfvEXT( target, pname, params ); } static void WINAPI wine_glGetColorTableParameterfvSGI( GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glGetColorTableParameterfvSGI)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetColorTableParameterfvSGI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetColorTableParameterfvSGI( target, pname, params ); + funcs->ext.p_glGetColorTableParameterfvSGI( target, pname, params ); } static void WINAPI wine_glGetColorTableParameteriv( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetColorTableParameteriv)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetColorTableParameteriv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetColorTableParameteriv( target, pname, params ); + funcs->ext.p_glGetColorTableParameteriv( target, pname, params ); } static void WINAPI wine_glGetColorTableParameterivEXT( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetColorTableParameterivEXT)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetColorTableParameterivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetColorTableParameterivEXT( target, pname, params ); + funcs->ext.p_glGetColorTableParameterivEXT( target, pname, params ); } static void WINAPI wine_glGetColorTableParameterivSGI( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetColorTableParameterivSGI)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetColorTableParameterivSGI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetColorTableParameterivSGI( target, pname, params ); + funcs->ext.p_glGetColorTableParameterivSGI( target, pname, params ); } static void WINAPI wine_glGetColorTableSGI( GLenum target, GLenum format, GLenum type, GLvoid* table ) { - void (*func_glGetColorTableSGI)( GLenum, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glGetColorTableSGI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, format, type, table ); - func_glGetColorTableSGI( target, format, type, table ); + funcs->ext.p_glGetColorTableSGI( target, format, type, table ); } static void WINAPI wine_glGetCombinerInputParameterfvNV( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat* params ) { - void (*func_glGetCombinerInputParameterfvNV)( GLenum, GLenum, GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetCombinerInputParameterfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", stage, portion, variable, pname, params ); - func_glGetCombinerInputParameterfvNV( stage, portion, variable, pname, params ); + funcs->ext.p_glGetCombinerInputParameterfvNV( stage, portion, variable, pname, params ); } static void WINAPI wine_glGetCombinerInputParameterivNV( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint* params ) { - void (*func_glGetCombinerInputParameterivNV)( GLenum, GLenum, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetCombinerInputParameterivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", stage, portion, variable, pname, params ); - func_glGetCombinerInputParameterivNV( stage, portion, variable, pname, params ); + funcs->ext.p_glGetCombinerInputParameterivNV( stage, portion, variable, pname, params ); } static void WINAPI wine_glGetCombinerOutputParameterfvNV( GLenum stage, GLenum portion, GLenum pname, GLfloat* params ) { - void (*func_glGetCombinerOutputParameterfvNV)( GLenum, GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetCombinerOutputParameterfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", stage, portion, pname, params ); - func_glGetCombinerOutputParameterfvNV( stage, portion, pname, params ); + funcs->ext.p_glGetCombinerOutputParameterfvNV( stage, portion, pname, params ); } static void WINAPI wine_glGetCombinerOutputParameterivNV( GLenum stage, GLenum portion, GLenum pname, GLint* params ) { - void (*func_glGetCombinerOutputParameterivNV)( GLenum, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetCombinerOutputParameterivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", stage, portion, pname, params ); - func_glGetCombinerOutputParameterivNV( stage, portion, pname, params ); + funcs->ext.p_glGetCombinerOutputParameterivNV( stage, portion, pname, params ); } static void WINAPI wine_glGetCombinerStageParameterfvNV( GLenum stage, GLenum pname, GLfloat* params ) { - void (*func_glGetCombinerStageParameterfvNV)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetCombinerStageParameterfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", stage, pname, params ); - func_glGetCombinerStageParameterfvNV( stage, pname, params ); + funcs->ext.p_glGetCombinerStageParameterfvNV( stage, pname, params ); } static void WINAPI wine_glGetCompressedMultiTexImageEXT( GLenum texunit, GLenum target, GLint lod, GLvoid* img ) { - void (*func_glGetCompressedMultiTexImageEXT)( GLenum, GLenum, GLint, GLvoid* ) = extension_funcs[EXT_glGetCompressedMultiTexImageEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, target, lod, img ); - func_glGetCompressedMultiTexImageEXT( texunit, target, lod, img ); + funcs->ext.p_glGetCompressedMultiTexImageEXT( texunit, target, lod, img ); } static void WINAPI wine_glGetCompressedTexImage( GLenum target, GLint level, GLvoid* img ) { - void (*func_glGetCompressedTexImage)( GLenum, GLint, GLvoid* ) = extension_funcs[EXT_glGetCompressedTexImage]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, level, img ); - func_glGetCompressedTexImage( target, level, img ); + funcs->ext.p_glGetCompressedTexImage( target, level, img ); } static void WINAPI wine_glGetCompressedTexImageARB( GLenum target, GLint level, GLvoid* img ) { - void (*func_glGetCompressedTexImageARB)( GLenum, GLint, GLvoid* ) = extension_funcs[EXT_glGetCompressedTexImageARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, level, img ); - func_glGetCompressedTexImageARB( target, level, img ); + funcs->ext.p_glGetCompressedTexImageARB( target, level, img ); } static void WINAPI wine_glGetCompressedTextureImageEXT( GLuint texture, GLenum target, GLint lod, GLvoid* img ) { - void (*func_glGetCompressedTextureImageEXT)( GLuint, GLenum, GLint, GLvoid* ) = extension_funcs[EXT_glGetCompressedTextureImageEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texture, target, lod, img ); - func_glGetCompressedTextureImageEXT( texture, target, lod, img ); + funcs->ext.p_glGetCompressedTextureImageEXT( texture, target, lod, img ); } static void WINAPI wine_glGetConvolutionFilter( GLenum target, GLenum format, GLenum type, GLvoid* image ) { - void (*func_glGetConvolutionFilter)( GLenum, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glGetConvolutionFilter]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, format, type, image ); - func_glGetConvolutionFilter( target, format, type, image ); + funcs->ext.p_glGetConvolutionFilter( target, format, type, image ); } static void WINAPI wine_glGetConvolutionFilterEXT( GLenum target, GLenum format, GLenum type, GLvoid* image ) { - void (*func_glGetConvolutionFilterEXT)( GLenum, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glGetConvolutionFilterEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, format, type, image ); - func_glGetConvolutionFilterEXT( target, format, type, image ); + funcs->ext.p_glGetConvolutionFilterEXT( target, format, type, image ); } static void WINAPI wine_glGetConvolutionParameterfv( GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glGetConvolutionParameterfv)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetConvolutionParameterfv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetConvolutionParameterfv( target, pname, params ); + funcs->ext.p_glGetConvolutionParameterfv( target, pname, params ); } static void WINAPI wine_glGetConvolutionParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glGetConvolutionParameterfvEXT)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetConvolutionParameterfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetConvolutionParameterfvEXT( target, pname, params ); + funcs->ext.p_glGetConvolutionParameterfvEXT( target, pname, params ); } static void WINAPI wine_glGetConvolutionParameteriv( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetConvolutionParameteriv)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetConvolutionParameteriv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetConvolutionParameteriv( target, pname, params ); + funcs->ext.p_glGetConvolutionParameteriv( target, pname, params ); } static void WINAPI wine_glGetConvolutionParameterivEXT( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetConvolutionParameterivEXT)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetConvolutionParameterivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetConvolutionParameterivEXT( target, pname, params ); + funcs->ext.p_glGetConvolutionParameterivEXT( target, pname, params ); } static GLuint WINAPI wine_glGetDebugMessageLogAMD( GLuint count, GLsizei bufsize, GLenum* categories, GLuint* severities, GLuint* ids, GLsizei* lengths, char* message ) { - GLuint (*func_glGetDebugMessageLogAMD)( GLuint, GLsizei, GLenum*, GLuint*, GLuint*, GLsizei*, char* ) = extension_funcs[EXT_glGetDebugMessageLogAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p, %p, %p, %p)\n", count, bufsize, categories, severities, ids, lengths, message ); - return func_glGetDebugMessageLogAMD( count, bufsize, categories, severities, ids, lengths, message ); + return funcs->ext.p_glGetDebugMessageLogAMD( count, bufsize, categories, severities, ids, lengths, message ); } static GLuint WINAPI wine_glGetDebugMessageLogARB( GLuint count, GLsizei bufsize, GLenum* sources, GLenum* types, GLuint* ids, GLenum* severities, GLsizei* lengths, char* messageLog ) { - GLuint (*func_glGetDebugMessageLogARB)( GLuint, GLsizei, GLenum*, GLenum*, GLuint*, GLenum*, GLsizei*, char* ) = extension_funcs[EXT_glGetDebugMessageLogARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p, %p, %p, %p, %p)\n", count, bufsize, sources, types, ids, severities, lengths, messageLog ); - return func_glGetDebugMessageLogARB( count, bufsize, sources, types, ids, severities, lengths, messageLog ); + return funcs->ext.p_glGetDebugMessageLogARB( count, bufsize, sources, types, ids, severities, lengths, messageLog ); } static void WINAPI wine_glGetDetailTexFuncSGIS( GLenum target, GLfloat* points ) { - void (*func_glGetDetailTexFuncSGIS)( GLenum, GLfloat* ) = extension_funcs[EXT_glGetDetailTexFuncSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, points ); - func_glGetDetailTexFuncSGIS( target, points ); + funcs->ext.p_glGetDetailTexFuncSGIS( target, points ); } static void WINAPI wine_glGetDoubleIndexedvEXT( GLenum target, GLuint index, GLdouble* data ) { - void (*func_glGetDoubleIndexedvEXT)( GLenum, GLuint, GLdouble* ) = extension_funcs[EXT_glGetDoubleIndexedvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, data ); - func_glGetDoubleIndexedvEXT( target, index, data ); + funcs->ext.p_glGetDoubleIndexedvEXT( target, index, data ); } static void WINAPI wine_glGetDoublei_v( GLenum target, GLuint index, GLdouble* data ) { - void (*func_glGetDoublei_v)( GLenum, GLuint, GLdouble* ) = extension_funcs[EXT_glGetDoublei_v]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, data ); - func_glGetDoublei_v( target, index, data ); + funcs->ext.p_glGetDoublei_v( target, index, data ); } static void WINAPI wine_glGetFenceivNV( GLuint fence, GLenum pname, GLint* params ) { - void (*func_glGetFenceivNV)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetFenceivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", fence, pname, params ); - func_glGetFenceivNV( fence, pname, params ); + funcs->ext.p_glGetFenceivNV( fence, pname, params ); } static void WINAPI wine_glGetFinalCombinerInputParameterfvNV( GLenum variable, GLenum pname, GLfloat* params ) { - void (*func_glGetFinalCombinerInputParameterfvNV)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetFinalCombinerInputParameterfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", variable, pname, params ); - func_glGetFinalCombinerInputParameterfvNV( variable, pname, params ); + funcs->ext.p_glGetFinalCombinerInputParameterfvNV( variable, pname, params ); } static void WINAPI wine_glGetFinalCombinerInputParameterivNV( GLenum variable, GLenum pname, GLint* params ) { - void (*func_glGetFinalCombinerInputParameterivNV)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetFinalCombinerInputParameterivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", variable, pname, params ); - func_glGetFinalCombinerInputParameterivNV( variable, pname, params ); + funcs->ext.p_glGetFinalCombinerInputParameterivNV( variable, pname, params ); } static void WINAPI wine_glGetFloatIndexedvEXT( GLenum target, GLuint index, GLfloat* data ) { - void (*func_glGetFloatIndexedvEXT)( GLenum, GLuint, GLfloat* ) = extension_funcs[EXT_glGetFloatIndexedvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, data ); - func_glGetFloatIndexedvEXT( target, index, data ); + funcs->ext.p_glGetFloatIndexedvEXT( target, index, data ); } static void WINAPI wine_glGetFloati_v( GLenum target, GLuint index, GLfloat* data ) { - void (*func_glGetFloati_v)( GLenum, GLuint, GLfloat* ) = extension_funcs[EXT_glGetFloati_v]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, data ); - func_glGetFloati_v( target, index, data ); + funcs->ext.p_glGetFloati_v( target, index, data ); } static void WINAPI wine_glGetFogFuncSGIS( GLfloat* points ) { - void (*func_glGetFogFuncSGIS)( GLfloat* ) = extension_funcs[EXT_glGetFogFuncSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", points ); - func_glGetFogFuncSGIS( points ); + funcs->ext.p_glGetFogFuncSGIS( points ); } static GLint WINAPI wine_glGetFragDataIndex( GLuint program, char* name ) { - GLint (*func_glGetFragDataIndex)( GLuint, char* ) = extension_funcs[EXT_glGetFragDataIndex]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", program, name ); - return func_glGetFragDataIndex( program, name ); + return funcs->ext.p_glGetFragDataIndex( program, name ); } static GLint WINAPI wine_glGetFragDataLocation( GLuint program, char* name ) { - GLint (*func_glGetFragDataLocation)( GLuint, char* ) = extension_funcs[EXT_glGetFragDataLocation]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", program, name ); - return func_glGetFragDataLocation( program, name ); + return funcs->ext.p_glGetFragDataLocation( program, name ); } static GLint WINAPI wine_glGetFragDataLocationEXT( GLuint program, char* name ) { - GLint (*func_glGetFragDataLocationEXT)( GLuint, char* ) = extension_funcs[EXT_glGetFragDataLocationEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", program, name ); - return func_glGetFragDataLocationEXT( program, name ); + return funcs->ext.p_glGetFragDataLocationEXT( program, name ); } static void WINAPI wine_glGetFragmentLightfvSGIX( GLenum light, GLenum pname, GLfloat* params ) { - void (*func_glGetFragmentLightfvSGIX)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetFragmentLightfvSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", light, pname, params ); - func_glGetFragmentLightfvSGIX( light, pname, params ); + funcs->ext.p_glGetFragmentLightfvSGIX( light, pname, params ); } static void WINAPI wine_glGetFragmentLightivSGIX( GLenum light, GLenum pname, GLint* params ) { - void (*func_glGetFragmentLightivSGIX)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetFragmentLightivSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", light, pname, params ); - func_glGetFragmentLightivSGIX( light, pname, params ); + funcs->ext.p_glGetFragmentLightivSGIX( light, pname, params ); } static void WINAPI wine_glGetFragmentMaterialfvSGIX( GLenum face, GLenum pname, GLfloat* params ) { - void (*func_glGetFragmentMaterialfvSGIX)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetFragmentMaterialfvSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", face, pname, params ); - func_glGetFragmentMaterialfvSGIX( face, pname, params ); + funcs->ext.p_glGetFragmentMaterialfvSGIX( face, pname, params ); } static void WINAPI wine_glGetFragmentMaterialivSGIX( GLenum face, GLenum pname, GLint* params ) { - void (*func_glGetFragmentMaterialivSGIX)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetFragmentMaterialivSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", face, pname, params ); - func_glGetFragmentMaterialivSGIX( face, pname, params ); + funcs->ext.p_glGetFragmentMaterialivSGIX( face, pname, params ); } static void WINAPI wine_glGetFramebufferAttachmentParameteriv( GLenum target, GLenum attachment, GLenum pname, GLint* params ) { - void (*func_glGetFramebufferAttachmentParameteriv)( GLenum, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetFramebufferAttachmentParameteriv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, attachment, pname, params ); - func_glGetFramebufferAttachmentParameteriv( target, attachment, pname, params ); + funcs->ext.p_glGetFramebufferAttachmentParameteriv( target, attachment, pname, params ); } static void WINAPI wine_glGetFramebufferAttachmentParameterivEXT( GLenum target, GLenum attachment, GLenum pname, GLint* params ) { - void (*func_glGetFramebufferAttachmentParameterivEXT)( GLenum, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetFramebufferAttachmentParameterivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, attachment, pname, params ); - func_glGetFramebufferAttachmentParameterivEXT( target, attachment, pname, params ); + funcs->ext.p_glGetFramebufferAttachmentParameterivEXT( target, attachment, pname, params ); } static void WINAPI wine_glGetFramebufferParameterivEXT( GLuint framebuffer, GLenum pname, GLint* params ) { - void (*func_glGetFramebufferParameterivEXT)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetFramebufferParameterivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", framebuffer, pname, params ); - func_glGetFramebufferParameterivEXT( framebuffer, pname, params ); + funcs->ext.p_glGetFramebufferParameterivEXT( framebuffer, pname, params ); } static GLenum WINAPI wine_glGetGraphicsResetStatusARB( void ) { - GLenum (*func_glGetGraphicsResetStatusARB)( void ) = extension_funcs[EXT_glGetGraphicsResetStatusARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - return func_glGetGraphicsResetStatusARB( ); + return funcs->ext.p_glGetGraphicsResetStatusARB( ); } static unsigned int WINAPI wine_glGetHandleARB( GLenum pname ) { - unsigned int (*func_glGetHandleARB)( GLenum ) = extension_funcs[EXT_glGetHandleARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", pname ); - return func_glGetHandleARB( pname ); + return funcs->ext.p_glGetHandleARB( pname ); } static void WINAPI wine_glGetHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid* values ) { - void (*func_glGetHistogram)( GLenum, GLboolean, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glGetHistogram]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", target, reset, format, type, values ); - func_glGetHistogram( target, reset, format, type, values ); + funcs->ext.p_glGetHistogram( target, reset, format, type, values ); } static void WINAPI wine_glGetHistogramEXT( GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid* values ) { - void (*func_glGetHistogramEXT)( GLenum, GLboolean, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glGetHistogramEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", target, reset, format, type, values ); - func_glGetHistogramEXT( target, reset, format, type, values ); + funcs->ext.p_glGetHistogramEXT( target, reset, format, type, values ); } static void WINAPI wine_glGetHistogramParameterfv( GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glGetHistogramParameterfv)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetHistogramParameterfv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetHistogramParameterfv( target, pname, params ); + funcs->ext.p_glGetHistogramParameterfv( target, pname, params ); } static void WINAPI wine_glGetHistogramParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glGetHistogramParameterfvEXT)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetHistogramParameterfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetHistogramParameterfvEXT( target, pname, params ); + funcs->ext.p_glGetHistogramParameterfvEXT( target, pname, params ); } static void WINAPI wine_glGetHistogramParameteriv( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetHistogramParameteriv)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetHistogramParameteriv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetHistogramParameteriv( target, pname, params ); + funcs->ext.p_glGetHistogramParameteriv( target, pname, params ); } static void WINAPI wine_glGetHistogramParameterivEXT( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetHistogramParameterivEXT)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetHistogramParameterivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetHistogramParameterivEXT( target, pname, params ); + funcs->ext.p_glGetHistogramParameterivEXT( target, pname, params ); } static UINT64 WINAPI wine_glGetImageHandleNV( GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format ) { - UINT64 (*func_glGetImageHandleNV)( GLuint, GLint, GLboolean, GLint, GLenum ) = extension_funcs[EXT_glGetImageHandleNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", texture, level, layered, layer, format ); - return func_glGetImageHandleNV( texture, level, layered, layer, format ); + return funcs->ext.p_glGetImageHandleNV( texture, level, layered, layer, format ); } static void WINAPI wine_glGetImageTransformParameterfvHP( GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glGetImageTransformParameterfvHP)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetImageTransformParameterfvHP]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetImageTransformParameterfvHP( target, pname, params ); + funcs->ext.p_glGetImageTransformParameterfvHP( target, pname, params ); } static void WINAPI wine_glGetImageTransformParameterivHP( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetImageTransformParameterivHP)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetImageTransformParameterivHP]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetImageTransformParameterivHP( target, pname, params ); + funcs->ext.p_glGetImageTransformParameterivHP( target, pname, params ); } static void WINAPI wine_glGetInfoLogARB( unsigned int obj, GLsizei maxLength, GLsizei* length, char* infoLog ) { - void (*func_glGetInfoLogARB)( unsigned int, GLsizei, GLsizei*, char* ) = extension_funcs[EXT_glGetInfoLogARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", obj, maxLength, length, infoLog ); - func_glGetInfoLogARB( obj, maxLength, length, infoLog ); + funcs->ext.p_glGetInfoLogARB( obj, maxLength, length, infoLog ); } static GLint WINAPI wine_glGetInstrumentsSGIX( void ) { - GLint (*func_glGetInstrumentsSGIX)( void ) = extension_funcs[EXT_glGetInstrumentsSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - return func_glGetInstrumentsSGIX( ); + return funcs->ext.p_glGetInstrumentsSGIX( ); } static void WINAPI wine_glGetInteger64i_v( GLenum target, GLuint index, INT64* data ) { - void (*func_glGetInteger64i_v)( GLenum, GLuint, INT64* ) = extension_funcs[EXT_glGetInteger64i_v]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, data ); - func_glGetInteger64i_v( target, index, data ); + funcs->ext.p_glGetInteger64i_v( target, index, data ); } static void WINAPI wine_glGetInteger64v( GLenum pname, INT64* params ) { - void (*func_glGetInteger64v)( GLenum, INT64* ) = extension_funcs[EXT_glGetInteger64v]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glGetInteger64v( pname, params ); + funcs->ext.p_glGetInteger64v( pname, params ); } static void WINAPI wine_glGetIntegerIndexedvEXT( GLenum target, GLuint index, GLint* data ) { - void (*func_glGetIntegerIndexedvEXT)( GLenum, GLuint, GLint* ) = extension_funcs[EXT_glGetIntegerIndexedvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, data ); - func_glGetIntegerIndexedvEXT( target, index, data ); + funcs->ext.p_glGetIntegerIndexedvEXT( target, index, data ); } static void WINAPI wine_glGetIntegeri_v( GLenum target, GLuint index, GLint* data ) { - void (*func_glGetIntegeri_v)( GLenum, GLuint, GLint* ) = extension_funcs[EXT_glGetIntegeri_v]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, data ); - func_glGetIntegeri_v( target, index, data ); + funcs->ext.p_glGetIntegeri_v( target, index, data ); } static void WINAPI wine_glGetIntegerui64i_vNV( GLenum value, GLuint index, UINT64* result ) { - void (*func_glGetIntegerui64i_vNV)( GLenum, GLuint, UINT64* ) = extension_funcs[EXT_glGetIntegerui64i_vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", value, index, result ); - func_glGetIntegerui64i_vNV( value, index, result ); + funcs->ext.p_glGetIntegerui64i_vNV( value, index, result ); } static void WINAPI wine_glGetIntegerui64vNV( GLenum value, UINT64* result ) { - void (*func_glGetIntegerui64vNV)( GLenum, UINT64* ) = extension_funcs[EXT_glGetIntegerui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", value, result ); - func_glGetIntegerui64vNV( value, result ); + funcs->ext.p_glGetIntegerui64vNV( value, result ); } static void WINAPI wine_glGetInternalformativ( GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params ) { - void (*func_glGetInternalformativ)( GLenum, GLenum, GLenum, GLsizei, GLint* ) = extension_funcs[EXT_glGetInternalformativ]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", target, internalformat, pname, bufSize, params ); - func_glGetInternalformativ( target, internalformat, pname, bufSize, params ); + funcs->ext.p_glGetInternalformativ( target, internalformat, pname, bufSize, params ); } static void WINAPI wine_glGetInvariantBooleanvEXT( GLuint id, GLenum value, GLboolean* data ) { - void (*func_glGetInvariantBooleanvEXT)( GLuint, GLenum, GLboolean* ) = extension_funcs[EXT_glGetInvariantBooleanvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, value, data ); - func_glGetInvariantBooleanvEXT( id, value, data ); + funcs->ext.p_glGetInvariantBooleanvEXT( id, value, data ); } static void WINAPI wine_glGetInvariantFloatvEXT( GLuint id, GLenum value, GLfloat* data ) { - void (*func_glGetInvariantFloatvEXT)( GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glGetInvariantFloatvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, value, data ); - func_glGetInvariantFloatvEXT( id, value, data ); + funcs->ext.p_glGetInvariantFloatvEXT( id, value, data ); } static void WINAPI wine_glGetInvariantIntegervEXT( GLuint id, GLenum value, GLint* data ) { - void (*func_glGetInvariantIntegervEXT)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetInvariantIntegervEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, value, data ); - func_glGetInvariantIntegervEXT( id, value, data ); + funcs->ext.p_glGetInvariantIntegervEXT( id, value, data ); } static void WINAPI wine_glGetListParameterfvSGIX( GLuint list, GLenum pname, GLfloat* params ) { - void (*func_glGetListParameterfvSGIX)( GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glGetListParameterfvSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", list, pname, params ); - func_glGetListParameterfvSGIX( list, pname, params ); + funcs->ext.p_glGetListParameterfvSGIX( list, pname, params ); } static void WINAPI wine_glGetListParameterivSGIX( GLuint list, GLenum pname, GLint* params ) { - void (*func_glGetListParameterivSGIX)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetListParameterivSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", list, pname, params ); - func_glGetListParameterivSGIX( list, pname, params ); + funcs->ext.p_glGetListParameterivSGIX( list, pname, params ); } static void WINAPI wine_glGetLocalConstantBooleanvEXT( GLuint id, GLenum value, GLboolean* data ) { - void (*func_glGetLocalConstantBooleanvEXT)( GLuint, GLenum, GLboolean* ) = extension_funcs[EXT_glGetLocalConstantBooleanvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, value, data ); - func_glGetLocalConstantBooleanvEXT( id, value, data ); + funcs->ext.p_glGetLocalConstantBooleanvEXT( id, value, data ); } static void WINAPI wine_glGetLocalConstantFloatvEXT( GLuint id, GLenum value, GLfloat* data ) { - void (*func_glGetLocalConstantFloatvEXT)( GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glGetLocalConstantFloatvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, value, data ); - func_glGetLocalConstantFloatvEXT( id, value, data ); + funcs->ext.p_glGetLocalConstantFloatvEXT( id, value, data ); } static void WINAPI wine_glGetLocalConstantIntegervEXT( GLuint id, GLenum value, GLint* data ) { - void (*func_glGetLocalConstantIntegervEXT)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetLocalConstantIntegervEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, value, data ); - func_glGetLocalConstantIntegervEXT( id, value, data ); + funcs->ext.p_glGetLocalConstantIntegervEXT( id, value, data ); } static void WINAPI wine_glGetMapAttribParameterfvNV( GLenum target, GLuint index, GLenum pname, GLfloat* params ) { - void (*func_glGetMapAttribParameterfvNV)( GLenum, GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glGetMapAttribParameterfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, index, pname, params ); - func_glGetMapAttribParameterfvNV( target, index, pname, params ); + funcs->ext.p_glGetMapAttribParameterfvNV( target, index, pname, params ); } static void WINAPI wine_glGetMapAttribParameterivNV( GLenum target, GLuint index, GLenum pname, GLint* params ) { - void (*func_glGetMapAttribParameterivNV)( GLenum, GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetMapAttribParameterivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, index, pname, params ); - func_glGetMapAttribParameterivNV( target, index, pname, params ); + funcs->ext.p_glGetMapAttribParameterivNV( target, index, pname, params ); } static void WINAPI wine_glGetMapControlPointsNV( GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, GLvoid* points ) { - void (*func_glGetMapControlPointsNV)( GLenum, GLuint, GLenum, GLsizei, GLsizei, GLboolean, GLvoid* ) = extension_funcs[EXT_glGetMapControlPointsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, index, type, ustride, vstride, packed, points ); - func_glGetMapControlPointsNV( target, index, type, ustride, vstride, packed, points ); + funcs->ext.p_glGetMapControlPointsNV( target, index, type, ustride, vstride, packed, points ); } static void WINAPI wine_glGetMapParameterfvNV( GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glGetMapParameterfvNV)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetMapParameterfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetMapParameterfvNV( target, pname, params ); + funcs->ext.p_glGetMapParameterfvNV( target, pname, params ); } static void WINAPI wine_glGetMapParameterivNV( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetMapParameterivNV)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetMapParameterivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetMapParameterivNV( target, pname, params ); + funcs->ext.p_glGetMapParameterivNV( target, pname, params ); } static void WINAPI wine_glGetMinmax( GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid* values ) { - void (*func_glGetMinmax)( GLenum, GLboolean, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glGetMinmax]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", target, reset, format, type, values ); - func_glGetMinmax( target, reset, format, type, values ); + funcs->ext.p_glGetMinmax( target, reset, format, type, values ); } static void WINAPI wine_glGetMinmaxEXT( GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid* values ) { - void (*func_glGetMinmaxEXT)( GLenum, GLboolean, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glGetMinmaxEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", target, reset, format, type, values ); - func_glGetMinmaxEXT( target, reset, format, type, values ); + funcs->ext.p_glGetMinmaxEXT( target, reset, format, type, values ); } static void WINAPI wine_glGetMinmaxParameterfv( GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glGetMinmaxParameterfv)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetMinmaxParameterfv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetMinmaxParameterfv( target, pname, params ); + funcs->ext.p_glGetMinmaxParameterfv( target, pname, params ); } static void WINAPI wine_glGetMinmaxParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glGetMinmaxParameterfvEXT)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetMinmaxParameterfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetMinmaxParameterfvEXT( target, pname, params ); + funcs->ext.p_glGetMinmaxParameterfvEXT( target, pname, params ); } static void WINAPI wine_glGetMinmaxParameteriv( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetMinmaxParameteriv)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetMinmaxParameteriv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetMinmaxParameteriv( target, pname, params ); + funcs->ext.p_glGetMinmaxParameteriv( target, pname, params ); } static void WINAPI wine_glGetMinmaxParameterivEXT( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetMinmaxParameterivEXT)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetMinmaxParameterivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetMinmaxParameterivEXT( target, pname, params ); + funcs->ext.p_glGetMinmaxParameterivEXT( target, pname, params ); } static void WINAPI wine_glGetMultiTexEnvfvEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glGetMultiTexEnvfvEXT)( GLenum, GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetMultiTexEnvfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params ); - func_glGetMultiTexEnvfvEXT( texunit, target, pname, params ); + funcs->ext.p_glGetMultiTexEnvfvEXT( texunit, target, pname, params ); } static void WINAPI wine_glGetMultiTexEnvivEXT( GLenum texunit, GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetMultiTexEnvivEXT)( GLenum, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetMultiTexEnvivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params ); - func_glGetMultiTexEnvivEXT( texunit, target, pname, params ); + funcs->ext.p_glGetMultiTexEnvivEXT( texunit, target, pname, params ); } static void WINAPI wine_glGetMultiTexGendvEXT( GLenum texunit, GLenum coord, GLenum pname, GLdouble* params ) { - void (*func_glGetMultiTexGendvEXT)( GLenum, GLenum, GLenum, GLdouble* ) = extension_funcs[EXT_glGetMultiTexGendvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, coord, pname, params ); - func_glGetMultiTexGendvEXT( texunit, coord, pname, params ); + funcs->ext.p_glGetMultiTexGendvEXT( texunit, coord, pname, params ); } static void WINAPI wine_glGetMultiTexGenfvEXT( GLenum texunit, GLenum coord, GLenum pname, GLfloat* params ) { - void (*func_glGetMultiTexGenfvEXT)( GLenum, GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetMultiTexGenfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, coord, pname, params ); - func_glGetMultiTexGenfvEXT( texunit, coord, pname, params ); + funcs->ext.p_glGetMultiTexGenfvEXT( texunit, coord, pname, params ); } static void WINAPI wine_glGetMultiTexGenivEXT( GLenum texunit, GLenum coord, GLenum pname, GLint* params ) { - void (*func_glGetMultiTexGenivEXT)( GLenum, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetMultiTexGenivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, coord, pname, params ); - func_glGetMultiTexGenivEXT( texunit, coord, pname, params ); + funcs->ext.p_glGetMultiTexGenivEXT( texunit, coord, pname, params ); } static void WINAPI wine_glGetMultiTexImageEXT( GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glGetMultiTexImageEXT)( GLenum, GLenum, GLint, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glGetMultiTexImageEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %p)\n", texunit, target, level, format, type, pixels ); - func_glGetMultiTexImageEXT( texunit, target, level, format, type, pixels ); + funcs->ext.p_glGetMultiTexImageEXT( texunit, target, level, format, type, pixels ); } static void WINAPI wine_glGetMultiTexLevelParameterfvEXT( GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat* params ) { - void (*func_glGetMultiTexLevelParameterfvEXT)( GLenum, GLenum, GLint, GLenum, GLfloat* ) = extension_funcs[EXT_glGetMultiTexLevelParameterfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", texunit, target, level, pname, params ); - func_glGetMultiTexLevelParameterfvEXT( texunit, target, level, pname, params ); + funcs->ext.p_glGetMultiTexLevelParameterfvEXT( texunit, target, level, pname, params ); } static void WINAPI wine_glGetMultiTexLevelParameterivEXT( GLenum texunit, GLenum target, GLint level, GLenum pname, GLint* params ) { - void (*func_glGetMultiTexLevelParameterivEXT)( GLenum, GLenum, GLint, GLenum, GLint* ) = extension_funcs[EXT_glGetMultiTexLevelParameterivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", texunit, target, level, pname, params ); - func_glGetMultiTexLevelParameterivEXT( texunit, target, level, pname, params ); + funcs->ext.p_glGetMultiTexLevelParameterivEXT( texunit, target, level, pname, params ); } static void WINAPI wine_glGetMultiTexParameterIivEXT( GLenum texunit, GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetMultiTexParameterIivEXT)( GLenum, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetMultiTexParameterIivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params ); - func_glGetMultiTexParameterIivEXT( texunit, target, pname, params ); + funcs->ext.p_glGetMultiTexParameterIivEXT( texunit, target, pname, params ); } static void WINAPI wine_glGetMultiTexParameterIuivEXT( GLenum texunit, GLenum target, GLenum pname, GLuint* params ) { - void (*func_glGetMultiTexParameterIuivEXT)( GLenum, GLenum, GLenum, GLuint* ) = extension_funcs[EXT_glGetMultiTexParameterIuivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params ); - func_glGetMultiTexParameterIuivEXT( texunit, target, pname, params ); + funcs->ext.p_glGetMultiTexParameterIuivEXT( texunit, target, pname, params ); } static void WINAPI wine_glGetMultiTexParameterfvEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glGetMultiTexParameterfvEXT)( GLenum, GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetMultiTexParameterfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params ); - func_glGetMultiTexParameterfvEXT( texunit, target, pname, params ); + funcs->ext.p_glGetMultiTexParameterfvEXT( texunit, target, pname, params ); } static void WINAPI wine_glGetMultiTexParameterivEXT( GLenum texunit, GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetMultiTexParameterivEXT)( GLenum, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetMultiTexParameterivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params ); - func_glGetMultiTexParameterivEXT( texunit, target, pname, params ); + funcs->ext.p_glGetMultiTexParameterivEXT( texunit, target, pname, params ); } static void WINAPI wine_glGetMultisamplefv( GLenum pname, GLuint index, GLfloat* val ) { - void (*func_glGetMultisamplefv)( GLenum, GLuint, GLfloat* ) = extension_funcs[EXT_glGetMultisamplefv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", pname, index, val ); - func_glGetMultisamplefv( pname, index, val ); + funcs->ext.p_glGetMultisamplefv( pname, index, val ); } static void WINAPI wine_glGetMultisamplefvNV( GLenum pname, GLuint index, GLfloat* val ) { - void (*func_glGetMultisamplefvNV)( GLenum, GLuint, GLfloat* ) = extension_funcs[EXT_glGetMultisamplefvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", pname, index, val ); - func_glGetMultisamplefvNV( pname, index, val ); + funcs->ext.p_glGetMultisamplefvNV( pname, index, val ); } static void WINAPI wine_glGetNamedBufferParameterivEXT( GLuint buffer, GLenum pname, GLint* params ) { - void (*func_glGetNamedBufferParameterivEXT)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetNamedBufferParameterivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", buffer, pname, params ); - func_glGetNamedBufferParameterivEXT( buffer, pname, params ); + funcs->ext.p_glGetNamedBufferParameterivEXT( buffer, pname, params ); } static void WINAPI wine_glGetNamedBufferParameterui64vNV( GLuint buffer, GLenum pname, UINT64* params ) { - void (*func_glGetNamedBufferParameterui64vNV)( GLuint, GLenum, UINT64* ) = extension_funcs[EXT_glGetNamedBufferParameterui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", buffer, pname, params ); - func_glGetNamedBufferParameterui64vNV( buffer, pname, params ); + funcs->ext.p_glGetNamedBufferParameterui64vNV( buffer, pname, params ); } static void WINAPI wine_glGetNamedBufferPointervEXT( GLuint buffer, GLenum pname, GLvoid** params ) { - void (*func_glGetNamedBufferPointervEXT)( GLuint, GLenum, GLvoid** ) = extension_funcs[EXT_glGetNamedBufferPointervEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", buffer, pname, params ); - func_glGetNamedBufferPointervEXT( buffer, pname, params ); + funcs->ext.p_glGetNamedBufferPointervEXT( buffer, pname, params ); } static void WINAPI wine_glGetNamedBufferSubDataEXT( GLuint buffer, INT_PTR offset, INT_PTR size, GLvoid* data ) { - void (*func_glGetNamedBufferSubDataEXT)( GLuint, INT_PTR, INT_PTR, GLvoid* ) = extension_funcs[EXT_glGetNamedBufferSubDataEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %ld, %ld, %p)\n", buffer, offset, size, data ); - func_glGetNamedBufferSubDataEXT( buffer, offset, size, data ); + funcs->ext.p_glGetNamedBufferSubDataEXT( buffer, offset, size, data ); } static void WINAPI wine_glGetNamedFramebufferAttachmentParameterivEXT( GLuint framebuffer, GLenum attachment, GLenum pname, GLint* params ) { - void (*func_glGetNamedFramebufferAttachmentParameterivEXT)( GLuint, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetNamedFramebufferAttachmentParameterivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", framebuffer, attachment, pname, params ); - func_glGetNamedFramebufferAttachmentParameterivEXT( framebuffer, attachment, pname, params ); + funcs->ext.p_glGetNamedFramebufferAttachmentParameterivEXT( framebuffer, attachment, pname, params ); } static void WINAPI wine_glGetNamedProgramLocalParameterIivEXT( GLuint program, GLenum target, GLuint index, GLint* params ) { - void (*func_glGetNamedProgramLocalParameterIivEXT)( GLuint, GLenum, GLuint, GLint* ) = extension_funcs[EXT_glGetNamedProgramLocalParameterIivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, target, index, params ); - func_glGetNamedProgramLocalParameterIivEXT( program, target, index, params ); + funcs->ext.p_glGetNamedProgramLocalParameterIivEXT( program, target, index, params ); } static void WINAPI wine_glGetNamedProgramLocalParameterIuivEXT( GLuint program, GLenum target, GLuint index, GLuint* params ) { - void (*func_glGetNamedProgramLocalParameterIuivEXT)( GLuint, GLenum, GLuint, GLuint* ) = extension_funcs[EXT_glGetNamedProgramLocalParameterIuivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, target, index, params ); - func_glGetNamedProgramLocalParameterIuivEXT( program, target, index, params ); + funcs->ext.p_glGetNamedProgramLocalParameterIuivEXT( program, target, index, params ); } static void WINAPI wine_glGetNamedProgramLocalParameterdvEXT( GLuint program, GLenum target, GLuint index, GLdouble* params ) { - void (*func_glGetNamedProgramLocalParameterdvEXT)( GLuint, GLenum, GLuint, GLdouble* ) = extension_funcs[EXT_glGetNamedProgramLocalParameterdvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, target, index, params ); - func_glGetNamedProgramLocalParameterdvEXT( program, target, index, params ); + funcs->ext.p_glGetNamedProgramLocalParameterdvEXT( program, target, index, params ); } static void WINAPI wine_glGetNamedProgramLocalParameterfvEXT( GLuint program, GLenum target, GLuint index, GLfloat* params ) { - void (*func_glGetNamedProgramLocalParameterfvEXT)( GLuint, GLenum, GLuint, GLfloat* ) = extension_funcs[EXT_glGetNamedProgramLocalParameterfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, target, index, params ); - func_glGetNamedProgramLocalParameterfvEXT( program, target, index, params ); + funcs->ext.p_glGetNamedProgramLocalParameterfvEXT( program, target, index, params ); } static void WINAPI wine_glGetNamedProgramStringEXT( GLuint program, GLenum target, GLenum pname, GLvoid* string ) { - void (*func_glGetNamedProgramStringEXT)( GLuint, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glGetNamedProgramStringEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, target, pname, string ); - func_glGetNamedProgramStringEXT( program, target, pname, string ); + funcs->ext.p_glGetNamedProgramStringEXT( program, target, pname, string ); } static void WINAPI wine_glGetNamedProgramivEXT( GLuint program, GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetNamedProgramivEXT)( GLuint, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetNamedProgramivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, target, pname, params ); - func_glGetNamedProgramivEXT( program, target, pname, params ); + funcs->ext.p_glGetNamedProgramivEXT( program, target, pname, params ); } static void WINAPI wine_glGetNamedRenderbufferParameterivEXT( GLuint renderbuffer, GLenum pname, GLint* params ) { - void (*func_glGetNamedRenderbufferParameterivEXT)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetNamedRenderbufferParameterivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", renderbuffer, pname, params ); - func_glGetNamedRenderbufferParameterivEXT( renderbuffer, pname, params ); + funcs->ext.p_glGetNamedRenderbufferParameterivEXT( renderbuffer, pname, params ); } static void WINAPI wine_glGetNamedStringARB( GLint namelen, char* name, GLsizei bufSize, GLint* stringlen, char* string ) { - void (*func_glGetNamedStringARB)( GLint, char*, GLsizei, GLint*, char* ) = extension_funcs[EXT_glGetNamedStringARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %d, %p, %p)\n", namelen, name, bufSize, stringlen, string ); - func_glGetNamedStringARB( namelen, name, bufSize, stringlen, string ); + funcs->ext.p_glGetNamedStringARB( namelen, name, bufSize, stringlen, string ); } static void WINAPI wine_glGetNamedStringivARB( GLint namelen, char* name, GLenum pname, GLint* params ) { - void (*func_glGetNamedStringivARB)( GLint, char*, GLenum, GLint* ) = extension_funcs[EXT_glGetNamedStringivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %d, %p)\n", namelen, name, pname, params ); - func_glGetNamedStringivARB( namelen, name, pname, params ); + funcs->ext.p_glGetNamedStringivARB( namelen, name, pname, params ); } static void WINAPI wine_glGetObjectBufferfvATI( GLuint buffer, GLenum pname, GLfloat* params ) { - void (*func_glGetObjectBufferfvATI)( GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glGetObjectBufferfvATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", buffer, pname, params ); - func_glGetObjectBufferfvATI( buffer, pname, params ); + funcs->ext.p_glGetObjectBufferfvATI( buffer, pname, params ); } static void WINAPI wine_glGetObjectBufferivATI( GLuint buffer, GLenum pname, GLint* params ) { - void (*func_glGetObjectBufferivATI)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetObjectBufferivATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", buffer, pname, params ); - func_glGetObjectBufferivATI( buffer, pname, params ); + funcs->ext.p_glGetObjectBufferivATI( buffer, pname, params ); } static void WINAPI wine_glGetObjectParameterfvARB( unsigned int obj, GLenum pname, GLfloat* params ) { - void (*func_glGetObjectParameterfvARB)( unsigned int, GLenum, GLfloat* ) = extension_funcs[EXT_glGetObjectParameterfvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", obj, pname, params ); - func_glGetObjectParameterfvARB( obj, pname, params ); + funcs->ext.p_glGetObjectParameterfvARB( obj, pname, params ); } static void WINAPI wine_glGetObjectParameterivAPPLE( GLenum objectType, GLuint name, GLenum pname, GLint* params ) { - void (*func_glGetObjectParameterivAPPLE)( GLenum, GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetObjectParameterivAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", objectType, name, pname, params ); - func_glGetObjectParameterivAPPLE( objectType, name, pname, params ); + funcs->ext.p_glGetObjectParameterivAPPLE( objectType, name, pname, params ); } static void WINAPI wine_glGetObjectParameterivARB( unsigned int obj, GLenum pname, GLint* params ) { - void (*func_glGetObjectParameterivARB)( unsigned int, GLenum, GLint* ) = extension_funcs[EXT_glGetObjectParameterivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", obj, pname, params ); - func_glGetObjectParameterivARB( obj, pname, params ); + funcs->ext.p_glGetObjectParameterivARB( obj, pname, params ); } static void WINAPI wine_glGetOcclusionQueryivNV( GLuint id, GLenum pname, GLint* params ) { - void (*func_glGetOcclusionQueryivNV)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetOcclusionQueryivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, pname, params ); - func_glGetOcclusionQueryivNV( id, pname, params ); + funcs->ext.p_glGetOcclusionQueryivNV( id, pname, params ); } static void WINAPI wine_glGetOcclusionQueryuivNV( GLuint id, GLenum pname, GLuint* params ) { - void (*func_glGetOcclusionQueryuivNV)( GLuint, GLenum, GLuint* ) = extension_funcs[EXT_glGetOcclusionQueryuivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, pname, params ); - func_glGetOcclusionQueryuivNV( id, pname, params ); + funcs->ext.p_glGetOcclusionQueryuivNV( id, pname, params ); } static void WINAPI wine_glGetPathColorGenfvNV( GLenum color, GLenum pname, GLfloat* value ) { - void (*func_glGetPathColorGenfvNV)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetPathColorGenfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", color, pname, value ); - func_glGetPathColorGenfvNV( color, pname, value ); + funcs->ext.p_glGetPathColorGenfvNV( color, pname, value ); } static void WINAPI wine_glGetPathColorGenivNV( GLenum color, GLenum pname, GLint* value ) { - void (*func_glGetPathColorGenivNV)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetPathColorGenivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", color, pname, value ); - func_glGetPathColorGenivNV( color, pname, value ); + funcs->ext.p_glGetPathColorGenivNV( color, pname, value ); } static void WINAPI wine_glGetPathCommandsNV( GLuint path, GLubyte* commands ) { - void (*func_glGetPathCommandsNV)( GLuint, GLubyte* ) = extension_funcs[EXT_glGetPathCommandsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", path, commands ); - func_glGetPathCommandsNV( path, commands ); + funcs->ext.p_glGetPathCommandsNV( path, commands ); } static void WINAPI wine_glGetPathCoordsNV( GLuint path, GLfloat* coords ) { - void (*func_glGetPathCoordsNV)( GLuint, GLfloat* ) = extension_funcs[EXT_glGetPathCoordsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", path, coords ); - func_glGetPathCoordsNV( path, coords ); + funcs->ext.p_glGetPathCoordsNV( path, coords ); } static void WINAPI wine_glGetPathDashArrayNV( GLuint path, GLfloat* dashArray ) { - void (*func_glGetPathDashArrayNV)( GLuint, GLfloat* ) = extension_funcs[EXT_glGetPathDashArrayNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", path, dashArray ); - func_glGetPathDashArrayNV( path, dashArray ); + funcs->ext.p_glGetPathDashArrayNV( path, dashArray ); } static GLfloat WINAPI wine_glGetPathLengthNV( GLuint path, GLsizei startSegment, GLsizei numSegments ) { - GLfloat (*func_glGetPathLengthNV)( GLuint, GLsizei, GLsizei ) = extension_funcs[EXT_glGetPathLengthNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", path, startSegment, numSegments ); - return func_glGetPathLengthNV( path, startSegment, numSegments ); + return funcs->ext.p_glGetPathLengthNV( path, startSegment, numSegments ); } static void WINAPI wine_glGetPathMetricRangeNV( GLbitfield metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, GLfloat* metrics ) { - void (*func_glGetPathMetricRangeNV)( GLbitfield, GLuint, GLsizei, GLsizei, GLfloat* ) = extension_funcs[EXT_glGetPathMetricRangeNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", metricQueryMask, firstPathName, numPaths, stride, metrics ); - func_glGetPathMetricRangeNV( metricQueryMask, firstPathName, numPaths, stride, metrics ); + funcs->ext.p_glGetPathMetricRangeNV( metricQueryMask, firstPathName, numPaths, stride, metrics ); } static void WINAPI wine_glGetPathMetricsNV( GLbitfield metricQueryMask, GLsizei numPaths, GLenum pathNameType, GLvoid* paths, GLuint pathBase, GLsizei stride, GLfloat* metrics ) { - void (*func_glGetPathMetricsNV)( GLbitfield, GLsizei, GLenum, GLvoid*, GLuint, GLsizei, GLfloat* ) = extension_funcs[EXT_glGetPathMetricsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %d, %d, %p)\n", metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics ); - func_glGetPathMetricsNV( metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics ); + funcs->ext.p_glGetPathMetricsNV( metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics ); } static void WINAPI wine_glGetPathParameterfvNV( GLuint path, GLenum pname, GLfloat* value ) { - void (*func_glGetPathParameterfvNV)( GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glGetPathParameterfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", path, pname, value ); - func_glGetPathParameterfvNV( path, pname, value ); + funcs->ext.p_glGetPathParameterfvNV( path, pname, value ); } static void WINAPI wine_glGetPathParameterivNV( GLuint path, GLenum pname, GLint* value ) { - void (*func_glGetPathParameterivNV)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetPathParameterivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", path, pname, value ); - func_glGetPathParameterivNV( path, pname, value ); + funcs->ext.p_glGetPathParameterivNV( path, pname, value ); } static void WINAPI wine_glGetPathSpacingNV( GLenum pathListMode, GLsizei numPaths, GLenum pathNameType, GLvoid* paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, GLenum transformType, GLfloat* returnedSpacing ) { - void (*func_glGetPathSpacingNV)( GLenum, GLsizei, GLenum, GLvoid*, GLuint, GLfloat, GLfloat, GLenum, GLfloat* ) = extension_funcs[EXT_glGetPathSpacingNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %d, %f, %f, %d, %p)\n", pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing ); - func_glGetPathSpacingNV( pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing ); + funcs->ext.p_glGetPathSpacingNV( pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing ); } static void WINAPI wine_glGetPathTexGenfvNV( GLenum texCoordSet, GLenum pname, GLfloat* value ) { - void (*func_glGetPathTexGenfvNV)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetPathTexGenfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", texCoordSet, pname, value ); - func_glGetPathTexGenfvNV( texCoordSet, pname, value ); + funcs->ext.p_glGetPathTexGenfvNV( texCoordSet, pname, value ); } static void WINAPI wine_glGetPathTexGenivNV( GLenum texCoordSet, GLenum pname, GLint* value ) { - void (*func_glGetPathTexGenivNV)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetPathTexGenivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", texCoordSet, pname, value ); - func_glGetPathTexGenivNV( texCoordSet, pname, value ); + funcs->ext.p_glGetPathTexGenivNV( texCoordSet, pname, value ); } static void WINAPI wine_glGetPerfMonitorCounterDataAMD( GLuint monitor, GLenum pname, GLsizei dataSize, GLuint* data, GLint* bytesWritten ) { - void (*func_glGetPerfMonitorCounterDataAMD)( GLuint, GLenum, GLsizei, GLuint*, GLint* ) = extension_funcs[EXT_glGetPerfMonitorCounterDataAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %p)\n", monitor, pname, dataSize, data, bytesWritten ); - func_glGetPerfMonitorCounterDataAMD( monitor, pname, dataSize, data, bytesWritten ); + funcs->ext.p_glGetPerfMonitorCounterDataAMD( monitor, pname, dataSize, data, bytesWritten ); } static void WINAPI wine_glGetPerfMonitorCounterInfoAMD( GLuint group, GLuint counter, GLenum pname, GLvoid* data ) { - void (*func_glGetPerfMonitorCounterInfoAMD)( GLuint, GLuint, GLenum, GLvoid* ) = extension_funcs[EXT_glGetPerfMonitorCounterInfoAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", group, counter, pname, data ); - func_glGetPerfMonitorCounterInfoAMD( group, counter, pname, data ); + funcs->ext.p_glGetPerfMonitorCounterInfoAMD( group, counter, pname, data ); } static void WINAPI wine_glGetPerfMonitorCounterStringAMD( GLuint group, GLuint counter, GLsizei bufSize, GLsizei* length, char* counterString ) { - void (*func_glGetPerfMonitorCounterStringAMD)( GLuint, GLuint, GLsizei, GLsizei*, char* ) = extension_funcs[EXT_glGetPerfMonitorCounterStringAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %p)\n", group, counter, bufSize, length, counterString ); - func_glGetPerfMonitorCounterStringAMD( group, counter, bufSize, length, counterString ); + funcs->ext.p_glGetPerfMonitorCounterStringAMD( group, counter, bufSize, length, counterString ); } static void WINAPI wine_glGetPerfMonitorCountersAMD( GLuint group, GLint* numCounters, GLint* maxActiveCounters, GLsizei counterSize, GLuint* counters ) { - void (*func_glGetPerfMonitorCountersAMD)( GLuint, GLint*, GLint*, GLsizei, GLuint* ) = extension_funcs[EXT_glGetPerfMonitorCountersAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %p, %d, %p)\n", group, numCounters, maxActiveCounters, counterSize, counters ); - func_glGetPerfMonitorCountersAMD( group, numCounters, maxActiveCounters, counterSize, counters ); + funcs->ext.p_glGetPerfMonitorCountersAMD( group, numCounters, maxActiveCounters, counterSize, counters ); } static void WINAPI wine_glGetPerfMonitorGroupStringAMD( GLuint group, GLsizei bufSize, GLsizei* length, char* groupString ) { - void (*func_glGetPerfMonitorGroupStringAMD)( GLuint, GLsizei, GLsizei*, char* ) = extension_funcs[EXT_glGetPerfMonitorGroupStringAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", group, bufSize, length, groupString ); - func_glGetPerfMonitorGroupStringAMD( group, bufSize, length, groupString ); + funcs->ext.p_glGetPerfMonitorGroupStringAMD( group, bufSize, length, groupString ); } static void WINAPI wine_glGetPerfMonitorGroupsAMD( GLint* numGroups, GLsizei groupsSize, GLuint* groups ) { - void (*func_glGetPerfMonitorGroupsAMD)( GLint*, GLsizei, GLuint* ) = extension_funcs[EXT_glGetPerfMonitorGroupsAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %d, %p)\n", numGroups, groupsSize, groups ); - func_glGetPerfMonitorGroupsAMD( numGroups, groupsSize, groups ); + funcs->ext.p_glGetPerfMonitorGroupsAMD( numGroups, groupsSize, groups ); } static void WINAPI wine_glGetPixelTexGenParameterfvSGIS( GLenum pname, GLfloat* params ) { - void (*func_glGetPixelTexGenParameterfvSGIS)( GLenum, GLfloat* ) = extension_funcs[EXT_glGetPixelTexGenParameterfvSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glGetPixelTexGenParameterfvSGIS( pname, params ); + funcs->ext.p_glGetPixelTexGenParameterfvSGIS( pname, params ); } static void WINAPI wine_glGetPixelTexGenParameterivSGIS( GLenum pname, GLint* params ) { - void (*func_glGetPixelTexGenParameterivSGIS)( GLenum, GLint* ) = extension_funcs[EXT_glGetPixelTexGenParameterivSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glGetPixelTexGenParameterivSGIS( pname, params ); + funcs->ext.p_glGetPixelTexGenParameterivSGIS( pname, params ); } static void WINAPI wine_glGetPointerIndexedvEXT( GLenum target, GLuint index, GLvoid** data ) { - void (*func_glGetPointerIndexedvEXT)( GLenum, GLuint, GLvoid** ) = extension_funcs[EXT_glGetPointerIndexedvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, data ); - func_glGetPointerIndexedvEXT( target, index, data ); + funcs->ext.p_glGetPointerIndexedvEXT( target, index, data ); } static void WINAPI wine_glGetPointervEXT( GLenum pname, GLvoid** params ) { - void (*func_glGetPointervEXT)( GLenum, GLvoid** ) = extension_funcs[EXT_glGetPointervEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glGetPointervEXT( pname, params ); + funcs->ext.p_glGetPointervEXT( pname, params ); } static void WINAPI wine_glGetProgramBinary( GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary ) { - void (*func_glGetProgramBinary)( GLuint, GLsizei, GLsizei*, GLenum*, GLvoid* ) = extension_funcs[EXT_glGetProgramBinary]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p, %p)\n", program, bufSize, length, binaryFormat, binary ); - func_glGetProgramBinary( program, bufSize, length, binaryFormat, binary ); + funcs->ext.p_glGetProgramBinary( program, bufSize, length, binaryFormat, binary ); } static void WINAPI wine_glGetProgramEnvParameterIivNV( GLenum target, GLuint index, GLint* params ) { - void (*func_glGetProgramEnvParameterIivNV)( GLenum, GLuint, GLint* ) = extension_funcs[EXT_glGetProgramEnvParameterIivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, params ); - func_glGetProgramEnvParameterIivNV( target, index, params ); + funcs->ext.p_glGetProgramEnvParameterIivNV( target, index, params ); } static void WINAPI wine_glGetProgramEnvParameterIuivNV( GLenum target, GLuint index, GLuint* params ) { - void (*func_glGetProgramEnvParameterIuivNV)( GLenum, GLuint, GLuint* ) = extension_funcs[EXT_glGetProgramEnvParameterIuivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, params ); - func_glGetProgramEnvParameterIuivNV( target, index, params ); + funcs->ext.p_glGetProgramEnvParameterIuivNV( target, index, params ); } static void WINAPI wine_glGetProgramEnvParameterdvARB( GLenum target, GLuint index, GLdouble* params ) { - void (*func_glGetProgramEnvParameterdvARB)( GLenum, GLuint, GLdouble* ) = extension_funcs[EXT_glGetProgramEnvParameterdvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, params ); - func_glGetProgramEnvParameterdvARB( target, index, params ); + funcs->ext.p_glGetProgramEnvParameterdvARB( target, index, params ); } static void WINAPI wine_glGetProgramEnvParameterfvARB( GLenum target, GLuint index, GLfloat* params ) { - void (*func_glGetProgramEnvParameterfvARB)( GLenum, GLuint, GLfloat* ) = extension_funcs[EXT_glGetProgramEnvParameterfvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, params ); - func_glGetProgramEnvParameterfvARB( target, index, params ); + funcs->ext.p_glGetProgramEnvParameterfvARB( target, index, params ); } static void WINAPI wine_glGetProgramInfoLog( GLuint program, GLsizei bufSize, GLsizei* length, char* infoLog ) { - void (*func_glGetProgramInfoLog)( GLuint, GLsizei, GLsizei*, char* ) = extension_funcs[EXT_glGetProgramInfoLog]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", program, bufSize, length, infoLog ); - func_glGetProgramInfoLog( program, bufSize, length, infoLog ); + funcs->ext.p_glGetProgramInfoLog( program, bufSize, length, infoLog ); } static void WINAPI wine_glGetProgramLocalParameterIivNV( GLenum target, GLuint index, GLint* params ) { - void (*func_glGetProgramLocalParameterIivNV)( GLenum, GLuint, GLint* ) = extension_funcs[EXT_glGetProgramLocalParameterIivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, params ); - func_glGetProgramLocalParameterIivNV( target, index, params ); + funcs->ext.p_glGetProgramLocalParameterIivNV( target, index, params ); } static void WINAPI wine_glGetProgramLocalParameterIuivNV( GLenum target, GLuint index, GLuint* params ) { - void (*func_glGetProgramLocalParameterIuivNV)( GLenum, GLuint, GLuint* ) = extension_funcs[EXT_glGetProgramLocalParameterIuivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, params ); - func_glGetProgramLocalParameterIuivNV( target, index, params ); + funcs->ext.p_glGetProgramLocalParameterIuivNV( target, index, params ); } static void WINAPI wine_glGetProgramLocalParameterdvARB( GLenum target, GLuint index, GLdouble* params ) { - void (*func_glGetProgramLocalParameterdvARB)( GLenum, GLuint, GLdouble* ) = extension_funcs[EXT_glGetProgramLocalParameterdvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, params ); - func_glGetProgramLocalParameterdvARB( target, index, params ); + funcs->ext.p_glGetProgramLocalParameterdvARB( target, index, params ); } static void WINAPI wine_glGetProgramLocalParameterfvARB( GLenum target, GLuint index, GLfloat* params ) { - void (*func_glGetProgramLocalParameterfvARB)( GLenum, GLuint, GLfloat* ) = extension_funcs[EXT_glGetProgramLocalParameterfvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, params ); - func_glGetProgramLocalParameterfvARB( target, index, params ); + funcs->ext.p_glGetProgramLocalParameterfvARB( target, index, params ); } static void WINAPI wine_glGetProgramNamedParameterdvNV( GLuint id, GLsizei len, GLubyte* name, GLdouble* params ) { - void (*func_glGetProgramNamedParameterdvNV)( GLuint, GLsizei, GLubyte*, GLdouble* ) = extension_funcs[EXT_glGetProgramNamedParameterdvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", id, len, name, params ); - func_glGetProgramNamedParameterdvNV( id, len, name, params ); + funcs->ext.p_glGetProgramNamedParameterdvNV( id, len, name, params ); } static void WINAPI wine_glGetProgramNamedParameterfvNV( GLuint id, GLsizei len, GLubyte* name, GLfloat* params ) { - void (*func_glGetProgramNamedParameterfvNV)( GLuint, GLsizei, GLubyte*, GLfloat* ) = extension_funcs[EXT_glGetProgramNamedParameterfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", id, len, name, params ); - func_glGetProgramNamedParameterfvNV( id, len, name, params ); + funcs->ext.p_glGetProgramNamedParameterfvNV( id, len, name, params ); } static void WINAPI wine_glGetProgramParameterdvNV( GLenum target, GLuint index, GLenum pname, GLdouble* params ) { - void (*func_glGetProgramParameterdvNV)( GLenum, GLuint, GLenum, GLdouble* ) = extension_funcs[EXT_glGetProgramParameterdvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, index, pname, params ); - func_glGetProgramParameterdvNV( target, index, pname, params ); + funcs->ext.p_glGetProgramParameterdvNV( target, index, pname, params ); } static void WINAPI wine_glGetProgramParameterfvNV( GLenum target, GLuint index, GLenum pname, GLfloat* params ) { - void (*func_glGetProgramParameterfvNV)( GLenum, GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glGetProgramParameterfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, index, pname, params ); - func_glGetProgramParameterfvNV( target, index, pname, params ); + funcs->ext.p_glGetProgramParameterfvNV( target, index, pname, params ); } static void WINAPI wine_glGetProgramPipelineInfoLog( GLuint pipeline, GLsizei bufSize, GLsizei* length, char* infoLog ) { - void (*func_glGetProgramPipelineInfoLog)( GLuint, GLsizei, GLsizei*, char* ) = extension_funcs[EXT_glGetProgramPipelineInfoLog]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", pipeline, bufSize, length, infoLog ); - func_glGetProgramPipelineInfoLog( pipeline, bufSize, length, infoLog ); + funcs->ext.p_glGetProgramPipelineInfoLog( pipeline, bufSize, length, infoLog ); } static void WINAPI wine_glGetProgramPipelineiv( GLuint pipeline, GLenum pname, GLint* params ) { - void (*func_glGetProgramPipelineiv)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetProgramPipelineiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", pipeline, pname, params ); - func_glGetProgramPipelineiv( pipeline, pname, params ); + funcs->ext.p_glGetProgramPipelineiv( pipeline, pname, params ); } static void WINAPI wine_glGetProgramStageiv( GLuint program, GLenum shadertype, GLenum pname, GLint* values ) { - void (*func_glGetProgramStageiv)( GLuint, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetProgramStageiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, shadertype, pname, values ); - func_glGetProgramStageiv( program, shadertype, pname, values ); + funcs->ext.p_glGetProgramStageiv( program, shadertype, pname, values ); } static void WINAPI wine_glGetProgramStringARB( GLenum target, GLenum pname, GLvoid* string ) { - void (*func_glGetProgramStringARB)( GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glGetProgramStringARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, string ); - func_glGetProgramStringARB( target, pname, string ); + funcs->ext.p_glGetProgramStringARB( target, pname, string ); } static void WINAPI wine_glGetProgramStringNV( GLuint id, GLenum pname, GLubyte* program ) { - void (*func_glGetProgramStringNV)( GLuint, GLenum, GLubyte* ) = extension_funcs[EXT_glGetProgramStringNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, pname, program ); - func_glGetProgramStringNV( id, pname, program ); + funcs->ext.p_glGetProgramStringNV( id, pname, program ); } static void WINAPI wine_glGetProgramSubroutineParameteruivNV( GLenum target, GLuint index, GLuint* param ) { - void (*func_glGetProgramSubroutineParameteruivNV)( GLenum, GLuint, GLuint* ) = extension_funcs[EXT_glGetProgramSubroutineParameteruivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, param ); - func_glGetProgramSubroutineParameteruivNV( target, index, param ); + funcs->ext.p_glGetProgramSubroutineParameteruivNV( target, index, param ); } static void WINAPI wine_glGetProgramiv( GLuint program, GLenum pname, GLint* params ) { - void (*func_glGetProgramiv)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetProgramiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", program, pname, params ); - func_glGetProgramiv( program, pname, params ); + funcs->ext.p_glGetProgramiv( program, pname, params ); } static void WINAPI wine_glGetProgramivARB( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetProgramivARB)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetProgramivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetProgramivARB( target, pname, params ); + funcs->ext.p_glGetProgramivARB( target, pname, params ); } static void WINAPI wine_glGetProgramivNV( GLuint id, GLenum pname, GLint* params ) { - void (*func_glGetProgramivNV)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetProgramivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, pname, params ); - func_glGetProgramivNV( id, pname, params ); + funcs->ext.p_glGetProgramivNV( id, pname, params ); } static void WINAPI wine_glGetQueryIndexediv( GLenum target, GLuint index, GLenum pname, GLint* params ) { - void (*func_glGetQueryIndexediv)( GLenum, GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetQueryIndexediv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, index, pname, params ); - func_glGetQueryIndexediv( target, index, pname, params ); + funcs->ext.p_glGetQueryIndexediv( target, index, pname, params ); } static void WINAPI wine_glGetQueryObjecti64v( GLuint id, GLenum pname, INT64* params ) { - void (*func_glGetQueryObjecti64v)( GLuint, GLenum, INT64* ) = extension_funcs[EXT_glGetQueryObjecti64v]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, pname, params ); - func_glGetQueryObjecti64v( id, pname, params ); + funcs->ext.p_glGetQueryObjecti64v( id, pname, params ); } static void WINAPI wine_glGetQueryObjecti64vEXT( GLuint id, GLenum pname, INT64* params ) { - void (*func_glGetQueryObjecti64vEXT)( GLuint, GLenum, INT64* ) = extension_funcs[EXT_glGetQueryObjecti64vEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, pname, params ); - func_glGetQueryObjecti64vEXT( id, pname, params ); + funcs->ext.p_glGetQueryObjecti64vEXT( id, pname, params ); } static void WINAPI wine_glGetQueryObjectiv( GLuint id, GLenum pname, GLint* params ) { - void (*func_glGetQueryObjectiv)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetQueryObjectiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, pname, params ); - func_glGetQueryObjectiv( id, pname, params ); + funcs->ext.p_glGetQueryObjectiv( id, pname, params ); } static void WINAPI wine_glGetQueryObjectivARB( GLuint id, GLenum pname, GLint* params ) { - void (*func_glGetQueryObjectivARB)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetQueryObjectivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, pname, params ); - func_glGetQueryObjectivARB( id, pname, params ); + funcs->ext.p_glGetQueryObjectivARB( id, pname, params ); } static void WINAPI wine_glGetQueryObjectui64v( GLuint id, GLenum pname, UINT64* params ) { - void (*func_glGetQueryObjectui64v)( GLuint, GLenum, UINT64* ) = extension_funcs[EXT_glGetQueryObjectui64v]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, pname, params ); - func_glGetQueryObjectui64v( id, pname, params ); + funcs->ext.p_glGetQueryObjectui64v( id, pname, params ); } static void WINAPI wine_glGetQueryObjectui64vEXT( GLuint id, GLenum pname, UINT64* params ) { - void (*func_glGetQueryObjectui64vEXT)( GLuint, GLenum, UINT64* ) = extension_funcs[EXT_glGetQueryObjectui64vEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, pname, params ); - func_glGetQueryObjectui64vEXT( id, pname, params ); + funcs->ext.p_glGetQueryObjectui64vEXT( id, pname, params ); } static void WINAPI wine_glGetQueryObjectuiv( GLuint id, GLenum pname, GLuint* params ) { - void (*func_glGetQueryObjectuiv)( GLuint, GLenum, GLuint* ) = extension_funcs[EXT_glGetQueryObjectuiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, pname, params ); - func_glGetQueryObjectuiv( id, pname, params ); + funcs->ext.p_glGetQueryObjectuiv( id, pname, params ); } static void WINAPI wine_glGetQueryObjectuivARB( GLuint id, GLenum pname, GLuint* params ) { - void (*func_glGetQueryObjectuivARB)( GLuint, GLenum, GLuint* ) = extension_funcs[EXT_glGetQueryObjectuivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, pname, params ); - func_glGetQueryObjectuivARB( id, pname, params ); + funcs->ext.p_glGetQueryObjectuivARB( id, pname, params ); } static void WINAPI wine_glGetQueryiv( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetQueryiv)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetQueryiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetQueryiv( target, pname, params ); + funcs->ext.p_glGetQueryiv( target, pname, params ); } static void WINAPI wine_glGetQueryivARB( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetQueryivARB)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetQueryivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetQueryivARB( target, pname, params ); + funcs->ext.p_glGetQueryivARB( target, pname, params ); } static void WINAPI wine_glGetRenderbufferParameteriv( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetRenderbufferParameteriv)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetRenderbufferParameteriv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetRenderbufferParameteriv( target, pname, params ); + funcs->ext.p_glGetRenderbufferParameteriv( target, pname, params ); } static void WINAPI wine_glGetRenderbufferParameterivEXT( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetRenderbufferParameterivEXT)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetRenderbufferParameterivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetRenderbufferParameterivEXT( target, pname, params ); + funcs->ext.p_glGetRenderbufferParameterivEXT( target, pname, params ); } static void WINAPI wine_glGetSamplerParameterIiv( GLuint sampler, GLenum pname, GLint* params ) { - void (*func_glGetSamplerParameterIiv)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetSamplerParameterIiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", sampler, pname, params ); - func_glGetSamplerParameterIiv( sampler, pname, params ); + funcs->ext.p_glGetSamplerParameterIiv( sampler, pname, params ); } static void WINAPI wine_glGetSamplerParameterIuiv( GLuint sampler, GLenum pname, GLuint* params ) { - void (*func_glGetSamplerParameterIuiv)( GLuint, GLenum, GLuint* ) = extension_funcs[EXT_glGetSamplerParameterIuiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", sampler, pname, params ); - func_glGetSamplerParameterIuiv( sampler, pname, params ); + funcs->ext.p_glGetSamplerParameterIuiv( sampler, pname, params ); } static void WINAPI wine_glGetSamplerParameterfv( GLuint sampler, GLenum pname, GLfloat* params ) { - void (*func_glGetSamplerParameterfv)( GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glGetSamplerParameterfv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", sampler, pname, params ); - func_glGetSamplerParameterfv( sampler, pname, params ); + funcs->ext.p_glGetSamplerParameterfv( sampler, pname, params ); } static void WINAPI wine_glGetSamplerParameteriv( GLuint sampler, GLenum pname, GLint* params ) { - void (*func_glGetSamplerParameteriv)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetSamplerParameteriv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", sampler, pname, params ); - func_glGetSamplerParameteriv( sampler, pname, params ); + funcs->ext.p_glGetSamplerParameteriv( sampler, pname, params ); } static void WINAPI wine_glGetSeparableFilter( GLenum target, GLenum format, GLenum type, GLvoid* row, GLvoid* column, GLvoid* span ) { - void (*func_glGetSeparableFilter)( GLenum, GLenum, GLenum, GLvoid*, GLvoid*, GLvoid* ) = extension_funcs[EXT_glGetSeparableFilter]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %p, %p)\n", target, format, type, row, column, span ); - func_glGetSeparableFilter( target, format, type, row, column, span ); + funcs->ext.p_glGetSeparableFilter( target, format, type, row, column, span ); } static void WINAPI wine_glGetSeparableFilterEXT( GLenum target, GLenum format, GLenum type, GLvoid* row, GLvoid* column, GLvoid* span ) { - void (*func_glGetSeparableFilterEXT)( GLenum, GLenum, GLenum, GLvoid*, GLvoid*, GLvoid* ) = extension_funcs[EXT_glGetSeparableFilterEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %p, %p)\n", target, format, type, row, column, span ); - func_glGetSeparableFilterEXT( target, format, type, row, column, span ); + funcs->ext.p_glGetSeparableFilterEXT( target, format, type, row, column, span ); } static void WINAPI wine_glGetShaderInfoLog( GLuint shader, GLsizei bufSize, GLsizei* length, char* infoLog ) { - void (*func_glGetShaderInfoLog)( GLuint, GLsizei, GLsizei*, char* ) = extension_funcs[EXT_glGetShaderInfoLog]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", shader, bufSize, length, infoLog ); - func_glGetShaderInfoLog( shader, bufSize, length, infoLog ); + funcs->ext.p_glGetShaderInfoLog( shader, bufSize, length, infoLog ); } static void WINAPI wine_glGetShaderPrecisionFormat( GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision ) { - void (*func_glGetShaderPrecisionFormat)( GLenum, GLenum, GLint*, GLint* ) = extension_funcs[EXT_glGetShaderPrecisionFormat]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", shadertype, precisiontype, range, precision ); - func_glGetShaderPrecisionFormat( shadertype, precisiontype, range, precision ); + funcs->ext.p_glGetShaderPrecisionFormat( shadertype, precisiontype, range, precision ); } static void WINAPI wine_glGetShaderSource( GLuint shader, GLsizei bufSize, GLsizei* length, char* source ) { - void (*func_glGetShaderSource)( GLuint, GLsizei, GLsizei*, char* ) = extension_funcs[EXT_glGetShaderSource]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", shader, bufSize, length, source ); - func_glGetShaderSource( shader, bufSize, length, source ); + funcs->ext.p_glGetShaderSource( shader, bufSize, length, source ); } static void WINAPI wine_glGetShaderSourceARB( unsigned int obj, GLsizei maxLength, GLsizei* length, char* source ) { - void (*func_glGetShaderSourceARB)( unsigned int, GLsizei, GLsizei*, char* ) = extension_funcs[EXT_glGetShaderSourceARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", obj, maxLength, length, source ); - func_glGetShaderSourceARB( obj, maxLength, length, source ); + funcs->ext.p_glGetShaderSourceARB( obj, maxLength, length, source ); } static void WINAPI wine_glGetShaderiv( GLuint shader, GLenum pname, GLint* params ) { - void (*func_glGetShaderiv)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetShaderiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", shader, pname, params ); - func_glGetShaderiv( shader, pname, params ); + funcs->ext.p_glGetShaderiv( shader, pname, params ); } static void WINAPI wine_glGetSharpenTexFuncSGIS( GLenum target, GLfloat* points ) { - void (*func_glGetSharpenTexFuncSGIS)( GLenum, GLfloat* ) = extension_funcs[EXT_glGetSharpenTexFuncSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, points ); - func_glGetSharpenTexFuncSGIS( target, points ); + funcs->ext.p_glGetSharpenTexFuncSGIS( target, points ); } static const GLubyte * WINAPI wine_glGetStringi( GLenum name, GLuint index ) { - const GLubyte * (*func_glGetStringi)( GLenum, GLuint ) = extension_funcs[EXT_glGetStringi]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", name, index ); - return func_glGetStringi( name, index ); + return funcs->ext.p_glGetStringi( name, index ); } static GLuint WINAPI wine_glGetSubroutineIndex( GLuint program, GLenum shadertype, char* name ) { - GLuint (*func_glGetSubroutineIndex)( GLuint, GLenum, char* ) = extension_funcs[EXT_glGetSubroutineIndex]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", program, shadertype, name ); - return func_glGetSubroutineIndex( program, shadertype, name ); + return funcs->ext.p_glGetSubroutineIndex( program, shadertype, name ); } static GLint WINAPI wine_glGetSubroutineUniformLocation( GLuint program, GLenum shadertype, char* name ) { - GLint (*func_glGetSubroutineUniformLocation)( GLuint, GLenum, char* ) = extension_funcs[EXT_glGetSubroutineUniformLocation]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", program, shadertype, name ); - return func_glGetSubroutineUniformLocation( program, shadertype, name ); + return funcs->ext.p_glGetSubroutineUniformLocation( program, shadertype, name ); } static void WINAPI wine_glGetSynciv( GLvoid* sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values ) { - void (*func_glGetSynciv)( GLvoid*, GLenum, GLsizei, GLsizei*, GLint* ) = extension_funcs[EXT_glGetSynciv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %d, %d, %p, %p)\n", sync, pname, bufSize, length, values ); - func_glGetSynciv( sync, pname, bufSize, length, values ); + funcs->ext.p_glGetSynciv( sync, pname, bufSize, length, values ); } static void WINAPI wine_glGetTexBumpParameterfvATI( GLenum pname, GLfloat* param ) { - void (*func_glGetTexBumpParameterfvATI)( GLenum, GLfloat* ) = extension_funcs[EXT_glGetTexBumpParameterfvATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, param ); - func_glGetTexBumpParameterfvATI( pname, param ); + funcs->ext.p_glGetTexBumpParameterfvATI( pname, param ); } static void WINAPI wine_glGetTexBumpParameterivATI( GLenum pname, GLint* param ) { - void (*func_glGetTexBumpParameterivATI)( GLenum, GLint* ) = extension_funcs[EXT_glGetTexBumpParameterivATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, param ); - func_glGetTexBumpParameterivATI( pname, param ); + funcs->ext.p_glGetTexBumpParameterivATI( pname, param ); } static void WINAPI wine_glGetTexFilterFuncSGIS( GLenum target, GLenum filter, GLfloat* weights ) { - void (*func_glGetTexFilterFuncSGIS)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetTexFilterFuncSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, filter, weights ); - func_glGetTexFilterFuncSGIS( target, filter, weights ); + funcs->ext.p_glGetTexFilterFuncSGIS( target, filter, weights ); } static void WINAPI wine_glGetTexParameterIiv( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetTexParameterIiv)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetTexParameterIiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetTexParameterIiv( target, pname, params ); + funcs->ext.p_glGetTexParameterIiv( target, pname, params ); } static void WINAPI wine_glGetTexParameterIivEXT( GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetTexParameterIivEXT)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetTexParameterIivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetTexParameterIivEXT( target, pname, params ); + funcs->ext.p_glGetTexParameterIivEXT( target, pname, params ); } static void WINAPI wine_glGetTexParameterIuiv( GLenum target, GLenum pname, GLuint* params ) { - void (*func_glGetTexParameterIuiv)( GLenum, GLenum, GLuint* ) = extension_funcs[EXT_glGetTexParameterIuiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetTexParameterIuiv( target, pname, params ); + funcs->ext.p_glGetTexParameterIuiv( target, pname, params ); } static void WINAPI wine_glGetTexParameterIuivEXT( GLenum target, GLenum pname, GLuint* params ) { - void (*func_glGetTexParameterIuivEXT)( GLenum, GLenum, GLuint* ) = extension_funcs[EXT_glGetTexParameterIuivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetTexParameterIuivEXT( target, pname, params ); + funcs->ext.p_glGetTexParameterIuivEXT( target, pname, params ); } static void WINAPI wine_glGetTexParameterPointervAPPLE( GLenum target, GLenum pname, GLvoid** params ) { - void (*func_glGetTexParameterPointervAPPLE)( GLenum, GLenum, GLvoid** ) = extension_funcs[EXT_glGetTexParameterPointervAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glGetTexParameterPointervAPPLE( target, pname, params ); + funcs->ext.p_glGetTexParameterPointervAPPLE( target, pname, params ); } static UINT64 WINAPI wine_glGetTextureHandleNV( GLuint texture ) { - UINT64 (*func_glGetTextureHandleNV)( GLuint ) = extension_funcs[EXT_glGetTextureHandleNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", texture ); - return func_glGetTextureHandleNV( texture ); + return funcs->ext.p_glGetTextureHandleNV( texture ); } static void WINAPI wine_glGetTextureImageEXT( GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glGetTextureImageEXT)( GLuint, GLenum, GLint, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glGetTextureImageEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %p)\n", texture, target, level, format, type, pixels ); - func_glGetTextureImageEXT( texture, target, level, format, type, pixels ); + funcs->ext.p_glGetTextureImageEXT( texture, target, level, format, type, pixels ); } static void WINAPI wine_glGetTextureLevelParameterfvEXT( GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat* params ) { - void (*func_glGetTextureLevelParameterfvEXT)( GLuint, GLenum, GLint, GLenum, GLfloat* ) = extension_funcs[EXT_glGetTextureLevelParameterfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", texture, target, level, pname, params ); - func_glGetTextureLevelParameterfvEXT( texture, target, level, pname, params ); + funcs->ext.p_glGetTextureLevelParameterfvEXT( texture, target, level, pname, params ); } static void WINAPI wine_glGetTextureLevelParameterivEXT( GLuint texture, GLenum target, GLint level, GLenum pname, GLint* params ) { - void (*func_glGetTextureLevelParameterivEXT)( GLuint, GLenum, GLint, GLenum, GLint* ) = extension_funcs[EXT_glGetTextureLevelParameterivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", texture, target, level, pname, params ); - func_glGetTextureLevelParameterivEXT( texture, target, level, pname, params ); + funcs->ext.p_glGetTextureLevelParameterivEXT( texture, target, level, pname, params ); } static void WINAPI wine_glGetTextureParameterIivEXT( GLuint texture, GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetTextureParameterIivEXT)( GLuint, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetTextureParameterIivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texture, target, pname, params ); - func_glGetTextureParameterIivEXT( texture, target, pname, params ); + funcs->ext.p_glGetTextureParameterIivEXT( texture, target, pname, params ); } static void WINAPI wine_glGetTextureParameterIuivEXT( GLuint texture, GLenum target, GLenum pname, GLuint* params ) { - void (*func_glGetTextureParameterIuivEXT)( GLuint, GLenum, GLenum, GLuint* ) = extension_funcs[EXT_glGetTextureParameterIuivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texture, target, pname, params ); - func_glGetTextureParameterIuivEXT( texture, target, pname, params ); + funcs->ext.p_glGetTextureParameterIuivEXT( texture, target, pname, params ); } static void WINAPI wine_glGetTextureParameterfvEXT( GLuint texture, GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glGetTextureParameterfvEXT)( GLuint, GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glGetTextureParameterfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texture, target, pname, params ); - func_glGetTextureParameterfvEXT( texture, target, pname, params ); + funcs->ext.p_glGetTextureParameterfvEXT( texture, target, pname, params ); } static void WINAPI wine_glGetTextureParameterivEXT( GLuint texture, GLenum target, GLenum pname, GLint* params ) { - void (*func_glGetTextureParameterivEXT)( GLuint, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glGetTextureParameterivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texture, target, pname, params ); - func_glGetTextureParameterivEXT( texture, target, pname, params ); + funcs->ext.p_glGetTextureParameterivEXT( texture, target, pname, params ); } static UINT64 WINAPI wine_glGetTextureSamplerHandleNV( GLuint texture, GLuint sampler ) { - UINT64 (*func_glGetTextureSamplerHandleNV)( GLuint, GLuint ) = extension_funcs[EXT_glGetTextureSamplerHandleNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", texture, sampler ); - return func_glGetTextureSamplerHandleNV( texture, sampler ); + return funcs->ext.p_glGetTextureSamplerHandleNV( texture, sampler ); } static void WINAPI wine_glGetTrackMatrixivNV( GLenum target, GLuint address, GLenum pname, GLint* params ) { - void (*func_glGetTrackMatrixivNV)( GLenum, GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetTrackMatrixivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, address, pname, params ); - func_glGetTrackMatrixivNV( target, address, pname, params ); + funcs->ext.p_glGetTrackMatrixivNV( target, address, pname, params ); } static void WINAPI wine_glGetTransformFeedbackVarying( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, char* name ) { - void (*func_glGetTransformFeedbackVarying)( GLuint, GLuint, GLsizei, GLsizei*, GLsizei*, GLenum*, char* ) = extension_funcs[EXT_glGetTransformFeedbackVarying]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %p, %p, %p)\n", program, index, bufSize, length, size, type, name ); - func_glGetTransformFeedbackVarying( program, index, bufSize, length, size, type, name ); + funcs->ext.p_glGetTransformFeedbackVarying( program, index, bufSize, length, size, type, name ); } static void WINAPI wine_glGetTransformFeedbackVaryingEXT( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, char* name ) { - void (*func_glGetTransformFeedbackVaryingEXT)( GLuint, GLuint, GLsizei, GLsizei*, GLsizei*, GLenum*, char* ) = extension_funcs[EXT_glGetTransformFeedbackVaryingEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %p, %p, %p)\n", program, index, bufSize, length, size, type, name ); - func_glGetTransformFeedbackVaryingEXT( program, index, bufSize, length, size, type, name ); + funcs->ext.p_glGetTransformFeedbackVaryingEXT( program, index, bufSize, length, size, type, name ); } static void WINAPI wine_glGetTransformFeedbackVaryingNV( GLuint program, GLuint index, GLint* location ) { - void (*func_glGetTransformFeedbackVaryingNV)( GLuint, GLuint, GLint* ) = extension_funcs[EXT_glGetTransformFeedbackVaryingNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", program, index, location ); - func_glGetTransformFeedbackVaryingNV( program, index, location ); + funcs->ext.p_glGetTransformFeedbackVaryingNV( program, index, location ); } static GLuint WINAPI wine_glGetUniformBlockIndex( GLuint program, char* uniformBlockName ) { - GLuint (*func_glGetUniformBlockIndex)( GLuint, char* ) = extension_funcs[EXT_glGetUniformBlockIndex]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", program, uniformBlockName ); - return func_glGetUniformBlockIndex( program, uniformBlockName ); + return funcs->ext.p_glGetUniformBlockIndex( program, uniformBlockName ); } static GLint WINAPI wine_glGetUniformBufferSizeEXT( GLuint program, GLint location ) { - GLint (*func_glGetUniformBufferSizeEXT)( GLuint, GLint ) = extension_funcs[EXT_glGetUniformBufferSizeEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", program, location ); - return func_glGetUniformBufferSizeEXT( program, location ); + return funcs->ext.p_glGetUniformBufferSizeEXT( program, location ); } static void WINAPI wine_glGetUniformIndices( GLuint program, GLsizei uniformCount, char* const* uniformNames, GLuint* uniformIndices ) { - void (*func_glGetUniformIndices)( GLuint, GLsizei, char* const*, GLuint* ) = extension_funcs[EXT_glGetUniformIndices]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", program, uniformCount, uniformNames, uniformIndices ); - func_glGetUniformIndices( program, uniformCount, uniformNames, uniformIndices ); + funcs->ext.p_glGetUniformIndices( program, uniformCount, uniformNames, uniformIndices ); } static GLint WINAPI wine_glGetUniformLocation( GLuint program, char* name ) { - GLint (*func_glGetUniformLocation)( GLuint, char* ) = extension_funcs[EXT_glGetUniformLocation]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", program, name ); - return func_glGetUniformLocation( program, name ); + return funcs->ext.p_glGetUniformLocation( program, name ); } static GLint WINAPI wine_glGetUniformLocationARB( unsigned int programObj, char* name ) { - GLint (*func_glGetUniformLocationARB)( unsigned int, char* ) = extension_funcs[EXT_glGetUniformLocationARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", programObj, name ); - return func_glGetUniformLocationARB( programObj, name ); + return funcs->ext.p_glGetUniformLocationARB( programObj, name ); } static INT_PTR WINAPI wine_glGetUniformOffsetEXT( GLuint program, GLint location ) { - INT_PTR (*func_glGetUniformOffsetEXT)( GLuint, GLint ) = extension_funcs[EXT_glGetUniformOffsetEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", program, location ); - return func_glGetUniformOffsetEXT( program, location ); + return funcs->ext.p_glGetUniformOffsetEXT( program, location ); } static void WINAPI wine_glGetUniformSubroutineuiv( GLenum shadertype, GLint location, GLuint* params ) { - void (*func_glGetUniformSubroutineuiv)( GLenum, GLint, GLuint* ) = extension_funcs[EXT_glGetUniformSubroutineuiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", shadertype, location, params ); - func_glGetUniformSubroutineuiv( shadertype, location, params ); + funcs->ext.p_glGetUniformSubroutineuiv( shadertype, location, params ); } static void WINAPI wine_glGetUniformdv( GLuint program, GLint location, GLdouble* params ) { - void (*func_glGetUniformdv)( GLuint, GLint, GLdouble* ) = extension_funcs[EXT_glGetUniformdv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", program, location, params ); - func_glGetUniformdv( program, location, params ); + funcs->ext.p_glGetUniformdv( program, location, params ); } static void WINAPI wine_glGetUniformfv( GLuint program, GLint location, GLfloat* params ) { - void (*func_glGetUniformfv)( GLuint, GLint, GLfloat* ) = extension_funcs[EXT_glGetUniformfv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", program, location, params ); - func_glGetUniformfv( program, location, params ); + funcs->ext.p_glGetUniformfv( program, location, params ); } static void WINAPI wine_glGetUniformfvARB( unsigned int programObj, GLint location, GLfloat* params ) { - void (*func_glGetUniformfvARB)( unsigned int, GLint, GLfloat* ) = extension_funcs[EXT_glGetUniformfvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", programObj, location, params ); - func_glGetUniformfvARB( programObj, location, params ); + funcs->ext.p_glGetUniformfvARB( programObj, location, params ); } static void WINAPI wine_glGetUniformi64vNV( GLuint program, GLint location, INT64* params ) { - void (*func_glGetUniformi64vNV)( GLuint, GLint, INT64* ) = extension_funcs[EXT_glGetUniformi64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", program, location, params ); - func_glGetUniformi64vNV( program, location, params ); + funcs->ext.p_glGetUniformi64vNV( program, location, params ); } static void WINAPI wine_glGetUniformiv( GLuint program, GLint location, GLint* params ) { - void (*func_glGetUniformiv)( GLuint, GLint, GLint* ) = extension_funcs[EXT_glGetUniformiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", program, location, params ); - func_glGetUniformiv( program, location, params ); + funcs->ext.p_glGetUniformiv( program, location, params ); } static void WINAPI wine_glGetUniformivARB( unsigned int programObj, GLint location, GLint* params ) { - void (*func_glGetUniformivARB)( unsigned int, GLint, GLint* ) = extension_funcs[EXT_glGetUniformivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", programObj, location, params ); - func_glGetUniformivARB( programObj, location, params ); + funcs->ext.p_glGetUniformivARB( programObj, location, params ); } static void WINAPI wine_glGetUniformui64vNV( GLuint program, GLint location, UINT64* params ) { - void (*func_glGetUniformui64vNV)( GLuint, GLint, UINT64* ) = extension_funcs[EXT_glGetUniformui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", program, location, params ); - func_glGetUniformui64vNV( program, location, params ); + funcs->ext.p_glGetUniformui64vNV( program, location, params ); } static void WINAPI wine_glGetUniformuiv( GLuint program, GLint location, GLuint* params ) { - void (*func_glGetUniformuiv)( GLuint, GLint, GLuint* ) = extension_funcs[EXT_glGetUniformuiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", program, location, params ); - func_glGetUniformuiv( program, location, params ); + funcs->ext.p_glGetUniformuiv( program, location, params ); } static void WINAPI wine_glGetUniformuivEXT( GLuint program, GLint location, GLuint* params ) { - void (*func_glGetUniformuivEXT)( GLuint, GLint, GLuint* ) = extension_funcs[EXT_glGetUniformuivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", program, location, params ); - func_glGetUniformuivEXT( program, location, params ); + funcs->ext.p_glGetUniformuivEXT( program, location, params ); } static void WINAPI wine_glGetVariantArrayObjectfvATI( GLuint id, GLenum pname, GLfloat* params ) { - void (*func_glGetVariantArrayObjectfvATI)( GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glGetVariantArrayObjectfvATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, pname, params ); - func_glGetVariantArrayObjectfvATI( id, pname, params ); + funcs->ext.p_glGetVariantArrayObjectfvATI( id, pname, params ); } static void WINAPI wine_glGetVariantArrayObjectivATI( GLuint id, GLenum pname, GLint* params ) { - void (*func_glGetVariantArrayObjectivATI)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetVariantArrayObjectivATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, pname, params ); - func_glGetVariantArrayObjectivATI( id, pname, params ); + funcs->ext.p_glGetVariantArrayObjectivATI( id, pname, params ); } static void WINAPI wine_glGetVariantBooleanvEXT( GLuint id, GLenum value, GLboolean* data ) { - void (*func_glGetVariantBooleanvEXT)( GLuint, GLenum, GLboolean* ) = extension_funcs[EXT_glGetVariantBooleanvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, value, data ); - func_glGetVariantBooleanvEXT( id, value, data ); + funcs->ext.p_glGetVariantBooleanvEXT( id, value, data ); } static void WINAPI wine_glGetVariantFloatvEXT( GLuint id, GLenum value, GLfloat* data ) { - void (*func_glGetVariantFloatvEXT)( GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glGetVariantFloatvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, value, data ); - func_glGetVariantFloatvEXT( id, value, data ); + funcs->ext.p_glGetVariantFloatvEXT( id, value, data ); } static void WINAPI wine_glGetVariantIntegervEXT( GLuint id, GLenum value, GLint* data ) { - void (*func_glGetVariantIntegervEXT)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetVariantIntegervEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, value, data ); - func_glGetVariantIntegervEXT( id, value, data ); + funcs->ext.p_glGetVariantIntegervEXT( id, value, data ); } static void WINAPI wine_glGetVariantPointervEXT( GLuint id, GLenum value, GLvoid** data ) { - void (*func_glGetVariantPointervEXT)( GLuint, GLenum, GLvoid** ) = extension_funcs[EXT_glGetVariantPointervEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, value, data ); - func_glGetVariantPointervEXT( id, value, data ); + funcs->ext.p_glGetVariantPointervEXT( id, value, data ); } static GLint WINAPI wine_glGetVaryingLocationNV( GLuint program, char* name ) { - GLint (*func_glGetVaryingLocationNV)( GLuint, char* ) = extension_funcs[EXT_glGetVaryingLocationNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", program, name ); - return func_glGetVaryingLocationNV( program, name ); + return funcs->ext.p_glGetVaryingLocationNV( program, name ); } static void WINAPI wine_glGetVertexAttribArrayObjectfvATI( GLuint index, GLenum pname, GLfloat* params ) { - void (*func_glGetVertexAttribArrayObjectfvATI)( GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glGetVertexAttribArrayObjectfvATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribArrayObjectfvATI( index, pname, params ); + funcs->ext.p_glGetVertexAttribArrayObjectfvATI( index, pname, params ); } static void WINAPI wine_glGetVertexAttribArrayObjectivATI( GLuint index, GLenum pname, GLint* params ) { - void (*func_glGetVertexAttribArrayObjectivATI)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetVertexAttribArrayObjectivATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribArrayObjectivATI( index, pname, params ); + funcs->ext.p_glGetVertexAttribArrayObjectivATI( index, pname, params ); } static void WINAPI wine_glGetVertexAttribIiv( GLuint index, GLenum pname, GLint* params ) { - void (*func_glGetVertexAttribIiv)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetVertexAttribIiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribIiv( index, pname, params ); + funcs->ext.p_glGetVertexAttribIiv( index, pname, params ); } static void WINAPI wine_glGetVertexAttribIivEXT( GLuint index, GLenum pname, GLint* params ) { - void (*func_glGetVertexAttribIivEXT)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetVertexAttribIivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribIivEXT( index, pname, params ); + funcs->ext.p_glGetVertexAttribIivEXT( index, pname, params ); } static void WINAPI wine_glGetVertexAttribIuiv( GLuint index, GLenum pname, GLuint* params ) { - void (*func_glGetVertexAttribIuiv)( GLuint, GLenum, GLuint* ) = extension_funcs[EXT_glGetVertexAttribIuiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribIuiv( index, pname, params ); + funcs->ext.p_glGetVertexAttribIuiv( index, pname, params ); } static void WINAPI wine_glGetVertexAttribIuivEXT( GLuint index, GLenum pname, GLuint* params ) { - void (*func_glGetVertexAttribIuivEXT)( GLuint, GLenum, GLuint* ) = extension_funcs[EXT_glGetVertexAttribIuivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribIuivEXT( index, pname, params ); + funcs->ext.p_glGetVertexAttribIuivEXT( index, pname, params ); } static void WINAPI wine_glGetVertexAttribLdv( GLuint index, GLenum pname, GLdouble* params ) { - void (*func_glGetVertexAttribLdv)( GLuint, GLenum, GLdouble* ) = extension_funcs[EXT_glGetVertexAttribLdv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribLdv( index, pname, params ); + funcs->ext.p_glGetVertexAttribLdv( index, pname, params ); } static void WINAPI wine_glGetVertexAttribLdvEXT( GLuint index, GLenum pname, GLdouble* params ) { - void (*func_glGetVertexAttribLdvEXT)( GLuint, GLenum, GLdouble* ) = extension_funcs[EXT_glGetVertexAttribLdvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribLdvEXT( index, pname, params ); + funcs->ext.p_glGetVertexAttribLdvEXT( index, pname, params ); } static void WINAPI wine_glGetVertexAttribLi64vNV( GLuint index, GLenum pname, INT64* params ) { - void (*func_glGetVertexAttribLi64vNV)( GLuint, GLenum, INT64* ) = extension_funcs[EXT_glGetVertexAttribLi64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribLi64vNV( index, pname, params ); + funcs->ext.p_glGetVertexAttribLi64vNV( index, pname, params ); } static void WINAPI wine_glGetVertexAttribLui64vNV( GLuint index, GLenum pname, UINT64* params ) { - void (*func_glGetVertexAttribLui64vNV)( GLuint, GLenum, UINT64* ) = extension_funcs[EXT_glGetVertexAttribLui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribLui64vNV( index, pname, params ); + funcs->ext.p_glGetVertexAttribLui64vNV( index, pname, params ); } static void WINAPI wine_glGetVertexAttribPointerv( GLuint index, GLenum pname, GLvoid** pointer ) { - void (*func_glGetVertexAttribPointerv)( GLuint, GLenum, GLvoid** ) = extension_funcs[EXT_glGetVertexAttribPointerv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, pointer ); - func_glGetVertexAttribPointerv( index, pname, pointer ); + funcs->ext.p_glGetVertexAttribPointerv( index, pname, pointer ); } static void WINAPI wine_glGetVertexAttribPointervARB( GLuint index, GLenum pname, GLvoid** pointer ) { - void (*func_glGetVertexAttribPointervARB)( GLuint, GLenum, GLvoid** ) = extension_funcs[EXT_glGetVertexAttribPointervARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, pointer ); - func_glGetVertexAttribPointervARB( index, pname, pointer ); + funcs->ext.p_glGetVertexAttribPointervARB( index, pname, pointer ); } static void WINAPI wine_glGetVertexAttribPointervNV( GLuint index, GLenum pname, GLvoid** pointer ) { - void (*func_glGetVertexAttribPointervNV)( GLuint, GLenum, GLvoid** ) = extension_funcs[EXT_glGetVertexAttribPointervNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, pointer ); - func_glGetVertexAttribPointervNV( index, pname, pointer ); + funcs->ext.p_glGetVertexAttribPointervNV( index, pname, pointer ); } static void WINAPI wine_glGetVertexAttribdv( GLuint index, GLenum pname, GLdouble* params ) { - void (*func_glGetVertexAttribdv)( GLuint, GLenum, GLdouble* ) = extension_funcs[EXT_glGetVertexAttribdv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribdv( index, pname, params ); + funcs->ext.p_glGetVertexAttribdv( index, pname, params ); } static void WINAPI wine_glGetVertexAttribdvARB( GLuint index, GLenum pname, GLdouble* params ) { - void (*func_glGetVertexAttribdvARB)( GLuint, GLenum, GLdouble* ) = extension_funcs[EXT_glGetVertexAttribdvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribdvARB( index, pname, params ); + funcs->ext.p_glGetVertexAttribdvARB( index, pname, params ); } static void WINAPI wine_glGetVertexAttribdvNV( GLuint index, GLenum pname, GLdouble* params ) { - void (*func_glGetVertexAttribdvNV)( GLuint, GLenum, GLdouble* ) = extension_funcs[EXT_glGetVertexAttribdvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribdvNV( index, pname, params ); + funcs->ext.p_glGetVertexAttribdvNV( index, pname, params ); } static void WINAPI wine_glGetVertexAttribfv( GLuint index, GLenum pname, GLfloat* params ) { - void (*func_glGetVertexAttribfv)( GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glGetVertexAttribfv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribfv( index, pname, params ); + funcs->ext.p_glGetVertexAttribfv( index, pname, params ); } static void WINAPI wine_glGetVertexAttribfvARB( GLuint index, GLenum pname, GLfloat* params ) { - void (*func_glGetVertexAttribfvARB)( GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glGetVertexAttribfvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribfvARB( index, pname, params ); + funcs->ext.p_glGetVertexAttribfvARB( index, pname, params ); } static void WINAPI wine_glGetVertexAttribfvNV( GLuint index, GLenum pname, GLfloat* params ) { - void (*func_glGetVertexAttribfvNV)( GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glGetVertexAttribfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribfvNV( index, pname, params ); + funcs->ext.p_glGetVertexAttribfvNV( index, pname, params ); } static void WINAPI wine_glGetVertexAttribiv( GLuint index, GLenum pname, GLint* params ) { - void (*func_glGetVertexAttribiv)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetVertexAttribiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribiv( index, pname, params ); + funcs->ext.p_glGetVertexAttribiv( index, pname, params ); } static void WINAPI wine_glGetVertexAttribivARB( GLuint index, GLenum pname, GLint* params ) { - void (*func_glGetVertexAttribivARB)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetVertexAttribivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribivARB( index, pname, params ); + funcs->ext.p_glGetVertexAttribivARB( index, pname, params ); } static void WINAPI wine_glGetVertexAttribivNV( GLuint index, GLenum pname, GLint* params ) { - void (*func_glGetVertexAttribivNV)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetVertexAttribivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, pname, params ); - func_glGetVertexAttribivNV( index, pname, params ); + funcs->ext.p_glGetVertexAttribivNV( index, pname, params ); } static void WINAPI wine_glGetVideoCaptureStreamdvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLdouble* params ) { - void (*func_glGetVideoCaptureStreamdvNV)( GLuint, GLuint, GLenum, GLdouble* ) = extension_funcs[EXT_glGetVideoCaptureStreamdvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", video_capture_slot, stream, pname, params ); - func_glGetVideoCaptureStreamdvNV( video_capture_slot, stream, pname, params ); + funcs->ext.p_glGetVideoCaptureStreamdvNV( video_capture_slot, stream, pname, params ); } static void WINAPI wine_glGetVideoCaptureStreamfvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLfloat* params ) { - void (*func_glGetVideoCaptureStreamfvNV)( GLuint, GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glGetVideoCaptureStreamfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", video_capture_slot, stream, pname, params ); - func_glGetVideoCaptureStreamfvNV( video_capture_slot, stream, pname, params ); + funcs->ext.p_glGetVideoCaptureStreamfvNV( video_capture_slot, stream, pname, params ); } static void WINAPI wine_glGetVideoCaptureStreamivNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLint* params ) { - void (*func_glGetVideoCaptureStreamivNV)( GLuint, GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetVideoCaptureStreamivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", video_capture_slot, stream, pname, params ); - func_glGetVideoCaptureStreamivNV( video_capture_slot, stream, pname, params ); + funcs->ext.p_glGetVideoCaptureStreamivNV( video_capture_slot, stream, pname, params ); } static void WINAPI wine_glGetVideoCaptureivNV( GLuint video_capture_slot, GLenum pname, GLint* params ) { - void (*func_glGetVideoCaptureivNV)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetVideoCaptureivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", video_capture_slot, pname, params ); - func_glGetVideoCaptureivNV( video_capture_slot, pname, params ); + funcs->ext.p_glGetVideoCaptureivNV( video_capture_slot, pname, params ); } static void WINAPI wine_glGetVideoi64vNV( GLuint video_slot, GLenum pname, INT64* params ) { - void (*func_glGetVideoi64vNV)( GLuint, GLenum, INT64* ) = extension_funcs[EXT_glGetVideoi64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", video_slot, pname, params ); - func_glGetVideoi64vNV( video_slot, pname, params ); + funcs->ext.p_glGetVideoi64vNV( video_slot, pname, params ); } static void WINAPI wine_glGetVideoivNV( GLuint video_slot, GLenum pname, GLint* params ) { - void (*func_glGetVideoivNV)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glGetVideoivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", video_slot, pname, params ); - func_glGetVideoivNV( video_slot, pname, params ); + funcs->ext.p_glGetVideoivNV( video_slot, pname, params ); } static void WINAPI wine_glGetVideoui64vNV( GLuint video_slot, GLenum pname, UINT64* params ) { - void (*func_glGetVideoui64vNV)( GLuint, GLenum, UINT64* ) = extension_funcs[EXT_glGetVideoui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", video_slot, pname, params ); - func_glGetVideoui64vNV( video_slot, pname, params ); + funcs->ext.p_glGetVideoui64vNV( video_slot, pname, params ); } static void WINAPI wine_glGetVideouivNV( GLuint video_slot, GLenum pname, GLuint* params ) { - void (*func_glGetVideouivNV)( GLuint, GLenum, GLuint* ) = extension_funcs[EXT_glGetVideouivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", video_slot, pname, params ); - func_glGetVideouivNV( video_slot, pname, params ); + funcs->ext.p_glGetVideouivNV( video_slot, pname, params ); } static void WINAPI wine_glGetnColorTableARB( GLenum target, GLenum format, GLenum type, GLsizei bufSize, GLvoid* table ) { - void (*func_glGetnColorTableARB)( GLenum, GLenum, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glGetnColorTableARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", target, format, type, bufSize, table ); - func_glGetnColorTableARB( target, format, type, bufSize, table ); + funcs->ext.p_glGetnColorTableARB( target, format, type, bufSize, table ); } static void WINAPI wine_glGetnCompressedTexImageARB( GLenum target, GLint lod, GLsizei bufSize, GLvoid* img ) { - void (*func_glGetnCompressedTexImageARB)( GLenum, GLint, GLsizei, GLvoid* ) = extension_funcs[EXT_glGetnCompressedTexImageARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, lod, bufSize, img ); - func_glGetnCompressedTexImageARB( target, lod, bufSize, img ); + funcs->ext.p_glGetnCompressedTexImageARB( target, lod, bufSize, img ); } static void WINAPI wine_glGetnConvolutionFilterARB( GLenum target, GLenum format, GLenum type, GLsizei bufSize, GLvoid* image ) { - void (*func_glGetnConvolutionFilterARB)( GLenum, GLenum, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glGetnConvolutionFilterARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", target, format, type, bufSize, image ); - func_glGetnConvolutionFilterARB( target, format, type, bufSize, image ); + funcs->ext.p_glGetnConvolutionFilterARB( target, format, type, bufSize, image ); } static void WINAPI wine_glGetnHistogramARB( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, GLvoid* values ) { - void (*func_glGetnHistogramARB)( GLenum, GLboolean, GLenum, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glGetnHistogramARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %p)\n", target, reset, format, type, bufSize, values ); - func_glGetnHistogramARB( target, reset, format, type, bufSize, values ); + funcs->ext.p_glGetnHistogramARB( target, reset, format, type, bufSize, values ); } static void WINAPI wine_glGetnMapdvARB( GLenum target, GLenum query, GLsizei bufSize, GLdouble* v ) { - void (*func_glGetnMapdvARB)( GLenum, GLenum, GLsizei, GLdouble* ) = extension_funcs[EXT_glGetnMapdvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, query, bufSize, v ); - func_glGetnMapdvARB( target, query, bufSize, v ); + funcs->ext.p_glGetnMapdvARB( target, query, bufSize, v ); } static void WINAPI wine_glGetnMapfvARB( GLenum target, GLenum query, GLsizei bufSize, GLfloat* v ) { - void (*func_glGetnMapfvARB)( GLenum, GLenum, GLsizei, GLfloat* ) = extension_funcs[EXT_glGetnMapfvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, query, bufSize, v ); - func_glGetnMapfvARB( target, query, bufSize, v ); + funcs->ext.p_glGetnMapfvARB( target, query, bufSize, v ); } static void WINAPI wine_glGetnMapivARB( GLenum target, GLenum query, GLsizei bufSize, GLint* v ) { - void (*func_glGetnMapivARB)( GLenum, GLenum, GLsizei, GLint* ) = extension_funcs[EXT_glGetnMapivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, query, bufSize, v ); - func_glGetnMapivARB( target, query, bufSize, v ); + funcs->ext.p_glGetnMapivARB( target, query, bufSize, v ); } static void WINAPI wine_glGetnMinmaxARB( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, GLvoid* values ) { - void (*func_glGetnMinmaxARB)( GLenum, GLboolean, GLenum, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glGetnMinmaxARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %p)\n", target, reset, format, type, bufSize, values ); - func_glGetnMinmaxARB( target, reset, format, type, bufSize, values ); + funcs->ext.p_glGetnMinmaxARB( target, reset, format, type, bufSize, values ); } static void WINAPI wine_glGetnPixelMapfvARB( GLenum map, GLsizei bufSize, GLfloat* values ) { - void (*func_glGetnPixelMapfvARB)( GLenum, GLsizei, GLfloat* ) = extension_funcs[EXT_glGetnPixelMapfvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", map, bufSize, values ); - func_glGetnPixelMapfvARB( map, bufSize, values ); + funcs->ext.p_glGetnPixelMapfvARB( map, bufSize, values ); } static void WINAPI wine_glGetnPixelMapuivARB( GLenum map, GLsizei bufSize, GLuint* values ) { - void (*func_glGetnPixelMapuivARB)( GLenum, GLsizei, GLuint* ) = extension_funcs[EXT_glGetnPixelMapuivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", map, bufSize, values ); - func_glGetnPixelMapuivARB( map, bufSize, values ); + funcs->ext.p_glGetnPixelMapuivARB( map, bufSize, values ); } static void WINAPI wine_glGetnPixelMapusvARB( GLenum map, GLsizei bufSize, GLushort* values ) { - void (*func_glGetnPixelMapusvARB)( GLenum, GLsizei, GLushort* ) = extension_funcs[EXT_glGetnPixelMapusvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", map, bufSize, values ); - func_glGetnPixelMapusvARB( map, bufSize, values ); + funcs->ext.p_glGetnPixelMapusvARB( map, bufSize, values ); } static void WINAPI wine_glGetnPolygonStippleARB( GLsizei bufSize, GLubyte* pattern ) { - void (*func_glGetnPolygonStippleARB)( GLsizei, GLubyte* ) = extension_funcs[EXT_glGetnPolygonStippleARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", bufSize, pattern ); - func_glGetnPolygonStippleARB( bufSize, pattern ); + funcs->ext.p_glGetnPolygonStippleARB( bufSize, pattern ); } static void WINAPI wine_glGetnSeparableFilterARB( GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, GLvoid* row, GLsizei columnBufSize, GLvoid* column, GLvoid* span ) { - void (*func_glGetnSeparableFilterARB)( GLenum, GLenum, GLenum, GLsizei, GLvoid*, GLsizei, GLvoid*, GLvoid* ) = extension_funcs[EXT_glGetnSeparableFilterARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p, %d, %p, %p)\n", target, format, type, rowBufSize, row, columnBufSize, column, span ); - func_glGetnSeparableFilterARB( target, format, type, rowBufSize, row, columnBufSize, column, span ); + funcs->ext.p_glGetnSeparableFilterARB( target, format, type, rowBufSize, row, columnBufSize, column, span ); } static void WINAPI wine_glGetnTexImageARB( GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, GLvoid* img ) { - void (*func_glGetnTexImageARB)( GLenum, GLint, GLenum, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glGetnTexImageARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %p)\n", target, level, format, type, bufSize, img ); - func_glGetnTexImageARB( target, level, format, type, bufSize, img ); + funcs->ext.p_glGetnTexImageARB( target, level, format, type, bufSize, img ); } static void WINAPI wine_glGetnUniformdvARB( GLuint program, GLint location, GLsizei bufSize, GLdouble* params ) { - void (*func_glGetnUniformdvARB)( GLuint, GLint, GLsizei, GLdouble* ) = extension_funcs[EXT_glGetnUniformdvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, bufSize, params ); - func_glGetnUniformdvARB( program, location, bufSize, params ); + funcs->ext.p_glGetnUniformdvARB( program, location, bufSize, params ); } static void WINAPI wine_glGetnUniformfvARB( GLuint program, GLint location, GLsizei bufSize, GLfloat* params ) { - void (*func_glGetnUniformfvARB)( GLuint, GLint, GLsizei, GLfloat* ) = extension_funcs[EXT_glGetnUniformfvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, bufSize, params ); - func_glGetnUniformfvARB( program, location, bufSize, params ); + funcs->ext.p_glGetnUniformfvARB( program, location, bufSize, params ); } static void WINAPI wine_glGetnUniformivARB( GLuint program, GLint location, GLsizei bufSize, GLint* params ) { - void (*func_glGetnUniformivARB)( GLuint, GLint, GLsizei, GLint* ) = extension_funcs[EXT_glGetnUniformivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, bufSize, params ); - func_glGetnUniformivARB( program, location, bufSize, params ); + funcs->ext.p_glGetnUniformivARB( program, location, bufSize, params ); } static void WINAPI wine_glGetnUniformuivARB( GLuint program, GLint location, GLsizei bufSize, GLuint* params ) { - void (*func_glGetnUniformuivARB)( GLuint, GLint, GLsizei, GLuint* ) = extension_funcs[EXT_glGetnUniformuivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, bufSize, params ); - func_glGetnUniformuivARB( program, location, bufSize, params ); + funcs->ext.p_glGetnUniformuivARB( program, location, bufSize, params ); } static void WINAPI wine_glGlobalAlphaFactorbSUN( GLbyte factor ) { - void (*func_glGlobalAlphaFactorbSUN)( GLbyte ) = extension_funcs[EXT_glGlobalAlphaFactorbSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", factor ); - func_glGlobalAlphaFactorbSUN( factor ); + funcs->ext.p_glGlobalAlphaFactorbSUN( factor ); } static void WINAPI wine_glGlobalAlphaFactordSUN( GLdouble factor ) { - void (*func_glGlobalAlphaFactordSUN)( GLdouble ) = extension_funcs[EXT_glGlobalAlphaFactordSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f)\n", factor ); - func_glGlobalAlphaFactordSUN( factor ); + funcs->ext.p_glGlobalAlphaFactordSUN( factor ); } static void WINAPI wine_glGlobalAlphaFactorfSUN( GLfloat factor ) { - void (*func_glGlobalAlphaFactorfSUN)( GLfloat ) = extension_funcs[EXT_glGlobalAlphaFactorfSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f)\n", factor ); - func_glGlobalAlphaFactorfSUN( factor ); + funcs->ext.p_glGlobalAlphaFactorfSUN( factor ); } static void WINAPI wine_glGlobalAlphaFactoriSUN( GLint factor ) { - void (*func_glGlobalAlphaFactoriSUN)( GLint ) = extension_funcs[EXT_glGlobalAlphaFactoriSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", factor ); - func_glGlobalAlphaFactoriSUN( factor ); + funcs->ext.p_glGlobalAlphaFactoriSUN( factor ); } static void WINAPI wine_glGlobalAlphaFactorsSUN( GLshort factor ) { - void (*func_glGlobalAlphaFactorsSUN)( GLshort ) = extension_funcs[EXT_glGlobalAlphaFactorsSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", factor ); - func_glGlobalAlphaFactorsSUN( factor ); + funcs->ext.p_glGlobalAlphaFactorsSUN( factor ); } static void WINAPI wine_glGlobalAlphaFactorubSUN( GLubyte factor ) { - void (*func_glGlobalAlphaFactorubSUN)( GLubyte ) = extension_funcs[EXT_glGlobalAlphaFactorubSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", factor ); - func_glGlobalAlphaFactorubSUN( factor ); + funcs->ext.p_glGlobalAlphaFactorubSUN( factor ); } static void WINAPI wine_glGlobalAlphaFactoruiSUN( GLuint factor ) { - void (*func_glGlobalAlphaFactoruiSUN)( GLuint ) = extension_funcs[EXT_glGlobalAlphaFactoruiSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", factor ); - func_glGlobalAlphaFactoruiSUN( factor ); + funcs->ext.p_glGlobalAlphaFactoruiSUN( factor ); } static void WINAPI wine_glGlobalAlphaFactorusSUN( GLushort factor ) { - void (*func_glGlobalAlphaFactorusSUN)( GLushort ) = extension_funcs[EXT_glGlobalAlphaFactorusSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", factor ); - func_glGlobalAlphaFactorusSUN( factor ); + funcs->ext.p_glGlobalAlphaFactorusSUN( factor ); } static void WINAPI wine_glHintPGI( GLenum target, GLint mode ) { - void (*func_glHintPGI)( GLenum, GLint ) = extension_funcs[EXT_glHintPGI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, mode ); - func_glHintPGI( target, mode ); + funcs->ext.p_glHintPGI( target, mode ); } static void WINAPI wine_glHistogram( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink ) { - void (*func_glHistogram)( GLenum, GLsizei, GLenum, GLboolean ) = extension_funcs[EXT_glHistogram]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", target, width, internalformat, sink ); - func_glHistogram( target, width, internalformat, sink ); + funcs->ext.p_glHistogram( target, width, internalformat, sink ); } static void WINAPI wine_glHistogramEXT( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink ) { - void (*func_glHistogramEXT)( GLenum, GLsizei, GLenum, GLboolean ) = extension_funcs[EXT_glHistogramEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", target, width, internalformat, sink ); - func_glHistogramEXT( target, width, internalformat, sink ); + funcs->ext.p_glHistogramEXT( target, width, internalformat, sink ); } static void WINAPI wine_glIglooInterfaceSGIX( GLenum pname, GLvoid* params ) { - void (*func_glIglooInterfaceSGIX)( GLenum, GLvoid* ) = extension_funcs[EXT_glIglooInterfaceSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glIglooInterfaceSGIX( pname, params ); + funcs->ext.p_glIglooInterfaceSGIX( pname, params ); } static void WINAPI wine_glImageTransformParameterfHP( GLenum target, GLenum pname, GLfloat param ) { - void (*func_glImageTransformParameterfHP)( GLenum, GLenum, GLfloat ) = extension_funcs[EXT_glImageTransformParameterfHP]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f)\n", target, pname, param ); - func_glImageTransformParameterfHP( target, pname, param ); + funcs->ext.p_glImageTransformParameterfHP( target, pname, param ); } static void WINAPI wine_glImageTransformParameterfvHP( GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glImageTransformParameterfvHP)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glImageTransformParameterfvHP]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glImageTransformParameterfvHP( target, pname, params ); + funcs->ext.p_glImageTransformParameterfvHP( target, pname, params ); } static void WINAPI wine_glImageTransformParameteriHP( GLenum target, GLenum pname, GLint param ) { - void (*func_glImageTransformParameteriHP)( GLenum, GLenum, GLint ) = extension_funcs[EXT_glImageTransformParameteriHP]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, pname, param ); - func_glImageTransformParameteriHP( target, pname, param ); + funcs->ext.p_glImageTransformParameteriHP( target, pname, param ); } static void WINAPI wine_glImageTransformParameterivHP( GLenum target, GLenum pname, GLint* params ) { - void (*func_glImageTransformParameterivHP)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glImageTransformParameterivHP]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glImageTransformParameterivHP( target, pname, params ); + funcs->ext.p_glImageTransformParameterivHP( target, pname, params ); } static GLvoid* WINAPI wine_glImportSyncEXT( GLenum external_sync_type, INT_PTR external_sync, GLbitfield flags ) { - GLvoid* (*func_glImportSyncEXT)( GLenum, INT_PTR, GLbitfield ) = extension_funcs[EXT_glImportSyncEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %ld, %d)\n", external_sync_type, external_sync, flags ); - return func_glImportSyncEXT( external_sync_type, external_sync, flags ); + return funcs->ext.p_glImportSyncEXT( external_sync_type, external_sync, flags ); } static void WINAPI wine_glIndexFormatNV( GLenum type, GLsizei stride ) { - void (*func_glIndexFormatNV)( GLenum, GLsizei ) = extension_funcs[EXT_glIndexFormatNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", type, stride ); - func_glIndexFormatNV( type, stride ); + funcs->ext.p_glIndexFormatNV( type, stride ); } static void WINAPI wine_glIndexFuncEXT( GLenum func, GLclampf ref ) { - void (*func_glIndexFuncEXT)( GLenum, GLclampf ) = extension_funcs[EXT_glIndexFuncEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", func, ref ); - func_glIndexFuncEXT( func, ref ); + funcs->ext.p_glIndexFuncEXT( func, ref ); } static void WINAPI wine_glIndexMaterialEXT( GLenum face, GLenum mode ) { - void (*func_glIndexMaterialEXT)( GLenum, GLenum ) = extension_funcs[EXT_glIndexMaterialEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", face, mode ); - func_glIndexMaterialEXT( face, mode ); + funcs->ext.p_glIndexMaterialEXT( face, mode ); } static void WINAPI wine_glIndexPointerEXT( GLenum type, GLsizei stride, GLsizei count, GLvoid* pointer ) { - void (*func_glIndexPointerEXT)( GLenum, GLsizei, GLsizei, GLvoid* ) = extension_funcs[EXT_glIndexPointerEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", type, stride, count, pointer ); - func_glIndexPointerEXT( type, stride, count, pointer ); + funcs->ext.p_glIndexPointerEXT( type, stride, count, pointer ); } static void WINAPI wine_glIndexPointerListIBM( GLenum type, GLint stride, GLvoid** pointer, GLint ptrstride ) { - void (*func_glIndexPointerListIBM)( GLenum, GLint, GLvoid**, GLint ) = extension_funcs[EXT_glIndexPointerListIBM]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %d)\n", type, stride, pointer, ptrstride ); - func_glIndexPointerListIBM( type, stride, pointer, ptrstride ); + funcs->ext.p_glIndexPointerListIBM( type, stride, pointer, ptrstride ); } static void WINAPI wine_glInsertComponentEXT( GLuint res, GLuint src, GLuint num ) { - void (*func_glInsertComponentEXT)( GLuint, GLuint, GLuint ) = extension_funcs[EXT_glInsertComponentEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", res, src, num ); - func_glInsertComponentEXT( res, src, num ); + funcs->ext.p_glInsertComponentEXT( res, src, num ); } static void WINAPI wine_glInstrumentsBufferSGIX( GLsizei size, GLint* buffer ) { - void (*func_glInstrumentsBufferSGIX)( GLsizei, GLint* ) = extension_funcs[EXT_glInstrumentsBufferSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", size, buffer ); - func_glInstrumentsBufferSGIX( size, buffer ); + funcs->ext.p_glInstrumentsBufferSGIX( size, buffer ); } static void WINAPI wine_glInterpolatePathsNV( GLuint resultPath, GLuint pathA, GLuint pathB, GLfloat weight ) { - void (*func_glInterpolatePathsNV)( GLuint, GLuint, GLuint, GLfloat ) = extension_funcs[EXT_glInterpolatePathsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %f)\n", resultPath, pathA, pathB, weight ); - func_glInterpolatePathsNV( resultPath, pathA, pathB, weight ); + funcs->ext.p_glInterpolatePathsNV( resultPath, pathA, pathB, weight ); } static GLboolean WINAPI wine_glIsAsyncMarkerSGIX( GLuint marker ) { - GLboolean (*func_glIsAsyncMarkerSGIX)( GLuint ) = extension_funcs[EXT_glIsAsyncMarkerSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", marker ); - return func_glIsAsyncMarkerSGIX( marker ); + return funcs->ext.p_glIsAsyncMarkerSGIX( marker ); } static GLboolean WINAPI wine_glIsBuffer( GLuint buffer ) { - GLboolean (*func_glIsBuffer)( GLuint ) = extension_funcs[EXT_glIsBuffer]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", buffer ); - return func_glIsBuffer( buffer ); + return funcs->ext.p_glIsBuffer( buffer ); } static GLboolean WINAPI wine_glIsBufferARB( GLuint buffer ) { - GLboolean (*func_glIsBufferARB)( GLuint ) = extension_funcs[EXT_glIsBufferARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", buffer ); - return func_glIsBufferARB( buffer ); + return funcs->ext.p_glIsBufferARB( buffer ); } static GLboolean WINAPI wine_glIsBufferResidentNV( GLenum target ) { - GLboolean (*func_glIsBufferResidentNV)( GLenum ) = extension_funcs[EXT_glIsBufferResidentNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", target ); - return func_glIsBufferResidentNV( target ); + return funcs->ext.p_glIsBufferResidentNV( target ); } static GLboolean WINAPI wine_glIsEnabledIndexedEXT( GLenum target, GLuint index ) { - GLboolean (*func_glIsEnabledIndexedEXT)( GLenum, GLuint ) = extension_funcs[EXT_glIsEnabledIndexedEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, index ); - return func_glIsEnabledIndexedEXT( target, index ); + return funcs->ext.p_glIsEnabledIndexedEXT( target, index ); } static GLboolean WINAPI wine_glIsEnabledi( GLenum target, GLuint index ) { - GLboolean (*func_glIsEnabledi)( GLenum, GLuint ) = extension_funcs[EXT_glIsEnabledi]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, index ); - return func_glIsEnabledi( target, index ); + return funcs->ext.p_glIsEnabledi( target, index ); } static GLboolean WINAPI wine_glIsFenceAPPLE( GLuint fence ) { - GLboolean (*func_glIsFenceAPPLE)( GLuint ) = extension_funcs[EXT_glIsFenceAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", fence ); - return func_glIsFenceAPPLE( fence ); + return funcs->ext.p_glIsFenceAPPLE( fence ); } static GLboolean WINAPI wine_glIsFenceNV( GLuint fence ) { - GLboolean (*func_glIsFenceNV)( GLuint ) = extension_funcs[EXT_glIsFenceNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", fence ); - return func_glIsFenceNV( fence ); + return funcs->ext.p_glIsFenceNV( fence ); } static GLboolean WINAPI wine_glIsFramebuffer( GLuint framebuffer ) { - GLboolean (*func_glIsFramebuffer)( GLuint ) = extension_funcs[EXT_glIsFramebuffer]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", framebuffer ); - return func_glIsFramebuffer( framebuffer ); + return funcs->ext.p_glIsFramebuffer( framebuffer ); } static GLboolean WINAPI wine_glIsFramebufferEXT( GLuint framebuffer ) { - GLboolean (*func_glIsFramebufferEXT)( GLuint ) = extension_funcs[EXT_glIsFramebufferEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", framebuffer ); - return func_glIsFramebufferEXT( framebuffer ); + return funcs->ext.p_glIsFramebufferEXT( framebuffer ); } static GLboolean WINAPI wine_glIsImageHandleResidentNV( UINT64 handle ) { - GLboolean (*func_glIsImageHandleResidentNV)( UINT64 ) = extension_funcs[EXT_glIsImageHandleResidentNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%s)\n", wine_dbgstr_longlong(handle) ); - return func_glIsImageHandleResidentNV( handle ); + return funcs->ext.p_glIsImageHandleResidentNV( handle ); } static GLboolean WINAPI wine_glIsNameAMD( GLenum identifier, GLuint name ) { - GLboolean (*func_glIsNameAMD)( GLenum, GLuint ) = extension_funcs[EXT_glIsNameAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", identifier, name ); - return func_glIsNameAMD( identifier, name ); + return funcs->ext.p_glIsNameAMD( identifier, name ); } static GLboolean WINAPI wine_glIsNamedBufferResidentNV( GLuint buffer ) { - GLboolean (*func_glIsNamedBufferResidentNV)( GLuint ) = extension_funcs[EXT_glIsNamedBufferResidentNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", buffer ); - return func_glIsNamedBufferResidentNV( buffer ); + return funcs->ext.p_glIsNamedBufferResidentNV( buffer ); } static GLboolean WINAPI wine_glIsNamedStringARB( GLint namelen, char* name ) { - GLboolean (*func_glIsNamedStringARB)( GLint, char* ) = extension_funcs[EXT_glIsNamedStringARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", namelen, name ); - return func_glIsNamedStringARB( namelen, name ); + return funcs->ext.p_glIsNamedStringARB( namelen, name ); } static GLboolean WINAPI wine_glIsObjectBufferATI( GLuint buffer ) { - GLboolean (*func_glIsObjectBufferATI)( GLuint ) = extension_funcs[EXT_glIsObjectBufferATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", buffer ); - return func_glIsObjectBufferATI( buffer ); + return funcs->ext.p_glIsObjectBufferATI( buffer ); } static GLboolean WINAPI wine_glIsOcclusionQueryNV( GLuint id ) { - GLboolean (*func_glIsOcclusionQueryNV)( GLuint ) = extension_funcs[EXT_glIsOcclusionQueryNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", id ); - return func_glIsOcclusionQueryNV( id ); + return funcs->ext.p_glIsOcclusionQueryNV( id ); } static GLboolean WINAPI wine_glIsPathNV( GLuint path ) { - GLboolean (*func_glIsPathNV)( GLuint ) = extension_funcs[EXT_glIsPathNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", path ); - return func_glIsPathNV( path ); + return funcs->ext.p_glIsPathNV( path ); } static GLboolean WINAPI wine_glIsPointInFillPathNV( GLuint path, GLuint mask, GLfloat x, GLfloat y ) { - GLboolean (*func_glIsPointInFillPathNV)( GLuint, GLuint, GLfloat, GLfloat ) = extension_funcs[EXT_glIsPointInFillPathNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f)\n", path, mask, x, y ); - return func_glIsPointInFillPathNV( path, mask, x, y ); + return funcs->ext.p_glIsPointInFillPathNV( path, mask, x, y ); } static GLboolean WINAPI wine_glIsPointInStrokePathNV( GLuint path, GLfloat x, GLfloat y ) { - GLboolean (*func_glIsPointInStrokePathNV)( GLuint, GLfloat, GLfloat ) = extension_funcs[EXT_glIsPointInStrokePathNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", path, x, y ); - return func_glIsPointInStrokePathNV( path, x, y ); + return funcs->ext.p_glIsPointInStrokePathNV( path, x, y ); } static GLboolean WINAPI wine_glIsProgram( GLuint program ) { - GLboolean (*func_glIsProgram)( GLuint ) = extension_funcs[EXT_glIsProgram]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", program ); - return func_glIsProgram( program ); + return funcs->ext.p_glIsProgram( program ); } static GLboolean WINAPI wine_glIsProgramARB( GLuint program ) { - GLboolean (*func_glIsProgramARB)( GLuint ) = extension_funcs[EXT_glIsProgramARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", program ); - return func_glIsProgramARB( program ); + return funcs->ext.p_glIsProgramARB( program ); } static GLboolean WINAPI wine_glIsProgramNV( GLuint id ) { - GLboolean (*func_glIsProgramNV)( GLuint ) = extension_funcs[EXT_glIsProgramNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", id ); - return func_glIsProgramNV( id ); + return funcs->ext.p_glIsProgramNV( id ); } static GLboolean WINAPI wine_glIsProgramPipeline( GLuint pipeline ) { - GLboolean (*func_glIsProgramPipeline)( GLuint ) = extension_funcs[EXT_glIsProgramPipeline]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", pipeline ); - return func_glIsProgramPipeline( pipeline ); + return funcs->ext.p_glIsProgramPipeline( pipeline ); } static GLboolean WINAPI wine_glIsQuery( GLuint id ) { - GLboolean (*func_glIsQuery)( GLuint ) = extension_funcs[EXT_glIsQuery]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", id ); - return func_glIsQuery( id ); + return funcs->ext.p_glIsQuery( id ); } static GLboolean WINAPI wine_glIsQueryARB( GLuint id ) { - GLboolean (*func_glIsQueryARB)( GLuint ) = extension_funcs[EXT_glIsQueryARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", id ); - return func_glIsQueryARB( id ); + return funcs->ext.p_glIsQueryARB( id ); } static GLboolean WINAPI wine_glIsRenderbuffer( GLuint renderbuffer ) { - GLboolean (*func_glIsRenderbuffer)( GLuint ) = extension_funcs[EXT_glIsRenderbuffer]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", renderbuffer ); - return func_glIsRenderbuffer( renderbuffer ); + return funcs->ext.p_glIsRenderbuffer( renderbuffer ); } static GLboolean WINAPI wine_glIsRenderbufferEXT( GLuint renderbuffer ) { - GLboolean (*func_glIsRenderbufferEXT)( GLuint ) = extension_funcs[EXT_glIsRenderbufferEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", renderbuffer ); - return func_glIsRenderbufferEXT( renderbuffer ); + return funcs->ext.p_glIsRenderbufferEXT( renderbuffer ); } static GLboolean WINAPI wine_glIsSampler( GLuint sampler ) { - GLboolean (*func_glIsSampler)( GLuint ) = extension_funcs[EXT_glIsSampler]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", sampler ); - return func_glIsSampler( sampler ); + return funcs->ext.p_glIsSampler( sampler ); } static GLboolean WINAPI wine_glIsShader( GLuint shader ) { - GLboolean (*func_glIsShader)( GLuint ) = extension_funcs[EXT_glIsShader]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", shader ); - return func_glIsShader( shader ); + return funcs->ext.p_glIsShader( shader ); } static GLboolean WINAPI wine_glIsSync( GLvoid* sync ) { - GLboolean (*func_glIsSync)( GLvoid* ) = extension_funcs[EXT_glIsSync]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", sync ); - return func_glIsSync( sync ); + return funcs->ext.p_glIsSync( sync ); } static GLboolean WINAPI wine_glIsTextureEXT( GLuint texture ) { - GLboolean (*func_glIsTextureEXT)( GLuint ) = extension_funcs[EXT_glIsTextureEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", texture ); - return func_glIsTextureEXT( texture ); + return funcs->ext.p_glIsTextureEXT( texture ); } static GLboolean WINAPI wine_glIsTextureHandleResidentNV( UINT64 handle ) { - GLboolean (*func_glIsTextureHandleResidentNV)( UINT64 ) = extension_funcs[EXT_glIsTextureHandleResidentNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%s)\n", wine_dbgstr_longlong(handle) ); - return func_glIsTextureHandleResidentNV( handle ); + return funcs->ext.p_glIsTextureHandleResidentNV( handle ); } static GLboolean WINAPI wine_glIsTransformFeedback( GLuint id ) { - GLboolean (*func_glIsTransformFeedback)( GLuint ) = extension_funcs[EXT_glIsTransformFeedback]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", id ); - return func_glIsTransformFeedback( id ); + return funcs->ext.p_glIsTransformFeedback( id ); } static GLboolean WINAPI wine_glIsTransformFeedbackNV( GLuint id ) { - GLboolean (*func_glIsTransformFeedbackNV)( GLuint ) = extension_funcs[EXT_glIsTransformFeedbackNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", id ); - return func_glIsTransformFeedbackNV( id ); + return funcs->ext.p_glIsTransformFeedbackNV( id ); } static GLboolean WINAPI wine_glIsVariantEnabledEXT( GLuint id, GLenum cap ) { - GLboolean (*func_glIsVariantEnabledEXT)( GLuint, GLenum ) = extension_funcs[EXT_glIsVariantEnabledEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", id, cap ); - return func_glIsVariantEnabledEXT( id, cap ); + return funcs->ext.p_glIsVariantEnabledEXT( id, cap ); } static GLboolean WINAPI wine_glIsVertexArray( GLuint array ) { - GLboolean (*func_glIsVertexArray)( GLuint ) = extension_funcs[EXT_glIsVertexArray]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", array ); - return func_glIsVertexArray( array ); + return funcs->ext.p_glIsVertexArray( array ); } static GLboolean WINAPI wine_glIsVertexArrayAPPLE( GLuint array ) { - GLboolean (*func_glIsVertexArrayAPPLE)( GLuint ) = extension_funcs[EXT_glIsVertexArrayAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", array ); - return func_glIsVertexArrayAPPLE( array ); + return funcs->ext.p_glIsVertexArrayAPPLE( array ); } static GLboolean WINAPI wine_glIsVertexAttribEnabledAPPLE( GLuint index, GLenum pname ) { - GLboolean (*func_glIsVertexAttribEnabledAPPLE)( GLuint, GLenum ) = extension_funcs[EXT_glIsVertexAttribEnabledAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", index, pname ); - return func_glIsVertexAttribEnabledAPPLE( index, pname ); + return funcs->ext.p_glIsVertexAttribEnabledAPPLE( index, pname ); } static void WINAPI wine_glLightEnviSGIX( GLenum pname, GLint param ) { - void (*func_glLightEnviSGIX)( GLenum, GLint ) = extension_funcs[EXT_glLightEnviSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", pname, param ); - func_glLightEnviSGIX( pname, param ); + funcs->ext.p_glLightEnviSGIX( pname, param ); } static void WINAPI wine_glLinkProgram( GLuint program ) { - void (*func_glLinkProgram)( GLuint ) = extension_funcs[EXT_glLinkProgram]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", program ); - func_glLinkProgram( program ); + funcs->ext.p_glLinkProgram( program ); } static void WINAPI wine_glLinkProgramARB( unsigned int programObj ) { - void (*func_glLinkProgramARB)( unsigned int ) = extension_funcs[EXT_glLinkProgramARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", programObj ); - func_glLinkProgramARB( programObj ); + funcs->ext.p_glLinkProgramARB( programObj ); } static void WINAPI wine_glListParameterfSGIX( GLuint list, GLenum pname, GLfloat param ) { - void (*func_glListParameterfSGIX)( GLuint, GLenum, GLfloat ) = extension_funcs[EXT_glListParameterfSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f)\n", list, pname, param ); - func_glListParameterfSGIX( list, pname, param ); + funcs->ext.p_glListParameterfSGIX( list, pname, param ); } static void WINAPI wine_glListParameterfvSGIX( GLuint list, GLenum pname, GLfloat* params ) { - void (*func_glListParameterfvSGIX)( GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glListParameterfvSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", list, pname, params ); - func_glListParameterfvSGIX( list, pname, params ); + funcs->ext.p_glListParameterfvSGIX( list, pname, params ); } static void WINAPI wine_glListParameteriSGIX( GLuint list, GLenum pname, GLint param ) { - void (*func_glListParameteriSGIX)( GLuint, GLenum, GLint ) = extension_funcs[EXT_glListParameteriSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", list, pname, param ); - func_glListParameteriSGIX( list, pname, param ); + funcs->ext.p_glListParameteriSGIX( list, pname, param ); } static void WINAPI wine_glListParameterivSGIX( GLuint list, GLenum pname, GLint* params ) { - void (*func_glListParameterivSGIX)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glListParameterivSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", list, pname, params ); - func_glListParameterivSGIX( list, pname, params ); + funcs->ext.p_glListParameterivSGIX( list, pname, params ); } static void WINAPI wine_glLoadIdentityDeformationMapSGIX( GLbitfield mask ) { - void (*func_glLoadIdentityDeformationMapSGIX)( GLbitfield ) = extension_funcs[EXT_glLoadIdentityDeformationMapSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", mask ); - func_glLoadIdentityDeformationMapSGIX( mask ); + funcs->ext.p_glLoadIdentityDeformationMapSGIX( mask ); } static void WINAPI wine_glLoadProgramNV( GLenum target, GLuint id, GLsizei len, GLubyte* program ) { - void (*func_glLoadProgramNV)( GLenum, GLuint, GLsizei, GLubyte* ) = extension_funcs[EXT_glLoadProgramNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, id, len, program ); - func_glLoadProgramNV( target, id, len, program ); + funcs->ext.p_glLoadProgramNV( target, id, len, program ); } static void WINAPI wine_glLoadTransposeMatrixd( GLdouble* m ) { - void (*func_glLoadTransposeMatrixd)( GLdouble* ) = extension_funcs[EXT_glLoadTransposeMatrixd]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", m ); - func_glLoadTransposeMatrixd( m ); + funcs->ext.p_glLoadTransposeMatrixd( m ); } static void WINAPI wine_glLoadTransposeMatrixdARB( GLdouble* m ) { - void (*func_glLoadTransposeMatrixdARB)( GLdouble* ) = extension_funcs[EXT_glLoadTransposeMatrixdARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", m ); - func_glLoadTransposeMatrixdARB( m ); + funcs->ext.p_glLoadTransposeMatrixdARB( m ); } static void WINAPI wine_glLoadTransposeMatrixf( GLfloat* m ) { - void (*func_glLoadTransposeMatrixf)( GLfloat* ) = extension_funcs[EXT_glLoadTransposeMatrixf]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", m ); - func_glLoadTransposeMatrixf( m ); + funcs->ext.p_glLoadTransposeMatrixf( m ); } static void WINAPI wine_glLoadTransposeMatrixfARB( GLfloat* m ) { - void (*func_glLoadTransposeMatrixfARB)( GLfloat* ) = extension_funcs[EXT_glLoadTransposeMatrixfARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", m ); - func_glLoadTransposeMatrixfARB( m ); + funcs->ext.p_glLoadTransposeMatrixfARB( m ); } static void WINAPI wine_glLockArraysEXT( GLint first, GLsizei count ) { - void (*func_glLockArraysEXT)( GLint, GLsizei ) = extension_funcs[EXT_glLockArraysEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", first, count ); - func_glLockArraysEXT( first, count ); + funcs->ext.p_glLockArraysEXT( first, count ); } static void WINAPI wine_glMTexCoord2fSGIS( GLenum target, GLfloat s, GLfloat t ) { - void (*func_glMTexCoord2fSGIS)( GLenum, GLfloat, GLfloat ) = extension_funcs[EXT_glMTexCoord2fSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", target, s, t ); - func_glMTexCoord2fSGIS( target, s, t ); + funcs->ext.p_glMTexCoord2fSGIS( target, s, t ); } static void WINAPI wine_glMTexCoord2fvSGIS( GLenum target, GLfloat * v ) { - void (*func_glMTexCoord2fvSGIS)( GLenum, GLfloat * ) = extension_funcs[EXT_glMTexCoord2fvSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMTexCoord2fvSGIS( target, v ); + funcs->ext.p_glMTexCoord2fvSGIS( target, v ); } static void WINAPI wine_glMakeBufferNonResidentNV( GLenum target ) { - void (*func_glMakeBufferNonResidentNV)( GLenum ) = extension_funcs[EXT_glMakeBufferNonResidentNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", target ); - func_glMakeBufferNonResidentNV( target ); + funcs->ext.p_glMakeBufferNonResidentNV( target ); } static void WINAPI wine_glMakeBufferResidentNV( GLenum target, GLenum access ) { - void (*func_glMakeBufferResidentNV)( GLenum, GLenum ) = extension_funcs[EXT_glMakeBufferResidentNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, access ); - func_glMakeBufferResidentNV( target, access ); + funcs->ext.p_glMakeBufferResidentNV( target, access ); } static void WINAPI wine_glMakeImageHandleNonResidentNV( UINT64 handle ) { - void (*func_glMakeImageHandleNonResidentNV)( UINT64 ) = extension_funcs[EXT_glMakeImageHandleNonResidentNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%s)\n", wine_dbgstr_longlong(handle) ); - func_glMakeImageHandleNonResidentNV( handle ); + funcs->ext.p_glMakeImageHandleNonResidentNV( handle ); } static void WINAPI wine_glMakeImageHandleResidentNV( UINT64 handle, GLenum access ) { - void (*func_glMakeImageHandleResidentNV)( UINT64, GLenum ) = extension_funcs[EXT_glMakeImageHandleResidentNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%s, %d)\n", wine_dbgstr_longlong(handle), access ); - func_glMakeImageHandleResidentNV( handle, access ); + funcs->ext.p_glMakeImageHandleResidentNV( handle, access ); } static void WINAPI wine_glMakeNamedBufferNonResidentNV( GLuint buffer ) { - void (*func_glMakeNamedBufferNonResidentNV)( GLuint ) = extension_funcs[EXT_glMakeNamedBufferNonResidentNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", buffer ); - func_glMakeNamedBufferNonResidentNV( buffer ); + funcs->ext.p_glMakeNamedBufferNonResidentNV( buffer ); } static void WINAPI wine_glMakeNamedBufferResidentNV( GLuint buffer, GLenum access ) { - void (*func_glMakeNamedBufferResidentNV)( GLuint, GLenum ) = extension_funcs[EXT_glMakeNamedBufferResidentNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", buffer, access ); - func_glMakeNamedBufferResidentNV( buffer, access ); + funcs->ext.p_glMakeNamedBufferResidentNV( buffer, access ); } static void WINAPI wine_glMakeTextureHandleNonResidentNV( UINT64 handle ) { - void (*func_glMakeTextureHandleNonResidentNV)( UINT64 ) = extension_funcs[EXT_glMakeTextureHandleNonResidentNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%s)\n", wine_dbgstr_longlong(handle) ); - func_glMakeTextureHandleNonResidentNV( handle ); + funcs->ext.p_glMakeTextureHandleNonResidentNV( handle ); } static void WINAPI wine_glMakeTextureHandleResidentNV( UINT64 handle ) { - void (*func_glMakeTextureHandleResidentNV)( UINT64 ) = extension_funcs[EXT_glMakeTextureHandleResidentNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%s)\n", wine_dbgstr_longlong(handle) ); - func_glMakeTextureHandleResidentNV( handle ); + funcs->ext.p_glMakeTextureHandleResidentNV( handle ); } static GLvoid* WINAPI wine_glMapBuffer( GLenum target, GLenum access ) { - GLvoid* (*func_glMapBuffer)( GLenum, GLenum ) = extension_funcs[EXT_glMapBuffer]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, access ); - return func_glMapBuffer( target, access ); + return funcs->ext.p_glMapBuffer( target, access ); } static GLvoid* WINAPI wine_glMapBufferARB( GLenum target, GLenum access ) { - GLvoid* (*func_glMapBufferARB)( GLenum, GLenum ) = extension_funcs[EXT_glMapBufferARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, access ); - return func_glMapBufferARB( target, access ); + return funcs->ext.p_glMapBufferARB( target, access ); } static GLvoid* WINAPI wine_glMapBufferRange( GLenum target, INT_PTR offset, INT_PTR length, GLbitfield access ) { - GLvoid* (*func_glMapBufferRange)( GLenum, INT_PTR, INT_PTR, GLbitfield ) = extension_funcs[EXT_glMapBufferRange]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %ld, %ld, %d)\n", target, offset, length, access ); - return func_glMapBufferRange( target, offset, length, access ); + return funcs->ext.p_glMapBufferRange( target, offset, length, access ); } static void WINAPI wine_glMapControlPointsNV( GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, GLvoid* points ) { - void (*func_glMapControlPointsNV)( GLenum, GLuint, GLenum, GLsizei, GLsizei, GLint, GLint, GLboolean, GLvoid* ) = extension_funcs[EXT_glMapControlPointsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, index, type, ustride, vstride, uorder, vorder, packed, points ); - func_glMapControlPointsNV( target, index, type, ustride, vstride, uorder, vorder, packed, points ); + funcs->ext.p_glMapControlPointsNV( target, index, type, ustride, vstride, uorder, vorder, packed, points ); } static GLvoid* WINAPI wine_glMapNamedBufferEXT( GLuint buffer, GLenum access ) { - GLvoid* (*func_glMapNamedBufferEXT)( GLuint, GLenum ) = extension_funcs[EXT_glMapNamedBufferEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", buffer, access ); - return func_glMapNamedBufferEXT( buffer, access ); + return funcs->ext.p_glMapNamedBufferEXT( buffer, access ); } static GLvoid* WINAPI wine_glMapNamedBufferRangeEXT( GLuint buffer, INT_PTR offset, INT_PTR length, GLbitfield access ) { - GLvoid* (*func_glMapNamedBufferRangeEXT)( GLuint, INT_PTR, INT_PTR, GLbitfield ) = extension_funcs[EXT_glMapNamedBufferRangeEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %ld, %ld, %d)\n", buffer, offset, length, access ); - return func_glMapNamedBufferRangeEXT( buffer, offset, length, access ); + return funcs->ext.p_glMapNamedBufferRangeEXT( buffer, offset, length, access ); } static GLvoid* WINAPI wine_glMapObjectBufferATI( GLuint buffer ) { - GLvoid* (*func_glMapObjectBufferATI)( GLuint ) = extension_funcs[EXT_glMapObjectBufferATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", buffer ); - return func_glMapObjectBufferATI( buffer ); + return funcs->ext.p_glMapObjectBufferATI( buffer ); } static void WINAPI wine_glMapParameterfvNV( GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glMapParameterfvNV)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glMapParameterfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glMapParameterfvNV( target, pname, params ); + funcs->ext.p_glMapParameterfvNV( target, pname, params ); } static void WINAPI wine_glMapParameterivNV( GLenum target, GLenum pname, GLint* params ) { - void (*func_glMapParameterivNV)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glMapParameterivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glMapParameterivNV( target, pname, params ); + funcs->ext.p_glMapParameterivNV( target, pname, params ); } static void WINAPI wine_glMapVertexAttrib1dAPPLE( GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, GLdouble* points ) { - void (*func_glMapVertexAttrib1dAPPLE)( GLuint, GLuint, GLdouble, GLdouble, GLint, GLint, GLdouble* ) = extension_funcs[EXT_glMapVertexAttrib1dAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f, %d, %d, %p)\n", index, size, u1, u2, stride, order, points ); - func_glMapVertexAttrib1dAPPLE( index, size, u1, u2, stride, order, points ); + funcs->ext.p_glMapVertexAttrib1dAPPLE( index, size, u1, u2, stride, order, points ); } static void WINAPI wine_glMapVertexAttrib1fAPPLE( GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, GLfloat* points ) { - void (*func_glMapVertexAttrib1fAPPLE)( GLuint, GLuint, GLfloat, GLfloat, GLint, GLint, GLfloat* ) = extension_funcs[EXT_glMapVertexAttrib1fAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f, %d, %d, %p)\n", index, size, u1, u2, stride, order, points ); - func_glMapVertexAttrib1fAPPLE( index, size, u1, u2, stride, order, points ); + funcs->ext.p_glMapVertexAttrib1fAPPLE( index, size, u1, u2, stride, order, points ); } static void WINAPI wine_glMapVertexAttrib2dAPPLE( GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble* points ) { - void (*func_glMapVertexAttrib2dAPPLE)( GLuint, GLuint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble* ) = extension_funcs[EXT_glMapVertexAttrib2dAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points ); - func_glMapVertexAttrib2dAPPLE( index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points ); + funcs->ext.p_glMapVertexAttrib2dAPPLE( index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points ); } static void WINAPI wine_glMapVertexAttrib2fAPPLE( GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat* points ) { - void (*func_glMapVertexAttrib2fAPPLE)( GLuint, GLuint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat* ) = extension_funcs[EXT_glMapVertexAttrib2fAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points ); - func_glMapVertexAttrib2fAPPLE( index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points ); + funcs->ext.p_glMapVertexAttrib2fAPPLE( index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points ); } static void WINAPI wine_glMatrixFrustumEXT( GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar ) { - void (*func_glMatrixFrustumEXT)( GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glMatrixFrustumEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f, %f, %f)\n", mode, left, right, bottom, top, zNear, zFar ); - func_glMatrixFrustumEXT( mode, left, right, bottom, top, zNear, zFar ); + funcs->ext.p_glMatrixFrustumEXT( mode, left, right, bottom, top, zNear, zFar ); } static void WINAPI wine_glMatrixIndexPointerARB( GLint size, GLenum type, GLsizei stride, GLvoid* pointer ) { - void (*func_glMatrixIndexPointerARB)( GLint, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glMatrixIndexPointerARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer ); - func_glMatrixIndexPointerARB( size, type, stride, pointer ); + funcs->ext.p_glMatrixIndexPointerARB( size, type, stride, pointer ); } static void WINAPI wine_glMatrixIndexubvARB( GLint size, GLubyte* indices ) { - void (*func_glMatrixIndexubvARB)( GLint, GLubyte* ) = extension_funcs[EXT_glMatrixIndexubvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", size, indices ); - func_glMatrixIndexubvARB( size, indices ); + funcs->ext.p_glMatrixIndexubvARB( size, indices ); } static void WINAPI wine_glMatrixIndexuivARB( GLint size, GLuint* indices ) { - void (*func_glMatrixIndexuivARB)( GLint, GLuint* ) = extension_funcs[EXT_glMatrixIndexuivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", size, indices ); - func_glMatrixIndexuivARB( size, indices ); + funcs->ext.p_glMatrixIndexuivARB( size, indices ); } static void WINAPI wine_glMatrixIndexusvARB( GLint size, GLushort* indices ) { - void (*func_glMatrixIndexusvARB)( GLint, GLushort* ) = extension_funcs[EXT_glMatrixIndexusvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", size, indices ); - func_glMatrixIndexusvARB( size, indices ); + funcs->ext.p_glMatrixIndexusvARB( size, indices ); } static void WINAPI wine_glMatrixLoadIdentityEXT( GLenum mode ) { - void (*func_glMatrixLoadIdentityEXT)( GLenum ) = extension_funcs[EXT_glMatrixLoadIdentityEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", mode ); - func_glMatrixLoadIdentityEXT( mode ); + funcs->ext.p_glMatrixLoadIdentityEXT( mode ); } static void WINAPI wine_glMatrixLoadTransposedEXT( GLenum mode, GLdouble* m ) { - void (*func_glMatrixLoadTransposedEXT)( GLenum, GLdouble* ) = extension_funcs[EXT_glMatrixLoadTransposedEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", mode, m ); - func_glMatrixLoadTransposedEXT( mode, m ); + funcs->ext.p_glMatrixLoadTransposedEXT( mode, m ); } static void WINAPI wine_glMatrixLoadTransposefEXT( GLenum mode, GLfloat* m ) { - void (*func_glMatrixLoadTransposefEXT)( GLenum, GLfloat* ) = extension_funcs[EXT_glMatrixLoadTransposefEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", mode, m ); - func_glMatrixLoadTransposefEXT( mode, m ); + funcs->ext.p_glMatrixLoadTransposefEXT( mode, m ); } static void WINAPI wine_glMatrixLoaddEXT( GLenum mode, GLdouble* m ) { - void (*func_glMatrixLoaddEXT)( GLenum, GLdouble* ) = extension_funcs[EXT_glMatrixLoaddEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", mode, m ); - func_glMatrixLoaddEXT( mode, m ); + funcs->ext.p_glMatrixLoaddEXT( mode, m ); } static void WINAPI wine_glMatrixLoadfEXT( GLenum mode, GLfloat* m ) { - void (*func_glMatrixLoadfEXT)( GLenum, GLfloat* ) = extension_funcs[EXT_glMatrixLoadfEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", mode, m ); - func_glMatrixLoadfEXT( mode, m ); + funcs->ext.p_glMatrixLoadfEXT( mode, m ); } static void WINAPI wine_glMatrixMultTransposedEXT( GLenum mode, GLdouble* m ) { - void (*func_glMatrixMultTransposedEXT)( GLenum, GLdouble* ) = extension_funcs[EXT_glMatrixMultTransposedEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", mode, m ); - func_glMatrixMultTransposedEXT( mode, m ); + funcs->ext.p_glMatrixMultTransposedEXT( mode, m ); } static void WINAPI wine_glMatrixMultTransposefEXT( GLenum mode, GLfloat* m ) { - void (*func_glMatrixMultTransposefEXT)( GLenum, GLfloat* ) = extension_funcs[EXT_glMatrixMultTransposefEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", mode, m ); - func_glMatrixMultTransposefEXT( mode, m ); + funcs->ext.p_glMatrixMultTransposefEXT( mode, m ); } static void WINAPI wine_glMatrixMultdEXT( GLenum mode, GLdouble* m ) { - void (*func_glMatrixMultdEXT)( GLenum, GLdouble* ) = extension_funcs[EXT_glMatrixMultdEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", mode, m ); - func_glMatrixMultdEXT( mode, m ); + funcs->ext.p_glMatrixMultdEXT( mode, m ); } static void WINAPI wine_glMatrixMultfEXT( GLenum mode, GLfloat* m ) { - void (*func_glMatrixMultfEXT)( GLenum, GLfloat* ) = extension_funcs[EXT_glMatrixMultfEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", mode, m ); - func_glMatrixMultfEXT( mode, m ); + funcs->ext.p_glMatrixMultfEXT( mode, m ); } static void WINAPI wine_glMatrixOrthoEXT( GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar ) { - void (*func_glMatrixOrthoEXT)( GLenum, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glMatrixOrthoEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f, %f, %f)\n", mode, left, right, bottom, top, zNear, zFar ); - func_glMatrixOrthoEXT( mode, left, right, bottom, top, zNear, zFar ); + funcs->ext.p_glMatrixOrthoEXT( mode, left, right, bottom, top, zNear, zFar ); } static void WINAPI wine_glMatrixPopEXT( GLenum mode ) { - void (*func_glMatrixPopEXT)( GLenum ) = extension_funcs[EXT_glMatrixPopEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", mode ); - func_glMatrixPopEXT( mode ); + funcs->ext.p_glMatrixPopEXT( mode ); } static void WINAPI wine_glMatrixPushEXT( GLenum mode ) { - void (*func_glMatrixPushEXT)( GLenum ) = extension_funcs[EXT_glMatrixPushEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", mode ); - func_glMatrixPushEXT( mode ); + funcs->ext.p_glMatrixPushEXT( mode ); } static void WINAPI wine_glMatrixRotatedEXT( GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z ) { - void (*func_glMatrixRotatedEXT)( GLenum, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glMatrixRotatedEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", mode, angle, x, y, z ); - func_glMatrixRotatedEXT( mode, angle, x, y, z ); + funcs->ext.p_glMatrixRotatedEXT( mode, angle, x, y, z ); } static void WINAPI wine_glMatrixRotatefEXT( GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glMatrixRotatefEXT)( GLenum, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glMatrixRotatefEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", mode, angle, x, y, z ); - func_glMatrixRotatefEXT( mode, angle, x, y, z ); + funcs->ext.p_glMatrixRotatefEXT( mode, angle, x, y, z ); } static void WINAPI wine_glMatrixScaledEXT( GLenum mode, GLdouble x, GLdouble y, GLdouble z ) { - void (*func_glMatrixScaledEXT)( GLenum, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glMatrixScaledEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", mode, x, y, z ); - func_glMatrixScaledEXT( mode, x, y, z ); + funcs->ext.p_glMatrixScaledEXT( mode, x, y, z ); } static void WINAPI wine_glMatrixScalefEXT( GLenum mode, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glMatrixScalefEXT)( GLenum, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glMatrixScalefEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", mode, x, y, z ); - func_glMatrixScalefEXT( mode, x, y, z ); + funcs->ext.p_glMatrixScalefEXT( mode, x, y, z ); } static void WINAPI wine_glMatrixTranslatedEXT( GLenum mode, GLdouble x, GLdouble y, GLdouble z ) { - void (*func_glMatrixTranslatedEXT)( GLenum, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glMatrixTranslatedEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", mode, x, y, z ); - func_glMatrixTranslatedEXT( mode, x, y, z ); + funcs->ext.p_glMatrixTranslatedEXT( mode, x, y, z ); } static void WINAPI wine_glMatrixTranslatefEXT( GLenum mode, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glMatrixTranslatefEXT)( GLenum, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glMatrixTranslatefEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", mode, x, y, z ); - func_glMatrixTranslatefEXT( mode, x, y, z ); + funcs->ext.p_glMatrixTranslatefEXT( mode, x, y, z ); } static void WINAPI wine_glMemoryBarrier( GLbitfield barriers ) { - void (*func_glMemoryBarrier)( GLbitfield ) = extension_funcs[EXT_glMemoryBarrier]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", barriers ); - func_glMemoryBarrier( barriers ); + funcs->ext.p_glMemoryBarrier( barriers ); } static void WINAPI wine_glMemoryBarrierEXT( GLbitfield barriers ) { - void (*func_glMemoryBarrierEXT)( GLbitfield ) = extension_funcs[EXT_glMemoryBarrierEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", barriers ); - func_glMemoryBarrierEXT( barriers ); + funcs->ext.p_glMemoryBarrierEXT( barriers ); } static void WINAPI wine_glMinSampleShading( GLfloat value ) { - void (*func_glMinSampleShading)( GLfloat ) = extension_funcs[EXT_glMinSampleShading]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f)\n", value ); - func_glMinSampleShading( value ); + funcs->ext.p_glMinSampleShading( value ); } static void WINAPI wine_glMinSampleShadingARB( GLfloat value ) { - void (*func_glMinSampleShadingARB)( GLfloat ) = extension_funcs[EXT_glMinSampleShadingARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f)\n", value ); - func_glMinSampleShadingARB( value ); + funcs->ext.p_glMinSampleShadingARB( value ); } static void WINAPI wine_glMinmax( GLenum target, GLenum internalformat, GLboolean sink ) { - void (*func_glMinmax)( GLenum, GLenum, GLboolean ) = extension_funcs[EXT_glMinmax]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, internalformat, sink ); - func_glMinmax( target, internalformat, sink ); + funcs->ext.p_glMinmax( target, internalformat, sink ); } static void WINAPI wine_glMinmaxEXT( GLenum target, GLenum internalformat, GLboolean sink ) { - void (*func_glMinmaxEXT)( GLenum, GLenum, GLboolean ) = extension_funcs[EXT_glMinmaxEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, internalformat, sink ); - func_glMinmaxEXT( target, internalformat, sink ); + funcs->ext.p_glMinmaxEXT( target, internalformat, sink ); } static void WINAPI wine_glMultTransposeMatrixd( GLdouble* m ) { - void (*func_glMultTransposeMatrixd)( GLdouble* ) = extension_funcs[EXT_glMultTransposeMatrixd]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", m ); - func_glMultTransposeMatrixd( m ); + funcs->ext.p_glMultTransposeMatrixd( m ); } static void WINAPI wine_glMultTransposeMatrixdARB( GLdouble* m ) { - void (*func_glMultTransposeMatrixdARB)( GLdouble* ) = extension_funcs[EXT_glMultTransposeMatrixdARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", m ); - func_glMultTransposeMatrixdARB( m ); + funcs->ext.p_glMultTransposeMatrixdARB( m ); } static void WINAPI wine_glMultTransposeMatrixf( GLfloat* m ) { - void (*func_glMultTransposeMatrixf)( GLfloat* ) = extension_funcs[EXT_glMultTransposeMatrixf]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", m ); - func_glMultTransposeMatrixf( m ); + funcs->ext.p_glMultTransposeMatrixf( m ); } static void WINAPI wine_glMultTransposeMatrixfARB( GLfloat* m ) { - void (*func_glMultTransposeMatrixfARB)( GLfloat* ) = extension_funcs[EXT_glMultTransposeMatrixfARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", m ); - func_glMultTransposeMatrixfARB( m ); + funcs->ext.p_glMultTransposeMatrixfARB( m ); } static void WINAPI wine_glMultiDrawArrays( GLenum mode, GLint* first, GLsizei* count, GLsizei primcount ) { - void (*func_glMultiDrawArrays)( GLenum, GLint*, GLsizei*, GLsizei ) = extension_funcs[EXT_glMultiDrawArrays]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %p, %d)\n", mode, first, count, primcount ); - func_glMultiDrawArrays( mode, first, count, primcount ); + funcs->ext.p_glMultiDrawArrays( mode, first, count, primcount ); } static void WINAPI wine_glMultiDrawArraysEXT( GLenum mode, GLint* first, GLsizei* count, GLsizei primcount ) { - void (*func_glMultiDrawArraysEXT)( GLenum, GLint*, GLsizei*, GLsizei ) = extension_funcs[EXT_glMultiDrawArraysEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %p, %d)\n", mode, first, count, primcount ); - func_glMultiDrawArraysEXT( mode, first, count, primcount ); + funcs->ext.p_glMultiDrawArraysEXT( mode, first, count, primcount ); } static void WINAPI wine_glMultiDrawArraysIndirectAMD( GLenum mode, GLvoid* indirect, GLsizei primcount, GLsizei stride ) { - void (*func_glMultiDrawArraysIndirectAMD)( GLenum, GLvoid*, GLsizei, GLsizei ) = extension_funcs[EXT_glMultiDrawArraysIndirectAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %d, %d)\n", mode, indirect, primcount, stride ); - func_glMultiDrawArraysIndirectAMD( mode, indirect, primcount, stride ); + funcs->ext.p_glMultiDrawArraysIndirectAMD( mode, indirect, primcount, stride ); } static void WINAPI wine_glMultiDrawElementArrayAPPLE( GLenum mode, GLint* first, GLsizei* count, GLsizei primcount ) { - void (*func_glMultiDrawElementArrayAPPLE)( GLenum, GLint*, GLsizei*, GLsizei ) = extension_funcs[EXT_glMultiDrawElementArrayAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %p, %d)\n", mode, first, count, primcount ); - func_glMultiDrawElementArrayAPPLE( mode, first, count, primcount ); + funcs->ext.p_glMultiDrawElementArrayAPPLE( mode, first, count, primcount ); } static void WINAPI wine_glMultiDrawElements( GLenum mode, GLsizei* count, GLenum type, GLvoid* const* indices, GLsizei primcount ) { - void (*func_glMultiDrawElements)( GLenum, GLsizei*, GLenum, GLvoid* const*, GLsizei ) = extension_funcs[EXT_glMultiDrawElements]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %d, %p, %d)\n", mode, count, type, indices, primcount ); - func_glMultiDrawElements( mode, count, type, indices, primcount ); + funcs->ext.p_glMultiDrawElements( mode, count, type, indices, primcount ); } static void WINAPI wine_glMultiDrawElementsBaseVertex( GLenum mode, GLsizei* count, GLenum type, GLvoid* const* indices, GLsizei primcount, GLint* basevertex ) { - void (*func_glMultiDrawElementsBaseVertex)( GLenum, GLsizei*, GLenum, GLvoid* const*, GLsizei, GLint* ) = extension_funcs[EXT_glMultiDrawElementsBaseVertex]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %d, %p, %d, %p)\n", mode, count, type, indices, primcount, basevertex ); - func_glMultiDrawElementsBaseVertex( mode, count, type, indices, primcount, basevertex ); + funcs->ext.p_glMultiDrawElementsBaseVertex( mode, count, type, indices, primcount, basevertex ); } static void WINAPI wine_glMultiDrawElementsEXT( GLenum mode, GLsizei* count, GLenum type, GLvoid** indices, GLsizei primcount ) { - void (*func_glMultiDrawElementsEXT)( GLenum, GLsizei*, GLenum, GLvoid**, GLsizei ) = extension_funcs[EXT_glMultiDrawElementsEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %d, %p, %d)\n", mode, count, type, indices, primcount ); - func_glMultiDrawElementsEXT( mode, count, type, indices, primcount ); + funcs->ext.p_glMultiDrawElementsEXT( mode, count, type, indices, primcount ); } static void WINAPI wine_glMultiDrawElementsIndirectAMD( GLenum mode, GLenum type, GLvoid* indirect, GLsizei primcount, GLsizei stride ) { - void (*func_glMultiDrawElementsIndirectAMD)( GLenum, GLenum, GLvoid*, GLsizei, GLsizei ) = extension_funcs[EXT_glMultiDrawElementsIndirectAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %d, %d)\n", mode, type, indirect, primcount, stride ); - func_glMultiDrawElementsIndirectAMD( mode, type, indirect, primcount, stride ); + funcs->ext.p_glMultiDrawElementsIndirectAMD( mode, type, indirect, primcount, stride ); } static void WINAPI wine_glMultiDrawRangeElementArrayAPPLE( GLenum mode, GLuint start, GLuint end, GLint* first, GLsizei* count, GLsizei primcount ) { - void (*func_glMultiDrawRangeElementArrayAPPLE)( GLenum, GLuint, GLuint, GLint*, GLsizei*, GLsizei ) = extension_funcs[EXT_glMultiDrawRangeElementArrayAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %p, %d)\n", mode, start, end, first, count, primcount ); - func_glMultiDrawRangeElementArrayAPPLE( mode, start, end, first, count, primcount ); + funcs->ext.p_glMultiDrawRangeElementArrayAPPLE( mode, start, end, first, count, primcount ); } static void WINAPI wine_glMultiModeDrawArraysIBM( GLenum* mode, GLint* first, GLsizei* count, GLsizei primcount, GLint modestride ) { - void (*func_glMultiModeDrawArraysIBM)( GLenum*, GLint*, GLsizei*, GLsizei, GLint ) = extension_funcs[EXT_glMultiModeDrawArraysIBM]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p, %p, %d, %d)\n", mode, first, count, primcount, modestride ); - func_glMultiModeDrawArraysIBM( mode, first, count, primcount, modestride ); + funcs->ext.p_glMultiModeDrawArraysIBM( mode, first, count, primcount, modestride ); } static void WINAPI wine_glMultiModeDrawElementsIBM( GLenum* mode, GLsizei* count, GLenum type, GLvoid* const* indices, GLsizei primcount, GLint modestride ) { - void (*func_glMultiModeDrawElementsIBM)( GLenum*, GLsizei*, GLenum, GLvoid* const*, GLsizei, GLint ) = extension_funcs[EXT_glMultiModeDrawElementsIBM]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p, %d, %p, %d, %d)\n", mode, count, type, indices, primcount, modestride ); - func_glMultiModeDrawElementsIBM( mode, count, type, indices, primcount, modestride ); + funcs->ext.p_glMultiModeDrawElementsIBM( mode, count, type, indices, primcount, modestride ); } static void WINAPI wine_glMultiTexBufferEXT( GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer ) { - void (*func_glMultiTexBufferEXT)( GLenum, GLenum, GLenum, GLuint ) = extension_funcs[EXT_glMultiTexBufferEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", texunit, target, internalformat, buffer ); - func_glMultiTexBufferEXT( texunit, target, internalformat, buffer ); + funcs->ext.p_glMultiTexBufferEXT( texunit, target, internalformat, buffer ); } static void WINAPI wine_glMultiTexCoord1d( GLenum target, GLdouble s ) { - void (*func_glMultiTexCoord1d)( GLenum, GLdouble ) = extension_funcs[EXT_glMultiTexCoord1d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", target, s ); - func_glMultiTexCoord1d( target, s ); + funcs->ext.p_glMultiTexCoord1d( target, s ); } static void WINAPI wine_glMultiTexCoord1dARB( GLenum target, GLdouble s ) { - void (*func_glMultiTexCoord1dARB)( GLenum, GLdouble ) = extension_funcs[EXT_glMultiTexCoord1dARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", target, s ); - func_glMultiTexCoord1dARB( target, s ); + funcs->ext.p_glMultiTexCoord1dARB( target, s ); } static void WINAPI wine_glMultiTexCoord1dSGIS( GLenum target, GLdouble s ) { - void (*func_glMultiTexCoord1dSGIS)( GLenum, GLdouble ) = extension_funcs[EXT_glMultiTexCoord1dSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", target, s ); - func_glMultiTexCoord1dSGIS( target, s ); + funcs->ext.p_glMultiTexCoord1dSGIS( target, s ); } static void WINAPI wine_glMultiTexCoord1dv( GLenum target, GLdouble* v ) { - void (*func_glMultiTexCoord1dv)( GLenum, GLdouble* ) = extension_funcs[EXT_glMultiTexCoord1dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord1dv( target, v ); + funcs->ext.p_glMultiTexCoord1dv( target, v ); } static void WINAPI wine_glMultiTexCoord1dvARB( GLenum target, GLdouble* v ) { - void (*func_glMultiTexCoord1dvARB)( GLenum, GLdouble* ) = extension_funcs[EXT_glMultiTexCoord1dvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord1dvARB( target, v ); + funcs->ext.p_glMultiTexCoord1dvARB( target, v ); } static void WINAPI wine_glMultiTexCoord1dvSGIS( GLenum target, GLdouble * v ) { - void (*func_glMultiTexCoord1dvSGIS)( GLenum, GLdouble * ) = extension_funcs[EXT_glMultiTexCoord1dvSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord1dvSGIS( target, v ); + funcs->ext.p_glMultiTexCoord1dvSGIS( target, v ); } static void WINAPI wine_glMultiTexCoord1f( GLenum target, GLfloat s ) { - void (*func_glMultiTexCoord1f)( GLenum, GLfloat ) = extension_funcs[EXT_glMultiTexCoord1f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", target, s ); - func_glMultiTexCoord1f( target, s ); + funcs->ext.p_glMultiTexCoord1f( target, s ); } static void WINAPI wine_glMultiTexCoord1fARB( GLenum target, GLfloat s ) { - void (*func_glMultiTexCoord1fARB)( GLenum, GLfloat ) = extension_funcs[EXT_glMultiTexCoord1fARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", target, s ); - func_glMultiTexCoord1fARB( target, s ); + funcs->ext.p_glMultiTexCoord1fARB( target, s ); } static void WINAPI wine_glMultiTexCoord1fSGIS( GLenum target, GLfloat s ) { - void (*func_glMultiTexCoord1fSGIS)( GLenum, GLfloat ) = extension_funcs[EXT_glMultiTexCoord1fSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", target, s ); - func_glMultiTexCoord1fSGIS( target, s ); + funcs->ext.p_glMultiTexCoord1fSGIS( target, s ); } static void WINAPI wine_glMultiTexCoord1fv( GLenum target, GLfloat* v ) { - void (*func_glMultiTexCoord1fv)( GLenum, GLfloat* ) = extension_funcs[EXT_glMultiTexCoord1fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord1fv( target, v ); + funcs->ext.p_glMultiTexCoord1fv( target, v ); } static void WINAPI wine_glMultiTexCoord1fvARB( GLenum target, GLfloat* v ) { - void (*func_glMultiTexCoord1fvARB)( GLenum, GLfloat* ) = extension_funcs[EXT_glMultiTexCoord1fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord1fvARB( target, v ); + funcs->ext.p_glMultiTexCoord1fvARB( target, v ); } static void WINAPI wine_glMultiTexCoord1fvSGIS( GLenum target, const GLfloat * v ) { - void (*func_glMultiTexCoord1fvSGIS)( GLenum, const GLfloat * ) = extension_funcs[EXT_glMultiTexCoord1fvSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord1fvSGIS( target, v ); + funcs->ext.p_glMultiTexCoord1fvSGIS( target, v ); } static void WINAPI wine_glMultiTexCoord1hNV( GLenum target, unsigned short s ) { - void (*func_glMultiTexCoord1hNV)( GLenum, unsigned short ) = extension_funcs[EXT_glMultiTexCoord1hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, s ); - func_glMultiTexCoord1hNV( target, s ); + funcs->ext.p_glMultiTexCoord1hNV( target, s ); } static void WINAPI wine_glMultiTexCoord1hvNV( GLenum target, unsigned short* v ) { - void (*func_glMultiTexCoord1hvNV)( GLenum, unsigned short* ) = extension_funcs[EXT_glMultiTexCoord1hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord1hvNV( target, v ); + funcs->ext.p_glMultiTexCoord1hvNV( target, v ); } static void WINAPI wine_glMultiTexCoord1i( GLenum target, GLint s ) { - void (*func_glMultiTexCoord1i)( GLenum, GLint ) = extension_funcs[EXT_glMultiTexCoord1i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, s ); - func_glMultiTexCoord1i( target, s ); + funcs->ext.p_glMultiTexCoord1i( target, s ); } static void WINAPI wine_glMultiTexCoord1iARB( GLenum target, GLint s ) { - void (*func_glMultiTexCoord1iARB)( GLenum, GLint ) = extension_funcs[EXT_glMultiTexCoord1iARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, s ); - func_glMultiTexCoord1iARB( target, s ); + funcs->ext.p_glMultiTexCoord1iARB( target, s ); } static void WINAPI wine_glMultiTexCoord1iSGIS( GLenum target, GLint s ) { - void (*func_glMultiTexCoord1iSGIS)( GLenum, GLint ) = extension_funcs[EXT_glMultiTexCoord1iSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, s ); - func_glMultiTexCoord1iSGIS( target, s ); + funcs->ext.p_glMultiTexCoord1iSGIS( target, s ); } static void WINAPI wine_glMultiTexCoord1iv( GLenum target, GLint* v ) { - void (*func_glMultiTexCoord1iv)( GLenum, GLint* ) = extension_funcs[EXT_glMultiTexCoord1iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord1iv( target, v ); + funcs->ext.p_glMultiTexCoord1iv( target, v ); } static void WINAPI wine_glMultiTexCoord1ivARB( GLenum target, GLint* v ) { - void (*func_glMultiTexCoord1ivARB)( GLenum, GLint* ) = extension_funcs[EXT_glMultiTexCoord1ivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord1ivARB( target, v ); + funcs->ext.p_glMultiTexCoord1ivARB( target, v ); } static void WINAPI wine_glMultiTexCoord1ivSGIS( GLenum target, GLint * v ) { - void (*func_glMultiTexCoord1ivSGIS)( GLenum, GLint * ) = extension_funcs[EXT_glMultiTexCoord1ivSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord1ivSGIS( target, v ); + funcs->ext.p_glMultiTexCoord1ivSGIS( target, v ); } static void WINAPI wine_glMultiTexCoord1s( GLenum target, GLshort s ) { - void (*func_glMultiTexCoord1s)( GLenum, GLshort ) = extension_funcs[EXT_glMultiTexCoord1s]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, s ); - func_glMultiTexCoord1s( target, s ); + funcs->ext.p_glMultiTexCoord1s( target, s ); } static void WINAPI wine_glMultiTexCoord1sARB( GLenum target, GLshort s ) { - void (*func_glMultiTexCoord1sARB)( GLenum, GLshort ) = extension_funcs[EXT_glMultiTexCoord1sARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, s ); - func_glMultiTexCoord1sARB( target, s ); + funcs->ext.p_glMultiTexCoord1sARB( target, s ); } static void WINAPI wine_glMultiTexCoord1sSGIS( GLenum target, GLshort s ) { - void (*func_glMultiTexCoord1sSGIS)( GLenum, GLshort ) = extension_funcs[EXT_glMultiTexCoord1sSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, s ); - func_glMultiTexCoord1sSGIS( target, s ); + funcs->ext.p_glMultiTexCoord1sSGIS( target, s ); } static void WINAPI wine_glMultiTexCoord1sv( GLenum target, GLshort* v ) { - void (*func_glMultiTexCoord1sv)( GLenum, GLshort* ) = extension_funcs[EXT_glMultiTexCoord1sv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord1sv( target, v ); + funcs->ext.p_glMultiTexCoord1sv( target, v ); } static void WINAPI wine_glMultiTexCoord1svARB( GLenum target, GLshort* v ) { - void (*func_glMultiTexCoord1svARB)( GLenum, GLshort* ) = extension_funcs[EXT_glMultiTexCoord1svARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord1svARB( target, v ); + funcs->ext.p_glMultiTexCoord1svARB( target, v ); } static void WINAPI wine_glMultiTexCoord1svSGIS( GLenum target, GLshort * v ) { - void (*func_glMultiTexCoord1svSGIS)( GLenum, GLshort * ) = extension_funcs[EXT_glMultiTexCoord1svSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord1svSGIS( target, v ); + funcs->ext.p_glMultiTexCoord1svSGIS( target, v ); } static void WINAPI wine_glMultiTexCoord2d( GLenum target, GLdouble s, GLdouble t ) { - void (*func_glMultiTexCoord2d)( GLenum, GLdouble, GLdouble ) = extension_funcs[EXT_glMultiTexCoord2d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", target, s, t ); - func_glMultiTexCoord2d( target, s, t ); + funcs->ext.p_glMultiTexCoord2d( target, s, t ); } static void WINAPI wine_glMultiTexCoord2dARB( GLenum target, GLdouble s, GLdouble t ) { - void (*func_glMultiTexCoord2dARB)( GLenum, GLdouble, GLdouble ) = extension_funcs[EXT_glMultiTexCoord2dARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", target, s, t ); - func_glMultiTexCoord2dARB( target, s, t ); + funcs->ext.p_glMultiTexCoord2dARB( target, s, t ); } static void WINAPI wine_glMultiTexCoord2dSGIS( GLenum target, GLdouble s, GLdouble t ) { - void (*func_glMultiTexCoord2dSGIS)( GLenum, GLdouble, GLdouble ) = extension_funcs[EXT_glMultiTexCoord2dSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", target, s, t ); - func_glMultiTexCoord2dSGIS( target, s, t ); + funcs->ext.p_glMultiTexCoord2dSGIS( target, s, t ); } static void WINAPI wine_glMultiTexCoord2dv( GLenum target, GLdouble* v ) { - void (*func_glMultiTexCoord2dv)( GLenum, GLdouble* ) = extension_funcs[EXT_glMultiTexCoord2dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord2dv( target, v ); + funcs->ext.p_glMultiTexCoord2dv( target, v ); } static void WINAPI wine_glMultiTexCoord2dvARB( GLenum target, GLdouble* v ) { - void (*func_glMultiTexCoord2dvARB)( GLenum, GLdouble* ) = extension_funcs[EXT_glMultiTexCoord2dvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord2dvARB( target, v ); + funcs->ext.p_glMultiTexCoord2dvARB( target, v ); } static void WINAPI wine_glMultiTexCoord2dvSGIS( GLenum target, GLdouble * v ) { - void (*func_glMultiTexCoord2dvSGIS)( GLenum, GLdouble * ) = extension_funcs[EXT_glMultiTexCoord2dvSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord2dvSGIS( target, v ); + funcs->ext.p_glMultiTexCoord2dvSGIS( target, v ); } static void WINAPI wine_glMultiTexCoord2f( GLenum target, GLfloat s, GLfloat t ) { - void (*func_glMultiTexCoord2f)( GLenum, GLfloat, GLfloat ) = extension_funcs[EXT_glMultiTexCoord2f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", target, s, t ); - func_glMultiTexCoord2f( target, s, t ); + funcs->ext.p_glMultiTexCoord2f( target, s, t ); } static void WINAPI wine_glMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t ) { - void (*func_glMultiTexCoord2fARB)( GLenum, GLfloat, GLfloat ) = extension_funcs[EXT_glMultiTexCoord2fARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", target, s, t ); - func_glMultiTexCoord2fARB( target, s, t ); + funcs->ext.p_glMultiTexCoord2fARB( target, s, t ); } static void WINAPI wine_glMultiTexCoord2fSGIS( GLenum target, GLfloat s, GLfloat t ) { - void (*func_glMultiTexCoord2fSGIS)( GLenum, GLfloat, GLfloat ) = extension_funcs[EXT_glMultiTexCoord2fSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", target, s, t ); - func_glMultiTexCoord2fSGIS( target, s, t ); + funcs->ext.p_glMultiTexCoord2fSGIS( target, s, t ); } static void WINAPI wine_glMultiTexCoord2fv( GLenum target, GLfloat* v ) { - void (*func_glMultiTexCoord2fv)( GLenum, GLfloat* ) = extension_funcs[EXT_glMultiTexCoord2fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord2fv( target, v ); + funcs->ext.p_glMultiTexCoord2fv( target, v ); } static void WINAPI wine_glMultiTexCoord2fvARB( GLenum target, GLfloat* v ) { - void (*func_glMultiTexCoord2fvARB)( GLenum, GLfloat* ) = extension_funcs[EXT_glMultiTexCoord2fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord2fvARB( target, v ); + funcs->ext.p_glMultiTexCoord2fvARB( target, v ); } static void WINAPI wine_glMultiTexCoord2fvSGIS( GLenum target, GLfloat * v ) { - void (*func_glMultiTexCoord2fvSGIS)( GLenum, GLfloat * ) = extension_funcs[EXT_glMultiTexCoord2fvSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord2fvSGIS( target, v ); + funcs->ext.p_glMultiTexCoord2fvSGIS( target, v ); } static void WINAPI wine_glMultiTexCoord2hNV( GLenum target, unsigned short s, unsigned short t ) { - void (*func_glMultiTexCoord2hNV)( GLenum, unsigned short, unsigned short ) = extension_funcs[EXT_glMultiTexCoord2hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, s, t ); - func_glMultiTexCoord2hNV( target, s, t ); + funcs->ext.p_glMultiTexCoord2hNV( target, s, t ); } static void WINAPI wine_glMultiTexCoord2hvNV( GLenum target, unsigned short* v ) { - void (*func_glMultiTexCoord2hvNV)( GLenum, unsigned short* ) = extension_funcs[EXT_glMultiTexCoord2hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord2hvNV( target, v ); + funcs->ext.p_glMultiTexCoord2hvNV( target, v ); } static void WINAPI wine_glMultiTexCoord2i( GLenum target, GLint s, GLint t ) { - void (*func_glMultiTexCoord2i)( GLenum, GLint, GLint ) = extension_funcs[EXT_glMultiTexCoord2i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, s, t ); - func_glMultiTexCoord2i( target, s, t ); + funcs->ext.p_glMultiTexCoord2i( target, s, t ); } static void WINAPI wine_glMultiTexCoord2iARB( GLenum target, GLint s, GLint t ) { - void (*func_glMultiTexCoord2iARB)( GLenum, GLint, GLint ) = extension_funcs[EXT_glMultiTexCoord2iARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, s, t ); - func_glMultiTexCoord2iARB( target, s, t ); + funcs->ext.p_glMultiTexCoord2iARB( target, s, t ); } static void WINAPI wine_glMultiTexCoord2iSGIS( GLenum target, GLint s, GLint t ) { - void (*func_glMultiTexCoord2iSGIS)( GLenum, GLint, GLint ) = extension_funcs[EXT_glMultiTexCoord2iSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, s, t ); - func_glMultiTexCoord2iSGIS( target, s, t ); + funcs->ext.p_glMultiTexCoord2iSGIS( target, s, t ); } static void WINAPI wine_glMultiTexCoord2iv( GLenum target, GLint* v ) { - void (*func_glMultiTexCoord2iv)( GLenum, GLint* ) = extension_funcs[EXT_glMultiTexCoord2iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord2iv( target, v ); + funcs->ext.p_glMultiTexCoord2iv( target, v ); } static void WINAPI wine_glMultiTexCoord2ivARB( GLenum target, GLint* v ) { - void (*func_glMultiTexCoord2ivARB)( GLenum, GLint* ) = extension_funcs[EXT_glMultiTexCoord2ivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord2ivARB( target, v ); + funcs->ext.p_glMultiTexCoord2ivARB( target, v ); } static void WINAPI wine_glMultiTexCoord2ivSGIS( GLenum target, GLint * v ) { - void (*func_glMultiTexCoord2ivSGIS)( GLenum, GLint * ) = extension_funcs[EXT_glMultiTexCoord2ivSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord2ivSGIS( target, v ); + funcs->ext.p_glMultiTexCoord2ivSGIS( target, v ); } static void WINAPI wine_glMultiTexCoord2s( GLenum target, GLshort s, GLshort t ) { - void (*func_glMultiTexCoord2s)( GLenum, GLshort, GLshort ) = extension_funcs[EXT_glMultiTexCoord2s]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, s, t ); - func_glMultiTexCoord2s( target, s, t ); + funcs->ext.p_glMultiTexCoord2s( target, s, t ); } static void WINAPI wine_glMultiTexCoord2sARB( GLenum target, GLshort s, GLshort t ) { - void (*func_glMultiTexCoord2sARB)( GLenum, GLshort, GLshort ) = extension_funcs[EXT_glMultiTexCoord2sARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, s, t ); - func_glMultiTexCoord2sARB( target, s, t ); + funcs->ext.p_glMultiTexCoord2sARB( target, s, t ); } static void WINAPI wine_glMultiTexCoord2sSGIS( GLenum target, GLshort s, GLshort t ) { - void (*func_glMultiTexCoord2sSGIS)( GLenum, GLshort, GLshort ) = extension_funcs[EXT_glMultiTexCoord2sSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, s, t ); - func_glMultiTexCoord2sSGIS( target, s, t ); + funcs->ext.p_glMultiTexCoord2sSGIS( target, s, t ); } static void WINAPI wine_glMultiTexCoord2sv( GLenum target, GLshort* v ) { - void (*func_glMultiTexCoord2sv)( GLenum, GLshort* ) = extension_funcs[EXT_glMultiTexCoord2sv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord2sv( target, v ); + funcs->ext.p_glMultiTexCoord2sv( target, v ); } static void WINAPI wine_glMultiTexCoord2svARB( GLenum target, GLshort* v ) { - void (*func_glMultiTexCoord2svARB)( GLenum, GLshort* ) = extension_funcs[EXT_glMultiTexCoord2svARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord2svARB( target, v ); + funcs->ext.p_glMultiTexCoord2svARB( target, v ); } static void WINAPI wine_glMultiTexCoord2svSGIS( GLenum target, GLshort * v ) { - void (*func_glMultiTexCoord2svSGIS)( GLenum, GLshort * ) = extension_funcs[EXT_glMultiTexCoord2svSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord2svSGIS( target, v ); + funcs->ext.p_glMultiTexCoord2svSGIS( target, v ); } static void WINAPI wine_glMultiTexCoord3d( GLenum target, GLdouble s, GLdouble t, GLdouble r ) { - void (*func_glMultiTexCoord3d)( GLenum, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glMultiTexCoord3d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", target, s, t, r ); - func_glMultiTexCoord3d( target, s, t, r ); + funcs->ext.p_glMultiTexCoord3d( target, s, t, r ); } static void WINAPI wine_glMultiTexCoord3dARB( GLenum target, GLdouble s, GLdouble t, GLdouble r ) { - void (*func_glMultiTexCoord3dARB)( GLenum, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glMultiTexCoord3dARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", target, s, t, r ); - func_glMultiTexCoord3dARB( target, s, t, r ); + funcs->ext.p_glMultiTexCoord3dARB( target, s, t, r ); } static void WINAPI wine_glMultiTexCoord3dSGIS( GLenum target, GLdouble s, GLdouble t, GLdouble r ) { - void (*func_glMultiTexCoord3dSGIS)( GLenum, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glMultiTexCoord3dSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", target, s, t, r ); - func_glMultiTexCoord3dSGIS( target, s, t, r ); + funcs->ext.p_glMultiTexCoord3dSGIS( target, s, t, r ); } static void WINAPI wine_glMultiTexCoord3dv( GLenum target, GLdouble* v ) { - void (*func_glMultiTexCoord3dv)( GLenum, GLdouble* ) = extension_funcs[EXT_glMultiTexCoord3dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord3dv( target, v ); + funcs->ext.p_glMultiTexCoord3dv( target, v ); } static void WINAPI wine_glMultiTexCoord3dvARB( GLenum target, GLdouble* v ) { - void (*func_glMultiTexCoord3dvARB)( GLenum, GLdouble* ) = extension_funcs[EXT_glMultiTexCoord3dvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord3dvARB( target, v ); + funcs->ext.p_glMultiTexCoord3dvARB( target, v ); } static void WINAPI wine_glMultiTexCoord3dvSGIS( GLenum target, GLdouble * v ) { - void (*func_glMultiTexCoord3dvSGIS)( GLenum, GLdouble * ) = extension_funcs[EXT_glMultiTexCoord3dvSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord3dvSGIS( target, v ); + funcs->ext.p_glMultiTexCoord3dvSGIS( target, v ); } static void WINAPI wine_glMultiTexCoord3f( GLenum target, GLfloat s, GLfloat t, GLfloat r ) { - void (*func_glMultiTexCoord3f)( GLenum, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glMultiTexCoord3f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", target, s, t, r ); - func_glMultiTexCoord3f( target, s, t, r ); + funcs->ext.p_glMultiTexCoord3f( target, s, t, r ); } static void WINAPI wine_glMultiTexCoord3fARB( GLenum target, GLfloat s, GLfloat t, GLfloat r ) { - void (*func_glMultiTexCoord3fARB)( GLenum, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glMultiTexCoord3fARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", target, s, t, r ); - func_glMultiTexCoord3fARB( target, s, t, r ); + funcs->ext.p_glMultiTexCoord3fARB( target, s, t, r ); } static void WINAPI wine_glMultiTexCoord3fSGIS( GLenum target, GLfloat s, GLfloat t, GLfloat r ) { - void (*func_glMultiTexCoord3fSGIS)( GLenum, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glMultiTexCoord3fSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", target, s, t, r ); - func_glMultiTexCoord3fSGIS( target, s, t, r ); + funcs->ext.p_glMultiTexCoord3fSGIS( target, s, t, r ); } static void WINAPI wine_glMultiTexCoord3fv( GLenum target, GLfloat* v ) { - void (*func_glMultiTexCoord3fv)( GLenum, GLfloat* ) = extension_funcs[EXT_glMultiTexCoord3fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord3fv( target, v ); + funcs->ext.p_glMultiTexCoord3fv( target, v ); } static void WINAPI wine_glMultiTexCoord3fvARB( GLenum target, GLfloat* v ) { - void (*func_glMultiTexCoord3fvARB)( GLenum, GLfloat* ) = extension_funcs[EXT_glMultiTexCoord3fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord3fvARB( target, v ); + funcs->ext.p_glMultiTexCoord3fvARB( target, v ); } static void WINAPI wine_glMultiTexCoord3fvSGIS( GLenum target, GLfloat * v ) { - void (*func_glMultiTexCoord3fvSGIS)( GLenum, GLfloat * ) = extension_funcs[EXT_glMultiTexCoord3fvSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord3fvSGIS( target, v ); + funcs->ext.p_glMultiTexCoord3fvSGIS( target, v ); } static void WINAPI wine_glMultiTexCoord3hNV( GLenum target, unsigned short s, unsigned short t, unsigned short r ) { - void (*func_glMultiTexCoord3hNV)( GLenum, unsigned short, unsigned short, unsigned short ) = extension_funcs[EXT_glMultiTexCoord3hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", target, s, t, r ); - func_glMultiTexCoord3hNV( target, s, t, r ); + funcs->ext.p_glMultiTexCoord3hNV( target, s, t, r ); } static void WINAPI wine_glMultiTexCoord3hvNV( GLenum target, unsigned short* v ) { - void (*func_glMultiTexCoord3hvNV)( GLenum, unsigned short* ) = extension_funcs[EXT_glMultiTexCoord3hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord3hvNV( target, v ); + funcs->ext.p_glMultiTexCoord3hvNV( target, v ); } static void WINAPI wine_glMultiTexCoord3i( GLenum target, GLint s, GLint t, GLint r ) { - void (*func_glMultiTexCoord3i)( GLenum, GLint, GLint, GLint ) = extension_funcs[EXT_glMultiTexCoord3i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", target, s, t, r ); - func_glMultiTexCoord3i( target, s, t, r ); + funcs->ext.p_glMultiTexCoord3i( target, s, t, r ); } static void WINAPI wine_glMultiTexCoord3iARB( GLenum target, GLint s, GLint t, GLint r ) { - void (*func_glMultiTexCoord3iARB)( GLenum, GLint, GLint, GLint ) = extension_funcs[EXT_glMultiTexCoord3iARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", target, s, t, r ); - func_glMultiTexCoord3iARB( target, s, t, r ); + funcs->ext.p_glMultiTexCoord3iARB( target, s, t, r ); } static void WINAPI wine_glMultiTexCoord3iSGIS( GLenum target, GLint s, GLint t, GLint r ) { - void (*func_glMultiTexCoord3iSGIS)( GLenum, GLint, GLint, GLint ) = extension_funcs[EXT_glMultiTexCoord3iSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", target, s, t, r ); - func_glMultiTexCoord3iSGIS( target, s, t, r ); + funcs->ext.p_glMultiTexCoord3iSGIS( target, s, t, r ); } static void WINAPI wine_glMultiTexCoord3iv( GLenum target, GLint* v ) { - void (*func_glMultiTexCoord3iv)( GLenum, GLint* ) = extension_funcs[EXT_glMultiTexCoord3iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord3iv( target, v ); + funcs->ext.p_glMultiTexCoord3iv( target, v ); } static void WINAPI wine_glMultiTexCoord3ivARB( GLenum target, GLint* v ) { - void (*func_glMultiTexCoord3ivARB)( GLenum, GLint* ) = extension_funcs[EXT_glMultiTexCoord3ivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord3ivARB( target, v ); + funcs->ext.p_glMultiTexCoord3ivARB( target, v ); } static void WINAPI wine_glMultiTexCoord3ivSGIS( GLenum target, GLint * v ) { - void (*func_glMultiTexCoord3ivSGIS)( GLenum, GLint * ) = extension_funcs[EXT_glMultiTexCoord3ivSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord3ivSGIS( target, v ); + funcs->ext.p_glMultiTexCoord3ivSGIS( target, v ); } static void WINAPI wine_glMultiTexCoord3s( GLenum target, GLshort s, GLshort t, GLshort r ) { - void (*func_glMultiTexCoord3s)( GLenum, GLshort, GLshort, GLshort ) = extension_funcs[EXT_glMultiTexCoord3s]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", target, s, t, r ); - func_glMultiTexCoord3s( target, s, t, r ); + funcs->ext.p_glMultiTexCoord3s( target, s, t, r ); } static void WINAPI wine_glMultiTexCoord3sARB( GLenum target, GLshort s, GLshort t, GLshort r ) { - void (*func_glMultiTexCoord3sARB)( GLenum, GLshort, GLshort, GLshort ) = extension_funcs[EXT_glMultiTexCoord3sARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", target, s, t, r ); - func_glMultiTexCoord3sARB( target, s, t, r ); + funcs->ext.p_glMultiTexCoord3sARB( target, s, t, r ); } static void WINAPI wine_glMultiTexCoord3sSGIS( GLenum target, GLshort s, GLshort t, GLshort r ) { - void (*func_glMultiTexCoord3sSGIS)( GLenum, GLshort, GLshort, GLshort ) = extension_funcs[EXT_glMultiTexCoord3sSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", target, s, t, r ); - func_glMultiTexCoord3sSGIS( target, s, t, r ); + funcs->ext.p_glMultiTexCoord3sSGIS( target, s, t, r ); } static void WINAPI wine_glMultiTexCoord3sv( GLenum target, GLshort* v ) { - void (*func_glMultiTexCoord3sv)( GLenum, GLshort* ) = extension_funcs[EXT_glMultiTexCoord3sv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord3sv( target, v ); + funcs->ext.p_glMultiTexCoord3sv( target, v ); } static void WINAPI wine_glMultiTexCoord3svARB( GLenum target, GLshort* v ) { - void (*func_glMultiTexCoord3svARB)( GLenum, GLshort* ) = extension_funcs[EXT_glMultiTexCoord3svARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord3svARB( target, v ); + funcs->ext.p_glMultiTexCoord3svARB( target, v ); } static void WINAPI wine_glMultiTexCoord3svSGIS( GLenum target, GLshort * v ) { - void (*func_glMultiTexCoord3svSGIS)( GLenum, GLshort * ) = extension_funcs[EXT_glMultiTexCoord3svSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord3svSGIS( target, v ); + funcs->ext.p_glMultiTexCoord3svSGIS( target, v ); } static void WINAPI wine_glMultiTexCoord4d( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q ) { - void (*func_glMultiTexCoord4d)( GLenum, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glMultiTexCoord4d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", target, s, t, r, q ); - func_glMultiTexCoord4d( target, s, t, r, q ); + funcs->ext.p_glMultiTexCoord4d( target, s, t, r, q ); } static void WINAPI wine_glMultiTexCoord4dARB( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q ) { - void (*func_glMultiTexCoord4dARB)( GLenum, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glMultiTexCoord4dARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", target, s, t, r, q ); - func_glMultiTexCoord4dARB( target, s, t, r, q ); + funcs->ext.p_glMultiTexCoord4dARB( target, s, t, r, q ); } static void WINAPI wine_glMultiTexCoord4dSGIS( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q ) { - void (*func_glMultiTexCoord4dSGIS)( GLenum, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glMultiTexCoord4dSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", target, s, t, r, q ); - func_glMultiTexCoord4dSGIS( target, s, t, r, q ); + funcs->ext.p_glMultiTexCoord4dSGIS( target, s, t, r, q ); } static void WINAPI wine_glMultiTexCoord4dv( GLenum target, GLdouble* v ) { - void (*func_glMultiTexCoord4dv)( GLenum, GLdouble* ) = extension_funcs[EXT_glMultiTexCoord4dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord4dv( target, v ); + funcs->ext.p_glMultiTexCoord4dv( target, v ); } static void WINAPI wine_glMultiTexCoord4dvARB( GLenum target, GLdouble* v ) { - void (*func_glMultiTexCoord4dvARB)( GLenum, GLdouble* ) = extension_funcs[EXT_glMultiTexCoord4dvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord4dvARB( target, v ); + funcs->ext.p_glMultiTexCoord4dvARB( target, v ); } static void WINAPI wine_glMultiTexCoord4dvSGIS( GLenum target, GLdouble * v ) { - void (*func_glMultiTexCoord4dvSGIS)( GLenum, GLdouble * ) = extension_funcs[EXT_glMultiTexCoord4dvSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord4dvSGIS( target, v ); + funcs->ext.p_glMultiTexCoord4dvSGIS( target, v ); } static void WINAPI wine_glMultiTexCoord4f( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q ) { - void (*func_glMultiTexCoord4f)( GLenum, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glMultiTexCoord4f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", target, s, t, r, q ); - func_glMultiTexCoord4f( target, s, t, r, q ); + funcs->ext.p_glMultiTexCoord4f( target, s, t, r, q ); } static void WINAPI wine_glMultiTexCoord4fARB( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q ) { - void (*func_glMultiTexCoord4fARB)( GLenum, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glMultiTexCoord4fARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", target, s, t, r, q ); - func_glMultiTexCoord4fARB( target, s, t, r, q ); + funcs->ext.p_glMultiTexCoord4fARB( target, s, t, r, q ); } static void WINAPI wine_glMultiTexCoord4fSGIS( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q ) { - void (*func_glMultiTexCoord4fSGIS)( GLenum, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glMultiTexCoord4fSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", target, s, t, r, q ); - func_glMultiTexCoord4fSGIS( target, s, t, r, q ); + funcs->ext.p_glMultiTexCoord4fSGIS( target, s, t, r, q ); } static void WINAPI wine_glMultiTexCoord4fv( GLenum target, GLfloat* v ) { - void (*func_glMultiTexCoord4fv)( GLenum, GLfloat* ) = extension_funcs[EXT_glMultiTexCoord4fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord4fv( target, v ); + funcs->ext.p_glMultiTexCoord4fv( target, v ); } static void WINAPI wine_glMultiTexCoord4fvARB( GLenum target, GLfloat* v ) { - void (*func_glMultiTexCoord4fvARB)( GLenum, GLfloat* ) = extension_funcs[EXT_glMultiTexCoord4fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord4fvARB( target, v ); + funcs->ext.p_glMultiTexCoord4fvARB( target, v ); } static void WINAPI wine_glMultiTexCoord4fvSGIS( GLenum target, GLfloat * v ) { - void (*func_glMultiTexCoord4fvSGIS)( GLenum, GLfloat * ) = extension_funcs[EXT_glMultiTexCoord4fvSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord4fvSGIS( target, v ); + funcs->ext.p_glMultiTexCoord4fvSGIS( target, v ); } static void WINAPI wine_glMultiTexCoord4hNV( GLenum target, unsigned short s, unsigned short t, unsigned short r, unsigned short q ) { - void (*func_glMultiTexCoord4hNV)( GLenum, unsigned short, unsigned short, unsigned short, unsigned short ) = extension_funcs[EXT_glMultiTexCoord4hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, s, t, r, q ); - func_glMultiTexCoord4hNV( target, s, t, r, q ); + funcs->ext.p_glMultiTexCoord4hNV( target, s, t, r, q ); } static void WINAPI wine_glMultiTexCoord4hvNV( GLenum target, unsigned short* v ) { - void (*func_glMultiTexCoord4hvNV)( GLenum, unsigned short* ) = extension_funcs[EXT_glMultiTexCoord4hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord4hvNV( target, v ); + funcs->ext.p_glMultiTexCoord4hvNV( target, v ); } static void WINAPI wine_glMultiTexCoord4i( GLenum target, GLint s, GLint t, GLint r, GLint q ) { - void (*func_glMultiTexCoord4i)( GLenum, GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glMultiTexCoord4i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, s, t, r, q ); - func_glMultiTexCoord4i( target, s, t, r, q ); + funcs->ext.p_glMultiTexCoord4i( target, s, t, r, q ); } static void WINAPI wine_glMultiTexCoord4iARB( GLenum target, GLint s, GLint t, GLint r, GLint q ) { - void (*func_glMultiTexCoord4iARB)( GLenum, GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glMultiTexCoord4iARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, s, t, r, q ); - func_glMultiTexCoord4iARB( target, s, t, r, q ); + funcs->ext.p_glMultiTexCoord4iARB( target, s, t, r, q ); } static void WINAPI wine_glMultiTexCoord4iSGIS( GLenum target, GLint s, GLint t, GLint r, GLint q ) { - void (*func_glMultiTexCoord4iSGIS)( GLenum, GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glMultiTexCoord4iSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, s, t, r, q ); - func_glMultiTexCoord4iSGIS( target, s, t, r, q ); + funcs->ext.p_glMultiTexCoord4iSGIS( target, s, t, r, q ); } static void WINAPI wine_glMultiTexCoord4iv( GLenum target, GLint* v ) { - void (*func_glMultiTexCoord4iv)( GLenum, GLint* ) = extension_funcs[EXT_glMultiTexCoord4iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord4iv( target, v ); + funcs->ext.p_glMultiTexCoord4iv( target, v ); } static void WINAPI wine_glMultiTexCoord4ivARB( GLenum target, GLint* v ) { - void (*func_glMultiTexCoord4ivARB)( GLenum, GLint* ) = extension_funcs[EXT_glMultiTexCoord4ivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord4ivARB( target, v ); + funcs->ext.p_glMultiTexCoord4ivARB( target, v ); } static void WINAPI wine_glMultiTexCoord4ivSGIS( GLenum target, GLint * v ) { - void (*func_glMultiTexCoord4ivSGIS)( GLenum, GLint * ) = extension_funcs[EXT_glMultiTexCoord4ivSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord4ivSGIS( target, v ); + funcs->ext.p_glMultiTexCoord4ivSGIS( target, v ); } static void WINAPI wine_glMultiTexCoord4s( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q ) { - void (*func_glMultiTexCoord4s)( GLenum, GLshort, GLshort, GLshort, GLshort ) = extension_funcs[EXT_glMultiTexCoord4s]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, s, t, r, q ); - func_glMultiTexCoord4s( target, s, t, r, q ); + funcs->ext.p_glMultiTexCoord4s( target, s, t, r, q ); } static void WINAPI wine_glMultiTexCoord4sARB( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q ) { - void (*func_glMultiTexCoord4sARB)( GLenum, GLshort, GLshort, GLshort, GLshort ) = extension_funcs[EXT_glMultiTexCoord4sARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, s, t, r, q ); - func_glMultiTexCoord4sARB( target, s, t, r, q ); + funcs->ext.p_glMultiTexCoord4sARB( target, s, t, r, q ); } static void WINAPI wine_glMultiTexCoord4sSGIS( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q ) { - void (*func_glMultiTexCoord4sSGIS)( GLenum, GLshort, GLshort, GLshort, GLshort ) = extension_funcs[EXT_glMultiTexCoord4sSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, s, t, r, q ); - func_glMultiTexCoord4sSGIS( target, s, t, r, q ); + funcs->ext.p_glMultiTexCoord4sSGIS( target, s, t, r, q ); } static void WINAPI wine_glMultiTexCoord4sv( GLenum target, GLshort* v ) { - void (*func_glMultiTexCoord4sv)( GLenum, GLshort* ) = extension_funcs[EXT_glMultiTexCoord4sv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord4sv( target, v ); + funcs->ext.p_glMultiTexCoord4sv( target, v ); } static void WINAPI wine_glMultiTexCoord4svARB( GLenum target, GLshort* v ) { - void (*func_glMultiTexCoord4svARB)( GLenum, GLshort* ) = extension_funcs[EXT_glMultiTexCoord4svARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord4svARB( target, v ); + funcs->ext.p_glMultiTexCoord4svARB( target, v ); } static void WINAPI wine_glMultiTexCoord4svSGIS( GLenum target, GLshort * v ) { - void (*func_glMultiTexCoord4svSGIS)( GLenum, GLshort * ) = extension_funcs[EXT_glMultiTexCoord4svSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", target, v ); - func_glMultiTexCoord4svSGIS( target, v ); + funcs->ext.p_glMultiTexCoord4svSGIS( target, v ); } static void WINAPI wine_glMultiTexCoordP1ui( GLenum texture, GLenum type, GLuint coords ) { - void (*func_glMultiTexCoordP1ui)( GLenum, GLenum, GLuint ) = extension_funcs[EXT_glMultiTexCoordP1ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", texture, type, coords ); - func_glMultiTexCoordP1ui( texture, type, coords ); + funcs->ext.p_glMultiTexCoordP1ui( texture, type, coords ); } static void WINAPI wine_glMultiTexCoordP1uiv( GLenum texture, GLenum type, GLuint* coords ) { - void (*func_glMultiTexCoordP1uiv)( GLenum, GLenum, GLuint* ) = extension_funcs[EXT_glMultiTexCoordP1uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", texture, type, coords ); - func_glMultiTexCoordP1uiv( texture, type, coords ); + funcs->ext.p_glMultiTexCoordP1uiv( texture, type, coords ); } static void WINAPI wine_glMultiTexCoordP2ui( GLenum texture, GLenum type, GLuint coords ) { - void (*func_glMultiTexCoordP2ui)( GLenum, GLenum, GLuint ) = extension_funcs[EXT_glMultiTexCoordP2ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", texture, type, coords ); - func_glMultiTexCoordP2ui( texture, type, coords ); + funcs->ext.p_glMultiTexCoordP2ui( texture, type, coords ); } static void WINAPI wine_glMultiTexCoordP2uiv( GLenum texture, GLenum type, GLuint* coords ) { - void (*func_glMultiTexCoordP2uiv)( GLenum, GLenum, GLuint* ) = extension_funcs[EXT_glMultiTexCoordP2uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", texture, type, coords ); - func_glMultiTexCoordP2uiv( texture, type, coords ); + funcs->ext.p_glMultiTexCoordP2uiv( texture, type, coords ); } static void WINAPI wine_glMultiTexCoordP3ui( GLenum texture, GLenum type, GLuint coords ) { - void (*func_glMultiTexCoordP3ui)( GLenum, GLenum, GLuint ) = extension_funcs[EXT_glMultiTexCoordP3ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", texture, type, coords ); - func_glMultiTexCoordP3ui( texture, type, coords ); + funcs->ext.p_glMultiTexCoordP3ui( texture, type, coords ); } static void WINAPI wine_glMultiTexCoordP3uiv( GLenum texture, GLenum type, GLuint* coords ) { - void (*func_glMultiTexCoordP3uiv)( GLenum, GLenum, GLuint* ) = extension_funcs[EXT_glMultiTexCoordP3uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", texture, type, coords ); - func_glMultiTexCoordP3uiv( texture, type, coords ); + funcs->ext.p_glMultiTexCoordP3uiv( texture, type, coords ); } static void WINAPI wine_glMultiTexCoordP4ui( GLenum texture, GLenum type, GLuint coords ) { - void (*func_glMultiTexCoordP4ui)( GLenum, GLenum, GLuint ) = extension_funcs[EXT_glMultiTexCoordP4ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", texture, type, coords ); - func_glMultiTexCoordP4ui( texture, type, coords ); + funcs->ext.p_glMultiTexCoordP4ui( texture, type, coords ); } static void WINAPI wine_glMultiTexCoordP4uiv( GLenum texture, GLenum type, GLuint* coords ) { - void (*func_glMultiTexCoordP4uiv)( GLenum, GLenum, GLuint* ) = extension_funcs[EXT_glMultiTexCoordP4uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", texture, type, coords ); - func_glMultiTexCoordP4uiv( texture, type, coords ); + funcs->ext.p_glMultiTexCoordP4uiv( texture, type, coords ); } static void WINAPI wine_glMultiTexCoordPointerEXT( GLenum texunit, GLint size, GLenum type, GLsizei stride, GLvoid* pointer ) { - void (*func_glMultiTexCoordPointerEXT)( GLenum, GLint, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glMultiTexCoordPointerEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", texunit, size, type, stride, pointer ); - func_glMultiTexCoordPointerEXT( texunit, size, type, stride, pointer ); + funcs->ext.p_glMultiTexCoordPointerEXT( texunit, size, type, stride, pointer ); } static void WINAPI wine_glMultiTexCoordPointerSGIS( GLenum target, GLint size, GLenum type, GLsizei stride, GLvoid * pointer ) { - void (*func_glMultiTexCoordPointerSGIS)( GLenum, GLint, GLenum, GLsizei, GLvoid * ) = extension_funcs[EXT_glMultiTexCoordPointerSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", target, size, type, stride, pointer ); - func_glMultiTexCoordPointerSGIS( target, size, type, stride, pointer ); + funcs->ext.p_glMultiTexCoordPointerSGIS( target, size, type, stride, pointer ); } static void WINAPI wine_glMultiTexEnvfEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat param ) { - void (*func_glMultiTexEnvfEXT)( GLenum, GLenum, GLenum, GLfloat ) = extension_funcs[EXT_glMultiTexEnvfEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %f)\n", texunit, target, pname, param ); - func_glMultiTexEnvfEXT( texunit, target, pname, param ); + funcs->ext.p_glMultiTexEnvfEXT( texunit, target, pname, param ); } static void WINAPI wine_glMultiTexEnvfvEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glMultiTexEnvfvEXT)( GLenum, GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glMultiTexEnvfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params ); - func_glMultiTexEnvfvEXT( texunit, target, pname, params ); + funcs->ext.p_glMultiTexEnvfvEXT( texunit, target, pname, params ); } static void WINAPI wine_glMultiTexEnviEXT( GLenum texunit, GLenum target, GLenum pname, GLint param ) { - void (*func_glMultiTexEnviEXT)( GLenum, GLenum, GLenum, GLint ) = extension_funcs[EXT_glMultiTexEnviEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", texunit, target, pname, param ); - func_glMultiTexEnviEXT( texunit, target, pname, param ); + funcs->ext.p_glMultiTexEnviEXT( texunit, target, pname, param ); } static void WINAPI wine_glMultiTexEnvivEXT( GLenum texunit, GLenum target, GLenum pname, GLint* params ) { - void (*func_glMultiTexEnvivEXT)( GLenum, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glMultiTexEnvivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params ); - func_glMultiTexEnvivEXT( texunit, target, pname, params ); + funcs->ext.p_glMultiTexEnvivEXT( texunit, target, pname, params ); } static void WINAPI wine_glMultiTexGendEXT( GLenum texunit, GLenum coord, GLenum pname, GLdouble param ) { - void (*func_glMultiTexGendEXT)( GLenum, GLenum, GLenum, GLdouble ) = extension_funcs[EXT_glMultiTexGendEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %f)\n", texunit, coord, pname, param ); - func_glMultiTexGendEXT( texunit, coord, pname, param ); + funcs->ext.p_glMultiTexGendEXT( texunit, coord, pname, param ); } static void WINAPI wine_glMultiTexGendvEXT( GLenum texunit, GLenum coord, GLenum pname, GLdouble* params ) { - void (*func_glMultiTexGendvEXT)( GLenum, GLenum, GLenum, GLdouble* ) = extension_funcs[EXT_glMultiTexGendvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, coord, pname, params ); - func_glMultiTexGendvEXT( texunit, coord, pname, params ); + funcs->ext.p_glMultiTexGendvEXT( texunit, coord, pname, params ); } static void WINAPI wine_glMultiTexGenfEXT( GLenum texunit, GLenum coord, GLenum pname, GLfloat param ) { - void (*func_glMultiTexGenfEXT)( GLenum, GLenum, GLenum, GLfloat ) = extension_funcs[EXT_glMultiTexGenfEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %f)\n", texunit, coord, pname, param ); - func_glMultiTexGenfEXT( texunit, coord, pname, param ); + funcs->ext.p_glMultiTexGenfEXT( texunit, coord, pname, param ); } static void WINAPI wine_glMultiTexGenfvEXT( GLenum texunit, GLenum coord, GLenum pname, GLfloat* params ) { - void (*func_glMultiTexGenfvEXT)( GLenum, GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glMultiTexGenfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, coord, pname, params ); - func_glMultiTexGenfvEXT( texunit, coord, pname, params ); + funcs->ext.p_glMultiTexGenfvEXT( texunit, coord, pname, params ); } static void WINAPI wine_glMultiTexGeniEXT( GLenum texunit, GLenum coord, GLenum pname, GLint param ) { - void (*func_glMultiTexGeniEXT)( GLenum, GLenum, GLenum, GLint ) = extension_funcs[EXT_glMultiTexGeniEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", texunit, coord, pname, param ); - func_glMultiTexGeniEXT( texunit, coord, pname, param ); + funcs->ext.p_glMultiTexGeniEXT( texunit, coord, pname, param ); } static void WINAPI wine_glMultiTexGenivEXT( GLenum texunit, GLenum coord, GLenum pname, GLint* params ) { - void (*func_glMultiTexGenivEXT)( GLenum, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glMultiTexGenivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, coord, pname, params ); - func_glMultiTexGenivEXT( texunit, coord, pname, params ); + funcs->ext.p_glMultiTexGenivEXT( texunit, coord, pname, params ); } static void WINAPI wine_glMultiTexImage1DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glMultiTexImage1DEXT)( GLenum, GLenum, GLint, GLenum, GLsizei, GLint, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glMultiTexImage1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, internalformat, width, border, format, type, pixels ); - func_glMultiTexImage1DEXT( texunit, target, level, internalformat, width, border, format, type, pixels ); + funcs->ext.p_glMultiTexImage1DEXT( texunit, target, level, internalformat, width, border, format, type, pixels ); } static void WINAPI wine_glMultiTexImage2DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glMultiTexImage2DEXT)( GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glMultiTexImage2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, internalformat, width, height, border, format, type, pixels ); - func_glMultiTexImage2DEXT( texunit, target, level, internalformat, width, height, border, format, type, pixels ); + funcs->ext.p_glMultiTexImage2DEXT( texunit, target, level, internalformat, width, height, border, format, type, pixels ); } static void WINAPI wine_glMultiTexImage3DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glMultiTexImage3DEXT)( GLenum, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glMultiTexImage3DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, internalformat, width, height, depth, border, format, type, pixels ); - func_glMultiTexImage3DEXT( texunit, target, level, internalformat, width, height, depth, border, format, type, pixels ); + funcs->ext.p_glMultiTexImage3DEXT( texunit, target, level, internalformat, width, height, depth, border, format, type, pixels ); } static void WINAPI wine_glMultiTexParameterIivEXT( GLenum texunit, GLenum target, GLenum pname, GLint* params ) { - void (*func_glMultiTexParameterIivEXT)( GLenum, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glMultiTexParameterIivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params ); - func_glMultiTexParameterIivEXT( texunit, target, pname, params ); + funcs->ext.p_glMultiTexParameterIivEXT( texunit, target, pname, params ); } static void WINAPI wine_glMultiTexParameterIuivEXT( GLenum texunit, GLenum target, GLenum pname, GLuint* params ) { - void (*func_glMultiTexParameterIuivEXT)( GLenum, GLenum, GLenum, GLuint* ) = extension_funcs[EXT_glMultiTexParameterIuivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params ); - func_glMultiTexParameterIuivEXT( texunit, target, pname, params ); + funcs->ext.p_glMultiTexParameterIuivEXT( texunit, target, pname, params ); } static void WINAPI wine_glMultiTexParameterfEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat param ) { - void (*func_glMultiTexParameterfEXT)( GLenum, GLenum, GLenum, GLfloat ) = extension_funcs[EXT_glMultiTexParameterfEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %f)\n", texunit, target, pname, param ); - func_glMultiTexParameterfEXT( texunit, target, pname, param ); + funcs->ext.p_glMultiTexParameterfEXT( texunit, target, pname, param ); } static void WINAPI wine_glMultiTexParameterfvEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glMultiTexParameterfvEXT)( GLenum, GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glMultiTexParameterfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params ); - func_glMultiTexParameterfvEXT( texunit, target, pname, params ); + funcs->ext.p_glMultiTexParameterfvEXT( texunit, target, pname, params ); } static void WINAPI wine_glMultiTexParameteriEXT( GLenum texunit, GLenum target, GLenum pname, GLint param ) { - void (*func_glMultiTexParameteriEXT)( GLenum, GLenum, GLenum, GLint ) = extension_funcs[EXT_glMultiTexParameteriEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", texunit, target, pname, param ); - func_glMultiTexParameteriEXT( texunit, target, pname, param ); + funcs->ext.p_glMultiTexParameteriEXT( texunit, target, pname, param ); } static void WINAPI wine_glMultiTexParameterivEXT( GLenum texunit, GLenum target, GLenum pname, GLint* params ) { - void (*func_glMultiTexParameterivEXT)( GLenum, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glMultiTexParameterivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params ); - func_glMultiTexParameterivEXT( texunit, target, pname, params ); + funcs->ext.p_glMultiTexParameterivEXT( texunit, target, pname, params ); } static void WINAPI wine_glMultiTexRenderbufferEXT( GLenum texunit, GLenum target, GLuint renderbuffer ) { - void (*func_glMultiTexRenderbufferEXT)( GLenum, GLenum, GLuint ) = extension_funcs[EXT_glMultiTexRenderbufferEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", texunit, target, renderbuffer ); - func_glMultiTexRenderbufferEXT( texunit, target, renderbuffer ); + funcs->ext.p_glMultiTexRenderbufferEXT( texunit, target, renderbuffer ); } static void WINAPI wine_glMultiTexSubImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glMultiTexSubImage1DEXT)( GLenum, GLenum, GLint, GLint, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glMultiTexSubImage1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, xoffset, width, format, type, pixels ); - func_glMultiTexSubImage1DEXT( texunit, target, level, xoffset, width, format, type, pixels ); + funcs->ext.p_glMultiTexSubImage1DEXT( texunit, target, level, xoffset, width, format, type, pixels ); } static void WINAPI wine_glMultiTexSubImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glMultiTexSubImage2DEXT)( GLenum, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glMultiTexSubImage2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, xoffset, yoffset, width, height, format, type, pixels ); - func_glMultiTexSubImage2DEXT( texunit, target, level, xoffset, yoffset, width, height, format, type, pixels ); + funcs->ext.p_glMultiTexSubImage2DEXT( texunit, target, level, xoffset, yoffset, width, height, format, type, pixels ); } static void WINAPI wine_glMultiTexSubImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glMultiTexSubImage3DEXT)( GLenum, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glMultiTexSubImage3DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels ); - func_glMultiTexSubImage3DEXT( texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels ); + funcs->ext.p_glMultiTexSubImage3DEXT( texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels ); } static void WINAPI wine_glNamedBufferDataEXT( GLuint buffer, INT_PTR size, GLvoid* data, GLenum usage ) { - void (*func_glNamedBufferDataEXT)( GLuint, INT_PTR, GLvoid*, GLenum ) = extension_funcs[EXT_glNamedBufferDataEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %ld, %p, %d)\n", buffer, size, data, usage ); - func_glNamedBufferDataEXT( buffer, size, data, usage ); + funcs->ext.p_glNamedBufferDataEXT( buffer, size, data, usage ); } static void WINAPI wine_glNamedBufferSubDataEXT( GLuint buffer, INT_PTR offset, INT_PTR size, GLvoid* data ) { - void (*func_glNamedBufferSubDataEXT)( GLuint, INT_PTR, INT_PTR, GLvoid* ) = extension_funcs[EXT_glNamedBufferSubDataEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %ld, %ld, %p)\n", buffer, offset, size, data ); - func_glNamedBufferSubDataEXT( buffer, offset, size, data ); + funcs->ext.p_glNamedBufferSubDataEXT( buffer, offset, size, data ); } static void WINAPI wine_glNamedCopyBufferSubDataEXT( GLuint readBuffer, GLuint writeBuffer, INT_PTR readOffset, INT_PTR writeOffset, INT_PTR size ) { - void (*func_glNamedCopyBufferSubDataEXT)( GLuint, GLuint, INT_PTR, INT_PTR, INT_PTR ) = extension_funcs[EXT_glNamedCopyBufferSubDataEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %ld, %ld, %ld)\n", readBuffer, writeBuffer, readOffset, writeOffset, size ); - func_glNamedCopyBufferSubDataEXT( readBuffer, writeBuffer, readOffset, writeOffset, size ); + funcs->ext.p_glNamedCopyBufferSubDataEXT( readBuffer, writeBuffer, readOffset, writeOffset, size ); } static void WINAPI wine_glNamedFramebufferRenderbufferEXT( GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) { - void (*func_glNamedFramebufferRenderbufferEXT)( GLuint, GLenum, GLenum, GLuint ) = extension_funcs[EXT_glNamedFramebufferRenderbufferEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", framebuffer, attachment, renderbuffertarget, renderbuffer ); - func_glNamedFramebufferRenderbufferEXT( framebuffer, attachment, renderbuffertarget, renderbuffer ); + funcs->ext.p_glNamedFramebufferRenderbufferEXT( framebuffer, attachment, renderbuffertarget, renderbuffer ); } static void WINAPI wine_glNamedFramebufferTexture1DEXT( GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) { - void (*func_glNamedFramebufferTexture1DEXT)( GLuint, GLenum, GLenum, GLuint, GLint ) = extension_funcs[EXT_glNamedFramebufferTexture1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", framebuffer, attachment, textarget, texture, level ); - func_glNamedFramebufferTexture1DEXT( framebuffer, attachment, textarget, texture, level ); + funcs->ext.p_glNamedFramebufferTexture1DEXT( framebuffer, attachment, textarget, texture, level ); } static void WINAPI wine_glNamedFramebufferTexture2DEXT( GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) { - void (*func_glNamedFramebufferTexture2DEXT)( GLuint, GLenum, GLenum, GLuint, GLint ) = extension_funcs[EXT_glNamedFramebufferTexture2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", framebuffer, attachment, textarget, texture, level ); - func_glNamedFramebufferTexture2DEXT( framebuffer, attachment, textarget, texture, level ); + funcs->ext.p_glNamedFramebufferTexture2DEXT( framebuffer, attachment, textarget, texture, level ); } static void WINAPI wine_glNamedFramebufferTexture3DEXT( GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset ) { - void (*func_glNamedFramebufferTexture3DEXT)( GLuint, GLenum, GLenum, GLuint, GLint, GLint ) = extension_funcs[EXT_glNamedFramebufferTexture3DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", framebuffer, attachment, textarget, texture, level, zoffset ); - func_glNamedFramebufferTexture3DEXT( framebuffer, attachment, textarget, texture, level, zoffset ); + funcs->ext.p_glNamedFramebufferTexture3DEXT( framebuffer, attachment, textarget, texture, level, zoffset ); } static void WINAPI wine_glNamedFramebufferTextureEXT( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level ) { - void (*func_glNamedFramebufferTextureEXT)( GLuint, GLenum, GLuint, GLint ) = extension_funcs[EXT_glNamedFramebufferTextureEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", framebuffer, attachment, texture, level ); - func_glNamedFramebufferTextureEXT( framebuffer, attachment, texture, level ); + funcs->ext.p_glNamedFramebufferTextureEXT( framebuffer, attachment, texture, level ); } static void WINAPI wine_glNamedFramebufferTextureFaceEXT( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face ) { - void (*func_glNamedFramebufferTextureFaceEXT)( GLuint, GLenum, GLuint, GLint, GLenum ) = extension_funcs[EXT_glNamedFramebufferTextureFaceEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", framebuffer, attachment, texture, level, face ); - func_glNamedFramebufferTextureFaceEXT( framebuffer, attachment, texture, level, face ); + funcs->ext.p_glNamedFramebufferTextureFaceEXT( framebuffer, attachment, texture, level, face ); } static void WINAPI wine_glNamedFramebufferTextureLayerEXT( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer ) { - void (*func_glNamedFramebufferTextureLayerEXT)( GLuint, GLenum, GLuint, GLint, GLint ) = extension_funcs[EXT_glNamedFramebufferTextureLayerEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", framebuffer, attachment, texture, level, layer ); - func_glNamedFramebufferTextureLayerEXT( framebuffer, attachment, texture, level, layer ); + funcs->ext.p_glNamedFramebufferTextureLayerEXT( framebuffer, attachment, texture, level, layer ); } static void WINAPI wine_glNamedProgramLocalParameter4dEXT( GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { - void (*func_glNamedProgramLocalParameter4dEXT)( GLuint, GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glNamedProgramLocalParameter4dEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %f, %f, %f, %f)\n", program, target, index, x, y, z, w ); - func_glNamedProgramLocalParameter4dEXT( program, target, index, x, y, z, w ); + funcs->ext.p_glNamedProgramLocalParameter4dEXT( program, target, index, x, y, z, w ); } static void WINAPI wine_glNamedProgramLocalParameter4dvEXT( GLuint program, GLenum target, GLuint index, GLdouble* params ) { - void (*func_glNamedProgramLocalParameter4dvEXT)( GLuint, GLenum, GLuint, GLdouble* ) = extension_funcs[EXT_glNamedProgramLocalParameter4dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, target, index, params ); - func_glNamedProgramLocalParameter4dvEXT( program, target, index, params ); + funcs->ext.p_glNamedProgramLocalParameter4dvEXT( program, target, index, params ); } static void WINAPI wine_glNamedProgramLocalParameter4fEXT( GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { - void (*func_glNamedProgramLocalParameter4fEXT)( GLuint, GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glNamedProgramLocalParameter4fEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %f, %f, %f, %f)\n", program, target, index, x, y, z, w ); - func_glNamedProgramLocalParameter4fEXT( program, target, index, x, y, z, w ); + funcs->ext.p_glNamedProgramLocalParameter4fEXT( program, target, index, x, y, z, w ); } static void WINAPI wine_glNamedProgramLocalParameter4fvEXT( GLuint program, GLenum target, GLuint index, GLfloat* params ) { - void (*func_glNamedProgramLocalParameter4fvEXT)( GLuint, GLenum, GLuint, GLfloat* ) = extension_funcs[EXT_glNamedProgramLocalParameter4fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, target, index, params ); - func_glNamedProgramLocalParameter4fvEXT( program, target, index, params ); + funcs->ext.p_glNamedProgramLocalParameter4fvEXT( program, target, index, params ); } static void WINAPI wine_glNamedProgramLocalParameterI4iEXT( GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w ) { - void (*func_glNamedProgramLocalParameterI4iEXT)( GLuint, GLenum, GLuint, GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glNamedProgramLocalParameterI4iEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", program, target, index, x, y, z, w ); - func_glNamedProgramLocalParameterI4iEXT( program, target, index, x, y, z, w ); + funcs->ext.p_glNamedProgramLocalParameterI4iEXT( program, target, index, x, y, z, w ); } static void WINAPI wine_glNamedProgramLocalParameterI4ivEXT( GLuint program, GLenum target, GLuint index, GLint* params ) { - void (*func_glNamedProgramLocalParameterI4ivEXT)( GLuint, GLenum, GLuint, GLint* ) = extension_funcs[EXT_glNamedProgramLocalParameterI4ivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, target, index, params ); - func_glNamedProgramLocalParameterI4ivEXT( program, target, index, params ); + funcs->ext.p_glNamedProgramLocalParameterI4ivEXT( program, target, index, params ); } static void WINAPI wine_glNamedProgramLocalParameterI4uiEXT( GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w ) { - void (*func_glNamedProgramLocalParameterI4uiEXT)( GLuint, GLenum, GLuint, GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glNamedProgramLocalParameterI4uiEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", program, target, index, x, y, z, w ); - func_glNamedProgramLocalParameterI4uiEXT( program, target, index, x, y, z, w ); + funcs->ext.p_glNamedProgramLocalParameterI4uiEXT( program, target, index, x, y, z, w ); } static void WINAPI wine_glNamedProgramLocalParameterI4uivEXT( GLuint program, GLenum target, GLuint index, GLuint* params ) { - void (*func_glNamedProgramLocalParameterI4uivEXT)( GLuint, GLenum, GLuint, GLuint* ) = extension_funcs[EXT_glNamedProgramLocalParameterI4uivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, target, index, params ); - func_glNamedProgramLocalParameterI4uivEXT( program, target, index, params ); + funcs->ext.p_glNamedProgramLocalParameterI4uivEXT( program, target, index, params ); } static void WINAPI wine_glNamedProgramLocalParameters4fvEXT( GLuint program, GLenum target, GLuint index, GLsizei count, GLfloat* params ) { - void (*func_glNamedProgramLocalParameters4fvEXT)( GLuint, GLenum, GLuint, GLsizei, GLfloat* ) = extension_funcs[EXT_glNamedProgramLocalParameters4fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, target, index, count, params ); - func_glNamedProgramLocalParameters4fvEXT( program, target, index, count, params ); + funcs->ext.p_glNamedProgramLocalParameters4fvEXT( program, target, index, count, params ); } static void WINAPI wine_glNamedProgramLocalParametersI4ivEXT( GLuint program, GLenum target, GLuint index, GLsizei count, GLint* params ) { - void (*func_glNamedProgramLocalParametersI4ivEXT)( GLuint, GLenum, GLuint, GLsizei, GLint* ) = extension_funcs[EXT_glNamedProgramLocalParametersI4ivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, target, index, count, params ); - func_glNamedProgramLocalParametersI4ivEXT( program, target, index, count, params ); + funcs->ext.p_glNamedProgramLocalParametersI4ivEXT( program, target, index, count, params ); } static void WINAPI wine_glNamedProgramLocalParametersI4uivEXT( GLuint program, GLenum target, GLuint index, GLsizei count, GLuint* params ) { - void (*func_glNamedProgramLocalParametersI4uivEXT)( GLuint, GLenum, GLuint, GLsizei, GLuint* ) = extension_funcs[EXT_glNamedProgramLocalParametersI4uivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, target, index, count, params ); - func_glNamedProgramLocalParametersI4uivEXT( program, target, index, count, params ); + funcs->ext.p_glNamedProgramLocalParametersI4uivEXT( program, target, index, count, params ); } static void WINAPI wine_glNamedProgramStringEXT( GLuint program, GLenum target, GLenum format, GLsizei len, GLvoid* string ) { - void (*func_glNamedProgramStringEXT)( GLuint, GLenum, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glNamedProgramStringEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, target, format, len, string ); - func_glNamedProgramStringEXT( program, target, format, len, string ); + funcs->ext.p_glNamedProgramStringEXT( program, target, format, len, string ); } static void WINAPI wine_glNamedRenderbufferStorageEXT( GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height ) { - void (*func_glNamedRenderbufferStorageEXT)( GLuint, GLenum, GLsizei, GLsizei ) = extension_funcs[EXT_glNamedRenderbufferStorageEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", renderbuffer, internalformat, width, height ); - func_glNamedRenderbufferStorageEXT( renderbuffer, internalformat, width, height ); + funcs->ext.p_glNamedRenderbufferStorageEXT( renderbuffer, internalformat, width, height ); } static void WINAPI wine_glNamedRenderbufferStorageMultisampleCoverageEXT( GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height ) { - void (*func_glNamedRenderbufferStorageMultisampleCoverageEXT)( GLuint, GLsizei, GLsizei, GLenum, GLsizei, GLsizei ) = extension_funcs[EXT_glNamedRenderbufferStorageMultisampleCoverageEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", renderbuffer, coverageSamples, colorSamples, internalformat, width, height ); - func_glNamedRenderbufferStorageMultisampleCoverageEXT( renderbuffer, coverageSamples, colorSamples, internalformat, width, height ); + funcs->ext.p_glNamedRenderbufferStorageMultisampleCoverageEXT( renderbuffer, coverageSamples, colorSamples, internalformat, width, height ); } static void WINAPI wine_glNamedRenderbufferStorageMultisampleEXT( GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height ) { - void (*func_glNamedRenderbufferStorageMultisampleEXT)( GLuint, GLsizei, GLenum, GLsizei, GLsizei ) = extension_funcs[EXT_glNamedRenderbufferStorageMultisampleEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", renderbuffer, samples, internalformat, width, height ); - func_glNamedRenderbufferStorageMultisampleEXT( renderbuffer, samples, internalformat, width, height ); + funcs->ext.p_glNamedRenderbufferStorageMultisampleEXT( renderbuffer, samples, internalformat, width, height ); } static void WINAPI wine_glNamedStringARB( GLenum type, GLint namelen, char* name, GLint stringlen, char* string ) { - void (*func_glNamedStringARB)( GLenum, GLint, char*, GLint, char* ) = extension_funcs[EXT_glNamedStringARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %d, %p)\n", type, namelen, name, stringlen, string ); - func_glNamedStringARB( type, namelen, name, stringlen, string ); + funcs->ext.p_glNamedStringARB( type, namelen, name, stringlen, string ); } static GLuint WINAPI wine_glNewBufferRegion( GLenum type ) { - GLuint (*func_glNewBufferRegion)( GLenum ) = extension_funcs[EXT_glNewBufferRegion]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", type ); - return func_glNewBufferRegion( type ); + return funcs->ext.p_glNewBufferRegion( type ); } static GLuint WINAPI wine_glNewObjectBufferATI( GLsizei size, GLvoid* pointer, GLenum usage ) { - GLuint (*func_glNewObjectBufferATI)( GLsizei, GLvoid*, GLenum ) = extension_funcs[EXT_glNewObjectBufferATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %d)\n", size, pointer, usage ); - return func_glNewObjectBufferATI( size, pointer, usage ); + return funcs->ext.p_glNewObjectBufferATI( size, pointer, usage ); } static void WINAPI wine_glNormal3fVertex3fSUN( GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glNormal3fVertex3fSUN)( GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glNormal3fVertex3fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f, %f, %f, %f)\n", nx, ny, nz, x, y, z ); - func_glNormal3fVertex3fSUN( nx, ny, nz, x, y, z ); + funcs->ext.p_glNormal3fVertex3fSUN( nx, ny, nz, x, y, z ); } static void WINAPI wine_glNormal3fVertex3fvSUN( GLfloat* n, GLfloat* v ) { - void (*func_glNormal3fVertex3fvSUN)( GLfloat*, GLfloat* ) = extension_funcs[EXT_glNormal3fVertex3fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p)\n", n, v ); - func_glNormal3fVertex3fvSUN( n, v ); + funcs->ext.p_glNormal3fVertex3fvSUN( n, v ); } static void WINAPI wine_glNormal3hNV( unsigned short nx, unsigned short ny, unsigned short nz ) { - void (*func_glNormal3hNV)( unsigned short, unsigned short, unsigned short ) = extension_funcs[EXT_glNormal3hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", nx, ny, nz ); - func_glNormal3hNV( nx, ny, nz ); + funcs->ext.p_glNormal3hNV( nx, ny, nz ); } static void WINAPI wine_glNormal3hvNV( unsigned short* v ) { - void (*func_glNormal3hvNV)( unsigned short* ) = extension_funcs[EXT_glNormal3hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glNormal3hvNV( v ); + funcs->ext.p_glNormal3hvNV( v ); } static void WINAPI wine_glNormalFormatNV( GLenum type, GLsizei stride ) { - void (*func_glNormalFormatNV)( GLenum, GLsizei ) = extension_funcs[EXT_glNormalFormatNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", type, stride ); - func_glNormalFormatNV( type, stride ); + funcs->ext.p_glNormalFormatNV( type, stride ); } static void WINAPI wine_glNormalP3ui( GLenum type, GLuint coords ) { - void (*func_glNormalP3ui)( GLenum, GLuint ) = extension_funcs[EXT_glNormalP3ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", type, coords ); - func_glNormalP3ui( type, coords ); + funcs->ext.p_glNormalP3ui( type, coords ); } static void WINAPI wine_glNormalP3uiv( GLenum type, GLuint* coords ) { - void (*func_glNormalP3uiv)( GLenum, GLuint* ) = extension_funcs[EXT_glNormalP3uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", type, coords ); - func_glNormalP3uiv( type, coords ); + funcs->ext.p_glNormalP3uiv( type, coords ); } static void WINAPI wine_glNormalPointerEXT( GLenum type, GLsizei stride, GLsizei count, GLvoid* pointer ) { - void (*func_glNormalPointerEXT)( GLenum, GLsizei, GLsizei, GLvoid* ) = extension_funcs[EXT_glNormalPointerEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", type, stride, count, pointer ); - func_glNormalPointerEXT( type, stride, count, pointer ); + funcs->ext.p_glNormalPointerEXT( type, stride, count, pointer ); } static void WINAPI wine_glNormalPointerListIBM( GLenum type, GLint stride, GLvoid** pointer, GLint ptrstride ) { - void (*func_glNormalPointerListIBM)( GLenum, GLint, GLvoid**, GLint ) = extension_funcs[EXT_glNormalPointerListIBM]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %d)\n", type, stride, pointer, ptrstride ); - func_glNormalPointerListIBM( type, stride, pointer, ptrstride ); + funcs->ext.p_glNormalPointerListIBM( type, stride, pointer, ptrstride ); } static void WINAPI wine_glNormalPointervINTEL( GLenum type, GLvoid** pointer ) { - void (*func_glNormalPointervINTEL)( GLenum, GLvoid** ) = extension_funcs[EXT_glNormalPointervINTEL]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", type, pointer ); - func_glNormalPointervINTEL( type, pointer ); + funcs->ext.p_glNormalPointervINTEL( type, pointer ); } static void WINAPI wine_glNormalStream3bATI( GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz ) { - void (*func_glNormalStream3bATI)( GLenum, GLbyte, GLbyte, GLbyte ) = extension_funcs[EXT_glNormalStream3bATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", stream, nx, ny, nz ); - func_glNormalStream3bATI( stream, nx, ny, nz ); + funcs->ext.p_glNormalStream3bATI( stream, nx, ny, nz ); } static void WINAPI wine_glNormalStream3bvATI( GLenum stream, GLbyte* coords ) { - void (*func_glNormalStream3bvATI)( GLenum, GLbyte* ) = extension_funcs[EXT_glNormalStream3bvATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glNormalStream3bvATI( stream, coords ); + funcs->ext.p_glNormalStream3bvATI( stream, coords ); } static void WINAPI wine_glNormalStream3dATI( GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz ) { - void (*func_glNormalStream3dATI)( GLenum, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glNormalStream3dATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", stream, nx, ny, nz ); - func_glNormalStream3dATI( stream, nx, ny, nz ); + funcs->ext.p_glNormalStream3dATI( stream, nx, ny, nz ); } static void WINAPI wine_glNormalStream3dvATI( GLenum stream, GLdouble* coords ) { - void (*func_glNormalStream3dvATI)( GLenum, GLdouble* ) = extension_funcs[EXT_glNormalStream3dvATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glNormalStream3dvATI( stream, coords ); + funcs->ext.p_glNormalStream3dvATI( stream, coords ); } static void WINAPI wine_glNormalStream3fATI( GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz ) { - void (*func_glNormalStream3fATI)( GLenum, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glNormalStream3fATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", stream, nx, ny, nz ); - func_glNormalStream3fATI( stream, nx, ny, nz ); + funcs->ext.p_glNormalStream3fATI( stream, nx, ny, nz ); } static void WINAPI wine_glNormalStream3fvATI( GLenum stream, GLfloat* coords ) { - void (*func_glNormalStream3fvATI)( GLenum, GLfloat* ) = extension_funcs[EXT_glNormalStream3fvATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glNormalStream3fvATI( stream, coords ); + funcs->ext.p_glNormalStream3fvATI( stream, coords ); } static void WINAPI wine_glNormalStream3iATI( GLenum stream, GLint nx, GLint ny, GLint nz ) { - void (*func_glNormalStream3iATI)( GLenum, GLint, GLint, GLint ) = extension_funcs[EXT_glNormalStream3iATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", stream, nx, ny, nz ); - func_glNormalStream3iATI( stream, nx, ny, nz ); + funcs->ext.p_glNormalStream3iATI( stream, nx, ny, nz ); } static void WINAPI wine_glNormalStream3ivATI( GLenum stream, GLint* coords ) { - void (*func_glNormalStream3ivATI)( GLenum, GLint* ) = extension_funcs[EXT_glNormalStream3ivATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glNormalStream3ivATI( stream, coords ); + funcs->ext.p_glNormalStream3ivATI( stream, coords ); } static void WINAPI wine_glNormalStream3sATI( GLenum stream, GLshort nx, GLshort ny, GLshort nz ) { - void (*func_glNormalStream3sATI)( GLenum, GLshort, GLshort, GLshort ) = extension_funcs[EXT_glNormalStream3sATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", stream, nx, ny, nz ); - func_glNormalStream3sATI( stream, nx, ny, nz ); + funcs->ext.p_glNormalStream3sATI( stream, nx, ny, nz ); } static void WINAPI wine_glNormalStream3svATI( GLenum stream, GLshort* coords ) { - void (*func_glNormalStream3svATI)( GLenum, GLshort* ) = extension_funcs[EXT_glNormalStream3svATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glNormalStream3svATI( stream, coords ); + funcs->ext.p_glNormalStream3svATI( stream, coords ); } static GLenum WINAPI wine_glObjectPurgeableAPPLE( GLenum objectType, GLuint name, GLenum option ) { - GLenum (*func_glObjectPurgeableAPPLE)( GLenum, GLuint, GLenum ) = extension_funcs[EXT_glObjectPurgeableAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", objectType, name, option ); - return func_glObjectPurgeableAPPLE( objectType, name, option ); + return funcs->ext.p_glObjectPurgeableAPPLE( objectType, name, option ); } static GLenum WINAPI wine_glObjectUnpurgeableAPPLE( GLenum objectType, GLuint name, GLenum option ) { - GLenum (*func_glObjectUnpurgeableAPPLE)( GLenum, GLuint, GLenum ) = extension_funcs[EXT_glObjectUnpurgeableAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", objectType, name, option ); - return func_glObjectUnpurgeableAPPLE( objectType, name, option ); + return funcs->ext.p_glObjectUnpurgeableAPPLE( objectType, name, option ); } static void WINAPI wine_glPNTrianglesfATI( GLenum pname, GLfloat param ) { - void (*func_glPNTrianglesfATI)( GLenum, GLfloat ) = extension_funcs[EXT_glPNTrianglesfATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", pname, param ); - func_glPNTrianglesfATI( pname, param ); + funcs->ext.p_glPNTrianglesfATI( pname, param ); } static void WINAPI wine_glPNTrianglesiATI( GLenum pname, GLint param ) { - void (*func_glPNTrianglesiATI)( GLenum, GLint ) = extension_funcs[EXT_glPNTrianglesiATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", pname, param ); - func_glPNTrianglesiATI( pname, param ); + funcs->ext.p_glPNTrianglesiATI( pname, param ); } static void WINAPI wine_glPassTexCoordATI( GLuint dst, GLuint coord, GLenum swizzle ) { - void (*func_glPassTexCoordATI)( GLuint, GLuint, GLenum ) = extension_funcs[EXT_glPassTexCoordATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", dst, coord, swizzle ); - func_glPassTexCoordATI( dst, coord, swizzle ); + funcs->ext.p_glPassTexCoordATI( dst, coord, swizzle ); } static void WINAPI wine_glPatchParameterfv( GLenum pname, GLfloat* values ) { - void (*func_glPatchParameterfv)( GLenum, GLfloat* ) = extension_funcs[EXT_glPatchParameterfv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, values ); - func_glPatchParameterfv( pname, values ); + funcs->ext.p_glPatchParameterfv( pname, values ); } static void WINAPI wine_glPatchParameteri( GLenum pname, GLint value ) { - void (*func_glPatchParameteri)( GLenum, GLint ) = extension_funcs[EXT_glPatchParameteri]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", pname, value ); - func_glPatchParameteri( pname, value ); + funcs->ext.p_glPatchParameteri( pname, value ); } static void WINAPI wine_glPathColorGenNV( GLenum color, GLenum genMode, GLenum colorFormat, GLfloat* coeffs ) { - void (*func_glPathColorGenNV)( GLenum, GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glPathColorGenNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", color, genMode, colorFormat, coeffs ); - func_glPathColorGenNV( color, genMode, colorFormat, coeffs ); + funcs->ext.p_glPathColorGenNV( color, genMode, colorFormat, coeffs ); } static void WINAPI wine_glPathCommandsNV( GLuint path, GLsizei numCommands, GLubyte* commands, GLsizei numCoords, GLenum coordType, GLvoid* coords ) { - void (*func_glPathCommandsNV)( GLuint, GLsizei, GLubyte*, GLsizei, GLenum, GLvoid* ) = extension_funcs[EXT_glPathCommandsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %d, %d, %p)\n", path, numCommands, commands, numCoords, coordType, coords ); - func_glPathCommandsNV( path, numCommands, commands, numCoords, coordType, coords ); + funcs->ext.p_glPathCommandsNV( path, numCommands, commands, numCoords, coordType, coords ); } static void WINAPI wine_glPathCoordsNV( GLuint path, GLsizei numCoords, GLenum coordType, GLvoid* coords ) { - void (*func_glPathCoordsNV)( GLuint, GLsizei, GLenum, GLvoid* ) = extension_funcs[EXT_glPathCoordsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", path, numCoords, coordType, coords ); - func_glPathCoordsNV( path, numCoords, coordType, coords ); + funcs->ext.p_glPathCoordsNV( path, numCoords, coordType, coords ); } static void WINAPI wine_glPathCoverDepthFuncNV( GLenum func ) { - void (*func_glPathCoverDepthFuncNV)( GLenum ) = extension_funcs[EXT_glPathCoverDepthFuncNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", func ); - func_glPathCoverDepthFuncNV( func ); + funcs->ext.p_glPathCoverDepthFuncNV( func ); } static void WINAPI wine_glPathDashArrayNV( GLuint path, GLsizei dashCount, GLfloat* dashArray ) { - void (*func_glPathDashArrayNV)( GLuint, GLsizei, GLfloat* ) = extension_funcs[EXT_glPathDashArrayNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", path, dashCount, dashArray ); - func_glPathDashArrayNV( path, dashCount, dashArray ); + funcs->ext.p_glPathDashArrayNV( path, dashCount, dashArray ); } static void WINAPI wine_glPathFogGenNV( GLenum genMode ) { - void (*func_glPathFogGenNV)( GLenum ) = extension_funcs[EXT_glPathFogGenNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", genMode ); - func_glPathFogGenNV( genMode ); + funcs->ext.p_glPathFogGenNV( genMode ); } static void WINAPI wine_glPathGlyphRangeNV( GLuint firstPathName, GLenum fontTarget, GLvoid* fontName, GLbitfield fontStyle, GLuint firstGlyph, GLsizei numGlyphs, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale ) { - void (*func_glPathGlyphRangeNV)( GLuint, GLenum, GLvoid*, GLbitfield, GLuint, GLsizei, GLenum, GLuint, GLfloat ) = extension_funcs[EXT_glPathGlyphRangeNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %d, %d, %d, %d, %d, %f)\n", firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale ); - func_glPathGlyphRangeNV( firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale ); + funcs->ext.p_glPathGlyphRangeNV( firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale ); } static void WINAPI wine_glPathGlyphsNV( GLuint firstPathName, GLenum fontTarget, GLvoid* fontName, GLbitfield fontStyle, GLsizei numGlyphs, GLenum type, GLvoid* charcodes, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale ) { - void (*func_glPathGlyphsNV)( GLuint, GLenum, GLvoid*, GLbitfield, GLsizei, GLenum, GLvoid*, GLenum, GLuint, GLfloat ) = extension_funcs[EXT_glPathGlyphsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %d, %d, %d, %p, %d, %d, %f)\n", firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale ); - func_glPathGlyphsNV( firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale ); + funcs->ext.p_glPathGlyphsNV( firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale ); } static void WINAPI wine_glPathParameterfNV( GLuint path, GLenum pname, GLfloat value ) { - void (*func_glPathParameterfNV)( GLuint, GLenum, GLfloat ) = extension_funcs[EXT_glPathParameterfNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f)\n", path, pname, value ); - func_glPathParameterfNV( path, pname, value ); + funcs->ext.p_glPathParameterfNV( path, pname, value ); } static void WINAPI wine_glPathParameterfvNV( GLuint path, GLenum pname, GLfloat* value ) { - void (*func_glPathParameterfvNV)( GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glPathParameterfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", path, pname, value ); - func_glPathParameterfvNV( path, pname, value ); + funcs->ext.p_glPathParameterfvNV( path, pname, value ); } static void WINAPI wine_glPathParameteriNV( GLuint path, GLenum pname, GLint value ) { - void (*func_glPathParameteriNV)( GLuint, GLenum, GLint ) = extension_funcs[EXT_glPathParameteriNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", path, pname, value ); - func_glPathParameteriNV( path, pname, value ); + funcs->ext.p_glPathParameteriNV( path, pname, value ); } static void WINAPI wine_glPathParameterivNV( GLuint path, GLenum pname, GLint* value ) { - void (*func_glPathParameterivNV)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glPathParameterivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", path, pname, value ); - func_glPathParameterivNV( path, pname, value ); + funcs->ext.p_glPathParameterivNV( path, pname, value ); } static void WINAPI wine_glPathStencilDepthOffsetNV( GLfloat factor, GLfloat units ) { - void (*func_glPathStencilDepthOffsetNV)( GLfloat, GLfloat ) = extension_funcs[EXT_glPathStencilDepthOffsetNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f)\n", factor, units ); - func_glPathStencilDepthOffsetNV( factor, units ); + funcs->ext.p_glPathStencilDepthOffsetNV( factor, units ); } static void WINAPI wine_glPathStencilFuncNV( GLenum func, GLint ref, GLuint mask ) { - void (*func_glPathStencilFuncNV)( GLenum, GLint, GLuint ) = extension_funcs[EXT_glPathStencilFuncNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", func, ref, mask ); - func_glPathStencilFuncNV( func, ref, mask ); + funcs->ext.p_glPathStencilFuncNV( func, ref, mask ); } static void WINAPI wine_glPathStringNV( GLuint path, GLenum format, GLsizei length, GLvoid* pathString ) { - void (*func_glPathStringNV)( GLuint, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glPathStringNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", path, format, length, pathString ); - func_glPathStringNV( path, format, length, pathString ); + funcs->ext.p_glPathStringNV( path, format, length, pathString ); } static void WINAPI wine_glPathSubCommandsNV( GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, GLubyte* commands, GLsizei numCoords, GLenum coordType, GLvoid* coords ) { - void (*func_glPathSubCommandsNV)( GLuint, GLsizei, GLsizei, GLsizei, GLubyte*, GLsizei, GLenum, GLvoid* ) = extension_funcs[EXT_glPathSubCommandsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p, %d, %d, %p)\n", path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords ); - func_glPathSubCommandsNV( path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords ); + funcs->ext.p_glPathSubCommandsNV( path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords ); } static void WINAPI wine_glPathSubCoordsNV( GLuint path, GLsizei coordStart, GLsizei numCoords, GLenum coordType, GLvoid* coords ) { - void (*func_glPathSubCoordsNV)( GLuint, GLsizei, GLsizei, GLenum, GLvoid* ) = extension_funcs[EXT_glPathSubCoordsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", path, coordStart, numCoords, coordType, coords ); - func_glPathSubCoordsNV( path, coordStart, numCoords, coordType, coords ); + funcs->ext.p_glPathSubCoordsNV( path, coordStart, numCoords, coordType, coords ); } static void WINAPI wine_glPathTexGenNV( GLenum texCoordSet, GLenum genMode, GLint components, GLfloat* coeffs ) { - void (*func_glPathTexGenNV)( GLenum, GLenum, GLint, GLfloat* ) = extension_funcs[EXT_glPathTexGenNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texCoordSet, genMode, components, coeffs ); - func_glPathTexGenNV( texCoordSet, genMode, components, coeffs ); + funcs->ext.p_glPathTexGenNV( texCoordSet, genMode, components, coeffs ); } static void WINAPI wine_glPauseTransformFeedback( void ) { - void (*func_glPauseTransformFeedback)( void ) = extension_funcs[EXT_glPauseTransformFeedback]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glPauseTransformFeedback( ); + funcs->ext.p_glPauseTransformFeedback( ); } static void WINAPI wine_glPauseTransformFeedbackNV( void ) { - void (*func_glPauseTransformFeedbackNV)( void ) = extension_funcs[EXT_glPauseTransformFeedbackNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glPauseTransformFeedbackNV( ); + funcs->ext.p_glPauseTransformFeedbackNV( ); } static void WINAPI wine_glPixelDataRangeNV( GLenum target, GLsizei length, GLvoid* pointer ) { - void (*func_glPixelDataRangeNV)( GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glPixelDataRangeNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, length, pointer ); - func_glPixelDataRangeNV( target, length, pointer ); + funcs->ext.p_glPixelDataRangeNV( target, length, pointer ); } static void WINAPI wine_glPixelTexGenParameterfSGIS( GLenum pname, GLfloat param ) { - void (*func_glPixelTexGenParameterfSGIS)( GLenum, GLfloat ) = extension_funcs[EXT_glPixelTexGenParameterfSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", pname, param ); - func_glPixelTexGenParameterfSGIS( pname, param ); + funcs->ext.p_glPixelTexGenParameterfSGIS( pname, param ); } static void WINAPI wine_glPixelTexGenParameterfvSGIS( GLenum pname, GLfloat* params ) { - void (*func_glPixelTexGenParameterfvSGIS)( GLenum, GLfloat* ) = extension_funcs[EXT_glPixelTexGenParameterfvSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glPixelTexGenParameterfvSGIS( pname, params ); + funcs->ext.p_glPixelTexGenParameterfvSGIS( pname, params ); } static void WINAPI wine_glPixelTexGenParameteriSGIS( GLenum pname, GLint param ) { - void (*func_glPixelTexGenParameteriSGIS)( GLenum, GLint ) = extension_funcs[EXT_glPixelTexGenParameteriSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", pname, param ); - func_glPixelTexGenParameteriSGIS( pname, param ); + funcs->ext.p_glPixelTexGenParameteriSGIS( pname, param ); } static void WINAPI wine_glPixelTexGenParameterivSGIS( GLenum pname, GLint* params ) { - void (*func_glPixelTexGenParameterivSGIS)( GLenum, GLint* ) = extension_funcs[EXT_glPixelTexGenParameterivSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glPixelTexGenParameterivSGIS( pname, params ); + funcs->ext.p_glPixelTexGenParameterivSGIS( pname, params ); } static void WINAPI wine_glPixelTexGenSGIX( GLenum mode ) { - void (*func_glPixelTexGenSGIX)( GLenum ) = extension_funcs[EXT_glPixelTexGenSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", mode ); - func_glPixelTexGenSGIX( mode ); + funcs->ext.p_glPixelTexGenSGIX( mode ); } static void WINAPI wine_glPixelTransformParameterfEXT( GLenum target, GLenum pname, GLfloat param ) { - void (*func_glPixelTransformParameterfEXT)( GLenum, GLenum, GLfloat ) = extension_funcs[EXT_glPixelTransformParameterfEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f)\n", target, pname, param ); - func_glPixelTransformParameterfEXT( target, pname, param ); + funcs->ext.p_glPixelTransformParameterfEXT( target, pname, param ); } static void WINAPI wine_glPixelTransformParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glPixelTransformParameterfvEXT)( GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glPixelTransformParameterfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glPixelTransformParameterfvEXT( target, pname, params ); + funcs->ext.p_glPixelTransformParameterfvEXT( target, pname, params ); } static void WINAPI wine_glPixelTransformParameteriEXT( GLenum target, GLenum pname, GLint param ) { - void (*func_glPixelTransformParameteriEXT)( GLenum, GLenum, GLint ) = extension_funcs[EXT_glPixelTransformParameteriEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, pname, param ); - func_glPixelTransformParameteriEXT( target, pname, param ); + funcs->ext.p_glPixelTransformParameteriEXT( target, pname, param ); } static void WINAPI wine_glPixelTransformParameterivEXT( GLenum target, GLenum pname, GLint* params ) { - void (*func_glPixelTransformParameterivEXT)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glPixelTransformParameterivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glPixelTransformParameterivEXT( target, pname, params ); + funcs->ext.p_glPixelTransformParameterivEXT( target, pname, params ); } static GLboolean WINAPI wine_glPointAlongPathNV( GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat* x, GLfloat* y, GLfloat* tangentX, GLfloat* tangentY ) { - GLboolean (*func_glPointAlongPathNV)( GLuint, GLsizei, GLsizei, GLfloat, GLfloat*, GLfloat*, GLfloat*, GLfloat* ) = extension_funcs[EXT_glPointAlongPathNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %f, %p, %p, %p, %p)\n", path, startSegment, numSegments, distance, x, y, tangentX, tangentY ); - return func_glPointAlongPathNV( path, startSegment, numSegments, distance, x, y, tangentX, tangentY ); + return funcs->ext.p_glPointAlongPathNV( path, startSegment, numSegments, distance, x, y, tangentX, tangentY ); } static void WINAPI wine_glPointParameterf( GLenum pname, GLfloat param ) { - void (*func_glPointParameterf)( GLenum, GLfloat ) = extension_funcs[EXT_glPointParameterf]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", pname, param ); - func_glPointParameterf( pname, param ); + funcs->ext.p_glPointParameterf( pname, param ); } static void WINAPI wine_glPointParameterfARB( GLenum pname, GLfloat param ) { - void (*func_glPointParameterfARB)( GLenum, GLfloat ) = extension_funcs[EXT_glPointParameterfARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", pname, param ); - func_glPointParameterfARB( pname, param ); + funcs->ext.p_glPointParameterfARB( pname, param ); } static void WINAPI wine_glPointParameterfEXT( GLenum pname, GLfloat param ) { - void (*func_glPointParameterfEXT)( GLenum, GLfloat ) = extension_funcs[EXT_glPointParameterfEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", pname, param ); - func_glPointParameterfEXT( pname, param ); + funcs->ext.p_glPointParameterfEXT( pname, param ); } static void WINAPI wine_glPointParameterfSGIS( GLenum pname, GLfloat param ) { - void (*func_glPointParameterfSGIS)( GLenum, GLfloat ) = extension_funcs[EXT_glPointParameterfSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", pname, param ); - func_glPointParameterfSGIS( pname, param ); + funcs->ext.p_glPointParameterfSGIS( pname, param ); } static void WINAPI wine_glPointParameterfv( GLenum pname, GLfloat* params ) { - void (*func_glPointParameterfv)( GLenum, GLfloat* ) = extension_funcs[EXT_glPointParameterfv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glPointParameterfv( pname, params ); + funcs->ext.p_glPointParameterfv( pname, params ); } static void WINAPI wine_glPointParameterfvARB( GLenum pname, GLfloat* params ) { - void (*func_glPointParameterfvARB)( GLenum, GLfloat* ) = extension_funcs[EXT_glPointParameterfvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glPointParameterfvARB( pname, params ); + funcs->ext.p_glPointParameterfvARB( pname, params ); } static void WINAPI wine_glPointParameterfvEXT( GLenum pname, GLfloat* params ) { - void (*func_glPointParameterfvEXT)( GLenum, GLfloat* ) = extension_funcs[EXT_glPointParameterfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glPointParameterfvEXT( pname, params ); + funcs->ext.p_glPointParameterfvEXT( pname, params ); } static void WINAPI wine_glPointParameterfvSGIS( GLenum pname, GLfloat* params ) { - void (*func_glPointParameterfvSGIS)( GLenum, GLfloat* ) = extension_funcs[EXT_glPointParameterfvSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glPointParameterfvSGIS( pname, params ); + funcs->ext.p_glPointParameterfvSGIS( pname, params ); } static void WINAPI wine_glPointParameteri( GLenum pname, GLint param ) { - void (*func_glPointParameteri)( GLenum, GLint ) = extension_funcs[EXT_glPointParameteri]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", pname, param ); - func_glPointParameteri( pname, param ); + funcs->ext.p_glPointParameteri( pname, param ); } static void WINAPI wine_glPointParameteriNV( GLenum pname, GLint param ) { - void (*func_glPointParameteriNV)( GLenum, GLint ) = extension_funcs[EXT_glPointParameteriNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", pname, param ); - func_glPointParameteriNV( pname, param ); + funcs->ext.p_glPointParameteriNV( pname, param ); } static void WINAPI wine_glPointParameteriv( GLenum pname, GLint* params ) { - void (*func_glPointParameteriv)( GLenum, GLint* ) = extension_funcs[EXT_glPointParameteriv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glPointParameteriv( pname, params ); + funcs->ext.p_glPointParameteriv( pname, params ); } static void WINAPI wine_glPointParameterivNV( GLenum pname, GLint* params ) { - void (*func_glPointParameterivNV)( GLenum, GLint* ) = extension_funcs[EXT_glPointParameterivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glPointParameterivNV( pname, params ); + funcs->ext.p_glPointParameterivNV( pname, params ); } static GLint WINAPI wine_glPollAsyncSGIX( GLuint* markerp ) { - GLint (*func_glPollAsyncSGIX)( GLuint* ) = extension_funcs[EXT_glPollAsyncSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", markerp ); - return func_glPollAsyncSGIX( markerp ); + return funcs->ext.p_glPollAsyncSGIX( markerp ); } static GLint WINAPI wine_glPollInstrumentsSGIX( GLint* marker_p ) { - GLint (*func_glPollInstrumentsSGIX)( GLint* ) = extension_funcs[EXT_glPollInstrumentsSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", marker_p ); - return func_glPollInstrumentsSGIX( marker_p ); + return funcs->ext.p_glPollInstrumentsSGIX( marker_p ); } static void WINAPI wine_glPolygonOffsetEXT( GLfloat factor, GLfloat bias ) { - void (*func_glPolygonOffsetEXT)( GLfloat, GLfloat ) = extension_funcs[EXT_glPolygonOffsetEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f)\n", factor, bias ); - func_glPolygonOffsetEXT( factor, bias ); + funcs->ext.p_glPolygonOffsetEXT( factor, bias ); } static void WINAPI wine_glPresentFrameDualFillNV( GLuint video_slot, UINT64 minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLenum target1, GLuint fill1, GLenum target2, GLuint fill2, GLenum target3, GLuint fill3 ) { - void (*func_glPresentFrameDualFillNV)( GLuint, UINT64, GLuint, GLuint, GLenum, GLenum, GLuint, GLenum, GLuint, GLenum, GLuint, GLenum, GLuint ) = extension_funcs[EXT_glPresentFrameDualFillNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", video_slot, wine_dbgstr_longlong(minPresentTime), beginPresentTimeId, presentDurationId, type, target0, fill0, target1, fill1, target2, fill2, target3, fill3 ); - func_glPresentFrameDualFillNV( video_slot, minPresentTime, beginPresentTimeId, presentDurationId, type, target0, fill0, target1, fill1, target2, fill2, target3, fill3 ); + funcs->ext.p_glPresentFrameDualFillNV( video_slot, minPresentTime, beginPresentTimeId, presentDurationId, type, target0, fill0, target1, fill1, target2, fill2, target3, fill3 ); } static void WINAPI wine_glPresentFrameKeyedNV( GLuint video_slot, UINT64 minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLuint key0, GLenum target1, GLuint fill1, GLuint key1 ) { - void (*func_glPresentFrameKeyedNV)( GLuint, UINT64, GLuint, GLuint, GLenum, GLenum, GLuint, GLuint, GLenum, GLuint, GLuint ) = extension_funcs[EXT_glPresentFrameKeyedNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", video_slot, wine_dbgstr_longlong(minPresentTime), beginPresentTimeId, presentDurationId, type, target0, fill0, key0, target1, fill1, key1 ); - func_glPresentFrameKeyedNV( video_slot, minPresentTime, beginPresentTimeId, presentDurationId, type, target0, fill0, key0, target1, fill1, key1 ); + funcs->ext.p_glPresentFrameKeyedNV( video_slot, minPresentTime, beginPresentTimeId, presentDurationId, type, target0, fill0, key0, target1, fill1, key1 ); } static void WINAPI wine_glPrimitiveRestartIndex( GLuint index ) { - void (*func_glPrimitiveRestartIndex)( GLuint ) = extension_funcs[EXT_glPrimitiveRestartIndex]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", index ); - func_glPrimitiveRestartIndex( index ); + funcs->ext.p_glPrimitiveRestartIndex( index ); } static void WINAPI wine_glPrimitiveRestartIndexNV( GLuint index ) { - void (*func_glPrimitiveRestartIndexNV)( GLuint ) = extension_funcs[EXT_glPrimitiveRestartIndexNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", index ); - func_glPrimitiveRestartIndexNV( index ); + funcs->ext.p_glPrimitiveRestartIndexNV( index ); } static void WINAPI wine_glPrimitiveRestartNV( void ) { - void (*func_glPrimitiveRestartNV)( void ) = extension_funcs[EXT_glPrimitiveRestartNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glPrimitiveRestartNV( ); + funcs->ext.p_glPrimitiveRestartNV( ); } static void WINAPI wine_glPrioritizeTexturesEXT( GLsizei n, GLuint* textures, GLclampf* priorities ) { - void (*func_glPrioritizeTexturesEXT)( GLsizei, GLuint*, GLclampf* ) = extension_funcs[EXT_glPrioritizeTexturesEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %p)\n", n, textures, priorities ); - func_glPrioritizeTexturesEXT( n, textures, priorities ); + funcs->ext.p_glPrioritizeTexturesEXT( n, textures, priorities ); } static void WINAPI wine_glProgramBinary( GLuint program, GLenum binaryFormat, GLvoid* binary, GLsizei length ) { - void (*func_glProgramBinary)( GLuint, GLenum, GLvoid*, GLsizei ) = extension_funcs[EXT_glProgramBinary]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %d)\n", program, binaryFormat, binary, length ); - func_glProgramBinary( program, binaryFormat, binary, length ); + funcs->ext.p_glProgramBinary( program, binaryFormat, binary, length ); } static void WINAPI wine_glProgramBufferParametersIivNV( GLenum target, GLuint buffer, GLuint index, GLsizei count, GLint* params ) { - void (*func_glProgramBufferParametersIivNV)( GLenum, GLuint, GLuint, GLsizei, GLint* ) = extension_funcs[EXT_glProgramBufferParametersIivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", target, buffer, index, count, params ); - func_glProgramBufferParametersIivNV( target, buffer, index, count, params ); + funcs->ext.p_glProgramBufferParametersIivNV( target, buffer, index, count, params ); } static void WINAPI wine_glProgramBufferParametersIuivNV( GLenum target, GLuint buffer, GLuint index, GLsizei count, GLuint* params ) { - void (*func_glProgramBufferParametersIuivNV)( GLenum, GLuint, GLuint, GLsizei, GLuint* ) = extension_funcs[EXT_glProgramBufferParametersIuivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", target, buffer, index, count, params ); - func_glProgramBufferParametersIuivNV( target, buffer, index, count, params ); + funcs->ext.p_glProgramBufferParametersIuivNV( target, buffer, index, count, params ); } static void WINAPI wine_glProgramBufferParametersfvNV( GLenum target, GLuint buffer, GLuint index, GLsizei count, GLfloat* params ) { - void (*func_glProgramBufferParametersfvNV)( GLenum, GLuint, GLuint, GLsizei, GLfloat* ) = extension_funcs[EXT_glProgramBufferParametersfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", target, buffer, index, count, params ); - func_glProgramBufferParametersfvNV( target, buffer, index, count, params ); + funcs->ext.p_glProgramBufferParametersfvNV( target, buffer, index, count, params ); } static void WINAPI wine_glProgramEnvParameter4dARB( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { - void (*func_glProgramEnvParameter4dARB)( GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glProgramEnvParameter4dARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f, %f, %f)\n", target, index, x, y, z, w ); - func_glProgramEnvParameter4dARB( target, index, x, y, z, w ); + funcs->ext.p_glProgramEnvParameter4dARB( target, index, x, y, z, w ); } static void WINAPI wine_glProgramEnvParameter4dvARB( GLenum target, GLuint index, GLdouble* params ) { - void (*func_glProgramEnvParameter4dvARB)( GLenum, GLuint, GLdouble* ) = extension_funcs[EXT_glProgramEnvParameter4dvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, params ); - func_glProgramEnvParameter4dvARB( target, index, params ); + funcs->ext.p_glProgramEnvParameter4dvARB( target, index, params ); } static void WINAPI wine_glProgramEnvParameter4fARB( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { - void (*func_glProgramEnvParameter4fARB)( GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glProgramEnvParameter4fARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f, %f, %f)\n", target, index, x, y, z, w ); - func_glProgramEnvParameter4fARB( target, index, x, y, z, w ); + funcs->ext.p_glProgramEnvParameter4fARB( target, index, x, y, z, w ); } static void WINAPI wine_glProgramEnvParameter4fvARB( GLenum target, GLuint index, GLfloat* params ) { - void (*func_glProgramEnvParameter4fvARB)( GLenum, GLuint, GLfloat* ) = extension_funcs[EXT_glProgramEnvParameter4fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, params ); - func_glProgramEnvParameter4fvARB( target, index, params ); + funcs->ext.p_glProgramEnvParameter4fvARB( target, index, params ); } static void WINAPI wine_glProgramEnvParameterI4iNV( GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w ) { - void (*func_glProgramEnvParameterI4iNV)( GLenum, GLuint, GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glProgramEnvParameterI4iNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", target, index, x, y, z, w ); - func_glProgramEnvParameterI4iNV( target, index, x, y, z, w ); + funcs->ext.p_glProgramEnvParameterI4iNV( target, index, x, y, z, w ); } static void WINAPI wine_glProgramEnvParameterI4ivNV( GLenum target, GLuint index, GLint* params ) { - void (*func_glProgramEnvParameterI4ivNV)( GLenum, GLuint, GLint* ) = extension_funcs[EXT_glProgramEnvParameterI4ivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, params ); - func_glProgramEnvParameterI4ivNV( target, index, params ); + funcs->ext.p_glProgramEnvParameterI4ivNV( target, index, params ); } static void WINAPI wine_glProgramEnvParameterI4uiNV( GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w ) { - void (*func_glProgramEnvParameterI4uiNV)( GLenum, GLuint, GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glProgramEnvParameterI4uiNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", target, index, x, y, z, w ); - func_glProgramEnvParameterI4uiNV( target, index, x, y, z, w ); + funcs->ext.p_glProgramEnvParameterI4uiNV( target, index, x, y, z, w ); } static void WINAPI wine_glProgramEnvParameterI4uivNV( GLenum target, GLuint index, GLuint* params ) { - void (*func_glProgramEnvParameterI4uivNV)( GLenum, GLuint, GLuint* ) = extension_funcs[EXT_glProgramEnvParameterI4uivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, params ); - func_glProgramEnvParameterI4uivNV( target, index, params ); + funcs->ext.p_glProgramEnvParameterI4uivNV( target, index, params ); } static void WINAPI wine_glProgramEnvParameters4fvEXT( GLenum target, GLuint index, GLsizei count, GLfloat* params ) { - void (*func_glProgramEnvParameters4fvEXT)( GLenum, GLuint, GLsizei, GLfloat* ) = extension_funcs[EXT_glProgramEnvParameters4fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, index, count, params ); - func_glProgramEnvParameters4fvEXT( target, index, count, params ); + funcs->ext.p_glProgramEnvParameters4fvEXT( target, index, count, params ); } static void WINAPI wine_glProgramEnvParametersI4ivNV( GLenum target, GLuint index, GLsizei count, GLint* params ) { - void (*func_glProgramEnvParametersI4ivNV)( GLenum, GLuint, GLsizei, GLint* ) = extension_funcs[EXT_glProgramEnvParametersI4ivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, index, count, params ); - func_glProgramEnvParametersI4ivNV( target, index, count, params ); + funcs->ext.p_glProgramEnvParametersI4ivNV( target, index, count, params ); } static void WINAPI wine_glProgramEnvParametersI4uivNV( GLenum target, GLuint index, GLsizei count, GLuint* params ) { - void (*func_glProgramEnvParametersI4uivNV)( GLenum, GLuint, GLsizei, GLuint* ) = extension_funcs[EXT_glProgramEnvParametersI4uivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, index, count, params ); - func_glProgramEnvParametersI4uivNV( target, index, count, params ); + funcs->ext.p_glProgramEnvParametersI4uivNV( target, index, count, params ); } static void WINAPI wine_glProgramLocalParameter4dARB( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { - void (*func_glProgramLocalParameter4dARB)( GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glProgramLocalParameter4dARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f, %f, %f)\n", target, index, x, y, z, w ); - func_glProgramLocalParameter4dARB( target, index, x, y, z, w ); + funcs->ext.p_glProgramLocalParameter4dARB( target, index, x, y, z, w ); } static void WINAPI wine_glProgramLocalParameter4dvARB( GLenum target, GLuint index, GLdouble* params ) { - void (*func_glProgramLocalParameter4dvARB)( GLenum, GLuint, GLdouble* ) = extension_funcs[EXT_glProgramLocalParameter4dvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, params ); - func_glProgramLocalParameter4dvARB( target, index, params ); + funcs->ext.p_glProgramLocalParameter4dvARB( target, index, params ); } static void WINAPI wine_glProgramLocalParameter4fARB( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { - void (*func_glProgramLocalParameter4fARB)( GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glProgramLocalParameter4fARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f, %f, %f)\n", target, index, x, y, z, w ); - func_glProgramLocalParameter4fARB( target, index, x, y, z, w ); + funcs->ext.p_glProgramLocalParameter4fARB( target, index, x, y, z, w ); } static void WINAPI wine_glProgramLocalParameter4fvARB( GLenum target, GLuint index, GLfloat* params ) { - void (*func_glProgramLocalParameter4fvARB)( GLenum, GLuint, GLfloat* ) = extension_funcs[EXT_glProgramLocalParameter4fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, params ); - func_glProgramLocalParameter4fvARB( target, index, params ); + funcs->ext.p_glProgramLocalParameter4fvARB( target, index, params ); } static void WINAPI wine_glProgramLocalParameterI4iNV( GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w ) { - void (*func_glProgramLocalParameterI4iNV)( GLenum, GLuint, GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glProgramLocalParameterI4iNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", target, index, x, y, z, w ); - func_glProgramLocalParameterI4iNV( target, index, x, y, z, w ); + funcs->ext.p_glProgramLocalParameterI4iNV( target, index, x, y, z, w ); } static void WINAPI wine_glProgramLocalParameterI4ivNV( GLenum target, GLuint index, GLint* params ) { - void (*func_glProgramLocalParameterI4ivNV)( GLenum, GLuint, GLint* ) = extension_funcs[EXT_glProgramLocalParameterI4ivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, params ); - func_glProgramLocalParameterI4ivNV( target, index, params ); + funcs->ext.p_glProgramLocalParameterI4ivNV( target, index, params ); } static void WINAPI wine_glProgramLocalParameterI4uiNV( GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w ) { - void (*func_glProgramLocalParameterI4uiNV)( GLenum, GLuint, GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glProgramLocalParameterI4uiNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", target, index, x, y, z, w ); - func_glProgramLocalParameterI4uiNV( target, index, x, y, z, w ); + funcs->ext.p_glProgramLocalParameterI4uiNV( target, index, x, y, z, w ); } static void WINAPI wine_glProgramLocalParameterI4uivNV( GLenum target, GLuint index, GLuint* params ) { - void (*func_glProgramLocalParameterI4uivNV)( GLenum, GLuint, GLuint* ) = extension_funcs[EXT_glProgramLocalParameterI4uivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, params ); - func_glProgramLocalParameterI4uivNV( target, index, params ); + funcs->ext.p_glProgramLocalParameterI4uivNV( target, index, params ); } static void WINAPI wine_glProgramLocalParameters4fvEXT( GLenum target, GLuint index, GLsizei count, GLfloat* params ) { - void (*func_glProgramLocalParameters4fvEXT)( GLenum, GLuint, GLsizei, GLfloat* ) = extension_funcs[EXT_glProgramLocalParameters4fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, index, count, params ); - func_glProgramLocalParameters4fvEXT( target, index, count, params ); + funcs->ext.p_glProgramLocalParameters4fvEXT( target, index, count, params ); } static void WINAPI wine_glProgramLocalParametersI4ivNV( GLenum target, GLuint index, GLsizei count, GLint* params ) { - void (*func_glProgramLocalParametersI4ivNV)( GLenum, GLuint, GLsizei, GLint* ) = extension_funcs[EXT_glProgramLocalParametersI4ivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, index, count, params ); - func_glProgramLocalParametersI4ivNV( target, index, count, params ); + funcs->ext.p_glProgramLocalParametersI4ivNV( target, index, count, params ); } static void WINAPI wine_glProgramLocalParametersI4uivNV( GLenum target, GLuint index, GLsizei count, GLuint* params ) { - void (*func_glProgramLocalParametersI4uivNV)( GLenum, GLuint, GLsizei, GLuint* ) = extension_funcs[EXT_glProgramLocalParametersI4uivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, index, count, params ); - func_glProgramLocalParametersI4uivNV( target, index, count, params ); + funcs->ext.p_glProgramLocalParametersI4uivNV( target, index, count, params ); } static void WINAPI wine_glProgramNamedParameter4dNV( GLuint id, GLsizei len, GLubyte* name, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { - void (*func_glProgramNamedParameter4dNV)( GLuint, GLsizei, GLubyte*, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glProgramNamedParameter4dNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %f, %f, %f, %f)\n", id, len, name, x, y, z, w ); - func_glProgramNamedParameter4dNV( id, len, name, x, y, z, w ); + funcs->ext.p_glProgramNamedParameter4dNV( id, len, name, x, y, z, w ); } static void WINAPI wine_glProgramNamedParameter4dvNV( GLuint id, GLsizei len, GLubyte* name, GLdouble* v ) { - void (*func_glProgramNamedParameter4dvNV)( GLuint, GLsizei, GLubyte*, GLdouble* ) = extension_funcs[EXT_glProgramNamedParameter4dvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", id, len, name, v ); - func_glProgramNamedParameter4dvNV( id, len, name, v ); + funcs->ext.p_glProgramNamedParameter4dvNV( id, len, name, v ); } static void WINAPI wine_glProgramNamedParameter4fNV( GLuint id, GLsizei len, GLubyte* name, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { - void (*func_glProgramNamedParameter4fNV)( GLuint, GLsizei, GLubyte*, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glProgramNamedParameter4fNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %f, %f, %f, %f)\n", id, len, name, x, y, z, w ); - func_glProgramNamedParameter4fNV( id, len, name, x, y, z, w ); + funcs->ext.p_glProgramNamedParameter4fNV( id, len, name, x, y, z, w ); } static void WINAPI wine_glProgramNamedParameter4fvNV( GLuint id, GLsizei len, GLubyte* name, GLfloat* v ) { - void (*func_glProgramNamedParameter4fvNV)( GLuint, GLsizei, GLubyte*, GLfloat* ) = extension_funcs[EXT_glProgramNamedParameter4fvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", id, len, name, v ); - func_glProgramNamedParameter4fvNV( id, len, name, v ); + funcs->ext.p_glProgramNamedParameter4fvNV( id, len, name, v ); } static void WINAPI wine_glProgramParameter4dNV( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { - void (*func_glProgramParameter4dNV)( GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glProgramParameter4dNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f, %f, %f)\n", target, index, x, y, z, w ); - func_glProgramParameter4dNV( target, index, x, y, z, w ); + funcs->ext.p_glProgramParameter4dNV( target, index, x, y, z, w ); } static void WINAPI wine_glProgramParameter4dvNV( GLenum target, GLuint index, GLdouble* v ) { - void (*func_glProgramParameter4dvNV)( GLenum, GLuint, GLdouble* ) = extension_funcs[EXT_glProgramParameter4dvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, v ); - func_glProgramParameter4dvNV( target, index, v ); + funcs->ext.p_glProgramParameter4dvNV( target, index, v ); } static void WINAPI wine_glProgramParameter4fNV( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { - void (*func_glProgramParameter4fNV)( GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glProgramParameter4fNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f, %f, %f)\n", target, index, x, y, z, w ); - func_glProgramParameter4fNV( target, index, x, y, z, w ); + funcs->ext.p_glProgramParameter4fNV( target, index, x, y, z, w ); } static void WINAPI wine_glProgramParameter4fvNV( GLenum target, GLuint index, GLfloat* v ) { - void (*func_glProgramParameter4fvNV)( GLenum, GLuint, GLfloat* ) = extension_funcs[EXT_glProgramParameter4fvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, index, v ); - func_glProgramParameter4fvNV( target, index, v ); + funcs->ext.p_glProgramParameter4fvNV( target, index, v ); } static void WINAPI wine_glProgramParameteri( GLuint program, GLenum pname, GLint value ) { - void (*func_glProgramParameteri)( GLuint, GLenum, GLint ) = extension_funcs[EXT_glProgramParameteri]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", program, pname, value ); - func_glProgramParameteri( program, pname, value ); + funcs->ext.p_glProgramParameteri( program, pname, value ); } static void WINAPI wine_glProgramParameteriARB( GLuint program, GLenum pname, GLint value ) { - void (*func_glProgramParameteriARB)( GLuint, GLenum, GLint ) = extension_funcs[EXT_glProgramParameteriARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", program, pname, value ); - func_glProgramParameteriARB( program, pname, value ); + funcs->ext.p_glProgramParameteriARB( program, pname, value ); } static void WINAPI wine_glProgramParameteriEXT( GLuint program, GLenum pname, GLint value ) { - void (*func_glProgramParameteriEXT)( GLuint, GLenum, GLint ) = extension_funcs[EXT_glProgramParameteriEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", program, pname, value ); - func_glProgramParameteriEXT( program, pname, value ); + funcs->ext.p_glProgramParameteriEXT( program, pname, value ); } static void WINAPI wine_glProgramParameters4dvNV( GLenum target, GLuint index, GLsizei count, GLdouble* v ) { - void (*func_glProgramParameters4dvNV)( GLenum, GLuint, GLsizei, GLdouble* ) = extension_funcs[EXT_glProgramParameters4dvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, index, count, v ); - func_glProgramParameters4dvNV( target, index, count, v ); + funcs->ext.p_glProgramParameters4dvNV( target, index, count, v ); } static void WINAPI wine_glProgramParameters4fvNV( GLenum target, GLuint index, GLsizei count, GLfloat* v ) { - void (*func_glProgramParameters4fvNV)( GLenum, GLuint, GLsizei, GLfloat* ) = extension_funcs[EXT_glProgramParameters4fvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, index, count, v ); - func_glProgramParameters4fvNV( target, index, count, v ); + funcs->ext.p_glProgramParameters4fvNV( target, index, count, v ); } static void WINAPI wine_glProgramStringARB( GLenum target, GLenum format, GLsizei len, GLvoid* string ) { - void (*func_glProgramStringARB)( GLenum, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glProgramStringARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, format, len, string ); - func_glProgramStringARB( target, format, len, string ); + funcs->ext.p_glProgramStringARB( target, format, len, string ); } static void WINAPI wine_glProgramSubroutineParametersuivNV( GLenum target, GLsizei count, GLuint* params ) { - void (*func_glProgramSubroutineParametersuivNV)( GLenum, GLsizei, GLuint* ) = extension_funcs[EXT_glProgramSubroutineParametersuivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, count, params ); - func_glProgramSubroutineParametersuivNV( target, count, params ); + funcs->ext.p_glProgramSubroutineParametersuivNV( target, count, params ); } static void WINAPI wine_glProgramUniform1d( GLuint program, GLint location, GLdouble v0 ) { - void (*func_glProgramUniform1d)( GLuint, GLint, GLdouble ) = extension_funcs[EXT_glProgramUniform1d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f)\n", program, location, v0 ); - func_glProgramUniform1d( program, location, v0 ); + funcs->ext.p_glProgramUniform1d( program, location, v0 ); } static void WINAPI wine_glProgramUniform1dEXT( GLuint program, GLint location, GLdouble x ) { - void (*func_glProgramUniform1dEXT)( GLuint, GLint, GLdouble ) = extension_funcs[EXT_glProgramUniform1dEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f)\n", program, location, x ); - func_glProgramUniform1dEXT( program, location, x ); + funcs->ext.p_glProgramUniform1dEXT( program, location, x ); } static void WINAPI wine_glProgramUniform1dv( GLuint program, GLint location, GLsizei count, GLdouble* value ) { - void (*func_glProgramUniform1dv)( GLuint, GLint, GLsizei, GLdouble* ) = extension_funcs[EXT_glProgramUniform1dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform1dv( program, location, count, value ); + funcs->ext.p_glProgramUniform1dv( program, location, count, value ); } static void WINAPI wine_glProgramUniform1dvEXT( GLuint program, GLint location, GLsizei count, GLdouble* value ) { - void (*func_glProgramUniform1dvEXT)( GLuint, GLint, GLsizei, GLdouble* ) = extension_funcs[EXT_glProgramUniform1dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform1dvEXT( program, location, count, value ); + funcs->ext.p_glProgramUniform1dvEXT( program, location, count, value ); } static void WINAPI wine_glProgramUniform1f( GLuint program, GLint location, GLfloat v0 ) { - void (*func_glProgramUniform1f)( GLuint, GLint, GLfloat ) = extension_funcs[EXT_glProgramUniform1f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f)\n", program, location, v0 ); - func_glProgramUniform1f( program, location, v0 ); + funcs->ext.p_glProgramUniform1f( program, location, v0 ); } static void WINAPI wine_glProgramUniform1fEXT( GLuint program, GLint location, GLfloat v0 ) { - void (*func_glProgramUniform1fEXT)( GLuint, GLint, GLfloat ) = extension_funcs[EXT_glProgramUniform1fEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f)\n", program, location, v0 ); - func_glProgramUniform1fEXT( program, location, v0 ); + funcs->ext.p_glProgramUniform1fEXT( program, location, v0 ); } static void WINAPI wine_glProgramUniform1fv( GLuint program, GLint location, GLsizei count, GLfloat* value ) { - void (*func_glProgramUniform1fv)( GLuint, GLint, GLsizei, GLfloat* ) = extension_funcs[EXT_glProgramUniform1fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform1fv( program, location, count, value ); + funcs->ext.p_glProgramUniform1fv( program, location, count, value ); } static void WINAPI wine_glProgramUniform1fvEXT( GLuint program, GLint location, GLsizei count, GLfloat* value ) { - void (*func_glProgramUniform1fvEXT)( GLuint, GLint, GLsizei, GLfloat* ) = extension_funcs[EXT_glProgramUniform1fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform1fvEXT( program, location, count, value ); + funcs->ext.p_glProgramUniform1fvEXT( program, location, count, value ); } static void WINAPI wine_glProgramUniform1i( GLuint program, GLint location, GLint v0 ) { - void (*func_glProgramUniform1i)( GLuint, GLint, GLint ) = extension_funcs[EXT_glProgramUniform1i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", program, location, v0 ); - func_glProgramUniform1i( program, location, v0 ); + funcs->ext.p_glProgramUniform1i( program, location, v0 ); } static void WINAPI wine_glProgramUniform1i64NV( GLuint program, GLint location, INT64 x ) { - void (*func_glProgramUniform1i64NV)( GLuint, GLint, INT64 ) = extension_funcs[EXT_glProgramUniform1i64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %s)\n", program, location, wine_dbgstr_longlong(x) ); - func_glProgramUniform1i64NV( program, location, x ); + funcs->ext.p_glProgramUniform1i64NV( program, location, x ); } static void WINAPI wine_glProgramUniform1i64vNV( GLuint program, GLint location, GLsizei count, INT64* value ) { - void (*func_glProgramUniform1i64vNV)( GLuint, GLint, GLsizei, INT64* ) = extension_funcs[EXT_glProgramUniform1i64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform1i64vNV( program, location, count, value ); + funcs->ext.p_glProgramUniform1i64vNV( program, location, count, value ); } static void WINAPI wine_glProgramUniform1iEXT( GLuint program, GLint location, GLint v0 ) { - void (*func_glProgramUniform1iEXT)( GLuint, GLint, GLint ) = extension_funcs[EXT_glProgramUniform1iEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", program, location, v0 ); - func_glProgramUniform1iEXT( program, location, v0 ); + funcs->ext.p_glProgramUniform1iEXT( program, location, v0 ); } static void WINAPI wine_glProgramUniform1iv( GLuint program, GLint location, GLsizei count, GLint* value ) { - void (*func_glProgramUniform1iv)( GLuint, GLint, GLsizei, GLint* ) = extension_funcs[EXT_glProgramUniform1iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform1iv( program, location, count, value ); + funcs->ext.p_glProgramUniform1iv( program, location, count, value ); } static void WINAPI wine_glProgramUniform1ivEXT( GLuint program, GLint location, GLsizei count, GLint* value ) { - void (*func_glProgramUniform1ivEXT)( GLuint, GLint, GLsizei, GLint* ) = extension_funcs[EXT_glProgramUniform1ivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform1ivEXT( program, location, count, value ); + funcs->ext.p_glProgramUniform1ivEXT( program, location, count, value ); } static void WINAPI wine_glProgramUniform1ui( GLuint program, GLint location, GLuint v0 ) { - void (*func_glProgramUniform1ui)( GLuint, GLint, GLuint ) = extension_funcs[EXT_glProgramUniform1ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", program, location, v0 ); - func_glProgramUniform1ui( program, location, v0 ); + funcs->ext.p_glProgramUniform1ui( program, location, v0 ); } static void WINAPI wine_glProgramUniform1ui64NV( GLuint program, GLint location, UINT64 x ) { - void (*func_glProgramUniform1ui64NV)( GLuint, GLint, UINT64 ) = extension_funcs[EXT_glProgramUniform1ui64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %s)\n", program, location, wine_dbgstr_longlong(x) ); - func_glProgramUniform1ui64NV( program, location, x ); + funcs->ext.p_glProgramUniform1ui64NV( program, location, x ); } static void WINAPI wine_glProgramUniform1ui64vNV( GLuint program, GLint location, GLsizei count, UINT64* value ) { - void (*func_glProgramUniform1ui64vNV)( GLuint, GLint, GLsizei, UINT64* ) = extension_funcs[EXT_glProgramUniform1ui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform1ui64vNV( program, location, count, value ); + funcs->ext.p_glProgramUniform1ui64vNV( program, location, count, value ); } static void WINAPI wine_glProgramUniform1uiEXT( GLuint program, GLint location, GLuint v0 ) { - void (*func_glProgramUniform1uiEXT)( GLuint, GLint, GLuint ) = extension_funcs[EXT_glProgramUniform1uiEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", program, location, v0 ); - func_glProgramUniform1uiEXT( program, location, v0 ); + funcs->ext.p_glProgramUniform1uiEXT( program, location, v0 ); } static void WINAPI wine_glProgramUniform1uiv( GLuint program, GLint location, GLsizei count, GLuint* value ) { - void (*func_glProgramUniform1uiv)( GLuint, GLint, GLsizei, GLuint* ) = extension_funcs[EXT_glProgramUniform1uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform1uiv( program, location, count, value ); + funcs->ext.p_glProgramUniform1uiv( program, location, count, value ); } static void WINAPI wine_glProgramUniform1uivEXT( GLuint program, GLint location, GLsizei count, GLuint* value ) { - void (*func_glProgramUniform1uivEXT)( GLuint, GLint, GLsizei, GLuint* ) = extension_funcs[EXT_glProgramUniform1uivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform1uivEXT( program, location, count, value ); + funcs->ext.p_glProgramUniform1uivEXT( program, location, count, value ); } static void WINAPI wine_glProgramUniform2d( GLuint program, GLint location, GLdouble v0, GLdouble v1 ) { - void (*func_glProgramUniform2d)( GLuint, GLint, GLdouble, GLdouble ) = extension_funcs[EXT_glProgramUniform2d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f)\n", program, location, v0, v1 ); - func_glProgramUniform2d( program, location, v0, v1 ); + funcs->ext.p_glProgramUniform2d( program, location, v0, v1 ); } static void WINAPI wine_glProgramUniform2dEXT( GLuint program, GLint location, GLdouble x, GLdouble y ) { - void (*func_glProgramUniform2dEXT)( GLuint, GLint, GLdouble, GLdouble ) = extension_funcs[EXT_glProgramUniform2dEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f)\n", program, location, x, y ); - func_glProgramUniform2dEXT( program, location, x, y ); + funcs->ext.p_glProgramUniform2dEXT( program, location, x, y ); } static void WINAPI wine_glProgramUniform2dv( GLuint program, GLint location, GLsizei count, GLdouble* value ) { - void (*func_glProgramUniform2dv)( GLuint, GLint, GLsizei, GLdouble* ) = extension_funcs[EXT_glProgramUniform2dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform2dv( program, location, count, value ); + funcs->ext.p_glProgramUniform2dv( program, location, count, value ); } static void WINAPI wine_glProgramUniform2dvEXT( GLuint program, GLint location, GLsizei count, GLdouble* value ) { - void (*func_glProgramUniform2dvEXT)( GLuint, GLint, GLsizei, GLdouble* ) = extension_funcs[EXT_glProgramUniform2dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform2dvEXT( program, location, count, value ); + funcs->ext.p_glProgramUniform2dvEXT( program, location, count, value ); } static void WINAPI wine_glProgramUniform2f( GLuint program, GLint location, GLfloat v0, GLfloat v1 ) { - void (*func_glProgramUniform2f)( GLuint, GLint, GLfloat, GLfloat ) = extension_funcs[EXT_glProgramUniform2f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f)\n", program, location, v0, v1 ); - func_glProgramUniform2f( program, location, v0, v1 ); + funcs->ext.p_glProgramUniform2f( program, location, v0, v1 ); } static void WINAPI wine_glProgramUniform2fEXT( GLuint program, GLint location, GLfloat v0, GLfloat v1 ) { - void (*func_glProgramUniform2fEXT)( GLuint, GLint, GLfloat, GLfloat ) = extension_funcs[EXT_glProgramUniform2fEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f)\n", program, location, v0, v1 ); - func_glProgramUniform2fEXT( program, location, v0, v1 ); + funcs->ext.p_glProgramUniform2fEXT( program, location, v0, v1 ); } static void WINAPI wine_glProgramUniform2fv( GLuint program, GLint location, GLsizei count, GLfloat* value ) { - void (*func_glProgramUniform2fv)( GLuint, GLint, GLsizei, GLfloat* ) = extension_funcs[EXT_glProgramUniform2fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform2fv( program, location, count, value ); + funcs->ext.p_glProgramUniform2fv( program, location, count, value ); } static void WINAPI wine_glProgramUniform2fvEXT( GLuint program, GLint location, GLsizei count, GLfloat* value ) { - void (*func_glProgramUniform2fvEXT)( GLuint, GLint, GLsizei, GLfloat* ) = extension_funcs[EXT_glProgramUniform2fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform2fvEXT( program, location, count, value ); + funcs->ext.p_glProgramUniform2fvEXT( program, location, count, value ); } static void WINAPI wine_glProgramUniform2i( GLuint program, GLint location, GLint v0, GLint v1 ) { - void (*func_glProgramUniform2i)( GLuint, GLint, GLint, GLint ) = extension_funcs[EXT_glProgramUniform2i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", program, location, v0, v1 ); - func_glProgramUniform2i( program, location, v0, v1 ); + funcs->ext.p_glProgramUniform2i( program, location, v0, v1 ); } static void WINAPI wine_glProgramUniform2i64NV( GLuint program, GLint location, INT64 x, INT64 y ) { - void (*func_glProgramUniform2i64NV)( GLuint, GLint, INT64, INT64 ) = extension_funcs[EXT_glProgramUniform2i64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) ); - func_glProgramUniform2i64NV( program, location, x, y ); + funcs->ext.p_glProgramUniform2i64NV( program, location, x, y ); } static void WINAPI wine_glProgramUniform2i64vNV( GLuint program, GLint location, GLsizei count, INT64* value ) { - void (*func_glProgramUniform2i64vNV)( GLuint, GLint, GLsizei, INT64* ) = extension_funcs[EXT_glProgramUniform2i64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform2i64vNV( program, location, count, value ); + funcs->ext.p_glProgramUniform2i64vNV( program, location, count, value ); } static void WINAPI wine_glProgramUniform2iEXT( GLuint program, GLint location, GLint v0, GLint v1 ) { - void (*func_glProgramUniform2iEXT)( GLuint, GLint, GLint, GLint ) = extension_funcs[EXT_glProgramUniform2iEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", program, location, v0, v1 ); - func_glProgramUniform2iEXT( program, location, v0, v1 ); + funcs->ext.p_glProgramUniform2iEXT( program, location, v0, v1 ); } static void WINAPI wine_glProgramUniform2iv( GLuint program, GLint location, GLsizei count, GLint* value ) { - void (*func_glProgramUniform2iv)( GLuint, GLint, GLsizei, GLint* ) = extension_funcs[EXT_glProgramUniform2iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform2iv( program, location, count, value ); + funcs->ext.p_glProgramUniform2iv( program, location, count, value ); } static void WINAPI wine_glProgramUniform2ivEXT( GLuint program, GLint location, GLsizei count, GLint* value ) { - void (*func_glProgramUniform2ivEXT)( GLuint, GLint, GLsizei, GLint* ) = extension_funcs[EXT_glProgramUniform2ivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform2ivEXT( program, location, count, value ); + funcs->ext.p_glProgramUniform2ivEXT( program, location, count, value ); } static void WINAPI wine_glProgramUniform2ui( GLuint program, GLint location, GLuint v0, GLuint v1 ) { - void (*func_glProgramUniform2ui)( GLuint, GLint, GLuint, GLuint ) = extension_funcs[EXT_glProgramUniform2ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", program, location, v0, v1 ); - func_glProgramUniform2ui( program, location, v0, v1 ); + funcs->ext.p_glProgramUniform2ui( program, location, v0, v1 ); } static void WINAPI wine_glProgramUniform2ui64NV( GLuint program, GLint location, UINT64 x, UINT64 y ) { - void (*func_glProgramUniform2ui64NV)( GLuint, GLint, UINT64, UINT64 ) = extension_funcs[EXT_glProgramUniform2ui64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) ); - func_glProgramUniform2ui64NV( program, location, x, y ); + funcs->ext.p_glProgramUniform2ui64NV( program, location, x, y ); } static void WINAPI wine_glProgramUniform2ui64vNV( GLuint program, GLint location, GLsizei count, UINT64* value ) { - void (*func_glProgramUniform2ui64vNV)( GLuint, GLint, GLsizei, UINT64* ) = extension_funcs[EXT_glProgramUniform2ui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform2ui64vNV( program, location, count, value ); + funcs->ext.p_glProgramUniform2ui64vNV( program, location, count, value ); } static void WINAPI wine_glProgramUniform2uiEXT( GLuint program, GLint location, GLuint v0, GLuint v1 ) { - void (*func_glProgramUniform2uiEXT)( GLuint, GLint, GLuint, GLuint ) = extension_funcs[EXT_glProgramUniform2uiEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", program, location, v0, v1 ); - func_glProgramUniform2uiEXT( program, location, v0, v1 ); + funcs->ext.p_glProgramUniform2uiEXT( program, location, v0, v1 ); } static void WINAPI wine_glProgramUniform2uiv( GLuint program, GLint location, GLsizei count, GLuint* value ) { - void (*func_glProgramUniform2uiv)( GLuint, GLint, GLsizei, GLuint* ) = extension_funcs[EXT_glProgramUniform2uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform2uiv( program, location, count, value ); + funcs->ext.p_glProgramUniform2uiv( program, location, count, value ); } static void WINAPI wine_glProgramUniform2uivEXT( GLuint program, GLint location, GLsizei count, GLuint* value ) { - void (*func_glProgramUniform2uivEXT)( GLuint, GLint, GLsizei, GLuint* ) = extension_funcs[EXT_glProgramUniform2uivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform2uivEXT( program, location, count, value ); + funcs->ext.p_glProgramUniform2uivEXT( program, location, count, value ); } static void WINAPI wine_glProgramUniform3d( GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2 ) { - void (*func_glProgramUniform3d)( GLuint, GLint, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glProgramUniform3d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f, %f)\n", program, location, v0, v1, v2 ); - func_glProgramUniform3d( program, location, v0, v1, v2 ); + funcs->ext.p_glProgramUniform3d( program, location, v0, v1, v2 ); } static void WINAPI wine_glProgramUniform3dEXT( GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z ) { - void (*func_glProgramUniform3dEXT)( GLuint, GLint, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glProgramUniform3dEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f, %f)\n", program, location, x, y, z ); - func_glProgramUniform3dEXT( program, location, x, y, z ); + funcs->ext.p_glProgramUniform3dEXT( program, location, x, y, z ); } static void WINAPI wine_glProgramUniform3dv( GLuint program, GLint location, GLsizei count, GLdouble* value ) { - void (*func_glProgramUniform3dv)( GLuint, GLint, GLsizei, GLdouble* ) = extension_funcs[EXT_glProgramUniform3dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform3dv( program, location, count, value ); + funcs->ext.p_glProgramUniform3dv( program, location, count, value ); } static void WINAPI wine_glProgramUniform3dvEXT( GLuint program, GLint location, GLsizei count, GLdouble* value ) { - void (*func_glProgramUniform3dvEXT)( GLuint, GLint, GLsizei, GLdouble* ) = extension_funcs[EXT_glProgramUniform3dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform3dvEXT( program, location, count, value ); + funcs->ext.p_glProgramUniform3dvEXT( program, location, count, value ); } static void WINAPI wine_glProgramUniform3f( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2 ) { - void (*func_glProgramUniform3f)( GLuint, GLint, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glProgramUniform3f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f, %f)\n", program, location, v0, v1, v2 ); - func_glProgramUniform3f( program, location, v0, v1, v2 ); + funcs->ext.p_glProgramUniform3f( program, location, v0, v1, v2 ); } static void WINAPI wine_glProgramUniform3fEXT( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2 ) { - void (*func_glProgramUniform3fEXT)( GLuint, GLint, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glProgramUniform3fEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f, %f)\n", program, location, v0, v1, v2 ); - func_glProgramUniform3fEXT( program, location, v0, v1, v2 ); + funcs->ext.p_glProgramUniform3fEXT( program, location, v0, v1, v2 ); } static void WINAPI wine_glProgramUniform3fv( GLuint program, GLint location, GLsizei count, GLfloat* value ) { - void (*func_glProgramUniform3fv)( GLuint, GLint, GLsizei, GLfloat* ) = extension_funcs[EXT_glProgramUniform3fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform3fv( program, location, count, value ); + funcs->ext.p_glProgramUniform3fv( program, location, count, value ); } static void WINAPI wine_glProgramUniform3fvEXT( GLuint program, GLint location, GLsizei count, GLfloat* value ) { - void (*func_glProgramUniform3fvEXT)( GLuint, GLint, GLsizei, GLfloat* ) = extension_funcs[EXT_glProgramUniform3fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform3fvEXT( program, location, count, value ); + funcs->ext.p_glProgramUniform3fvEXT( program, location, count, value ); } static void WINAPI wine_glProgramUniform3i( GLuint program, GLint location, GLint v0, GLint v1, GLint v2 ) { - void (*func_glProgramUniform3i)( GLuint, GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glProgramUniform3i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", program, location, v0, v1, v2 ); - func_glProgramUniform3i( program, location, v0, v1, v2 ); + funcs->ext.p_glProgramUniform3i( program, location, v0, v1, v2 ); } static void WINAPI wine_glProgramUniform3i64NV( GLuint program, GLint location, INT64 x, INT64 y, INT64 z ) { - void (*func_glProgramUniform3i64NV)( GLuint, GLint, INT64, INT64, INT64 ) = extension_funcs[EXT_glProgramUniform3i64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) ); - func_glProgramUniform3i64NV( program, location, x, y, z ); + funcs->ext.p_glProgramUniform3i64NV( program, location, x, y, z ); } static void WINAPI wine_glProgramUniform3i64vNV( GLuint program, GLint location, GLsizei count, INT64* value ) { - void (*func_glProgramUniform3i64vNV)( GLuint, GLint, GLsizei, INT64* ) = extension_funcs[EXT_glProgramUniform3i64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform3i64vNV( program, location, count, value ); + funcs->ext.p_glProgramUniform3i64vNV( program, location, count, value ); } static void WINAPI wine_glProgramUniform3iEXT( GLuint program, GLint location, GLint v0, GLint v1, GLint v2 ) { - void (*func_glProgramUniform3iEXT)( GLuint, GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glProgramUniform3iEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", program, location, v0, v1, v2 ); - func_glProgramUniform3iEXT( program, location, v0, v1, v2 ); + funcs->ext.p_glProgramUniform3iEXT( program, location, v0, v1, v2 ); } static void WINAPI wine_glProgramUniform3iv( GLuint program, GLint location, GLsizei count, GLint* value ) { - void (*func_glProgramUniform3iv)( GLuint, GLint, GLsizei, GLint* ) = extension_funcs[EXT_glProgramUniform3iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform3iv( program, location, count, value ); + funcs->ext.p_glProgramUniform3iv( program, location, count, value ); } static void WINAPI wine_glProgramUniform3ivEXT( GLuint program, GLint location, GLsizei count, GLint* value ) { - void (*func_glProgramUniform3ivEXT)( GLuint, GLint, GLsizei, GLint* ) = extension_funcs[EXT_glProgramUniform3ivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform3ivEXT( program, location, count, value ); + funcs->ext.p_glProgramUniform3ivEXT( program, location, count, value ); } static void WINAPI wine_glProgramUniform3ui( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2 ) { - void (*func_glProgramUniform3ui)( GLuint, GLint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glProgramUniform3ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", program, location, v0, v1, v2 ); - func_glProgramUniform3ui( program, location, v0, v1, v2 ); + funcs->ext.p_glProgramUniform3ui( program, location, v0, v1, v2 ); } static void WINAPI wine_glProgramUniform3ui64NV( GLuint program, GLint location, UINT64 x, UINT64 y, UINT64 z ) { - void (*func_glProgramUniform3ui64NV)( GLuint, GLint, UINT64, UINT64, UINT64 ) = extension_funcs[EXT_glProgramUniform3ui64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) ); - func_glProgramUniform3ui64NV( program, location, x, y, z ); + funcs->ext.p_glProgramUniform3ui64NV( program, location, x, y, z ); } static void WINAPI wine_glProgramUniform3ui64vNV( GLuint program, GLint location, GLsizei count, UINT64* value ) { - void (*func_glProgramUniform3ui64vNV)( GLuint, GLint, GLsizei, UINT64* ) = extension_funcs[EXT_glProgramUniform3ui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform3ui64vNV( program, location, count, value ); + funcs->ext.p_glProgramUniform3ui64vNV( program, location, count, value ); } static void WINAPI wine_glProgramUniform3uiEXT( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2 ) { - void (*func_glProgramUniform3uiEXT)( GLuint, GLint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glProgramUniform3uiEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", program, location, v0, v1, v2 ); - func_glProgramUniform3uiEXT( program, location, v0, v1, v2 ); + funcs->ext.p_glProgramUniform3uiEXT( program, location, v0, v1, v2 ); } static void WINAPI wine_glProgramUniform3uiv( GLuint program, GLint location, GLsizei count, GLuint* value ) { - void (*func_glProgramUniform3uiv)( GLuint, GLint, GLsizei, GLuint* ) = extension_funcs[EXT_glProgramUniform3uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform3uiv( program, location, count, value ); + funcs->ext.p_glProgramUniform3uiv( program, location, count, value ); } static void WINAPI wine_glProgramUniform3uivEXT( GLuint program, GLint location, GLsizei count, GLuint* value ) { - void (*func_glProgramUniform3uivEXT)( GLuint, GLint, GLsizei, GLuint* ) = extension_funcs[EXT_glProgramUniform3uivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform3uivEXT( program, location, count, value ); + funcs->ext.p_glProgramUniform3uivEXT( program, location, count, value ); } static void WINAPI wine_glProgramUniform4d( GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3 ) { - void (*func_glProgramUniform4d)( GLuint, GLint, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glProgramUniform4d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f, %f, %f)\n", program, location, v0, v1, v2, v3 ); - func_glProgramUniform4d( program, location, v0, v1, v2, v3 ); + funcs->ext.p_glProgramUniform4d( program, location, v0, v1, v2, v3 ); } static void WINAPI wine_glProgramUniform4dEXT( GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { - void (*func_glProgramUniform4dEXT)( GLuint, GLint, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glProgramUniform4dEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f, %f, %f)\n", program, location, x, y, z, w ); - func_glProgramUniform4dEXT( program, location, x, y, z, w ); + funcs->ext.p_glProgramUniform4dEXT( program, location, x, y, z, w ); } static void WINAPI wine_glProgramUniform4dv( GLuint program, GLint location, GLsizei count, GLdouble* value ) { - void (*func_glProgramUniform4dv)( GLuint, GLint, GLsizei, GLdouble* ) = extension_funcs[EXT_glProgramUniform4dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform4dv( program, location, count, value ); + funcs->ext.p_glProgramUniform4dv( program, location, count, value ); } static void WINAPI wine_glProgramUniform4dvEXT( GLuint program, GLint location, GLsizei count, GLdouble* value ) { - void (*func_glProgramUniform4dvEXT)( GLuint, GLint, GLsizei, GLdouble* ) = extension_funcs[EXT_glProgramUniform4dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform4dvEXT( program, location, count, value ); + funcs->ext.p_glProgramUniform4dvEXT( program, location, count, value ); } static void WINAPI wine_glProgramUniform4f( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) { - void (*func_glProgramUniform4f)( GLuint, GLint, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glProgramUniform4f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f, %f, %f)\n", program, location, v0, v1, v2, v3 ); - func_glProgramUniform4f( program, location, v0, v1, v2, v3 ); + funcs->ext.p_glProgramUniform4f( program, location, v0, v1, v2, v3 ); } static void WINAPI wine_glProgramUniform4fEXT( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) { - void (*func_glProgramUniform4fEXT)( GLuint, GLint, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glProgramUniform4fEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f, %f, %f, %f)\n", program, location, v0, v1, v2, v3 ); - func_glProgramUniform4fEXT( program, location, v0, v1, v2, v3 ); + funcs->ext.p_glProgramUniform4fEXT( program, location, v0, v1, v2, v3 ); } static void WINAPI wine_glProgramUniform4fv( GLuint program, GLint location, GLsizei count, GLfloat* value ) { - void (*func_glProgramUniform4fv)( GLuint, GLint, GLsizei, GLfloat* ) = extension_funcs[EXT_glProgramUniform4fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform4fv( program, location, count, value ); + funcs->ext.p_glProgramUniform4fv( program, location, count, value ); } static void WINAPI wine_glProgramUniform4fvEXT( GLuint program, GLint location, GLsizei count, GLfloat* value ) { - void (*func_glProgramUniform4fvEXT)( GLuint, GLint, GLsizei, GLfloat* ) = extension_funcs[EXT_glProgramUniform4fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform4fvEXT( program, location, count, value ); + funcs->ext.p_glProgramUniform4fvEXT( program, location, count, value ); } static void WINAPI wine_glProgramUniform4i( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3 ) { - void (*func_glProgramUniform4i)( GLuint, GLint, GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glProgramUniform4i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", program, location, v0, v1, v2, v3 ); - func_glProgramUniform4i( program, location, v0, v1, v2, v3 ); + funcs->ext.p_glProgramUniform4i( program, location, v0, v1, v2, v3 ); } static void WINAPI wine_glProgramUniform4i64NV( GLuint program, GLint location, INT64 x, INT64 y, INT64 z, INT64 w ) { - void (*func_glProgramUniform4i64NV)( GLuint, GLint, INT64, INT64, INT64, INT64 ) = extension_funcs[EXT_glProgramUniform4i64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %s, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) ); - func_glProgramUniform4i64NV( program, location, x, y, z, w ); + funcs->ext.p_glProgramUniform4i64NV( program, location, x, y, z, w ); } static void WINAPI wine_glProgramUniform4i64vNV( GLuint program, GLint location, GLsizei count, INT64* value ) { - void (*func_glProgramUniform4i64vNV)( GLuint, GLint, GLsizei, INT64* ) = extension_funcs[EXT_glProgramUniform4i64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform4i64vNV( program, location, count, value ); + funcs->ext.p_glProgramUniform4i64vNV( program, location, count, value ); } static void WINAPI wine_glProgramUniform4iEXT( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3 ) { - void (*func_glProgramUniform4iEXT)( GLuint, GLint, GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glProgramUniform4iEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", program, location, v0, v1, v2, v3 ); - func_glProgramUniform4iEXT( program, location, v0, v1, v2, v3 ); + funcs->ext.p_glProgramUniform4iEXT( program, location, v0, v1, v2, v3 ); } static void WINAPI wine_glProgramUniform4iv( GLuint program, GLint location, GLsizei count, GLint* value ) { - void (*func_glProgramUniform4iv)( GLuint, GLint, GLsizei, GLint* ) = extension_funcs[EXT_glProgramUniform4iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform4iv( program, location, count, value ); + funcs->ext.p_glProgramUniform4iv( program, location, count, value ); } static void WINAPI wine_glProgramUniform4ivEXT( GLuint program, GLint location, GLsizei count, GLint* value ) { - void (*func_glProgramUniform4ivEXT)( GLuint, GLint, GLsizei, GLint* ) = extension_funcs[EXT_glProgramUniform4ivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform4ivEXT( program, location, count, value ); + funcs->ext.p_glProgramUniform4ivEXT( program, location, count, value ); } static void WINAPI wine_glProgramUniform4ui( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) { - void (*func_glProgramUniform4ui)( GLuint, GLint, GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glProgramUniform4ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", program, location, v0, v1, v2, v3 ); - func_glProgramUniform4ui( program, location, v0, v1, v2, v3 ); + funcs->ext.p_glProgramUniform4ui( program, location, v0, v1, v2, v3 ); } static void WINAPI wine_glProgramUniform4ui64NV( GLuint program, GLint location, UINT64 x, UINT64 y, UINT64 z, UINT64 w ) { - void (*func_glProgramUniform4ui64NV)( GLuint, GLint, UINT64, UINT64, UINT64, UINT64 ) = extension_funcs[EXT_glProgramUniform4ui64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %s, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) ); - func_glProgramUniform4ui64NV( program, location, x, y, z, w ); + funcs->ext.p_glProgramUniform4ui64NV( program, location, x, y, z, w ); } static void WINAPI wine_glProgramUniform4ui64vNV( GLuint program, GLint location, GLsizei count, UINT64* value ) { - void (*func_glProgramUniform4ui64vNV)( GLuint, GLint, GLsizei, UINT64* ) = extension_funcs[EXT_glProgramUniform4ui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform4ui64vNV( program, location, count, value ); + funcs->ext.p_glProgramUniform4ui64vNV( program, location, count, value ); } static void WINAPI wine_glProgramUniform4uiEXT( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) { - void (*func_glProgramUniform4uiEXT)( GLuint, GLint, GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glProgramUniform4uiEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", program, location, v0, v1, v2, v3 ); - func_glProgramUniform4uiEXT( program, location, v0, v1, v2, v3 ); + funcs->ext.p_glProgramUniform4uiEXT( program, location, v0, v1, v2, v3 ); } static void WINAPI wine_glProgramUniform4uiv( GLuint program, GLint location, GLsizei count, GLuint* value ) { - void (*func_glProgramUniform4uiv)( GLuint, GLint, GLsizei, GLuint* ) = extension_funcs[EXT_glProgramUniform4uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform4uiv( program, location, count, value ); + funcs->ext.p_glProgramUniform4uiv( program, location, count, value ); } static void WINAPI wine_glProgramUniform4uivEXT( GLuint program, GLint location, GLsizei count, GLuint* value ) { - void (*func_glProgramUniform4uivEXT)( GLuint, GLint, GLsizei, GLuint* ) = extension_funcs[EXT_glProgramUniform4uivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniform4uivEXT( program, location, count, value ); + funcs->ext.p_glProgramUniform4uivEXT( program, location, count, value ); } static void WINAPI wine_glProgramUniformHandleui64NV( GLuint program, GLint location, UINT64 value ) { - void (*func_glProgramUniformHandleui64NV)( GLuint, GLint, UINT64 ) = extension_funcs[EXT_glProgramUniformHandleui64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %s)\n", program, location, wine_dbgstr_longlong(value) ); - func_glProgramUniformHandleui64NV( program, location, value ); + funcs->ext.p_glProgramUniformHandleui64NV( program, location, value ); } static void WINAPI wine_glProgramUniformHandleui64vNV( GLuint program, GLint location, GLsizei count, UINT64* values ) { - void (*func_glProgramUniformHandleui64vNV)( GLuint, GLint, GLsizei, UINT64* ) = extension_funcs[EXT_glProgramUniformHandleui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, values ); - func_glProgramUniformHandleui64vNV( program, location, count, values ); + funcs->ext.p_glProgramUniformHandleui64vNV( program, location, count, values ); } static void WINAPI wine_glProgramUniformMatrix2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glProgramUniformMatrix2dv)( GLuint, GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glProgramUniformMatrix2dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix2dv( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix2dv( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix2dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glProgramUniformMatrix2dvEXT)( GLuint, GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glProgramUniformMatrix2dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix2dvEXT( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix2dvEXT( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glProgramUniformMatrix2fv)( GLuint, GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glProgramUniformMatrix2fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix2fv( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix2fv( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix2fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glProgramUniformMatrix2fvEXT)( GLuint, GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glProgramUniformMatrix2fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix2fvEXT( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix2fvEXT( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix2x3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glProgramUniformMatrix2x3dv)( GLuint, GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glProgramUniformMatrix2x3dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix2x3dv( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix2x3dv( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix2x3dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glProgramUniformMatrix2x3dvEXT)( GLuint, GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glProgramUniformMatrix2x3dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix2x3dvEXT( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix2x3dvEXT( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix2x3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glProgramUniformMatrix2x3fv)( GLuint, GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glProgramUniformMatrix2x3fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix2x3fv( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix2x3fv( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix2x3fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glProgramUniformMatrix2x3fvEXT)( GLuint, GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glProgramUniformMatrix2x3fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix2x3fvEXT( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix2x3fvEXT( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix2x4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glProgramUniformMatrix2x4dv)( GLuint, GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glProgramUniformMatrix2x4dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix2x4dv( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix2x4dv( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix2x4dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glProgramUniformMatrix2x4dvEXT)( GLuint, GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glProgramUniformMatrix2x4dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix2x4dvEXT( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix2x4dvEXT( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix2x4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glProgramUniformMatrix2x4fv)( GLuint, GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glProgramUniformMatrix2x4fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix2x4fv( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix2x4fv( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix2x4fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glProgramUniformMatrix2x4fvEXT)( GLuint, GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glProgramUniformMatrix2x4fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix2x4fvEXT( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix2x4fvEXT( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glProgramUniformMatrix3dv)( GLuint, GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glProgramUniformMatrix3dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix3dv( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix3dv( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix3dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glProgramUniformMatrix3dvEXT)( GLuint, GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glProgramUniformMatrix3dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix3dvEXT( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix3dvEXT( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glProgramUniformMatrix3fv)( GLuint, GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glProgramUniformMatrix3fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix3fv( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix3fv( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix3fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glProgramUniformMatrix3fvEXT)( GLuint, GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glProgramUniformMatrix3fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix3fvEXT( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix3fvEXT( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix3x2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glProgramUniformMatrix3x2dv)( GLuint, GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glProgramUniformMatrix3x2dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix3x2dv( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix3x2dv( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix3x2dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glProgramUniformMatrix3x2dvEXT)( GLuint, GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glProgramUniformMatrix3x2dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix3x2dvEXT( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix3x2dvEXT( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix3x2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glProgramUniformMatrix3x2fv)( GLuint, GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glProgramUniformMatrix3x2fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix3x2fv( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix3x2fv( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix3x2fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glProgramUniformMatrix3x2fvEXT)( GLuint, GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glProgramUniformMatrix3x2fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix3x2fvEXT( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix3x2fvEXT( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix3x4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glProgramUniformMatrix3x4dv)( GLuint, GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glProgramUniformMatrix3x4dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix3x4dv( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix3x4dv( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix3x4dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glProgramUniformMatrix3x4dvEXT)( GLuint, GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glProgramUniformMatrix3x4dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix3x4dvEXT( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix3x4dvEXT( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix3x4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glProgramUniformMatrix3x4fv)( GLuint, GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glProgramUniformMatrix3x4fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix3x4fv( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix3x4fv( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix3x4fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glProgramUniformMatrix3x4fvEXT)( GLuint, GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glProgramUniformMatrix3x4fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix3x4fvEXT( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix3x4fvEXT( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glProgramUniformMatrix4dv)( GLuint, GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glProgramUniformMatrix4dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix4dv( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix4dv( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix4dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glProgramUniformMatrix4dvEXT)( GLuint, GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glProgramUniformMatrix4dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix4dvEXT( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix4dvEXT( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glProgramUniformMatrix4fv)( GLuint, GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glProgramUniformMatrix4fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix4fv( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix4fv( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix4fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glProgramUniformMatrix4fvEXT)( GLuint, GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glProgramUniformMatrix4fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix4fvEXT( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix4fvEXT( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix4x2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glProgramUniformMatrix4x2dv)( GLuint, GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glProgramUniformMatrix4x2dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix4x2dv( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix4x2dv( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix4x2dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glProgramUniformMatrix4x2dvEXT)( GLuint, GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glProgramUniformMatrix4x2dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix4x2dvEXT( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix4x2dvEXT( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix4x2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glProgramUniformMatrix4x2fv)( GLuint, GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glProgramUniformMatrix4x2fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix4x2fv( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix4x2fv( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix4x2fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glProgramUniformMatrix4x2fvEXT)( GLuint, GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glProgramUniformMatrix4x2fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix4x2fvEXT( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix4x2fvEXT( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix4x3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glProgramUniformMatrix4x3dv)( GLuint, GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glProgramUniformMatrix4x3dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix4x3dv( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix4x3dv( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix4x3dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glProgramUniformMatrix4x3dvEXT)( GLuint, GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glProgramUniformMatrix4x3dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix4x3dvEXT( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix4x3dvEXT( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix4x3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glProgramUniformMatrix4x3fv)( GLuint, GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glProgramUniformMatrix4x3fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix4x3fv( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix4x3fv( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformMatrix4x3fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glProgramUniformMatrix4x3fvEXT)( GLuint, GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glProgramUniformMatrix4x3fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value ); - func_glProgramUniformMatrix4x3fvEXT( program, location, count, transpose, value ); + funcs->ext.p_glProgramUniformMatrix4x3fvEXT( program, location, count, transpose, value ); } static void WINAPI wine_glProgramUniformui64NV( GLuint program, GLint location, UINT64 value ) { - void (*func_glProgramUniformui64NV)( GLuint, GLint, UINT64 ) = extension_funcs[EXT_glProgramUniformui64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %s)\n", program, location, wine_dbgstr_longlong(value) ); - func_glProgramUniformui64NV( program, location, value ); + funcs->ext.p_glProgramUniformui64NV( program, location, value ); } static void WINAPI wine_glProgramUniformui64vNV( GLuint program, GLint location, GLsizei count, UINT64* value ) { - void (*func_glProgramUniformui64vNV)( GLuint, GLint, GLsizei, UINT64* ) = extension_funcs[EXT_glProgramUniformui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", program, location, count, value ); - func_glProgramUniformui64vNV( program, location, count, value ); + funcs->ext.p_glProgramUniformui64vNV( program, location, count, value ); } static void WINAPI wine_glProgramVertexLimitNV( GLenum target, GLint limit ) { - void (*func_glProgramVertexLimitNV)( GLenum, GLint ) = extension_funcs[EXT_glProgramVertexLimitNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, limit ); - func_glProgramVertexLimitNV( target, limit ); + funcs->ext.p_glProgramVertexLimitNV( target, limit ); } static void WINAPI wine_glProvokingVertex( GLenum mode ) { - void (*func_glProvokingVertex)( GLenum ) = extension_funcs[EXT_glProvokingVertex]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", mode ); - func_glProvokingVertex( mode ); + funcs->ext.p_glProvokingVertex( mode ); } static void WINAPI wine_glProvokingVertexEXT( GLenum mode ) { - void (*func_glProvokingVertexEXT)( GLenum ) = extension_funcs[EXT_glProvokingVertexEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", mode ); - func_glProvokingVertexEXT( mode ); + funcs->ext.p_glProvokingVertexEXT( mode ); } static void WINAPI wine_glPushClientAttribDefaultEXT( GLbitfield mask ) { - void (*func_glPushClientAttribDefaultEXT)( GLbitfield ) = extension_funcs[EXT_glPushClientAttribDefaultEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", mask ); - func_glPushClientAttribDefaultEXT( mask ); + funcs->ext.p_glPushClientAttribDefaultEXT( mask ); } static void WINAPI wine_glQueryCounter( GLuint id, GLenum target ) { - void (*func_glQueryCounter)( GLuint, GLenum ) = extension_funcs[EXT_glQueryCounter]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", id, target ); - func_glQueryCounter( id, target ); + funcs->ext.p_glQueryCounter( id, target ); } static void WINAPI wine_glReadBufferRegion( GLenum region, GLint x, GLint y, GLsizei width, GLsizei height ) { - void (*func_glReadBufferRegion)( GLenum, GLint, GLint, GLsizei, GLsizei ) = extension_funcs[EXT_glReadBufferRegion]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", region, x, y, width, height ); - func_glReadBufferRegion( region, x, y, width, height ); + funcs->ext.p_glReadBufferRegion( region, x, y, width, height ); } static void WINAPI wine_glReadInstrumentsSGIX( GLint marker ) { - void (*func_glReadInstrumentsSGIX)( GLint ) = extension_funcs[EXT_glReadInstrumentsSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", marker ); - func_glReadInstrumentsSGIX( marker ); + funcs->ext.p_glReadInstrumentsSGIX( marker ); } static void WINAPI wine_glReadnPixelsARB( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, GLvoid* data ) { - void (*func_glReadnPixelsARB)( GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glReadnPixelsARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", x, y, width, height, format, type, bufSize, data ); - func_glReadnPixelsARB( x, y, width, height, format, type, bufSize, data ); + funcs->ext.p_glReadnPixelsARB( x, y, width, height, format, type, bufSize, data ); } static void WINAPI wine_glReferencePlaneSGIX( GLdouble* equation ) { - void (*func_glReferencePlaneSGIX)( GLdouble* ) = extension_funcs[EXT_glReferencePlaneSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", equation ); - func_glReferencePlaneSGIX( equation ); + funcs->ext.p_glReferencePlaneSGIX( equation ); } static void WINAPI wine_glReleaseShaderCompiler( void ) { - void (*func_glReleaseShaderCompiler)( void ) = extension_funcs[EXT_glReleaseShaderCompiler]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glReleaseShaderCompiler( ); + funcs->ext.p_glReleaseShaderCompiler( ); } static void WINAPI wine_glRenderbufferStorage( GLenum target, GLenum internalformat, GLsizei width, GLsizei height ) { - void (*func_glRenderbufferStorage)( GLenum, GLenum, GLsizei, GLsizei ) = extension_funcs[EXT_glRenderbufferStorage]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", target, internalformat, width, height ); - func_glRenderbufferStorage( target, internalformat, width, height ); + funcs->ext.p_glRenderbufferStorage( target, internalformat, width, height ); } static void WINAPI wine_glRenderbufferStorageEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height ) { - void (*func_glRenderbufferStorageEXT)( GLenum, GLenum, GLsizei, GLsizei ) = extension_funcs[EXT_glRenderbufferStorageEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", target, internalformat, width, height ); - func_glRenderbufferStorageEXT( target, internalformat, width, height ); + funcs->ext.p_glRenderbufferStorageEXT( target, internalformat, width, height ); } static void WINAPI wine_glRenderbufferStorageMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height ) { - void (*func_glRenderbufferStorageMultisample)( GLenum, GLsizei, GLenum, GLsizei, GLsizei ) = extension_funcs[EXT_glRenderbufferStorageMultisample]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, samples, internalformat, width, height ); - func_glRenderbufferStorageMultisample( target, samples, internalformat, width, height ); + funcs->ext.p_glRenderbufferStorageMultisample( target, samples, internalformat, width, height ); } static void WINAPI wine_glRenderbufferStorageMultisampleCoverageNV( GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height ) { - void (*func_glRenderbufferStorageMultisampleCoverageNV)( GLenum, GLsizei, GLsizei, GLenum, GLsizei, GLsizei ) = extension_funcs[EXT_glRenderbufferStorageMultisampleCoverageNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", target, coverageSamples, colorSamples, internalformat, width, height ); - func_glRenderbufferStorageMultisampleCoverageNV( target, coverageSamples, colorSamples, internalformat, width, height ); + funcs->ext.p_glRenderbufferStorageMultisampleCoverageNV( target, coverageSamples, colorSamples, internalformat, width, height ); } static void WINAPI wine_glRenderbufferStorageMultisampleEXT( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height ) { - void (*func_glRenderbufferStorageMultisampleEXT)( GLenum, GLsizei, GLenum, GLsizei, GLsizei ) = extension_funcs[EXT_glRenderbufferStorageMultisampleEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, samples, internalformat, width, height ); - func_glRenderbufferStorageMultisampleEXT( target, samples, internalformat, width, height ); + funcs->ext.p_glRenderbufferStorageMultisampleEXT( target, samples, internalformat, width, height ); } static void WINAPI wine_glReplacementCodePointerSUN( GLenum type, GLsizei stride, GLvoid** pointer ) { - void (*func_glReplacementCodePointerSUN)( GLenum, GLsizei, GLvoid** ) = extension_funcs[EXT_glReplacementCodePointerSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", type, stride, pointer ); - func_glReplacementCodePointerSUN( type, stride, pointer ); + funcs->ext.p_glReplacementCodePointerSUN( type, stride, pointer ); } static void WINAPI wine_glReplacementCodeubSUN( GLubyte code ) { - void (*func_glReplacementCodeubSUN)( GLubyte ) = extension_funcs[EXT_glReplacementCodeubSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", code ); - func_glReplacementCodeubSUN( code ); + funcs->ext.p_glReplacementCodeubSUN( code ); } static void WINAPI wine_glReplacementCodeubvSUN( GLubyte* code ) { - void (*func_glReplacementCodeubvSUN)( GLubyte* ) = extension_funcs[EXT_glReplacementCodeubvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", code ); - func_glReplacementCodeubvSUN( code ); + funcs->ext.p_glReplacementCodeubvSUN( code ); } static void WINAPI wine_glReplacementCodeuiColor3fVertex3fSUN( GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glReplacementCodeuiColor3fVertex3fSUN)( GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glReplacementCodeuiColor3fVertex3fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f, %f, %f)\n", rc, r, g, b, x, y, z ); - func_glReplacementCodeuiColor3fVertex3fSUN( rc, r, g, b, x, y, z ); + funcs->ext.p_glReplacementCodeuiColor3fVertex3fSUN( rc, r, g, b, x, y, z ); } static void WINAPI wine_glReplacementCodeuiColor3fVertex3fvSUN( GLuint* rc, GLfloat* c, GLfloat* v ) { - void (*func_glReplacementCodeuiColor3fVertex3fvSUN)( GLuint*, GLfloat*, GLfloat* ) = extension_funcs[EXT_glReplacementCodeuiColor3fVertex3fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p, %p)\n", rc, c, v ); - func_glReplacementCodeuiColor3fVertex3fvSUN( rc, c, v ); + funcs->ext.p_glReplacementCodeuiColor3fVertex3fvSUN( rc, c, v ); } static void WINAPI wine_glReplacementCodeuiColor4fNormal3fVertex3fSUN( GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glReplacementCodeuiColor4fNormal3fVertex3fSUN)( GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glReplacementCodeuiColor4fNormal3fVertex3fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", rc, r, g, b, a, nx, ny, nz, x, y, z ); - func_glReplacementCodeuiColor4fNormal3fVertex3fSUN( rc, r, g, b, a, nx, ny, nz, x, y, z ); + funcs->ext.p_glReplacementCodeuiColor4fNormal3fVertex3fSUN( rc, r, g, b, a, nx, ny, nz, x, y, z ); } static void WINAPI wine_glReplacementCodeuiColor4fNormal3fVertex3fvSUN( GLuint* rc, GLfloat* c, GLfloat* n, GLfloat* v ) { - void (*func_glReplacementCodeuiColor4fNormal3fVertex3fvSUN)( GLuint*, GLfloat*, GLfloat*, GLfloat* ) = extension_funcs[EXT_glReplacementCodeuiColor4fNormal3fVertex3fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p, %p, %p)\n", rc, c, n, v ); - func_glReplacementCodeuiColor4fNormal3fVertex3fvSUN( rc, c, n, v ); + funcs->ext.p_glReplacementCodeuiColor4fNormal3fVertex3fvSUN( rc, c, n, v ); } static void WINAPI wine_glReplacementCodeuiColor4ubVertex3fSUN( GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glReplacementCodeuiColor4ubVertex3fSUN)( GLuint, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glReplacementCodeuiColor4ubVertex3fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %f, %f, %f)\n", rc, r, g, b, a, x, y, z ); - func_glReplacementCodeuiColor4ubVertex3fSUN( rc, r, g, b, a, x, y, z ); + funcs->ext.p_glReplacementCodeuiColor4ubVertex3fSUN( rc, r, g, b, a, x, y, z ); } static void WINAPI wine_glReplacementCodeuiColor4ubVertex3fvSUN( GLuint* rc, GLubyte* c, GLfloat* v ) { - void (*func_glReplacementCodeuiColor4ubVertex3fvSUN)( GLuint*, GLubyte*, GLfloat* ) = extension_funcs[EXT_glReplacementCodeuiColor4ubVertex3fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p, %p)\n", rc, c, v ); - func_glReplacementCodeuiColor4ubVertex3fvSUN( rc, c, v ); + funcs->ext.p_glReplacementCodeuiColor4ubVertex3fvSUN( rc, c, v ); } static void WINAPI wine_glReplacementCodeuiNormal3fVertex3fSUN( GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glReplacementCodeuiNormal3fVertex3fSUN)( GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glReplacementCodeuiNormal3fVertex3fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f, %f, %f)\n", rc, nx, ny, nz, x, y, z ); - func_glReplacementCodeuiNormal3fVertex3fSUN( rc, nx, ny, nz, x, y, z ); + funcs->ext.p_glReplacementCodeuiNormal3fVertex3fSUN( rc, nx, ny, nz, x, y, z ); } static void WINAPI wine_glReplacementCodeuiNormal3fVertex3fvSUN( GLuint* rc, GLfloat* n, GLfloat* v ) { - void (*func_glReplacementCodeuiNormal3fVertex3fvSUN)( GLuint*, GLfloat*, GLfloat* ) = extension_funcs[EXT_glReplacementCodeuiNormal3fVertex3fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p, %p)\n", rc, n, v ); - func_glReplacementCodeuiNormal3fVertex3fvSUN( rc, n, v ); + funcs->ext.p_glReplacementCodeuiNormal3fVertex3fvSUN( rc, n, v ); } static void WINAPI wine_glReplacementCodeuiSUN( GLuint code ) { - void (*func_glReplacementCodeuiSUN)( GLuint ) = extension_funcs[EXT_glReplacementCodeuiSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", code ); - func_glReplacementCodeuiSUN( code ); + funcs->ext.p_glReplacementCodeuiSUN( code ); } static void WINAPI wine_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN( GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN)( GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", rc, s, t, r, g, b, a, nx, ny, nz, x, y, z ); - func_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN( rc, s, t, r, g, b, a, nx, ny, nz, x, y, z ); + funcs->ext.p_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN( rc, s, t, r, g, b, a, nx, ny, nz, x, y, z ); } static void WINAPI wine_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN( GLuint* rc, GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v ) { - void (*func_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN)( GLuint*, GLfloat*, GLfloat*, GLfloat*, GLfloat* ) = extension_funcs[EXT_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p, %p, %p, %p)\n", rc, tc, c, n, v ); - func_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN( rc, tc, c, n, v ); + funcs->ext.p_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN( rc, tc, c, n, v ); } static void WINAPI wine_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN( GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN)( GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f, %f, %f, %f, %f)\n", rc, s, t, nx, ny, nz, x, y, z ); - func_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN( rc, s, t, nx, ny, nz, x, y, z ); + funcs->ext.p_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN( rc, s, t, nx, ny, nz, x, y, z ); } static void WINAPI wine_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN( GLuint* rc, GLfloat* tc, GLfloat* n, GLfloat* v ) { - void (*func_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN)( GLuint*, GLfloat*, GLfloat*, GLfloat* ) = extension_funcs[EXT_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p, %p, %p)\n", rc, tc, n, v ); - func_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN( rc, tc, n, v ); + funcs->ext.p_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN( rc, tc, n, v ); } static void WINAPI wine_glReplacementCodeuiTexCoord2fVertex3fSUN( GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glReplacementCodeuiTexCoord2fVertex3fSUN)( GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glReplacementCodeuiTexCoord2fVertex3fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f, %f)\n", rc, s, t, x, y, z ); - func_glReplacementCodeuiTexCoord2fVertex3fSUN( rc, s, t, x, y, z ); + funcs->ext.p_glReplacementCodeuiTexCoord2fVertex3fSUN( rc, s, t, x, y, z ); } static void WINAPI wine_glReplacementCodeuiTexCoord2fVertex3fvSUN( GLuint* rc, GLfloat* tc, GLfloat* v ) { - void (*func_glReplacementCodeuiTexCoord2fVertex3fvSUN)( GLuint*, GLfloat*, GLfloat* ) = extension_funcs[EXT_glReplacementCodeuiTexCoord2fVertex3fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p, %p)\n", rc, tc, v ); - func_glReplacementCodeuiTexCoord2fVertex3fvSUN( rc, tc, v ); + funcs->ext.p_glReplacementCodeuiTexCoord2fVertex3fvSUN( rc, tc, v ); } static void WINAPI wine_glReplacementCodeuiVertex3fSUN( GLuint rc, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glReplacementCodeuiVertex3fSUN)( GLuint, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glReplacementCodeuiVertex3fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", rc, x, y, z ); - func_glReplacementCodeuiVertex3fSUN( rc, x, y, z ); + funcs->ext.p_glReplacementCodeuiVertex3fSUN( rc, x, y, z ); } static void WINAPI wine_glReplacementCodeuiVertex3fvSUN( GLuint* rc, GLfloat* v ) { - void (*func_glReplacementCodeuiVertex3fvSUN)( GLuint*, GLfloat* ) = extension_funcs[EXT_glReplacementCodeuiVertex3fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p)\n", rc, v ); - func_glReplacementCodeuiVertex3fvSUN( rc, v ); + funcs->ext.p_glReplacementCodeuiVertex3fvSUN( rc, v ); } static void WINAPI wine_glReplacementCodeuivSUN( GLuint* code ) { - void (*func_glReplacementCodeuivSUN)( GLuint* ) = extension_funcs[EXT_glReplacementCodeuivSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", code ); - func_glReplacementCodeuivSUN( code ); + funcs->ext.p_glReplacementCodeuivSUN( code ); } static void WINAPI wine_glReplacementCodeusSUN( GLushort code ) { - void (*func_glReplacementCodeusSUN)( GLushort ) = extension_funcs[EXT_glReplacementCodeusSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", code ); - func_glReplacementCodeusSUN( code ); + funcs->ext.p_glReplacementCodeusSUN( code ); } static void WINAPI wine_glReplacementCodeusvSUN( GLushort* code ) { - void (*func_glReplacementCodeusvSUN)( GLushort* ) = extension_funcs[EXT_glReplacementCodeusvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", code ); - func_glReplacementCodeusvSUN( code ); + funcs->ext.p_glReplacementCodeusvSUN( code ); } static void WINAPI wine_glRequestResidentProgramsNV( GLsizei n, GLuint* programs ) { - void (*func_glRequestResidentProgramsNV)( GLsizei, GLuint* ) = extension_funcs[EXT_glRequestResidentProgramsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", n, programs ); - func_glRequestResidentProgramsNV( n, programs ); + funcs->ext.p_glRequestResidentProgramsNV( n, programs ); } static void WINAPI wine_glResetHistogram( GLenum target ) { - void (*func_glResetHistogram)( GLenum ) = extension_funcs[EXT_glResetHistogram]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", target ); - func_glResetHistogram( target ); + funcs->ext.p_glResetHistogram( target ); } static void WINAPI wine_glResetHistogramEXT( GLenum target ) { - void (*func_glResetHistogramEXT)( GLenum ) = extension_funcs[EXT_glResetHistogramEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", target ); - func_glResetHistogramEXT( target ); + funcs->ext.p_glResetHistogramEXT( target ); } static void WINAPI wine_glResetMinmax( GLenum target ) { - void (*func_glResetMinmax)( GLenum ) = extension_funcs[EXT_glResetMinmax]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", target ); - func_glResetMinmax( target ); + funcs->ext.p_glResetMinmax( target ); } static void WINAPI wine_glResetMinmaxEXT( GLenum target ) { - void (*func_glResetMinmaxEXT)( GLenum ) = extension_funcs[EXT_glResetMinmaxEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", target ); - func_glResetMinmaxEXT( target ); + funcs->ext.p_glResetMinmaxEXT( target ); } static void WINAPI wine_glResizeBuffersMESA( void ) { - void (*func_glResizeBuffersMESA)( void ) = extension_funcs[EXT_glResizeBuffersMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glResizeBuffersMESA( ); + funcs->ext.p_glResizeBuffersMESA( ); } static void WINAPI wine_glResumeTransformFeedback( void ) { - void (*func_glResumeTransformFeedback)( void ) = extension_funcs[EXT_glResumeTransformFeedback]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glResumeTransformFeedback( ); + funcs->ext.p_glResumeTransformFeedback( ); } static void WINAPI wine_glResumeTransformFeedbackNV( void ) { - void (*func_glResumeTransformFeedbackNV)( void ) = extension_funcs[EXT_glResumeTransformFeedbackNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glResumeTransformFeedbackNV( ); + funcs->ext.p_glResumeTransformFeedbackNV( ); } static void WINAPI wine_glSampleCoverage( GLfloat value, GLboolean invert ) { - void (*func_glSampleCoverage)( GLfloat, GLboolean ) = extension_funcs[EXT_glSampleCoverage]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %d)\n", value, invert ); - func_glSampleCoverage( value, invert ); + funcs->ext.p_glSampleCoverage( value, invert ); } static void WINAPI wine_glSampleCoverageARB( GLfloat value, GLboolean invert ) { - void (*func_glSampleCoverageARB)( GLfloat, GLboolean ) = extension_funcs[EXT_glSampleCoverageARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %d)\n", value, invert ); - func_glSampleCoverageARB( value, invert ); + funcs->ext.p_glSampleCoverageARB( value, invert ); } static void WINAPI wine_glSampleMapATI( GLuint dst, GLuint interp, GLenum swizzle ) { - void (*func_glSampleMapATI)( GLuint, GLuint, GLenum ) = extension_funcs[EXT_glSampleMapATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", dst, interp, swizzle ); - func_glSampleMapATI( dst, interp, swizzle ); + funcs->ext.p_glSampleMapATI( dst, interp, swizzle ); } static void WINAPI wine_glSampleMaskEXT( GLclampf value, GLboolean invert ) { - void (*func_glSampleMaskEXT)( GLclampf, GLboolean ) = extension_funcs[EXT_glSampleMaskEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %d)\n", value, invert ); - func_glSampleMaskEXT( value, invert ); + funcs->ext.p_glSampleMaskEXT( value, invert ); } static void WINAPI wine_glSampleMaskIndexedNV( GLuint index, GLbitfield mask ) { - void (*func_glSampleMaskIndexedNV)( GLuint, GLbitfield ) = extension_funcs[EXT_glSampleMaskIndexedNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", index, mask ); - func_glSampleMaskIndexedNV( index, mask ); + funcs->ext.p_glSampleMaskIndexedNV( index, mask ); } static void WINAPI wine_glSampleMaskSGIS( GLclampf value, GLboolean invert ) { - void (*func_glSampleMaskSGIS)( GLclampf, GLboolean ) = extension_funcs[EXT_glSampleMaskSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %d)\n", value, invert ); - func_glSampleMaskSGIS( value, invert ); + funcs->ext.p_glSampleMaskSGIS( value, invert ); } static void WINAPI wine_glSampleMaski( GLuint index, GLbitfield mask ) { - void (*func_glSampleMaski)( GLuint, GLbitfield ) = extension_funcs[EXT_glSampleMaski]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", index, mask ); - func_glSampleMaski( index, mask ); + funcs->ext.p_glSampleMaski( index, mask ); } static void WINAPI wine_glSamplePatternEXT( GLenum pattern ) { - void (*func_glSamplePatternEXT)( GLenum ) = extension_funcs[EXT_glSamplePatternEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", pattern ); - func_glSamplePatternEXT( pattern ); + funcs->ext.p_glSamplePatternEXT( pattern ); } static void WINAPI wine_glSamplePatternSGIS( GLenum pattern ) { - void (*func_glSamplePatternSGIS)( GLenum ) = extension_funcs[EXT_glSamplePatternSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", pattern ); - func_glSamplePatternSGIS( pattern ); + funcs->ext.p_glSamplePatternSGIS( pattern ); } static void WINAPI wine_glSamplerParameterIiv( GLuint sampler, GLenum pname, GLint* param ) { - void (*func_glSamplerParameterIiv)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glSamplerParameterIiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", sampler, pname, param ); - func_glSamplerParameterIiv( sampler, pname, param ); + funcs->ext.p_glSamplerParameterIiv( sampler, pname, param ); } static void WINAPI wine_glSamplerParameterIuiv( GLuint sampler, GLenum pname, GLuint* param ) { - void (*func_glSamplerParameterIuiv)( GLuint, GLenum, GLuint* ) = extension_funcs[EXT_glSamplerParameterIuiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", sampler, pname, param ); - func_glSamplerParameterIuiv( sampler, pname, param ); + funcs->ext.p_glSamplerParameterIuiv( sampler, pname, param ); } static void WINAPI wine_glSamplerParameterf( GLuint sampler, GLenum pname, GLfloat param ) { - void (*func_glSamplerParameterf)( GLuint, GLenum, GLfloat ) = extension_funcs[EXT_glSamplerParameterf]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %f)\n", sampler, pname, param ); - func_glSamplerParameterf( sampler, pname, param ); + funcs->ext.p_glSamplerParameterf( sampler, pname, param ); } static void WINAPI wine_glSamplerParameterfv( GLuint sampler, GLenum pname, GLfloat* param ) { - void (*func_glSamplerParameterfv)( GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glSamplerParameterfv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", sampler, pname, param ); - func_glSamplerParameterfv( sampler, pname, param ); + funcs->ext.p_glSamplerParameterfv( sampler, pname, param ); } static void WINAPI wine_glSamplerParameteri( GLuint sampler, GLenum pname, GLint param ) { - void (*func_glSamplerParameteri)( GLuint, GLenum, GLint ) = extension_funcs[EXT_glSamplerParameteri]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", sampler, pname, param ); - func_glSamplerParameteri( sampler, pname, param ); + funcs->ext.p_glSamplerParameteri( sampler, pname, param ); } static void WINAPI wine_glSamplerParameteriv( GLuint sampler, GLenum pname, GLint* param ) { - void (*func_glSamplerParameteriv)( GLuint, GLenum, GLint* ) = extension_funcs[EXT_glSamplerParameteriv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", sampler, pname, param ); - func_glSamplerParameteriv( sampler, pname, param ); + funcs->ext.p_glSamplerParameteriv( sampler, pname, param ); } static void WINAPI wine_glScissorArrayv( GLuint first, GLsizei count, GLint* v ) { - void (*func_glScissorArrayv)( GLuint, GLsizei, GLint* ) = extension_funcs[EXT_glScissorArrayv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", first, count, v ); - func_glScissorArrayv( first, count, v ); + funcs->ext.p_glScissorArrayv( first, count, v ); } static void WINAPI wine_glScissorIndexed( GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height ) { - void (*func_glScissorIndexed)( GLuint, GLint, GLint, GLsizei, GLsizei ) = extension_funcs[EXT_glScissorIndexed]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", index, left, bottom, width, height ); - func_glScissorIndexed( index, left, bottom, width, height ); + funcs->ext.p_glScissorIndexed( index, left, bottom, width, height ); } static void WINAPI wine_glScissorIndexedv( GLuint index, GLint* v ) { - void (*func_glScissorIndexedv)( GLuint, GLint* ) = extension_funcs[EXT_glScissorIndexedv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glScissorIndexedv( index, v ); + funcs->ext.p_glScissorIndexedv( index, v ); } static void WINAPI wine_glSecondaryColor3b( GLbyte red, GLbyte green, GLbyte blue ) { - void (*func_glSecondaryColor3b)( GLbyte, GLbyte, GLbyte ) = extension_funcs[EXT_glSecondaryColor3b]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", red, green, blue ); - func_glSecondaryColor3b( red, green, blue ); + funcs->ext.p_glSecondaryColor3b( red, green, blue ); } static void WINAPI wine_glSecondaryColor3bEXT( GLbyte red, GLbyte green, GLbyte blue ) { - void (*func_glSecondaryColor3bEXT)( GLbyte, GLbyte, GLbyte ) = extension_funcs[EXT_glSecondaryColor3bEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", red, green, blue ); - func_glSecondaryColor3bEXT( red, green, blue ); + funcs->ext.p_glSecondaryColor3bEXT( red, green, blue ); } static void WINAPI wine_glSecondaryColor3bv( GLbyte* v ) { - void (*func_glSecondaryColor3bv)( GLbyte* ) = extension_funcs[EXT_glSecondaryColor3bv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glSecondaryColor3bv( v ); + funcs->ext.p_glSecondaryColor3bv( v ); } static void WINAPI wine_glSecondaryColor3bvEXT( GLbyte* v ) { - void (*func_glSecondaryColor3bvEXT)( GLbyte* ) = extension_funcs[EXT_glSecondaryColor3bvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glSecondaryColor3bvEXT( v ); + funcs->ext.p_glSecondaryColor3bvEXT( v ); } static void WINAPI wine_glSecondaryColor3d( GLdouble red, GLdouble green, GLdouble blue ) { - void (*func_glSecondaryColor3d)( GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glSecondaryColor3d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f)\n", red, green, blue ); - func_glSecondaryColor3d( red, green, blue ); + funcs->ext.p_glSecondaryColor3d( red, green, blue ); } static void WINAPI wine_glSecondaryColor3dEXT( GLdouble red, GLdouble green, GLdouble blue ) { - void (*func_glSecondaryColor3dEXT)( GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glSecondaryColor3dEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f)\n", red, green, blue ); - func_glSecondaryColor3dEXT( red, green, blue ); + funcs->ext.p_glSecondaryColor3dEXT( red, green, blue ); } static void WINAPI wine_glSecondaryColor3dv( GLdouble* v ) { - void (*func_glSecondaryColor3dv)( GLdouble* ) = extension_funcs[EXT_glSecondaryColor3dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glSecondaryColor3dv( v ); + funcs->ext.p_glSecondaryColor3dv( v ); } static void WINAPI wine_glSecondaryColor3dvEXT( GLdouble* v ) { - void (*func_glSecondaryColor3dvEXT)( GLdouble* ) = extension_funcs[EXT_glSecondaryColor3dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glSecondaryColor3dvEXT( v ); + funcs->ext.p_glSecondaryColor3dvEXT( v ); } static void WINAPI wine_glSecondaryColor3f( GLfloat red, GLfloat green, GLfloat blue ) { - void (*func_glSecondaryColor3f)( GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glSecondaryColor3f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f)\n", red, green, blue ); - func_glSecondaryColor3f( red, green, blue ); + funcs->ext.p_glSecondaryColor3f( red, green, blue ); } static void WINAPI wine_glSecondaryColor3fEXT( GLfloat red, GLfloat green, GLfloat blue ) { - void (*func_glSecondaryColor3fEXT)( GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glSecondaryColor3fEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f)\n", red, green, blue ); - func_glSecondaryColor3fEXT( red, green, blue ); + funcs->ext.p_glSecondaryColor3fEXT( red, green, blue ); } static void WINAPI wine_glSecondaryColor3fv( GLfloat* v ) { - void (*func_glSecondaryColor3fv)( GLfloat* ) = extension_funcs[EXT_glSecondaryColor3fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glSecondaryColor3fv( v ); + funcs->ext.p_glSecondaryColor3fv( v ); } static void WINAPI wine_glSecondaryColor3fvEXT( GLfloat* v ) { - void (*func_glSecondaryColor3fvEXT)( GLfloat* ) = extension_funcs[EXT_glSecondaryColor3fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glSecondaryColor3fvEXT( v ); + funcs->ext.p_glSecondaryColor3fvEXT( v ); } static void WINAPI wine_glSecondaryColor3hNV( unsigned short red, unsigned short green, unsigned short blue ) { - void (*func_glSecondaryColor3hNV)( unsigned short, unsigned short, unsigned short ) = extension_funcs[EXT_glSecondaryColor3hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", red, green, blue ); - func_glSecondaryColor3hNV( red, green, blue ); + funcs->ext.p_glSecondaryColor3hNV( red, green, blue ); } static void WINAPI wine_glSecondaryColor3hvNV( unsigned short* v ) { - void (*func_glSecondaryColor3hvNV)( unsigned short* ) = extension_funcs[EXT_glSecondaryColor3hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glSecondaryColor3hvNV( v ); + funcs->ext.p_glSecondaryColor3hvNV( v ); } static void WINAPI wine_glSecondaryColor3i( GLint red, GLint green, GLint blue ) { - void (*func_glSecondaryColor3i)( GLint, GLint, GLint ) = extension_funcs[EXT_glSecondaryColor3i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", red, green, blue ); - func_glSecondaryColor3i( red, green, blue ); + funcs->ext.p_glSecondaryColor3i( red, green, blue ); } static void WINAPI wine_glSecondaryColor3iEXT( GLint red, GLint green, GLint blue ) { - void (*func_glSecondaryColor3iEXT)( GLint, GLint, GLint ) = extension_funcs[EXT_glSecondaryColor3iEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", red, green, blue ); - func_glSecondaryColor3iEXT( red, green, blue ); + funcs->ext.p_glSecondaryColor3iEXT( red, green, blue ); } static void WINAPI wine_glSecondaryColor3iv( GLint* v ) { - void (*func_glSecondaryColor3iv)( GLint* ) = extension_funcs[EXT_glSecondaryColor3iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glSecondaryColor3iv( v ); + funcs->ext.p_glSecondaryColor3iv( v ); } static void WINAPI wine_glSecondaryColor3ivEXT( GLint* v ) { - void (*func_glSecondaryColor3ivEXT)( GLint* ) = extension_funcs[EXT_glSecondaryColor3ivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glSecondaryColor3ivEXT( v ); + funcs->ext.p_glSecondaryColor3ivEXT( v ); } static void WINAPI wine_glSecondaryColor3s( GLshort red, GLshort green, GLshort blue ) { - void (*func_glSecondaryColor3s)( GLshort, GLshort, GLshort ) = extension_funcs[EXT_glSecondaryColor3s]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", red, green, blue ); - func_glSecondaryColor3s( red, green, blue ); + funcs->ext.p_glSecondaryColor3s( red, green, blue ); } static void WINAPI wine_glSecondaryColor3sEXT( GLshort red, GLshort green, GLshort blue ) { - void (*func_glSecondaryColor3sEXT)( GLshort, GLshort, GLshort ) = extension_funcs[EXT_glSecondaryColor3sEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", red, green, blue ); - func_glSecondaryColor3sEXT( red, green, blue ); + funcs->ext.p_glSecondaryColor3sEXT( red, green, blue ); } static void WINAPI wine_glSecondaryColor3sv( GLshort* v ) { - void (*func_glSecondaryColor3sv)( GLshort* ) = extension_funcs[EXT_glSecondaryColor3sv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glSecondaryColor3sv( v ); + funcs->ext.p_glSecondaryColor3sv( v ); } static void WINAPI wine_glSecondaryColor3svEXT( GLshort* v ) { - void (*func_glSecondaryColor3svEXT)( GLshort* ) = extension_funcs[EXT_glSecondaryColor3svEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glSecondaryColor3svEXT( v ); + funcs->ext.p_glSecondaryColor3svEXT( v ); } static void WINAPI wine_glSecondaryColor3ub( GLubyte red, GLubyte green, GLubyte blue ) { - void (*func_glSecondaryColor3ub)( GLubyte, GLubyte, GLubyte ) = extension_funcs[EXT_glSecondaryColor3ub]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", red, green, blue ); - func_glSecondaryColor3ub( red, green, blue ); + funcs->ext.p_glSecondaryColor3ub( red, green, blue ); } static void WINAPI wine_glSecondaryColor3ubEXT( GLubyte red, GLubyte green, GLubyte blue ) { - void (*func_glSecondaryColor3ubEXT)( GLubyte, GLubyte, GLubyte ) = extension_funcs[EXT_glSecondaryColor3ubEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", red, green, blue ); - func_glSecondaryColor3ubEXT( red, green, blue ); + funcs->ext.p_glSecondaryColor3ubEXT( red, green, blue ); } static void WINAPI wine_glSecondaryColor3ubv( GLubyte* v ) { - void (*func_glSecondaryColor3ubv)( GLubyte* ) = extension_funcs[EXT_glSecondaryColor3ubv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glSecondaryColor3ubv( v ); + funcs->ext.p_glSecondaryColor3ubv( v ); } static void WINAPI wine_glSecondaryColor3ubvEXT( GLubyte* v ) { - void (*func_glSecondaryColor3ubvEXT)( GLubyte* ) = extension_funcs[EXT_glSecondaryColor3ubvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glSecondaryColor3ubvEXT( v ); + funcs->ext.p_glSecondaryColor3ubvEXT( v ); } static void WINAPI wine_glSecondaryColor3ui( GLuint red, GLuint green, GLuint blue ) { - void (*func_glSecondaryColor3ui)( GLuint, GLuint, GLuint ) = extension_funcs[EXT_glSecondaryColor3ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", red, green, blue ); - func_glSecondaryColor3ui( red, green, blue ); + funcs->ext.p_glSecondaryColor3ui( red, green, blue ); } static void WINAPI wine_glSecondaryColor3uiEXT( GLuint red, GLuint green, GLuint blue ) { - void (*func_glSecondaryColor3uiEXT)( GLuint, GLuint, GLuint ) = extension_funcs[EXT_glSecondaryColor3uiEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", red, green, blue ); - func_glSecondaryColor3uiEXT( red, green, blue ); + funcs->ext.p_glSecondaryColor3uiEXT( red, green, blue ); } static void WINAPI wine_glSecondaryColor3uiv( GLuint* v ) { - void (*func_glSecondaryColor3uiv)( GLuint* ) = extension_funcs[EXT_glSecondaryColor3uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glSecondaryColor3uiv( v ); + funcs->ext.p_glSecondaryColor3uiv( v ); } static void WINAPI wine_glSecondaryColor3uivEXT( GLuint* v ) { - void (*func_glSecondaryColor3uivEXT)( GLuint* ) = extension_funcs[EXT_glSecondaryColor3uivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glSecondaryColor3uivEXT( v ); + funcs->ext.p_glSecondaryColor3uivEXT( v ); } static void WINAPI wine_glSecondaryColor3us( GLushort red, GLushort green, GLushort blue ) { - void (*func_glSecondaryColor3us)( GLushort, GLushort, GLushort ) = extension_funcs[EXT_glSecondaryColor3us]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", red, green, blue ); - func_glSecondaryColor3us( red, green, blue ); + funcs->ext.p_glSecondaryColor3us( red, green, blue ); } static void WINAPI wine_glSecondaryColor3usEXT( GLushort red, GLushort green, GLushort blue ) { - void (*func_glSecondaryColor3usEXT)( GLushort, GLushort, GLushort ) = extension_funcs[EXT_glSecondaryColor3usEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", red, green, blue ); - func_glSecondaryColor3usEXT( red, green, blue ); + funcs->ext.p_glSecondaryColor3usEXT( red, green, blue ); } static void WINAPI wine_glSecondaryColor3usv( GLushort* v ) { - void (*func_glSecondaryColor3usv)( GLushort* ) = extension_funcs[EXT_glSecondaryColor3usv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glSecondaryColor3usv( v ); + funcs->ext.p_glSecondaryColor3usv( v ); } static void WINAPI wine_glSecondaryColor3usvEXT( GLushort* v ) { - void (*func_glSecondaryColor3usvEXT)( GLushort* ) = extension_funcs[EXT_glSecondaryColor3usvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glSecondaryColor3usvEXT( v ); + funcs->ext.p_glSecondaryColor3usvEXT( v ); } static void WINAPI wine_glSecondaryColorFormatNV( GLint size, GLenum type, GLsizei stride ) { - void (*func_glSecondaryColorFormatNV)( GLint, GLenum, GLsizei ) = extension_funcs[EXT_glSecondaryColorFormatNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", size, type, stride ); - func_glSecondaryColorFormatNV( size, type, stride ); + funcs->ext.p_glSecondaryColorFormatNV( size, type, stride ); } static void WINAPI wine_glSecondaryColorP3ui( GLenum type, GLuint color ) { - void (*func_glSecondaryColorP3ui)( GLenum, GLuint ) = extension_funcs[EXT_glSecondaryColorP3ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", type, color ); - func_glSecondaryColorP3ui( type, color ); + funcs->ext.p_glSecondaryColorP3ui( type, color ); } static void WINAPI wine_glSecondaryColorP3uiv( GLenum type, GLuint* color ) { - void (*func_glSecondaryColorP3uiv)( GLenum, GLuint* ) = extension_funcs[EXT_glSecondaryColorP3uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", type, color ); - func_glSecondaryColorP3uiv( type, color ); + funcs->ext.p_glSecondaryColorP3uiv( type, color ); } static void WINAPI wine_glSecondaryColorPointer( GLint size, GLenum type, GLsizei stride, GLvoid* pointer ) { - void (*func_glSecondaryColorPointer)( GLint, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glSecondaryColorPointer]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer ); - func_glSecondaryColorPointer( size, type, stride, pointer ); + funcs->ext.p_glSecondaryColorPointer( size, type, stride, pointer ); } static void WINAPI wine_glSecondaryColorPointerEXT( GLint size, GLenum type, GLsizei stride, GLvoid* pointer ) { - void (*func_glSecondaryColorPointerEXT)( GLint, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glSecondaryColorPointerEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer ); - func_glSecondaryColorPointerEXT( size, type, stride, pointer ); + funcs->ext.p_glSecondaryColorPointerEXT( size, type, stride, pointer ); } static void WINAPI wine_glSecondaryColorPointerListIBM( GLint size, GLenum type, GLint stride, GLvoid** pointer, GLint ptrstride ) { - void (*func_glSecondaryColorPointerListIBM)( GLint, GLenum, GLint, GLvoid**, GLint ) = extension_funcs[EXT_glSecondaryColorPointerListIBM]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %d)\n", size, type, stride, pointer, ptrstride ); - func_glSecondaryColorPointerListIBM( size, type, stride, pointer, ptrstride ); + funcs->ext.p_glSecondaryColorPointerListIBM( size, type, stride, pointer, ptrstride ); } static void WINAPI wine_glSelectPerfMonitorCountersAMD( GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint* counterList ) { - void (*func_glSelectPerfMonitorCountersAMD)( GLuint, GLboolean, GLuint, GLint, GLuint* ) = extension_funcs[EXT_glSelectPerfMonitorCountersAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", monitor, enable, group, numCounters, counterList ); - func_glSelectPerfMonitorCountersAMD( monitor, enable, group, numCounters, counterList ); + funcs->ext.p_glSelectPerfMonitorCountersAMD( monitor, enable, group, numCounters, counterList ); } static void WINAPI wine_glSelectTextureCoordSetSGIS( GLenum target ) { - void (*func_glSelectTextureCoordSetSGIS)( GLenum ) = extension_funcs[EXT_glSelectTextureCoordSetSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", target ); - func_glSelectTextureCoordSetSGIS( target ); + funcs->ext.p_glSelectTextureCoordSetSGIS( target ); } static void WINAPI wine_glSelectTextureSGIS( GLenum target ) { - void (*func_glSelectTextureSGIS)( GLenum ) = extension_funcs[EXT_glSelectTextureSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", target ); - func_glSelectTextureSGIS( target ); + funcs->ext.p_glSelectTextureSGIS( target ); } static void WINAPI wine_glSeparableFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* row, GLvoid* column ) { - void (*func_glSeparableFilter2D)( GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, GLvoid*, GLvoid* ) = extension_funcs[EXT_glSeparableFilter2D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %p, %p)\n", target, internalformat, width, height, format, type, row, column ); - func_glSeparableFilter2D( target, internalformat, width, height, format, type, row, column ); + funcs->ext.p_glSeparableFilter2D( target, internalformat, width, height, format, type, row, column ); } static void WINAPI wine_glSeparableFilter2DEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* row, GLvoid* column ) { - void (*func_glSeparableFilter2DEXT)( GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, GLvoid*, GLvoid* ) = extension_funcs[EXT_glSeparableFilter2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %p, %p)\n", target, internalformat, width, height, format, type, row, column ); - func_glSeparableFilter2DEXT( target, internalformat, width, height, format, type, row, column ); + funcs->ext.p_glSeparableFilter2DEXT( target, internalformat, width, height, format, type, row, column ); } static void WINAPI wine_glSetFenceAPPLE( GLuint fence ) { - void (*func_glSetFenceAPPLE)( GLuint ) = extension_funcs[EXT_glSetFenceAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", fence ); - func_glSetFenceAPPLE( fence ); + funcs->ext.p_glSetFenceAPPLE( fence ); } static void WINAPI wine_glSetFenceNV( GLuint fence, GLenum condition ) { - void (*func_glSetFenceNV)( GLuint, GLenum ) = extension_funcs[EXT_glSetFenceNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", fence, condition ); - func_glSetFenceNV( fence, condition ); + funcs->ext.p_glSetFenceNV( fence, condition ); } static void WINAPI wine_glSetFragmentShaderConstantATI( GLuint dst, GLfloat* value ) { - void (*func_glSetFragmentShaderConstantATI)( GLuint, GLfloat* ) = extension_funcs[EXT_glSetFragmentShaderConstantATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", dst, value ); - func_glSetFragmentShaderConstantATI( dst, value ); + funcs->ext.p_glSetFragmentShaderConstantATI( dst, value ); } static void WINAPI wine_glSetInvariantEXT( GLuint id, GLenum type, GLvoid* addr ) { - void (*func_glSetInvariantEXT)( GLuint, GLenum, GLvoid* ) = extension_funcs[EXT_glSetInvariantEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, type, addr ); - func_glSetInvariantEXT( id, type, addr ); + funcs->ext.p_glSetInvariantEXT( id, type, addr ); } static void WINAPI wine_glSetLocalConstantEXT( GLuint id, GLenum type, GLvoid* addr ) { - void (*func_glSetLocalConstantEXT)( GLuint, GLenum, GLvoid* ) = extension_funcs[EXT_glSetLocalConstantEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", id, type, addr ); - func_glSetLocalConstantEXT( id, type, addr ); + funcs->ext.p_glSetLocalConstantEXT( id, type, addr ); } static void WINAPI wine_glSetMultisamplefvAMD( GLenum pname, GLuint index, GLfloat* val ) { - void (*func_glSetMultisamplefvAMD)( GLenum, GLuint, GLfloat* ) = extension_funcs[EXT_glSetMultisamplefvAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", pname, index, val ); - func_glSetMultisamplefvAMD( pname, index, val ); + funcs->ext.p_glSetMultisamplefvAMD( pname, index, val ); } static void WINAPI wine_glShaderBinary( GLsizei count, GLuint* shaders, GLenum binaryformat, GLvoid* binary, GLsizei length ) { - void (*func_glShaderBinary)( GLsizei, GLuint*, GLenum, GLvoid*, GLsizei ) = extension_funcs[EXT_glShaderBinary]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %d, %p, %d)\n", count, shaders, binaryformat, binary, length ); - func_glShaderBinary( count, shaders, binaryformat, binary, length ); + funcs->ext.p_glShaderBinary( count, shaders, binaryformat, binary, length ); } static void WINAPI wine_glShaderOp1EXT( GLenum op, GLuint res, GLuint arg1 ) { - void (*func_glShaderOp1EXT)( GLenum, GLuint, GLuint ) = extension_funcs[EXT_glShaderOp1EXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", op, res, arg1 ); - func_glShaderOp1EXT( op, res, arg1 ); + funcs->ext.p_glShaderOp1EXT( op, res, arg1 ); } static void WINAPI wine_glShaderOp2EXT( GLenum op, GLuint res, GLuint arg1, GLuint arg2 ) { - void (*func_glShaderOp2EXT)( GLenum, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glShaderOp2EXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", op, res, arg1, arg2 ); - func_glShaderOp2EXT( op, res, arg1, arg2 ); + funcs->ext.p_glShaderOp2EXT( op, res, arg1, arg2 ); } static void WINAPI wine_glShaderOp3EXT( GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3 ) { - void (*func_glShaderOp3EXT)( GLenum, GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glShaderOp3EXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", op, res, arg1, arg2, arg3 ); - func_glShaderOp3EXT( op, res, arg1, arg2, arg3 ); + funcs->ext.p_glShaderOp3EXT( op, res, arg1, arg2, arg3 ); } static void WINAPI wine_glShaderSource( GLuint shader, GLsizei count, char* const* string, GLint* length ) { - void (*func_glShaderSource)( GLuint, GLsizei, char* const*, GLint* ) = extension_funcs[EXT_glShaderSource]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", shader, count, string, length ); - func_glShaderSource( shader, count, string, length ); + funcs->ext.p_glShaderSource( shader, count, string, length ); } static void WINAPI wine_glShaderSourceARB( unsigned int shaderObj, GLsizei count, char** string, GLint* length ) { - void (*func_glShaderSourceARB)( unsigned int, GLsizei, char**, GLint* ) = extension_funcs[EXT_glShaderSourceARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", shaderObj, count, string, length ); - func_glShaderSourceARB( shaderObj, count, string, length ); + funcs->ext.p_glShaderSourceARB( shaderObj, count, string, length ); } static void WINAPI wine_glSharpenTexFuncSGIS( GLenum target, GLsizei n, GLfloat* points ) { - void (*func_glSharpenTexFuncSGIS)( GLenum, GLsizei, GLfloat* ) = extension_funcs[EXT_glSharpenTexFuncSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, n, points ); - func_glSharpenTexFuncSGIS( target, n, points ); + funcs->ext.p_glSharpenTexFuncSGIS( target, n, points ); } static void WINAPI wine_glSpriteParameterfSGIX( GLenum pname, GLfloat param ) { - void (*func_glSpriteParameterfSGIX)( GLenum, GLfloat ) = extension_funcs[EXT_glSpriteParameterfSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", pname, param ); - func_glSpriteParameterfSGIX( pname, param ); + funcs->ext.p_glSpriteParameterfSGIX( pname, param ); } static void WINAPI wine_glSpriteParameterfvSGIX( GLenum pname, GLfloat* params ) { - void (*func_glSpriteParameterfvSGIX)( GLenum, GLfloat* ) = extension_funcs[EXT_glSpriteParameterfvSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glSpriteParameterfvSGIX( pname, params ); + funcs->ext.p_glSpriteParameterfvSGIX( pname, params ); } static void WINAPI wine_glSpriteParameteriSGIX( GLenum pname, GLint param ) { - void (*func_glSpriteParameteriSGIX)( GLenum, GLint ) = extension_funcs[EXT_glSpriteParameteriSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", pname, param ); - func_glSpriteParameteriSGIX( pname, param ); + funcs->ext.p_glSpriteParameteriSGIX( pname, param ); } static void WINAPI wine_glSpriteParameterivSGIX( GLenum pname, GLint* params ) { - void (*func_glSpriteParameterivSGIX)( GLenum, GLint* ) = extension_funcs[EXT_glSpriteParameterivSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, params ); - func_glSpriteParameterivSGIX( pname, params ); + funcs->ext.p_glSpriteParameterivSGIX( pname, params ); } static void WINAPI wine_glStartInstrumentsSGIX( void ) { - void (*func_glStartInstrumentsSGIX)( void ) = extension_funcs[EXT_glStartInstrumentsSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glStartInstrumentsSGIX( ); + funcs->ext.p_glStartInstrumentsSGIX( ); } static void WINAPI wine_glStencilClearTagEXT( GLsizei stencilTagBits, GLuint stencilClearTag ) { - void (*func_glStencilClearTagEXT)( GLsizei, GLuint ) = extension_funcs[EXT_glStencilClearTagEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", stencilTagBits, stencilClearTag ); - func_glStencilClearTagEXT( stencilTagBits, stencilClearTag ); + funcs->ext.p_glStencilClearTagEXT( stencilTagBits, stencilClearTag ); } static void WINAPI wine_glStencilFillPathInstancedNV( GLsizei numPaths, GLenum pathNameType, GLvoid* paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum transformType, GLfloat* transformValues ) { - void (*func_glStencilFillPathInstancedNV)( GLsizei, GLenum, GLvoid*, GLuint, GLenum, GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glStencilFillPathInstancedNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %d, %d, %d, %d, %p)\n", numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues ); - func_glStencilFillPathInstancedNV( numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues ); + funcs->ext.p_glStencilFillPathInstancedNV( numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues ); } static void WINAPI wine_glStencilFillPathNV( GLuint path, GLenum fillMode, GLuint mask ) { - void (*func_glStencilFillPathNV)( GLuint, GLenum, GLuint ) = extension_funcs[EXT_glStencilFillPathNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", path, fillMode, mask ); - func_glStencilFillPathNV( path, fillMode, mask ); + funcs->ext.p_glStencilFillPathNV( path, fillMode, mask ); } static void WINAPI wine_glStencilFuncSeparate( GLenum face, GLenum func, GLint ref, GLuint mask ) { - void (*func_glStencilFuncSeparate)( GLenum, GLenum, GLint, GLuint ) = extension_funcs[EXT_glStencilFuncSeparate]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", face, func, ref, mask ); - func_glStencilFuncSeparate( face, func, ref, mask ); + funcs->ext.p_glStencilFuncSeparate( face, func, ref, mask ); } static void WINAPI wine_glStencilFuncSeparateATI( GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask ) { - void (*func_glStencilFuncSeparateATI)( GLenum, GLenum, GLint, GLuint ) = extension_funcs[EXT_glStencilFuncSeparateATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", frontfunc, backfunc, ref, mask ); - func_glStencilFuncSeparateATI( frontfunc, backfunc, ref, mask ); + funcs->ext.p_glStencilFuncSeparateATI( frontfunc, backfunc, ref, mask ); } static void WINAPI wine_glStencilMaskSeparate( GLenum face, GLuint mask ) { - void (*func_glStencilMaskSeparate)( GLenum, GLuint ) = extension_funcs[EXT_glStencilMaskSeparate]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", face, mask ); - func_glStencilMaskSeparate( face, mask ); + funcs->ext.p_glStencilMaskSeparate( face, mask ); } static void WINAPI wine_glStencilOpSeparate( GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass ) { - void (*func_glStencilOpSeparate)( GLenum, GLenum, GLenum, GLenum ) = extension_funcs[EXT_glStencilOpSeparate]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", face, sfail, dpfail, dppass ); - func_glStencilOpSeparate( face, sfail, dpfail, dppass ); + funcs->ext.p_glStencilOpSeparate( face, sfail, dpfail, dppass ); } static void WINAPI wine_glStencilOpSeparateATI( GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass ) { - void (*func_glStencilOpSeparateATI)( GLenum, GLenum, GLenum, GLenum ) = extension_funcs[EXT_glStencilOpSeparateATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", face, sfail, dpfail, dppass ); - func_glStencilOpSeparateATI( face, sfail, dpfail, dppass ); + funcs->ext.p_glStencilOpSeparateATI( face, sfail, dpfail, dppass ); } static void WINAPI wine_glStencilOpValueAMD( GLenum face, GLuint value ) { - void (*func_glStencilOpValueAMD)( GLenum, GLuint ) = extension_funcs[EXT_glStencilOpValueAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", face, value ); - func_glStencilOpValueAMD( face, value ); + funcs->ext.p_glStencilOpValueAMD( face, value ); } static void WINAPI wine_glStencilStrokePathInstancedNV( GLsizei numPaths, GLenum pathNameType, GLvoid* paths, GLuint pathBase, GLint reference, GLuint mask, GLenum transformType, GLfloat* transformValues ) { - void (*func_glStencilStrokePathInstancedNV)( GLsizei, GLenum, GLvoid*, GLuint, GLint, GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glStencilStrokePathInstancedNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %d, %d, %d, %d, %p)\n", numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues ); - func_glStencilStrokePathInstancedNV( numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues ); + funcs->ext.p_glStencilStrokePathInstancedNV( numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues ); } static void WINAPI wine_glStencilStrokePathNV( GLuint path, GLint reference, GLuint mask ) { - void (*func_glStencilStrokePathNV)( GLuint, GLint, GLuint ) = extension_funcs[EXT_glStencilStrokePathNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", path, reference, mask ); - func_glStencilStrokePathNV( path, reference, mask ); + funcs->ext.p_glStencilStrokePathNV( path, reference, mask ); } static void WINAPI wine_glStopInstrumentsSGIX( GLint marker ) { - void (*func_glStopInstrumentsSGIX)( GLint ) = extension_funcs[EXT_glStopInstrumentsSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", marker ); - func_glStopInstrumentsSGIX( marker ); + funcs->ext.p_glStopInstrumentsSGIX( marker ); } static void WINAPI wine_glStringMarkerGREMEDY( GLsizei len, GLvoid* string ) { - void (*func_glStringMarkerGREMEDY)( GLsizei, GLvoid* ) = extension_funcs[EXT_glStringMarkerGREMEDY]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", len, string ); - func_glStringMarkerGREMEDY( len, string ); + funcs->ext.p_glStringMarkerGREMEDY( len, string ); } static void WINAPI wine_glSwizzleEXT( GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW ) { - void (*func_glSwizzleEXT)( GLuint, GLuint, GLenum, GLenum, GLenum, GLenum ) = extension_funcs[EXT_glSwizzleEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", res, in, outX, outY, outZ, outW ); - func_glSwizzleEXT( res, in, outX, outY, outZ, outW ); + funcs->ext.p_glSwizzleEXT( res, in, outX, outY, outZ, outW ); } static void WINAPI wine_glTagSampleBufferSGIX( void ) { - void (*func_glTagSampleBufferSGIX)( void ) = extension_funcs[EXT_glTagSampleBufferSGIX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glTagSampleBufferSGIX( ); + funcs->ext.p_glTagSampleBufferSGIX( ); } static void WINAPI wine_glTangent3bEXT( GLbyte tx, GLbyte ty, GLbyte tz ) { - void (*func_glTangent3bEXT)( GLbyte, GLbyte, GLbyte ) = extension_funcs[EXT_glTangent3bEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", tx, ty, tz ); - func_glTangent3bEXT( tx, ty, tz ); + funcs->ext.p_glTangent3bEXT( tx, ty, tz ); } static void WINAPI wine_glTangent3bvEXT( GLbyte* v ) { - void (*func_glTangent3bvEXT)( GLbyte* ) = extension_funcs[EXT_glTangent3bvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glTangent3bvEXT( v ); + funcs->ext.p_glTangent3bvEXT( v ); } static void WINAPI wine_glTangent3dEXT( GLdouble tx, GLdouble ty, GLdouble tz ) { - void (*func_glTangent3dEXT)( GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glTangent3dEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f)\n", tx, ty, tz ); - func_glTangent3dEXT( tx, ty, tz ); + funcs->ext.p_glTangent3dEXT( tx, ty, tz ); } static void WINAPI wine_glTangent3dvEXT( GLdouble* v ) { - void (*func_glTangent3dvEXT)( GLdouble* ) = extension_funcs[EXT_glTangent3dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glTangent3dvEXT( v ); + funcs->ext.p_glTangent3dvEXT( v ); } static void WINAPI wine_glTangent3fEXT( GLfloat tx, GLfloat ty, GLfloat tz ) { - void (*func_glTangent3fEXT)( GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glTangent3fEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f)\n", tx, ty, tz ); - func_glTangent3fEXT( tx, ty, tz ); + funcs->ext.p_glTangent3fEXT( tx, ty, tz ); } static void WINAPI wine_glTangent3fvEXT( GLfloat* v ) { - void (*func_glTangent3fvEXT)( GLfloat* ) = extension_funcs[EXT_glTangent3fvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glTangent3fvEXT( v ); + funcs->ext.p_glTangent3fvEXT( v ); } static void WINAPI wine_glTangent3iEXT( GLint tx, GLint ty, GLint tz ) { - void (*func_glTangent3iEXT)( GLint, GLint, GLint ) = extension_funcs[EXT_glTangent3iEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", tx, ty, tz ); - func_glTangent3iEXT( tx, ty, tz ); + funcs->ext.p_glTangent3iEXT( tx, ty, tz ); } static void WINAPI wine_glTangent3ivEXT( GLint* v ) { - void (*func_glTangent3ivEXT)( GLint* ) = extension_funcs[EXT_glTangent3ivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glTangent3ivEXT( v ); + funcs->ext.p_glTangent3ivEXT( v ); } static void WINAPI wine_glTangent3sEXT( GLshort tx, GLshort ty, GLshort tz ) { - void (*func_glTangent3sEXT)( GLshort, GLshort, GLshort ) = extension_funcs[EXT_glTangent3sEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", tx, ty, tz ); - func_glTangent3sEXT( tx, ty, tz ); + funcs->ext.p_glTangent3sEXT( tx, ty, tz ); } static void WINAPI wine_glTangent3svEXT( GLshort* v ) { - void (*func_glTangent3svEXT)( GLshort* ) = extension_funcs[EXT_glTangent3svEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glTangent3svEXT( v ); + funcs->ext.p_glTangent3svEXT( v ); } static void WINAPI wine_glTangentPointerEXT( GLenum type, GLsizei stride, GLvoid* pointer ) { - void (*func_glTangentPointerEXT)( GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glTangentPointerEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", type, stride, pointer ); - func_glTangentPointerEXT( type, stride, pointer ); + funcs->ext.p_glTangentPointerEXT( type, stride, pointer ); } static void WINAPI wine_glTbufferMask3DFX( GLuint mask ) { - void (*func_glTbufferMask3DFX)( GLuint ) = extension_funcs[EXT_glTbufferMask3DFX]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", mask ); - func_glTbufferMask3DFX( mask ); + funcs->ext.p_glTbufferMask3DFX( mask ); } static void WINAPI wine_glTessellationFactorAMD( GLfloat factor ) { - void (*func_glTessellationFactorAMD)( GLfloat ) = extension_funcs[EXT_glTessellationFactorAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f)\n", factor ); - func_glTessellationFactorAMD( factor ); + funcs->ext.p_glTessellationFactorAMD( factor ); } static void WINAPI wine_glTessellationModeAMD( GLenum mode ) { - void (*func_glTessellationModeAMD)( GLenum ) = extension_funcs[EXT_glTessellationModeAMD]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", mode ); - func_glTessellationModeAMD( mode ); + funcs->ext.p_glTessellationModeAMD( mode ); } static GLboolean WINAPI wine_glTestFenceAPPLE( GLuint fence ) { - GLboolean (*func_glTestFenceAPPLE)( GLuint ) = extension_funcs[EXT_glTestFenceAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", fence ); - return func_glTestFenceAPPLE( fence ); + return funcs->ext.p_glTestFenceAPPLE( fence ); } static GLboolean WINAPI wine_glTestFenceNV( GLuint fence ) { - GLboolean (*func_glTestFenceNV)( GLuint ) = extension_funcs[EXT_glTestFenceNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", fence ); - return func_glTestFenceNV( fence ); + return funcs->ext.p_glTestFenceNV( fence ); } static GLboolean WINAPI wine_glTestObjectAPPLE( GLenum object, GLuint name ) { - GLboolean (*func_glTestObjectAPPLE)( GLenum, GLuint ) = extension_funcs[EXT_glTestObjectAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", object, name ); - return func_glTestObjectAPPLE( object, name ); + return funcs->ext.p_glTestObjectAPPLE( object, name ); } static void WINAPI wine_glTexBuffer( GLenum target, GLenum internalformat, GLuint buffer ) { - void (*func_glTexBuffer)( GLenum, GLenum, GLuint ) = extension_funcs[EXT_glTexBuffer]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, internalformat, buffer ); - func_glTexBuffer( target, internalformat, buffer ); + funcs->ext.p_glTexBuffer( target, internalformat, buffer ); } static void WINAPI wine_glTexBufferARB( GLenum target, GLenum internalformat, GLuint buffer ) { - void (*func_glTexBufferARB)( GLenum, GLenum, GLuint ) = extension_funcs[EXT_glTexBufferARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, internalformat, buffer ); - func_glTexBufferARB( target, internalformat, buffer ); + funcs->ext.p_glTexBufferARB( target, internalformat, buffer ); } static void WINAPI wine_glTexBufferEXT( GLenum target, GLenum internalformat, GLuint buffer ) { - void (*func_glTexBufferEXT)( GLenum, GLenum, GLuint ) = extension_funcs[EXT_glTexBufferEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", target, internalformat, buffer ); - func_glTexBufferEXT( target, internalformat, buffer ); + funcs->ext.p_glTexBufferEXT( target, internalformat, buffer ); } static void WINAPI wine_glTexBumpParameterfvATI( GLenum pname, GLfloat* param ) { - void (*func_glTexBumpParameterfvATI)( GLenum, GLfloat* ) = extension_funcs[EXT_glTexBumpParameterfvATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, param ); - func_glTexBumpParameterfvATI( pname, param ); + funcs->ext.p_glTexBumpParameterfvATI( pname, param ); } static void WINAPI wine_glTexBumpParameterivATI( GLenum pname, GLint* param ) { - void (*func_glTexBumpParameterivATI)( GLenum, GLint* ) = extension_funcs[EXT_glTexBumpParameterivATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", pname, param ); - func_glTexBumpParameterivATI( pname, param ); + funcs->ext.p_glTexBumpParameterivATI( pname, param ); } static void WINAPI wine_glTexCoord1hNV( unsigned short s ) { - void (*func_glTexCoord1hNV)( unsigned short ) = extension_funcs[EXT_glTexCoord1hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", s ); - func_glTexCoord1hNV( s ); + funcs->ext.p_glTexCoord1hNV( s ); } static void WINAPI wine_glTexCoord1hvNV( unsigned short* v ) { - void (*func_glTexCoord1hvNV)( unsigned short* ) = extension_funcs[EXT_glTexCoord1hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glTexCoord1hvNV( v ); + funcs->ext.p_glTexCoord1hvNV( v ); } static void WINAPI wine_glTexCoord2fColor3fVertex3fSUN( GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glTexCoord2fColor3fVertex3fSUN)( GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glTexCoord2fColor3fVertex3fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, r, g, b, x, y, z ); - func_glTexCoord2fColor3fVertex3fSUN( s, t, r, g, b, x, y, z ); + funcs->ext.p_glTexCoord2fColor3fVertex3fSUN( s, t, r, g, b, x, y, z ); } static void WINAPI wine_glTexCoord2fColor3fVertex3fvSUN( GLfloat* tc, GLfloat* c, GLfloat* v ) { - void (*func_glTexCoord2fColor3fVertex3fvSUN)( GLfloat*, GLfloat*, GLfloat* ) = extension_funcs[EXT_glTexCoord2fColor3fVertex3fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p, %p)\n", tc, c, v ); - func_glTexCoord2fColor3fVertex3fvSUN( tc, c, v ); + funcs->ext.p_glTexCoord2fColor3fVertex3fvSUN( tc, c, v ); } static void WINAPI wine_glTexCoord2fColor4fNormal3fVertex3fSUN( GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glTexCoord2fColor4fNormal3fVertex3fSUN)( GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glTexCoord2fColor4fNormal3fVertex3fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, r, g, b, a, nx, ny, nz, x, y, z ); - func_glTexCoord2fColor4fNormal3fVertex3fSUN( s, t, r, g, b, a, nx, ny, nz, x, y, z ); + funcs->ext.p_glTexCoord2fColor4fNormal3fVertex3fSUN( s, t, r, g, b, a, nx, ny, nz, x, y, z ); } static void WINAPI wine_glTexCoord2fColor4fNormal3fVertex3fvSUN( GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v ) { - void (*func_glTexCoord2fColor4fNormal3fVertex3fvSUN)( GLfloat*, GLfloat*, GLfloat*, GLfloat* ) = extension_funcs[EXT_glTexCoord2fColor4fNormal3fVertex3fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p, %p, %p)\n", tc, c, n, v ); - func_glTexCoord2fColor4fNormal3fVertex3fvSUN( tc, c, n, v ); + funcs->ext.p_glTexCoord2fColor4fNormal3fVertex3fvSUN( tc, c, n, v ); } static void WINAPI wine_glTexCoord2fColor4ubVertex3fSUN( GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glTexCoord2fColor4ubVertex3fSUN)( GLfloat, GLfloat, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glTexCoord2fColor4ubVertex3fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %d, %d, %d, %d, %f, %f, %f)\n", s, t, r, g, b, a, x, y, z ); - func_glTexCoord2fColor4ubVertex3fSUN( s, t, r, g, b, a, x, y, z ); + funcs->ext.p_glTexCoord2fColor4ubVertex3fSUN( s, t, r, g, b, a, x, y, z ); } static void WINAPI wine_glTexCoord2fColor4ubVertex3fvSUN( GLfloat* tc, GLubyte* c, GLfloat* v ) { - void (*func_glTexCoord2fColor4ubVertex3fvSUN)( GLfloat*, GLubyte*, GLfloat* ) = extension_funcs[EXT_glTexCoord2fColor4ubVertex3fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p, %p)\n", tc, c, v ); - func_glTexCoord2fColor4ubVertex3fvSUN( tc, c, v ); + funcs->ext.p_glTexCoord2fColor4ubVertex3fvSUN( tc, c, v ); } static void WINAPI wine_glTexCoord2fNormal3fVertex3fSUN( GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glTexCoord2fNormal3fVertex3fSUN)( GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glTexCoord2fNormal3fVertex3fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, nx, ny, nz, x, y, z ); - func_glTexCoord2fNormal3fVertex3fSUN( s, t, nx, ny, nz, x, y, z ); + funcs->ext.p_glTexCoord2fNormal3fVertex3fSUN( s, t, nx, ny, nz, x, y, z ); } static void WINAPI wine_glTexCoord2fNormal3fVertex3fvSUN( GLfloat* tc, GLfloat* n, GLfloat* v ) { - void (*func_glTexCoord2fNormal3fVertex3fvSUN)( GLfloat*, GLfloat*, GLfloat* ) = extension_funcs[EXT_glTexCoord2fNormal3fVertex3fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p, %p)\n", tc, n, v ); - func_glTexCoord2fNormal3fVertex3fvSUN( tc, n, v ); + funcs->ext.p_glTexCoord2fNormal3fVertex3fvSUN( tc, n, v ); } static void WINAPI wine_glTexCoord2fVertex3fSUN( GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glTexCoord2fVertex3fSUN)( GLfloat, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glTexCoord2fVertex3fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f, %f, %f)\n", s, t, x, y, z ); - func_glTexCoord2fVertex3fSUN( s, t, x, y, z ); + funcs->ext.p_glTexCoord2fVertex3fSUN( s, t, x, y, z ); } static void WINAPI wine_glTexCoord2fVertex3fvSUN( GLfloat* tc, GLfloat* v ) { - void (*func_glTexCoord2fVertex3fvSUN)( GLfloat*, GLfloat* ) = extension_funcs[EXT_glTexCoord2fVertex3fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p)\n", tc, v ); - func_glTexCoord2fVertex3fvSUN( tc, v ); + funcs->ext.p_glTexCoord2fVertex3fvSUN( tc, v ); } static void WINAPI wine_glTexCoord2hNV( unsigned short s, unsigned short t ) { - void (*func_glTexCoord2hNV)( unsigned short, unsigned short ) = extension_funcs[EXT_glTexCoord2hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", s, t ); - func_glTexCoord2hNV( s, t ); + funcs->ext.p_glTexCoord2hNV( s, t ); } static void WINAPI wine_glTexCoord2hvNV( unsigned short* v ) { - void (*func_glTexCoord2hvNV)( unsigned short* ) = extension_funcs[EXT_glTexCoord2hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glTexCoord2hvNV( v ); + funcs->ext.p_glTexCoord2hvNV( v ); } static void WINAPI wine_glTexCoord3hNV( unsigned short s, unsigned short t, unsigned short r ) { - void (*func_glTexCoord3hNV)( unsigned short, unsigned short, unsigned short ) = extension_funcs[EXT_glTexCoord3hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", s, t, r ); - func_glTexCoord3hNV( s, t, r ); + funcs->ext.p_glTexCoord3hNV( s, t, r ); } static void WINAPI wine_glTexCoord3hvNV( unsigned short* v ) { - void (*func_glTexCoord3hvNV)( unsigned short* ) = extension_funcs[EXT_glTexCoord3hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glTexCoord3hvNV( v ); + funcs->ext.p_glTexCoord3hvNV( v ); } static void WINAPI wine_glTexCoord4fColor4fNormal3fVertex4fSUN( GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { - void (*func_glTexCoord4fColor4fNormal3fVertex4fSUN)( GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glTexCoord4fColor4fNormal3fVertex4fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w ); - func_glTexCoord4fColor4fNormal3fVertex4fSUN( s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w ); + funcs->ext.p_glTexCoord4fColor4fNormal3fVertex4fSUN( s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w ); } static void WINAPI wine_glTexCoord4fColor4fNormal3fVertex4fvSUN( GLfloat* tc, GLfloat* c, GLfloat* n, GLfloat* v ) { - void (*func_glTexCoord4fColor4fNormal3fVertex4fvSUN)( GLfloat*, GLfloat*, GLfloat*, GLfloat* ) = extension_funcs[EXT_glTexCoord4fColor4fNormal3fVertex4fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p, %p, %p)\n", tc, c, n, v ); - func_glTexCoord4fColor4fNormal3fVertex4fvSUN( tc, c, n, v ); + funcs->ext.p_glTexCoord4fColor4fNormal3fVertex4fvSUN( tc, c, n, v ); } static void WINAPI wine_glTexCoord4fVertex4fSUN( GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { - void (*func_glTexCoord4fVertex4fSUN)( GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glTexCoord4fVertex4fSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, p, q, x, y, z, w ); - func_glTexCoord4fVertex4fSUN( s, t, p, q, x, y, z, w ); + funcs->ext.p_glTexCoord4fVertex4fSUN( s, t, p, q, x, y, z, w ); } static void WINAPI wine_glTexCoord4fVertex4fvSUN( GLfloat* tc, GLfloat* v ) { - void (*func_glTexCoord4fVertex4fvSUN)( GLfloat*, GLfloat* ) = extension_funcs[EXT_glTexCoord4fVertex4fvSUN]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p)\n", tc, v ); - func_glTexCoord4fVertex4fvSUN( tc, v ); + funcs->ext.p_glTexCoord4fVertex4fvSUN( tc, v ); } static void WINAPI wine_glTexCoord4hNV( unsigned short s, unsigned short t, unsigned short r, unsigned short q ) { - void (*func_glTexCoord4hNV)( unsigned short, unsigned short, unsigned short, unsigned short ) = extension_funcs[EXT_glTexCoord4hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", s, t, r, q ); - func_glTexCoord4hNV( s, t, r, q ); + funcs->ext.p_glTexCoord4hNV( s, t, r, q ); } static void WINAPI wine_glTexCoord4hvNV( unsigned short* v ) { - void (*func_glTexCoord4hvNV)( unsigned short* ) = extension_funcs[EXT_glTexCoord4hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glTexCoord4hvNV( v ); + funcs->ext.p_glTexCoord4hvNV( v ); } static void WINAPI wine_glTexCoordFormatNV( GLint size, GLenum type, GLsizei stride ) { - void (*func_glTexCoordFormatNV)( GLint, GLenum, GLsizei ) = extension_funcs[EXT_glTexCoordFormatNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", size, type, stride ); - func_glTexCoordFormatNV( size, type, stride ); + funcs->ext.p_glTexCoordFormatNV( size, type, stride ); } static void WINAPI wine_glTexCoordP1ui( GLenum type, GLuint coords ) { - void (*func_glTexCoordP1ui)( GLenum, GLuint ) = extension_funcs[EXT_glTexCoordP1ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", type, coords ); - func_glTexCoordP1ui( type, coords ); + funcs->ext.p_glTexCoordP1ui( type, coords ); } static void WINAPI wine_glTexCoordP1uiv( GLenum type, GLuint* coords ) { - void (*func_glTexCoordP1uiv)( GLenum, GLuint* ) = extension_funcs[EXT_glTexCoordP1uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", type, coords ); - func_glTexCoordP1uiv( type, coords ); + funcs->ext.p_glTexCoordP1uiv( type, coords ); } static void WINAPI wine_glTexCoordP2ui( GLenum type, GLuint coords ) { - void (*func_glTexCoordP2ui)( GLenum, GLuint ) = extension_funcs[EXT_glTexCoordP2ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", type, coords ); - func_glTexCoordP2ui( type, coords ); + funcs->ext.p_glTexCoordP2ui( type, coords ); } static void WINAPI wine_glTexCoordP2uiv( GLenum type, GLuint* coords ) { - void (*func_glTexCoordP2uiv)( GLenum, GLuint* ) = extension_funcs[EXT_glTexCoordP2uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", type, coords ); - func_glTexCoordP2uiv( type, coords ); + funcs->ext.p_glTexCoordP2uiv( type, coords ); } static void WINAPI wine_glTexCoordP3ui( GLenum type, GLuint coords ) { - void (*func_glTexCoordP3ui)( GLenum, GLuint ) = extension_funcs[EXT_glTexCoordP3ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", type, coords ); - func_glTexCoordP3ui( type, coords ); + funcs->ext.p_glTexCoordP3ui( type, coords ); } static void WINAPI wine_glTexCoordP3uiv( GLenum type, GLuint* coords ) { - void (*func_glTexCoordP3uiv)( GLenum, GLuint* ) = extension_funcs[EXT_glTexCoordP3uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", type, coords ); - func_glTexCoordP3uiv( type, coords ); + funcs->ext.p_glTexCoordP3uiv( type, coords ); } static void WINAPI wine_glTexCoordP4ui( GLenum type, GLuint coords ) { - void (*func_glTexCoordP4ui)( GLenum, GLuint ) = extension_funcs[EXT_glTexCoordP4ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", type, coords ); - func_glTexCoordP4ui( type, coords ); + funcs->ext.p_glTexCoordP4ui( type, coords ); } static void WINAPI wine_glTexCoordP4uiv( GLenum type, GLuint* coords ) { - void (*func_glTexCoordP4uiv)( GLenum, GLuint* ) = extension_funcs[EXT_glTexCoordP4uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", type, coords ); - func_glTexCoordP4uiv( type, coords ); + funcs->ext.p_glTexCoordP4uiv( type, coords ); } static void WINAPI wine_glTexCoordPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, GLvoid* pointer ) { - void (*func_glTexCoordPointerEXT)( GLint, GLenum, GLsizei, GLsizei, GLvoid* ) = extension_funcs[EXT_glTexCoordPointerEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", size, type, stride, count, pointer ); - func_glTexCoordPointerEXT( size, type, stride, count, pointer ); + funcs->ext.p_glTexCoordPointerEXT( size, type, stride, count, pointer ); } static void WINAPI wine_glTexCoordPointerListIBM( GLint size, GLenum type, GLint stride, GLvoid** pointer, GLint ptrstride ) { - void (*func_glTexCoordPointerListIBM)( GLint, GLenum, GLint, GLvoid**, GLint ) = extension_funcs[EXT_glTexCoordPointerListIBM]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %d)\n", size, type, stride, pointer, ptrstride ); - func_glTexCoordPointerListIBM( size, type, stride, pointer, ptrstride ); + funcs->ext.p_glTexCoordPointerListIBM( size, type, stride, pointer, ptrstride ); } static void WINAPI wine_glTexCoordPointervINTEL( GLint size, GLenum type, GLvoid** pointer ) { - void (*func_glTexCoordPointervINTEL)( GLint, GLenum, GLvoid** ) = extension_funcs[EXT_glTexCoordPointervINTEL]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", size, type, pointer ); - func_glTexCoordPointervINTEL( size, type, pointer ); + funcs->ext.p_glTexCoordPointervINTEL( size, type, pointer ); } static void WINAPI wine_glTexFilterFuncSGIS( GLenum target, GLenum filter, GLsizei n, GLfloat* weights ) { - void (*func_glTexFilterFuncSGIS)( GLenum, GLenum, GLsizei, GLfloat* ) = extension_funcs[EXT_glTexFilterFuncSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", target, filter, n, weights ); - func_glTexFilterFuncSGIS( target, filter, n, weights ); + funcs->ext.p_glTexFilterFuncSGIS( target, filter, n, weights ); } static void WINAPI wine_glTexImage2DMultisample( GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations ) { - void (*func_glTexImage2DMultisample)( GLenum, GLsizei, GLint, GLsizei, GLsizei, GLboolean ) = extension_funcs[EXT_glTexImage2DMultisample]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", target, samples, internalformat, width, height, fixedsamplelocations ); - func_glTexImage2DMultisample( target, samples, internalformat, width, height, fixedsamplelocations ); + funcs->ext.p_glTexImage2DMultisample( target, samples, internalformat, width, height, fixedsamplelocations ); } static void WINAPI wine_glTexImage2DMultisampleCoverageNV( GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations ) { - void (*func_glTexImage2DMultisampleCoverageNV)( GLenum, GLsizei, GLsizei, GLint, GLsizei, GLsizei, GLboolean ) = extension_funcs[EXT_glTexImage2DMultisampleCoverageNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations ); - func_glTexImage2DMultisampleCoverageNV( target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations ); + funcs->ext.p_glTexImage2DMultisampleCoverageNV( target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations ); } static void WINAPI wine_glTexImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glTexImage3D)( GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glTexImage3D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, border, format, type, pixels ); - func_glTexImage3D( target, level, internalformat, width, height, depth, border, format, type, pixels ); + funcs->ext.p_glTexImage3D( target, level, internalformat, width, height, depth, border, format, type, pixels ); } static void WINAPI wine_glTexImage3DEXT( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glTexImage3DEXT)( GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glTexImage3DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, border, format, type, pixels ); - func_glTexImage3DEXT( target, level, internalformat, width, height, depth, border, format, type, pixels ); + funcs->ext.p_glTexImage3DEXT( target, level, internalformat, width, height, depth, border, format, type, pixels ); } static void WINAPI wine_glTexImage3DMultisample( GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations ) { - void (*func_glTexImage3DMultisample)( GLenum, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean ) = extension_funcs[EXT_glTexImage3DMultisample]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", target, samples, internalformat, width, height, depth, fixedsamplelocations ); - func_glTexImage3DMultisample( target, samples, internalformat, width, height, depth, fixedsamplelocations ); + funcs->ext.p_glTexImage3DMultisample( target, samples, internalformat, width, height, depth, fixedsamplelocations ); } static void WINAPI wine_glTexImage3DMultisampleCoverageNV( GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations ) { - void (*func_glTexImage3DMultisampleCoverageNV)( GLenum, GLsizei, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean ) = extension_funcs[EXT_glTexImage3DMultisampleCoverageNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations ); - func_glTexImage3DMultisampleCoverageNV( target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations ); + funcs->ext.p_glTexImage3DMultisampleCoverageNV( target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations ); } static void WINAPI wine_glTexImage4DSGIS( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glTexImage4DSGIS)( GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glTexImage4DSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, size4d, border, format, type, pixels ); - func_glTexImage4DSGIS( target, level, internalformat, width, height, depth, size4d, border, format, type, pixels ); + funcs->ext.p_glTexImage4DSGIS( target, level, internalformat, width, height, depth, size4d, border, format, type, pixels ); } static void WINAPI wine_glTexParameterIiv( GLenum target, GLenum pname, GLint* params ) { - void (*func_glTexParameterIiv)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glTexParameterIiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glTexParameterIiv( target, pname, params ); + funcs->ext.p_glTexParameterIiv( target, pname, params ); } static void WINAPI wine_glTexParameterIivEXT( GLenum target, GLenum pname, GLint* params ) { - void (*func_glTexParameterIivEXT)( GLenum, GLenum, GLint* ) = extension_funcs[EXT_glTexParameterIivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glTexParameterIivEXT( target, pname, params ); + funcs->ext.p_glTexParameterIivEXT( target, pname, params ); } static void WINAPI wine_glTexParameterIuiv( GLenum target, GLenum pname, GLuint* params ) { - void (*func_glTexParameterIuiv)( GLenum, GLenum, GLuint* ) = extension_funcs[EXT_glTexParameterIuiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glTexParameterIuiv( target, pname, params ); + funcs->ext.p_glTexParameterIuiv( target, pname, params ); } static void WINAPI wine_glTexParameterIuivEXT( GLenum target, GLenum pname, GLuint* params ) { - void (*func_glTexParameterIuivEXT)( GLenum, GLenum, GLuint* ) = extension_funcs[EXT_glTexParameterIuivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, pname, params ); - func_glTexParameterIuivEXT( target, pname, params ); + funcs->ext.p_glTexParameterIuivEXT( target, pname, params ); } static void WINAPI wine_glTexRenderbufferNV( GLenum target, GLuint renderbuffer ) { - void (*func_glTexRenderbufferNV)( GLenum, GLuint ) = extension_funcs[EXT_glTexRenderbufferNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", target, renderbuffer ); - func_glTexRenderbufferNV( target, renderbuffer ); + funcs->ext.p_glTexRenderbufferNV( target, renderbuffer ); } static void WINAPI wine_glTexStorage1D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width ) { - void (*func_glTexStorage1D)( GLenum, GLsizei, GLenum, GLsizei ) = extension_funcs[EXT_glTexStorage1D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", target, levels, internalformat, width ); - func_glTexStorage1D( target, levels, internalformat, width ); + funcs->ext.p_glTexStorage1D( target, levels, internalformat, width ); } static void WINAPI wine_glTexStorage2D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height ) { - void (*func_glTexStorage2D)( GLenum, GLsizei, GLenum, GLsizei, GLsizei ) = extension_funcs[EXT_glTexStorage2D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", target, levels, internalformat, width, height ); - func_glTexStorage2D( target, levels, internalformat, width, height ); + funcs->ext.p_glTexStorage2D( target, levels, internalformat, width, height ); } static void WINAPI wine_glTexStorage3D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth ) { - void (*func_glTexStorage3D)( GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei ) = extension_funcs[EXT_glTexStorage3D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", target, levels, internalformat, width, height, depth ); - func_glTexStorage3D( target, levels, internalformat, width, height, depth ); + funcs->ext.p_glTexStorage3D( target, levels, internalformat, width, height, depth ); } static void WINAPI wine_glTexSubImage1DEXT( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glTexSubImage1DEXT)( GLenum, GLint, GLint, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glTexSubImage1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, width, format, type, pixels ); - func_glTexSubImage1DEXT( target, level, xoffset, width, format, type, pixels ); + funcs->ext.p_glTexSubImage1DEXT( target, level, xoffset, width, format, type, pixels ); } static void WINAPI wine_glTexSubImage2DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glTexSubImage2DEXT)( GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glTexSubImage2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, width, height, format, type, pixels ); - func_glTexSubImage2DEXT( target, level, xoffset, yoffset, width, height, format, type, pixels ); + funcs->ext.p_glTexSubImage2DEXT( target, level, xoffset, yoffset, width, height, format, type, pixels ); } static void WINAPI wine_glTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glTexSubImage3D)( GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glTexSubImage3D]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels ); - func_glTexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels ); + funcs->ext.p_glTexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels ); } static void WINAPI wine_glTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glTexSubImage3DEXT)( GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glTexSubImage3DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels ); - func_glTexSubImage3DEXT( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels ); + funcs->ext.p_glTexSubImage3DEXT( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels ); } static void WINAPI wine_glTexSubImage4DSGIS( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glTexSubImage4DSGIS)( GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glTexSubImage4DSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels ); - func_glTexSubImage4DSGIS( target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels ); + funcs->ext.p_glTexSubImage4DSGIS( target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels ); } static void WINAPI wine_glTextureBarrierNV( void ) { - void (*func_glTextureBarrierNV)( void ) = extension_funcs[EXT_glTextureBarrierNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glTextureBarrierNV( ); + funcs->ext.p_glTextureBarrierNV( ); } static void WINAPI wine_glTextureBufferEXT( GLuint texture, GLenum target, GLenum internalformat, GLuint buffer ) { - void (*func_glTextureBufferEXT)( GLuint, GLenum, GLenum, GLuint ) = extension_funcs[EXT_glTextureBufferEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", texture, target, internalformat, buffer ); - func_glTextureBufferEXT( texture, target, internalformat, buffer ); + funcs->ext.p_glTextureBufferEXT( texture, target, internalformat, buffer ); } static void WINAPI wine_glTextureColorMaskSGIS( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) { - void (*func_glTextureColorMaskSGIS)( GLboolean, GLboolean, GLboolean, GLboolean ) = extension_funcs[EXT_glTextureColorMaskSGIS]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha ); - func_glTextureColorMaskSGIS( red, green, blue, alpha ); + funcs->ext.p_glTextureColorMaskSGIS( red, green, blue, alpha ); } static void WINAPI wine_glTextureImage1DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glTextureImage1DEXT)( GLuint, GLenum, GLint, GLenum, GLsizei, GLint, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glTextureImage1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, internalformat, width, border, format, type, pixels ); - func_glTextureImage1DEXT( texture, target, level, internalformat, width, border, format, type, pixels ); + funcs->ext.p_glTextureImage1DEXT( texture, target, level, internalformat, width, border, format, type, pixels ); } static void WINAPI wine_glTextureImage2DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glTextureImage2DEXT)( GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glTextureImage2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, internalformat, width, height, border, format, type, pixels ); - func_glTextureImage2DEXT( texture, target, level, internalformat, width, height, border, format, type, pixels ); + funcs->ext.p_glTextureImage2DEXT( texture, target, level, internalformat, width, height, border, format, type, pixels ); } static void WINAPI wine_glTextureImage2DMultisampleCoverageNV( GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations ) { - void (*func_glTextureImage2DMultisampleCoverageNV)( GLuint, GLenum, GLsizei, GLsizei, GLint, GLsizei, GLsizei, GLboolean ) = extension_funcs[EXT_glTextureImage2DMultisampleCoverageNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations ); - func_glTextureImage2DMultisampleCoverageNV( texture, target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations ); + funcs->ext.p_glTextureImage2DMultisampleCoverageNV( texture, target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations ); } static void WINAPI wine_glTextureImage2DMultisampleNV( GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations ) { - void (*func_glTextureImage2DMultisampleNV)( GLuint, GLenum, GLsizei, GLint, GLsizei, GLsizei, GLboolean ) = extension_funcs[EXT_glTextureImage2DMultisampleNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", texture, target, samples, internalFormat, width, height, fixedSampleLocations ); - func_glTextureImage2DMultisampleNV( texture, target, samples, internalFormat, width, height, fixedSampleLocations ); + funcs->ext.p_glTextureImage2DMultisampleNV( texture, target, samples, internalFormat, width, height, fixedSampleLocations ); } static void WINAPI wine_glTextureImage3DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glTextureImage3DEXT)( GLuint, GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glTextureImage3DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, internalformat, width, height, depth, border, format, type, pixels ); - func_glTextureImage3DEXT( texture, target, level, internalformat, width, height, depth, border, format, type, pixels ); + funcs->ext.p_glTextureImage3DEXT( texture, target, level, internalformat, width, height, depth, border, format, type, pixels ); } static void WINAPI wine_glTextureImage3DMultisampleCoverageNV( GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations ) { - void (*func_glTextureImage3DMultisampleCoverageNV)( GLuint, GLenum, GLsizei, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean ) = extension_funcs[EXT_glTextureImage3DMultisampleCoverageNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations ); - func_glTextureImage3DMultisampleCoverageNV( texture, target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations ); + funcs->ext.p_glTextureImage3DMultisampleCoverageNV( texture, target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations ); } static void WINAPI wine_glTextureImage3DMultisampleNV( GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations ) { - void (*func_glTextureImage3DMultisampleNV)( GLuint, GLenum, GLsizei, GLint, GLsizei, GLsizei, GLsizei, GLboolean ) = extension_funcs[EXT_glTextureImage3DMultisampleNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations ); - func_glTextureImage3DMultisampleNV( texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations ); + funcs->ext.p_glTextureImage3DMultisampleNV( texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations ); } static void WINAPI wine_glTextureLightEXT( GLenum pname ) { - void (*func_glTextureLightEXT)( GLenum ) = extension_funcs[EXT_glTextureLightEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", pname ); - func_glTextureLightEXT( pname ); + funcs->ext.p_glTextureLightEXT( pname ); } static void WINAPI wine_glTextureMaterialEXT( GLenum face, GLenum mode ) { - void (*func_glTextureMaterialEXT)( GLenum, GLenum ) = extension_funcs[EXT_glTextureMaterialEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", face, mode ); - func_glTextureMaterialEXT( face, mode ); + funcs->ext.p_glTextureMaterialEXT( face, mode ); } static void WINAPI wine_glTextureNormalEXT( GLenum mode ) { - void (*func_glTextureNormalEXT)( GLenum ) = extension_funcs[EXT_glTextureNormalEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", mode ); - func_glTextureNormalEXT( mode ); + funcs->ext.p_glTextureNormalEXT( mode ); } static void WINAPI wine_glTextureParameterIivEXT( GLuint texture, GLenum target, GLenum pname, GLint* params ) { - void (*func_glTextureParameterIivEXT)( GLuint, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glTextureParameterIivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texture, target, pname, params ); - func_glTextureParameterIivEXT( texture, target, pname, params ); + funcs->ext.p_glTextureParameterIivEXT( texture, target, pname, params ); } static void WINAPI wine_glTextureParameterIuivEXT( GLuint texture, GLenum target, GLenum pname, GLuint* params ) { - void (*func_glTextureParameterIuivEXT)( GLuint, GLenum, GLenum, GLuint* ) = extension_funcs[EXT_glTextureParameterIuivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texture, target, pname, params ); - func_glTextureParameterIuivEXT( texture, target, pname, params ); + funcs->ext.p_glTextureParameterIuivEXT( texture, target, pname, params ); } static void WINAPI wine_glTextureParameterfEXT( GLuint texture, GLenum target, GLenum pname, GLfloat param ) { - void (*func_glTextureParameterfEXT)( GLuint, GLenum, GLenum, GLfloat ) = extension_funcs[EXT_glTextureParameterfEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %f)\n", texture, target, pname, param ); - func_glTextureParameterfEXT( texture, target, pname, param ); + funcs->ext.p_glTextureParameterfEXT( texture, target, pname, param ); } static void WINAPI wine_glTextureParameterfvEXT( GLuint texture, GLenum target, GLenum pname, GLfloat* params ) { - void (*func_glTextureParameterfvEXT)( GLuint, GLenum, GLenum, GLfloat* ) = extension_funcs[EXT_glTextureParameterfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texture, target, pname, params ); - func_glTextureParameterfvEXT( texture, target, pname, params ); + funcs->ext.p_glTextureParameterfvEXT( texture, target, pname, params ); } static void WINAPI wine_glTextureParameteriEXT( GLuint texture, GLenum target, GLenum pname, GLint param ) { - void (*func_glTextureParameteriEXT)( GLuint, GLenum, GLenum, GLint ) = extension_funcs[EXT_glTextureParameteriEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", texture, target, pname, param ); - func_glTextureParameteriEXT( texture, target, pname, param ); + funcs->ext.p_glTextureParameteriEXT( texture, target, pname, param ); } static void WINAPI wine_glTextureParameterivEXT( GLuint texture, GLenum target, GLenum pname, GLint* params ) { - void (*func_glTextureParameterivEXT)( GLuint, GLenum, GLenum, GLint* ) = extension_funcs[EXT_glTextureParameterivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", texture, target, pname, params ); - func_glTextureParameterivEXT( texture, target, pname, params ); + funcs->ext.p_glTextureParameterivEXT( texture, target, pname, params ); } static void WINAPI wine_glTextureRangeAPPLE( GLenum target, GLsizei length, GLvoid* pointer ) { - void (*func_glTextureRangeAPPLE)( GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glTextureRangeAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", target, length, pointer ); - func_glTextureRangeAPPLE( target, length, pointer ); + funcs->ext.p_glTextureRangeAPPLE( target, length, pointer ); } static void WINAPI wine_glTextureRenderbufferEXT( GLuint texture, GLenum target, GLuint renderbuffer ) { - void (*func_glTextureRenderbufferEXT)( GLuint, GLenum, GLuint ) = extension_funcs[EXT_glTextureRenderbufferEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", texture, target, renderbuffer ); - func_glTextureRenderbufferEXT( texture, target, renderbuffer ); + funcs->ext.p_glTextureRenderbufferEXT( texture, target, renderbuffer ); } static void WINAPI wine_glTextureStorage1DEXT( GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width ) { - void (*func_glTextureStorage1DEXT)( GLuint, GLenum, GLsizei, GLenum, GLsizei ) = extension_funcs[EXT_glTextureStorage1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", texture, target, levels, internalformat, width ); - func_glTextureStorage1DEXT( texture, target, levels, internalformat, width ); + funcs->ext.p_glTextureStorage1DEXT( texture, target, levels, internalformat, width ); } static void WINAPI wine_glTextureStorage2DEXT( GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height ) { - void (*func_glTextureStorage2DEXT)( GLuint, GLenum, GLsizei, GLenum, GLsizei, GLsizei ) = extension_funcs[EXT_glTextureStorage2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", texture, target, levels, internalformat, width, height ); - func_glTextureStorage2DEXT( texture, target, levels, internalformat, width, height ); + funcs->ext.p_glTextureStorage2DEXT( texture, target, levels, internalformat, width, height ); } static void WINAPI wine_glTextureStorage3DEXT( GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth ) { - void (*func_glTextureStorage3DEXT)( GLuint, GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei ) = extension_funcs[EXT_glTextureStorage3DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", texture, target, levels, internalformat, width, height, depth ); - func_glTextureStorage3DEXT( texture, target, levels, internalformat, width, height, depth ); + funcs->ext.p_glTextureStorage3DEXT( texture, target, levels, internalformat, width, height, depth ); } static void WINAPI wine_glTextureSubImage1DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glTextureSubImage1DEXT)( GLuint, GLenum, GLint, GLint, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glTextureSubImage1DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, xoffset, width, format, type, pixels ); - func_glTextureSubImage1DEXT( texture, target, level, xoffset, width, format, type, pixels ); + funcs->ext.p_glTextureSubImage1DEXT( texture, target, level, xoffset, width, format, type, pixels ); } static void WINAPI wine_glTextureSubImage2DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glTextureSubImage2DEXT)( GLuint, GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glTextureSubImage2DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, xoffset, yoffset, width, height, format, type, pixels ); - func_glTextureSubImage2DEXT( texture, target, level, xoffset, yoffset, width, height, format, type, pixels ); + funcs->ext.p_glTextureSubImage2DEXT( texture, target, level, xoffset, yoffset, width, height, format, type, pixels ); } static void WINAPI wine_glTextureSubImage3DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid* pixels ) { - void (*func_glTextureSubImage3DEXT)( GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLvoid* ) = extension_funcs[EXT_glTextureSubImage3DEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels ); - func_glTextureSubImage3DEXT( texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels ); + funcs->ext.p_glTextureSubImage3DEXT( texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels ); } static void WINAPI wine_glTrackMatrixNV( GLenum target, GLuint address, GLenum matrix, GLenum transform ) { - void (*func_glTrackMatrixNV)( GLenum, GLuint, GLenum, GLenum ) = extension_funcs[EXT_glTrackMatrixNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", target, address, matrix, transform ); - func_glTrackMatrixNV( target, address, matrix, transform ); + funcs->ext.p_glTrackMatrixNV( target, address, matrix, transform ); } static void WINAPI wine_glTransformFeedbackAttribsNV( GLuint count, GLint* attribs, GLenum bufferMode ) { - void (*func_glTransformFeedbackAttribsNV)( GLuint, GLint*, GLenum ) = extension_funcs[EXT_glTransformFeedbackAttribsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %d)\n", count, attribs, bufferMode ); - func_glTransformFeedbackAttribsNV( count, attribs, bufferMode ); + funcs->ext.p_glTransformFeedbackAttribsNV( count, attribs, bufferMode ); } static void WINAPI wine_glTransformFeedbackStreamAttribsNV( GLsizei count, GLint* attribs, GLsizei nbuffers, GLint* bufstreams, GLenum bufferMode ) { - void (*func_glTransformFeedbackStreamAttribsNV)( GLsizei, GLint*, GLsizei, GLint*, GLenum ) = extension_funcs[EXT_glTransformFeedbackStreamAttribsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %d, %p, %d)\n", count, attribs, nbuffers, bufstreams, bufferMode ); - func_glTransformFeedbackStreamAttribsNV( count, attribs, nbuffers, bufstreams, bufferMode ); + funcs->ext.p_glTransformFeedbackStreamAttribsNV( count, attribs, nbuffers, bufstreams, bufferMode ); } static void WINAPI wine_glTransformFeedbackVaryings( GLuint program, GLsizei count, char* const* varyings, GLenum bufferMode ) { - void (*func_glTransformFeedbackVaryings)( GLuint, GLsizei, char* const*, GLenum ) = extension_funcs[EXT_glTransformFeedbackVaryings]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %d)\n", program, count, varyings, bufferMode ); - func_glTransformFeedbackVaryings( program, count, varyings, bufferMode ); + funcs->ext.p_glTransformFeedbackVaryings( program, count, varyings, bufferMode ); } static void WINAPI wine_glTransformFeedbackVaryingsEXT( GLuint program, GLsizei count, char** varyings, GLenum bufferMode ) { - void (*func_glTransformFeedbackVaryingsEXT)( GLuint, GLsizei, char**, GLenum ) = extension_funcs[EXT_glTransformFeedbackVaryingsEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %d)\n", program, count, varyings, bufferMode ); - func_glTransformFeedbackVaryingsEXT( program, count, varyings, bufferMode ); + funcs->ext.p_glTransformFeedbackVaryingsEXT( program, count, varyings, bufferMode ); } static void WINAPI wine_glTransformFeedbackVaryingsNV( GLuint program, GLsizei count, GLint* locations, GLenum bufferMode ) { - void (*func_glTransformFeedbackVaryingsNV)( GLuint, GLsizei, GLint*, GLenum ) = extension_funcs[EXT_glTransformFeedbackVaryingsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %d)\n", program, count, locations, bufferMode ); - func_glTransformFeedbackVaryingsNV( program, count, locations, bufferMode ); + funcs->ext.p_glTransformFeedbackVaryingsNV( program, count, locations, bufferMode ); } static void WINAPI wine_glTransformPathNV( GLuint resultPath, GLuint srcPath, GLenum transformType, GLfloat* transformValues ) { - void (*func_glTransformPathNV)( GLuint, GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glTransformPathNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", resultPath, srcPath, transformType, transformValues ); - func_glTransformPathNV( resultPath, srcPath, transformType, transformValues ); + funcs->ext.p_glTransformPathNV( resultPath, srcPath, transformType, transformValues ); } static void WINAPI wine_glUniform1d( GLint location, GLdouble x ) { - void (*func_glUniform1d)( GLint, GLdouble ) = extension_funcs[EXT_glUniform1d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", location, x ); - func_glUniform1d( location, x ); + funcs->ext.p_glUniform1d( location, x ); } static void WINAPI wine_glUniform1dv( GLint location, GLsizei count, GLdouble* value ) { - void (*func_glUniform1dv)( GLint, GLsizei, GLdouble* ) = extension_funcs[EXT_glUniform1dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform1dv( location, count, value ); + funcs->ext.p_glUniform1dv( location, count, value ); } static void WINAPI wine_glUniform1f( GLint location, GLfloat v0 ) { - void (*func_glUniform1f)( GLint, GLfloat ) = extension_funcs[EXT_glUniform1f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", location, v0 ); - func_glUniform1f( location, v0 ); + funcs->ext.p_glUniform1f( location, v0 ); } static void WINAPI wine_glUniform1fARB( GLint location, GLfloat v0 ) { - void (*func_glUniform1fARB)( GLint, GLfloat ) = extension_funcs[EXT_glUniform1fARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", location, v0 ); - func_glUniform1fARB( location, v0 ); + funcs->ext.p_glUniform1fARB( location, v0 ); } static void WINAPI wine_glUniform1fv( GLint location, GLsizei count, GLfloat* value ) { - void (*func_glUniform1fv)( GLint, GLsizei, GLfloat* ) = extension_funcs[EXT_glUniform1fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform1fv( location, count, value ); + funcs->ext.p_glUniform1fv( location, count, value ); } static void WINAPI wine_glUniform1fvARB( GLint location, GLsizei count, GLfloat* value ) { - void (*func_glUniform1fvARB)( GLint, GLsizei, GLfloat* ) = extension_funcs[EXT_glUniform1fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform1fvARB( location, count, value ); + funcs->ext.p_glUniform1fvARB( location, count, value ); } static void WINAPI wine_glUniform1i( GLint location, GLint v0 ) { - void (*func_glUniform1i)( GLint, GLint ) = extension_funcs[EXT_glUniform1i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", location, v0 ); - func_glUniform1i( location, v0 ); + funcs->ext.p_glUniform1i( location, v0 ); } static void WINAPI wine_glUniform1i64NV( GLint location, INT64 x ) { - void (*func_glUniform1i64NV)( GLint, INT64 ) = extension_funcs[EXT_glUniform1i64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s)\n", location, wine_dbgstr_longlong(x) ); - func_glUniform1i64NV( location, x ); + funcs->ext.p_glUniform1i64NV( location, x ); } static void WINAPI wine_glUniform1i64vNV( GLint location, GLsizei count, INT64* value ) { - void (*func_glUniform1i64vNV)( GLint, GLsizei, INT64* ) = extension_funcs[EXT_glUniform1i64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform1i64vNV( location, count, value ); + funcs->ext.p_glUniform1i64vNV( location, count, value ); } static void WINAPI wine_glUniform1iARB( GLint location, GLint v0 ) { - void (*func_glUniform1iARB)( GLint, GLint ) = extension_funcs[EXT_glUniform1iARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", location, v0 ); - func_glUniform1iARB( location, v0 ); + funcs->ext.p_glUniform1iARB( location, v0 ); } static void WINAPI wine_glUniform1iv( GLint location, GLsizei count, GLint* value ) { - void (*func_glUniform1iv)( GLint, GLsizei, GLint* ) = extension_funcs[EXT_glUniform1iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform1iv( location, count, value ); + funcs->ext.p_glUniform1iv( location, count, value ); } static void WINAPI wine_glUniform1ivARB( GLint location, GLsizei count, GLint* value ) { - void (*func_glUniform1ivARB)( GLint, GLsizei, GLint* ) = extension_funcs[EXT_glUniform1ivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform1ivARB( location, count, value ); + funcs->ext.p_glUniform1ivARB( location, count, value ); } static void WINAPI wine_glUniform1ui( GLint location, GLuint v0 ) { - void (*func_glUniform1ui)( GLint, GLuint ) = extension_funcs[EXT_glUniform1ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", location, v0 ); - func_glUniform1ui( location, v0 ); + funcs->ext.p_glUniform1ui( location, v0 ); } static void WINAPI wine_glUniform1ui64NV( GLint location, UINT64 x ) { - void (*func_glUniform1ui64NV)( GLint, UINT64 ) = extension_funcs[EXT_glUniform1ui64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s)\n", location, wine_dbgstr_longlong(x) ); - func_glUniform1ui64NV( location, x ); + funcs->ext.p_glUniform1ui64NV( location, x ); } static void WINAPI wine_glUniform1ui64vNV( GLint location, GLsizei count, UINT64* value ) { - void (*func_glUniform1ui64vNV)( GLint, GLsizei, UINT64* ) = extension_funcs[EXT_glUniform1ui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform1ui64vNV( location, count, value ); + funcs->ext.p_glUniform1ui64vNV( location, count, value ); } static void WINAPI wine_glUniform1uiEXT( GLint location, GLuint v0 ) { - void (*func_glUniform1uiEXT)( GLint, GLuint ) = extension_funcs[EXT_glUniform1uiEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", location, v0 ); - func_glUniform1uiEXT( location, v0 ); + funcs->ext.p_glUniform1uiEXT( location, v0 ); } static void WINAPI wine_glUniform1uiv( GLint location, GLsizei count, GLuint* value ) { - void (*func_glUniform1uiv)( GLint, GLsizei, GLuint* ) = extension_funcs[EXT_glUniform1uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform1uiv( location, count, value ); + funcs->ext.p_glUniform1uiv( location, count, value ); } static void WINAPI wine_glUniform1uivEXT( GLint location, GLsizei count, GLuint* value ) { - void (*func_glUniform1uivEXT)( GLint, GLsizei, GLuint* ) = extension_funcs[EXT_glUniform1uivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform1uivEXT( location, count, value ); + funcs->ext.p_glUniform1uivEXT( location, count, value ); } static void WINAPI wine_glUniform2d( GLint location, GLdouble x, GLdouble y ) { - void (*func_glUniform2d)( GLint, GLdouble, GLdouble ) = extension_funcs[EXT_glUniform2d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", location, x, y ); - func_glUniform2d( location, x, y ); + funcs->ext.p_glUniform2d( location, x, y ); } static void WINAPI wine_glUniform2dv( GLint location, GLsizei count, GLdouble* value ) { - void (*func_glUniform2dv)( GLint, GLsizei, GLdouble* ) = extension_funcs[EXT_glUniform2dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform2dv( location, count, value ); + funcs->ext.p_glUniform2dv( location, count, value ); } static void WINAPI wine_glUniform2f( GLint location, GLfloat v0, GLfloat v1 ) { - void (*func_glUniform2f)( GLint, GLfloat, GLfloat ) = extension_funcs[EXT_glUniform2f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", location, v0, v1 ); - func_glUniform2f( location, v0, v1 ); + funcs->ext.p_glUniform2f( location, v0, v1 ); } static void WINAPI wine_glUniform2fARB( GLint location, GLfloat v0, GLfloat v1 ) { - void (*func_glUniform2fARB)( GLint, GLfloat, GLfloat ) = extension_funcs[EXT_glUniform2fARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", location, v0, v1 ); - func_glUniform2fARB( location, v0, v1 ); + funcs->ext.p_glUniform2fARB( location, v0, v1 ); } static void WINAPI wine_glUniform2fv( GLint location, GLsizei count, GLfloat* value ) { - void (*func_glUniform2fv)( GLint, GLsizei, GLfloat* ) = extension_funcs[EXT_glUniform2fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform2fv( location, count, value ); + funcs->ext.p_glUniform2fv( location, count, value ); } static void WINAPI wine_glUniform2fvARB( GLint location, GLsizei count, GLfloat* value ) { - void (*func_glUniform2fvARB)( GLint, GLsizei, GLfloat* ) = extension_funcs[EXT_glUniform2fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform2fvARB( location, count, value ); + funcs->ext.p_glUniform2fvARB( location, count, value ); } static void WINAPI wine_glUniform2i( GLint location, GLint v0, GLint v1 ) { - void (*func_glUniform2i)( GLint, GLint, GLint ) = extension_funcs[EXT_glUniform2i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", location, v0, v1 ); - func_glUniform2i( location, v0, v1 ); + funcs->ext.p_glUniform2i( location, v0, v1 ); } static void WINAPI wine_glUniform2i64NV( GLint location, INT64 x, INT64 y ) { - void (*func_glUniform2i64NV)( GLint, INT64, INT64 ) = extension_funcs[EXT_glUniform2i64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) ); - func_glUniform2i64NV( location, x, y ); + funcs->ext.p_glUniform2i64NV( location, x, y ); } static void WINAPI wine_glUniform2i64vNV( GLint location, GLsizei count, INT64* value ) { - void (*func_glUniform2i64vNV)( GLint, GLsizei, INT64* ) = extension_funcs[EXT_glUniform2i64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform2i64vNV( location, count, value ); + funcs->ext.p_glUniform2i64vNV( location, count, value ); } static void WINAPI wine_glUniform2iARB( GLint location, GLint v0, GLint v1 ) { - void (*func_glUniform2iARB)( GLint, GLint, GLint ) = extension_funcs[EXT_glUniform2iARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", location, v0, v1 ); - func_glUniform2iARB( location, v0, v1 ); + funcs->ext.p_glUniform2iARB( location, v0, v1 ); } static void WINAPI wine_glUniform2iv( GLint location, GLsizei count, GLint* value ) { - void (*func_glUniform2iv)( GLint, GLsizei, GLint* ) = extension_funcs[EXT_glUniform2iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform2iv( location, count, value ); + funcs->ext.p_glUniform2iv( location, count, value ); } static void WINAPI wine_glUniform2ivARB( GLint location, GLsizei count, GLint* value ) { - void (*func_glUniform2ivARB)( GLint, GLsizei, GLint* ) = extension_funcs[EXT_glUniform2ivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform2ivARB( location, count, value ); + funcs->ext.p_glUniform2ivARB( location, count, value ); } static void WINAPI wine_glUniform2ui( GLint location, GLuint v0, GLuint v1 ) { - void (*func_glUniform2ui)( GLint, GLuint, GLuint ) = extension_funcs[EXT_glUniform2ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", location, v0, v1 ); - func_glUniform2ui( location, v0, v1 ); + funcs->ext.p_glUniform2ui( location, v0, v1 ); } static void WINAPI wine_glUniform2ui64NV( GLint location, UINT64 x, UINT64 y ) { - void (*func_glUniform2ui64NV)( GLint, UINT64, UINT64 ) = extension_funcs[EXT_glUniform2ui64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) ); - func_glUniform2ui64NV( location, x, y ); + funcs->ext.p_glUniform2ui64NV( location, x, y ); } static void WINAPI wine_glUniform2ui64vNV( GLint location, GLsizei count, UINT64* value ) { - void (*func_glUniform2ui64vNV)( GLint, GLsizei, UINT64* ) = extension_funcs[EXT_glUniform2ui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform2ui64vNV( location, count, value ); + funcs->ext.p_glUniform2ui64vNV( location, count, value ); } static void WINAPI wine_glUniform2uiEXT( GLint location, GLuint v0, GLuint v1 ) { - void (*func_glUniform2uiEXT)( GLint, GLuint, GLuint ) = extension_funcs[EXT_glUniform2uiEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", location, v0, v1 ); - func_glUniform2uiEXT( location, v0, v1 ); + funcs->ext.p_glUniform2uiEXT( location, v0, v1 ); } static void WINAPI wine_glUniform2uiv( GLint location, GLsizei count, GLuint* value ) { - void (*func_glUniform2uiv)( GLint, GLsizei, GLuint* ) = extension_funcs[EXT_glUniform2uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform2uiv( location, count, value ); + funcs->ext.p_glUniform2uiv( location, count, value ); } static void WINAPI wine_glUniform2uivEXT( GLint location, GLsizei count, GLuint* value ) { - void (*func_glUniform2uivEXT)( GLint, GLsizei, GLuint* ) = extension_funcs[EXT_glUniform2uivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform2uivEXT( location, count, value ); + funcs->ext.p_glUniform2uivEXT( location, count, value ); } static void WINAPI wine_glUniform3d( GLint location, GLdouble x, GLdouble y, GLdouble z ) { - void (*func_glUniform3d)( GLint, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glUniform3d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", location, x, y, z ); - func_glUniform3d( location, x, y, z ); + funcs->ext.p_glUniform3d( location, x, y, z ); } static void WINAPI wine_glUniform3dv( GLint location, GLsizei count, GLdouble* value ) { - void (*func_glUniform3dv)( GLint, GLsizei, GLdouble* ) = extension_funcs[EXT_glUniform3dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform3dv( location, count, value ); + funcs->ext.p_glUniform3dv( location, count, value ); } static void WINAPI wine_glUniform3f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2 ) { - void (*func_glUniform3f)( GLint, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glUniform3f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", location, v0, v1, v2 ); - func_glUniform3f( location, v0, v1, v2 ); + funcs->ext.p_glUniform3f( location, v0, v1, v2 ); } static void WINAPI wine_glUniform3fARB( GLint location, GLfloat v0, GLfloat v1, GLfloat v2 ) { - void (*func_glUniform3fARB)( GLint, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glUniform3fARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", location, v0, v1, v2 ); - func_glUniform3fARB( location, v0, v1, v2 ); + funcs->ext.p_glUniform3fARB( location, v0, v1, v2 ); } static void WINAPI wine_glUniform3fv( GLint location, GLsizei count, GLfloat* value ) { - void (*func_glUniform3fv)( GLint, GLsizei, GLfloat* ) = extension_funcs[EXT_glUniform3fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform3fv( location, count, value ); + funcs->ext.p_glUniform3fv( location, count, value ); } static void WINAPI wine_glUniform3fvARB( GLint location, GLsizei count, GLfloat* value ) { - void (*func_glUniform3fvARB)( GLint, GLsizei, GLfloat* ) = extension_funcs[EXT_glUniform3fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform3fvARB( location, count, value ); + funcs->ext.p_glUniform3fvARB( location, count, value ); } static void WINAPI wine_glUniform3i( GLint location, GLint v0, GLint v1, GLint v2 ) { - void (*func_glUniform3i)( GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glUniform3i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", location, v0, v1, v2 ); - func_glUniform3i( location, v0, v1, v2 ); + funcs->ext.p_glUniform3i( location, v0, v1, v2 ); } static void WINAPI wine_glUniform3i64NV( GLint location, INT64 x, INT64 y, INT64 z ) { - void (*func_glUniform3i64NV)( GLint, INT64, INT64, INT64 ) = extension_funcs[EXT_glUniform3i64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) ); - func_glUniform3i64NV( location, x, y, z ); + funcs->ext.p_glUniform3i64NV( location, x, y, z ); } static void WINAPI wine_glUniform3i64vNV( GLint location, GLsizei count, INT64* value ) { - void (*func_glUniform3i64vNV)( GLint, GLsizei, INT64* ) = extension_funcs[EXT_glUniform3i64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform3i64vNV( location, count, value ); + funcs->ext.p_glUniform3i64vNV( location, count, value ); } static void WINAPI wine_glUniform3iARB( GLint location, GLint v0, GLint v1, GLint v2 ) { - void (*func_glUniform3iARB)( GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glUniform3iARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", location, v0, v1, v2 ); - func_glUniform3iARB( location, v0, v1, v2 ); + funcs->ext.p_glUniform3iARB( location, v0, v1, v2 ); } static void WINAPI wine_glUniform3iv( GLint location, GLsizei count, GLint* value ) { - void (*func_glUniform3iv)( GLint, GLsizei, GLint* ) = extension_funcs[EXT_glUniform3iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform3iv( location, count, value ); + funcs->ext.p_glUniform3iv( location, count, value ); } static void WINAPI wine_glUniform3ivARB( GLint location, GLsizei count, GLint* value ) { - void (*func_glUniform3ivARB)( GLint, GLsizei, GLint* ) = extension_funcs[EXT_glUniform3ivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform3ivARB( location, count, value ); + funcs->ext.p_glUniform3ivARB( location, count, value ); } static void WINAPI wine_glUniform3ui( GLint location, GLuint v0, GLuint v1, GLuint v2 ) { - void (*func_glUniform3ui)( GLint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glUniform3ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", location, v0, v1, v2 ); - func_glUniform3ui( location, v0, v1, v2 ); + funcs->ext.p_glUniform3ui( location, v0, v1, v2 ); } static void WINAPI wine_glUniform3ui64NV( GLint location, UINT64 x, UINT64 y, UINT64 z ) { - void (*func_glUniform3ui64NV)( GLint, UINT64, UINT64, UINT64 ) = extension_funcs[EXT_glUniform3ui64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) ); - func_glUniform3ui64NV( location, x, y, z ); + funcs->ext.p_glUniform3ui64NV( location, x, y, z ); } static void WINAPI wine_glUniform3ui64vNV( GLint location, GLsizei count, UINT64* value ) { - void (*func_glUniform3ui64vNV)( GLint, GLsizei, UINT64* ) = extension_funcs[EXT_glUniform3ui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform3ui64vNV( location, count, value ); + funcs->ext.p_glUniform3ui64vNV( location, count, value ); } static void WINAPI wine_glUniform3uiEXT( GLint location, GLuint v0, GLuint v1, GLuint v2 ) { - void (*func_glUniform3uiEXT)( GLint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glUniform3uiEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", location, v0, v1, v2 ); - func_glUniform3uiEXT( location, v0, v1, v2 ); + funcs->ext.p_glUniform3uiEXT( location, v0, v1, v2 ); } static void WINAPI wine_glUniform3uiv( GLint location, GLsizei count, GLuint* value ) { - void (*func_glUniform3uiv)( GLint, GLsizei, GLuint* ) = extension_funcs[EXT_glUniform3uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform3uiv( location, count, value ); + funcs->ext.p_glUniform3uiv( location, count, value ); } static void WINAPI wine_glUniform3uivEXT( GLint location, GLsizei count, GLuint* value ) { - void (*func_glUniform3uivEXT)( GLint, GLsizei, GLuint* ) = extension_funcs[EXT_glUniform3uivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform3uivEXT( location, count, value ); + funcs->ext.p_glUniform3uivEXT( location, count, value ); } static void WINAPI wine_glUniform4d( GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { - void (*func_glUniform4d)( GLint, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glUniform4d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", location, x, y, z, w ); - func_glUniform4d( location, x, y, z, w ); + funcs->ext.p_glUniform4d( location, x, y, z, w ); } static void WINAPI wine_glUniform4dv( GLint location, GLsizei count, GLdouble* value ) { - void (*func_glUniform4dv)( GLint, GLsizei, GLdouble* ) = extension_funcs[EXT_glUniform4dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform4dv( location, count, value ); + funcs->ext.p_glUniform4dv( location, count, value ); } static void WINAPI wine_glUniform4f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) { - void (*func_glUniform4f)( GLint, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glUniform4f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", location, v0, v1, v2, v3 ); - func_glUniform4f( location, v0, v1, v2, v3 ); + funcs->ext.p_glUniform4f( location, v0, v1, v2, v3 ); } static void WINAPI wine_glUniform4fARB( GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) { - void (*func_glUniform4fARB)( GLint, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glUniform4fARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", location, v0, v1, v2, v3 ); - func_glUniform4fARB( location, v0, v1, v2, v3 ); + funcs->ext.p_glUniform4fARB( location, v0, v1, v2, v3 ); } static void WINAPI wine_glUniform4fv( GLint location, GLsizei count, GLfloat* value ) { - void (*func_glUniform4fv)( GLint, GLsizei, GLfloat* ) = extension_funcs[EXT_glUniform4fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform4fv( location, count, value ); + funcs->ext.p_glUniform4fv( location, count, value ); } static void WINAPI wine_glUniform4fvARB( GLint location, GLsizei count, GLfloat* value ) { - void (*func_glUniform4fvARB)( GLint, GLsizei, GLfloat* ) = extension_funcs[EXT_glUniform4fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform4fvARB( location, count, value ); + funcs->ext.p_glUniform4fvARB( location, count, value ); } static void WINAPI wine_glUniform4i( GLint location, GLint v0, GLint v1, GLint v2, GLint v3 ) { - void (*func_glUniform4i)( GLint, GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glUniform4i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", location, v0, v1, v2, v3 ); - func_glUniform4i( location, v0, v1, v2, v3 ); + funcs->ext.p_glUniform4i( location, v0, v1, v2, v3 ); } static void WINAPI wine_glUniform4i64NV( GLint location, INT64 x, INT64 y, INT64 z, INT64 w ) { - void (*func_glUniform4i64NV)( GLint, INT64, INT64, INT64, INT64 ) = extension_funcs[EXT_glUniform4i64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) ); - func_glUniform4i64NV( location, x, y, z, w ); + funcs->ext.p_glUniform4i64NV( location, x, y, z, w ); } static void WINAPI wine_glUniform4i64vNV( GLint location, GLsizei count, INT64* value ) { - void (*func_glUniform4i64vNV)( GLint, GLsizei, INT64* ) = extension_funcs[EXT_glUniform4i64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform4i64vNV( location, count, value ); + funcs->ext.p_glUniform4i64vNV( location, count, value ); } static void WINAPI wine_glUniform4iARB( GLint location, GLint v0, GLint v1, GLint v2, GLint v3 ) { - void (*func_glUniform4iARB)( GLint, GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glUniform4iARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", location, v0, v1, v2, v3 ); - func_glUniform4iARB( location, v0, v1, v2, v3 ); + funcs->ext.p_glUniform4iARB( location, v0, v1, v2, v3 ); } static void WINAPI wine_glUniform4iv( GLint location, GLsizei count, GLint* value ) { - void (*func_glUniform4iv)( GLint, GLsizei, GLint* ) = extension_funcs[EXT_glUniform4iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform4iv( location, count, value ); + funcs->ext.p_glUniform4iv( location, count, value ); } static void WINAPI wine_glUniform4ivARB( GLint location, GLsizei count, GLint* value ) { - void (*func_glUniform4ivARB)( GLint, GLsizei, GLint* ) = extension_funcs[EXT_glUniform4ivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform4ivARB( location, count, value ); + funcs->ext.p_glUniform4ivARB( location, count, value ); } static void WINAPI wine_glUniform4ui( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) { - void (*func_glUniform4ui)( GLint, GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glUniform4ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", location, v0, v1, v2, v3 ); - func_glUniform4ui( location, v0, v1, v2, v3 ); + funcs->ext.p_glUniform4ui( location, v0, v1, v2, v3 ); } static void WINAPI wine_glUniform4ui64NV( GLint location, UINT64 x, UINT64 y, UINT64 z, UINT64 w ) { - void (*func_glUniform4ui64NV)( GLint, UINT64, UINT64, UINT64, UINT64 ) = extension_funcs[EXT_glUniform4ui64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) ); - func_glUniform4ui64NV( location, x, y, z, w ); + funcs->ext.p_glUniform4ui64NV( location, x, y, z, w ); } static void WINAPI wine_glUniform4ui64vNV( GLint location, GLsizei count, UINT64* value ) { - void (*func_glUniform4ui64vNV)( GLint, GLsizei, UINT64* ) = extension_funcs[EXT_glUniform4ui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform4ui64vNV( location, count, value ); + funcs->ext.p_glUniform4ui64vNV( location, count, value ); } static void WINAPI wine_glUniform4uiEXT( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) { - void (*func_glUniform4uiEXT)( GLint, GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glUniform4uiEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", location, v0, v1, v2, v3 ); - func_glUniform4uiEXT( location, v0, v1, v2, v3 ); + funcs->ext.p_glUniform4uiEXT( location, v0, v1, v2, v3 ); } static void WINAPI wine_glUniform4uiv( GLint location, GLsizei count, GLuint* value ) { - void (*func_glUniform4uiv)( GLint, GLsizei, GLuint* ) = extension_funcs[EXT_glUniform4uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform4uiv( location, count, value ); + funcs->ext.p_glUniform4uiv( location, count, value ); } static void WINAPI wine_glUniform4uivEXT( GLint location, GLsizei count, GLuint* value ) { - void (*func_glUniform4uivEXT)( GLint, GLsizei, GLuint* ) = extension_funcs[EXT_glUniform4uivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniform4uivEXT( location, count, value ); + funcs->ext.p_glUniform4uivEXT( location, count, value ); } static void WINAPI wine_glUniformBlockBinding( GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding ) { - void (*func_glUniformBlockBinding)( GLuint, GLuint, GLuint ) = extension_funcs[EXT_glUniformBlockBinding]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", program, uniformBlockIndex, uniformBlockBinding ); - func_glUniformBlockBinding( program, uniformBlockIndex, uniformBlockBinding ); + funcs->ext.p_glUniformBlockBinding( program, uniformBlockIndex, uniformBlockBinding ); } static void WINAPI wine_glUniformBufferEXT( GLuint program, GLint location, GLuint buffer ) { - void (*func_glUniformBufferEXT)( GLuint, GLint, GLuint ) = extension_funcs[EXT_glUniformBufferEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", program, location, buffer ); - func_glUniformBufferEXT( program, location, buffer ); + funcs->ext.p_glUniformBufferEXT( program, location, buffer ); } static void WINAPI wine_glUniformHandleui64NV( GLint location, UINT64 value ) { - void (*func_glUniformHandleui64NV)( GLint, UINT64 ) = extension_funcs[EXT_glUniformHandleui64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s)\n", location, wine_dbgstr_longlong(value) ); - func_glUniformHandleui64NV( location, value ); + funcs->ext.p_glUniformHandleui64NV( location, value ); } static void WINAPI wine_glUniformHandleui64vNV( GLint location, GLsizei count, UINT64* value ) { - void (*func_glUniformHandleui64vNV)( GLint, GLsizei, UINT64* ) = extension_funcs[EXT_glUniformHandleui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniformHandleui64vNV( location, count, value ); + funcs->ext.p_glUniformHandleui64vNV( location, count, value ); } static void WINAPI wine_glUniformMatrix2dv( GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glUniformMatrix2dv)( GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glUniformMatrix2dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix2dv( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix2dv( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix2fv( GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glUniformMatrix2fv)( GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glUniformMatrix2fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix2fv( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix2fv( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix2fvARB( GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glUniformMatrix2fvARB)( GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glUniformMatrix2fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix2fvARB( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix2fvARB( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix2x3dv( GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glUniformMatrix2x3dv)( GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glUniformMatrix2x3dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix2x3dv( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix2x3dv( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix2x3fv( GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glUniformMatrix2x3fv)( GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glUniformMatrix2x3fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix2x3fv( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix2x3fv( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix2x4dv( GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glUniformMatrix2x4dv)( GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glUniformMatrix2x4dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix2x4dv( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix2x4dv( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix2x4fv( GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glUniformMatrix2x4fv)( GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glUniformMatrix2x4fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix2x4fv( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix2x4fv( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix3dv( GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glUniformMatrix3dv)( GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glUniformMatrix3dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix3dv( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix3dv( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix3fv( GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glUniformMatrix3fv)( GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glUniformMatrix3fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix3fv( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix3fv( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix3fvARB( GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glUniformMatrix3fvARB)( GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glUniformMatrix3fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix3fvARB( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix3fvARB( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix3x2dv( GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glUniformMatrix3x2dv)( GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glUniformMatrix3x2dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix3x2dv( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix3x2dv( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix3x2fv( GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glUniformMatrix3x2fv)( GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glUniformMatrix3x2fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix3x2fv( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix3x2fv( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix3x4dv( GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glUniformMatrix3x4dv)( GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glUniformMatrix3x4dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix3x4dv( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix3x4dv( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix3x4fv( GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glUniformMatrix3x4fv)( GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glUniformMatrix3x4fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix3x4fv( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix3x4fv( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix4dv( GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glUniformMatrix4dv)( GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glUniformMatrix4dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix4dv( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix4dv( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix4fv( GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glUniformMatrix4fv)( GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glUniformMatrix4fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix4fv( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix4fv( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix4fvARB( GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glUniformMatrix4fvARB)( GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glUniformMatrix4fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix4fvARB( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix4fvARB( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix4x2dv( GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glUniformMatrix4x2dv)( GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glUniformMatrix4x2dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix4x2dv( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix4x2dv( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix4x2fv( GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glUniformMatrix4x2fv)( GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glUniformMatrix4x2fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix4x2fv( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix4x2fv( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix4x3dv( GLint location, GLsizei count, GLboolean transpose, GLdouble* value ) { - void (*func_glUniformMatrix4x3dv)( GLint, GLsizei, GLboolean, GLdouble* ) = extension_funcs[EXT_glUniformMatrix4x3dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix4x3dv( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix4x3dv( location, count, transpose, value ); } static void WINAPI wine_glUniformMatrix4x3fv( GLint location, GLsizei count, GLboolean transpose, GLfloat* value ) { - void (*func_glUniformMatrix4x3fv)( GLint, GLsizei, GLboolean, GLfloat* ) = extension_funcs[EXT_glUniformMatrix4x3fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value ); - func_glUniformMatrix4x3fv( location, count, transpose, value ); + funcs->ext.p_glUniformMatrix4x3fv( location, count, transpose, value ); } static void WINAPI wine_glUniformSubroutinesuiv( GLenum shadertype, GLsizei count, GLuint* indices ) { - void (*func_glUniformSubroutinesuiv)( GLenum, GLsizei, GLuint* ) = extension_funcs[EXT_glUniformSubroutinesuiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", shadertype, count, indices ); - func_glUniformSubroutinesuiv( shadertype, count, indices ); + funcs->ext.p_glUniformSubroutinesuiv( shadertype, count, indices ); } static void WINAPI wine_glUniformui64NV( GLint location, UINT64 value ) { - void (*func_glUniformui64NV)( GLint, UINT64 ) = extension_funcs[EXT_glUniformui64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s)\n", location, wine_dbgstr_longlong(value) ); - func_glUniformui64NV( location, value ); + funcs->ext.p_glUniformui64NV( location, value ); } static void WINAPI wine_glUniformui64vNV( GLint location, GLsizei count, UINT64* value ) { - void (*func_glUniformui64vNV)( GLint, GLsizei, UINT64* ) = extension_funcs[EXT_glUniformui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", location, count, value ); - func_glUniformui64vNV( location, count, value ); + funcs->ext.p_glUniformui64vNV( location, count, value ); } static void WINAPI wine_glUnlockArraysEXT( void ) { - void (*func_glUnlockArraysEXT)( void ) = extension_funcs[EXT_glUnlockArraysEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glUnlockArraysEXT( ); + funcs->ext.p_glUnlockArraysEXT( ); } static GLboolean WINAPI wine_glUnmapBuffer( GLenum target ) { - GLboolean (*func_glUnmapBuffer)( GLenum ) = extension_funcs[EXT_glUnmapBuffer]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", target ); - return func_glUnmapBuffer( target ); + return funcs->ext.p_glUnmapBuffer( target ); } static GLboolean WINAPI wine_glUnmapBufferARB( GLenum target ) { - GLboolean (*func_glUnmapBufferARB)( GLenum ) = extension_funcs[EXT_glUnmapBufferARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", target ); - return func_glUnmapBufferARB( target ); + return funcs->ext.p_glUnmapBufferARB( target ); } static GLboolean WINAPI wine_glUnmapNamedBufferEXT( GLuint buffer ) { - GLboolean (*func_glUnmapNamedBufferEXT)( GLuint ) = extension_funcs[EXT_glUnmapNamedBufferEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", buffer ); - return func_glUnmapNamedBufferEXT( buffer ); + return funcs->ext.p_glUnmapNamedBufferEXT( buffer ); } static void WINAPI wine_glUnmapObjectBufferATI( GLuint buffer ) { - void (*func_glUnmapObjectBufferATI)( GLuint ) = extension_funcs[EXT_glUnmapObjectBufferATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", buffer ); - func_glUnmapObjectBufferATI( buffer ); + funcs->ext.p_glUnmapObjectBufferATI( buffer ); } static void WINAPI wine_glUpdateObjectBufferATI( GLuint buffer, GLuint offset, GLsizei size, GLvoid* pointer, GLenum preserve ) { - void (*func_glUpdateObjectBufferATI)( GLuint, GLuint, GLsizei, GLvoid*, GLenum ) = extension_funcs[EXT_glUpdateObjectBufferATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %d)\n", buffer, offset, size, pointer, preserve ); - func_glUpdateObjectBufferATI( buffer, offset, size, pointer, preserve ); + funcs->ext.p_glUpdateObjectBufferATI( buffer, offset, size, pointer, preserve ); } static void WINAPI wine_glUseProgram( GLuint program ) { - void (*func_glUseProgram)( GLuint ) = extension_funcs[EXT_glUseProgram]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", program ); - func_glUseProgram( program ); + funcs->ext.p_glUseProgram( program ); } static void WINAPI wine_glUseProgramObjectARB( unsigned int programObj ) { - void (*func_glUseProgramObjectARB)( unsigned int ) = extension_funcs[EXT_glUseProgramObjectARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", programObj ); - func_glUseProgramObjectARB( programObj ); + funcs->ext.p_glUseProgramObjectARB( programObj ); } static void WINAPI wine_glUseProgramStages( GLuint pipeline, GLbitfield stages, GLuint program ) { - void (*func_glUseProgramStages)( GLuint, GLbitfield, GLuint ) = extension_funcs[EXT_glUseProgramStages]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", pipeline, stages, program ); - func_glUseProgramStages( pipeline, stages, program ); + funcs->ext.p_glUseProgramStages( pipeline, stages, program ); } static void WINAPI wine_glUseShaderProgramEXT( GLenum type, GLuint program ) { - void (*func_glUseShaderProgramEXT)( GLenum, GLuint ) = extension_funcs[EXT_glUseShaderProgramEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", type, program ); - func_glUseShaderProgramEXT( type, program ); + funcs->ext.p_glUseShaderProgramEXT( type, program ); } static void WINAPI wine_glVDPAUFiniNV( void ) { - void (*func_glVDPAUFiniNV)( void ) = extension_funcs[EXT_glVDPAUFiniNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("()\n"); - func_glVDPAUFiniNV( ); + funcs->ext.p_glVDPAUFiniNV( ); } static void WINAPI wine_glVDPAUGetSurfaceivNV( INT_PTR surface, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values ) { - void (*func_glVDPAUGetSurfaceivNV)( INT_PTR, GLenum, GLsizei, GLsizei*, GLint* ) = extension_funcs[EXT_glVDPAUGetSurfaceivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%ld, %d, %d, %p, %p)\n", surface, pname, bufSize, length, values ); - func_glVDPAUGetSurfaceivNV( surface, pname, bufSize, length, values ); + funcs->ext.p_glVDPAUGetSurfaceivNV( surface, pname, bufSize, length, values ); } static void WINAPI wine_glVDPAUInitNV( GLvoid* vdpDevice, GLvoid* getProcAddress ) { - void (*func_glVDPAUInitNV)( GLvoid*, GLvoid* ) = extension_funcs[EXT_glVDPAUInitNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %p)\n", vdpDevice, getProcAddress ); - func_glVDPAUInitNV( vdpDevice, getProcAddress ); + funcs->ext.p_glVDPAUInitNV( vdpDevice, getProcAddress ); } static void WINAPI wine_glVDPAUIsSurfaceNV( INT_PTR surface ) { - void (*func_glVDPAUIsSurfaceNV)( INT_PTR ) = extension_funcs[EXT_glVDPAUIsSurfaceNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%ld)\n", surface ); - func_glVDPAUIsSurfaceNV( surface ); + funcs->ext.p_glVDPAUIsSurfaceNV( surface ); } static void WINAPI wine_glVDPAUMapSurfacesNV( GLsizei numSurfaces, INT_PTR* surfaces ) { - void (*func_glVDPAUMapSurfacesNV)( GLsizei, INT_PTR* ) = extension_funcs[EXT_glVDPAUMapSurfacesNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", numSurfaces, surfaces ); - func_glVDPAUMapSurfacesNV( numSurfaces, surfaces ); + funcs->ext.p_glVDPAUMapSurfacesNV( numSurfaces, surfaces ); } static INT_PTR WINAPI wine_glVDPAURegisterOutputSurfaceNV( GLvoid* vdpSurface, GLenum target, GLsizei numTextureNames, GLuint* textureNames ) { - INT_PTR (*func_glVDPAURegisterOutputSurfaceNV)( GLvoid*, GLenum, GLsizei, GLuint* ) = extension_funcs[EXT_glVDPAURegisterOutputSurfaceNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %d, %d, %p)\n", vdpSurface, target, numTextureNames, textureNames ); - return func_glVDPAURegisterOutputSurfaceNV( vdpSurface, target, numTextureNames, textureNames ); + return funcs->ext.p_glVDPAURegisterOutputSurfaceNV( vdpSurface, target, numTextureNames, textureNames ); } static INT_PTR WINAPI wine_glVDPAURegisterVideoSurfaceNV( GLvoid* vdpSurface, GLenum target, GLsizei numTextureNames, GLuint* textureNames ) { - INT_PTR (*func_glVDPAURegisterVideoSurfaceNV)( GLvoid*, GLenum, GLsizei, GLuint* ) = extension_funcs[EXT_glVDPAURegisterVideoSurfaceNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %d, %d, %p)\n", vdpSurface, target, numTextureNames, textureNames ); - return func_glVDPAURegisterVideoSurfaceNV( vdpSurface, target, numTextureNames, textureNames ); + return funcs->ext.p_glVDPAURegisterVideoSurfaceNV( vdpSurface, target, numTextureNames, textureNames ); } static void WINAPI wine_glVDPAUSurfaceAccessNV( INT_PTR surface, GLenum access ) { - void (*func_glVDPAUSurfaceAccessNV)( INT_PTR, GLenum ) = extension_funcs[EXT_glVDPAUSurfaceAccessNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%ld, %d)\n", surface, access ); - func_glVDPAUSurfaceAccessNV( surface, access ); + funcs->ext.p_glVDPAUSurfaceAccessNV( surface, access ); } static void WINAPI wine_glVDPAUUnmapSurfacesNV( GLsizei numSurface, INT_PTR* surfaces ) { - void (*func_glVDPAUUnmapSurfacesNV)( GLsizei, INT_PTR* ) = extension_funcs[EXT_glVDPAUUnmapSurfacesNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", numSurface, surfaces ); - func_glVDPAUUnmapSurfacesNV( numSurface, surfaces ); + funcs->ext.p_glVDPAUUnmapSurfacesNV( numSurface, surfaces ); } static void WINAPI wine_glVDPAUUnregisterSurfaceNV( INT_PTR surface ) { - void (*func_glVDPAUUnregisterSurfaceNV)( INT_PTR ) = extension_funcs[EXT_glVDPAUUnregisterSurfaceNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%ld)\n", surface ); - func_glVDPAUUnregisterSurfaceNV( surface ); + funcs->ext.p_glVDPAUUnregisterSurfaceNV( surface ); } static void WINAPI wine_glValidateProgram( GLuint program ) { - void (*func_glValidateProgram)( GLuint ) = extension_funcs[EXT_glValidateProgram]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", program ); - func_glValidateProgram( program ); + funcs->ext.p_glValidateProgram( program ); } static void WINAPI wine_glValidateProgramARB( unsigned int programObj ) { - void (*func_glValidateProgramARB)( unsigned int ) = extension_funcs[EXT_glValidateProgramARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", programObj ); - func_glValidateProgramARB( programObj ); + funcs->ext.p_glValidateProgramARB( programObj ); } static void WINAPI wine_glValidateProgramPipeline( GLuint pipeline ) { - void (*func_glValidateProgramPipeline)( GLuint ) = extension_funcs[EXT_glValidateProgramPipeline]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", pipeline ); - func_glValidateProgramPipeline( pipeline ); + funcs->ext.p_glValidateProgramPipeline( pipeline ); } static void WINAPI wine_glVariantArrayObjectATI( GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset ) { - void (*func_glVariantArrayObjectATI)( GLuint, GLenum, GLsizei, GLuint, GLuint ) = extension_funcs[EXT_glVariantArrayObjectATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", id, type, stride, buffer, offset ); - func_glVariantArrayObjectATI( id, type, stride, buffer, offset ); + funcs->ext.p_glVariantArrayObjectATI( id, type, stride, buffer, offset ); } static void WINAPI wine_glVariantPointerEXT( GLuint id, GLenum type, GLuint stride, GLvoid* addr ) { - void (*func_glVariantPointerEXT)( GLuint, GLenum, GLuint, GLvoid* ) = extension_funcs[EXT_glVariantPointerEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", id, type, stride, addr ); - func_glVariantPointerEXT( id, type, stride, addr ); + funcs->ext.p_glVariantPointerEXT( id, type, stride, addr ); } static void WINAPI wine_glVariantbvEXT( GLuint id, GLbyte* addr ) { - void (*func_glVariantbvEXT)( GLuint, GLbyte* ) = extension_funcs[EXT_glVariantbvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", id, addr ); - func_glVariantbvEXT( id, addr ); + funcs->ext.p_glVariantbvEXT( id, addr ); } static void WINAPI wine_glVariantdvEXT( GLuint id, GLdouble* addr ) { - void (*func_glVariantdvEXT)( GLuint, GLdouble* ) = extension_funcs[EXT_glVariantdvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", id, addr ); - func_glVariantdvEXT( id, addr ); + funcs->ext.p_glVariantdvEXT( id, addr ); } static void WINAPI wine_glVariantfvEXT( GLuint id, GLfloat* addr ) { - void (*func_glVariantfvEXT)( GLuint, GLfloat* ) = extension_funcs[EXT_glVariantfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", id, addr ); - func_glVariantfvEXT( id, addr ); + funcs->ext.p_glVariantfvEXT( id, addr ); } static void WINAPI wine_glVariantivEXT( GLuint id, GLint* addr ) { - void (*func_glVariantivEXT)( GLuint, GLint* ) = extension_funcs[EXT_glVariantivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", id, addr ); - func_glVariantivEXT( id, addr ); + funcs->ext.p_glVariantivEXT( id, addr ); } static void WINAPI wine_glVariantsvEXT( GLuint id, GLshort* addr ) { - void (*func_glVariantsvEXT)( GLuint, GLshort* ) = extension_funcs[EXT_glVariantsvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", id, addr ); - func_glVariantsvEXT( id, addr ); + funcs->ext.p_glVariantsvEXT( id, addr ); } static void WINAPI wine_glVariantubvEXT( GLuint id, GLubyte* addr ) { - void (*func_glVariantubvEXT)( GLuint, GLubyte* ) = extension_funcs[EXT_glVariantubvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", id, addr ); - func_glVariantubvEXT( id, addr ); + funcs->ext.p_glVariantubvEXT( id, addr ); } static void WINAPI wine_glVariantuivEXT( GLuint id, GLuint* addr ) { - void (*func_glVariantuivEXT)( GLuint, GLuint* ) = extension_funcs[EXT_glVariantuivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", id, addr ); - func_glVariantuivEXT( id, addr ); + funcs->ext.p_glVariantuivEXT( id, addr ); } static void WINAPI wine_glVariantusvEXT( GLuint id, GLushort* addr ) { - void (*func_glVariantusvEXT)( GLuint, GLushort* ) = extension_funcs[EXT_glVariantusvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", id, addr ); - func_glVariantusvEXT( id, addr ); + funcs->ext.p_glVariantusvEXT( id, addr ); } static void WINAPI wine_glVertex2hNV( unsigned short x, unsigned short y ) { - void (*func_glVertex2hNV)( unsigned short, unsigned short ) = extension_funcs[EXT_glVertex2hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", x, y ); - func_glVertex2hNV( x, y ); + funcs->ext.p_glVertex2hNV( x, y ); } static void WINAPI wine_glVertex2hvNV( unsigned short* v ) { - void (*func_glVertex2hvNV)( unsigned short* ) = extension_funcs[EXT_glVertex2hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glVertex2hvNV( v ); + funcs->ext.p_glVertex2hvNV( v ); } static void WINAPI wine_glVertex3hNV( unsigned short x, unsigned short y, unsigned short z ) { - void (*func_glVertex3hNV)( unsigned short, unsigned short, unsigned short ) = extension_funcs[EXT_glVertex3hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", x, y, z ); - func_glVertex3hNV( x, y, z ); + funcs->ext.p_glVertex3hNV( x, y, z ); } static void WINAPI wine_glVertex3hvNV( unsigned short* v ) { - void (*func_glVertex3hvNV)( unsigned short* ) = extension_funcs[EXT_glVertex3hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glVertex3hvNV( v ); + funcs->ext.p_glVertex3hvNV( v ); } static void WINAPI wine_glVertex4hNV( unsigned short x, unsigned short y, unsigned short z, unsigned short w ) { - void (*func_glVertex4hNV)( unsigned short, unsigned short, unsigned short, unsigned short ) = extension_funcs[EXT_glVertex4hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", x, y, z, w ); - func_glVertex4hNV( x, y, z, w ); + funcs->ext.p_glVertex4hNV( x, y, z, w ); } static void WINAPI wine_glVertex4hvNV( unsigned short* v ) { - void (*func_glVertex4hvNV)( unsigned short* ) = extension_funcs[EXT_glVertex4hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glVertex4hvNV( v ); + funcs->ext.p_glVertex4hvNV( v ); } static void WINAPI wine_glVertexArrayParameteriAPPLE( GLenum pname, GLint param ) { - void (*func_glVertexArrayParameteriAPPLE)( GLenum, GLint ) = extension_funcs[EXT_glVertexArrayParameteriAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", pname, param ); - func_glVertexArrayParameteriAPPLE( pname, param ); + funcs->ext.p_glVertexArrayParameteriAPPLE( pname, param ); } static void WINAPI wine_glVertexArrayRangeAPPLE( GLsizei length, GLvoid* pointer ) { - void (*func_glVertexArrayRangeAPPLE)( GLsizei, GLvoid* ) = extension_funcs[EXT_glVertexArrayRangeAPPLE]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", length, pointer ); - func_glVertexArrayRangeAPPLE( length, pointer ); + funcs->ext.p_glVertexArrayRangeAPPLE( length, pointer ); } static void WINAPI wine_glVertexArrayRangeNV( GLsizei length, GLvoid* pointer ) { - void (*func_glVertexArrayRangeNV)( GLsizei, GLvoid* ) = extension_funcs[EXT_glVertexArrayRangeNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", length, pointer ); - func_glVertexArrayRangeNV( length, pointer ); + funcs->ext.p_glVertexArrayRangeNV( length, pointer ); } static void WINAPI wine_glVertexArrayVertexAttribLOffsetEXT( GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, INT_PTR offset ) { - void (*func_glVertexArrayVertexAttribLOffsetEXT)( GLuint, GLuint, GLuint, GLint, GLenum, GLsizei, INT_PTR ) = extension_funcs[EXT_glVertexArrayVertexAttribLOffsetEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %ld)\n", vaobj, buffer, index, size, type, stride, offset ); - func_glVertexArrayVertexAttribLOffsetEXT( vaobj, buffer, index, size, type, stride, offset ); + funcs->ext.p_glVertexArrayVertexAttribLOffsetEXT( vaobj, buffer, index, size, type, stride, offset ); } static void WINAPI wine_glVertexAttrib1d( GLuint index, GLdouble x ) { - void (*func_glVertexAttrib1d)( GLuint, GLdouble ) = extension_funcs[EXT_glVertexAttrib1d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", index, x ); - func_glVertexAttrib1d( index, x ); + funcs->ext.p_glVertexAttrib1d( index, x ); } static void WINAPI wine_glVertexAttrib1dARB( GLuint index, GLdouble x ) { - void (*func_glVertexAttrib1dARB)( GLuint, GLdouble ) = extension_funcs[EXT_glVertexAttrib1dARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", index, x ); - func_glVertexAttrib1dARB( index, x ); + funcs->ext.p_glVertexAttrib1dARB( index, x ); } static void WINAPI wine_glVertexAttrib1dNV( GLuint index, GLdouble x ) { - void (*func_glVertexAttrib1dNV)( GLuint, GLdouble ) = extension_funcs[EXT_glVertexAttrib1dNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", index, x ); - func_glVertexAttrib1dNV( index, x ); + funcs->ext.p_glVertexAttrib1dNV( index, x ); } static void WINAPI wine_glVertexAttrib1dv( GLuint index, GLdouble* v ) { - void (*func_glVertexAttrib1dv)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttrib1dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib1dv( index, v ); + funcs->ext.p_glVertexAttrib1dv( index, v ); } static void WINAPI wine_glVertexAttrib1dvARB( GLuint index, GLdouble* v ) { - void (*func_glVertexAttrib1dvARB)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttrib1dvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib1dvARB( index, v ); + funcs->ext.p_glVertexAttrib1dvARB( index, v ); } static void WINAPI wine_glVertexAttrib1dvNV( GLuint index, GLdouble* v ) { - void (*func_glVertexAttrib1dvNV)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttrib1dvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib1dvNV( index, v ); + funcs->ext.p_glVertexAttrib1dvNV( index, v ); } static void WINAPI wine_glVertexAttrib1f( GLuint index, GLfloat x ) { - void (*func_glVertexAttrib1f)( GLuint, GLfloat ) = extension_funcs[EXT_glVertexAttrib1f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", index, x ); - func_glVertexAttrib1f( index, x ); + funcs->ext.p_glVertexAttrib1f( index, x ); } static void WINAPI wine_glVertexAttrib1fARB( GLuint index, GLfloat x ) { - void (*func_glVertexAttrib1fARB)( GLuint, GLfloat ) = extension_funcs[EXT_glVertexAttrib1fARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", index, x ); - func_glVertexAttrib1fARB( index, x ); + funcs->ext.p_glVertexAttrib1fARB( index, x ); } static void WINAPI wine_glVertexAttrib1fNV( GLuint index, GLfloat x ) { - void (*func_glVertexAttrib1fNV)( GLuint, GLfloat ) = extension_funcs[EXT_glVertexAttrib1fNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", index, x ); - func_glVertexAttrib1fNV( index, x ); + funcs->ext.p_glVertexAttrib1fNV( index, x ); } static void WINAPI wine_glVertexAttrib1fv( GLuint index, GLfloat* v ) { - void (*func_glVertexAttrib1fv)( GLuint, GLfloat* ) = extension_funcs[EXT_glVertexAttrib1fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib1fv( index, v ); + funcs->ext.p_glVertexAttrib1fv( index, v ); } static void WINAPI wine_glVertexAttrib1fvARB( GLuint index, GLfloat* v ) { - void (*func_glVertexAttrib1fvARB)( GLuint, GLfloat* ) = extension_funcs[EXT_glVertexAttrib1fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib1fvARB( index, v ); + funcs->ext.p_glVertexAttrib1fvARB( index, v ); } static void WINAPI wine_glVertexAttrib1fvNV( GLuint index, GLfloat* v ) { - void (*func_glVertexAttrib1fvNV)( GLuint, GLfloat* ) = extension_funcs[EXT_glVertexAttrib1fvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib1fvNV( index, v ); + funcs->ext.p_glVertexAttrib1fvNV( index, v ); } static void WINAPI wine_glVertexAttrib1hNV( GLuint index, unsigned short x ) { - void (*func_glVertexAttrib1hNV)( GLuint, unsigned short ) = extension_funcs[EXT_glVertexAttrib1hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", index, x ); - func_glVertexAttrib1hNV( index, x ); + funcs->ext.p_glVertexAttrib1hNV( index, x ); } static void WINAPI wine_glVertexAttrib1hvNV( GLuint index, unsigned short* v ) { - void (*func_glVertexAttrib1hvNV)( GLuint, unsigned short* ) = extension_funcs[EXT_glVertexAttrib1hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib1hvNV( index, v ); + funcs->ext.p_glVertexAttrib1hvNV( index, v ); } static void WINAPI wine_glVertexAttrib1s( GLuint index, GLshort x ) { - void (*func_glVertexAttrib1s)( GLuint, GLshort ) = extension_funcs[EXT_glVertexAttrib1s]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", index, x ); - func_glVertexAttrib1s( index, x ); + funcs->ext.p_glVertexAttrib1s( index, x ); } static void WINAPI wine_glVertexAttrib1sARB( GLuint index, GLshort x ) { - void (*func_glVertexAttrib1sARB)( GLuint, GLshort ) = extension_funcs[EXT_glVertexAttrib1sARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", index, x ); - func_glVertexAttrib1sARB( index, x ); + funcs->ext.p_glVertexAttrib1sARB( index, x ); } static void WINAPI wine_glVertexAttrib1sNV( GLuint index, GLshort x ) { - void (*func_glVertexAttrib1sNV)( GLuint, GLshort ) = extension_funcs[EXT_glVertexAttrib1sNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", index, x ); - func_glVertexAttrib1sNV( index, x ); + funcs->ext.p_glVertexAttrib1sNV( index, x ); } static void WINAPI wine_glVertexAttrib1sv( GLuint index, GLshort* v ) { - void (*func_glVertexAttrib1sv)( GLuint, GLshort* ) = extension_funcs[EXT_glVertexAttrib1sv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib1sv( index, v ); + funcs->ext.p_glVertexAttrib1sv( index, v ); } static void WINAPI wine_glVertexAttrib1svARB( GLuint index, GLshort* v ) { - void (*func_glVertexAttrib1svARB)( GLuint, GLshort* ) = extension_funcs[EXT_glVertexAttrib1svARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib1svARB( index, v ); + funcs->ext.p_glVertexAttrib1svARB( index, v ); } static void WINAPI wine_glVertexAttrib1svNV( GLuint index, GLshort* v ) { - void (*func_glVertexAttrib1svNV)( GLuint, GLshort* ) = extension_funcs[EXT_glVertexAttrib1svNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib1svNV( index, v ); + funcs->ext.p_glVertexAttrib1svNV( index, v ); } static void WINAPI wine_glVertexAttrib2d( GLuint index, GLdouble x, GLdouble y ) { - void (*func_glVertexAttrib2d)( GLuint, GLdouble, GLdouble ) = extension_funcs[EXT_glVertexAttrib2d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", index, x, y ); - func_glVertexAttrib2d( index, x, y ); + funcs->ext.p_glVertexAttrib2d( index, x, y ); } static void WINAPI wine_glVertexAttrib2dARB( GLuint index, GLdouble x, GLdouble y ) { - void (*func_glVertexAttrib2dARB)( GLuint, GLdouble, GLdouble ) = extension_funcs[EXT_glVertexAttrib2dARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", index, x, y ); - func_glVertexAttrib2dARB( index, x, y ); + funcs->ext.p_glVertexAttrib2dARB( index, x, y ); } static void WINAPI wine_glVertexAttrib2dNV( GLuint index, GLdouble x, GLdouble y ) { - void (*func_glVertexAttrib2dNV)( GLuint, GLdouble, GLdouble ) = extension_funcs[EXT_glVertexAttrib2dNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", index, x, y ); - func_glVertexAttrib2dNV( index, x, y ); + funcs->ext.p_glVertexAttrib2dNV( index, x, y ); } static void WINAPI wine_glVertexAttrib2dv( GLuint index, GLdouble* v ) { - void (*func_glVertexAttrib2dv)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttrib2dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib2dv( index, v ); + funcs->ext.p_glVertexAttrib2dv( index, v ); } static void WINAPI wine_glVertexAttrib2dvARB( GLuint index, GLdouble* v ) { - void (*func_glVertexAttrib2dvARB)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttrib2dvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib2dvARB( index, v ); + funcs->ext.p_glVertexAttrib2dvARB( index, v ); } static void WINAPI wine_glVertexAttrib2dvNV( GLuint index, GLdouble* v ) { - void (*func_glVertexAttrib2dvNV)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttrib2dvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib2dvNV( index, v ); + funcs->ext.p_glVertexAttrib2dvNV( index, v ); } static void WINAPI wine_glVertexAttrib2f( GLuint index, GLfloat x, GLfloat y ) { - void (*func_glVertexAttrib2f)( GLuint, GLfloat, GLfloat ) = extension_funcs[EXT_glVertexAttrib2f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", index, x, y ); - func_glVertexAttrib2f( index, x, y ); + funcs->ext.p_glVertexAttrib2f( index, x, y ); } static void WINAPI wine_glVertexAttrib2fARB( GLuint index, GLfloat x, GLfloat y ) { - void (*func_glVertexAttrib2fARB)( GLuint, GLfloat, GLfloat ) = extension_funcs[EXT_glVertexAttrib2fARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", index, x, y ); - func_glVertexAttrib2fARB( index, x, y ); + funcs->ext.p_glVertexAttrib2fARB( index, x, y ); } static void WINAPI wine_glVertexAttrib2fNV( GLuint index, GLfloat x, GLfloat y ) { - void (*func_glVertexAttrib2fNV)( GLuint, GLfloat, GLfloat ) = extension_funcs[EXT_glVertexAttrib2fNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", index, x, y ); - func_glVertexAttrib2fNV( index, x, y ); + funcs->ext.p_glVertexAttrib2fNV( index, x, y ); } static void WINAPI wine_glVertexAttrib2fv( GLuint index, GLfloat* v ) { - void (*func_glVertexAttrib2fv)( GLuint, GLfloat* ) = extension_funcs[EXT_glVertexAttrib2fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib2fv( index, v ); + funcs->ext.p_glVertexAttrib2fv( index, v ); } static void WINAPI wine_glVertexAttrib2fvARB( GLuint index, GLfloat* v ) { - void (*func_glVertexAttrib2fvARB)( GLuint, GLfloat* ) = extension_funcs[EXT_glVertexAttrib2fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib2fvARB( index, v ); + funcs->ext.p_glVertexAttrib2fvARB( index, v ); } static void WINAPI wine_glVertexAttrib2fvNV( GLuint index, GLfloat* v ) { - void (*func_glVertexAttrib2fvNV)( GLuint, GLfloat* ) = extension_funcs[EXT_glVertexAttrib2fvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib2fvNV( index, v ); + funcs->ext.p_glVertexAttrib2fvNV( index, v ); } static void WINAPI wine_glVertexAttrib2hNV( GLuint index, unsigned short x, unsigned short y ) { - void (*func_glVertexAttrib2hNV)( GLuint, unsigned short, unsigned short ) = extension_funcs[EXT_glVertexAttrib2hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", index, x, y ); - func_glVertexAttrib2hNV( index, x, y ); + funcs->ext.p_glVertexAttrib2hNV( index, x, y ); } static void WINAPI wine_glVertexAttrib2hvNV( GLuint index, unsigned short* v ) { - void (*func_glVertexAttrib2hvNV)( GLuint, unsigned short* ) = extension_funcs[EXT_glVertexAttrib2hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib2hvNV( index, v ); + funcs->ext.p_glVertexAttrib2hvNV( index, v ); } static void WINAPI wine_glVertexAttrib2s( GLuint index, GLshort x, GLshort y ) { - void (*func_glVertexAttrib2s)( GLuint, GLshort, GLshort ) = extension_funcs[EXT_glVertexAttrib2s]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", index, x, y ); - func_glVertexAttrib2s( index, x, y ); + funcs->ext.p_glVertexAttrib2s( index, x, y ); } static void WINAPI wine_glVertexAttrib2sARB( GLuint index, GLshort x, GLshort y ) { - void (*func_glVertexAttrib2sARB)( GLuint, GLshort, GLshort ) = extension_funcs[EXT_glVertexAttrib2sARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", index, x, y ); - func_glVertexAttrib2sARB( index, x, y ); + funcs->ext.p_glVertexAttrib2sARB( index, x, y ); } static void WINAPI wine_glVertexAttrib2sNV( GLuint index, GLshort x, GLshort y ) { - void (*func_glVertexAttrib2sNV)( GLuint, GLshort, GLshort ) = extension_funcs[EXT_glVertexAttrib2sNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", index, x, y ); - func_glVertexAttrib2sNV( index, x, y ); + funcs->ext.p_glVertexAttrib2sNV( index, x, y ); } static void WINAPI wine_glVertexAttrib2sv( GLuint index, GLshort* v ) { - void (*func_glVertexAttrib2sv)( GLuint, GLshort* ) = extension_funcs[EXT_glVertexAttrib2sv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib2sv( index, v ); + funcs->ext.p_glVertexAttrib2sv( index, v ); } static void WINAPI wine_glVertexAttrib2svARB( GLuint index, GLshort* v ) { - void (*func_glVertexAttrib2svARB)( GLuint, GLshort* ) = extension_funcs[EXT_glVertexAttrib2svARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib2svARB( index, v ); + funcs->ext.p_glVertexAttrib2svARB( index, v ); } static void WINAPI wine_glVertexAttrib2svNV( GLuint index, GLshort* v ) { - void (*func_glVertexAttrib2svNV)( GLuint, GLshort* ) = extension_funcs[EXT_glVertexAttrib2svNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib2svNV( index, v ); + funcs->ext.p_glVertexAttrib2svNV( index, v ); } static void WINAPI wine_glVertexAttrib3d( GLuint index, GLdouble x, GLdouble y, GLdouble z ) { - void (*func_glVertexAttrib3d)( GLuint, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glVertexAttrib3d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", index, x, y, z ); - func_glVertexAttrib3d( index, x, y, z ); + funcs->ext.p_glVertexAttrib3d( index, x, y, z ); } static void WINAPI wine_glVertexAttrib3dARB( GLuint index, GLdouble x, GLdouble y, GLdouble z ) { - void (*func_glVertexAttrib3dARB)( GLuint, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glVertexAttrib3dARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", index, x, y, z ); - func_glVertexAttrib3dARB( index, x, y, z ); + funcs->ext.p_glVertexAttrib3dARB( index, x, y, z ); } static void WINAPI wine_glVertexAttrib3dNV( GLuint index, GLdouble x, GLdouble y, GLdouble z ) { - void (*func_glVertexAttrib3dNV)( GLuint, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glVertexAttrib3dNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", index, x, y, z ); - func_glVertexAttrib3dNV( index, x, y, z ); + funcs->ext.p_glVertexAttrib3dNV( index, x, y, z ); } static void WINAPI wine_glVertexAttrib3dv( GLuint index, GLdouble* v ) { - void (*func_glVertexAttrib3dv)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttrib3dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib3dv( index, v ); + funcs->ext.p_glVertexAttrib3dv( index, v ); } static void WINAPI wine_glVertexAttrib3dvARB( GLuint index, GLdouble* v ) { - void (*func_glVertexAttrib3dvARB)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttrib3dvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib3dvARB( index, v ); + funcs->ext.p_glVertexAttrib3dvARB( index, v ); } static void WINAPI wine_glVertexAttrib3dvNV( GLuint index, GLdouble* v ) { - void (*func_glVertexAttrib3dvNV)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttrib3dvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib3dvNV( index, v ); + funcs->ext.p_glVertexAttrib3dvNV( index, v ); } static void WINAPI wine_glVertexAttrib3f( GLuint index, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glVertexAttrib3f)( GLuint, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glVertexAttrib3f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", index, x, y, z ); - func_glVertexAttrib3f( index, x, y, z ); + funcs->ext.p_glVertexAttrib3f( index, x, y, z ); } static void WINAPI wine_glVertexAttrib3fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glVertexAttrib3fARB)( GLuint, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glVertexAttrib3fARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", index, x, y, z ); - func_glVertexAttrib3fARB( index, x, y, z ); + funcs->ext.p_glVertexAttrib3fARB( index, x, y, z ); } static void WINAPI wine_glVertexAttrib3fNV( GLuint index, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glVertexAttrib3fNV)( GLuint, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glVertexAttrib3fNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", index, x, y, z ); - func_glVertexAttrib3fNV( index, x, y, z ); + funcs->ext.p_glVertexAttrib3fNV( index, x, y, z ); } static void WINAPI wine_glVertexAttrib3fv( GLuint index, GLfloat* v ) { - void (*func_glVertexAttrib3fv)( GLuint, GLfloat* ) = extension_funcs[EXT_glVertexAttrib3fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib3fv( index, v ); + funcs->ext.p_glVertexAttrib3fv( index, v ); } static void WINAPI wine_glVertexAttrib3fvARB( GLuint index, GLfloat* v ) { - void (*func_glVertexAttrib3fvARB)( GLuint, GLfloat* ) = extension_funcs[EXT_glVertexAttrib3fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib3fvARB( index, v ); + funcs->ext.p_glVertexAttrib3fvARB( index, v ); } static void WINAPI wine_glVertexAttrib3fvNV( GLuint index, GLfloat* v ) { - void (*func_glVertexAttrib3fvNV)( GLuint, GLfloat* ) = extension_funcs[EXT_glVertexAttrib3fvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib3fvNV( index, v ); + funcs->ext.p_glVertexAttrib3fvNV( index, v ); } static void WINAPI wine_glVertexAttrib3hNV( GLuint index, unsigned short x, unsigned short y, unsigned short z ) { - void (*func_glVertexAttrib3hNV)( GLuint, unsigned short, unsigned short, unsigned short ) = extension_funcs[EXT_glVertexAttrib3hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", index, x, y, z ); - func_glVertexAttrib3hNV( index, x, y, z ); + funcs->ext.p_glVertexAttrib3hNV( index, x, y, z ); } static void WINAPI wine_glVertexAttrib3hvNV( GLuint index, unsigned short* v ) { - void (*func_glVertexAttrib3hvNV)( GLuint, unsigned short* ) = extension_funcs[EXT_glVertexAttrib3hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib3hvNV( index, v ); + funcs->ext.p_glVertexAttrib3hvNV( index, v ); } static void WINAPI wine_glVertexAttrib3s( GLuint index, GLshort x, GLshort y, GLshort z ) { - void (*func_glVertexAttrib3s)( GLuint, GLshort, GLshort, GLshort ) = extension_funcs[EXT_glVertexAttrib3s]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", index, x, y, z ); - func_glVertexAttrib3s( index, x, y, z ); + funcs->ext.p_glVertexAttrib3s( index, x, y, z ); } static void WINAPI wine_glVertexAttrib3sARB( GLuint index, GLshort x, GLshort y, GLshort z ) { - void (*func_glVertexAttrib3sARB)( GLuint, GLshort, GLshort, GLshort ) = extension_funcs[EXT_glVertexAttrib3sARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", index, x, y, z ); - func_glVertexAttrib3sARB( index, x, y, z ); + funcs->ext.p_glVertexAttrib3sARB( index, x, y, z ); } static void WINAPI wine_glVertexAttrib3sNV( GLuint index, GLshort x, GLshort y, GLshort z ) { - void (*func_glVertexAttrib3sNV)( GLuint, GLshort, GLshort, GLshort ) = extension_funcs[EXT_glVertexAttrib3sNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", index, x, y, z ); - func_glVertexAttrib3sNV( index, x, y, z ); + funcs->ext.p_glVertexAttrib3sNV( index, x, y, z ); } static void WINAPI wine_glVertexAttrib3sv( GLuint index, GLshort* v ) { - void (*func_glVertexAttrib3sv)( GLuint, GLshort* ) = extension_funcs[EXT_glVertexAttrib3sv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib3sv( index, v ); + funcs->ext.p_glVertexAttrib3sv( index, v ); } static void WINAPI wine_glVertexAttrib3svARB( GLuint index, GLshort* v ) { - void (*func_glVertexAttrib3svARB)( GLuint, GLshort* ) = extension_funcs[EXT_glVertexAttrib3svARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib3svARB( index, v ); + funcs->ext.p_glVertexAttrib3svARB( index, v ); } static void WINAPI wine_glVertexAttrib3svNV( GLuint index, GLshort* v ) { - void (*func_glVertexAttrib3svNV)( GLuint, GLshort* ) = extension_funcs[EXT_glVertexAttrib3svNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib3svNV( index, v ); + funcs->ext.p_glVertexAttrib3svNV( index, v ); } static void WINAPI wine_glVertexAttrib4Nbv( GLuint index, GLbyte* v ) { - void (*func_glVertexAttrib4Nbv)( GLuint, GLbyte* ) = extension_funcs[EXT_glVertexAttrib4Nbv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4Nbv( index, v ); + funcs->ext.p_glVertexAttrib4Nbv( index, v ); } static void WINAPI wine_glVertexAttrib4NbvARB( GLuint index, GLbyte* v ) { - void (*func_glVertexAttrib4NbvARB)( GLuint, GLbyte* ) = extension_funcs[EXT_glVertexAttrib4NbvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4NbvARB( index, v ); + funcs->ext.p_glVertexAttrib4NbvARB( index, v ); } static void WINAPI wine_glVertexAttrib4Niv( GLuint index, GLint* v ) { - void (*func_glVertexAttrib4Niv)( GLuint, GLint* ) = extension_funcs[EXT_glVertexAttrib4Niv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4Niv( index, v ); + funcs->ext.p_glVertexAttrib4Niv( index, v ); } static void WINAPI wine_glVertexAttrib4NivARB( GLuint index, GLint* v ) { - void (*func_glVertexAttrib4NivARB)( GLuint, GLint* ) = extension_funcs[EXT_glVertexAttrib4NivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4NivARB( index, v ); + funcs->ext.p_glVertexAttrib4NivARB( index, v ); } static void WINAPI wine_glVertexAttrib4Nsv( GLuint index, GLshort* v ) { - void (*func_glVertexAttrib4Nsv)( GLuint, GLshort* ) = extension_funcs[EXT_glVertexAttrib4Nsv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4Nsv( index, v ); + funcs->ext.p_glVertexAttrib4Nsv( index, v ); } static void WINAPI wine_glVertexAttrib4NsvARB( GLuint index, GLshort* v ) { - void (*func_glVertexAttrib4NsvARB)( GLuint, GLshort* ) = extension_funcs[EXT_glVertexAttrib4NsvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4NsvARB( index, v ); + funcs->ext.p_glVertexAttrib4NsvARB( index, v ); } static void WINAPI wine_glVertexAttrib4Nub( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w ) { - void (*func_glVertexAttrib4Nub)( GLuint, GLubyte, GLubyte, GLubyte, GLubyte ) = extension_funcs[EXT_glVertexAttrib4Nub]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w ); - func_glVertexAttrib4Nub( index, x, y, z, w ); + funcs->ext.p_glVertexAttrib4Nub( index, x, y, z, w ); } static void WINAPI wine_glVertexAttrib4NubARB( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w ) { - void (*func_glVertexAttrib4NubARB)( GLuint, GLubyte, GLubyte, GLubyte, GLubyte ) = extension_funcs[EXT_glVertexAttrib4NubARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w ); - func_glVertexAttrib4NubARB( index, x, y, z, w ); + funcs->ext.p_glVertexAttrib4NubARB( index, x, y, z, w ); } static void WINAPI wine_glVertexAttrib4Nubv( GLuint index, GLubyte* v ) { - void (*func_glVertexAttrib4Nubv)( GLuint, GLubyte* ) = extension_funcs[EXT_glVertexAttrib4Nubv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4Nubv( index, v ); + funcs->ext.p_glVertexAttrib4Nubv( index, v ); } static void WINAPI wine_glVertexAttrib4NubvARB( GLuint index, GLubyte* v ) { - void (*func_glVertexAttrib4NubvARB)( GLuint, GLubyte* ) = extension_funcs[EXT_glVertexAttrib4NubvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4NubvARB( index, v ); + funcs->ext.p_glVertexAttrib4NubvARB( index, v ); } static void WINAPI wine_glVertexAttrib4Nuiv( GLuint index, GLuint* v ) { - void (*func_glVertexAttrib4Nuiv)( GLuint, GLuint* ) = extension_funcs[EXT_glVertexAttrib4Nuiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4Nuiv( index, v ); + funcs->ext.p_glVertexAttrib4Nuiv( index, v ); } static void WINAPI wine_glVertexAttrib4NuivARB( GLuint index, GLuint* v ) { - void (*func_glVertexAttrib4NuivARB)( GLuint, GLuint* ) = extension_funcs[EXT_glVertexAttrib4NuivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4NuivARB( index, v ); + funcs->ext.p_glVertexAttrib4NuivARB( index, v ); } static void WINAPI wine_glVertexAttrib4Nusv( GLuint index, GLushort* v ) { - void (*func_glVertexAttrib4Nusv)( GLuint, GLushort* ) = extension_funcs[EXT_glVertexAttrib4Nusv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4Nusv( index, v ); + funcs->ext.p_glVertexAttrib4Nusv( index, v ); } static void WINAPI wine_glVertexAttrib4NusvARB( GLuint index, GLushort* v ) { - void (*func_glVertexAttrib4NusvARB)( GLuint, GLushort* ) = extension_funcs[EXT_glVertexAttrib4NusvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4NusvARB( index, v ); + funcs->ext.p_glVertexAttrib4NusvARB( index, v ); } static void WINAPI wine_glVertexAttrib4bv( GLuint index, GLbyte* v ) { - void (*func_glVertexAttrib4bv)( GLuint, GLbyte* ) = extension_funcs[EXT_glVertexAttrib4bv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4bv( index, v ); + funcs->ext.p_glVertexAttrib4bv( index, v ); } static void WINAPI wine_glVertexAttrib4bvARB( GLuint index, GLbyte* v ) { - void (*func_glVertexAttrib4bvARB)( GLuint, GLbyte* ) = extension_funcs[EXT_glVertexAttrib4bvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4bvARB( index, v ); + funcs->ext.p_glVertexAttrib4bvARB( index, v ); } static void WINAPI wine_glVertexAttrib4d( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { - void (*func_glVertexAttrib4d)( GLuint, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glVertexAttrib4d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", index, x, y, z, w ); - func_glVertexAttrib4d( index, x, y, z, w ); + funcs->ext.p_glVertexAttrib4d( index, x, y, z, w ); } static void WINAPI wine_glVertexAttrib4dARB( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { - void (*func_glVertexAttrib4dARB)( GLuint, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glVertexAttrib4dARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", index, x, y, z, w ); - func_glVertexAttrib4dARB( index, x, y, z, w ); + funcs->ext.p_glVertexAttrib4dARB( index, x, y, z, w ); } static void WINAPI wine_glVertexAttrib4dNV( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { - void (*func_glVertexAttrib4dNV)( GLuint, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glVertexAttrib4dNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", index, x, y, z, w ); - func_glVertexAttrib4dNV( index, x, y, z, w ); + funcs->ext.p_glVertexAttrib4dNV( index, x, y, z, w ); } static void WINAPI wine_glVertexAttrib4dv( GLuint index, GLdouble* v ) { - void (*func_glVertexAttrib4dv)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttrib4dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4dv( index, v ); + funcs->ext.p_glVertexAttrib4dv( index, v ); } static void WINAPI wine_glVertexAttrib4dvARB( GLuint index, GLdouble* v ) { - void (*func_glVertexAttrib4dvARB)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttrib4dvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4dvARB( index, v ); + funcs->ext.p_glVertexAttrib4dvARB( index, v ); } static void WINAPI wine_glVertexAttrib4dvNV( GLuint index, GLdouble* v ) { - void (*func_glVertexAttrib4dvNV)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttrib4dvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4dvNV( index, v ); + funcs->ext.p_glVertexAttrib4dvNV( index, v ); } static void WINAPI wine_glVertexAttrib4f( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { - void (*func_glVertexAttrib4f)( GLuint, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glVertexAttrib4f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", index, x, y, z, w ); - func_glVertexAttrib4f( index, x, y, z, w ); + funcs->ext.p_glVertexAttrib4f( index, x, y, z, w ); } static void WINAPI wine_glVertexAttrib4fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { - void (*func_glVertexAttrib4fARB)( GLuint, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glVertexAttrib4fARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", index, x, y, z, w ); - func_glVertexAttrib4fARB( index, x, y, z, w ); + funcs->ext.p_glVertexAttrib4fARB( index, x, y, z, w ); } static void WINAPI wine_glVertexAttrib4fNV( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { - void (*func_glVertexAttrib4fNV)( GLuint, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glVertexAttrib4fNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", index, x, y, z, w ); - func_glVertexAttrib4fNV( index, x, y, z, w ); + funcs->ext.p_glVertexAttrib4fNV( index, x, y, z, w ); } static void WINAPI wine_glVertexAttrib4fv( GLuint index, GLfloat* v ) { - void (*func_glVertexAttrib4fv)( GLuint, GLfloat* ) = extension_funcs[EXT_glVertexAttrib4fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4fv( index, v ); + funcs->ext.p_glVertexAttrib4fv( index, v ); } static void WINAPI wine_glVertexAttrib4fvARB( GLuint index, GLfloat* v ) { - void (*func_glVertexAttrib4fvARB)( GLuint, GLfloat* ) = extension_funcs[EXT_glVertexAttrib4fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4fvARB( index, v ); + funcs->ext.p_glVertexAttrib4fvARB( index, v ); } static void WINAPI wine_glVertexAttrib4fvNV( GLuint index, GLfloat* v ) { - void (*func_glVertexAttrib4fvNV)( GLuint, GLfloat* ) = extension_funcs[EXT_glVertexAttrib4fvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4fvNV( index, v ); + funcs->ext.p_glVertexAttrib4fvNV( index, v ); } static void WINAPI wine_glVertexAttrib4hNV( GLuint index, unsigned short x, unsigned short y, unsigned short z, unsigned short w ) { - void (*func_glVertexAttrib4hNV)( GLuint, unsigned short, unsigned short, unsigned short, unsigned short ) = extension_funcs[EXT_glVertexAttrib4hNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w ); - func_glVertexAttrib4hNV( index, x, y, z, w ); + funcs->ext.p_glVertexAttrib4hNV( index, x, y, z, w ); } static void WINAPI wine_glVertexAttrib4hvNV( GLuint index, unsigned short* v ) { - void (*func_glVertexAttrib4hvNV)( GLuint, unsigned short* ) = extension_funcs[EXT_glVertexAttrib4hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4hvNV( index, v ); + funcs->ext.p_glVertexAttrib4hvNV( index, v ); } static void WINAPI wine_glVertexAttrib4iv( GLuint index, GLint* v ) { - void (*func_glVertexAttrib4iv)( GLuint, GLint* ) = extension_funcs[EXT_glVertexAttrib4iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4iv( index, v ); + funcs->ext.p_glVertexAttrib4iv( index, v ); } static void WINAPI wine_glVertexAttrib4ivARB( GLuint index, GLint* v ) { - void (*func_glVertexAttrib4ivARB)( GLuint, GLint* ) = extension_funcs[EXT_glVertexAttrib4ivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4ivARB( index, v ); + funcs->ext.p_glVertexAttrib4ivARB( index, v ); } static void WINAPI wine_glVertexAttrib4s( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w ) { - void (*func_glVertexAttrib4s)( GLuint, GLshort, GLshort, GLshort, GLshort ) = extension_funcs[EXT_glVertexAttrib4s]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w ); - func_glVertexAttrib4s( index, x, y, z, w ); + funcs->ext.p_glVertexAttrib4s( index, x, y, z, w ); } static void WINAPI wine_glVertexAttrib4sARB( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w ) { - void (*func_glVertexAttrib4sARB)( GLuint, GLshort, GLshort, GLshort, GLshort ) = extension_funcs[EXT_glVertexAttrib4sARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w ); - func_glVertexAttrib4sARB( index, x, y, z, w ); + funcs->ext.p_glVertexAttrib4sARB( index, x, y, z, w ); } static void WINAPI wine_glVertexAttrib4sNV( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w ) { - void (*func_glVertexAttrib4sNV)( GLuint, GLshort, GLshort, GLshort, GLshort ) = extension_funcs[EXT_glVertexAttrib4sNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w ); - func_glVertexAttrib4sNV( index, x, y, z, w ); + funcs->ext.p_glVertexAttrib4sNV( index, x, y, z, w ); } static void WINAPI wine_glVertexAttrib4sv( GLuint index, GLshort* v ) { - void (*func_glVertexAttrib4sv)( GLuint, GLshort* ) = extension_funcs[EXT_glVertexAttrib4sv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4sv( index, v ); + funcs->ext.p_glVertexAttrib4sv( index, v ); } static void WINAPI wine_glVertexAttrib4svARB( GLuint index, GLshort* v ) { - void (*func_glVertexAttrib4svARB)( GLuint, GLshort* ) = extension_funcs[EXT_glVertexAttrib4svARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4svARB( index, v ); + funcs->ext.p_glVertexAttrib4svARB( index, v ); } static void WINAPI wine_glVertexAttrib4svNV( GLuint index, GLshort* v ) { - void (*func_glVertexAttrib4svNV)( GLuint, GLshort* ) = extension_funcs[EXT_glVertexAttrib4svNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4svNV( index, v ); + funcs->ext.p_glVertexAttrib4svNV( index, v ); } static void WINAPI wine_glVertexAttrib4ubNV( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w ) { - void (*func_glVertexAttrib4ubNV)( GLuint, GLubyte, GLubyte, GLubyte, GLubyte ) = extension_funcs[EXT_glVertexAttrib4ubNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w ); - func_glVertexAttrib4ubNV( index, x, y, z, w ); + funcs->ext.p_glVertexAttrib4ubNV( index, x, y, z, w ); } static void WINAPI wine_glVertexAttrib4ubv( GLuint index, GLubyte* v ) { - void (*func_glVertexAttrib4ubv)( GLuint, GLubyte* ) = extension_funcs[EXT_glVertexAttrib4ubv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4ubv( index, v ); + funcs->ext.p_glVertexAttrib4ubv( index, v ); } static void WINAPI wine_glVertexAttrib4ubvARB( GLuint index, GLubyte* v ) { - void (*func_glVertexAttrib4ubvARB)( GLuint, GLubyte* ) = extension_funcs[EXT_glVertexAttrib4ubvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4ubvARB( index, v ); + funcs->ext.p_glVertexAttrib4ubvARB( index, v ); } static void WINAPI wine_glVertexAttrib4ubvNV( GLuint index, GLubyte* v ) { - void (*func_glVertexAttrib4ubvNV)( GLuint, GLubyte* ) = extension_funcs[EXT_glVertexAttrib4ubvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4ubvNV( index, v ); + funcs->ext.p_glVertexAttrib4ubvNV( index, v ); } static void WINAPI wine_glVertexAttrib4uiv( GLuint index, GLuint* v ) { - void (*func_glVertexAttrib4uiv)( GLuint, GLuint* ) = extension_funcs[EXT_glVertexAttrib4uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4uiv( index, v ); + funcs->ext.p_glVertexAttrib4uiv( index, v ); } static void WINAPI wine_glVertexAttrib4uivARB( GLuint index, GLuint* v ) { - void (*func_glVertexAttrib4uivARB)( GLuint, GLuint* ) = extension_funcs[EXT_glVertexAttrib4uivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4uivARB( index, v ); + funcs->ext.p_glVertexAttrib4uivARB( index, v ); } static void WINAPI wine_glVertexAttrib4usv( GLuint index, GLushort* v ) { - void (*func_glVertexAttrib4usv)( GLuint, GLushort* ) = extension_funcs[EXT_glVertexAttrib4usv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4usv( index, v ); + funcs->ext.p_glVertexAttrib4usv( index, v ); } static void WINAPI wine_glVertexAttrib4usvARB( GLuint index, GLushort* v ) { - void (*func_glVertexAttrib4usvARB)( GLuint, GLushort* ) = extension_funcs[EXT_glVertexAttrib4usvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttrib4usvARB( index, v ); + funcs->ext.p_glVertexAttrib4usvARB( index, v ); } static void WINAPI wine_glVertexAttribArrayObjectATI( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset ) { - void (*func_glVertexAttribArrayObjectATI)( GLuint, GLint, GLenum, GLboolean, GLsizei, GLuint, GLuint ) = extension_funcs[EXT_glVertexAttribArrayObjectATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", index, size, type, normalized, stride, buffer, offset ); - func_glVertexAttribArrayObjectATI( index, size, type, normalized, stride, buffer, offset ); + funcs->ext.p_glVertexAttribArrayObjectATI( index, size, type, normalized, stride, buffer, offset ); } static void WINAPI wine_glVertexAttribDivisor( GLuint index, GLuint divisor ) { - void (*func_glVertexAttribDivisor)( GLuint, GLuint ) = extension_funcs[EXT_glVertexAttribDivisor]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", index, divisor ); - func_glVertexAttribDivisor( index, divisor ); + funcs->ext.p_glVertexAttribDivisor( index, divisor ); } static void WINAPI wine_glVertexAttribDivisorARB( GLuint index, GLuint divisor ) { - void (*func_glVertexAttribDivisorARB)( GLuint, GLuint ) = extension_funcs[EXT_glVertexAttribDivisorARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", index, divisor ); - func_glVertexAttribDivisorARB( index, divisor ); + funcs->ext.p_glVertexAttribDivisorARB( index, divisor ); } static void WINAPI wine_glVertexAttribFormatNV( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride ) { - void (*func_glVertexAttribFormatNV)( GLuint, GLint, GLenum, GLboolean, GLsizei ) = extension_funcs[EXT_glVertexAttribFormatNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", index, size, type, normalized, stride ); - func_glVertexAttribFormatNV( index, size, type, normalized, stride ); + funcs->ext.p_glVertexAttribFormatNV( index, size, type, normalized, stride ); } static void WINAPI wine_glVertexAttribI1i( GLuint index, GLint x ) { - void (*func_glVertexAttribI1i)( GLuint, GLint ) = extension_funcs[EXT_glVertexAttribI1i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", index, x ); - func_glVertexAttribI1i( index, x ); + funcs->ext.p_glVertexAttribI1i( index, x ); } static void WINAPI wine_glVertexAttribI1iEXT( GLuint index, GLint x ) { - void (*func_glVertexAttribI1iEXT)( GLuint, GLint ) = extension_funcs[EXT_glVertexAttribI1iEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", index, x ); - func_glVertexAttribI1iEXT( index, x ); + funcs->ext.p_glVertexAttribI1iEXT( index, x ); } static void WINAPI wine_glVertexAttribI1iv( GLuint index, GLint* v ) { - void (*func_glVertexAttribI1iv)( GLuint, GLint* ) = extension_funcs[EXT_glVertexAttribI1iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI1iv( index, v ); + funcs->ext.p_glVertexAttribI1iv( index, v ); } static void WINAPI wine_glVertexAttribI1ivEXT( GLuint index, GLint* v ) { - void (*func_glVertexAttribI1ivEXT)( GLuint, GLint* ) = extension_funcs[EXT_glVertexAttribI1ivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI1ivEXT( index, v ); + funcs->ext.p_glVertexAttribI1ivEXT( index, v ); } static void WINAPI wine_glVertexAttribI1ui( GLuint index, GLuint x ) { - void (*func_glVertexAttribI1ui)( GLuint, GLuint ) = extension_funcs[EXT_glVertexAttribI1ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", index, x ); - func_glVertexAttribI1ui( index, x ); + funcs->ext.p_glVertexAttribI1ui( index, x ); } static void WINAPI wine_glVertexAttribI1uiEXT( GLuint index, GLuint x ) { - void (*func_glVertexAttribI1uiEXT)( GLuint, GLuint ) = extension_funcs[EXT_glVertexAttribI1uiEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", index, x ); - func_glVertexAttribI1uiEXT( index, x ); + funcs->ext.p_glVertexAttribI1uiEXT( index, x ); } static void WINAPI wine_glVertexAttribI1uiv( GLuint index, GLuint* v ) { - void (*func_glVertexAttribI1uiv)( GLuint, GLuint* ) = extension_funcs[EXT_glVertexAttribI1uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI1uiv( index, v ); + funcs->ext.p_glVertexAttribI1uiv( index, v ); } static void WINAPI wine_glVertexAttribI1uivEXT( GLuint index, GLuint* v ) { - void (*func_glVertexAttribI1uivEXT)( GLuint, GLuint* ) = extension_funcs[EXT_glVertexAttribI1uivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI1uivEXT( index, v ); + funcs->ext.p_glVertexAttribI1uivEXT( index, v ); } static void WINAPI wine_glVertexAttribI2i( GLuint index, GLint x, GLint y ) { - void (*func_glVertexAttribI2i)( GLuint, GLint, GLint ) = extension_funcs[EXT_glVertexAttribI2i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", index, x, y ); - func_glVertexAttribI2i( index, x, y ); + funcs->ext.p_glVertexAttribI2i( index, x, y ); } static void WINAPI wine_glVertexAttribI2iEXT( GLuint index, GLint x, GLint y ) { - void (*func_glVertexAttribI2iEXT)( GLuint, GLint, GLint ) = extension_funcs[EXT_glVertexAttribI2iEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", index, x, y ); - func_glVertexAttribI2iEXT( index, x, y ); + funcs->ext.p_glVertexAttribI2iEXT( index, x, y ); } static void WINAPI wine_glVertexAttribI2iv( GLuint index, GLint* v ) { - void (*func_glVertexAttribI2iv)( GLuint, GLint* ) = extension_funcs[EXT_glVertexAttribI2iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI2iv( index, v ); + funcs->ext.p_glVertexAttribI2iv( index, v ); } static void WINAPI wine_glVertexAttribI2ivEXT( GLuint index, GLint* v ) { - void (*func_glVertexAttribI2ivEXT)( GLuint, GLint* ) = extension_funcs[EXT_glVertexAttribI2ivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI2ivEXT( index, v ); + funcs->ext.p_glVertexAttribI2ivEXT( index, v ); } static void WINAPI wine_glVertexAttribI2ui( GLuint index, GLuint x, GLuint y ) { - void (*func_glVertexAttribI2ui)( GLuint, GLuint, GLuint ) = extension_funcs[EXT_glVertexAttribI2ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", index, x, y ); - func_glVertexAttribI2ui( index, x, y ); + funcs->ext.p_glVertexAttribI2ui( index, x, y ); } static void WINAPI wine_glVertexAttribI2uiEXT( GLuint index, GLuint x, GLuint y ) { - void (*func_glVertexAttribI2uiEXT)( GLuint, GLuint, GLuint ) = extension_funcs[EXT_glVertexAttribI2uiEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", index, x, y ); - func_glVertexAttribI2uiEXT( index, x, y ); + funcs->ext.p_glVertexAttribI2uiEXT( index, x, y ); } static void WINAPI wine_glVertexAttribI2uiv( GLuint index, GLuint* v ) { - void (*func_glVertexAttribI2uiv)( GLuint, GLuint* ) = extension_funcs[EXT_glVertexAttribI2uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI2uiv( index, v ); + funcs->ext.p_glVertexAttribI2uiv( index, v ); } static void WINAPI wine_glVertexAttribI2uivEXT( GLuint index, GLuint* v ) { - void (*func_glVertexAttribI2uivEXT)( GLuint, GLuint* ) = extension_funcs[EXT_glVertexAttribI2uivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI2uivEXT( index, v ); + funcs->ext.p_glVertexAttribI2uivEXT( index, v ); } static void WINAPI wine_glVertexAttribI3i( GLuint index, GLint x, GLint y, GLint z ) { - void (*func_glVertexAttribI3i)( GLuint, GLint, GLint, GLint ) = extension_funcs[EXT_glVertexAttribI3i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", index, x, y, z ); - func_glVertexAttribI3i( index, x, y, z ); + funcs->ext.p_glVertexAttribI3i( index, x, y, z ); } static void WINAPI wine_glVertexAttribI3iEXT( GLuint index, GLint x, GLint y, GLint z ) { - void (*func_glVertexAttribI3iEXT)( GLuint, GLint, GLint, GLint ) = extension_funcs[EXT_glVertexAttribI3iEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", index, x, y, z ); - func_glVertexAttribI3iEXT( index, x, y, z ); + funcs->ext.p_glVertexAttribI3iEXT( index, x, y, z ); } static void WINAPI wine_glVertexAttribI3iv( GLuint index, GLint* v ) { - void (*func_glVertexAttribI3iv)( GLuint, GLint* ) = extension_funcs[EXT_glVertexAttribI3iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI3iv( index, v ); + funcs->ext.p_glVertexAttribI3iv( index, v ); } static void WINAPI wine_glVertexAttribI3ivEXT( GLuint index, GLint* v ) { - void (*func_glVertexAttribI3ivEXT)( GLuint, GLint* ) = extension_funcs[EXT_glVertexAttribI3ivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI3ivEXT( index, v ); + funcs->ext.p_glVertexAttribI3ivEXT( index, v ); } static void WINAPI wine_glVertexAttribI3ui( GLuint index, GLuint x, GLuint y, GLuint z ) { - void (*func_glVertexAttribI3ui)( GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glVertexAttribI3ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", index, x, y, z ); - func_glVertexAttribI3ui( index, x, y, z ); + funcs->ext.p_glVertexAttribI3ui( index, x, y, z ); } static void WINAPI wine_glVertexAttribI3uiEXT( GLuint index, GLuint x, GLuint y, GLuint z ) { - void (*func_glVertexAttribI3uiEXT)( GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glVertexAttribI3uiEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", index, x, y, z ); - func_glVertexAttribI3uiEXT( index, x, y, z ); + funcs->ext.p_glVertexAttribI3uiEXT( index, x, y, z ); } static void WINAPI wine_glVertexAttribI3uiv( GLuint index, GLuint* v ) { - void (*func_glVertexAttribI3uiv)( GLuint, GLuint* ) = extension_funcs[EXT_glVertexAttribI3uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI3uiv( index, v ); + funcs->ext.p_glVertexAttribI3uiv( index, v ); } static void WINAPI wine_glVertexAttribI3uivEXT( GLuint index, GLuint* v ) { - void (*func_glVertexAttribI3uivEXT)( GLuint, GLuint* ) = extension_funcs[EXT_glVertexAttribI3uivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI3uivEXT( index, v ); + funcs->ext.p_glVertexAttribI3uivEXT( index, v ); } static void WINAPI wine_glVertexAttribI4bv( GLuint index, GLbyte* v ) { - void (*func_glVertexAttribI4bv)( GLuint, GLbyte* ) = extension_funcs[EXT_glVertexAttribI4bv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI4bv( index, v ); + funcs->ext.p_glVertexAttribI4bv( index, v ); } static void WINAPI wine_glVertexAttribI4bvEXT( GLuint index, GLbyte* v ) { - void (*func_glVertexAttribI4bvEXT)( GLuint, GLbyte* ) = extension_funcs[EXT_glVertexAttribI4bvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI4bvEXT( index, v ); + funcs->ext.p_glVertexAttribI4bvEXT( index, v ); } static void WINAPI wine_glVertexAttribI4i( GLuint index, GLint x, GLint y, GLint z, GLint w ) { - void (*func_glVertexAttribI4i)( GLuint, GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glVertexAttribI4i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w ); - func_glVertexAttribI4i( index, x, y, z, w ); + funcs->ext.p_glVertexAttribI4i( index, x, y, z, w ); } static void WINAPI wine_glVertexAttribI4iEXT( GLuint index, GLint x, GLint y, GLint z, GLint w ) { - void (*func_glVertexAttribI4iEXT)( GLuint, GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glVertexAttribI4iEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w ); - func_glVertexAttribI4iEXT( index, x, y, z, w ); + funcs->ext.p_glVertexAttribI4iEXT( index, x, y, z, w ); } static void WINAPI wine_glVertexAttribI4iv( GLuint index, GLint* v ) { - void (*func_glVertexAttribI4iv)( GLuint, GLint* ) = extension_funcs[EXT_glVertexAttribI4iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI4iv( index, v ); + funcs->ext.p_glVertexAttribI4iv( index, v ); } static void WINAPI wine_glVertexAttribI4ivEXT( GLuint index, GLint* v ) { - void (*func_glVertexAttribI4ivEXT)( GLuint, GLint* ) = extension_funcs[EXT_glVertexAttribI4ivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI4ivEXT( index, v ); + funcs->ext.p_glVertexAttribI4ivEXT( index, v ); } static void WINAPI wine_glVertexAttribI4sv( GLuint index, GLshort* v ) { - void (*func_glVertexAttribI4sv)( GLuint, GLshort* ) = extension_funcs[EXT_glVertexAttribI4sv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI4sv( index, v ); + funcs->ext.p_glVertexAttribI4sv( index, v ); } static void WINAPI wine_glVertexAttribI4svEXT( GLuint index, GLshort* v ) { - void (*func_glVertexAttribI4svEXT)( GLuint, GLshort* ) = extension_funcs[EXT_glVertexAttribI4svEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI4svEXT( index, v ); + funcs->ext.p_glVertexAttribI4svEXT( index, v ); } static void WINAPI wine_glVertexAttribI4ubv( GLuint index, GLubyte* v ) { - void (*func_glVertexAttribI4ubv)( GLuint, GLubyte* ) = extension_funcs[EXT_glVertexAttribI4ubv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI4ubv( index, v ); + funcs->ext.p_glVertexAttribI4ubv( index, v ); } static void WINAPI wine_glVertexAttribI4ubvEXT( GLuint index, GLubyte* v ) { - void (*func_glVertexAttribI4ubvEXT)( GLuint, GLubyte* ) = extension_funcs[EXT_glVertexAttribI4ubvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI4ubvEXT( index, v ); + funcs->ext.p_glVertexAttribI4ubvEXT( index, v ); } static void WINAPI wine_glVertexAttribI4ui( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w ) { - void (*func_glVertexAttribI4ui)( GLuint, GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glVertexAttribI4ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w ); - func_glVertexAttribI4ui( index, x, y, z, w ); + funcs->ext.p_glVertexAttribI4ui( index, x, y, z, w ); } static void WINAPI wine_glVertexAttribI4uiEXT( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w ) { - void (*func_glVertexAttribI4uiEXT)( GLuint, GLuint, GLuint, GLuint, GLuint ) = extension_funcs[EXT_glVertexAttribI4uiEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w ); - func_glVertexAttribI4uiEXT( index, x, y, z, w ); + funcs->ext.p_glVertexAttribI4uiEXT( index, x, y, z, w ); } static void WINAPI wine_glVertexAttribI4uiv( GLuint index, GLuint* v ) { - void (*func_glVertexAttribI4uiv)( GLuint, GLuint* ) = extension_funcs[EXT_glVertexAttribI4uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI4uiv( index, v ); + funcs->ext.p_glVertexAttribI4uiv( index, v ); } static void WINAPI wine_glVertexAttribI4uivEXT( GLuint index, GLuint* v ) { - void (*func_glVertexAttribI4uivEXT)( GLuint, GLuint* ) = extension_funcs[EXT_glVertexAttribI4uivEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI4uivEXT( index, v ); + funcs->ext.p_glVertexAttribI4uivEXT( index, v ); } static void WINAPI wine_glVertexAttribI4usv( GLuint index, GLushort* v ) { - void (*func_glVertexAttribI4usv)( GLuint, GLushort* ) = extension_funcs[EXT_glVertexAttribI4usv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI4usv( index, v ); + funcs->ext.p_glVertexAttribI4usv( index, v ); } static void WINAPI wine_glVertexAttribI4usvEXT( GLuint index, GLushort* v ) { - void (*func_glVertexAttribI4usvEXT)( GLuint, GLushort* ) = extension_funcs[EXT_glVertexAttribI4usvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribI4usvEXT( index, v ); + funcs->ext.p_glVertexAttribI4usvEXT( index, v ); } static void WINAPI wine_glVertexAttribIFormatNV( GLuint index, GLint size, GLenum type, GLsizei stride ) { - void (*func_glVertexAttribIFormatNV)( GLuint, GLint, GLenum, GLsizei ) = extension_funcs[EXT_glVertexAttribIFormatNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", index, size, type, stride ); - func_glVertexAttribIFormatNV( index, size, type, stride ); + funcs->ext.p_glVertexAttribIFormatNV( index, size, type, stride ); } static void WINAPI wine_glVertexAttribIPointer( GLuint index, GLint size, GLenum type, GLsizei stride, GLvoid* pointer ) { - void (*func_glVertexAttribIPointer)( GLuint, GLint, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glVertexAttribIPointer]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", index, size, type, stride, pointer ); - func_glVertexAttribIPointer( index, size, type, stride, pointer ); + funcs->ext.p_glVertexAttribIPointer( index, size, type, stride, pointer ); } static void WINAPI wine_glVertexAttribIPointerEXT( GLuint index, GLint size, GLenum type, GLsizei stride, GLvoid* pointer ) { - void (*func_glVertexAttribIPointerEXT)( GLuint, GLint, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glVertexAttribIPointerEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", index, size, type, stride, pointer ); - func_glVertexAttribIPointerEXT( index, size, type, stride, pointer ); + funcs->ext.p_glVertexAttribIPointerEXT( index, size, type, stride, pointer ); } static void WINAPI wine_glVertexAttribL1d( GLuint index, GLdouble x ) { - void (*func_glVertexAttribL1d)( GLuint, GLdouble ) = extension_funcs[EXT_glVertexAttribL1d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", index, x ); - func_glVertexAttribL1d( index, x ); + funcs->ext.p_glVertexAttribL1d( index, x ); } static void WINAPI wine_glVertexAttribL1dEXT( GLuint index, GLdouble x ) { - void (*func_glVertexAttribL1dEXT)( GLuint, GLdouble ) = extension_funcs[EXT_glVertexAttribL1dEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", index, x ); - func_glVertexAttribL1dEXT( index, x ); + funcs->ext.p_glVertexAttribL1dEXT( index, x ); } static void WINAPI wine_glVertexAttribL1dv( GLuint index, GLdouble* v ) { - void (*func_glVertexAttribL1dv)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttribL1dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribL1dv( index, v ); + funcs->ext.p_glVertexAttribL1dv( index, v ); } static void WINAPI wine_glVertexAttribL1dvEXT( GLuint index, GLdouble* v ) { - void (*func_glVertexAttribL1dvEXT)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttribL1dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribL1dvEXT( index, v ); + funcs->ext.p_glVertexAttribL1dvEXT( index, v ); } static void WINAPI wine_glVertexAttribL1i64NV( GLuint index, INT64 x ) { - void (*func_glVertexAttribL1i64NV)( GLuint, INT64 ) = extension_funcs[EXT_glVertexAttribL1i64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s)\n", index, wine_dbgstr_longlong(x) ); - func_glVertexAttribL1i64NV( index, x ); + funcs->ext.p_glVertexAttribL1i64NV( index, x ); } static void WINAPI wine_glVertexAttribL1i64vNV( GLuint index, INT64* v ) { - void (*func_glVertexAttribL1i64vNV)( GLuint, INT64* ) = extension_funcs[EXT_glVertexAttribL1i64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribL1i64vNV( index, v ); + funcs->ext.p_glVertexAttribL1i64vNV( index, v ); } static void WINAPI wine_glVertexAttribL1ui64NV( GLuint index, UINT64 x ) { - void (*func_glVertexAttribL1ui64NV)( GLuint, UINT64 ) = extension_funcs[EXT_glVertexAttribL1ui64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s)\n", index, wine_dbgstr_longlong(x) ); - func_glVertexAttribL1ui64NV( index, x ); + funcs->ext.p_glVertexAttribL1ui64NV( index, x ); } static void WINAPI wine_glVertexAttribL1ui64vNV( GLuint index, UINT64* v ) { - void (*func_glVertexAttribL1ui64vNV)( GLuint, UINT64* ) = extension_funcs[EXT_glVertexAttribL1ui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribL1ui64vNV( index, v ); + funcs->ext.p_glVertexAttribL1ui64vNV( index, v ); } static void WINAPI wine_glVertexAttribL2d( GLuint index, GLdouble x, GLdouble y ) { - void (*func_glVertexAttribL2d)( GLuint, GLdouble, GLdouble ) = extension_funcs[EXT_glVertexAttribL2d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", index, x, y ); - func_glVertexAttribL2d( index, x, y ); + funcs->ext.p_glVertexAttribL2d( index, x, y ); } static void WINAPI wine_glVertexAttribL2dEXT( GLuint index, GLdouble x, GLdouble y ) { - void (*func_glVertexAttribL2dEXT)( GLuint, GLdouble, GLdouble ) = extension_funcs[EXT_glVertexAttribL2dEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", index, x, y ); - func_glVertexAttribL2dEXT( index, x, y ); + funcs->ext.p_glVertexAttribL2dEXT( index, x, y ); } static void WINAPI wine_glVertexAttribL2dv( GLuint index, GLdouble* v ) { - void (*func_glVertexAttribL2dv)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttribL2dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribL2dv( index, v ); + funcs->ext.p_glVertexAttribL2dv( index, v ); } static void WINAPI wine_glVertexAttribL2dvEXT( GLuint index, GLdouble* v ) { - void (*func_glVertexAttribL2dvEXT)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttribL2dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribL2dvEXT( index, v ); + funcs->ext.p_glVertexAttribL2dvEXT( index, v ); } static void WINAPI wine_glVertexAttribL2i64NV( GLuint index, INT64 x, INT64 y ) { - void (*func_glVertexAttribL2i64NV)( GLuint, INT64, INT64 ) = extension_funcs[EXT_glVertexAttribL2i64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s, %s)\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) ); - func_glVertexAttribL2i64NV( index, x, y ); + funcs->ext.p_glVertexAttribL2i64NV( index, x, y ); } static void WINAPI wine_glVertexAttribL2i64vNV( GLuint index, INT64* v ) { - void (*func_glVertexAttribL2i64vNV)( GLuint, INT64* ) = extension_funcs[EXT_glVertexAttribL2i64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribL2i64vNV( index, v ); + funcs->ext.p_glVertexAttribL2i64vNV( index, v ); } static void WINAPI wine_glVertexAttribL2ui64NV( GLuint index, UINT64 x, UINT64 y ) { - void (*func_glVertexAttribL2ui64NV)( GLuint, UINT64, UINT64 ) = extension_funcs[EXT_glVertexAttribL2ui64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s, %s)\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) ); - func_glVertexAttribL2ui64NV( index, x, y ); + funcs->ext.p_glVertexAttribL2ui64NV( index, x, y ); } static void WINAPI wine_glVertexAttribL2ui64vNV( GLuint index, UINT64* v ) { - void (*func_glVertexAttribL2ui64vNV)( GLuint, UINT64* ) = extension_funcs[EXT_glVertexAttribL2ui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribL2ui64vNV( index, v ); + funcs->ext.p_glVertexAttribL2ui64vNV( index, v ); } static void WINAPI wine_glVertexAttribL3d( GLuint index, GLdouble x, GLdouble y, GLdouble z ) { - void (*func_glVertexAttribL3d)( GLuint, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glVertexAttribL3d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", index, x, y, z ); - func_glVertexAttribL3d( index, x, y, z ); + funcs->ext.p_glVertexAttribL3d( index, x, y, z ); } static void WINAPI wine_glVertexAttribL3dEXT( GLuint index, GLdouble x, GLdouble y, GLdouble z ) { - void (*func_glVertexAttribL3dEXT)( GLuint, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glVertexAttribL3dEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", index, x, y, z ); - func_glVertexAttribL3dEXT( index, x, y, z ); + funcs->ext.p_glVertexAttribL3dEXT( index, x, y, z ); } static void WINAPI wine_glVertexAttribL3dv( GLuint index, GLdouble* v ) { - void (*func_glVertexAttribL3dv)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttribL3dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribL3dv( index, v ); + funcs->ext.p_glVertexAttribL3dv( index, v ); } static void WINAPI wine_glVertexAttribL3dvEXT( GLuint index, GLdouble* v ) { - void (*func_glVertexAttribL3dvEXT)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttribL3dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribL3dvEXT( index, v ); + funcs->ext.p_glVertexAttribL3dvEXT( index, v ); } static void WINAPI wine_glVertexAttribL3i64NV( GLuint index, INT64 x, INT64 y, INT64 z ) { - void (*func_glVertexAttribL3i64NV)( GLuint, INT64, INT64, INT64 ) = extension_funcs[EXT_glVertexAttribL3i64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s, %s, %s)\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) ); - func_glVertexAttribL3i64NV( index, x, y, z ); + funcs->ext.p_glVertexAttribL3i64NV( index, x, y, z ); } static void WINAPI wine_glVertexAttribL3i64vNV( GLuint index, INT64* v ) { - void (*func_glVertexAttribL3i64vNV)( GLuint, INT64* ) = extension_funcs[EXT_glVertexAttribL3i64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribL3i64vNV( index, v ); + funcs->ext.p_glVertexAttribL3i64vNV( index, v ); } static void WINAPI wine_glVertexAttribL3ui64NV( GLuint index, UINT64 x, UINT64 y, UINT64 z ) { - void (*func_glVertexAttribL3ui64NV)( GLuint, UINT64, UINT64, UINT64 ) = extension_funcs[EXT_glVertexAttribL3ui64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s, %s, %s)\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) ); - func_glVertexAttribL3ui64NV( index, x, y, z ); + funcs->ext.p_glVertexAttribL3ui64NV( index, x, y, z ); } static void WINAPI wine_glVertexAttribL3ui64vNV( GLuint index, UINT64* v ) { - void (*func_glVertexAttribL3ui64vNV)( GLuint, UINT64* ) = extension_funcs[EXT_glVertexAttribL3ui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribL3ui64vNV( index, v ); + funcs->ext.p_glVertexAttribL3ui64vNV( index, v ); } static void WINAPI wine_glVertexAttribL4d( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { - void (*func_glVertexAttribL4d)( GLuint, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glVertexAttribL4d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", index, x, y, z, w ); - func_glVertexAttribL4d( index, x, y, z, w ); + funcs->ext.p_glVertexAttribL4d( index, x, y, z, w ); } static void WINAPI wine_glVertexAttribL4dEXT( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { - void (*func_glVertexAttribL4dEXT)( GLuint, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glVertexAttribL4dEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", index, x, y, z, w ); - func_glVertexAttribL4dEXT( index, x, y, z, w ); + funcs->ext.p_glVertexAttribL4dEXT( index, x, y, z, w ); } static void WINAPI wine_glVertexAttribL4dv( GLuint index, GLdouble* v ) { - void (*func_glVertexAttribL4dv)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttribL4dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribL4dv( index, v ); + funcs->ext.p_glVertexAttribL4dv( index, v ); } static void WINAPI wine_glVertexAttribL4dvEXT( GLuint index, GLdouble* v ) { - void (*func_glVertexAttribL4dvEXT)( GLuint, GLdouble* ) = extension_funcs[EXT_glVertexAttribL4dvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribL4dvEXT( index, v ); + funcs->ext.p_glVertexAttribL4dvEXT( index, v ); } static void WINAPI wine_glVertexAttribL4i64NV( GLuint index, INT64 x, INT64 y, INT64 z, INT64 w ) { - void (*func_glVertexAttribL4i64NV)( GLuint, INT64, INT64, INT64, INT64 ) = extension_funcs[EXT_glVertexAttribL4i64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s, %s, %s, %s)\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) ); - func_glVertexAttribL4i64NV( index, x, y, z, w ); + funcs->ext.p_glVertexAttribL4i64NV( index, x, y, z, w ); } static void WINAPI wine_glVertexAttribL4i64vNV( GLuint index, INT64* v ) { - void (*func_glVertexAttribL4i64vNV)( GLuint, INT64* ) = extension_funcs[EXT_glVertexAttribL4i64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribL4i64vNV( index, v ); + funcs->ext.p_glVertexAttribL4i64vNV( index, v ); } static void WINAPI wine_glVertexAttribL4ui64NV( GLuint index, UINT64 x, UINT64 y, UINT64 z, UINT64 w ) { - void (*func_glVertexAttribL4ui64NV)( GLuint, UINT64, UINT64, UINT64, UINT64 ) = extension_funcs[EXT_glVertexAttribL4ui64NV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %s, %s, %s, %s)\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) ); - func_glVertexAttribL4ui64NV( index, x, y, z, w ); + funcs->ext.p_glVertexAttribL4ui64NV( index, x, y, z, w ); } static void WINAPI wine_glVertexAttribL4ui64vNV( GLuint index, UINT64* v ) { - void (*func_glVertexAttribL4ui64vNV)( GLuint, UINT64* ) = extension_funcs[EXT_glVertexAttribL4ui64vNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glVertexAttribL4ui64vNV( index, v ); + funcs->ext.p_glVertexAttribL4ui64vNV( index, v ); } static void WINAPI wine_glVertexAttribLFormatNV( GLuint index, GLint size, GLenum type, GLsizei stride ) { - void (*func_glVertexAttribLFormatNV)( GLuint, GLint, GLenum, GLsizei ) = extension_funcs[EXT_glVertexAttribLFormatNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", index, size, type, stride ); - func_glVertexAttribLFormatNV( index, size, type, stride ); + funcs->ext.p_glVertexAttribLFormatNV( index, size, type, stride ); } static void WINAPI wine_glVertexAttribLPointer( GLuint index, GLint size, GLenum type, GLsizei stride, GLvoid* pointer ) { - void (*func_glVertexAttribLPointer)( GLuint, GLint, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glVertexAttribLPointer]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", index, size, type, stride, pointer ); - func_glVertexAttribLPointer( index, size, type, stride, pointer ); + funcs->ext.p_glVertexAttribLPointer( index, size, type, stride, pointer ); } static void WINAPI wine_glVertexAttribLPointerEXT( GLuint index, GLint size, GLenum type, GLsizei stride, GLvoid* pointer ) { - void (*func_glVertexAttribLPointerEXT)( GLuint, GLint, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glVertexAttribLPointerEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", index, size, type, stride, pointer ); - func_glVertexAttribLPointerEXT( index, size, type, stride, pointer ); + funcs->ext.p_glVertexAttribLPointerEXT( index, size, type, stride, pointer ); } static void WINAPI wine_glVertexAttribP1ui( GLuint index, GLenum type, GLboolean normalized, GLuint value ) { - void (*func_glVertexAttribP1ui)( GLuint, GLenum, GLboolean, GLuint ) = extension_funcs[EXT_glVertexAttribP1ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", index, type, normalized, value ); - func_glVertexAttribP1ui( index, type, normalized, value ); + funcs->ext.p_glVertexAttribP1ui( index, type, normalized, value ); } static void WINAPI wine_glVertexAttribP1uiv( GLuint index, GLenum type, GLboolean normalized, GLuint* value ) { - void (*func_glVertexAttribP1uiv)( GLuint, GLenum, GLboolean, GLuint* ) = extension_funcs[EXT_glVertexAttribP1uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", index, type, normalized, value ); - func_glVertexAttribP1uiv( index, type, normalized, value ); + funcs->ext.p_glVertexAttribP1uiv( index, type, normalized, value ); } static void WINAPI wine_glVertexAttribP2ui( GLuint index, GLenum type, GLboolean normalized, GLuint value ) { - void (*func_glVertexAttribP2ui)( GLuint, GLenum, GLboolean, GLuint ) = extension_funcs[EXT_glVertexAttribP2ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", index, type, normalized, value ); - func_glVertexAttribP2ui( index, type, normalized, value ); + funcs->ext.p_glVertexAttribP2ui( index, type, normalized, value ); } static void WINAPI wine_glVertexAttribP2uiv( GLuint index, GLenum type, GLboolean normalized, GLuint* value ) { - void (*func_glVertexAttribP2uiv)( GLuint, GLenum, GLboolean, GLuint* ) = extension_funcs[EXT_glVertexAttribP2uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", index, type, normalized, value ); - func_glVertexAttribP2uiv( index, type, normalized, value ); + funcs->ext.p_glVertexAttribP2uiv( index, type, normalized, value ); } static void WINAPI wine_glVertexAttribP3ui( GLuint index, GLenum type, GLboolean normalized, GLuint value ) { - void (*func_glVertexAttribP3ui)( GLuint, GLenum, GLboolean, GLuint ) = extension_funcs[EXT_glVertexAttribP3ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", index, type, normalized, value ); - func_glVertexAttribP3ui( index, type, normalized, value ); + funcs->ext.p_glVertexAttribP3ui( index, type, normalized, value ); } static void WINAPI wine_glVertexAttribP3uiv( GLuint index, GLenum type, GLboolean normalized, GLuint* value ) { - void (*func_glVertexAttribP3uiv)( GLuint, GLenum, GLboolean, GLuint* ) = extension_funcs[EXT_glVertexAttribP3uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", index, type, normalized, value ); - func_glVertexAttribP3uiv( index, type, normalized, value ); + funcs->ext.p_glVertexAttribP3uiv( index, type, normalized, value ); } static void WINAPI wine_glVertexAttribP4ui( GLuint index, GLenum type, GLboolean normalized, GLuint value ) { - void (*func_glVertexAttribP4ui)( GLuint, GLenum, GLboolean, GLuint ) = extension_funcs[EXT_glVertexAttribP4ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", index, type, normalized, value ); - func_glVertexAttribP4ui( index, type, normalized, value ); + funcs->ext.p_glVertexAttribP4ui( index, type, normalized, value ); } static void WINAPI wine_glVertexAttribP4uiv( GLuint index, GLenum type, GLboolean normalized, GLuint* value ) { - void (*func_glVertexAttribP4uiv)( GLuint, GLenum, GLboolean, GLuint* ) = extension_funcs[EXT_glVertexAttribP4uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", index, type, normalized, value ); - func_glVertexAttribP4uiv( index, type, normalized, value ); + funcs->ext.p_glVertexAttribP4uiv( index, type, normalized, value ); } static void WINAPI wine_glVertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLvoid* pointer ) { - void (*func_glVertexAttribPointer)( GLuint, GLint, GLenum, GLboolean, GLsizei, GLvoid* ) = extension_funcs[EXT_glVertexAttribPointer]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %p)\n", index, size, type, normalized, stride, pointer ); - func_glVertexAttribPointer( index, size, type, normalized, stride, pointer ); + funcs->ext.p_glVertexAttribPointer( index, size, type, normalized, stride, pointer ); } static void WINAPI wine_glVertexAttribPointerARB( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLvoid* pointer ) { - void (*func_glVertexAttribPointerARB)( GLuint, GLint, GLenum, GLboolean, GLsizei, GLvoid* ) = extension_funcs[EXT_glVertexAttribPointerARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %p)\n", index, size, type, normalized, stride, pointer ); - func_glVertexAttribPointerARB( index, size, type, normalized, stride, pointer ); + funcs->ext.p_glVertexAttribPointerARB( index, size, type, normalized, stride, pointer ); } static void WINAPI wine_glVertexAttribPointerNV( GLuint index, GLint fsize, GLenum type, GLsizei stride, GLvoid* pointer ) { - void (*func_glVertexAttribPointerNV)( GLuint, GLint, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glVertexAttribPointerNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", index, fsize, type, stride, pointer ); - func_glVertexAttribPointerNV( index, fsize, type, stride, pointer ); + funcs->ext.p_glVertexAttribPointerNV( index, fsize, type, stride, pointer ); } static void WINAPI wine_glVertexAttribs1dvNV( GLuint index, GLsizei count, GLdouble* v ) { - void (*func_glVertexAttribs1dvNV)( GLuint, GLsizei, GLdouble* ) = extension_funcs[EXT_glVertexAttribs1dvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, count, v ); - func_glVertexAttribs1dvNV( index, count, v ); + funcs->ext.p_glVertexAttribs1dvNV( index, count, v ); } static void WINAPI wine_glVertexAttribs1fvNV( GLuint index, GLsizei count, GLfloat* v ) { - void (*func_glVertexAttribs1fvNV)( GLuint, GLsizei, GLfloat* ) = extension_funcs[EXT_glVertexAttribs1fvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, count, v ); - func_glVertexAttribs1fvNV( index, count, v ); + funcs->ext.p_glVertexAttribs1fvNV( index, count, v ); } static void WINAPI wine_glVertexAttribs1hvNV( GLuint index, GLsizei n, unsigned short* v ) { - void (*func_glVertexAttribs1hvNV)( GLuint, GLsizei, unsigned short* ) = extension_funcs[EXT_glVertexAttribs1hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, n, v ); - func_glVertexAttribs1hvNV( index, n, v ); + funcs->ext.p_glVertexAttribs1hvNV( index, n, v ); } static void WINAPI wine_glVertexAttribs1svNV( GLuint index, GLsizei count, GLshort* v ) { - void (*func_glVertexAttribs1svNV)( GLuint, GLsizei, GLshort* ) = extension_funcs[EXT_glVertexAttribs1svNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, count, v ); - func_glVertexAttribs1svNV( index, count, v ); + funcs->ext.p_glVertexAttribs1svNV( index, count, v ); } static void WINAPI wine_glVertexAttribs2dvNV( GLuint index, GLsizei count, GLdouble* v ) { - void (*func_glVertexAttribs2dvNV)( GLuint, GLsizei, GLdouble* ) = extension_funcs[EXT_glVertexAttribs2dvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, count, v ); - func_glVertexAttribs2dvNV( index, count, v ); + funcs->ext.p_glVertexAttribs2dvNV( index, count, v ); } static void WINAPI wine_glVertexAttribs2fvNV( GLuint index, GLsizei count, GLfloat* v ) { - void (*func_glVertexAttribs2fvNV)( GLuint, GLsizei, GLfloat* ) = extension_funcs[EXT_glVertexAttribs2fvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, count, v ); - func_glVertexAttribs2fvNV( index, count, v ); + funcs->ext.p_glVertexAttribs2fvNV( index, count, v ); } static void WINAPI wine_glVertexAttribs2hvNV( GLuint index, GLsizei n, unsigned short* v ) { - void (*func_glVertexAttribs2hvNV)( GLuint, GLsizei, unsigned short* ) = extension_funcs[EXT_glVertexAttribs2hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, n, v ); - func_glVertexAttribs2hvNV( index, n, v ); + funcs->ext.p_glVertexAttribs2hvNV( index, n, v ); } static void WINAPI wine_glVertexAttribs2svNV( GLuint index, GLsizei count, GLshort* v ) { - void (*func_glVertexAttribs2svNV)( GLuint, GLsizei, GLshort* ) = extension_funcs[EXT_glVertexAttribs2svNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, count, v ); - func_glVertexAttribs2svNV( index, count, v ); + funcs->ext.p_glVertexAttribs2svNV( index, count, v ); } static void WINAPI wine_glVertexAttribs3dvNV( GLuint index, GLsizei count, GLdouble* v ) { - void (*func_glVertexAttribs3dvNV)( GLuint, GLsizei, GLdouble* ) = extension_funcs[EXT_glVertexAttribs3dvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, count, v ); - func_glVertexAttribs3dvNV( index, count, v ); + funcs->ext.p_glVertexAttribs3dvNV( index, count, v ); } static void WINAPI wine_glVertexAttribs3fvNV( GLuint index, GLsizei count, GLfloat* v ) { - void (*func_glVertexAttribs3fvNV)( GLuint, GLsizei, GLfloat* ) = extension_funcs[EXT_glVertexAttribs3fvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, count, v ); - func_glVertexAttribs3fvNV( index, count, v ); + funcs->ext.p_glVertexAttribs3fvNV( index, count, v ); } static void WINAPI wine_glVertexAttribs3hvNV( GLuint index, GLsizei n, unsigned short* v ) { - void (*func_glVertexAttribs3hvNV)( GLuint, GLsizei, unsigned short* ) = extension_funcs[EXT_glVertexAttribs3hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, n, v ); - func_glVertexAttribs3hvNV( index, n, v ); + funcs->ext.p_glVertexAttribs3hvNV( index, n, v ); } static void WINAPI wine_glVertexAttribs3svNV( GLuint index, GLsizei count, GLshort* v ) { - void (*func_glVertexAttribs3svNV)( GLuint, GLsizei, GLshort* ) = extension_funcs[EXT_glVertexAttribs3svNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, count, v ); - func_glVertexAttribs3svNV( index, count, v ); + funcs->ext.p_glVertexAttribs3svNV( index, count, v ); } static void WINAPI wine_glVertexAttribs4dvNV( GLuint index, GLsizei count, GLdouble* v ) { - void (*func_glVertexAttribs4dvNV)( GLuint, GLsizei, GLdouble* ) = extension_funcs[EXT_glVertexAttribs4dvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, count, v ); - func_glVertexAttribs4dvNV( index, count, v ); + funcs->ext.p_glVertexAttribs4dvNV( index, count, v ); } static void WINAPI wine_glVertexAttribs4fvNV( GLuint index, GLsizei count, GLfloat* v ) { - void (*func_glVertexAttribs4fvNV)( GLuint, GLsizei, GLfloat* ) = extension_funcs[EXT_glVertexAttribs4fvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, count, v ); - func_glVertexAttribs4fvNV( index, count, v ); + funcs->ext.p_glVertexAttribs4fvNV( index, count, v ); } static void WINAPI wine_glVertexAttribs4hvNV( GLuint index, GLsizei n, unsigned short* v ) { - void (*func_glVertexAttribs4hvNV)( GLuint, GLsizei, unsigned short* ) = extension_funcs[EXT_glVertexAttribs4hvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, n, v ); - func_glVertexAttribs4hvNV( index, n, v ); + funcs->ext.p_glVertexAttribs4hvNV( index, n, v ); } static void WINAPI wine_glVertexAttribs4svNV( GLuint index, GLsizei count, GLshort* v ) { - void (*func_glVertexAttribs4svNV)( GLuint, GLsizei, GLshort* ) = extension_funcs[EXT_glVertexAttribs4svNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, count, v ); - func_glVertexAttribs4svNV( index, count, v ); + funcs->ext.p_glVertexAttribs4svNV( index, count, v ); } static void WINAPI wine_glVertexAttribs4ubvNV( GLuint index, GLsizei count, GLubyte* v ) { - void (*func_glVertexAttribs4ubvNV)( GLuint, GLsizei, GLubyte* ) = extension_funcs[EXT_glVertexAttribs4ubvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", index, count, v ); - func_glVertexAttribs4ubvNV( index, count, v ); + funcs->ext.p_glVertexAttribs4ubvNV( index, count, v ); } static void WINAPI wine_glVertexBlendARB( GLint count ) { - void (*func_glVertexBlendARB)( GLint ) = extension_funcs[EXT_glVertexBlendARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", count ); - func_glVertexBlendARB( count ); + funcs->ext.p_glVertexBlendARB( count ); } static void WINAPI wine_glVertexBlendEnvfATI( GLenum pname, GLfloat param ) { - void (*func_glVertexBlendEnvfATI)( GLenum, GLfloat ) = extension_funcs[EXT_glVertexBlendEnvfATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", pname, param ); - func_glVertexBlendEnvfATI( pname, param ); + funcs->ext.p_glVertexBlendEnvfATI( pname, param ); } static void WINAPI wine_glVertexBlendEnviATI( GLenum pname, GLint param ) { - void (*func_glVertexBlendEnviATI)( GLenum, GLint ) = extension_funcs[EXT_glVertexBlendEnviATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", pname, param ); - func_glVertexBlendEnviATI( pname, param ); + funcs->ext.p_glVertexBlendEnviATI( pname, param ); } static void WINAPI wine_glVertexFormatNV( GLint size, GLenum type, GLsizei stride ) { - void (*func_glVertexFormatNV)( GLint, GLenum, GLsizei ) = extension_funcs[EXT_glVertexFormatNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", size, type, stride ); - func_glVertexFormatNV( size, type, stride ); + funcs->ext.p_glVertexFormatNV( size, type, stride ); } static void WINAPI wine_glVertexP2ui( GLenum type, GLuint value ) { - void (*func_glVertexP2ui)( GLenum, GLuint ) = extension_funcs[EXT_glVertexP2ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", type, value ); - func_glVertexP2ui( type, value ); + funcs->ext.p_glVertexP2ui( type, value ); } static void WINAPI wine_glVertexP2uiv( GLenum type, GLuint* value ) { - void (*func_glVertexP2uiv)( GLenum, GLuint* ) = extension_funcs[EXT_glVertexP2uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", type, value ); - func_glVertexP2uiv( type, value ); + funcs->ext.p_glVertexP2uiv( type, value ); } static void WINAPI wine_glVertexP3ui( GLenum type, GLuint value ) { - void (*func_glVertexP3ui)( GLenum, GLuint ) = extension_funcs[EXT_glVertexP3ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", type, value ); - func_glVertexP3ui( type, value ); + funcs->ext.p_glVertexP3ui( type, value ); } static void WINAPI wine_glVertexP3uiv( GLenum type, GLuint* value ) { - void (*func_glVertexP3uiv)( GLenum, GLuint* ) = extension_funcs[EXT_glVertexP3uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", type, value ); - func_glVertexP3uiv( type, value ); + funcs->ext.p_glVertexP3uiv( type, value ); } static void WINAPI wine_glVertexP4ui( GLenum type, GLuint value ) { - void (*func_glVertexP4ui)( GLenum, GLuint ) = extension_funcs[EXT_glVertexP4ui]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", type, value ); - func_glVertexP4ui( type, value ); + funcs->ext.p_glVertexP4ui( type, value ); } static void WINAPI wine_glVertexP4uiv( GLenum type, GLuint* value ) { - void (*func_glVertexP4uiv)( GLenum, GLuint* ) = extension_funcs[EXT_glVertexP4uiv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", type, value ); - func_glVertexP4uiv( type, value ); + funcs->ext.p_glVertexP4uiv( type, value ); } static void WINAPI wine_glVertexPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, GLvoid* pointer ) { - void (*func_glVertexPointerEXT)( GLint, GLenum, GLsizei, GLsizei, GLvoid* ) = extension_funcs[EXT_glVertexPointerEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %p)\n", size, type, stride, count, pointer ); - func_glVertexPointerEXT( size, type, stride, count, pointer ); + funcs->ext.p_glVertexPointerEXT( size, type, stride, count, pointer ); } static void WINAPI wine_glVertexPointerListIBM( GLint size, GLenum type, GLint stride, GLvoid** pointer, GLint ptrstride ) { - void (*func_glVertexPointerListIBM)( GLint, GLenum, GLint, GLvoid**, GLint ) = extension_funcs[EXT_glVertexPointerListIBM]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p, %d)\n", size, type, stride, pointer, ptrstride ); - func_glVertexPointerListIBM( size, type, stride, pointer, ptrstride ); + funcs->ext.p_glVertexPointerListIBM( size, type, stride, pointer, ptrstride ); } static void WINAPI wine_glVertexPointervINTEL( GLint size, GLenum type, GLvoid** pointer ) { - void (*func_glVertexPointervINTEL)( GLint, GLenum, GLvoid** ) = extension_funcs[EXT_glVertexPointervINTEL]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", size, type, pointer ); - func_glVertexPointervINTEL( size, type, pointer ); + funcs->ext.p_glVertexPointervINTEL( size, type, pointer ); } static void WINAPI wine_glVertexStream1dATI( GLenum stream, GLdouble x ) { - void (*func_glVertexStream1dATI)( GLenum, GLdouble ) = extension_funcs[EXT_glVertexStream1dATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", stream, x ); - func_glVertexStream1dATI( stream, x ); + funcs->ext.p_glVertexStream1dATI( stream, x ); } static void WINAPI wine_glVertexStream1dvATI( GLenum stream, GLdouble* coords ) { - void (*func_glVertexStream1dvATI)( GLenum, GLdouble* ) = extension_funcs[EXT_glVertexStream1dvATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glVertexStream1dvATI( stream, coords ); + funcs->ext.p_glVertexStream1dvATI( stream, coords ); } static void WINAPI wine_glVertexStream1fATI( GLenum stream, GLfloat x ) { - void (*func_glVertexStream1fATI)( GLenum, GLfloat ) = extension_funcs[EXT_glVertexStream1fATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f)\n", stream, x ); - func_glVertexStream1fATI( stream, x ); + funcs->ext.p_glVertexStream1fATI( stream, x ); } static void WINAPI wine_glVertexStream1fvATI( GLenum stream, GLfloat* coords ) { - void (*func_glVertexStream1fvATI)( GLenum, GLfloat* ) = extension_funcs[EXT_glVertexStream1fvATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glVertexStream1fvATI( stream, coords ); + funcs->ext.p_glVertexStream1fvATI( stream, coords ); } static void WINAPI wine_glVertexStream1iATI( GLenum stream, GLint x ) { - void (*func_glVertexStream1iATI)( GLenum, GLint ) = extension_funcs[EXT_glVertexStream1iATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", stream, x ); - func_glVertexStream1iATI( stream, x ); + funcs->ext.p_glVertexStream1iATI( stream, x ); } static void WINAPI wine_glVertexStream1ivATI( GLenum stream, GLint* coords ) { - void (*func_glVertexStream1ivATI)( GLenum, GLint* ) = extension_funcs[EXT_glVertexStream1ivATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glVertexStream1ivATI( stream, coords ); + funcs->ext.p_glVertexStream1ivATI( stream, coords ); } static void WINAPI wine_glVertexStream1sATI( GLenum stream, GLshort x ) { - void (*func_glVertexStream1sATI)( GLenum, GLshort ) = extension_funcs[EXT_glVertexStream1sATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", stream, x ); - func_glVertexStream1sATI( stream, x ); + funcs->ext.p_glVertexStream1sATI( stream, x ); } static void WINAPI wine_glVertexStream1svATI( GLenum stream, GLshort* coords ) { - void (*func_glVertexStream1svATI)( GLenum, GLshort* ) = extension_funcs[EXT_glVertexStream1svATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glVertexStream1svATI( stream, coords ); + funcs->ext.p_glVertexStream1svATI( stream, coords ); } static void WINAPI wine_glVertexStream2dATI( GLenum stream, GLdouble x, GLdouble y ) { - void (*func_glVertexStream2dATI)( GLenum, GLdouble, GLdouble ) = extension_funcs[EXT_glVertexStream2dATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", stream, x, y ); - func_glVertexStream2dATI( stream, x, y ); + funcs->ext.p_glVertexStream2dATI( stream, x, y ); } static void WINAPI wine_glVertexStream2dvATI( GLenum stream, GLdouble* coords ) { - void (*func_glVertexStream2dvATI)( GLenum, GLdouble* ) = extension_funcs[EXT_glVertexStream2dvATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glVertexStream2dvATI( stream, coords ); + funcs->ext.p_glVertexStream2dvATI( stream, coords ); } static void WINAPI wine_glVertexStream2fATI( GLenum stream, GLfloat x, GLfloat y ) { - void (*func_glVertexStream2fATI)( GLenum, GLfloat, GLfloat ) = extension_funcs[EXT_glVertexStream2fATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f)\n", stream, x, y ); - func_glVertexStream2fATI( stream, x, y ); + funcs->ext.p_glVertexStream2fATI( stream, x, y ); } static void WINAPI wine_glVertexStream2fvATI( GLenum stream, GLfloat* coords ) { - void (*func_glVertexStream2fvATI)( GLenum, GLfloat* ) = extension_funcs[EXT_glVertexStream2fvATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glVertexStream2fvATI( stream, coords ); + funcs->ext.p_glVertexStream2fvATI( stream, coords ); } static void WINAPI wine_glVertexStream2iATI( GLenum stream, GLint x, GLint y ) { - void (*func_glVertexStream2iATI)( GLenum, GLint, GLint ) = extension_funcs[EXT_glVertexStream2iATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", stream, x, y ); - func_glVertexStream2iATI( stream, x, y ); + funcs->ext.p_glVertexStream2iATI( stream, x, y ); } static void WINAPI wine_glVertexStream2ivATI( GLenum stream, GLint* coords ) { - void (*func_glVertexStream2ivATI)( GLenum, GLint* ) = extension_funcs[EXT_glVertexStream2ivATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glVertexStream2ivATI( stream, coords ); + funcs->ext.p_glVertexStream2ivATI( stream, coords ); } static void WINAPI wine_glVertexStream2sATI( GLenum stream, GLshort x, GLshort y ) { - void (*func_glVertexStream2sATI)( GLenum, GLshort, GLshort ) = extension_funcs[EXT_glVertexStream2sATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", stream, x, y ); - func_glVertexStream2sATI( stream, x, y ); + funcs->ext.p_glVertexStream2sATI( stream, x, y ); } static void WINAPI wine_glVertexStream2svATI( GLenum stream, GLshort* coords ) { - void (*func_glVertexStream2svATI)( GLenum, GLshort* ) = extension_funcs[EXT_glVertexStream2svATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glVertexStream2svATI( stream, coords ); + funcs->ext.p_glVertexStream2svATI( stream, coords ); } static void WINAPI wine_glVertexStream3dATI( GLenum stream, GLdouble x, GLdouble y, GLdouble z ) { - void (*func_glVertexStream3dATI)( GLenum, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glVertexStream3dATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", stream, x, y, z ); - func_glVertexStream3dATI( stream, x, y, z ); + funcs->ext.p_glVertexStream3dATI( stream, x, y, z ); } static void WINAPI wine_glVertexStream3dvATI( GLenum stream, GLdouble* coords ) { - void (*func_glVertexStream3dvATI)( GLenum, GLdouble* ) = extension_funcs[EXT_glVertexStream3dvATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glVertexStream3dvATI( stream, coords ); + funcs->ext.p_glVertexStream3dvATI( stream, coords ); } static void WINAPI wine_glVertexStream3fATI( GLenum stream, GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glVertexStream3fATI)( GLenum, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glVertexStream3fATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f)\n", stream, x, y, z ); - func_glVertexStream3fATI( stream, x, y, z ); + funcs->ext.p_glVertexStream3fATI( stream, x, y, z ); } static void WINAPI wine_glVertexStream3fvATI( GLenum stream, GLfloat* coords ) { - void (*func_glVertexStream3fvATI)( GLenum, GLfloat* ) = extension_funcs[EXT_glVertexStream3fvATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glVertexStream3fvATI( stream, coords ); + funcs->ext.p_glVertexStream3fvATI( stream, coords ); } static void WINAPI wine_glVertexStream3iATI( GLenum stream, GLint x, GLint y, GLint z ) { - void (*func_glVertexStream3iATI)( GLenum, GLint, GLint, GLint ) = extension_funcs[EXT_glVertexStream3iATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", stream, x, y, z ); - func_glVertexStream3iATI( stream, x, y, z ); + funcs->ext.p_glVertexStream3iATI( stream, x, y, z ); } static void WINAPI wine_glVertexStream3ivATI( GLenum stream, GLint* coords ) { - void (*func_glVertexStream3ivATI)( GLenum, GLint* ) = extension_funcs[EXT_glVertexStream3ivATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glVertexStream3ivATI( stream, coords ); + funcs->ext.p_glVertexStream3ivATI( stream, coords ); } static void WINAPI wine_glVertexStream3sATI( GLenum stream, GLshort x, GLshort y, GLshort z ) { - void (*func_glVertexStream3sATI)( GLenum, GLshort, GLshort, GLshort ) = extension_funcs[EXT_glVertexStream3sATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", stream, x, y, z ); - func_glVertexStream3sATI( stream, x, y, z ); + funcs->ext.p_glVertexStream3sATI( stream, x, y, z ); } static void WINAPI wine_glVertexStream3svATI( GLenum stream, GLshort* coords ) { - void (*func_glVertexStream3svATI)( GLenum, GLshort* ) = extension_funcs[EXT_glVertexStream3svATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glVertexStream3svATI( stream, coords ); + funcs->ext.p_glVertexStream3svATI( stream, coords ); } static void WINAPI wine_glVertexStream4dATI( GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { - void (*func_glVertexStream4dATI)( GLenum, GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glVertexStream4dATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", stream, x, y, z, w ); - func_glVertexStream4dATI( stream, x, y, z, w ); + funcs->ext.p_glVertexStream4dATI( stream, x, y, z, w ); } static void WINAPI wine_glVertexStream4dvATI( GLenum stream, GLdouble* coords ) { - void (*func_glVertexStream4dvATI)( GLenum, GLdouble* ) = extension_funcs[EXT_glVertexStream4dvATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glVertexStream4dvATI( stream, coords ); + funcs->ext.p_glVertexStream4dvATI( stream, coords ); } static void WINAPI wine_glVertexStream4fATI( GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { - void (*func_glVertexStream4fATI)( GLenum, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glVertexStream4fATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", stream, x, y, z, w ); - func_glVertexStream4fATI( stream, x, y, z, w ); + funcs->ext.p_glVertexStream4fATI( stream, x, y, z, w ); } static void WINAPI wine_glVertexStream4fvATI( GLenum stream, GLfloat* coords ) { - void (*func_glVertexStream4fvATI)( GLenum, GLfloat* ) = extension_funcs[EXT_glVertexStream4fvATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glVertexStream4fvATI( stream, coords ); + funcs->ext.p_glVertexStream4fvATI( stream, coords ); } static void WINAPI wine_glVertexStream4iATI( GLenum stream, GLint x, GLint y, GLint z, GLint w ) { - void (*func_glVertexStream4iATI)( GLenum, GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glVertexStream4iATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", stream, x, y, z, w ); - func_glVertexStream4iATI( stream, x, y, z, w ); + funcs->ext.p_glVertexStream4iATI( stream, x, y, z, w ); } static void WINAPI wine_glVertexStream4ivATI( GLenum stream, GLint* coords ) { - void (*func_glVertexStream4ivATI)( GLenum, GLint* ) = extension_funcs[EXT_glVertexStream4ivATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glVertexStream4ivATI( stream, coords ); + funcs->ext.p_glVertexStream4ivATI( stream, coords ); } static void WINAPI wine_glVertexStream4sATI( GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w ) { - void (*func_glVertexStream4sATI)( GLenum, GLshort, GLshort, GLshort, GLshort ) = extension_funcs[EXT_glVertexStream4sATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d)\n", stream, x, y, z, w ); - func_glVertexStream4sATI( stream, x, y, z, w ); + funcs->ext.p_glVertexStream4sATI( stream, x, y, z, w ); } static void WINAPI wine_glVertexStream4svATI( GLenum stream, GLshort* coords ) { - void (*func_glVertexStream4svATI)( GLenum, GLshort* ) = extension_funcs[EXT_glVertexStream4svATI]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", stream, coords ); - func_glVertexStream4svATI( stream, coords ); + funcs->ext.p_glVertexStream4svATI( stream, coords ); } static void WINAPI wine_glVertexWeightPointerEXT( GLsizei size, GLenum type, GLsizei stride, GLvoid* pointer ) { - void (*func_glVertexWeightPointerEXT)( GLsizei, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glVertexWeightPointerEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer ); - func_glVertexWeightPointerEXT( size, type, stride, pointer ); + funcs->ext.p_glVertexWeightPointerEXT( size, type, stride, pointer ); } static void WINAPI wine_glVertexWeightfEXT( GLfloat weight ) { - void (*func_glVertexWeightfEXT)( GLfloat ) = extension_funcs[EXT_glVertexWeightfEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f)\n", weight ); - func_glVertexWeightfEXT( weight ); + funcs->ext.p_glVertexWeightfEXT( weight ); } static void WINAPI wine_glVertexWeightfvEXT( GLfloat* weight ) { - void (*func_glVertexWeightfvEXT)( GLfloat* ) = extension_funcs[EXT_glVertexWeightfvEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", weight ); - func_glVertexWeightfvEXT( weight ); + funcs->ext.p_glVertexWeightfvEXT( weight ); } static void WINAPI wine_glVertexWeighthNV( unsigned short weight ) { - void (*func_glVertexWeighthNV)( unsigned short ) = extension_funcs[EXT_glVertexWeighthNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d)\n", weight ); - func_glVertexWeighthNV( weight ); + funcs->ext.p_glVertexWeighthNV( weight ); } static void WINAPI wine_glVertexWeighthvNV( unsigned short* weight ) { - void (*func_glVertexWeighthvNV)( unsigned short* ) = extension_funcs[EXT_glVertexWeighthvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", weight ); - func_glVertexWeighthvNV( weight ); + funcs->ext.p_glVertexWeighthvNV( weight ); } static GLenum WINAPI wine_glVideoCaptureNV( GLuint video_capture_slot, GLuint* sequence_num, UINT64* capture_time ) { - GLenum (*func_glVideoCaptureNV)( GLuint, GLuint*, UINT64* ) = extension_funcs[EXT_glVideoCaptureNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p, %p)\n", video_capture_slot, sequence_num, capture_time ); - return func_glVideoCaptureNV( video_capture_slot, sequence_num, capture_time ); + return funcs->ext.p_glVideoCaptureNV( video_capture_slot, sequence_num, capture_time ); } static void WINAPI wine_glVideoCaptureStreamParameterdvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLdouble* params ) { - void (*func_glVideoCaptureStreamParameterdvNV)( GLuint, GLuint, GLenum, GLdouble* ) = extension_funcs[EXT_glVideoCaptureStreamParameterdvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", video_capture_slot, stream, pname, params ); - func_glVideoCaptureStreamParameterdvNV( video_capture_slot, stream, pname, params ); + funcs->ext.p_glVideoCaptureStreamParameterdvNV( video_capture_slot, stream, pname, params ); } static void WINAPI wine_glVideoCaptureStreamParameterfvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLfloat* params ) { - void (*func_glVideoCaptureStreamParameterfvNV)( GLuint, GLuint, GLenum, GLfloat* ) = extension_funcs[EXT_glVideoCaptureStreamParameterfvNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", video_capture_slot, stream, pname, params ); - func_glVideoCaptureStreamParameterfvNV( video_capture_slot, stream, pname, params ); + funcs->ext.p_glVideoCaptureStreamParameterfvNV( video_capture_slot, stream, pname, params ); } static void WINAPI wine_glVideoCaptureStreamParameterivNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLint* params ) { - void (*func_glVideoCaptureStreamParameterivNV)( GLuint, GLuint, GLenum, GLint* ) = extension_funcs[EXT_glVideoCaptureStreamParameterivNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", video_capture_slot, stream, pname, params ); - func_glVideoCaptureStreamParameterivNV( video_capture_slot, stream, pname, params ); + funcs->ext.p_glVideoCaptureStreamParameterivNV( video_capture_slot, stream, pname, params ); } static void WINAPI wine_glViewportArrayv( GLuint first, GLsizei count, GLfloat* v ) { - void (*func_glViewportArrayv)( GLuint, GLsizei, GLfloat* ) = extension_funcs[EXT_glViewportArrayv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p)\n", first, count, v ); - func_glViewportArrayv( first, count, v ); + funcs->ext.p_glViewportArrayv( first, count, v ); } static void WINAPI wine_glViewportIndexedf( GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h ) { - void (*func_glViewportIndexedf)( GLuint, GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glViewportIndexedf]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %f, %f, %f, %f)\n", index, x, y, w, h ); - func_glViewportIndexedf( index, x, y, w, h ); + funcs->ext.p_glViewportIndexedf( index, x, y, w, h ); } static void WINAPI wine_glViewportIndexedfv( GLuint index, GLfloat* v ) { - void (*func_glViewportIndexedfv)( GLuint, GLfloat* ) = extension_funcs[EXT_glViewportIndexedfv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", index, v ); - func_glViewportIndexedfv( index, v ); + funcs->ext.p_glViewportIndexedfv( index, v ); } static void WINAPI wine_glWaitSync( GLvoid* sync, GLbitfield flags, UINT64 timeout ) { - void (*func_glWaitSync)( GLvoid*, GLbitfield, UINT64 ) = extension_funcs[EXT_glWaitSync]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p, %d, %s)\n", sync, flags, wine_dbgstr_longlong(timeout) ); - func_glWaitSync( sync, flags, timeout ); + funcs->ext.p_glWaitSync( sync, flags, timeout ); } static void WINAPI wine_glWeightPathsNV( GLuint resultPath, GLsizei numPaths, GLuint* paths, GLfloat* weights ) { - void (*func_glWeightPathsNV)( GLuint, GLsizei, GLuint*, GLfloat* ) = extension_funcs[EXT_glWeightPathsNV]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %p, %p)\n", resultPath, numPaths, paths, weights ); - func_glWeightPathsNV( resultPath, numPaths, paths, weights ); + funcs->ext.p_glWeightPathsNV( resultPath, numPaths, paths, weights ); } static void WINAPI wine_glWeightPointerARB( GLint size, GLenum type, GLsizei stride, GLvoid* pointer ) { - void (*func_glWeightPointerARB)( GLint, GLenum, GLsizei, GLvoid* ) = extension_funcs[EXT_glWeightPointerARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer ); - func_glWeightPointerARB( size, type, stride, pointer ); + funcs->ext.p_glWeightPointerARB( size, type, stride, pointer ); } static void WINAPI wine_glWeightbvARB( GLint size, GLbyte* weights ) { - void (*func_glWeightbvARB)( GLint, GLbyte* ) = extension_funcs[EXT_glWeightbvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", size, weights ); - func_glWeightbvARB( size, weights ); + funcs->ext.p_glWeightbvARB( size, weights ); } static void WINAPI wine_glWeightdvARB( GLint size, GLdouble* weights ) { - void (*func_glWeightdvARB)( GLint, GLdouble* ) = extension_funcs[EXT_glWeightdvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", size, weights ); - func_glWeightdvARB( size, weights ); + funcs->ext.p_glWeightdvARB( size, weights ); } static void WINAPI wine_glWeightfvARB( GLint size, GLfloat* weights ) { - void (*func_glWeightfvARB)( GLint, GLfloat* ) = extension_funcs[EXT_glWeightfvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", size, weights ); - func_glWeightfvARB( size, weights ); + funcs->ext.p_glWeightfvARB( size, weights ); } static void WINAPI wine_glWeightivARB( GLint size, GLint* weights ) { - void (*func_glWeightivARB)( GLint, GLint* ) = extension_funcs[EXT_glWeightivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", size, weights ); - func_glWeightivARB( size, weights ); + funcs->ext.p_glWeightivARB( size, weights ); } static void WINAPI wine_glWeightsvARB( GLint size, GLshort* weights ) { - void (*func_glWeightsvARB)( GLint, GLshort* ) = extension_funcs[EXT_glWeightsvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", size, weights ); - func_glWeightsvARB( size, weights ); + funcs->ext.p_glWeightsvARB( size, weights ); } static void WINAPI wine_glWeightubvARB( GLint size, GLubyte* weights ) { - void (*func_glWeightubvARB)( GLint, GLubyte* ) = extension_funcs[EXT_glWeightubvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", size, weights ); - func_glWeightubvARB( size, weights ); + funcs->ext.p_glWeightubvARB( size, weights ); } static void WINAPI wine_glWeightuivARB( GLint size, GLuint* weights ) { - void (*func_glWeightuivARB)( GLint, GLuint* ) = extension_funcs[EXT_glWeightuivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", size, weights ); - func_glWeightuivARB( size, weights ); + funcs->ext.p_glWeightuivARB( size, weights ); } static void WINAPI wine_glWeightusvARB( GLint size, GLushort* weights ) { - void (*func_glWeightusvARB)( GLint, GLushort* ) = extension_funcs[EXT_glWeightusvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %p)\n", size, weights ); - func_glWeightusvARB( size, weights ); + funcs->ext.p_glWeightusvARB( size, weights ); } static void WINAPI wine_glWindowPos2d( GLdouble x, GLdouble y ) { - void (*func_glWindowPos2d)( GLdouble, GLdouble ) = extension_funcs[EXT_glWindowPos2d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f)\n", x, y ); - func_glWindowPos2d( x, y ); + funcs->ext.p_glWindowPos2d( x, y ); } static void WINAPI wine_glWindowPos2dARB( GLdouble x, GLdouble y ) { - void (*func_glWindowPos2dARB)( GLdouble, GLdouble ) = extension_funcs[EXT_glWindowPos2dARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f)\n", x, y ); - func_glWindowPos2dARB( x, y ); + funcs->ext.p_glWindowPos2dARB( x, y ); } static void WINAPI wine_glWindowPos2dMESA( GLdouble x, GLdouble y ) { - void (*func_glWindowPos2dMESA)( GLdouble, GLdouble ) = extension_funcs[EXT_glWindowPos2dMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f)\n", x, y ); - func_glWindowPos2dMESA( x, y ); + funcs->ext.p_glWindowPos2dMESA( x, y ); } static void WINAPI wine_glWindowPos2dv( GLdouble* v ) { - void (*func_glWindowPos2dv)( GLdouble* ) = extension_funcs[EXT_glWindowPos2dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos2dv( v ); + funcs->ext.p_glWindowPos2dv( v ); } static void WINAPI wine_glWindowPos2dvARB( GLdouble* v ) { - void (*func_glWindowPos2dvARB)( GLdouble* ) = extension_funcs[EXT_glWindowPos2dvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos2dvARB( v ); + funcs->ext.p_glWindowPos2dvARB( v ); } static void WINAPI wine_glWindowPos2dvMESA( GLdouble* v ) { - void (*func_glWindowPos2dvMESA)( GLdouble* ) = extension_funcs[EXT_glWindowPos2dvMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos2dvMESA( v ); + funcs->ext.p_glWindowPos2dvMESA( v ); } static void WINAPI wine_glWindowPos2f( GLfloat x, GLfloat y ) { - void (*func_glWindowPos2f)( GLfloat, GLfloat ) = extension_funcs[EXT_glWindowPos2f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f)\n", x, y ); - func_glWindowPos2f( x, y ); + funcs->ext.p_glWindowPos2f( x, y ); } static void WINAPI wine_glWindowPos2fARB( GLfloat x, GLfloat y ) { - void (*func_glWindowPos2fARB)( GLfloat, GLfloat ) = extension_funcs[EXT_glWindowPos2fARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f)\n", x, y ); - func_glWindowPos2fARB( x, y ); + funcs->ext.p_glWindowPos2fARB( x, y ); } static void WINAPI wine_glWindowPos2fMESA( GLfloat x, GLfloat y ) { - void (*func_glWindowPos2fMESA)( GLfloat, GLfloat ) = extension_funcs[EXT_glWindowPos2fMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f)\n", x, y ); - func_glWindowPos2fMESA( x, y ); + funcs->ext.p_glWindowPos2fMESA( x, y ); } static void WINAPI wine_glWindowPos2fv( GLfloat* v ) { - void (*func_glWindowPos2fv)( GLfloat* ) = extension_funcs[EXT_glWindowPos2fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos2fv( v ); + funcs->ext.p_glWindowPos2fv( v ); } static void WINAPI wine_glWindowPos2fvARB( GLfloat* v ) { - void (*func_glWindowPos2fvARB)( GLfloat* ) = extension_funcs[EXT_glWindowPos2fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos2fvARB( v ); + funcs->ext.p_glWindowPos2fvARB( v ); } static void WINAPI wine_glWindowPos2fvMESA( GLfloat* v ) { - void (*func_glWindowPos2fvMESA)( GLfloat* ) = extension_funcs[EXT_glWindowPos2fvMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos2fvMESA( v ); + funcs->ext.p_glWindowPos2fvMESA( v ); } static void WINAPI wine_glWindowPos2i( GLint x, GLint y ) { - void (*func_glWindowPos2i)( GLint, GLint ) = extension_funcs[EXT_glWindowPos2i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", x, y ); - func_glWindowPos2i( x, y ); + funcs->ext.p_glWindowPos2i( x, y ); } static void WINAPI wine_glWindowPos2iARB( GLint x, GLint y ) { - void (*func_glWindowPos2iARB)( GLint, GLint ) = extension_funcs[EXT_glWindowPos2iARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", x, y ); - func_glWindowPos2iARB( x, y ); + funcs->ext.p_glWindowPos2iARB( x, y ); } static void WINAPI wine_glWindowPos2iMESA( GLint x, GLint y ) { - void (*func_glWindowPos2iMESA)( GLint, GLint ) = extension_funcs[EXT_glWindowPos2iMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", x, y ); - func_glWindowPos2iMESA( x, y ); + funcs->ext.p_glWindowPos2iMESA( x, y ); } static void WINAPI wine_glWindowPos2iv( GLint* v ) { - void (*func_glWindowPos2iv)( GLint* ) = extension_funcs[EXT_glWindowPos2iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos2iv( v ); + funcs->ext.p_glWindowPos2iv( v ); } static void WINAPI wine_glWindowPos2ivARB( GLint* v ) { - void (*func_glWindowPos2ivARB)( GLint* ) = extension_funcs[EXT_glWindowPos2ivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos2ivARB( v ); + funcs->ext.p_glWindowPos2ivARB( v ); } static void WINAPI wine_glWindowPos2ivMESA( GLint* v ) { - void (*func_glWindowPos2ivMESA)( GLint* ) = extension_funcs[EXT_glWindowPos2ivMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos2ivMESA( v ); + funcs->ext.p_glWindowPos2ivMESA( v ); } static void WINAPI wine_glWindowPos2s( GLshort x, GLshort y ) { - void (*func_glWindowPos2s)( GLshort, GLshort ) = extension_funcs[EXT_glWindowPos2s]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", x, y ); - func_glWindowPos2s( x, y ); + funcs->ext.p_glWindowPos2s( x, y ); } static void WINAPI wine_glWindowPos2sARB( GLshort x, GLshort y ) { - void (*func_glWindowPos2sARB)( GLshort, GLshort ) = extension_funcs[EXT_glWindowPos2sARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", x, y ); - func_glWindowPos2sARB( x, y ); + funcs->ext.p_glWindowPos2sARB( x, y ); } static void WINAPI wine_glWindowPos2sMESA( GLshort x, GLshort y ) { - void (*func_glWindowPos2sMESA)( GLshort, GLshort ) = extension_funcs[EXT_glWindowPos2sMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d)\n", x, y ); - func_glWindowPos2sMESA( x, y ); + funcs->ext.p_glWindowPos2sMESA( x, y ); } static void WINAPI wine_glWindowPos2sv( GLshort* v ) { - void (*func_glWindowPos2sv)( GLshort* ) = extension_funcs[EXT_glWindowPos2sv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos2sv( v ); + funcs->ext.p_glWindowPos2sv( v ); } static void WINAPI wine_glWindowPos2svARB( GLshort* v ) { - void (*func_glWindowPos2svARB)( GLshort* ) = extension_funcs[EXT_glWindowPos2svARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos2svARB( v ); + funcs->ext.p_glWindowPos2svARB( v ); } static void WINAPI wine_glWindowPos2svMESA( GLshort* v ) { - void (*func_glWindowPos2svMESA)( GLshort* ) = extension_funcs[EXT_glWindowPos2svMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos2svMESA( v ); + funcs->ext.p_glWindowPos2svMESA( v ); } static void WINAPI wine_glWindowPos3d( GLdouble x, GLdouble y, GLdouble z ) { - void (*func_glWindowPos3d)( GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glWindowPos3d]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f)\n", x, y, z ); - func_glWindowPos3d( x, y, z ); + funcs->ext.p_glWindowPos3d( x, y, z ); } static void WINAPI wine_glWindowPos3dARB( GLdouble x, GLdouble y, GLdouble z ) { - void (*func_glWindowPos3dARB)( GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glWindowPos3dARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f)\n", x, y, z ); - func_glWindowPos3dARB( x, y, z ); + funcs->ext.p_glWindowPos3dARB( x, y, z ); } static void WINAPI wine_glWindowPos3dMESA( GLdouble x, GLdouble y, GLdouble z ) { - void (*func_glWindowPos3dMESA)( GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glWindowPos3dMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f)\n", x, y, z ); - func_glWindowPos3dMESA( x, y, z ); + funcs->ext.p_glWindowPos3dMESA( x, y, z ); } static void WINAPI wine_glWindowPos3dv( GLdouble* v ) { - void (*func_glWindowPos3dv)( GLdouble* ) = extension_funcs[EXT_glWindowPos3dv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos3dv( v ); + funcs->ext.p_glWindowPos3dv( v ); } static void WINAPI wine_glWindowPos3dvARB( GLdouble* v ) { - void (*func_glWindowPos3dvARB)( GLdouble* ) = extension_funcs[EXT_glWindowPos3dvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos3dvARB( v ); + funcs->ext.p_glWindowPos3dvARB( v ); } static void WINAPI wine_glWindowPos3dvMESA( GLdouble* v ) { - void (*func_glWindowPos3dvMESA)( GLdouble* ) = extension_funcs[EXT_glWindowPos3dvMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos3dvMESA( v ); + funcs->ext.p_glWindowPos3dvMESA( v ); } static void WINAPI wine_glWindowPos3f( GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glWindowPos3f)( GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glWindowPos3f]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f)\n", x, y, z ); - func_glWindowPos3f( x, y, z ); + funcs->ext.p_glWindowPos3f( x, y, z ); } static void WINAPI wine_glWindowPos3fARB( GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glWindowPos3fARB)( GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glWindowPos3fARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f)\n", x, y, z ); - func_glWindowPos3fARB( x, y, z ); + funcs->ext.p_glWindowPos3fARB( x, y, z ); } static void WINAPI wine_glWindowPos3fMESA( GLfloat x, GLfloat y, GLfloat z ) { - void (*func_glWindowPos3fMESA)( GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glWindowPos3fMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f)\n", x, y, z ); - func_glWindowPos3fMESA( x, y, z ); + funcs->ext.p_glWindowPos3fMESA( x, y, z ); } static void WINAPI wine_glWindowPos3fv( GLfloat* v ) { - void (*func_glWindowPos3fv)( GLfloat* ) = extension_funcs[EXT_glWindowPos3fv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos3fv( v ); + funcs->ext.p_glWindowPos3fv( v ); } static void WINAPI wine_glWindowPos3fvARB( GLfloat* v ) { - void (*func_glWindowPos3fvARB)( GLfloat* ) = extension_funcs[EXT_glWindowPos3fvARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos3fvARB( v ); + funcs->ext.p_glWindowPos3fvARB( v ); } static void WINAPI wine_glWindowPos3fvMESA( GLfloat* v ) { - void (*func_glWindowPos3fvMESA)( GLfloat* ) = extension_funcs[EXT_glWindowPos3fvMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos3fvMESA( v ); + funcs->ext.p_glWindowPos3fvMESA( v ); } static void WINAPI wine_glWindowPos3i( GLint x, GLint y, GLint z ) { - void (*func_glWindowPos3i)( GLint, GLint, GLint ) = extension_funcs[EXT_glWindowPos3i]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", x, y, z ); - func_glWindowPos3i( x, y, z ); + funcs->ext.p_glWindowPos3i( x, y, z ); } static void WINAPI wine_glWindowPos3iARB( GLint x, GLint y, GLint z ) { - void (*func_glWindowPos3iARB)( GLint, GLint, GLint ) = extension_funcs[EXT_glWindowPos3iARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", x, y, z ); - func_glWindowPos3iARB( x, y, z ); + funcs->ext.p_glWindowPos3iARB( x, y, z ); } static void WINAPI wine_glWindowPos3iMESA( GLint x, GLint y, GLint z ) { - void (*func_glWindowPos3iMESA)( GLint, GLint, GLint ) = extension_funcs[EXT_glWindowPos3iMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", x, y, z ); - func_glWindowPos3iMESA( x, y, z ); + funcs->ext.p_glWindowPos3iMESA( x, y, z ); } static void WINAPI wine_glWindowPos3iv( GLint* v ) { - void (*func_glWindowPos3iv)( GLint* ) = extension_funcs[EXT_glWindowPos3iv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos3iv( v ); + funcs->ext.p_glWindowPos3iv( v ); } static void WINAPI wine_glWindowPos3ivARB( GLint* v ) { - void (*func_glWindowPos3ivARB)( GLint* ) = extension_funcs[EXT_glWindowPos3ivARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos3ivARB( v ); + funcs->ext.p_glWindowPos3ivARB( v ); } static void WINAPI wine_glWindowPos3ivMESA( GLint* v ) { - void (*func_glWindowPos3ivMESA)( GLint* ) = extension_funcs[EXT_glWindowPos3ivMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos3ivMESA( v ); + funcs->ext.p_glWindowPos3ivMESA( v ); } static void WINAPI wine_glWindowPos3s( GLshort x, GLshort y, GLshort z ) { - void (*func_glWindowPos3s)( GLshort, GLshort, GLshort ) = extension_funcs[EXT_glWindowPos3s]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", x, y, z ); - func_glWindowPos3s( x, y, z ); + funcs->ext.p_glWindowPos3s( x, y, z ); } static void WINAPI wine_glWindowPos3sARB( GLshort x, GLshort y, GLshort z ) { - void (*func_glWindowPos3sARB)( GLshort, GLshort, GLshort ) = extension_funcs[EXT_glWindowPos3sARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", x, y, z ); - func_glWindowPos3sARB( x, y, z ); + funcs->ext.p_glWindowPos3sARB( x, y, z ); } static void WINAPI wine_glWindowPos3sMESA( GLshort x, GLshort y, GLshort z ) { - void (*func_glWindowPos3sMESA)( GLshort, GLshort, GLshort ) = extension_funcs[EXT_glWindowPos3sMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d)\n", x, y, z ); - func_glWindowPos3sMESA( x, y, z ); + funcs->ext.p_glWindowPos3sMESA( x, y, z ); } static void WINAPI wine_glWindowPos3sv( GLshort* v ) { - void (*func_glWindowPos3sv)( GLshort* ) = extension_funcs[EXT_glWindowPos3sv]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos3sv( v ); + funcs->ext.p_glWindowPos3sv( v ); } static void WINAPI wine_glWindowPos3svARB( GLshort* v ) { - void (*func_glWindowPos3svARB)( GLshort* ) = extension_funcs[EXT_glWindowPos3svARB]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos3svARB( v ); + funcs->ext.p_glWindowPos3svARB( v ); } static void WINAPI wine_glWindowPos3svMESA( GLshort* v ) { - void (*func_glWindowPos3svMESA)( GLshort* ) = extension_funcs[EXT_glWindowPos3svMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos3svMESA( v ); + funcs->ext.p_glWindowPos3svMESA( v ); } static void WINAPI wine_glWindowPos4dMESA( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { - void (*func_glWindowPos4dMESA)( GLdouble, GLdouble, GLdouble, GLdouble ) = extension_funcs[EXT_glWindowPos4dMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f, %f)\n", x, y, z, w ); - func_glWindowPos4dMESA( x, y, z, w ); + funcs->ext.p_glWindowPos4dMESA( x, y, z, w ); } static void WINAPI wine_glWindowPos4dvMESA( GLdouble* v ) { - void (*func_glWindowPos4dvMESA)( GLdouble* ) = extension_funcs[EXT_glWindowPos4dvMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos4dvMESA( v ); + funcs->ext.p_glWindowPos4dvMESA( v ); } static void WINAPI wine_glWindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { - void (*func_glWindowPos4fMESA)( GLfloat, GLfloat, GLfloat, GLfloat ) = extension_funcs[EXT_glWindowPos4fMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%f, %f, %f, %f)\n", x, y, z, w ); - func_glWindowPos4fMESA( x, y, z, w ); + funcs->ext.p_glWindowPos4fMESA( x, y, z, w ); } static void WINAPI wine_glWindowPos4fvMESA( GLfloat* v ) { - void (*func_glWindowPos4fvMESA)( GLfloat* ) = extension_funcs[EXT_glWindowPos4fvMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos4fvMESA( v ); + funcs->ext.p_glWindowPos4fvMESA( v ); } static void WINAPI wine_glWindowPos4iMESA( GLint x, GLint y, GLint z, GLint w ) { - void (*func_glWindowPos4iMESA)( GLint, GLint, GLint, GLint ) = extension_funcs[EXT_glWindowPos4iMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", x, y, z, w ); - func_glWindowPos4iMESA( x, y, z, w ); + funcs->ext.p_glWindowPos4iMESA( x, y, z, w ); } static void WINAPI wine_glWindowPos4ivMESA( GLint* v ) { - void (*func_glWindowPos4ivMESA)( GLint* ) = extension_funcs[EXT_glWindowPos4ivMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos4ivMESA( v ); + funcs->ext.p_glWindowPos4ivMESA( v ); } static void WINAPI wine_glWindowPos4sMESA( GLshort x, GLshort y, GLshort z, GLshort w ) { - void (*func_glWindowPos4sMESA)( GLshort, GLshort, GLshort, GLshort ) = extension_funcs[EXT_glWindowPos4sMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d)\n", x, y, z, w ); - func_glWindowPos4sMESA( x, y, z, w ); + funcs->ext.p_glWindowPos4sMESA( x, y, z, w ); } static void WINAPI wine_glWindowPos4svMESA( GLshort* v ) { - void (*func_glWindowPos4svMESA)( GLshort* ) = extension_funcs[EXT_glWindowPos4svMESA]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%p)\n", v ); - func_glWindowPos4svMESA( v ); + funcs->ext.p_glWindowPos4svMESA( v ); } static void WINAPI wine_glWriteMaskEXT( GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW ) { - void (*func_glWriteMaskEXT)( GLuint, GLuint, GLenum, GLenum, GLenum, GLenum ) = extension_funcs[EXT_glWriteMaskEXT]; + const struct opengl_funcs *funcs = NtCurrentTeb()->glTable; TRACE("(%d, %d, %d, %d, %d, %d)\n", res, in, outX, outY, outZ, outW ); - func_glWriteMaskEXT( res, in, outX, outY, outZ, outW ); + funcs->ext.p_glWriteMaskEXT( res, in, outX, outY, outZ, outW ); } /* The table giving the correspondence between names and functions */ -const OpenGL_extension extension_registry[NB_EXTENSIONS] = { +const OpenGL_extension extension_registry[2064] = { { "glActiveProgramEXT", "GL_EXT_separate_shader_objects", wine_glActiveProgramEXT }, { "glActiveShaderProgram", "GL_ARB_separate_shader_objects", wine_glActiveShaderProgram }, { "glActiveStencilFaceEXT", "GL_EXT_stencil_two_side", wine_glActiveStencilFaceEXT }, diff --git a/dlls/opengl32/opengl_ext.h b/dlls/opengl32/opengl_ext.h index aab3e772f76..5e938517127 100644 --- a/dlls/opengl32/opengl_ext.h +++ b/dlls/opengl32/opengl_ext.h @@ -43,7 +43,6 @@ typedef struct { void *func; /* pointer to the Wine function for this extension */ } OpenGL_extension; -extern void *extension_funcs[]; extern const OpenGL_extension extension_registry[]; extern const int extension_registry_size; diff --git a/dlls/opengl32/wgl.c b/dlls/opengl32/wgl.c index b0c560be9d3..8acc173c2de 100644 --- a/dlls/opengl32/wgl.c +++ b/dlls/opengl32/wgl.c @@ -758,9 +758,9 @@ PROC WINAPI wglGetProcAddress(LPCSTR lpszProc) { return ret; } else { + struct opengl_funcs *funcs = NtCurrentTeb()->glTable; + *((void **)&funcs->ext + (ext_ret - extension_registry)) = local_func; TRACE("returning function (%p)\n", ext_ret->func); - extension_funcs[ext_ret - extension_registry] = local_func; - return ext_ret->func; } } -- 2.11.4.GIT