Skip to content
Normal view History Permalink
GLee.c 851 KiB
Newer Older
Luis Peñaranda's avatar
initial commit
Luis Peñaranda committed
3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 
PFNGLBINORMAL3IVEXTPROC pglBinormal3ivEXT=_Lazy_glBinormal3ivEXT;
PFNGLBINORMAL3SEXTPROC pglBinormal3sEXT=_Lazy_glBinormal3sEXT;
PFNGLBINORMAL3SVEXTPROC pglBinormal3svEXT=_Lazy_glBinormal3svEXT;
PFNGLTANGENTPOINTEREXTPROC pglTangentPointerEXT=_Lazy_glTangentPointerEXT;
PFNGLBINORMALPOINTEREXTPROC pglBinormalPointerEXT=_Lazy_glBinormalPointerEXT;
#endif 

/* GL_EXT_texture_env_combine */

#ifdef __GLEE_GL_EXT_texture_env_combine
#endif 

/* GL_APPLE_specular_vector */

#ifdef __GLEE_GL_APPLE_specular_vector
#endif 

/* GL_APPLE_transform_hint */

#ifdef __GLEE_GL_APPLE_transform_hint
#endif 

/* GL_SGIX_fog_scale */

#ifdef __GLEE_GL_SGIX_fog_scale
#endif 

/* GL_SUNX_constant_data */

#ifdef __GLEE_GL_SUNX_constant_data
void __stdcall _Lazy_glFinishTextureSUNX(void)                                            {if (GLeeInit()) glFinishTextureSUNX();}
PFNGLFINISHTEXTURESUNXPROC pglFinishTextureSUNX=_Lazy_glFinishTextureSUNX;
#endif 

/* GL_SUN_global_alpha */

#ifdef __GLEE_GL_SUN_global_alpha
void __stdcall _Lazy_glGlobalAlphaFactorbSUN(GLbyte factor)                               {if (GLeeInit()) glGlobalAlphaFactorbSUN(factor);}
void __stdcall _Lazy_glGlobalAlphaFactorsSUN(GLshort factor)                              {if (GLeeInit()) glGlobalAlphaFactorsSUN(factor);}
void __stdcall _Lazy_glGlobalAlphaFactoriSUN(GLint factor)                                {if (GLeeInit()) glGlobalAlphaFactoriSUN(factor);}
void __stdcall _Lazy_glGlobalAlphaFactorfSUN(GLfloat factor)                              {if (GLeeInit()) glGlobalAlphaFactorfSUN(factor);}
void __stdcall _Lazy_glGlobalAlphaFactordSUN(GLdouble factor)                             {if (GLeeInit()) glGlobalAlphaFactordSUN(factor);}
void __stdcall _Lazy_glGlobalAlphaFactorubSUN(GLubyte factor)                             {if (GLeeInit()) glGlobalAlphaFactorubSUN(factor);}
void __stdcall _Lazy_glGlobalAlphaFactorusSUN(GLushort factor)                            {if (GLeeInit()) glGlobalAlphaFactorusSUN(factor);}
void __stdcall _Lazy_glGlobalAlphaFactoruiSUN(GLuint factor)                              {if (GLeeInit()) glGlobalAlphaFactoruiSUN(factor);}
PFNGLGLOBALALPHAFACTORBSUNPROC pglGlobalAlphaFactorbSUN=_Lazy_glGlobalAlphaFactorbSUN;
PFNGLGLOBALALPHAFACTORSSUNPROC pglGlobalAlphaFactorsSUN=_Lazy_glGlobalAlphaFactorsSUN;
PFNGLGLOBALALPHAFACTORISUNPROC pglGlobalAlphaFactoriSUN=_Lazy_glGlobalAlphaFactoriSUN;
PFNGLGLOBALALPHAFACTORFSUNPROC pglGlobalAlphaFactorfSUN=_Lazy_glGlobalAlphaFactorfSUN;
PFNGLGLOBALALPHAFACTORDSUNPROC pglGlobalAlphaFactordSUN=_Lazy_glGlobalAlphaFactordSUN;
PFNGLGLOBALALPHAFACTORUBSUNPROC pglGlobalAlphaFactorubSUN=_Lazy_glGlobalAlphaFactorubSUN;
PFNGLGLOBALALPHAFACTORUSSUNPROC pglGlobalAlphaFactorusSUN=_Lazy_glGlobalAlphaFactorusSUN;
PFNGLGLOBALALPHAFACTORUISUNPROC pglGlobalAlphaFactoruiSUN=_Lazy_glGlobalAlphaFactoruiSUN;
#endif 

/* GL_SUN_triangle_list */

#ifdef __GLEE_GL_SUN_triangle_list
void __stdcall _Lazy_glReplacementCodeuiSUN(GLuint code)                                  {if (GLeeInit()) glReplacementCodeuiSUN(code);}
void __stdcall _Lazy_glReplacementCodeusSUN(GLushort code)                                {if (GLeeInit()) glReplacementCodeusSUN(code);}
void __stdcall _Lazy_glReplacementCodeubSUN(GLubyte code)                                 {if (GLeeInit()) glReplacementCodeubSUN(code);}
void __stdcall _Lazy_glReplacementCodeuivSUN(const GLuint * code)                         {if (GLeeInit()) glReplacementCodeuivSUN(code);}
void __stdcall _Lazy_glReplacementCodeusvSUN(const GLushort * code)                       {if (GLeeInit()) glReplacementCodeusvSUN(code);}
void __stdcall _Lazy_glReplacementCodeubvSUN(const GLubyte * code)                        {if (GLeeInit()) glReplacementCodeubvSUN(code);}
void __stdcall _Lazy_glReplacementCodePointerSUN(GLenum type, GLsizei stride, const GLvoid* * pointer)  {if (GLeeInit()) glReplacementCodePointerSUN(type, stride, pointer);}
PFNGLREPLACEMENTCODEUISUNPROC pglReplacementCodeuiSUN=_Lazy_glReplacementCodeuiSUN;
PFNGLREPLACEMENTCODEUSSUNPROC pglReplacementCodeusSUN=_Lazy_glReplacementCodeusSUN;
PFNGLREPLACEMENTCODEUBSUNPROC pglReplacementCodeubSUN=_Lazy_glReplacementCodeubSUN;
PFNGLREPLACEMENTCODEUIVSUNPROC pglReplacementCodeuivSUN=_Lazy_glReplacementCodeuivSUN;
PFNGLREPLACEMENTCODEUSVSUNPROC pglReplacementCodeusvSUN=_Lazy_glReplacementCodeusvSUN;
PFNGLREPLACEMENTCODEUBVSUNPROC pglReplacementCodeubvSUN=_Lazy_glReplacementCodeubvSUN;
PFNGLREPLACEMENTCODEPOINTERSUNPROC pglReplacementCodePointerSUN=_Lazy_glReplacementCodePointerSUN;
#endif 

/* GL_SUN_vertex */

