frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug #2996: libglx / libGLcore should use a dispatch table 

Port all changes from the (monolithic) accelerated_indirect-0-0-1 branch to
    the modular trunk. This will break the Darwin and cygwin builds. Other
    than the changes to symlink-mesa.sh and the various Makefile.am files,
    to code is identical to what's in the branch.
Reviewed by: airlied, krh
This commit is contained in:
Ian Romanick 2006-01-12 00:21:59 +00:00
parent c56e9a8849
commit 847d83ec3c
39 changed files with 15772 additions and 13106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

621
ChangeLog
View File

@ -1,3 +1,624 @@
2006-01-11 Ian Romanick <idr@us.ibm.com>
reviewed by: airlied, krh
* GL/glx/Makefile.am:
* GL/glx/g_disptab.c:
* GL/glx/g_disptab.h:
* GL/glx/g_disptab_EXT.c:
* GL/glx/g_disptab_EXT.h:
* GL/glx/g_render.c:
* GL/glx/g_renderswap.c:
* GL/glx/g_single.c:
* GL/glx/g_singleswap.c:
* GL/glx/glxcmds.c: (DoMakeCurrent), (__glXWaitGL),
(__glXCopyContext), (__glXSwapBuffers), (__glXVendorPrivate):
* GL/glx/glxcmdsswap.c: (__glXSwapVendorPrivate):
* GL/glx/glxserver.h:
* GL/glx/impsize.h:
* GL/glx/indirect_dispatch.c: (__glXDisp_NewList),
(__glXDisp_EndList), (__glXDisp_CallList), (__glXDisp_CallLists),
(__glXDisp_DeleteLists), (__glXDisp_GenLists),
(__glXDisp_ListBase), (__glXDisp_Begin), (__glXDisp_Bitmap),
(__glXDisp_Color3bv), (__glXDisp_Color3dv), (__glXDisp_Color3fv),
(__glXDisp_Color3iv), (__glXDisp_Color3sv), (__glXDisp_Color3ubv),
(__glXDisp_Color3uiv), (__glXDisp_Color3usv), (__glXDisp_Color4bv),
(__glXDisp_Color4dv), (__glXDisp_Color4fv), (__glXDisp_Color4iv),
(__glXDisp_Color4sv), (__glXDisp_Color4ubv), (__glXDisp_Color4uiv),
(__glXDisp_Color4usv), (__glXDisp_EdgeFlagv), (__glXDisp_End),
(__glXDisp_Indexdv), (__glXDisp_Indexfv), (__glXDisp_Indexiv),
(__glXDisp_Indexsv), (__glXDisp_Normal3bv), (__glXDisp_Normal3dv),
(__glXDisp_Normal3fv), (__glXDisp_Normal3iv),
(__glXDisp_Normal3sv), (__glXDisp_RasterPos2dv),
(__glXDisp_RasterPos2fv), (__glXDisp_RasterPos2iv),
(__glXDisp_RasterPos2sv), (__glXDisp_RasterPos3dv),
(__glXDisp_RasterPos3fv), (__glXDisp_RasterPos3iv),
(__glXDisp_RasterPos3sv), (__glXDisp_RasterPos4dv),
(__glXDisp_RasterPos4fv), (__glXDisp_RasterPos4iv),
(__glXDisp_RasterPos4sv), (__glXDisp_Rectdv), (__glXDisp_Rectfv),
(__glXDisp_Rectiv), (__glXDisp_Rectsv), (__glXDisp_TexCoord1dv),
(__glXDisp_TexCoord1fv), (__glXDisp_TexCoord1iv),
(__glXDisp_TexCoord1sv), (__glXDisp_TexCoord2dv),
(__glXDisp_TexCoord2fv), (__glXDisp_TexCoord2iv),
(__glXDisp_TexCoord2sv), (__glXDisp_TexCoord3dv),
(__glXDisp_TexCoord3fv), (__glXDisp_TexCoord3iv),
(__glXDisp_TexCoord3sv), (__glXDisp_TexCoord4dv),
(__glXDisp_TexCoord4fv), (__glXDisp_TexCoord4iv),
(__glXDisp_TexCoord4sv), (__glXDisp_Vertex2dv),
(__glXDisp_Vertex2fv), (__glXDisp_Vertex2iv),
(__glXDisp_Vertex2sv), (__glXDisp_Vertex3dv),
(__glXDisp_Vertex3fv), (__glXDisp_Vertex3iv),
(__glXDisp_Vertex3sv), (__glXDisp_Vertex4dv),
(__glXDisp_Vertex4fv), (__glXDisp_Vertex4iv),
(__glXDisp_Vertex4sv), (__glXDisp_ClipPlane),
(__glXDisp_ColorMaterial), (__glXDisp_CullFace), (__glXDisp_Fogf),
(__glXDisp_Fogfv), (__glXDisp_Fogi), (__glXDisp_Fogiv),
(__glXDisp_FrontFace), (__glXDisp_Hint), (__glXDisp_Lightf),
(__glXDisp_Lightfv), (__glXDisp_Lighti), (__glXDisp_Lightiv),
(__glXDisp_LightModelf), (__glXDisp_LightModelfv),
(__glXDisp_LightModeli), (__glXDisp_LightModeliv),
(__glXDisp_LineStipple), (__glXDisp_LineWidth),
(__glXDisp_Materialf), (__glXDisp_Materialfv),
(__glXDisp_Materiali), (__glXDisp_Materialiv),
(__glXDisp_PointSize), (__glXDisp_PolygonMode),
(__glXDisp_PolygonStipple), (__glXDisp_Scissor),
(__glXDisp_ShadeModel), (__glXDisp_TexParameterf),
(__glXDisp_TexParameterfv), (__glXDisp_TexParameteri),
(__glXDisp_TexParameteriv), (__glXDisp_TexImage1D),
(__glXDisp_TexImage2D), (__glXDisp_TexEnvf), (__glXDisp_TexEnvfv),
(__glXDisp_TexEnvi), (__glXDisp_TexEnviv), (__glXDisp_TexGend),
(__glXDisp_TexGendv), (__glXDisp_TexGenf), (__glXDisp_TexGenfv),
(__glXDisp_TexGeni), (__glXDisp_TexGeniv), (__glXDisp_InitNames),
(__glXDisp_LoadName), (__glXDisp_PassThrough), (__glXDisp_PopName),
(__glXDisp_PushName), (__glXDisp_DrawBuffer), (__glXDisp_Clear),
(__glXDisp_ClearAccum), (__glXDisp_ClearIndex),
(__glXDisp_ClearColor), (__glXDisp_ClearStencil),
(__glXDisp_ClearDepth), (__glXDisp_StencilMask),
(__glXDisp_ColorMask), (__glXDisp_DepthMask),
(__glXDisp_IndexMask), (__glXDisp_Accum), (__glXDisp_Disable),
(__glXDisp_Enable), (__glXDisp_PopAttrib), (__glXDisp_PushAttrib),
(__glXDisp_MapGrid1d), (__glXDisp_MapGrid1f),
(__glXDisp_MapGrid2d), (__glXDisp_MapGrid2f),
(__glXDisp_EvalCoord1dv), (__glXDisp_EvalCoord1fv),
(__glXDisp_EvalCoord2dv), (__glXDisp_EvalCoord2fv),
(__glXDisp_EvalMesh1), (__glXDisp_EvalPoint1),
(__glXDisp_EvalMesh2), (__glXDisp_EvalPoint2),
(__glXDisp_AlphaFunc), (__glXDisp_BlendFunc), (__glXDisp_LogicOp),
(__glXDisp_StencilFunc), (__glXDisp_StencilOp),
(__glXDisp_DepthFunc), (__glXDisp_PixelZoom),
(__glXDisp_PixelTransferf), (__glXDisp_PixelTransferi),
(__glXDisp_PixelStoref), (__glXDisp_PixelStorei),
(__glXDisp_PixelMapfv), (__glXDisp_PixelMapuiv),
(__glXDisp_PixelMapusv), (__glXDisp_ReadBuffer),
(__glXDisp_CopyPixels), (__glXDisp_DrawPixels),
(__glXDisp_GetBooleanv), (__glXDisp_GetClipPlane),
(__glXDisp_GetDoublev), (__glXDisp_GetError),
(__glXDisp_GetFloatv), (__glXDisp_GetIntegerv),
(__glXDisp_GetLightfv), (__glXDisp_GetLightiv),
(__glXDisp_GetMapdv), (__glXDisp_GetMapfv), (__glXDisp_GetMapiv),
(__glXDisp_GetMaterialfv), (__glXDisp_GetMaterialiv),
(__glXDisp_GetPixelMapfv), (__glXDisp_GetPixelMapuiv),
(__glXDisp_GetPixelMapusv), (__glXDisp_GetTexEnvfv),
(__glXDisp_GetTexEnviv), (__glXDisp_GetTexGendv),
(__glXDisp_GetTexGenfv), (__glXDisp_GetTexGeniv),
(__glXDisp_GetTexParameterfv), (__glXDisp_GetTexParameteriv),
(__glXDisp_GetTexLevelParameterfv),
(__glXDisp_GetTexLevelParameteriv), (__glXDisp_IsEnabled),
(__glXDisp_IsList), (__glXDisp_DepthRange), (__glXDisp_Frustum),
(__glXDisp_LoadIdentity), (__glXDisp_LoadMatrixf),
(__glXDisp_LoadMatrixd), (__glXDisp_MatrixMode),
(__glXDisp_MultMatrixf), (__glXDisp_MultMatrixd),
(__glXDisp_Ortho), (__glXDisp_PopMatrix), (__glXDisp_PushMatrix),
(__glXDisp_Rotated), (__glXDisp_Rotatef), (__glXDisp_Scaled),
(__glXDisp_Scalef), (__glXDisp_Translated), (__glXDisp_Translatef),
(__glXDisp_Viewport), (__glXDisp_BindTexture),
(__glXDisp_Indexubv), (__glXDisp_PolygonOffset),
(__glXDisp_AreTexturesResident), (__glXDisp_CopyTexImage1D),
(__glXDisp_CopyTexImage2D), (__glXDisp_CopyTexSubImage1D),
(__glXDisp_CopyTexSubImage2D), (__glXDisp_DeleteTextures),
(__glXDisp_GenTextures), (__glXDisp_IsTexture),
(__glXDisp_PrioritizeTextures), (__glXDisp_TexSubImage1D),
(__glXDisp_TexSubImage2D), (__glXDisp_BlendColor),
(__glXDisp_BlendEquation), (__glXDisp_ColorTable),
(__glXDisp_ColorTableParameterfv),
(__glXDisp_ColorTableParameteriv), (__glXDisp_CopyColorTable),
(__glXDisp_GetColorTableParameterfv),
(__glXDisp_GetColorTableParameteriv), (__glXDisp_ColorSubTable),
(__glXDisp_CopyColorSubTable), (__glXDisp_ConvolutionFilter1D),
(__glXDisp_ConvolutionFilter2D), (__glXDisp_ConvolutionParameterf),
(__glXDisp_ConvolutionParameterfv),
(__glXDisp_ConvolutionParameteri),
(__glXDisp_ConvolutionParameteriv),
(__glXDisp_CopyConvolutionFilter1D),
(__glXDisp_CopyConvolutionFilter2D),
(__glXDisp_GetConvolutionParameterfv),
(__glXDisp_GetConvolutionParameteriv),
(__glXDisp_GetHistogramParameterfv),
(__glXDisp_GetHistogramParameteriv),
(__glXDisp_GetMinmaxParameterfv), (__glXDisp_GetMinmaxParameteriv),
(__glXDisp_Histogram), (__glXDisp_Minmax),
(__glXDisp_ResetHistogram), (__glXDisp_ResetMinmax),
(__glXDisp_TexImage3D), (__glXDisp_TexSubImage3D),
(__glXDisp_CopyTexSubImage3D), (__glXDisp_ActiveTextureARB),
(__glXDisp_MultiTexCoord1dvARB), (__glXDisp_MultiTexCoord1fvARB),
(__glXDisp_MultiTexCoord1ivARB), (__glXDisp_MultiTexCoord1svARB),
(__glXDisp_MultiTexCoord2dvARB), (__glXDisp_MultiTexCoord2fvARB),
(__glXDisp_MultiTexCoord2ivARB), (__glXDisp_MultiTexCoord2svARB),
(__glXDisp_MultiTexCoord3dvARB), (__glXDisp_MultiTexCoord3fvARB),
(__glXDisp_MultiTexCoord3ivARB), (__glXDisp_MultiTexCoord3svARB),
(__glXDisp_MultiTexCoord4dvARB), (__glXDisp_MultiTexCoord4fvARB),
(__glXDisp_MultiTexCoord4ivARB), (__glXDisp_MultiTexCoord4svARB),
(__glXDisp_SampleCoverageARB), (__glXDisp_DrawBuffersARB),
(__glXDisp_AreTexturesResidentEXT), (__glXDisp_GenTexturesEXT),
(__glXDisp_IsTextureEXT), (__glXDisp_SampleMaskSGIS),
(__glXDisp_SamplePatternSGIS), (__glXDisp_PointParameterfEXT),
(__glXDisp_PointParameterfvEXT), (__glXDisp_WindowPos3fvMESA),
(__glXDisp_BlendFuncSeparateEXT), (__glXDisp_FogCoordfvEXT),
(__glXDisp_FogCoorddvEXT), (__glXDisp_CompressedTexImage3DARB),
(__glXDisp_CompressedTexImage2DARB),
(__glXDisp_CompressedTexImage1DARB),
(__glXDisp_CompressedTexSubImage3DARB),
(__glXDisp_CompressedTexSubImage2DARB),
(__glXDisp_CompressedTexSubImage1DARB),
(__glXDisp_SecondaryColor3bvEXT), (__glXDisp_SecondaryColor3dvEXT),
(__glXDisp_SecondaryColor3fvEXT), (__glXDisp_SecondaryColor3ivEXT),
(__glXDisp_SecondaryColor3svEXT),
(__glXDisp_SecondaryColor3ubvEXT),
(__glXDisp_SecondaryColor3uivEXT),
(__glXDisp_SecondaryColor3usvEXT),
(__glXDisp_AreProgramsResidentNV), (__glXDisp_BindProgramNV),
(__glXDisp_DeleteProgramsNV), (__glXDisp_ExecuteProgramNV),
(__glXDisp_GenProgramsNV), (__glXDisp_GetProgramParameterdvNV),
(__glXDisp_GetProgramParameterfvNV), (__glXDisp_GetProgramivNV),
(__glXDisp_GetTrackMatrixivNV), (__glXDisp_GetVertexAttribdvARB),
(__glXDisp_GetVertexAttribfvARB), (__glXDisp_GetVertexAttribivARB),
(__glXDisp_IsProgramNV), (__glXDisp_LoadProgramNV),
(__glXDisp_ProgramParameter4dvNV),
(__glXDisp_ProgramParameter4fvNV),
(__glXDisp_ProgramParameters4dvNV),
(__glXDisp_ProgramParameters4fvNV),
(__glXDisp_RequestResidentProgramsNV), (__glXDisp_TrackMatrixNV),
(__glXDisp_VertexAttrib1dvARB), (__glXDisp_VertexAttrib1fvARB),
(__glXDisp_VertexAttrib1svARB), (__glXDisp_VertexAttrib2dvARB),
(__glXDisp_VertexAttrib2fvARB), (__glXDisp_VertexAttrib2svARB),
(__glXDisp_VertexAttrib3dvARB), (__glXDisp_VertexAttrib3fvARB),
(__glXDisp_VertexAttrib3svARB), (__glXDisp_VertexAttrib4dvARB),
(__glXDisp_VertexAttrib4fvARB), (__glXDisp_VertexAttrib4svARB),
(__glXDisp_VertexAttrib4NubvARB), (__glXDisp_VertexAttribs1dvNV),
(__glXDisp_VertexAttribs1fvNV), (__glXDisp_VertexAttribs1svNV),
(__glXDisp_VertexAttribs2dvNV), (__glXDisp_VertexAttribs2fvNV),
(__glXDisp_VertexAttribs2svNV), (__glXDisp_VertexAttribs3dvNV),
(__glXDisp_VertexAttribs3fvNV), (__glXDisp_VertexAttribs3svNV),
(__glXDisp_VertexAttribs4dvNV), (__glXDisp_VertexAttribs4fvNV),
(__glXDisp_VertexAttribs4svNV), (__glXDisp_VertexAttribs4ubvNV),
(__glXDisp_PointParameteriNV), (__glXDisp_PointParameterivNV),
(__glXDisp_ActiveStencilFaceEXT), (__glXDisp_VertexAttrib4bvARB),
(__glXDisp_VertexAttrib4ivARB), (__glXDisp_VertexAttrib4ubvARB),
(__glXDisp_VertexAttrib4usvARB), (__glXDisp_VertexAttrib4uivARB),
(__glXDisp_VertexAttrib4NbvARB), (__glXDisp_VertexAttrib4NsvARB),
(__glXDisp_VertexAttrib4NivARB), (__glXDisp_VertexAttrib4NusvARB),
(__glXDisp_VertexAttrib4NuivARB), (__glXDisp_ProgramStringARB),
(__glXDisp_ProgramEnvParameter4dvARB),
(__glXDisp_ProgramEnvParameter4fvARB),
(__glXDisp_ProgramLocalParameter4dvARB),
(__glXDisp_ProgramLocalParameter4fvARB),
(__glXDisp_GetProgramEnvParameterdvARB),
(__glXDisp_GetProgramEnvParameterfvARB),
(__glXDisp_GetProgramLocalParameterdvARB),
(__glXDisp_GetProgramLocalParameterfvARB),
(__glXDisp_GetProgramivARB),
(__glXDisp_ProgramNamedParameter4fvNV),
(__glXDisp_ProgramNamedParameter4dvNV),
(__glXDisp_GetProgramNamedParameterfvNV),
(__glXDisp_GetProgramNamedParameterdvNV),
(__glXDisp_GenQueriesARB), (__glXDisp_DeleteQueriesARB),
(__glXDisp_IsQueryARB), (__glXDisp_BeginQueryARB),
(__glXDisp_EndQueryARB), (__glXDisp_GetQueryivARB),
(__glXDisp_GetQueryObjectivARB), (__glXDisp_GetQueryObjectuivARB),
(__glXDisp_GetVertexAttribdvNV), (__glXDisp_GetVertexAttribfvNV),
(__glXDisp_GetVertexAttribivNV), (__glXDisp_VertexAttrib1dvNV),
(__glXDisp_VertexAttrib1fvNV), (__glXDisp_VertexAttrib1svNV),
(__glXDisp_VertexAttrib2dvNV), (__glXDisp_VertexAttrib2fvNV),
(__glXDisp_VertexAttrib2svNV), (__glXDisp_VertexAttrib3dvNV),
(__glXDisp_VertexAttrib3fvNV), (__glXDisp_VertexAttrib3svNV),
(__glXDisp_VertexAttrib4dvNV), (__glXDisp_VertexAttrib4fvNV),
(__glXDisp_VertexAttrib4svNV), (__glXDisp_VertexAttrib4ubvNV),
(__glXDisp_IsRenderbufferEXT), (__glXDisp_BindRenderbufferEXT),
(__glXDisp_DeleteRenderbuffersEXT),
(__glXDisp_GenRenderbuffersEXT),
(__glXDisp_RenderbufferStorageEXT),
(__glXDisp_GetRenderbufferParameterivEXT),
(__glXDisp_IsFramebufferEXT), (__glXDisp_BindFramebufferEXT),
(__glXDisp_DeleteFramebuffersEXT), (__glXDisp_GenFramebuffersEXT),
(__glXDisp_CheckFramebufferStatusEXT),
(__glXDisp_FramebufferTexture1DEXT),
(__glXDisp_FramebufferTexture2DEXT),
(__glXDisp_FramebufferTexture3DEXT),
(__glXDisp_FramebufferRenderbufferEXT),
(__glXDisp_GetFramebufferAttachmentParameterivEXT),
(__glXDisp_GenerateMipmapEXT):
* GL/glx/indirect_dispatch.h:
* GL/glx/indirect_dispatch_swap.c: (bswap_ENUM), (bswap_CARD32),
(bswap_CARD16), (bswap_FLOAT32), (bswap_FLOAT64), (bswap_16_array),
(bswap_32_array), (bswap_64_array), (__glXDispSwap_NewList),
(__glXDispSwap_EndList), (__glXDispSwap_CallList),
(__glXDispSwap_CallLists), (__glXDispSwap_DeleteLists),
(__glXDispSwap_GenLists), (__glXDispSwap_ListBase),
(__glXDispSwap_Begin), (__glXDispSwap_Bitmap),
(__glXDispSwap_Color3bv), (__glXDispSwap_Color3dv),
(__glXDispSwap_Color3fv), (__glXDispSwap_Color3iv),
(__glXDispSwap_Color3sv), (__glXDispSwap_Color3ubv),
(__glXDispSwap_Color3uiv), (__glXDispSwap_Color3usv),
(__glXDispSwap_Color4bv), (__glXDispSwap_Color4dv),
(__glXDispSwap_Color4fv), (__glXDispSwap_Color4iv),
(__glXDispSwap_Color4sv), (__glXDispSwap_Color4ubv),
(__glXDispSwap_Color4uiv), (__glXDispSwap_Color4usv),
(__glXDispSwap_EdgeFlagv), (__glXDispSwap_End),
(__glXDispSwap_Indexdv), (__glXDispSwap_Indexfv),
(__glXDispSwap_Indexiv), (__glXDispSwap_Indexsv),
(__glXDispSwap_Normal3bv), (__glXDispSwap_Normal3dv),
(__glXDispSwap_Normal3fv), (__glXDispSwap_Normal3iv),
(__glXDispSwap_Normal3sv), (__glXDispSwap_RasterPos2dv),
(__glXDispSwap_RasterPos2fv), (__glXDispSwap_RasterPos2iv),
(__glXDispSwap_RasterPos2sv), (__glXDispSwap_RasterPos3dv),
(__glXDispSwap_RasterPos3fv), (__glXDispSwap_RasterPos3iv),
(__glXDispSwap_RasterPos3sv), (__glXDispSwap_RasterPos4dv),
(__glXDispSwap_RasterPos4fv), (__glXDispSwap_RasterPos4iv),
(__glXDispSwap_RasterPos4sv), (__glXDispSwap_Rectdv),
(__glXDispSwap_Rectfv), (__glXDispSwap_Rectiv),
(__glXDispSwap_Rectsv), (__glXDispSwap_TexCoord1dv),
(__glXDispSwap_TexCoord1fv), (__glXDispSwap_TexCoord1iv),
(__glXDispSwap_TexCoord1sv), (__glXDispSwap_TexCoord2dv),
(__glXDispSwap_TexCoord2fv), (__glXDispSwap_TexCoord2iv),
(__glXDispSwap_TexCoord2sv), (__glXDispSwap_TexCoord3dv),
(__glXDispSwap_TexCoord3fv), (__glXDispSwap_TexCoord3iv),
(__glXDispSwap_TexCoord3sv), (__glXDispSwap_TexCoord4dv),
(__glXDispSwap_TexCoord4fv), (__glXDispSwap_TexCoord4iv),
(__glXDispSwap_TexCoord4sv), (__glXDispSwap_Vertex2dv),
(__glXDispSwap_Vertex2fv), (__glXDispSwap_Vertex2iv),
(__glXDispSwap_Vertex2sv), (__glXDispSwap_Vertex3dv),
(__glXDispSwap_Vertex3fv), (__glXDispSwap_Vertex3iv),
(__glXDispSwap_Vertex3sv), (__glXDispSwap_Vertex4dv),
(__glXDispSwap_Vertex4fv), (__glXDispSwap_Vertex4iv),
(__glXDispSwap_Vertex4sv), (__glXDispSwap_ClipPlane),
(__glXDispSwap_ColorMaterial), (__glXDispSwap_CullFace),
(__glXDispSwap_Fogf), (__glXDispSwap_Fogfv), (__glXDispSwap_Fogi),
(__glXDispSwap_Fogiv), (__glXDispSwap_FrontFace),
(__glXDispSwap_Hint), (__glXDispSwap_Lightf),
(__glXDispSwap_Lightfv), (__glXDispSwap_Lighti),
(__glXDispSwap_Lightiv), (__glXDispSwap_LightModelf),
(__glXDispSwap_LightModelfv), (__glXDispSwap_LightModeli),
(__glXDispSwap_LightModeliv), (__glXDispSwap_LineStipple),
(__glXDispSwap_LineWidth), (__glXDispSwap_Materialf),
(__glXDispSwap_Materialfv), (__glXDispSwap_Materiali),
(__glXDispSwap_Materialiv), (__glXDispSwap_PointSize),
(__glXDispSwap_PolygonMode), (__glXDispSwap_PolygonStipple),
(__glXDispSwap_Scissor), (__glXDispSwap_ShadeModel),
(__glXDispSwap_TexParameterf), (__glXDispSwap_TexParameterfv),
(__glXDispSwap_TexParameteri), (__glXDispSwap_TexParameteriv),
(__glXDispSwap_TexImage1D), (__glXDispSwap_TexImage2D),
(__glXDispSwap_TexEnvf), (__glXDispSwap_TexEnvfv),
(__glXDispSwap_TexEnvi), (__glXDispSwap_TexEnviv),
(__glXDispSwap_TexGend), (__glXDispSwap_TexGendv),
(__glXDispSwap_TexGenf), (__glXDispSwap_TexGenfv),
(__glXDispSwap_TexGeni), (__glXDispSwap_TexGeniv),
(__glXDispSwap_InitNames), (__glXDispSwap_LoadName),
(__glXDispSwap_PassThrough), (__glXDispSwap_PopName),
(__glXDispSwap_PushName), (__glXDispSwap_DrawBuffer),
(__glXDispSwap_Clear), (__glXDispSwap_ClearAccum),
(__glXDispSwap_ClearIndex), (__glXDispSwap_ClearColor),
(__glXDispSwap_ClearStencil), (__glXDispSwap_ClearDepth),
(__glXDispSwap_StencilMask), (__glXDispSwap_ColorMask),
(__glXDispSwap_DepthMask), (__glXDispSwap_IndexMask),
(__glXDispSwap_Accum), (__glXDispSwap_Disable),
(__glXDispSwap_Enable), (__glXDispSwap_PopAttrib),
(__glXDispSwap_PushAttrib), (__glXDispSwap_MapGrid1d),
(__glXDispSwap_MapGrid1f), (__glXDispSwap_MapGrid2d),
(__glXDispSwap_MapGrid2f), (__glXDispSwap_EvalCoord1dv),
(__glXDispSwap_EvalCoord1fv), (__glXDispSwap_EvalCoord2dv),
(__glXDispSwap_EvalCoord2fv), (__glXDispSwap_EvalMesh1),
(__glXDispSwap_EvalPoint1), (__glXDispSwap_EvalMesh2),
(__glXDispSwap_EvalPoint2), (__glXDispSwap_AlphaFunc),
(__glXDispSwap_BlendFunc), (__glXDispSwap_LogicOp),
(__glXDispSwap_StencilFunc), (__glXDispSwap_StencilOp),
(__glXDispSwap_DepthFunc), (__glXDispSwap_PixelZoom),
(__glXDispSwap_PixelTransferf), (__glXDispSwap_PixelTransferi),
(__glXDispSwap_PixelStoref), (__glXDispSwap_PixelStorei),
(__glXDispSwap_PixelMapfv), (__glXDispSwap_PixelMapuiv),
(__glXDispSwap_PixelMapusv), (__glXDispSwap_ReadBuffer),
(__glXDispSwap_CopyPixels), (__glXDispSwap_DrawPixels),
(__glXDispSwap_GetBooleanv), (__glXDispSwap_GetClipPlane),
(__glXDispSwap_GetDoublev), (__glXDispSwap_GetError),
(__glXDispSwap_GetFloatv), (__glXDispSwap_GetIntegerv),
(__glXDispSwap_GetLightfv), (__glXDispSwap_GetLightiv),
(__glXDispSwap_GetMapdv), (__glXDispSwap_GetMapfv),
(__glXDispSwap_GetMapiv), (__glXDispSwap_GetMaterialfv),
(__glXDispSwap_GetMaterialiv), (__glXDispSwap_GetPixelMapfv),
(__glXDispSwap_GetPixelMapuiv), (__glXDispSwap_GetPixelMapusv),
(__glXDispSwap_GetTexEnvfv), (__glXDispSwap_GetTexEnviv),
(__glXDispSwap_GetTexGendv), (__glXDispSwap_GetTexGenfv),
(__glXDispSwap_GetTexGeniv), (__glXDispSwap_GetTexParameterfv),
(__glXDispSwap_GetTexParameteriv),
(__glXDispSwap_GetTexLevelParameterfv),
(__glXDispSwap_GetTexLevelParameteriv), (__glXDispSwap_IsEnabled),
(__glXDispSwap_IsList), (__glXDispSwap_DepthRange),
(__glXDispSwap_Frustum), (__glXDispSwap_LoadIdentity),
(__glXDispSwap_LoadMatrixf), (__glXDispSwap_LoadMatrixd),
(__glXDispSwap_MatrixMode), (__glXDispSwap_MultMatrixf),
(__glXDispSwap_MultMatrixd), (__glXDispSwap_Ortho),
(__glXDispSwap_PopMatrix), (__glXDispSwap_PushMatrix),
(__glXDispSwap_Rotated), (__glXDispSwap_Rotatef),
(__glXDispSwap_Scaled), (__glXDispSwap_Scalef),
(__glXDispSwap_Translated), (__glXDispSwap_Translatef),
(__glXDispSwap_Viewport), (__glXDispSwap_BindTexture),
(__glXDispSwap_Indexubv), (__glXDispSwap_PolygonOffset),
(__glXDispSwap_AreTexturesResident),
(__glXDispSwap_CopyTexImage1D), (__glXDispSwap_CopyTexImage2D),
(__glXDispSwap_CopyTexSubImage1D),
(__glXDispSwap_CopyTexSubImage2D), (__glXDispSwap_DeleteTextures),
(__glXDispSwap_GenTextures), (__glXDispSwap_IsTexture),
(__glXDispSwap_PrioritizeTextures), (__glXDispSwap_TexSubImage1D),
(__glXDispSwap_TexSubImage2D), (__glXDispSwap_BlendColor),
(__glXDispSwap_BlendEquation), (__glXDispSwap_ColorTable),
(__glXDispSwap_ColorTableParameterfv),
(__glXDispSwap_ColorTableParameteriv),
(__glXDispSwap_CopyColorTable),
(__glXDispSwap_GetColorTableParameterfv),
(__glXDispSwap_GetColorTableParameteriv),
(__glXDispSwap_ColorSubTable), (__glXDispSwap_CopyColorSubTable),
(__glXDispSwap_ConvolutionFilter1D),
(__glXDispSwap_ConvolutionFilter2D),
(__glXDispSwap_ConvolutionParameterf),
(__glXDispSwap_ConvolutionParameterfv),
(__glXDispSwap_ConvolutionParameteri),
(__glXDispSwap_ConvolutionParameteriv),
(__glXDispSwap_CopyConvolutionFilter1D),
(__glXDispSwap_CopyConvolutionFilter2D),
(__glXDispSwap_GetConvolutionParameterfv),
(__glXDispSwap_GetConvolutionParameteriv),
(__glXDispSwap_GetHistogramParameterfv),
(__glXDispSwap_GetHistogramParameteriv),
(__glXDispSwap_GetMinmaxParameterfv),
(__glXDispSwap_GetMinmaxParameteriv), (__glXDispSwap_Histogram),
(__glXDispSwap_Minmax), (__glXDispSwap_ResetHistogram),
(__glXDispSwap_ResetMinmax), (__glXDispSwap_TexImage3D),
(__glXDispSwap_TexSubImage3D), (__glXDispSwap_CopyTexSubImage3D),
(__glXDispSwap_ActiveTextureARB),
(__glXDispSwap_MultiTexCoord1dvARB),
(__glXDispSwap_MultiTexCoord1fvARB),
(__glXDispSwap_MultiTexCoord1ivARB),
(__glXDispSwap_MultiTexCoord1svARB),
(__glXDispSwap_MultiTexCoord2dvARB),
(__glXDispSwap_MultiTexCoord2fvARB),
(__glXDispSwap_MultiTexCoord2ivARB),
(__glXDispSwap_MultiTexCoord2svARB),
(__glXDispSwap_MultiTexCoord3dvARB),
(__glXDispSwap_MultiTexCoord3fvARB),
(__glXDispSwap_MultiTexCoord3ivARB),
(__glXDispSwap_MultiTexCoord3svARB),
(__glXDispSwap_MultiTexCoord4dvARB),
(__glXDispSwap_MultiTexCoord4fvARB),
(__glXDispSwap_MultiTexCoord4ivARB),
(__glXDispSwap_MultiTexCoord4svARB),
(__glXDispSwap_SampleCoverageARB), (__glXDispSwap_DrawBuffersARB),
(__glXDispSwap_AreTexturesResidentEXT),
(__glXDispSwap_GenTexturesEXT), (__glXDispSwap_IsTextureEXT),
(__glXDispSwap_SampleMaskSGIS), (__glXDispSwap_SamplePatternSGIS),
(__glXDispSwap_PointParameterfEXT),
(__glXDispSwap_PointParameterfvEXT),
(__glXDispSwap_WindowPos3fvMESA),
(__glXDispSwap_BlendFuncSeparateEXT),
(__glXDispSwap_FogCoordfvEXT), (__glXDispSwap_FogCoorddvEXT),
(__glXDispSwap_CompressedTexImage3DARB),
(__glXDispSwap_CompressedTexImage2DARB),
(__glXDispSwap_CompressedTexImage1DARB),
(__glXDispSwap_CompressedTexSubImage3DARB),
(__glXDispSwap_CompressedTexSubImage2DARB),
(__glXDispSwap_CompressedTexSubImage1DARB),
(__glXDispSwap_SecondaryColor3bvEXT),
(__glXDispSwap_SecondaryColor3dvEXT),
(__glXDispSwap_SecondaryColor3fvEXT),
(__glXDispSwap_SecondaryColor3ivEXT),
(__glXDispSwap_SecondaryColor3svEXT),
(__glXDispSwap_SecondaryColor3ubvEXT),
(__glXDispSwap_SecondaryColor3uivEXT),
(__glXDispSwap_SecondaryColor3usvEXT),
(__glXDispSwap_AreProgramsResidentNV),
(__glXDispSwap_BindProgramNV), (__glXDispSwap_DeleteProgramsNV),
(__glXDispSwap_ExecuteProgramNV), (__glXDispSwap_GenProgramsNV),
(__glXDispSwap_GetProgramParameterdvNV),
(__glXDispSwap_GetProgramParameterfvNV),
(__glXDispSwap_GetProgramivNV), (__glXDispSwap_GetTrackMatrixivNV),
(__glXDispSwap_GetVertexAttribdvARB),
(__glXDispSwap_GetVertexAttribfvARB),
(__glXDispSwap_GetVertexAttribivARB), (__glXDispSwap_IsProgramNV),
(__glXDispSwap_LoadProgramNV),
(__glXDispSwap_ProgramParameter4dvNV),
(__glXDispSwap_ProgramParameter4fvNV),
(__glXDispSwap_ProgramParameters4dvNV),
(__glXDispSwap_ProgramParameters4fvNV),
(__glXDispSwap_RequestResidentProgramsNV),
(__glXDispSwap_TrackMatrixNV), (__glXDispSwap_VertexAttrib1dvARB),
(__glXDispSwap_VertexAttrib1fvARB),
(__glXDispSwap_VertexAttrib1svARB),
(__glXDispSwap_VertexAttrib2dvARB),
(__glXDispSwap_VertexAttrib2fvARB),
(__glXDispSwap_VertexAttrib2svARB),
(__glXDispSwap_VertexAttrib3dvARB),
(__glXDispSwap_VertexAttrib3fvARB),
(__glXDispSwap_VertexAttrib3svARB),
(__glXDispSwap_VertexAttrib4dvARB),
(__glXDispSwap_VertexAttrib4fvARB),
(__glXDispSwap_VertexAttrib4svARB),
(__glXDispSwap_VertexAttrib4NubvARB),
(__glXDispSwap_VertexAttribs1dvNV),
(__glXDispSwap_VertexAttribs1fvNV),
(__glXDispSwap_VertexAttribs1svNV),
(__glXDispSwap_VertexAttribs2dvNV),
(__glXDispSwap_VertexAttribs2fvNV),
(__glXDispSwap_VertexAttribs2svNV),
(__glXDispSwap_VertexAttribs3dvNV),
(__glXDispSwap_VertexAttribs3fvNV),
(__glXDispSwap_VertexAttribs3svNV),
(__glXDispSwap_VertexAttribs4dvNV),
(__glXDispSwap_VertexAttribs4fvNV),
(__glXDispSwap_VertexAttribs4svNV),
(__glXDispSwap_VertexAttribs4ubvNV),
(__glXDispSwap_PointParameteriNV),
(__glXDispSwap_PointParameterivNV),
(__glXDispSwap_ActiveStencilFaceEXT),
(__glXDispSwap_VertexAttrib4bvARB),
(__glXDispSwap_VertexAttrib4ivARB),
(__glXDispSwap_VertexAttrib4ubvARB),
(__glXDispSwap_VertexAttrib4usvARB),
(__glXDispSwap_VertexAttrib4uivARB),
(__glXDispSwap_VertexAttrib4NbvARB),
(__glXDispSwap_VertexAttrib4NsvARB),
(__glXDispSwap_VertexAttrib4NivARB),
(__glXDispSwap_VertexAttrib4NusvARB),
(__glXDispSwap_VertexAttrib4NuivARB),
(__glXDispSwap_ProgramStringARB),
(__glXDispSwap_ProgramEnvParameter4dvARB),
(__glXDispSwap_ProgramEnvParameter4fvARB),
(__glXDispSwap_ProgramLocalParameter4dvARB),
(__glXDispSwap_ProgramLocalParameter4fvARB),
(__glXDispSwap_GetProgramEnvParameterdvARB),
(__glXDispSwap_GetProgramEnvParameterfvARB),
(__glXDispSwap_GetProgramLocalParameterdvARB),
(__glXDispSwap_GetProgramLocalParameterfvARB),
(__glXDispSwap_GetProgramivARB),
(__glXDispSwap_ProgramNamedParameter4fvNV),
(__glXDispSwap_ProgramNamedParameter4dvNV),
(__glXDispSwap_GetProgramNamedParameterfvNV),
(__glXDispSwap_GetProgramNamedParameterdvNV),
(__glXDispSwap_GenQueriesARB), (__glXDispSwap_DeleteQueriesARB),
(__glXDispSwap_IsQueryARB), (__glXDispSwap_BeginQueryARB),
(__glXDispSwap_EndQueryARB), (__glXDispSwap_GetQueryivARB),
(__glXDispSwap_GetQueryObjectivARB),
(__glXDispSwap_GetQueryObjectuivARB),
(__glXDispSwap_GetVertexAttribdvNV),
(__glXDispSwap_GetVertexAttribfvNV),
(__glXDispSwap_GetVertexAttribivNV),
(__glXDispSwap_VertexAttrib1dvNV),
(__glXDispSwap_VertexAttrib1fvNV),
(__glXDispSwap_VertexAttrib1svNV),
(__glXDispSwap_VertexAttrib2dvNV),
(__glXDispSwap_VertexAttrib2fvNV),
(__glXDispSwap_VertexAttrib2svNV),
(__glXDispSwap_VertexAttrib3dvNV),
(__glXDispSwap_VertexAttrib3fvNV),
(__glXDispSwap_VertexAttrib3svNV),
(__glXDispSwap_VertexAttrib4dvNV),
(__glXDispSwap_VertexAttrib4fvNV),
(__glXDispSwap_VertexAttrib4svNV),
(__glXDispSwap_VertexAttrib4ubvNV),
(__glXDispSwap_IsRenderbufferEXT),
(__glXDispSwap_BindRenderbufferEXT),
(__glXDispSwap_DeleteRenderbuffersEXT),
(__glXDispSwap_GenRenderbuffersEXT),
(__glXDispSwap_RenderbufferStorageEXT),
(__glXDispSwap_GetRenderbufferParameterivEXT),
(__glXDispSwap_IsFramebufferEXT),
(__glXDispSwap_BindFramebufferEXT),
(__glXDispSwap_DeleteFramebuffersEXT),
(__glXDispSwap_GenFramebuffersEXT),
(__glXDispSwap_CheckFramebufferStatusEXT),
(__glXDispSwap_FramebufferTexture1DEXT),
(__glXDispSwap_FramebufferTexture2DEXT),
(__glXDispSwap_FramebufferTexture3DEXT),
(__glXDispSwap_FramebufferRenderbufferEXT),
(__glXDispSwap_GetFramebufferAttachmentParameterivEXT),
(__glXDispSwap_GenerateMipmapEXT):
* GL/glx/indirect_reqsize.c: (__glXCallListsReqSize),
(__glXBitmapReqSize), (__glXFogfvReqSize), (__glXLightfvReqSize),
(__glXLightModelfvReqSize), (__glXMaterialfvReqSize),
(__glXPolygonStippleReqSize), (__glXTexParameterfvReqSize),
(__glXTexImage1DReqSize), (__glXTexImage2DReqSize),
(__glXTexEnvfvReqSize), (__glXTexGendvReqSize),
(__glXTexGenfvReqSize), (__glXPixelMapfvReqSize),
(__glXPixelMapusvReqSize), (__glXDrawPixelsReqSize),
(__glXPrioritizeTexturesReqSize), (__glXTexSubImage1DReqSize),
(__glXTexSubImage2DReqSize), (__glXColorTableReqSize),
(__glXColorTableParameterfvReqSize), (__glXColorSubTableReqSize),
(__glXConvolutionFilter1DReqSize),
(__glXConvolutionFilter2DReqSize),
(__glXConvolutionParameterfvReqSize), (__glXTexImage3DReqSize),
(__glXTexSubImage3DReqSize), (__glXDrawBuffersARBReqSize),
(__glXPointParameterfvEXTReqSize),
(__glXCompressedTexImage3DARBReqSize),
(__glXCompressedTexImage2DARBReqSize),
(__glXCompressedTexImage1DARBReqSize),
(__glXCompressedTexSubImage3DARBReqSize),
(__glXLoadProgramNVReqSize), (__glXProgramParameters4dvNVReqSize),
(__glXProgramParameters4fvNVReqSize),
(__glXVertexAttribs1dvNVReqSize), (__glXVertexAttribs2dvNVReqSize),
(__glXVertexAttribs3dvNVReqSize), (__glXVertexAttribs3fvNVReqSize),
(__glXVertexAttribs3svNVReqSize), (__glXVertexAttribs4dvNVReqSize),
(__glXProgramNamedParameter4fvNVReqSize):
* GL/glx/indirect_reqsize.h:
* GL/glx/indirect_size_get.c: (__glCallLists_size),
(__glFogfv_size), (__glLightfv_size), (__glLightModelfv_size),
(__glMaterialfv_size), (__glTexParameterfv_size),
(__glTexEnvfv_size), (__glTexGendv_size), (__glMap1d_size),
(__glMap2d_size), (__glGetBooleanv_size),
(__glGetTexParameterfv_size), (__glGetTexLevelParameterfv_size),
(__glColorTableParameterfv_size),
(__glGetColorTableParameterfv_size),
(__glConvolutionParameterfv_size),
(__glGetConvolutionParameterfv_size),
(__glGetHistogramParameterfv_size),
(__glGetMinmaxParameterfv_size), (__glPointParameterfvEXT_size),
(__glGetProgramivNV_size), (__glGetVertexAttribdvARB_size),
(__glGetProgramivARB_size), (__glGetQueryivARB_size),
(__glGetQueryObjectivARB_size), (__glGetVertexAttribdvNV_size),
(__glGetFramebufferAttachmentParameterivEXT_size):
* GL/glx/indirect_size_get.h:
* GL/glx/indirect_util.c: (__glGetBooleanv_variable_size),
(__glXGetAnswerBuffer), (__glXSendReply), (__glXSendReplySwap):
* GL/glx/indirect_util.h:
* GL/glx/render2.c: (__glXDisp_Map1f), (__glXDisp_Map2f),
(__glXDisp_Map1d), (__glXDisp_Map2d), (__glXDisp_DrawArrays):
* GL/glx/render2swap.c: (__glXDispSwap_Map1f),
(__glXDispSwap_Map2f), (__glXDispSwap_Map1d),
(__glXDispSwap_Map2d), (__glXDispSwap_DrawArrays):
* GL/glx/renderpix.c: (__glXDisp_SeparableFilter2D):
* GL/glx/renderpixswap.c: (__glXDispSwap_SeparableFilter2D):
* GL/glx/rensize.c: (__glXMap1dReqSize), (__glXMap1fReqSize),
(__glXMap2dReqSize), (__glXMap2fReqSize), (__glXDrawArraysSize),
(__glXSeparableFilter2DReqSize):
* GL/glx/rensizetab.c:
* GL/glx/single2.c: (__glXDisp_FeedbackBuffer),
(__glXDisp_SelectBuffer), (__glXDisp_RenderMode),
(__glXDisp_Flush), (__glXDisp_Finish), (DoGetString),
(__glXDisp_GetString):
* GL/glx/single2swap.c: (__glXDispSwap_FeedbackBuffer),
(__glXDispSwap_SelectBuffer), (__glXDispSwap_RenderMode),
(__glXDispSwap_Flush), (__glXDispSwap_Finish),
(__glXDispSwap_GetString):
* GL/glx/singlepix.c: (__glXDisp_ReadPixels),
(__glXDisp_GetTexImage), (__glXDisp_GetPolygonStipple),
(__glXDisp_GetSeparableFilter), (__glXDisp_GetConvolutionFilter),
(__glXDisp_GetHistogram), (__glXDisp_GetMinmax),
(__glXDisp_GetColorTable):
* GL/glx/singlepixswap.c: (__glXDispSwap_ReadPixels),
(__glXDispSwap_GetTexImage), (__glXDispSwap_GetPolygonStipple),
(__glXDispSwap_GetSeparableFilter),
(__glXDispSwap_GetConvolutionFilter), (__glXDispSwap_GetHistogram),
(__glXDispSwap_GetMinmax), (__glXDispSwap_GetColorTable):
* GL/glx/singlesize.c: (__glGetMap_size), (__glGetPixelMap_size),
(__glGetTexImage_size):
* GL/glx/singlesize.h:
* GL/glx/xfont.c: (__glXMakeBitmapFromGlyph),
(MakeBitmapsFromFont), (__glXUseXFont):
* GL/mesa/Makefile.am:
* GL/mesa/main/Makefile.am:
* GL/symlink-mesa.sh:
Bug #2996: libglx / libGLcore should use a dispatch table
Port all changes from the (monolithic) accelerated_indirect-0-0-1
branch to the modular trunk. This will break the Darwin and cygwin
builds. Other than the changes to symlink-mesa.sh and the various
Makefile.am files, to code is identical to what's in the branch.
2006-01-10 Daniel Stone <daniel@freedesktop.org>
* configure.ac:

