diff options
Diffstat (limited to 'src/mesa')
39 files changed, 2987 insertions, 988 deletions
diff --git a/src/mesa/drivers/dri/common/extension_helper.h b/src/mesa/drivers/dri/common/extension_helper.h index 39384ca31b4..4a6606819cf 100644 --- a/src/mesa/drivers/dri/common/extension_helper.h +++ b/src/mesa/drivers/dri/common/extension_helper.h @@ -26,6 +26,7 @@ */ #include "utils.h" +#include "dispatch.h" #ifndef NULL # define NULL 0 @@ -4579,1308 +4580,1308 @@ static const char WindowPos2fMESA_names[] = #if defined(need_GL_3DFX_tbuffer) static const struct dri_extension_function GL_3DFX_tbuffer_functions[] = { - { TbufferMask3DFX_names, 553 }, - { NULL, 0 } + { TbufferMask3DFX_names, TbufferMask3DFX_remap_index, 553 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_ARB_draw_buffers) static const struct dri_extension_function GL_ARB_draw_buffers_functions[] = { - { DrawBuffersARB_names, 413 }, - { NULL, 0 } + { DrawBuffersARB_names, DrawBuffersARB_remap_index, 413 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_ARB_matrix_palette) static const struct dri_extension_function GL_ARB_matrix_palette_functions[] = { - { MatrixIndexusvARB_names, -1 }, - { MatrixIndexuivARB_names, -1 }, - { CurrentPaletteMatrixARB_names, -1 }, - { MatrixIndexubvARB_names, -1 }, - { MatrixIndexPointerARB_names, -1 }, - { NULL, 0 } + { MatrixIndexusvARB_names, MatrixIndexusvARB_remap_index, -1 }, + { MatrixIndexuivARB_names, MatrixIndexuivARB_remap_index, -1 }, + { CurrentPaletteMatrixARB_names, CurrentPaletteMatrixARB_remap_index, -1 }, + { MatrixIndexubvARB_names, MatrixIndexubvARB_remap_index, -1 }, + { MatrixIndexPointerARB_names, MatrixIndexPointerARB_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_ARB_multisample) static const struct dri_extension_function GL_ARB_multisample_functions[] = { - { SampleCoverageARB_names, 412 }, - { NULL, 0 } + { SampleCoverageARB_names, SampleCoverageARB_remap_index, 412 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_ARB_occlusion_query) static const struct dri_extension_function GL_ARB_occlusion_query_functions[] = { - { BeginQueryARB_names, 703 }, - { GetQueryivARB_names, 705 }, - { GetQueryObjectivARB_names, 706 }, - { EndQueryARB_names, 704 }, - { GetQueryObjectuivARB_names, 707 }, - { DeleteQueriesARB_names, 701 }, - { IsQueryARB_names, 702 }, - { GenQueriesARB_names, 700 }, - { NULL, 0 } + { BeginQueryARB_names, BeginQueryARB_remap_index, 703 }, + { GetQueryivARB_names, GetQueryivARB_remap_index, 705 }, + { GetQueryObjectivARB_names, GetQueryObjectivARB_remap_index, 706 }, + { EndQueryARB_names, EndQueryARB_remap_index, 704 }, + { GetQueryObjectuivARB_names, GetQueryObjectuivARB_remap_index, 707 }, + { DeleteQueriesARB_names, DeleteQueriesARB_remap_index, 701 }, + { IsQueryARB_names, IsQueryARB_remap_index, 702 }, + { GenQueriesARB_names, GenQueriesARB_remap_index, 700 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_ARB_point_parameters) static const struct dri_extension_function GL_ARB_point_parameters_functions[] = { - { PointParameterfEXT_names, 458 }, - { PointParameterfvEXT_names, 459 }, - { NULL, 0 } + { PointParameterfEXT_names, PointParameterfEXT_remap_index, 458 }, + { PointParameterfvEXT_names, PointParameterfvEXT_remap_index, 459 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_ARB_shader_objects) static const struct dri_extension_function GL_ARB_shader_objects_functions[] = { - { UniformMatrix3fvARB_names, 739 }, - { Uniform2fARB_names, 723 }, - { Uniform2ivARB_names, 735 }, - { UniformMatrix4fvARB_names, 740 }, - { CreateProgramObjectARB_names, 717 }, - { Uniform3iARB_names, 728 }, - { CreateShaderObjectARB_names, 714 }, - { AttachObjectARB_names, 718 }, - { UniformMatrix2fvARB_names, 738 }, - { GetAttachedObjectsARB_names, 744 }, - { Uniform3fvARB_names, 732 }, - { GetHandleARB_names, 712 }, - { GetActiveUniformARB_names, 746 }, - { GetUniformivARB_names, 748 }, - { Uniform2fvARB_names, 731 }, - { DeleteObjectARB_names, 711 }, - { UseProgramObjectARB_names, 720 }, - { Uniform3ivARB_names, 736 }, - { CompileShaderARB_names, 716 }, - { Uniform4fARB_names, 725 }, - { LinkProgramARB_names, 719 }, - { ShaderSourceARB_names, 715 }, - { Uniform4ivARB_names, 737 }, - { Uniform1ivARB_names, 734 }, - { ValidateProgramARB_names, 721 }, - { Uniform1iARB_names, 726 }, - { Uniform4fvARB_names, 733 }, - { GetUniformfvARB_names, 747 }, - { DetachObjectARB_names, 713 }, - { Uniform4iARB_names, 729 }, - { Uniform2iARB_names, 727 }, - { GetObjectParameterivARB_names, 742 }, - { GetUniformLocationARB_names, 745 }, - { GetShaderSourceARB_names, 749 }, - { Uniform1fARB_names, 722 }, - { Uniform1fvARB_names, 730 }, - { Uniform3fARB_names, 724 }, - { GetObjectParameterfvARB_names, 741 }, - { GetInfoLogARB_names, 743 }, - { NULL, 0 } + { UniformMatrix3fvARB_names, UniformMatrix3fvARB_remap_index, 739 }, + { Uniform2fARB_names, Uniform2fARB_remap_index, 723 }, + { Uniform2ivARB_names, Uniform2ivARB_remap_index, 735 }, + { UniformMatrix4fvARB_names, UniformMatrix4fvARB_remap_index, 740 }, + { CreateProgramObjectARB_names, CreateProgramObjectARB_remap_index, 717 }, + { Uniform3iARB_names, Uniform3iARB_remap_index, 728 }, + { CreateShaderObjectARB_names, CreateShaderObjectARB_remap_index, 714 }, + { AttachObjectARB_names, AttachObjectARB_remap_index, 718 }, + { UniformMatrix2fvARB_names, UniformMatrix2fvARB_remap_index, 738 }, + { GetAttachedObjectsARB_names, GetAttachedObjectsARB_remap_index, 744 }, + { Uniform3fvARB_names, Uniform3fvARB_remap_index, 732 }, + { GetHandleARB_names, GetHandleARB_remap_index, 712 }, + { GetActiveUniformARB_names, GetActiveUniformARB_remap_index, 746 }, + { GetUniformivARB_names, GetUniformivARB_remap_index, 748 }, + { Uniform2fvARB_names, Uniform2fvARB_remap_index, 731 }, + { DeleteObjectARB_names, DeleteObjectARB_remap_index, 711 }, + { UseProgramObjectARB_names, UseProgramObjectARB_remap_index, 720 }, + { Uniform3ivARB_names, Uniform3ivARB_remap_index, 736 }, + { CompileShaderARB_names, CompileShaderARB_remap_index, 716 }, + { Uniform4fARB_names, Uniform4fARB_remap_index, 725 }, + { LinkProgramARB_names, LinkProgramARB_remap_index, 719 }, + { ShaderSourceARB_names, ShaderSourceARB_remap_index, 715 }, + { Uniform4ivARB_names, Uniform4ivARB_remap_index, 737 }, + { Uniform1ivARB_names, Uniform1ivARB_remap_index, 734 }, + { ValidateProgramARB_names, ValidateProgramARB_remap_index, 721 }, + { Uniform1iARB_names, Uniform1iARB_remap_index, 726 }, + { Uniform4fvARB_names, Uniform4fvARB_remap_index, 733 }, + { GetUniformfvARB_names, GetUniformfvARB_remap_index, 747 }, + { DetachObjectARB_names, DetachObjectARB_remap_index, 713 }, + { Uniform4iARB_names, Uniform4iARB_remap_index, 729 }, + { Uniform2iARB_names, Uniform2iARB_remap_index, 727 }, + { GetObjectParameterivARB_names, GetObjectParameterivARB_remap_index, 742 }, + { GetUniformLocationARB_names, GetUniformLocationARB_remap_index, 745 }, + { GetShaderSourceARB_names, GetShaderSourceARB_remap_index, 749 }, + { Uniform1fARB_names, Uniform1fARB_remap_index, 722 }, + { Uniform1fvARB_names, Uniform1fvARB_remap_index, 730 }, + { Uniform3fARB_names, Uniform3fARB_remap_index, 724 }, + { GetObjectParameterfvARB_names, GetObjectParameterfvARB_remap_index, 741 }, + { GetInfoLogARB_names, GetInfoLogARB_remap_index, 743 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_ARB_texture_compression) static const struct dri_extension_function GL_ARB_texture_compression_functions[] = { - { CompressedTexSubImage2DARB_names, 558 }, - { CompressedTexImage3DARB_names, 554 }, - { CompressedTexImage1DARB_names, 556 }, - { CompressedTexSubImage1DARB_names, 559 }, - { CompressedTexSubImage3DARB_names, 557 }, - { CompressedTexImage2DARB_names, 555 }, - { GetCompressedTexImageARB_names, 560 }, - { NULL, 0 } + { CompressedTexSubImage2DARB_names, CompressedTexSubImage2DARB_remap_index, 558 }, + { CompressedTexImage3DARB_names, CompressedTexImage3DARB_remap_index, 554 }, + { CompressedTexImage1DARB_names, CompressedTexImage1DARB_remap_index, 556 }, + { CompressedTexSubImage1DARB_names, CompressedTexSubImage1DARB_remap_index, 559 }, + { CompressedTexSubImage3DARB_names, CompressedTexSubImage3DARB_remap_index, 557 }, + { CompressedTexImage2DARB_names, CompressedTexImage2DARB_remap_index, 555 }, + { GetCompressedTexImageARB_names, GetCompressedTexImageARB_remap_index, 560 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_ARB_transpose_matrix) static const struct dri_extension_function GL_ARB_transpose_matrix_functions[] = { - { MultTransposeMatrixdARB_names, 411 }, - { LoadTransposeMatrixdARB_names, 409 }, - { MultTransposeMatrixfARB_names, 410 }, - { LoadTransposeMatrixfARB_names, 408 }, - { NULL, 0 } + { MultTransposeMatrixdARB_names, MultTransposeMatrixdARB_remap_index, 411 }, + { LoadTransposeMatrixdARB_names, LoadTransposeMatrixdARB_remap_index, 409 }, + { MultTransposeMatrixfARB_names, MultTransposeMatrixfARB_remap_index, 410 }, + { LoadTransposeMatrixfARB_names, LoadTransposeMatrixfARB_remap_index, 408 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_ARB_vertex_blend) static const struct dri_extension_function GL_ARB_vertex_blend_functions[] = { - { WeightubvARB_names, -1 }, - { WeightivARB_names, -1 }, - { WeightPointerARB_names, -1 }, - { WeightfvARB_names, -1 }, - { WeightbvARB_names, -1 }, - { WeightusvARB_names, -1 }, - { VertexBlendARB_names, -1 }, - { WeightsvARB_names, -1 }, - { WeightdvARB_names, -1 }, - { WeightuivARB_names, -1 }, - { NULL, 0 } + { WeightubvARB_names, WeightubvARB_remap_index, -1 }, + { WeightivARB_names, WeightivARB_remap_index, -1 }, + { WeightPointerARB_names, WeightPointerARB_remap_index, -1 }, + { WeightfvARB_names, WeightfvARB_remap_index, -1 }, + { WeightbvARB_names, WeightbvARB_remap_index, -1 }, + { WeightusvARB_names, WeightusvARB_remap_index, -1 }, + { VertexBlendARB_names, VertexBlendARB_remap_index, -1 }, + { WeightsvARB_names, WeightsvARB_remap_index, -1 }, + { WeightdvARB_names, WeightdvARB_remap_index, -1 }, + { WeightuivARB_names, WeightuivARB_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_ARB_vertex_buffer_object) static const struct dri_extension_function GL_ARB_vertex_buffer_object_functions[] = { - { GetBufferSubDataARB_names, 695 }, - { BufferSubDataARB_names, 690 }, - { BufferDataARB_names, 689 }, - { GetBufferPointervARB_names, 694 }, - { GetBufferParameterivARB_names, 693 }, - { MapBufferARB_names, 697 }, - { IsBufferARB_names, 696 }, - { DeleteBuffersARB_names, 691 }, - { UnmapBufferARB_names, 698 }, - { BindBufferARB_names, 688 }, - { GenBuffersARB_names, 692 }, - { NULL, 0 } + { GetBufferSubDataARB_names, GetBufferSubDataARB_remap_index, 695 }, + { BufferSubDataARB_names, BufferSubDataARB_remap_index, 690 }, + { BufferDataARB_names, BufferDataARB_remap_index, 689 }, + { GetBufferPointervARB_names, GetBufferPointervARB_remap_index, 694 }, + { GetBufferParameterivARB_names, GetBufferParameterivARB_remap_index, 693 }, + { MapBufferARB_names, MapBufferARB_remap_index, 697 }, + { IsBufferARB_names, IsBufferARB_remap_index, 696 }, + { DeleteBuffersARB_names, DeleteBuffersARB_remap_index, 691 }, + { UnmapBufferARB_names, UnmapBufferARB_remap_index, 698 }, + { BindBufferARB_names, BindBufferARB_remap_index, 688 }, + { GenBuffersARB_names, GenBuffersARB_remap_index, 692 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_ARB_vertex_program) static const struct dri_extension_function GL_ARB_vertex_program_functions[] = { - { ProgramEnvParameter4dvARB_names, 669 }, - { VertexAttrib2fARB_names, 611 }, - { VertexAttrib3fARB_names, 617 }, - { VertexAttrib1svARB_names, 608 }, - { VertexAttrib4NusvARB_names, 662 }, - { DisableVertexAttribArrayARB_names, 666 }, - { ProgramLocalParameter4dARB_names, 672 }, - { VertexAttrib1fARB_names, 605 }, - { VertexAttrib4NbvARB_names, 659 }, - { VertexAttrib1sARB_names, 607 }, - { GetProgramLocalParameterfvARB_names, 679 }, - { VertexAttrib3dvARB_names, 616 }, - { ProgramEnvParameter4fvARB_names, 671 }, - { GetVertexAttribivARB_names, 590 }, - { VertexAttrib4ivARB_names, 655 }, - { VertexAttrib4bvARB_names, 654 }, - { VertexAttrib3dARB_names, 615 }, - { VertexAttrib4fARB_names, 623 }, - { VertexAttrib4fvARB_names, 624 }, - { ProgramLocalParameter4dvARB_names, 673 }, - { VertexAttrib4usvARB_names, 657 }, - { VertexAttrib2dARB_names, 609 }, - { VertexAttrib1dvARB_names, 604 }, - { GetVertexAttribfvARB_names, 589 }, - { VertexAttrib4ubvARB_names, 656 }, - { ProgramEnvParameter4fARB_names, 670 }, - { VertexAttrib4sARB_names, 625 }, - { VertexAttrib2dvARB_names, 610 }, - { VertexAttrib2fvARB_names, 612 }, - { VertexAttrib4NivARB_names, 661 }, - { GetProgramStringARB_names, 681 }, - { VertexAttrib4NuivARB_names, 663 }, - { IsProgramNV_names, 592 }, - { ProgramEnvParameter4dARB_names, 668 }, - { VertexAttrib1dARB_names, 603 }, - { VertexAttrib3svARB_names, 620 }, - { GetVertexAttribdvARB_names, 588 }, - { VertexAttrib4dvARB_names, 622 }, - { VertexAttribPointerARB_names, 664 }, - { VertexAttrib4NsvARB_names, 660 }, - { VertexAttrib3fvARB_names, 618 }, - { VertexAttrib4NubARB_names, 627 }, - { GetProgramEnvParameterfvARB_names, 677 }, - { ProgramLocalParameter4fvARB_names, 675 }, - { DeleteProgramsNV_names, 580 }, - { GetVertexAttribPointervNV_names, 591 }, - { VertexAttrib4dARB_names, 621 }, - { GetProgramLocalParameterdvARB_names, 678 }, - { GetProgramivARB_names, 680 }, - { VertexAttrib3sARB_names, 619 }, - { ProgramStringARB_names, 667 }, - { ProgramLocalParameter4fARB_names, 674 }, - { EnableVertexAttribArrayARB_names, 665 }, - { VertexAttrib4uivARB_names, 658 }, - { BindProgramNV_names, 579 }, - { VertexAttrib4svARB_names, 626 }, - { VertexAttrib2svARB_names, 614 }, - { VertexAttrib4NubvARB_names, 628 }, - { GetProgramEnvParameterdvARB_names, 676 }, - { VertexAttrib2sARB_names, 613 }, - { VertexAttrib1fvARB_names, 606 }, - { GenProgramsNV_names, 582 }, - { NULL, 0 } + { ProgramEnvParameter4dvARB_names, ProgramEnvParameter4dvARB_remap_index, 669 }, + { VertexAttrib2fARB_names, VertexAttrib2fARB_remap_index, 611 }, + { VertexAttrib3fARB_names, VertexAttrib3fARB_remap_index, 617 }, + { VertexAttrib1svARB_names, VertexAttrib1svARB_remap_index, 608 }, + { VertexAttrib4NusvARB_names, VertexAttrib4NusvARB_remap_index, 662 }, + { DisableVertexAttribArrayARB_names, DisableVertexAttribArrayARB_remap_index, 666 }, + { ProgramLocalParameter4dARB_names, ProgramLocalParameter4dARB_remap_index, 672 }, + { VertexAttrib1fARB_names, VertexAttrib1fARB_remap_index, 605 }, + { VertexAttrib4NbvARB_names, VertexAttrib4NbvARB_remap_index, 659 }, + { VertexAttrib1sARB_names, VertexAttrib1sARB_remap_index, 607 }, + { GetProgramLocalParameterfvARB_names, GetProgramLocalParameterfvARB_remap_index, 679 }, + { VertexAttrib3dvARB_names, VertexAttrib3dvARB_remap_index, 616 }, + { ProgramEnvParameter4fvARB_names, ProgramEnvParameter4fvARB_remap_index, 671 }, + { GetVertexAttribivARB_names, GetVertexAttribivARB_remap_index, 590 }, + { VertexAttrib4ivARB_names, VertexAttrib4ivARB_remap_index, 655 }, + { VertexAttrib4bvARB_names, VertexAttrib4bvARB_remap_index, 654 }, + { VertexAttrib3dARB_names, VertexAttrib3dARB_remap_index, 615 }, + { VertexAttrib4fARB_names, VertexAttrib4fARB_remap_index, 623 }, + { VertexAttrib4fvARB_names, VertexAttrib4fvARB_remap_index, 624 }, + { ProgramLocalParameter4dvARB_names, ProgramLocalParameter4dvARB_remap_index, 673 }, + { VertexAttrib4usvARB_names, VertexAttrib4usvARB_remap_index, 657 }, + { VertexAttrib2dARB_names, VertexAttrib2dARB_remap_index, 609 }, + { VertexAttrib1dvARB_names, VertexAttrib1dvARB_remap_index, 604 }, + { GetVertexAttribfvARB_names, GetVertexAttribfvARB_remap_index, 589 }, + { VertexAttrib4ubvARB_names, VertexAttrib4ubvARB_remap_index, 656 }, + { ProgramEnvParameter4fARB_names, ProgramEnvParameter4fARB_remap_index, 670 }, + { VertexAttrib4sARB_names, VertexAttrib4sARB_remap_index, 625 }, + { VertexAttrib2dvARB_names, VertexAttrib2dvARB_remap_index, 610 }, + { VertexAttrib2fvARB_names, VertexAttrib2fvARB_remap_index, 612 }, + { VertexAttrib4NivARB_names, VertexAttrib4NivARB_remap_index, 661 }, + { GetProgramStringARB_names, GetProgramStringARB_remap_index, 681 }, + { VertexAttrib4NuivARB_names, VertexAttrib4NuivARB_remap_index, 663 }, + { IsProgramNV_names, IsProgramNV_remap_index, 592 }, + { ProgramEnvParameter4dARB_names, ProgramEnvParameter4dARB_remap_index, 668 }, + { VertexAttrib1dARB_names, VertexAttrib1dARB_remap_index, 603 }, + { VertexAttrib3svARB_names, VertexAttrib3svARB_remap_index, 620 }, + { GetVertexAttribdvARB_names, GetVertexAttribdvARB_remap_index, 588 }, + { VertexAttrib4dvARB_names, VertexAttrib4dvARB_remap_index, 622 }, + { VertexAttribPointerARB_names, VertexAttribPointerARB_remap_index, 664 }, + { VertexAttrib4NsvARB_names, VertexAttrib4NsvARB_remap_index, 660 }, + { VertexAttrib3fvARB_names, VertexAttrib3fvARB_remap_index, 618 }, + { VertexAttrib4NubARB_names, VertexAttrib4NubARB_remap_index, 627 }, + { GetProgramEnvParameterfvARB_names, GetProgramEnvParameterfvARB_remap_index, 677 }, + { ProgramLocalParameter4fvARB_names, ProgramLocalParameter4fvARB_remap_index, 675 }, + { DeleteProgramsNV_names, DeleteProgramsNV_remap_index, 580 }, + { GetVertexAttribPointervNV_names, GetVertexAttribPointervNV_remap_index, 591 }, + { VertexAttrib4dARB_names, VertexAttrib4dARB_remap_index, 621 }, + { GetProgramLocalParameterdvARB_names, GetProgramLocalParameterdvARB_remap_index, 678 }, + { GetProgramivARB_names, GetProgramivARB_remap_index, 680 }, + { VertexAttrib3sARB_names, VertexAttrib3sARB_remap_index, 619 }, + { ProgramStringARB_names, ProgramStringARB_remap_index, 667 }, + { ProgramLocalParameter4fARB_names, ProgramLocalParameter4fARB_remap_index, 674 }, + { EnableVertexAttribArrayARB_names, EnableVertexAttribArrayARB_remap_index, 665 }, + { VertexAttrib4uivARB_names, VertexAttrib4uivARB_remap_index, 658 }, + { BindProgramNV_names, BindProgramNV_remap_index, 579 }, + { VertexAttrib4svARB_names, VertexAttrib4svARB_remap_index, 626 }, + { VertexAttrib2svARB_names, VertexAttrib2svARB_remap_index, 614 }, + { VertexAttrib4NubvARB_names, VertexAttrib4NubvARB_remap_index, 628 }, + { GetProgramEnvParameterdvARB_names, GetProgramEnvParameterdvARB_remap_index, 676 }, + { VertexAttrib2sARB_names, VertexAttrib2sARB_remap_index, 613 }, + { VertexAttrib1fvARB_names, VertexAttrib1fvARB_remap_index, 606 }, + { GenProgramsNV_names, GenProgramsNV_remap_index, 582 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_ARB_vertex_shader) static const struct dri_extension_function GL_ARB_vertex_shader_functions[] = { - { GetActiveAttribARB_names, 751 }, - { GetAttribLocationARB_names, 752 }, - { BindAttribLocationARB_names, 750 }, - { NULL, 0 } + { GetActiveAttribARB_names, GetActiveAttribARB_remap_index, 751 }, + { GetAttribLocationARB_names, GetAttribLocationARB_remap_index, 752 }, + { BindAttribLocationARB_names, BindAttribLocationARB_remap_index, 750 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_ARB_window_pos) static const struct dri_extension_function GL_ARB_window_pos_functions[] = { - { WindowPos3fMESA_names, 523 }, - { WindowPos2dvMESA_names, 514 }, - { WindowPos2svMESA_names, 520 }, - { WindowPos3dMESA_names, 521 }, - { WindowPos2fvMESA_names, 516 }, - { WindowPos2dMESA_names, 513 }, - { WindowPos3dvMESA_names, 522 }, - { WindowPos3fvMESA_names, 524 }, - { WindowPos2iMESA_names, 517 }, - { WindowPos3sMESA_names, 527 }, - { WindowPos2ivMESA_names, 518 }, - { WindowPos2sMESA_names, 519 }, - { WindowPos3iMESA_names, 525 }, - { WindowPos3ivMESA_names, 526 }, - { WindowPos3svMESA_names, 528 }, - { WindowPos2fMESA_names, 515 }, - { NULL, 0 } + { WindowPos3fMESA_names, WindowPos3fMESA_remap_index, 523 }, + { WindowPos2dvMESA_names, WindowPos2dvMESA_remap_index, 514 }, + { WindowPos2svMESA_names, WindowPos2svMESA_remap_index, 520 }, + { WindowPos3dMESA_names, WindowPos3dMESA_remap_index, 521 }, + { WindowPos2fvMESA_names, WindowPos2fvMESA_remap_index, 516 }, + { WindowPos2dMESA_names, WindowPos2dMESA_remap_index, 513 }, + { WindowPos3dvMESA_names, WindowPos3dvMESA_remap_index, 522 }, + { WindowPos3fvMESA_names, WindowPos3fvMESA_remap_index, 524 }, + { WindowPos2iMESA_names, WindowPos2iMESA_remap_index, 517 }, + { WindowPos3sMESA_names, WindowPos3sMESA_remap_index, 527 }, + { WindowPos2ivMESA_names, WindowPos2ivMESA_remap_index, 518 }, + { WindowPos2sMESA_names, WindowPos2sMESA_remap_index, 519 }, + { WindowPos3iMESA_names, WindowPos3iMESA_remap_index, 525 }, + { WindowPos3ivMESA_names, WindowPos3ivMESA_remap_index, 526 }, + { WindowPos3svMESA_names, WindowPos3svMESA_remap_index, 528 }, + { WindowPos2fMESA_names, WindowPos2fMESA_remap_index, 515 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_ATI_blend_equation_separate) static const struct dri_extension_function GL_ATI_blend_equation_separate_functions[] = { - { BlendEquationSeparateEXT_names, 710 }, - { NULL, 0 } + { BlendEquationSeparateEXT_names, BlendEquationSeparateEXT_remap_index, 710 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_ATI_draw_buffers) static const struct dri_extension_function GL_ATI_draw_buffers_functions[] = { - { DrawBuffersARB_names, 413 }, - { NULL, 0 } + { DrawBuffersARB_names, DrawBuffersARB_remap_index, 413 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_ATI_fragment_shader) static const struct dri_extension_function GL_ATI_fragment_shader_functions[] = { - { ColorFragmentOp3ATI_names, 791 }, - { ColorFragmentOp2ATI_names, 790 }, - { DeleteFragmentShaderATI_names, 784 }, - { SetFragmentShaderConstantATI_names, 795 }, - { SampleMapATI_names, 788 }, - { AlphaFragmentOp2ATI_names, 793 }, - { AlphaFragmentOp1ATI_names, 792 }, - { ColorFragmentOp1ATI_names, 789 }, - { AlphaFragmentOp3ATI_names, 794 }, - { PassTexCoordATI_names, 787 }, - { BeginFragmentShaderATI_names, 785 }, - { BindFragmentShaderATI_names, 783 }, - { GenFragmentShadersATI_names, 782 }, - { EndFragmentShaderATI_names, 786 }, - { NULL, 0 } + { ColorFragmentOp3ATI_names, ColorFragmentOp3ATI_remap_index, 791 }, + { ColorFragmentOp2ATI_names, ColorFragmentOp2ATI_remap_index, 790 }, + { DeleteFragmentShaderATI_names, DeleteFragmentShaderATI_remap_index, 784 }, + { SetFragmentShaderConstantATI_names, SetFragmentShaderConstantATI_remap_index, 795 }, + { SampleMapATI_names, SampleMapATI_remap_index, 788 }, + { AlphaFragmentOp2ATI_names, AlphaFragmentOp2ATI_remap_index, 793 }, + { AlphaFragmentOp1ATI_names, AlphaFragmentOp1ATI_remap_index, 792 }, + { ColorFragmentOp1ATI_names, ColorFragmentOp1ATI_remap_index, 789 }, + { AlphaFragmentOp3ATI_names, AlphaFragmentOp3ATI_remap_index, 794 }, + { PassTexCoordATI_names, PassTexCoordATI_remap_index, 787 }, + { BeginFragmentShaderATI_names, BeginFragmentShaderATI_remap_index, 785 }, + { BindFragmentShaderATI_names, BindFragmentShaderATI_remap_index, 783 }, + { GenFragmentShadersATI_names, GenFragmentShadersATI_remap_index, 782 }, + { EndFragmentShaderATI_names, EndFragmentShaderATI_remap_index, 786 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_blend_color) static const struct dri_extension_function GL_EXT_blend_color_functions[] = { - { BlendColor_names, 336 }, - { NULL, 0 } + { BlendColor_names, -1, 336 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_blend_equation_separate) static const struct dri_extension_function GL_EXT_blend_equation_separate_functions[] = { - { BlendEquationSeparateEXT_names, 710 }, - { NULL, 0 } + { BlendEquationSeparateEXT_names, BlendEquationSeparateEXT_remap_index, 710 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_blend_func_separate) static const struct dri_extension_function GL_EXT_blend_func_separate_functions[] = { - { BlendFuncSeparateEXT_names, 537 }, - { NULL, 0 } + { BlendFuncSeparateEXT_names, BlendFuncSeparateEXT_remap_index, 537 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_blend_minmax) static const struct dri_extension_function GL_EXT_blend_minmax_functions[] = { - { BlendEquation_names, 337 }, - { NULL, 0 } + { BlendEquation_names, -1, 337 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_color_subtable) static const struct dri_extension_function GL_EXT_color_subtable_functions[] = { - { ColorSubTable_names, 346 }, - { CopyColorSubTable_names, 347 }, - { NULL, 0 } + { ColorSubTable_names, -1, 346 }, + { CopyColorSubTable_names, -1, 347 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_compiled_vertex_array) static const struct dri_extension_function GL_EXT_compiled_vertex_array_functions[] = { - { UnlockArraysEXT_names, 541 }, - { LockArraysEXT_names, 540 }, - { NULL, 0 } + { UnlockArraysEXT_names, UnlockArraysEXT_remap_index, 541 }, + { LockArraysEXT_names, LockArraysEXT_remap_index, 540 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_convolution) static const struct dri_extension_function GL_EXT_convolution_functions[] = { - { ConvolutionFilter1D_names, 348 }, - { CopyConvolutionFilter1D_names, 354 }, - { ConvolutionFilter2D_names, 349 }, - { ConvolutionParameteriv_names, 353 }, - { ConvolutionParameterfv_names, 351 }, - { GetSeparableFilterEXT_names, 426 }, - { GetConvolutionFilterEXT_names, 423 }, - { GetConvolutionParameterfvEXT_names, 424 }, - { SeparableFilter2D_names, 360 }, - { ConvolutionParameteri_names, 352 }, - { ConvolutionParameterf_names, 350 }, - { GetConvolutionParameterivEXT_names, 425 }, - { CopyConvolutionFilter2D_names, 355 }, - { NULL, 0 } + { ConvolutionFilter1D_names, -1, 348 }, + { CopyConvolutionFilter1D_names, -1, 354 }, + { ConvolutionFilter2D_names, -1, 349 }, + { ConvolutionParameteriv_names, -1, 353 }, + { ConvolutionParameterfv_names, -1, 351 }, + { GetSeparableFilterEXT_names, GetSeparableFilterEXT_remap_index, 426 }, + { GetConvolutionFilterEXT_names, GetConvolutionFilterEXT_remap_index, 423 }, + { GetConvolutionParameterfvEXT_names, GetConvolutionParameterfvEXT_remap_index, 424 }, + { SeparableFilter2D_names, -1, 360 }, + { ConvolutionParameteri_names, -1, 352 }, + { ConvolutionParameterf_names, -1, 350 }, + { GetConvolutionParameterivEXT_names, GetConvolutionParameterivEXT_remap_index, 425 }, + { CopyConvolutionFilter2D_names, -1, 355 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_coordinate_frame) static const struct dri_extension_function GL_EXT_coordinate_frame_functions[] = { - { Binormal3fEXT_names, -1 }, - { TangentPointerEXT_names, -1 }, - { Binormal3ivEXT_names, -1 }, - { Tangent3sEXT_names, -1 }, - { Tangent3fvEXT_names, -1 }, - { Tangent3dvEXT_names, -1 }, - { Binormal3bvEXT_names, -1 }, - { Binormal3dEXT_names, -1 }, - { Tangent3fEXT_names, -1 }, - { Binormal3sEXT_names, -1 }, - { Tangent3ivEXT_names, -1 }, - { Tangent3dEXT_names, -1 }, - { Binormal3svEXT_names, -1 }, - { Binormal3dvEXT_names, -1 }, - { Tangent3iEXT_names, -1 }, - { Tangent3bvEXT_names, -1 }, - { Binormal3fvEXT_names, -1 }, - { Tangent3bEXT_names, -1 }, - { BinormalPointerEXT_names, -1 }, - { Tangent3svEXT_names, -1 }, - { Binormal3bEXT_names, -1 }, - { Binormal3iEXT_names, -1 }, - { NULL, 0 } + { Binormal3fEXT_names, Binormal3fEXT_remap_index, -1 }, + { TangentPointerEXT_names, TangentPointerEXT_remap_index, -1 }, + { Binormal3ivEXT_names, Binormal3ivEXT_remap_index, -1 }, + { Tangent3sEXT_names, Tangent3sEXT_remap_index, -1 }, + { Tangent3fvEXT_names, Tangent3fvEXT_remap_index, -1 }, + { Tangent3dvEXT_names, Tangent3dvEXT_remap_index, -1 }, + { Binormal3bvEXT_names, Binormal3bvEXT_remap_index, -1 }, + { Binormal3dEXT_names, Binormal3dEXT_remap_index, -1 }, + { Tangent3fEXT_names, Tangent3fEXT_remap_index, -1 }, + { Binormal3sEXT_names, Binormal3sEXT_remap_index, -1 }, + { Tangent3ivEXT_names, Tangent3ivEXT_remap_index, -1 }, + { Tangent3dEXT_names, Tangent3dEXT_remap_index, -1 }, + { Binormal3svEXT_names, Binormal3svEXT_remap_index, -1 }, + { Binormal3dvEXT_names, Binormal3dvEXT_remap_index, -1 }, + { Tangent3iEXT_names, Tangent3iEXT_remap_index, -1 }, + { Tangent3bvEXT_names, Tangent3bvEXT_remap_index, -1 }, + { Binormal3fvEXT_names, Binormal3fvEXT_remap_index, -1 }, + { Tangent3bEXT_names, Tangent3bEXT_remap_index, -1 }, + { BinormalPointerEXT_names, BinormalPointerEXT_remap_index, -1 }, + { Tangent3svEXT_names, Tangent3svEXT_remap_index, -1 }, + { Binormal3bEXT_names, Binormal3bEXT_remap_index, -1 }, + { Binormal3iEXT_names, Binormal3iEXT_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_copy_texture) static const struct dri_extension_function GL_EXT_copy_texture_functions[] = { - { CopyTexSubImage3D_names, 373 }, - { CopyTexImage2D_names, 324 }, - { CopyTexImage1D_names, 323 }, - { CopyTexSubImage2D_names, 326 }, - { CopyTexSubImage1D_names, 325 }, - { NULL, 0 } + { CopyTexSubImage3D_names, -1, 373 }, + { CopyTexImage2D_names, -1, 324 }, + { CopyTexImage1D_names, -1, 323 }, + { CopyTexSubImage2D_names, -1, 326 }, + { CopyTexSubImage1D_names, -1, 325 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_cull_vertex) static const struct dri_extension_function GL_EXT_cull_vertex_functions[] = { - { CullParameterdvEXT_names, 542 }, - { CullParameterfvEXT_names, 543 }, - { NULL, 0 } + { CullParameterdvEXT_names, CullParameterdvEXT_remap_index, 542 }, + { CullParameterfvEXT_names, CullParameterfvEXT_remap_index, 543 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_depth_bounds_test) static const struct dri_extension_function GL_EXT_depth_bounds_test_functions[] = { - { DepthBoundsEXT_names, 699 }, - { NULL, 0 } + { DepthBoundsEXT_names, DepthBoundsEXT_remap_index, 699 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_draw_range_elements) static const struct dri_extension_function GL_EXT_draw_range_elements_functions[] = { - { DrawRangeElements_names, 338 }, - { NULL, 0 } + { DrawRangeElements_names, -1, 338 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_fog_coord) static const struct dri_extension_function GL_EXT_fog_coord_functions[] = { - { FogCoorddEXT_names, 547 }, - { FogCoordfEXT_names, 545 }, - { FogCoordPointerEXT_names, 549 }, - { FogCoordfvEXT_names, 546 }, - { FogCoorddvEXT_names, 548 }, - { NULL, 0 } + { FogCoorddEXT_names, FogCoorddEXT_remap_index, 547 }, + { FogCoordfEXT_names, FogCoordfEXT_remap_index, 545 }, + { FogCoordPointerEXT_names, FogCoordPointerEXT_remap_index, 549 }, + { FogCoordfvEXT_names, FogCoordfvEXT_remap_index, 546 }, + { FogCoorddvEXT_names, FogCoorddvEXT_remap_index, 548 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_framebuffer_object) static const struct dri_extension_function GL_EXT_framebuffer_object_functions[] = { - { GenerateMipmapEXT_names, 812 }, - { IsRenderbufferEXT_names, 796 }, - { RenderbufferStorageEXT_names, 800 }, - { CheckFramebufferStatusEXT_names, 806 }, - { DeleteRenderbuffersEXT_names, 798 }, - { FramebufferTexture3DEXT_names, 809 }, - { FramebufferRenderbufferEXT_names, 810 }, - { FramebufferTexture1DEXT_names, 807 }, - { BindFramebufferEXT_names, 803 }, - { GenRenderbuffersEXT_names, 799 }, - { IsFramebufferEXT_names, 802 }, - { FramebufferTexture2DEXT_names, 808 }, - { GetFramebufferAttachmentParameterivEXT_names, 811 }, - { DeleteFramebuffersEXT_names, 804 }, - { GenFramebuffersEXT_names, 805 }, - { BindRenderbufferEXT_names, 797 }, - { GetRenderbufferParameterivEXT_names, 801 }, - { NULL, 0 } + { GenerateMipmapEXT_names, GenerateMipmapEXT_remap_index, 812 }, + { IsRenderbufferEXT_names, IsRenderbufferEXT_remap_index, 796 }, + { RenderbufferStorageEXT_names, RenderbufferStorageEXT_remap_index, 800 }, + { CheckFramebufferStatusEXT_names, CheckFramebufferStatusEXT_remap_index, 806 }, + { DeleteRenderbuffersEXT_names, DeleteRenderbuffersEXT_remap_index, 798 }, + { FramebufferTexture3DEXT_names, FramebufferTexture3DEXT_remap_index, 809 }, + { FramebufferRenderbufferEXT_names, FramebufferRenderbufferEXT_remap_index, 810 }, + { FramebufferTexture1DEXT_names, FramebufferTexture1DEXT_remap_index, 807 }, + { BindFramebufferEXT_names, BindFramebufferEXT_remap_index, 803 }, + { GenRenderbuffersEXT_names, GenRenderbuffersEXT_remap_index, 799 }, + { IsFramebufferEXT_names, IsFramebufferEXT_remap_index, 802 }, + { FramebufferTexture2DEXT_names, FramebufferTexture2DEXT_remap_index, 808 }, + { GetFramebufferAttachmentParameterivEXT_names, GetFramebufferAttachmentParameterivEXT_remap_index, 811 }, + { DeleteFramebuffersEXT_names, DeleteFramebuffersEXT_remap_index, 804 }, + { GenFramebuffersEXT_names, GenFramebuffersEXT_remap_index, 805 }, + { BindRenderbufferEXT_names, BindRenderbufferEXT_remap_index, 797 }, + { GetRenderbufferParameterivEXT_names, GetRenderbufferParameterivEXT_remap_index, 801 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_histogram) static const struct dri_extension_function GL_EXT_histogram_functions[] = { - { Histogram_names, 367 }, - { GetHistogramParameterivEXT_names, 419 }, - { ResetHistogram_names, 369 }, - { GetMinmaxEXT_names, 420 }, - { GetHistogramParameterfvEXT_names, 418 }, - { GetHistogramEXT_names, 417 }, - { GetMinmaxParameterfvEXT_names, 421 }, - { ResetMinmax_names, 370 }, - { GetMinmaxParameterivEXT_names, 422 }, - { Minmax_names, 368 }, - { NULL, 0 } + { Histogram_names, -1, 367 }, + { GetHistogramParameterivEXT_names, GetHistogramParameterivEXT_remap_index, 419 }, + { ResetHistogram_names, -1, 369 }, + { GetMinmaxEXT_names, GetMinmaxEXT_remap_index, 420 }, + { GetHistogramParameterfvEXT_names, GetHistogramParameterfvEXT_remap_index, 418 }, + { GetHistogramEXT_names, GetHistogramEXT_remap_index, 417 }, + { GetMinmaxParameterfvEXT_names, GetMinmaxParameterfvEXT_remap_index, 421 }, + { ResetMinmax_names, -1, 370 }, + { GetMinmaxParameterivEXT_names, GetMinmaxParameterivEXT_remap_index, 422 }, + { Minmax_names, -1, 368 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_index_func) static const struct dri_extension_function GL_EXT_index_func_functions[] = { - { IndexFuncEXT_names, 539 }, - { NULL, 0 } + { IndexFuncEXT_names, IndexFuncEXT_remap_index, 539 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_index_material) static const struct dri_extension_function GL_EXT_index_material_functions[] = { - { IndexMaterialEXT_names, 538 }, - { NULL, 0 } + { IndexMaterialEXT_names, IndexMaterialEXT_remap_index, 538 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_light_texture) static const struct dri_extension_function GL_EXT_light_texture_functions[] = { - { ApplyTextureEXT_names, -1 }, - { TextureMaterialEXT_names, -1 }, - { TextureLightEXT_names, -1 }, - { NULL, 0 } + { ApplyTextureEXT_names, ApplyTextureEXT_remap_index, -1 }, + { TextureMaterialEXT_names, TextureMaterialEXT_remap_index, -1 }, + { TextureLightEXT_names, TextureLightEXT_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_multi_draw_arrays) static const struct dri_extension_function GL_EXT_multi_draw_arrays_functions[] = { - { MultiDrawElementsEXT_names, 645 }, - { MultiDrawArraysEXT_names, 644 }, - { NULL, 0 } + { MultiDrawElementsEXT_names, MultiDrawElementsEXT_remap_index, 645 }, + { MultiDrawArraysEXT_names, MultiDrawArraysEXT_remap_index, 644 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_multisample) static const struct dri_extension_function GL_EXT_multisample_functions[] = { - { SampleMaskSGIS_names, 446 }, - { SamplePatternSGIS_names, 447 }, - { NULL, 0 } + { SampleMaskSGIS_names, SampleMaskSGIS_remap_index, 446 }, + { SamplePatternSGIS_names, SamplePatternSGIS_remap_index, 447 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_paletted_texture) static const struct dri_extension_function GL_EXT_paletted_texture_functions[] = { - { GetColorTableParameterivEXT_names, 551 }, - { GetColorTableEXT_names, 550 }, - { ColorTable_names, 339 }, - { GetColorTableParameterfvEXT_names, 552 }, - { NULL, 0 } + { GetColorTableParameterivEXT_names, GetColorTableParameterivEXT_remap_index, 551 }, + { GetColorTableEXT_names, GetColorTableEXT_remap_index, 550 }, + { ColorTable_names, -1, 339 }, + { GetColorTableParameterfvEXT_names, GetColorTableParameterfvEXT_remap_index, 552 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_pixel_transform) static const struct dri_extension_function GL_EXT_pixel_transform_functions[] = { - { PixelTransformParameterfvEXT_names, -1 }, - { PixelTransformParameteriEXT_names, -1 }, - { PixelTransformParameterfEXT_names, -1 }, - { PixelTransformParameterivEXT_names, -1 }, - { NULL, 0 } + { PixelTransformParameterfvEXT_names, PixelTransformParameterfvEXT_remap_index, -1 }, + { PixelTransformParameteriEXT_names, PixelTransformParameteriEXT_remap_index, -1 }, + { PixelTransformParameterfEXT_names, PixelTransformParameterfEXT_remap_index, -1 }, + { PixelTransformParameterivEXT_names, PixelTransformParameterivEXT_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_point_parameters) static const struct dri_extension_function GL_EXT_point_parameters_functions[] = { - { PointParameterfEXT_names, 458 }, - { PointParameterfvEXT_names, 459 }, - { NULL, 0 } + { PointParameterfEXT_names, PointParameterfEXT_remap_index, 458 }, + { PointParameterfvEXT_names, PointParameterfvEXT_remap_index, 459 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_polygon_offset) static const struct dri_extension_function GL_EXT_polygon_offset_functions[] = { - { PolygonOffsetEXT_names, 414 }, - { NULL, 0 } + { PolygonOffsetEXT_names, PolygonOffsetEXT_remap_index, 414 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_secondary_color) static const struct dri_extension_function GL_EXT_secondary_color_functions[] = { - { SecondaryColor3iEXT_names, 567 }, - { SecondaryColor3bEXT_names, 561 }, - { SecondaryColor3bvEXT_names, 562 }, - { SecondaryColor3sEXT_names, 569 }, - { SecondaryColor3dEXT_names, 563 }, - { SecondaryColorPointerEXT_names, 577 }, - { SecondaryColor3uiEXT_names, 573 }, - { SecondaryColor3usvEXT_names, 576 }, - { SecondaryColor3ivEXT_names, 568 }, - { SecondaryColor3fvEXT_names, 566 }, - { SecondaryColor3ubvEXT_names, 572 }, - { SecondaryColor3uivEXT_names, 574 }, - { SecondaryColor3dvEXT_names, 564 }, - { SecondaryColor3usEXT_names, 575 }, - { SecondaryColor3ubEXT_names, 571 }, - { SecondaryColor3fEXT_names, 565 }, - { SecondaryColor3svEXT_names, 570 }, - { NULL, 0 } + { SecondaryColor3iEXT_names, SecondaryColor3iEXT_remap_index, 567 }, + { SecondaryColor3bEXT_names, SecondaryColor3bEXT_remap_index, 561 }, + { SecondaryColor3bvEXT_names, SecondaryColor3bvEXT_remap_index, 562 }, + { SecondaryColor3sEXT_names, SecondaryColor3sEXT_remap_index, 569 }, + { SecondaryColor3dEXT_names, SecondaryColor3dEXT_remap_index, 563 }, + { SecondaryColorPointerEXT_names, SecondaryColorPointerEXT_remap_index, 577 }, + { SecondaryColor3uiEXT_names, SecondaryColor3uiEXT_remap_index, 573 }, + { SecondaryColor3usvEXT_names, SecondaryColor3usvEXT_remap_index, 576 }, + { SecondaryColor3ivEXT_names, SecondaryColor3ivEXT_remap_index, 568 }, + { SecondaryColor3fvEXT_names, SecondaryColor3fvEXT_remap_index, 566 }, + { SecondaryColor3ubvEXT_names, SecondaryColor3ubvEXT_remap_index, 572 }, + { SecondaryColor3uivEXT_names, SecondaryColor3uivEXT_remap_index, 574 }, + { SecondaryColor3dvEXT_names, SecondaryColor3dvEXT_remap_index, 564 }, + { SecondaryColor3usEXT_names, SecondaryColor3usEXT_remap_index, 575 }, + { SecondaryColor3ubEXT_names, SecondaryColor3ubEXT_remap_index, 571 }, + { SecondaryColor3fEXT_names, SecondaryColor3fEXT_remap_index, 565 }, + { SecondaryColor3svEXT_names, SecondaryColor3svEXT_remap_index, 570 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_stencil_two_side) static const struct dri_extension_function GL_EXT_stencil_two_side_functions[] = { - { ActiveStencilFaceEXT_names, 646 }, - { NULL, 0 } + { ActiveStencilFaceEXT_names, ActiveStencilFaceEXT_remap_index, 646 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_subtexture) static const struct dri_extension_function GL_EXT_subtexture_functions[] = { - { TexSubImage1D_names, 332 }, - { TexSubImage2D_names, 333 }, - { NULL, 0 } + { TexSubImage1D_names, -1, 332 }, + { TexSubImage2D_names, -1, 333 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_texture3D) static const struct dri_extension_function GL_EXT_texture3D_functions[] = { - { TexImage3D_names, 371 }, - { TexSubImage3D_names, 372 }, - { NULL, 0 } + { TexImage3D_names, -1, 371 }, + { TexSubImage3D_names, -1, 372 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_texture_object) static const struct dri_extension_function GL_EXT_texture_object_functions[] = { - { PrioritizeTextures_names, 331 }, - { DeleteTextures_names, 327 }, - { GenTexturesEXT_names, 440 }, - { AreTexturesResidentEXT_names, 439 }, - { BindTexture_names, 307 }, - { IsTextureEXT_names, 441 }, - { NULL, 0 } + { PrioritizeTextures_names, -1, 331 }, + { DeleteTextures_names, -1, 327 }, + { GenTexturesEXT_names, GenTexturesEXT_remap_index, 440 }, + { AreTexturesResidentEXT_names, AreTexturesResidentEXT_remap_index, 439 }, + { BindTexture_names, -1, 307 }, + { IsTextureEXT_names, IsTextureEXT_remap_index, 441 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_texture_perturb_normal) static const struct dri_extension_function GL_EXT_texture_perturb_normal_functions[] = { - { TextureNormalEXT_names, -1 }, - { NULL, 0 } + { TextureNormalEXT_names, TextureNormalEXT_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_vertex_array) static const struct dri_extension_function GL_EXT_vertex_array_functions[] = { - { IndexPointerEXT_names, 450 }, - { NormalPointerEXT_names, 451 }, - { VertexPointerEXT_names, 453 }, - { TexCoordPointerEXT_names, 452 }, - { EdgeFlagPointerEXT_names, 449 }, - { ArrayElement_names, 306 }, - { ColorPointerEXT_names, 448 }, - { GetPointerv_names, 329 }, - { DrawArrays_names, 310 }, - { NULL, 0 } + { IndexPointerEXT_names, IndexPointerEXT_remap_index, 450 }, + { NormalPointerEXT_names, NormalPointerEXT_remap_index, 451 }, + { VertexPointerEXT_names, VertexPointerEXT_remap_index, 453 }, + { TexCoordPointerEXT_names, TexCoordPointerEXT_remap_index, 452 }, + { EdgeFlagPointerEXT_names, EdgeFlagPointerEXT_remap_index, 449 }, + { ArrayElement_names, -1, 306 }, + { ColorPointerEXT_names, ColorPointerEXT_remap_index, 448 }, + { GetPointerv_names, -1, 329 }, + { DrawArrays_names, -1, 310 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_EXT_vertex_weighting) static const struct dri_extension_function GL_EXT_vertex_weighting_functions[] = { - { VertexWeightfvEXT_names, 495 }, - { VertexWeightfEXT_names, 494 }, - { VertexWeightPointerEXT_names, 496 }, - { NULL, 0 } + { VertexWeightfvEXT_names, VertexWeightfvEXT_remap_index, 495 }, + { VertexWeightfEXT_names, VertexWeightfEXT_remap_index, 494 }, + { VertexWeightPointerEXT_names, VertexWeightPointerEXT_remap_index, 496 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_HP_image_transform) static const struct dri_extension_function GL_HP_image_transform_functions[] = { - { GetImageTransformParameterfvHP_names, -1 }, - { ImageTransformParameterfHP_names, -1 }, - { ImageTransformParameterfvHP_names, -1 }, - { ImageTransformParameteriHP_names, -1 }, - { GetImageTransformParameterivHP_names, -1 }, - { ImageTransformParameterivHP_names, -1 }, - { NULL, 0 } + { GetImageTransformParameterfvHP_names, GetImageTransformParameterfvHP_remap_index, -1 }, + { ImageTransformParameterfHP_names, ImageTransformParameterfHP_remap_index, -1 }, + { ImageTransformParameterfvHP_names, ImageTransformParameterfvHP_remap_index, -1 }, + { ImageTransformParameteriHP_names, ImageTransformParameteriHP_remap_index, -1 }, + { GetImageTransformParameterivHP_names, GetImageTransformParameterivHP_remap_index, -1 }, + { ImageTransformParameterivHP_names, ImageTransformParameterivHP_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_IBM_multimode_draw_arrays) static const struct dri_extension_function GL_IBM_multimode_draw_arrays_functions[] = { - { MultiModeDrawArraysIBM_names, 708 }, - { MultiModeDrawElementsIBM_names, 709 }, - { NULL, 0 } + { MultiModeDrawArraysIBM_names, MultiModeDrawArraysIBM_remap_index, 708 }, + { MultiModeDrawElementsIBM_names, MultiModeDrawElementsIBM_remap_index, 709 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_IBM_vertex_array_lists) static const struct dri_extension_function GL_IBM_vertex_array_lists_functions[] = { - { SecondaryColorPointerListIBM_names, -1 }, - { NormalPointerListIBM_names, -1 }, - { FogCoordPointerListIBM_names, -1 }, - { VertexPointerListIBM_names, -1 }, - { ColorPointerListIBM_names, -1 }, - { TexCoordPointerListIBM_names, -1 }, - { IndexPointerListIBM_names, -1 }, - { EdgeFlagPointerListIBM_names, -1 }, - { NULL, 0 } + { SecondaryColorPointerListIBM_names, SecondaryColorPointerListIBM_remap_index, -1 }, + { NormalPointerListIBM_names, NormalPointerListIBM_remap_index, -1 }, + { FogCoordPointerListIBM_names, FogCoordPointerListIBM_remap_index, -1 }, + { VertexPointerListIBM_names, VertexPointerListIBM_remap_index, -1 }, + { ColorPointerListIBM_names, ColorPointerListIBM_remap_index, -1 }, + { TexCoordPointerListIBM_names, TexCoordPointerListIBM_remap_index, -1 }, + { IndexPointerListIBM_names, IndexPointerListIBM_remap_index, -1 }, + { EdgeFlagPointerListIBM_names, EdgeFlagPointerListIBM_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_INGR_blend_func_separate) static const struct dri_extension_function GL_INGR_blend_func_separate_functions[] = { - { BlendFuncSeparateEXT_names, 537 }, - { NULL, 0 } + { BlendFuncSeparateEXT_names, BlendFuncSeparateEXT_remap_index, 537 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_INTEL_parallel_arrays) static const struct dri_extension_function GL_INTEL_parallel_arrays_functions[] = { - { VertexPointervINTEL_names, -1 }, - { ColorPointervINTEL_names, -1 }, - { NormalPointervINTEL_names, -1 }, - { TexCoordPointervINTEL_names, -1 }, - { NULL, 0 } + { VertexPointervINTEL_names, VertexPointervINTEL_remap_index, -1 }, + { ColorPointervINTEL_names, ColorPointervINTEL_remap_index, -1 }, + { NormalPointervINTEL_names, NormalPointervINTEL_remap_index, -1 }, + { TexCoordPointervINTEL_names, TexCoordPointervINTEL_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_MESA_resize_buffers) static const struct dri_extension_function GL_MESA_resize_buffers_functions[] = { - { ResizeBuffersMESA_names, 512 }, - { NULL, 0 } + { ResizeBuffersMESA_names, ResizeBuffersMESA_remap_index, 512 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_MESA_window_pos) static const struct dri_extension_function GL_MESA_window_pos_functions[] = { - { WindowPos3fMESA_names, 523 }, - { WindowPos2dvMESA_names, 514 }, - { WindowPos4svMESA_names, 536 }, - { WindowPos2svMESA_names, 520 }, - { WindowPos3dMESA_names, 521 }, - { WindowPos2fvMESA_names, 516 }, - { WindowPos4dMESA_names, 529 }, - { WindowPos2dMESA_names, 513 }, - { WindowPos4ivMESA_names, 534 }, - { WindowPos4fMESA_names, 531 }, - { WindowPos3dvMESA_names, 522 }, - { WindowPos3fvMESA_names, 524 }, - { WindowPos4dvMESA_names, 530 }, - { WindowPos2iMESA_names, 517 }, - { WindowPos3sMESA_names, 527 }, - { WindowPos4sMESA_names, 535 }, - { WindowPos2ivMESA_names, 518 }, - { WindowPos2sMESA_names, 519 }, - { WindowPos3iMESA_names, 525 }, - { WindowPos3ivMESA_names, 526 }, - { WindowPos4iMESA_names, 533 }, - { WindowPos4fvMESA_names, 532 }, - { WindowPos3svMESA_names, 528 }, - { WindowPos2fMESA_names, 515 }, - { NULL, 0 } + { WindowPos3fMESA_names, WindowPos3fMESA_remap_index, 523 }, + { WindowPos2dvMESA_names, WindowPos2dvMESA_remap_index, 514 }, + { WindowPos4svMESA_names, WindowPos4svMESA_remap_index, 536 }, + { WindowPos2svMESA_names, WindowPos2svMESA_remap_index, 520 }, + { WindowPos3dMESA_names, WindowPos3dMESA_remap_index, 521 }, + { WindowPos2fvMESA_names, WindowPos2fvMESA_remap_index, 516 }, + { WindowPos4dMESA_names, WindowPos4dMESA_remap_index, 529 }, + { WindowPos2dMESA_names, WindowPos2dMESA_remap_index, 513 }, + { WindowPos4ivMESA_names, WindowPos4ivMESA_remap_index, 534 }, + { WindowPos4fMESA_names, WindowPos4fMESA_remap_index, 531 }, + { WindowPos3dvMESA_names, WindowPos3dvMESA_remap_index, 522 }, + { WindowPos3fvMESA_names, WindowPos3fvMESA_remap_index, 524 }, + { WindowPos4dvMESA_names, WindowPos4dvMESA_remap_index, 530 }, + { WindowPos2iMESA_names, WindowPos2iMESA_remap_index, 517 }, + { WindowPos3sMESA_names, WindowPos3sMESA_remap_index, 527 }, + { WindowPos4sMESA_names, WindowPos4sMESA_remap_index, 535 }, + { WindowPos2ivMESA_names, WindowPos2ivMESA_remap_index, 518 }, + { WindowPos2sMESA_names, WindowPos2sMESA_remap_index, 519 }, + { WindowPos3iMESA_names, WindowPos3iMESA_remap_index, 525 }, + { WindowPos3ivMESA_names, WindowPos3ivMESA_remap_index, 526 }, + { WindowPos4iMESA_names, WindowPos4iMESA_remap_index, 533 }, + { WindowPos4fvMESA_names, WindowPos4fvMESA_remap_index, 532 }, + { WindowPos3svMESA_names, WindowPos3svMESA_remap_index, 528 }, + { WindowPos2fMESA_names, WindowPos2fMESA_remap_index, 515 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_NV_evaluators) static const struct dri_extension_function GL_NV_evaluators_functions[] = { - { GetMapAttribParameterivNV_names, -1 }, - { MapControlPointsNV_names, -1 }, - { MapParameterfvNV_names, -1 }, - { EvalMapsNV_names, -1 }, - { GetMapAttribParameterfvNV_names, -1 }, - { MapParameterivNV_names, -1 }, - { GetMapParameterivNV_names, -1 }, - { GetMapParameterfvNV_names, -1 }, - { GetMapControlPointsNV_names, -1 }, - { NULL, 0 } + { GetMapAttribParameterivNV_names, GetMapAttribParameterivNV_remap_index, -1 }, + { MapControlPointsNV_names, MapControlPointsNV_remap_index, -1 }, + { MapParameterfvNV_names, MapParameterfvNV_remap_index, -1 }, + { EvalMapsNV_names, EvalMapsNV_remap_index, -1 }, + { GetMapAttribParameterfvNV_names, GetMapAttribParameterfvNV_remap_index, -1 }, + { MapParameterivNV_names, MapParameterivNV_remap_index, -1 }, + { GetMapParameterivNV_names, GetMapParameterivNV_remap_index, -1 }, + { GetMapParameterfvNV_names, GetMapParameterfvNV_remap_index, -1 }, + { GetMapControlPointsNV_names, GetMapControlPointsNV_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_NV_fence) static const struct dri_extension_function GL_NV_fence_functions[] = { - { GenFencesNV_names, 648 }, - { TestFenceNV_names, 650 }, - { IsFenceNV_names, 649 }, - { DeleteFencesNV_names, 647 }, - { SetFenceNV_names, 653 }, - { GetFenceivNV_names, 651 }, - { FinishFenceNV_names, 652 }, - { NULL, 0 } + { GenFencesNV_names, GenFencesNV_remap_index, 648 }, + { TestFenceNV_names, TestFenceNV_remap_index, 650 }, + { IsFenceNV_names, IsFenceNV_remap_index, 649 }, + { DeleteFencesNV_names, DeleteFencesNV_remap_index, 647 }, + { SetFenceNV_names, SetFenceNV_remap_index, 653 }, + { GetFenceivNV_names, GetFenceivNV_remap_index, 651 }, + { FinishFenceNV_names, FinishFenceNV_remap_index, 652 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_NV_fragment_program) static const struct dri_extension_function GL_NV_fragment_program_functions[] = { - { GetProgramNamedParameterdvNV_names, 687 }, - { GetProgramNamedParameterfvNV_names, 686 }, - { ProgramNamedParameter4fNV_names, 682 }, - { ProgramNamedParameter4fvNV_names, 684 }, - { ProgramNamedParameter4dvNV_names, 685 }, - { ProgramNamedParameter4dNV_names, 683 }, - { NULL, 0 } + { GetProgramNamedParameterdvNV_names, GetProgramNamedParameterdvNV_remap_index, 687 }, + { GetProgramNamedParameterfvNV_names, GetProgramNamedParameterfvNV_remap_index, 686 }, + { ProgramNamedParameter4fNV_names, ProgramNamedParameter4fNV_remap_index, 682 }, + { ProgramNamedParameter4fvNV_names, ProgramNamedParameter4fvNV_remap_index, 684 }, + { ProgramNamedParameter4dvNV_names, ProgramNamedParameter4dvNV_remap_index, 685 }, + { ProgramNamedParameter4dNV_names, ProgramNamedParameter4dNV_remap_index, 683 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_NV_point_sprite) static const struct dri_extension_function GL_NV_point_sprite_functions[] = { - { PointParameteriNV_names, 642 }, - { PointParameterivNV_names, 643 }, - { NULL, 0 } + { PointParameteriNV_names, PointParameteriNV_remap_index, 642 }, + { PointParameterivNV_names, PointParameterivNV_remap_index, 643 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_NV_register_combiners) static const struct dri_extension_function GL_NV_register_combiners_functions[] = { - { CombinerParameterfvNV_names, 499 }, - { GetCombinerOutputParameterfvNV_names, 508 }, - { FinalCombinerInputNV_names, 505 }, - { GetCombinerInputParameterfvNV_names, 506 }, - { GetCombinerOutputParameterivNV_names, 509 }, - { CombinerOutputNV_names, 504 }, - { CombinerParameteriNV_names, 502 }, - { GetFinalCombinerInputParameterivNV_names, 511 }, - { CombinerInputNV_names, 503 }, - { CombinerParameterfNV_names, 500 }, - { GetFinalCombinerInputParameterfvNV_names, 510 }, - { GetCombinerInputParameterivNV_names, 507 }, - { CombinerParameterivNV_names, 501 }, - { NULL, 0 } + { CombinerParameterfvNV_names, CombinerParameterfvNV_remap_index, 499 }, + { GetCombinerOutputParameterfvNV_names, GetCombinerOutputParameterfvNV_remap_index, 508 }, + { FinalCombinerInputNV_names, FinalCombinerInputNV_remap_index, 505 }, + { GetCombinerInputParameterfvNV_names, GetCombinerInputParameterfvNV_remap_index, 506 }, + { GetCombinerOutputParameterivNV_names, GetCombinerOutputParameterivNV_remap_index, 509 }, + { CombinerOutputNV_names, CombinerOutputNV_remap_index, 504 }, + { CombinerParameteriNV_names, CombinerParameteriNV_remap_index, 502 }, + { GetFinalCombinerInputParameterivNV_names, GetFinalCombinerInputParameterivNV_remap_index, 511 }, + { CombinerInputNV_names, CombinerInputNV_remap_index, 503 }, + { CombinerParameterfNV_names, CombinerParameterfNV_remap_index, 500 }, + { GetFinalCombinerInputParameterfvNV_names, GetFinalCombinerInputParameterfvNV_remap_index, 510 }, + { GetCombinerInputParameterivNV_names, GetCombinerInputParameterivNV_remap_index, 507 }, + { CombinerParameterivNV_names, CombinerParameterivNV_remap_index, 501 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_NV_register_combiners2) static const struct dri_extension_function GL_NV_register_combiners2_functions[] = { - { CombinerStageParameterfvNV_names, -1 }, - { GetCombinerStageParameterfvNV_names, -1 }, - { NULL, 0 } + { CombinerStageParameterfvNV_names, CombinerStageParameterfvNV_remap_index, -1 }, + { GetCombinerStageParameterfvNV_names, GetCombinerStageParameterfvNV_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_NV_vertex_array_range) static const struct dri_extension_function GL_NV_vertex_array_range_functions[] = { - { FlushVertexArrayRangeNV_names, 497 }, - { VertexArrayRangeNV_names, 498 }, - { NULL, 0 } + { FlushVertexArrayRangeNV_names, FlushVertexArrayRangeNV_remap_index, 497 }, + { VertexArrayRangeNV_names, VertexArrayRangeNV_remap_index, 498 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_NV_vertex_program) static const struct dri_extension_function GL_NV_vertex_program_functions[] = { - { ProgramParameter4fNV_names, 596 }, - { VertexAttrib4ubvNV_names, 781 }, - { VertexAttrib4svNV_names, 779 }, - { VertexAttribs1dvNV_names, 629 }, - { ProgramParameter4dvNV_names, 595 }, - { VertexAttrib4fNV_names, 776 }, - { VertexAttrib2dNV_names, 762 }, - { VertexAttrib4ubNV_names, 780 }, - { VertexAttribs3dvNV_names, 635 }, - { VertexAttribs4fvNV_names, 639 }, - { VertexAttrib2sNV_names, 766 }, - { VertexAttribs3fvNV_names, 636 }, - { ProgramParameter4dNV_names, 594 }, - { LoadProgramNV_names, 593 }, - { VertexAttrib4fvNV_names, 777 }, - { VertexAttrib3fNV_names, 770 }, - { VertexAttribs2dvNV_names, 632 }, - { GetProgramParameterfvNV_names, 584 }, - { VertexAttrib3dNV_names, 768 }, - { VertexAttrib2fvNV_names, 765 }, - { VertexAttrib2dvNV_names, 763 }, - { VertexAttrib1dvNV_names, 757 }, - { ProgramParameter4fvNV_names, 597 }, - { VertexAttrib1svNV_names, 761 }, - { VertexAttribs2svNV_names, 634 }, - { GetVertexAttribivNV_names, 755 }, - { GetVertexAttribfvNV_names, 754 }, - { VertexAttrib2svNV_names, 767 }, - { VertexAttribs1fvNV_names, 630 }, - { IsProgramNV_names, 592 }, - { VertexAttrib4sNV_names, 778 }, - { VertexAttrib2fNV_names, 764 }, - { RequestResidentProgramsNV_names, 600 }, - { ExecuteProgramNV_names, 581 }, - { VertexAttribPointerNV_names, 602 }, - { TrackMatrixNV_names, 601 }, - { GetProgramParameterdvNV_names, 583 }, - { VertexAttrib3sNV_names, 772 }, - { GetTrackMatrixivNV_names, 587 }, - { VertexAttrib3svNV_names, 773 }, - { ProgramParameters4fvNV_names, 599 }, - { GetProgramivNV_names, 585 }, - { GetVertexAttribdvNV_names, 753 }, - { VertexAttrib3fvNV_names, 771 }, - { VertexAttribs2fvNV_names, 633 }, - { VertexAttrib1fvNV_names, 759 }, - { DeleteProgramsNV_names, 580 }, - { GetVertexAttribPointervNV_names, 591 }, - { GetProgramStringNV_names, 586 }, - { VertexAttribs4dvNV_names, 638 }, - { ProgramParameters4dvNV_names, 598 }, - { VertexAttrib1fNV_names, 758 }, - { VertexAttrib4dNV_names, 774 }, - { VertexAttribs4ubvNV_names, 641 }, - { VertexAttribs3svNV_names, 637 }, - { VertexAttrib1sNV_names, 760 }, - { BindProgramNV_names, 579 }, - { AreProgramsResidentNV_names, 578 }, - { VertexAttrib3dvNV_names, 769 }, - { VertexAttrib1dNV_names, 756 }, - { VertexAttribs4svNV_names, 640 }, - { VertexAttribs1svNV_names, 631 }, - { GenProgramsNV_names, 582 }, - { VertexAttrib4dvNV_names, 775 }, - { NULL, 0 } + { ProgramParameter4fNV_names, ProgramParameter4fNV_remap_index, 596 }, + { VertexAttrib4ubvNV_names, VertexAttrib4ubvNV_remap_index, 781 }, + { VertexAttrib4svNV_names, VertexAttrib4svNV_remap_index, 779 }, + { VertexAttribs1dvNV_names, VertexAttribs1dvNV_remap_index, 629 }, + { ProgramParameter4dvNV_names, ProgramParameter4dvNV_remap_index, 595 }, + { VertexAttrib4fNV_names, VertexAttrib4fNV_remap_index, 776 }, + { VertexAttrib2dNV_names, VertexAttrib2dNV_remap_index, 762 }, + { VertexAttrib4ubNV_names, VertexAttrib4ubNV_remap_index, 780 }, + { VertexAttribs3dvNV_names, VertexAttribs3dvNV_remap_index, 635 }, + { VertexAttribs4fvNV_names, VertexAttribs4fvNV_remap_index, 639 }, + { VertexAttrib2sNV_names, VertexAttrib2sNV_remap_index, 766 }, + { VertexAttribs3fvNV_names, VertexAttribs3fvNV_remap_index, 636 }, + { ProgramParameter4dNV_names, ProgramParameter4dNV_remap_index, 594 }, + { LoadProgramNV_names, LoadProgramNV_remap_index, 593 }, + { VertexAttrib4fvNV_names, VertexAttrib4fvNV_remap_index, 777 }, + { VertexAttrib3fNV_names, VertexAttrib3fNV_remap_index, 770 }, + { VertexAttribs2dvNV_names, VertexAttribs2dvNV_remap_index, 632 }, + { GetProgramParameterfvNV_names, GetProgramParameterfvNV_remap_index, 584 }, + { VertexAttrib3dNV_names, VertexAttrib3dNV_remap_index, 768 }, + { VertexAttrib2fvNV_names, VertexAttrib2fvNV_remap_index, 765 }, + { VertexAttrib2dvNV_names, VertexAttrib2dvNV_remap_index, 763 }, + { VertexAttrib1dvNV_names, VertexAttrib1dvNV_remap_index, 757 }, + { ProgramParameter4fvNV_names, ProgramParameter4fvNV_remap_index, 597 }, + { VertexAttrib1svNV_names, VertexAttrib1svNV_remap_index, 761 }, + { VertexAttribs2svNV_names, VertexAttribs2svNV_remap_index, 634 }, + { GetVertexAttribivNV_names, GetVertexAttribivNV_remap_index, 755 }, + { GetVertexAttribfvNV_names, GetVertexAttribfvNV_remap_index, 754 }, + { VertexAttrib2svNV_names, VertexAttrib2svNV_remap_index, 767 }, + { VertexAttribs1fvNV_names, VertexAttribs1fvNV_remap_index, 630 }, + { IsProgramNV_names, IsProgramNV_remap_index, 592 }, + { VertexAttrib4sNV_names, VertexAttrib4sNV_remap_index, 778 }, + { VertexAttrib2fNV_names, VertexAttrib2fNV_remap_index, 764 }, + { RequestResidentProgramsNV_names, RequestResidentProgramsNV_remap_index, 600 }, + { ExecuteProgramNV_names, ExecuteProgramNV_remap_index, 581 }, + { VertexAttribPointerNV_names, VertexAttribPointerNV_remap_index, 602 }, + { TrackMatrixNV_names, TrackMatrixNV_remap_index, 601 }, + { GetProgramParameterdvNV_names, GetProgramParameterdvNV_remap_index, 583 }, + { VertexAttrib3sNV_names, VertexAttrib3sNV_remap_index, 772 }, + { GetTrackMatrixivNV_names, GetTrackMatrixivNV_remap_index, 587 }, + { VertexAttrib3svNV_names, VertexAttrib3svNV_remap_index, 773 }, + { ProgramParameters4fvNV_names, ProgramParameters4fvNV_remap_index, 599 }, + { GetProgramivNV_names, GetProgramivNV_remap_index, 585 }, + { GetVertexAttribdvNV_names, GetVertexAttribdvNV_remap_index, 753 }, + { VertexAttrib3fvNV_names, VertexAttrib3fvNV_remap_index, 771 }, + { VertexAttribs2fvNV_names, VertexAttribs2fvNV_remap_index, 633 }, + { VertexAttrib1fvNV_names, VertexAttrib1fvNV_remap_index, 759 }, + { DeleteProgramsNV_names, DeleteProgramsNV_remap_index, 580 }, + { GetVertexAttribPointervNV_names, GetVertexAttribPointervNV_remap_index, 591 }, + { GetProgramStringNV_names, GetProgramStringNV_remap_index, 586 }, + { VertexAttribs4dvNV_names, VertexAttribs4dvNV_remap_index, 638 }, + { ProgramParameters4dvNV_names, ProgramParameters4dvNV_remap_index, 598 }, + { VertexAttrib1fNV_names, VertexAttrib1fNV_remap_index, 758 }, + { VertexAttrib4dNV_names, VertexAttrib4dNV_remap_index, 774 }, + { VertexAttribs4ubvNV_names, VertexAttribs4ubvNV_remap_index, 641 }, + { VertexAttribs3svNV_names, VertexAttribs3svNV_remap_index, 637 }, + { VertexAttrib1sNV_names, VertexAttrib1sNV_remap_index, 760 }, + { BindProgramNV_names, BindProgramNV_remap_index, 579 }, + { AreProgramsResidentNV_names, AreProgramsResidentNV_remap_index, 578 }, + { VertexAttrib3dvNV_names, VertexAttrib3dvNV_remap_index, 769 }, + { VertexAttrib1dNV_names, VertexAttrib1dNV_remap_index, 756 }, + { VertexAttribs4svNV_names, VertexAttribs4svNV_remap_index, 640 }, + { VertexAttribs1svNV_names, VertexAttribs1svNV_remap_index, 631 }, + { GenProgramsNV_names, GenProgramsNV_remap_index, 582 }, + { VertexAttrib4dvNV_names, VertexAttrib4dvNV_remap_index, 775 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_PGI_misc_hints) static const struct dri_extension_function GL_PGI_misc_hints_functions[] = { - { HintPGI_names, 544 }, - { NULL, 0 } + { HintPGI_names, HintPGI_remap_index, 544 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIS_detail_texture) static const struct dri_extension_function GL_SGIS_detail_texture_functions[] = { - { GetDetailTexFuncSGIS_names, 443 }, - { DetailTexFuncSGIS_names, 442 }, - { NULL, 0 } + { GetDetailTexFuncSGIS_names, GetDetailTexFuncSGIS_remap_index, 443 }, + { DetailTexFuncSGIS_names, DetailTexFuncSGIS_remap_index, 442 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIS_fog_function) static const struct dri_extension_function GL_SGIS_fog_function_functions[] = { - { FogFuncSGIS_names, -1 }, - { GetFogFuncSGIS_names, -1 }, - { NULL, 0 } + { FogFuncSGIS_names, FogFuncSGIS_remap_index, -1 }, + { GetFogFuncSGIS_names, GetFogFuncSGIS_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIS_multisample) static const struct dri_extension_function GL_SGIS_multisample_functions[] = { - { SampleMaskSGIS_names, 446 }, - { SamplePatternSGIS_names, 447 }, - { NULL, 0 } + { SampleMaskSGIS_names, SampleMaskSGIS_remap_index, 446 }, + { SamplePatternSGIS_names, SamplePatternSGIS_remap_index, 447 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIS_pixel_texture) static const struct dri_extension_function GL_SGIS_pixel_texture_functions[] = { - { PixelTexGenParameterfvSGIS_names, 434 }, - { GetPixelTexGenParameterivSGIS_names, 435 }, - { PixelTexGenParameteriSGIS_names, 431 }, - { PixelTexGenParameterivSGIS_names, 432 }, - { PixelTexGenParameterfSGIS_names, 433 }, - { GetPixelTexGenParameterfvSGIS_names, 436 }, - { NULL, 0 } + { PixelTexGenParameterfvSGIS_names, PixelTexGenParameterfvSGIS_remap_index, 434 }, + { GetPixelTexGenParameterivSGIS_names, GetPixelTexGenParameterivSGIS_remap_index, 435 }, + { PixelTexGenParameteriSGIS_names, PixelTexGenParameteriSGIS_remap_index, 431 }, + { PixelTexGenParameterivSGIS_names, PixelTexGenParameterivSGIS_remap_index, 432 }, + { PixelTexGenParameterfSGIS_names, PixelTexGenParameterfSGIS_remap_index, 433 }, + { GetPixelTexGenParameterfvSGIS_names, GetPixelTexGenParameterfvSGIS_remap_index, 436 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIS_point_parameters) static const struct dri_extension_function GL_SGIS_point_parameters_functions[] = { - { PointParameterfEXT_names, 458 }, - { PointParameterfvEXT_names, 459 }, - { NULL, 0 } + { PointParameterfEXT_names, PointParameterfEXT_remap_index, 458 }, + { PointParameterfvEXT_names, PointParameterfvEXT_remap_index, 459 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIS_sharpen_texture) static const struct dri_extension_function GL_SGIS_sharpen_texture_functions[] = { - { GetSharpenTexFuncSGIS_names, 445 }, - { SharpenTexFuncSGIS_names, 444 }, - { NULL, 0 } + { GetSharpenTexFuncSGIS_names, GetSharpenTexFuncSGIS_remap_index, 445 }, + { SharpenTexFuncSGIS_names, SharpenTexFuncSGIS_remap_index, 444 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIS_texture4D) static const struct dri_extension_function GL_SGIS_texture4D_functions[] = { - { TexImage4DSGIS_names, 437 }, - { TexSubImage4DSGIS_names, 438 }, - { NULL, 0 } + { TexImage4DSGIS_names, TexImage4DSGIS_remap_index, 437 }, + { TexSubImage4DSGIS_names, TexSubImage4DSGIS_remap_index, 438 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIS_texture_color_mask) static const struct dri_extension_function GL_SGIS_texture_color_mask_functions[] = { - { TextureColorMaskSGIS_names, -1 }, - { NULL, 0 } + { TextureColorMaskSGIS_names, TextureColorMaskSGIS_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIS_texture_filter4) static const struct dri_extension_function GL_SGIS_texture_filter4_functions[] = { - { GetTexFilterFuncSGIS_names, 415 }, - { TexFilterFuncSGIS_names, 416 }, - { NULL, 0 } + { GetTexFilterFuncSGIS_names, GetTexFilterFuncSGIS_remap_index, 415 }, + { TexFilterFuncSGIS_names, TexFilterFuncSGIS_remap_index, 416 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIX_async) static const struct dri_extension_function GL_SGIX_async_functions[] = { - { AsyncMarkerSGIX_names, -1 }, - { FinishAsyncSGIX_names, -1 }, - { PollAsyncSGIX_names, -1 }, - { DeleteAsyncMarkersSGIX_names, -1 }, - { IsAsyncMarkerSGIX_names, -1 }, - { GenAsyncMarkersSGIX_names, -1 }, - { NULL, 0 } + { AsyncMarkerSGIX_names, AsyncMarkerSGIX_remap_index, -1 }, + { FinishAsyncSGIX_names, FinishAsyncSGIX_remap_index, -1 }, + { PollAsyncSGIX_names, PollAsyncSGIX_remap_index, -1 }, + { DeleteAsyncMarkersSGIX_names, DeleteAsyncMarkersSGIX_remap_index, -1 }, + { IsAsyncMarkerSGIX_names, IsAsyncMarkerSGIX_remap_index, -1 }, + { GenAsyncMarkersSGIX_names, GenAsyncMarkersSGIX_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIX_flush_raster) static const struct dri_extension_function GL_SGIX_flush_raster_functions[] = { - { FlushRasterSGIX_names, 469 }, - { NULL, 0 } + { FlushRasterSGIX_names, FlushRasterSGIX_remap_index, 469 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIX_fragment_lighting) static const struct dri_extension_function GL_SGIX_fragment_lighting_functions[] = { - { FragmentMaterialfvSGIX_names, 486 }, - { FragmentLightModelivSGIX_names, 484 }, - { FragmentLightiSGIX_names, 479 }, - { GetFragmentMaterialfvSGIX_names, 491 }, - { FragmentMaterialfSGIX_names, 485 }, - { GetFragmentLightivSGIX_names, 490 }, - { FragmentLightModeliSGIX_names, 483 }, - { FragmentLightivSGIX_names, 480 }, - { GetFragmentMaterialivSGIX_names, 492 }, - { FragmentLightModelfSGIX_names, 481 }, - { FragmentColorMaterialSGIX_names, 476 }, - { FragmentMaterialiSGIX_names, 487 }, - { LightEnviSGIX_names, 493 }, - { FragmentLightModelfvSGIX_names, 482 }, - { FragmentLightfvSGIX_names, 478 }, - { FragmentLightfSGIX_names, 477 }, - { GetFragmentLightfvSGIX_names, 489 }, - { FragmentMaterialivSGIX_names, 488 }, - { NULL, 0 } + { FragmentMaterialfvSGIX_names, FragmentMaterialfvSGIX_remap_index, 486 }, + { FragmentLightModelivSGIX_names, FragmentLightModelivSGIX_remap_index, 484 }, + { FragmentLightiSGIX_names, FragmentLightiSGIX_remap_index, 479 }, + { GetFragmentMaterialfvSGIX_names, GetFragmentMaterialfvSGIX_remap_index, 491 }, + { FragmentMaterialfSGIX_names, FragmentMaterialfSGIX_remap_index, 485 }, + { GetFragmentLightivSGIX_names, GetFragmentLightivSGIX_remap_index, 490 }, + { FragmentLightModeliSGIX_names, FragmentLightModeliSGIX_remap_index, 483 }, + { FragmentLightivSGIX_names, FragmentLightivSGIX_remap_index, 480 }, + { GetFragmentMaterialivSGIX_names, GetFragmentMaterialivSGIX_remap_index, 492 }, + { FragmentLightModelfSGIX_names, FragmentLightModelfSGIX_remap_index, 481 }, + { FragmentColorMaterialSGIX_names, FragmentColorMaterialSGIX_remap_index, 476 }, + { FragmentMaterialiSGIX_names, FragmentMaterialiSGIX_remap_index, 487 }, + { LightEnviSGIX_names, LightEnviSGIX_remap_index, 493 }, + { FragmentLightModelfvSGIX_names, FragmentLightModelfvSGIX_remap_index, 482 }, + { FragmentLightfvSGIX_names, FragmentLightfvSGIX_remap_index, 478 }, + { FragmentLightfSGIX_names, FragmentLightfSGIX_remap_index, 477 }, + { GetFragmentLightfvSGIX_names, GetFragmentLightfvSGIX_remap_index, 489 }, + { FragmentMaterialivSGIX_names, FragmentMaterialivSGIX_remap_index, 488 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIX_framezoom) static const struct dri_extension_function GL_SGIX_framezoom_functions[] = { - { FrameZoomSGIX_names, 466 }, - { NULL, 0 } + { FrameZoomSGIX_names, FrameZoomSGIX_remap_index, 466 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIX_igloo_interface) static const struct dri_extension_function GL_SGIX_igloo_interface_functions[] = { - { IglooInterfaceSGIX_names, -1 }, - { NULL, 0 } + { IglooInterfaceSGIX_names, IglooInterfaceSGIX_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIX_instruments) static const struct dri_extension_function GL_SGIX_instruments_functions[] = { - { ReadInstrumentsSGIX_names, 463 }, - { GetInstrumentsSGIX_names, 460 }, - { StartInstrumentsSGIX_names, 464 }, - { StopInstrumentsSGIX_names, 465 }, - { InstrumentsBufferSGIX_names, 461 }, - { PollInstrumentsSGIX_names, 462 }, - { NULL, 0 } + { ReadInstrumentsSGIX_names, ReadInstrumentsSGIX_remap_index, 463 }, + { GetInstrumentsSGIX_names, GetInstrumentsSGIX_remap_index, 460 }, + { StartInstrumentsSGIX_names, StartInstrumentsSGIX_remap_index, 464 }, + { StopInstrumentsSGIX_names, StopInstrumentsSGIX_remap_index, 465 }, + { InstrumentsBufferSGIX_names, InstrumentsBufferSGIX_remap_index, 461 }, + { PollInstrumentsSGIX_names, PollInstrumentsSGIX_remap_index, 462 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIX_list_priority) static const struct dri_extension_function GL_SGIX_list_priority_functions[] = { - { ListParameterfSGIX_names, 472 }, - { GetListParameterivSGIX_names, 471 }, - { GetListParameterfvSGIX_names, 470 }, - { ListParameteriSGIX_names, 474 }, - { ListParameterfvSGIX_names, 473 }, - { ListParameterivSGIX_names, 475 }, - { NULL, 0 } + { ListParameterfSGIX_names, ListParameterfSGIX_remap_index, 472 }, + { GetListParameterivSGIX_names, GetListParameterivSGIX_remap_index, 471 }, + { GetListParameterfvSGIX_names, GetListParameterfvSGIX_remap_index, 470 }, + { ListParameteriSGIX_names, ListParameteriSGIX_remap_index, 474 }, + { ListParameterfvSGIX_names, ListParameterfvSGIX_remap_index, 473 }, + { ListParameterivSGIX_names, ListParameterivSGIX_remap_index, 475 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIX_pixel_texture) static const struct dri_extension_function GL_SGIX_pixel_texture_functions[] = { - { PixelTexGenSGIX_names, 430 }, - { NULL, 0 } + { PixelTexGenSGIX_names, PixelTexGenSGIX_remap_index, 430 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIX_polynomial_ffd) static const struct dri_extension_function GL_SGIX_polynomial_ffd_functions[] = { - { LoadIdentityDeformationMapSGIX_names, -1 }, - { DeformationMap3dSGIX_names, -1 }, - { DeformSGIX_names, -1 }, - { DeformationMap3fSGIX_names, -1 }, - { NULL, 0 } + { LoadIdentityDeformationMapSGIX_names, LoadIdentityDeformationMapSGIX_remap_index, -1 }, + { DeformationMap3dSGIX_names, DeformationMap3dSGIX_remap_index, -1 }, + { DeformSGIX_names, DeformSGIX_remap_index, -1 }, + { DeformationMap3fSGIX_names, DeformationMap3fSGIX_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIX_reference_plane) static const struct dri_extension_function GL_SGIX_reference_plane_functions[] = { - { ReferencePlaneSGIX_names, 468 }, - { NULL, 0 } + { ReferencePlaneSGIX_names, ReferencePlaneSGIX_remap_index, 468 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIX_sprite) static const struct dri_extension_function GL_SGIX_sprite_functions[] = { - { SpriteParameterfvSGIX_names, 455 }, - { SpriteParameteriSGIX_names, 456 }, - { SpriteParameterfSGIX_names, 454 }, - { SpriteParameterivSGIX_names, 457 }, - { NULL, 0 } + { SpriteParameterfvSGIX_names, SpriteParameterfvSGIX_remap_index, 455 }, + { SpriteParameteriSGIX_names, SpriteParameteriSGIX_remap_index, 456 }, + { SpriteParameterfSGIX_names, SpriteParameterfSGIX_remap_index, 454 }, + { SpriteParameterivSGIX_names, SpriteParameterivSGIX_remap_index, 457 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGIX_tag_sample_buffer) static const struct dri_extension_function GL_SGIX_tag_sample_buffer_functions[] = { - { TagSampleBufferSGIX_names, 467 }, - { NULL, 0 } + { TagSampleBufferSGIX_names, TagSampleBufferSGIX_remap_index, 467 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SGI_color_table) static const struct dri_extension_function GL_SGI_color_table_functions[] = { - { GetColorTableParameterfvSGI_names, 428 }, - { ColorTableParameteriv_names, 341 }, - { ColorTable_names, 339 }, - { CopyColorTable_names, 342 }, - { ColorTableParameterfv_names, 340 }, - { GetColorTableParameterivSGI_names, 429 }, - { GetColorTableSGI_names, 427 }, - { NULL, 0 } + { GetColorTableParameterfvSGI_names, GetColorTableParameterfvSGI_remap_index, 428 }, + { ColorTableParameteriv_names, -1, 341 }, + { ColorTable_names, -1, 339 }, + { CopyColorTable_names, -1, 342 }, + { ColorTableParameterfv_names, -1, 340 }, + { GetColorTableParameterivSGI_names, GetColorTableParameterivSGI_remap_index, 429 }, + { GetColorTableSGI_names, GetColorTableSGI_remap_index, 427 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SUNX_constant_data) static const struct dri_extension_function GL_SUNX_constant_data_functions[] = { - { FinishTextureSUNX_names, -1 }, - { NULL, 0 } + { FinishTextureSUNX_names, FinishTextureSUNX_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SUN_global_alpha) static const struct dri_extension_function GL_SUN_global_alpha_functions[] = { - { GlobalAlphaFactorubSUN_names, -1 }, - { GlobalAlphaFactoriSUN_names, -1 }, - { GlobalAlphaFactordSUN_names, -1 }, - { GlobalAlphaFactoruiSUN_names, -1 }, - { GlobalAlphaFactorbSUN_names, -1 }, - { GlobalAlphaFactorfSUN_names, -1 }, - { GlobalAlphaFactorusSUN_names, -1 }, - { GlobalAlphaFactorsSUN_names, -1 }, - { NULL, 0 } + { GlobalAlphaFactorubSUN_names, GlobalAlphaFactorubSUN_remap_index, -1 }, + { GlobalAlphaFactoriSUN_names, GlobalAlphaFactoriSUN_remap_index, -1 }, + { GlobalAlphaFactordSUN_names, GlobalAlphaFactordSUN_remap_index, -1 }, + { GlobalAlphaFactoruiSUN_names, GlobalAlphaFactoruiSUN_remap_index, -1 }, + { GlobalAlphaFactorbSUN_names, GlobalAlphaFactorbSUN_remap_index, -1 }, + { GlobalAlphaFactorfSUN_names, GlobalAlphaFactorfSUN_remap_index, -1 }, + { GlobalAlphaFactorusSUN_names, GlobalAlphaFactorusSUN_remap_index, -1 }, + { GlobalAlphaFactorsSUN_names, GlobalAlphaFactorsSUN_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SUN_mesh_array) static const struct dri_extension_function GL_SUN_mesh_array_functions[] = { - { DrawMeshArraysSUN_names, -1 }, - { NULL, 0 } + { DrawMeshArraysSUN_names, DrawMeshArraysSUN_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SUN_triangle_list) static const struct dri_extension_function GL_SUN_triangle_list_functions[] = { - { ReplacementCodeubSUN_names, -1 }, - { ReplacementCodeubvSUN_names, -1 }, - { ReplacementCodeuivSUN_names, -1 }, - { ReplacementCodeusvSUN_names, -1 }, - { ReplacementCodePointerSUN_names, -1 }, - { ReplacementCodeusSUN_names, -1 }, - { ReplacementCodeuiSUN_names, -1 }, - { NULL, 0 } + { ReplacementCodeubSUN_names, ReplacementCodeubSUN_remap_index, -1 }, + { ReplacementCodeubvSUN_names, ReplacementCodeubvSUN_remap_index, -1 }, + { ReplacementCodeuivSUN_names, ReplacementCodeuivSUN_remap_index, -1 }, + { ReplacementCodeusvSUN_names, ReplacementCodeusvSUN_remap_index, -1 }, + { ReplacementCodePointerSUN_names, ReplacementCodePointerSUN_remap_index, -1 }, + { ReplacementCodeusSUN_names, ReplacementCodeusSUN_remap_index, -1 }, + { ReplacementCodeuiSUN_names, ReplacementCodeuiSUN_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_SUN_vertex) static const struct dri_extension_function GL_SUN_vertex_functions[] = { - { ReplacementCodeuiColor3fVertex3fvSUN_names, -1 }, - { TexCoord4fColor4fNormal3fVertex4fvSUN_names, -1 }, - { TexCoord2fColor4ubVertex3fvSUN_names, -1 }, - { ReplacementCodeuiVertex3fvSUN_names, -1 }, - { ReplacementCodeuiTexCoord2fVertex3fvSUN_names, -1 }, - { ReplacementCodeuiNormal3fVertex3fSUN_names, -1 }, - { Color4ubVertex3fvSUN_names, -1 }, - { Color4ubVertex3fSUN_names, -1 }, - { TexCoord2fVertex3fSUN_names, -1 }, - { TexCoord2fColor4fNormal3fVertex3fSUN_names, -1 }, - { TexCoord2fNormal3fVertex3fvSUN_names, -1 }, - { ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN_names, -1 }, - { ReplacementCodeuiTexCoord2fVertex3fSUN_names, -1 }, - { Color3fVertex3fSUN_names, -1 }, - { ReplacementCodeuiNormal3fVertex3fvSUN_names, -1 }, - { Color3fVertex3fvSUN_names, -1 }, - { Color4fNormal3fVertex3fvSUN_names, -1 }, - { ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_names, -1 }, - { ReplacementCodeuiColor4fNormal3fVertex3fvSUN_names, -1 }, - { ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_names, -1 }, - { TexCoord2fColor3fVertex3fSUN_names, -1 }, - { TexCoord4fColor4fNormal3fVertex4fSUN_names, -1 }, - { Color4ubVertex2fvSUN_names, -1 }, - { Normal3fVertex3fSUN_names, -1 }, - { ReplacementCodeuiColor4fNormal3fVertex3fSUN_names, -1 }, - { TexCoord2fNormal3fVertex3fSUN_names, -1 }, - { TexCoord2fVertex3fvSUN_names, -1 }, - { Color4ubVertex2fSUN_names, -1 }, - { ReplacementCodeuiColor4ubVertex3fSUN_names, -1 }, - { TexCoord2fColor4ubVertex3fSUN_names, -1 }, - { Normal3fVertex3fvSUN_names, -1 }, - { Color4fNormal3fVertex3fSUN_names, -1 }, - { TexCoord2fColor4fNormal3fVertex3fvSUN_names, -1 }, - { ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN_names, -1 }, - { ReplacementCodeuiColor4ubVertex3fvSUN_names, -1 }, - { ReplacementCodeuiColor3fVertex3fSUN_names, -1 }, - { TexCoord4fVertex4fSUN_names, -1 }, - { TexCoord2fColor3fVertex3fvSUN_names, -1 }, - { TexCoord4fVertex4fvSUN_names, -1 }, - { ReplacementCodeuiVertex3fSUN_names, -1 }, - { NULL, 0 } + { ReplacementCodeuiColor3fVertex3fvSUN_names, ReplacementCodeuiColor3fVertex3fvSUN_remap_index, -1 }, + { TexCoord4fColor4fNormal3fVertex4fvSUN_names, TexCoord4fColor4fNormal3fVertex4fvSUN_remap_index, -1 }, + { TexCoord2fColor4ubVertex3fvSUN_names, TexCoord2fColor4ubVertex3fvSUN_remap_index, -1 }, + { ReplacementCodeuiVertex3fvSUN_names, ReplacementCodeuiVertex3fvSUN_remap_index, -1 }, + { ReplacementCodeuiTexCoord2fVertex3fvSUN_names, ReplacementCodeuiTexCoord2fVertex3fvSUN_remap_index, -1 }, + { ReplacementCodeuiNormal3fVertex3fSUN_names, ReplacementCodeuiNormal3fVertex3fSUN_remap_index, -1 }, + { Color4ubVertex3fvSUN_names, Color4ubVertex3fvSUN_remap_index, -1 }, + { Color4ubVertex3fSUN_names, Color4ubVertex3fSUN_remap_index, -1 }, + { TexCoord2fVertex3fSUN_names, TexCoord2fVertex3fSUN_remap_index, -1 }, + { TexCoord2fColor4fNormal3fVertex3fSUN_names, TexCoord2fColor4fNormal3fVertex3fSUN_remap_index, -1 }, + { TexCoord2fNormal3fVertex3fvSUN_names, TexCoord2fNormal3fVertex3fvSUN_remap_index, -1 }, + { ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN_names, ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN_remap_index, -1 }, + { ReplacementCodeuiTexCoord2fVertex3fSUN_names, ReplacementCodeuiTexCoord2fVertex3fSUN_remap_index, -1 }, + { Color3fVertex3fSUN_names, Color3fVertex3fSUN_remap_index, -1 }, + { ReplacementCodeuiNormal3fVertex3fvSUN_names, ReplacementCodeuiNormal3fVertex3fvSUN_remap_index, -1 }, + { Color3fVertex3fvSUN_names, Color3fVertex3fvSUN_remap_index, -1 }, + { Color4fNormal3fVertex3fvSUN_names, Color4fNormal3fVertex3fvSUN_remap_index, -1 }, + { ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_names, ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_remap_index, -1 }, + { ReplacementCodeuiColor4fNormal3fVertex3fvSUN_names, ReplacementCodeuiColor4fNormal3fVertex3fvSUN_remap_index, -1 }, + { ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_names, ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_remap_index, -1 }, + { TexCoord2fColor3fVertex3fSUN_names, TexCoord2fColor3fVertex3fSUN_remap_index, -1 }, + { TexCoord4fColor4fNormal3fVertex4fSUN_names, TexCoord4fColor4fNormal3fVertex4fSUN_remap_index, -1 }, + { Color4ubVertex2fvSUN_names, Color4ubVertex2fvSUN_remap_index, -1 }, + { Normal3fVertex3fSUN_names, Normal3fVertex3fSUN_remap_index, -1 }, + { ReplacementCodeuiColor4fNormal3fVertex3fSUN_names, ReplacementCodeuiColor4fNormal3fVertex3fSUN_remap_index, -1 }, + { TexCoord2fNormal3fVertex3fSUN_names, TexCoord2fNormal3fVertex3fSUN_remap_index, -1 }, + { TexCoord2fVertex3fvSUN_names, TexCoord2fVertex3fvSUN_remap_index, -1 }, + { Color4ubVertex2fSUN_names, Color4ubVertex2fSUN_remap_index, -1 }, + { ReplacementCodeuiColor4ubVertex3fSUN_names, ReplacementCodeuiColor4ubVertex3fSUN_remap_index, -1 }, + { TexCoord2fColor4ubVertex3fSUN_names, TexCoord2fColor4ubVertex3fSUN_remap_index, -1 }, + { Normal3fVertex3fvSUN_names, Normal3fVertex3fvSUN_remap_index, -1 }, + { Color4fNormal3fVertex3fSUN_names, Color4fNormal3fVertex3fSUN_remap_index, -1 }, + { TexCoord2fColor4fNormal3fVertex3fvSUN_names, TexCoord2fColor4fNormal3fVertex3fvSUN_remap_index, -1 }, + { ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN_names, ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN_remap_index, -1 }, + { ReplacementCodeuiColor4ubVertex3fvSUN_names, ReplacementCodeuiColor4ubVertex3fvSUN_remap_index, -1 }, + { ReplacementCodeuiColor3fVertex3fSUN_names, ReplacementCodeuiColor3fVertex3fSUN_remap_index, -1 }, + { TexCoord4fVertex4fSUN_names, TexCoord4fVertex4fSUN_remap_index, -1 }, + { TexCoord2fColor3fVertex3fvSUN_names, TexCoord2fColor3fVertex3fvSUN_remap_index, -1 }, + { TexCoord4fVertex4fvSUN_names, TexCoord4fVertex4fvSUN_remap_index, -1 }, + { ReplacementCodeuiVertex3fSUN_names, ReplacementCodeuiVertex3fSUN_remap_index, -1 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_VERSION_1_3) static const struct dri_extension_function GL_VERSION_1_3_functions[] = { - { SampleCoverageARB_names, 412 }, - { MultiTexCoord3sARB_names, 398 }, - { ActiveTextureARB_names, 374 }, - { CompressedTexSubImage2DARB_names, 558 }, - { CompressedTexImage3DARB_names, 554 }, - { MultiTexCoord1fvARB_names, 379 }, - { MultTransposeMatrixdARB_names, 411 }, - { CompressedTexImage1DARB_names, 556 }, - { MultiTexCoord3dARB_names, 392 }, - { MultiTexCoord2iARB_names, 388 }, - { MultiTexCoord2svARB_names, 391 }, - { MultiTexCoord2fARB_names, 386 }, - { LoadTransposeMatrixdARB_names, 409 }, - { MultiTexCoord3fvARB_names, 395 }, - { MultiTexCoord4sARB_names, 406 }, - { MultiTexCoord2dvARB_names, 385 }, - { MultiTexCoord1svARB_names, 383 }, - { MultiTexCoord3svARB_names, 399 }, - { MultiTexCoord4iARB_names, 404 }, - { MultiTexCoord3iARB_names, 396 }, - { MultiTexCoord1dARB_names, 376 }, - { MultiTexCoord3dvARB_names, 393 }, - { MultiTexCoord3ivARB_names, 397 }, - { MultiTexCoord2sARB_names, 390 }, - { MultiTexCoord4ivARB_names, 405 }, - { CompressedTexSubImage1DARB_names, 559 }, - { ClientActiveTextureARB_names, 375 }, - { CompressedTexSubImage3DARB_names, 557 }, - { MultiTexCoord2dARB_names, 384 }, - { MultiTexCoord4dvARB_names, 401 }, - { MultiTexCoord4fvARB_names, 403 }, - { MultiTexCoord3fARB_names, 394 }, - { MultTransposeMatrixfARB_names, 410 }, - { CompressedTexImage2DARB_names, 555 }, - { MultiTexCoord4dARB_names, 400 }, - { MultiTexCoord1sARB_names, 382 }, - { MultiTexCoord1dvARB_names, 377 }, - { MultiTexCoord1ivARB_names, 381 }, - { MultiTexCoord2ivARB_names, 389 }, - { MultiTexCoord1iARB_names, 380 }, - { GetCompressedTexImageARB_names, 560 }, - { MultiTexCoord4svARB_names, 407 }, - { MultiTexCoord1fARB_names, 378 }, - { MultiTexCoord4fARB_names, 402 }, - { LoadTransposeMatrixfARB_names, 408 }, - { MultiTexCoord2fvARB_names, 387 }, - { NULL, 0 } + { SampleCoverageARB_names, SampleCoverageARB_remap_index, 412 }, + { MultiTexCoord3sARB_names, -1, 398 }, + { ActiveTextureARB_names, -1, 374 }, + { CompressedTexSubImage2DARB_names, CompressedTexSubImage2DARB_remap_index, 558 }, + { CompressedTexImage3DARB_names, CompressedTexImage3DARB_remap_index, 554 }, + { MultiTexCoord1fvARB_names, -1, 379 }, + { MultTransposeMatrixdARB_names, MultTransposeMatrixdARB_remap_index, 411 }, + { CompressedTexImage1DARB_names, CompressedTexImage1DARB_remap_index, 556 }, + { MultiTexCoord3dARB_names, -1, 392 }, + { MultiTexCoord2iARB_names, -1, 388 }, + { MultiTexCoord2svARB_names, -1, 391 }, + { MultiTexCoord2fARB_names, -1, 386 }, + { LoadTransposeMatrixdARB_names, LoadTransposeMatrixdARB_remap_index, 409 }, + { MultiTexCoord3fvARB_names, -1, 395 }, + { MultiTexCoord4sARB_names, -1, 406 }, + { MultiTexCoord2dvARB_names, -1, 385 }, + { MultiTexCoord1svARB_names, -1, 383 }, + { MultiTexCoord3svARB_names, -1, 399 }, + { MultiTexCoord4iARB_names, -1, 404 }, + { MultiTexCoord3iARB_names, -1, 396 }, + { MultiTexCoord1dARB_names, -1, 376 }, + { MultiTexCoord3dvARB_names, -1, 393 }, + { MultiTexCoord3ivARB_names, -1, 397 }, + { MultiTexCoord2sARB_names, -1, 390 }, + { MultiTexCoord4ivARB_names, -1, 405 }, + { CompressedTexSubImage1DARB_names, CompressedTexSubImage1DARB_remap_index, 559 }, + { ClientActiveTextureARB_names, -1, 375 }, + { CompressedTexSubImage3DARB_names, CompressedTexSubImage3DARB_remap_index, 557 }, + { MultiTexCoord2dARB_names, -1, 384 }, + { MultiTexCoord4dvARB_names, -1, 401 }, + { MultiTexCoord4fvARB_names, -1, 403 }, + { MultiTexCoord3fARB_names, -1, 394 }, + { MultTransposeMatrixfARB_names, MultTransposeMatrixfARB_remap_index, 410 }, + { CompressedTexImage2DARB_names, CompressedTexImage2DARB_remap_index, 555 }, + { MultiTexCoord4dARB_names, -1, 400 }, + { MultiTexCoord1sARB_names, -1, 382 }, + { MultiTexCoord1dvARB_names, -1, 377 }, + { MultiTexCoord1ivARB_names, -1, 381 }, + { MultiTexCoord2ivARB_names, -1, 389 }, + { MultiTexCoord1iARB_names, -1, 380 }, + { GetCompressedTexImageARB_names, GetCompressedTexImageARB_remap_index, 560 }, + { MultiTexCoord4svARB_names, -1, 407 }, + { MultiTexCoord1fARB_names, -1, 378 }, + { MultiTexCoord4fARB_names, -1, 402 }, + { LoadTransposeMatrixfARB_names, LoadTransposeMatrixfARB_remap_index, 408 }, + { MultiTexCoord2fvARB_names, -1, 387 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_VERSION_1_4) static const struct dri_extension_function GL_VERSION_1_4_functions[] = { - { PointParameteriNV_names, 642 }, - { SecondaryColor3iEXT_names, 567 }, - { WindowPos3fMESA_names, 523 }, - { WindowPos2dvMESA_names, 514 }, - { SecondaryColor3bEXT_names, 561 }, - { PointParameterfEXT_names, 458 }, - { FogCoorddEXT_names, 547 }, - { FogCoordfEXT_names, 545 }, - { WindowPos2svMESA_names, 520 }, - { WindowPos3dMESA_names, 521 }, - { PointParameterfvEXT_names, 459 }, - { WindowPos2fvMESA_names, 516 }, - { SecondaryColor3bvEXT_names, 562 }, - { SecondaryColor3sEXT_names, 569 }, - { SecondaryColor3dEXT_names, 563 }, - { WindowPos2dMESA_names, 513 }, - { SecondaryColorPointerEXT_names, 577 }, - { SecondaryColor3uiEXT_names, 573 }, - { SecondaryColor3usvEXT_names, 576 }, - { WindowPos3dvMESA_names, 522 }, - { PointParameterivNV_names, 643 }, - { WindowPos3fvMESA_names, 524 }, - { SecondaryColor3ivEXT_names, 568 }, - { WindowPos2iMESA_names, 517 }, - { SecondaryColor3fvEXT_names, 566 }, - { WindowPos3sMESA_names, 527 }, - { WindowPos2ivMESA_names, 518 }, - { MultiDrawElementsEXT_names, 645 }, - { WindowPos2sMESA_names, 519 }, - { FogCoordPointerEXT_names, 549 }, - { SecondaryColor3ubvEXT_names, 572 }, - { SecondaryColor3uivEXT_names, 574 }, - { WindowPos3iMESA_names, 525 }, - { SecondaryColor3dvEXT_names, 564 }, - { MultiDrawArraysEXT_names, 644 }, - { SecondaryColor3usEXT_names, 575 }, - { FogCoordfvEXT_names, 546 }, - { SecondaryColor3ubEXT_names, 571 }, - { BlendFuncSeparateEXT_names, 537 }, - { SecondaryColor3fEXT_names, 565 }, - { WindowPos3ivMESA_names, 526 }, - { SecondaryColor3svEXT_names, 570 }, - { FogCoorddvEXT_names, 548 }, - { WindowPos3svMESA_names, 528 }, - { WindowPos2fMESA_names, 515 }, - { NULL, 0 } + { PointParameteriNV_names, PointParameteriNV_remap_index, 642 }, + { SecondaryColor3iEXT_names, SecondaryColor3iEXT_remap_index, 567 }, + { WindowPos3fMESA_names, WindowPos3fMESA_remap_index, 523 }, + { WindowPos2dvMESA_names, WindowPos2dvMESA_remap_index, 514 }, + { SecondaryColor3bEXT_names, SecondaryColor3bEXT_remap_index, 561 }, + { PointParameterfEXT_names, PointParameterfEXT_remap_index, 458 }, + { FogCoorddEXT_names, FogCoorddEXT_remap_index, 547 }, + { FogCoordfEXT_names, FogCoordfEXT_remap_index, 545 }, + { WindowPos2svMESA_names, WindowPos2svMESA_remap_index, 520 }, + { WindowPos3dMESA_names, WindowPos3dMESA_remap_index, 521 }, + { PointParameterfvEXT_names, PointParameterfvEXT_remap_index, 459 }, + { WindowPos2fvMESA_names, WindowPos2fvMESA_remap_index, 516 }, + { SecondaryColor3bvEXT_names, SecondaryColor3bvEXT_remap_index, 562 }, + { SecondaryColor3sEXT_names, SecondaryColor3sEXT_remap_index, 569 }, + { SecondaryColor3dEXT_names, SecondaryColor3dEXT_remap_index, 563 }, + { WindowPos2dMESA_names, WindowPos2dMESA_remap_index, 513 }, + { SecondaryColorPointerEXT_names, SecondaryColorPointerEXT_remap_index, 577 }, + { SecondaryColor3uiEXT_names, SecondaryColor3uiEXT_remap_index, 573 }, + { SecondaryColor3usvEXT_names, SecondaryColor3usvEXT_remap_index, 576 }, + { WindowPos3dvMESA_names, WindowPos3dvMESA_remap_index, 522 }, + { PointParameterivNV_names, PointParameterivNV_remap_index, 643 }, + { WindowPos3fvMESA_names, WindowPos3fvMESA_remap_index, 524 }, + { SecondaryColor3ivEXT_names, SecondaryColor3ivEXT_remap_index, 568 }, + { WindowPos2iMESA_names, WindowPos2iMESA_remap_index, 517 }, + { SecondaryColor3fvEXT_names, SecondaryColor3fvEXT_remap_index, 566 }, + { WindowPos3sMESA_names, WindowPos3sMESA_remap_index, 527 }, + { WindowPos2ivMESA_names, WindowPos2ivMESA_remap_index, 518 }, + { MultiDrawElementsEXT_names, MultiDrawElementsEXT_remap_index, 645 }, + { WindowPos2sMESA_names, WindowPos2sMESA_remap_index, 519 }, + { FogCoordPointerEXT_names, FogCoordPointerEXT_remap_index, 549 }, + { SecondaryColor3ubvEXT_names, SecondaryColor3ubvEXT_remap_index, 572 }, + { SecondaryColor3uivEXT_names, SecondaryColor3uivEXT_remap_index, 574 }, + { WindowPos3iMESA_names, WindowPos3iMESA_remap_index, 525 }, + { SecondaryColor3dvEXT_names, SecondaryColor3dvEXT_remap_index, 564 }, + { MultiDrawArraysEXT_names, MultiDrawArraysEXT_remap_index, 644 }, + { SecondaryColor3usEXT_names, SecondaryColor3usEXT_remap_index, 575 }, + { FogCoordfvEXT_names, FogCoordfvEXT_remap_index, 546 }, + { SecondaryColor3ubEXT_names, SecondaryColor3ubEXT_remap_index, 571 }, + { BlendFuncSeparateEXT_names, BlendFuncSeparateEXT_remap_index, 537 }, + { SecondaryColor3fEXT_names, SecondaryColor3fEXT_remap_index, 565 }, + { WindowPos3ivMESA_names, WindowPos3ivMESA_remap_index, 526 }, + { SecondaryColor3svEXT_names, SecondaryColor3svEXT_remap_index, 570 }, + { FogCoorddvEXT_names, FogCoorddvEXT_remap_index, 548 }, + { WindowPos3svMESA_names, WindowPos3svMESA_remap_index, 528 }, + { WindowPos2fMESA_names, WindowPos2fMESA_remap_index, 515 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_VERSION_1_5) static const struct dri_extension_function GL_VERSION_1_5_functions[] = { - { BeginQueryARB_names, 703 }, - { GetBufferSubDataARB_names, 695 }, - { BufferSubDataARB_names, 690 }, - { GetQueryivARB_names, 705 }, - { GetQueryObjectivARB_names, 706 }, - { BufferDataARB_names, 689 }, - { EndQueryARB_names, 704 }, - { GetBufferPointervARB_names, 694 }, - { GetQueryObjectuivARB_names, 707 }, - { GetBufferParameterivARB_names, 693 }, - { DeleteQueriesARB_names, 701 }, - { IsQueryARB_names, 702 }, - { MapBufferARB_names, 697 }, - { GenQueriesARB_names, 700 }, - { IsBufferARB_names, 696 }, - { DeleteBuffersARB_names, 691 }, - { UnmapBufferARB_names, 698 }, - { BindBufferARB_names, 688 }, - { GenBuffersARB_names, 692 }, - { NULL, 0 } + { BeginQueryARB_names, BeginQueryARB_remap_index, 703 }, + { GetBufferSubDataARB_names, GetBufferSubDataARB_remap_index, 695 }, + { BufferSubDataARB_names, BufferSubDataARB_remap_index, 690 }, + { GetQueryivARB_names, GetQueryivARB_remap_index, 705 }, + { GetQueryObjectivARB_names, GetQueryObjectivARB_remap_index, 706 }, + { BufferDataARB_names, BufferDataARB_remap_index, 689 }, + { EndQueryARB_names, EndQueryARB_remap_index, 704 }, + { GetBufferPointervARB_names, GetBufferPointervARB_remap_index, 694 }, + { GetQueryObjectuivARB_names, GetQueryObjectuivARB_remap_index, 707 }, + { GetBufferParameterivARB_names, GetBufferParameterivARB_remap_index, 693 }, + { DeleteQueriesARB_names, DeleteQueriesARB_remap_index, 701 }, + { IsQueryARB_names, IsQueryARB_remap_index, 702 }, + { MapBufferARB_names, MapBufferARB_remap_index, 697 }, + { GenQueriesARB_names, GenQueriesARB_remap_index, 700 }, + { IsBufferARB_names, IsBufferARB_remap_index, 696 }, + { DeleteBuffersARB_names, DeleteBuffersARB_remap_index, 691 }, + { UnmapBufferARB_names, UnmapBufferARB_remap_index, 698 }, + { BindBufferARB_names, BindBufferARB_remap_index, 688 }, + { GenBuffersARB_names, GenBuffersARB_remap_index, 692 }, + { NULL, 0, 0 } }; #endif #if defined(need_GL_VERSION_2_0) static const struct dri_extension_function GL_VERSION_2_0_functions[] = { - { StencilMaskSeparate_names, 815 }, - { StencilOpSeparate_names, 814 }, - { StencilFuncSeparate_names, 813 }, - { NULL, 0 } + { StencilMaskSeparate_names, StencilMaskSeparate_remap_index, 815 }, + { StencilOpSeparate_names, StencilOpSeparate_remap_index, 814 }, + { StencilFuncSeparate_names, StencilFuncSeparate_remap_index, 813 }, + { NULL, 0, 0 } }; #endif diff --git a/src/mesa/drivers/dri/common/utils.c b/src/mesa/drivers/dri/common/utils.c index 41367b85d85..b6fb06ffac9 100644 --- a/src/mesa/drivers/dri/common/utils.c +++ b/src/mesa/drivers/dri/common/utils.c @@ -34,6 +34,9 @@ #include "mtypes.h" #include "extensions.h" #include "utils.h" +#include "dispatch.h" + +unsigned driDispatchRemapTable[ driDispatchRemapTable_size ]; #if defined(USE_X86_ASM) #include "x86/common_x86_asm.h" @@ -176,6 +179,30 @@ driGetRendererString( char * buffer, const char * hardware_name, +#define need_GL_ARB_multisample +#define need_GL_ARB_transpose_matrix +#define need_GL_ARB_window_pos +#define need_GL_EXT_compiled_vertex_array +#define need_GL_EXT_polygon_offset +#define need_GL_EXT_texture_object +#define need_GL_EXT_vertex_array +#define need_GL_MESA_window_pos + +#include "extension_helper.h" + +static const struct dri_extension all_mesa_extensions[] = { + { "GL_ARB_multisample", GL_ARB_multisample_functions }, + { "GL_ARB_transpose_matrix", GL_ARB_transpose_matrix_functions }, + { "GL_ARB_window_pos", GL_ARB_window_pos_functions }, + { "GL_EXT_compiled_vertex_array", GL_EXT_compiled_vertex_array_functions }, + { "GL_EXT_polygon_offset", GL_EXT_polygon_offset_functions }, + { "GL_EXT_texture_object", GL_EXT_texture_object_functions }, + { "GL_EXT_vertex_array", GL_EXT_vertex_array_functions }, + { "GL_MESA_window_pos", GL_MESA_window_pos_functions }, + { NULL, NULL } +}; + + /** * Enable extensions supported by the driver. * @@ -189,9 +216,15 @@ void driInitExtensions( GLcontext * ctx, const struct dri_extension * extensions_to_enable, GLboolean enable_imaging ) { + static int first_time = 1; unsigned i; - if ( enable_imaging ) { + if ( first_time ) { + first_time = 0; + driInitExtensions( ctx, all_mesa_extensions, GL_FALSE ); + } + + if ( (ctx != NULL) && enable_imaging ) { _mesa_enable_imaging_extensions( ctx ); } @@ -220,12 +253,14 @@ void driInitSingleExtension( GLcontext * ctx, { unsigned i; + if ( ext->functions != NULL ) { for ( i = 0 ; ext->functions[i].strings != NULL ; i++ ) { const char * functions[16]; const char * parameter_signature; const char * str = ext->functions[i].strings; unsigned j; + unsigned offset; /* Separate the parameter signature from the rest of the string. @@ -260,14 +295,23 @@ void driInitSingleExtension( GLcontext * ctx, /* Add each entry-point to the dispatch table. */ - for ( j = 0 ; functions[j] != NULL ; j++ ) { - _glapi_add_entrypoint( functions[j], - ext->functions[i].offset ); + offset = _glapi_add_dispatch( functions, parameter_signature ); + if ( ext->functions[i].remap_index != -1 ) { + driDispatchRemapTable[ ext->functions[i].remap_index ] = offset; + } + + if ( (ext->functions[i].offset != -1) + && (ext->functions[i].offset != offset) ) { + fprintf(stderr, "DISPATCH ERROR! %s -> %u != %u\n", functions[0], + driDispatchRemapTable[ ext->functions[i].remap_index ], + ext->functions[i].offset); } } } - _mesa_enable_extension( ctx, ext->name ); + if ( ctx != NULL ) { + _mesa_enable_extension( ctx, ext->name ); + } } diff --git a/src/mesa/drivers/dri/common/utils.h b/src/mesa/drivers/dri/common/utils.h index 6640229e475..26d178f7478 100644 --- a/src/mesa/drivers/dri/common/utils.h +++ b/src/mesa/drivers/dri/common/utils.h @@ -55,9 +55,15 @@ struct dri_extension_function { /** + * Location in the remap table where the dispatch offset should be + * stored. + */ + int remap_index; + + /** * Offset of the function in the dispatch table. */ - unsigned offset; + int offset; }; /** diff --git a/src/mesa/drivers/dri/ffb/ffb_xmesa.c b/src/mesa/drivers/dri/ffb/ffb_xmesa.c index f49b40aa833..e260e1de24b 100644 --- a/src/mesa/drivers/dri/ffb/ffb_xmesa.c +++ b/src/mesa/drivers/dri/ffb/ffb_xmesa.c @@ -708,7 +708,7 @@ ffbFillInModes( unsigned pixel_bits, unsigned depth_bits, * failure. */ PUBLIC -void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, +void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, const __GLcontextModes * modes, const __DRIversion * ddx_version, const __DRIversion * dri_version, diff --git a/src/mesa/drivers/dri/i810/i810screen.c b/src/mesa/drivers/dri/i810/i810screen.c index 1b9d4aa3699..7c5f38e3586 100644 --- a/src/mesa/drivers/dri/i810/i810screen.c +++ b/src/mesa/drivers/dri/i810/i810screen.c @@ -424,7 +424,7 @@ static const struct __DriverAPIRec i810API = { * failure. */ PUBLIC -void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, +void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, const __GLcontextModes * modes, const __DRIversion * ddx_version, const __DRIversion * dri_version, diff --git a/src/mesa/drivers/dri/i830/i830_context.c b/src/mesa/drivers/dri/i830/i830_context.c index d408e47c4af..45fcbd2e3b6 100644 --- a/src/mesa/drivers/dri/i830/i830_context.c +++ b/src/mesa/drivers/dri/i830/i830_context.c @@ -149,7 +149,7 @@ static void i830BufferSize(GLframebuffer *buffer, /* Extension strings exported by the i830 driver. */ -static const struct dri_extension card_extensions[] = +const struct dri_extension card_extensions[] = { { "GL_ARB_multisample", GL_ARB_multisample_functions }, { "GL_ARB_multitexture", NULL }, diff --git a/src/mesa/drivers/dri/i830/i830_screen.c b/src/mesa/drivers/dri/i830/i830_screen.c index c77657d6f06..b1a5618f410 100644 --- a/src/mesa/drivers/dri/i830/i830_screen.c +++ b/src/mesa/drivers/dri/i830/i830_screen.c @@ -67,6 +67,7 @@ DRI_CONF_BEGIN DRI_CONF_END; const GLuint __driNConfigOptions = 2; +extern const struct dri_extension card_extensions[]; static int i830_malloc_proxy_buf(drmBufMapPtr buffers) { @@ -502,7 +503,7 @@ i830FillInModes( unsigned pixel_bits, unsigned depth_bits, * failure. */ PUBLIC -void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, +void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, const __GLcontextModes * modes, const __DRIversion * ddx_version, const __DRIversion * dri_version, @@ -538,6 +539,16 @@ void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIsc (dri_priv->cpp == 2) ? 16 : 24, (dri_priv->cpp == 2) ? 0 : 8, (dri_priv->backOffset != dri_priv->depthOffset) ); + + /* Calling driInitExtensions here, with a NULL context pointer, does not actually + * enable the extensions. It just makes sure that all the dispatch offsets for all + * the extensions that *might* be enables are known. This is needed because the + * dispatch offsets need to be known when _mesa_context_create is called, but we can't + * enable the extensions until we have a context pointer. + * + * Hello chicken. Hello egg. How are you two today? + */ + driInitExtensions( NULL, card_extensions, GL_FALSE ); } return (void *) psp; diff --git a/src/mesa/drivers/dri/i915/i830_context.c b/src/mesa/drivers/dri/i915/i830_context.c index c817397db57..6088db67e20 100644 --- a/src/mesa/drivers/dri/i915/i830_context.c +++ b/src/mesa/drivers/dri/i915/i830_context.c @@ -38,7 +38,7 @@ * Mesa's Driver Functions ***************************************/ -static const struct dri_extension card_extensions[] = +static const struct dri_extension i830_extensions[] = { { "GL_ARB_texture_env_crossbar", NULL }, { NULL, NULL } @@ -109,7 +109,7 @@ GLboolean i830CreateContext( const __GLcontextModes *mesaVis, intel->verts = TNL_CONTEXT(ctx)->clipspace.vertex_buf; - driInitExtensions( ctx, card_extensions, GL_FALSE ); + driInitExtensions( ctx, i830_extensions, GL_FALSE ); i830InitState( i830 ); diff --git a/src/mesa/drivers/dri/i915/i915_context.c b/src/mesa/drivers/dri/i915/i915_context.c index 66628365a66..42f91241b26 100644 --- a/src/mesa/drivers/dri/i915/i915_context.c +++ b/src/mesa/drivers/dri/i915/i915_context.c @@ -45,7 +45,7 @@ * Mesa's Driver Functions ***************************************/ -static const struct dri_extension card_extensions[] = +static const struct dri_extension i915_extensions[] = { { "GL_ARB_depth_texture", NULL }, { "GL_ARB_fragment_program", NULL }, @@ -166,7 +166,7 @@ GLboolean i915CreateContext( const __GLcontextModes *mesaVis, ctx->Const.MaxFragmentProgramAddressRegs = 0; /* I don't think we have one */ - driInitExtensions( ctx, card_extensions, GL_FALSE ); + driInitExtensions( ctx, i915_extensions, GL_FALSE ); _tnl_init_vertices( ctx, ctx->Const.MaxArrayLockSize + 12, diff --git a/src/mesa/drivers/dri/i915/intel_context.c b/src/mesa/drivers/dri/i915/intel_context.c index d30136a7d5d..4639105e1f8 100644 --- a/src/mesa/drivers/dri/i915/intel_context.c +++ b/src/mesa/drivers/dri/i915/intel_context.c @@ -153,7 +153,7 @@ static void intelBufferSize(GLframebuffer *buffer, * It appears that ARB_texture_env_crossbar has "disappeared" compared to the * old i830-specific driver. */ -static const struct dri_extension card_extensions[] = +const struct dri_extension card_extensions[] = { { "GL_ARB_multisample", GL_ARB_multisample_functions }, { "GL_ARB_multitexture", NULL }, diff --git a/src/mesa/drivers/dri/i915/intel_screen.c b/src/mesa/drivers/dri/i915/intel_screen.c index ca8f34657ca..e474850c634 100644 --- a/src/mesa/drivers/dri/i915/intel_screen.c +++ b/src/mesa/drivers/dri/i915/intel_screen.c @@ -54,6 +54,7 @@ DRI_CONF_BEGIN DRI_CONF_END; const GLuint __driNConfigOptions = 1; +extern const struct dri_extension card_extensions[]; static void intelPrintDRIInfo(intelScreenPrivate *intelScreen, __DRIscreenPrivate *sPriv, @@ -457,7 +458,7 @@ intelFillInModes( unsigned pixel_bits, unsigned depth_bits, * failure. */ PUBLIC -void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, +void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, const __GLcontextModes * modes, const __DRIversion * ddx_version, const __DRIversion * dri_version, @@ -493,6 +494,16 @@ void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIsc (dri_priv->cpp == 2) ? 16 : 24, (dri_priv->cpp == 2) ? 0 : 8, (dri_priv->backOffset != dri_priv->depthOffset) ); + + /* Calling driInitExtensions here, with a NULL context pointer, does not actually + * enable the extensions. It just makes sure that all the dispatch offsets for all + * the extensions that *might* be enables are known. This is needed because the + * dispatch offsets need to be known when _mesa_context_create is called, but we can't + * enable the extensions until we have a context pointer. + * + * Hello chicken. Hello egg. How are you two today? + */ + driInitExtensions( NULL, card_extensions, GL_FALSE ); } return (void *) psp; diff --git a/src/mesa/drivers/dri/mach64/mach64_screen.c b/src/mesa/drivers/dri/mach64/mach64_screen.c index 91aa31eecc0..df1ed92fe7d 100644 --- a/src/mesa/drivers/dri/mach64/mach64_screen.c +++ b/src/mesa/drivers/dri/mach64/mach64_screen.c @@ -498,7 +498,7 @@ static struct __DriverAPIRec mach64API = { * failure. */ PUBLIC -void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, +void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, const __GLcontextModes * modes, const __DRIversion * ddx_version, const __DRIversion * dri_version, diff --git a/src/mesa/drivers/dri/mga/mga_xmesa.c b/src/mesa/drivers/dri/mga/mga_xmesa.c index e310f619586..ef080b5695a 100644 --- a/src/mesa/drivers/dri/mga/mga_xmesa.c +++ b/src/mesa/drivers/dri/mga/mga_xmesa.c @@ -934,7 +934,7 @@ static const struct __DriverAPIRec mgaAPI = { * failure. */ PUBLIC -void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, +void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, const __GLcontextModes * modes, const __DRIversion * ddx_version, const __DRIversion * dri_version, @@ -970,6 +970,20 @@ void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIsc (dri_priv->cpp == 2) ? 16 : 24, (dri_priv->cpp == 2) ? 0 : 8, (dri_priv->backOffset != dri_priv->depthOffset) ); + + /* Calling driInitExtensions here, with a NULL context pointer, does not actually + * enable the extensions. It just makes sure that all the dispatch offsets for all + * the extensions that *might* be enables are known. This is needed because the + * dispatch offsets need to be known when _mesa_context_create is called, but we can't + * enable the extensions until we have a context pointer. + * + * Hello chicken. Hello egg. How are you two today? + */ + driInitExtensions( NULL, card_extensions, GL_FALSE ); + driInitExtensions( NULL, g400_extensions, GL_FALSE ); + driInitSingleExtension( NULL, ARB_vp_extension ); + driInitExtensions( NULL, NV_vp_extensions, GL_FALSE ); + } return (void *) psp; diff --git a/src/mesa/drivers/dri/r128/r128_context.c b/src/mesa/drivers/dri/r128/r128_context.c index c0036c14908..f071bbecbfd 100644 --- a/src/mesa/drivers/dri/r128/r128_context.c +++ b/src/mesa/drivers/dri/r128/r128_context.c @@ -71,7 +71,7 @@ int R128_DEBUG = 0; #define need_GL_EXT_blend_minmax #include "extension_helper.h" -static const struct dri_extension card_extensions[] = +const struct dri_extension card_extensions[] = { { "GL_ARB_multisample", GL_ARB_multisample_functions }, { "GL_ARB_multitexture", NULL }, diff --git a/src/mesa/drivers/dri/r128/r128_screen.c b/src/mesa/drivers/dri/r128/r128_screen.c index f5d0287ed9f..b6177bf691d 100644 --- a/src/mesa/drivers/dri/r128/r128_screen.c +++ b/src/mesa/drivers/dri/r128/r128_screen.c @@ -75,6 +75,8 @@ static const GLuint __driNConfigOptions = 4; static const GLuint __driNConfigOptions = 3; #endif +extern const struct dri_extension card_extensions[]; + #if 1 /* Including xf86PciInfo.h introduces a bunch of errors... */ @@ -482,7 +484,7 @@ r128FillInModes( unsigned pixel_bits, unsigned depth_bits, * failure. */ PUBLIC -void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, +void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, const __GLcontextModes * modes, const __DRIversion * ddx_version, const __DRIversion * dri_version, @@ -519,6 +521,16 @@ void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIsc (dri_priv->bpp == 16) ? 16 : 24, (dri_priv->bpp == 16) ? 0 : 8, (dri_priv->backOffset != dri_priv->depthOffset) ); + + /* Calling driInitExtensions here, with a NULL context pointer, does not actually + * enable the extensions. It just makes sure that all the dispatch offsets for all + * the extensions that *might* be enables are known. This is needed because the + * dispatch offsets need to be known when _mesa_context_create is called, but we can't + * enable the extensions until we have a context pointer. + * + * Hello chicken. Hello egg. How are you two today? + */ + driInitExtensions( NULL, card_extensions, GL_FALSE ); } return (void *) psp; diff --git a/src/mesa/drivers/dri/r200/r200_context.c b/src/mesa/drivers/dri/r200/r200_context.c index 06834fb626e..fc5cf5a33f3 100644 --- a/src/mesa/drivers/dri/r200/r200_context.c +++ b/src/mesa/drivers/dri/r200/r200_context.c @@ -131,7 +131,7 @@ static const GLubyte *r200GetString( GLcontext *ctx, GLenum name ) /* Extension strings exported by the R200 driver. */ -static const struct dri_extension card_extensions[] = +const struct dri_extension card_extensions[] = { { "GL_ARB_multisample", GL_ARB_multisample_functions }, { "GL_ARB_multitexture", NULL }, @@ -162,17 +162,17 @@ static const struct dri_extension card_extensions[] = { NULL, NULL } }; -static const struct dri_extension blend_extensions[] = { +const struct dri_extension blend_extensions[] = { { "GL_EXT_blend_equation_separate", GL_EXT_blend_equation_separate_functions }, { "GL_EXT_blend_func_separate", GL_EXT_blend_func_separate_functions }, { NULL, NULL } }; -static const struct dri_extension ARB_vp_extension[] = { +const struct dri_extension ARB_vp_extension[] = { { "GL_ARB_vertex_program", GL_ARB_vertex_program_functions } }; -static const struct dri_extension NV_vp_extension[] = { +const struct dri_extension NV_vp_extension[] = { { "GL_NV_vertex_program", GL_NV_vertex_program_functions } }; diff --git a/src/mesa/drivers/dri/r200/r200_screen.c b/src/mesa/drivers/dri/r200/r200_screen.c index ddb3a91b1dc..f0e09d5fc4e 100644 --- a/src/mesa/drivers/dri/r200/r200_screen.c +++ b/src/mesa/drivers/dri/r200/r200_screen.c @@ -90,6 +90,11 @@ DRI_CONF_BEGIN DRI_CONF_END; static const GLuint __driNConfigOptions = 17; +extern const struct dri_extension card_extensions[]; +extern const struct dri_extension blend_extensions[]; +extern const struct dri_extension ARB_vp_extension[]; +extern const struct dri_extension NV_vp_extension[]; + #if 1 /* Including xf86PciInfo.h introduces a bunch of errors... */ @@ -642,7 +647,7 @@ static const struct __DriverAPIRec r200API = { * failure. */ PUBLIC -void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, +void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, const __GLcontextModes * modes, const __DRIversion * ddx_version, const __DRIversion * dri_version, @@ -678,6 +683,19 @@ void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIsc (dri_priv->bpp == 16) ? 16 : 24, (dri_priv->bpp == 16) ? 0 : 8, (dri_priv->backOffset != dri_priv->depthOffset) ); + + /* Calling driInitExtensions here, with a NULL context pointer, does not actually + * enable the extensions. It just makes sure that all the dispatch offsets for all + * the extensions that *might* be enables are known. This is needed because the + * dispatch offsets need to be known when _mesa_context_create is called, but we can't + * enable the extensions until we have a context pointer. + * + * Hello chicken. Hello egg. How are you two today? + */ + driInitExtensions( NULL, card_extensions, GL_FALSE ); + driInitExtensions( NULL, blend_extensions, GL_FALSE ); + driInitSingleExtension( NULL, ARB_vp_extension ); + driInitSingleExtension( NULL, NV_vp_extension ); } return (void *) psp; diff --git a/src/mesa/drivers/dri/r300/r300_context.c b/src/mesa/drivers/dri/r300/r300_context.c index 9100ac2565b..b3017372fe6 100644 --- a/src/mesa/drivers/dri/r300/r300_context.c +++ b/src/mesa/drivers/dri/r300/r300_context.c @@ -73,7 +73,7 @@ int hw_tcl_on=0; #define need_GL_EXT_blend_minmax #include "extension_helper.h" -static const struct dri_extension card_extensions[] = { +const struct dri_extension card_extensions[] = { {"GL_ARB_multisample", GL_ARB_multisample_functions}, {"GL_ARB_multitexture", NULL}, {"GL_ARB_texture_border_clamp", NULL}, diff --git a/src/mesa/drivers/dri/r300/radeon_screen.c b/src/mesa/drivers/dri/r300/radeon_screen.c index bc65dd81b8a..18919ddeb12 100644 --- a/src/mesa/drivers/dri/r300/radeon_screen.c +++ b/src/mesa/drivers/dri/r300/radeon_screen.c @@ -132,6 +132,7 @@ DRI_CONF_BEGIN DRI_CONF_END; static const GLuint __driR300NConfigOptions = 13; +extern const struct dri_extension card_extensions[]; #ifndef RADEON_DEBUG int RADEON_DEBUG = 0; @@ -789,7 +790,7 @@ static const struct __DriverAPIRec radeonAPI = { * \return A pointer to a \c __DRIscreenPrivate on success, or \c NULL on * failure. */ -void *__driCreateNewScreen_20050725(__DRInativeDisplay * dpy, int scrn, +void *__driCreateNewScreen_20050727(__DRInativeDisplay * dpy, int scrn, __DRIscreen * psc, const __GLcontextModes * modes, const __DRIversion * ddx_version, const __DRIversion * dri_version, @@ -826,6 +827,15 @@ void *__driCreateNewScreen_20050725(__DRInativeDisplay * dpy, int scrn, 16) ? 0 : 8, (dri_priv->backOffset != dri_priv->depthOffset)); + /* Calling driInitExtensions here, with a NULL context pointer, does not actually + * enable the extensions. It just makes sure that all the dispatch offsets for all + * the extensions that *might* be enables are known. This is needed because the + * dispatch offsets need to be known when _mesa_context_create is called, but we can't + * enable the extensions until we have a context pointer. + * + * Hello chicken. Hello egg. How are you two today? + */ + driInitExtensions( NULL, card_extensions, GL_FALSE ); } return (void *)psp; diff --git a/src/mesa/drivers/dri/radeon/radeon_context.c b/src/mesa/drivers/dri/radeon/radeon_context.c index 12f5f401151..c96f38e0abb 100644 --- a/src/mesa/drivers/dri/radeon/radeon_context.c +++ b/src/mesa/drivers/dri/radeon/radeon_context.c @@ -125,7 +125,7 @@ static const GLubyte *radeonGetString( GLcontext *ctx, GLenum name ) /* Extension strings exported by the R100 driver. */ -static const struct dri_extension card_extensions[] = +const struct dri_extension card_extensions[] = { { "GL_ARB_multisample", GL_ARB_multisample_functions }, { "GL_ARB_multitexture", NULL }, diff --git a/src/mesa/drivers/dri/radeon/radeon_screen.c b/src/mesa/drivers/dri/radeon/radeon_screen.c index 9cd60875b1b..0a2bb7e9161 100644 --- a/src/mesa/drivers/dri/radeon/radeon_screen.c +++ b/src/mesa/drivers/dri/radeon/radeon_screen.c @@ -83,6 +83,8 @@ DRI_CONF_BEGIN DRI_CONF_END; static const GLuint __driNConfigOptions = 13; +extern const struct dri_extension card_extensions[]; + #if 1 /* Including xf86PciInfo.h introduces a bunch of errors... */ @@ -566,7 +568,7 @@ static struct __DriverAPIRec radeonAPI = { * failure. */ PUBLIC -void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, +void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, const __GLcontextModes * modes, const __DRIversion * ddx_version, const __DRIversion * dri_version, @@ -602,6 +604,16 @@ void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIsc (dri_priv->bpp == 16) ? 16 : 24, (dri_priv->bpp == 16) ? 0 : 8, (dri_priv->backOffset != dri_priv->depthOffset) ); + + /* Calling driInitExtensions here, with a NULL context pointer, does not actually + * enable the extensions. It just makes sure that all the dispatch offsets for all + * the extensions that *might* be enables are known. This is needed because the + * dispatch offsets need to be known when _mesa_context_create is called, but we can't + * enable the extensions until we have a context pointer. + * + * Hello chicken. Hello egg. How are you two today? + */ + driInitExtensions( NULL, card_extensions, GL_FALSE ); } return (void *) psp; diff --git a/src/mesa/drivers/dri/savage/savage_xmesa.c b/src/mesa/drivers/dri/savage/savage_xmesa.c index bb8f015e760..fa20d10edb3 100644 --- a/src/mesa/drivers/dri/savage/savage_xmesa.c +++ b/src/mesa/drivers/dri/savage/savage_xmesa.c @@ -128,7 +128,7 @@ unsigned long time_sum=0; struct timeval tv_s1,tv_f1; #endif -static const struct dri_extension common_extensions[] = +static const struct dri_extension card_extensions[] = { { "GL_ARB_multisample", GL_ARB_multisample_functions }, { "GL_ARB_multitexture", NULL }, @@ -534,7 +534,7 @@ savageCreateContext( const __GLcontextModes *mesaVis, debug_control ); #endif - driInitExtensions( ctx, common_extensions, GL_TRUE ); + driInitExtensions( ctx, card_extensions, GL_TRUE ); if (savageScreen->chipset >= S3_SAVAGE4) driInitExtensions( ctx, s4_extensions, GL_FALSE ); if (ctx->Mesa_DXTn || @@ -997,7 +997,7 @@ savageFillInModes( unsigned pixel_bits, unsigned depth_bits, * failure. */ PUBLIC -void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, +void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, const __GLcontextModes * modes, const __DRIversion * ddx_version, const __DRIversion * dri_version, @@ -1033,6 +1033,16 @@ void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIsc (dri_priv->cpp == 2) ? 16 : 24, (dri_priv->cpp == 2) ? 0 : 8, (dri_priv->backOffset != dri_priv->depthOffset) ); + + /* Calling driInitExtensions here, with a NULL context pointer, does not actually + * enable the extensions. It just makes sure that all the dispatch offsets for all + * the extensions that *might* be enables are known. This is needed because the + * dispatch offsets need to be known when _mesa_context_create is called, but we can't + * enable the extensions until we have a context pointer. + * + * Hello chicken. Hello egg. How are you two today? + */ + driInitExtensions( NULL, card_extensions, GL_FALSE ); } return (void *) psp; diff --git a/src/mesa/drivers/dri/sis/sis_context.c b/src/mesa/drivers/dri/sis/sis_context.c index 2c544524587..6f48eed721e 100644 --- a/src/mesa/drivers/dri/sis/sis_context.c +++ b/src/mesa/drivers/dri/sis/sis_context.c @@ -64,7 +64,7 @@ int GlobalCurrentHwcx = -1; int GlobalHwcxCountBase = 1; int GlobalCmdQueueLen = 0; -static const struct dri_extension card_extensions[] = +const struct dri_extension card_extensions[] = { { "GL_ARB_multisample", GL_ARB_multisample_functions }, { "GL_ARB_multitexture", NULL }, diff --git a/src/mesa/drivers/dri/sis/sis_screen.c b/src/mesa/drivers/dri/sis/sis_screen.c index 592852e9418..174a74169ce 100644 --- a/src/mesa/drivers/dri/sis/sis_screen.c +++ b/src/mesa/drivers/dri/sis/sis_screen.c @@ -413,7 +413,7 @@ static struct __DriverAPIRec sisAPI = { * failure. */ PUBLIC -void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, +void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, const __GLcontextModes *modes, const __DRIversion *ddx_version, diff --git a/src/mesa/drivers/dri/tdfx/tdfx_context.c b/src/mesa/drivers/dri/tdfx/tdfx_context.c index 724416197f2..d90d4f06b96 100644 --- a/src/mesa/drivers/dri/tdfx/tdfx_context.c +++ b/src/mesa/drivers/dri/tdfx/tdfx_context.c @@ -83,7 +83,7 @@ /** * Common extension strings exported by all cards */ -static const struct dri_extension card_extensions[] = +const struct dri_extension card_extensions[] = { { "GL_ARB_multisample", GL_ARB_multisample_functions }, { "GL_ARB_texture_mirrored_repeat", NULL }, @@ -123,7 +123,7 @@ static const struct dri_extension card_extensions[] = /** * Extension strings exported only by Naplam (e.g., Voodoo4 & Voodoo5) cards. */ -static const struct dri_extension napalm_extensions[] = +const struct dri_extension napalm_extensions[] = { { "GL_ARB_texture_compression", GL_ARB_texture_compression_functions }, { "GL_ARB_texture_env_combine", NULL }, diff --git a/src/mesa/drivers/dri/tdfx/tdfx_screen.c b/src/mesa/drivers/dri/tdfx/tdfx_screen.c index b373129646b..0da4d7e3c2e 100644 --- a/src/mesa/drivers/dri/tdfx/tdfx_screen.c +++ b/src/mesa/drivers/dri/tdfx/tdfx_screen.c @@ -65,6 +65,9 @@ DRI_CONF_END; static const GLuint __driNConfigOptions = 1; +extern const struct dri_extension card_extensions[]; +extern const struct dri_extension napalm_extensions[]; + static GLboolean tdfxCreateScreen( __DRIscreenPrivate *sPriv ) { @@ -426,7 +429,7 @@ static __GLcontextModes *tdfxFillInModes(unsigned pixel_bits, * failure. */ PUBLIC -void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, +void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, const __GLcontextModes * modes, const __DRIversion * ddx_version, const __DRIversion * dri_version, @@ -467,6 +470,17 @@ void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, __DRIsc *driver_modes = tdfxFillInModes(bpp, (bpp == 16) ? 16 : 24, (bpp == 16) ? 0 : 8, (dri_priv->backOffset!=dri_priv->depthOffset)); + + /* Calling driInitExtensions here, with a NULL context pointer, does not actually + * enable the extensions. It just makes sure that all the dispatch offsets for all + * the extensions that *might* be enables are known. This is needed because the + * dispatch offsets need to be known when _mesa_context_create is called, but we can't + * enable the extensions until we have a context pointer. + * + * Hello chicken. Hello egg. How are you two today? + */ + driInitExtensions( NULL, card_extensions, GL_FALSE ); + driInitExtensions( NULL, napalm_extensions, GL_FALSE ); } return (void *)psp; diff --git a/src/mesa/drivers/dri/trident/trident_context.c b/src/mesa/drivers/dri/trident/trident_context.c index 0af70e96fc9..8d0717937e8 100644 --- a/src/mesa/drivers/dri/trident/trident_context.c +++ b/src/mesa/drivers/dri/trident/trident_context.c @@ -426,7 +426,7 @@ static struct __DriverAPIRec tridentAPI = { }; -PUBLIC void *__driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, +PUBLIC void *__driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, const __GLcontextModes * modes, const __DRIversion * ddx_version, diff --git a/src/mesa/drivers/dri/unichrome/via_context.c b/src/mesa/drivers/dri/unichrome/via_context.c index ca31245b0fd..abcdcd70a5e 100644 --- a/src/mesa/drivers/dri/unichrome/via_context.c +++ b/src/mesa/drivers/dri/unichrome/via_context.c @@ -251,7 +251,7 @@ static void viaBufferSize(GLframebuffer *buffer, GLuint *width, GLuint *height) /* Extension strings exported by the Unichrome driver. */ -static const struct dri_extension card_extensions[] = +const struct dri_extension card_extensions[] = { { "GL_ARB_multisample", GL_ARB_multisample_functions }, { "GL_ARB_multitexture", NULL }, diff --git a/src/mesa/drivers/dri/unichrome/via_screen.c b/src/mesa/drivers/dri/unichrome/via_screen.c index 8de73539259..2ae2322f8ac 100644 --- a/src/mesa/drivers/dri/unichrome/via_screen.c +++ b/src/mesa/drivers/dri/unichrome/via_screen.c @@ -61,6 +61,7 @@ DRI_CONF_BEGIN DRI_CONF_END; static const GLuint __driNConfigOptions = 3; +extern const struct dri_extension card_extensions[]; static int getSwapInfo( __DRIdrawablePrivate *dPriv, __DRIswapInfo * sInfo ); @@ -402,7 +403,7 @@ viaFillInModes( unsigned pixel_bits, GLboolean have_back_buffer ) * failure. */ PUBLIC -void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, +void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, const __GLcontextModes * modes, const __DRIversion * ddx_version, @@ -437,6 +438,16 @@ void * __driCreateNewScreen_20050725( __DRInativeDisplay *dpy, int scrn, VIADRIPtr dri_priv = (VIADRIPtr) psp->pDevPriv; *driver_modes = viaFillInModes( dri_priv->bytesPerPixel * 8, GL_TRUE ); + + /* Calling driInitExtensions here, with a NULL context pointer, does not actually + * enable the extensions. It just makes sure that all the dispatch offsets for all + * the extensions that *might* be enables are known. This is needed because the + * dispatch offsets need to be known when _mesa_context_create is called, but we can't + * enable the extensions until we have a context pointer. + * + * Hello chicken. Hello egg. How are you two today? + */ + driInitExtensions( NULL, card_extensions, GL_FALSE ); } fprintf(stderr, "%s - succeeded\n", __FUNCTION__); diff --git a/src/mesa/glapi/dispatch.h b/src/mesa/glapi/dispatch.h index 3295598e2d1..1e61edcf9f4 100644 --- a/src/mesa/glapi/dispatch.h +++ b/src/mesa/glapi/dispatch.h @@ -44,7 +44,7 @@ #define GET_by_offset(disp, offset) \ (((_glapi_proc *)(disp))[offset]) #define SET_by_offset(disp, offset, fn) \ - ((((_glapi_proc *)(disp))[offset]) = fn) + ((((_glapi_proc *)(disp))[offset]) = (_glapi_proc) fn) #define CALL_NewList(disp, parameters) (*((disp)->NewList)) parameters #define GET_NewList(disp) ((disp)->NewList) @@ -1270,6 +1270,9 @@ #define CALL_MultiTexCoord4svARB(disp, parameters) (*((disp)->MultiTexCoord4svARB)) parameters #define GET_MultiTexCoord4svARB(disp) ((disp)->MultiTexCoord4svARB) #define SET_MultiTexCoord4svARB(disp, fn) ((disp)->MultiTexCoord4svARB = fn) + +#if !defined(IN_DRI_DRIVER) + #define CALL_LoadTransposeMatrixfARB(disp, parameters) (*((disp)->LoadTransposeMatrixfARB)) parameters #define GET_LoadTransposeMatrixfARB(disp) ((disp)->LoadTransposeMatrixfARB) #define SET_LoadTransposeMatrixfARB(disp, fn) ((disp)->LoadTransposeMatrixfARB = fn) @@ -2495,4 +2498,1645 @@ #define GET_StencilMaskSeparate(disp) ((disp)->StencilMaskSeparate) #define SET_StencilMaskSeparate(disp, fn) ((disp)->StencilMaskSeparate = fn) +#else + +#define driDispatchRemapTable_size 408 +extern unsigned driDispatchRemapTable[ driDispatchRemapTable_size ]; + +#define LoadTransposeMatrixfARB_remap_index 0 +#define LoadTransposeMatrixdARB_remap_index 1 +#define MultTransposeMatrixfARB_remap_index 2 +#define MultTransposeMatrixdARB_remap_index 3 +#define SampleCoverageARB_remap_index 4 +#define DrawBuffersARB_remap_index 5 +#define PolygonOffsetEXT_remap_index 6 +#define GetTexFilterFuncSGIS_remap_index 7 +#define TexFilterFuncSGIS_remap_index 8 +#define GetHistogramEXT_remap_index 9 +#define GetHistogramParameterfvEXT_remap_index 10 +#define GetHistogramParameterivEXT_remap_index 11 +#define GetMinmaxEXT_remap_index 12 +#define GetMinmaxParameterfvEXT_remap_index 13 +#define GetMinmaxParameterivEXT_remap_index 14 +#define GetConvolutionFilterEXT_remap_index 15 +#define GetConvolutionParameterfvEXT_remap_index 16 +#define GetConvolutionParameterivEXT_remap_index 17 +#define GetSeparableFilterEXT_remap_index 18 +#define GetColorTableSGI_remap_index 19 +#define GetColorTableParameterfvSGI_remap_index 20 +#define GetColorTableParameterivSGI_remap_index 21 +#define PixelTexGenSGIX_remap_index 22 +#define PixelTexGenParameteriSGIS_remap_index 23 +#define PixelTexGenParameterivSGIS_remap_index 24 +#define PixelTexGenParameterfSGIS_remap_index 25 +#define PixelTexGenParameterfvSGIS_remap_index 26 +#define GetPixelTexGenParameterivSGIS_remap_index 27 +#define GetPixelTexGenParameterfvSGIS_remap_index 28 +#define TexImage4DSGIS_remap_index 29 +#define TexSubImage4DSGIS_remap_index 30 +#define AreTexturesResidentEXT_remap_index 31 +#define GenTexturesEXT_remap_index 32 +#define IsTextureEXT_remap_index 33 +#define DetailTexFuncSGIS_remap_index 34 +#define GetDetailTexFuncSGIS_remap_index 35 +#define SharpenTexFuncSGIS_remap_index 36 +#define GetSharpenTexFuncSGIS_remap_index 37 +#define SampleMaskSGIS_remap_index 38 +#define SamplePatternSGIS_remap_index 39 +#define ColorPointerEXT_remap_index 40 +#define EdgeFlagPointerEXT_remap_index 41 +#define IndexPointerEXT_remap_index 42 +#define NormalPointerEXT_remap_index 43 +#define TexCoordPointerEXT_remap_index 44 +#define VertexPointerEXT_remap_index 45 +#define SpriteParameterfSGIX_remap_index 46 +#define SpriteParameterfvSGIX_remap_index 47 +#define SpriteParameteriSGIX_remap_index 48 +#define SpriteParameterivSGIX_remap_index 49 +#define PointParameterfEXT_remap_index 50 +#define PointParameterfvEXT_remap_index 51 +#define GetInstrumentsSGIX_remap_index 52 +#define InstrumentsBufferSGIX_remap_index 53 +#define PollInstrumentsSGIX_remap_index 54 +#define ReadInstrumentsSGIX_remap_index 55 +#define StartInstrumentsSGIX_remap_index 56 +#define StopInstrumentsSGIX_remap_index 57 +#define FrameZoomSGIX_remap_index 58 +#define TagSampleBufferSGIX_remap_index 59 +#define ReferencePlaneSGIX_remap_index 60 +#define FlushRasterSGIX_remap_index 61 +#define GetListParameterfvSGIX_remap_index 62 +#define GetListParameterivSGIX_remap_index 63 +#define ListParameterfSGIX_remap_index 64 +#define ListParameterfvSGIX_remap_index 65 +#define ListParameteriSGIX_remap_index 66 +#define ListParameterivSGIX_remap_index 67 +#define FragmentColorMaterialSGIX_remap_index 68 +#define FragmentLightfSGIX_remap_index 69 +#define FragmentLightfvSGIX_remap_index 70 +#define FragmentLightiSGIX_remap_index 71 +#define FragmentLightivSGIX_remap_index 72 +#define FragmentLightModelfSGIX_remap_index 73 +#define FragmentLightModelfvSGIX_remap_index 74 +#define FragmentLightModeliSGIX_remap_index 75 +#define FragmentLightModelivSGIX_remap_index 76 +#define FragmentMaterialfSGIX_remap_index 77 +#define FragmentMaterialfvSGIX_remap_index 78 +#define FragmentMaterialiSGIX_remap_index 79 +#define FragmentMaterialivSGIX_remap_index 80 +#define GetFragmentLightfvSGIX_remap_index 81 +#define GetFragmentLightivSGIX_remap_index 82 +#define GetFragmentMaterialfvSGIX_remap_index 83 +#define GetFragmentMaterialivSGIX_remap_index 84 +#define LightEnviSGIX_remap_index 85 +#define VertexWeightfEXT_remap_index 86 +#define VertexWeightfvEXT_remap_index 87 +#define VertexWeightPointerEXT_remap_index 88 +#define FlushVertexArrayRangeNV_remap_index 89 +#define VertexArrayRangeNV_remap_index 90 +#define CombinerParameterfvNV_remap_index 91 +#define CombinerParameterfNV_remap_index 92 +#define CombinerParameterivNV_remap_index 93 +#define CombinerParameteriNV_remap_index 94 +#define CombinerInputNV_remap_index 95 +#define CombinerOutputNV_remap_index 96 +#define FinalCombinerInputNV_remap_index 97 +#define GetCombinerInputParameterfvNV_remap_index 98 +#define GetCombinerInputParameterivNV_remap_index 99 +#define GetCombinerOutputParameterfvNV_remap_index 100 +#define GetCombinerOutputParameterivNV_remap_index 101 +#define GetFinalCombinerInputParameterfvNV_remap_index 102 +#define GetFinalCombinerInputParameterivNV_remap_index 103 +#define ResizeBuffersMESA_remap_index 104 +#define WindowPos2dMESA_remap_index 105 +#define WindowPos2dvMESA_remap_index 106 +#define WindowPos2fMESA_remap_index 107 +#define WindowPos2fvMESA_remap_index 108 +#define WindowPos2iMESA_remap_index 109 +#define WindowPos2ivMESA_remap_index 110 +#define WindowPos2sMESA_remap_index 111 +#define WindowPos2svMESA_remap_index 112 +#define WindowPos3dMESA_remap_index 113 +#define WindowPos3dvMESA_remap_index 114 +#define WindowPos3fMESA_remap_index 115 +#define WindowPos3fvMESA_remap_index 116 +#define WindowPos3iMESA_remap_index 117 +#define WindowPos3ivMESA_remap_index 118 +#define WindowPos3sMESA_remap_index 119 +#define WindowPos3svMESA_remap_index 120 +#define WindowPos4dMESA_remap_index 121 +#define WindowPos4dvMESA_remap_index 122 +#define WindowPos4fMESA_remap_index 123 +#define WindowPos4fvMESA_remap_index 124 +#define WindowPos4iMESA_remap_index 125 +#define WindowPos4ivMESA_remap_index 126 +#define WindowPos4sMESA_remap_index 127 +#define WindowPos4svMESA_remap_index 128 +#define BlendFuncSeparateEXT_remap_index 129 +#define IndexMaterialEXT_remap_index 130 +#define IndexFuncEXT_remap_index 131 +#define LockArraysEXT_remap_index 132 +#define UnlockArraysEXT_remap_index 133 +#define CullParameterdvEXT_remap_index 134 +#define CullParameterfvEXT_remap_index 135 +#define HintPGI_remap_index 136 +#define FogCoordfEXT_remap_index 137 +#define FogCoordfvEXT_remap_index 138 +#define FogCoorddEXT_remap_index 139 +#define FogCoorddvEXT_remap_index 140 +#define FogCoordPointerEXT_remap_index 141 +#define GetColorTableEXT_remap_index 142 +#define GetColorTableParameterivEXT_remap_index 143 +#define GetColorTableParameterfvEXT_remap_index 144 +#define TbufferMask3DFX_remap_index 145 +#define CompressedTexImage3DARB_remap_index 146 +#define CompressedTexImage2DARB_remap_index 147 +#define CompressedTexImage1DARB_remap_index 148 +#define CompressedTexSubImage3DARB_remap_index 149 +#define CompressedTexSubImage2DARB_remap_index 150 +#define CompressedTexSubImage1DARB_remap_index 151 +#define GetCompressedTexImageARB_remap_index 152 +#define SecondaryColor3bEXT_remap_index 153 +#define SecondaryColor3bvEXT_remap_index 154 +#define SecondaryColor3dEXT_remap_index 155 +#define SecondaryColor3dvEXT_remap_index 156 +#define SecondaryColor3fEXT_remap_index 157 +#define SecondaryColor3fvEXT_remap_index 158 +#define SecondaryColor3iEXT_remap_index 159 +#define SecondaryColor3ivEXT_remap_index 160 +#define SecondaryColor3sEXT_remap_index 161 +#define SecondaryColor3svEXT_remap_index 162 +#define SecondaryColor3ubEXT_remap_index 163 +#define SecondaryColor3ubvEXT_remap_index 164 +#define SecondaryColor3uiEXT_remap_index 165 +#define SecondaryColor3uivEXT_remap_index 166 +#define SecondaryColor3usEXT_remap_index 167 +#define SecondaryColor3usvEXT_remap_index 168 +#define SecondaryColorPointerEXT_remap_index 169 +#define AreProgramsResidentNV_remap_index 170 +#define BindProgramNV_remap_index 171 +#define DeleteProgramsNV_remap_index 172 +#define ExecuteProgramNV_remap_index 173 +#define GenProgramsNV_remap_index 174 +#define GetProgramParameterdvNV_remap_index 175 +#define GetProgramParameterfvNV_remap_index 176 +#define GetProgramivNV_remap_index 177 +#define GetProgramStringNV_remap_index 178 +#define GetTrackMatrixivNV_remap_index 179 +#define GetVertexAttribdvARB_remap_index 180 +#define GetVertexAttribfvARB_remap_index 181 +#define GetVertexAttribivARB_remap_index 182 +#define GetVertexAttribPointervNV_remap_index 183 +#define IsProgramNV_remap_index 184 +#define LoadProgramNV_remap_index 185 +#define ProgramParameter4dNV_remap_index 186 +#define ProgramParameter4dvNV_remap_index 187 +#define ProgramParameter4fNV_remap_index 188 +#define ProgramParameter4fvNV_remap_index 189 +#define ProgramParameters4dvNV_remap_index 190 +#define ProgramParameters4fvNV_remap_index 191 +#define RequestResidentProgramsNV_remap_index 192 +#define TrackMatrixNV_remap_index 193 +#define VertexAttribPointerNV_remap_index 194 +#define VertexAttrib1dARB_remap_index 195 +#define VertexAttrib1dvARB_remap_index 196 +#define VertexAttrib1fARB_remap_index 197 +#define VertexAttrib1fvARB_remap_index 198 +#define VertexAttrib1sARB_remap_index 199 +#define VertexAttrib1svARB_remap_index 200 +#define VertexAttrib2dARB_remap_index 201 +#define VertexAttrib2dvARB_remap_index 202 +#define VertexAttrib2fARB_remap_index 203 +#define VertexAttrib2fvARB_remap_index 204 +#define VertexAttrib2sARB_remap_index 205 +#define VertexAttrib2svARB_remap_index 206 +#define VertexAttrib3dARB_remap_index 207 +#define VertexAttrib3dvARB_remap_index 208 +#define VertexAttrib3fARB_remap_index 209 +#define VertexAttrib3fvARB_remap_index 210 +#define VertexAttrib3sARB_remap_index 211 +#define VertexAttrib3svARB_remap_index 212 +#define VertexAttrib4dARB_remap_index 213 +#define VertexAttrib4dvARB_remap_index 214 +#define VertexAttrib4fARB_remap_index 215 +#define VertexAttrib4fvARB_remap_index 216 +#define VertexAttrib4sARB_remap_index 217 +#define VertexAttrib4svARB_remap_index 218 +#define VertexAttrib4NubARB_remap_index 219 +#define VertexAttrib4NubvARB_remap_index 220 +#define VertexAttribs1dvNV_remap_index 221 +#define VertexAttribs1fvNV_remap_index 222 +#define VertexAttribs1svNV_remap_index 223 +#define VertexAttribs2dvNV_remap_index 224 +#define VertexAttribs2fvNV_remap_index 225 +#define VertexAttribs2svNV_remap_index 226 +#define VertexAttribs3dvNV_remap_index 227 +#define VertexAttribs3fvNV_remap_index 228 +#define VertexAttribs3svNV_remap_index 229 +#define VertexAttribs4dvNV_remap_index 230 +#define VertexAttribs4fvNV_remap_index 231 +#define VertexAttribs4svNV_remap_index 232 +#define VertexAttribs4ubvNV_remap_index 233 +#define PointParameteriNV_remap_index 234 +#define PointParameterivNV_remap_index 235 +#define MultiDrawArraysEXT_remap_index 236 +#define MultiDrawElementsEXT_remap_index 237 +#define ActiveStencilFaceEXT_remap_index 238 +#define DeleteFencesNV_remap_index 239 +#define GenFencesNV_remap_index 240 +#define IsFenceNV_remap_index 241 +#define TestFenceNV_remap_index 242 +#define GetFenceivNV_remap_index 243 +#define FinishFenceNV_remap_index 244 +#define SetFenceNV_remap_index 245 +#define VertexAttrib4bvARB_remap_index 246 +#define VertexAttrib4ivARB_remap_index 247 +#define VertexAttrib4ubvARB_remap_index 248 +#define VertexAttrib4usvARB_remap_index 249 +#define VertexAttrib4uivARB_remap_index 250 +#define VertexAttrib4NbvARB_remap_index 251 +#define VertexAttrib4NsvARB_remap_index 252 +#define VertexAttrib4NivARB_remap_index 253 +#define VertexAttrib4NusvARB_remap_index 254 +#define VertexAttrib4NuivARB_remap_index 255 +#define VertexAttribPointerARB_remap_index 256 +#define EnableVertexAttribArrayARB_remap_index 257 +#define DisableVertexAttribArrayARB_remap_index 258 +#define ProgramStringARB_remap_index 259 +#define ProgramEnvParameter4dARB_remap_index 260 +#define ProgramEnvParameter4dvARB_remap_index 261 +#define ProgramEnvParameter4fARB_remap_index 262 +#define ProgramEnvParameter4fvARB_remap_index 263 +#define ProgramLocalParameter4dARB_remap_index 264 +#define ProgramLocalParameter4dvARB_remap_index 265 +#define ProgramLocalParameter4fARB_remap_index 266 +#define ProgramLocalParameter4fvARB_remap_index 267 +#define GetProgramEnvParameterdvARB_remap_index 268 +#define GetProgramEnvParameterfvARB_remap_index 269 +#define GetProgramLocalParameterdvARB_remap_index 270 +#define GetProgramLocalParameterfvARB_remap_index 271 +#define GetProgramivARB_remap_index 272 +#define GetProgramStringARB_remap_index 273 +#define ProgramNamedParameter4fNV_remap_index 274 +#define ProgramNamedParameter4dNV_remap_index 275 +#define ProgramNamedParameter4fvNV_remap_index 276 +#define ProgramNamedParameter4dvNV_remap_index 277 +#define GetProgramNamedParameterfvNV_remap_index 278 +#define GetProgramNamedParameterdvNV_remap_index 279 +#define BindBufferARB_remap_index 280 +#define BufferDataARB_remap_index 281 +#define BufferSubDataARB_remap_index 282 +#define DeleteBuffersARB_remap_index 283 +#define GenBuffersARB_remap_index 284 +#define GetBufferParameterivARB_remap_index 285 +#define GetBufferPointervARB_remap_index 286 +#define GetBufferSubDataARB_remap_index 287 +#define IsBufferARB_remap_index 288 +#define MapBufferARB_remap_index 289 +#define UnmapBufferARB_remap_index 290 +#define DepthBoundsEXT_remap_index 291 +#define GenQueriesARB_remap_index 292 +#define DeleteQueriesARB_remap_index 293 +#define IsQueryARB_remap_index 294 +#define BeginQueryARB_remap_index 295 +#define EndQueryARB_remap_index 296 +#define GetQueryivARB_remap_index 297 +#define GetQueryObjectivARB_remap_index 298 +#define GetQueryObjectuivARB_remap_index 299 +#define MultiModeDrawArraysIBM_remap_index 300 +#define MultiModeDrawElementsIBM_remap_index 301 +#define BlendEquationSeparateEXT_remap_index 302 +#define DeleteObjectARB_remap_index 303 +#define GetHandleARB_remap_index 304 +#define DetachObjectARB_remap_index 305 +#define CreateShaderObjectARB_remap_index 306 +#define ShaderSourceARB_remap_index 307 +#define CompileShaderARB_remap_index 308 +#define CreateProgramObjectARB_remap_index 309 +#define AttachObjectARB_remap_index 310 +#define LinkProgramARB_remap_index 311 +#define UseProgramObjectARB_remap_index 312 +#define ValidateProgramARB_remap_index 313 +#define Uniform1fARB_remap_index 314 +#define Uniform2fARB_remap_index 315 +#define Uniform3fARB_remap_index 316 +#define Uniform4fARB_remap_index 317 +#define Uniform1iARB_remap_index 318 +#define Uniform2iARB_remap_index 319 +#define Uniform3iARB_remap_index 320 +#define Uniform4iARB_remap_index 321 +#define Uniform1fvARB_remap_index 322 +#define Uniform2fvARB_remap_index 323 +#define Uniform3fvARB_remap_index 324 +#define Uniform4fvARB_remap_index 325 +#define Uniform1ivARB_remap_index 326 +#define Uniform2ivARB_remap_index 327 +#define Uniform3ivARB_remap_index 328 +#define Uniform4ivARB_remap_index 329 +#define UniformMatrix2fvARB_remap_index 330 +#define UniformMatrix3fvARB_remap_index 331 +#define UniformMatrix4fvARB_remap_index 332 +#define GetObjectParameterfvARB_remap_index 333 +#define GetObjectParameterivARB_remap_index 334 +#define GetInfoLogARB_remap_index 335 +#define GetAttachedObjectsARB_remap_index 336 +#define GetUniformLocationARB_remap_index 337 +#define GetActiveUniformARB_remap_index 338 +#define GetUniformfvARB_remap_index 339 +#define GetUniformivARB_remap_index 340 +#define GetShaderSourceARB_remap_index 341 +#define BindAttribLocationARB_remap_index 342 +#define GetActiveAttribARB_remap_index 343 +#define GetAttribLocationARB_remap_index 344 +#define GetVertexAttribdvNV_remap_index 345 +#define GetVertexAttribfvNV_remap_index 346 +#define GetVertexAttribivNV_remap_index 347 +#define VertexAttrib1dNV_remap_index 348 +#define VertexAttrib1dvNV_remap_index 349 +#define VertexAttrib1fNV_remap_index 350 +#define VertexAttrib1fvNV_remap_index 351 +#define VertexAttrib1sNV_remap_index 352 +#define VertexAttrib1svNV_remap_index 353 +#define VertexAttrib2dNV_remap_index 354 +#define VertexAttrib2dvNV_remap_index 355 +#define VertexAttrib2fNV_remap_index 356 +#define VertexAttrib2fvNV_remap_index 357 +#define VertexAttrib2sNV_remap_index 358 +#define VertexAttrib2svNV_remap_index 359 +#define VertexAttrib3dNV_remap_index 360 +#define VertexAttrib3dvNV_remap_index 361 +#define VertexAttrib3fNV_remap_index 362 +#define VertexAttrib3fvNV_remap_index 363 +#define VertexAttrib3sNV_remap_index 364 +#define VertexAttrib3svNV_remap_index 365 +#define VertexAttrib4dNV_remap_index 366 +#define VertexAttrib4dvNV_remap_index 367 +#define VertexAttrib4fNV_remap_index 368 +#define VertexAttrib4fvNV_remap_index 369 +#define VertexAttrib4sNV_remap_index 370 +#define VertexAttrib4svNV_remap_index 371 +#define VertexAttrib4ubNV_remap_index 372 +#define VertexAttrib4ubvNV_remap_index 373 +#define GenFragmentShadersATI_remap_index 374 +#define BindFragmentShaderATI_remap_index 375 +#define DeleteFragmentShaderATI_remap_index 376 +#define BeginFragmentShaderATI_remap_index 377 +#define EndFragmentShaderATI_remap_index 378 +#define PassTexCoordATI_remap_index 379 +#define SampleMapATI_remap_index 380 +#define ColorFragmentOp1ATI_remap_index 381 +#define ColorFragmentOp2ATI_remap_index 382 +#define ColorFragmentOp3ATI_remap_index 383 +#define AlphaFragmentOp1ATI_remap_index 384 +#define AlphaFragmentOp2ATI_remap_index 385 +#define AlphaFragmentOp3ATI_remap_index 386 +#define SetFragmentShaderConstantATI_remap_index 387 +#define IsRenderbufferEXT_remap_index 388 +#define BindRenderbufferEXT_remap_index 389 +#define DeleteRenderbuffersEXT_remap_index 390 +#define GenRenderbuffersEXT_remap_index 391 +#define RenderbufferStorageEXT_remap_index 392 +#define GetRenderbufferParameterivEXT_remap_index 393 +#define IsFramebufferEXT_remap_index 394 +#define BindFramebufferEXT_remap_index 395 +#define DeleteFramebuffersEXT_remap_index 396 +#define GenFramebuffersEXT_remap_index 397 +#define CheckFramebufferStatusEXT_remap_index 398 +#define FramebufferTexture1DEXT_remap_index 399 +#define FramebufferTexture2DEXT_remap_index 400 +#define FramebufferTexture3DEXT_remap_index 401 +#define FramebufferRenderbufferEXT_remap_index 402 +#define GetFramebufferAttachmentParameterivEXT_remap_index 403 +#define GenerateMipmapEXT_remap_index 404 +#define StencilFuncSeparate_remap_index 405 +#define StencilOpSeparate_remap_index 406 +#define StencilMaskSeparate_remap_index 407 + +#define CALL_LoadTransposeMatrixfARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), driDispatchRemapTable[LoadTransposeMatrixfARB_remap_index], parameters) +#define GET_LoadTransposeMatrixfARB(disp) GET_by_offset(disp, driDispatchRemapTable[LoadTransposeMatrixfARB_remap_index]) +#define SET_LoadTransposeMatrixfARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[LoadTransposeMatrixfARB_remap_index], fn) +#define CALL_LoadTransposeMatrixdARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), driDispatchRemapTable[LoadTransposeMatrixdARB_remap_index], parameters) +#define GET_LoadTransposeMatrixdARB(disp) GET_by_offset(disp, driDispatchRemapTable[LoadTransposeMatrixdARB_remap_index]) +#define SET_LoadTransposeMatrixdARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[LoadTransposeMatrixdARB_remap_index], fn) +#define CALL_MultTransposeMatrixfARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), driDispatchRemapTable[MultTransposeMatrixfARB_remap_index], parameters) +#define GET_MultTransposeMatrixfARB(disp) GET_by_offset(disp, driDispatchRemapTable[MultTransposeMatrixfARB_remap_index]) +#define SET_MultTransposeMatrixfARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[MultTransposeMatrixfARB_remap_index], fn) +#define CALL_MultTransposeMatrixdARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), driDispatchRemapTable[MultTransposeMatrixdARB_remap_index], parameters) +#define GET_MultTransposeMatrixdARB(disp) GET_by_offset(disp, driDispatchRemapTable[MultTransposeMatrixdARB_remap_index]) +#define SET_MultTransposeMatrixdARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[MultTransposeMatrixdARB_remap_index], fn) +#define CALL_SampleCoverageARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampf, GLboolean)), driDispatchRemapTable[SampleCoverageARB_remap_index], parameters) +#define GET_SampleCoverageARB(disp) GET_by_offset(disp, driDispatchRemapTable[SampleCoverageARB_remap_index]) +#define SET_SampleCoverageARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SampleCoverageARB_remap_index], fn) +#define CALL_DrawBuffersARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLenum *)), driDispatchRemapTable[DrawBuffersARB_remap_index], parameters) +#define GET_DrawBuffersARB(disp) GET_by_offset(disp, driDispatchRemapTable[DrawBuffersARB_remap_index]) +#define SET_DrawBuffersARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DrawBuffersARB_remap_index], fn) +#define CALL_PolygonOffsetEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat)), driDispatchRemapTable[PolygonOffsetEXT_remap_index], parameters) +#define GET_PolygonOffsetEXT(disp) GET_by_offset(disp, driDispatchRemapTable[PolygonOffsetEXT_remap_index]) +#define SET_PolygonOffsetEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PolygonOffsetEXT_remap_index], fn) +#define CALL_GetTexFilterFuncSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetTexFilterFuncSGIS_remap_index], parameters) +#define GET_GetTexFilterFuncSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[GetTexFilterFuncSGIS_remap_index]) +#define SET_GetTexFilterFuncSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetTexFilterFuncSGIS_remap_index], fn) +#define CALL_TexFilterFuncSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLsizei, const GLfloat *)), driDispatchRemapTable[TexFilterFuncSGIS_remap_index], parameters) +#define GET_TexFilterFuncSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[TexFilterFuncSGIS_remap_index]) +#define SET_TexFilterFuncSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[TexFilterFuncSGIS_remap_index], fn) +#define CALL_GetHistogramEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLboolean, GLenum, GLenum, GLvoid *)), driDispatchRemapTable[GetHistogramEXT_remap_index], parameters) +#define GET_GetHistogramEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetHistogramEXT_remap_index]) +#define SET_GetHistogramEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetHistogramEXT_remap_index], fn) +#define CALL_GetHistogramParameterfvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetHistogramParameterfvEXT_remap_index], parameters) +#define GET_GetHistogramParameterfvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetHistogramParameterfvEXT_remap_index]) +#define SET_GetHistogramParameterfvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetHistogramParameterfvEXT_remap_index], fn) +#define CALL_GetHistogramParameterivEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetHistogramParameterivEXT_remap_index], parameters) +#define GET_GetHistogramParameterivEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetHistogramParameterivEXT_remap_index]) +#define SET_GetHistogramParameterivEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetHistogramParameterivEXT_remap_index], fn) +#define CALL_GetMinmaxEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLboolean, GLenum, GLenum, GLvoid *)), driDispatchRemapTable[GetMinmaxEXT_remap_index], parameters) +#define GET_GetMinmaxEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetMinmaxEXT_remap_index]) +#define SET_GetMinmaxEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetMinmaxEXT_remap_index], fn) +#define CALL_GetMinmaxParameterfvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetMinmaxParameterfvEXT_remap_index], parameters) +#define GET_GetMinmaxParameterfvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetMinmaxParameterfvEXT_remap_index]) +#define SET_GetMinmaxParameterfvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetMinmaxParameterfvEXT_remap_index], fn) +#define CALL_GetMinmaxParameterivEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetMinmaxParameterivEXT_remap_index], parameters) +#define GET_GetMinmaxParameterivEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetMinmaxParameterivEXT_remap_index]) +#define SET_GetMinmaxParameterivEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetMinmaxParameterivEXT_remap_index], fn) +#define CALL_GetConvolutionFilterEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLvoid *)), driDispatchRemapTable[GetConvolutionFilterEXT_remap_index], parameters) +#define GET_GetConvolutionFilterEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetConvolutionFilterEXT_remap_index]) +#define SET_GetConvolutionFilterEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetConvolutionFilterEXT_remap_index], fn) +#define CALL_GetConvolutionParameterfvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetConvolutionParameterfvEXT_remap_index], parameters) +#define GET_GetConvolutionParameterfvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetConvolutionParameterfvEXT_remap_index]) +#define SET_GetConvolutionParameterfvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetConvolutionParameterfvEXT_remap_index], fn) +#define CALL_GetConvolutionParameterivEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetConvolutionParameterivEXT_remap_index], parameters) +#define GET_GetConvolutionParameterivEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetConvolutionParameterivEXT_remap_index]) +#define SET_GetConvolutionParameterivEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetConvolutionParameterivEXT_remap_index], fn) +#define CALL_GetSeparableFilterEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *)), driDispatchRemapTable[GetSeparableFilterEXT_remap_index], parameters) +#define GET_GetSeparableFilterEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetSeparableFilterEXT_remap_index]) +#define SET_GetSeparableFilterEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetSeparableFilterEXT_remap_index], fn) +#define CALL_GetColorTableSGI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLvoid *)), driDispatchRemapTable[GetColorTableSGI_remap_index], parameters) +#define GET_GetColorTableSGI(disp) GET_by_offset(disp, driDispatchRemapTable[GetColorTableSGI_remap_index]) +#define SET_GetColorTableSGI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetColorTableSGI_remap_index], fn) +#define CALL_GetColorTableParameterfvSGI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetColorTableParameterfvSGI_remap_index], parameters) +#define GET_GetColorTableParameterfvSGI(disp) GET_by_offset(disp, driDispatchRemapTable[GetColorTableParameterfvSGI_remap_index]) +#define SET_GetColorTableParameterfvSGI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetColorTableParameterfvSGI_remap_index], fn) +#define CALL_GetColorTableParameterivSGI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetColorTableParameterivSGI_remap_index], parameters) +#define GET_GetColorTableParameterivSGI(disp) GET_by_offset(disp, driDispatchRemapTable[GetColorTableParameterivSGI_remap_index]) +#define SET_GetColorTableParameterivSGI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetColorTableParameterivSGI_remap_index], fn) +#define CALL_PixelTexGenSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[PixelTexGenSGIX_remap_index], parameters) +#define GET_PixelTexGenSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[PixelTexGenSGIX_remap_index]) +#define SET_PixelTexGenSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PixelTexGenSGIX_remap_index], fn) +#define CALL_PixelTexGenParameteriSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), driDispatchRemapTable[PixelTexGenParameteriSGIS_remap_index], parameters) +#define GET_PixelTexGenParameteriSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[PixelTexGenParameteriSGIS_remap_index]) +#define SET_PixelTexGenParameteriSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PixelTexGenParameteriSGIS_remap_index], fn) +#define CALL_PixelTexGenParameterivSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), driDispatchRemapTable[PixelTexGenParameterivSGIS_remap_index], parameters) +#define GET_PixelTexGenParameterivSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[PixelTexGenParameterivSGIS_remap_index]) +#define SET_PixelTexGenParameterivSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PixelTexGenParameterivSGIS_remap_index], fn) +#define CALL_PixelTexGenParameterfSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), driDispatchRemapTable[PixelTexGenParameterfSGIS_remap_index], parameters) +#define GET_PixelTexGenParameterfSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[PixelTexGenParameterfSGIS_remap_index]) +#define SET_PixelTexGenParameterfSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PixelTexGenParameterfSGIS_remap_index], fn) +#define CALL_PixelTexGenParameterfvSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), driDispatchRemapTable[PixelTexGenParameterfvSGIS_remap_index], parameters) +#define GET_PixelTexGenParameterfvSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[PixelTexGenParameterfvSGIS_remap_index]) +#define SET_PixelTexGenParameterfvSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PixelTexGenParameterfvSGIS_remap_index], fn) +#define CALL_GetPixelTexGenParameterivSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint *)), driDispatchRemapTable[GetPixelTexGenParameterivSGIS_remap_index], parameters) +#define GET_GetPixelTexGenParameterivSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[GetPixelTexGenParameterivSGIS_remap_index]) +#define SET_GetPixelTexGenParameterivSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetPixelTexGenParameterivSGIS_remap_index], fn) +#define CALL_GetPixelTexGenParameterfvSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat *)), driDispatchRemapTable[GetPixelTexGenParameterfvSGIS_remap_index], parameters) +#define GET_GetPixelTexGenParameterfvSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[GetPixelTexGenParameterfvSGIS_remap_index]) +#define SET_GetPixelTexGenParameterfvSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetPixelTexGenParameterfvSGIS_remap_index], fn) +#define CALL_TexImage4DSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *)), driDispatchRemapTable[TexImage4DSGIS_remap_index], parameters) +#define GET_TexImage4DSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[TexImage4DSGIS_remap_index]) +#define SET_TexImage4DSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[TexImage4DSGIS_remap_index], fn) +#define CALL_TexSubImage4DSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *)), driDispatchRemapTable[TexSubImage4DSGIS_remap_index], parameters) +#define GET_TexSubImage4DSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[TexSubImage4DSGIS_remap_index]) +#define SET_TexSubImage4DSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[TexSubImage4DSGIS_remap_index], fn) +#define CALL_AreTexturesResidentEXT(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLsizei, const GLuint *, GLboolean *)), driDispatchRemapTable[AreTexturesResidentEXT_remap_index], parameters) +#define GET_AreTexturesResidentEXT(disp) GET_by_offset(disp, driDispatchRemapTable[AreTexturesResidentEXT_remap_index]) +#define SET_AreTexturesResidentEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[AreTexturesResidentEXT_remap_index], fn) +#define CALL_GenTexturesEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), driDispatchRemapTable[GenTexturesEXT_remap_index], parameters) +#define GET_GenTexturesEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GenTexturesEXT_remap_index]) +#define SET_GenTexturesEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GenTexturesEXT_remap_index], fn) +#define CALL_IsTextureEXT(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[IsTextureEXT_remap_index], parameters) +#define GET_IsTextureEXT(disp) GET_by_offset(disp, driDispatchRemapTable[IsTextureEXT_remap_index]) +#define SET_IsTextureEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IsTextureEXT_remap_index], fn) +#define CALL_DetailTexFuncSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLfloat *)), driDispatchRemapTable[DetailTexFuncSGIS_remap_index], parameters) +#define GET_DetailTexFuncSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[DetailTexFuncSGIS_remap_index]) +#define SET_DetailTexFuncSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DetailTexFuncSGIS_remap_index], fn) +#define CALL_GetDetailTexFuncSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat *)), driDispatchRemapTable[GetDetailTexFuncSGIS_remap_index], parameters) +#define GET_GetDetailTexFuncSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[GetDetailTexFuncSGIS_remap_index]) +#define SET_GetDetailTexFuncSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetDetailTexFuncSGIS_remap_index], fn) +#define CALL_SharpenTexFuncSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLfloat *)), driDispatchRemapTable[SharpenTexFuncSGIS_remap_index], parameters) +#define GET_SharpenTexFuncSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[SharpenTexFuncSGIS_remap_index]) +#define SET_SharpenTexFuncSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SharpenTexFuncSGIS_remap_index], fn) +#define CALL_GetSharpenTexFuncSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat *)), driDispatchRemapTable[GetSharpenTexFuncSGIS_remap_index], parameters) +#define GET_GetSharpenTexFuncSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[GetSharpenTexFuncSGIS_remap_index]) +#define SET_GetSharpenTexFuncSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetSharpenTexFuncSGIS_remap_index], fn) +#define CALL_SampleMaskSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampf, GLboolean)), driDispatchRemapTable[SampleMaskSGIS_remap_index], parameters) +#define GET_SampleMaskSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[SampleMaskSGIS_remap_index]) +#define SET_SampleMaskSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SampleMaskSGIS_remap_index], fn) +#define CALL_SamplePatternSGIS(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[SamplePatternSGIS_remap_index], parameters) +#define GET_SamplePatternSGIS(disp) GET_by_offset(disp, driDispatchRemapTable[SamplePatternSGIS_remap_index]) +#define SET_SamplePatternSGIS(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SamplePatternSGIS_remap_index], fn) +#define CALL_ColorPointerEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *)), driDispatchRemapTable[ColorPointerEXT_remap_index], parameters) +#define GET_ColorPointerEXT(disp) GET_by_offset(disp, driDispatchRemapTable[ColorPointerEXT_remap_index]) +#define SET_ColorPointerEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ColorPointerEXT_remap_index], fn) +#define CALL_EdgeFlagPointerEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLsizei, const GLboolean *)), driDispatchRemapTable[EdgeFlagPointerEXT_remap_index], parameters) +#define GET_EdgeFlagPointerEXT(disp) GET_by_offset(disp, driDispatchRemapTable[EdgeFlagPointerEXT_remap_index]) +#define SET_EdgeFlagPointerEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[EdgeFlagPointerEXT_remap_index], fn) +#define CALL_IndexPointerEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, GLsizei, const GLvoid *)), driDispatchRemapTable[IndexPointerEXT_remap_index], parameters) +#define GET_IndexPointerEXT(disp) GET_by_offset(disp, driDispatchRemapTable[IndexPointerEXT_remap_index]) +#define SET_IndexPointerEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IndexPointerEXT_remap_index], fn) +#define CALL_NormalPointerEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, GLsizei, const GLvoid *)), driDispatchRemapTable[NormalPointerEXT_remap_index], parameters) +#define GET_NormalPointerEXT(disp) GET_by_offset(disp, driDispatchRemapTable[NormalPointerEXT_remap_index]) +#define SET_NormalPointerEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[NormalPointerEXT_remap_index], fn) +#define CALL_TexCoordPointerEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *)), driDispatchRemapTable[TexCoordPointerEXT_remap_index], parameters) +#define GET_TexCoordPointerEXT(disp) GET_by_offset(disp, driDispatchRemapTable[TexCoordPointerEXT_remap_index]) +#define SET_TexCoordPointerEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[TexCoordPointerEXT_remap_index], fn) +#define CALL_VertexPointerEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLenum, GLsizei, GLsizei, const GLvoid *)), driDispatchRemapTable[VertexPointerEXT_remap_index], parameters) +#define GET_VertexPointerEXT(disp) GET_by_offset(disp, driDispatchRemapTable[VertexPointerEXT_remap_index]) +#define SET_VertexPointerEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexPointerEXT_remap_index], fn) +#define CALL_SpriteParameterfSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), driDispatchRemapTable[SpriteParameterfSGIX_remap_index], parameters) +#define GET_SpriteParameterfSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[SpriteParameterfSGIX_remap_index]) +#define SET_SpriteParameterfSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SpriteParameterfSGIX_remap_index], fn) +#define CALL_SpriteParameterfvSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), driDispatchRemapTable[SpriteParameterfvSGIX_remap_index], parameters) +#define GET_SpriteParameterfvSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[SpriteParameterfvSGIX_remap_index]) +#define SET_SpriteParameterfvSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SpriteParameterfvSGIX_remap_index], fn) +#define CALL_SpriteParameteriSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), driDispatchRemapTable[SpriteParameteriSGIX_remap_index], parameters) +#define GET_SpriteParameteriSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[SpriteParameteriSGIX_remap_index]) +#define SET_SpriteParameteriSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SpriteParameteriSGIX_remap_index], fn) +#define CALL_SpriteParameterivSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), driDispatchRemapTable[SpriteParameterivSGIX_remap_index], parameters) +#define GET_SpriteParameterivSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[SpriteParameterivSGIX_remap_index]) +#define SET_SpriteParameterivSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SpriteParameterivSGIX_remap_index], fn) +#define CALL_PointParameterfEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), driDispatchRemapTable[PointParameterfEXT_remap_index], parameters) +#define GET_PointParameterfEXT(disp) GET_by_offset(disp, driDispatchRemapTable[PointParameterfEXT_remap_index]) +#define SET_PointParameterfEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PointParameterfEXT_remap_index], fn) +#define CALL_PointParameterfvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), driDispatchRemapTable[PointParameterfvEXT_remap_index], parameters) +#define GET_PointParameterfvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[PointParameterfvEXT_remap_index]) +#define SET_PointParameterfvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PointParameterfvEXT_remap_index], fn) +#define CALL_GetInstrumentsSGIX(disp, parameters) CALL_by_offset(disp, (GLint (GLAPIENTRYP)(void)), driDispatchRemapTable[GetInstrumentsSGIX_remap_index], parameters) +#define GET_GetInstrumentsSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[GetInstrumentsSGIX_remap_index]) +#define SET_GetInstrumentsSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetInstrumentsSGIX_remap_index], fn) +#define CALL_InstrumentsBufferSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLint *)), driDispatchRemapTable[InstrumentsBufferSGIX_remap_index], parameters) +#define GET_InstrumentsBufferSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[InstrumentsBufferSGIX_remap_index]) +#define SET_InstrumentsBufferSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[InstrumentsBufferSGIX_remap_index], fn) +#define CALL_PollInstrumentsSGIX(disp, parameters) CALL_by_offset(disp, (GLint (GLAPIENTRYP)(GLint *)), driDispatchRemapTable[PollInstrumentsSGIX_remap_index], parameters) +#define GET_PollInstrumentsSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[PollInstrumentsSGIX_remap_index]) +#define SET_PollInstrumentsSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PollInstrumentsSGIX_remap_index], fn) +#define CALL_ReadInstrumentsSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint)), driDispatchRemapTable[ReadInstrumentsSGIX_remap_index], parameters) +#define GET_ReadInstrumentsSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[ReadInstrumentsSGIX_remap_index]) +#define SET_ReadInstrumentsSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ReadInstrumentsSGIX_remap_index], fn) +#define CALL_StartInstrumentsSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), driDispatchRemapTable[StartInstrumentsSGIX_remap_index], parameters) +#define GET_StartInstrumentsSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[StartInstrumentsSGIX_remap_index]) +#define SET_StartInstrumentsSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[StartInstrumentsSGIX_remap_index], fn) +#define CALL_StopInstrumentsSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint)), driDispatchRemapTable[StopInstrumentsSGIX_remap_index], parameters) +#define GET_StopInstrumentsSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[StopInstrumentsSGIX_remap_index]) +#define SET_StopInstrumentsSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[StopInstrumentsSGIX_remap_index], fn) +#define CALL_FrameZoomSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint)), driDispatchRemapTable[FrameZoomSGIX_remap_index], parameters) +#define GET_FrameZoomSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FrameZoomSGIX_remap_index]) +#define SET_FrameZoomSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FrameZoomSGIX_remap_index], fn) +#define CALL_TagSampleBufferSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), driDispatchRemapTable[TagSampleBufferSGIX_remap_index], parameters) +#define GET_TagSampleBufferSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[TagSampleBufferSGIX_remap_index]) +#define SET_TagSampleBufferSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[TagSampleBufferSGIX_remap_index], fn) +#define CALL_ReferencePlaneSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), driDispatchRemapTable[ReferencePlaneSGIX_remap_index], parameters) +#define GET_ReferencePlaneSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[ReferencePlaneSGIX_remap_index]) +#define SET_ReferencePlaneSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ReferencePlaneSGIX_remap_index], fn) +#define CALL_FlushRasterSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), driDispatchRemapTable[FlushRasterSGIX_remap_index], parameters) +#define GET_FlushRasterSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FlushRasterSGIX_remap_index]) +#define SET_FlushRasterSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FlushRasterSGIX_remap_index], fn) +#define CALL_GetListParameterfvSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLfloat *)), driDispatchRemapTable[GetListParameterfvSGIX_remap_index], parameters) +#define GET_GetListParameterfvSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[GetListParameterfvSGIX_remap_index]) +#define SET_GetListParameterfvSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetListParameterfvSGIX_remap_index], fn) +#define CALL_GetListParameterivSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLint *)), driDispatchRemapTable[GetListParameterivSGIX_remap_index], parameters) +#define GET_GetListParameterivSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[GetListParameterivSGIX_remap_index]) +#define SET_GetListParameterivSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetListParameterivSGIX_remap_index], fn) +#define CALL_ListParameterfSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLfloat)), driDispatchRemapTable[ListParameterfSGIX_remap_index], parameters) +#define GET_ListParameterfSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[ListParameterfSGIX_remap_index]) +#define SET_ListParameterfSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ListParameterfSGIX_remap_index], fn) +#define CALL_ListParameterfvSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, const GLfloat *)), driDispatchRemapTable[ListParameterfvSGIX_remap_index], parameters) +#define GET_ListParameterfvSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[ListParameterfvSGIX_remap_index]) +#define SET_ListParameterfvSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ListParameterfvSGIX_remap_index], fn) +#define CALL_ListParameteriSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLint)), driDispatchRemapTable[ListParameteriSGIX_remap_index], parameters) +#define GET_ListParameteriSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[ListParameteriSGIX_remap_index]) +#define SET_ListParameteriSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ListParameteriSGIX_remap_index], fn) +#define CALL_ListParameterivSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, const GLint *)), driDispatchRemapTable[ListParameterivSGIX_remap_index], parameters) +#define GET_ListParameterivSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[ListParameterivSGIX_remap_index]) +#define SET_ListParameterivSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ListParameterivSGIX_remap_index], fn) +#define CALL_FragmentColorMaterialSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum)), driDispatchRemapTable[FragmentColorMaterialSGIX_remap_index], parameters) +#define GET_FragmentColorMaterialSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentColorMaterialSGIX_remap_index]) +#define SET_FragmentColorMaterialSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentColorMaterialSGIX_remap_index], fn) +#define CALL_FragmentLightfSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat)), driDispatchRemapTable[FragmentLightfSGIX_remap_index], parameters) +#define GET_FragmentLightfSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentLightfSGIX_remap_index]) +#define SET_FragmentLightfSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentLightfSGIX_remap_index], fn) +#define CALL_FragmentLightfvSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfloat *)), driDispatchRemapTable[FragmentLightfvSGIX_remap_index], parameters) +#define GET_FragmentLightfvSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentLightfvSGIX_remap_index]) +#define SET_FragmentLightfvSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentLightfvSGIX_remap_index], fn) +#define CALL_FragmentLightiSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint)), driDispatchRemapTable[FragmentLightiSGIX_remap_index], parameters) +#define GET_FragmentLightiSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentLightiSGIX_remap_index]) +#define SET_FragmentLightiSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentLightiSGIX_remap_index], fn) +#define CALL_FragmentLightivSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLint *)), driDispatchRemapTable[FragmentLightivSGIX_remap_index], parameters) +#define GET_FragmentLightivSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentLightivSGIX_remap_index]) +#define SET_FragmentLightivSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentLightivSGIX_remap_index], fn) +#define CALL_FragmentLightModelfSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), driDispatchRemapTable[FragmentLightModelfSGIX_remap_index], parameters) +#define GET_FragmentLightModelfSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentLightModelfSGIX_remap_index]) +#define SET_FragmentLightModelfSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentLightModelfSGIX_remap_index], fn) +#define CALL_FragmentLightModelfvSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), driDispatchRemapTable[FragmentLightModelfvSGIX_remap_index], parameters) +#define GET_FragmentLightModelfvSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentLightModelfvSGIX_remap_index]) +#define SET_FragmentLightModelfvSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentLightModelfvSGIX_remap_index], fn) +#define CALL_FragmentLightModeliSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), driDispatchRemapTable[FragmentLightModeliSGIX_remap_index], parameters) +#define GET_FragmentLightModeliSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentLightModeliSGIX_remap_index]) +#define SET_FragmentLightModeliSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentLightModeliSGIX_remap_index], fn) +#define CALL_FragmentLightModelivSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), driDispatchRemapTable[FragmentLightModelivSGIX_remap_index], parameters) +#define GET_FragmentLightModelivSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentLightModelivSGIX_remap_index]) +#define SET_FragmentLightModelivSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentLightModelivSGIX_remap_index], fn) +#define CALL_FragmentMaterialfSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat)), driDispatchRemapTable[FragmentMaterialfSGIX_remap_index], parameters) +#define GET_FragmentMaterialfSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentMaterialfSGIX_remap_index]) +#define SET_FragmentMaterialfSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentMaterialfSGIX_remap_index], fn) +#define CALL_FragmentMaterialfvSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLfloat *)), driDispatchRemapTable[FragmentMaterialfvSGIX_remap_index], parameters) +#define GET_FragmentMaterialfvSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentMaterialfvSGIX_remap_index]) +#define SET_FragmentMaterialfvSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentMaterialfvSGIX_remap_index], fn) +#define CALL_FragmentMaterialiSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint)), driDispatchRemapTable[FragmentMaterialiSGIX_remap_index], parameters) +#define GET_FragmentMaterialiSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentMaterialiSGIX_remap_index]) +#define SET_FragmentMaterialiSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentMaterialiSGIX_remap_index], fn) +#define CALL_FragmentMaterialivSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, const GLint *)), driDispatchRemapTable[FragmentMaterialivSGIX_remap_index], parameters) +#define GET_FragmentMaterialivSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[FragmentMaterialivSGIX_remap_index]) +#define SET_FragmentMaterialivSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FragmentMaterialivSGIX_remap_index], fn) +#define CALL_GetFragmentLightfvSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetFragmentLightfvSGIX_remap_index], parameters) +#define GET_GetFragmentLightfvSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[GetFragmentLightfvSGIX_remap_index]) +#define SET_GetFragmentLightfvSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetFragmentLightfvSGIX_remap_index], fn) +#define CALL_GetFragmentLightivSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetFragmentLightivSGIX_remap_index], parameters) +#define GET_GetFragmentLightivSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[GetFragmentLightivSGIX_remap_index]) +#define SET_GetFragmentLightivSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetFragmentLightivSGIX_remap_index], fn) +#define CALL_GetFragmentMaterialfvSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetFragmentMaterialfvSGIX_remap_index], parameters) +#define GET_GetFragmentMaterialfvSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[GetFragmentMaterialfvSGIX_remap_index]) +#define SET_GetFragmentMaterialfvSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetFragmentMaterialfvSGIX_remap_index], fn) +#define CALL_GetFragmentMaterialivSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetFragmentMaterialivSGIX_remap_index], parameters) +#define GET_GetFragmentMaterialivSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[GetFragmentMaterialivSGIX_remap_index]) +#define SET_GetFragmentMaterialivSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetFragmentMaterialivSGIX_remap_index], fn) +#define CALL_LightEnviSGIX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), driDispatchRemapTable[LightEnviSGIX_remap_index], parameters) +#define GET_LightEnviSGIX(disp) GET_by_offset(disp, driDispatchRemapTable[LightEnviSGIX_remap_index]) +#define SET_LightEnviSGIX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[LightEnviSGIX_remap_index], fn) +#define CALL_VertexWeightfEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat)), driDispatchRemapTable[VertexWeightfEXT_remap_index], parameters) +#define GET_VertexWeightfEXT(disp) GET_by_offset(disp, driDispatchRemapTable[VertexWeightfEXT_remap_index]) +#define SET_VertexWeightfEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexWeightfEXT_remap_index], fn) +#define CALL_VertexWeightfvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), driDispatchRemapTable[VertexWeightfvEXT_remap_index], parameters) +#define GET_VertexWeightfvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[VertexWeightfvEXT_remap_index]) +#define SET_VertexWeightfvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexWeightfvEXT_remap_index], fn) +#define CALL_VertexWeightPointerEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLenum, GLsizei, const GLvoid *)), driDispatchRemapTable[VertexWeightPointerEXT_remap_index], parameters) +#define GET_VertexWeightPointerEXT(disp) GET_by_offset(disp, driDispatchRemapTable[VertexWeightPointerEXT_remap_index]) +#define SET_VertexWeightPointerEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexWeightPointerEXT_remap_index], fn) +#define CALL_FlushVertexArrayRangeNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), driDispatchRemapTable[FlushVertexArrayRangeNV_remap_index], parameters) +#define GET_FlushVertexArrayRangeNV(disp) GET_by_offset(disp, driDispatchRemapTable[FlushVertexArrayRangeNV_remap_index]) +#define SET_FlushVertexArrayRangeNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FlushVertexArrayRangeNV_remap_index], fn) +#define CALL_VertexArrayRangeNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLvoid *)), driDispatchRemapTable[VertexArrayRangeNV_remap_index], parameters) +#define GET_VertexArrayRangeNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexArrayRangeNV_remap_index]) +#define SET_VertexArrayRangeNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexArrayRangeNV_remap_index], fn) +#define CALL_CombinerParameterfvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLfloat *)), driDispatchRemapTable[CombinerParameterfvNV_remap_index], parameters) +#define GET_CombinerParameterfvNV(disp) GET_by_offset(disp, driDispatchRemapTable[CombinerParameterfvNV_remap_index]) +#define SET_CombinerParameterfvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CombinerParameterfvNV_remap_index], fn) +#define CALL_CombinerParameterfNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat)), driDispatchRemapTable[CombinerParameterfNV_remap_index], parameters) +#define GET_CombinerParameterfNV(disp) GET_by_offset(disp, driDispatchRemapTable[CombinerParameterfNV_remap_index]) +#define SET_CombinerParameterfNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CombinerParameterfNV_remap_index], fn) +#define CALL_CombinerParameterivNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), driDispatchRemapTable[CombinerParameterivNV_remap_index], parameters) +#define GET_CombinerParameterivNV(disp) GET_by_offset(disp, driDispatchRemapTable[CombinerParameterivNV_remap_index]) +#define SET_CombinerParameterivNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CombinerParameterivNV_remap_index], fn) +#define CALL_CombinerParameteriNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), driDispatchRemapTable[CombinerParameteriNV_remap_index], parameters) +#define GET_CombinerParameteriNV(disp) GET_by_offset(disp, driDispatchRemapTable[CombinerParameteriNV_remap_index]) +#define SET_CombinerParameteriNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CombinerParameteriNV_remap_index], fn) +#define CALL_CombinerInputNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLenum, GLenum, GLenum)), driDispatchRemapTable[CombinerInputNV_remap_index], parameters) +#define GET_CombinerInputNV(disp) GET_by_offset(disp, driDispatchRemapTable[CombinerInputNV_remap_index]) +#define SET_CombinerInputNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CombinerInputNV_remap_index], fn) +#define CALL_CombinerOutputNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean)), driDispatchRemapTable[CombinerOutputNV_remap_index], parameters) +#define GET_CombinerOutputNV(disp) GET_by_offset(disp, driDispatchRemapTable[CombinerOutputNV_remap_index]) +#define SET_CombinerOutputNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CombinerOutputNV_remap_index], fn) +#define CALL_FinalCombinerInputNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLenum)), driDispatchRemapTable[FinalCombinerInputNV_remap_index], parameters) +#define GET_FinalCombinerInputNV(disp) GET_by_offset(disp, driDispatchRemapTable[FinalCombinerInputNV_remap_index]) +#define SET_FinalCombinerInputNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FinalCombinerInputNV_remap_index], fn) +#define CALL_GetCombinerInputParameterfvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetCombinerInputParameterfvNV_remap_index], parameters) +#define GET_GetCombinerInputParameterfvNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetCombinerInputParameterfvNV_remap_index]) +#define SET_GetCombinerInputParameterfvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetCombinerInputParameterfvNV_remap_index], fn) +#define CALL_GetCombinerInputParameterivNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLenum, GLint *)), driDispatchRemapTable[GetCombinerInputParameterivNV_remap_index], parameters) +#define GET_GetCombinerInputParameterivNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetCombinerInputParameterivNV_remap_index]) +#define SET_GetCombinerInputParameterivNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetCombinerInputParameterivNV_remap_index], fn) +#define CALL_GetCombinerOutputParameterfvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetCombinerOutputParameterfvNV_remap_index], parameters) +#define GET_GetCombinerOutputParameterfvNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetCombinerOutputParameterfvNV_remap_index]) +#define SET_GetCombinerOutputParameterfvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetCombinerOutputParameterfvNV_remap_index], fn) +#define CALL_GetCombinerOutputParameterivNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLint *)), driDispatchRemapTable[GetCombinerOutputParameterivNV_remap_index], parameters) +#define GET_GetCombinerOutputParameterivNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetCombinerOutputParameterivNV_remap_index]) +#define SET_GetCombinerOutputParameterivNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetCombinerOutputParameterivNV_remap_index], fn) +#define CALL_GetFinalCombinerInputParameterfvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetFinalCombinerInputParameterfvNV_remap_index], parameters) +#define GET_GetFinalCombinerInputParameterfvNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetFinalCombinerInputParameterfvNV_remap_index]) +#define SET_GetFinalCombinerInputParameterfvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetFinalCombinerInputParameterfvNV_remap_index], fn) +#define CALL_GetFinalCombinerInputParameterivNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetFinalCombinerInputParameterivNV_remap_index], parameters) +#define GET_GetFinalCombinerInputParameterivNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetFinalCombinerInputParameterivNV_remap_index]) +#define SET_GetFinalCombinerInputParameterivNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetFinalCombinerInputParameterivNV_remap_index], fn) +#define CALL_ResizeBuffersMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), driDispatchRemapTable[ResizeBuffersMESA_remap_index], parameters) +#define GET_ResizeBuffersMESA(disp) GET_by_offset(disp, driDispatchRemapTable[ResizeBuffersMESA_remap_index]) +#define SET_ResizeBuffersMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ResizeBuffersMESA_remap_index], fn) +#define CALL_WindowPos2dMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble)), driDispatchRemapTable[WindowPos2dMESA_remap_index], parameters) +#define GET_WindowPos2dMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos2dMESA_remap_index]) +#define SET_WindowPos2dMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos2dMESA_remap_index], fn) +#define CALL_WindowPos2dvMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), driDispatchRemapTable[WindowPos2dvMESA_remap_index], parameters) +#define GET_WindowPos2dvMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos2dvMESA_remap_index]) +#define SET_WindowPos2dvMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos2dvMESA_remap_index], fn) +#define CALL_WindowPos2fMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat)), driDispatchRemapTable[WindowPos2fMESA_remap_index], parameters) +#define GET_WindowPos2fMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos2fMESA_remap_index]) +#define SET_WindowPos2fMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos2fMESA_remap_index], fn) +#define CALL_WindowPos2fvMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), driDispatchRemapTable[WindowPos2fvMESA_remap_index], parameters) +#define GET_WindowPos2fvMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos2fvMESA_remap_index]) +#define SET_WindowPos2fvMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos2fvMESA_remap_index], fn) +#define CALL_WindowPos2iMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint)), driDispatchRemapTable[WindowPos2iMESA_remap_index], parameters) +#define GET_WindowPos2iMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos2iMESA_remap_index]) +#define SET_WindowPos2iMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos2iMESA_remap_index], fn) +#define CALL_WindowPos2ivMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), driDispatchRemapTable[WindowPos2ivMESA_remap_index], parameters) +#define GET_WindowPos2ivMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos2ivMESA_remap_index]) +#define SET_WindowPos2ivMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos2ivMESA_remap_index], fn) +#define CALL_WindowPos2sMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort)), driDispatchRemapTable[WindowPos2sMESA_remap_index], parameters) +#define GET_WindowPos2sMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos2sMESA_remap_index]) +#define SET_WindowPos2sMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos2sMESA_remap_index], fn) +#define CALL_WindowPos2svMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), driDispatchRemapTable[WindowPos2svMESA_remap_index], parameters) +#define GET_WindowPos2svMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos2svMESA_remap_index]) +#define SET_WindowPos2svMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos2svMESA_remap_index], fn) +#define CALL_WindowPos3dMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[WindowPos3dMESA_remap_index], parameters) +#define GET_WindowPos3dMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos3dMESA_remap_index]) +#define SET_WindowPos3dMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos3dMESA_remap_index], fn) +#define CALL_WindowPos3dvMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), driDispatchRemapTable[WindowPos3dvMESA_remap_index], parameters) +#define GET_WindowPos3dvMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos3dvMESA_remap_index]) +#define SET_WindowPos3dvMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos3dvMESA_remap_index], fn) +#define CALL_WindowPos3fMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[WindowPos3fMESA_remap_index], parameters) +#define GET_WindowPos3fMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos3fMESA_remap_index]) +#define SET_WindowPos3fMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos3fMESA_remap_index], fn) +#define CALL_WindowPos3fvMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), driDispatchRemapTable[WindowPos3fvMESA_remap_index], parameters) +#define GET_WindowPos3fvMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos3fvMESA_remap_index]) +#define SET_WindowPos3fvMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos3fvMESA_remap_index], fn) +#define CALL_WindowPos3iMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint)), driDispatchRemapTable[WindowPos3iMESA_remap_index], parameters) +#define GET_WindowPos3iMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos3iMESA_remap_index]) +#define SET_WindowPos3iMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos3iMESA_remap_index], fn) +#define CALL_WindowPos3ivMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), driDispatchRemapTable[WindowPos3ivMESA_remap_index], parameters) +#define GET_WindowPos3ivMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos3ivMESA_remap_index]) +#define SET_WindowPos3ivMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos3ivMESA_remap_index], fn) +#define CALL_WindowPos3sMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort)), driDispatchRemapTable[WindowPos3sMESA_remap_index], parameters) +#define GET_WindowPos3sMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos3sMESA_remap_index]) +#define SET_WindowPos3sMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos3sMESA_remap_index], fn) +#define CALL_WindowPos3svMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), driDispatchRemapTable[WindowPos3svMESA_remap_index], parameters) +#define GET_WindowPos3svMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos3svMESA_remap_index]) +#define SET_WindowPos3svMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos3svMESA_remap_index], fn) +#define CALL_WindowPos4dMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[WindowPos4dMESA_remap_index], parameters) +#define GET_WindowPos4dMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos4dMESA_remap_index]) +#define SET_WindowPos4dMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos4dMESA_remap_index], fn) +#define CALL_WindowPos4dvMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), driDispatchRemapTable[WindowPos4dvMESA_remap_index], parameters) +#define GET_WindowPos4dvMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos4dvMESA_remap_index]) +#define SET_WindowPos4dvMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos4dvMESA_remap_index], fn) +#define CALL_WindowPos4fMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[WindowPos4fMESA_remap_index], parameters) +#define GET_WindowPos4fMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos4fMESA_remap_index]) +#define SET_WindowPos4fMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos4fMESA_remap_index], fn) +#define CALL_WindowPos4fvMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), driDispatchRemapTable[WindowPos4fvMESA_remap_index], parameters) +#define GET_WindowPos4fvMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos4fvMESA_remap_index]) +#define SET_WindowPos4fvMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos4fvMESA_remap_index], fn) +#define CALL_WindowPos4iMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint)), driDispatchRemapTable[WindowPos4iMESA_remap_index], parameters) +#define GET_WindowPos4iMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos4iMESA_remap_index]) +#define SET_WindowPos4iMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos4iMESA_remap_index], fn) +#define CALL_WindowPos4ivMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), driDispatchRemapTable[WindowPos4ivMESA_remap_index], parameters) +#define GET_WindowPos4ivMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos4ivMESA_remap_index]) +#define SET_WindowPos4ivMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos4ivMESA_remap_index], fn) +#define CALL_WindowPos4sMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort, GLshort)), driDispatchRemapTable[WindowPos4sMESA_remap_index], parameters) +#define GET_WindowPos4sMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos4sMESA_remap_index]) +#define SET_WindowPos4sMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos4sMESA_remap_index], fn) +#define CALL_WindowPos4svMESA(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), driDispatchRemapTable[WindowPos4svMESA_remap_index], parameters) +#define GET_WindowPos4svMESA(disp) GET_by_offset(disp, driDispatchRemapTable[WindowPos4svMESA_remap_index]) +#define SET_WindowPos4svMESA(disp, fn) SET_by_offset(disp, driDispatchRemapTable[WindowPos4svMESA_remap_index], fn) +#define CALL_BlendFuncSeparateEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLenum)), driDispatchRemapTable[BlendFuncSeparateEXT_remap_index], parameters) +#define GET_BlendFuncSeparateEXT(disp) GET_by_offset(disp, driDispatchRemapTable[BlendFuncSeparateEXT_remap_index]) +#define SET_BlendFuncSeparateEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BlendFuncSeparateEXT_remap_index], fn) +#define CALL_IndexMaterialEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum)), driDispatchRemapTable[IndexMaterialEXT_remap_index], parameters) +#define GET_IndexMaterialEXT(disp) GET_by_offset(disp, driDispatchRemapTable[IndexMaterialEXT_remap_index]) +#define SET_IndexMaterialEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IndexMaterialEXT_remap_index], fn) +#define CALL_IndexFuncEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLclampf)), driDispatchRemapTable[IndexFuncEXT_remap_index], parameters) +#define GET_IndexFuncEXT(disp) GET_by_offset(disp, driDispatchRemapTable[IndexFuncEXT_remap_index]) +#define SET_IndexFuncEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IndexFuncEXT_remap_index], fn) +#define CALL_LockArraysEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei)), driDispatchRemapTable[LockArraysEXT_remap_index], parameters) +#define GET_LockArraysEXT(disp) GET_by_offset(disp, driDispatchRemapTable[LockArraysEXT_remap_index]) +#define SET_LockArraysEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[LockArraysEXT_remap_index], fn) +#define CALL_UnlockArraysEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), driDispatchRemapTable[UnlockArraysEXT_remap_index], parameters) +#define GET_UnlockArraysEXT(disp) GET_by_offset(disp, driDispatchRemapTable[UnlockArraysEXT_remap_index]) +#define SET_UnlockArraysEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[UnlockArraysEXT_remap_index], fn) +#define CALL_CullParameterdvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLdouble *)), driDispatchRemapTable[CullParameterdvEXT_remap_index], parameters) +#define GET_CullParameterdvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[CullParameterdvEXT_remap_index]) +#define SET_CullParameterdvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CullParameterdvEXT_remap_index], fn) +#define CALL_CullParameterfvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLfloat *)), driDispatchRemapTable[CullParameterfvEXT_remap_index], parameters) +#define GET_CullParameterfvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[CullParameterfvEXT_remap_index]) +#define SET_CullParameterfvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CullParameterfvEXT_remap_index], fn) +#define CALL_HintPGI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), driDispatchRemapTable[HintPGI_remap_index], parameters) +#define GET_HintPGI(disp) GET_by_offset(disp, driDispatchRemapTable[HintPGI_remap_index]) +#define SET_HintPGI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[HintPGI_remap_index], fn) +#define CALL_FogCoordfEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat)), driDispatchRemapTable[FogCoordfEXT_remap_index], parameters) +#define GET_FogCoordfEXT(disp) GET_by_offset(disp, driDispatchRemapTable[FogCoordfEXT_remap_index]) +#define SET_FogCoordfEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FogCoordfEXT_remap_index], fn) +#define CALL_FogCoordfvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), driDispatchRemapTable[FogCoordfvEXT_remap_index], parameters) +#define GET_FogCoordfvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[FogCoordfvEXT_remap_index]) +#define SET_FogCoordfvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FogCoordfvEXT_remap_index], fn) +#define CALL_FogCoorddEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble)), driDispatchRemapTable[FogCoorddEXT_remap_index], parameters) +#define GET_FogCoorddEXT(disp) GET_by_offset(disp, driDispatchRemapTable[FogCoorddEXT_remap_index]) +#define SET_FogCoorddEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FogCoorddEXT_remap_index], fn) +#define CALL_FogCoorddvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), driDispatchRemapTable[FogCoorddvEXT_remap_index], parameters) +#define GET_FogCoorddvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[FogCoorddvEXT_remap_index]) +#define SET_FogCoorddvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FogCoorddvEXT_remap_index], fn) +#define CALL_FogCoordPointerEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizei, const GLvoid *)), driDispatchRemapTable[FogCoordPointerEXT_remap_index], parameters) +#define GET_FogCoordPointerEXT(disp) GET_by_offset(disp, driDispatchRemapTable[FogCoordPointerEXT_remap_index]) +#define SET_FogCoordPointerEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FogCoordPointerEXT_remap_index], fn) +#define CALL_GetColorTableEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLvoid *)), driDispatchRemapTable[GetColorTableEXT_remap_index], parameters) +#define GET_GetColorTableEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetColorTableEXT_remap_index]) +#define SET_GetColorTableEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetColorTableEXT_remap_index], fn) +#define CALL_GetColorTableParameterivEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetColorTableParameterivEXT_remap_index], parameters) +#define GET_GetColorTableParameterivEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetColorTableParameterivEXT_remap_index]) +#define SET_GetColorTableParameterivEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetColorTableParameterivEXT_remap_index], fn) +#define CALL_GetColorTableParameterfvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLfloat *)), driDispatchRemapTable[GetColorTableParameterfvEXT_remap_index], parameters) +#define GET_GetColorTableParameterfvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetColorTableParameterfvEXT_remap_index]) +#define SET_GetColorTableParameterfvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetColorTableParameterfvEXT_remap_index], fn) +#define CALL_TbufferMask3DFX(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[TbufferMask3DFX_remap_index], parameters) +#define GET_TbufferMask3DFX(disp) GET_by_offset(disp, driDispatchRemapTable[TbufferMask3DFX_remap_index]) +#define SET_TbufferMask3DFX(disp, fn) SET_by_offset(disp, driDispatchRemapTable[TbufferMask3DFX_remap_index], fn) +#define CALL_CompressedTexImage3DARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *)), driDispatchRemapTable[CompressedTexImage3DARB_remap_index], parameters) +#define GET_CompressedTexImage3DARB(disp) GET_by_offset(disp, driDispatchRemapTable[CompressedTexImage3DARB_remap_index]) +#define SET_CompressedTexImage3DARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CompressedTexImage3DARB_remap_index], fn) +#define CALL_CompressedTexImage2DARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *)), driDispatchRemapTable[CompressedTexImage2DARB_remap_index], parameters) +#define GET_CompressedTexImage2DARB(disp) GET_by_offset(disp, driDispatchRemapTable[CompressedTexImage2DARB_remap_index]) +#define SET_CompressedTexImage2DARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CompressedTexImage2DARB_remap_index], fn) +#define CALL_CompressedTexImage1DARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const GLvoid *)), driDispatchRemapTable[CompressedTexImage1DARB_remap_index], parameters) +#define GET_CompressedTexImage1DARB(disp) GET_by_offset(disp, driDispatchRemapTable[CompressedTexImage1DARB_remap_index]) +#define SET_CompressedTexImage1DARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CompressedTexImage1DARB_remap_index], fn) +#define CALL_CompressedTexSubImage3DARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *)), driDispatchRemapTable[CompressedTexSubImage3DARB_remap_index], parameters) +#define GET_CompressedTexSubImage3DARB(disp) GET_by_offset(disp, driDispatchRemapTable[CompressedTexSubImage3DARB_remap_index]) +#define SET_CompressedTexSubImage3DARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CompressedTexSubImage3DARB_remap_index], fn) +#define CALL_CompressedTexSubImage2DARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *)), driDispatchRemapTable[CompressedTexSubImage2DARB_remap_index], parameters) +#define GET_CompressedTexSubImage2DARB(disp) GET_by_offset(disp, driDispatchRemapTable[CompressedTexSubImage2DARB_remap_index]) +#define SET_CompressedTexSubImage2DARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CompressedTexSubImage2DARB_remap_index], fn) +#define CALL_CompressedTexSubImage1DARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const GLvoid *)), driDispatchRemapTable[CompressedTexSubImage1DARB_remap_index], parameters) +#define GET_CompressedTexSubImage1DARB(disp) GET_by_offset(disp, driDispatchRemapTable[CompressedTexSubImage1DARB_remap_index]) +#define SET_CompressedTexSubImage1DARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CompressedTexSubImage1DARB_remap_index], fn) +#define CALL_GetCompressedTexImageARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint, GLvoid *)), driDispatchRemapTable[GetCompressedTexImageARB_remap_index], parameters) +#define GET_GetCompressedTexImageARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetCompressedTexImageARB_remap_index]) +#define SET_GetCompressedTexImageARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetCompressedTexImageARB_remap_index], fn) +#define CALL_SecondaryColor3bEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLbyte, GLbyte, GLbyte)), driDispatchRemapTable[SecondaryColor3bEXT_remap_index], parameters) +#define GET_SecondaryColor3bEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3bEXT_remap_index]) +#define SET_SecondaryColor3bEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3bEXT_remap_index], fn) +#define CALL_SecondaryColor3bvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLbyte *)), driDispatchRemapTable[SecondaryColor3bvEXT_remap_index], parameters) +#define GET_SecondaryColor3bvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3bvEXT_remap_index]) +#define SET_SecondaryColor3bvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3bvEXT_remap_index], fn) +#define CALL_SecondaryColor3dEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[SecondaryColor3dEXT_remap_index], parameters) +#define GET_SecondaryColor3dEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3dEXT_remap_index]) +#define SET_SecondaryColor3dEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3dEXT_remap_index], fn) +#define CALL_SecondaryColor3dvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLdouble *)), driDispatchRemapTable[SecondaryColor3dvEXT_remap_index], parameters) +#define GET_SecondaryColor3dvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3dvEXT_remap_index]) +#define SET_SecondaryColor3dvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3dvEXT_remap_index], fn) +#define CALL_SecondaryColor3fEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[SecondaryColor3fEXT_remap_index], parameters) +#define GET_SecondaryColor3fEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3fEXT_remap_index]) +#define SET_SecondaryColor3fEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3fEXT_remap_index], fn) +#define CALL_SecondaryColor3fvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLfloat *)), driDispatchRemapTable[SecondaryColor3fvEXT_remap_index], parameters) +#define GET_SecondaryColor3fvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3fvEXT_remap_index]) +#define SET_SecondaryColor3fvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3fvEXT_remap_index], fn) +#define CALL_SecondaryColor3iEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint)), driDispatchRemapTable[SecondaryColor3iEXT_remap_index], parameters) +#define GET_SecondaryColor3iEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3iEXT_remap_index]) +#define SET_SecondaryColor3iEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3iEXT_remap_index], fn) +#define CALL_SecondaryColor3ivEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLint *)), driDispatchRemapTable[SecondaryColor3ivEXT_remap_index], parameters) +#define GET_SecondaryColor3ivEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3ivEXT_remap_index]) +#define SET_SecondaryColor3ivEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3ivEXT_remap_index], fn) +#define CALL_SecondaryColor3sEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLshort, GLshort, GLshort)), driDispatchRemapTable[SecondaryColor3sEXT_remap_index], parameters) +#define GET_SecondaryColor3sEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3sEXT_remap_index]) +#define SET_SecondaryColor3sEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3sEXT_remap_index], fn) +#define CALL_SecondaryColor3svEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLshort *)), driDispatchRemapTable[SecondaryColor3svEXT_remap_index], parameters) +#define GET_SecondaryColor3svEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3svEXT_remap_index]) +#define SET_SecondaryColor3svEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3svEXT_remap_index], fn) +#define CALL_SecondaryColor3ubEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLubyte, GLubyte, GLubyte)), driDispatchRemapTable[SecondaryColor3ubEXT_remap_index], parameters) +#define GET_SecondaryColor3ubEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3ubEXT_remap_index]) +#define SET_SecondaryColor3ubEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3ubEXT_remap_index], fn) +#define CALL_SecondaryColor3ubvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLubyte *)), driDispatchRemapTable[SecondaryColor3ubvEXT_remap_index], parameters) +#define GET_SecondaryColor3ubvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3ubvEXT_remap_index]) +#define SET_SecondaryColor3ubvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3ubvEXT_remap_index], fn) +#define CALL_SecondaryColor3uiEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint, GLuint)), driDispatchRemapTable[SecondaryColor3uiEXT_remap_index], parameters) +#define GET_SecondaryColor3uiEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3uiEXT_remap_index]) +#define SET_SecondaryColor3uiEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3uiEXT_remap_index], fn) +#define CALL_SecondaryColor3uivEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLuint *)), driDispatchRemapTable[SecondaryColor3uivEXT_remap_index], parameters) +#define GET_SecondaryColor3uivEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3uivEXT_remap_index]) +#define SET_SecondaryColor3uivEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3uivEXT_remap_index], fn) +#define CALL_SecondaryColor3usEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLushort, GLushort, GLushort)), driDispatchRemapTable[SecondaryColor3usEXT_remap_index], parameters) +#define GET_SecondaryColor3usEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3usEXT_remap_index]) +#define SET_SecondaryColor3usEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3usEXT_remap_index], fn) +#define CALL_SecondaryColor3usvEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLushort *)), driDispatchRemapTable[SecondaryColor3usvEXT_remap_index], parameters) +#define GET_SecondaryColor3usvEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColor3usvEXT_remap_index]) +#define SET_SecondaryColor3usvEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColor3usvEXT_remap_index], fn) +#define CALL_SecondaryColorPointerEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLenum, GLsizei, const GLvoid *)), driDispatchRemapTable[SecondaryColorPointerEXT_remap_index], parameters) +#define GET_SecondaryColorPointerEXT(disp) GET_by_offset(disp, driDispatchRemapTable[SecondaryColorPointerEXT_remap_index]) +#define SET_SecondaryColorPointerEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SecondaryColorPointerEXT_remap_index], fn) +#define CALL_AreProgramsResidentNV(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLsizei, const GLuint *, GLboolean *)), driDispatchRemapTable[AreProgramsResidentNV_remap_index], parameters) +#define GET_AreProgramsResidentNV(disp) GET_by_offset(disp, driDispatchRemapTable[AreProgramsResidentNV_remap_index]) +#define SET_AreProgramsResidentNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[AreProgramsResidentNV_remap_index], fn) +#define CALL_BindProgramNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), driDispatchRemapTable[BindProgramNV_remap_index], parameters) +#define GET_BindProgramNV(disp) GET_by_offset(disp, driDispatchRemapTable[BindProgramNV_remap_index]) +#define SET_BindProgramNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BindProgramNV_remap_index], fn) +#define CALL_DeleteProgramsNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), driDispatchRemapTable[DeleteProgramsNV_remap_index], parameters) +#define GET_DeleteProgramsNV(disp) GET_by_offset(disp, driDispatchRemapTable[DeleteProgramsNV_remap_index]) +#define SET_DeleteProgramsNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DeleteProgramsNV_remap_index], fn) +#define CALL_ExecuteProgramNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, const GLfloat *)), driDispatchRemapTable[ExecuteProgramNV_remap_index], parameters) +#define GET_ExecuteProgramNV(disp) GET_by_offset(disp, driDispatchRemapTable[ExecuteProgramNV_remap_index]) +#define SET_ExecuteProgramNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ExecuteProgramNV_remap_index], fn) +#define CALL_GenProgramsNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), driDispatchRemapTable[GenProgramsNV_remap_index], parameters) +#define GET_GenProgramsNV(disp) GET_by_offset(disp, driDispatchRemapTable[GenProgramsNV_remap_index]) +#define SET_GenProgramsNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GenProgramsNV_remap_index], fn) +#define CALL_GetProgramParameterdvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLenum, GLdouble *)), driDispatchRemapTable[GetProgramParameterdvNV_remap_index], parameters) +#define GET_GetProgramParameterdvNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramParameterdvNV_remap_index]) +#define SET_GetProgramParameterdvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramParameterdvNV_remap_index], fn) +#define CALL_GetProgramParameterfvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLenum, GLfloat *)), driDispatchRemapTable[GetProgramParameterfvNV_remap_index], parameters) +#define GET_GetProgramParameterfvNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramParameterfvNV_remap_index]) +#define SET_GetProgramParameterfvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramParameterfvNV_remap_index], fn) +#define CALL_GetProgramivNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLint *)), driDispatchRemapTable[GetProgramivNV_remap_index], parameters) +#define GET_GetProgramivNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramivNV_remap_index]) +#define SET_GetProgramivNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramivNV_remap_index], fn) +#define CALL_GetProgramStringNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLubyte *)), driDispatchRemapTable[GetProgramStringNV_remap_index], parameters) +#define GET_GetProgramStringNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramStringNV_remap_index]) +#define SET_GetProgramStringNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramStringNV_remap_index], fn) +#define CALL_GetTrackMatrixivNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLenum, GLint *)), driDispatchRemapTable[GetTrackMatrixivNV_remap_index], parameters) +#define GET_GetTrackMatrixivNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetTrackMatrixivNV_remap_index]) +#define SET_GetTrackMatrixivNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetTrackMatrixivNV_remap_index], fn) +#define CALL_GetVertexAttribdvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLdouble *)), driDispatchRemapTable[GetVertexAttribdvARB_remap_index], parameters) +#define GET_GetVertexAttribdvARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetVertexAttribdvARB_remap_index]) +#define SET_GetVertexAttribdvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetVertexAttribdvARB_remap_index], fn) +#define CALL_GetVertexAttribfvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLfloat *)), driDispatchRemapTable[GetVertexAttribfvARB_remap_index], parameters) +#define GET_GetVertexAttribfvARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetVertexAttribfvARB_remap_index]) +#define SET_GetVertexAttribfvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetVertexAttribfvARB_remap_index], fn) +#define CALL_GetVertexAttribivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLint *)), driDispatchRemapTable[GetVertexAttribivARB_remap_index], parameters) +#define GET_GetVertexAttribivARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetVertexAttribivARB_remap_index]) +#define SET_GetVertexAttribivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetVertexAttribivARB_remap_index], fn) +#define CALL_GetVertexAttribPointervNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLvoid **)), driDispatchRemapTable[GetVertexAttribPointervNV_remap_index], parameters) +#define GET_GetVertexAttribPointervNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetVertexAttribPointervNV_remap_index]) +#define SET_GetVertexAttribPointervNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetVertexAttribPointervNV_remap_index], fn) +#define CALL_IsProgramNV(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[IsProgramNV_remap_index], parameters) +#define GET_IsProgramNV(disp) GET_by_offset(disp, driDispatchRemapTable[IsProgramNV_remap_index]) +#define SET_IsProgramNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IsProgramNV_remap_index], fn) +#define CALL_LoadProgramNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLsizei, const GLubyte *)), driDispatchRemapTable[LoadProgramNV_remap_index], parameters) +#define GET_LoadProgramNV(disp) GET_by_offset(disp, driDispatchRemapTable[LoadProgramNV_remap_index]) +#define SET_LoadProgramNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[LoadProgramNV_remap_index], fn) +#define CALL_ProgramParameter4dNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[ProgramParameter4dNV_remap_index], parameters) +#define GET_ProgramParameter4dNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramParameter4dNV_remap_index]) +#define SET_ProgramParameter4dNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramParameter4dNV_remap_index], fn) +#define CALL_ProgramParameter4dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, const GLdouble *)), driDispatchRemapTable[ProgramParameter4dvNV_remap_index], parameters) +#define GET_ProgramParameter4dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramParameter4dvNV_remap_index]) +#define SET_ProgramParameter4dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramParameter4dvNV_remap_index], fn) +#define CALL_ProgramParameter4fNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[ProgramParameter4fNV_remap_index], parameters) +#define GET_ProgramParameter4fNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramParameter4fNV_remap_index]) +#define SET_ProgramParameter4fNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramParameter4fNV_remap_index], fn) +#define CALL_ProgramParameter4fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, const GLfloat *)), driDispatchRemapTable[ProgramParameter4fvNV_remap_index], parameters) +#define GET_ProgramParameter4fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramParameter4fvNV_remap_index]) +#define SET_ProgramParameter4fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramParameter4fvNV_remap_index], fn) +#define CALL_ProgramParameters4dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, const GLdouble *)), driDispatchRemapTable[ProgramParameters4dvNV_remap_index], parameters) +#define GET_ProgramParameters4dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramParameters4dvNV_remap_index]) +#define SET_ProgramParameters4dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramParameters4dvNV_remap_index], fn) +#define CALL_ProgramParameters4fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, const GLfloat *)), driDispatchRemapTable[ProgramParameters4fvNV_remap_index], parameters) +#define GET_ProgramParameters4fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramParameters4fvNV_remap_index]) +#define SET_ProgramParameters4fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramParameters4fvNV_remap_index], fn) +#define CALL_RequestResidentProgramsNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), driDispatchRemapTable[RequestResidentProgramsNV_remap_index], parameters) +#define GET_RequestResidentProgramsNV(disp) GET_by_offset(disp, driDispatchRemapTable[RequestResidentProgramsNV_remap_index]) +#define SET_RequestResidentProgramsNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[RequestResidentProgramsNV_remap_index], fn) +#define CALL_TrackMatrixNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLenum, GLenum)), driDispatchRemapTable[TrackMatrixNV_remap_index], parameters) +#define GET_TrackMatrixNV(disp) GET_by_offset(disp, driDispatchRemapTable[TrackMatrixNV_remap_index]) +#define SET_TrackMatrixNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[TrackMatrixNV_remap_index], fn) +#define CALL_VertexAttribPointerNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLint, GLenum, GLsizei, const GLvoid *)), driDispatchRemapTable[VertexAttribPointerNV_remap_index], parameters) +#define GET_VertexAttribPointerNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribPointerNV_remap_index]) +#define SET_VertexAttribPointerNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribPointerNV_remap_index], fn) +#define CALL_VertexAttrib1dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLdouble)), driDispatchRemapTable[VertexAttrib1dARB_remap_index], parameters) +#define GET_VertexAttrib1dARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1dARB_remap_index]) +#define SET_VertexAttrib1dARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1dARB_remap_index], fn) +#define CALL_VertexAttrib1dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLdouble *)), driDispatchRemapTable[VertexAttrib1dvARB_remap_index], parameters) +#define GET_VertexAttrib1dvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1dvARB_remap_index]) +#define SET_VertexAttrib1dvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1dvARB_remap_index], fn) +#define CALL_VertexAttrib1fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat)), driDispatchRemapTable[VertexAttrib1fARB_remap_index], parameters) +#define GET_VertexAttrib1fARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1fARB_remap_index]) +#define SET_VertexAttrib1fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1fARB_remap_index], fn) +#define CALL_VertexAttrib1fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), driDispatchRemapTable[VertexAttrib1fvARB_remap_index], parameters) +#define GET_VertexAttrib1fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1fvARB_remap_index]) +#define SET_VertexAttrib1fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1fvARB_remap_index], fn) +#define CALL_VertexAttrib1sARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLshort)), driDispatchRemapTable[VertexAttrib1sARB_remap_index], parameters) +#define GET_VertexAttrib1sARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1sARB_remap_index]) +#define SET_VertexAttrib1sARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1sARB_remap_index], fn) +#define CALL_VertexAttrib1svARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLshort *)), driDispatchRemapTable[VertexAttrib1svARB_remap_index], parameters) +#define GET_VertexAttrib1svARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1svARB_remap_index]) +#define SET_VertexAttrib1svARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1svARB_remap_index], fn) +#define CALL_VertexAttrib2dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLdouble, GLdouble)), driDispatchRemapTable[VertexAttrib2dARB_remap_index], parameters) +#define GET_VertexAttrib2dARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2dARB_remap_index]) +#define SET_VertexAttrib2dARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2dARB_remap_index], fn) +#define CALL_VertexAttrib2dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLdouble *)), driDispatchRemapTable[VertexAttrib2dvARB_remap_index], parameters) +#define GET_VertexAttrib2dvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2dvARB_remap_index]) +#define SET_VertexAttrib2dvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2dvARB_remap_index], fn) +#define CALL_VertexAttrib2fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat, GLfloat)), driDispatchRemapTable[VertexAttrib2fARB_remap_index], parameters) +#define GET_VertexAttrib2fARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2fARB_remap_index]) +#define SET_VertexAttrib2fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2fARB_remap_index], fn) +#define CALL_VertexAttrib2fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), driDispatchRemapTable[VertexAttrib2fvARB_remap_index], parameters) +#define GET_VertexAttrib2fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2fvARB_remap_index]) +#define SET_VertexAttrib2fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2fvARB_remap_index], fn) +#define CALL_VertexAttrib2sARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLshort, GLshort)), driDispatchRemapTable[VertexAttrib2sARB_remap_index], parameters) +#define GET_VertexAttrib2sARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2sARB_remap_index]) +#define SET_VertexAttrib2sARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2sARB_remap_index], fn) +#define CALL_VertexAttrib2svARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLshort *)), driDispatchRemapTable[VertexAttrib2svARB_remap_index], parameters) +#define GET_VertexAttrib2svARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2svARB_remap_index]) +#define SET_VertexAttrib2svARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2svARB_remap_index], fn) +#define CALL_VertexAttrib3dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[VertexAttrib3dARB_remap_index], parameters) +#define GET_VertexAttrib3dARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3dARB_remap_index]) +#define SET_VertexAttrib3dARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3dARB_remap_index], fn) +#define CALL_VertexAttrib3dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLdouble *)), driDispatchRemapTable[VertexAttrib3dvARB_remap_index], parameters) +#define GET_VertexAttrib3dvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3dvARB_remap_index]) +#define SET_VertexAttrib3dvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3dvARB_remap_index], fn) +#define CALL_VertexAttrib3fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[VertexAttrib3fARB_remap_index], parameters) +#define GET_VertexAttrib3fARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3fARB_remap_index]) +#define SET_VertexAttrib3fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3fARB_remap_index], fn) +#define CALL_VertexAttrib3fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), driDispatchRemapTable[VertexAttrib3fvARB_remap_index], parameters) +#define GET_VertexAttrib3fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3fvARB_remap_index]) +#define SET_VertexAttrib3fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3fvARB_remap_index], fn) +#define CALL_VertexAttrib3sARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLshort, GLshort, GLshort)), driDispatchRemapTable[VertexAttrib3sARB_remap_index], parameters) +#define GET_VertexAttrib3sARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3sARB_remap_index]) +#define SET_VertexAttrib3sARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3sARB_remap_index], fn) +#define CALL_VertexAttrib3svARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLshort *)), driDispatchRemapTable[VertexAttrib3svARB_remap_index], parameters) +#define GET_VertexAttrib3svARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3svARB_remap_index]) +#define SET_VertexAttrib3svARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3svARB_remap_index], fn) +#define CALL_VertexAttrib4dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLdouble, GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[VertexAttrib4dARB_remap_index], parameters) +#define GET_VertexAttrib4dARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4dARB_remap_index]) +#define SET_VertexAttrib4dARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4dARB_remap_index], fn) +#define CALL_VertexAttrib4dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLdouble *)), driDispatchRemapTable[VertexAttrib4dvARB_remap_index], parameters) +#define GET_VertexAttrib4dvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4dvARB_remap_index]) +#define SET_VertexAttrib4dvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4dvARB_remap_index], fn) +#define CALL_VertexAttrib4fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[VertexAttrib4fARB_remap_index], parameters) +#define GET_VertexAttrib4fARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4fARB_remap_index]) +#define SET_VertexAttrib4fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4fARB_remap_index], fn) +#define CALL_VertexAttrib4fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), driDispatchRemapTable[VertexAttrib4fvARB_remap_index], parameters) +#define GET_VertexAttrib4fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4fvARB_remap_index]) +#define SET_VertexAttrib4fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4fvARB_remap_index], fn) +#define CALL_VertexAttrib4sARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLshort, GLshort, GLshort, GLshort)), driDispatchRemapTable[VertexAttrib4sARB_remap_index], parameters) +#define GET_VertexAttrib4sARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4sARB_remap_index]) +#define SET_VertexAttrib4sARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4sARB_remap_index], fn) +#define CALL_VertexAttrib4svARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLshort *)), driDispatchRemapTable[VertexAttrib4svARB_remap_index], parameters) +#define GET_VertexAttrib4svARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4svARB_remap_index]) +#define SET_VertexAttrib4svARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4svARB_remap_index], fn) +#define CALL_VertexAttrib4NubARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLubyte, GLubyte, GLubyte, GLubyte)), driDispatchRemapTable[VertexAttrib4NubARB_remap_index], parameters) +#define GET_VertexAttrib4NubARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NubARB_remap_index]) +#define SET_VertexAttrib4NubARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NubARB_remap_index], fn) +#define CALL_VertexAttrib4NubvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLubyte *)), driDispatchRemapTable[VertexAttrib4NubvARB_remap_index], parameters) +#define GET_VertexAttrib4NubvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NubvARB_remap_index]) +#define SET_VertexAttrib4NubvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NubvARB_remap_index], fn) +#define CALL_VertexAttribs1dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLdouble *)), driDispatchRemapTable[VertexAttribs1dvNV_remap_index], parameters) +#define GET_VertexAttribs1dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs1dvNV_remap_index]) +#define SET_VertexAttribs1dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs1dvNV_remap_index], fn) +#define CALL_VertexAttribs1fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLfloat *)), driDispatchRemapTable[VertexAttribs1fvNV_remap_index], parameters) +#define GET_VertexAttribs1fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs1fvNV_remap_index]) +#define SET_VertexAttribs1fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs1fvNV_remap_index], fn) +#define CALL_VertexAttribs1svNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLshort *)), driDispatchRemapTable[VertexAttribs1svNV_remap_index], parameters) +#define GET_VertexAttribs1svNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs1svNV_remap_index]) +#define SET_VertexAttribs1svNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs1svNV_remap_index], fn) +#define CALL_VertexAttribs2dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLdouble *)), driDispatchRemapTable[VertexAttribs2dvNV_remap_index], parameters) +#define GET_VertexAttribs2dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs2dvNV_remap_index]) +#define SET_VertexAttribs2dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs2dvNV_remap_index], fn) +#define CALL_VertexAttribs2fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLfloat *)), driDispatchRemapTable[VertexAttribs2fvNV_remap_index], parameters) +#define GET_VertexAttribs2fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs2fvNV_remap_index]) +#define SET_VertexAttribs2fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs2fvNV_remap_index], fn) +#define CALL_VertexAttribs2svNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLshort *)), driDispatchRemapTable[VertexAttribs2svNV_remap_index], parameters) +#define GET_VertexAttribs2svNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs2svNV_remap_index]) +#define SET_VertexAttribs2svNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs2svNV_remap_index], fn) +#define CALL_VertexAttribs3dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLdouble *)), driDispatchRemapTable[VertexAttribs3dvNV_remap_index], parameters) +#define GET_VertexAttribs3dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs3dvNV_remap_index]) +#define SET_VertexAttribs3dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs3dvNV_remap_index], fn) +#define CALL_VertexAttribs3fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLfloat *)), driDispatchRemapTable[VertexAttribs3fvNV_remap_index], parameters) +#define GET_VertexAttribs3fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs3fvNV_remap_index]) +#define SET_VertexAttribs3fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs3fvNV_remap_index], fn) +#define CALL_VertexAttribs3svNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLshort *)), driDispatchRemapTable[VertexAttribs3svNV_remap_index], parameters) +#define GET_VertexAttribs3svNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs3svNV_remap_index]) +#define SET_VertexAttribs3svNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs3svNV_remap_index], fn) +#define CALL_VertexAttribs4dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLdouble *)), driDispatchRemapTable[VertexAttribs4dvNV_remap_index], parameters) +#define GET_VertexAttribs4dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs4dvNV_remap_index]) +#define SET_VertexAttribs4dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs4dvNV_remap_index], fn) +#define CALL_VertexAttribs4fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLfloat *)), driDispatchRemapTable[VertexAttribs4fvNV_remap_index], parameters) +#define GET_VertexAttribs4fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs4fvNV_remap_index]) +#define SET_VertexAttribs4fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs4fvNV_remap_index], fn) +#define CALL_VertexAttribs4svNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLshort *)), driDispatchRemapTable[VertexAttribs4svNV_remap_index], parameters) +#define GET_VertexAttribs4svNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs4svNV_remap_index]) +#define SET_VertexAttribs4svNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs4svNV_remap_index], fn) +#define CALL_VertexAttribs4ubvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLubyte *)), driDispatchRemapTable[VertexAttribs4ubvNV_remap_index], parameters) +#define GET_VertexAttribs4ubvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribs4ubvNV_remap_index]) +#define SET_VertexAttribs4ubvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribs4ubvNV_remap_index], fn) +#define CALL_PointParameteriNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint)), driDispatchRemapTable[PointParameteriNV_remap_index], parameters) +#define GET_PointParameteriNV(disp) GET_by_offset(disp, driDispatchRemapTable[PointParameteriNV_remap_index]) +#define SET_PointParameteriNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PointParameteriNV_remap_index], fn) +#define CALL_PointParameterivNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLint *)), driDispatchRemapTable[PointParameterivNV_remap_index], parameters) +#define GET_PointParameterivNV(disp) GET_by_offset(disp, driDispatchRemapTable[PointParameterivNV_remap_index]) +#define SET_PointParameterivNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PointParameterivNV_remap_index], fn) +#define CALL_MultiDrawArraysEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLint *, GLsizei *, GLsizei)), driDispatchRemapTable[MultiDrawArraysEXT_remap_index], parameters) +#define GET_MultiDrawArraysEXT(disp) GET_by_offset(disp, driDispatchRemapTable[MultiDrawArraysEXT_remap_index]) +#define SET_MultiDrawArraysEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[MultiDrawArraysEXT_remap_index], fn) +#define CALL_MultiDrawElementsEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, const GLsizei *, GLenum, const GLvoid **, GLsizei)), driDispatchRemapTable[MultiDrawElementsEXT_remap_index], parameters) +#define GET_MultiDrawElementsEXT(disp) GET_by_offset(disp, driDispatchRemapTable[MultiDrawElementsEXT_remap_index]) +#define SET_MultiDrawElementsEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[MultiDrawElementsEXT_remap_index], fn) +#define CALL_ActiveStencilFaceEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[ActiveStencilFaceEXT_remap_index], parameters) +#define GET_ActiveStencilFaceEXT(disp) GET_by_offset(disp, driDispatchRemapTable[ActiveStencilFaceEXT_remap_index]) +#define SET_ActiveStencilFaceEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ActiveStencilFaceEXT_remap_index], fn) +#define CALL_DeleteFencesNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), driDispatchRemapTable[DeleteFencesNV_remap_index], parameters) +#define GET_DeleteFencesNV(disp) GET_by_offset(disp, driDispatchRemapTable[DeleteFencesNV_remap_index]) +#define SET_DeleteFencesNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DeleteFencesNV_remap_index], fn) +#define CALL_GenFencesNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), driDispatchRemapTable[GenFencesNV_remap_index], parameters) +#define GET_GenFencesNV(disp) GET_by_offset(disp, driDispatchRemapTable[GenFencesNV_remap_index]) +#define SET_GenFencesNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GenFencesNV_remap_index], fn) +#define CALL_IsFenceNV(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[IsFenceNV_remap_index], parameters) +#define GET_IsFenceNV(disp) GET_by_offset(disp, driDispatchRemapTable[IsFenceNV_remap_index]) +#define SET_IsFenceNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IsFenceNV_remap_index], fn) +#define CALL_TestFenceNV(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[TestFenceNV_remap_index], parameters) +#define GET_TestFenceNV(disp) GET_by_offset(disp, driDispatchRemapTable[TestFenceNV_remap_index]) +#define SET_TestFenceNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[TestFenceNV_remap_index], fn) +#define CALL_GetFenceivNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLint *)), driDispatchRemapTable[GetFenceivNV_remap_index], parameters) +#define GET_GetFenceivNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetFenceivNV_remap_index]) +#define SET_GetFenceivNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetFenceivNV_remap_index], fn) +#define CALL_FinishFenceNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[FinishFenceNV_remap_index], parameters) +#define GET_FinishFenceNV(disp) GET_by_offset(disp, driDispatchRemapTable[FinishFenceNV_remap_index]) +#define SET_FinishFenceNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FinishFenceNV_remap_index], fn) +#define CALL_SetFenceNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum)), driDispatchRemapTable[SetFenceNV_remap_index], parameters) +#define GET_SetFenceNV(disp) GET_by_offset(disp, driDispatchRemapTable[SetFenceNV_remap_index]) +#define SET_SetFenceNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SetFenceNV_remap_index], fn) +#define CALL_VertexAttrib4bvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLbyte *)), driDispatchRemapTable[VertexAttrib4bvARB_remap_index], parameters) +#define GET_VertexAttrib4bvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4bvARB_remap_index]) +#define SET_VertexAttrib4bvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4bvARB_remap_index], fn) +#define CALL_VertexAttrib4ivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLint *)), driDispatchRemapTable[VertexAttrib4ivARB_remap_index], parameters) +#define GET_VertexAttrib4ivARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4ivARB_remap_index]) +#define SET_VertexAttrib4ivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4ivARB_remap_index], fn) +#define CALL_VertexAttrib4ubvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLubyte *)), driDispatchRemapTable[VertexAttrib4ubvARB_remap_index], parameters) +#define GET_VertexAttrib4ubvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4ubvARB_remap_index]) +#define SET_VertexAttrib4ubvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4ubvARB_remap_index], fn) +#define CALL_VertexAttrib4usvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLushort *)), driDispatchRemapTable[VertexAttrib4usvARB_remap_index], parameters) +#define GET_VertexAttrib4usvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4usvARB_remap_index]) +#define SET_VertexAttrib4usvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4usvARB_remap_index], fn) +#define CALL_VertexAttrib4uivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLuint *)), driDispatchRemapTable[VertexAttrib4uivARB_remap_index], parameters) +#define GET_VertexAttrib4uivARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4uivARB_remap_index]) +#define SET_VertexAttrib4uivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4uivARB_remap_index], fn) +#define CALL_VertexAttrib4NbvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLbyte *)), driDispatchRemapTable[VertexAttrib4NbvARB_remap_index], parameters) +#define GET_VertexAttrib4NbvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NbvARB_remap_index]) +#define SET_VertexAttrib4NbvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NbvARB_remap_index], fn) +#define CALL_VertexAttrib4NsvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLshort *)), driDispatchRemapTable[VertexAttrib4NsvARB_remap_index], parameters) +#define GET_VertexAttrib4NsvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NsvARB_remap_index]) +#define SET_VertexAttrib4NsvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NsvARB_remap_index], fn) +#define CALL_VertexAttrib4NivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLint *)), driDispatchRemapTable[VertexAttrib4NivARB_remap_index], parameters) +#define GET_VertexAttrib4NivARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NivARB_remap_index]) +#define SET_VertexAttrib4NivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NivARB_remap_index], fn) +#define CALL_VertexAttrib4NusvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLushort *)), driDispatchRemapTable[VertexAttrib4NusvARB_remap_index], parameters) +#define GET_VertexAttrib4NusvARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NusvARB_remap_index]) +#define SET_VertexAttrib4NusvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NusvARB_remap_index], fn) +#define CALL_VertexAttrib4NuivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLuint *)), driDispatchRemapTable[VertexAttrib4NuivARB_remap_index], parameters) +#define GET_VertexAttrib4NuivARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NuivARB_remap_index]) +#define SET_VertexAttrib4NuivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4NuivARB_remap_index], fn) +#define CALL_VertexAttribPointerARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid *)), driDispatchRemapTable[VertexAttribPointerARB_remap_index], parameters) +#define GET_VertexAttribPointerARB(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttribPointerARB_remap_index]) +#define SET_VertexAttribPointerARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttribPointerARB_remap_index], fn) +#define CALL_EnableVertexAttribArrayARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[EnableVertexAttribArrayARB_remap_index], parameters) +#define GET_EnableVertexAttribArrayARB(disp) GET_by_offset(disp, driDispatchRemapTable[EnableVertexAttribArrayARB_remap_index]) +#define SET_EnableVertexAttribArrayARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[EnableVertexAttribArrayARB_remap_index], fn) +#define CALL_DisableVertexAttribArrayARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[DisableVertexAttribArrayARB_remap_index], parameters) +#define GET_DisableVertexAttribArrayARB(disp) GET_by_offset(disp, driDispatchRemapTable[DisableVertexAttribArrayARB_remap_index]) +#define SET_DisableVertexAttribArrayARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DisableVertexAttribArrayARB_remap_index], fn) +#define CALL_ProgramStringARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLsizei, const GLvoid *)), driDispatchRemapTable[ProgramStringARB_remap_index], parameters) +#define GET_ProgramStringARB(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramStringARB_remap_index]) +#define SET_ProgramStringARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramStringARB_remap_index], fn) +#define CALL_ProgramEnvParameter4dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[ProgramEnvParameter4dARB_remap_index], parameters) +#define GET_ProgramEnvParameter4dARB(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramEnvParameter4dARB_remap_index]) +#define SET_ProgramEnvParameter4dARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramEnvParameter4dARB_remap_index], fn) +#define CALL_ProgramEnvParameter4dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, const GLdouble *)), driDispatchRemapTable[ProgramEnvParameter4dvARB_remap_index], parameters) +#define GET_ProgramEnvParameter4dvARB(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramEnvParameter4dvARB_remap_index]) +#define SET_ProgramEnvParameter4dvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramEnvParameter4dvARB_remap_index], fn) +#define CALL_ProgramEnvParameter4fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[ProgramEnvParameter4fARB_remap_index], parameters) +#define GET_ProgramEnvParameter4fARB(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramEnvParameter4fARB_remap_index]) +#define SET_ProgramEnvParameter4fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramEnvParameter4fARB_remap_index], fn) +#define CALL_ProgramEnvParameter4fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, const GLfloat *)), driDispatchRemapTable[ProgramEnvParameter4fvARB_remap_index], parameters) +#define GET_ProgramEnvParameter4fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramEnvParameter4fvARB_remap_index]) +#define SET_ProgramEnvParameter4fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramEnvParameter4fvARB_remap_index], fn) +#define CALL_ProgramLocalParameter4dARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[ProgramLocalParameter4dARB_remap_index], parameters) +#define GET_ProgramLocalParameter4dARB(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramLocalParameter4dARB_remap_index]) +#define SET_ProgramLocalParameter4dARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramLocalParameter4dARB_remap_index], fn) +#define CALL_ProgramLocalParameter4dvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, const GLdouble *)), driDispatchRemapTable[ProgramLocalParameter4dvARB_remap_index], parameters) +#define GET_ProgramLocalParameter4dvARB(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramLocalParameter4dvARB_remap_index]) +#define SET_ProgramLocalParameter4dvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramLocalParameter4dvARB_remap_index], fn) +#define CALL_ProgramLocalParameter4fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[ProgramLocalParameter4fARB_remap_index], parameters) +#define GET_ProgramLocalParameter4fARB(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramLocalParameter4fARB_remap_index]) +#define SET_ProgramLocalParameter4fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramLocalParameter4fARB_remap_index], fn) +#define CALL_ProgramLocalParameter4fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, const GLfloat *)), driDispatchRemapTable[ProgramLocalParameter4fvARB_remap_index], parameters) +#define GET_ProgramLocalParameter4fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramLocalParameter4fvARB_remap_index]) +#define SET_ProgramLocalParameter4fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramLocalParameter4fvARB_remap_index], fn) +#define CALL_GetProgramEnvParameterdvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLdouble *)), driDispatchRemapTable[GetProgramEnvParameterdvARB_remap_index], parameters) +#define GET_GetProgramEnvParameterdvARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramEnvParameterdvARB_remap_index]) +#define SET_GetProgramEnvParameterdvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramEnvParameterdvARB_remap_index], fn) +#define CALL_GetProgramEnvParameterfvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLfloat *)), driDispatchRemapTable[GetProgramEnvParameterfvARB_remap_index], parameters) +#define GET_GetProgramEnvParameterfvARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramEnvParameterfvARB_remap_index]) +#define SET_GetProgramEnvParameterfvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramEnvParameterfvARB_remap_index], fn) +#define CALL_GetProgramLocalParameterdvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLdouble *)), driDispatchRemapTable[GetProgramLocalParameterdvARB_remap_index], parameters) +#define GET_GetProgramLocalParameterdvARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramLocalParameterdvARB_remap_index]) +#define SET_GetProgramLocalParameterdvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramLocalParameterdvARB_remap_index], fn) +#define CALL_GetProgramLocalParameterfvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLfloat *)), driDispatchRemapTable[GetProgramLocalParameterfvARB_remap_index], parameters) +#define GET_GetProgramLocalParameterfvARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramLocalParameterfvARB_remap_index]) +#define SET_GetProgramLocalParameterfvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramLocalParameterfvARB_remap_index], fn) +#define CALL_GetProgramivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetProgramivARB_remap_index], parameters) +#define GET_GetProgramivARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramivARB_remap_index]) +#define SET_GetProgramivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramivARB_remap_index], fn) +#define CALL_GetProgramStringARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLvoid *)), driDispatchRemapTable[GetProgramStringARB_remap_index], parameters) +#define GET_GetProgramStringARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramStringARB_remap_index]) +#define SET_GetProgramStringARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramStringARB_remap_index], fn) +#define CALL_ProgramNamedParameter4fNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLubyte *, GLfloat, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[ProgramNamedParameter4fNV_remap_index], parameters) +#define GET_ProgramNamedParameter4fNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramNamedParameter4fNV_remap_index]) +#define SET_ProgramNamedParameter4fNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramNamedParameter4fNV_remap_index], fn) +#define CALL_ProgramNamedParameter4dNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLubyte *, GLdouble, GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[ProgramNamedParameter4dNV_remap_index], parameters) +#define GET_ProgramNamedParameter4dNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramNamedParameter4dNV_remap_index]) +#define SET_ProgramNamedParameter4dNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramNamedParameter4dNV_remap_index], fn) +#define CALL_ProgramNamedParameter4fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLubyte *, const GLfloat *)), driDispatchRemapTable[ProgramNamedParameter4fvNV_remap_index], parameters) +#define GET_ProgramNamedParameter4fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramNamedParameter4fvNV_remap_index]) +#define SET_ProgramNamedParameter4fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramNamedParameter4fvNV_remap_index], fn) +#define CALL_ProgramNamedParameter4dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLubyte *, const GLdouble *)), driDispatchRemapTable[ProgramNamedParameter4dvNV_remap_index], parameters) +#define GET_ProgramNamedParameter4dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[ProgramNamedParameter4dvNV_remap_index]) +#define SET_ProgramNamedParameter4dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ProgramNamedParameter4dvNV_remap_index], fn) +#define CALL_GetProgramNamedParameterfvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLubyte *, GLfloat *)), driDispatchRemapTable[GetProgramNamedParameterfvNV_remap_index], parameters) +#define GET_GetProgramNamedParameterfvNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramNamedParameterfvNV_remap_index]) +#define SET_GetProgramNamedParameterfvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramNamedParameterfvNV_remap_index], fn) +#define CALL_GetProgramNamedParameterdvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLsizei, const GLubyte *, GLdouble *)), driDispatchRemapTable[GetProgramNamedParameterdvNV_remap_index], parameters) +#define GET_GetProgramNamedParameterdvNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetProgramNamedParameterdvNV_remap_index]) +#define SET_GetProgramNamedParameterdvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetProgramNamedParameterdvNV_remap_index], fn) +#define CALL_BindBufferARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), driDispatchRemapTable[BindBufferARB_remap_index], parameters) +#define GET_BindBufferARB(disp) GET_by_offset(disp, driDispatchRemapTable[BindBufferARB_remap_index]) +#define SET_BindBufferARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BindBufferARB_remap_index], fn) +#define CALL_BufferDataARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLsizeiptrARB, const GLvoid *, GLenum)), driDispatchRemapTable[BufferDataARB_remap_index], parameters) +#define GET_BufferDataARB(disp) GET_by_offset(disp, driDispatchRemapTable[BufferDataARB_remap_index]) +#define SET_BufferDataARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BufferDataARB_remap_index], fn) +#define CALL_BufferSubDataARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLintptrARB, GLsizeiptrARB, const GLvoid *)), driDispatchRemapTable[BufferSubDataARB_remap_index], parameters) +#define GET_BufferSubDataARB(disp) GET_by_offset(disp, driDispatchRemapTable[BufferSubDataARB_remap_index]) +#define SET_BufferSubDataARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BufferSubDataARB_remap_index], fn) +#define CALL_DeleteBuffersARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), driDispatchRemapTable[DeleteBuffersARB_remap_index], parameters) +#define GET_DeleteBuffersARB(disp) GET_by_offset(disp, driDispatchRemapTable[DeleteBuffersARB_remap_index]) +#define SET_DeleteBuffersARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DeleteBuffersARB_remap_index], fn) +#define CALL_GenBuffersARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), driDispatchRemapTable[GenBuffersARB_remap_index], parameters) +#define GET_GenBuffersARB(disp) GET_by_offset(disp, driDispatchRemapTable[GenBuffersARB_remap_index]) +#define SET_GenBuffersARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GenBuffersARB_remap_index], fn) +#define CALL_GetBufferParameterivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetBufferParameterivARB_remap_index], parameters) +#define GET_GetBufferParameterivARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetBufferParameterivARB_remap_index]) +#define SET_GetBufferParameterivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetBufferParameterivARB_remap_index], fn) +#define CALL_GetBufferPointervARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLvoid **)), driDispatchRemapTable[GetBufferPointervARB_remap_index], parameters) +#define GET_GetBufferPointervARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetBufferPointervARB_remap_index]) +#define SET_GetBufferPointervARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetBufferPointervARB_remap_index], fn) +#define CALL_GetBufferSubDataARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLintptrARB, GLsizeiptrARB, GLvoid *)), driDispatchRemapTable[GetBufferSubDataARB_remap_index], parameters) +#define GET_GetBufferSubDataARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetBufferSubDataARB_remap_index]) +#define SET_GetBufferSubDataARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetBufferSubDataARB_remap_index], fn) +#define CALL_IsBufferARB(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[IsBufferARB_remap_index], parameters) +#define GET_IsBufferARB(disp) GET_by_offset(disp, driDispatchRemapTable[IsBufferARB_remap_index]) +#define SET_IsBufferARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IsBufferARB_remap_index], fn) +#define CALL_MapBufferARB(disp, parameters) CALL_by_offset(disp, (GLvoid * (GLAPIENTRYP)(GLenum, GLenum)), driDispatchRemapTable[MapBufferARB_remap_index], parameters) +#define GET_MapBufferARB(disp) GET_by_offset(disp, driDispatchRemapTable[MapBufferARB_remap_index]) +#define SET_MapBufferARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[MapBufferARB_remap_index], fn) +#define CALL_UnmapBufferARB(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[UnmapBufferARB_remap_index], parameters) +#define GET_UnmapBufferARB(disp) GET_by_offset(disp, driDispatchRemapTable[UnmapBufferARB_remap_index]) +#define SET_UnmapBufferARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[UnmapBufferARB_remap_index], fn) +#define CALL_DepthBoundsEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLclampd, GLclampd)), driDispatchRemapTable[DepthBoundsEXT_remap_index], parameters) +#define GET_DepthBoundsEXT(disp) GET_by_offset(disp, driDispatchRemapTable[DepthBoundsEXT_remap_index]) +#define SET_DepthBoundsEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DepthBoundsEXT_remap_index], fn) +#define CALL_GenQueriesARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), driDispatchRemapTable[GenQueriesARB_remap_index], parameters) +#define GET_GenQueriesARB(disp) GET_by_offset(disp, driDispatchRemapTable[GenQueriesARB_remap_index]) +#define SET_GenQueriesARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GenQueriesARB_remap_index], fn) +#define CALL_DeleteQueriesARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), driDispatchRemapTable[DeleteQueriesARB_remap_index], parameters) +#define GET_DeleteQueriesARB(disp) GET_by_offset(disp, driDispatchRemapTable[DeleteQueriesARB_remap_index]) +#define SET_DeleteQueriesARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DeleteQueriesARB_remap_index], fn) +#define CALL_IsQueryARB(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[IsQueryARB_remap_index], parameters) +#define GET_IsQueryARB(disp) GET_by_offset(disp, driDispatchRemapTable[IsQueryARB_remap_index]) +#define SET_IsQueryARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IsQueryARB_remap_index], fn) +#define CALL_BeginQueryARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), driDispatchRemapTable[BeginQueryARB_remap_index], parameters) +#define GET_BeginQueryARB(disp) GET_by_offset(disp, driDispatchRemapTable[BeginQueryARB_remap_index]) +#define SET_BeginQueryARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BeginQueryARB_remap_index], fn) +#define CALL_EndQueryARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[EndQueryARB_remap_index], parameters) +#define GET_EndQueryARB(disp) GET_by_offset(disp, driDispatchRemapTable[EndQueryARB_remap_index]) +#define SET_EndQueryARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[EndQueryARB_remap_index], fn) +#define CALL_GetQueryivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetQueryivARB_remap_index], parameters) +#define GET_GetQueryivARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetQueryivARB_remap_index]) +#define SET_GetQueryivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetQueryivARB_remap_index], fn) +#define CALL_GetQueryObjectivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLint *)), driDispatchRemapTable[GetQueryObjectivARB_remap_index], parameters) +#define GET_GetQueryObjectivARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetQueryObjectivARB_remap_index]) +#define SET_GetQueryObjectivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetQueryObjectivARB_remap_index], fn) +#define CALL_GetQueryObjectuivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLuint *)), driDispatchRemapTable[GetQueryObjectuivARB_remap_index], parameters) +#define GET_GetQueryObjectuivARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetQueryObjectuivARB_remap_index]) +#define SET_GetQueryObjectuivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetQueryObjectuivARB_remap_index], fn) +#define CALL_MultiModeDrawArraysIBM(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLenum *, const GLint *, const GLsizei *, GLsizei, GLint)), driDispatchRemapTable[MultiModeDrawArraysIBM_remap_index], parameters) +#define GET_MultiModeDrawArraysIBM(disp) GET_by_offset(disp, driDispatchRemapTable[MultiModeDrawArraysIBM_remap_index]) +#define SET_MultiModeDrawArraysIBM(disp, fn) SET_by_offset(disp, driDispatchRemapTable[MultiModeDrawArraysIBM_remap_index], fn) +#define CALL_MultiModeDrawElementsIBM(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(const GLenum *, const GLsizei *, GLenum, const GLvoid * const *, GLsizei, GLint)), driDispatchRemapTable[MultiModeDrawElementsIBM_remap_index], parameters) +#define GET_MultiModeDrawElementsIBM(disp) GET_by_offset(disp, driDispatchRemapTable[MultiModeDrawElementsIBM_remap_index]) +#define SET_MultiModeDrawElementsIBM(disp, fn) SET_by_offset(disp, driDispatchRemapTable[MultiModeDrawElementsIBM_remap_index], fn) +#define CALL_BlendEquationSeparateEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum)), driDispatchRemapTable[BlendEquationSeparateEXT_remap_index], parameters) +#define GET_BlendEquationSeparateEXT(disp) GET_by_offset(disp, driDispatchRemapTable[BlendEquationSeparateEXT_remap_index]) +#define SET_BlendEquationSeparateEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BlendEquationSeparateEXT_remap_index], fn) +#define CALL_DeleteObjectARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB)), driDispatchRemapTable[DeleteObjectARB_remap_index], parameters) +#define GET_DeleteObjectARB(disp) GET_by_offset(disp, driDispatchRemapTable[DeleteObjectARB_remap_index]) +#define SET_DeleteObjectARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DeleteObjectARB_remap_index], fn) +#define CALL_GetHandleARB(disp, parameters) CALL_by_offset(disp, (GLhandleARB (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[GetHandleARB_remap_index], parameters) +#define GET_GetHandleARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetHandleARB_remap_index]) +#define SET_GetHandleARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetHandleARB_remap_index], fn) +#define CALL_DetachObjectARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLhandleARB)), driDispatchRemapTable[DetachObjectARB_remap_index], parameters) +#define GET_DetachObjectARB(disp) GET_by_offset(disp, driDispatchRemapTable[DetachObjectARB_remap_index]) +#define SET_DetachObjectARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DetachObjectARB_remap_index], fn) +#define CALL_CreateShaderObjectARB(disp, parameters) CALL_by_offset(disp, (GLhandleARB (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[CreateShaderObjectARB_remap_index], parameters) +#define GET_CreateShaderObjectARB(disp) GET_by_offset(disp, driDispatchRemapTable[CreateShaderObjectARB_remap_index]) +#define SET_CreateShaderObjectARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CreateShaderObjectARB_remap_index], fn) +#define CALL_ShaderSourceARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLsizei, const GLcharARB **, const GLint *)), driDispatchRemapTable[ShaderSourceARB_remap_index], parameters) +#define GET_ShaderSourceARB(disp) GET_by_offset(disp, driDispatchRemapTable[ShaderSourceARB_remap_index]) +#define SET_ShaderSourceARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ShaderSourceARB_remap_index], fn) +#define CALL_CompileShaderARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB)), driDispatchRemapTable[CompileShaderARB_remap_index], parameters) +#define GET_CompileShaderARB(disp) GET_by_offset(disp, driDispatchRemapTable[CompileShaderARB_remap_index]) +#define SET_CompileShaderARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CompileShaderARB_remap_index], fn) +#define CALL_CreateProgramObjectARB(disp, parameters) CALL_by_offset(disp, (GLhandleARB (GLAPIENTRYP)(void)), driDispatchRemapTable[CreateProgramObjectARB_remap_index], parameters) +#define GET_CreateProgramObjectARB(disp) GET_by_offset(disp, driDispatchRemapTable[CreateProgramObjectARB_remap_index]) +#define SET_CreateProgramObjectARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CreateProgramObjectARB_remap_index], fn) +#define CALL_AttachObjectARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLhandleARB)), driDispatchRemapTable[AttachObjectARB_remap_index], parameters) +#define GET_AttachObjectARB(disp) GET_by_offset(disp, driDispatchRemapTable[AttachObjectARB_remap_index]) +#define SET_AttachObjectARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[AttachObjectARB_remap_index], fn) +#define CALL_LinkProgramARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB)), driDispatchRemapTable[LinkProgramARB_remap_index], parameters) +#define GET_LinkProgramARB(disp) GET_by_offset(disp, driDispatchRemapTable[LinkProgramARB_remap_index]) +#define SET_LinkProgramARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[LinkProgramARB_remap_index], fn) +#define CALL_UseProgramObjectARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB)), driDispatchRemapTable[UseProgramObjectARB_remap_index], parameters) +#define GET_UseProgramObjectARB(disp) GET_by_offset(disp, driDispatchRemapTable[UseProgramObjectARB_remap_index]) +#define SET_UseProgramObjectARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[UseProgramObjectARB_remap_index], fn) +#define CALL_ValidateProgramARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB)), driDispatchRemapTable[ValidateProgramARB_remap_index], parameters) +#define GET_ValidateProgramARB(disp) GET_by_offset(disp, driDispatchRemapTable[ValidateProgramARB_remap_index]) +#define SET_ValidateProgramARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ValidateProgramARB_remap_index], fn) +#define CALL_Uniform1fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLfloat)), driDispatchRemapTable[Uniform1fARB_remap_index], parameters) +#define GET_Uniform1fARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform1fARB_remap_index]) +#define SET_Uniform1fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform1fARB_remap_index], fn) +#define CALL_Uniform2fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLfloat, GLfloat)), driDispatchRemapTable[Uniform2fARB_remap_index], parameters) +#define GET_Uniform2fARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform2fARB_remap_index]) +#define SET_Uniform2fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform2fARB_remap_index], fn) +#define CALL_Uniform3fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[Uniform3fARB_remap_index], parameters) +#define GET_Uniform3fARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform3fARB_remap_index]) +#define SET_Uniform3fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform3fARB_remap_index], fn) +#define CALL_Uniform4fARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLfloat, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[Uniform4fARB_remap_index], parameters) +#define GET_Uniform4fARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform4fARB_remap_index]) +#define SET_Uniform4fARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform4fARB_remap_index], fn) +#define CALL_Uniform1iARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint)), driDispatchRemapTable[Uniform1iARB_remap_index], parameters) +#define GET_Uniform1iARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform1iARB_remap_index]) +#define SET_Uniform1iARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform1iARB_remap_index], fn) +#define CALL_Uniform2iARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint)), driDispatchRemapTable[Uniform2iARB_remap_index], parameters) +#define GET_Uniform2iARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform2iARB_remap_index]) +#define SET_Uniform2iARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform2iARB_remap_index], fn) +#define CALL_Uniform3iARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint)), driDispatchRemapTable[Uniform3iARB_remap_index], parameters) +#define GET_Uniform3iARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform3iARB_remap_index]) +#define SET_Uniform3iARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform3iARB_remap_index], fn) +#define CALL_Uniform4iARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLint, GLint, GLint, GLint)), driDispatchRemapTable[Uniform4iARB_remap_index], parameters) +#define GET_Uniform4iARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform4iARB_remap_index]) +#define SET_Uniform4iARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform4iARB_remap_index], fn) +#define CALL_Uniform1fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLfloat *)), driDispatchRemapTable[Uniform1fvARB_remap_index], parameters) +#define GET_Uniform1fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform1fvARB_remap_index]) +#define SET_Uniform1fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform1fvARB_remap_index], fn) +#define CALL_Uniform2fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLfloat *)), driDispatchRemapTable[Uniform2fvARB_remap_index], parameters) +#define GET_Uniform2fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform2fvARB_remap_index]) +#define SET_Uniform2fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform2fvARB_remap_index], fn) +#define CALL_Uniform3fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLfloat *)), driDispatchRemapTable[Uniform3fvARB_remap_index], parameters) +#define GET_Uniform3fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform3fvARB_remap_index]) +#define SET_Uniform3fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform3fvARB_remap_index], fn) +#define CALL_Uniform4fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLfloat *)), driDispatchRemapTable[Uniform4fvARB_remap_index], parameters) +#define GET_Uniform4fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform4fvARB_remap_index]) +#define SET_Uniform4fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform4fvARB_remap_index], fn) +#define CALL_Uniform1ivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLint *)), driDispatchRemapTable[Uniform1ivARB_remap_index], parameters) +#define GET_Uniform1ivARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform1ivARB_remap_index]) +#define SET_Uniform1ivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform1ivARB_remap_index], fn) +#define CALL_Uniform2ivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLint *)), driDispatchRemapTable[Uniform2ivARB_remap_index], parameters) +#define GET_Uniform2ivARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform2ivARB_remap_index]) +#define SET_Uniform2ivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform2ivARB_remap_index], fn) +#define CALL_Uniform3ivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLint *)), driDispatchRemapTable[Uniform3ivARB_remap_index], parameters) +#define GET_Uniform3ivARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform3ivARB_remap_index]) +#define SET_Uniform3ivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform3ivARB_remap_index], fn) +#define CALL_Uniform4ivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, const GLint *)), driDispatchRemapTable[Uniform4ivARB_remap_index], parameters) +#define GET_Uniform4ivARB(disp) GET_by_offset(disp, driDispatchRemapTable[Uniform4ivARB_remap_index]) +#define SET_Uniform4ivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[Uniform4ivARB_remap_index], fn) +#define CALL_UniformMatrix2fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, GLboolean, const GLfloat *)), driDispatchRemapTable[UniformMatrix2fvARB_remap_index], parameters) +#define GET_UniformMatrix2fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[UniformMatrix2fvARB_remap_index]) +#define SET_UniformMatrix2fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[UniformMatrix2fvARB_remap_index], fn) +#define CALL_UniformMatrix3fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, GLboolean, const GLfloat *)), driDispatchRemapTable[UniformMatrix3fvARB_remap_index], parameters) +#define GET_UniformMatrix3fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[UniformMatrix3fvARB_remap_index]) +#define SET_UniformMatrix3fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[UniformMatrix3fvARB_remap_index], fn) +#define CALL_UniformMatrix4fvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLint, GLsizei, GLboolean, const GLfloat *)), driDispatchRemapTable[UniformMatrix4fvARB_remap_index], parameters) +#define GET_UniformMatrix4fvARB(disp) GET_by_offset(disp, driDispatchRemapTable[UniformMatrix4fvARB_remap_index]) +#define SET_UniformMatrix4fvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[UniformMatrix4fvARB_remap_index], fn) +#define CALL_GetObjectParameterfvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLenum, GLfloat *)), driDispatchRemapTable[GetObjectParameterfvARB_remap_index], parameters) +#define GET_GetObjectParameterfvARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetObjectParameterfvARB_remap_index]) +#define SET_GetObjectParameterfvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetObjectParameterfvARB_remap_index], fn) +#define CALL_GetObjectParameterivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLenum, GLint *)), driDispatchRemapTable[GetObjectParameterivARB_remap_index], parameters) +#define GET_GetObjectParameterivARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetObjectParameterivARB_remap_index]) +#define SET_GetObjectParameterivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetObjectParameterivARB_remap_index], fn) +#define CALL_GetInfoLogARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLsizei, GLsizei *, GLcharARB *)), driDispatchRemapTable[GetInfoLogARB_remap_index], parameters) +#define GET_GetInfoLogARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetInfoLogARB_remap_index]) +#define SET_GetInfoLogARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetInfoLogARB_remap_index], fn) +#define CALL_GetAttachedObjectsARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLsizei, GLsizei *, GLhandleARB *)), driDispatchRemapTable[GetAttachedObjectsARB_remap_index], parameters) +#define GET_GetAttachedObjectsARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetAttachedObjectsARB_remap_index]) +#define SET_GetAttachedObjectsARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetAttachedObjectsARB_remap_index], fn) +#define CALL_GetUniformLocationARB(disp, parameters) CALL_by_offset(disp, (GLint (GLAPIENTRYP)(GLhandleARB, const GLcharARB *)), driDispatchRemapTable[GetUniformLocationARB_remap_index], parameters) +#define GET_GetUniformLocationARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetUniformLocationARB_remap_index]) +#define SET_GetUniformLocationARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetUniformLocationARB_remap_index], fn) +#define CALL_GetActiveUniformARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLcharARB *)), driDispatchRemapTable[GetActiveUniformARB_remap_index], parameters) +#define GET_GetActiveUniformARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetActiveUniformARB_remap_index]) +#define SET_GetActiveUniformARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetActiveUniformARB_remap_index], fn) +#define CALL_GetUniformfvARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLint, GLfloat *)), driDispatchRemapTable[GetUniformfvARB_remap_index], parameters) +#define GET_GetUniformfvARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetUniformfvARB_remap_index]) +#define SET_GetUniformfvARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetUniformfvARB_remap_index], fn) +#define CALL_GetUniformivARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLint, GLint *)), driDispatchRemapTable[GetUniformivARB_remap_index], parameters) +#define GET_GetUniformivARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetUniformivARB_remap_index]) +#define SET_GetUniformivARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetUniformivARB_remap_index], fn) +#define CALL_GetShaderSourceARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLsizei, GLsizei *, GLcharARB *)), driDispatchRemapTable[GetShaderSourceARB_remap_index], parameters) +#define GET_GetShaderSourceARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetShaderSourceARB_remap_index]) +#define SET_GetShaderSourceARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetShaderSourceARB_remap_index], fn) +#define CALL_BindAttribLocationARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLuint, const GLcharARB *)), driDispatchRemapTable[BindAttribLocationARB_remap_index], parameters) +#define GET_BindAttribLocationARB(disp) GET_by_offset(disp, driDispatchRemapTable[BindAttribLocationARB_remap_index]) +#define SET_BindAttribLocationARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BindAttribLocationARB_remap_index], fn) +#define CALL_GetActiveAttribARB(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLhandleARB, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLcharARB *)), driDispatchRemapTable[GetActiveAttribARB_remap_index], parameters) +#define GET_GetActiveAttribARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetActiveAttribARB_remap_index]) +#define SET_GetActiveAttribARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetActiveAttribARB_remap_index], fn) +#define CALL_GetAttribLocationARB(disp, parameters) CALL_by_offset(disp, (GLint (GLAPIENTRYP)(GLhandleARB, const GLcharARB *)), driDispatchRemapTable[GetAttribLocationARB_remap_index], parameters) +#define GET_GetAttribLocationARB(disp) GET_by_offset(disp, driDispatchRemapTable[GetAttribLocationARB_remap_index]) +#define SET_GetAttribLocationARB(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetAttribLocationARB_remap_index], fn) +#define CALL_GetVertexAttribdvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLdouble *)), driDispatchRemapTable[GetVertexAttribdvNV_remap_index], parameters) +#define GET_GetVertexAttribdvNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetVertexAttribdvNV_remap_index]) +#define SET_GetVertexAttribdvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetVertexAttribdvNV_remap_index], fn) +#define CALL_GetVertexAttribfvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLfloat *)), driDispatchRemapTable[GetVertexAttribfvNV_remap_index], parameters) +#define GET_GetVertexAttribfvNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetVertexAttribfvNV_remap_index]) +#define SET_GetVertexAttribfvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetVertexAttribfvNV_remap_index], fn) +#define CALL_GetVertexAttribivNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLenum, GLint *)), driDispatchRemapTable[GetVertexAttribivNV_remap_index], parameters) +#define GET_GetVertexAttribivNV(disp) GET_by_offset(disp, driDispatchRemapTable[GetVertexAttribivNV_remap_index]) +#define SET_GetVertexAttribivNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetVertexAttribivNV_remap_index], fn) +#define CALL_VertexAttrib1dNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLdouble)), driDispatchRemapTable[VertexAttrib1dNV_remap_index], parameters) +#define GET_VertexAttrib1dNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1dNV_remap_index]) +#define SET_VertexAttrib1dNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1dNV_remap_index], fn) +#define CALL_VertexAttrib1dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLdouble *)), driDispatchRemapTable[VertexAttrib1dvNV_remap_index], parameters) +#define GET_VertexAttrib1dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1dvNV_remap_index]) +#define SET_VertexAttrib1dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1dvNV_remap_index], fn) +#define CALL_VertexAttrib1fNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat)), driDispatchRemapTable[VertexAttrib1fNV_remap_index], parameters) +#define GET_VertexAttrib1fNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1fNV_remap_index]) +#define SET_VertexAttrib1fNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1fNV_remap_index], fn) +#define CALL_VertexAttrib1fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), driDispatchRemapTable[VertexAttrib1fvNV_remap_index], parameters) +#define GET_VertexAttrib1fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1fvNV_remap_index]) +#define SET_VertexAttrib1fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1fvNV_remap_index], fn) +#define CALL_VertexAttrib1sNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLshort)), driDispatchRemapTable[VertexAttrib1sNV_remap_index], parameters) +#define GET_VertexAttrib1sNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1sNV_remap_index]) +#define SET_VertexAttrib1sNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1sNV_remap_index], fn) +#define CALL_VertexAttrib1svNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLshort *)), driDispatchRemapTable[VertexAttrib1svNV_remap_index], parameters) +#define GET_VertexAttrib1svNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib1svNV_remap_index]) +#define SET_VertexAttrib1svNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib1svNV_remap_index], fn) +#define CALL_VertexAttrib2dNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLdouble, GLdouble)), driDispatchRemapTable[VertexAttrib2dNV_remap_index], parameters) +#define GET_VertexAttrib2dNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2dNV_remap_index]) +#define SET_VertexAttrib2dNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2dNV_remap_index], fn) +#define CALL_VertexAttrib2dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLdouble *)), driDispatchRemapTable[VertexAttrib2dvNV_remap_index], parameters) +#define GET_VertexAttrib2dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2dvNV_remap_index]) +#define SET_VertexAttrib2dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2dvNV_remap_index], fn) +#define CALL_VertexAttrib2fNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat, GLfloat)), driDispatchRemapTable[VertexAttrib2fNV_remap_index], parameters) +#define GET_VertexAttrib2fNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2fNV_remap_index]) +#define SET_VertexAttrib2fNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2fNV_remap_index], fn) +#define CALL_VertexAttrib2fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), driDispatchRemapTable[VertexAttrib2fvNV_remap_index], parameters) +#define GET_VertexAttrib2fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2fvNV_remap_index]) +#define SET_VertexAttrib2fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2fvNV_remap_index], fn) +#define CALL_VertexAttrib2sNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLshort, GLshort)), driDispatchRemapTable[VertexAttrib2sNV_remap_index], parameters) +#define GET_VertexAttrib2sNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2sNV_remap_index]) +#define SET_VertexAttrib2sNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2sNV_remap_index], fn) +#define CALL_VertexAttrib2svNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLshort *)), driDispatchRemapTable[VertexAttrib2svNV_remap_index], parameters) +#define GET_VertexAttrib2svNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib2svNV_remap_index]) +#define SET_VertexAttrib2svNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib2svNV_remap_index], fn) +#define CALL_VertexAttrib3dNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[VertexAttrib3dNV_remap_index], parameters) +#define GET_VertexAttrib3dNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3dNV_remap_index]) +#define SET_VertexAttrib3dNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3dNV_remap_index], fn) +#define CALL_VertexAttrib3dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLdouble *)), driDispatchRemapTable[VertexAttrib3dvNV_remap_index], parameters) +#define GET_VertexAttrib3dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3dvNV_remap_index]) +#define SET_VertexAttrib3dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3dvNV_remap_index], fn) +#define CALL_VertexAttrib3fNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[VertexAttrib3fNV_remap_index], parameters) +#define GET_VertexAttrib3fNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3fNV_remap_index]) +#define SET_VertexAttrib3fNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3fNV_remap_index], fn) +#define CALL_VertexAttrib3fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), driDispatchRemapTable[VertexAttrib3fvNV_remap_index], parameters) +#define GET_VertexAttrib3fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3fvNV_remap_index]) +#define SET_VertexAttrib3fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3fvNV_remap_index], fn) +#define CALL_VertexAttrib3sNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLshort, GLshort, GLshort)), driDispatchRemapTable[VertexAttrib3sNV_remap_index], parameters) +#define GET_VertexAttrib3sNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3sNV_remap_index]) +#define SET_VertexAttrib3sNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3sNV_remap_index], fn) +#define CALL_VertexAttrib3svNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLshort *)), driDispatchRemapTable[VertexAttrib3svNV_remap_index], parameters) +#define GET_VertexAttrib3svNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib3svNV_remap_index]) +#define SET_VertexAttrib3svNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib3svNV_remap_index], fn) +#define CALL_VertexAttrib4dNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLdouble, GLdouble, GLdouble, GLdouble)), driDispatchRemapTable[VertexAttrib4dNV_remap_index], parameters) +#define GET_VertexAttrib4dNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4dNV_remap_index]) +#define SET_VertexAttrib4dNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4dNV_remap_index], fn) +#define CALL_VertexAttrib4dvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLdouble *)), driDispatchRemapTable[VertexAttrib4dvNV_remap_index], parameters) +#define GET_VertexAttrib4dvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4dvNV_remap_index]) +#define SET_VertexAttrib4dvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4dvNV_remap_index], fn) +#define CALL_VertexAttrib4fNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLfloat, GLfloat, GLfloat, GLfloat)), driDispatchRemapTable[VertexAttrib4fNV_remap_index], parameters) +#define GET_VertexAttrib4fNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4fNV_remap_index]) +#define SET_VertexAttrib4fNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4fNV_remap_index], fn) +#define CALL_VertexAttrib4fvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), driDispatchRemapTable[VertexAttrib4fvNV_remap_index], parameters) +#define GET_VertexAttrib4fvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4fvNV_remap_index]) +#define SET_VertexAttrib4fvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4fvNV_remap_index], fn) +#define CALL_VertexAttrib4sNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLshort, GLshort, GLshort, GLshort)), driDispatchRemapTable[VertexAttrib4sNV_remap_index], parameters) +#define GET_VertexAttrib4sNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4sNV_remap_index]) +#define SET_VertexAttrib4sNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4sNV_remap_index], fn) +#define CALL_VertexAttrib4svNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLshort *)), driDispatchRemapTable[VertexAttrib4svNV_remap_index], parameters) +#define GET_VertexAttrib4svNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4svNV_remap_index]) +#define SET_VertexAttrib4svNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4svNV_remap_index], fn) +#define CALL_VertexAttrib4ubNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLubyte, GLubyte, GLubyte, GLubyte)), driDispatchRemapTable[VertexAttrib4ubNV_remap_index], parameters) +#define GET_VertexAttrib4ubNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4ubNV_remap_index]) +#define SET_VertexAttrib4ubNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4ubNV_remap_index], fn) +#define CALL_VertexAttrib4ubvNV(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLubyte *)), driDispatchRemapTable[VertexAttrib4ubvNV_remap_index], parameters) +#define GET_VertexAttrib4ubvNV(disp) GET_by_offset(disp, driDispatchRemapTable[VertexAttrib4ubvNV_remap_index]) +#define SET_VertexAttrib4ubvNV(disp, fn) SET_by_offset(disp, driDispatchRemapTable[VertexAttrib4ubvNV_remap_index], fn) +#define CALL_GenFragmentShadersATI(disp, parameters) CALL_by_offset(disp, (GLuint (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[GenFragmentShadersATI_remap_index], parameters) +#define GET_GenFragmentShadersATI(disp) GET_by_offset(disp, driDispatchRemapTable[GenFragmentShadersATI_remap_index]) +#define SET_GenFragmentShadersATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GenFragmentShadersATI_remap_index], fn) +#define CALL_BindFragmentShaderATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[BindFragmentShaderATI_remap_index], parameters) +#define GET_BindFragmentShaderATI(disp) GET_by_offset(disp, driDispatchRemapTable[BindFragmentShaderATI_remap_index]) +#define SET_BindFragmentShaderATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BindFragmentShaderATI_remap_index], fn) +#define CALL_DeleteFragmentShaderATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[DeleteFragmentShaderATI_remap_index], parameters) +#define GET_DeleteFragmentShaderATI(disp) GET_by_offset(disp, driDispatchRemapTable[DeleteFragmentShaderATI_remap_index]) +#define SET_DeleteFragmentShaderATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DeleteFragmentShaderATI_remap_index], fn) +#define CALL_BeginFragmentShaderATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), driDispatchRemapTable[BeginFragmentShaderATI_remap_index], parameters) +#define GET_BeginFragmentShaderATI(disp) GET_by_offset(disp, driDispatchRemapTable[BeginFragmentShaderATI_remap_index]) +#define SET_BeginFragmentShaderATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BeginFragmentShaderATI_remap_index], fn) +#define CALL_EndFragmentShaderATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(void)), driDispatchRemapTable[EndFragmentShaderATI_remap_index], parameters) +#define GET_EndFragmentShaderATI(disp) GET_by_offset(disp, driDispatchRemapTable[EndFragmentShaderATI_remap_index]) +#define SET_EndFragmentShaderATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[EndFragmentShaderATI_remap_index], fn) +#define CALL_PassTexCoordATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint, GLenum)), driDispatchRemapTable[PassTexCoordATI_remap_index], parameters) +#define GET_PassTexCoordATI(disp) GET_by_offset(disp, driDispatchRemapTable[PassTexCoordATI_remap_index]) +#define SET_PassTexCoordATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[PassTexCoordATI_remap_index], fn) +#define CALL_SampleMapATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, GLuint, GLenum)), driDispatchRemapTable[SampleMapATI_remap_index], parameters) +#define GET_SampleMapATI(disp) GET_by_offset(disp, driDispatchRemapTable[SampleMapATI_remap_index]) +#define SET_SampleMapATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SampleMapATI_remap_index], fn) +#define CALL_ColorFragmentOp1ATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint)), driDispatchRemapTable[ColorFragmentOp1ATI_remap_index], parameters) +#define GET_ColorFragmentOp1ATI(disp) GET_by_offset(disp, driDispatchRemapTable[ColorFragmentOp1ATI_remap_index]) +#define SET_ColorFragmentOp1ATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ColorFragmentOp1ATI_remap_index], fn) +#define CALL_ColorFragmentOp2ATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint)), driDispatchRemapTable[ColorFragmentOp2ATI_remap_index], parameters) +#define GET_ColorFragmentOp2ATI(disp) GET_by_offset(disp, driDispatchRemapTable[ColorFragmentOp2ATI_remap_index]) +#define SET_ColorFragmentOp2ATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ColorFragmentOp2ATI_remap_index], fn) +#define CALL_ColorFragmentOp3ATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint)), driDispatchRemapTable[ColorFragmentOp3ATI_remap_index], parameters) +#define GET_ColorFragmentOp3ATI(disp) GET_by_offset(disp, driDispatchRemapTable[ColorFragmentOp3ATI_remap_index]) +#define SET_ColorFragmentOp3ATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[ColorFragmentOp3ATI_remap_index], fn) +#define CALL_AlphaFragmentOp1ATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, GLuint, GLuint, GLuint)), driDispatchRemapTable[AlphaFragmentOp1ATI_remap_index], parameters) +#define GET_AlphaFragmentOp1ATI(disp) GET_by_offset(disp, driDispatchRemapTable[AlphaFragmentOp1ATI_remap_index]) +#define SET_AlphaFragmentOp1ATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[AlphaFragmentOp1ATI_remap_index], fn) +#define CALL_AlphaFragmentOp2ATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint)), driDispatchRemapTable[AlphaFragmentOp2ATI_remap_index], parameters) +#define GET_AlphaFragmentOp2ATI(disp) GET_by_offset(disp, driDispatchRemapTable[AlphaFragmentOp2ATI_remap_index]) +#define SET_AlphaFragmentOp2ATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[AlphaFragmentOp2ATI_remap_index], fn) +#define CALL_AlphaFragmentOp3ATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint)), driDispatchRemapTable[AlphaFragmentOp3ATI_remap_index], parameters) +#define GET_AlphaFragmentOp3ATI(disp) GET_by_offset(disp, driDispatchRemapTable[AlphaFragmentOp3ATI_remap_index]) +#define SET_AlphaFragmentOp3ATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[AlphaFragmentOp3ATI_remap_index], fn) +#define CALL_SetFragmentShaderConstantATI(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLuint, const GLfloat *)), driDispatchRemapTable[SetFragmentShaderConstantATI_remap_index], parameters) +#define GET_SetFragmentShaderConstantATI(disp) GET_by_offset(disp, driDispatchRemapTable[SetFragmentShaderConstantATI_remap_index]) +#define SET_SetFragmentShaderConstantATI(disp, fn) SET_by_offset(disp, driDispatchRemapTable[SetFragmentShaderConstantATI_remap_index], fn) +#define CALL_IsRenderbufferEXT(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[IsRenderbufferEXT_remap_index], parameters) +#define GET_IsRenderbufferEXT(disp) GET_by_offset(disp, driDispatchRemapTable[IsRenderbufferEXT_remap_index]) +#define SET_IsRenderbufferEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IsRenderbufferEXT_remap_index], fn) +#define CALL_BindRenderbufferEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), driDispatchRemapTable[BindRenderbufferEXT_remap_index], parameters) +#define GET_BindRenderbufferEXT(disp) GET_by_offset(disp, driDispatchRemapTable[BindRenderbufferEXT_remap_index]) +#define SET_BindRenderbufferEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BindRenderbufferEXT_remap_index], fn) +#define CALL_DeleteRenderbuffersEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), driDispatchRemapTable[DeleteRenderbuffersEXT_remap_index], parameters) +#define GET_DeleteRenderbuffersEXT(disp) GET_by_offset(disp, driDispatchRemapTable[DeleteRenderbuffersEXT_remap_index]) +#define SET_DeleteRenderbuffersEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DeleteRenderbuffersEXT_remap_index], fn) +#define CALL_GenRenderbuffersEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), driDispatchRemapTable[GenRenderbuffersEXT_remap_index], parameters) +#define GET_GenRenderbuffersEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GenRenderbuffersEXT_remap_index]) +#define SET_GenRenderbuffersEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GenRenderbuffersEXT_remap_index], fn) +#define CALL_RenderbufferStorageEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLsizei, GLsizei)), driDispatchRemapTable[RenderbufferStorageEXT_remap_index], parameters) +#define GET_RenderbufferStorageEXT(disp) GET_by_offset(disp, driDispatchRemapTable[RenderbufferStorageEXT_remap_index]) +#define SET_RenderbufferStorageEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[RenderbufferStorageEXT_remap_index], fn) +#define CALL_GetRenderbufferParameterivEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint *)), driDispatchRemapTable[GetRenderbufferParameterivEXT_remap_index], parameters) +#define GET_GetRenderbufferParameterivEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetRenderbufferParameterivEXT_remap_index]) +#define SET_GetRenderbufferParameterivEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetRenderbufferParameterivEXT_remap_index], fn) +#define CALL_IsFramebufferEXT(disp, parameters) CALL_by_offset(disp, (GLboolean (GLAPIENTRYP)(GLuint)), driDispatchRemapTable[IsFramebufferEXT_remap_index], parameters) +#define GET_IsFramebufferEXT(disp) GET_by_offset(disp, driDispatchRemapTable[IsFramebufferEXT_remap_index]) +#define SET_IsFramebufferEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[IsFramebufferEXT_remap_index], fn) +#define CALL_BindFramebufferEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), driDispatchRemapTable[BindFramebufferEXT_remap_index], parameters) +#define GET_BindFramebufferEXT(disp) GET_by_offset(disp, driDispatchRemapTable[BindFramebufferEXT_remap_index]) +#define SET_BindFramebufferEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[BindFramebufferEXT_remap_index], fn) +#define CALL_DeleteFramebuffersEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, const GLuint *)), driDispatchRemapTable[DeleteFramebuffersEXT_remap_index], parameters) +#define GET_DeleteFramebuffersEXT(disp) GET_by_offset(disp, driDispatchRemapTable[DeleteFramebuffersEXT_remap_index]) +#define SET_DeleteFramebuffersEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[DeleteFramebuffersEXT_remap_index], fn) +#define CALL_GenFramebuffersEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLsizei, GLuint *)), driDispatchRemapTable[GenFramebuffersEXT_remap_index], parameters) +#define GET_GenFramebuffersEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GenFramebuffersEXT_remap_index]) +#define SET_GenFramebuffersEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GenFramebuffersEXT_remap_index], fn) +#define CALL_CheckFramebufferStatusEXT(disp, parameters) CALL_by_offset(disp, (GLenum (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[CheckFramebufferStatusEXT_remap_index], parameters) +#define GET_CheckFramebufferStatusEXT(disp) GET_by_offset(disp, driDispatchRemapTable[CheckFramebufferStatusEXT_remap_index]) +#define SET_CheckFramebufferStatusEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[CheckFramebufferStatusEXT_remap_index], fn) +#define CALL_FramebufferTexture1DEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLuint, GLint)), driDispatchRemapTable[FramebufferTexture1DEXT_remap_index], parameters) +#define GET_FramebufferTexture1DEXT(disp) GET_by_offset(disp, driDispatchRemapTable[FramebufferTexture1DEXT_remap_index]) +#define SET_FramebufferTexture1DEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FramebufferTexture1DEXT_remap_index], fn) +#define CALL_FramebufferTexture2DEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLuint, GLint)), driDispatchRemapTable[FramebufferTexture2DEXT_remap_index], parameters) +#define GET_FramebufferTexture2DEXT(disp) GET_by_offset(disp, driDispatchRemapTable[FramebufferTexture2DEXT_remap_index]) +#define SET_FramebufferTexture2DEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FramebufferTexture2DEXT_remap_index], fn) +#define CALL_FramebufferTexture3DEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLuint, GLint, GLint)), driDispatchRemapTable[FramebufferTexture3DEXT_remap_index], parameters) +#define GET_FramebufferTexture3DEXT(disp) GET_by_offset(disp, driDispatchRemapTable[FramebufferTexture3DEXT_remap_index]) +#define SET_FramebufferTexture3DEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FramebufferTexture3DEXT_remap_index], fn) +#define CALL_FramebufferRenderbufferEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLuint)), driDispatchRemapTable[FramebufferRenderbufferEXT_remap_index], parameters) +#define GET_FramebufferRenderbufferEXT(disp) GET_by_offset(disp, driDispatchRemapTable[FramebufferRenderbufferEXT_remap_index]) +#define SET_FramebufferRenderbufferEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[FramebufferRenderbufferEXT_remap_index], fn) +#define CALL_GetFramebufferAttachmentParameterivEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLint *)), driDispatchRemapTable[GetFramebufferAttachmentParameterivEXT_remap_index], parameters) +#define GET_GetFramebufferAttachmentParameterivEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GetFramebufferAttachmentParameterivEXT_remap_index]) +#define SET_GetFramebufferAttachmentParameterivEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GetFramebufferAttachmentParameterivEXT_remap_index], fn) +#define CALL_GenerateMipmapEXT(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum)), driDispatchRemapTable[GenerateMipmapEXT_remap_index], parameters) +#define GET_GenerateMipmapEXT(disp) GET_by_offset(disp, driDispatchRemapTable[GenerateMipmapEXT_remap_index]) +#define SET_GenerateMipmapEXT(disp, fn) SET_by_offset(disp, driDispatchRemapTable[GenerateMipmapEXT_remap_index], fn) +#define CALL_StencilFuncSeparate(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLint, GLuint)), driDispatchRemapTable[StencilFuncSeparate_remap_index], parameters) +#define GET_StencilFuncSeparate(disp) GET_by_offset(disp, driDispatchRemapTable[StencilFuncSeparate_remap_index]) +#define SET_StencilFuncSeparate(disp, fn) SET_by_offset(disp, driDispatchRemapTable[StencilFuncSeparate_remap_index], fn) +#define CALL_StencilOpSeparate(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLenum, GLenum, GLenum)), driDispatchRemapTable[StencilOpSeparate_remap_index], parameters) +#define GET_StencilOpSeparate(disp) GET_by_offset(disp, driDispatchRemapTable[StencilOpSeparate_remap_index]) +#define SET_StencilOpSeparate(disp, fn) SET_by_offset(disp, driDispatchRemapTable[StencilOpSeparate_remap_index], fn) +#define CALL_StencilMaskSeparate(disp, parameters) CALL_by_offset(disp, (void (GLAPIENTRYP)(GLenum, GLuint)), driDispatchRemapTable[StencilMaskSeparate_remap_index], parameters) +#define GET_StencilMaskSeparate(disp) GET_by_offset(disp, driDispatchRemapTable[StencilMaskSeparate_remap_index]) +#define SET_StencilMaskSeparate(disp, fn) SET_by_offset(disp, driDispatchRemapTable[StencilMaskSeparate_remap_index], fn) + +#endif /* !defined(IN_DRI_DRIVER) */ + #endif /* !defined( _DISPATCH_H_ ) */ diff --git a/src/mesa/glapi/extension_helper.py b/src/mesa/glapi/extension_helper.py index 21f5b56fbbd..a2a16a8b364 100644 --- a/src/mesa/glapi/extension_helper.py +++ b/src/mesa/glapi/extension_helper.py @@ -102,6 +102,24 @@ vtxfmt = [ "EvalMesh2", \ ] +def all_entrypoints_in_abi(f, abi, api): + for n in f.entry_points: + [category, num] = api.get_category_for_name( n ) + if category not in abi: + return 0 + + return 1 + + +def any_entrypoints_in_abi(f, abi, api): + for n in f.entry_points: + [category, num] = api.get_category_for_name( n ) + if category in abi: + return 1 + + return 0 + + def condition_for_function(f, abi, all_not_in_ABI): """Create a C-preprocessor condition for the function. @@ -133,6 +151,7 @@ class PrintGlExtensionGlue(gl_XML.gl_print_base): def printRealHeader(self): print '#include "utils.h"' + print '#include "dispatch.h"' print '' return @@ -178,7 +197,7 @@ class PrintGlExtensionGlue(gl_XML.gl_print_base): if not category_list.has_key(c): category_list[ c ] = [] - category_list[ c ].append( [f.name, f.offset] ) + category_list[ c ].append( f ) print ' "";' print '#endif' @@ -190,9 +209,17 @@ class PrintGlExtensionGlue(gl_XML.gl_print_base): for category in keys: print '#if defined(need_%s)' % (category) print 'static const struct dri_extension_function %s_functions[] = {' % (category) - for [function, offset] in category_list[ category ]: - print ' { %s_names, %d },' % (function, offset) - print ' { NULL, 0 }' + + for f in category_list[ category ]: + if any_entrypoints_in_abi(f, abi, api): + index_name = "-1" + else: + index_name = "%s_remap_index" % (f.name) + + print ' { %s_names, %s, %d },' % (f.name, index_name, f.offset) + + + print ' { NULL, 0, 0 }' print '};' print '#endif' print '' diff --git a/src/mesa/glapi/gl_offsets.py b/src/mesa/glapi/gl_offsets.py index dfd7fda9d77..6f6be2069c2 100644 --- a/src/mesa/glapi/gl_offsets.py +++ b/src/mesa/glapi/gl_offsets.py @@ -41,8 +41,14 @@ class PrintGlOffsets(gl_XML.gl_print_base): return def printBody(self, api): + last_static = 0 for f in api.functionIterateByOffset(): print '#define _gloffset_%s %d' % (f.name, f.offset) + if f.offset > last_static: + last_static = f.offset + + print '#define _gloffset_FIRST_DYNAMIC %d' % (last_static + 1) + return def show_usage(): diff --git a/src/mesa/glapi/gl_table.py b/src/mesa/glapi/gl_table.py index d585b43cde5..864ac8a8c3e 100644 --- a/src/mesa/glapi/gl_table.py +++ b/src/mesa/glapi/gl_table.py @@ -52,6 +52,8 @@ class PrintGlTable(gl_XML.gl_print_base): print '#define GLAPIENTRYP' print '#endif' print '' + print 'typedef void (*_glapi_proc)(void); /* generic function pointer */' + print '' print 'struct _glapi_table' print '{' return @@ -93,15 +95,9 @@ class PrintRemapTable(gl_XML.gl_print_base): print '#define GET_by_offset(disp, offset) \\' print ' (((_glapi_proc *)(disp))[offset])' print '#define SET_by_offset(disp, offset, fn) \\' - print ' ((((_glapi_proc *)(disp))[offset]) = fn)' + print ' ((((_glapi_proc *)(disp))[offset]) = (_glapi_proc) fn)' print '' - for f in api.functionIterateByOffset(): - print '#define CALL_%s(disp, parameters) (*((disp)->%s)) parameters' % (f.name, f.name) - print '#define GET_%s(disp) ((disp)->%s)' % (f.name, f.name) - print '#define SET_%s(disp, fn) ((disp)->%s = fn)' % (f.name, f.name) - return - abi = [ "1.0", "1.1", "1.2", "GL_ARB_multitexture" ] functions = [] @@ -116,26 +112,44 @@ class PrintRemapTable(gl_XML.gl_print_base): abi_functions.append( f ) - print 'struct _mesa_dispatch_remap_table {' + for f in abi_functions: + print '#define CALL_%s(disp, parameters) (*((disp)->%s)) parameters' % (f.name, f.name) + print '#define GET_%s(disp) ((disp)->%s)' % (f.name, f.name) + print '#define SET_%s(disp, fn) ((disp)->%s = fn)' % (f.name, f.name) + + + print '' + print '#if !defined(IN_DRI_DRIVER)' + print '' for [f, index] in functions: - print ' unsigned %s;' % (f.name) + print '#define CALL_%s(disp, parameters) (*((disp)->%s)) parameters' % (f.name, f.name) + print '#define GET_%s(disp) ((disp)->%s)' % (f.name, f.name) + print '#define SET_%s(disp, fn) ((disp)->%s = fn)' % (f.name, f.name) - print '};' print '' - print '/* %u functions need remapping. */' % (count) + print '#else' + print '' + print '#define driDispatchRemapTable_size %u' % (count) + print 'extern unsigned driDispatchRemapTable[ driDispatchRemapTable_size ];' print '' - for f in abi_functions: - print '#define CALL_%s(disp, parameters) (*disp->%s) parameters' % (f.name, f.name) + for [f, index] in functions: + print '#define %s_remap_index %u' % (f.name, index) + print '' for [f, index] in functions: arg_string = gl_XML.create_parameter_string( f.parameters, 0 ) cast = '%s (GLAPIENTRYP)(%s)' % (f.return_type, arg_string) - print '#define CALL_%s(disp, parameters) (* (%s) (((_glapi_proc *)disp)[dispatch_remap.%s])) parameters' % (f.name, cast, f.name) + print '#define CALL_%s(disp, parameters) CALL_by_offset(disp, (%s), driDispatchRemapTable[%s_remap_index], parameters)' % (f.name, cast, f.name) + print '#define GET_%s(disp) GET_by_offset(disp, driDispatchRemapTable[%s_remap_index])' % (f.name, f.name) + print '#define SET_%s(disp, fn) SET_by_offset(disp, driDispatchRemapTable[%s_remap_index], fn)' % (f.name, f.name) + + print '' + print '#endif /* !defined(IN_DRI_DRIVER) */' return diff --git a/src/mesa/glapi/glapi.c b/src/mesa/glapi/glapi.c index 5132bebaef5..47a1f164582 100644 --- a/src/mesa/glapi/glapi.c +++ b/src/mesa/glapi/glapi.c @@ -671,14 +671,52 @@ get_static_proc_name( GLuint offset ) #define DISPATCH_TABLE_SIZE (sizeof(struct _glapi_table) / sizeof(void *) + MAX_EXTENSION_FUNCS) -struct name_address_offset { - const char *Name; - _glapi_proc Address; - GLuint Offset; +/** + * Track information about a function added to the GL API. + */ +struct _glapi_function { + /** + * Name of the function. + */ + const char * name; + + + /** + * Text string that describes the types of the parameters passed to the + * named function. Parameter types are converted to characters using the + * following rules: + * - 'i' for \c GLint, \c GLuint, and \c GLenum + * - 'p' for any pointer type + * - 'f' for \c GLfloat and \c GLclampf + * - 'd' for \c GLdouble and \c GLclampd + */ + const char * parameter_signature; + + + /** + * Offset in the dispatch table where the pointer to the real function is + * located. If the driver has not requested that the named function be + * added to the dispatch table, this will have the value ~0. + */ + unsigned dispatch_offset; + + + /** + * Pointer to the dispatch stub for the named function. + * + * \todo + * The semantic of this field should be changed slightly. Currently, it + * is always expected to be non-\c NULL. However, it would be better to + * only allocate the entry-point stub when the application requests the + * function via \c glXGetProcAddress. This would save memory for all the + * functions that the driver exports but that the application never wants + * to call. + */ + _glapi_proc dispatch_stub; }; -static struct name_address_offset ExtEntryTable[MAX_EXTENSION_FUNCS]; +static struct _glapi_function ExtEntryTable[MAX_EXTENSION_FUNCS]; static GLuint NumExtEntryPoints = 0; #ifdef USE_SPARC_ASM @@ -814,76 +852,189 @@ fill_in_entrypoint_offset(_glapi_proc entrypoint, GLuint offset) /** - * Add a new extension function entrypoint. - * Return: GL_TRUE = success or GL_FALSE = failure + * Generate new entrypoint + * + * Use a temporary dispatch offset of ~0 (i.e. -1). Later, when the driver + * calls \c _glapi_add_dispatch we'll put in the proper offset. If that + * never happens, and the user calls this function, he'll segfault. That's + * what you get when you try calling a GL function that doesn't really exist. + * + * \param funcName Name of the function to create an entry-point for. + * + * \sa _glapi_add_entrypoint */ -PUBLIC GLboolean -_glapi_add_entrypoint(const char *funcName, GLuint offset) + +static struct _glapi_function * +add_function_name( const char * funcName ) { - /* trivial rejection test */ + struct _glapi_function * entry = NULL; + + if (NumExtEntryPoints < MAX_EXTENSION_FUNCS) { + _glapi_proc entrypoint = generate_entrypoint(~0); + if (entrypoint != NULL) { + entry = & ExtEntryTable[NumExtEntryPoints]; + + ExtEntryTable[NumExtEntryPoints].name = str_dup(funcName); + ExtEntryTable[NumExtEntryPoints].parameter_signature = NULL; + ExtEntryTable[NumExtEntryPoints].dispatch_offset = ~0; + ExtEntryTable[NumExtEntryPoints].dispatch_stub = entrypoint; + NumExtEntryPoints++; + } + } + + return entry; +} + + +/** + * Fill-in the dispatch stub for the named function. + * + * This function is intended to be called by a hardware driver. When called, + * a dispatch stub may be created created for the function. A pointer to this + * dispatch function will be returned by glXGetProcAddress. + * + * \param function_names Array of pointers to function names that should + * share a common dispatch offset. + * \param parameter_signature String representing the types of the parameters + * passed to the named function. Parameter types + * are converted to characters using the following + * rules: + * - 'i' for \c GLint, \c GLuint, and \c GLenum + * - 'p' for any pointer type + * - 'f' for \c GLfloat and \c GLclampf + * - 'd' for \c GLdouble and \c GLclampd + * + * \returns + * The offset in the dispatch table of the named function. A pointer to the + * driver's implementation of the named function should be stored at + * \c dispatch_table[\c offset]. + * + * \sa glXGetProcAddress + * + * \warning + * This function can only handle up to 8 names at a time. As far as I know, + * the maximum number of names ever associated with an existing GL function is + * 4 (\c glPointParameterfSGIS, \c glPointParameterfEXT, + * \c glPointParameterfARB, and \c glPointParameterf), so this should not be + * too painful of a limitation. + * + * \todo + * Determine whether or not \c parameter_signature should be allowed to be + * \c NULL. It doesn't seem like much of a hardship for drivers to have to + * pass in an empty string. + * + * \todo + * Determine if code should be added to reject function names that start with + * 'glX'. + * + * \bug + * Add code to compare \c parameter_signature with the parameter signature of + * a static function. In order to do that, we need to find a way to \b get + * the parameter signature of a static function. + */ + +PUBLIC int +_glapi_add_dispatch( const char * const * function_names, + const char * parameter_signature ) +{ + static int next_dynamic_offset = _gloffset_FIRST_DYNAMIC; + const char * const real_sig = (parameter_signature != NULL) + ? parameter_signature : ""; + struct _glapi_function * entry[8]; + GLboolean is_static[8]; + unsigned i; + unsigned j; + int offset = ~0; + int new_offset; + + + (void) memset( is_static, 0, sizeof( is_static ) ); + (void) memset( entry, 0, sizeof( entry ) ); + + for ( i = 0 ; function_names[i] != NULL ; i++ ) { + /* Do some trivial validation on the name of the function. + */ + #ifdef MANGLE - if (!funcName || funcName[0] != 'm' || funcName[1] != 'g' || funcName[2] != 'l') - return GL_FALSE; + if (!function_names[i] || function_names[i][0] != 'm' || function_names[i][1] != 'g' || function_names[i][2] != 'l') + return GL_FALSE; #else - if (!funcName || funcName[0] != 'g' || funcName[1] != 'l') - return GL_FALSE; + if (!function_names[i] || function_names[i][0] != 'g' || function_names[i][1] != 'l') + return GL_FALSE; #endif - - /* first check if the named function is already statically present */ - { - GLint index = get_static_proc_offset(funcName); - if (index >= 0) { - return (GLboolean) ((GLuint) index == offset); /* bad offset! */ + + + /* Determine if the named function already exists. If the function does + * exist, it must have the same parameter signature as the function + * being added. + */ + + new_offset = get_static_proc_offset(function_names[i]); + if (new_offset >= 0) { + /* FIXME: Make sure the parameter signatures match! How do we get + * FIXME: the parameter signature for static functions? + */ + + if ( (offset != ~0) && (new_offset != offset) ) { + return -1; + } + + is_static[i] = GL_TRUE; + offset = new_offset; } - } - - /* See if this function has already been dynamically added */ - { - GLuint i; - for (i = 0; i < NumExtEntryPoints; i++) { - if (strcmp(ExtEntryTable[i].Name, funcName) == 0) { - /* function already registered */ - if (ExtEntryTable[i].Offset == offset) { - return GL_TRUE; /* offsets match */ - } - else if (ExtEntryTable[i].Offset == (GLuint) ~0 - && offset < DISPATCH_TABLE_SIZE) { - /* need to patch-up the dispatch code */ - if (offset != (GLuint) ~0) { - fill_in_entrypoint_offset(ExtEntryTable[i].Address, offset); - ExtEntryTable[i].Offset = offset; - } - return GL_TRUE; - } - else { - return GL_FALSE; /* bad offset! */ - } - } + + + for ( j = 0 ; j < NumExtEntryPoints ; j++ ) { + if (strcmp(ExtEntryTable[j].name, function_names[i]) == 0) { + /* The offset may be ~0 if the function name was added by + * glXGetProcAddress but never filled in by the driver. + */ + + if (ExtEntryTable[j].dispatch_offset != ~0) { + if (strcmp(real_sig, ExtEntryTable[j].parameter_signature) + != 0) { + return -1; + } + + if ( (offset != ~0) && (ExtEntryTable[j].dispatch_offset != offset) ) { + return -1; + } + + offset = ExtEntryTable[j].dispatch_offset; + } + + entry[i] = & ExtEntryTable[j]; + break; + } } } - /* This is a new function, try to add it. */ - if (NumExtEntryPoints >= MAX_EXTENSION_FUNCS || - offset >= DISPATCH_TABLE_SIZE) { - /* No space left */ - return GL_FALSE; + + if (offset == ~0) { + offset = next_dynamic_offset; + next_dynamic_offset++; } - else { - _glapi_proc entrypoint = generate_entrypoint(offset); - if (!entrypoint) - return GL_FALSE; /* couldn't generate assembly */ - /* OK! */ - ExtEntryTable[NumExtEntryPoints].Name = str_dup(funcName); - ExtEntryTable[NumExtEntryPoints].Offset = offset; - ExtEntryTable[NumExtEntryPoints].Address = entrypoint; - NumExtEntryPoints++; - return GL_TRUE; /* success */ - } + for ( i = 0 ; function_names[i] != NULL ; i++ ) { + if (! is_static[i] ) { + if (entry[i] == NULL) { + entry[i] = add_function_name( function_names[i] ); + if (entry[i] == NULL) { + /* FIXME: Possible memory leak here. + */ + return -1; + } + } + - /* should never get here, silence compiler warnings */ - return GL_FALSE; + entry[i]->parameter_signature = str_dup(real_sig); + fill_in_entrypoint_offset(entry[i]->dispatch_stub, offset); + entry[i]->dispatch_offset = offset; + } + } + + return offset; } @@ -896,8 +1047,8 @@ _glapi_get_proc_offset(const char *funcName) /* search extension functions first */ GLuint i; for (i = 0; i < NumExtEntryPoints; i++) { - if (strcmp(ExtEntryTable[i].Name, funcName) == 0) { - return ExtEntryTable[i].Offset; + if (strcmp(ExtEntryTable[i].name, funcName) == 0) { + return ExtEntryTable[i].dispatch_offset; } } @@ -915,6 +1066,7 @@ _glapi_get_proc_offset(const char *funcName) PUBLIC _glapi_proc _glapi_get_proc_address(const char *funcName) { + struct _glapi_function * entry; GLuint i; #ifdef MANGLE @@ -927,8 +1079,8 @@ _glapi_get_proc_address(const char *funcName) /* search extension functions first */ for (i = 0; i < NumExtEntryPoints; i++) { - if (strcmp(ExtEntryTable[i].Name, funcName) == 0) { - return ExtEntryTable[i].Address; + if (strcmp(ExtEntryTable[i].name, funcName) == 0) { + return ExtEntryTable[i].dispatch_stub; } } @@ -939,28 +1091,8 @@ _glapi_get_proc_address(const char *funcName) return func; } - /* generate new entrypoint - use a temporary dispatch offset of - * ~0 (i.e. -1). Later, when the driver calls _glapi_add_entrypoint() - * we'll put in the proper offset. If that never happens, and the - * user calls this function, he'll segfault. That's what you get - * when you try calling a GL function that doesn't really exist. - */ - if (NumExtEntryPoints < MAX_EXTENSION_FUNCS) { - _glapi_proc entrypoint = generate_entrypoint(~0); - if (!entrypoint) - return GL_FALSE; - - ExtEntryTable[NumExtEntryPoints].Name = str_dup(funcName); - ExtEntryTable[NumExtEntryPoints].Offset = ~0; - ExtEntryTable[NumExtEntryPoints].Address = entrypoint; - NumExtEntryPoints++; - - return entrypoint; - } - else { - /* no space for new functions! */ - return NULL; - } + entry = add_function_name(funcName); + return (entry == NULL) ? NULL : entry->dispatch_stub; } @@ -983,8 +1115,8 @@ _glapi_get_proc_name(GLuint offset) /* search added extension functions */ for (i = 0; i < NumExtEntryPoints; i++) { - if (ExtEntryTable[i].Offset == offset) { - return ExtEntryTable[i].Name; + if (ExtEntryTable[i].dispatch_offset == offset) { + return ExtEntryTable[i].name; } } return NULL; diff --git a/src/mesa/glapi/glapi.h b/src/mesa/glapi/glapi.h index c334203394f..eb26ebf87b5 100644 --- a/src/mesa/glapi/glapi.h +++ b/src/mesa/glapi/glapi.h @@ -46,13 +46,10 @@ #include "GL/gl.h" - -struct _glapi_table; +#include "glapitable.h" typedef void (*_glapi_warning_func)(void *ctx, const char *str, ...); -typedef void (*_glapi_proc)(void); /* generic function pointer */ - #if defined (GLX_USE_TLS) @@ -140,9 +137,9 @@ extern void _glapi_check_table(const struct _glapi_table *table); -extern GLboolean -_glapi_add_entrypoint(const char *funcName, GLuint offset); - +extern int +_glapi_add_dispatch( const char * const * function_names, + const char * parameter_signature ); extern GLint _glapi_get_proc_offset(const char *funcName); diff --git a/src/mesa/glapi/glapioffsets.h b/src/mesa/glapi/glapioffsets.h index f7e9c95bd88..262b69e67dd 100644 --- a/src/mesa/glapi/glapioffsets.h +++ b/src/mesa/glapi/glapioffsets.h @@ -845,5 +845,6 @@ #define _gloffset_StencilFuncSeparate 813 #define _gloffset_StencilOpSeparate 814 #define _gloffset_StencilMaskSeparate 815 +#define _gloffset_FIRST_DYNAMIC 816 #endif /* !defined( _GLAPI_OFFSETS_H_ ) */ diff --git a/src/mesa/glapi/glapitable.h b/src/mesa/glapi/glapitable.h index a450311e625..b4c70bdaae9 100644 --- a/src/mesa/glapi/glapitable.h +++ b/src/mesa/glapi/glapitable.h @@ -33,6 +33,8 @@ #define GLAPIENTRYP #endif +typedef void (*_glapi_proc)(void); /* generic function pointer */ + struct _glapi_table { void (GLAPIENTRYP NewList)(GLuint list, GLenum mode); /* 0 */ diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h index 6c036da8743..956fc9971e8 100644 --- a/src/mesa/main/mtypes.h +++ b/src/mesa/main/mtypes.h @@ -2598,7 +2598,10 @@ struct gl_tnl_module * On restore, only need to swap these functions back in. */ /*@{*/ - void *Swapped[NUM_VERTEX_FORMAT_ENTRIES][2]; + struct { + _glapi_proc * location; + _glapi_proc function; + } Swapped[NUM_VERTEX_FORMAT_ENTRIES]; GLuint SwapCount; /*@}*/ }; diff --git a/src/mesa/main/vtxfmt.c b/src/mesa/main/vtxfmt.c index 0d285cb26c9..dcb684837c8 100644 --- a/src/mesa/main/vtxfmt.c +++ b/src/mesa/main/vtxfmt.c @@ -49,15 +49,14 @@ { \ GET_CURRENT_CONTEXT(ctx); \ struct gl_tnl_module *tnl = &(ctx->TnlModule); \ - typedef void (*func_ptr_t)(void); \ \ ASSERT( tnl->Current ); \ ASSERT( tnl->SwapCount < NUM_VERTEX_FORMAT_ENTRIES ); \ \ /* Save the swapped function's dispatch entry so it can be */ \ /* restored later. */ \ - tnl->Swapped[tnl->SwapCount][0] = (void *)&(GET_ ## FUNC (ctx->Exec)); \ - *(func_ptr_t *)(tnl->Swapped[tnl->SwapCount]+1) = (func_ptr_t)TAG(FUNC); \ + tnl->Swapped[tnl->SwapCount].location = (_glapi_proc *) & (GET_ ## FUNC (ctx->Exec)); \ + tnl->Swapped[tnl->SwapCount].function = (_glapi_proc)TAG(FUNC); \ tnl->SwapCount++; \ \ if ( 0 ) \ @@ -177,7 +176,7 @@ void _mesa_restore_exec_vtxfmt( GLcontext *ctx ) /* Restore the neutral tnl module wrapper. */ for ( i = 0 ; i < tnl->SwapCount ; i++ ) { - *(void **)tnl->Swapped[i][0] = tnl->Swapped[i][1]; + *(tnl->Swapped[i].location) = tnl->Swapped[i].function; } tnl->SwapCount = 0; |