#ifdef __GLEE_GL_SUN_vertex
void __stdcall _Lazy_glColor4ubVertex2fSUN(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y)  {if (GLeeInit()) glColor4ubVertex2fSUN(r, g, b, a, x, y);}
void __stdcall _Lazy_glColor4ubVertex2fvSUN(const GLubyte * c, const GLfloat * v)         {if (GLeeInit()) glColor4ubVertex2fvSUN(c, v);}
void __stdcall _Lazy_glColor4ubVertex3fSUN(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glColor4ubVertex3fSUN(r, g, b, a, x, y, z);}
void __stdcall _Lazy_glColor4ubVertex3fvSUN(const GLubyte * c, const GLfloat * v)         {if (GLeeInit()) glColor4ubVertex3fvSUN(c, v);}
void __stdcall _Lazy_glColor3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glColor3fVertex3fSUN(r, g, b, x, y, z);}
void __stdcall _Lazy_glColor3fVertex3fvSUN(const GLfloat * c, const GLfloat * v)          {if (GLeeInit()) glColor3fVertex3fvSUN(c, v);}
void __stdcall _Lazy_glNormal3fVertex3fSUN(GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glNormal3fVertex3fSUN(nx, ny, nz, x, y, z);}
void __stdcall _Lazy_glNormal3fVertex3fvSUN(const GLfloat * n, const GLfloat * v)         {if (GLeeInit()) glNormal3fVertex3fvSUN(n, v);}
void __stdcall _Lazy_glColor4fNormal3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glColor4fNormal3fVertex3fSUN(r, g, b, a, nx, ny, nz, x, y, z);}
void __stdcall _Lazy_glColor4fNormal3fVertex3fvSUN(const GLfloat * c, const GLfloat * n, const GLfloat * v)  {if (GLeeInit()) glColor4fNormal3fVertex3fvSUN(c, n, v);}
void __stdcall _Lazy_glTexCoord2fVertex3fSUN(GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glTexCoord2fVertex3fSUN(s, t, x, y, z);}
void __stdcall _Lazy_glTexCoord2fVertex3fvSUN(const GLfloat * tc, const GLfloat * v)      {if (GLeeInit()) glTexCoord2fVertex3fvSUN(tc, v);}
void __stdcall _Lazy_glTexCoord4fVertex4fSUN(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w)  {if (GLeeInit()) glTexCoord4fVertex4fSUN(s, t, p, q, x, y, z, w);}
void __stdcall _Lazy_glTexCoord4fVertex4fvSUN(const GLfloat * tc, const GLfloat * v)      {if (GLeeInit()) glTexCoord4fVertex4fvSUN(tc, v);}
void __stdcall _Lazy_glTexCoord2fColor4ubVertex3fSUN(GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glTexCoord2fColor4ubVertex3fSUN(s, t, r, g, b, a, x, y, z);}
void __stdcall _Lazy_glTexCoord2fColor4ubVertex3fvSUN(const GLfloat * tc, const GLubyte * c, const GLfloat * v)  {if (GLeeInit()) glTexCoord2fColor4ubVertex3fvSUN(tc, c, v);}
void __stdcall _Lazy_glTexCoord2fColor3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glTexCoord2fColor3fVertex3fSUN(s, t, r, g, b, x, y, z);}
void __stdcall _Lazy_glTexCoord2fColor3fVertex3fvSUN(const GLfloat * tc, const GLfloat * c, const GLfloat * v)  {if (GLeeInit()) glTexCoord2fColor3fVertex3fvSUN(tc, c, v);}
void __stdcall _Lazy_glTexCoord2fNormal3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glTexCoord2fNormal3fVertex3fSUN(s, t, nx, ny, nz, x, y, z);}
void __stdcall _Lazy_glTexCoord2fNormal3fVertex3fvSUN(const GLfloat * tc, const GLfloat * n, const GLfloat * v)  {if (GLeeInit()) glTexCoord2fNormal3fVertex3fvSUN(tc, n, v);}
void __stdcall _Lazy_glTexCoord2fColor4fNormal3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glTexCoord2fColor4fNormal3fVertex3fSUN(s, t, r, g, b, a, nx, ny, nz, x, y, z);}
void __stdcall _Lazy_glTexCoord2fColor4fNormal3fVertex3fvSUN(const GLfloat * tc, const GLfloat * c, const GLfloat * n, const GLfloat * v)  {if (GLeeInit()) glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, c, n, v);}
void __stdcall _Lazy_glTexCoord4fColor4fNormal3fVertex4fSUN(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w)  {if (GLeeInit()) glTexCoord4fColor4fNormal3fVertex4fSUN(s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w);}
void __stdcall _Lazy_glTexCoord4fColor4fNormal3fVertex4fvSUN(const GLfloat * tc, const GLfloat * c, const GLfloat * n, const GLfloat * v)  {if (GLeeInit()) glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, c, n, v);}
void __stdcall _Lazy_glReplacementCodeuiVertex3fSUN(GLuint rc, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glReplacementCodeuiVertex3fSUN(rc, x, y, z);}
void __stdcall _Lazy_glReplacementCodeuiVertex3fvSUN(const GLuint * rc, const GLfloat * v)  {if (GLeeInit()) glReplacementCodeuiVertex3fvSUN(rc, v);}
void __stdcall _Lazy_glReplacementCodeuiColor4ubVertex3fSUN(GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glReplacementCodeuiColor4ubVertex3fSUN(rc, r, g, b, a, x, y, z);}
void __stdcall _Lazy_glReplacementCodeuiColor4ubVertex3fvSUN(const GLuint * rc, const GLubyte * c, const GLfloat * v)  {if (GLeeInit()) glReplacementCodeuiColor4ubVertex3fvSUN(rc, c, v);}
void __stdcall _Lazy_glReplacementCodeuiColor3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glReplacementCodeuiColor3fVertex3fSUN(rc, r, g, b, x, y, z);}
void __stdcall _Lazy_glReplacementCodeuiColor3fVertex3fvSUN(const GLuint * rc, const GLfloat * c, const GLfloat * v)  {if (GLeeInit()) glReplacementCodeuiColor3fVertex3fvSUN(rc, c, v);}
void __stdcall _Lazy_glReplacementCodeuiNormal3fVertex3fSUN(GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glReplacementCodeuiNormal3fVertex3fSUN(rc, nx, ny, nz, x, y, z);}
void __stdcall _Lazy_glReplacementCodeuiNormal3fVertex3fvSUN(const GLuint * rc, const GLfloat * n, const GLfloat * v)  {if (GLeeInit()) glReplacementCodeuiNormal3fVertex3fvSUN(rc, n, v);}
void __stdcall _Lazy_glReplacementCodeuiColor4fNormal3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glReplacementCodeuiColor4fNormal3fVertex3fSUN(rc, r, g, b, a, nx, ny, nz, x, y, z);}
void __stdcall _Lazy_glReplacementCodeuiColor4fNormal3fVertex3fvSUN(const GLuint * rc, const GLfloat * c, const GLfloat * n, const GLfloat * v)  {if (GLeeInit()) glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, c, n, v);}
void __stdcall _Lazy_glReplacementCodeuiTexCoord2fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glReplacementCodeuiTexCoord2fVertex3fSUN(rc, s, t, x, y, z);}
void __stdcall _Lazy_glReplacementCodeuiTexCoord2fVertex3fvSUN(const GLuint * rc, const GLfloat * tc, const GLfloat * v)  {if (GLeeInit()) glReplacementCodeuiTexCoord2fVertex3fvSUN(rc, tc, v);}
void __stdcall _Lazy_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc, s, t, nx, ny, nz, x, y, z);}
void __stdcall _Lazy_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(const GLuint * rc, const GLfloat * tc, const GLfloat * n, const GLfloat * v)  {if (GLeeInit()) glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, tc, n, v);}
void __stdcall _Lazy_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc, s, t, r, g, b, a, nx, ny, nz, x, y, z);}
void __stdcall _Lazy_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(const GLuint * rc, const GLfloat * tc, const GLfloat * c, const GLfloat * n, const GLfloat * v)  {if (GLeeInit()) glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, c, n, v);}
PFNGLCOLOR4UBVERTEX2FSUNPROC pglColor4ubVertex2fSUN=_Lazy_glColor4ubVertex2fSUN;
PFNGLCOLOR4UBVERTEX2FVSUNPROC pglColor4ubVertex2fvSUN=_Lazy_glColor4ubVertex2fvSUN;
PFNGLCOLOR4UBVERTEX3FSUNPROC pglColor4ubVertex3fSUN=_Lazy_glColor4ubVertex3fSUN;
PFNGLCOLOR4UBVERTEX3FVSUNPROC pglColor4ubVertex3fvSUN=_Lazy_glColor4ubVertex3fvSUN;
PFNGLCOLOR3FVERTEX3FSUNPROC pglColor3fVertex3fSUN=_Lazy_glColor3fVertex3fSUN;
PFNGLCOLOR3FVERTEX3FVSUNPROC pglColor3fVertex3fvSUN=_Lazy_glColor3fVertex3fvSUN;
PFNGLNORMAL3FVERTEX3FSUNPROC pglNormal3fVertex3fSUN=_Lazy_glNormal3fVertex3fSUN;
PFNGLNORMAL3FVERTEX3FVSUNPROC pglNormal3fVertex3fvSUN=_Lazy_glNormal3fVertex3fvSUN;
PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC pglColor4fNormal3fVertex3fSUN=_Lazy_glColor4fNormal3fVertex3fSUN;
PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC pglColor4fNormal3fVertex3fvSUN=_Lazy_glColor4fNormal3fVertex3fvSUN;
PFNGLTEXCOORD2FVERTEX3FSUNPROC pglTexCoord2fVertex3fSUN=_Lazy_glTexCoord2fVertex3fSUN;
PFNGLTEXCOORD2FVERTEX3FVSUNPROC pglTexCoord2fVertex3fvSUN=_Lazy_glTexCoord2fVertex3fvSUN;
PFNGLTEXCOORD4FVERTEX4FSUNPROC pglTexCoord4fVertex4fSUN=_Lazy_glTexCoord4fVertex4fSUN;
PFNGLTEXCOORD4FVERTEX4FVSUNPROC pglTexCoord4fVertex4fvSUN=_Lazy_glTexCoord4fVertex4fvSUN;
PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC pglTexCoord2fColor4ubVertex3fSUN=_Lazy_glTexCoord2fColor4ubVertex3fSUN;
PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC pglTexCoord2fColor4ubVertex3fvSUN=_Lazy_glTexCoord2fColor4ubVertex3fvSUN;
PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC pglTexCoord2fColor3fVertex3fSUN=_Lazy_glTexCoord2fColor3fVertex3fSUN;
PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC pglTexCoord2fColor3fVertex3fvSUN=_Lazy_glTexCoord2fColor3fVertex3fvSUN;
PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC pglTexCoord2fNormal3fVertex3fSUN=_Lazy_glTexCoord2fNormal3fVertex3fSUN;
PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC pglTexCoord2fNormal3fVertex3fvSUN=_Lazy_glTexCoord2fNormal3fVertex3fvSUN;
PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC pglTexCoord2fColor4fNormal3fVertex3fSUN=_Lazy_glTexCoord2fColor4fNormal3fVertex3fSUN;
PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC pglTexCoord2fColor4fNormal3fVertex3fvSUN=_Lazy_glTexCoord2fColor4fNormal3fVertex3fvSUN;
PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC pglTexCoord4fColor4fNormal3fVertex4fSUN=_Lazy_glTexCoord4fColor4fNormal3fVertex4fSUN;
PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC pglTexCoord4fColor4fNormal3fVertex4fvSUN=_Lazy_glTexCoord4fColor4fNormal3fVertex4fvSUN;
PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC pglReplacementCodeuiVertex3fSUN=_Lazy_glReplacementCodeuiVertex3fSUN;
PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC pglReplacementCodeuiVertex3fvSUN=_Lazy_glReplacementCodeuiVertex3fvSUN;
PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC pglReplacementCodeuiColor4ubVertex3fSUN=_Lazy_glReplacementCodeuiColor4ubVertex3fSUN;
PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC pglReplacementCodeuiColor4ubVertex3fvSUN=_Lazy_glReplacementCodeuiColor4ubVertex3fvSUN;
PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC pglReplacementCodeuiColor3fVertex3fSUN=_Lazy_glReplacementCodeuiColor3fVertex3fSUN;
PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC pglReplacementCodeuiColor3fVertex3fvSUN=_Lazy_glReplacementCodeuiColor3fVertex3fvSUN;
PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC pglReplacementCodeuiNormal3fVertex3fSUN=_Lazy_glReplacementCodeuiNormal3fVertex3fSUN;
PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC pglReplacementCodeuiNormal3fVertex3fvSUN=_Lazy_glReplacementCodeuiNormal3fVertex3fvSUN;
PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC pglReplacementCodeuiColor4fNormal3fVertex3fSUN=_Lazy_glReplacementCodeuiColor4fNormal3fVertex3fSUN;
PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC pglReplacementCodeuiColor4fNormal3fVertex3fvSUN=_Lazy_glReplacementCodeuiColor4fNormal3fVertex3fvSUN;
PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC pglReplacementCodeuiTexCoord2fVertex3fSUN=_Lazy_glReplacementCodeuiTexCoord2fVertex3fSUN;
PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC pglReplacementCodeuiTexCoord2fVertex3fvSUN=_Lazy_glReplacementCodeuiTexCoord2fVertex3fvSUN;
PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC pglReplacementCodeuiTexCoord2fNormal3fVertex3fSUN=_Lazy_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN;
PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC pglReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN=_Lazy_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN;
PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC pglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN=_Lazy_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN;
PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC pglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN=_Lazy_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN;
#endif 

/* GL_EXT_blend_func_separate */

#ifdef __GLEE_GL_EXT_blend_func_separate
void __stdcall _Lazy_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)  {if (GLeeInit()) glBlendFuncSeparateEXT(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);}
PFNGLBLENDFUNCSEPARATEEXTPROC pglBlendFuncSeparateEXT=_Lazy_glBlendFuncSeparateEXT;
#endif 

/* GL_INGR_color_clamp */

#ifdef __GLEE_GL_INGR_color_clamp
#endif 

/* GL_INGR_interlace_read */

#ifdef __GLEE_GL_INGR_interlace_read
#endif 

/* GL_EXT_stencil_wrap */

#ifdef __GLEE_GL_EXT_stencil_wrap
#endif 

/* GL_EXT_422_pixels */

#ifdef __GLEE_GL_EXT_422_pixels
#endif 

/* GL_NV_texgen_reflection */

#ifdef __GLEE_GL_NV_texgen_reflection
#endif 

/* GL_EXT_texture_cube_map */

#ifdef __GLEE_GL_EXT_texture_cube_map
#endif 

/* GL_SUN_convolution_border_modes */

#ifdef __GLEE_GL_SUN_convolution_border_modes
#endif 

/* GL_EXT_texture_env_add */

#ifdef __GLEE_GL_EXT_texture_env_add
#endif 

/* GL_EXT_texture_lod_bias */

#ifdef __GLEE_GL_EXT_texture_lod_bias
#endif 

/* GL_EXT_texture_filter_anisotropic */

#ifdef __GLEE_GL_EXT_texture_filter_anisotropic
#endif 

/* GL_EXT_vertex_weighting */

#ifdef __GLEE_GL_EXT_vertex_weighting
void __stdcall _Lazy_glVertexWeightfEXT(GLfloat weight)                                   {if (GLeeInit()) glVertexWeightfEXT(weight);}
void __stdcall _Lazy_glVertexWeightfvEXT(const GLfloat * weight)                          {if (GLeeInit()) glVertexWeightfvEXT(weight);}
void __stdcall _Lazy_glVertexWeightPointerEXT(GLsizei size, GLenum type, GLsizei stride, const GLvoid * pointer)  {if (GLeeInit()) glVertexWeightPointerEXT(size, type, stride, pointer);}
PFNGLVERTEXWEIGHTFEXTPROC pglVertexWeightfEXT=_Lazy_glVertexWeightfEXT;
PFNGLVERTEXWEIGHTFVEXTPROC pglVertexWeightfvEXT=_Lazy_glVertexWeightfvEXT;
PFNGLVERTEXWEIGHTPOINTEREXTPROC pglVertexWeightPointerEXT=_Lazy_glVertexWeightPointerEXT;
#endif 

/* GL_NV_light_max_exponent */

#ifdef __GLEE_GL_NV_light_max_exponent
#endif 

/* GL_NV_vertex_array_range */

#ifdef __GLEE_GL_NV_vertex_array_range
void __stdcall _Lazy_glFlushVertexArrayRangeNV(void)                                      {if (GLeeInit()) glFlushVertexArrayRangeNV();}
void __stdcall _Lazy_glVertexArrayRangeNV(GLsizei length, const GLvoid * pointer)         {if (GLeeInit()) glVertexArrayRangeNV(length, pointer);}
PFNGLFLUSHVERTEXARRAYRANGENVPROC pglFlushVertexArrayRangeNV=_Lazy_glFlushVertexArrayRangeNV;
PFNGLVERTEXARRAYRANGENVPROC pglVertexArrayRangeNV=_Lazy_glVertexArrayRangeNV;
#endif 

/* GL_NV_register_combiners */

#ifdef __GLEE_GL_NV_register_combiners
void __stdcall _Lazy_glCombinerParameterfvNV(GLenum pname, const GLfloat * params)        {if (GLeeInit()) glCombinerParameterfvNV(pname, params);}
void __stdcall _Lazy_glCombinerParameterfNV(GLenum pname, GLfloat param)                  {if (GLeeInit()) glCombinerParameterfNV(pname, param);}
void __stdcall _Lazy_glCombinerParameterivNV(GLenum pname, const GLint * params)          {if (GLeeInit()) glCombinerParameterivNV(pname, params);}
void __stdcall _Lazy_glCombinerParameteriNV(GLenum pname, GLint param)                    {if (GLeeInit()) glCombinerParameteriNV(pname, param);}
void __stdcall _Lazy_glCombinerInputNV(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)  {if (GLeeInit()) glCombinerInputNV(stage, portion, variable, input, mapping, componentUsage);}
void __stdcall _Lazy_glCombinerOutputNV(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum)  {if (GLeeInit()) glCombinerOutputNV(stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum);}
void __stdcall _Lazy_glFinalCombinerInputNV(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)  {if (GLeeInit()) glFinalCombinerInputNV(variable, input, mapping, componentUsage);}
void __stdcall _Lazy_glGetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetCombinerInputParameterfvNV(stage, portion, variable, pname, params);}
void __stdcall _Lazy_glGetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params)  {if (GLeeInit()) glGetCombinerInputParameterivNV(stage, portion, variable, pname, params);}
void __stdcall _Lazy_glGetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetCombinerOutputParameterfvNV(stage, portion, pname, params);}
void __stdcall _Lazy_glGetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, GLint * params)  {if (GLeeInit()) glGetCombinerOutputParameterivNV(stage, portion, pname, params);}
void __stdcall _Lazy_glGetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetFinalCombinerInputParameterfvNV(variable, pname, params);}
void __stdcall _Lazy_glGetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, GLint * params)  {if (GLeeInit()) glGetFinalCombinerInputParameterivNV(variable, pname, params);}
PFNGLCOMBINERPARAMETERFVNVPROC pglCombinerParameterfvNV=_Lazy_glCombinerParameterfvNV;
PFNGLCOMBINERPARAMETERFNVPROC pglCombinerParameterfNV=_Lazy_glCombinerParameterfNV;
PFNGLCOMBINERPARAMETERIVNVPROC pglCombinerParameterivNV=_Lazy_glCombinerParameterivNV;
PFNGLCOMBINERPARAMETERINVPROC pglCombinerParameteriNV=_Lazy_glCombinerParameteriNV;
PFNGLCOMBINERINPUTNVPROC pglCombinerInputNV=_Lazy_glCombinerInputNV;
PFNGLCOMBINEROUTPUTNVPROC pglCombinerOutputNV=_Lazy_glCombinerOutputNV;
PFNGLFINALCOMBINERINPUTNVPROC pglFinalCombinerInputNV=_Lazy_glFinalCombinerInputNV;
PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC pglGetCombinerInputParameterfvNV=_Lazy_glGetCombinerInputParameterfvNV;
PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC pglGetCombinerInputParameterivNV=_Lazy_glGetCombinerInputParameterivNV;
PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC pglGetCombinerOutputParameterfvNV=_Lazy_glGetCombinerOutputParameterfvNV;
PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC pglGetCombinerOutputParameterivNV=_Lazy_glGetCombinerOutputParameterivNV;
PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC pglGetFinalCombinerInputParameterfvNV=_Lazy_glGetFinalCombinerInputParameterfvNV;
PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC pglGetFinalCombinerInputParameterivNV=_Lazy_glGetFinalCombinerInputParameterivNV;
#endif 