20
GL/glx/Makefile.am
View File

@ -5,6 +5,8 @@ AM_CFLAGS = \
@GL_CFLAGS@ \
@XLIB_CFLAGS@ \
-I@MESA_SOURCE@/include \
-I@MESA_SOURCE@/src/mesa/glapi \
-I@MESA_SOURCE@/src/mesa/main \
@SERVER_DEFINES@ \
@MODULE_DEFINES@ \
@LOADER_DEFINES@
@ -14,20 +16,18 @@ AM_CFLAGS = \
INCLUDES = -I$(top_srcdir)/GL/include -I$(top_srcdir)/hw/xfree86/os-support
nodist_libglx_la_SOURCES = indirect_size.c indirect_size.h
nodist_libglx_la_SOURCES = indirect_size.h
libglx_la_SOURCES = \
g_disptab.c \
g_disptab.h \
g_disptab_EXT.c \
g_disptab_EXT.h \
g_render.c \
g_renderswap.c \
g_single.c \
g_singleswap.c \
glapi.c \
glcontextmodes.c \
glcontextmodes.h \
global.c \
glthread.c \
glxbuf.c \
glxbuf.h \
glxcmds.c \
@ -50,7 +50,15 @@ libglx_la_SOURCES = \
glxserver.h \
glxutil.c \
glxutil.h \
impsize.h \
indirect_dispatch.c \
indirect_dispatch.h \
indirect_dispatch_swap.c \
indirect_reqsize.c \
indirect_reqsize.h \
indirect_size_get.c \
indirect_size_get.h \
indirect_util.c \
indirect_util.h \
render2.c \
render2swap.c \
renderpix.c \

6
GL/glx/g_disptab.c
View File