/* GL_NV_fog_distance */

#ifdef __GLEE_GL_NV_fog_distance
#endif 

/* GL_NV_texgen_emboss */

#ifdef __GLEE_GL_NV_texgen_emboss
#endif 

/* GL_NV_blend_square */

#ifdef __GLEE_GL_NV_blend_square
#endif 

/* GL_NV_texture_env_combine4 */

#ifdef __GLEE_GL_NV_texture_env_combine4
#endif 

/* GL_MESA_resize_buffers */

#ifdef __GLEE_GL_MESA_resize_buffers
void __stdcall _Lazy_glResizeBuffersMESA(void)                                            {if (GLeeInit()) glResizeBuffersMESA();}
PFNGLRESIZEBUFFERSMESAPROC pglResizeBuffersMESA=_Lazy_glResizeBuffersMESA;
#endif 

/* GL_MESA_window_pos */

#ifdef __GLEE_GL_MESA_window_pos
void __stdcall _Lazy_glWindowPos2dMESA(GLdouble x, GLdouble y)                            {if (GLeeInit()) glWindowPos2dMESA(x, y);}
void __stdcall _Lazy_glWindowPos2dvMESA(const GLdouble * v)                               {if (GLeeInit()) glWindowPos2dvMESA(v);}
void __stdcall _Lazy_glWindowPos2fMESA(GLfloat x, GLfloat y)                              {if (GLeeInit()) glWindowPos2fMESA(x, y);}
void __stdcall _Lazy_glWindowPos2fvMESA(const GLfloat * v)                                {if (GLeeInit()) glWindowPos2fvMESA(v);}
void __stdcall _Lazy_glWindowPos2iMESA(GLint x, GLint y)                                  {if (GLeeInit()) glWindowPos2iMESA(x, y);}
void __stdcall _Lazy_glWindowPos2ivMESA(const GLint * v)                                  {if (GLeeInit()) glWindowPos2ivMESA(v);}
void __stdcall _Lazy_glWindowPos2sMESA(GLshort x, GLshort y)                              {if (GLeeInit()) glWindowPos2sMESA(x, y);}
void __stdcall _Lazy_glWindowPos2svMESA(const GLshort * v)                                {if (GLeeInit()) glWindowPos2svMESA(v);}
void __stdcall _Lazy_glWindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z)                {if (GLeeInit()) glWindowPos3dMESA(x, y, z);}
void __stdcall _Lazy_glWindowPos3dvMESA(const GLdouble * v)                               {if (GLeeInit()) glWindowPos3dvMESA(v);}
void __stdcall _Lazy_glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)                   {if (GLeeInit()) glWindowPos3fMESA(x, y, z);}
void __stdcall _Lazy_glWindowPos3fvMESA(const GLfloat * v)                                {if (GLeeInit()) glWindowPos3fvMESA(v);}
void __stdcall _Lazy_glWindowPos3iMESA(GLint x, GLint y, GLint z)                         {if (GLeeInit()) glWindowPos3iMESA(x, y, z);}
void __stdcall _Lazy_glWindowPos3ivMESA(const GLint * v)                                  {if (GLeeInit()) glWindowPos3ivMESA(v);}
void __stdcall _Lazy_glWindowPos3sMESA(GLshort x, GLshort y, GLshort z)                   {if (GLeeInit()) glWindowPos3sMESA(x, y, z);}
void __stdcall _Lazy_glWindowPos3svMESA(const GLshort * v)                                {if (GLeeInit()) glWindowPos3svMESA(v);}
void __stdcall _Lazy_glWindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w)    {if (GLeeInit()) glWindowPos4dMESA(x, y, z, w);}
void __stdcall _Lazy_glWindowPos4dvMESA(const GLdouble * v)                               {if (GLeeInit()) glWindowPos4dvMESA(v);}
void __stdcall _Lazy_glWindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w)        {if (GLeeInit()) glWindowPos4fMESA(x, y, z, w);}
void __stdcall _Lazy_glWindowPos4fvMESA(const GLfloat * v)                                {if (GLeeInit()) glWindowPos4fvMESA(v);}
void __stdcall _Lazy_glWindowPos4iMESA(GLint x, GLint y, GLint z, GLint w)                {if (GLeeInit()) glWindowPos4iMESA(x, y, z, w);}
void __stdcall _Lazy_glWindowPos4ivMESA(const GLint * v)                                  {if (GLeeInit()) glWindowPos4ivMESA(v);}
void __stdcall _Lazy_glWindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w)        {if (GLeeInit()) glWindowPos4sMESA(x, y, z, w);}
void __stdcall _Lazy_glWindowPos4svMESA(const GLshort * v)                                {if (GLeeInit()) glWindowPos4svMESA(v);}
PFNGLWINDOWPOS2DMESAPROC pglWindowPos2dMESA=_Lazy_glWindowPos2dMESA;
PFNGLWINDOWPOS2DVMESAPROC pglWindowPos2dvMESA=_Lazy_glWindowPos2dvMESA;
PFNGLWINDOWPOS2FMESAPROC pglWindowPos2fMESA=_Lazy_glWindowPos2fMESA;
PFNGLWINDOWPOS2FVMESAPROC pglWindowPos2fvMESA=_Lazy_glWindowPos2fvMESA;
PFNGLWINDOWPOS2IMESAPROC pglWindowPos2iMESA=_Lazy_glWindowPos2iMESA;
PFNGLWINDOWPOS2IVMESAPROC pglWindowPos2ivMESA=_Lazy_glWindowPos2ivMESA;
PFNGLWINDOWPOS2SMESAPROC pglWindowPos2sMESA=_Lazy_glWindowPos2sMESA;
PFNGLWINDOWPOS2SVMESAPROC pglWindowPos2svMESA=_Lazy_glWindowPos2svMESA;
PFNGLWINDOWPOS3DMESAPROC pglWindowPos3dMESA=_Lazy_glWindowPos3dMESA;
PFNGLWINDOWPOS3DVMESAPROC pglWindowPos3dvMESA=_Lazy_glWindowPos3dvMESA;
PFNGLWINDOWPOS3FMESAPROC pglWindowPos3fMESA=_Lazy_glWindowPos3fMESA;
PFNGLWINDOWPOS3FVMESAPROC pglWindowPos3fvMESA=_Lazy_glWindowPos3fvMESA;
PFNGLWINDOWPOS3IMESAPROC pglWindowPos3iMESA=_Lazy_glWindowPos3iMESA;
PFNGLWINDOWPOS3IVMESAPROC pglWindowPos3ivMESA=_Lazy_glWindowPos3ivMESA;
PFNGLWINDOWPOS3SMESAPROC pglWindowPos3sMESA=_Lazy_glWindowPos3sMESA;
PFNGLWINDOWPOS3SVMESAPROC pglWindowPos3svMESA=_Lazy_glWindowPos3svMESA;
PFNGLWINDOWPOS4DMESAPROC pglWindowPos4dMESA=_Lazy_glWindowPos4dMESA;
PFNGLWINDOWPOS4DVMESAPROC pglWindowPos4dvMESA=_Lazy_glWindowPos4dvMESA;
PFNGLWINDOWPOS4FMESAPROC pglWindowPos4fMESA=_Lazy_glWindowPos4fMESA;
PFNGLWINDOWPOS4FVMESAPROC pglWindowPos4fvMESA=_Lazy_glWindowPos4fvMESA;
PFNGLWINDOWPOS4IMESAPROC pglWindowPos4iMESA=_Lazy_glWindowPos4iMESA;
PFNGLWINDOWPOS4IVMESAPROC pglWindowPos4ivMESA=_Lazy_glWindowPos4ivMESA;
PFNGLWINDOWPOS4SMESAPROC pglWindowPos4sMESA=_Lazy_glWindowPos4sMESA;
PFNGLWINDOWPOS4SVMESAPROC pglWindowPos4svMESA=_Lazy_glWindowPos4svMESA;
#endif 

/* GL_EXT_texture_compression_s3tc */

#ifdef __GLEE_GL_EXT_texture_compression_s3tc
#endif 

/* GL_IBM_cull_vertex */

#ifdef __GLEE_GL_IBM_cull_vertex
#endif 

/* GL_IBM_multimode_draw_arrays */

#ifdef __GLEE_GL_IBM_multimode_draw_arrays
void __stdcall _Lazy_glMultiModeDrawArraysIBM(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride)  {if (GLeeInit()) glMultiModeDrawArraysIBM(mode, first, count, primcount, modestride);}
void __stdcall _Lazy_glMultiModeDrawElementsIBM(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid* const * indices, GLsizei primcount, GLint modestride)  {if (GLeeInit()) glMultiModeDrawElementsIBM(mode, count, type, indices, primcount, modestride);}
PFNGLMULTIMODEDRAWARRAYSIBMPROC pglMultiModeDrawArraysIBM=_Lazy_glMultiModeDrawArraysIBM;
PFNGLMULTIMODEDRAWELEMENTSIBMPROC pglMultiModeDrawElementsIBM=_Lazy_glMultiModeDrawElementsIBM;
#endif 

/* GL_IBM_vertex_array_lists */

#ifdef __GLEE_GL_IBM_vertex_array_lists
void __stdcall _Lazy_glColorPointerListIBM(GLint size, GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride)  {if (GLeeInit()) glColorPointerListIBM(size, type, stride, pointer, ptrstride);}
void __stdcall _Lazy_glSecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride)  {if (GLeeInit()) glSecondaryColorPointerListIBM(size, type, stride, pointer, ptrstride);}
void __stdcall _Lazy_glEdgeFlagPointerListIBM(GLint stride, const GLboolean* * pointer, GLint ptrstride)  {if (GLeeInit()) glEdgeFlagPointerListIBM(stride, pointer, ptrstride);}
void __stdcall _Lazy_glFogCoordPointerListIBM(GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride)  {if (GLeeInit()) glFogCoordPointerListIBM(type, stride, pointer, ptrstride);}
void __stdcall _Lazy_glIndexPointerListIBM(GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride)  {if (GLeeInit()) glIndexPointerListIBM(type, stride, pointer, ptrstride);}
void __stdcall _Lazy_glNormalPointerListIBM(GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride)  {if (GLeeInit()) glNormalPointerListIBM(type, stride, pointer, ptrstride);}
void __stdcall _Lazy_glTexCoordPointerListIBM(GLint size, GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride)  {if (GLeeInit()) glTexCoordPointerListIBM(size, type, stride, pointer, ptrstride);}
void __stdcall _Lazy_glVertexPointerListIBM(GLint size, GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride)  {if (GLeeInit()) glVertexPointerListIBM(size, type, stride, pointer, ptrstride);}
PFNGLCOLORPOINTERLISTIBMPROC pglColorPointerListIBM=_Lazy_glColorPointerListIBM;
PFNGLSECONDARYCOLORPOINTERLISTIBMPROC pglSecondaryColorPointerListIBM=_Lazy_glSecondaryColorPointerListIBM;
PFNGLEDGEFLAGPOINTERLISTIBMPROC pglEdgeFlagPointerListIBM=_Lazy_glEdgeFlagPointerListIBM;
PFNGLFOGCOORDPOINTERLISTIBMPROC pglFogCoordPointerListIBM=_Lazy_glFogCoordPointerListIBM;
PFNGLINDEXPOINTERLISTIBMPROC pglIndexPointerListIBM=_Lazy_glIndexPointerListIBM;
PFNGLNORMALPOINTERLISTIBMPROC pglNormalPointerListIBM=_Lazy_glNormalPointerListIBM;
PFNGLTEXCOORDPOINTERLISTIBMPROC pglTexCoordPointerListIBM=_Lazy_glTexCoordPointerListIBM;
PFNGLVERTEXPOINTERLISTIBMPROC pglVertexPointerListIBM=_Lazy_glVertexPointerListIBM;
#endif 

/* GL_SGIX_subsample */

#ifdef __GLEE_GL_SGIX_subsample
#endif 

/* GL_SGIX_ycrcb_subsample */

#ifdef __GLEE_GL_SGIX_ycrcb_subsample
#endif 

/* GL_SGIX_ycrcba */

#ifdef __GLEE_GL_SGIX_ycrcba
#endif 

/* GL_SGI_depth_pass_instrument */

#ifdef __GLEE_GL_SGI_depth_pass_instrument
#endif 

/* GL_3DFX_texture_compression_FXT1 */

#ifdef __GLEE_GL_3DFX_texture_compression_FXT1
#endif 

/* GL_3DFX_multisample */

#ifdef __GLEE_GL_3DFX_multisample
#endif 

/* GL_3DFX_tbuffer */

#ifdef __GLEE_GL_3DFX_tbuffer
void __stdcall _Lazy_glTbufferMask3DFX(GLuint mask)                                       {if (GLeeInit()) glTbufferMask3DFX(mask);}
PFNGLTBUFFERMASK3DFXPROC pglTbufferMask3DFX=_Lazy_glTbufferMask3DFX;
#endif 

/* GL_EXT_multisample */

#ifdef __GLEE_GL_EXT_multisample
void __stdcall _Lazy_glSampleMaskEXT(GLclampf value, GLboolean invert)                    {if (GLeeInit()) glSampleMaskEXT(value, invert);}
void __stdcall _Lazy_glSamplePatternEXT(GLenum pattern)                                   {if (GLeeInit()) glSamplePatternEXT(pattern);}
PFNGLSAMPLEMASKEXTPROC pglSampleMaskEXT=_Lazy_glSampleMaskEXT;
PFNGLSAMPLEPATTERNEXTPROC pglSamplePatternEXT=_Lazy_glSamplePatternEXT;
#endif 

/* GL_SGIX_vertex_preclip */

#ifdef __GLEE_GL_SGIX_vertex_preclip
#endif 

/* GL_SGIX_convolution_accuracy */

#ifdef __GLEE_GL_SGIX_convolution_accuracy
#endif 

/* GL_SGIX_resample */

#ifdef __GLEE_GL_SGIX_resample
#endif 

/* GL_SGIS_point_line_texgen */

#ifdef __GLEE_GL_SGIS_point_line_texgen
#endif 

/* GL_SGIS_texture_color_mask */

#ifdef __GLEE_GL_SGIS_texture_color_mask
void __stdcall _Lazy_glTextureColorMaskSGIS(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)  {if (GLeeInit()) glTextureColorMaskSGIS(red, green, blue, alpha);}
PFNGLTEXTURECOLORMASKSGISPROC pglTextureColorMaskSGIS=_Lazy_glTextureColorMaskSGIS;
#endif 

/* GL_EXT_texture_env_dot3 */

#ifdef __GLEE_GL_EXT_texture_env_dot3
#endif 

/* GL_ATI_texture_mirror_once */

#ifdef __GLEE_GL_ATI_texture_mirror_once
#endif 

/* GL_NV_fence */

#ifdef __GLEE_GL_NV_fence
void __stdcall _Lazy_glDeleteFencesNV(GLsizei n, const GLuint * fences)                   {if (GLeeInit()) glDeleteFencesNV(n, fences);}
void __stdcall _Lazy_glGenFencesNV(GLsizei n, GLuint * fences)                            {if (GLeeInit()) glGenFencesNV(n, fences);}
GLboolean __stdcall _Lazy_glIsFenceNV(GLuint fence)                                       {if (GLeeInit()) return glIsFenceNV(fence); return (GLboolean)0;}
GLboolean __stdcall _Lazy_glTestFenceNV(GLuint fence)                                     {if (GLeeInit()) return glTestFenceNV(fence); return (GLboolean)0;}
void __stdcall _Lazy_glGetFenceivNV(GLuint fence, GLenum pname, GLint * params)           {if (GLeeInit()) glGetFenceivNV(fence, pname, params);}
void __stdcall _Lazy_glFinishFenceNV(GLuint fence)                                        {if (GLeeInit()) glFinishFenceNV(fence);}
void __stdcall _Lazy_glSetFenceNV(GLuint fence, GLenum condition)                         {if (GLeeInit()) glSetFenceNV(fence, condition);}
PFNGLDELETEFENCESNVPROC pglDeleteFencesNV=_Lazy_glDeleteFencesNV;
PFNGLGENFENCESNVPROC pglGenFencesNV=_Lazy_glGenFencesNV;
PFNGLISFENCENVPROC pglIsFenceNV=_Lazy_glIsFenceNV;
PFNGLTESTFENCENVPROC pglTestFenceNV=_Lazy_glTestFenceNV;
PFNGLGETFENCEIVNVPROC pglGetFenceivNV=_Lazy_glGetFenceivNV;
PFNGLFINISHFENCENVPROC pglFinishFenceNV=_Lazy_glFinishFenceNV;
PFNGLSETFENCENVPROC pglSetFenceNV=_Lazy_glSetFenceNV;
#endif 

/* GL_IBM_texture_mirrored_repeat */

#ifdef __GLEE_GL_IBM_texture_mirrored_repeat
#endif 

/* GL_NV_evaluators */

#ifdef __GLEE_GL_NV_evaluators
void __stdcall _Lazy_glMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid * points)  {if (GLeeInit()) glMapControlPointsNV(target, index, type, ustride, vstride, uorder, vorder, packed, points);}
void __stdcall _Lazy_glMapParameterivNV(GLenum target, GLenum pname, const GLint * params)  {if (GLeeInit()) glMapParameterivNV(target, pname, params);}
void __stdcall _Lazy_glMapParameterfvNV(GLenum target, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glMapParameterfvNV(target, pname, params);}
void __stdcall _Lazy_glGetMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, GLvoid * points)  {if (GLeeInit()) glGetMapControlPointsNV(target, index, type, ustride, vstride, packed, points);}
void __stdcall _Lazy_glGetMapParameterivNV(GLenum target, GLenum pname, GLint * params)   {if (GLeeInit()) glGetMapParameterivNV(target, pname, params);}
void __stdcall _Lazy_glGetMapParameterfvNV(GLenum target, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetMapParameterfvNV(target, pname, params);}
void __stdcall _Lazy_glGetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, GLint * params)  {if (GLeeInit()) glGetMapAttribParameterivNV(target, index, pname, params);}
void __stdcall _Lazy_glGetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetMapAttribParameterfvNV(target, index, pname, params);}
void __stdcall _Lazy_glEvalMapsNV(GLenum target, GLenum mode)                             {if (GLeeInit()) glEvalMapsNV(target, mode);}
PFNGLMAPCONTROLPOINTSNVPROC pglMapControlPointsNV=_Lazy_glMapControlPointsNV;
PFNGLMAPPARAMETERIVNVPROC pglMapParameterivNV=_Lazy_glMapParameterivNV;
PFNGLMAPPARAMETERFVNVPROC pglMapParameterfvNV=_Lazy_glMapParameterfvNV;
PFNGLGETMAPCONTROLPOINTSNVPROC pglGetMapControlPointsNV=_Lazy_glGetMapControlPointsNV;
PFNGLGETMAPPARAMETERIVNVPROC pglGetMapParameterivNV=_Lazy_glGetMapParameterivNV;
PFNGLGETMAPPARAMETERFVNVPROC pglGetMapParameterfvNV=_Lazy_glGetMapParameterfvNV;
PFNGLGETMAPATTRIBPARAMETERIVNVPROC pglGetMapAttribParameterivNV=_Lazy_glGetMapAttribParameterivNV;
PFNGLGETMAPATTRIBPARAMETERFVNVPROC pglGetMapAttribParameterfvNV=_Lazy_glGetMapAttribParameterfvNV;
PFNGLEVALMAPSNVPROC pglEvalMapsNV=_Lazy_glEvalMapsNV;
#endif 

/* GL_NV_packed_depth_stencil */

#ifdef __GLEE_GL_NV_packed_depth_stencil
#endif 

/* GL_NV_register_combiners2 */

#ifdef __GLEE_GL_NV_register_combiners2
void __stdcall _Lazy_glCombinerStageParameterfvNV(GLenum stage, GLenum pname, const GLfloat * params)  {if (GLeeInit()) glCombinerStageParameterfvNV(stage, pname, params);}
void __stdcall _Lazy_glGetCombinerStageParameterfvNV(GLenum stage, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetCombinerStageParameterfvNV(stage, pname, params);}
PFNGLCOMBINERSTAGEPARAMETERFVNVPROC pglCombinerStageParameterfvNV=_Lazy_glCombinerStageParameterfvNV;
PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC pglGetCombinerStageParameterfvNV=_Lazy_glGetCombinerStageParameterfvNV;
#endif 

/* GL_NV_texture_compression_vtc */

#ifdef __GLEE_GL_NV_texture_compression_vtc
#endif 

/* GL_NV_texture_rectangle */

#ifdef __GLEE_GL_NV_texture_rectangle
#endif 

/* GL_NV_texture_shader */

#ifdef __GLEE_GL_NV_texture_shader
#endif 

/* GL_NV_texture_shader2 */

#ifdef __GLEE_GL_NV_texture_shader2
#endif 

/* GL_NV_vertex_array_range2 */

#ifdef __GLEE_GL_NV_vertex_array_range2
#endif 

/* GL_NV_vertex_program */