@ -36,6 +36,8 @@
#include "glxserver.h"
#include "glxext.h"
#include "g_disptab.h"
#include "indirect_dispatch.h"
__GLXdispatchSingleProcPtr __glXSingleTable[__GLX_SINGLE_TABLE_SIZE] = {
__glXNoSuchSingleOpcode,
__glXRender,
@ -431,7 +433,7 @@ __GLXdispatchRenderProcPtr __glXRenderTable[] = {
__glXNoSuchRenderOpcode,
__glXDisp_SampleCoverageARB,
#ifndef MISSING_GL_EXTS
__glXDisp_WindowPos3fARB /* 230 */
__glXDisp_WindowPos3fvMESA /* 230 */
#else
__glXNoSuchRenderOpcode
#endif
@ -832,7 +834,7 @@ __GLXdispatchRenderProcPtr __glXSwapRenderTable[__GLX_RENDER_TABLE_SIZE] = {
__glXNoSuchRenderOpcode,
__glXDispSwap_SampleCoverageARB,
#ifndef MISSING_GL_EXTS
__glXDispSwap_WindowPos3fARB /* 230 */
__glXDispSwap_WindowPos3fvMESA /* 230 */
#else
__glXNoSuchRenderOpcode
#endif

550
GL/glx/g_disptab.h
View File

@ -60,281 +60,6 @@ extern int __glXGetFBConfigs(__GLXclientState*, GLbyte*);
extern int __glXCreateNewContext(__GLXclientState*, GLbyte*);
extern int __glXCreatePixmap(__GLXclientState*, GLbyte*);
extern int __glXDisp_NewList(__GLXclientState*, GLbyte*);
extern int __glXDisp_EndList(__GLXclientState*, GLbyte*);
extern int __glXDisp_DeleteLists(__GLXclientState*, GLbyte*);
extern int __glXDisp_GenLists(__GLXclientState*, GLbyte*);
extern int __glXDisp_FeedbackBuffer(__GLXclientState*, GLbyte*);
extern int __glXDisp_SelectBuffer(__GLXclientState*, GLbyte*);
extern int __glXDisp_RenderMode(__GLXclientState*, GLbyte*);
extern int __glXDisp_Finish(__GLXclientState*, GLbyte*);
extern int __glXDisp_PixelStoref(__GLXclientState*, GLbyte*);
extern int __glXDisp_PixelStorei(__GLXclientState*, GLbyte*);
extern int __glXDisp_ReadPixels(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetBooleanv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetClipPlane(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetDoublev(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetError(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetFloatv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetIntegerv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetLightfv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetLightiv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetMapdv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetMapfv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetMapiv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetMaterialfv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetMaterialiv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetPixelMapfv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetPixelMapuiv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetPixelMapusv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetPolygonStipple(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetString(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetTexEnvfv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetTexEnviv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetTexGendv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetTexGenfv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetTexGeniv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetTexImage(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetTexParameterfv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetTexParameteriv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetTexLevelParameterfv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetTexLevelParameteriv(__GLXclientState*, GLbyte*);
extern int __glXDisp_IsEnabled(__GLXclientState*, GLbyte*);
extern int __glXDisp_IsList(__GLXclientState*, GLbyte*);
extern int __glXDisp_Flush(__GLXclientState*, GLbyte*);
extern int __glXDisp_AreTexturesResident(__GLXclientState*, GLbyte*);
extern int __glXDisp_DeleteTextures(__GLXclientState*, GLbyte*);
extern int __glXDisp_GenTextures(__GLXclientState*, GLbyte*);
extern int __glXDisp_IsTexture(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetColorTable(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetColorTableParameterfv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetColorTableParameteriv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetConvolutionFilter(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetConvolutionParameterfv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetConvolutionParameteriv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetSeparableFilter(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetHistogram(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetHistogramParameterfv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetHistogramParameteriv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetMinmax(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetMinmaxParameterfv(__GLXclientState*, GLbyte*);
extern int __glXDisp_GetMinmaxParameteriv(__GLXclientState*, GLbyte*);
extern void __glXDisp_CallList(GLbyte*);
extern void __glXDisp_CallLists(GLbyte*);
extern void __glXDisp_ListBase(GLbyte*);
extern void __glXDisp_Begin(GLbyte*);
extern void __glXDisp_Bitmap(GLbyte*);
extern void __glXDisp_Color3bv(GLbyte*);
extern void __glXDisp_Color3dv(GLbyte*);
extern void __glXDisp_Color3fv(GLbyte*);
extern void __glXDisp_Color3iv(GLbyte*);
extern void __glXDisp_Color3sv(GLbyte*);
extern void __glXDisp_Color3ubv(GLbyte*);
extern void __glXDisp_Color3uiv(GLbyte*);
extern void __glXDisp_Color3usv(GLbyte*);
extern void __glXDisp_Color4bv(GLbyte*);
extern void __glXDisp_Color4dv(GLbyte*);
extern void __glXDisp_Color4fv(GLbyte*);
extern void __glXDisp_Color4iv(GLbyte*);
extern void __glXDisp_Color4sv(GLbyte*);
extern void __glXDisp_Color4ubv(GLbyte*);
extern void __glXDisp_Color4uiv(GLbyte*);
extern void __glXDisp_Color4usv(GLbyte*);
extern void __glXDisp_EdgeFlagv(GLbyte*);
extern void __glXDisp_End(GLbyte*);
extern void __glXDisp_Indexdv(GLbyte*);
extern void __glXDisp_Indexfv(GLbyte*);
extern void __glXDisp_Indexiv(GLbyte*);
extern void __glXDisp_Indexsv(GLbyte*);
extern void __glXDisp_Normal3bv(GLbyte*);
extern void __glXDisp_Normal3dv(GLbyte*);
extern void __glXDisp_Normal3fv(GLbyte*);
extern void __glXDisp_Normal3iv(GLbyte*);
extern void __glXDisp_Normal3sv(GLbyte*);
extern void __glXDisp_RasterPos2dv(GLbyte*);
extern void __glXDisp_RasterPos2fv(GLbyte*);
extern void __glXDisp_RasterPos2iv(GLbyte*);
extern void __glXDisp_RasterPos2sv(GLbyte*);
extern void __glXDisp_RasterPos3dv(GLbyte*);
extern void __glXDisp_RasterPos3fv(GLbyte*);
extern void __glXDisp_RasterPos3iv(GLbyte*);
extern void __glXDisp_RasterPos3sv(GLbyte*);
extern void __glXDisp_RasterPos4dv(GLbyte*);
extern void __glXDisp_RasterPos4fv(GLbyte*);
extern void __glXDisp_RasterPos4iv(GLbyte*);
extern void __glXDisp_RasterPos4sv(GLbyte*);
extern void __glXDisp_Rectdv(GLbyte*);
extern void __glXDisp_Rectfv(GLbyte*);
extern void __glXDisp_Rectiv(GLbyte*);
extern void __glXDisp_Rectsv(GLbyte*);
extern void __glXDisp_TexCoord1dv(GLbyte*);
extern void __glXDisp_TexCoord1fv(GLbyte*);
extern void __glXDisp_TexCoord1iv(GLbyte*);
extern void __glXDisp_TexCoord1sv(GLbyte*);
extern void __glXDisp_TexCoord2dv(GLbyte*);
extern void __glXDisp_TexCoord2fv(GLbyte*);
extern void __glXDisp_TexCoord2iv(GLbyte*);
extern void __glXDisp_TexCoord2sv(GLbyte*);
extern void __glXDisp_TexCoord3dv(GLbyte*);
extern void __glXDisp_TexCoord3fv(GLbyte*);
extern void __glXDisp_TexCoord3iv(GLbyte*);
extern void __glXDisp_TexCoord3sv(GLbyte*);
extern void __glXDisp_TexCoord4dv(GLbyte*);
extern void __glXDisp_TexCoord4fv(GLbyte*);
extern void __glXDisp_TexCoord4iv(GLbyte*);
extern void __glXDisp_TexCoord4sv(GLbyte*);
extern void __glXDisp_Vertex2dv(GLbyte*);
extern void __glXDisp_Vertex2fv(GLbyte*);
extern void __glXDisp_Vertex2iv(GLbyte*);
extern void __glXDisp_Vertex2sv(GLbyte*);
extern void __glXDisp_Vertex3dv(GLbyte*);
extern void __glXDisp_Vertex3fv(GLbyte*);
extern void __glXDisp_Vertex3iv(GLbyte*);
extern void __glXDisp_Vertex3sv(GLbyte*);
extern void __glXDisp_Vertex4dv(GLbyte*);
extern void __glXDisp_Vertex4fv(GLbyte*);
extern void __glXDisp_Vertex4iv(GLbyte*);
extern void __glXDisp_Vertex4sv(GLbyte*);
extern void __glXDisp_ClipPlane(GLbyte*);
extern void __glXDisp_ColorMaterial(GLbyte*);
extern void __glXDisp_CullFace(GLbyte*);
extern void __glXDisp_Fogf(GLbyte*);
extern void __glXDisp_Fogfv(GLbyte*);
extern void __glXDisp_Fogi(GLbyte*);
extern void __glXDisp_Fogiv(GLbyte*);
extern void __glXDisp_FrontFace(GLbyte*);
extern void __glXDisp_Hint(GLbyte*);
extern void __glXDisp_Lightf(GLbyte*);
extern void __glXDisp_Lightfv(GLbyte*);
extern void __glXDisp_Lighti(GLbyte*);
extern void __glXDisp_Lightiv(GLbyte*);
extern void __glXDisp_LightModelf(GLbyte*);
extern void __glXDisp_LightModelfv(GLbyte*);
extern void __glXDisp_LightModeli(GLbyte*);
extern void __glXDisp_LightModeliv(GLbyte*);
extern void __glXDisp_LineStipple(GLbyte*);
extern void __glXDisp_LineWidth(GLbyte*);
extern void __glXDisp_Materialf(GLbyte*);
extern void __glXDisp_Materialfv(GLbyte*);
extern void __glXDisp_Materiali(GLbyte*);
extern void __glXDisp_Materialiv(GLbyte*);
extern void __glXDisp_PointSize(GLbyte*);
extern void __glXDisp_PolygonMode(GLbyte*);
extern void __glXDisp_PolygonStipple(GLbyte*);
extern void __glXDisp_Scissor(GLbyte*);
extern void __glXDisp_ShadeModel(GLbyte*);
extern void __glXDisp_TexParameterf(GLbyte*);
extern void __glXDisp_TexParameterfv(GLbyte*);
extern void __glXDisp_TexParameteri(GLbyte*);
extern void __glXDisp_TexParameteriv(GLbyte*);
extern void __glXDisp_TexImage1D(GLbyte*);
extern void __glXDisp_TexImage2D(GLbyte*);
extern void __glXDisp_TexEnvf(GLbyte*);
extern void __glXDisp_TexEnvfv(GLbyte*);
extern void __glXDisp_TexEnvi(GLbyte*);
extern void __glXDisp_TexEnviv(GLbyte*);
extern void __glXDisp_TexGend(GLbyte*);
extern void __glXDisp_TexGendv(GLbyte*);
extern void __glXDisp_TexGenf(GLbyte*);
extern void __glXDisp_TexGenfv(GLbyte*);
extern void __glXDisp_TexGeni(GLbyte*);
extern void __glXDisp_TexGeniv(GLbyte*);
extern void __glXDisp_InitNames(GLbyte*);
extern void __glXDisp_LoadName(GLbyte*);
extern void __glXDisp_PassThrough(GLbyte*);
extern void __glXDisp_PopName(GLbyte*);
extern void __glXDisp_PushName(GLbyte*);
extern void __glXDisp_DrawBuffer(GLbyte*);
extern void __glXDisp_Clear(GLbyte*);
extern void __glXDisp_ClearAccum(GLbyte*);
extern void __glXDisp_ClearIndex(GLbyte*);
extern void __glXDisp_ClearColor(GLbyte*);
extern void __glXDisp_ClearStencil(GLbyte*);
extern void __glXDisp_ClearDepth(GLbyte*);
extern void __glXDisp_StencilMask(GLbyte*);
extern void __glXDisp_ColorMask(GLbyte*);
extern void __glXDisp_DepthMask(GLbyte*);
extern void __glXDisp_IndexMask(GLbyte*);
extern void __glXDisp_Accum(GLbyte*);
extern void __glXDisp_Disable(GLbyte*);
extern void __glXDisp_Enable(GLbyte*);
extern void __glXDisp_PopAttrib(GLbyte*);
extern void __glXDisp_PushAttrib(GLbyte*);
extern void __glXDisp_Map1d(GLbyte*);
extern void __glXDisp_Map1f(GLbyte*);
extern void __glXDisp_Map2d(GLbyte*);
extern void __glXDisp_Map2f(GLbyte*);
extern void __glXDisp_MapGrid1d(GLbyte*);
extern void __glXDisp_MapGrid1f(GLbyte*);
extern void __glXDisp_MapGrid2d(GLbyte*);
extern void __glXDisp_MapGrid2f(GLbyte*);
extern void __glXDisp_EvalCoord1dv(GLbyte*);
extern void __glXDisp_EvalCoord1fv(GLbyte*);
extern void __glXDisp_EvalCoord2dv(GLbyte*);
extern void __glXDisp_EvalCoord2fv(GLbyte*);
extern void __glXDisp_EvalMesh1(GLbyte*);
extern void __glXDisp_EvalPoint1(GLbyte*);
extern void __glXDisp_EvalMesh2(GLbyte*);
extern void __glXDisp_EvalPoint2(GLbyte*);
extern void __glXDisp_AlphaFunc(GLbyte*);
extern void __glXDisp_BlendFunc(GLbyte*);
extern void __glXDisp_LogicOp(GLbyte*);
extern void __glXDisp_StencilFunc(GLbyte*);
extern void __glXDisp_StencilOp(GLbyte*);
extern void __glXDisp_DepthFunc(GLbyte*);
extern void __glXDisp_PixelZoom(GLbyte*);
extern void __glXDisp_PixelTransferf(GLbyte*);
extern void __glXDisp_PixelTransferi(GLbyte*);
extern void __glXDisp_PixelMapfv(GLbyte*);
extern void __glXDisp_PixelMapuiv(GLbyte*);
extern void __glXDisp_PixelMapusv(GLbyte*);
extern void __glXDisp_ReadBuffer(GLbyte*);
extern void __glXDisp_CopyPixels(GLbyte*);
extern void __glXDisp_DrawPixels(GLbyte*);
extern void __glXDisp_DepthRange(GLbyte*);
extern void __glXDisp_Frustum(GLbyte*);
extern void __glXDisp_LoadIdentity(GLbyte*);
extern void __glXDisp_LoadMatrixf(GLbyte*);
extern void __glXDisp_LoadMatrixd(GLbyte*);
extern void __glXDisp_MatrixMode(GLbyte*);
extern void __glXDisp_MultMatrixf(GLbyte*);
extern void __glXDisp_MultMatrixd(GLbyte*);
extern void __glXDisp_Ortho(GLbyte*);
extern void __glXDisp_PopMatrix(GLbyte*);
extern void __glXDisp_PushMatrix(GLbyte*);
extern void __glXDisp_Rotated(GLbyte*);
extern void __glXDisp_Rotatef(GLbyte*);
extern void __glXDisp_Scaled(GLbyte*);
extern void __glXDisp_Scalef(GLbyte*);
extern void __glXDisp_Translated(GLbyte*);
extern void __glXDisp_Translatef(GLbyte*);
extern void __glXDisp_Viewport(GLbyte*);
extern void __glXDisp_PolygonOffset(GLbyte*);
extern void __glXDisp_DrawArrays(GLbyte*);
extern void __glXDisp_Indexubv(GLbyte*);
extern void __glXDisp_ColorSubTable(GLbyte*);
extern void __glXDisp_CopyColorSubTable(GLbyte*);
extern void __glXDisp_ActiveTextureARB(GLbyte*);
extern void __glXDisp_MultiTexCoord1dvARB(GLbyte*);
extern void __glXDisp_MultiTexCoord1fvARB(GLbyte*);
extern void __glXDisp_MultiTexCoord1ivARB(GLbyte*);
extern void __glXDisp_MultiTexCoord1svARB(GLbyte*);
extern void __glXDisp_MultiTexCoord2dvARB(GLbyte*);
extern void __glXDisp_MultiTexCoord2fvARB(GLbyte*);
extern void __glXDisp_MultiTexCoord2ivARB(GLbyte*);
extern void __glXDisp_MultiTexCoord2svARB(GLbyte*);
extern void __glXDisp_MultiTexCoord3dvARB(GLbyte*);
extern void __glXDisp_MultiTexCoord3fvARB(GLbyte*);
extern void __glXDisp_MultiTexCoord3ivARB(GLbyte*);
extern void __glXDisp_MultiTexCoord3svARB(GLbyte*);
extern void __glXDisp_MultiTexCoord4dvARB(GLbyte*);
extern void __glXDisp_MultiTexCoord4fvARB(GLbyte*);
extern void __glXDisp_MultiTexCoord4ivARB(GLbyte*);
extern void __glXDisp_MultiTexCoord4svARB(GLbyte*);
extern void __glXDisp_SampleCoverageARB(GLbyte *);
extern void __glXDisp_WindowPos3fARB(GLbyte *);
extern int __glXSwapRender(__GLXclientState*, GLbyte*);
extern int __glXSwapRenderLarge(__GLXclientState*, GLbyte*);
extern int __glXSwapCreateContext(__GLXclientState*, GLbyte*);
@ -360,281 +85,6 @@ extern int __glXSwapGetFBConfigs(__GLXclientState*, GLbyte*);
extern int __glXSwapCreateNewContext(__GLXclientState*, GLbyte*);
extern int __glXSwapCreatePixmap(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_NewList(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_EndList(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_DeleteLists(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GenLists(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_FeedbackBuffer(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_SelectBuffer(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_RenderMode(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_Finish(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_PixelStoref(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_PixelStorei(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_ReadPixels(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetBooleanv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetClipPlane(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetDoublev(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetError(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetFloatv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetIntegerv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetLightfv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetLightiv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetMapdv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetMapfv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetMapiv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetMaterialfv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetMaterialiv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetPixelMapfv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetPixelMapuiv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetPixelMapusv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetPolygonStipple(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetString(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetTexEnvfv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetTexEnviv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetTexGendv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetTexGenfv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetTexGeniv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetTexImage(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetTexParameterfv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetTexParameteriv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetTexLevelParameterfv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetTexLevelParameteriv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_IsEnabled(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_IsList(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_Flush(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_AreTexturesResident(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_DeleteTextures(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GenTextures(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_IsTexture(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetColorTable(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetColorTableParameterfv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetColorTableParameteriv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetConvolutionFilter(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetConvolutionParameterfv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetConvolutionParameteriv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetSeparableFilter(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetHistogram(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetHistogramParameterfv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetHistogramParameteriv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetMinmax(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetMinmaxParameterfv(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GetMinmaxParameteriv(__GLXclientState*, GLbyte*);
extern void __glXDispSwap_CallList(GLbyte*);
extern void __glXDispSwap_CallLists(GLbyte*);
extern void __glXDispSwap_ListBase(GLbyte*);
extern void __glXDispSwap_Begin(GLbyte*);
extern void __glXDispSwap_Bitmap(GLbyte*);
extern void __glXDispSwap_Color3bv(GLbyte*);
extern void __glXDispSwap_Color3dv(GLbyte*);
extern void __glXDispSwap_Color3fv(GLbyte*);
extern void __glXDispSwap_Color3iv(GLbyte*);
extern void __glXDispSwap_Color3sv(GLbyte*);
extern void __glXDispSwap_Color3ubv(GLbyte*);
extern void __glXDispSwap_Color3uiv(GLbyte*);
extern void __glXDispSwap_Color3usv(GLbyte*);
extern void __glXDispSwap_Color4bv(GLbyte*);
extern void __glXDispSwap_Color4dv(GLbyte*);
extern void __glXDispSwap_Color4fv(GLbyte*);
extern void __glXDispSwap_Color4iv(GLbyte*);
extern void __glXDispSwap_Color4sv(GLbyte*);
extern void __glXDispSwap_Color4ubv(GLbyte*);
extern void __glXDispSwap_Color4uiv(GLbyte*);
extern void __glXDispSwap_Color4usv(GLbyte*);
extern void __glXDispSwap_EdgeFlagv(GLbyte*);
extern void __glXDispSwap_End(GLbyte*);
extern void __glXDispSwap_Indexdv(GLbyte*);
extern void __glXDispSwap_Indexfv(GLbyte*);
extern void __glXDispSwap_Indexiv(GLbyte*);
extern void __glXDispSwap_Indexsv(GLbyte*);
extern void __glXDispSwap_Normal3bv(GLbyte*);
extern void __glXDispSwap_Normal3dv(GLbyte*);
extern void __glXDispSwap_Normal3fv(GLbyte*);
extern void __glXDispSwap_Normal3iv(GLbyte*);
extern void __glXDispSwap_Normal3sv(GLbyte*);
extern void __glXDispSwap_RasterPos2dv(GLbyte*);
extern void __glXDispSwap_RasterPos2fv(GLbyte*);
extern void __glXDispSwap_RasterPos2iv(GLbyte*);
extern void __glXDispSwap_RasterPos2sv(GLbyte*);
extern void __glXDispSwap_RasterPos3dv(GLbyte*);
extern void __glXDispSwap_RasterPos3fv(GLbyte*);
extern void __glXDispSwap_RasterPos3iv(GLbyte*);
extern void __glXDispSwap_RasterPos3sv(GLbyte*);
extern void __glXDispSwap_RasterPos4dv(GLbyte*);
extern void __glXDispSwap_RasterPos4fv(GLbyte*);
extern void __glXDispSwap_RasterPos4iv(GLbyte*);
extern void __glXDispSwap_RasterPos4sv(GLbyte*);
extern void __glXDispSwap_Rectdv(GLbyte*);
extern void __glXDispSwap_Rectfv(GLbyte*);
extern void __glXDispSwap_Rectiv(GLbyte*);
extern void __glXDispSwap_Rectsv(GLbyte*);
extern void __glXDispSwap_TexCoord1dv(GLbyte*);
extern void __glXDispSwap_TexCoord1fv(GLbyte*);
extern void __glXDispSwap_TexCoord1iv(GLbyte*);
extern void __glXDispSwap_TexCoord1sv(GLbyte*);
extern void __glXDispSwap_TexCoord2dv(GLbyte*);
extern void __glXDispSwap_TexCoord2fv(GLbyte*);
extern void __glXDispSwap_TexCoord2iv(GLbyte*);
extern void __glXDispSwap_TexCoord2sv(GLbyte*);
extern void __glXDispSwap_TexCoord3dv(GLbyte*);
extern void __glXDispSwap_TexCoord3fv(GLbyte*);
extern void __glXDispSwap_TexCoord3iv(GLbyte*);
extern void __glXDispSwap_TexCoord3sv(GLbyte*);
extern void __glXDispSwap_TexCoord4dv(GLbyte*);
extern void __glXDispSwap_TexCoord4fv(GLbyte*);
extern void __glXDispSwap_TexCoord4iv(GLbyte*);
extern void __glXDispSwap_TexCoord4sv(GLbyte*);
extern void __glXDispSwap_Vertex2dv(GLbyte*);
extern void __glXDispSwap_Vertex2fv(GLbyte*);
extern void __glXDispSwap_Vertex2iv(GLbyte*);
extern void __glXDispSwap_Vertex2sv(GLbyte*);
extern void __glXDispSwap_Vertex3dv(GLbyte*);
extern void __glXDispSwap_Vertex3fv(GLbyte*);
extern void __glXDispSwap_Vertex3iv(GLbyte*);
extern void __glXDispSwap_Vertex3sv(GLbyte*);
extern void __glXDispSwap_Vertex4dv(GLbyte*);
extern void __glXDispSwap_Vertex4fv(GLbyte*);
extern void __glXDispSwap_Vertex4iv(GLbyte*);
extern void __glXDispSwap_Vertex4sv(GLbyte*);
extern void __glXDispSwap_ClipPlane(GLbyte*);
extern void __glXDispSwap_ColorMaterial(GLbyte*);
extern void __glXDispSwap_CullFace(GLbyte*);
extern void __glXDispSwap_Fogf(GLbyte*);
extern void __glXDispSwap_Fogfv(GLbyte*);
extern void __glXDispSwap_Fogi(GLbyte*);
extern void __glXDispSwap_Fogiv(GLbyte*);
extern void __glXDispSwap_FrontFace(GLbyte*);
extern void __glXDispSwap_Hint(GLbyte*);
extern void __glXDispSwap_Lightf(GLbyte*);
extern void __glXDispSwap_Lightfv(GLbyte*);
extern void __glXDispSwap_Lighti(GLbyte*);
extern void __glXDispSwap_Lightiv(GLbyte*);
extern void __glXDispSwap_LightModelf(GLbyte*);
extern void __glXDispSwap_LightModelfv(GLbyte*);
extern void __glXDispSwap_LightModeli(GLbyte*);
extern void __glXDispSwap_LightModeliv(GLbyte*);
extern void __glXDispSwap_LineStipple(GLbyte*);
extern void __glXDispSwap_LineWidth(GLbyte*);
extern void __glXDispSwap_Materialf(GLbyte*);
extern void __glXDispSwap_Materialfv(GLbyte*);
extern void __glXDispSwap_Materiali(GLbyte*);
extern void __glXDispSwap_Materialiv(GLbyte*);
extern void __glXDispSwap_PointSize(GLbyte*);
extern void __glXDispSwap_PolygonMode(GLbyte*);
extern void __glXDispSwap_PolygonStipple(GLbyte*);
extern void __glXDispSwap_Scissor(GLbyte*);
extern void __glXDispSwap_ShadeModel(GLbyte*);
extern void __glXDispSwap_TexParameterf(GLbyte*);
extern void __glXDispSwap_TexParameterfv(GLbyte*);
extern void __glXDispSwap_TexParameteri(GLbyte*);
extern void __glXDispSwap_TexParameteriv(GLbyte*);
extern void __glXDispSwap_TexImage1D(GLbyte*);
extern void __glXDispSwap_TexImage2D(GLbyte*);
extern void __glXDispSwap_TexEnvf(GLbyte*);
extern void __glXDispSwap_TexEnvfv(GLbyte*);
extern void __glXDispSwap_TexEnvi(GLbyte*);
extern void __glXDispSwap_TexEnviv(GLbyte*);
extern void __glXDispSwap_TexGend(GLbyte*);
extern void __glXDispSwap_TexGendv(GLbyte*);
extern void __glXDispSwap_TexGenf(GLbyte*);
extern void __glXDispSwap_TexGenfv(GLbyte*);
extern void __glXDispSwap_TexGeni(GLbyte*);
extern void __glXDispSwap_TexGeniv(GLbyte*);
extern void __glXDispSwap_InitNames(GLbyte*);
extern void __glXDispSwap_LoadName(GLbyte*);
extern void __glXDispSwap_PassThrough(GLbyte*);
extern void __glXDispSwap_PopName(GLbyte*);
extern void __glXDispSwap_PushName(GLbyte*);
extern void __glXDispSwap_DrawBuffer(GLbyte*);
extern void __glXDispSwap_Clear(GLbyte*);
extern void __glXDispSwap_ClearAccum(GLbyte*);
extern void __glXDispSwap_ClearIndex(GLbyte*);
extern void __glXDispSwap_ClearColor(GLbyte*);
extern void __glXDispSwap_ClearStencil(GLbyte*);
extern void __glXDispSwap_ClearDepth(GLbyte*);
extern void __glXDispSwap_StencilMask(GLbyte*);
extern void __glXDispSwap_ColorMask(GLbyte*);
extern void __glXDispSwap_DepthMask(GLbyte*);
extern void __glXDispSwap_IndexMask(GLbyte*);
extern void __glXDispSwap_Accum(GLbyte*);
extern void __glXDispSwap_Disable(GLbyte*);
extern void __glXDispSwap_Enable(GLbyte*);
extern void __glXDispSwap_PopAttrib(GLbyte*);
extern void __glXDispSwap_PushAttrib(GLbyte*);
extern void __glXDispSwap_Map1d(GLbyte*);
extern void __glXDispSwap_Map1f(GLbyte*);
extern void __glXDispSwap_Map2d(GLbyte*);
extern void __glXDispSwap_Map2f(GLbyte*);
extern void __glXDispSwap_MapGrid1d(GLbyte*);
extern void __glXDispSwap_MapGrid1f(GLbyte*);
extern void __glXDispSwap_MapGrid2d(GLbyte*);
extern void __glXDispSwap_MapGrid2f(GLbyte*);
extern void __glXDispSwap_EvalCoord1dv(GLbyte*);
extern void __glXDispSwap_EvalCoord1fv(GLbyte*);
extern void __glXDispSwap_EvalCoord2dv(GLbyte*);
extern void __glXDispSwap_EvalCoord2fv(GLbyte*);
extern void __glXDispSwap_EvalMesh1(GLbyte*);
extern void __glXDispSwap_EvalPoint1(GLbyte*);
extern void __glXDispSwap_EvalMesh2(GLbyte*);
extern void __glXDispSwap_EvalPoint2(GLbyte*);
extern void __glXDispSwap_AlphaFunc(GLbyte*);
extern void __glXDispSwap_BlendFunc(GLbyte*);
extern void __glXDispSwap_LogicOp(GLbyte*);
extern void __glXDispSwap_StencilFunc(GLbyte*);
extern void __glXDispSwap_StencilOp(GLbyte*);
extern void __glXDispSwap_DepthFunc(GLbyte*);
extern void __glXDispSwap_PixelZoom(GLbyte*);
extern void __glXDispSwap_PixelTransferf(GLbyte*);
extern void __glXDispSwap_PixelTransferi(GLbyte*);
extern void __glXDispSwap_PixelMapfv(GLbyte*);
extern void __glXDispSwap_PixelMapuiv(GLbyte*);
extern void __glXDispSwap_PixelMapusv(GLbyte*);
extern void __glXDispSwap_ReadBuffer(GLbyte*);
extern void __glXDispSwap_CopyPixels(GLbyte*);
extern void __glXDispSwap_DrawPixels(GLbyte*);
extern void __glXDispSwap_DepthRange(GLbyte*);
extern void __glXDispSwap_Frustum(GLbyte*);
extern void __glXDispSwap_LoadIdentity(GLbyte*);
extern void __glXDispSwap_LoadMatrixf(GLbyte*);
extern void __glXDispSwap_LoadMatrixd(GLbyte*);
extern void __glXDispSwap_MatrixMode(GLbyte*);
extern void __glXDispSwap_MultMatrixf(GLbyte*);
extern void __glXDispSwap_MultMatrixd(GLbyte*);
extern void __glXDispSwap_Ortho(GLbyte*);
extern void __glXDispSwap_PopMatrix(GLbyte*);
extern void __glXDispSwap_PushMatrix(GLbyte*);
extern void __glXDispSwap_Rotated(GLbyte*);
extern void __glXDispSwap_Rotatef(GLbyte*);
extern void __glXDispSwap_Scaled(GLbyte*);
extern void __glXDispSwap_Scalef(GLbyte*);
extern void __glXDispSwap_Translated(GLbyte*);
extern void __glXDispSwap_Translatef(GLbyte*);
extern void __glXDispSwap_Viewport(GLbyte*);
extern void __glXDispSwap_PolygonOffset(GLbyte*);
extern void __glXDispSwap_DrawArrays(GLbyte*);
extern void __glXDispSwap_Indexubv(GLbyte*);
extern void __glXDispSwap_ColorSubTable(GLbyte*);
extern void __glXDispSwap_CopyColorSubTable(GLbyte*);
extern void __glXDispSwap_ActiveTextureARB(GLbyte*);
extern void __glXDispSwap_MultiTexCoord1dvARB(GLbyte*);
extern void __glXDispSwap_MultiTexCoord1fvARB(GLbyte*);
extern void __glXDispSwap_MultiTexCoord1ivARB(GLbyte*);
extern void __glXDispSwap_MultiTexCoord1svARB(GLbyte*);
extern void __glXDispSwap_MultiTexCoord2dvARB(GLbyte*);
extern void __glXDispSwap_MultiTexCoord2fvARB(GLbyte*);
extern void __glXDispSwap_MultiTexCoord2ivARB(GLbyte*);
extern void __glXDispSwap_MultiTexCoord2svARB(GLbyte*);
extern void __glXDispSwap_MultiTexCoord3dvARB(GLbyte*);
extern void __glXDispSwap_MultiTexCoord3fvARB(GLbyte*);
extern void __glXDispSwap_MultiTexCoord3ivARB(GLbyte*);
extern void __glXDispSwap_MultiTexCoord3svARB(GLbyte*);
extern void __glXDispSwap_MultiTexCoord4dvARB(GLbyte*);
extern void __glXDispSwap_MultiTexCoord4fvARB(GLbyte*);
extern void __glXDispSwap_MultiTexCoord4ivARB(GLbyte*);
extern void __glXDispSwap_MultiTexCoord4svARB(GLbyte*);
extern void __glXDispSwap_SampleCoverageARB(GLbyte *);
extern void __glXDispSwap_WindowPos3fARB(GLbyte *);
#define __GLX_MIN_GLXCMD_OPCODE 1
#define __GLX_MAX_GLXCMD_OPCODE 20
#define __GLX_MIN_RENDER_OPCODE 1

62
GL/glx/g_disptab_EXT.c
View File

@ -36,6 +36,8 @@
#include "glxserver.h"
#include "glxext.h"
#include "g_disptab_EXT.h"
#include "indirect_dispatch.h"
__GLXdispatchRenderProcPtr __glXRenderTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT - __GLX_MIN_RENDER_OPCODE_EXT + 1] = {
__glXDisp_ColorTable, /* 2053 */
__glXDisp_ColorTableParameterfv, /* 2054 */
@ -50,8 +52,8 @@ __GLXdispatchRenderProcPtr __glXRenderTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT - __
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
#ifndef MISSING_GL_EXTS
__glXDisp_PointParameterfARB, /* 2065 */
__glXDisp_PointParameterfvARB, /* 2066 */
__glXDisp_PointParameterfEXT, /* 2065 */
__glXDisp_PointParameterfvEXT, /* 2066 */
#else
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
@ -2105,7 +2107,7 @@ __GLXdispatchRenderProcPtr __glXRenderTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT - __
__glXDisp_ResetMinmax,
__glXDisp_TexImage3D,
__glXDisp_TexSubImage3D,
__glXDisp_DrawArraysEXT,
__glXDisp_DrawArrays,
__glXDisp_BindTexture,
__glXDisp_PrioritizeTextures,
__glXDisp_CopyTexImage1D,
@ -2114,17 +2116,17 @@ __GLXdispatchRenderProcPtr __glXRenderTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT - __
__glXDisp_CopyTexSubImage2D, /* 4122 */
__glXDisp_CopyTexSubImage3D, /* 4123 */
#ifndef MISSING_GL_EXTS
__glXDisp_FogCoordfv, /* 4124 */
__glXDisp_FogCoorddv, /* 4125 */
__glXDisp_SecondaryColor3bv, /* 4126 */
__glXDisp_SecondaryColor3sv, /* 4127 */
__glXDisp_SecondaryColor3iv, /* 4128 */
__glXDisp_SecondaryColor3fv, /* 4129 */
__glXDisp_SecondaryColor3dv, /* 4130 */
__glXDisp_SecondaryColor3ubv, /* 4131 */
__glXDisp_SecondaryColor3usv, /* 4132 */
__glXDisp_SecondaryColor3uiv, /* 4133 */
__glXDisp_BlendFuncSeparate, /* 4134 */
__glXDisp_FogCoordfvEXT, /* 4124 */
__glXDisp_FogCoorddvEXT, /* 4125 */
__glXDisp_SecondaryColor3bvEXT, /* 4126 */
__glXDisp_SecondaryColor3svEXT, /* 4127 */
__glXDisp_SecondaryColor3ivEXT, /* 4128 */
__glXDisp_SecondaryColor3fvEXT, /* 4129 */
__glXDisp_SecondaryColor3dvEXT, /* 4130 */
__glXDisp_SecondaryColor3ubvEXT, /* 4131 */
__glXDisp_SecondaryColor3usvEXT, /* 4132 */
__glXDisp_SecondaryColor3uivEXT, /* 4133 */
__glXDisp_BlendFuncSeparateEXT, /* 4134 */
#else
__glXNoSuchRenderOpcode, /* 4124 */
__glXNoSuchRenderOpcode, /* 4125 */
@ -2235,7 +2237,7 @@ __GLXdispatchRenderProcPtr __glXRenderTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT - __
};
__GLXdispatchVendorPrivProcPtr __glXVendorPrivTable_EXT[__GLX_MAX_VENDPRIV_OPCODE_EXT - __GLX_MIN_VENDPRIV_OPCODE_EXT + 1] = {
__glXDisp_AreTexturesResidentEXT, /* 11 */
__glXDisp_DeleteTexturesEXT, /* 12 */
__glXDisp_DeleteTextures, /* 12 */
__glXDisp_GenTexturesEXT, /* 13 */
__glXDisp_IsTextureEXT, /* 14 */
};
@ -2255,8 +2257,8 @@ __GLXdispatchRenderProcPtr __glXSwapRenderTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
#ifndef MISSING_GL_EXTS
__glXDispSwap_PointParameterfARB, /* 2065 */
__glXDispSwap_PointParameterfvARB, /* 2066 */
__glXDispSwap_PointParameterfEXT, /* 2065 */
__glXDispSwap_PointParameterfvEXT, /* 2066 */
#else
__glXNoSuchRenderOpcode,
__glXNoSuchRenderOpcode,
@ -4310,7 +4312,7 @@ __GLXdispatchRenderProcPtr __glXSwapRenderTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT
__glXDispSwap_ResetMinmax,
__glXDispSwap_TexImage3D,
__glXDispSwap_TexSubImage3D,
__glXDispSwap_DrawArraysEXT,
__glXDispSwap_DrawArrays,
__glXDispSwap_BindTexture,
__glXDispSwap_PrioritizeTextures,
__glXDispSwap_CopyTexImage1D,
@ -4319,17 +4321,17 @@ __GLXdispatchRenderProcPtr __glXSwapRenderTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT
__glXDispSwap_CopyTexSubImage2D, /* 4122 */
__glXDispSwap_CopyTexSubImage3D, /* 4123 */
#ifndef MISSING_GL_EXTS
__glXDispSwap_FogCoordfv, /* 4124 */
__glXDispSwap_FogCoorddv, /* 4125 */
__glXDispSwap_SecondaryColor3bv, /* 4126 */
__glXDispSwap_SecondaryColor3sv, /* 4127 */
__glXDispSwap_SecondaryColor3iv, /* 4128 */
__glXDispSwap_SecondaryColor3fv, /* 4129 */
__glXDispSwap_SecondaryColor3dv, /* 4130 */
__glXDispSwap_SecondaryColor3ubv, /* 4131 */
__glXDispSwap_SecondaryColor3usv, /* 4132 */
__glXDispSwap_SecondaryColor3uiv, /* 4133 */
__glXDisp_BlendFuncSeparate, /* 4134 */
__glXDispSwap_FogCoordfvEXT, /* 4124 */
__glXDispSwap_FogCoorddvEXT, /* 4125 */
__glXDispSwap_SecondaryColor3bvEXT, /* 4126 */
__glXDispSwap_SecondaryColor3svEXT, /* 4127 */
__glXDispSwap_SecondaryColor3ivEXT, /* 4128 */
__glXDispSwap_SecondaryColor3fvEXT, /* 4129 */
__glXDispSwap_SecondaryColor3dvEXT, /* 4130 */
__glXDispSwap_SecondaryColor3ubvEXT, /* 4131 */
__glXDispSwap_SecondaryColor3usvEXT, /* 4132 */
__glXDispSwap_SecondaryColor3uivEXT, /* 4133 */
__glXDisp_BlendFuncSeparateEXT, /* 4134 */
#else
__glXNoSuchRenderOpcode, /* 4124 */
__glXNoSuchRenderOpcode, /* 4125 */
@ -4440,7 +4442,7 @@ __GLXdispatchRenderProcPtr __glXSwapRenderTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT
};
__GLXdispatchVendorPrivProcPtr __glXSwapVendorPrivTable_EXT[__GLX_MAX_VENDPRIV_OPCODE_EXT - __GLX_MIN_VENDPRIV_OPCODE_EXT + 1] = {
__glXDispSwap_AreTexturesResidentEXT, /* 11 */
__glXDispSwap_DeleteTexturesEXT, /* 12 */
__glXDispSwap_DeleteTextures, /* 12 */
__glXDispSwap_GenTexturesEXT, /* 13 */
__glXDispSwap_IsTextureEXT, /* 14 */
};

111
GL/glx/g_disptab_EXT.h
View File

@ -35,117 +35,6 @@
** version 1.2.1 Specification.
*/
extern int __glXDisp_AreTexturesResidentEXT(__GLXclientState*, GLbyte*);
extern int __glXDisp_DeleteTexturesEXT(__GLXclientState*, GLbyte*);
extern int __glXDisp_GenTexturesEXT(__GLXclientState*, GLbyte*);
extern int __glXDisp_IsTextureEXT(__GLXclientState*, GLbyte*);
extern void __glXDisp_ColorTable(GLbyte*);
extern void __glXDisp_ColorTableParameterfv(GLbyte*);
extern void __glXDisp_ColorTableParameteriv(GLbyte*);
extern void __glXDisp_CopyColorTable(GLbyte*);
extern void __glXDisp_BlendColor(GLbyte*);
extern void __glXDisp_BlendEquation(GLbyte*);
extern void __glXDisp_TexSubImage1D(GLbyte*);
extern void __glXDisp_TexSubImage2D(GLbyte*);
extern void __glXDisp_ConvolutionFilter1D(GLbyte*);
extern void __glXDisp_ConvolutionFilter2D(GLbyte*);
extern void __glXDisp_ConvolutionParameterf(GLbyte*);
extern void __glXDisp_ConvolutionParameterfv(GLbyte*);
extern void __glXDisp_ConvolutionParameteri(GLbyte*);
extern void __glXDisp_ConvolutionParameteriv(GLbyte*);
extern void __glXDisp_CopyConvolutionFilter1D(GLbyte*);
extern void __glXDisp_CopyConvolutionFilter2D(GLbyte*);
extern void __glXDisp_SeparableFilter2D(GLbyte*);
extern void __glXDisp_Histogram(GLbyte*);
extern void __glXDisp_Minmax(GLbyte*);
extern void __glXDisp_ResetHistogram(GLbyte*);
extern void __glXDisp_ResetMinmax(GLbyte*);
extern void __glXDisp_TexImage3D(GLbyte*);
extern void __glXDisp_TexSubImage3D(GLbyte*);
extern void __glXDisp_DrawArraysEXT(GLbyte*);
extern void __glXDisp_BindTexture(GLbyte*);
extern void __glXDisp_PrioritizeTextures(GLbyte*);
extern void __glXDisp_CopyTexImage1D(GLbyte*);
extern void __glXDisp_CopyTexImage2D(GLbyte*);
extern void __glXDisp_CopyTexSubImage1D(GLbyte*);
extern void __glXDisp_CopyTexSubImage2D(GLbyte*);
extern void __glXDisp_CopyTexSubImage3D(GLbyte*);
extern void __glXDisp_PointParameterfARB(GLbyte*);
extern void __glXDisp_PointParameterfvARB(GLbyte*);
extern void __glXDisp_FogCoordfv(GLbyte *);
extern void __glXDisp_FogCoorddv(GLbyte *);
extern void __glXDispSwap_FogCoordfv(GLbyte *);
extern void __glXDispSwap_FogCoorddv(GLbyte *);
extern void __glXDisp_SecondaryColor3bv(GLbyte *);
extern void __glXDisp_SecondaryColor3sv(GLbyte *);
extern void __glXDisp_SecondaryColor3iv(GLbyte *);
extern void __glXDisp_SecondaryColor3ubv(GLbyte *);
extern void __glXDisp_SecondaryColor3usv(GLbyte *);
extern void __glXDisp_SecondaryColor3uiv(GLbyte *);
extern void __glXDisp_SecondaryColor3fv(GLbyte *);
extern void __glXDisp_SecondaryColor3dv(GLbyte *);
extern void __glXDispSwap_SecondaryColor3bv(GLbyte *);
extern void __glXDispSwap_SecondaryColor3sv(GLbyte *);
extern void __glXDispSwap_SecondaryColor3iv(GLbyte *);
extern void __glXDispSwap_SecondaryColor3ubv(GLbyte *);
extern void __glXDispSwap_SecondaryColor3usv(GLbyte *);
extern void __glXDispSwap_SecondaryColor3uiv(GLbyte *);
extern void __glXDispSwap_SecondaryColor3fv(GLbyte *);
extern void __glXDispSwap_SecondaryColor3dv(GLbyte *);
extern void __glXDisp_BlendFuncSeparate(GLbyte *);
extern void __glXDispSwap_BlendFuncSeparate(GLbyte *);
extern void __glXDisp_PointParameteriNV(GLbyte *);
extern void __glXDisp_PointParameterivNV(GLbyte *);
extern void __glXDispSwap_PointParameteriNV(GLbyte *);
extern void __glXDispSwap_PointParameterivNV(GLbyte *);
extern void __glXDisp_ActiveStencilFaceEXT(GLbyte*);
extern int __glXDispSwap_AreTexturesResidentEXT(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_DeleteTexturesEXT(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_GenTexturesEXT(__GLXclientState*, GLbyte*);
extern int __glXDispSwap_IsTextureEXT(__GLXclientState*, GLbyte*);
extern void __glXDispSwap_ColorTable(GLbyte*);
extern void __glXDispSwap_ColorTableParameterfv(GLbyte*);
extern void __glXDispSwap_ColorTableParameteriv(GLbyte*);
extern void __glXDispSwap_CopyColorTable(GLbyte*);
extern void __glXDispSwap_BlendColor(GLbyte*);
extern void __glXDispSwap_BlendEquation(GLbyte*);
extern void __glXDispSwap_TexSubImage1D(GLbyte*);
extern void __glXDispSwap_TexSubImage2D(GLbyte*);
extern void __glXDispSwap_ConvolutionFilter1D(GLbyte*);
extern void __glXDispSwap_ConvolutionFilter2D(GLbyte*);
extern void __glXDispSwap_ConvolutionParameterf(GLbyte*);
extern void __glXDispSwap_ConvolutionParameterfv(GLbyte*);
extern void __glXDispSwap_ConvolutionParameteri(GLbyte*);
extern void __glXDispSwap_ConvolutionParameteriv(GLbyte*);
extern void __glXDispSwap_CopyConvolutionFilter1D(GLbyte*);
extern void __glXDispSwap_CopyConvolutionFilter2D(GLbyte*);
extern void __glXDispSwap_SeparableFilter2D(GLbyte*);
extern void __glXDispSwap_Histogram(GLbyte*);
extern void __glXDispSwap_Minmax(GLbyte*);
extern void __glXDispSwap_ResetHistogram(GLbyte*);
extern void __glXDispSwap_ResetMinmax(GLbyte*);
extern void __glXDispSwap_TexImage3D(GLbyte*);
extern void __glXDispSwap_TexSubImage3D(GLbyte*);
extern void __glXDispSwap_DrawArraysEXT(GLbyte*);
extern void __glXDispSwap_BindTexture(GLbyte*);
extern void __glXDispSwap_PrioritizeTextures(GLbyte*);
extern void __glXDispSwap_CopyTexImage1D(GLbyte*);
extern void __glXDispSwap_CopyTexImage2D(GLbyte*);
extern void __glXDispSwap_CopyTexSubImage1D(GLbyte*);
extern void __glXDispSwap_CopyTexSubImage2D(GLbyte*);
extern void __glXDispSwap_CopyTexSubImage3D(GLbyte*);
extern void __glXDispSwap_PointParameterfARB(GLbyte*);
extern void __glXDispSwap_PointParameterfvARB(GLbyte*);
extern void __glXDispSwap_ActiveStencilFaceEXT(GLbyte*);
#define __GLX_MIN_RENDER_OPCODE_EXT 2053
#define __GLX_MAX_RENDER_OPCODE_EXT 4222
#define __GLX_MIN_VENDPRIV_OPCODE_EXT 11

2282
GL/glx/g_render.c
View File

File diff suppressed because it is too large Load Diff

3387
GL/glx/g_renderswap.c
View File

File diff suppressed because it is too large Load Diff

1787
GL/glx/g_single.c
View File

File diff suppressed because it is too large Load Diff

2208
GL/glx/g_singleswap.c
View File

File diff suppressed because it is too large Load Diff

18
GL/glx/glxcmds.c
View File

@ -52,6 +52,10 @@
#include "glxext.h"
#include "GL/glx_ansic.h"
#include "glcontextmodes.h"
#include "glapitable.h"
#include "glapi.h"
#include "glthread.h"
#include "dispatch.h"
/************************************************************************/
@ -624,7 +628,7 @@ int DoMakeCurrent( __GLXclientState *cl,
*/
if (__GLX_HAS_UNFLUSHED_CMDS(prevglxc)) {
if (__glXForceCurrent(cl, tag, (int *)&error)) {
glFlush();
CALL_Flush( GET_DISPATCH(), () );
__GLX_NOTE_FLUSHED_CMDS(prevglxc);
} else {
return error;
@ -810,7 +814,7 @@ int __glXWaitGL(__GLXclientState *cl, GLbyte *pc)
if (!__glXForceCurrent(cl, req->contextTag, &error)) {
return error;
}
glFinish();
CALL_Finish( GET_DISPATCH(), () );
return Success;
}
@ -896,7 +900,7 @@ int __glXCopyContext(__GLXclientState *cl, GLbyte *pc)
** Do whatever is needed to make sure that all preceding requests
** in both streams are completed before the copy is executed.
*/
glFinish();
CALL_Finish( GET_DISPATCH(), () );
__GLX_NOTE_FLUSHED_CMDS(tagcx);
} else {
return error;
@ -1325,7 +1329,7 @@ int __glXSwapBuffers(__GLXclientState *cl, GLbyte *pc)
** Do whatever is needed to make sure that all preceding requests
** in both streams are completed before the swap is executed.
*/
glFinish();
CALL_Finish( GET_DISPATCH(), () );
__GLX_NOTE_FLUSHED_CMDS(glxc);
} else {
return error;
@ -1971,11 +1975,11 @@ int __glXVendorPrivate(__GLXclientState *cl, GLbyte *pc)
#ifndef __DARWIN__
switch( vendorcode ) {
case X_GLvop_SampleMaskSGIS:
glSampleMaskSGIS(*(GLfloat *)(pc + 4),
*(GLboolean *)(pc + 8));
CALL_SampleMaskSGIS( GET_DISPATCH(),
(*(GLfloat *)(pc + 4), *(GLboolean *)(pc + 8)) );
return Success;
case X_GLvop_SamplePatternSGIS:
glSamplePatternSGIS( *(GLenum *)(pc + 4));
CALL_SamplePatternSGIS( GET_DISPATCH(), (*(GLenum *)(pc + 4)) );
return Success;
case X_GLXvop_BindSwapBarrierSGIX:
return __glXBindSwapBarrierSGIX(cl, pc);

10
GL/glx/glxcmdsswap.c
View File

@ -50,6 +50,10 @@
#include <windowstr.h>
#include "glxext.h"
#include "GL/glx_ansic.h"
#include "glapitable.h"
#include "glapi.h"
#include "glthread.h"
#include "dispatch.h"
static int __glXSwapGetFBConfigsSGIX(__GLXclientState *cl, GLbyte *pc);
static int __glXSwapCreateContextWithConfigSGIX(__GLXclientState *cl, GLbyte *pc);
@ -813,12 +817,12 @@ int __glXSwapVendorPrivate(__GLXclientState *cl, GLbyte *pc)
case X_GLvop_SampleMaskSGIS:
__GLX_SWAP_FLOAT(pc + 4);
__GLX_SWAP_INT(pc + 8);
glSampleMaskSGIS(*(GLfloat *)(pc + 4),
*(GLboolean *)(pc + 8));
CALL_SampleMaskSGIS( GET_DISPATCH(),
(*(GLfloat *)(pc + 4), *(GLboolean *)(pc + 8)) );
return Success;
case X_GLvop_SamplePatternSGIS:
__GLX_SWAP_INT(pc + 4);
glSamplePatternSGIS( *(GLenum *)(pc + 4));
CALL_SamplePatternSGIS( GET_DISPATCH(), (*(GLenum *)(pc + 4)) );
return Success;
}
#endif

56
GL/glx/glxserver.h
View File

@ -178,7 +178,7 @@ extern __GLXprocPtr __glXProcTable[];
*/
typedef struct {
int bytes;
int (*varsize)(GLbyte *pc, Bool swap);
int (*varsize)(const GLbyte *pc, Bool swap);
} __GLXrenderSizeData;
extern __GLXrenderSizeData __glXRenderSizeTable[];
extern __GLXrenderSizeData __glXRenderSizeTable_EXT[];
@ -230,58 +230,6 @@ extern int __glXImageSize(GLenum format, GLenum type,
GLint imageHeight, GLint rowLength, GLint skipImages, GLint skipRows,
GLint alignment);
extern int __glXCallListsReqSize(GLbyte *pc, Bool swap);
extern int __glXBitmapReqSize(GLbyte *pc, Bool swap);
extern int __glXFogfvReqSize(GLbyte *pc, Bool swap);
extern int __glXFogivReqSize(GLbyte *pc, Bool swap);
extern int __glXLightfvReqSize(GLbyte *pc, Bool swap);
extern int __glXLightivReqSize(GLbyte *pc, Bool swap);
extern int __glXLightModelfvReqSize(GLbyte *pc, Bool swap);
extern int __glXLightModelivReqSize(GLbyte *pc, Bool swap);
extern int __glXMaterialfvReqSize(GLbyte *pc, Bool swap);
extern int __glXMaterialivReqSize(GLbyte *pc, Bool swap);
extern int __glXTexParameterfvReqSize(GLbyte *pc, Bool swap);
extern int __glXTexParameterivReqSize(GLbyte *pc, Bool swap);
extern int __glXTexImage1DReqSize(GLbyte *pc, Bool swap);
extern int __glXTexImage2DReqSize(GLbyte *pc, Bool swap);
extern int __glXTexEnvfvReqSize(GLbyte *pc, Bool swap);
extern int __glXTexEnvivReqSize(GLbyte *pc, Bool swap);
extern int __glXTexGendvReqSize(GLbyte *pc, Bool swap);
extern int __glXTexGenfvReqSize(GLbyte *pc, Bool swap);
extern int __glXTexGenivReqSize(GLbyte *pc, Bool swap);
extern int __glXMap1dReqSize(GLbyte *pc, Bool swap);
extern int __glXMap1fReqSize(GLbyte *pc, Bool swap);
extern int __glXMap2dReqSize(GLbyte *pc, Bool swap);
extern int __glXMap2fReqSize(GLbyte *pc, Bool swap);
extern int __glXPixelMapfvReqSize(GLbyte *pc, Bool swap);
extern int __glXPixelMapuivReqSize(GLbyte *pc, Bool swap);
extern int __glXPixelMapusvReqSize(GLbyte *pc, Bool swap);
extern int __glXDrawPixelsReqSize(GLbyte *pc, Bool swap);
extern int __glXDrawArraysSize(GLbyte *pc, Bool swap);
extern int __glXPrioritizeTexturesReqSize(GLbyte *pc, Bool swap);
extern int __glXTexSubImage1DReqSize(GLbyte *pc, Bool swap);
extern int __glXTexSubImage2DReqSize(GLbyte *pc, Bool swap);
extern int __glXTexImage3DReqSize(GLbyte *pc, Bool swap );
extern int __glXTexSubImage3DReqSize(GLbyte *pc, Bool swap);
extern int __glXConvolutionFilter1DReqSize(GLbyte *pc, Bool swap);
extern int __glXConvolutionFilter2DReqSize(GLbyte *pc, Bool swap);
extern int __glXConvolutionParameterivReqSize(GLbyte *pc, Bool swap);
extern int __glXConvolutionParameterfvReqSize(GLbyte *pc, Bool swap);
extern int __glXSeparableFilter2DReqSize(GLbyte *pc, Bool swap);
extern int __glXColorTableReqSize(GLbyte *pc, Bool swap);
extern int __glXColorSubTableReqSize(GLbyte *pc, Bool swap);
extern int __glXColorTableParameterfvReqSize(GLbyte *pc, Bool swap);
extern int __glXColorTableParameterivReqSize(GLbyte *pc, Bool swap);
/*
* Routines for computing the size of returned data.
*/
extern int __glXConvolutionParameterivSize(GLenum pname);
extern int __glXConvolutionParameterfvSize(GLenum pname);
extern int __glXColorTableParameterfvSize(GLenum pname);
extern int __glXColorTableParameterivSize(GLenum pname);
extern int __glXPointParameterfvARBReqSize(GLbyte *pc, Bool swap);
extern int __glXPointParameterivReqSize(GLbyte *pc, Bool swap);
extern int __glXDrawArraysSize(const GLbyte *pc, Bool swap);
#endif /* !__GLX_server_h__ */

56
GL/glx/impsize.h
View File

@ -1,56 +0,0 @@
/* $XFree86: xc/programs/Xserver/GL/glx/impsize.h,v 1.4 2003/09/28 20:15:43 alanh Exp $ */
#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#ifndef _impsize_h_
#define _impsize_h_
/*
** License Applicability. Except to the extent portions of this file are
** made subject to an alternative license as permitted in the SGI Free
** Software License B, Version 1.1 (the "License"), the contents of this
** file are subject only to the provisions of the License. You may not use
** this file except in compliance with the License. You may obtain a copy
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
**
** http://oss.sgi.com/projects/FreeB
**
** Note that, as provided in the License, the Software is distributed on an
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
**
** Original Code. The Original Code is: OpenGL Sample Implementation,
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
** Copyright in any portions created by third parties is as indicated
** elsewhere herein. All Rights Reserved.
**
** Additional Notice Provisions: The application programming interfaces
** established by SGI in conjunction with the Original Code are The
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
** Window System(R) (Version 1.3), released October 19, 1998. This software
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
** published by SGI, but has not been independently verified as being
** compliant with the OpenGL(R) version 1.2.1 Specification.
**
*/
/*
** These are defined in libsampleGL.a. They are not technically part of
** the defined interface between libdixGL.a and libsampleGL.a (that interface
** being the functions in the __glXScreenInfo structure, plus the OpenGL API
** itself), but we thought it was better to call these routines than to
** replicate the code in here.
*/
#include "indirect_size.h"
extern int __glDrawPixels_size(GLenum format, GLenum type, GLsizei w,GLsizei h);
#endif /* _impsize_h_ */

5654
GL/glx/indirect_dispatch.c Normal file
View File

File diff suppressed because it is too large Load Diff

931
GL/glx/indirect_dispatch.h Normal file
View File

@ -0,0 +1,931 @@
/* DO NOT EDIT - This file generated automatically by glX_proto_recv.py (from Mesa) script */
/*
* (C) Copyright IBM Corporation 2005
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sub license,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
* IBM,
* AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#if !defined( _INDIRECT_DISPATCH_H_ )
# define _INDIRECT_DISPATCH_H_
# if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__)
# define HIDDEN __attribute__((visibility("hidden")))
# else
# define HIDDEN
# endif
struct __GLXclientStateRec;
extern HIDDEN void __glXDisp_MapGrid1d(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MapGrid1d(GLbyte * pc);
extern HIDDEN void __glXDisp_MapGrid1f(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MapGrid1f(GLbyte * pc);
extern HIDDEN int __glXDisp_NewList(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_NewList(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_LoadIdentity(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LoadIdentity(GLbyte * pc);
extern HIDDEN void __glXDisp_SampleCoverageARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SampleCoverageARB(GLbyte * pc);
extern HIDDEN void __glXDisp_ConvolutionFilter1D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ConvolutionFilter1D(GLbyte * pc);
extern HIDDEN void __glXDisp_BeginQueryARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_BeginQueryARB(GLbyte * pc);
extern HIDDEN void __glXDisp_RasterPos3dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RasterPos3dv(GLbyte * pc);
extern HIDDEN void __glXDisp_PointParameteriNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PointParameteriNV(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord1iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord1iv(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord4sv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord4sv(GLbyte * pc);
extern HIDDEN void __glXDisp_ActiveTextureARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ActiveTextureARB(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4ubvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4ubvNV(GLbyte * pc);
extern HIDDEN int __glXDisp_GetProgramNamedParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetProgramNamedParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Histogram(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Histogram(GLbyte * pc);
extern HIDDEN int __glXDisp_GetMapfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetMapfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_PolygonStipple(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PolygonStipple(GLbyte * pc);
extern HIDDEN int __glXDisp_GetPixelMapfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetPixelMapfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Color3uiv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color3uiv(GLbyte * pc);
extern HIDDEN int __glXDisp_IsEnabled(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_IsEnabled(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_VertexAttrib4svNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4svNV(GLbyte * pc);
extern HIDDEN void __glXDisp_EvalCoord2fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_EvalCoord2fv(GLbyte * pc);
extern HIDDEN void __glXDisp_ProgramEnvParameter4dvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ProgramEnvParameter4dvARB(GLbyte * pc);
extern HIDDEN int __glXDisp_GetMapiv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetMapiv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Indexubv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Indexubv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetQueryivARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetQueryivARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_TexImage3D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexImage3D(GLbyte * pc);
extern HIDDEN void __glXDisp_Color3ubv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color3ubv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetQueryObjectivARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetQueryObjectivARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Vertex3dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Vertex3dv(GLbyte * pc);
extern HIDDEN void __glXDisp_CompressedTexSubImage2DARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CompressedTexSubImage2DARB(GLbyte * pc);
extern HIDDEN void __glXDisp_LightModeliv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LightModeliv(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib1svARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib1svARB(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttribs1dvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs1dvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_Normal3bv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Normal3bv(GLbyte * pc);
extern HIDDEN void __glXDisp_TexGeniv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexGeniv(GLbyte * pc);
extern HIDDEN void __glXDisp_Vertex3iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Vertex3iv(GLbyte * pc);
extern HIDDEN void __glXDisp_CopyConvolutionFilter1D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CopyConvolutionFilter1D(GLbyte * pc);
extern HIDDEN void __glXDisp_BlendColor(GLbyte * pc);
extern HIDDEN void __glXDispSwap_BlendColor(GLbyte * pc);
extern HIDDEN void __glXDisp_CallLists(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CallLists(GLbyte * pc);
extern HIDDEN void __glXDisp_Normal3iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Normal3iv(GLbyte * pc);
extern HIDDEN void __glXDisp_PassThrough(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PassThrough(GLbyte * pc);
extern HIDDEN void __glXDisp_Viewport(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Viewport(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4NusvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4NusvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_PrioritizeTextures(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PrioritizeTextures(GLbyte * pc);
extern HIDDEN void __glXDisp_ResetHistogram(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ResetHistogram(GLbyte * pc);
extern HIDDEN int __glXDisp_GetProgramNamedParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetProgramNamedParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_PointParameterfEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PointParameterfEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_ProgramParameter4dvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ProgramParameter4dvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord2sv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord2sv(GLbyte * pc);
extern HIDDEN void __glXDisp_Vertex4dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Vertex4dv(GLbyte * pc);
extern HIDDEN void __glXDisp_CompressedTexImage3DARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CompressedTexImage3DARB(GLbyte * pc);
extern HIDDEN void __glXDisp_Color3sv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color3sv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetConvolutionParameteriv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetConvolutionParameteriv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Vertex2dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Vertex2dv(GLbyte * pc);
extern HIDDEN void __glXDisp_MultiTexCoord1fvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord1fvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord3iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord3iv(GLbyte * pc);
extern HIDDEN void __glXDisp_Color3fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color3fv(GLbyte * pc);
extern HIDDEN void __glXDisp_PointSize(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PointSize(GLbyte * pc);
extern HIDDEN void __glXDisp_PopName(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PopName(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4NbvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4NbvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_Vertex4sv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Vertex4sv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetTexEnvfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetTexEnvfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_TexEnvi(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexEnvi(GLbyte * pc);
extern HIDDEN int __glXDisp_GetClipPlane(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetClipPlane(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_VertexAttribs3dvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs3dvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttribs4fvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs4fvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_Scaled(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Scaled(GLbyte * pc);
extern HIDDEN void __glXDisp_Scalef(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Scalef(GLbyte * pc);
extern HIDDEN void __glXDisp_AlphaFunc(GLbyte * pc);
extern HIDDEN void __glXDispSwap_AlphaFunc(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord2iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord2iv(GLbyte * pc);
extern HIDDEN void __glXDisp_CompressedTexImage1DARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CompressedTexImage1DARB(GLbyte * pc);
extern HIDDEN void __glXDisp_Rotated(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Rotated(GLbyte * pc);
extern HIDDEN int __glXDisp_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_ReadPixels(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_EdgeFlagv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_EdgeFlagv(GLbyte * pc);
extern HIDDEN void __glXDisp_Color4iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color4iv(GLbyte * pc);
extern HIDDEN void __glXDisp_TexParameterf(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexParameterf(GLbyte * pc);
extern HIDDEN void __glXDisp_TexParameteri(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexParameteri(GLbyte * pc);
extern HIDDEN void __glXDisp_DrawPixels(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DrawPixels(GLbyte * pc);
extern HIDDEN void __glXDisp_MultiTexCoord2svARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord2svARB(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttribs3fvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs3fvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_GenerateMipmapEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_GenerateMipmapEXT(GLbyte * pc);
extern HIDDEN int __glXDisp_GenLists(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GenLists(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_MapGrid2d(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MapGrid2d(GLbyte * pc);
extern HIDDEN void __glXDisp_MapGrid2f(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MapGrid2f(GLbyte * pc);
extern HIDDEN void __glXDisp_Scissor(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Scissor(GLbyte * pc);
extern HIDDEN void __glXDisp_Fogf(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Fogf(GLbyte * pc);
extern HIDDEN void __glXDisp_TexSubImage1D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexSubImage1D(GLbyte * pc);
extern HIDDEN void __glXDisp_Color4usv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color4usv(GLbyte * pc);
extern HIDDEN void __glXDisp_Fogi(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Fogi(GLbyte * pc);
extern HIDDEN void __glXDisp_DepthRange(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DepthRange(GLbyte * pc);
extern HIDDEN void __glXDisp_RasterPos3iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RasterPos3iv(GLbyte * pc);
extern HIDDEN void __glXDisp_PixelMapfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PixelMapfv(GLbyte * pc);
extern HIDDEN void __glXDisp_Color3usv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color3usv(GLbyte * pc);
extern HIDDEN void __glXDisp_DrawBuffersARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DrawBuffersARB(GLbyte * pc);
extern HIDDEN int __glXDisp_AreTexturesResident(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_AreTexturesResident(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_IsRenderbufferEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_IsRenderbufferEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_ColorTableParameteriv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ColorTableParameteriv(GLbyte * pc);
extern HIDDEN void __glXDisp_PointParameterfvEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PointParameterfvEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_Color3bv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color3bv(GLbyte * pc);
extern HIDDEN void __glXDisp_SecondaryColor3bvEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SecondaryColor3bvEXT(GLbyte * pc);
extern HIDDEN int __glXDisp_GetProgramLocalParameterfvARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetProgramLocalParameterfvARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_RenderbufferStorageEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RenderbufferStorageEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_ColorTable(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ColorTable(GLbyte * pc);
extern HIDDEN void __glXDisp_Accum(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Accum(GLbyte * pc);
extern HIDDEN int __glXDisp_GetTexImage(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetTexImage(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_ConvolutionFilter2D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ConvolutionFilter2D(GLbyte * pc);
extern HIDDEN int __glXDisp_Finish(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_Finish(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_ClearStencil(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ClearStencil(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib3dvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib3dvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_ConvolutionParameteriv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ConvolutionParameteriv(GLbyte * pc);
extern HIDDEN void __glXDisp_RasterPos2fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RasterPos2fv(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord1fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord1fv(GLbyte * pc);
extern HIDDEN void __glXDisp_ProgramEnvParameter4fvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ProgramEnvParameter4fvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_RasterPos4fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RasterPos4fv(GLbyte * pc);
extern HIDDEN void __glXDisp_ClearIndex(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ClearIndex(GLbyte * pc);
extern HIDDEN void __glXDisp_LoadMatrixd(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LoadMatrixd(GLbyte * pc);
extern HIDDEN void __glXDisp_RasterPos2dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RasterPos2dv(GLbyte * pc);
extern HIDDEN void __glXDisp_ConvolutionParameterfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ConvolutionParameterfv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetTexGendv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetTexGendv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_LoadProgramNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LoadProgramNV(GLbyte * pc);
extern HIDDEN int __glXDisp_EndList(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_EndList(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_VertexAttrib4fvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4fvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_EvalCoord1fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_EvalCoord1fv(GLbyte * pc);
extern HIDDEN void __glXDisp_EvalMesh2(GLbyte * pc);
extern HIDDEN void __glXDispSwap_EvalMesh2(GLbyte * pc);
extern HIDDEN void __glXDisp_Vertex4fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Vertex4fv(GLbyte * pc);
extern HIDDEN int __glXDisp_CheckFramebufferStatusEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_CheckFramebufferStatusEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetVertexAttribivARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetVertexAttribivARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetMinmax(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetMinmax(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Normal3fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Normal3fv(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4ivARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4ivARB(GLbyte * pc);
extern HIDDEN void __glXDisp_End(GLbyte * pc);
extern HIDDEN void __glXDispSwap_End(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttribs2dvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs2dvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_MultiTexCoord3fvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord3fvARB(GLbyte * pc);
extern HIDDEN int __glXDisp_GetProgramParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetProgramParameterfvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_TexSubImage2D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexSubImage2D(GLbyte * pc);
extern HIDDEN void __glXDisp_DeleteRenderbuffersEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DeleteRenderbuffersEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_TexGenfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexGenfv(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4bvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4bvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_FramebufferTexture3DEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_FramebufferTexture3DEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_BlendEquation(GLbyte * pc);
extern HIDDEN void __glXDispSwap_BlendEquation(GLbyte * pc);
extern HIDDEN int __glXDisp_GetError(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetError(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_TexCoord3dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord3dv(GLbyte * pc);
extern HIDDEN void __glXDisp_Indexdv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Indexdv(GLbyte * pc);
extern HIDDEN void __glXDisp_PushName(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PushName(GLbyte * pc);
extern HIDDEN void __glXDisp_MultiTexCoord2dvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord2dvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_ProgramNamedParameter4fvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ProgramNamedParameter4fvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4fvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4fvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_MultiTexCoord1svARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord1svARB(GLbyte * pc);
extern HIDDEN void __glXDisp_EndQueryARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_EndQueryARB(GLbyte * pc);
extern HIDDEN void __glXDisp_DepthMask(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DepthMask(GLbyte * pc);
extern HIDDEN int __glXDisp_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetMaterialiv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_StencilOp(GLbyte * pc);
extern HIDDEN void __glXDispSwap_StencilOp(GLbyte * pc);
extern HIDDEN void __glXDisp_MultiTexCoord3svARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord3svARB(GLbyte * pc);
extern HIDDEN void __glXDisp_TexEnvfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexEnvfv(GLbyte * pc);
extern HIDDEN void __glXDisp_LoadMatrixf(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LoadMatrixf(GLbyte * pc);
extern HIDDEN void __glXDisp_Color4bv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color4bv(GLbyte * pc);
extern HIDDEN void __glXDisp_SecondaryColor3usvEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SecondaryColor3usvEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib2fvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib2fvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_ProgramLocalParameter4dvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ProgramLocalParameter4dvARB(GLbyte * pc);
extern HIDDEN int __glXDisp_DeleteLists(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_DeleteLists(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_LogicOp(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LogicOp(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord4fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord4fv(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib2dvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib2dvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_FramebufferRenderbufferEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_FramebufferRenderbufferEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib1dvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib1dvNV(GLbyte * pc);
extern HIDDEN int __glXDisp_GenTextures(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GenTextures(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_FramebufferTexture1DEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_FramebufferTexture1DEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_ProgramParameter4fvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ProgramParameter4fvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_RasterPos2sv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RasterPos2sv(GLbyte * pc);
extern HIDDEN void __glXDisp_Color4ubv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color4ubv(GLbyte * pc);
extern HIDDEN void __glXDisp_DrawBuffer(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DrawBuffer(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord2fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord2fv(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord1sv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord1sv(GLbyte * pc);
extern HIDDEN void __glXDisp_DepthFunc(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DepthFunc(GLbyte * pc);
extern HIDDEN void __glXDisp_PixelMapusv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PixelMapusv(GLbyte * pc);
extern HIDDEN void __glXDisp_PointParameterivNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PointParameterivNV(GLbyte * pc);
extern HIDDEN void __glXDisp_BlendFunc(GLbyte * pc);
extern HIDDEN void __glXDispSwap_BlendFunc(GLbyte * pc);
extern HIDDEN void __glXDisp_MultiTexCoord3dvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord3dvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_ProgramNamedParameter4dvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ProgramNamedParameter4dvNV(GLbyte * pc);
extern HIDDEN int __glXDisp_Flush(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_Flush(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Color4uiv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color4uiv(GLbyte * pc);
extern HIDDEN void __glXDisp_RasterPos3sv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RasterPos3sv(GLbyte * pc);
extern HIDDEN void __glXDisp_BindFramebufferEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_BindFramebufferEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_PushAttrib(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PushAttrib(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4usvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4usvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_TexParameteriv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexParameteriv(GLbyte * pc);
extern HIDDEN void __glXDisp_WindowPos3fvMESA(GLbyte * pc);
extern HIDDEN void __glXDispSwap_WindowPos3fvMESA(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib1svNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib1svNV(GLbyte * pc);
extern HIDDEN void __glXDisp_RasterPos3fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RasterPos3fv(GLbyte * pc);
extern HIDDEN void __glXDisp_CopyTexSubImage3D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CopyTexSubImage3D(GLbyte * pc);
extern HIDDEN int __glXDisp_GetColorTable(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetColorTable(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_SelectBuffer(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Indexiv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Indexiv(GLbyte * pc);
extern HIDDEN void __glXDisp_CopyColorTable(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CopyColorTable(GLbyte * pc);
extern HIDDEN int __glXDisp_GetHistogramParameterfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetHistogramParameterfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Frustum(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Frustum(GLbyte * pc);
extern HIDDEN int __glXDisp_GetString(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetString(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_TexEnvf(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexEnvf(GLbyte * pc);
extern HIDDEN void __glXDisp_MultiTexCoord3ivARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord3ivARB(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib1dvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib1dvARB(GLbyte * pc);
extern HIDDEN int __glXDisp_DeleteTextures(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_DeleteTextures(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetTexLevelParameteriv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetTexLevelParameteriv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_ClearAccum(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ClearAccum(GLbyte * pc);
extern HIDDEN int __glXDisp_GetVertexAttribfvARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetVertexAttribfvARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_SecondaryColor3ivEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SecondaryColor3ivEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord4iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord4iv(GLbyte * pc);
extern HIDDEN void __glXDisp_PolygonOffset(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PolygonOffset(GLbyte * pc);
extern HIDDEN void __glXDisp_SampleMaskSGIS(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SampleMaskSGIS(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4ubvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4ubvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_CopyTexImage2D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CopyTexImage2D(GLbyte * pc);
extern HIDDEN void __glXDisp_Lightfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Lightfv(GLbyte * pc);
extern HIDDEN void __glXDisp_ClearDepth(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ClearDepth(GLbyte * pc);
extern HIDDEN void __glXDisp_ColorSubTable(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ColorSubTable(GLbyte * pc);
extern HIDDEN void __glXDisp_Color4fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color4fv(GLbyte * pc);
extern HIDDEN void __glXDisp_MultiTexCoord4ivARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord4ivARB(GLbyte * pc);
extern HIDDEN void __glXDisp_Lightiv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Lightiv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetQueryObjectuivARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetQueryObjectuivARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetTexParameteriv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetTexParameteriv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GenRenderbuffersEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GenRenderbuffersEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_VertexAttrib2dvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib2dvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttribs2svNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs2svNV(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib2fvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib2fvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_Rectdv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Rectdv(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4NivARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4NivARB(GLbyte * pc);
extern HIDDEN void __glXDisp_Materialiv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Materialiv(GLbyte * pc);
extern HIDDEN void __glXDisp_SecondaryColor3fvEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SecondaryColor3fvEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_PolygonMode(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PolygonMode(GLbyte * pc);
extern HIDDEN void __glXDisp_CompressedTexSubImage1DARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CompressedTexSubImage1DARB(GLbyte * pc);
extern HIDDEN int __glXDisp_GetVertexAttribivNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetVertexAttribivNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetProgramStringARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_TexGeni(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexGeni(GLbyte * pc);
extern HIDDEN void __glXDisp_TexGenf(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexGenf(GLbyte * pc);
extern HIDDEN void __glXDisp_TexGend(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexGend(GLbyte * pc);
extern HIDDEN int __glXDisp_GetPolygonStipple(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetPolygonStipple(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetVertexAttribfvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetVertexAttribfvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_VertexAttrib2svNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib2svNV(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttribs1fvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs1fvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4NuivARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4NuivARB(GLbyte * pc);
extern HIDDEN void __glXDisp_Color4sv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color4sv(GLbyte * pc);
extern HIDDEN int __glXDisp_IsProgramNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_IsProgramNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_PixelZoom(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PixelZoom(GLbyte * pc);
extern HIDDEN void __glXDisp_ColorTableParameterfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ColorTableParameterfv(GLbyte * pc);
extern HIDDEN void __glXDisp_PixelMapuiv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PixelMapuiv(GLbyte * pc);
extern HIDDEN void __glXDisp_Color3dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color3dv(GLbyte * pc);
extern HIDDEN int __glXDisp_IsTexture(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_IsTexture(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_DeleteQueriesARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_DeleteQueriesARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetMapdv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetMapdv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_SamplePatternSGIS(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SamplePatternSGIS(GLbyte * pc);
extern HIDDEN int __glXDisp_PixelStoref(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_PixelStoref(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_IsQueryARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_PixelStorei(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_EvalCoord2dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_EvalCoord2dv(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib3svARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib3svARB(GLbyte * pc);
extern HIDDEN void __glXDisp_ColorMaterial(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ColorMaterial(GLbyte * pc);
extern HIDDEN void __glXDisp_CompressedTexSubImage3DARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CompressedTexSubImage3DARB(GLbyte * pc);
extern HIDDEN int __glXDisp_IsFramebufferEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_IsFramebufferEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetVertexAttribdvARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetVertexAttribdvARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetSeparableFilter(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetSeparableFilter(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_RequestResidentProgramsNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RequestResidentProgramsNV(GLbyte * pc);
extern HIDDEN int __glXDisp_FeedbackBuffer(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_FeedbackBuffer(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_RasterPos2iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RasterPos2iv(GLbyte * pc);
extern HIDDEN void __glXDisp_TexImage1D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexImage1D(GLbyte * pc);
extern HIDDEN void __glXDisp_FrontFace(GLbyte * pc);
extern HIDDEN void __glXDispSwap_FrontFace(GLbyte * pc);
extern HIDDEN void __glXDisp_SecondaryColor3ubvEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SecondaryColor3ubvEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4dvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4dvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_ExecuteProgramNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ExecuteProgramNV(GLbyte * pc);
extern HIDDEN void __glXDisp_Normal3dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Normal3dv(GLbyte * pc);
extern HIDDEN void __glXDisp_Lightf(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Lightf(GLbyte * pc);
extern HIDDEN void __glXDisp_MatrixMode(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MatrixMode(GLbyte * pc);
extern HIDDEN void __glXDisp_FramebufferTexture2DEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_FramebufferTexture2DEXT(GLbyte * pc);
extern HIDDEN int __glXDisp_GetPixelMapusv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetPixelMapusv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Lighti(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Lighti(GLbyte * pc);
extern HIDDEN int __glXDisp_GetFramebufferAttachmentParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetFramebufferAttachmentParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_MultiTexCoord4dvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord4dvARB(GLbyte * pc);
extern HIDDEN int __glXDisp_GetDoublev(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetDoublev(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_MultMatrixd(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultMatrixd(GLbyte * pc);
extern HIDDEN void __glXDisp_MultMatrixf(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultMatrixf(GLbyte * pc);
extern HIDDEN void __glXDisp_MultiTexCoord4fvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord4fvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_TrackMatrixNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TrackMatrixNV(GLbyte * pc);
extern HIDDEN void __glXDisp_RasterPos4sv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RasterPos4sv(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4NsvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4NsvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib3fvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib3fvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_ClearColor(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ClearColor(GLbyte * pc);
extern HIDDEN void __glXDisp_DeleteFramebuffersEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DeleteFramebuffersEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_TexEnviv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexEnviv(GLbyte * pc);
extern HIDDEN void __glXDisp_TexSubImage3D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexSubImage3D(GLbyte * pc);
extern HIDDEN void __glXDisp_SecondaryColor3uivEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SecondaryColor3uivEXT(GLbyte * pc);
extern HIDDEN int __glXDisp_GetColorTableParameterfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetColorTableParameterfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Bitmap(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Bitmap(GLbyte * pc);
extern HIDDEN int __glXDisp_GetTexLevelParameterfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetTexLevelParameterfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GenFramebuffersEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GenFramebuffersEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetProgramParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetProgramParameterdvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Vertex2sv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Vertex2sv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetIntegerv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetIntegerv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetProgramEnvParameterfvARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetProgramEnvParameterfvARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetTrackMatrixivNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetTrackMatrixivNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_VertexAttrib3svNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib3svNV(GLbyte * pc);
extern HIDDEN int __glXDisp_GetTexEnviv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetTexEnviv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_SeparableFilter2D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SeparableFilter2D(GLbyte * pc);
extern HIDDEN void __glXDisp_Map1d(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Map1d(GLbyte * pc);
extern HIDDEN void __glXDisp_Map1f(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Map1f(GLbyte * pc);
extern HIDDEN void __glXDisp_CompressedTexImage2DARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CompressedTexImage2DARB(GLbyte * pc);
extern HIDDEN void __glXDisp_TexImage2D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexImage2D(GLbyte * pc);
extern HIDDEN void __glXDisp_ProgramParameters4fvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ProgramParameters4fvNV(GLbyte * pc);
extern HIDDEN int __glXDisp_GetProgramivNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetProgramivNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetMinmaxParameteriv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetMinmaxParameteriv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_PixelTransferf(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PixelTransferf(GLbyte * pc);
extern HIDDEN void __glXDisp_CopyTexImage1D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CopyTexImage1D(GLbyte * pc);
extern HIDDEN void __glXDisp_PushMatrix(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PushMatrix(GLbyte * pc);
extern HIDDEN void __glXDisp_Fogiv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Fogiv(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord1dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord1dv(GLbyte * pc);
extern HIDDEN void __glXDisp_PixelTransferi(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PixelTransferi(GLbyte * pc);
extern HIDDEN int __glXDisp_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetVertexAttribdvNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_VertexAttrib3fvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib3fvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_Rotatef(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Rotatef(GLbyte * pc);
extern HIDDEN void __glXDisp_Clear(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Clear(GLbyte * pc);
extern HIDDEN void __glXDisp_ReadBuffer(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ReadBuffer(GLbyte * pc);
extern HIDDEN void __glXDisp_ConvolutionParameteri(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ConvolutionParameteri(GLbyte * pc);
extern HIDDEN void __glXDisp_Ortho(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Ortho(GLbyte * pc);
extern HIDDEN void __glXDisp_ListBase(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ListBase(GLbyte * pc);
extern HIDDEN void __glXDisp_ConvolutionParameterf(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ConvolutionParameterf(GLbyte * pc);
extern HIDDEN int __glXDisp_GetColorTableParameteriv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetColorTableParameteriv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_ShadeModel(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ShadeModel(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttribs2fvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs2fvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_Rectiv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Rectiv(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib1fvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib1fvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_SecondaryColor3dvEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SecondaryColor3dvEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_Vertex2fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Vertex2fv(GLbyte * pc);
extern HIDDEN void __glXDisp_BindRenderbufferEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_BindRenderbufferEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_Vertex3sv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Vertex3sv(GLbyte * pc);
extern HIDDEN void __glXDisp_ProgramLocalParameter4fvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ProgramLocalParameter4fvARB(GLbyte * pc);
extern HIDDEN int __glXDisp_DeleteProgramsNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_DeleteProgramsNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_EvalMesh1(GLbyte * pc);
extern HIDDEN void __glXDispSwap_EvalMesh1(GLbyte * pc);
extern HIDDEN void __glXDisp_MultiTexCoord1dvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord1dvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_Vertex2iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Vertex2iv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetProgramStringNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetProgramStringNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_LineWidth(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LineWidth(GLbyte * pc);
extern HIDDEN void __glXDisp_TexGendv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexGendv(GLbyte * pc);
extern HIDDEN void __glXDisp_ResetMinmax(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ResetMinmax(GLbyte * pc);
extern HIDDEN int __glXDisp_GenTexturesEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GenTexturesEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetConvolutionParameterfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetConvolutionParameterfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_VertexAttribs4dvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs4dvNV(GLbyte * pc);
extern HIDDEN int __glXDisp_GetMaterialfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetMaterialfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_CallList(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CallList(GLbyte * pc);
extern HIDDEN void __glXDisp_Materialfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Materialfv(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord3fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord3fv(GLbyte * pc);
extern HIDDEN void __glXDisp_FogCoordfvEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_FogCoordfvEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_MultiTexCoord1ivARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord1ivARB(GLbyte * pc);
extern HIDDEN void __glXDisp_MultiTexCoord2ivARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord2ivARB(GLbyte * pc);
extern HIDDEN void __glXDisp_CopyTexSubImage2D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CopyTexSubImage2D(GLbyte * pc);
extern HIDDEN void __glXDisp_Color3iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color3iv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetProgramLocalParameterdvARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetProgramLocalParameterdvARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetHistogramParameteriv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetHistogramParameteriv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetConvolutionFilter(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetConvolutionFilter(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetProgramivARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetProgramivARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_BlendFuncSeparateEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_BlendFuncSeparateEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_ProgramParameters4dvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ProgramParameters4dvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_EvalPoint2(GLbyte * pc);
extern HIDDEN void __glXDispSwap_EvalPoint2(GLbyte * pc);
extern HIDDEN void __glXDisp_EvalPoint1(GLbyte * pc);
extern HIDDEN void __glXDispSwap_EvalPoint1(GLbyte * pc);
extern HIDDEN void __glXDisp_PopMatrix(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PopMatrix(GLbyte * pc);
extern HIDDEN int __glXDisp_AreTexturesResidentEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_AreTexturesResidentEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetTexGeniv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetTexGeniv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Map2d(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Map2d(GLbyte * pc);
extern HIDDEN void __glXDisp_Map2f(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Map2f(GLbyte * pc);
extern HIDDEN void __glXDisp_ProgramStringARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ProgramStringARB(GLbyte * pc);
extern HIDDEN void __glXDisp_RasterPos4dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RasterPos4dv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetCompressedTexImageARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetCompressedTexImageARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetTexGenfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetTexGenfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetHistogram(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetHistogram(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_ActiveStencilFaceEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ActiveStencilFaceEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_Materialf(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Materialf(GLbyte * pc);
extern HIDDEN void __glXDisp_Materiali(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Materiali(GLbyte * pc);
extern HIDDEN void __glXDisp_Indexsv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Indexsv(GLbyte * pc);
extern HIDDEN void __glXDisp_MultiTexCoord4svARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord4svARB(GLbyte * pc);
extern HIDDEN void __glXDisp_LightModelfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LightModelfv(GLbyte * pc);
extern HIDDEN void __glXDisp_TexCoord2dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord2dv(GLbyte * pc);
extern HIDDEN int __glXDisp_GenQueriesARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GenQueriesARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_EvalCoord1dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_EvalCoord1dv(GLbyte * pc);
extern HIDDEN void __glXDisp_Translated(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Translated(GLbyte * pc);
extern HIDDEN void __glXDisp_Translatef(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Translatef(GLbyte * pc);
extern HIDDEN void __glXDisp_StencilMask(GLbyte * pc);
extern HIDDEN void __glXDispSwap_StencilMask(GLbyte * pc);
extern HIDDEN int __glXDisp_GetLightiv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetLightiv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_IsList(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_IsList(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_RenderMode(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_RenderMode(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_LoadName(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LoadName(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttribs4ubvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs4ubvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_CopyTexSubImage1D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CopyTexSubImage1D(GLbyte * pc);
extern HIDDEN void __glXDisp_CullFace(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CullFace(GLbyte * pc);
extern HIDDEN void __glXDisp_BindTexture(GLbyte * pc);
extern HIDDEN void __glXDispSwap_BindTexture(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttribs3svNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs3svNV(GLbyte * pc);
extern HIDDEN void __glXDisp_StencilFunc(GLbyte * pc);
extern HIDDEN void __glXDispSwap_StencilFunc(GLbyte * pc);
extern HIDDEN void __glXDisp_CopyPixels(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CopyPixels(GLbyte * pc);
extern HIDDEN void __glXDisp_Rectsv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Rectsv(GLbyte * pc);
extern HIDDEN void __glXDisp_CopyConvolutionFilter2D(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CopyConvolutionFilter2D(GLbyte * pc);
extern HIDDEN void __glXDisp_TexParameterfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexParameterfv(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4uivARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4uivARB(GLbyte * pc);
extern HIDDEN void __glXDisp_ClipPlane(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ClipPlane(GLbyte * pc);
extern HIDDEN int __glXDisp_IsTextureEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_IsTextureEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetPixelMapuiv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetPixelMapuiv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Indexfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Indexfv(GLbyte * pc);
extern HIDDEN void __glXDisp_SecondaryColor3svEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_SecondaryColor3svEXT(GLbyte * pc);
extern HIDDEN void __glXDisp_IndexMask(GLbyte * pc);
extern HIDDEN void __glXDispSwap_IndexMask(GLbyte * pc);
extern HIDDEN void __glXDisp_BindProgramNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_BindProgramNV(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4svARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4svARB(GLbyte * pc);
extern HIDDEN int __glXDisp_GetFloatv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetFloatv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_TexCoord3sv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord3sv(GLbyte * pc);
extern HIDDEN void __glXDisp_PopAttrib(GLbyte * pc);
extern HIDDEN void __glXDispSwap_PopAttrib(GLbyte * pc);
extern HIDDEN void __glXDisp_Fogfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Fogfv(GLbyte * pc);
extern HIDDEN void __glXDisp_InitNames(GLbyte * pc);
extern HIDDEN void __glXDispSwap_InitNames(GLbyte * pc);
extern HIDDEN void __glXDisp_Normal3sv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Normal3sv(GLbyte * pc);
extern HIDDEN void __glXDisp_Minmax(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Minmax(GLbyte * pc);
extern HIDDEN void __glXDisp_FogCoorddvEXT(GLbyte * pc);
extern HIDDEN void __glXDispSwap_FogCoorddvEXT(GLbyte * pc);
extern HIDDEN int __glXDisp_GetBooleanv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetBooleanv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Hint(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Hint(GLbyte * pc);
extern HIDDEN void __glXDisp_Color4dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Color4dv(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib2svARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib2svARB(GLbyte * pc);
extern HIDDEN int __glXDisp_AreProgramsResidentNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_AreProgramsResidentNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_CopyColorSubTable(GLbyte * pc);
extern HIDDEN void __glXDispSwap_CopyColorSubTable(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib4NubvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4NubvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttrib3dvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib3dvNV(GLbyte * pc);
extern HIDDEN void __glXDisp_Vertex4iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Vertex4iv(GLbyte * pc);
extern HIDDEN int __glXDisp_GetProgramEnvParameterdvARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetProgramEnvParameterdvARB(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_TexCoord4dv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_TexCoord4dv(GLbyte * pc);
extern HIDDEN void __glXDisp_Begin(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Begin(GLbyte * pc);
extern HIDDEN void __glXDisp_LightModeli(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LightModeli(GLbyte * pc);
extern HIDDEN void __glXDisp_Rectfv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Rectfv(GLbyte * pc);
extern HIDDEN void __glXDisp_LightModelf(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LightModelf(GLbyte * pc);
extern HIDDEN int __glXDisp_GetTexParameterfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetTexParameterfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDisp_GetLightfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetLightfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_Disable(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Disable(GLbyte * pc);
extern HIDDEN void __glXDisp_MultiTexCoord2fvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_MultiTexCoord2fvARB(GLbyte * pc);
extern HIDDEN int __glXDisp_GetRenderbufferParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetRenderbufferParameterivEXT(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_DrawArrays(GLbyte * pc);
extern HIDDEN void __glXDispSwap_DrawArrays(GLbyte * pc);
extern HIDDEN void __glXDisp_ColorMask(GLbyte * pc);
extern HIDDEN void __glXDispSwap_ColorMask(GLbyte * pc);
extern HIDDEN void __glXDisp_RasterPos4iv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_RasterPos4iv(GLbyte * pc);
extern HIDDEN void __glXDisp_Enable(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Enable(GLbyte * pc);
extern HIDDEN void __glXDisp_LineStipple(GLbyte * pc);
extern HIDDEN void __glXDispSwap_LineStipple(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttribs4svNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs4svNV(GLbyte * pc);
extern HIDDEN int __glXDisp_GetMinmaxParameterfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GetMinmaxParameterfv(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_VertexAttrib1fvARB(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib1fvARB(GLbyte * pc);
extern HIDDEN void __glXDisp_VertexAttribs1svNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttribs1svNV(GLbyte * pc);
extern HIDDEN void __glXDisp_Vertex3fv(GLbyte * pc);
extern HIDDEN void __glXDispSwap_Vertex3fv(GLbyte * pc);
extern HIDDEN int __glXDisp_GenProgramsNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN int __glXDispSwap_GenProgramsNV(struct __GLXclientStateRec *, GLbyte *);
extern HIDDEN void __glXDisp_VertexAttrib4dvNV(GLbyte * pc);
extern HIDDEN void __glXDispSwap_VertexAttrib4dvNV(GLbyte * pc);
# undef HIDDEN
#endif /* !defined( _INDIRECT_DISPATCH_H_ ) */

5806
GL/glx/indirect_dispatch_swap.c Normal file
View File

File diff suppressed because it is too large Load Diff

839
GL/glx/indirect_reqsize.c Normal file
View File

@ -0,0 +1,839 @@
/* DO NOT EDIT - This file generated automatically by glX_proto_size.py (from Mesa) script */
/*
* (C) Copyright IBM Corporation 2005
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sub license,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
* IBM,
* AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <GL/gl.h>
#include "glxserver.h"
#include "indirect_size.h"
#include "indirect_reqsize.h"
#if defined(linux)
# include <byteswap.h>
# define SWAP_32(v) do { (v) = bswap_32(v); } while(0)
#else
# include <X11/misc.h>
# define SWAP_32(v) do { char tmp; swapl(&v, tmp); } while(0)
#endif
#define __GLX_PAD(x) (((x) + 3) & ~3)
#if defined(__CYGWIN__) || defined(__MINGW32__)
# undef HAVE_ALIAS
#endif
#ifdef HAVE_ALIAS
# define ALIAS2(from,to) \
GLint __glX ## from ## ReqSize( const GLbyte * pc, Bool swap ) \
__attribute__ ((alias( # to )));
# define ALIAS(from,to) ALIAS2( from, __glX ## to ## ReqSize )
#else
# define ALIAS(from,to) \
GLint __glX ## from ## ReqSize( const GLbyte * pc, Bool swap ) \
{ return __glX ## to ## ReqSize( pc, swap ); }
#endif
int
__glXCallListsReqSize( const GLbyte * pc, Bool swap )
{
GLsizei n = *(GLsizei *)(pc + 0);
GLenum type = * (GLenum *)(pc + 4);
GLsizei compsize;
if (swap) {
SWAP_32( n );
SWAP_32( type );
}
compsize = __glCallLists_size(type);
return __GLX_PAD((compsize * n));
}
int
__glXBitmapReqSize( const GLbyte * pc, Bool swap )
{
GLint row_length = * (GLint *)(pc + 4);
GLint image_height = 0;
GLint skip_images = 0;
GLint skip_rows = * (GLint *)(pc + 8);
GLint alignment = * (GLint *)(pc + 16);
GLsizei width = *(GLsizei *)(pc + 20);
GLsizei height = *(GLsizei *)(pc + 24);
if (swap) {
SWAP_32( row_length );
SWAP_32( skip_rows );
SWAP_32( alignment );
SWAP_32( width );
SWAP_32( height );
}
return __glXImageSize(GL_COLOR_INDEX, GL_BITMAP, 0, width, height, 1,
image_height, row_length, skip_images,
skip_rows, alignment);
}
int
__glXFogfvReqSize( const GLbyte * pc, Bool swap )
{
GLenum pname = * (GLenum *)(pc + 0);
GLsizei compsize;
if (swap) {
SWAP_32( pname );
}
compsize = __glFogfv_size(pname);
return __GLX_PAD((compsize * 4));
}
int
__glXLightfvReqSize( const GLbyte * pc, Bool swap )
{
GLenum pname = * (GLenum *)(pc + 4);
GLsizei compsize;
if (swap) {
SWAP_32( pname );
}
compsize = __glLightfv_size(pname);
return __GLX_PAD((compsize * 4));
}
int
__glXLightModelfvReqSize( const GLbyte * pc, Bool swap )
{
GLenum pname = * (GLenum *)(pc + 0);
GLsizei compsize;
if (swap) {
SWAP_32( pname );
}
compsize = __glLightModelfv_size(pname);
return __GLX_PAD((compsize * 4));
}
int
__glXMaterialfvReqSize( const GLbyte * pc, Bool swap )
{
GLenum pname = * (GLenum *)(pc + 4);
GLsizei compsize;
if (swap) {
SWAP_32( pname );
}
compsize = __glMaterialfv_size(pname);
return __GLX_PAD((compsize * 4));
}
int
__glXPolygonStippleReqSize( const GLbyte * pc, Bool swap )
{
GLint row_length = * (GLint *)(pc + 4);
GLint image_height = 0;
GLint skip_images = 0;
GLint skip_rows = * (GLint *)(pc + 8);
GLint alignment = * (GLint *)(pc + 16);
if (swap) {
SWAP_32( row_length );
SWAP_32( skip_rows );
SWAP_32( alignment );
}
return __glXImageSize(GL_COLOR_INDEX, GL_BITMAP, 0, 32, 32, 1,
image_height, row_length, skip_images,
skip_rows, alignment);
}
int
__glXTexParameterfvReqSize( const GLbyte * pc, Bool swap )
{
GLenum pname = * (GLenum *)(pc + 4);
GLsizei compsize;
if (swap) {
SWAP_32( pname );
}
compsize = __glTexParameterfv_size(pname);
return __GLX_PAD((compsize * 4));
}
int
__glXTexImage1DReqSize( const GLbyte * pc, Bool swap )
{
GLint row_length = * (GLint *)(pc + 4);
GLint image_height = 0;
GLint skip_images = 0;
GLint skip_rows = * (GLint *)(pc + 8);
GLint alignment = * (GLint *)(pc + 16);
GLenum target = * (GLenum *)(pc + 20);
GLsizei width = *(GLsizei *)(pc + 32);
GLenum format = * (GLenum *)(pc + 44);
GLenum type = * (GLenum *)(pc + 48);
if (swap) {
SWAP_32( row_length );
SWAP_32( skip_rows );
SWAP_32( alignment );
SWAP_32( target );
SWAP_32( width );
SWAP_32( format );
SWAP_32( type );
}
return __glXImageSize(format, type, target, width, 1, 1,
image_height, row_length, skip_images,
skip_rows, alignment);
}
int
__glXTexImage2DReqSize( const GLbyte * pc, Bool swap )
{
GLint row_length = * (GLint *)(pc + 4);
GLint image_height = 0;
GLint skip_images = 0;
GLint skip_rows = * (GLint *)(pc + 8);
GLint alignment = * (GLint *)(pc + 16);
GLenum target = * (GLenum *)(pc + 20);
GLsizei width = *(GLsizei *)(pc + 32);
GLsizei height = *(GLsizei *)(pc + 36);
GLenum format = * (GLenum *)(pc + 44);
GLenum type = * (GLenum *)(pc + 48);
if (swap) {
SWAP_32( row_length );
SWAP_32( skip_rows );
SWAP_32( alignment );
SWAP_32( target );
SWAP_32( width );
SWAP_32( height );
SWAP_32( format );
SWAP_32( type );
}
return __glXImageSize(format, type, target, width, height, 1,
image_height, row_length, skip_images,
skip_rows, alignment);
}
int
__glXTexEnvfvReqSize( const GLbyte * pc, Bool swap )
{
GLenum pname = * (GLenum *)(pc + 4);
GLsizei compsize;
if (swap) {
SWAP_32( pname );
}
compsize = __glTexEnvfv_size(pname);
return __GLX_PAD((compsize * 4));
}
int
__glXTexGendvReqSize( const GLbyte * pc, Bool swap )
{
GLenum pname = * (GLenum *)(pc + 4);
GLsizei compsize;
if (swap) {
SWAP_32( pname );
}
compsize = __glTexGendv_size(pname);
return __GLX_PAD((compsize * 8));
}
int
__glXTexGenfvReqSize( const GLbyte * pc, Bool swap )
{
GLenum pname = * (GLenum *)(pc + 4);
GLsizei compsize;
if (swap) {
SWAP_32( pname );
}
compsize = __glTexGenfv_size(pname);
return __GLX_PAD((compsize * 4));
}
int
__glXPixelMapfvReqSize( const GLbyte * pc, Bool swap )
{
GLsizei mapsize = *(GLsizei *)(pc + 4);
if (swap) {
SWAP_32( mapsize );
}
return __GLX_PAD((mapsize * 4));
}
int
__glXPixelMapusvReqSize( const GLbyte * pc, Bool swap )
{
GLsizei mapsize = *(GLsizei *)(pc + 4);
if (swap) {
SWAP_32( mapsize );
}
return __GLX_PAD((mapsize * 2));
}
int
__glXDrawPixelsReqSize( const GLbyte * pc, Bool swap )
{
GLint row_length = * (GLint *)(pc + 4);
GLint image_height = 0;
GLint skip_images = 0;
GLint skip_rows = * (GLint *)(pc + 8);
GLint alignment = * (GLint *)(pc + 16);
GLsizei width = *(GLsizei *)(pc + 20);
GLsizei height = *(GLsizei *)(pc + 24);
GLenum format = * (GLenum *)(pc + 28);
GLenum type = * (GLenum *)(pc + 32);
if (swap) {
SWAP_32( row_length );
SWAP_32( skip_rows );
SWAP_32( alignment );
SWAP_32( width );
SWAP_32( height );
SWAP_32( format );
SWAP_32( type );
}
return __glXImageSize(format, type, 0, width, height, 1,
image_height, row_length, skip_images,
skip_rows, alignment);
}
int
__glXPrioritizeTexturesReqSize( const GLbyte * pc, Bool swap )
{
GLsizei n = *(GLsizei *)(pc + 0);
if (swap) {
SWAP_32( n );
}
return __GLX_PAD((n * 4) + (n * 4));
}
int
__glXTexSubImage1DReqSize( const GLbyte * pc, Bool swap )
{
GLint row_length = * (GLint *)(pc + 4);
GLint image_height = 0;
GLint skip_images = 0;
GLint skip_rows = * (GLint *)(pc + 8);
GLint alignment = * (GLint *)(pc + 16);
GLenum target = * (GLenum *)(pc + 20);
GLsizei width = *(GLsizei *)(pc + 36);
GLenum format = * (GLenum *)(pc + 44);
GLenum type = * (GLenum *)(pc + 48);
if (swap) {
SWAP_32( row_length );
SWAP_32( skip_rows );
SWAP_32( alignment );
SWAP_32( target );
SWAP_32( width );
SWAP_32( format );
SWAP_32( type );
}
return __glXImageSize(format, type, target, width, 1, 1,
image_height, row_length, skip_images,
skip_rows, alignment);
}
int
__glXTexSubImage2DReqSize( const GLbyte * pc, Bool swap )
{
GLint row_length = * (GLint *)(pc + 4);
GLint image_height = 0;
GLint skip_images = 0;
GLint skip_rows = * (GLint *)(pc + 8);
GLint alignment = * (GLint *)(pc + 16);
GLenum target = * (GLenum *)(pc + 20);
GLsizei width = *(GLsizei *)(pc + 36);
GLsizei height = *(GLsizei *)(pc + 40);
GLenum format = * (GLenum *)(pc + 44);
GLenum type = * (GLenum *)(pc + 48);
if (swap) {
SWAP_32( row_length );
SWAP_32( skip_rows );
SWAP_32( alignment );
SWAP_32( target );
SWAP_32( width );
SWAP_32( height );
SWAP_32( format );
SWAP_32( type );
}
return __glXImageSize(format, type, target, width, height, 1,
image_height, row_length, skip_images,
skip_rows, alignment);
}
int
__glXColorTableReqSize( const GLbyte * pc, Bool swap )
{
GLint row_length = * (GLint *)(pc + 4);
GLint image_height = 0;
GLint skip_images = 0;
GLint skip_rows = * (GLint *)(pc + 8);
GLint alignment = * (GLint *)(pc + 16);
GLenum target = * (GLenum *)(pc + 20);
GLsizei width = *(GLsizei *)(pc + 28);
GLenum format = * (GLenum *)(pc + 32);
GLenum type = * (GLenum *)(pc + 36);
if (swap) {
SWAP_32( row_length );
SWAP_32( skip_rows );
SWAP_32( alignment );
SWAP_32( target );
SWAP_32( width );
SWAP_32( format );
SWAP_32( type );
}
return __glXImageSize(format, type, target, width, 1, 1,
image_height, row_length, skip_images,
skip_rows, alignment);
}
int
__glXColorTableParameterfvReqSize( const GLbyte * pc, Bool swap )
{
GLenum pname = * (GLenum *)(pc + 4);
GLsizei compsize;
if (swap) {
SWAP_32( pname );
}
compsize = __glColorTableParameterfv_size(pname);
return __GLX_PAD((compsize * 4));
}
int
__glXColorSubTableReqSize( const GLbyte * pc, Bool swap )
{
GLint row_length = * (GLint *)(pc + 4);
GLint image_height = 0;
GLint skip_images = 0;
GLint skip_rows = * (GLint *)(pc + 8);
GLint alignment = * (GLint *)(pc + 16);
GLenum target = * (GLenum *)(pc + 20);
GLsizei count = *(GLsizei *)(pc + 28);
GLenum format = * (GLenum *)(pc + 32);
GLenum type = * (GLenum *)(pc + 36);
if (swap) {
SWAP_32( row_length );
SWAP_32( skip_rows );
SWAP_32( alignment );
SWAP_32( target );
SWAP_32( count );
SWAP_32( format );
SWAP_32( type );
}
return __glXImageSize(format, type, target, count, 1, 1,
image_height, row_length, skip_images,
skip_rows, alignment);
}
int
__glXConvolutionFilter1DReqSize( const GLbyte * pc, Bool swap )
{
GLint row_length = * (GLint *)(pc + 4);
GLint image_height = 0;
GLint skip_images = 0;
GLint skip_rows = * (GLint *)(pc + 8);
GLint alignment = * (GLint *)(pc + 16);
GLenum target = * (GLenum *)(pc + 20);
GLsizei width = *(GLsizei *)(pc + 28);
GLenum format = * (GLenum *)(pc + 36);
GLenum type = * (GLenum *)(pc + 40);
if (swap) {
SWAP_32( row_length );
SWAP_32( skip_rows );
SWAP_32( alignment );
SWAP_32( target );
SWAP_32( width );
SWAP_32( format );
SWAP_32( type );
}
return __glXImageSize(format, type, target, width, 1, 1,
image_height, row_length, skip_images,
skip_rows, alignment);
}
int
__glXConvolutionFilter2DReqSize( const GLbyte * pc, Bool swap )
{
GLint row_length = * (GLint *)(pc + 4);
GLint image_height = 0;
GLint skip_images = 0;
GLint skip_rows = * (GLint *)(pc + 8);
GLint alignment = * (GLint *)(pc + 16);
GLenum target = * (GLenum *)(pc + 20);
GLsizei width = *(GLsizei *)(pc + 28);
GLsizei height = *(GLsizei *)(pc + 32);
GLenum format = * (GLenum *)(pc + 36);
GLenum type = * (GLenum *)(pc + 40);
if (swap) {
SWAP_32( row_length );
SWAP_32( skip_rows );
SWAP_32( alignment );
SWAP_32( target );
SWAP_32( width );
SWAP_32( height );
SWAP_32( format );
SWAP_32( type );
}
return __glXImageSize(format, type, target, width, height, 1,
image_height, row_length, skip_images,
skip_rows, alignment);
}
int
__glXConvolutionParameterfvReqSize( const GLbyte * pc, Bool swap )
{
GLenum pname = * (GLenum *)(pc + 4);
GLsizei compsize;
if (swap) {
SWAP_32( pname );
}
compsize = __glConvolutionParameterfv_size(pname);
return __GLX_PAD((compsize * 4));
}
int
__glXTexImage3DReqSize( const GLbyte * pc, Bool swap )
{
GLint row_length = * (GLint *)(pc + 4);
GLint image_height = * (GLint *)(pc + 8);
GLint skip_rows = * (GLint *)(pc + 16);
GLint skip_images = * (GLint *)(pc + 20);
GLint alignment = * (GLint *)(pc + 32);
GLenum target = * (GLenum *)(pc + 36);
GLsizei width = *(GLsizei *)(pc + 48);
GLsizei height = *(GLsizei *)(pc + 52);
GLsizei depth = *(GLsizei *)(pc + 56);
GLenum format = * (GLenum *)(pc + 68);
GLenum type = * (GLenum *)(pc + 72);
if (swap) {
SWAP_32( row_length );
SWAP_32( image_height );
SWAP_32( skip_rows );
SWAP_32( skip_images );
SWAP_32( alignment );
SWAP_32( target );
SWAP_32( width );
SWAP_32( height );
SWAP_32( depth );
SWAP_32( format );
SWAP_32( type );
}
return __glXImageSize(format, type, target, width, height, depth,
image_height, row_length, skip_images,
skip_rows, alignment);
}
int
__glXTexSubImage3DReqSize( const GLbyte * pc, Bool swap )
{
GLint row_length = * (GLint *)(pc + 4);
GLint image_height = * (GLint *)(pc + 8);
GLint skip_rows = * (GLint *)(pc + 16);
GLint skip_images = * (GLint *)(pc + 20);
GLint alignment = * (GLint *)(pc + 32);
GLenum target = * (GLenum *)(pc + 36);
GLsizei width = *(GLsizei *)(pc + 60);
GLsizei height = *(GLsizei *)(pc + 64);
GLsizei depth = *(GLsizei *)(pc + 68);
GLenum format = * (GLenum *)(pc + 76);
GLenum type = * (GLenum *)(pc + 80);
if (swap) {
SWAP_32( row_length );
SWAP_32( image_height );
SWAP_32( skip_rows );
SWAP_32( skip_images );
SWAP_32( alignment );
SWAP_32( target );
SWAP_32( width );
SWAP_32( height );
SWAP_32( depth );
SWAP_32( format );
SWAP_32( type );
}
return __glXImageSize(format, type, target, width, height, depth,
image_height, row_length, skip_images,
skip_rows, alignment);
}
int
__glXDrawBuffersARBReqSize( const GLbyte * pc, Bool swap )
{
GLsizei n = *(GLsizei *)(pc + 0);
if (swap) {
SWAP_32( n );
}
return __GLX_PAD((n * 4));
}
int
__glXPointParameterfvEXTReqSize( const GLbyte * pc, Bool swap )
{
GLenum pname = * (GLenum *)(pc + 0);
GLsizei compsize;
if (swap) {
SWAP_32( pname );
}
compsize = __glPointParameterfvEXT_size(pname);
return __GLX_PAD((compsize * 4));
}
int
__glXCompressedTexImage3DARBReqSize( const GLbyte * pc, Bool swap )
{
GLsizei imageSize = *(GLsizei *)(pc + 28);
if (swap) {
SWAP_32( imageSize );
}
return __GLX_PAD(imageSize);
}
int
__glXCompressedTexImage2DARBReqSize( const GLbyte * pc, Bool swap )
{
GLsizei imageSize = *(GLsizei *)(pc + 24);
if (swap) {
SWAP_32( imageSize );
}
return __GLX_PAD(imageSize);
}
int
__glXCompressedTexImage1DARBReqSize( const GLbyte * pc, Bool swap )
{
GLsizei imageSize = *(GLsizei *)(pc + 20);
if (swap) {
SWAP_32( imageSize );
}
return __GLX_PAD(imageSize);
}
int
__glXCompressedTexSubImage3DARBReqSize( const GLbyte * pc, Bool swap )
{
GLsizei imageSize = *(GLsizei *)(pc + 36);
if (swap) {
SWAP_32( imageSize );
}
return __GLX_PAD(imageSize);
}
int
__glXLoadProgramNVReqSize( const GLbyte * pc, Bool swap )
{
GLsizei len = *(GLsizei *)(pc + 8);
if (swap) {
SWAP_32( len );
}
return __GLX_PAD(len);
}
int
__glXProgramParameters4dvNVReqSize( const GLbyte * pc, Bool swap )
{
GLuint num = * (GLuint *)(pc + 8);
if (swap) {
SWAP_32( num );
}
return __GLX_PAD((num * 32));
}
int
__glXProgramParameters4fvNVReqSize( const GLbyte * pc, Bool swap )
{
GLuint num = * (GLuint *)(pc + 8);
if (swap) {
SWAP_32( num );
}
return __GLX_PAD((num * 16));
}
int
__glXVertexAttribs1dvNVReqSize( const GLbyte * pc, Bool swap )
{
GLsizei n = *(GLsizei *)(pc + 4);
if (swap) {
SWAP_32( n );
}
return __GLX_PAD((n * 8));
}
int
__glXVertexAttribs2dvNVReqSize( const GLbyte * pc, Bool swap )
{
GLsizei n = *(GLsizei *)(pc + 4);
if (swap) {
SWAP_32( n );
}
return __GLX_PAD((n * 16));
}
int
__glXVertexAttribs3dvNVReqSize( const GLbyte * pc, Bool swap )
{
GLsizei n = *(GLsizei *)(pc + 4);
if (swap) {
SWAP_32( n );
}
return __GLX_PAD((n * 24));
}
int
__glXVertexAttribs3fvNVReqSize( const GLbyte * pc, Bool swap )
{
GLsizei n = *(GLsizei *)(pc + 4);
if (swap) {
SWAP_32( n );
}
return __GLX_PAD((n * 12));
}
int
__glXVertexAttribs3svNVReqSize( const GLbyte * pc, Bool swap )
{
GLsizei n = *(GLsizei *)(pc + 4);
if (swap) {
SWAP_32( n );
}
return __GLX_PAD((n * 6));
}
int
__glXVertexAttribs4dvNVReqSize( const GLbyte * pc, Bool swap )
{
GLsizei n = *(GLsizei *)(pc + 4);
if (swap) {
SWAP_32( n );
}
return __GLX_PAD((n * 32));
}
int
__glXProgramNamedParameter4fvNVReqSize( const GLbyte * pc, Bool swap )
{
GLsizei len = *(GLsizei *)(pc + 4);
if (swap) {
SWAP_32( len );
}
return __GLX_PAD(len);
}
ALIAS( Fogiv, Fogfv )
ALIAS( Lightiv, Lightfv )
ALIAS( LightModeliv, LightModelfv )
ALIAS( Materialiv, Materialfv )
ALIAS( TexParameteriv, TexParameterfv )
ALIAS( TexEnviv, TexEnvfv )
ALIAS( TexGeniv, TexGenfv )
ALIAS( PixelMapuiv, PixelMapfv )
ALIAS( ColorTableParameteriv, ColorTableParameterfv )
ALIAS( ConvolutionParameteriv, ConvolutionParameterfv )
ALIAS( CompressedTexSubImage2DARB, CompressedTexImage3DARB )
ALIAS( CompressedTexSubImage1DARB, CompressedTexImage1DARB )
ALIAS( RequestResidentProgramsNV, DrawBuffersARB )
ALIAS( VertexAttribs1fvNV, PixelMapfv )
ALIAS( VertexAttribs1svNV, PixelMapusv )
ALIAS( VertexAttribs2fvNV, VertexAttribs1dvNV )
ALIAS( VertexAttribs2svNV, PixelMapfv )
ALIAS( VertexAttribs4fvNV, VertexAttribs2dvNV )
ALIAS( VertexAttribs4svNV, VertexAttribs1dvNV )
ALIAS( VertexAttribs4ubvNV, PixelMapfv )
ALIAS( PointParameterivNV, PointParameterfvEXT )
ALIAS( ProgramStringARB, LoadProgramNV )
ALIAS( ProgramNamedParameter4dvNV, CompressedTexSubImage3DARB )
ALIAS( DeleteRenderbuffersEXT, DrawBuffersARB )
ALIAS( DeleteFramebuffersEXT, DrawBuffersARB )

121
GL/glx/indirect_reqsize.h Normal file
View File

@ -0,0 +1,121 @@
/* DO NOT EDIT - This file generated automatically by glX_proto_size.py (from Mesa) script */
/*
* (C) Copyright IBM Corporation 2005
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sub license,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
* IBM,
* AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#if !defined( _INDIRECT_REQSIZE_H_ )
# define _INDIRECT_REQSIZE_H_
# if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__)
# define HIDDEN __attribute__((visibility("hidden")))
# else
# define HIDDEN
# endif
# if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
# define PURE __attribute__((pure))
# else
# define PURE
# endif
extern PURE HIDDEN int __glXCallListsReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXBitmapReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXFogfvReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXFogivReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXLightfvReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXLightivReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXLightModelfvReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXLightModelivReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXMaterialfvReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXMaterialivReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXPolygonStippleReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXTexParameterfvReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXTexParameterivReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXTexImage1DReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXTexImage2DReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXTexEnvfvReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXTexEnvivReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXTexGendvReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXTexGenfvReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXTexGenivReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXMap1dReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXMap1fReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXMap2dReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXMap2fReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXPixelMapfvReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXPixelMapuivReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXPixelMapusvReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXDrawPixelsReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXDrawArraysReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXPrioritizeTexturesReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXTexSubImage1DReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXTexSubImage2DReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXColorTableReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXColorTableParameterfvReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXColorTableParameterivReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXColorSubTableReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXConvolutionFilter1DReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXConvolutionFilter2DReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXConvolutionParameterfvReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXConvolutionParameterivReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXSeparableFilter2DReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXTexImage3DReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXTexSubImage3DReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXDrawBuffersARBReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXPointParameterfvEXTReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXCompressedTexImage3DARBReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXCompressedTexImage2DARBReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXCompressedTexImage1DARBReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXCompressedTexSubImage3DARBReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXCompressedTexSubImage2DARBReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXCompressedTexSubImage1DARBReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXLoadProgramNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXProgramParameters4dvNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXProgramParameters4fvNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXRequestResidentProgramsNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXVertexAttribs1dvNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXVertexAttribs1fvNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXVertexAttribs1svNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXVertexAttribs2dvNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXVertexAttribs2fvNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXVertexAttribs2svNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXVertexAttribs3dvNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXVertexAttribs3fvNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXVertexAttribs3svNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXVertexAttribs4dvNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXVertexAttribs4fvNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXVertexAttribs4svNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXVertexAttribs4ubvNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXPointParameterivNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXProgramStringARBReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXProgramNamedParameter4fvNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXProgramNamedParameter4dvNVReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXDeleteRenderbuffersEXTReqSize(const GLbyte *pc, Bool swap);
extern PURE HIDDEN int __glXDeleteFramebuffersEXTReqSize(const GLbyte *pc, Bool swap);
# undef HIDDEN
# undef PURE
#endif /* !defined( _INDIRECT_REQSIZE_H_ ) */

1161
GL/glx/indirect_size_get.c Normal file
View File

File diff suppressed because it is too large Load Diff

99
GL/glx/indirect_size_get.h Normal file
View File

@ -0,0 +1,99 @@
/* DO NOT EDIT - This file generated automatically by glX_proto_size.py (from Mesa) script */
/*
* (C) Copyright IBM Corporation 2004
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sub license,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
* IBM,
* AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#if !defined( _INDIRECT_SIZE_GET_H_ )
# define _INDIRECT_SIZE_GET_H_
/**
* \file
* Prototypes for functions used to determine the number of data elements in
* various GLX protocol messages.
*
* \author Ian Romanick <idr@us.ibm.com>
*/
# if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
# define PURE __attribute__((pure))
# else
# define PURE
# endif
# if defined(__i386__) && defined(__GNUC__) && !defined(__CYGWIN__) && !defined(__MINGW32__)
# define FASTCALL __attribute__((fastcall))
# else
# define FASTCALL
# endif
# if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) && defined(__ELF__)
# define INTERNAL __attribute__((visibility("internal")))
# else
# define INTERNAL
# endif
extern INTERNAL PURE FASTCALL GLint __glGetBooleanv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetDoublev_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetFloatv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetIntegerv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetLightfv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetLightiv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetMaterialfv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetMaterialiv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetTexEnvfv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetTexEnviv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetTexGendv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetTexGenfv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetTexGeniv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetTexParameterfv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetTexParameteriv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetTexLevelParameterfv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetTexLevelParameteriv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetColorTableParameterfv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetColorTableParameteriv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetConvolutionParameterfv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetConvolutionParameteriv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetHistogramParameterfv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetHistogramParameteriv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetMinmaxParameterfv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetMinmaxParameteriv_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetProgramivNV_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribdvARB_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribfvARB_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribivARB_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetProgramivARB_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetQueryivARB_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetQueryObjectivARB_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetQueryObjectuivARB_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribdvNV_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribfvNV_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetVertexAttribivNV_size(GLenum);
extern INTERNAL PURE FASTCALL GLint __glGetFramebufferAttachmentParameterivEXT_size(GLenum);
# undef PURE
# undef FASTCALL
# undef INTERNAL
#endif /* !defined( _INDIRECT_SIZE_GET_H_ ) */

192
GL/glx/indirect_util.c Normal file
View File

@ -0,0 +1,192 @@
/*
* (C) Copyright IBM Corporation 2005
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sub license,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
* IBM,
* AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <X11/Xmd.h>
#include <GL/gl.h>
#include <GL/glxproto.h>
#include <byteswap.h>
#include <inttypes.h>
#include "indirect_size.h"
#include "indirect_size_get.h"
#include "indirect_dispatch.h"
#include "glxserver.h"
#include "singlesize.h"
#include "glapitable.h"
#include "glapi.h"
#include "glthread.h"
#include "dispatch.h"
#include "glxext.h"
#include "indirect_util.h"
#define __GLX_PAD(a) (((a)+3)&~3)
extern xGLXSingleReply __glXReply;
GLint
__glGetBooleanv_variable_size( GLenum e )
{
if ( e == GL_COMPRESSED_TEXTURE_FORMATS ) {
GLint temp;
CALL_GetIntegerv( GET_DISPATCH(),
(GL_NUM_COMPRESSED_TEXTURE_FORMATS, & temp) );
return temp;
}
else {
return 0;
}
}
/**
* Get a properly aligned buffer to hold reply data.
*
* \warning
* This function assumes that \c local_buffer is already properly aligned.
* It also assumes that \c alignment is a power of two.
*/
void *
__glXGetAnswerBuffer( __GLXclientState * cl, size_t required_size,
void * local_buffer, size_t local_size, unsigned alignment )
{
void * buffer = local_buffer;
const unsigned mask = alignment - 1;
if ( local_size < required_size ) {
const size_t worst_case_size = required_size + alignment;
intptr_t temp_buf;
if ( cl->returnBufSize < worst_case_size ) {
void * temp = xrealloc( cl->returnBuf, worst_case_size );
if ( temp == NULL ) {
return NULL;
}
cl->returnBuf = temp;
cl->returnBufSize = worst_case_size;
}
temp_buf = (intptr_t) cl->returnBuf;
temp_buf = (temp_buf + mask) & ~mask;
buffer = (void *) temp_buf;
}
return buffer;
}
/**
* Send a GLX reply to the client.
*
* Technically speaking, there are several different ways to encode a GLX
* reply. The primary difference is whether or not certain fields (e.g.,
* retval, size, and "pad3") are set. This function gets around that by
* always setting all of the fields to "reasonable" values. This does no
* harm to clients, but it does make the server-side code much more compact.
*/
void
__glXSendReply( ClientPtr client, const void * data, size_t elements,
size_t element_size, GLboolean always_array, CARD32 retval )
{
size_t reply_ints = 0;
if ( __glXErrorOccured() ) {
elements = 0;
}
else if ( (elements > 1) || always_array ) {
reply_ints = ((elements * element_size) + 3) >> 2;
}
__glXReply.length = reply_ints;
__glXReply.type = X_Reply;
__glXReply.sequenceNumber = client->sequence;
__glXReply.size = elements;
__glXReply.retval = retval;
/* It is faster on almost always every architecture to just copy the 8
* bytes, even when not necessary, than check to see of the value of
* elements requires it. Copying the data when not needed will do no
* harm.
*/
(void) memcpy( & __glXReply.pad3, data, 8 );
WriteToClient( client, sz_xGLXSingleReply, (char *) & __glXReply );
if ( reply_ints != 0 ) {
WriteToClient( client, reply_ints * 4, (char *) data );
}
}
/**
* Send a GLX reply to the client.
*
* Technically speaking, there are several different ways to encode a GLX
* reply. The primary difference is whether or not certain fields (e.g.,
* retval, size, and "pad3") are set. This function gets around that by
* always setting all of the fields to "reasonable" values. This does no
* harm to clients, but it does make the server-side code much more compact.
*
* \warning
* This function assumes that values stored in \c data will be byte-swapped
* by the caller if necessary.
*/
void
__glXSendReplySwap( ClientPtr client, const void * data, size_t elements,
size_t element_size, GLboolean always_array, CARD32 retval )
{
size_t reply_ints = 0;
if ( __glXErrorOccured() ) {
elements = 0;
}
else if ( (elements > 1) || always_array ) {
reply_ints = ((elements * element_size) + 3) >> 2;
}
__glXReply.length = bswap_32( reply_ints );
__glXReply.type = bswap_32( X_Reply );
__glXReply.sequenceNumber = bswap_32( client->sequence );
__glXReply.size = bswap_32( elements );
__glXReply.retval = bswap_32( retval );
/* It is faster on almost always every architecture to just copy the 8
* bytes, even when not necessary, than check to see of the value of
* elements requires it. Copying the data when not needed will do no
* harm.
*/
(void) memcpy( & __glXReply.pad3, data, 8 );
WriteToClient( client, sz_xGLXSingleReply, (char *) & __glXReply );
if ( reply_ints != 0 ) {
WriteToClient( client, reply_ints * 4, (char *) data );
}
}

43
GL/glx/indirect_util.h Normal file
View File

@ -0,0 +1,43 @@
/*
* (C) Copyright IBM Corporation 2005
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sub license,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
* IBM,
* AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#ifndef __GLX_INDIRECT_UTIL_H__
#define __GLX_INDIRECT_UTIL_H__
extern GLint __glGetBooleanv_variable_size( GLenum e );
extern void * __glXGetAnswerBuffer( __GLXclientState * cl,
size_t required_size, void * local_buffer, size_t local_size,
unsigned alignment );
extern void __glXSendReply( ClientPtr client, const void * data,
size_t elements, size_t element_size, GLboolean always_array,
CARD32 retval );
extern void __glXSendReplySwap( ClientPtr client, const void * data,
size_t elements, size_t element_size, GLboolean always_array,
CARD32 retval );
#endif /* __GLX_INDIRECT_UTIL_H__ */

76
GL/glx/render2.c
View File

@ -41,8 +41,12 @@
#include <glxserver.h>
#include "unpack.h"
#include "g_disptab.h"
#include "g_disptab_EXT.h"
#include "indirect_size.h"
#include "indirect_dispatch.h"
#include "glapitable.h"
#include "glapi.h"
#include "glthread.h"
#include "dispatch.h"
void __glXDisp_Map1f(GLbyte *pc)
@ -58,7 +62,7 @@ void __glXDisp_Map1f(GLbyte *pc)
points = (GLfloat *)(pc + 16);
k = __glMap1f_size(target);
glMap1f(target, u1, u2, k, order, points);
CALL_Map1f( GET_DISPATCH(), (target, u1, u2, k, order, points) );
}
void __glXDisp_Map2f(GLbyte *pc)
@ -80,7 +84,7 @@ void __glXDisp_Map2f(GLbyte *pc)
ustride = vorder * k;
vstride = k;
glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
CALL_Map2f( GET_DISPATCH(), (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points) );
}
void __glXDisp_Map1d(GLbyte *pc)
@ -122,7 +126,7 @@ void __glXDisp_Map1d(GLbyte *pc)
#else
points = (GLdouble*) pc;
#endif
glMap1d(target, u1, u2, k, order, points);
CALL_Map1d( GET_DISPATCH(), (target, u1, u2, k, order, points) );
}
void __glXDisp_Map2d(GLbyte *pc)
@ -170,17 +174,7 @@ void __glXDisp_Map2d(GLbyte *pc)
#else
points = (GLdouble*) pc;
#endif
glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}
void __glXDisp_CallLists(GLbyte *pc)
{
GLenum type;
GLsizei n;
type = *(GLenum *)(pc + 4);
n = *(GLsizei *)(pc + 0);
glCallLists(n, type, pc + 8);
CALL_Map2d( GET_DISPATCH(), (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points) );
}
void __glXDisp_DrawArrays(GLbyte *pc)
@ -214,36 +208,36 @@ void __glXDisp_DrawArrays(GLbyte *pc)
switch (component) {
case GL_VERTEX_ARRAY:
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(numVals, datatype, stride, pc);
CALL_EnableClientState( GET_DISPATCH(), (GL_VERTEX_ARRAY) );
CALL_VertexPointer( GET_DISPATCH(), (numVals, datatype, stride, pc) );
break;
case GL_NORMAL_ARRAY:
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(datatype, stride, pc);
CALL_EnableClientState( GET_DISPATCH(), (GL_NORMAL_ARRAY) );
CALL_NormalPointer( GET_DISPATCH(), (datatype, stride, pc) );
break;
case GL_COLOR_ARRAY:
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(numVals, datatype, stride, pc);
CALL_EnableClientState( GET_DISPATCH(), (GL_COLOR_ARRAY) );
CALL_ColorPointer( GET_DISPATCH(), (numVals, datatype, stride, pc) );
break;
case GL_INDEX_ARRAY:
glEnableClientState(GL_INDEX_ARRAY);
glIndexPointer(datatype, stride, pc);
CALL_EnableClientState( GET_DISPATCH(), (GL_INDEX_ARRAY) );
CALL_IndexPointer( GET_DISPATCH(), (datatype, stride, pc) );
break;
case GL_TEXTURE_COORD_ARRAY:
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(numVals, datatype, stride, pc);
CALL_EnableClientState( GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY) );
CALL_TexCoordPointer( GET_DISPATCH(), (numVals, datatype, stride, pc) );
break;
case GL_EDGE_FLAG_ARRAY:
glEnableClientState(GL_EDGE_FLAG_ARRAY);
glEdgeFlagPointer(stride, (const GLboolean *)pc);
CALL_EnableClientState( GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY) );
CALL_EdgeFlagPointer( GET_DISPATCH(), (stride, (const GLboolean *)pc) );
break;
case GL_SECONDARY_COLOR_ARRAY:
glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
glSecondaryColorPointer(numVals, datatype, stride, pc);
CALL_EnableClientState( GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY) );
CALL_SecondaryColorPointerEXT( GET_DISPATCH(), (numVals, datatype, stride, pc) );
break;
case GL_FOG_COORD_ARRAY:
glEnableClientState(GL_FOG_COORD_ARRAY);
glFogCoordPointer(datatype, stride, pc);
CALL_EnableClientState( GET_DISPATCH(), (GL_FOG_COORD_ARRAY) );
CALL_FogCoordPointerEXT( GET_DISPATCH(), (datatype, stride, pc) );
break;
default:
break;
@ -252,17 +246,17 @@ void __glXDisp_DrawArrays(GLbyte *pc)
pc += __GLX_PAD(numVals * __glXTypeSize(datatype));
}
glDrawArrays(primType, 0, numVertexes);
CALL_DrawArrays( GET_DISPATCH(), (primType, 0, numVertexes) );
/* turn off anything we might have turned on */
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_INDEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_EDGE_FLAG_ARRAY);
glDisableClientState(GL_SECONDARY_COLOR_ARRAY);
glDisableClientState(GL_FOG_COORD_ARRAY);
CALL_DisableClientState( GET_DISPATCH(), (GL_VERTEX_ARRAY) );
CALL_DisableClientState( GET_DISPATCH(), (GL_NORMAL_ARRAY) );
CALL_DisableClientState( GET_DISPATCH(), (GL_COLOR_ARRAY) );
CALL_DisableClientState( GET_DISPATCH(), (GL_INDEX_ARRAY) );
CALL_DisableClientState( GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY) );
CALL_DisableClientState( GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY) );
CALL_DisableClientState( GET_DISPATCH(), (GL_SECONDARY_COLOR_ARRAY) );
CALL_DisableClientState( GET_DISPATCH(), (GL_FOG_COORD_ARRAY) );
}
void __glXDisp_DrawArraysEXT(GLbyte *pc)

89
GL/glx/render2swap.c
View File

@ -41,8 +41,12 @@
#include "glxserver.h"
#include "unpack.h"
#include "g_disptab.h"
#include "g_disptab_EXT.h"
#include "indirect_size.h"
#include "indirect_dispatch.h"
#include "glapitable.h"
#include "glapi.h"
#include "glthread.h"
#include "dispatch.h"
void __glXDispSwap_Map1f(GLbyte *pc)
@ -74,7 +78,7 @@ void __glXDispSwap_Map1f(GLbyte *pc)
}
__GLX_SWAP_FLOAT_ARRAY(points, compsize);
glMap1f(target, u1, u2, k, order, points);
CALL_Map1f( GET_DISPATCH(), (target, u1, u2, k, order, points) );
}
void __glXDispSwap_Map2f(GLbyte *pc)
@ -115,7 +119,7 @@ void __glXDispSwap_Map2f(GLbyte *pc)
}
__GLX_SWAP_FLOAT_ARRAY(points, compsize);
glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
CALL_Map2f( GET_DISPATCH(), (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points) );
}
void __glXDispSwap_Map1d(GLbyte *pc)
@ -159,7 +163,7 @@ void __glXDispSwap_Map1d(GLbyte *pc)
#else
points = (GLdouble*) pc;
#endif
glMap1d(target, u1, u2, k, order, points);
CALL_Map1d( GET_DISPATCH(), (target, u1, u2, k, order, points) );
}
void __glXDispSwap_Map2d(GLbyte *pc)
@ -211,42 +215,7 @@ void __glXDispSwap_Map2d(GLbyte *pc)
#else
points = (GLdouble*) pc;
#endif
glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}
void __glXDispSwap_CallLists(GLbyte *pc)
{
GLenum type;
GLsizei n;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
__GLX_SWAP_INT(pc + 4);
__GLX_SWAP_INT(pc + 0);
type = *(GLenum *)(pc + 4);
n = *(GLsizei *)(pc + 0);
switch (type) {
case GL_BYTE:
case GL_UNSIGNED_BYTE:
case GL_2_BYTES:
case GL_3_BYTES:
case GL_4_BYTES:
break;
case GL_SHORT:
case GL_UNSIGNED_SHORT:
__GLX_SWAP_SHORT_ARRAY(pc+8, n);
break;
case GL_INT:
case GL_UNSIGNED_INT:
__GLX_SWAP_INT_ARRAY(pc+8, n);
break;
case GL_FLOAT:
__GLX_SWAP_FLOAT_ARRAY(pc+8, n);
break;
}
glCallLists(n, type, pc+8);
CALL_Map2d( GET_DISPATCH(), (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points) );
}
static void swapArray(GLint numVals, GLenum datatype,
@ -346,28 +315,28 @@ void __glXDispSwap_DrawArrays(GLbyte *pc)
switch (component) {
case GL_VERTEX_ARRAY:
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(numVals, datatype, stride, pc);
CALL_EnableClientState( GET_DISPATCH(), (GL_VERTEX_ARRAY) );
CALL_VertexPointer( GET_DISPATCH(), (numVals, datatype, stride, pc) );
break;
case GL_NORMAL_ARRAY:
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(datatype, stride, pc);
CALL_EnableClientState( GET_DISPATCH(), (GL_NORMAL_ARRAY) );
CALL_NormalPointer( GET_DISPATCH(), (datatype, stride, pc) );
break;
case GL_COLOR_ARRAY:
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(numVals, datatype, stride, pc);
CALL_EnableClientState( GET_DISPATCH(), (GL_COLOR_ARRAY) );
CALL_ColorPointer( GET_DISPATCH(), (numVals, datatype, stride, pc) );
break;
case GL_INDEX_ARRAY:
glEnableClientState(GL_INDEX_ARRAY);
glIndexPointer(datatype, stride, pc);
CALL_EnableClientState( GET_DISPATCH(), (GL_INDEX_ARRAY) );
CALL_IndexPointer( GET_DISPATCH(), (datatype, stride, pc) );
break;
case GL_TEXTURE_COORD_ARRAY:
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(numVals, datatype, stride, pc);
CALL_EnableClientState( GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY) );
CALL_TexCoordPointer( GET_DISPATCH(), (numVals, datatype, stride, pc) );
break;
case GL_EDGE_FLAG_ARRAY:
glEnableClientState(GL_EDGE_FLAG_ARRAY);
glEdgeFlagPointer(stride, (const GLboolean *)pc);
CALL_EnableClientState( GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY) );
CALL_EdgeFlagPointer( GET_DISPATCH(), (stride, (const GLboolean *)pc) );
break;
default:
break;
@ -376,15 +345,15 @@ void __glXDispSwap_DrawArrays(GLbyte *pc)
pc += __GLX_PAD(numVals * __glXTypeSize(datatype));
}
glDrawArrays(primType, 0, numVertexes);
CALL_DrawArrays( GET_DISPATCH(), (primType, 0, numVertexes) );
/* turn off anything we might have turned on */
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_INDEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_EDGE_FLAG_ARRAY);
CALL_DisableClientState( GET_DISPATCH(), (GL_VERTEX_ARRAY) );
CALL_DisableClientState( GET_DISPATCH(), (GL_NORMAL_ARRAY) );
CALL_DisableClientState( GET_DISPATCH(), (GL_COLOR_ARRAY) );
CALL_DisableClientState( GET_DISPATCH(), (GL_INDEX_ARRAY) );
CALL_DisableClientState( GET_DISPATCH(), (GL_TEXTURE_COORD_ARRAY) );
CALL_DisableClientState( GET_DISPATCH(), (GL_EDGE_FLAG_ARRAY) );
}
void __glXDispSwap_DrawArraysEXT(GLbyte *pc)

262
GL/glx/renderpix.c
View File

@ -41,247 +41,11 @@
#include "glxserver.h"
#include "unpack.h"
#include "g_disptab.h"
#include "g_disptab_EXT.h"
void __glXDisp_PolygonStipple(GLbyte *pc)
{
__GLXpixelHeader *hdr = (__GLXpixelHeader *) pc;
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
glPolygonStipple((GLubyte *)(hdr+1));
}
void __glXDisp_Bitmap(GLbyte *pc)
{
__GLXdispatchBitmapHeader *hdr = (__GLXdispatchBitmapHeader *) pc;
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
glBitmap((GLsizei) hdr->width,
(GLsizei) hdr->height,
(GLfloat) hdr->xorig,
(GLfloat) hdr->yorig,
(GLfloat) hdr->xmove,
(GLfloat) hdr->ymove,
(GLubyte *)(hdr+1));
}
void __glXDisp_TexImage1D(GLbyte *pc)
{
__GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;
glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
glTexImage1D(hdr->target,
(GLint) hdr->level,
(GLint) hdr->components,
(GLsizei) hdr->width,
(GLint) hdr->border,
hdr->format,
hdr->type,
(GLvoid *)(hdr+1));
}
void __glXDisp_TexImage2D(GLbyte *pc)
{
__GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;
glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
glTexImage2D(hdr->target,
(GLint) hdr->level,
(GLint) hdr->components,
(GLsizei) hdr->width,
(GLsizei) hdr->height,
(GLint) hdr->border,
hdr->format,
hdr->type,
(GLvoid *)(hdr+1));
}
void __glXDisp_TexImage3D(GLbyte *pc)
{
__GLXdispatchTexImage3DHeader *hdr = (__GLXdispatchTexImage3DHeader *) pc;
glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, hdr->imageHeight);
glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_IMAGES, hdr->skipImages);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
glTexImage3D(hdr->target, hdr->level, hdr->internalformat, hdr->width,
hdr->height, hdr->depth, hdr->border, hdr->format, hdr->type,
(GLvoid *)(hdr+1));
}
void __glXDisp_DrawPixels(GLbyte *pc)
{
__GLXdispatchDrawPixelsHeader *hdr = (__GLXdispatchDrawPixelsHeader *) pc;
glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
glDrawPixels((GLsizei) hdr->width,
(GLsizei) hdr->height,
hdr->format,
hdr->type,
(GLvoid *)(hdr+1));
}
void __glXDisp_TexSubImage1D(GLbyte *pc)
{
__GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;
glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
glTexSubImage1D(hdr->target,
(GLint) hdr->level,
(GLint) hdr->xoffset,
(GLsizei) hdr->width,
hdr->format,
hdr->type,
(GLvoid *)(hdr+1));
}
void __glXDisp_TexSubImage2D(GLbyte *pc)
{
__GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;
glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
glTexSubImage2D(hdr->target,
(GLint) hdr->level,
(GLint) hdr->xoffset,
(GLint) hdr->yoffset,
(GLsizei) hdr->width,
(GLsizei) hdr->height,
hdr->format,
hdr->type,
(GLvoid *)(hdr+1));
}
void __glXDisp_TexSubImage3D(GLbyte *pc)
{
__GLXdispatchTexSubImage3DHeader *hdr =
(__GLXdispatchTexSubImage3DHeader *) pc;
glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, hdr->imageHeight);
glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_IMAGES, hdr->skipImages);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
glTexSubImage3D(hdr->target, hdr->level, hdr->xoffset, hdr->yoffset,
hdr->zoffset, hdr->width, hdr->height, hdr->depth,
hdr->format, hdr->type, (GLvoid *)(hdr+1));
}
void __glXDisp_ColorTable(GLbyte *pc)
{
__GLXdispatchColorTableHeader *hdr =
(__GLXdispatchColorTableHeader *) pc;
glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
glColorTable(hdr->target, hdr->internalformat,
hdr->width, hdr->format, hdr->type,
(GLvoid *)(hdr+1));
}
void __glXDisp_ColorSubTable(GLbyte *pc)
{
__GLXdispatchColorSubTableHeader *hdr =
(__GLXdispatchColorSubTableHeader *) pc;
glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
glColorSubTable(hdr->target, hdr->start, hdr->count, hdr->format,
hdr->type, (GLvoid *)(hdr+1));
}
void __glXDisp_ConvolutionFilter1D(GLbyte *pc)
{
__GLXdispatchConvolutionFilterHeader *hdr =
(__GLXdispatchConvolutionFilterHeader *) pc;
glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
glConvolutionFilter1D(hdr->target, hdr->internalformat,
hdr->width, hdr->format, hdr->type,
(GLvoid *)(hdr+1));
}
void __glXDisp_ConvolutionFilter2D(GLbyte *pc)
{
__GLXdispatchConvolutionFilterHeader *hdr =
(__GLXdispatchConvolutionFilterHeader *) pc;
glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
glConvolutionFilter2D(hdr->target, hdr->internalformat,
hdr->width, hdr->height, hdr->format, hdr->type,
(GLvoid *)(hdr+1));
}
#include "indirect_dispatch.h"
#include "glapitable.h"
#include "glapi.h"
#include "glthread.h"
#include "dispatch.h"
void __glXDisp_SeparableFilter2D(GLbyte *pc)
{
@ -291,12 +55,12 @@ void __glXDisp_SeparableFilter2D(GLbyte *pc)
hdrlen = __GLX_PAD(__GLX_CONV_FILT_CMD_DISPATCH_HDR_SIZE);
glPixelStorei(GL_UNPACK_SWAP_BYTES, hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes) );
CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) );
CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, hdr->rowLength) );
CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, hdr->skipRows) );
CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, hdr->skipPixels) );
CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, hdr->alignment) );
/* XXX check this usage - internal code called
** a version without the packing parameters
@ -306,7 +70,7 @@ void __glXDisp_SeparableFilter2D(GLbyte *pc)
hdr->alignment);
image1len = __GLX_PAD(image1len);
glSeparableFilter2D(hdr->target, hdr->internalformat,
CALL_SeparableFilter2D( GET_DISPATCH(), (hdr->target, hdr->internalformat,
hdr->width, hdr->height, hdr->format, hdr->type,
((GLubyte *)hdr+hdrlen), ((GLubyte *)hdr+hdrlen+image1len));
((GLubyte *)hdr+hdrlen), ((GLubyte *)hdr+hdrlen+image1len)) );
}

487
GL/glx/renderpixswap.c
View File

@ -41,472 +41,11 @@
#include "glxserver.h"
#include "unpack.h"
#include "g_disptab.h"
#include "g_disptab_EXT.h"
void __glXDispSwap_PolygonStipple(GLbyte *pc)
{
__GLXpixelHeader *hdr = (__GLXpixelHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
__GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
__GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *)&hdr->alignment);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
glPolygonStipple((GLubyte *)(hdr+1));
}
void __glXDispSwap_Bitmap(GLbyte *pc)
{
__GLXdispatchBitmapHeader *hdr = (__GLXdispatchBitmapHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
__GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
__GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *)&hdr->alignment);
__GLX_SWAP_INT((GLbyte *)&hdr->width);
__GLX_SWAP_INT((GLbyte *)&hdr->height);
__GLX_SWAP_FLOAT((GLbyte *)&hdr->xorig);
__GLX_SWAP_FLOAT((GLbyte *)&hdr->yorig);
__GLX_SWAP_FLOAT((GLbyte *)&hdr->xmove);
__GLX_SWAP_FLOAT((GLbyte *)&hdr->ymove);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
glBitmap((GLsizei) hdr->width,
(GLsizei) hdr->height,
(GLfloat) hdr->xorig,
(GLfloat) hdr->yorig,
(GLfloat) hdr->xmove,
(GLfloat) hdr->ymove,
(GLubyte *)(hdr+1));
}
void __glXDispSwap_TexImage1D(GLbyte *pc)
{
__GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
__GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
__GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *)&hdr->alignment);
__GLX_SWAP_INT((GLbyte *)&hdr->target);
__GLX_SWAP_INT((GLbyte *)&hdr->level);
__GLX_SWAP_INT((GLbyte *)&hdr->components);
__GLX_SWAP_INT((GLbyte *)&hdr->width);
__GLX_SWAP_INT((GLbyte *)&hdr->height);
__GLX_SWAP_INT((GLbyte *)&hdr->border);
__GLX_SWAP_INT((GLbyte *)&hdr->format);
__GLX_SWAP_INT((GLbyte *)&hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
** the pixel data.
*/
glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
glTexImage1D(hdr->target,
(GLint) hdr->level,
(GLint) hdr->components,
(GLsizei) hdr->width,
(GLint) hdr->border,
hdr->format,
hdr->type,
(GLvoid *)(hdr+1));
}
void __glXDispSwap_TexImage2D(GLbyte *pc)
{
__GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
__GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
__GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *)&hdr->alignment);
__GLX_SWAP_INT((GLbyte *)&hdr->target);
__GLX_SWAP_INT((GLbyte *)&hdr->level);
__GLX_SWAP_INT((GLbyte *)&hdr->components);
__GLX_SWAP_INT((GLbyte *)&hdr->width);
__GLX_SWAP_INT((GLbyte *)&hdr->height);
__GLX_SWAP_INT((GLbyte *)&hdr->border);
__GLX_SWAP_INT((GLbyte *)&hdr->format);
__GLX_SWAP_INT((GLbyte *)&hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
** the pixel data.
*/
glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
glTexImage2D(hdr->target,
(GLint) hdr->level,
(GLint) hdr->components,
(GLsizei) hdr->width,
(GLsizei) hdr->height,
(GLint) hdr->border,
hdr->format,
hdr->type,
(GLvoid *)(hdr+1));
}
void __glXDispSwap_TexImage3D(GLbyte *pc)
{
__GLXdispatchTexImage3DHeader *hdr = (__GLXdispatchTexImage3DHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
__GLX_SWAP_INT((GLbyte *)&hdr->imageHeight);
__GLX_SWAP_INT((GLbyte *)&hdr->imageDepth);
__GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
__GLX_SWAP_INT((GLbyte *)&hdr->skipImages);
__GLX_SWAP_INT((GLbyte *)&hdr->skipVolumes);
__GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *)&hdr->alignment);
__GLX_SWAP_INT((GLbyte *)&hdr->target);
__GLX_SWAP_INT((GLbyte *)&hdr->level);
__GLX_SWAP_INT((GLbyte *)&hdr->internalformat);
__GLX_SWAP_INT((GLbyte *)&hdr->width);
__GLX_SWAP_INT((GLbyte *)&hdr->height);
__GLX_SWAP_INT((GLbyte *)&hdr->depth);
__GLX_SWAP_INT((GLbyte *)&hdr->size4d);
__GLX_SWAP_INT((GLbyte *)&hdr->border);
__GLX_SWAP_INT((GLbyte *)&hdr->format);
__GLX_SWAP_INT((GLbyte *)&hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
** the pixel data.
*/
glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, hdr->imageHeight);
glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_IMAGES, hdr->skipImages);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
glTexImage3D(hdr->target, hdr->level, hdr->internalformat, hdr->width,
hdr->height, hdr->depth, hdr->border, hdr->format, hdr->type,
(GLvoid *)(hdr+1));
}
void __glXDispSwap_DrawPixels(GLbyte *pc)
{
__GLXdispatchDrawPixelsHeader *hdr = (__GLXdispatchDrawPixelsHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
__GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
__GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *)&hdr->alignment);
__GLX_SWAP_INT((GLbyte *)&hdr->width);
__GLX_SWAP_INT((GLbyte *)&hdr->height);
__GLX_SWAP_INT((GLbyte *)&hdr->format);
__GLX_SWAP_INT((GLbyte *)&hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
** the pixel data.
*/
glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
glDrawPixels((GLsizei) hdr->width,
(GLsizei) hdr->height,
hdr->format,
hdr->type,
(GLvoid *)(hdr+1));
}
void __glXDispSwap_TexSubImage1D(GLbyte *pc)
{
__GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
__GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
__GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *)&hdr->alignment);
__GLX_SWAP_INT((GLbyte *)&hdr->target);
__GLX_SWAP_INT((GLbyte *)&hdr->level);
__GLX_SWAP_INT((GLbyte *)&hdr->xoffset);
__GLX_SWAP_INT((GLbyte *)&hdr->width);
__GLX_SWAP_INT((GLbyte *)&hdr->format);
__GLX_SWAP_INT((GLbyte *)&hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
** the pixel data.
*/
glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
glTexSubImage1D(hdr->target,
(GLint) hdr->level,
(GLint) hdr->xoffset,
(GLsizei) hdr->width,
hdr->format,
hdr->type,
(GLvoid *)(hdr+1));
}
void __glXDispSwap_TexSubImage2D(GLbyte *pc)
{
__GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
__GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
__GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *)&hdr->alignment);
__GLX_SWAP_INT((GLbyte *)&hdr->target);
__GLX_SWAP_INT((GLbyte *)&hdr->level);
__GLX_SWAP_INT((GLbyte *)&hdr->xoffset);
__GLX_SWAP_INT((GLbyte *)&hdr->yoffset);
__GLX_SWAP_INT((GLbyte *)&hdr->width);
__GLX_SWAP_INT((GLbyte *)&hdr->height);
__GLX_SWAP_INT((GLbyte *)&hdr->format);
__GLX_SWAP_INT((GLbyte *)&hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
** the pixel data.
*/
glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint) hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, (GLint) hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, (GLint) hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, (GLint) hdr->alignment);
glTexSubImage2D(hdr->target,
(GLint) hdr->level,
(GLint) hdr->xoffset,
(GLint) hdr->yoffset,
(GLsizei) hdr->width,
(GLsizei) hdr->height,
hdr->format,
hdr->type,
(GLvoid *)(hdr+1));
}
void __glXDispSwap_TexSubImage3D(GLbyte *pc)
{
__GLXdispatchTexSubImage3DHeader *hdr =
(__GLXdispatchTexSubImage3DHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
__GLX_SWAP_INT((GLbyte *)&hdr->imageHeight);
__GLX_SWAP_INT((GLbyte *)&hdr->imageDepth);
__GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
__GLX_SWAP_INT((GLbyte *)&hdr->skipImages);
__GLX_SWAP_INT((GLbyte *)&hdr->skipVolumes);
__GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *)&hdr->alignment);
__GLX_SWAP_INT((GLbyte *)&hdr->target);
__GLX_SWAP_INT((GLbyte *)&hdr->level);
__GLX_SWAP_INT((GLbyte *)&hdr->xoffset);
__GLX_SWAP_INT((GLbyte *)&hdr->yoffset);
__GLX_SWAP_INT((GLbyte *)&hdr->zoffset);
__GLX_SWAP_INT((GLbyte *)&hdr->width);
__GLX_SWAP_INT((GLbyte *)&hdr->height);
__GLX_SWAP_INT((GLbyte *)&hdr->depth);
__GLX_SWAP_INT((GLbyte *)&hdr->size4d);
__GLX_SWAP_INT((GLbyte *)&hdr->format);
__GLX_SWAP_INT((GLbyte *)&hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
** the pixel data.
*/
glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, hdr->imageHeight);
glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_IMAGES, hdr->skipImages);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
glTexSubImage3D(hdr->target, hdr->level, hdr->xoffset, hdr->yoffset,
hdr->zoffset, hdr->width, hdr->height, hdr->depth,
hdr->format, hdr->type, (GLvoid *)(hdr+1));
}
void __glXDispSwap_ColorTable(GLbyte *pc)
{
__GLXdispatchColorTableHeader *hdr =
(__GLXdispatchColorTableHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
__GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
__GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *)&hdr->alignment);
__GLX_SWAP_INT((GLbyte *)&hdr->target);
__GLX_SWAP_INT((GLbyte *)&hdr->internalformat);
__GLX_SWAP_INT((GLbyte *)&hdr->width);
__GLX_SWAP_INT((GLbyte *)&hdr->format);
__GLX_SWAP_INT((GLbyte *)&hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
** the pixel data.
*/
glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
glColorTable(hdr->target, hdr->internalformat,
hdr->width, hdr->format, hdr->type,
(GLvoid *)(hdr+1));
}
void __glXDispSwap_ColorSubTable(GLbyte *pc)
{
__GLXdispatchColorSubTableHeader *hdr =
(__GLXdispatchColorSubTableHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
__GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
__GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *)&hdr->alignment);
__GLX_SWAP_INT((GLbyte *)&hdr->target);
__GLX_SWAP_INT((GLbyte *)&hdr->start);
__GLX_SWAP_INT((GLbyte *)&hdr->count);
__GLX_SWAP_INT((GLbyte *)&hdr->format);
__GLX_SWAP_INT((GLbyte *)&hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
** the pixel data.
*/
glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
glColorSubTable(hdr->target, hdr->start, hdr->count, hdr->format,
hdr->type, (GLvoid *)(hdr+1));
}
void __glXDispSwap_ConvolutionFilter1D(GLbyte *pc)
{
__GLXdispatchConvolutionFilterHeader *hdr =
(__GLXdispatchConvolutionFilterHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
__GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
__GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *)&hdr->alignment);
__GLX_SWAP_INT((GLbyte *)&hdr->target);
__GLX_SWAP_INT((GLbyte *)&hdr->internalformat);
__GLX_SWAP_INT((GLbyte *)&hdr->width);
__GLX_SWAP_INT((GLbyte *)&hdr->format);
__GLX_SWAP_INT((GLbyte *)&hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
** the pixel data.
*/
glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
glConvolutionFilter2D(hdr->target, hdr->internalformat,
hdr->width, 1, hdr->format, hdr->type,
(GLvoid *)(hdr+1));
}
void __glXDispSwap_ConvolutionFilter2D(GLbyte *pc)
{
__GLXdispatchConvolutionFilterHeader *hdr =
(__GLXdispatchConvolutionFilterHeader *) pc;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_SWAP_INT((GLbyte *)&hdr->rowLength);
__GLX_SWAP_INT((GLbyte *)&hdr->skipRows);
__GLX_SWAP_INT((GLbyte *)&hdr->skipPixels);
__GLX_SWAP_INT((GLbyte *)&hdr->alignment);
__GLX_SWAP_INT((GLbyte *)&hdr->target);
__GLX_SWAP_INT((GLbyte *)&hdr->internalformat);
__GLX_SWAP_INT((GLbyte *)&hdr->width);
__GLX_SWAP_INT((GLbyte *)&hdr->height);
__GLX_SWAP_INT((GLbyte *)&hdr->format);
__GLX_SWAP_INT((GLbyte *)&hdr->type);
/*
** Just invert swapBytes flag; the GL will figure out if it needs to swap
** the pixel data.
*/
glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
glConvolutionFilter2D(hdr->target, hdr->internalformat,
hdr->width, hdr->height, hdr->format, hdr->type,
(GLvoid *)(hdr+1));
}
#include "indirect_dispatch.h"
#include "glapitable.h"
#include "glapi.h"
#include "glthread.h"
#include "dispatch.h"
void __glXDispSwap_SeparableFilter2D(GLbyte *pc)
{
@ -533,12 +72,12 @@ void __glXDispSwap_SeparableFilter2D(GLbyte *pc)
** Just invert swapBytes flag; the GL will figure out if it needs to swap
** the pixel data.
*/
glPixelStorei(GL_UNPACK_SWAP_BYTES, !hdr->swapBytes);
glPixelStorei(GL_UNPACK_LSB_FIRST, hdr->lsbFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, hdr->rowLength);
glPixelStorei(GL_UNPACK_SKIP_ROWS, hdr->skipRows);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, hdr->skipPixels);
glPixelStorei(GL_UNPACK_ALIGNMENT, hdr->alignment);
CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, !hdr->swapBytes) );
CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) );
CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, hdr->rowLength) );
CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, hdr->skipRows) );
CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, hdr->skipPixels) );
CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, hdr->alignment) );
/* XXX check this usage - internal code called
** a version without the packing parameters
@ -549,7 +88,7 @@ void __glXDispSwap_SeparableFilter2D(GLbyte *pc)
image1len = __GLX_PAD(image1len);
glSeparableFilter2D(hdr->target, hdr->internalformat,
CALL_SeparableFilter2D( GET_DISPATCH(), (hdr->target, hdr->internalformat,
hdr->width, hdr->height, hdr->format, hdr->type,
((GLubyte *)hdr+hdrlen), ((GLubyte *)hdr+hdrlen+image1len));
((GLubyte *)hdr+hdrlen), ((GLubyte *)hdr+hdrlen+image1len)) );
}

579
GL/glx/rensize.c
View File

@ -42,138 +42,20 @@
#include "glxserver.h"
#include "GL/glxproto.h"
#include "unpack.h"
#include "impsize.h"
#include "indirect_size.h"
#include "indirect_reqsize.h"
#define SWAPL(a) \
(((a & 0xff000000U)>>24) | ((a & 0xff0000U)>>8) | \
((a & 0xff00U)<<8) | ((a & 0xffU)<<24))
int __glXCallListsReqSize(GLbyte *pc, Bool swap )
{
GLsizei n = *(GLsizei *)(pc + 0);
GLenum type = *(GLenum *)(pc + 4);
if (swap) {
n = SWAPL( n );
type = SWAPL( type );
}
return n * __glCallLists_size( type );
}
int __glXFogivReqSize(GLbyte *pc, Bool swap )
{
GLenum pname = *(GLenum *)(pc + 0);
if (swap) {
pname = SWAPL( pname );
}
return 4 * __glFogiv_size( pname ); /* defined in samplegl lib */
}
int __glXFogfvReqSize(GLbyte *pc, Bool swap )
{
return __glXFogivReqSize( pc, swap );
}
int __glXLightfvReqSize(GLbyte *pc, Bool swap )
{
GLenum pname = *(GLenum *)(pc + 4);
if (swap) {
pname = SWAPL( pname );
}
return 4 * __glLightfv_size( pname ); /* defined in samplegl lib */
}
int __glXLightivReqSize(GLbyte *pc, Bool swap )
{
return __glXLightfvReqSize( pc, swap );
}
int __glXLightModelfvReqSize(GLbyte *pc, Bool swap )
{
GLenum pname = *(GLenum *)(pc + 0);
if (swap) {
pname = SWAPL( pname );
}
return 4 * __glLightModelfv_size( pname ); /* defined in samplegl lib */
}
int __glXLightModelivReqSize(GLbyte *pc, Bool swap )
{
return __glXLightModelfvReqSize( pc, swap );
}
int __glXMaterialfvReqSize(GLbyte *pc, Bool swap )
{
GLenum pname = *(GLenum *)(pc + 4);
if (swap) {
pname = SWAPL( pname );
}
return 4 * __glMaterialfv_size( pname ); /* defined in samplegl lib */
}
int __glXMaterialivReqSize(GLbyte *pc, Bool swap )
{
return __glXMaterialfvReqSize( pc, swap );
}
int __glXTexGendvReqSize(GLbyte *pc, Bool swap )
{
GLenum pname = *(GLenum *)(pc + 4);
if (swap) {
pname = SWAPL( pname );
}
return 8 * __glTexGendv_size( pname ); /* defined in samplegl lib */
}
int __glXTexGenfvReqSize(GLbyte *pc, Bool swap )
{
GLenum pname = *(GLenum *)(pc + 4);
if (swap) {
pname = SWAPL( pname );
}
return 4 * __glTexGenfv_size( pname ); /* defined in samplegl lib */
}
int __glXTexGenivReqSize(GLbyte *pc, Bool swap )
{
return __glXTexGenfvReqSize( pc, swap );
}
int __glXTexParameterfvReqSize(GLbyte *pc, Bool swap )
{
GLenum pname = *(GLenum *)(pc + 4);
if (swap) {
pname = SWAPL( pname );
}
return 4 * __glTexParameterfv_size( pname ); /* defined in samplegl lib */
}
int __glXTexParameterivReqSize(GLbyte *pc, Bool swap )
{
return __glXTexParameterfvReqSize( pc, swap );
}
int __glXTexEnvfvReqSize(GLbyte *pc, Bool swap )
{
GLenum pname = *(GLenum *)(pc + 4);
if (swap) {
pname = SWAPL( pname );
}
return 4 * __glTexEnvfv_size( pname ); /* defined in samplegl lib */
}
int __glXTexEnvivReqSize(GLbyte *pc, Bool swap )
{
return __glXTexEnvfvReqSize( pc, swap );
}
static int Map1Size( GLint k, GLint order)
{
if (order <= 0 || k < 0) return -1;
return k * order;
}
int __glXMap1dReqSize(GLbyte *pc, Bool swap )
int __glXMap1dReqSize( const GLbyte *pc, Bool swap )
{
GLenum target;
GLint order, k;
@ -188,7 +70,7 @@ int __glXMap1dReqSize(GLbyte *pc, Bool swap )
return 8 * Map1Size( k, order );
}
int __glXMap1fReqSize(GLbyte *pc, Bool swap )
int __glXMap1fReqSize( const GLbyte *pc, Bool swap )
{
GLenum target;
GLint order, k;
@ -209,7 +91,7 @@ static int Map2Size(int k, int majorOrder, int minorOrder)
return k * majorOrder * minorOrder;
}
int __glXMap2dReqSize(GLbyte *pc, Bool swap )
int __glXMap2dReqSize( const GLbyte *pc, Bool swap )
{
GLenum target;
GLint uorder, vorder, k;
@ -226,7 +108,7 @@ int __glXMap2dReqSize(GLbyte *pc, Bool swap )
return 8 * Map2Size( k, uorder, vorder );
}
int __glXMap2fReqSize(GLbyte *pc, Bool swap )
int __glXMap2fReqSize( const GLbyte *pc, Bool swap )
{
GLenum target;
GLint uorder, vorder, k;
@ -243,31 +125,6 @@ int __glXMap2fReqSize(GLbyte *pc, Bool swap )
return 4 * Map2Size( k, uorder, vorder );
}
int __glXPixelMapfvReqSize(GLbyte *pc, Bool swap )
{
GLint mapsize;
mapsize = *(GLint *)(pc + 4);
if (swap) {
mapsize = SWAPL( mapsize );
}
return 4 * mapsize;
}
int __glXPixelMapuivReqSize(GLbyte *pc, Bool swap )
{
return __glXPixelMapfvReqSize( pc, swap );
}
int __glXPixelMapusvReqSize(GLbyte *pc, Bool swap )
{
GLint mapsize;
mapsize = *(GLint *)(pc + 4);
if (swap) {
mapsize = SWAPL( mapsize );
}
return 2 * mapsize;
}
/**
* Calculate the size of an image.
*
@ -451,110 +308,6 @@ int __glXImageSize( GLenum format, GLenum type, GLenum target,
}
int __glXDrawPixelsReqSize(GLbyte *pc, Bool swap )
{
__GLXdispatchDrawPixelsHeader *hdr = (__GLXdispatchDrawPixelsHeader *) pc;
GLenum format = hdr->format;
GLenum type = hdr->type;
GLint w = hdr->width;
GLint h = hdr->height;
GLint rowLength = hdr->rowLength;
GLint skipRows = hdr->skipRows;
GLint alignment = hdr->alignment;
if (swap) {
format = SWAPL( format );
type = SWAPL( type );
w = SWAPL( w );
h = SWAPL( h );
rowLength = SWAPL( rowLength );
skipRows = SWAPL( skipRows );
alignment = SWAPL( alignment );
}
return __glXImageSize( format, type, 0, w, h, 1,
0, rowLength, 0, skipRows, alignment );
}
int __glXBitmapReqSize(GLbyte *pc, Bool swap )
{
__GLXdispatchBitmapHeader *hdr = (__GLXdispatchBitmapHeader *) pc;
GLint w = hdr->width;
GLint h = hdr->height;
GLint rowLength = hdr->rowLength;
GLint skipRows = hdr->skipRows;
GLint alignment = hdr->alignment;
if (swap) {
w = SWAPL( w );
h = SWAPL( h );
rowLength = SWAPL( rowLength );
skipRows = SWAPL( skipRows );
alignment = SWAPL( alignment );
}
return __glXImageSize( GL_COLOR_INDEX, GL_BITMAP, 0, w, h, 1,
0, rowLength, 0, skipRows, alignment );
}
int __glXTexImage1DReqSize(GLbyte *pc, Bool swap )
{
__GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;
GLenum target = hdr->target;
GLenum format = hdr->format;
GLenum type = hdr->type;
GLint w = hdr->width;
GLint rowLength = hdr->rowLength;
GLint skipRows = hdr->skipRows;
GLint alignment = hdr->alignment;
if (swap) {
target = SWAPL( target );
format = SWAPL( format );
type = SWAPL( type );
w = SWAPL( w );
rowLength = SWAPL( rowLength );
skipRows = SWAPL( skipRows );
alignment = SWAPL( alignment );
}
if (target == GL_PROXY_TEXTURE_1D) {
return 0;
} else if (format == GL_STENCIL_INDEX || format == GL_DEPTH_COMPONENT) {
return -1;
}
return __glXImageSize( format, type, 0, w, 1, 1,
0, rowLength, 0, skipRows, alignment );
}
int __glXTexImage2DReqSize(GLbyte *pc, Bool swap )
{
__GLXdispatchTexImageHeader *hdr = (__GLXdispatchTexImageHeader *) pc;
GLenum target = hdr->target;
GLenum format = hdr->format;
GLenum type = hdr->type;
GLint w = hdr->width;
GLint h = hdr->height;
GLint rowLength = hdr->rowLength;
GLint skipRows = hdr->skipRows;
GLint alignment = hdr->alignment;
if (swap) {
target = SWAPL( target );
format = SWAPL( format );
type = SWAPL( type );
w = SWAPL( w );
h = SWAPL( h );
rowLength = SWAPL( rowLength );
skipRows = SWAPL( skipRows );
alignment = SWAPL( alignment );
}
if (target == GL_PROXY_TEXTURE_2D || target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) {
return 0;
} else if (format == GL_STENCIL_INDEX || format == GL_DEPTH_COMPONENT) {
return -1;
}
return __glXImageSize( format, type, 0, w, h, 1,
0, rowLength, 0, skipRows, alignment );
}
/* XXX this is used elsewhere - should it be exported from glxserver.h? */
int __glXTypeSize(GLenum enm)
{
@ -571,7 +324,7 @@ int __glXTypeSize(GLenum enm)
}
}
int __glXDrawArraysSize( GLbyte *pc, Bool swap )
int __glXDrawArraysSize( const GLbyte *pc, Bool swap )
{
__GLXdispatchDrawArraysHeader *hdr = (__GLXdispatchDrawArraysHeader *) pc;
__GLXdispatchDrawArraysComponentHeader *compHeader;
@ -638,217 +391,7 @@ int __glXDrawArraysSize( GLbyte *pc, Bool swap )
(numVertexes * arrayElementSize));
}
int __glXPrioritizeTexturesReqSize(GLbyte *pc, Bool swap )
{
GLint n = *(GLsizei *)(pc + 0);
if (swap) n = SWAPL(n);
return(8*n); /* 4*n for textures, 4*n for priorities */
}
int __glXTexSubImage1DReqSize(GLbyte *pc, Bool swap )
{
__GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;
GLenum format = hdr->format;
GLenum type = hdr->type;
GLint w = hdr->width;
GLint rowLength = hdr->rowLength;
GLint skipRows = hdr->skipRows;
GLint alignment = hdr->alignment;
if (swap) {
format = SWAPL( format );
type = SWAPL( type );
w = SWAPL( w );
rowLength = SWAPL( rowLength );
skipRows = SWAPL( skipRows );
alignment = SWAPL( alignment );
}
return __glXImageSize( format, type, 0, w, 1, 1,
0, rowLength, 0, skipRows, alignment );
}
int __glXTexSubImage2DReqSize(GLbyte *pc, Bool swap )
{
__GLXdispatchTexSubImageHeader *hdr = (__GLXdispatchTexSubImageHeader *) pc;
GLenum format = hdr->format;
GLenum type = hdr->type;
GLint w = hdr->width;
GLint h = hdr->height;
GLint rowLength = hdr->rowLength;
GLint skipRows = hdr->skipRows;
GLint alignment = hdr->alignment;
if (swap) {
format = SWAPL( format );
type = SWAPL( type );
w = SWAPL( w );
h = SWAPL( h );
rowLength = SWAPL( rowLength );
skipRows = SWAPL( skipRows );
alignment = SWAPL( alignment );
}
return __glXImageSize( format, type, 0, w, h, 1,
0, rowLength, 0, skipRows, alignment );
}
int __glXTexImage3DReqSize(GLbyte *pc, Bool swap )
{
__GLXdispatchTexImage3DHeader *hdr = (__GLXdispatchTexImage3DHeader *) pc;
GLenum target = hdr->target;
GLenum format = hdr->format;
GLenum type = hdr->type;
GLint w = hdr->width;
GLint h = hdr->height;
GLint d = hdr->depth;
GLint imageHeight = hdr->imageHeight;
GLint rowLength = hdr->rowLength;
GLint skipImages = hdr->skipImages;
GLint skipRows = hdr->skipRows;
GLint alignment = hdr->alignment;
GLint nullImage = hdr->nullimage;
if (swap) {
target = SWAPL( target );
format = SWAPL( format );
type = SWAPL( type );
w = SWAPL( w );
h = SWAPL( h );
d = SWAPL( d );
imageHeight = SWAPL( imageHeight );
rowLength = SWAPL( rowLength );
skipImages = SWAPL( skipImages );
skipRows = SWAPL( skipRows );
alignment = SWAPL( alignment );
}
if (target == GL_PROXY_TEXTURE_3D || nullImage) {
return 0;
} else {
return __glXImageSize( format, type, target, w, h, d, imageHeight,
rowLength, skipImages, skipRows, alignment );
}
}
int __glXTexSubImage3DReqSize(GLbyte *pc, Bool swap )
{
__GLXdispatchTexSubImage3DHeader *hdr =
(__GLXdispatchTexSubImage3DHeader *) pc;
GLenum target = hdr->target;
GLenum format = hdr->format;
GLenum type = hdr->type;
GLint w = hdr->width;
GLint h = hdr->height;
GLint d = hdr->depth;
GLint imageHeight = hdr->imageHeight;
GLint rowLength = hdr->rowLength;
GLint skipImages = hdr->skipImages;
GLint skipRows = hdr->skipRows;
GLint alignment = hdr->alignment;
if (swap) {
target = SWAPL( target );
format = SWAPL( format );
type = SWAPL( type );
w = SWAPL( w );
h = SWAPL( h );
d = SWAPL( d );
imageHeight = SWAPL( imageHeight );
rowLength = SWAPL( rowLength );
skipImages = SWAPL( skipImages );
skipRows = SWAPL( skipRows );
alignment = SWAPL( alignment );
}
if (target == GL_PROXY_TEXTURE_3D) {
return 0;
} else {
return __glXImageSize( format, type, target, w, h, d, imageHeight,
rowLength, skipImages, skipRows, alignment );
}
}
int __glXConvolutionFilter1DReqSize(GLbyte *pc, Bool swap )
{
__GLXdispatchConvolutionFilterHeader *hdr =
(__GLXdispatchConvolutionFilterHeader *) pc;
GLenum format = hdr->format;
GLenum type = hdr->type;
GLint w = hdr->width;
GLint rowLength = hdr->rowLength;
GLint alignment = hdr->alignment;
if (swap) {
format = SWAPL( format );
type = SWAPL( type );
w = SWAPL( w );
rowLength = SWAPL( rowLength );
alignment = SWAPL( alignment );
}
return __glXImageSize( format, type, 0, w, 1, 1,
0, rowLength, 0, 0, alignment );
}
int __glXConvolutionFilter2DReqSize(GLbyte *pc, Bool swap )
{
__GLXdispatchConvolutionFilterHeader *hdr =
(__GLXdispatchConvolutionFilterHeader *) pc;
GLenum format = hdr->format;
GLenum type = hdr->type;
GLint w = hdr->width;
GLint h = hdr->height;
GLint rowLength = hdr->rowLength;
GLint skipRows = hdr->skipRows;
GLint alignment = hdr->alignment;
if (swap) {
format = SWAPL( format );
type = SWAPL( type );
w = SWAPL( w );
h = SWAPL( h );
rowLength = SWAPL( rowLength );
skipRows = SWAPL( skipRows );
alignment = SWAPL( alignment );
}
return __glXImageSize( format, type, 0, w, h, 1,
0, rowLength, 0, skipRows, alignment );
}
int __glXConvolutionParameterivSize(GLenum pname)
{
switch (pname) {
case GL_CONVOLUTION_BORDER_COLOR:
case GL_CONVOLUTION_FILTER_SCALE:
case GL_CONVOLUTION_FILTER_BIAS:
return 4;
case GL_CONVOLUTION_BORDER_MODE:
return 1;
default:
return -1;
}
}
int __glXConvolutionParameterfvSize(GLenum pname)
{
return __glXConvolutionParameterivSize(pname);
}
int __glXConvolutionParameterivReqSize(GLbyte *pc, Bool swap )
{
GLenum pname = *(GLenum *)(pc + 4);
if (swap) {
pname = SWAPL( pname );
}
return 4 * __glXConvolutionParameterivSize( pname );
}
int __glXConvolutionParameterfvReqSize(GLbyte *pc, Bool swap )
{
return __glXConvolutionParameterivReqSize( pc, swap );
}
int __glXSeparableFilter2DReqSize(GLbyte *pc, Bool swap )
int __glXSeparableFilter2DReqSize( const GLbyte *pc, Bool swap )
{
__GLXdispatchConvolutionFilterHeader *hdr =
(__GLXdispatchConvolutionFilterHeader *) pc;
@ -879,109 +422,3 @@ int __glXSeparableFilter2DReqSize(GLbyte *pc, Bool swap )
return image1size + image2size;
}
int __glXColorTableParameterfvSize(GLenum pname)
{
/* currently, only scale and bias are supported; return RGBA */
switch(pname) {
case GL_COLOR_TABLE_SCALE:
case GL_COLOR_TABLE_BIAS:
return 4;
default:
return 0;
}
}
int __glXColorTableParameterivSize(GLenum pname)
{
/* fv and iv are the same in this context */
return __glXColorTableParameterfvSize(pname);
}
int __glXColorTableReqSize(GLbyte *pc, Bool swap )
{
__GLXdispatchColorTableHeader *hdr =
(__GLXdispatchColorTableHeader *) pc;
GLenum target = hdr->target;
GLenum format = hdr->format;
GLenum type = hdr->type;
GLint w = hdr->width;
GLint rowLength = hdr->rowLength;
GLint alignment = hdr->alignment;
switch (target) {
case GL_PROXY_TEXTURE_1D:
case GL_PROXY_TEXTURE_2D:
case GL_PROXY_TEXTURE_3D:
case GL_PROXY_COLOR_TABLE:
case GL_PROXY_POST_CONVOLUTION_COLOR_TABLE:
case GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE:
case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
return 0;
}
if (swap) {
format = SWAPL( format );
type = SWAPL( type );
w = SWAPL( w );
rowLength = SWAPL( rowLength );
alignment = SWAPL( alignment );
}
return __glXImageSize( format, type, 0, w, 1, 1,
0, rowLength, 0, 0, alignment );
}
int __glXColorSubTableReqSize(GLbyte *pc, Bool swap )
{
__GLXdispatchColorSubTableHeader *hdr =
(__GLXdispatchColorSubTableHeader *) pc;
GLenum format = hdr->format;
GLenum type = hdr->type;
GLint count = hdr->count;
GLint rowLength = hdr->rowLength;
GLint alignment = hdr->alignment;
if (swap) {
format = SWAPL( format );
type = SWAPL( type );
count = SWAPL( count );
rowLength = SWAPL( rowLength );
alignment = SWAPL( alignment );
}
return __glXImageSize( format, type, 0, count, 1, 1,
0, rowLength, 0, 0, alignment );
}
int __glXColorTableParameterfvReqSize(GLbyte *pc, Bool swap )
{
GLenum pname = *(GLenum *)(pc + 4);
if (swap) {
pname = SWAPL( pname );
}
return 4 * __glXColorTableParameterfvSize(pname);
}
int __glXColorTableParameterivReqSize(GLbyte *pc, Bool swap )
{
/* no difference between fv and iv versions */
return __glXColorTableParameterfvReqSize(pc, swap);
}
int __glXPointParameterfvARBReqSize(GLbyte *pc, Bool swap )
{
GLenum pname = *(GLenum *)(pc + 0);
if (swap) {
pname = SWAPL( pname );
}
return 4 * __glPointParameterfvEXT_size( pname );
}
int __glXPointParameterivReqSize(GLbyte *pc, Bool swap )
{
/* no difference between fv and iv versions */
return __glXPointParameterfvARBReqSize(pc, swap);
}