#ifdef __GLEE_GL_NV_vertex_program
GLboolean __stdcall _Lazy_glAreProgramsResidentNV(GLsizei n, const GLuint * programs, GLboolean * residences)  {if (GLeeInit()) return glAreProgramsResidentNV(n, programs, residences); return (GLboolean)0;}
void __stdcall _Lazy_glBindProgramNV(GLenum target, GLuint id)                            {if (GLeeInit()) glBindProgramNV(target, id);}
void __stdcall _Lazy_glDeleteProgramsNV(GLsizei n, const GLuint * programs)               {if (GLeeInit()) glDeleteProgramsNV(n, programs);}
void __stdcall _Lazy_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat * params)  {if (GLeeInit()) glExecuteProgramNV(target, id, params);}
void __stdcall _Lazy_glGenProgramsNV(GLsizei n, GLuint * programs)                        {if (GLeeInit()) glGenProgramsNV(n, programs);}
void __stdcall _Lazy_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble * params)  {if (GLeeInit()) glGetProgramParameterdvNV(target, index, pname, params);}
void __stdcall _Lazy_glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetProgramParameterfvNV(target, index, pname, params);}
void __stdcall _Lazy_glGetProgramivNV(GLuint id, GLenum pname, GLint * params)            {if (GLeeInit()) glGetProgramivNV(id, pname, params);}
void __stdcall _Lazy_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte * program)     {if (GLeeInit()) glGetProgramStringNV(id, pname, program);}
void __stdcall _Lazy_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint * params)  {if (GLeeInit()) glGetTrackMatrixivNV(target, address, pname, params);}
void __stdcall _Lazy_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble * params)  {if (GLeeInit()) glGetVertexAttribdvNV(index, pname, params);}
void __stdcall _Lazy_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetVertexAttribfvNV(index, pname, params);}
void __stdcall _Lazy_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params)    {if (GLeeInit()) glGetVertexAttribivNV(index, pname, params);}
void __stdcall _Lazy_glGetVertexAttribPointervNV(GLuint index, GLenum pname, GLvoid* * pointer)  {if (GLeeInit()) glGetVertexAttribPointervNV(index, pname, pointer);}
GLboolean __stdcall _Lazy_glIsProgramNV(GLuint id)                                        {if (GLeeInit()) return glIsProgramNV(id); return (GLboolean)0;}
void __stdcall _Lazy_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte * program)  {if (GLeeInit()) glLoadProgramNV(target, id, len, program);}
void __stdcall _Lazy_glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)  {if (GLeeInit()) glProgramParameter4dNV(target, index, x, y, z, w);}
void __stdcall _Lazy_glProgramParameter4dvNV(GLenum target, GLuint index, const GLdouble * v)  {if (GLeeInit()) glProgramParameter4dvNV(target, index, v);}
void __stdcall _Lazy_glProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)  {if (GLeeInit()) glProgramParameter4fNV(target, index, x, y, z, w);}
void __stdcall _Lazy_glProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat * v)  {if (GLeeInit()) glProgramParameter4fvNV(target, index, v);}
void __stdcall _Lazy_glProgramParameters4dvNV(GLenum target, GLuint index, GLuint count, const GLdouble * v)  {if (GLeeInit()) glProgramParameters4dvNV(target, index, count, v);}
void __stdcall _Lazy_glProgramParameters4fvNV(GLenum target, GLuint index, GLuint count, const GLfloat * v)  {if (GLeeInit()) glProgramParameters4fvNV(target, index, count, v);}
void __stdcall _Lazy_glRequestResidentProgramsNV(GLsizei n, const GLuint * programs)      {if (GLeeInit()) glRequestResidentProgramsNV(n, programs);}
void __stdcall _Lazy_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform)  {if (GLeeInit()) glTrackMatrixNV(target, address, matrix, transform);}
void __stdcall _Lazy_glVertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid * pointer)  {if (GLeeInit()) glVertexAttribPointerNV(index, fsize, type, stride, pointer);}
void __stdcall _Lazy_glVertexAttrib1dNV(GLuint index, GLdouble x)                         {if (GLeeInit()) glVertexAttrib1dNV(index, x);}
void __stdcall _Lazy_glVertexAttrib1dvNV(GLuint index, const GLdouble * v)                {if (GLeeInit()) glVertexAttrib1dvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib1fNV(GLuint index, GLfloat x)                          {if (GLeeInit()) glVertexAttrib1fNV(index, x);}
void __stdcall _Lazy_glVertexAttrib1fvNV(GLuint index, const GLfloat * v)                 {if (GLeeInit()) glVertexAttrib1fvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib1sNV(GLuint index, GLshort x)                          {if (GLeeInit()) glVertexAttrib1sNV(index, x);}
void __stdcall _Lazy_glVertexAttrib1svNV(GLuint index, const GLshort * v)                 {if (GLeeInit()) glVertexAttrib1svNV(index, v);}
void __stdcall _Lazy_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y)             {if (GLeeInit()) glVertexAttrib2dNV(index, x, y);}
void __stdcall _Lazy_glVertexAttrib2dvNV(GLuint index, const GLdouble * v)                {if (GLeeInit()) glVertexAttrib2dvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)               {if (GLeeInit()) glVertexAttrib2fNV(index, x, y);}
void __stdcall _Lazy_glVertexAttrib2fvNV(GLuint index, const GLfloat * v)                 {if (GLeeInit()) glVertexAttrib2fvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y)               {if (GLeeInit()) glVertexAttrib2sNV(index, x, y);}
void __stdcall _Lazy_glVertexAttrib2svNV(GLuint index, const GLshort * v)                 {if (GLeeInit()) glVertexAttrib2svNV(index, v);}
void __stdcall _Lazy_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z)  {if (GLeeInit()) glVertexAttrib3dNV(index, x, y, z);}
void __stdcall _Lazy_glVertexAttrib3dvNV(GLuint index, const GLdouble * v)                {if (GLeeInit()) glVertexAttrib3dvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)    {if (GLeeInit()) glVertexAttrib3fNV(index, x, y, z);}
void __stdcall _Lazy_glVertexAttrib3fvNV(GLuint index, const GLfloat * v)                 {if (GLeeInit()) glVertexAttrib3fvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z)    {if (GLeeInit()) glVertexAttrib3sNV(index, x, y, z);}
void __stdcall _Lazy_glVertexAttrib3svNV(GLuint index, const GLshort * v)                 {if (GLeeInit()) glVertexAttrib3svNV(index, v);}
void __stdcall _Lazy_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)  {if (GLeeInit()) glVertexAttrib4dNV(index, x, y, z, w);}
void __stdcall _Lazy_glVertexAttrib4dvNV(GLuint index, const GLdouble * v)                {if (GLeeInit()) glVertexAttrib4dvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)  {if (GLeeInit()) glVertexAttrib4fNV(index, x, y, z, w);}
void __stdcall _Lazy_glVertexAttrib4fvNV(GLuint index, const GLfloat * v)                 {if (GLeeInit()) glVertexAttrib4fvNV(index, v);}
void __stdcall _Lazy_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)  {if (GLeeInit()) glVertexAttrib4sNV(index, x, y, z, w);}
void __stdcall _Lazy_glVertexAttrib4svNV(GLuint index, const GLshort * v)                 {if (GLeeInit()) glVertexAttrib4svNV(index, v);}
void __stdcall _Lazy_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)  {if (GLeeInit()) glVertexAttrib4ubNV(index, x, y, z, w);}
void __stdcall _Lazy_glVertexAttrib4ubvNV(GLuint index, const GLubyte * v)                {if (GLeeInit()) glVertexAttrib4ubvNV(index, v);}
void __stdcall _Lazy_glVertexAttribs1dvNV(GLuint index, GLsizei count, const GLdouble * v)  {if (GLeeInit()) glVertexAttribs1dvNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs1fvNV(GLuint index, GLsizei count, const GLfloat * v)  {if (GLeeInit()) glVertexAttribs1fvNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs1svNV(GLuint index, GLsizei count, const GLshort * v)  {if (GLeeInit()) glVertexAttribs1svNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs2dvNV(GLuint index, GLsizei count, const GLdouble * v)  {if (GLeeInit()) glVertexAttribs2dvNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs2fvNV(GLuint index, GLsizei count, const GLfloat * v)  {if (GLeeInit()) glVertexAttribs2fvNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs2svNV(GLuint index, GLsizei count, const GLshort * v)  {if (GLeeInit()) glVertexAttribs2svNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs3dvNV(GLuint index, GLsizei count, const GLdouble * v)  {if (GLeeInit()) glVertexAttribs3dvNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs3fvNV(GLuint index, GLsizei count, const GLfloat * v)  {if (GLeeInit()) glVertexAttribs3fvNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs3svNV(GLuint index, GLsizei count, const GLshort * v)  {if (GLeeInit()) glVertexAttribs3svNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs4dvNV(GLuint index, GLsizei count, const GLdouble * v)  {if (GLeeInit()) glVertexAttribs4dvNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs4fvNV(GLuint index, GLsizei count, const GLfloat * v)  {if (GLeeInit()) glVertexAttribs4fvNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs4svNV(GLuint index, GLsizei count, const GLshort * v)  {if (GLeeInit()) glVertexAttribs4svNV(index, count, v);}
void __stdcall _Lazy_glVertexAttribs4ubvNV(GLuint index, GLsizei count, const GLubyte * v)  {if (GLeeInit()) glVertexAttribs4ubvNV(index, count, v);}
PFNGLAREPROGRAMSRESIDENTNVPROC pglAreProgramsResidentNV=_Lazy_glAreProgramsResidentNV;
PFNGLBINDPROGRAMNVPROC pglBindProgramNV=_Lazy_glBindProgramNV;
PFNGLDELETEPROGRAMSNVPROC pglDeleteProgramsNV=_Lazy_glDeleteProgramsNV;
PFNGLEXECUTEPROGRAMNVPROC pglExecuteProgramNV=_Lazy_glExecuteProgramNV;
PFNGLGENPROGRAMSNVPROC pglGenProgramsNV=_Lazy_glGenProgramsNV;
PFNGLGETPROGRAMPARAMETERDVNVPROC pglGetProgramParameterdvNV=_Lazy_glGetProgramParameterdvNV;
PFNGLGETPROGRAMPARAMETERFVNVPROC pglGetProgramParameterfvNV=_Lazy_glGetProgramParameterfvNV;
PFNGLGETPROGRAMIVNVPROC pglGetProgramivNV=_Lazy_glGetProgramivNV;
PFNGLGETPROGRAMSTRINGNVPROC pglGetProgramStringNV=_Lazy_glGetProgramStringNV;
PFNGLGETTRACKMATRIXIVNVPROC pglGetTrackMatrixivNV=_Lazy_glGetTrackMatrixivNV;
PFNGLGETVERTEXATTRIBDVNVPROC pglGetVertexAttribdvNV=_Lazy_glGetVertexAttribdvNV;
PFNGLGETVERTEXATTRIBFVNVPROC pglGetVertexAttribfvNV=_Lazy_glGetVertexAttribfvNV;
PFNGLGETVERTEXATTRIBIVNVPROC pglGetVertexAttribivNV=_Lazy_glGetVertexAttribivNV;
PFNGLGETVERTEXATTRIBPOINTERVNVPROC pglGetVertexAttribPointervNV=_Lazy_glGetVertexAttribPointervNV;
PFNGLISPROGRAMNVPROC pglIsProgramNV=_Lazy_glIsProgramNV;
PFNGLLOADPROGRAMNVPROC pglLoadProgramNV=_Lazy_glLoadProgramNV;
PFNGLPROGRAMPARAMETER4DNVPROC pglProgramParameter4dNV=_Lazy_glProgramParameter4dNV;
PFNGLPROGRAMPARAMETER4DVNVPROC pglProgramParameter4dvNV=_Lazy_glProgramParameter4dvNV;
PFNGLPROGRAMPARAMETER4FNVPROC pglProgramParameter4fNV=_Lazy_glProgramParameter4fNV;
PFNGLPROGRAMPARAMETER4FVNVPROC pglProgramParameter4fvNV=_Lazy_glProgramParameter4fvNV;
PFNGLPROGRAMPARAMETERS4DVNVPROC pglProgramParameters4dvNV=_Lazy_glProgramParameters4dvNV;
PFNGLPROGRAMPARAMETERS4FVNVPROC pglProgramParameters4fvNV=_Lazy_glProgramParameters4fvNV;
PFNGLREQUESTRESIDENTPROGRAMSNVPROC pglRequestResidentProgramsNV=_Lazy_glRequestResidentProgramsNV;
PFNGLTRACKMATRIXNVPROC pglTrackMatrixNV=_Lazy_glTrackMatrixNV;
PFNGLVERTEXATTRIBPOINTERNVPROC pglVertexAttribPointerNV=_Lazy_glVertexAttribPointerNV;
PFNGLVERTEXATTRIB1DNVPROC pglVertexAttrib1dNV=_Lazy_glVertexAttrib1dNV;
PFNGLVERTEXATTRIB1DVNVPROC pglVertexAttrib1dvNV=_Lazy_glVertexAttrib1dvNV;
PFNGLVERTEXATTRIB1FNVPROC pglVertexAttrib1fNV=_Lazy_glVertexAttrib1fNV;
PFNGLVERTEXATTRIB1FVNVPROC pglVertexAttrib1fvNV=_Lazy_glVertexAttrib1fvNV;
PFNGLVERTEXATTRIB1SNVPROC pglVertexAttrib1sNV=_Lazy_glVertexAttrib1sNV;
PFNGLVERTEXATTRIB1SVNVPROC pglVertexAttrib1svNV=_Lazy_glVertexAttrib1svNV;
PFNGLVERTEXATTRIB2DNVPROC pglVertexAttrib2dNV=_Lazy_glVertexAttrib2dNV;
PFNGLVERTEXATTRIB2DVNVPROC pglVertexAttrib2dvNV=_Lazy_glVertexAttrib2dvNV;
PFNGLVERTEXATTRIB2FNVPROC pglVertexAttrib2fNV=_Lazy_glVertexAttrib2fNV;
PFNGLVERTEXATTRIB2FVNVPROC pglVertexAttrib2fvNV=_Lazy_glVertexAttrib2fvNV;
PFNGLVERTEXATTRIB2SNVPROC pglVertexAttrib2sNV=_Lazy_glVertexAttrib2sNV;
PFNGLVERTEXATTRIB2SVNVPROC pglVertexAttrib2svNV=_Lazy_glVertexAttrib2svNV;
PFNGLVERTEXATTRIB3DNVPROC pglVertexAttrib3dNV=_Lazy_glVertexAttrib3dNV;
PFNGLVERTEXATTRIB3DVNVPROC pglVertexAttrib3dvNV=_Lazy_glVertexAttrib3dvNV;
PFNGLVERTEXATTRIB3FNVPROC pglVertexAttrib3fNV=_Lazy_glVertexAttrib3fNV;
PFNGLVERTEXATTRIB3FVNVPROC pglVertexAttrib3fvNV=_Lazy_glVertexAttrib3fvNV;
PFNGLVERTEXATTRIB3SNVPROC pglVertexAttrib3sNV=_Lazy_glVertexAttrib3sNV;
PFNGLVERTEXATTRIB3SVNVPROC pglVertexAttrib3svNV=_Lazy_glVertexAttrib3svNV;
PFNGLVERTEXATTRIB4DNVPROC pglVertexAttrib4dNV=_Lazy_glVertexAttrib4dNV;
PFNGLVERTEXATTRIB4DVNVPROC pglVertexAttrib4dvNV=_Lazy_glVertexAttrib4dvNV;
PFNGLVERTEXATTRIB4FNVPROC pglVertexAttrib4fNV=_Lazy_glVertexAttrib4fNV;
PFNGLVERTEXATTRIB4FVNVPROC pglVertexAttrib4fvNV=_Lazy_glVertexAttrib4fvNV;
PFNGLVERTEXATTRIB4SNVPROC pglVertexAttrib4sNV=_Lazy_glVertexAttrib4sNV;
PFNGLVERTEXATTRIB4SVNVPROC pglVertexAttrib4svNV=_Lazy_glVertexAttrib4svNV;
PFNGLVERTEXATTRIB4UBNVPROC pglVertexAttrib4ubNV=_Lazy_glVertexAttrib4ubNV;
PFNGLVERTEXATTRIB4UBVNVPROC pglVertexAttrib4ubvNV=_Lazy_glVertexAttrib4ubvNV;
PFNGLVERTEXATTRIBS1DVNVPROC pglVertexAttribs1dvNV=_Lazy_glVertexAttribs1dvNV;
PFNGLVERTEXATTRIBS1FVNVPROC pglVertexAttribs1fvNV=_Lazy_glVertexAttribs1fvNV;
PFNGLVERTEXATTRIBS1SVNVPROC pglVertexAttribs1svNV=_Lazy_glVertexAttribs1svNV;
PFNGLVERTEXATTRIBS2DVNVPROC pglVertexAttribs2dvNV=_Lazy_glVertexAttribs2dvNV;
PFNGLVERTEXATTRIBS2FVNVPROC pglVertexAttribs2fvNV=_Lazy_glVertexAttribs2fvNV;
PFNGLVERTEXATTRIBS2SVNVPROC pglVertexAttribs2svNV=_Lazy_glVertexAttribs2svNV;
PFNGLVERTEXATTRIBS3DVNVPROC pglVertexAttribs3dvNV=_Lazy_glVertexAttribs3dvNV;
PFNGLVERTEXATTRIBS3FVNVPROC pglVertexAttribs3fvNV=_Lazy_glVertexAttribs3fvNV;
PFNGLVERTEXATTRIBS3SVNVPROC pglVertexAttribs3svNV=_Lazy_glVertexAttribs3svNV;
PFNGLVERTEXATTRIBS4DVNVPROC pglVertexAttribs4dvNV=_Lazy_glVertexAttribs4dvNV;
PFNGLVERTEXATTRIBS4FVNVPROC pglVertexAttribs4fvNV=_Lazy_glVertexAttribs4fvNV;
PFNGLVERTEXATTRIBS4SVNVPROC pglVertexAttribs4svNV=_Lazy_glVertexAttribs4svNV;
PFNGLVERTEXATTRIBS4UBVNVPROC pglVertexAttribs4ubvNV=_Lazy_glVertexAttribs4ubvNV;
#endif 

/* GL_SGIX_texture_coordinate_clamp */

#ifdef __GLEE_GL_SGIX_texture_coordinate_clamp
#endif 

/* GL_SGIX_scalebias_hint */

#ifdef __GLEE_GL_SGIX_scalebias_hint
#endif 

/* GL_OML_interlace */

#ifdef __GLEE_GL_OML_interlace
#endif 

/* GL_OML_subsample */

#ifdef __GLEE_GL_OML_subsample
#endif 

/* GL_OML_resample */

#ifdef __GLEE_GL_OML_resample
#endif 

/* GL_NV_copy_depth_to_color */

#ifdef __GLEE_GL_NV_copy_depth_to_color
#endif 

/* GL_ATI_envmap_bumpmap */

#ifdef __GLEE_GL_ATI_envmap_bumpmap
void __stdcall _Lazy_glTexBumpParameterivATI(GLenum pname, const GLint * param)           {if (GLeeInit()) glTexBumpParameterivATI(pname, param);}
void __stdcall _Lazy_glTexBumpParameterfvATI(GLenum pname, const GLfloat * param)         {if (GLeeInit()) glTexBumpParameterfvATI(pname, param);}
void __stdcall _Lazy_glGetTexBumpParameterivATI(GLenum pname, GLint * param)              {if (GLeeInit()) glGetTexBumpParameterivATI(pname, param);}
void __stdcall _Lazy_glGetTexBumpParameterfvATI(GLenum pname, GLfloat * param)            {if (GLeeInit()) glGetTexBumpParameterfvATI(pname, param);}
PFNGLTEXBUMPPARAMETERIVATIPROC pglTexBumpParameterivATI=_Lazy_glTexBumpParameterivATI;
PFNGLTEXBUMPPARAMETERFVATIPROC pglTexBumpParameterfvATI=_Lazy_glTexBumpParameterfvATI;
PFNGLGETTEXBUMPPARAMETERIVATIPROC pglGetTexBumpParameterivATI=_Lazy_glGetTexBumpParameterivATI;
PFNGLGETTEXBUMPPARAMETERFVATIPROC pglGetTexBumpParameterfvATI=_Lazy_glGetTexBumpParameterfvATI;
#endif 

/* GL_ATI_fragment_shader */

#ifdef __GLEE_GL_ATI_fragment_shader
GLuint __stdcall _Lazy_glGenFragmentShadersATI(GLuint range)                              {if (GLeeInit()) return glGenFragmentShadersATI(range); return (GLuint)0;}
void __stdcall _Lazy_glBindFragmentShaderATI(GLuint id)                                   {if (GLeeInit()) glBindFragmentShaderATI(id);}
void __stdcall _Lazy_glDeleteFragmentShaderATI(GLuint id)                                 {if (GLeeInit()) glDeleteFragmentShaderATI(id);}
void __stdcall _Lazy_glBeginFragmentShaderATI(void)                                       {if (GLeeInit()) glBeginFragmentShaderATI();}
void __stdcall _Lazy_glEndFragmentShaderATI(void)                                         {if (GLeeInit()) glEndFragmentShaderATI();}
void __stdcall _Lazy_glPassTexCoordATI(GLuint dst, GLuint coord, GLenum swizzle)          {if (GLeeInit()) glPassTexCoordATI(dst, coord, swizzle);}
void __stdcall _Lazy_glSampleMapATI(GLuint dst, GLuint interp, GLenum swizzle)            {if (GLeeInit()) glSampleMapATI(dst, interp, swizzle);}
void __stdcall _Lazy_glColorFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)  {if (GLeeInit()) glColorFragmentOp1ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod);}
void __stdcall _Lazy_glColorFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)  {if (GLeeInit()) glColorFragmentOp2ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);}
void __stdcall _Lazy_glColorFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)  {if (GLeeInit()) glColorFragmentOp3ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);}
void __stdcall _Lazy_glAlphaFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)  {if (GLeeInit()) glAlphaFragmentOp1ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod);}
void __stdcall _Lazy_glAlphaFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)  {if (GLeeInit()) glAlphaFragmentOp2ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);}
void __stdcall _Lazy_glAlphaFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)  {if (GLeeInit()) glAlphaFragmentOp3ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);}
void __stdcall _Lazy_glSetFragmentShaderConstantATI(GLuint dst, const GLfloat * value)    {if (GLeeInit()) glSetFragmentShaderConstantATI(dst, value);}
PFNGLGENFRAGMENTSHADERSATIPROC pglGenFragmentShadersATI=_Lazy_glGenFragmentShadersATI;
PFNGLBINDFRAGMENTSHADERATIPROC pglBindFragmentShaderATI=_Lazy_glBindFragmentShaderATI;
PFNGLDELETEFRAGMENTSHADERATIPROC pglDeleteFragmentShaderATI=_Lazy_glDeleteFragmentShaderATI;
PFNGLBEGINFRAGMENTSHADERATIPROC pglBeginFragmentShaderATI=_Lazy_glBeginFragmentShaderATI;
PFNGLENDFRAGMENTSHADERATIPROC pglEndFragmentShaderATI=_Lazy_glEndFragmentShaderATI;
PFNGLPASSTEXCOORDATIPROC pglPassTexCoordATI=_Lazy_glPassTexCoordATI;
PFNGLSAMPLEMAPATIPROC pglSampleMapATI=_Lazy_glSampleMapATI;
PFNGLCOLORFRAGMENTOP1ATIPROC pglColorFragmentOp1ATI=_Lazy_glColorFragmentOp1ATI;
PFNGLCOLORFRAGMENTOP2ATIPROC pglColorFragmentOp2ATI=_Lazy_glColorFragmentOp2ATI;
PFNGLCOLORFRAGMENTOP3ATIPROC pglColorFragmentOp3ATI=_Lazy_glColorFragmentOp3ATI;
PFNGLALPHAFRAGMENTOP1ATIPROC pglAlphaFragmentOp1ATI=_Lazy_glAlphaFragmentOp1ATI;
PFNGLALPHAFRAGMENTOP2ATIPROC pglAlphaFragmentOp2ATI=_Lazy_glAlphaFragmentOp2ATI;
PFNGLALPHAFRAGMENTOP3ATIPROC pglAlphaFragmentOp3ATI=_Lazy_glAlphaFragmentOp3ATI;
PFNGLSETFRAGMENTSHADERCONSTANTATIPROC pglSetFragmentShaderConstantATI=_Lazy_glSetFragmentShaderConstantATI;
#endif 