11
GL/glx/rensizetab.c
View File

@ -39,6 +39,7 @@
#endif
#include "glxserver.h"
#include "indirect_reqsize.h"
#include "g_disptab_EXT.h"
__GLXrenderSizeData __glXRenderSizeTable[__GLX_MAX_RENDER_OPCODE_EXT - __GLX_MIN_RENDER_OPCODE_EXT + 1] = {
@ -272,7 +273,7 @@ __GLXrenderSizeData __glXRenderSizeTable[__GLX_MAX_RENDER_OPCODE_EXT - __GLX_MIN
/* no such opcode */ { 0, 0 },
/* no such opcode */ { 0, 0 },
/* no such opcode */ { 0, 0 },
/* WindowPos3fARB 230 */ { 16, 0 },
/* WindowPos3fvMESA 230 */ { 16, 0 },
};
__GLXrenderSizeData __glXRenderSizeTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT - __GLX_MIN_RENDER_OPCODE_EXT + 1] = {
/* ColorTable 2053 */ { 44, __glXColorTableReqSize },
@ -287,8 +288,8 @@ __GLXrenderSizeData __glXRenderSizeTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT - __GLX
/* no such opcode */ { 0, 0 },
/* no such opcode */ { 0, 0 },
/* no such opcode */ { 0, 0 },
/* PointParameterfARB 2065 */ { 12, 0 },
/* PointParameterfvARB 2066 */ { 8, __glXPointParameterfvARBReqSize },
/* PointParameterfEXT 2065 */ { 12, 0 },
/* PointParameterfvEXT 2066 */ { 8, __glXPointParameterfvEXTReqSize },
/* no such opcode */ { 0, 0 },
/* no such opcode */ { 0, 0 },
/* no such opcode */ { 0, 0 },
@ -2443,6 +2444,6 @@ __GLXrenderSizeData __glXRenderSizeTable_EXT[__GLX_MAX_RENDER_OPCODE_EXT - __GLX
/* no such opcode */ { 0, 0 },
/* no such opcode */ { 0, 0 },
/* ActiveStencilFaceEXT 4220 */ { 8, 0 },
/* PointParameteri 4221 */ { 12, 0 },
/* PointParameteriv 4222 */ { 8, __glXPointParameterivReqSize },
/* PointParameteriNV 4221 */ { 12, 0 },
/* PointParameterivNV 4222 */ { 8, __glXPointParameterivNVReqSize },
};

47
GL/glx/single2.c
View File

@ -42,9 +42,13 @@
#include "glxserver.h"
#include "glxutil.h"
#include "glxext.h"
#include "indirect_dispatch.h"
#include "unpack.h"
#include "g_disptab.h"
#include "GL/glx_ansic.h"
#include "glapitable.h"
#include "glapi.h"
#include "glthread.h"
#include "dispatch.h"
int __glXDisp_FeedbackBuffer(__GLXclientState *cl, GLbyte *pc)
{
@ -71,7 +75,7 @@ int __glXDisp_FeedbackBuffer(__GLXclientState *cl, GLbyte *pc)
}
cx->feedbackBufSize = size;
}
glFeedbackBuffer(size, type, cx->feedbackBuf);
CALL_FeedbackBuffer( GET_DISPATCH(), (size, type, cx->feedbackBuf) );
__GLX_NOTE_UNFLUSHED_CMDS(cx);
return Success;
}
@ -99,7 +103,7 @@ int __glXDisp_SelectBuffer(__GLXclientState *cl, GLbyte *pc)
}
cx->selectBufSize = size;
}
glSelectBuffer(size, cx->selectBuf);
CALL_SelectBuffer( GET_DISPATCH(), (size, cx->selectBuf) );
__GLX_NOTE_UNFLUSHED_CMDS(cx);
return Success;
}
@ -121,10 +125,10 @@ int __glXDisp_RenderMode(__GLXclientState *cl, GLbyte *pc)
pc += __GLX_SINGLE_HDR_SIZE;
newMode = *(GLenum*) pc;
retval = glRenderMode(newMode);
retval = CALL_RenderMode( GET_DISPATCH(), (newMode) );
/* Check that render mode worked */
glGetIntegerv(GL_RENDER_MODE, &newModeCheck);
CALL_GetIntegerv( GET_DISPATCH(), (GL_RENDER_MODE, &newModeCheck) );
if (newModeCheck != newMode) {
/* Render mode change failed. Bail */
newMode = newModeCheck;
@ -212,7 +216,7 @@ int __glXDisp_Flush(__GLXclientState *cl, GLbyte *pc)
return error;
}
glFlush();
CALL_Flush( GET_DISPATCH(), () );
__GLX_NOTE_FLUSHED_CMDS(cx);
return Success;
}
@ -229,7 +233,7 @@ int __glXDisp_Finish(__GLXclientState *cl, GLbyte *pc)
}
/* Do a local glFinish */
glFinish();
CALL_Finish( GET_DISPATCH(), () );
__GLX_NOTE_FLUSHED_CMDS(cx);
/* Send empty reply packet to indicate finish is finished */
@ -326,7 +330,7 @@ int DoGetString(__GLXclientState *cl, GLbyte *pc, GLboolean need_swap)
pc += __GLX_SINGLE_HDR_SIZE;
name = *(GLenum *)(pc + 0);
string = (const char *)glGetString(name);
string = (const char *) CALL_GetString( GET_DISPATCH(), (name) );
client = cl->client;
/*
@ -382,30 +386,3 @@ int __glXDisp_GetString(__GLXclientState *cl, GLbyte *pc)
{
return DoGetString(cl, pc, GL_FALSE);
}
int __glXDisp_GetClipPlane(__GLXclientState *cl, GLbyte *pc)
{
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
GLdouble answer[4];
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
__glXClearErrorOccured();
glGetClipPlane(*(GLenum *)(pc + 0), answer);
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_SEND_HEADER();
} else {
__GLX_BEGIN_REPLY(32);
__GLX_SEND_HEADER();
__GLX_SEND_DOUBLE_ARRAY(4);
}
return Success;
}

51
GL/glx/single2swap.c
View File

@ -42,9 +42,13 @@
#include "glxserver.h"
#include "glxutil.h"
#include "glxext.h"
#include "indirect_dispatch.h"
#include "unpack.h"
#include "g_disptab.h"
#include "GL/glx_ansic.h"
#include "glapitable.h"
#include "glapi.h"
#include "glthread.h"
#include "dispatch.h"
int __glXDispSwap_FeedbackBuffer(__GLXclientState *cl, GLbyte *pc)
{
@ -75,7 +79,7 @@ int __glXDispSwap_FeedbackBuffer(__GLXclientState *cl, GLbyte *pc)
}
cx->feedbackBufSize = size;
}
glFeedbackBuffer(size, type, cx->feedbackBuf);
CALL_FeedbackBuffer( GET_DISPATCH(), (size, type, cx->feedbackBuf) );
__GLX_NOTE_UNFLUSHED_CMDS(cx);
return Success;
}
@ -106,7 +110,7 @@ int __glXDispSwap_SelectBuffer(__GLXclientState *cl, GLbyte *pc)
}
cx->selectBufSize = size;
}
glSelectBuffer(size, cx->selectBuf);
CALL_SelectBuffer( GET_DISPATCH(), (size, cx->selectBuf) );
__GLX_NOTE_UNFLUSHED_CMDS(cx);
return Success;
}
@ -132,10 +136,10 @@ int __glXDispSwap_RenderMode(__GLXclientState *cl, GLbyte *pc)
pc += __GLX_SINGLE_HDR_SIZE;
__GLX_SWAP_INT(pc);
newMode = *(GLenum*) pc;
retval = glRenderMode(newMode);
retval = CALL_RenderMode( GET_DISPATCH(), (newMode) );
/* Check that render mode worked */
glGetIntegerv(GL_RENDER_MODE, &newModeCheck);
CALL_GetIntegerv( GET_DISPATCH(), (GL_RENDER_MODE, &newModeCheck) );
if (newModeCheck != newMode) {
/* Render mode change failed. Bail */
newMode = newModeCheck;
@ -232,7 +236,7 @@ int __glXDispSwap_Flush(__GLXclientState *cl, GLbyte *pc)
return error;
}
glFlush();
CALL_Flush( GET_DISPATCH(), () );
__GLX_NOTE_FLUSHED_CMDS(cx);
return Success;
}
@ -251,7 +255,7 @@ int __glXDispSwap_Finish(__GLXclientState *cl, GLbyte *pc)
}
/* Do a local glFinish */
glFinish();
CALL_Finish( GET_DISPATCH(), () );
__GLX_NOTE_FLUSHED_CMDS(cx);
/* Send empty reply packet to indicate finish is finished */
@ -268,36 +272,3 @@ int __glXDispSwap_GetString(__GLXclientState *cl, GLbyte *pc)
{
return DoGetString(cl, pc, GL_TRUE);
}
int __glXDispSwap_GetClipPlane(__GLXclientState *cl, GLbyte *pc)
{
__GLXcontext *cx;
ClientPtr client = cl->client;
int error;
GLdouble answer[4];
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
__GLX_SWAP_INT(&((xGLXSingleReq *)pc)->contextTag);
cx = __glXForceCurrent(cl, __GLX_GET_SINGLE_CONTEXT_TAG(pc), &error);
if (!cx) {
return error;
}
pc += __GLX_SINGLE_HDR_SIZE;
__GLX_SWAP_INT(pc + 0);
__glXClearErrorOccured();
glGetClipPlane(*(GLenum *)(pc + 0), answer);
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_SWAP_REPLY_HEADER();
__GLX_SEND_HEADER();
} else {
__GLX_SWAP_DOUBLE_ARRAY((GLbyte *)answer, 4);
__GLX_BEGIN_REPLY(32);
__GLX_SWAP_REPLY_HEADER();
__GLX_SEND_HEADER();
__GLX_SEND_DOUBLE_ARRAY(4);
}
return Success;
}