/* GL_ATI_pn_triangles */

#ifdef __GLEE_GL_ATI_pn_triangles
void __stdcall _Lazy_glPNTrianglesiATI(GLenum pname, GLint param)                         {if (GLeeInit()) glPNTrianglesiATI(pname, param);}
void __stdcall _Lazy_glPNTrianglesfATI(GLenum pname, GLfloat param)                       {if (GLeeInit()) glPNTrianglesfATI(pname, param);}
PFNGLPNTRIANGLESIATIPROC pglPNTrianglesiATI=_Lazy_glPNTrianglesiATI;
PFNGLPNTRIANGLESFATIPROC pglPNTrianglesfATI=_Lazy_glPNTrianglesfATI;
#endif 

/* GL_ATI_vertex_array_object */

#ifdef __GLEE_GL_ATI_vertex_array_object
GLuint __stdcall _Lazy_glNewObjectBufferATI(GLsizei size, const GLvoid * pointer, GLenum usage)  {if (GLeeInit()) return glNewObjectBufferATI(size, pointer, usage); return (GLuint)0;}
GLboolean __stdcall _Lazy_glIsObjectBufferATI(GLuint buffer)                              {if (GLeeInit()) return glIsObjectBufferATI(buffer); return (GLboolean)0;}
void __stdcall _Lazy_glUpdateObjectBufferATI(GLuint buffer, GLuint offset, GLsizei size, const GLvoid * pointer, GLenum preserve)  {if (GLeeInit()) glUpdateObjectBufferATI(buffer, offset, size, pointer, preserve);}
void __stdcall _Lazy_glGetObjectBufferfvATI(GLuint buffer, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetObjectBufferfvATI(buffer, pname, params);}
void __stdcall _Lazy_glGetObjectBufferivATI(GLuint buffer, GLenum pname, GLint * params)  {if (GLeeInit()) glGetObjectBufferivATI(buffer, pname, params);}
void __stdcall _Lazy_glFreeObjectBufferATI(GLuint buffer)                                 {if (GLeeInit()) glFreeObjectBufferATI(buffer);}
void __stdcall _Lazy_glArrayObjectATI(GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset)  {if (GLeeInit()) glArrayObjectATI(array, size, type, stride, buffer, offset);}
void __stdcall _Lazy_glGetArrayObjectfvATI(GLenum array, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetArrayObjectfvATI(array, pname, params);}
void __stdcall _Lazy_glGetArrayObjectivATI(GLenum array, GLenum pname, GLint * params)    {if (GLeeInit()) glGetArrayObjectivATI(array, pname, params);}
void __stdcall _Lazy_glVariantArrayObjectATI(GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset)  {if (GLeeInit()) glVariantArrayObjectATI(id, type, stride, buffer, offset);}
void __stdcall _Lazy_glGetVariantArrayObjectfvATI(GLuint id, GLenum pname, GLfloat * params)  {if (GLeeInit()) glGetVariantArrayObjectfvATI(id, pname, params);}
void __stdcall _Lazy_glGetVariantArrayObjectivATI(GLuint id, GLenum pname, GLint * params)  {if (GLeeInit()) glGetVariantArrayObjectivATI(id, pname, params);}
PFNGLNEWOBJECTBUFFERATIPROC pglNewObjectBufferATI=_Lazy_glNewObjectBufferATI;
PFNGLISOBJECTBUFFERATIPROC pglIsObjectBufferATI=_Lazy_glIsObjectBufferATI;
PFNGLUPDATEOBJECTBUFFERATIPROC pglUpdateObjectBufferATI=_Lazy_glUpdateObjectBufferATI;
PFNGLGETOBJECTBUFFERFVATIPROC pglGetObjectBufferfvATI=_Lazy_glGetObjectBufferfvATI;
PFNGLGETOBJECTBUFFERIVATIPROC pglGetObjectBufferivATI=_Lazy_glGetObjectBufferivATI;
PFNGLFREEOBJECTBUFFERATIPROC pglFreeObjectBufferATI=_Lazy_glFreeObjectBufferATI;
PFNGLARRAYOBJECTATIPROC pglArrayObjectATI=_Lazy_glArrayObjectATI;
PFNGLGETARRAYOBJECTFVATIPROC pglGetArrayObjectfvATI=_Lazy_glGetArrayObjectfvATI;
PFNGLGETARRAYOBJECTIVATIPROC pglGetArrayObjectivATI=_Lazy_glGetArrayObjectivATI;
PFNGLVARIANTARRAYOBJECTATIPROC pglVariantArrayObjectATI=_Lazy_glVariantArrayObjectATI;
PFNGLGETVARIANTARRAYOBJECTFVATIPROC pglGetVariantArrayObjectfvATI=_Lazy_glGetVariantArrayObjectfvATI;
PFNGLGETVARIANTARRAYOBJECTIVATIPROC pglGetVariantArrayObjectivATI=_Lazy_glGetVariantArrayObjectivATI;
#endif 

/* GL_EXT_vertex_shader */

#ifdef __GLEE_GL_EXT_vertex_shader
void __stdcall _Lazy_glBeginVertexShaderEXT(void)                                         {if (GLeeInit()) glBeginVertexShaderEXT();}
void __stdcall _Lazy_glEndVertexShaderEXT(void)                                           {if (GLeeInit()) glEndVertexShaderEXT();}
void __stdcall _Lazy_glBindVertexShaderEXT(GLuint id)                                     {if (GLeeInit()) glBindVertexShaderEXT(id);}
GLuint __stdcall _Lazy_glGenVertexShadersEXT(GLuint range)                                {if (GLeeInit()) return glGenVertexShadersEXT(range); return (GLuint)0;}
void __stdcall _Lazy_glDeleteVertexShaderEXT(GLuint id)                                   {if (GLeeInit()) glDeleteVertexShaderEXT(id);}
void __stdcall _Lazy_glShaderOp1EXT(GLenum op, GLuint res, GLuint arg1)                   {if (GLeeInit()) glShaderOp1EXT(op, res, arg1);}
void __stdcall _Lazy_glShaderOp2EXT(GLenum op, GLuint res, GLuint arg1, GLuint arg2)      {if (GLeeInit()) glShaderOp2EXT(op, res, arg1, arg2);}
void __stdcall _Lazy_glShaderOp3EXT(GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3)  {if (GLeeInit()) glShaderOp3EXT(op, res, arg1, arg2, arg3);}
void __stdcall _Lazy_glSwizzleEXT(GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW)  {if (GLeeInit()) glSwizzleEXT(res, in, outX, outY, outZ, outW);}
void __stdcall _Lazy_glWriteMaskEXT(GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW)  {if (GLeeInit()) glWriteMaskEXT(res, in, outX, outY, outZ, outW);}
void __stdcall _Lazy_glInsertComponentEXT(GLuint res, GLuint src, GLuint num)             {if (GLeeInit()) glInsertComponentEXT(res, src, num);}
void __stdcall _Lazy_glExtractComponentEXT(GLuint res, GLuint src, GLuint num)            {if (GLeeInit()) glExtractComponentEXT(res, src, num);}
GLuint __stdcall _Lazy_glGenSymbolsEXT(GLenum datatype, GLenum storagetype, GLenum range, GLuint components)  {if (GLeeInit()) return glGenSymbolsEXT(datatype, storagetype, range, components); return (GLuint)0;}
void __stdcall _Lazy_glSetInvariantEXT(GLuint id, GLenum type, const GLvoid * addr)       {if (GLeeInit()) glSetInvariantEXT(id, type, addr);}
void __stdcall _Lazy_glSetLocalConstantEXT(GLuint id, GLenum type, const GLvoid * addr)   {if (GLeeInit()) glSetLocalConstantEXT(id, type, addr);}
void __stdcall _Lazy_glVariantbvEXT(GLuint id, const GLbyte * addr)                       {if (GLeeInit()) glVariantbvEXT(id, addr);}
void __stdcall _Lazy_glVariantsvEXT(GLuint id, const GLshort * addr)                      {if (GLeeInit()) glVariantsvEXT(id, addr);}
void __stdcall _Lazy_glVariantivEXT(GLuint id, const GLint * addr)                        {if (GLeeInit()) glVariantivEXT(id, addr);}
void __stdcall _Lazy_glVariantfvEXT(GLuint id, const GLfloat * addr)                      {if (GLeeInit()) glVariantfvEXT(id, addr);}
void __stdcall _Lazy_glVariantdvEXT(GLuint id, const GLdouble * addr)                     {if (GLeeInit()) glVariantdvEXT(id, addr);}
void __stdcall _Lazy_glVariantubvEXT(GLuint id, const GLubyte * addr)                     {if (GLeeInit()) glVariantubvEXT(id, addr);}
void __stdcall _Lazy_glVariantusvEXT(GLuint id, const GLushort * addr)                    {if (GLeeInit()) glVariantusvEXT(id, addr);}
void __stdcall _Lazy_glVariantuivEXT(GLuint id, const GLuint * addr)                      {if (GLeeInit()) glVariantuivEXT(id, addr);}
void __stdcall _Lazy_glVariantPointerEXT(GLuint id, GLenum type, GLuint stride, const GLvoid * addr)  {if (GLeeInit()) glVariantPointerEXT(id, type, stride, addr);}
void __stdcall _Lazy_glEnableVariantClientStateEXT(GLuint id)                             {if (GLeeInit()) glEnableVariantClientStateEXT(id);}
void __stdcall _Lazy_glDisableVariantClientStateEXT(GLuint id)                            {if (GLeeInit()) glDisableVariantClientStateEXT(id);}
GLuint __stdcall _Lazy_glBindLightParameterEXT(GLenum light, GLenum value)                {if (GLeeInit()) return glBindLightParameterEXT(light, value); return (GLuint)0;}
GLuint __stdcall _Lazy_glBindMaterialParameterEXT(GLenum face, GLenum value)              {if (GLeeInit()) return glBindMaterialParameterEXT(face, value); return (GLuint)0;}
GLuint __stdcall _Lazy_glBindTexGenParameterEXT(GLenum unit, GLenum coord, GLenum value)  {if (GLeeInit()) return glBindTexGenParameterEXT(unit, coord, value); return (GLuint)0;}
GLuint __stdcall _Lazy_glBindTextureUnitParameterEXT(GLenum unit, GLenum value)           {if (GLeeInit()) return glBindTextureUnitParameterEXT(unit, value); return (GLuint)0;}
GLuint __stdcall _Lazy_glBindParameterEXT(GLenum value)                                   {if (GLeeInit()) return glBindParameterEXT(value); return (GLuint)0;}
GLboolean __stdcall _Lazy_glIsVariantEnabledEXT(GLuint id, GLenum cap)                    {if (GLeeInit()) return glIsVariantEnabledEXT(id, cap); return (GLboolean)0;}
void __stdcall _Lazy_glGetVariantBooleanvEXT(GLuint id, GLenum value, GLboolean * data)   {if (GLeeInit()) glGetVariantBooleanvEXT(id, value, data);}
void __stdcall _Lazy_glGetVariantIntegervEXT(GLuint id, GLenum value, GLint * data)       {if (GLeeInit()) glGetVariantIntegervEXT(id, value, data);}
void __stdcall _Lazy_glGetVariantFloatvEXT(GLuint id, GLenum value, GLfloat * data)       {if (GLeeInit()) glGetVariantFloatvEXT(id, value, data);}
void __stdcall _Lazy_glGetVariantPointervEXT(GLuint id, GLenum value, GLvoid* * data)     {if (GLeeInit()) glGetVariantPointervEXT(id, value, data);}
void __stdcall _Lazy_glGetInvariantBooleanvEXT(GLuint id, GLenum value, GLboolean * data)  {if (GLeeInit()) glGetInvariantBooleanvEXT(id, value, data);}
void __stdcall _Lazy_glGetInvariantIntegervEXT(GLuint id, GLenum value, GLint * data)     {if (GLeeInit()) glGetInvariantIntegervEXT(id, value, data);}
void __stdcall _Lazy_glGetInvariantFloatvEXT(GLuint id, GLenum value, GLfloat * data)     {if (GLeeInit()) glGetInvariantFloatvEXT(id, value, data);}
void __stdcall _Lazy_glGetLocalConstantBooleanvEXT(GLuint id, GLenum value, GLboolean * data)  {if (GLeeInit()) glGetLocalConstantBooleanvEXT(id, value, data);}
void __stdcall _Lazy_glGetLocalConstantIntegervEXT(GLuint id, GLenum value, GLint * data)  {if (GLeeInit()) glGetLocalConstantIntegervEXT(id, value, data);}
void __stdcall _Lazy_glGetLocalConstantFloatvEXT(GLuint id, GLenum value, GLfloat * data)  {if (GLeeInit()) glGetLocalConstantFloatvEXT(id, value, data);}
PFNGLBEGINVERTEXSHADEREXTPROC pglBeginVertexShaderEXT=_Lazy_glBeginVertexShaderEXT;
PFNGLENDVERTEXSHADEREXTPROC pglEndVertexShaderEXT=_Lazy_glEndVertexShaderEXT;
PFNGLBINDVERTEXSHADEREXTPROC pglBindVertexShaderEXT=_Lazy_glBindVertexShaderEXT;
PFNGLGENVERTEXSHADERSEXTPROC pglGenVertexShadersEXT=_Lazy_glGenVertexShadersEXT;
PFNGLDELETEVERTEXSHADEREXTPROC pglDeleteVertexShaderEXT=_Lazy_glDeleteVertexShaderEXT;
PFNGLSHADEROP1EXTPROC pglShaderOp1EXT=_Lazy_glShaderOp1EXT;
PFNGLSHADEROP2EXTPROC pglShaderOp2EXT=_Lazy_glShaderOp2EXT;
PFNGLSHADEROP3EXTPROC pglShaderOp3EXT=_Lazy_glShaderOp3EXT;
PFNGLSWIZZLEEXTPROC pglSwizzleEXT=_Lazy_glSwizzleEXT;
PFNGLWRITEMASKEXTPROC pglWriteMaskEXT=_Lazy_glWriteMaskEXT;
PFNGLINSERTCOMPONENTEXTPROC pglInsertComponentEXT=_Lazy_glInsertComponentEXT;
PFNGLEXTRACTCOMPONENTEXTPROC pglExtractComponentEXT=_Lazy_glExtractComponentEXT;
PFNGLGENSYMBOLSEXTPROC pglGenSymbolsEXT=_Lazy_glGenSymbolsEXT;
PFNGLSETINVARIANTEXTPROC pglSetInvariantEXT=_Lazy_glSetInvariantEXT;
PFNGLSETLOCALCONSTANTEXTPROC pglSetLocalConstantEXT=_Lazy_glSetLocalConstantEXT;
PFNGLVARIANTBVEXTPROC pglVariantbvEXT=_Lazy_glVariantbvEXT;
PFNGLVARIANTSVEXTPROC pglVariantsvEXT=_Lazy_glVariantsvEXT;
PFNGLVARIANTIVEXTPROC pglVariantivEXT=_Lazy_glVariantivEXT;
PFNGLVARIANTFVEXTPROC pglVariantfvEXT=_Lazy_glVariantfvEXT;
PFNGLVARIANTDVEXTPROC pglVariantdvEXT=_Lazy_glVariantdvEXT;
PFNGLVARIANTUBVEXTPROC pglVariantubvEXT=_Lazy_glVariantubvEXT;
PFNGLVARIANTUSVEXTPROC pglVariantusvEXT=_Lazy_glVariantusvEXT;
PFNGLVARIANTUIVEXTPROC pglVariantuivEXT=_Lazy_glVariantuivEXT;
PFNGLVARIANTPOINTEREXTPROC pglVariantPointerEXT=_Lazy_glVariantPointerEXT;
PFNGLENABLEVARIANTCLIENTSTATEEXTPROC pglEnableVariantClientStateEXT=_Lazy_glEnableVariantClientStateEXT;
PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC pglDisableVariantClientStateEXT=_Lazy_glDisableVariantClientStateEXT;
PFNGLBINDLIGHTPARAMETEREXTPROC pglBindLightParameterEXT=_Lazy_glBindLightParameterEXT;
PFNGLBINDMATERIALPARAMETEREXTPROC pglBindMaterialParameterEXT=_Lazy_glBindMaterialParameterEXT;
PFNGLBINDTEXGENPARAMETEREXTPROC pglBindTexGenParameterEXT=_Lazy_glBindTexGenParameterEXT;
PFNGLBINDTEXTUREUNITPARAMETEREXTPROC pglBindTextureUnitParameterEXT=_Lazy_glBindTextureUnitParameterEXT;
PFNGLBINDPARAMETEREXTPROC pglBindParameterEXT=_Lazy_glBindParameterEXT;
PFNGLISVARIANTENABLEDEXTPROC pglIsVariantEnabledEXT=_Lazy_glIsVariantEnabledEXT;
PFNGLGETVARIANTBOOLEANVEXTPROC pglGetVariantBooleanvEXT=_Lazy_glGetVariantBooleanvEXT;
PFNGLGETVARIANTINTEGERVEXTPROC pglGetVariantIntegervEXT=_Lazy_glGetVariantIntegervEXT;
PFNGLGETVARIANTFLOATVEXTPROC pglGetVariantFloatvEXT=_Lazy_glGetVariantFloatvEXT;
PFNGLGETVARIANTPOINTERVEXTPROC pglGetVariantPointervEXT=_Lazy_glGetVariantPointervEXT;
PFNGLGETINVARIANTBOOLEANVEXTPROC pglGetInvariantBooleanvEXT=_Lazy_glGetInvariantBooleanvEXT;
PFNGLGETINVARIANTINTEGERVEXTPROC pglGetInvariantIntegervEXT=_Lazy_glGetInvariantIntegervEXT;
PFNGLGETINVARIANTFLOATVEXTPROC pglGetInvariantFloatvEXT=_Lazy_glGetInvariantFloatvEXT;
PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC pglGetLocalConstantBooleanvEXT=_Lazy_glGetLocalConstantBooleanvEXT;
PFNGLGETLOCALCONSTANTINTEGERVEXTPROC pglGetLocalConstantIntegervEXT=_Lazy_glGetLocalConstantIntegervEXT;
PFNGLGETLOCALCONSTANTFLOATVEXTPROC pglGetLocalConstantFloatvEXT=_Lazy_glGetLocalConstantFloatvEXT;
#endif 

/* GL_ATI_vertex_streams */