72
GL/glx/singlepix.c
View File

@ -43,8 +43,12 @@
#include "glxext.h"
#include "singlesize.h"
#include "unpack.h"
#include "g_disptab.h"
#include "g_disptab_EXT.h"
#include "indirect_size_get.h"
#include "indirect_dispatch.h"
#include "glapitable.h"
#include "glapi.h"
#include "glthread.h"
#include "dispatch.h"
int __glXDisp_ReadPixels(__GLXclientState *cl, GLbyte *pc)
{
@ -72,11 +76,11 @@ int __glXDisp_ReadPixels(__GLXclientState *cl, GLbyte *pc)
compsize = __glReadPixels_size(format,type,width,height);
if (compsize < 0) compsize = 0;
glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
glPixelStorei(GL_PACK_LSB_FIRST, lsbFirst);
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, swapBytes) );
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_LSB_FIRST, lsbFirst) );
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
__glXClearErrorOccured();
glReadPixels(
CALL_ReadPixels( GET_DISPATCH(), (
*(GLint *)(pc + 0),
*(GLint *)(pc + 4),
*(GLsizei *)(pc + 8),
@ -84,7 +88,7 @@ int __glXDisp_ReadPixels(__GLXclientState *cl, GLbyte *pc)
*(GLenum *)(pc + 16),
*(GLenum *)(pc + 20),
answer
);
) );
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
@ -120,10 +124,10 @@ int __glXDisp_GetTexImage(__GLXclientState *cl, GLbyte *pc)
target = *(GLenum *)(pc + 0);
swapBytes = *(GLboolean *)(pc + 16);
glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, &width);
glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, &height);
CALL_GetTexLevelParameteriv( GET_DISPATCH(), (target, level, GL_TEXTURE_WIDTH, &width) );
CALL_GetTexLevelParameteriv( GET_DISPATCH(), (target, level, GL_TEXTURE_HEIGHT, &height) );
if ( target == GL_TEXTURE_3D) {
glGetTexLevelParameteriv(target, level, GL_TEXTURE_DEPTH, &depth);
CALL_GetTexLevelParameteriv( GET_DISPATCH(), (target, level, GL_TEXTURE_DEPTH, &depth) );
}
/*
* The three queries above might fail if we're in a state where queries
@ -132,16 +136,16 @@ int __glXDisp_GetTexImage(__GLXclientState *cl, GLbyte *pc)
compsize = __glGetTexImage_size(target,level,format,type,width,height,depth);
if (compsize < 0) compsize = 0;
glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, swapBytes) );
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
__glXClearErrorOccured();
glGetTexImage(
CALL_GetTexImage( GET_DISPATCH(), (
*(GLenum *)(pc + 0),
*(GLint *)(pc + 4),
*(GLenum *)(pc + 8),
*(GLenum *)(pc + 12),
answer
);
) );
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
@ -174,13 +178,11 @@ int __glXDisp_GetPolygonStipple(__GLXclientState *cl, GLbyte *pc)
pc += __GLX_SINGLE_HDR_SIZE;
lsbFirst = *(GLboolean *)(pc + 0);
glPixelStorei(GL_PACK_LSB_FIRST, lsbFirst);
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_LSB_FIRST, lsbFirst) );
__GLX_GET_ANSWER_BUFFER(answer,cl,128,1);
__glXClearErrorOccured();
glGetPolygonStipple(
(GLubyte *) answer
);
CALL_GetPolygonStipple( GET_DISPATCH(), ((GLubyte *) answer) );
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
@ -218,8 +220,8 @@ int __glXDisp_GetSeparableFilter(__GLXclientState *cl, GLbyte *pc)
/* target must be SEPARABLE_2D, however I guess we can let the GL
barf on this one.... */
glGetConvolutionParameteriv(target, GL_CONVOLUTION_WIDTH, &width);
glGetConvolutionParameteriv(target, GL_CONVOLUTION_HEIGHT, &height);
CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_WIDTH, &width) );
CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_HEIGHT, &height) );
/*
* The two queries above might fail if we're in a state where queries
* are illegal, but then width and height would still be zero anyway.
@ -232,17 +234,17 @@ int __glXDisp_GetSeparableFilter(__GLXclientState *cl, GLbyte *pc)
compsize = __GLX_PAD(compsize);
compsize2 = __GLX_PAD(compsize2);
glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, swapBytes) );
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize + compsize2,1);
__glXClearErrorOccured();
glGetSeparableFilter(
CALL_GetSeparableFilter( GET_DISPATCH(), (
*(GLenum *)(pc + 0),
*(GLenum *)(pc + 4),
*(GLenum *)(pc + 8),
answer,
answer + compsize,
NULL
);
) );
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
@ -280,11 +282,11 @@ int __glXDisp_GetConvolutionFilter(__GLXclientState *cl, GLbyte *pc)
target = *(GLenum *)(pc + 0);
swapBytes = *(GLboolean *)(pc + 12);
glGetConvolutionParameteriv(target, GL_CONVOLUTION_WIDTH, &width);
CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_WIDTH, &width) );
if (target == GL_CONVOLUTION_1D) {
height = 1;
} else {
glGetConvolutionParameteriv(target, GL_CONVOLUTION_HEIGHT, &height);
CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_HEIGHT, &height) );
}
/*
* The two queries above might fail if we're in a state where queries
@ -293,15 +295,15 @@ int __glXDisp_GetConvolutionFilter(__GLXclientState *cl, GLbyte *pc)
compsize = __glGetTexImage_size(target,1,format,type,width,height,1);
if (compsize < 0) compsize = 0;
glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, swapBytes) );
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
__glXClearErrorOccured();
glGetConvolutionFilter(
CALL_GetConvolutionFilter( GET_DISPATCH(), (
*(GLenum *)(pc + 0),
*(GLenum *)(pc + 4),
*(GLenum *)(pc + 8),
answer
);
) );
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
@ -340,7 +342,7 @@ int __glXDisp_GetHistogram(__GLXclientState *cl, GLbyte *pc)
swapBytes = *(GLboolean *)(pc + 12);
reset = *(GLboolean *)(pc + 13);
glGetHistogramParameteriv(target, GL_HISTOGRAM_WIDTH, &width);
CALL_GetHistogramParameteriv( GET_DISPATCH(), (target, GL_HISTOGRAM_WIDTH, &width) );
/*
* The one query above might fail if we're in a state where queries
* are illegal, but then width would still be zero anyway.
@ -348,10 +350,10 @@ int __glXDisp_GetHistogram(__GLXclientState *cl, GLbyte *pc)
compsize = __glGetTexImage_size(target,1,format,type,width,1,1);
if (compsize < 0) compsize = 0;
glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, swapBytes) );
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
__glXClearErrorOccured();
glGetHistogram( target, reset, format, type, answer);
CALL_GetHistogram( GET_DISPATCH(), (target, reset, format, type, answer) );
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
@ -391,10 +393,10 @@ int __glXDisp_GetMinmax(__GLXclientState *cl, GLbyte *pc)
compsize = __glGetTexImage_size(target,1,format,type,2,1,1);
if (compsize < 0) compsize = 0;
glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, swapBytes) );
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
__glXClearErrorOccured();
glGetMinmax( target, reset, format, type, answer);
CALL_GetMinmax( GET_DISPATCH(), (target, reset, format, type, answer) );
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
@ -430,7 +432,7 @@ int __glXDisp_GetColorTable(__GLXclientState *cl, GLbyte *pc)
type = *(GLenum *)(pc + 8);
swapBytes = *(GLboolean *)(pc + 12);
glGetColorTableParameteriv(target, GL_COLOR_TABLE_WIDTH, &width);
CALL_GetColorTableParameteriv( GET_DISPATCH(), (target, GL_COLOR_TABLE_WIDTH, &width) );
/*
* The one query above might fail if we're in a state where queries
* are illegal, but then width would still be zero anyway.
@ -438,15 +440,15 @@ int __glXDisp_GetColorTable(__GLXclientState *cl, GLbyte *pc)
compsize = __glGetTexImage_size(target,1,format,type,width,1,1);
if (compsize < 0) compsize = 0;
glPixelStorei(GL_PACK_SWAP_BYTES, swapBytes);
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, swapBytes) );
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
__glXClearErrorOccured();
glGetColorTable(
CALL_GetColorTable( GET_DISPATCH(), (
*(GLenum *)(pc + 0),
*(GLenum *)(pc + 4),
*(GLenum *)(pc + 8),
answer
);
) );
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);

74
GL/glx/singlepixswap.c
View File

@ -43,8 +43,12 @@
#include "glxext.h"
#include "singlesize.h"
#include "unpack.h"
#include "g_disptab.h"
#include "g_disptab_EXT.h"
#include "indirect_dispatch.h"
#include "indirect_size_get.h"
#include "glapitable.h"
#include "glapi.h"
#include "glthread.h"
#include "dispatch.h"
int __glXDispSwap_ReadPixels(__GLXclientState *cl, GLbyte *pc)
{
@ -81,18 +85,18 @@ int __glXDispSwap_ReadPixels(__GLXclientState *cl, GLbyte *pc)
compsize = __glReadPixels_size(format,type,width,height);
if (compsize < 0) compsize = 0;
glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
glPixelStorei(GL_PACK_LSB_FIRST, lsbFirst);
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) );
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_LSB_FIRST, lsbFirst) );
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
__glXClearErrorOccured();
glReadPixels(
*(GLint *)(pc + 0),
CALL_ReadPixels( GET_DISPATCH(),
(*(GLint *)(pc + 0),
*(GLint *)(pc + 4),
*(GLsizei *)(pc + 8),
*(GLsizei *)(pc + 12),
*(GLenum *)(pc + 16),
*(GLenum *)(pc + 20),
answer
answer)
);
if (__glXErrorOccured()) {
@ -138,10 +142,10 @@ int __glXDispSwap_GetTexImage(__GLXclientState *cl, GLbyte *pc)
target = *(GLenum *)(pc + 0);
swapBytes = *(GLboolean *)(pc + 16);
glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, &width);
glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, &height);
CALL_GetTexLevelParameteriv( GET_DISPATCH(), (target, level, GL_TEXTURE_WIDTH, &width) );
CALL_GetTexLevelParameteriv( GET_DISPATCH(), (target, level, GL_TEXTURE_HEIGHT, &height) );
if ( target == GL_TEXTURE_3D) {
glGetTexLevelParameteriv(target, level, GL_TEXTURE_DEPTH, &depth);
CALL_GetTexLevelParameteriv( GET_DISPATCH(), (target, level, GL_TEXTURE_DEPTH, &depth) );
}
/*
* The three queries above might fail if we're in a state where queries
@ -150,16 +154,16 @@ int __glXDispSwap_GetTexImage(__GLXclientState *cl, GLbyte *pc)
compsize = __glGetTexImage_size(target,level,format,type,width,height,depth);
if (compsize < 0) compsize = 0;
glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) );
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
__glXClearErrorOccured();
glGetTexImage(
CALL_GetTexImage( GET_DISPATCH(), (
*(GLenum *)(pc + 0),
*(GLint *)(pc + 4),
*(GLenum *)(pc + 8),
*(GLenum *)(pc + 12),
answer
);
) );
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
@ -198,13 +202,11 @@ int __glXDispSwap_GetPolygonStipple(__GLXclientState *cl, GLbyte *pc)
pc += __GLX_SINGLE_HDR_SIZE;
lsbFirst = *(GLboolean *)(pc + 0);
glPixelStorei(GL_PACK_LSB_FIRST, lsbFirst);
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_LSB_FIRST, lsbFirst) );
__GLX_GET_ANSWER_BUFFER(answer,cl,128,1);
__glXClearErrorOccured();
glGetPolygonStipple(
(GLubyte *) answer
);
CALL_GetPolygonStipple( GET_DISPATCH(), ((GLubyte *) answer) );
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
__GLX_SWAP_REPLY_HEADER();
@ -248,8 +250,8 @@ int __glXDispSwap_GetSeparableFilter(__GLXclientState *cl, GLbyte *pc)
/* target must be SEPARABLE_2D, however I guess we can let the GL
barf on this one.... */
glGetConvolutionParameteriv(target, GL_CONVOLUTION_WIDTH, &width);
glGetConvolutionParameteriv(target, GL_CONVOLUTION_HEIGHT, &height);
CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_WIDTH, &width) );
CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_HEIGHT, &height) );
/*
* The two queries above might fail if we're in a state where queries
* are illegal, but then width and height would still be zero anyway.
@ -262,17 +264,17 @@ int __glXDispSwap_GetSeparableFilter(__GLXclientState *cl, GLbyte *pc)
compsize = __GLX_PAD(compsize);
compsize2 = __GLX_PAD(compsize2);
glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) );
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize + compsize2,1);
__glXClearErrorOccured();
glGetSeparableFilter(
CALL_GetSeparableFilter( GET_DISPATCH(), (
*(GLenum *)(pc + 0),
*(GLenum *)(pc + 4),
*(GLenum *)(pc + 8),
answer,
answer + compsize,
NULL
);
) );
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
@ -317,11 +319,11 @@ int __glXDispSwap_GetConvolutionFilter(__GLXclientState *cl, GLbyte *pc)
target = *(GLenum *)(pc + 0);
swapBytes = *(GLboolean *)(pc + 12);
glGetConvolutionParameteriv(target, GL_CONVOLUTION_WIDTH, &width);
CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_WIDTH, &width) );
if (target == GL_CONVOLUTION_2D) {
height = 1;
} else {
glGetConvolutionParameteriv(target, GL_CONVOLUTION_HEIGHT, &height);
CALL_GetConvolutionParameteriv( GET_DISPATCH(), (target, GL_CONVOLUTION_HEIGHT, &height) );
}
/*
* The two queries above might fail if we're in a state where queries
@ -330,15 +332,15 @@ int __glXDispSwap_GetConvolutionFilter(__GLXclientState *cl, GLbyte *pc)
compsize = __glGetTexImage_size(target,1,format,type,width,height,1);
if (compsize < 0) compsize = 0;
glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) );
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
__glXClearErrorOccured();
glGetConvolutionFilter(
CALL_GetConvolutionFilter( GET_DISPATCH(), (
*(GLenum *)(pc + 0),
*(GLenum *)(pc + 4),
*(GLenum *)(pc + 8),
answer
);
) );
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
@ -384,7 +386,7 @@ int __glXDispSwap_GetHistogram(__GLXclientState *cl, GLbyte *pc)
swapBytes = *(GLboolean *)(pc + 12);
reset = *(GLboolean *)(pc + 13);
glGetHistogramParameteriv(target, GL_HISTOGRAM_WIDTH, &width);
CALL_GetHistogramParameteriv( GET_DISPATCH(), (target, GL_HISTOGRAM_WIDTH, &width) );
/*
* The one query above might fail if we're in a state where queries
* are illegal, but then width would still be zero anyway.
@ -392,10 +394,10 @@ int __glXDispSwap_GetHistogram(__GLXclientState *cl, GLbyte *pc)
compsize = __glGetTexImage_size(target,1,format,type,width,1,1);
if (compsize < 0) compsize = 0;
glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) );
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
__glXClearErrorOccured();
glGetHistogram( target, reset, format, type, answer);
CALL_GetHistogram( GET_DISPATCH(), (target, reset, format, type, answer) );
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
@ -441,10 +443,10 @@ int __glXDispSwap_GetMinmax(__GLXclientState *cl, GLbyte *pc)
compsize = __glGetTexImage_size(target,1,format,type,2,1,1);
if (compsize < 0) compsize = 0;
glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) );
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
__glXClearErrorOccured();
glGetMinmax( target, reset, format, type, answer);
CALL_GetMinmax( GET_DISPATCH(), (target, reset, format, type, answer) );
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);
@ -485,7 +487,7 @@ int __glXDispSwap_GetColorTable(__GLXclientState *cl, GLbyte *pc)
target = *(GLenum *)(pc + 0);
swapBytes = *(GLboolean *)(pc + 12);
glGetColorTableParameteriv(target, GL_COLOR_TABLE_WIDTH, &width);
CALL_GetColorTableParameteriv( GET_DISPATCH(), (target, GL_COLOR_TABLE_WIDTH, &width) );
/*
* The one query above might fail if we're in a state where queries
* are illegal, but then width would still be zero anyway.
@ -493,15 +495,15 @@ int __glXDispSwap_GetColorTable(__GLXclientState *cl, GLbyte *pc)
compsize = __glGetTexImage_size(target,1,format,type,width,1,1);
if (compsize < 0) compsize = 0;
glPixelStorei(GL_PACK_SWAP_BYTES, !swapBytes);
CALL_PixelStorei( GET_DISPATCH(), (GL_PACK_SWAP_BYTES, !swapBytes) );
__GLX_GET_ANSWER_BUFFER(answer,cl,compsize,1);
__glXClearErrorOccured();
glGetColorTable(
CALL_GetColorTable( GET_DISPATCH(), (
*(GLenum *)(pc + 0),
*(GLenum *)(pc + 4),
*(GLenum *)(pc + 8),
answer
);
) );
if (__glXErrorOccured()) {
__GLX_BEGIN_REPLY(0);

1039
GL/glx/singlesize.c
View File

File diff suppressed because it is too large Load Diff

27
GL/glx/singlesize.h
View File

@ -45,43 +45,16 @@
extern GLint __glReadPixels_size(GLenum format, GLenum type,
GLint width, GLint height);
extern GLint __glGetTexEnvfv_size(GLenum pname);
extern GLint __glGetTexEnviv_size(GLenum pname);
extern GLint __glGetTexGenfv_size(GLenum pname);
extern GLint __glGetTexGendv_size(GLenum pname);
extern GLint __glGetTexGeniv_size(GLenum pname);
extern GLint __glGetTexParameterfv_size(GLenum pname);
extern GLint __glGetTexParameteriv_size(GLenum pname);
extern GLint __glGetLightfv_size(GLenum pname);
extern GLint __glGetLightiv_size(GLenum pname);
extern GLint __glGetMap_size(GLenum pname, GLenum query);
extern GLint __glGetMapdv_size(GLenum target, GLenum query);
extern GLint __glGetMapfv_size(GLenum target, GLenum query);
extern GLint __glGetMapiv_size(GLenum target, GLenum query);
extern GLint __glGetMaterialfv_size(GLenum pname);
extern GLint __glGetMaterialiv_size(GLenum pname);
extern GLint __glGetPixelMap_size(GLenum map);
extern GLint __glGetPixelMapfv_size(GLenum map);
extern GLint __glGetPixelMapuiv_size(GLenum map);
extern GLint __glGetPixelMapusv_size(GLenum map);
extern GLint __glGet_size(GLenum sq);
extern GLint __glGetDoublev_size(GLenum sq);
extern GLint __glGetFloatv_size(GLenum sq);
extern GLint __glGetIntegerv_size(GLenum sq);
extern GLint __glGetBooleanv_size(GLenum sq);
extern GLint __glGetTexLevelParameterfv_size(GLenum pname);
extern GLint __glGetTexLevelParameteriv_size(GLenum pname);
extern GLint __glGetTexImage_size(GLenum target, GLint level, GLenum format,
GLenum type, GLint width, GLint height,
GLint depth);
extern GLint __glGetColorTableParameterfv_size(GLenum pname);
extern GLint __glGetColorTableParameteriv_size(GLenum pname);
extern GLint __glGetConvolutionParameterfv_size(GLenum pname);
extern GLint __glGetConvolutionParameteriv_size(GLenum pname);
extern GLint __glGetHistogramParameterfv_size(GLenum pname);
extern GLint __glGetHistogramParameteriv_size(GLenum pname);
extern GLint __glGetMinmaxParameterfv_size(GLenum pname);
extern GLint __glGetMinmaxParameteriv_size(GLenum pname);
#endif /* _singlesize_h_ */