#ifdef __GLEE_GL_ATI_vertex_streams
void __stdcall _Lazy_glVertexStream1sATI(GLenum stream, GLshort x)                        {if (GLeeInit()) glVertexStream1sATI(stream, x);}
void __stdcall _Lazy_glVertexStream1svATI(GLenum stream, const GLshort * coords)          {if (GLeeInit()) glVertexStream1svATI(stream, coords);}
void __stdcall _Lazy_glVertexStream1iATI(GLenum stream, GLint x)                          {if (GLeeInit()) glVertexStream1iATI(stream, x);}
void __stdcall _Lazy_glVertexStream1ivATI(GLenum stream, const GLint * coords)            {if (GLeeInit()) glVertexStream1ivATI(stream, coords);}
void __stdcall _Lazy_glVertexStream1fATI(GLenum stream, GLfloat x)                        {if (GLeeInit()) glVertexStream1fATI(stream, x);}
void __stdcall _Lazy_glVertexStream1fvATI(GLenum stream, const GLfloat * coords)          {if (GLeeInit()) glVertexStream1fvATI(stream, coords);}
void __stdcall _Lazy_glVertexStream1dATI(GLenum stream, GLdouble x)                       {if (GLeeInit()) glVertexStream1dATI(stream, x);}
void __stdcall _Lazy_glVertexStream1dvATI(GLenum stream, const GLdouble * coords)         {if (GLeeInit()) glVertexStream1dvATI(stream, coords);}
void __stdcall _Lazy_glVertexStream2sATI(GLenum stream, GLshort x, GLshort y)             {if (GLeeInit()) glVertexStream2sATI(stream, x, y);}
void __stdcall _Lazy_glVertexStream2svATI(GLenum stream, const GLshort * coords)          {if (GLeeInit()) glVertexStream2svATI(stream, coords);}
void __stdcall _Lazy_glVertexStream2iATI(GLenum stream, GLint x, GLint y)                 {if (GLeeInit()) glVertexStream2iATI(stream, x, y);}
void __stdcall _Lazy_glVertexStream2ivATI(GLenum stream, const GLint * coords)            {if (GLeeInit()) glVertexStream2ivATI(stream, coords);}
void __stdcall _Lazy_glVertexStream2fATI(GLenum stream, GLfloat x, GLfloat y)             {if (GLeeInit()) glVertexStream2fATI(stream, x, y);}
void __stdcall _Lazy_glVertexStream2fvATI(GLenum stream, const GLfloat * coords)          {if (GLeeInit()) glVertexStream2fvATI(stream, coords);}
void __stdcall _Lazy_glVertexStream2dATI(GLenum stream, GLdouble x, GLdouble y)           {if (GLeeInit()) glVertexStream2dATI(stream, x, y);}
void __stdcall _Lazy_glVertexStream2dvATI(GLenum stream, const GLdouble * coords)         {if (GLeeInit()) glVertexStream2dvATI(stream, coords);}
void __stdcall _Lazy_glVertexStream3sATI(GLenum stream, GLshort x, GLshort y, GLshort z)  {if (GLeeInit()) glVertexStream3sATI(stream, x, y, z);}
void __stdcall _Lazy_glVertexStream3svATI(GLenum stream, const GLshort * coords)          {if (GLeeInit()) glVertexStream3svATI(stream, coords);}
void __stdcall _Lazy_glVertexStream3iATI(GLenum stream, GLint x, GLint y, GLint z)        {if (GLeeInit()) glVertexStream3iATI(stream, x, y, z);}
void __stdcall _Lazy_glVertexStream3ivATI(GLenum stream, const GLint * coords)            {if (GLeeInit()) glVertexStream3ivATI(stream, coords);}
void __stdcall _Lazy_glVertexStream3fATI(GLenum stream, GLfloat x, GLfloat y, GLfloat z)  {if (GLeeInit()) glVertexStream3fATI(stream, x, y, z);}
void __stdcall _Lazy_glVertexStream3fvATI(GLenum stream, const GLfloat * coords)          {if (GLeeInit()) glVertexStream3fvATI(stream, coords);}
void __stdcall _Lazy_glVertexStream3dATI(GLenum stream, GLdouble x, GLdouble y, GLdouble z)  {if (GLeeInit()) glVertexStream3dATI(stream, x, y, z);}
void __stdcall _Lazy_glVertexStream3dvATI(GLenum stream, const GLdouble * coords)         {if (GLeeInit()) glVertexStream3dvATI(stream, coords);}
void __stdcall _Lazy_glVertexStream4sATI(GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w)  {if (GLeeInit()) glVertexStream4sATI(stream, x, y, z, w);}
void __stdcall _Lazy_glVertexStream4svATI(GLenum stream, const GLshort * coords)          {if (GLeeInit()) glVertexStream4svATI(stream, coords);}
void __stdcall _Lazy_glVertexStream4iATI(GLenum stream, GLint x, GLint y, GLint z, GLint w)  {if (GLeeInit()) glVertexStream4iATI(stream, x, y, z, w);}
void __stdcall _Lazy_glVertexStream4ivATI(GLenum stream, const GLint * coords)            {if (GLeeInit()) glVertexStream4ivATI(stream, coords);}
void __stdcall _Lazy_glVertexStream4fATI(GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w)  {if (GLeeInit()) glVertexStream4fATI(stream, x, y, z, w);}
void __stdcall _Lazy_glVertexStream4fvATI(GLenum stream, const GLfloat * coords)          {if (GLeeInit()) glVertexStream4fvATI(stream, coords);}
void __stdcall _Lazy_glVertexStream4dATI(GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w)  {if (GLeeInit()) glVertexStream4dATI(stream, x, y, z, w);}
void __stdcall _Lazy_glVertexStream4dvATI(GLenum stream, const GLdouble * coords)         {if (GLeeInit()) glVertexStream4dvATI(stream, coords);}
void __stdcall _Lazy_glNormalStream3bATI(GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz)  {if (GLeeInit()) glNormalStream3bATI(stream, nx, ny, nz);}
void __stdcall _Lazy_glNormalStream3bvATI(GLenum stream, const GLbyte * coords)           {if (GLeeInit()) glNormalStream3bvATI(stream, coords);}
void __stdcall _Lazy_glNormalStream3sATI(GLenum stream, GLshort nx, GLshort ny, GLshort nz)  {if (GLeeInit()) glNormalStream3sATI(stream, nx, ny, nz);}
void __stdcall _Lazy_glNormalStream3svATI(GLenum stream, const GLshort * coords)          {if (GLeeInit()) glNormalStream3svATI(stream, coords);}
void __stdcall _Lazy_glNormalStream3iATI(GLenum stream, GLint nx, GLint ny, GLint nz)     {if (GLeeInit()) glNormalStream3iATI(stream, nx, ny, nz);}
void __stdcall _Lazy_glNormalStream3ivATI(GLenum stream, const GLint * coords)            {if (GLeeInit()) glNormalStream3ivATI(stream, coords);}
void __stdcall _Lazy_glNormalStream3fATI(GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz)  {if (GLeeInit()) glNormalStream3fATI(stream, nx, ny, nz);}
void __stdcall _Lazy_glNormalStream3fvATI(GLenum stream, const GLfloat * coords)          {if (GLeeInit()) glNormalStream3fvATI(stream, coords);}
void __stdcall _Lazy_glNormalStream3dATI(GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz)  {if (GLeeInit()) glNormalStream3dATI(stream, nx, ny, nz);}
void __stdcall _Lazy_glNormalStream3dvATI(GLenum stream, const GLdouble * coords)         {if (GLeeInit()) glNormalStream3dvATI(stream, coords);}
void __stdcall _Lazy_glClientActiveVertexStreamATI(GLenum stream)                         {if (GLeeInit()) glClientActiveVertexStreamATI(stream);}
void __stdcall _Lazy_glVertexBlendEnviATI(GLenum pname, GLint param)                      {if (GLeeInit()) glVertexBlendEnviATI(pname, param);}
void __stdcall _Lazy_glVertexBlendEnvfATI(GLenum pname, GLfloat param)                    {if (GLeeInit()) glVertexBlendEnvfATI(pname, param);}
PFNGLVERTEXSTREAM1SATIPROC pglVertexStream1sATI=_Lazy_glVertexStream1sATI;
PFNGLVERTEXSTREAM1SVATIPROC pglVertexStream1svATI=_Lazy_glVertexStream1svATI;
PFNGLVERTEXSTREAM1IATIPROC pglVertexStream1iATI=_Lazy_glVertexStream1iATI;
PFNGLVERTEXSTREAM1IVATIPROC pglVertexStream1ivATI=_Lazy_glVertexStream1ivATI;
PFNGLVERTEXSTREAM1FATIPROC pglVertexStream1fATI=_Lazy_glVertexStream1fATI;
PFNGLVERTEXSTREAM1FVATIPROC pglVertexStream1fvATI=_Lazy_glVertexStream1fvATI;
PFNGLVERTEXSTREAM1DATIPROC pglVertexStream1dATI=_Lazy_glVertexStream1dATI;
PFNGLVERTEXSTREAM1DVATIPROC pglVertexStream1dvATI=_Lazy_glVertexStream1dvATI;
PFNGLVERTEXSTREAM2SATIPROC pglVertexStream2sATI=_Lazy_glVertexStream2sATI;
PFNGLVERTEXSTREAM2SVATIPROC pglVertexStream2svATI=_Lazy_glVertexStream2svATI;
PFNGLVERTEXSTREAM2IATIPROC pglVertexStream2iATI=_Lazy_glVertexStream2iATI;
PFNGLVERTEXSTREAM2IVATIPROC pglVertexStream2ivATI=_Lazy_glVertexStream2ivATI;
PFNGLVERTEXSTREAM2FATIPROC pglVertexStream2fATI=_Lazy_glVertexStream2fATI;
PFNGLVERTEXSTREAM2FVATIPROC pglVertexStream2fvATI=_Lazy_glVertexStream2fvATI;
PFNGLVERTEXSTREAM2DATIPROC pglVertexStream2dATI=_Lazy_glVertexStream2dATI;
PFNGLVERTEXSTREAM2DVATIPROC pglVertexStream2dvATI=_Lazy_glVertexStream2dvATI;
PFNGLVERTEXSTREAM3SATIPROC pglVertexStream3sATI=_Lazy_glVertexStream3sATI;
PFNGLVERTEXSTREAM3SVATIPROC pglVertexStream3svATI=_Lazy_glVertexStream3svATI;
PFNGLVERTEXSTREAM3IATIPROC pglVertexStream3iATI=_Lazy_glVertexStream3iATI;
PFNGLVERTEXSTREAM3IVATIPROC pglVertexStream3ivATI=_Lazy_glVertexStream3ivATI;
PFNGLVERTEXSTREAM3FATIPROC pglVertexStream3fATI=_Lazy_glVertexStream3fATI;
PFNGLVERTEXSTREAM3FVATIPROC pglVertexStream3fvATI=_Lazy_glVertexStream3fvATI;
PFNGLVERTEXSTREAM3DATIPROC pglVertexStream3dATI=_Lazy_glVertexStream3dATI;
PFNGLVERTEXSTREAM3DVATIPROC pglVertexStream3dvATI=_Lazy_glVertexStream3dvATI;
PFNGLVERTEXSTREAM4SATIPROC pglVertexStream4sATI=_Lazy_glVertexStream4sATI;
PFNGLVERTEXSTREAM4SVATIPROC pglVertexStream4svATI=_Lazy_glVertexStream4svATI;
PFNGLVERTEXSTREAM4IATIPROC pglVertexStream4iATI=_Lazy_glVertexStream4iATI;
PFNGLVERTEXSTREAM4IVATIPROC pglVertexStream4ivATI=_Lazy_glVertexStream4ivATI;
PFNGLVERTEXSTREAM4FATIPROC pglVertexStream4fATI=_Lazy_glVertexStream4fATI;
PFNGLVERTEXSTREAM4FVATIPROC pglVertexStream4fvATI=_Lazy_glVertexStream4fvATI;
PFNGLVERTEXSTREAM4DATIPROC pglVertexStream4dATI=_Lazy_glVertexStream4dATI;
PFNGLVERTEXSTREAM4DVATIPROC pglVertexStream4dvATI=_Lazy_glVertexStream4dvATI;
PFNGLNORMALSTREAM3BATIPROC pglNormalStream3bATI=_Lazy_glNormalStream3bATI;
PFNGLNORMALSTREAM3BVATIPROC pglNormalStream3bvATI=_Lazy_glNormalStream3bvATI;
PFNGLNORMALSTREAM3SATIPROC pglNormalStream3sATI=_Lazy_glNormalStream3sATI;
PFNGLNORMALSTREAM3SVATIPROC pglNormalStream3svATI=_Lazy_glNormalStream3svATI;
PFNGLNORMALSTREAM3IATIPROC pglNormalStream3iATI=_Lazy_glNormalStream3iATI;
PFNGLNORMALSTREAM3IVATIPROC pglNormalStream3ivATI=_Lazy_glNormalStream3ivATI;
PFNGLNORMALSTREAM3FATIPROC pglNormalStream3fATI=_Lazy_glNormalStream3fATI;
PFNGLNORMALSTREAM3FVATIPROC pglNormalStream3fvATI=_Lazy_glNormalStream3fvATI;
PFNGLNORMALSTREAM3DATIPROC pglNormalStream3dATI=_Lazy_glNormalStream3dATI;
PFNGLNORMALSTREAM3DVATIPROC pglNormalStream3dvATI=_Lazy_glNormalStream3dvATI;
PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC pglClientActiveVertexStreamATI=_Lazy_glClientActiveVertexStreamATI;
PFNGLVERTEXBLENDENVIATIPROC pglVertexBlendEnviATI=_Lazy_glVertexBlendEnviATI;
PFNGLVERTEXBLENDENVFATIPROC pglVertexBlendEnvfATI=_Lazy_glVertexBlendEnvfATI;
#endif 

/* GL_ATI_element_array */

#ifdef __GLEE_GL_ATI_element_array
void __stdcall _Lazy_glElementPointerATI(GLenum type, const GLvoid * pointer)             {if (GLeeInit()) glElementPointerATI(type, pointer);}
void __stdcall _Lazy_glDrawElementArrayATI(GLenum mode, GLsizei count)                    {if (GLeeInit()) glDrawElementArrayATI(mode, count);}
void __stdcall _Lazy_glDrawRangeElementArrayATI(GLenum mode, GLuint start, GLuint end, GLsizei count)  {if (GLeeInit()) glDrawRangeElementArrayATI(mode, start, end, count);}
PFNGLELEMENTPOINTERATIPROC pglElementPointerATI=_Lazy_glElementPointerATI;
PFNGLDRAWELEMENTARRAYATIPROC pglDrawElementArrayATI=_Lazy_glDrawElementArrayATI;
Show full blame