30
GL/glx/xfont.c
View File

@ -41,8 +41,12 @@
#include "glxserver.h"
#include "glxutil.h"
#include "unpack.h"
#include "g_disptab.h"
#include <unpack.h>
#include "glapitable.h"
#include "glapi.h"
#include "glthread.h"
#include "dispatch.h"
#include <GL/gl.h>
#include <pixmapstr.h>
#include <windowstr.h>
@ -96,8 +100,10 @@ static int __glXMakeBitmapFromGlyph(FontPtr font, CharInfoPtr pci)
pglyph -= widthPadded;
p += widthPadded;
}
glBitmap(w, h, -pci->metrics.leftSideBearing, pci->metrics.descent,
pci->metrics.characterWidth, 0, allocbuf ? allocbuf : buf);
CALL_Bitmap( GET_DISPATCH(), (w, h, -pci->metrics.leftSideBearing,
pci->metrics.descent,
pci->metrics.characterWidth, 0,
allocbuf ? allocbuf : buf) );
if (allocbuf) {
__glXFree(allocbuf);
@ -120,12 +126,12 @@ MakeBitmapsFromFont(FontPtr pFont, int first, int count, int list_base)
int rv; /* return value */
int encoding = (FONTLASTROW(pFont) == 0) ? Linear16Bit : TwoD16Bit;
glPixelStorei(GL_UNPACK_SWAP_BYTES, FALSE);
glPixelStorei(GL_UNPACK_LSB_FIRST, BITMAP_BIT_ORDER == LSBFirst);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
glPixelStorei(GL_UNPACK_ALIGNMENT, GLYPHPADBYTES);
CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, FALSE) );
CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, BITMAP_BIT_ORDER == LSBFirst) );
CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, 0) );
CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, 0) );
CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, 0) );
CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, GLYPHPADBYTES) );
for (i=0; i < count; i++) {
chs[0] = (first + i) >> 8; /* high byte is first byte */
chs[1] = first + i;
@ -136,14 +142,14 @@ MakeBitmapsFromFont(FontPtr pFont, int first, int count, int list_base)
/*
** Define a display list containing just a glBitmap() call.
*/
glNewList(list_base + i, GL_COMPILE);
CALL_NewList( GET_DISPATCH(), (list_base + i, GL_COMPILE) );
if (nglyphs ) {
rv = __glXMakeBitmapFromGlyph(pFont, pci);
if (rv) {
return rv;
}
}
glEndList();
CALL_EndList( GET_DISPATCH(), () );
}
return Success;
}
@ -166,7 +172,7 @@ int __glXUseXFont(__GLXclientState *cl, GLbyte *pc)
return error;
}
glGetIntegerv(GL_LIST_INDEX, (GLint*) &currentListIndex);
CALL_GetIntegerv( GET_DISPATCH(), (GL_LIST_INDEX, (GLint*) &currentListIndex) );
if (currentListIndex != 0) {
/*
** A display list is currently being made. It is an error

5
GL/mesa/Makefile.am
View File

@ -1,10 +1,9 @@
SUBDIRS = glapi main math array_cache swrast swrast_setup tnl shader X
SUBDIRS = main math array_cache swrast swrast_setup tnl shader X
noinst_LTLIBRARIES = libGLcore.la
libGLcore_la_SOURCES = dummy.c
libGLcore_la_LIBADD = glapi/libglapi.la \
main/libmain.la \
libGLcore_la_LIBADD = main/libmain.la \
math/libmath.la \
array_cache/libac.la \
swrast/libswrast.la \

1
GL/mesa/main/Makefile.am
View File

@ -34,7 +34,6 @@ nodist_libmain_la_SOURCES = accum.c \
convolve.c \
debug.c \
depth.c \
dispatch.c \
dlist.c \
drawpix.c \
enable.c \

8
GL/symlink-mesa.sh
View File

@ -63,7 +63,6 @@ symlink_mesa_glapi() {
dst_dir mesa/glapi
action dispatch.h
action glapi.c
action glapi.h
action glapioffsets.h
action glapitable.h
@ -111,7 +110,6 @@ symlink_mesa_main() {
action debug.h
action depth.c
action depth.h
action dispatch.c
action dlist.c
action dlist.h
action drawpix.c
@ -521,13 +519,17 @@ symlink_glx() {
src_dir src/glx/x11
dst_dir glx
action indirect_size.c
action indirect_size.h
src_dir src/mesa/drivers/dri/common
action glcontextmodes.c
action glcontextmodes.h
src_dir src/mesa/glapi
action glapi.c
action glthread.c
}
#########