Stripped out a lot of useless info from the spec, by selecting only what is needed.

[cl-glfw/jecs.git] / lib / opengl.lisp

;;;; This file was automatically generated by /home/bill/programming/cl-glfw/generators/make-bindings-from-spec.lisp

(in-package #:cl-glfw-opengl) 

;;;; {{{ attribmask

(defconstant +current-bit+ #x1) 
(defconstant +point-bit+ #x2) 
(defconstant +line-bit+ #x4) 
(defconstant +polygon-bit+ #x8) 
(defconstant +polygon-stipple-bit+ #x10) 
(defconstant +pixel-mode-bit+ #x20) 
(defconstant +lighting-bit+ #x40) 
(defconstant +fog-bit+ #x80) 
(defconstant +depth-buffer-bit+ #x100) 
(defconstant +accum-buffer-bit+ #x200) 
(defconstant +stencil-buffer-bit+ #x400) 
(defconstant +viewport-bit+ #x800) 
(defconstant +transform-bit+ #x1000) 
(defconstant +enable-bit+ #x2000) 
(defconstant +color-buffer-bit+ #x4000) 
(defconstant +hint-bit+ #x8000) 
(defconstant +eval-bit+ #x10000) 
(defconstant +list-bit+ #x20000) 
(defconstant +texture-bit+ #x40000) 
(defconstant +scissor-bit+ #x80000) 
(defconstant +all-attrib-bits+ #xFFFFFFFF) 

;;;; }}}

;;;; {{{ clientattribmask

(defconstant +client-pixel-store-bit+ #x1) 
(defconstant +client-vertex-array-bit+ #x2) 
(defconstant +client-all-attrib-bits+ #xFFFFFFFF) 

;;;; }}}

;;;; {{{ boolean

(defconstant +false+ #x0) 
(defconstant +true+ #x1) 

;;;; }}}

;;;; {{{ beginmode

(defconstant +points+ #x0) 
(defconstant +lines+ #x1) 
(defconstant +line-loop+ #x2) 
(defconstant +line-strip+ #x3) 
(defconstant +triangles+ #x4) 
(defconstant +triangle-strip+ #x5) 
(defconstant +triangle-fan+ #x6) 
(defconstant +quads+ #x7) 
(defconstant +quad-strip+ #x8) 
(defconstant +polygon+ #x9) 

;;;; }}}

;;;; {{{ accumop

(defconstant +accum+ #x100) 
(defconstant +load+ #x101) 
(defconstant +return+ #x102) 
(defconstant +mult+ #x103) 
(defconstant +add+ #x104) 

;;;; }}}

;;;; {{{ alphafunction

(defconstant +never+ #x200) 
(defconstant +less+ #x201) 
(defconstant +equal+ #x202) 
(defconstant +lequal+ #x203) 
(defconstant +greater+ #x204) 
(defconstant +notequal+ #x205) 
(defconstant +gequal+ #x206) 
(defconstant +always+ #x207) 

;;;; }}}

;;;; {{{ blendingfactordest

(defconstant +zero+ #x0) 
(defconstant +one+ #x1) 
(defconstant +src-color+ #x300) 
(defconstant +one-minus-src-color+ #x301) 
(defconstant +src-alpha+ #x302) 
(defconstant +one-minus-src-alpha+ #x303) 
(defconstant +dst-alpha+ #x304) 
(defconstant +one-minus-dst-alpha+ #x305) 
(defconstant +constant-color-ext+ #x8001) 
(defconstant +one-minus-constant-color-ext+ #x8002) 
(defconstant +constant-alpha-ext+ #x8003) 
(defconstant +one-minus-constant-alpha-ext+ #x8004) 

;;;; }}}

;;;; {{{ blendingfactorsrc

(defconstant +dst-color+ #x306) 
(defconstant +one-minus-dst-color+ #x307) 
(defconstant +src-alpha-saturate+ #x308) 

;;;; }}}

;;;; {{{ blendequationmodeext

(defconstant +logic-op+ #xBF1) 
(defconstant +func-add-ext+ #x8006) 
(defconstant +min-ext+ #x8007) 
(defconstant +max-ext+ #x8008) 
(defconstant +func-subtract-ext+ #x800A) 
(defconstant +func-reverse-subtract-ext+ #x800B) 
(defconstant +alpha-min-sgix+ #x8320) 
(defconstant +alpha-max-sgix+ #x8321) 

;;;; }}}

;;;; {{{ colormaterialface

(defconstant +front+ #x404) 
(defconstant +back+ #x405) 
(defconstant +front-and-back+ #x408) 

;;;; }}}

;;;; {{{ colormaterialparameter

(defconstant +ambient+ #x1200) 
(defconstant +diffuse+ #x1201) 
(defconstant +specular+ #x1202) 
(defconstant +emission+ #x1600) 
(defconstant +ambient-and-diffuse+ #x1602) 

;;;; }}}

;;;; {{{ colorpointertype

(defconstant +byte+ #x1400) 
(defconstant +unsigned-byte+ #x1401) 
(defconstant +short+ #x1402) 
(defconstant +unsigned-short+ #x1403) 
(defconstant +int+ #x1404) 
(defconstant +unsigned-int+ #x1405) 
(defconstant +float+ #x1406) 
(defconstant +double+ #x140A) 

;;;; }}}

;;;; {{{ colortableparameterpnamesgi

(defconstant +color-table-scale-sgi+ #x80D6) 
(defconstant +color-table-bias-sgi+ #x80D7) 

;;;; }}}

;;;; {{{ colortabletargetsgi

(defconstant +color-table-sgi+ #x80D0) 
(defconstant +post-convolution-color-table-sgi+ #x80D1) 
(defconstant +post-color-matrix-color-table-sgi+ #x80D2) 
(defconstant +proxy-color-table-sgi+ #x80D3) 
(defconstant +proxy-post-convolution-color-table-sgi+ #x80D4) 
(defconstant +proxy-post-color-matrix-color-table-sgi+ #x80D5) 
(defconstant +texture-color-table-sgi+ #x80BC) 
(defconstant +proxy-texture-color-table-sgi+ #x80BD) 

;;;; }}}

;;;; {{{ convolutionbordermodeext

(defconstant +reduce-ext+ #x8016) 

;;;; }}}

;;;; {{{ convolutionparameterext

(defconstant +convolution-border-mode-ext+ #x8013) 
(defconstant +convolution-filter-scale-ext+ #x8014) 
(defconstant +convolution-filter-bias-ext+ #x8015) 

;;;; }}}

;;;; {{{ convolutiontargetext

(defconstant +convolution-1d-ext+ #x8010) 
(defconstant +convolution-2d-ext+ #x8011) 

;;;; }}}

;;;; {{{ drawbuffermode

(defconstant +none+ #x0) 
(defconstant +front-left+ #x400) 
(defconstant +front-right+ #x401) 
(defconstant +back-left+ #x402) 
(defconstant +back-right+ #x403) 
(defconstant +left+ #x406) 
(defconstant +right+ #x407) 
(defconstant +aux0+ #x409) 
(defconstant +aux1+ #x40A) 
(defconstant +aux2+ #x40B) 
(defconstant +aux3+ #x40C) 

;;;; }}}

;;;; {{{ enablecap

(defconstant +fog+ #xB60) 
(defconstant +lighting+ #xB50) 
(defconstant +texture-1d+ #xDE0) 
(defconstant +texture-2d+ #xDE1) 
(defconstant +line-stipple+ #xB24) 
(defconstant +polygon-stipple+ #xB42) 
(defconstant +cull-face+ #xB44) 
(defconstant +alpha-test+ #xBC0) 
(defconstant +blend+ #xBE2) 
(defconstant +index-logic-op+ #xBF1) 
(defconstant +color-logic-op+ #xBF2) 
(defconstant +dither+ #xBD0) 
(defconstant +stencil-test+ #xB90) 
(defconstant +depth-test+ #xB71) 
(defconstant +clip-plane0+ #x3000) 
(defconstant +clip-plane1+ #x3001) 
(defconstant +clip-plane2+ #x3002) 
(defconstant +clip-plane3+ #x3003) 
(defconstant +clip-plane4+ #x3004) 
(defconstant +clip-plane5+ #x3005) 
(defconstant +light0+ #x4000) 
(defconstant +light1+ #x4001) 
(defconstant +light2+ #x4002) 
(defconstant +light3+ #x4003) 
(defconstant +light4+ #x4004) 
(defconstant +light5+ #x4005) 
(defconstant +light6+ #x4006) 
(defconstant +light7+ #x4007) 
(defconstant +texture-gen-s+ #xC60) 
(defconstant +texture-gen-t+ #xC61) 
(defconstant +texture-gen-r+ #xC62) 
(defconstant +texture-gen-q+ #xC63) 
(defconstant +map1-vertex-3+ #xD97) 
(defconstant +map1-vertex-4+ #xD98) 
(defconstant +map1-color-4+ #xD90) 
(defconstant +map1-index+ #xD91) 
(defconstant +map1-normal+ #xD92) 
(defconstant +map1-texture-coord-1+ #xD93) 
(defconstant +map1-texture-coord-2+ #xD94) 
(defconstant +map1-texture-coord-3+ #xD95) 
(defconstant +map1-texture-coord-4+ #xD96) 
(defconstant +map2-vertex-3+ #xDB7) 
(defconstant +map2-vertex-4+ #xDB8) 
(defconstant +map2-color-4+ #xDB0) 
(defconstant +map2-index+ #xDB1) 
(defconstant +map2-normal+ #xDB2) 
(defconstant +map2-texture-coord-1+ #xDB3) 
(defconstant +map2-texture-coord-2+ #xDB4) 
(defconstant +map2-texture-coord-3+ #xDB5) 
(defconstant +map2-texture-coord-4+ #xDB6) 
(defconstant +point-smooth+ #xB10) 
(defconstant +line-smooth+ #xB20) 
(defconstant +polygon-smooth+ #xB41) 
(defconstant +scissor-test+ #xC11) 
(defconstant +color-material+ #xB57) 
(defconstant +normalize+ #xBA1) 
(defconstant +auto-normal+ #xD80) 
(defconstant +polygon-offset-point+ #x2A01) 
(defconstant +polygon-offset-line+ #x2A02) 
(defconstant +polygon-offset-fill+ #x8037) 
(defconstant +vertex-array+ #x8074) 
(defconstant +normal-array+ #x8075) 
(defconstant +color-array+ #x8076) 
(defconstant +index-array+ #x8077) 
(defconstant +texture-coord-array+ #x8078) 
(defconstant +edge-flag-array+ #x8079) 
(defconstant +separable-2d-ext+ #x8012) 
(defconstant +histogram-ext+ #x8024) 
(defconstant +minmax-ext+ #x802E) 
(defconstant +rescale-normal-ext+ #x803A) 
(defconstant +shared-texture-palette-ext+ #x81FB) 
(defconstant +texture-3d-ext+ #x806F) 
(defconstant +multisample-sgis+ #x809D) 
(defconstant +sample-alpha-to-mask-sgis+ #x809E) 
(defconstant +sample-alpha-to-one-sgis+ #x809F) 
(defconstant +sample-mask-sgis+ #x80A0) 
(defconstant +texture-4d-sgis+ #x8134) 
(defconstant +async-histogram-sgix+ #x832C) 
(defconstant +async-tex-image-sgix+ #x835C) 
(defconstant +async-draw-pixels-sgix+ #x835D) 
(defconstant +async-read-pixels-sgix+ #x835E) 
(defconstant +calligraphic-fragment-sgix+ #x8183) 
(defconstant +fog-offset-sgix+ #x8198) 
(defconstant +fragment-lighting-sgix+ #x8400) 
(defconstant +fragment-color-material-sgix+ #x8401) 
(defconstant +fragment-light0-sgix+ #x840C) 
(defconstant +fragment-light1-sgix+ #x840D) 
(defconstant +fragment-light2-sgix+ #x840E) 
(defconstant +fragment-light3-sgix+ #x840F) 
(defconstant +fragment-light4-sgix+ #x8410) 
(defconstant +fragment-light5-sgix+ #x8411) 
(defconstant +fragment-light6-sgix+ #x8412) 
(defconstant +fragment-light7-sgix+ #x8413) 
(defconstant +framezoom-sgix+ #x818B) 
(defconstant +interlace-sgix+ #x8094) 
(defconstant +ir-instrument1-sgix+ #x817F) 
(defconstant +pixel-tex-gen-sgix+ #x8139) 
(defconstant +pixel-texture-sgis+ #x8353) 
(defconstant +reference-plane-sgix+ #x817D) 
(defconstant +sprite-sgix+ #x8148) 

;;;; }}}

;;;; {{{ errorcode

(defconstant +no-error+ #x0) 
(defconstant +invalid-enum+ #x500) 
(defconstant +invalid-value+ #x501) 
(defconstant +invalid-operation+ #x502) 
(defconstant +stack-overflow+ #x503) 
(defconstant +stack-underflow+ #x504) 
(defconstant +out-of-memory+ #x505) 
(defconstant +table-too-large-ext+ #x8031) 
(defconstant +texture-too-large-ext+ #x8065) 

;;;; }}}

;;;; {{{ feedbacktype

(defconstant +2d+ #x600) 
(defconstant +3d+ #x601) 
(defconstant +3d-color+ #x602) 
(defconstant +3d-color-texture+ #x603) 
(defconstant +4d-color-texture+ #x604) 

;;;; }}}

;;;; {{{ feedbacktoken

(defconstant +pass-through-token+ #x700) 
(defconstant +point-token+ #x701) 
(defconstant +line-token+ #x702) 
(defconstant +polygon-token+ #x703) 
(defconstant +bitmap-token+ #x704) 
(defconstant +draw-pixel-token+ #x705) 
(defconstant +copy-pixel-token+ #x706) 
(defconstant +line-reset-token+ #x707) 

;;;; }}}

;;;; {{{ ffdmasksgix

(defconstant +texture-deformation-bit-sgix+ #x1) 
(defconstant +geometry-deformation-bit-sgix+ #x2) 

;;;; }}}

;;;; {{{ ffdtargetsgix

(defconstant +geometry-deformation-sgix+ #x8194) 
(defconstant +texture-deformation-sgix+ #x8195) 

;;;; }}}

;;;; {{{ fogmode

(defconstant +linear+ #x2601) 
(defconstant +exp+ #x800) 
(defconstant +exp2+ #x801) 
(defconstant +fog-func-sgis+ #x812A) 

;;;; }}}

;;;; {{{ fogparameter

(defconstant +fog-color+ #xB66) 
(defconstant +fog-density+ #xB62) 
(defconstant +fog-end+ #xB64) 
(defconstant +fog-index+ #xB61) 
(defconstant +fog-mode+ #xB65) 
(defconstant +fog-start+ #xB63) 
(defconstant +fog-offset-value-sgix+ #x8199) 

;;;; }}}

;;;; {{{ fragmentlightmodelparametersgix

(defconstant +fragment-light-model-local-viewer-sgix+ #x8408) 
(defconstant +fragment-light-model-two-side-sgix+ #x8409) 
(defconstant +fragment-light-model-ambient-sgix+ #x840A) 
(defconstant +fragment-light-model-normal-interpolation-sgix+ #x840B) 

;;;; }}}

;;;; {{{ frontfacedirection

(defconstant +cw+ #x900) 
(defconstant +ccw+ #x901) 

;;;; }}}

;;;; {{{ getcolortableparameterpnamesgi

(defconstant +color-table-format-sgi+ #x80D8) 
(defconstant +color-table-width-sgi+ #x80D9) 
(defconstant +color-table-red-size-sgi+ #x80DA) 
(defconstant +color-table-green-size-sgi+ #x80DB) 
(defconstant +color-table-blue-size-sgi+ #x80DC) 
(defconstant +color-table-alpha-size-sgi+ #x80DD) 
(defconstant +color-table-luminance-size-sgi+ #x80DE) 
(defconstant +color-table-intensity-size-sgi+ #x80DF) 

;;;; }}}

;;;; {{{ getconvolutionparameter

(defconstant +convolution-format-ext+ #x8017) 
(defconstant +convolution-width-ext+ #x8018) 
(defconstant +convolution-height-ext+ #x8019) 
(defconstant +max-convolution-width-ext+ #x801A) 
(defconstant +max-convolution-height-ext+ #x801B) 

;;;; }}}

;;;; {{{ gethistogramparameterpnameext

(defconstant +histogram-width-ext+ #x8026) 
(defconstant +histogram-format-ext+ #x8027) 
(defconstant +histogram-red-size-ext+ #x8028) 
(defconstant +histogram-green-size-ext+ #x8029) 
(defconstant +histogram-blue-size-ext+ #x802A) 
(defconstant +histogram-alpha-size-ext+ #x802B) 
(defconstant +histogram-luminance-size-ext+ #x802C) 
(defconstant +histogram-sink-ext+ #x802D) 

;;;; }}}

;;;; {{{ getmapquery

(defconstant +coeff+ #xA00) 
(defconstant +order+ #xA01) 
(defconstant +domain+ #xA02) 

;;;; }}}

;;;; {{{ getminmaxparameterpnameext

(defconstant +minmax-format-ext+ #x802F) 
(defconstant +minmax-sink-ext+ #x8030) 

;;;; }}}

;;;; {{{ getpixelmap

(defconstant +pixel-map-i-to-i+ #xC70) 
(defconstant +pixel-map-s-to-s+ #xC71) 
(defconstant +pixel-map-i-to-r+ #xC72) 
(defconstant +pixel-map-i-to-g+ #xC73) 
(defconstant +pixel-map-i-to-b+ #xC74) 
(defconstant +pixel-map-i-to-a+ #xC75) 
(defconstant +pixel-map-r-to-r+ #xC76) 
(defconstant +pixel-map-g-to-g+ #xC77) 
(defconstant +pixel-map-b-to-b+ #xC78) 
(defconstant +pixel-map-a-to-a+ #xC79) 

;;;; }}}

;;;; {{{ getpointervpname

(defconstant +vertex-array-pointer+ #x808E) 
(defconstant +normal-array-pointer+ #x808F) 
(defconstant +color-array-pointer+ #x8090) 
(defconstant +index-array-pointer+ #x8091) 
(defconstant +texture-coord-array-pointer+ #x8092) 
(defconstant +edge-flag-array-pointer+ #x8093) 
(defconstant +feedback-buffer-pointer+ #xDF0) 
(defconstant +selection-buffer-pointer+ #xDF3) 
(defconstant +instrument-buffer-pointer-sgix+ #x8180) 

;;;; }}}

;;;; {{{ getpname

(defconstant +current-color+ #xB00) 
(defconstant +current-index+ #xB01) 
(defconstant +current-normal+ #xB02) 
(defconstant +current-texture-coords+ #xB03) 
(defconstant +current-raster-color+ #xB04) 
(defconstant +current-raster-index+ #xB05) 
(defconstant +current-raster-texture-coords+ #xB06) 
(defconstant +current-raster-position+ #xB07) 
(defconstant +current-raster-position-valid+ #xB08) 
(defconstant +current-raster-distance+ #xB09) 
(defconstant +point-size+ #xB11) 
(defconstant +point-size-range+ #xB12) 
(defconstant +point-size-granularity+ #xB13) 
(defconstant +line-width+ #xB21) 
(defconstant +line-width-range+ #xB22) 
(defconstant +line-width-granularity+ #xB23) 
(defconstant +line-stipple-pattern+ #xB25) 
(defconstant +line-stipple-repeat+ #xB26) 
(defconstant +smooth-point-size-range+ #xB12) 
(defconstant +smooth-point-size-granularity+ #xB13) 
(defconstant +smooth-line-width-range+ #xB22) 
(defconstant +smooth-line-width-granularity+ #xB23) 
(defconstant +aliased-point-size-range+ #x846D) 
(defconstant +aliased-line-width-range+ #x846E) 
(defconstant +list-mode+ #xB30) 
(defconstant +max-list-nesting+ #xB31) 
(defconstant +list-base+ #xB32) 
(defconstant +list-index+ #xB33) 
(defconstant +polygon-mode+ #xB40) 
(defconstant +edge-flag+ #xB43) 
(defconstant +cull-face-mode+ #xB45) 
(defconstant +front-face+ #xB46) 
(defconstant +light-model-local-viewer+ #xB51) 
(defconstant +light-model-two-side+ #xB52) 
(defconstant +light-model-ambient+ #xB53) 
(defconstant +shade-model+ #xB54) 
(defconstant +color-material-face+ #xB55) 
(defconstant +color-material-parameter+ #xB56) 
(defconstant +depth-range+ #xB70) 
(defconstant +depth-writemask+ #xB72) 
(defconstant +depth-clear-value+ #xB73) 
(defconstant +depth-func+ #xB74) 
(defconstant +accum-clear-value+ #xB80) 
(defconstant +stencil-clear-value+ #xB91) 
(defconstant +stencil-func+ #xB92) 
(defconstant +stencil-value-mask+ #xB93) 
(defconstant +stencil-fail+ #xB94) 
(defconstant +stencil-pass-depth-fail+ #xB95) 
(defconstant +stencil-pass-depth-pass+ #xB96) 
(defconstant +stencil-ref+ #xB97) 
(defconstant +stencil-writemask+ #xB98) 
(defconstant +matrix-mode+ #xBA0) 
(defconstant +viewport+ #xBA2) 
(defconstant +modelview-stack-depth+ #xBA3) 
(defconstant +projection-stack-depth+ #xBA4) 
(defconstant +texture-stack-depth+ #xBA5) 
(defconstant +modelview-matrix+ #xBA6) 
(defconstant +projection-matrix+ #xBA7) 
(defconstant +texture-matrix+ #xBA8) 
(defconstant +attrib-stack-depth+ #xBB0) 
(defconstant +client-attrib-stack-depth+ #xBB1) 
(defconstant +alpha-test-func+ #xBC1) 
(defconstant +alpha-test-ref+ #xBC2) 
(defconstant +blend-dst+ #xBE0) 
(defconstant +blend-src+ #xBE1) 
(defconstant +logic-op-mode+ #xBF0) 
(defconstant +aux-buffers+ #xC00) 
(defconstant +draw-buffer+ #xC01) 
(defconstant +read-buffer+ #xC02) 
(defconstant +scissor-box+ #xC10) 
(defconstant +index-clear-value+ #xC20) 
(defconstant +index-writemask+ #xC21) 
(defconstant +color-clear-value+ #xC22) 
(defconstant +color-writemask+ #xC23) 
(defconstant +index-mode+ #xC30) 
(defconstant +rgba-mode+ #xC31) 
(defconstant +doublebuffer+ #xC32) 
(defconstant +stereo+ #xC33) 
(defconstant +render-mode+ #xC40) 
(defconstant +perspective-correction-hint+ #xC50) 
(defconstant +point-smooth-hint+ #xC51) 
(defconstant +line-smooth-hint+ #xC52) 
(defconstant +polygon-smooth-hint+ #xC53) 
(defconstant +fog-hint+ #xC54) 
(defconstant +pixel-map-i-to-i-size+ #xCB0) 
(defconstant +pixel-map-s-to-s-size+ #xCB1) 
(defconstant +pixel-map-i-to-r-size+ #xCB2) 
(defconstant +pixel-map-i-to-g-size+ #xCB3) 
(defconstant +pixel-map-i-to-b-size+ #xCB4) 
(defconstant +pixel-map-i-to-a-size+ #xCB5) 
(defconstant +pixel-map-r-to-r-size+ #xCB6) 
(defconstant +pixel-map-g-to-g-size+ #xCB7) 
(defconstant +pixel-map-b-to-b-size+ #xCB8) 
(defconstant +pixel-map-a-to-a-size+ #xCB9) 
(defconstant +unpack-swap-bytes+ #xCF0) 
(defconstant +unpack-lsb-first+ #xCF1) 
(defconstant +unpack-row-length+ #xCF2) 
(defconstant +unpack-skip-rows+ #xCF3) 
(defconstant +unpack-skip-pixels+ #xCF4) 
(defconstant +unpack-alignment+ #xCF5) 
(defconstant +pack-swap-bytes+ #xD00) 
(defconstant +pack-lsb-first+ #xD01) 
(defconstant +pack-row-length+ #xD02) 
(defconstant +pack-skip-rows+ #xD03) 
(defconstant +pack-skip-pixels+ #xD04) 
(defconstant +pack-alignment+ #xD05) 
(defconstant +map-color+ #xD10) 
(defconstant +map-stencil+ #xD11) 
(defconstant +index-shift+ #xD12) 
(defconstant +index-offset+ #xD13) 
(defconstant +red-scale+ #xD14) 
(defconstant +red-bias+ #xD15) 
(defconstant +zoom-x+ #xD16) 
(defconstant +zoom-y+ #xD17) 
(defconstant +green-scale+ #xD18) 
(defconstant +green-bias+ #xD19) 
(defconstant +blue-scale+ #xD1A) 
(defconstant +blue-bias+ #xD1B) 
(defconstant +alpha-scale+ #xD1C) 
(defconstant +alpha-bias+ #xD1D) 
(defconstant +depth-scale+ #xD1E) 
(defconstant +depth-bias+ #xD1F) 
(defconstant +max-eval-order+ #xD30) 
(defconstant +max-lights+ #xD31) 
(defconstant +max-clip-planes+ #xD32) 
(defconstant +max-texture-size+ #xD33) 
(defconstant +max-pixel-map-table+ #xD34) 
(defconstant +max-attrib-stack-depth+ #xD35) 
(defconstant +max-modelview-stack-depth+ #xD36) 
(defconstant +max-name-stack-depth+ #xD37) 
(defconstant +max-projection-stack-depth+ #xD38) 
(defconstant +max-texture-stack-depth+ #xD39) 
(defconstant +max-viewport-dims+ #xD3A) 
(defconstant +max-client-attrib-stack-depth+ #xD3B) 
(defconstant +subpixel-bits+ #xD50) 
(defconstant +index-bits+ #xD51) 
(defconstant +red-bits+ #xD52) 
(defconstant +green-bits+ #xD53) 
(defconstant +blue-bits+ #xD54) 
(defconstant +alpha-bits+ #xD55) 
(defconstant +depth-bits+ #xD56) 
(defconstant +stencil-bits+ #xD57) 
(defconstant +accum-red-bits+ #xD58) 
(defconstant +accum-green-bits+ #xD59) 
(defconstant +accum-blue-bits+ #xD5A) 
(defconstant +accum-alpha-bits+ #xD5B) 
(defconstant +name-stack-depth+ #xD70) 
(defconstant +map1-grid-domain+ #xDD0) 
(defconstant +map1-grid-segments+ #xDD1) 
(defconstant +map2-grid-domain+ #xDD2) 
(defconstant +map2-grid-segments+ #xDD3) 
(defconstant +feedback-buffer-size+ #xDF1) 
(defconstant +feedback-buffer-type+ #xDF2) 
(defconstant +selection-buffer-size+ #xDF4) 
(defconstant +polygon-offset-units+ #x2A00) 
(defconstant +polygon-offset-factor+ #x8038) 
(defconstant +texture-binding-1d+ #x8068) 
(defconstant +texture-binding-2d+ #x8069) 
(defconstant +texture-binding-3d+ #x806A) 
(defconstant +vertex-array-size+ #x807A) 
(defconstant +vertex-array-type+ #x807B) 
(defconstant +vertex-array-stride+ #x807C) 
(defconstant +normal-array-type+ #x807E) 
(defconstant +normal-array-stride+ #x807F) 
(defconstant +color-array-size+ #x8081) 
(defconstant +color-array-type+ #x8082) 
(defconstant +color-array-stride+ #x8083) 
(defconstant +index-array-type+ #x8085) 
(defconstant +index-array-stride+ #x8086) 
(defconstant +texture-coord-array-size+ #x8088) 
(defconstant +texture-coord-array-type+ #x8089) 
(defconstant +texture-coord-array-stride+ #x808A) 
(defconstant +edge-flag-array-stride+ #x808C) 
(defconstant +light-model-color-control+ #x81F8) 
(defconstant +blend-color-ext+ #x8005) 
(defconstant +blend-equation-ext+ #x8009) 
(defconstant +pack-cmyk-hint-ext+ #x800E) 
(defconstant +unpack-cmyk-hint-ext+ #x800F) 
(defconstant +post-convolution-red-scale-ext+ #x801C) 
(defconstant +post-convolution-green-scale-ext+ #x801D) 
(defconstant +post-convolution-blue-scale-ext+ #x801E) 
(defconstant +post-convolution-alpha-scale-ext+ #x801F) 
(defconstant +post-convolution-red-bias-ext+ #x8020) 
(defconstant +post-convolution-green-bias-ext+ #x8021) 
(defconstant +post-convolution-blue-bias-ext+ #x8022) 
(defconstant +post-convolution-alpha-bias-ext+ #x8023) 
(defconstant +polygon-offset-bias-ext+ #x8039) 
(defconstant +texture-3d-binding-ext+ #x806A) 
(defconstant +pack-skip-images-ext+ #x806B) 
(defconstant +pack-image-height-ext+ #x806C) 
(defconstant +unpack-skip-images-ext+ #x806D) 
(defconstant +unpack-image-height-ext+ #x806E) 
(defconstant +max-3d-texture-size-ext+ #x8073) 
(defconstant +vertex-array-count-ext+ #x807D) 
(defconstant +normal-array-count-ext+ #x8080) 
(defconstant +color-array-count-ext+ #x8084) 
(defconstant +index-array-count-ext+ #x8087) 
(defconstant +texture-coord-array-count-ext+ #x808B) 
(defconstant +edge-flag-array-count-ext+ #x808D) 
(defconstant +detail-texture-2d-binding-sgis+ #x8096) 
(defconstant +fog-func-points-sgis+ #x812B) 
(defconstant +max-fog-func-points-sgis+ #x812C) 
(defconstant +generate-mipmap-hint-sgis+ #x8192) 
(defconstant +sample-buffers-sgis+ #x80A8) 
(defconstant +samples-sgis+ #x80A9) 
(defconstant +sample-mask-value-sgis+ #x80AA) 
(defconstant +sample-mask-invert-sgis+ #x80AB) 
(defconstant +sample-pattern-sgis+ #x80AC) 
(defconstant +point-size-min-sgis+ #x8126) 
(defconstant +point-size-max-sgis+ #x8127) 
(defconstant +point-fade-threshold-size-sgis+ #x8128) 
(defconstant +distance-attenuation-sgis+ #x8129) 
(defconstant +pack-skip-volumes-sgis+ #x8130) 
(defconstant +pack-image-depth-sgis+ #x8131) 
(defconstant +unpack-skip-volumes-sgis+ #x8132) 
(defconstant +unpack-image-depth-sgis+ #x8133) 
(defconstant +max-4d-texture-size-sgis+ #x8138) 
(defconstant +texture-4d-binding-sgis+ #x814F) 
(defconstant +async-marker-sgix+ #x8329) 
(defconstant +max-async-histogram-sgix+ #x832D) 
(defconstant +max-async-tex-image-sgix+ #x835F) 
(defconstant +max-async-draw-pixels-sgix+ #x8360) 
(defconstant +max-async-read-pixels-sgix+ #x8361) 
(defconstant +max-clipmap-virtual-depth-sgix+ #x8178) 
(defconstant +max-clipmap-depth-sgix+ #x8177) 
(defconstant +convolution-hint-sgix+ #x8316) 
(defconstant +fragment-color-material-face-sgix+ #x8402) 
(defconstant +fragment-color-material-parameter-sgix+ #x8403) 
(defconstant +max-fragment-lights-sgix+ #x8404) 
(defconstant +max-active-lights-sgix+ #x8405) 
(defconstant +light-env-mode-sgix+ #x8407) 
(defconstant +framezoom-factor-sgix+ #x818C) 
(defconstant +max-framezoom-factor-sgix+ #x818D) 
(defconstant +instrument-measurements-sgix+ #x8181) 
(defconstant +pixel-tex-gen-mode-sgix+ #x832B) 
(defconstant +pixel-tile-best-alignment-sgix+ #x813E) 
(defconstant +pixel-tile-cache-increment-sgix+ #x813F) 
(defconstant +pixel-tile-width-sgix+ #x8140) 
(defconstant +pixel-tile-height-sgix+ #x8141) 
(defconstant +pixel-tile-grid-width-sgix+ #x8142) 
(defconstant +pixel-tile-grid-height-sgix+ #x8143) 
(defconstant +pixel-tile-grid-depth-sgix+ #x8144) 
(defconstant +pixel-tile-cache-size-sgix+ #x8145) 
(defconstant +deformations-mask-sgix+ #x8196) 
(defconstant +reference-plane-equation-sgix+ #x817E) 
(defconstant +sprite-mode-sgix+ #x8149) 
(defconstant +sprite-axis-sgix+ #x814A) 
(defconstant +sprite-translation-sgix+ #x814B) 
(defconstant +pack-subsample-rate-sgix+ #x85A0) 
(defconstant +unpack-subsample-rate-sgix+ #x85A1) 
(defconstant +pack-resample-sgix+ #x842C) 
(defconstant +unpack-resample-sgix+ #x842D) 
(defconstant +post-texture-filter-bias-range-sgix+ #x817B) 
(defconstant +post-texture-filter-scale-range-sgix+ #x817C) 
(defconstant +vertex-preclip-sgix+ #x83EE) 
(defconstant +vertex-preclip-hint-sgix+ #x83EF) 
(defconstant +color-matrix-sgi+ #x80B1) 
(defconstant +color-matrix-stack-depth-sgi+ #x80B2) 
(defconstant +max-color-matrix-stack-depth-sgi+ #x80B3) 
(defconstant +post-color-matrix-red-scale-sgi+ #x80B4) 
(defconstant +post-color-matrix-green-scale-sgi+ #x80B5) 
(defconstant +post-color-matrix-blue-scale-sgi+ #x80B6) 
(defconstant +post-color-matrix-alpha-scale-sgi+ #x80B7) 
(defconstant +post-color-matrix-red-bias-sgi+ #x80B8) 
(defconstant +post-color-matrix-green-bias-sgi+ #x80B9) 
(defconstant +post-color-matrix-blue-bias-sgi+ #x80BA) 
(defconstant +post-color-matrix-alpha-bias-sgi+ #x80BB) 

;;;; }}}

;;;; {{{ gettextureparameter

(defconstant +texture-mag-filter+ #x2800) 
(defconstant +texture-min-filter+ #x2801) 
(defconstant +texture-wrap-s+ #x2802) 
(defconstant +texture-wrap-t+ #x2803) 
(defconstant +texture-width+ #x1000) 
(defconstant +texture-height+ #x1001) 
(defconstant +texture-internal-format+ #x1003) 
(defconstant +texture-components+ #x1003) 
(defconstant +texture-border-color+ #x1004) 
(defconstant +texture-border+ #x1005) 
(defconstant +texture-red-size+ #x805C) 
(defconstant +texture-green-size+ #x805D) 
(defconstant +texture-blue-size+ #x805E) 
(defconstant +texture-alpha-size+ #x805F) 
(defconstant +texture-luminance-size+ #x8060) 
(defconstant +texture-intensity-size+ #x8061) 
(defconstant +texture-priority+ #x8066) 
(defconstant +texture-resident+ #x8067) 
(defconstant +texture-depth-ext+ #x8071) 
(defconstant +texture-wrap-r-ext+ #x8072) 
(defconstant +detail-texture-level-sgis+ #x809A) 
(defconstant +detail-texture-mode-sgis+ #x809B) 
(defconstant +detail-texture-func-points-sgis+ #x809C) 
(defconstant +generate-mipmap-sgis+ #x8191) 
(defconstant +sharpen-texture-func-points-sgis+ #x80B0) 
(defconstant +texture-filter4-size-sgis+ #x8147) 
(defconstant +texture-min-lod-sgis+ #x813A) 
(defconstant +texture-max-lod-sgis+ #x813B) 
(defconstant +texture-base-level-sgis+ #x813C) 
(defconstant +texture-max-level-sgis+ #x813D) 
(defconstant +dual-texture-select-sgis+ #x8124) 
(defconstant +quad-texture-select-sgis+ #x8125) 
(defconstant +texture-4dsize-sgis+ #x8136) 
(defconstant +texture-wrap-q-sgis+ #x8137) 
(defconstant +texture-clipmap-center-sgix+ #x8171) 
(defconstant +texture-clipmap-frame-sgix+ #x8172) 
(defconstant +texture-clipmap-offset-sgix+ #x8173) 
(defconstant +texture-clipmap-virtual-depth-sgix+ #x8174) 
(defconstant +texture-clipmap-lod-offset-sgix+ #x8175) 
(defconstant +texture-clipmap-depth-sgix+ #x8176) 
(defconstant +texture-compare-sgix+ #x819A) 
(defconstant +texture-compare-operator-sgix+ #x819B) 
(defconstant +texture-lequal-r-sgix+ #x819C) 
(defconstant +texture-gequal-r-sgix+ #x819D) 
(defconstant +shadow-ambient-sgix+ #x80BF) 
(defconstant +texture-max-clamp-s-sgix+ #x8369) 
(defconstant +texture-max-clamp-t-sgix+ #x836A) 
(defconstant +texture-max-clamp-r-sgix+ #x836B) 
(defconstant +texture-lod-bias-s-sgix+ #x818E) 
(defconstant +texture-lod-bias-t-sgix+ #x818F) 
(defconstant +texture-lod-bias-r-sgix+ #x8190) 
(defconstant +post-texture-filter-bias-sgix+ #x8179) 
(defconstant +post-texture-filter-scale-sgix+ #x817A) 

;;;; }}}

;;;; {{{ hintmode

(defconstant +dont-care+ #x1100) 
(defconstant +fastest+ #x1101) 
(defconstant +nicest+ #x1102) 

;;;; }}}

;;;; {{{ hinttarget

(defconstant +texture-multi-buffer-hint-sgix+ #x812E) 

;;;; }}}

;;;; {{{ histogramtargetext

(defconstant +proxy-histogram-ext+ #x8025) 

;;;; }}}

;;;; {{{ lightenvmodesgix

(defconstant +replace+ #x1E01) 
(defconstant +modulate+ #x2100) 

;;;; }}}

;;;; {{{ lightmodelcolorcontrol

(defconstant +single-color+ #x81F9) 
(defconstant +separate-specular-color+ #x81FA) 

;;;; }}}

;;;; {{{ lightparameter

(defconstant +position+ #x1203) 
(defconstant +spot-direction+ #x1204) 
(defconstant +spot-exponent+ #x1205) 
(defconstant +spot-cutoff+ #x1206) 
(defconstant +constant-attenuation+ #x1207) 
(defconstant +linear-attenuation+ #x1208) 
(defconstant +quadratic-attenuation+ #x1209) 

;;;; }}}

;;;; {{{ listmode

(defconstant +compile+ #x1300) 
(defconstant +compile-and-execute+ #x1301) 

;;;; }}}

;;;; {{{ datatype

(defconstant +2-bytes+ #x1407) 
(defconstant +3-bytes+ #x1408) 
(defconstant +4-bytes+ #x1409) 
(defconstant +double-ext+ #x140A) 

;;;; }}}

;;;; {{{ listparametername

(defconstant +list-priority-sgix+ #x8182) 

;;;; }}}

;;;; {{{ logicop

(defconstant +clear+ #x1500) 
(defconstant +and+ #x1501) 
(defconstant +and-reverse+ #x1502) 
(defconstant +copy+ #x1503) 
(defconstant +and-inverted+ #x1504) 
(defconstant +noop+ #x1505) 
(defconstant +xor+ #x1506) 
(defconstant +or+ #x1507) 
(defconstant +nor+ #x1508) 
(defconstant +equiv+ #x1509) 
(defconstant +invert+ #x150A) 
(defconstant +or-reverse+ #x150B) 
(defconstant +copy-inverted+ #x150C) 
(defconstant +or-inverted+ #x150D) 
(defconstant +nand+ #x150E) 
(defconstant +set+ #x150F) 

;;;; }}}

;;;; {{{ materialparameter

(defconstant +shininess+ #x1601) 
(defconstant +color-indexes+ #x1603) 

;;;; }}}

;;;; {{{ matrixmode

(defconstant +modelview+ #x1700) 
(defconstant +projection+ #x1701) 
(defconstant +texture+ #x1702) 

;;;; }}}

;;;; {{{ meshmode1

(defconstant +point+ #x1B00) 
(defconstant +line+ #x1B01) 

;;;; }}}

;;;; {{{ meshmode2

(defconstant +fill+ #x1B02) 

;;;; }}}

;;;; {{{ pixelcopytype

(defconstant +color+ #x1800) 
(defconstant +depth+ #x1801) 
(defconstant +stencil+ #x1802) 

;;;; }}}

;;;; {{{ pixelformat

(defconstant +color-index+ #x1900) 
(defconstant +stencil-index+ #x1901) 
(defconstant +depth-component+ #x1902) 
(defconstant +red+ #x1903) 
(defconstant +green+ #x1904) 
(defconstant +blue+ #x1905) 
(defconstant +alpha+ #x1906) 
(defconstant +rgb+ #x1907) 
(defconstant +rgba+ #x1908) 
(defconstant +luminance+ #x1909) 
(defconstant +luminance-alpha+ #x190A) 
(defconstant +abgr-ext+ #x8000) 
(defconstant +cmyk-ext+ #x800C) 
(defconstant +cmyka-ext+ #x800D) 
(defconstant +r5-g6-b5-icc-sgix+ :unable-to-resolve) 
(defconstant +r5-g6-b5-a8-icc-sgix+ :unable-to-resolve) 
(defconstant +alpha16-icc-sgix+ :unable-to-resolve) 
(defconstant +luminance16-icc-sgix+ :unable-to-resolve) 
(defconstant +luminance16-alpha8-icc-sgix+ :unable-to-resolve) 
(defconstant +ycrcb-422-sgix+ #x81BB) 
(defconstant +ycrcb-444-sgix+ #x81BC) 

;;;; }}}

;;;; {{{ pixelstoreresamplemode

(defconstant +resample-replicate-sgix+ #x842E) 
(defconstant +resample-zero-fill-sgix+ #x842F) 
(defconstant +resample-decimate-sgix+ #x8430) 

;;;; }}}

;;;; {{{ pixelstoresubsamplerate

(defconstant +pixel-subsample-4444-sgix+ #x85A2) 
(defconstant +pixel-subsample-2424-sgix+ #x85A3) 
(defconstant +pixel-subsample-4242-sgix+ #x85A4) 

;;;; }}}

;;;; {{{ pixeltexgenmode

(defconstant +pixel-tex-gen-alpha-replace-sgix+ #x8187) 
(defconstant +pixel-tex-gen-alpha-no-replace-sgix+ #x8188) 
(defconstant +pixel-tex-gen-alpha-ms-sgix+ #x818A) 
(defconstant +pixel-tex-gen-alpha-ls-sgix+ #x8189) 

;;;; }}}

;;;; {{{ pixeltexgenparameternamesgis

(defconstant +pixel-fragment-rgb-source-sgis+ #x8354) 
(defconstant +pixel-fragment-alpha-source-sgis+ #x8355) 

;;;; }}}

;;;; {{{ pixeltype

(defconstant +bitmap+ #x1A00) 
(defconstant +unsigned-byte-3-3-2-ext+ #x8032) 
(defconstant +unsigned-short-4-4-4-4-ext+ #x8033) 
(defconstant +unsigned-short-5-5-5-1-ext+ #x8034) 
(defconstant +unsigned-int-8-8-8-8-ext+ #x8035) 
(defconstant +unsigned-int-10-10-10-2-ext+ #x8036) 

;;;; }}}

;;;; {{{ renderingmode

(defconstant +render+ #x1C00) 
(defconstant +feedback+ #x1C01) 
(defconstant +select+ #x1C02) 

;;;; }}}

;;;; {{{ samplepatternsgis

(defconstant +1pass-sgis+ #x80A1) 
(defconstant +2pass-0-sgis+ #x80A2) 
(defconstant +2pass-1-sgis+ #x80A3) 
(defconstant +4pass-0-sgis+ #x80A4) 
(defconstant +4pass-1-sgis+ #x80A5) 
(defconstant +4pass-2-sgis+ #x80A6) 
(defconstant +4pass-3-sgis+ #x80A7) 

;;;; }}}

;;;; {{{ shadingmodel

(defconstant +flat+ #x1D00) 
(defconstant +smooth+ #x1D01) 

;;;; }}}

;;;; {{{ stencilop

(defconstant +keep+ #x1E00) 
(defconstant +incr+ #x1E02) 
(defconstant +decr+ #x1E03) 

;;;; }}}

;;;; {{{ stringname

(defconstant +vendor+ #x1F00) 
(defconstant +renderer+ #x1F01) 
(defconstant +version+ #x1F02) 
(defconstant +extensions+ #x1F03) 

;;;; }}}

;;;; {{{ texturecoordname

(defconstant +s+ #x2000) 
(defconstant +t+ #x2001) 
(defconstant +r+ #x2002) 
(defconstant +q+ #x2003) 

;;;; }}}

;;;; {{{ textureenvmode

(defconstant +decal+ #x2101) 
(defconstant +replace-ext+ #x8062) 
(defconstant +texture-env-bias-sgix+ #x80BE) 

;;;; }}}

;;;; {{{ textureenvparameter

(defconstant +texture-env-mode+ #x2200) 
(defconstant +texture-env-color+ #x2201) 

;;;; }}}

;;;; {{{ textureenvtarget

(defconstant +texture-env+ #x2300) 

;;;; }}}

;;;; {{{ texturefilterfuncsgis

(defconstant +filter4-sgis+ #x8146) 

;;;; }}}

;;;; {{{ texturegenmode

(defconstant +eye-linear+ #x2400) 
(defconstant +object-linear+ #x2401) 
(defconstant +sphere-map+ #x2402) 
(defconstant +eye-distance-to-point-sgis+ #x81F0) 
(defconstant +object-distance-to-point-sgis+ #x81F1) 
(defconstant +eye-distance-to-line-sgis+ #x81F2) 
(defconstant +object-distance-to-line-sgis+ #x81F3) 

;;;; }}}

;;;; {{{ texturegenparameter

(defconstant +texture-gen-mode+ #x2500) 
(defconstant +object-plane+ #x2501) 
(defconstant +eye-plane+ #x2502) 
(defconstant +eye-point-sgis+ #x81F4) 
(defconstant +object-point-sgis+ #x81F5) 
(defconstant +eye-line-sgis+ #x81F6) 
(defconstant +object-line-sgis+ #x81F7) 

;;;; }}}

;;;; {{{ texturemagfilter

(defconstant +nearest+ #x2600) 
(defconstant +linear-detail-sgis+ #x8097) 
(defconstant +linear-detail-alpha-sgis+ #x8098) 
(defconstant +linear-detail-color-sgis+ #x8099) 
(defconstant +linear-sharpen-sgis+ #x80AD) 
(defconstant +linear-sharpen-alpha-sgis+ #x80AE) 
(defconstant +linear-sharpen-color-sgis+ #x80AF) 
(defconstant +pixel-tex-gen-q-ceiling-sgix+ #x8184) 
(defconstant +pixel-tex-gen-q-round-sgix+ #x8185) 
(defconstant +pixel-tex-gen-q-floor-sgix+ #x8186) 

;;;; }}}

;;;; {{{ textureminfilter

(defconstant +nearest-mipmap-nearest+ #x2700) 
(defconstant +linear-mipmap-nearest+ #x2701) 
(defconstant +nearest-mipmap-linear+ #x2702) 
(defconstant +linear-mipmap-linear+ #x2703) 
(defconstant +linear-clipmap-linear-sgix+ #x8170) 
(defconstant +nearest-clipmap-nearest-sgix+ #x844D) 
(defconstant +nearest-clipmap-linear-sgix+ #x844E) 
(defconstant +linear-clipmap-nearest-sgix+ #x844F) 

;;;; }}}

;;;; {{{ texturetarget

(defconstant +proxy-texture-1d+ #x8063) 
(defconstant +proxy-texture-2d+ #x8064) 
(defconstant +proxy-texture-3d-ext+ #x8070) 
(defconstant +detail-texture-2d-sgis+ #x8095) 
(defconstant +proxy-texture-4d-sgis+ #x8135) 

;;;; }}}

;;;; {{{ texturewrapmode

(defconstant +clamp+ #x2900) 
(defconstant +repeat+ #x2901) 
(defconstant +clamp-to-border-sgis+ #x812D) 
(defconstant +clamp-to-edge-sgis+ #x812F) 

;;;; }}}

;;;; {{{ pixelinternalformat

(defconstant +r3-g3-b2+ #x2A10) 
(defconstant +alpha4+ #x803B) 
(defconstant +alpha8+ #x803C) 
(defconstant +alpha12+ #x803D) 
(defconstant +alpha16+ #x803E) 
(defconstant +luminance4+ #x803F) 
(defconstant +luminance8+ #x8040) 
(defconstant +luminance12+ #x8041) 
(defconstant +luminance16+ #x8042) 
(defconstant +luminance4-alpha4+ #x8043) 
(defconstant +luminance6-alpha2+ #x8044) 
(defconstant +luminance8-alpha8+ #x8045) 
(defconstant +luminance12-alpha4+ #x8046) 
(defconstant +luminance12-alpha12+ #x8047) 
(defconstant +luminance16-alpha16+ #x8048) 
(defconstant +intensity+ #x8049) 
(defconstant +intensity4+ #x804A) 
(defconstant +intensity8+ #x804B) 
(defconstant +intensity12+ #x804C) 
(defconstant +intensity16+ #x804D) 
(defconstant +rgb4+ #x804F) 
(defconstant +rgb5+ #x8050) 
(defconstant +rgb8+ #x8051) 
(defconstant +rgb10+ #x8052) 
(defconstant +rgb12+ #x8053) 
(defconstant +rgb16+ #x8054) 
(defconstant +rgba2+ #x8055) 
(defconstant +rgba4+ #x8056) 
(defconstant +rgb5-a1+ #x8057) 
(defconstant +rgba8+ #x8058) 
(defconstant +rgb10-a2+ #x8059) 
(defconstant +rgba12+ #x805A) 
(defconstant +rgba16+ #x805B) 
(defconstant +rgb2-ext+ #x804E) 
(defconstant +dual-alpha4-sgis+ #x8110) 
(defconstant +dual-alpha8-sgis+ #x8111) 
(defconstant +dual-alpha12-sgis+ #x8112) 
(defconstant +dual-alpha16-sgis+ #x8113) 
(defconstant +dual-luminance4-sgis+ #x8114) 
(defconstant +dual-luminance8-sgis+ #x8115) 
(defconstant +dual-luminance12-sgis+ #x8116) 
(defconstant +dual-luminance16-sgis+ #x8117) 
(defconstant +dual-intensity4-sgis+ #x8118) 
(defconstant +dual-intensity8-sgis+ #x8119) 
(defconstant +dual-intensity12-sgis+ #x811A) 
(defconstant +dual-intensity16-sgis+ #x811B) 
(defconstant +dual-luminance-alpha4-sgis+ #x811C) 
(defconstant +dual-luminance-alpha8-sgis+ #x811D) 
(defconstant +quad-alpha4-sgis+ #x811E) 
(defconstant +quad-alpha8-sgis+ #x811F) 
(defconstant +quad-luminance4-sgis+ #x8120) 
(defconstant +quad-luminance8-sgis+ #x8121) 
(defconstant +quad-intensity4-sgis+ #x8122) 
(defconstant +quad-intensity8-sgis+ #x8123) 
(defconstant +depth-component16-sgix+ #x81A5) 
(defconstant +depth-component24-sgix+ #x81A6) 
(defconstant +depth-component32-sgix+ #x81A7) 
(defconstant +rgb-icc-sgix+ :unable-to-resolve) 
(defconstant +rgba-icc-sgix+ :unable-to-resolve) 
(defconstant +alpha-icc-sgix+ :unable-to-resolve) 
(defconstant +luminance-icc-sgix+ :unable-to-resolve) 
(defconstant +intensity-icc-sgix+ :unable-to-resolve) 
(defconstant +luminance-alpha-icc-sgix+ :unable-to-resolve) 
(defconstant +intensity16-icc-sgix+ :unable-to-resolve) 

;;;; }}}

;;;; {{{ interleavedarrayformat

(defconstant +v2f+ #x2A20) 
(defconstant +v3f+ #x2A21) 
(defconstant +c4ub-v2f+ #x2A22) 
(defconstant +c4ub-v3f+ #x2A23) 
(defconstant +c3f-v3f+ #x2A24) 
(defconstant +n3f-v3f+ #x2A25) 
(defconstant +c4f-n3f-v3f+ #x2A26) 
(defconstant +t2f-v3f+ #x2A27) 
(defconstant +t4f-v4f+ #x2A28) 
(defconstant +t2f-c4ub-v3f+ #x2A29) 
(defconstant +t2f-c3f-v3f+ #x2A2A) 
(defconstant +t2f-n3f-v3f+ #x2A2B) 
(defconstant +t2f-c4f-n3f-v3f+ #x2A2C) 
(defconstant +t4f-c4f-n3f-v4f+ #x2A2D) 

;;;; }}}

;;;; {{{ ext_blend_subtract

(defconstant +func-subtract+ #x800A) 
(defconstant +func-reverse-subtract+ #x800B) 

;;;; }}}

;;;; {{{ ext_packed_pixels

(defconstant +unsigned-byte-3-3-2+ #x8032) 
(defconstant +unsigned-short-4-4-4-4+ #x8033) 
(defconstant +unsigned-short-5-5-5-1+ #x8034) 
(defconstant +unsigned-int-8-8-8-8+ #x8035) 
(defconstant +unsigned-int-10-10-10-2+ #x8036) 
(defconstant +unsigned-byte-2-3-3-rev+ #x8362) 
(defconstant +unsigned-byte-2-3-3-rev-ext+ #x8362) 
(defconstant +unsigned-short-5-6-5+ #x8363) 
(defconstant +unsigned-short-5-6-5-ext+ #x8363) 
(defconstant +unsigned-short-5-6-5-rev+ #x8364) 
(defconstant +unsigned-short-5-6-5-rev-ext+ #x8364) 
(defconstant +unsigned-short-4-4-4-4-rev+ #x8365) 
(defconstant +unsigned-short-4-4-4-4-rev-ext+ #x8365) 
(defconstant +unsigned-short-1-5-5-5-rev+ #x8366) 
(defconstant +unsigned-short-1-5-5-5-rev-ext+ #x8366) 
(defconstant +unsigned-int-8-8-8-8-rev+ #x8367) 
(defconstant +unsigned-int-8-8-8-8-rev-ext+ #x8367) 
(defconstant +unsigned-int-2-10-10-10-rev+ #x8368) 
(defconstant +unsigned-int-2-10-10-10-rev-ext+ #x8368) 

;;;; }}}

;;;; {{{ ext_rescale_normal

(defconstant +rescale-normal+ #x803A) 

;;;; }}}

;;;; {{{ ext_texture

(defconstant +alpha4-ext+ #x803B) 
(defconstant +alpha8-ext+ #x803C) 
(defconstant +alpha12-ext+ #x803D) 
(defconstant +alpha16-ext+ #x803E) 
(defconstant +luminance4-ext+ #x803F) 
(defconstant +luminance8-ext+ #x8040) 
(defconstant +luminance12-ext+ #x8041) 
(defconstant +luminance16-ext+ #x8042) 
(defconstant +luminance4-alpha4-ext+ #x8043) 
(defconstant +luminance6-alpha2-ext+ #x8044) 
(defconstant +luminance8-alpha8-ext+ #x8045) 
(defconstant +luminance12-alpha4-ext+ #x8046) 
(defconstant +luminance12-alpha12-ext+ #x8047) 
(defconstant +luminance16-alpha16-ext+ #x8048) 
(defconstant +intensity-ext+ #x8049) 
(defconstant +intensity4-ext+ #x804A) 
(defconstant +intensity8-ext+ #x804B) 
(defconstant +intensity12-ext+ #x804C) 
(defconstant +intensity16-ext+ #x804D) 
(defconstant +rgb4-ext+ #x804F) 
(defconstant +rgb5-ext+ #x8050) 
(defconstant +rgb8-ext+ #x8051) 
(defconstant +rgb10-ext+ #x8052) 
(defconstant +rgb12-ext+ #x8053) 
(defconstant +rgb16-ext+ #x8054) 
(defconstant +rgba2-ext+ #x8055) 
(defconstant +rgba4-ext+ #x8056) 
(defconstant +rgb5-a1-ext+ #x8057) 
(defconstant +rgba8-ext+ #x8058) 
(defconstant +rgb10-a2-ext+ #x8059) 
(defconstant +rgba12-ext+ #x805A) 
(defconstant +rgba16-ext+ #x805B) 
(defconstant +texture-red-size-ext+ #x805C) 
(defconstant +texture-green-size-ext+ #x805D) 
(defconstant +texture-blue-size-ext+ #x805E) 
(defconstant +texture-alpha-size-ext+ #x805F) 
(defconstant +texture-luminance-size-ext+ #x8060) 
(defconstant +texture-intensity-size-ext+ #x8061) 
(defconstant +proxy-texture-1d-ext+ #x8063) 
(defconstant +proxy-texture-2d-ext+ #x8064) 

;;;; }}}

;;;; {{{ sgi_color_matrix

(defconstant +color-matrix+ #x80B1) 
(defconstant +color-matrix-stack-depth+ #x80B2) 
(defconstant +max-color-matrix-stack-depth+ #x80B3) 
(defconstant +post-color-matrix-red-scale+ #x80B4) 
(defconstant +post-color-matrix-green-scale+ #x80B5) 
(defconstant +post-color-matrix-blue-scale+ #x80B6) 
(defconstant +post-color-matrix-alpha-scale+ #x80B7) 
(defconstant +post-color-matrix-red-bias+ #x80B8) 
(defconstant +post-color-matrix-green-bias+ #x80B9) 
(defconstant +post-color-matrix-blue-bias+ #x80BA) 
(defconstant +post-color-matrix-alpha-bias+ #x80BB) 

;;;; }}}

;;;; {{{ ext_bgra

(defconstant +bgr+ #x80E0) 
(defconstant +bgr-ext+ #x80E0) 
(defconstant +bgra+ #x80E1) 
(defconstant +bgra-ext+ #x80E1) 

;;;; }}}

;;;; {{{ sgis_texture_border_clamp

(defconstant +clamp-to-border+ #x812D) 
(defconstant +clamp-to-border-arb+ #x812D) 

;;;; }}}

;;;; {{{ sgis_texture_edge_clamp

(defconstant +clamp-to-edge+ #x812F) 

;;;; }}}

;;;; {{{ sgis_texture_lod

(defconstant +texture-min-lod+ #x813A) 
(defconstant +texture-max-lod+ #x813B) 
(defconstant +texture-base-level+ #x813C) 
(defconstant +texture-max-level+ #x813D) 

;;;; }}}

;;;; {{{ hp_convolution_border_modes

(defconstant +ignore-border-hp+ #x8150) 
(defconstant +constant-border+ #x8151) 
(defconstant +constant-border-hp+ #x8151) 
(defconstant +replicate-border+ #x8153) 
(defconstant +replicate-border-hp+ #x8153) 
(defconstant +convolution-border-color+ #x8154) 
(defconstant +convolution-border-color-hp+ #x8154) 

;;;; }}}

;;;; {{{ sgis_generate_mipmap

(defconstant +generate-mipmap+ #x8191) 
(defconstant +generate-mipmap-hint+ #x8192) 
(defconstant +max-deformation-order-sgix+ #x8197) 

;;;; }}}

;;;; {{{ sgix_depth_texture

(defconstant +depth-component16+ #x81A5) 
(defconstant +depth-component24+ #x81A6) 
(defconstant +depth-component32+ #x81A7) 

;;;; }}}

;;;; {{{ ext_separate_specular_color

(defconstant +light-model-color-control-ext+ #x81F8) 
(defconstant +single-color-ext+ #x81F9) 
(defconstant +separate-specular-color-ext+ #x81FA) 

;;;; }}}

;;;; {{{ sgix_texture_coordinate_clamp

(defconstant +fog-factor-to-alpha-sgix+ #x836F) 

;;;; }}}

;;;; {{{ ext_texture_compression_s3tc

(defconstant +compressed-rgb-s3tc-dxt1-ext+ #x83F0) 
(defconstant +compressed-rgba-s3tc-dxt1-ext+ #x83F1) 
(defconstant +compressed-rgba-s3tc-dxt3-ext+ #x83F2) 
(defconstant +compressed-rgba-s3tc-dxt5-ext+ #x83F3) 

;;;; }}}

;;;; {{{ arb_imaging

(defconstant +constant-color+ #x8001) 
(defconstant +one-minus-constant-color+ #x8002) 
(defconstant +constant-alpha+ #x8003) 
(defconstant +one-minus-constant-alpha+ #x8004) 
(defconstant +blend-color+ #x8005) 
(defconstant +func-add+ #x8006) 
(defconstant +min+ #x8007) 
(defconstant +max+ #x8008) 
(defconstant +blend-equation+ #x8009) 
(defconstant +convolution-1d+ #x8010) 
(defconstant +convolution-2d+ #x8011) 
(defconstant +separable-2d+ #x8012) 
(defconstant +convolution-border-mode+ #x8013) 
(defconstant +convolution-filter-scale+ #x8014) 
(defconstant +convolution-filter-bias+ #x8015) 
(defconstant +reduce+ #x8016) 
(defconstant +convolution-format+ #x8017) 
(defconstant +convolution-width+ #x8018) 
(defconstant +convolution-height+ #x8019) 
(defconstant +max-convolution-width+ #x801A) 
(defconstant +max-convolution-height+ #x801B) 
(defconstant +post-convolution-red-scale+ #x801C) 
(defconstant +post-convolution-green-scale+ #x801D) 
(defconstant +post-convolution-blue-scale+ #x801E) 
(defconstant +post-convolution-alpha-scale+ #x801F) 
(defconstant +post-convolution-red-bias+ #x8020) 
(defconstant +post-convolution-green-bias+ #x8021) 
(defconstant +post-convolution-blue-bias+ #x8022) 
(defconstant +post-convolution-alpha-bias+ #x8023) 
(defconstant +histogram+ #x8024) 
(defconstant +proxy-histogram+ #x8025) 
(defconstant +histogram-width+ #x8026) 
(defconstant +histogram-format+ #x8027) 
(defconstant +histogram-red-size+ #x8028) 
(defconstant +histogram-green-size+ #x8029) 
(defconstant +histogram-blue-size+ #x802A) 
(defconstant +histogram-alpha-size+ #x802B) 
(defconstant +histogram-luminance-size+ #x802C) 
(defconstant +histogram-sink+ #x802D) 
(defconstant +minmax+ #x802E) 
(defconstant +minmax-format+ #x802F) 
(defconstant +minmax-sink+ #x8030) 
(defconstant +table-too-large+ #x8031) 
(defconstant +color-table+ #x80D0) 
(defconstant +post-convolution-color-table+ #x80D1) 
(defconstant +post-color-matrix-color-table+ #x80D2) 
(defconstant +proxy-color-table+ #x80D3) 
(defconstant +proxy-post-convolution-color-table+ #x80D4) 
(defconstant +proxy-post-color-matrix-color-table+ #x80D5) 
(defconstant +color-table-scale+ #x80D6) 
(defconstant +color-table-bias+ #x80D7) 
(defconstant +color-table-format+ #x80D8) 
(defconstant +color-table-width+ #x80D9) 
(defconstant +color-table-red-size+ #x80DA) 
(defconstant +color-table-green-size+ #x80DB) 
(defconstant +color-table-blue-size+ #x80DC) 
(defconstant +color-table-alpha-size+ #x80DD) 
(defconstant +color-table-luminance-size+ #x80DE) 
(defconstant +color-table-intensity-size+ #x80DF) 

;;;; }}}

;;;; {{{ arb_texture_cube_map

(defconstant +normal-map-arb+ #x8511) 
(defconstant +reflection-map-arb+ #x8512) 
(defconstant +texture-cube-map-arb+ #x8513) 
(defconstant +texture-binding-cube-map-arb+ #x8514) 
(defconstant +texture-cube-map-positive-x-arb+ #x8515) 
(defconstant +texture-cube-map-negative-x-arb+ #x8516) 
(defconstant +texture-cube-map-positive-y-arb+ #x8517) 
(defconstant +texture-cube-map-negative-y-arb+ #x8518) 
(defconstant +texture-cube-map-positive-z-arb+ #x8519) 
(defconstant +texture-cube-map-negative-z-arb+ #x851A) 
(defconstant +proxy-texture-cube-map-arb+ #x851B) 
(defconstant +max-cube-map-texture-size-arb+ #x851C) 

;;;; }}}

;;;; {{{ arb_texture_env_combine

(defconstant +combine-arb+ #x8570) 
(defconstant +combine-rgb-arb+ #x8571) 
(defconstant +combine-alpha-arb+ #x8572) 
(defconstant +source0-rgb-arb+ #x8580) 
(defconstant +source1-rgb-arb+ #x8581) 
(defconstant +source2-rgb-arb+ #x8582) 
(defconstant +source0-alpha-arb+ #x8588) 
(defconstant +source1-alpha-arb+ #x8589) 
(defconstant +source2-alpha-arb+ #x858A) 
(defconstant +operand0-rgb-arb+ #x8590) 
(defconstant +operand1-rgb-arb+ #x8591) 
(defconstant +operand2-rgb-arb+ #x8592) 
(defconstant +operand0-alpha-arb+ #x8598) 
(defconstant +operand1-alpha-arb+ #x8599) 
(defconstant +operand2-alpha-arb+ #x859A) 
(defconstant +rgb-scale-arb+ #x8573) 
(defconstant +add-signed-arb+ #x8574) 
(defconstant +interpolate-arb+ #x8575) 
(defconstant +subtract-arb+ #x84E7) 
(defconstant +constant-arb+ #x8576) 
(defconstant +primary-color-arb+ #x8577) 
(defconstant +previous-arb+ #x8578) 

;;;; }}}

;;;; {{{ arb_texture_env_dot3

(defconstant +dot3-rgb-arb+ #x86AE) 
(defconstant +dot3-rgba-arb+ #x86AF) 

;;;; }}}

;;;; {{{ arb_texture_mirrored_repeat

(defconstant +mirrored-repeat-arb+ #x8370) 

;;;; }}}

;;;; {{{ arb_depth_texture

(defconstant +depth-component16-arb+ #x81A5) 
(defconstant +depth-component24-arb+ #x81A6) 
(defconstant +depth-component32-arb+ #x81A7) 
(defconstant +texture-depth-size-arb+ #x884A) 
(defconstant +depth-texture-mode-arb+ #x884B) 

;;;; }}}

;;;; {{{ arb_shadow

(defconstant +texture-compare-mode-arb+ #x884C) 
(defconstant +texture-compare-func-arb+ #x884D) 
(defconstant +compare-r-to-texture-arb+ #x884E) 

;;;; }}}

;;;; {{{ arb_shadow_ambient

(defconstant +texture-compare-fail-value-arb+ #x80BF) 

;;;; }}}

;;;; {{{ arb_fragment_program

(defconstant +fragment-program-arb+ #x8804) 
(defconstant +program-alu-instructions-arb+ #x8805) 
(defconstant +program-tex-instructions-arb+ #x8806) 
(defconstant +program-tex-indirections-arb+ #x8807) 
(defconstant +program-native-alu-instructions-arb+ #x8808) 
(defconstant +program-native-tex-instructions-arb+ #x8809) 
(defconstant +program-native-tex-indirections-arb+ #x880A) 
(defconstant +max-program-alu-instructions-arb+ #x880B) 
(defconstant +max-program-tex-instructions-arb+ #x880C) 
(defconstant +max-program-tex-indirections-arb+ #x880D) 
(defconstant +max-program-native-alu-instructions-arb+ #x880E) 
(defconstant +max-program-native-tex-instructions-arb+ #x880F) 
(defconstant +max-program-native-tex-indirections-arb+ #x8810) 
(defconstant +max-texture-coords-arb+ #x8871) 
(defconstant +max-texture-image-units-arb+ #x8872) 

;;;; }}}

;;;; {{{ arb_fragment_shader

(defconstant +fragment-shader-arb+ #x8B30) 
(defconstant +max-fragment-uniform-components-arb+ #x8B49) 
(defconstant +fragment-shader-derivative-hint-arb+ #x8B8B) 

;;;; }}}

;;;; {{{ arb_shading_language_100

(defconstant +shading-language-version-arb+ #x8B8C) 

;;;; }}}

;;;; {{{ arb_point_sprite

(defconstant +point-sprite-arb+ #x8861) 
(defconstant +coord-replace-arb+ #x8862) 

;;;; }}}

;;;; {{{ arb_texture_rectangle

(defconstant +texture-rectangle-arb+ #x84F5) 
(defconstant +texture-binding-rectangle-arb+ #x84F6) 
(defconstant +proxy-texture-rectangle-arb+ #x84F7) 
(defconstant +max-rectangle-texture-size-arb+ #x84F8) 

;;;; }}}

;;;; {{{ arb_half_float_pixel

(defconstant +half-float-arb+ #x140B) 

;;;; }}}

;;;; {{{ arb_texture_float

(defconstant +texture-red-type-arb+ #x8C10) 
(defconstant +texture-green-type-arb+ #x8C11) 
(defconstant +texture-blue-type-arb+ #x8C12) 
(defconstant +texture-alpha-type-arb+ #x8C13) 
(defconstant +texture-luminance-type-arb+ #x8C14) 
(defconstant +texture-intensity-type-arb+ #x8C15) 
(defconstant +texture-depth-type-arb+ #x8C16) 
(defconstant +unsigned-normalized-arb+ #x8C17) 
(defconstant +rgba32f-arb+ #x8814) 
(defconstant +rgb32f-arb+ #x8815) 
(defconstant +alpha32f-arb+ #x8816) 
(defconstant +intensity32f-arb+ #x8817) 
(defconstant +luminance32f-arb+ #x8818) 
(defconstant +luminance-alpha32f-arb+ #x8819) 
(defconstant +rgba16f-arb+ #x881A) 
(defconstant +rgb16f-arb+ #x881B) 
(defconstant +alpha16f-arb+ #x881C) 
(defconstant +intensity16f-arb+ #x881D) 
(defconstant +luminance16f-arb+ #x881E) 
(defconstant +luminance-alpha16f-arb+ #x881F) 

;;;; }}}

;;;; {{{ arb_pixel_buffer_object

(defconstant +pixel-pack-buffer-arb+ #x88EB) 
(defconstant +pixel-unpack-buffer-arb+ #x88EC) 
(defconstant +pixel-pack-buffer-binding-arb+ #x88ED) 
(defconstant +pixel-unpack-buffer-binding-arb+ #x88EF) 

;;;; }}}

;;;; {{{ pgi_vertex_hints

(defconstant +vertex-data-hint-pgi+ #x1A22A) 
(defconstant +vertex-consistent-hint-pgi+ #x1A22B) 
(defconstant +material-side-hint-pgi+ #x1A22C) 
(defconstant +max-vertex-hint-pgi+ #x1A22D) 
(defconstant +color3-bit-pgi+ #x10000) 
(defconstant +color4-bit-pgi+ #x20000) 
(defconstant +edgeflag-bit-pgi+ #x40000) 
(defconstant +index-bit-pgi+ #x80000) 
(defconstant +mat-ambient-bit-pgi+ #x100000) 
(defconstant +mat-ambient-and-diffuse-bit-pgi+ #x200000) 
(defconstant +mat-diffuse-bit-pgi+ #x400000) 
(defconstant +mat-emission-bit-pgi+ #x800000) 
(defconstant +mat-color-indexes-bit-pgi+ #x1000000) 
(defconstant +mat-shininess-bit-pgi+ #x2000000) 
(defconstant +mat-specular-bit-pgi+ #x4000000) 
(defconstant +normal-bit-pgi+ #x8000000) 
(defconstant +texcoord1-bit-pgi+ #x10000000) 
(defconstant +texcoord2-bit-pgi+ #x20000000) 
(defconstant +texcoord3-bit-pgi+ #x40000000) 
(defconstant +texcoord4-bit-pgi+ #x80000000) 
(defconstant +vertex23-bit-pgi+ #x4) 
(defconstant +vertex4-bit-pgi+ #x8) 

;;;; }}}

;;;; {{{ ext_clip_volume_hint

(defconstant +clip-volume-clipping-hint-ext+ #x80F0) 

;;;; }}}

;;;; {{{ ext_index_array_formats

(defconstant +iui-v2f-ext+ #x81AD) 
(defconstant +iui-v3f-ext+ #x81AE) 
(defconstant +iui-n3f-v2f-ext+ #x81AF) 
(defconstant +iui-n3f-v3f-ext+ #x81B0) 
(defconstant +t2f-iui-v2f-ext+ #x81B1) 
(defconstant +t2f-iui-v3f-ext+ #x81B2) 
(defconstant +t2f-iui-n3f-v2f-ext+ #x81B3) 
(defconstant +t2f-iui-n3f-v3f-ext+ #x81B4) 

;;;; }}}

;;;; {{{ ibm_rasterpos_clip

(defconstant +raster-position-unclipped-ibm+ #x19262) 

;;;; }}}

;;;; {{{ hp_texture_lighting

(defconstant +texture-lighting-mode-hp+ #x8167) 
(defconstant +texture-post-specular-hp+ #x8168) 
(defconstant +texture-pre-specular-hp+ #x8169) 

;;;; }}}

;;;; {{{ win_phong_shading

(defconstant +phong-win+ #x80EA) 
(defconstant +phong-hint-win+ #x80EB) 

;;;; }}}

;;;; {{{ win_specular_fog

(defconstant +fog-specular-texture-win+ #x80EC) 

;;;; }}}

;;;; {{{ hp_occlusion_test

(defconstant +occlusion-test-hp+ #x8165) 
(defconstant +occlusion-test-result-hp+ #x8166) 

;;;; }}}

;;;; {{{ rend_screen_coordinates

(defconstant +screen-coordinates-rend+ #x8490) 
(defconstant +inverted-screen-w-rend+ #x8491) 

;;;; }}}

;;;; {{{ ext_texture_env_combine

(defconstant +combine-ext+ #x8570) 
(defconstant +combine-rgb-ext+ #x8571) 
(defconstant +combine-alpha-ext+ #x8572) 
(defconstant +rgb-scale-ext+ #x8573) 
(defconstant +add-signed-ext+ #x8574) 
(defconstant +interpolate-ext+ #x8575) 
(defconstant +constant-ext+ #x8576) 
(defconstant +primary-color-ext+ #x8577) 
(defconstant +previous-ext+ #x8578) 
(defconstant +source0-rgb-ext+ #x8580) 
(defconstant +source1-rgb-ext+ #x8581) 
(defconstant +source2-rgb-ext+ #x8582) 
(defconstant +source0-alpha-ext+ #x8588) 
(defconstant +source1-alpha-ext+ #x8589) 
(defconstant +source2-alpha-ext+ #x858A) 
(defconstant +operand0-rgb-ext+ #x8590) 
(defconstant +operand1-rgb-ext+ #x8591) 
(defconstant +operand2-rgb-ext+ #x8592) 
(defconstant +operand0-alpha-ext+ #x8598) 
(defconstant +operand1-alpha-ext+ #x8599) 
(defconstant +operand2-alpha-ext+ #x859A) 

;;;; }}}

;;;; {{{ apple_specular_vector

(defconstant +light-model-specular-vector-apple+ #x85B0) 

;;;; }}}

;;;; {{{ apple_transform_hint

(defconstant +transform-hint-apple+ #x85B1) 

;;;; }}}

;;;; {{{ sgix_fog_scale

(defconstant +fog-scale-sgix+ #x81FC) 
(defconstant +fog-scale-value-sgix+ #x81FD) 

;;;; }}}

;;;; {{{ ingr_color_clamp

(defconstant +red-min-clamp-ingr+ #x8560) 
(defconstant +green-min-clamp-ingr+ #x8561) 
(defconstant +blue-min-clamp-ingr+ #x8562) 
(defconstant +alpha-min-clamp-ingr+ #x8563) 
(defconstant +red-max-clamp-ingr+ #x8564) 
(defconstant +green-max-clamp-ingr+ #x8565) 
(defconstant +blue-max-clamp-ingr+ #x8566) 
(defconstant +alpha-max-clamp-ingr+ #x8567) 

;;;; }}}

;;;; {{{ ingr_interlace_read

(defconstant +interlace-read-ingr+ #x8568) 

;;;; }}}

;;;; {{{ ext_stencil_wrap

(defconstant +incr-wrap-ext+ #x8507) 
(defconstant +decr-wrap-ext+ #x8508) 

;;;; }}}

;;;; {{{ ext_422_pixels

(defconstant +422-ext+ #x80CC) 
(defconstant +422-rev-ext+ #x80CD) 
(defconstant +422-average-ext+ #x80CE) 
(defconstant +422-rev-average-ext+ #x80CF) 

;;;; }}}

;;;; {{{ nv_texgen_reflection

(defconstant +normal-map-nv+ #x8511) 
(defconstant +reflection-map-nv+ #x8512) 

;;;; }}}

;;;; {{{ ext_texture_cube_map

(defconstant +normal-map-ext+ #x8511) 
(defconstant +reflection-map-ext+ #x8512) 
(defconstant +texture-cube-map-ext+ #x8513) 
(defconstant +texture-binding-cube-map-ext+ #x8514) 
(defconstant +texture-cube-map-positive-x-ext+ #x8515) 
(defconstant +texture-cube-map-negative-x-ext+ #x8516) 
(defconstant +texture-cube-map-positive-y-ext+ #x8517) 
(defconstant +texture-cube-map-negative-y-ext+ #x8518) 
(defconstant +texture-cube-map-positive-z-ext+ #x8519) 
(defconstant +texture-cube-map-negative-z-ext+ #x851A) 
(defconstant +proxy-texture-cube-map-ext+ #x851B) 
(defconstant +max-cube-map-texture-size-ext+ #x851C) 

;;;; }}}

;;;; {{{ sun_convolution_border_modes

(defconstant +wrap-border-sun+ #x81D4) 

;;;; }}}

;;;; {{{ ext_texture_lod_bias

(defconstant +max-texture-lod-bias-ext+ #x84FD) 
(defconstant +texture-filter-control-ext+ #x8500) 
(defconstant +texture-lod-bias-ext+ #x8501) 

;;;; }}}

;;;; {{{ ext_texture_filter_anisotropic

(defconstant +texture-max-anisotropy-ext+ #x84FE) 
(defconstant +max-texture-max-anisotropy-ext+ #x84FF) 

;;;; }}}

;;;; {{{ nv_light_max_exponent

(defconstant +max-shininess-nv+ #x8504) 
(defconstant +max-spot-exponent-nv+ #x8505) 

;;;; }}}

;;;; {{{ nv_fog_distance

(defconstant +fog-distance-mode-nv+ #x855A) 
(defconstant +eye-radial-nv+ #x855B) 
(defconstant +eye-plane-absolute-nv+ #x855C) 

;;;; }}}

;;;; {{{ nv_texgen_emboss

(defconstant +emboss-light-nv+ #x855D) 
(defconstant +emboss-constant-nv+ #x855E) 
(defconstant +emboss-map-nv+ #x855F) 

;;;; }}}

;;;; {{{ nv_texture_env_combine4

(defconstant +combine4-nv+ #x8503) 
(defconstant +source3-rgb-nv+ #x8583) 
(defconstant +source3-alpha-nv+ #x858B) 
(defconstant +operand3-rgb-nv+ #x8593) 
(defconstant +operand3-alpha-nv+ #x859B) 

;;;; }}}

;;;; {{{ ibm_cull_vertex

(defconstant +cull-vertex-ibm+ #x1928A) 

;;;; }}}

;;;; {{{ sgix_ycrcba

(defconstant +ycrcb-sgix+ #x8318) 
(defconstant +ycrcba-sgix+ #x8319) 

;;;; }}}

;;;; {{{ sgi_depth_pass_instrument

(defconstant +depth-pass-instrument-sgix+ #x8310) 
(defconstant +depth-pass-instrument-counters-sgix+ #x8311) 
(defconstant +depth-pass-instrument-max-sgix+ #x8312) 

;;;; }}}

;;;; {{{ 3dfx_texture_compression_fxt1

(defconstant +compressed-rgb-fxt1-3dfx+ #x86B0) 
(defconstant +compressed-rgba-fxt1-3dfx+ #x86B1) 

;;;; }}}

;;;; {{{ 3dfx_multisample

(defconstant +multisample-3dfx+ #x86B2) 
(defconstant +sample-buffers-3dfx+ #x86B3) 
(defconstant +samples-3dfx+ #x86B4) 
(defconstant +multisample-bit-3dfx+ #x20000000) 

;;;; }}}

;;;; {{{ ext_texture_env_dot3

(defconstant +dot3-rgb-ext+ #x8740) 
(defconstant +dot3-rgba-ext+ #x8741) 

;;;; }}}

;;;; {{{ ati_texture_mirror_once

(defconstant +mirror-clamp-ati+ #x8742) 
(defconstant +mirror-clamp-to-edge-ati+ #x8743) 

;;;; }}}

;;;; {{{ ibm_texture_mirrored_repeat

(defconstant +mirrored-repeat-ibm+ #x8370) 

;;;; }}}

;;;; {{{ nv_packed_depth_stencil

(defconstant +depth-stencil-nv+ #x84F9) 
(defconstant +unsigned-int-24-8-nv+ #x84FA) 

;;;; }}}

;;;; {{{ nv_texture_rectangle

(defconstant +texture-rectangle-nv+ #x84F5) 
(defconstant +texture-binding-rectangle-nv+ #x84F6) 
(defconstant +proxy-texture-rectangle-nv+ #x84F7) 
(defconstant +max-rectangle-texture-size-nv+ #x84F8) 

;;;; }}}

;;;; {{{ nv_texture_shader

(defconstant +offset-texture-rectangle-nv+ #x864C) 
(defconstant +offset-texture-rectangle-scale-nv+ #x864D) 
(defconstant +dot-product-texture-rectangle-nv+ #x864E) 
(defconstant +rgba-unsigned-dot-product-mapping-nv+ #x86D9) 
(defconstant +unsigned-int-s8-s8-8-8-nv+ #x86DA) 
(defconstant +unsigned-int-8-8-s8-s8-rev-nv+ #x86DB) 
(defconstant +dsdt-mag-intensity-nv+ #x86DC) 
(defconstant +shader-consistent-nv+ #x86DD) 
(defconstant +texture-shader-nv+ #x86DE) 
(defconstant +shader-operation-nv+ #x86DF) 
(defconstant +cull-modes-nv+ #x86E0) 
(defconstant +offset-texture-matrix-nv+ #x86E1) 
(defconstant +offset-texture-scale-nv+ #x86E2) 
(defconstant +offset-texture-bias-nv+ #x86E3) 
(defconstant +offset-texture-2d-matrix-nv+ #x86E1) 
(defconstant +offset-texture-2d-scale-nv+ #x86E2) 
(defconstant +offset-texture-2d-bias-nv+ #x86E3) 
(defconstant +previous-texture-input-nv+ #x86E4) 
(defconstant +const-eye-nv+ #x86E5) 
(defconstant +pass-through-nv+ #x86E6) 
(defconstant +cull-fragment-nv+ #x86E7) 
(defconstant +offset-texture-2d-nv+ #x86E8) 
(defconstant +dependent-ar-texture-2d-nv+ #x86E9) 
(defconstant +dependent-gb-texture-2d-nv+ #x86EA) 
(defconstant +dot-product-nv+ #x86EC) 
(defconstant +dot-product-depth-replace-nv+ #x86ED) 
(defconstant +dot-product-texture-2d-nv+ #x86EE) 
(defconstant +dot-product-texture-cube-map-nv+ #x86F0) 
(defconstant +dot-product-diffuse-cube-map-nv+ #x86F1) 
(defconstant +dot-product-reflect-cube-map-nv+ #x86F2) 
(defconstant +dot-product-const-eye-reflect-cube-map-nv+ #x86F3) 
(defconstant +hilo-nv+ #x86F4) 
(defconstant +dsdt-nv+ #x86F5) 
(defconstant +dsdt-mag-nv+ #x86F6) 
(defconstant +dsdt-mag-vib-nv+ #x86F7) 
(defconstant +hilo16-nv+ #x86F8) 
(defconstant +signed-hilo-nv+ #x86F9) 
(defconstant +signed-hilo16-nv+ #x86FA) 
(defconstant +signed-rgba-nv+ #x86FB) 
(defconstant +signed-rgba8-nv+ #x86FC) 
(defconstant +signed-rgb-nv+ #x86FE) 
(defconstant +signed-rgb8-nv+ #x86FF) 
(defconstant +signed-luminance-nv+ #x8701) 
(defconstant +signed-luminance8-nv+ #x8702) 
(defconstant +signed-luminance-alpha-nv+ #x8703) 
(defconstant +signed-luminance8-alpha8-nv+ #x8704) 
(defconstant +signed-alpha-nv+ #x8705) 
(defconstant +signed-alpha8-nv+ #x8706) 
(defconstant +signed-intensity-nv+ #x8707) 
(defconstant +signed-intensity8-nv+ #x8708) 
(defconstant +dsdt8-nv+ #x8709) 
(defconstant +dsdt8-mag8-nv+ #x870A) 
(defconstant +dsdt8-mag8-intensity8-nv+ #x870B) 
(defconstant +signed-rgb-unsigned-alpha-nv+ #x870C) 
(defconstant +signed-rgb8-unsigned-alpha8-nv+ #x870D) 
(defconstant +hi-scale-nv+ #x870E) 
(defconstant +lo-scale-nv+ #x870F) 
(defconstant +ds-scale-nv+ #x8710) 
(defconstant +dt-scale-nv+ #x8711) 
(defconstant +magnitude-scale-nv+ #x8712) 
(defconstant +vibrance-scale-nv+ #x8713) 
(defconstant +hi-bias-nv+ #x8714) 
(defconstant +lo-bias-nv+ #x8715) 
(defconstant +ds-bias-nv+ #x8716) 
(defconstant +dt-bias-nv+ #x8717) 
(defconstant +magnitude-bias-nv+ #x8718) 
(defconstant +vibrance-bias-nv+ #x8719) 
(defconstant +texture-border-values-nv+ #x871A) 
(defconstant +texture-hi-size-nv+ #x871B) 
(defconstant +texture-lo-size-nv+ #x871C) 
(defconstant +texture-ds-size-nv+ #x871D) 
(defconstant +texture-dt-size-nv+ #x871E) 
(defconstant +texture-mag-size-nv+ #x871F) 

;;;; }}}

;;;; {{{ nv_texture_shader2

(defconstant +dot-product-texture-3d-nv+ #x86EF) 

;;;; }}}

;;;; {{{ nv_vertex_array_range2

(defconstant +vertex-array-range-without-flush-nv+ #x8533) 

;;;; }}}

;;;; {{{ sgix_scalebias_hint

(defconstant +scalebias-hint-sgix+ #x8322) 

;;;; }}}

;;;; {{{ oml_interlace

(defconstant +interlace-oml+ #x8980) 
(defconstant +interlace-read-oml+ #x8981) 

;;;; }}}

;;;; {{{ oml_subsample

(defconstant +format-subsample-24-24-oml+ #x8982) 
(defconstant +format-subsample-244-244-oml+ #x8983) 

;;;; }}}

;;;; {{{ oml_resample

(defconstant +pack-resample-oml+ #x8984) 
(defconstant +unpack-resample-oml+ #x8985) 
(defconstant +resample-replicate-oml+ #x8986) 
(defconstant +resample-zero-fill-oml+ #x8987) 
(defconstant +resample-average-oml+ #x8988) 
(defconstant +resample-decimate-oml+ #x8989) 

;;;; }}}

;;;; {{{ nv_copy_depth_to_color

(defconstant +depth-stencil-to-rgba-nv+ #x886E) 
(defconstant +depth-stencil-to-bgra-nv+ #x886F) 

;;;; }}}

;;;; {{{ sun_slice_accum

(defconstant +slice-accum-sun+ #x85CC) 

;;;; }}}

;;;; {{{ nv_multisample_filter_hint

(defconstant +multisample-filter-hint-nv+ #x8534) 

;;;; }}}

;;;; {{{ nv_depth_clamp

(defconstant +depth-clamp-nv+ #x864F) 

;;;; }}}

;;;; {{{ nv_texture_shader3

(defconstant +offset-projective-texture-2d-nv+ #x8850) 
(defconstant +offset-projective-texture-2d-scale-nv+ #x8851) 
(defconstant +offset-projective-texture-rectangle-nv+ #x8852) 
(defconstant +offset-projective-texture-rectangle-scale-nv+ #x8853) 
(defconstant +offset-hilo-texture-2d-nv+ #x8854) 
(defconstant +offset-hilo-texture-rectangle-nv+ #x8855) 
(defconstant +offset-hilo-projective-texture-2d-nv+ #x8856) 
(defconstant +offset-hilo-projective-texture-rectangle-nv+ #x8857) 
(defconstant +dependent-hilo-texture-2d-nv+ #x8858) 
(defconstant +dependent-rgb-texture-3d-nv+ #x8859) 
(defconstant +dependent-rgb-texture-cube-map-nv+ #x885A) 
(defconstant +dot-product-pass-through-nv+ #x885B) 
(defconstant +dot-product-texture-1d-nv+ #x885C) 
(defconstant +dot-product-affine-depth-replace-nv+ #x885D) 
(defconstant +hilo8-nv+ #x885E) 
(defconstant +signed-hilo8-nv+ #x885F) 
(defconstant +force-blue-to-one-nv+ #x8860) 

;;;; }}}

;;;; {{{ ati_text_fragment_shader

(defconstant +text-fragment-shader-ati+ #x8200) 

;;;; }}}

;;;; {{{ apple_client_storage

(defconstant +unpack-client-storage-apple+ #x85B2) 

;;;; }}}

;;;; {{{ apple_ycbcr_422

(defconstant +ycbcr-422-apple+ #x85B9) 
(defconstant +unsigned-short-8-8-apple+ #x85BA) 
(defconstant +unsigned-short-8-8-rev-apple+ #x85BB) 

;;;; }}}

;;;; {{{ s3_s3tc

(defconstant +rgb-s3tc+ #x83A0) 
(defconstant +rgb4-s3tc+ #x83A1) 
(defconstant +rgba-s3tc+ #x83A2) 
(defconstant +rgba4-s3tc+ #x83A3) 

;;;; }}}

;;;; {{{ ati_pixel_format_float

(defconstant +type-rgba-float-ati+ #x8820) 
(defconstant +color-clear-unclamped-value-ati+ #x8835) 

;;;; }}}

;;;; {{{ ati_texture_env_combine3

(defconstant +modulate-add-ati+ #x8744) 
(defconstant +modulate-signed-add-ati+ #x8745) 
(defconstant +modulate-subtract-ati+ #x8746) 

;;;; }}}

;;;; {{{ ati_texture_float

(defconstant +rgba-float32-ati+ #x8814) 
(defconstant +rgb-float32-ati+ #x8815) 
(defconstant +alpha-float32-ati+ #x8816) 
(defconstant +intensity-float32-ati+ #x8817) 
(defconstant +luminance-float32-ati+ #x8818) 
(defconstant +luminance-alpha-float32-ati+ #x8819) 
(defconstant +rgba-float16-ati+ #x881A) 
(defconstant +rgb-float16-ati+ #x881B) 
(defconstant +alpha-float16-ati+ #x881C) 
(defconstant +intensity-float16-ati+ #x881D) 
(defconstant +luminance-float16-ati+ #x881E) 
(defconstant +luminance-alpha-float16-ati+ #x881F) 

;;;; }}}

;;;; {{{ nv_float_buffer

(defconstant +float-r-nv+ #x8880) 
(defconstant +float-rg-nv+ #x8881) 
(defconstant +float-rgb-nv+ #x8882) 
(defconstant +float-rgba-nv+ #x8883) 
(defconstant +float-r16-nv+ #x8884) 
(defconstant +float-r32-nv+ #x8885) 
(defconstant +float-rg16-nv+ #x8886) 
(defconstant +float-rg32-nv+ #x8887) 
(defconstant +float-rgb16-nv+ #x8888) 
(defconstant +float-rgb32-nv+ #x8889) 
(defconstant +float-rgba16-nv+ #x888A) 
(defconstant +float-rgba32-nv+ #x888B) 
(defconstant +texture-float-components-nv+ #x888C) 
(defconstant +float-clear-color-value-nv+ #x888D) 
(defconstant +float-rgba-mode-nv+ #x888E) 

;;;; }}}

;;;; {{{ nv_texture_expand_normal

(defconstant +texture-unsigned-remap-mode-nv+ #x888F) 

;;;; }}}

;;;; {{{ oes_read_format

(defconstant +implementation-color-read-type-oes+ #x8B9A) 
(defconstant +implementation-color-read-format-oes+ #x8B9B) 

;;;; }}}

;;;; {{{ ext_texture_mirror_clamp

(defconstant +mirror-clamp-ext+ #x8742) 
(defconstant +mirror-clamp-to-edge-ext+ #x8743) 
(defconstant +mirror-clamp-to-border-ext+ #x8912) 

;;;; }}}

;;;; {{{ mesa_pack_invert

(defconstant +pack-invert-mesa+ #x8758) 

;;;; }}}

;;;; {{{ mesa_ycbcr_texture

(defconstant +unsigned-short-8-8-mesa+ #x85BA) 
(defconstant +unsigned-short-8-8-rev-mesa+ #x85BB) 
(defconstant +ycbcr-mesa+ #x8757) 

;;;; }}}

;;;; {{{ ext_pixel_buffer_object

(defconstant +pixel-pack-buffer-ext+ #x88EB) 
(defconstant +pixel-unpack-buffer-ext+ #x88EC) 
(defconstant +pixel-pack-buffer-binding-ext+ #x88ED) 
(defconstant +pixel-unpack-buffer-binding-ext+ #x88EF) 

;;;; }}}

;;;; {{{ nv_fragment_program2

(defconstant +max-program-exec-instructions-nv+ #x88F4) 
(defconstant +max-program-call-depth-nv+ #x88F5) 
(defconstant +max-program-if-depth-nv+ #x88F6) 
(defconstant +max-program-loop-depth-nv+ #x88F7) 
(defconstant +max-program-loop-count-nv+ #x88F8) 

;;;; }}}

;;;; {{{ nv_vertex_program3

(defconstant +max-vertex-texture-image-units-arb+ #x8B4C) 

;;;; }}}

;;;; {{{ ext_packed_depth_stencil

(defconstant +depth-stencil-ext+ #x84F9) 
(defconstant +unsigned-int-24-8-ext+ #x84FA) 
(defconstant +depth24-stencil8-ext+ #x88F0) 
(defconstant +texture-stencil-size-ext+ #x88F1) 

;;;; }}}

;;;; {{{ ext_texture_srgb

(defconstant +srgb-ext+ #x8C40) 
(defconstant +srgb8-ext+ #x8C41) 
(defconstant +srgb-alpha-ext+ #x8C42) 
(defconstant +srgb8-alpha8-ext+ #x8C43) 
(defconstant +sluminance-alpha-ext+ #x8C44) 
(defconstant +sluminance8-alpha8-ext+ #x8C45) 
(defconstant +sluminance-ext+ #x8C46) 
(defconstant +sluminance8-ext+ #x8C47) 
(defconstant +compressed-srgb-ext+ #x8C48) 
(defconstant +compressed-srgb-alpha-ext+ #x8C49) 
(defconstant +compressed-sluminance-ext+ #x8C4A) 
(defconstant +compressed-sluminance-alpha-ext+ #x8C4B) 
(defconstant +compressed-srgb-s3tc-dxt1-ext+ #x8C4C) 
(defconstant +compressed-srgb-alpha-s3tc-dxt1-ext+ #x8C4D) 
(defconstant +compressed-srgb-alpha-s3tc-dxt3-ext+ #x8C4E) 
(defconstant +compressed-srgb-alpha-s3tc-dxt5-ext+ #x8C4F) 

;;;; }}}

;;;; {{{ mesax_texture_stack

(defconstant +texture-1d-stack-mesax+ #x8759) 
(defconstant +texture-2d-stack-mesax+ #x875A) 
(defconstant +proxy-texture-1d-stack-mesax+ #x875B) 
(defconstant +proxy-texture-2d-stack-mesax+ #x875C) 
(defconstant +texture-1d-stack-binding-mesax+ #x875D) 
(defconstant +texture-2d-stack-binding-mesax+ #x875E) 

;;;; }}}

;;;; {{{ ext_packed_float

(defconstant +r11f-g11f-b10f-ext+ #x8C3A) 
(defconstant +unsigned-int-10f-11f-11f-rev-ext+ #x8C3B) 
(defconstant +rgba-signed-components-ext+ #x8C3C) 

;;;; }}}

;;;; {{{ ext_texture_array

(defconstant +texture-1d-array-ext+ #x8C18) 
(defconstant +proxy-texture-1d-array-ext+ #x8C19) 
(defconstant +texture-2d-array-ext+ #x8C1A) 
(defconstant +proxy-texture-2d-array-ext+ #x8C1B) 
(defconstant +texture-binding-1d-array-ext+ #x8C1C) 
(defconstant +texture-binding-2d-array-ext+ #x8C1D) 
(defconstant +max-array-texture-layers-ext+ #x88FF) 
(defconstant +compare-ref-depth-to-texture-ext+ #x884E) 
(defconstant +framebuffer-attachment-texture-layer-ext+ #x8CD4) 

;;;; }}}

;;;; {{{ ext_texture_compression_latc

(defconstant +compressed-luminance-latc1-ext+ #x8C70) 
(defconstant +compressed-signed-luminance-latc1-ext+ #x8C71) 
(defconstant +compressed-luminance-alpha-latc2-ext+ #x8C72) 
(defconstant +compressed-signed-luminance-alpha-latc2-ext+ #x8C73) 

;;;; }}}

;;;; {{{ ext_texture_compression_rgtc

(defconstant +compressed-red-rgtc1-ext+ #x8DBB) 
(defconstant +compressed-signed-red-rgtc1-ext+ #x8DBC) 
(defconstant +compressed-red-green-rgtc2-ext+ #x8DBD) 
(defconstant +compressed-signed-red-green-rgtc2-ext+ #x8DBE) 

;;;; }}}

;;;; {{{ ext_texture_shared_exponent

(defconstant +rgb9-e5-ext+ #x8C3D) 
(defconstant +unsigned-int-5-9-9-9-rev-ext+ #x8C3E) 
(defconstant +texture-shared-size-ext+ #x8C3F) 

;;;; }}}

;;;; {{{ ext_framebuffer_srgb

(defconstant +framebuffer-srgb-ext+ #x8DB9) 
(defconstant +framebuffer-srgb-capable-ext+ #x8DBA) 

;;;; }}}

;;;; {{{ display-list

(defglfun "ListBase" list-base :return "void" :args
 ((:name |base| :type |List| :direction :in)) :category "display-list" :version
 "1.0") 
(defglfun "GenLists" gen-lists :return "List" :args
 ((:name |range| :type |SizeI| :direction :in)) :category "display-list"
 :version "1.0") 
(defglfun "DeleteLists" delete-lists :return "void" :args
 ((:name |list| :type |List| :direction :in)
  (:name |range| :type |SizeI| :direction :in))
 :category "display-list" :version "1.0") 
(defglfun "CallLists" call-lists :return "void" :args
 ((:name |n| :type |SizeI| :direction :in)
  (:name |type| :type |ListNameType| :direction :in)
  (:name |lists| :type |Void| :direction :in :array t :size (|n| |type|)))
 :category "display-list" :version "1.0") 
(defglfun "CallList" call-list :return "void" :args
 ((:name |list| :type |List| :direction :in)) :category "display-list" :version
 "1.0") 
(defglfun "EndList" end-list :return "void" :args nil :category "display-list"
 :version "1.0") 
(defglfun "NewList" new-list :return "void" :args
 ((:name |list| :type |List| :direction :in)
  (:name |mode| :type |ListMode| :direction :in))
 :category "display-list" :version "1.0") 

;;;; }}}

;;;; {{{ drawing

(defglfun "Vertex4sv" vertex-4sv :return "void" :args
 ((:name |v| :type |CoordS| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "Vertex4s" vertex-4s :return "void" :args
 ((:name |x| :type |CoordS| :direction :in)
  (:name |y| :type |CoordS| :direction :in)
  (:name |z| :type |CoordS| :direction :in)
  (:name |w| :type |CoordS| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Vertex4iv" vertex-4iv :return "void" :args
 ((:name |v| :type |CoordI| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "Vertex4i" vertex-4i :return "void" :args
 ((:name |x| :type |CoordI| :direction :in)
  (:name |y| :type |CoordI| :direction :in)
  (:name |z| :type |CoordI| :direction :in)
  (:name |w| :type |CoordI| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Vertex4fv" vertex-4fv :return "void" :args
 ((:name |v| :type |CoordF| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "Vertex4f" vertex-4f :return "void" :args
 ((:name |x| :type |CoordF| :direction :in)
  (:name |y| :type |CoordF| :direction :in)
  (:name |z| :type |CoordF| :direction :in)
  (:name |w| :type |CoordF| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Vertex4dv" vertex-4dv :return "void" :args
 ((:name |v| :type |CoordD| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "Vertex4d" vertex-4d :return "void" :args
 ((:name |x| :type |CoordD| :direction :in)
  (:name |y| :type |CoordD| :direction :in)
  (:name |z| :type |CoordD| :direction :in)
  (:name |w| :type |CoordD| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Vertex3sv" vertex-3sv :return "void" :args
 ((:name |v| :type |CoordS| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "Vertex3s" vertex-3s :return "void" :args
 ((:name |x| :type |CoordS| :direction :in)
  (:name |y| :type |CoordS| :direction :in)
  (:name |z| :type |CoordS| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Vertex3iv" vertex-3iv :return "void" :args
 ((:name |v| :type |CoordI| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "Vertex3i" vertex-3i :return "void" :args
 ((:name |x| :type |CoordI| :direction :in)
  (:name |y| :type |CoordI| :direction :in)
  (:name |z| :type |CoordI| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Vertex3fv" vertex-3fv :return "void" :args
 ((:name |v| :type |CoordF| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "Vertex3f" vertex-3f :return "void" :args
 ((:name |x| :type |CoordF| :direction :in)
  (:name |y| :type |CoordF| :direction :in)
  (:name |z| :type |CoordF| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Vertex3dv" vertex-3dv :return "void" :args
 ((:name |v| :type |CoordD| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "Vertex3d" vertex-3d :return "void" :args
 ((:name |x| :type |CoordD| :direction :in)
  (:name |y| :type |CoordD| :direction :in)
  (:name |z| :type |CoordD| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Vertex2sv" vertex-2sv :return "void" :args
 ((:name |v| :type |CoordS| :direction :in :array t :size #x2)) :category
 "drawing" :version "1.0") 
(defglfun "Vertex2s" vertex-2s :return "void" :args
 ((:name |x| :type |CoordS| :direction :in)
  (:name |y| :type |CoordS| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Vertex2iv" vertex-2iv :return "void" :args
 ((:name |v| :type |CoordI| :direction :in :array t :size #x2)) :category
 "drawing" :version "1.0") 
(defglfun "Vertex2i" vertex-2i :return "void" :args
 ((:name |x| :type |CoordI| :direction :in)
  (:name |y| :type |CoordI| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Vertex2fv" vertex-2fv :return "void" :args
 ((:name |v| :type |CoordF| :direction :in :array t :size #x2)) :category
 "drawing" :version "1.0") 
(defglfun "Vertex2f" vertex-2f :return "void" :args
 ((:name |x| :type |CoordF| :direction :in)
  (:name |y| :type |CoordF| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Vertex2dv" vertex-2dv :return "void" :args
 ((:name |v| :type |CoordD| :direction :in :array t :size #x2)) :category
 "drawing" :version "1.0") 
(defglfun "Vertex2d" vertex-2d :return "void" :args
 ((:name |x| :type |CoordD| :direction :in)
  (:name |y| :type |CoordD| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "TexCoord4sv" tex-coord-4sv :return "void" :args
 ((:name |v| :type |CoordS| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "TexCoord4s" tex-coord-4s :return "void" :args
 ((:name |s| :type |CoordS| :direction :in)
  (:name |t| :type |CoordS| :direction :in)
  (:name |r| :type |CoordS| :direction :in)
  (:name |q| :type |CoordS| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "TexCoord4iv" tex-coord-4iv :return "void" :args
 ((:name |v| :type |CoordI| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "TexCoord4i" tex-coord-4i :return "void" :args
 ((:name |s| :type |CoordI| :direction :in)
  (:name |t| :type |CoordI| :direction :in)
  (:name |r| :type |CoordI| :direction :in)
  (:name |q| :type |CoordI| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "TexCoord4fv" tex-coord-4fv :return "void" :args
 ((:name |v| :type |CoordF| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "TexCoord4f" tex-coord-4f :return "void" :args
 ((:name |s| :type |CoordF| :direction :in)
  (:name |t| :type |CoordF| :direction :in)
  (:name |r| :type |CoordF| :direction :in)
  (:name |q| :type |CoordF| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "TexCoord4dv" tex-coord-4dv :return "void" :args
 ((:name |v| :type |CoordD| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "TexCoord4d" tex-coord-4d :return "void" :args
 ((:name |s| :type |CoordD| :direction :in)
  (:name |t| :type |CoordD| :direction :in)
  (:name |r| :type |CoordD| :direction :in)
  (:name |q| :type |CoordD| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "TexCoord3sv" tex-coord-3sv :return "void" :args
 ((:name |v| :type |CoordS| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "TexCoord3s" tex-coord-3s :return "void" :args
 ((:name |s| :type |CoordS| :direction :in)
  (:name |t| :type |CoordS| :direction :in)
  (:name |r| :type |CoordS| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "TexCoord3iv" tex-coord-3iv :return "void" :args
 ((:name |v| :type |CoordI| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "TexCoord3i" tex-coord-3i :return "void" :args
 ((:name |s| :type |CoordI| :direction :in)
  (:name |t| :type |CoordI| :direction :in)
  (:name |r| :type |CoordI| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "TexCoord3fv" tex-coord-3fv :return "void" :args
 ((:name |v| :type |CoordF| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "TexCoord3f" tex-coord-3f :return "void" :args
 ((:name |s| :type |CoordF| :direction :in)
  (:name |t| :type |CoordF| :direction :in)
  (:name |r| :type |CoordF| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "TexCoord3dv" tex-coord-3dv :return "void" :args
 ((:name |v| :type |CoordD| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "TexCoord3d" tex-coord-3d :return "void" :args
 ((:name |s| :type |CoordD| :direction :in)
  (:name |t| :type |CoordD| :direction :in)
  (:name |r| :type |CoordD| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "TexCoord2sv" tex-coord-2sv :return "void" :args
 ((:name |v| :type |CoordS| :direction :in :array t :size #x2)) :category
 "drawing" :version "1.0") 
(defglfun "TexCoord2s" tex-coord-2s :return "void" :args
 ((:name |s| :type |CoordS| :direction :in)
  (:name |t| :type |CoordS| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "TexCoord2iv" tex-coord-2iv :return "void" :args
 ((:name |v| :type |CoordI| :direction :in :array t :size #x2)) :category
 "drawing" :version "1.0") 
(defglfun "TexCoord2i" tex-coord-2i :return "void" :args
 ((:name |s| :type |CoordI| :direction :in)
  (:name |t| :type |CoordI| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "TexCoord2fv" tex-coord-2fv :return "void" :args
 ((:name |v| :type |CoordF| :direction :in :array t :size #x2)) :category
 "drawing" :version "1.0") 
(defglfun "TexCoord2f" tex-coord-2f :return "void" :args
 ((:name |s| :type |CoordF| :direction :in)
  (:name |t| :type |CoordF| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "TexCoord2dv" tex-coord-2dv :return "void" :args
 ((:name |v| :type |CoordD| :direction :in :array t :size #x2)) :category
 "drawing" :version "1.0") 
(defglfun "TexCoord2d" tex-coord-2d :return "void" :args
 ((:name |s| :type |CoordD| :direction :in)
  (:name |t| :type |CoordD| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "TexCoord1sv" tex-coord-1sv :return "void" :args
 ((:name |v| :type |CoordS| :direction :in :array t :size #x1)) :category
 "drawing" :version "1.0") 
(defglfun "TexCoord1s" tex-coord-1s :return "void" :args
 ((:name |s| :type |CoordS| :direction :in)) :category "drawing" :version "1.0") 
(defglfun "TexCoord1iv" tex-coord-1iv :return "void" :args
 ((:name |v| :type |CoordI| :direction :in :array t :size #x1)) :category
 "drawing" :version "1.0") 
(defglfun "TexCoord1i" tex-coord-1i :return "void" :args
 ((:name |s| :type |CoordI| :direction :in)) :category "drawing" :version "1.0") 
(defglfun "TexCoord1fv" tex-coord-1fv :return "void" :args
 ((:name |v| :type |CoordF| :direction :in :array t :size #x1)) :category
 "drawing" :version "1.0") 
(defglfun "TexCoord1f" tex-coord-1f :return "void" :args
 ((:name |s| :type |CoordF| :direction :in)) :category "drawing" :version "1.0") 
(defglfun "TexCoord1dv" tex-coord-1dv :return "void" :args
 ((:name |v| :type |CoordD| :direction :in :array t :size #x1)) :category
 "drawing" :version "1.0") 
(defglfun "TexCoord1d" tex-coord-1d :return "void" :args
 ((:name |s| :type |CoordD| :direction :in)) :category "drawing" :version "1.0") 
(defglfun "Rectsv" rect-sv :return "void" :args
 ((:name |v1| :type |CoordS| :direction :in :array t :size #x2)
  (:name |v2| :type |CoordS| :direction :in :array t :size #x2))
 :category "drawing" :version "1.0") 
(defglfun "Rects" rect-s :return "void" :args
 ((:name |x1| :type |CoordS| :direction :in)
  (:name |y1| :type |CoordS| :direction :in)
  (:name |x2| :type |CoordS| :direction :in)
  (:name |y2| :type |CoordS| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Rectiv" rect-iv :return "void" :args
 ((:name |v1| :type |CoordI| :direction :in :array t :size #x2)
  (:name |v2| :type |CoordI| :direction :in :array t :size #x2))
 :category "drawing" :version "1.0") 
(defglfun "Recti" rect-i :return "void" :args
 ((:name |x1| :type |CoordI| :direction :in)
  (:name |y1| :type |CoordI| :direction :in)
  (:name |x2| :type |CoordI| :direction :in)
  (:name |y2| :type |CoordI| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Rectfv" rect-fv :return "void" :args
 ((:name |v1| :type |CoordF| :direction :in :array t :size #x2)
  (:name |v2| :type |CoordF| :direction :in :array t :size #x2))
 :category "drawing" :version "1.0") 
(defglfun "Rectf" rect-f :return "void" :args
 ((:name |x1| :type |CoordF| :direction :in)
  (:name |y1| :type |CoordF| :direction :in)
  (:name |x2| :type |CoordF| :direction :in)
  (:name |y2| :type |CoordF| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Rectdv" rect-dv :return "void" :args
 ((:name |v1| :type |CoordD| :direction :in :array t :size #x2)
  (:name |v2| :type |CoordD| :direction :in :array t :size #x2))
 :category "drawing" :version "1.0") 
(defglfun "Rectd" rect-d :return "void" :args
 ((:name |x1| :type |CoordD| :direction :in)
  (:name |y1| :type |CoordD| :direction :in)
  (:name |x2| :type |CoordD| :direction :in)
  (:name |y2| :type |CoordD| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "RasterPos4sv" raster-pos-4sv :return "void" :args
 ((:name |v| :type |CoordS| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "RasterPos4s" raster-pos-4s :return "void" :args
 ((:name |x| :type |CoordS| :direction :in)
  (:name |y| :type |CoordS| :direction :in)
  (:name |z| :type |CoordS| :direction :in)
  (:name |w| :type |CoordS| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "RasterPos4iv" raster-pos-4iv :return "void" :args
 ((:name |v| :type |CoordI| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "RasterPos4i" raster-pos-4i :return "void" :args
 ((:name |x| :type |CoordI| :direction :in)
  (:name |y| :type |CoordI| :direction :in)
  (:name |z| :type |CoordI| :direction :in)
  (:name |w| :type |CoordI| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "RasterPos4fv" raster-pos-4fv :return "void" :args
 ((:name |v| :type |CoordF| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "RasterPos4f" raster-pos-4f :return "void" :args
 ((:name |x| :type |CoordF| :direction :in)
  (:name |y| :type |CoordF| :direction :in)
  (:name |z| :type |CoordF| :direction :in)
  (:name |w| :type |CoordF| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "RasterPos4dv" raster-pos-4dv :return "void" :args
 ((:name |v| :type |CoordD| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "RasterPos4d" raster-pos-4d :return "void" :args
 ((:name |x| :type |CoordD| :direction :in)
  (:name |y| :type |CoordD| :direction :in)
  (:name |z| :type |CoordD| :direction :in)
  (:name |w| :type |CoordD| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "RasterPos3sv" raster-pos-3sv :return "void" :args
 ((:name |v| :type |CoordS| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "RasterPos3s" raster-pos-3s :return "void" :args
 ((:name |x| :type |CoordS| :direction :in)
  (:name |y| :type |CoordS| :direction :in)
  (:name |z| :type |CoordS| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "RasterPos3iv" raster-pos-3iv :return "void" :args
 ((:name |v| :type |CoordI| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "RasterPos3i" raster-pos-3i :return "void" :args
 ((:name |x| :type |CoordI| :direction :in)
  (:name |y| :type |CoordI| :direction :in)
  (:name |z| :type |CoordI| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "RasterPos3fv" raster-pos-3fv :return "void" :args
 ((:name |v| :type |CoordF| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "RasterPos3f" raster-pos-3f :return "void" :args
 ((:name |x| :type |CoordF| :direction :in)
  (:name |y| :type |CoordF| :direction :in)
  (:name |z| :type |CoordF| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "RasterPos3dv" raster-pos-3dv :return "void" :args
 ((:name |v| :type |CoordD| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "RasterPos3d" raster-pos-3d :return "void" :args
 ((:name |x| :type |CoordD| :direction :in)
  (:name |y| :type |CoordD| :direction :in)
  (:name |z| :type |CoordD| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "RasterPos2sv" raster-pos-2sv :return "void" :args
 ((:name |v| :type |CoordS| :direction :in :array t :size #x2)) :category
 "drawing" :version "1.0") 
(defglfun "RasterPos2s" raster-pos-2s :return "void" :args
 ((:name |x| :type |CoordS| :direction :in)
  (:name |y| :type |CoordS| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "RasterPos2iv" raster-pos-2iv :return "void" :args
 ((:name |v| :type |CoordI| :direction :in :array t :size #x2)) :category
 "drawing" :version "1.0") 
(defglfun "RasterPos2i" raster-pos-2i :return "void" :args
 ((:name |x| :type |CoordI| :direction :in)
  (:name |y| :type |CoordI| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "RasterPos2fv" raster-pos-2fv :return "void" :args
 ((:name |v| :type |CoordF| :direction :in :array t :size #x2)) :category
 "drawing" :version "1.0") 
(defglfun "RasterPos2f" raster-pos-2f :return "void" :args
 ((:name |x| :type |CoordF| :direction :in)
  (:name |y| :type |CoordF| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "RasterPos2dv" raster-pos-2dv :return "void" :args
 ((:name |v| :type |CoordD| :direction :in :array t :size #x2)) :category
 "drawing" :version "1.0") 
(defglfun "RasterPos2d" raster-pos-2d :return "void" :args
 ((:name |x| :type |CoordD| :direction :in)
  (:name |y| :type |CoordD| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Normal3sv" normal-3sv :return "void" :args
 ((:name |v| :type |Int16| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "Normal3s" normal-3s :return "void" :args
 ((:name |nx| :type |Int16| :direction :in)
  (:name |ny| :type |Int16| :direction :in)
  (:name |nz| :type |Int16| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Normal3iv" normal-3iv :return "void" :args
 ((:name |v| :type |Int32| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "Normal3i" normal-3i :return "void" :args
 ((:name |nx| :type |Int32| :direction :in)
  (:name |ny| :type |Int32| :direction :in)
  (:name |nz| :type |Int32| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Normal3fv" normal-3fv :return "void" :args
 ((:name |v| :type |CoordF| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "Normal3f" normal-3f :return "void" :args
 ((:name |nx| :type |CoordF| :direction :in)
  (:name |ny| :type |CoordF| :direction :in)
  (:name |nz| :type |CoordF| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Normal3dv" normal-3dv :return "void" :args
 ((:name |v| :type |CoordD| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "Normal3d" normal-3d :return "void" :args
 ((:name |nx| :type |CoordD| :direction :in)
  (:name |ny| :type |CoordD| :direction :in)
  (:name |nz| :type |CoordD| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Normal3bv" normal-3bv :return "void" :args
 ((:name |v| :type |Int8| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "Normal3b" normal-3b :return "void" :args
 ((:name |nx| :type |Int8| :direction :in)
  (:name |ny| :type |Int8| :direction :in)
  (:name |nz| :type |Int8| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Indexsv" index-sv :return "void" :args
 ((:name |c| :type |ColorIndexValueS| :direction :in :array t :size #x1))
 :category "drawing" :version "1.0") 
(defglfun "Indexs" index-s :return "void" :args
 ((:name |c| :type |ColorIndexValueS| :direction :in)) :category "drawing"
 :version "1.0") 
(defglfun "Indexiv" index-iv :return "void" :args
 ((:name |c| :type |ColorIndexValueI| :direction :in :array t :size #x1))
 :category "drawing" :version "1.0") 
(defglfun "Indexi" index-i :return "void" :args
 ((:name |c| :type |ColorIndexValueI| :direction :in)) :category "drawing"
 :version "1.0") 
(defglfun "Indexfv" index-fv :return "void" :args
 ((:name |c| :type |ColorIndexValueF| :direction :in :array t :size #x1))
 :category "drawing" :version "1.0") 
(defglfun "Indexf" index-f :return "void" :args
 ((:name |c| :type |ColorIndexValueF| :direction :in)) :category "drawing"
 :version "1.0") 
(defglfun "Indexdv" index-dv :return "void" :args
 ((:name |c| :type |ColorIndexValueD| :direction :in :array t :size #x1))
 :category "drawing" :version "1.0") 
(defglfun "Indexd" index-d :return "void" :args
 ((:name |c| :type |ColorIndexValueD| :direction :in)) :category "drawing"
 :version "1.0") 
(defglfun "End" end :return "void" :args nil :category "drawing" :version "1.0") 
(defglfun "EdgeFlagv" edge-flagv :return "void" :args
 ((:name |flag| :type |Boolean| :direction :in :array t :size #x1)) :category
 "drawing" :version "1.0") 
(defglfun "EdgeFlag" edge-flag :return "void" :args
 ((:name |flag| :type |Boolean| :direction :in)) :category "drawing" :version
 "1.0") 
(defglfun "Color4usv" color-4usv :return "void" :args
 ((:name |v| :type |ColorUS| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "Color4us" color-4us :return "void" :args
 ((:name |red| :type |ColorUS| :direction :in)
  (:name |green| :type |ColorUS| :direction :in)
  (:name |blue| :type |ColorUS| :direction :in)
  (:name |alpha| :type |ColorUS| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Color4uiv" color-4uiv :return "void" :args
 ((:name |v| :type |ColorUI| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "Color4ui" color-4ui :return "void" :args
 ((:name |red| :type |ColorUI| :direction :in)
  (:name |green| :type |ColorUI| :direction :in)
  (:name |blue| :type |ColorUI| :direction :in)
  (:name |alpha| :type |ColorUI| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Color4ubv" color-4ubv :return "void" :args
 ((:name |v| :type |ColorUB| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "Color4ub" color-4ub :return "void" :args
 ((:name |red| :type |ColorUB| :direction :in)
  (:name |green| :type |ColorUB| :direction :in)
  (:name |blue| :type |ColorUB| :direction :in)
  (:name |alpha| :type |ColorUB| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Color4sv" color-4sv :return "void" :args
 ((:name |v| :type |ColorS| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "Color4s" color-4s :return "void" :args
 ((:name |red| :type |ColorS| :direction :in)
  (:name |green| :type |ColorS| :direction :in)
  (:name |blue| :type |ColorS| :direction :in)
  (:name |alpha| :type |ColorS| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Color4iv" color-4iv :return "void" :args
 ((:name |v| :type |ColorI| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "Color4i" color-4i :return "void" :args
 ((:name |red| :type |ColorI| :direction :in)
  (:name |green| :type |ColorI| :direction :in)
  (:name |blue| :type |ColorI| :direction :in)
  (:name |alpha| :type |ColorI| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Color4fv" color-4fv :return "void" :args
 ((:name |v| :type |ColorF| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "Color4f" color-4f :return "void" :args
 ((:name |red| :type |ColorF| :direction :in)
  (:name |green| :type |ColorF| :direction :in)
  (:name |blue| :type |ColorF| :direction :in)
  (:name |alpha| :type |ColorF| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Color4dv" color-4dv :return "void" :args
 ((:name |v| :type |ColorD| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "Color4d" color-4d :return "void" :args
 ((:name |red| :type |ColorD| :direction :in)
  (:name |green| :type |ColorD| :direction :in)
  (:name |blue| :type |ColorD| :direction :in)
  (:name |alpha| :type |ColorD| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Color4bv" color-4bv :return "void" :args
 ((:name |v| :type |ColorB| :direction :in :array t :size #x4)) :category
 "drawing" :version "1.0") 
(defglfun "Color4b" color-4b :return "void" :args
 ((:name |red| :type |ColorB| :direction :in)
  (:name |green| :type |ColorB| :direction :in)
  (:name |blue| :type |ColorB| :direction :in)
  (:name |alpha| :type |ColorB| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Color3usv" color-3usv :return "void" :args
 ((:name |v| :type |ColorUS| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "Color3us" color-3us :return "void" :args
 ((:name |red| :type |ColorUS| :direction :in)
  (:name |green| :type |ColorUS| :direction :in)
  (:name |blue| :type |ColorUS| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Color3uiv" color-3uiv :return "void" :args
 ((:name |v| :type |ColorUI| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "Color3ui" color-3ui :return "void" :args
 ((:name |red| :type |ColorUI| :direction :in)
  (:name |green| :type |ColorUI| :direction :in)
  (:name |blue| :type |ColorUI| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Color3ubv" color-3ubv :return "void" :args
 ((:name |v| :type |ColorUB| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "Color3ub" color-3ub :return "void" :args
 ((:name |red| :type |ColorUB| :direction :in)
  (:name |green| :type |ColorUB| :direction :in)
  (:name |blue| :type |ColorUB| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Color3sv" color-3sv :return "void" :args
 ((:name |v| :type |ColorS| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "Color3s" color-3s :return "void" :args
 ((:name |red| :type |ColorS| :direction :in)
  (:name |green| :type |ColorS| :direction :in)
  (:name |blue| :type |ColorS| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Color3iv" color-3iv :return "void" :args
 ((:name |v| :type |ColorI| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "Color3i" color-3i :return "void" :args
 ((:name |red| :type |ColorI| :direction :in)
  (:name |green| :type |ColorI| :direction :in)
  (:name |blue| :type |ColorI| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Color3fv" color-3fv :return "void" :args
 ((:name |v| :type |ColorF| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "Color3f" color-3f :return "void" :args
 ((:name |red| :type |ColorF| :direction :in)
  (:name |green| :type |ColorF| :direction :in)
  (:name |blue| :type |ColorF| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Color3dv" color-3dv :return "void" :args
 ((:name |v| :type |ColorD| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "Color3d" color-3d :return "void" :args
 ((:name |red| :type |ColorD| :direction :in)
  (:name |green| :type |ColorD| :direction :in)
  (:name |blue| :type |ColorD| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Color3bv" color-3bv :return "void" :args
 ((:name |v| :type |ColorB| :direction :in :array t :size #x3)) :category
 "drawing" :version "1.0") 
(defglfun "Color3b" color-3b :return "void" :args
 ((:name |red| :type |ColorB| :direction :in)
  (:name |green| :type |ColorB| :direction :in)
  (:name |blue| :type |ColorB| :direction :in))
 :category "drawing" :version "1.0") 
(defglfun "Bitmap" bitmap :return "void" :args
 ((:name |width| :type |SizeI| :direction :in)
  (:name |height| :type |SizeI| :direction :in)
  (:name |xorig| :type |CoordF| :direction :in)
  (:name |yorig| :type |CoordF| :direction :in)
  (:name |xmove| :type |CoordF| :direction :in)
  (:name |ymove| :type |CoordF| :direction :in)
  (:name |bitmap| :type |UInt8| :direction :in :array t :size
   (|width| |height|)))
 :category "drawing" :version "1.0") 
(defglfun "Begin" begin :return "void" :args
 ((:name |mode| :type |BeginMode| :direction :in)) :category "drawing" :version
 "1.0") 

;;;; }}}

;;;; {{{ drawing-control

(defglfun "TexGeniv" tex-gen-iv :return "void" :args
 ((:name |coord| :type |TextureCoordName| :direction :in)
  (:name |pname| :type |TextureGenParameter| :direction :in)
  (:name |params| :type |CheckedInt32| :direction :in :array t :size
   (|pname|)))
 :category "drawing-control" :version "1.0") 
(defglfun "TexGeni" tex-gen-i :return "void" :args
 ((:name |coord| :type |TextureCoordName| :direction :in)
  (:name |pname| :type |TextureGenParameter| :direction :in)
  (:name |param| :type |CheckedInt32| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "TexGenfv" tex-gen-fv :return "void" :args
 ((:name |coord| :type |TextureCoordName| :direction :in)
  (:name |pname| :type |TextureGenParameter| :direction :in)
  (:name |params| :type |CheckedFloat32| :direction :in :array t :size
   (|pname|)))
 :category "drawing-control" :version "1.0") 
(defglfun "TexGenf" tex-gen-f :return "void" :args
 ((:name |coord| :type |TextureCoordName| :direction :in)
  (:name |pname| :type |TextureGenParameter| :direction :in)
  (:name |param| :type |CheckedFloat32| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "TexGendv" tex-gen-dv :return "void" :args
 ((:name |coord| :type |TextureCoordName| :direction :in)
  (:name |pname| :type |TextureGenParameter| :direction :in)
  (:name |params| :type |Float64| :direction :in :array t :size (|pname|)))
 :category "drawing-control" :version "1.0") 
(defglfun "TexGend" tex-gen-d :return "void" :args
 ((:name |coord| :type |TextureCoordName| :direction :in)
  (:name |pname| :type |TextureGenParameter| :direction :in)
  (:name |param| :type |Float64| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "TexEnviv" tex-env-iv :return "void" :args
 ((:name |target| :type |TextureEnvTarget| :direction :in)
  (:name |pname| :type |TextureEnvParameter| :direction :in)
  (:name |params| :type |CheckedInt32| :direction :in :array t :size
   (|pname|)))
 :category "drawing-control" :version "1.0") 
(defglfun "TexEnvi" tex-env-i :return "void" :args
 ((:name |target| :type |TextureEnvTarget| :direction :in)
  (:name |pname| :type |TextureEnvParameter| :direction :in)
  (:name |param| :type |CheckedInt32| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "TexEnvfv" tex-env-fv :return "void" :args
 ((:name |target| :type |TextureEnvTarget| :direction :in)
  (:name |pname| :type |TextureEnvParameter| :direction :in)
  (:name |params| :type |CheckedFloat32| :direction :in :array t :size
   (|pname|)))
 :category "drawing-control" :version "1.0") 
(defglfun "TexEnvf" tex-env-f :return "void" :args
 ((:name |target| :type |TextureEnvTarget| :direction :in)
  (:name |pname| :type |TextureEnvParameter| :direction :in)
  (:name |param| :type |CheckedFloat32| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "TexImage2D" tex-image-2d :return "void" :args
 ((:name |target| :type |TextureTarget| :direction :in)
  (:name |level| :type |CheckedInt32| :direction :in)
  (:name |internalformat| :type |TextureComponentCount| :direction :in)
  (:name |width| :type |SizeI| :direction :in)
  (:name |height| :type |SizeI| :direction :in)
  (:name |border| :type |CheckedInt32| :direction :in)
  (:name |format| :type |PixelFormat| :direction :in)
  (:name |type| :type |PixelType| :direction :in)
  (:name |pixels| :type |Void| :direction :in :array t :size
   (|format| |type| |width| |height|)))
 :category "drawing-control" :version "1.0") 
(defglfun "TexImage1D" tex-image-1d :return "void" :args
 ((:name |target| :type |TextureTarget| :direction :in)
  (:name |level| :type |CheckedInt32| :direction :in)
  (:name |internalformat| :type |TextureComponentCount| :direction :in)
  (:name |width| :type |SizeI| :direction :in)
  (:name |border| :type |CheckedInt32| :direction :in)
  (:name |format| :type |PixelFormat| :direction :in)
  (:name |type| :type |PixelType| :direction :in)
  (:name |pixels| :type |Void| :direction :in :array t :size
   (|format| |type| |width|)))
 :category "drawing-control" :version "1.0") 
(defglfun "TexParameteriv" tex-parameter-iv :return "void" :args
 ((:name |target| :type |TextureTarget| :direction :in)
  (:name |pname| :type |TextureParameterName| :direction :in)
  (:name |params| :type |CheckedInt32| :direction :in :array t :size
   (|pname|)))
 :category "drawing-control" :version "1.0") 
(defglfun "TexParameteri" tex-parameter-i :return "void" :args
 ((:name |target| :type |TextureTarget| :direction :in)
  (:name |pname| :type |TextureParameterName| :direction :in)
  (:name |param| :type |CheckedInt32| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "TexParameterfv" tex-parameter-fv :return "void" :args
 ((:name |target| :type |TextureTarget| :direction :in)
  (:name |pname| :type |TextureParameterName| :direction :in)
  (:name |params| :type |CheckedFloat32| :direction :in :array t :size
   (|pname|)))
 :category "drawing-control" :version "1.0") 
(defglfun "TexParameterf" tex-parameter-f :return "void" :args
 ((:name |target| :type |TextureTarget| :direction :in)
  (:name |pname| :type |TextureParameterName| :direction :in)
  (:name |param| :type |CheckedFloat32| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "ShadeModel" shade-model :return "void" :args
 ((:name |mode| :type |ShadingModel| :direction :in)) :category
 "drawing-control" :version "1.0") 
(defglfun "Scissor" scissor :return "void" :args
 ((:name |x| :type |WinCoord| :direction :in)
  (:name |y| :type |WinCoord| :direction :in)
  (:name |width| :type |SizeI| :direction :in)
  (:name |height| :type |SizeI| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "PolygonStipple" polygon-stipple :return "void" :args
 ((:name |mask| :type |UInt8| :direction :in :array t)) :category
 "drawing-control" :version "1.0") 
(defglfun "PolygonMode" polygon-mode :return "void" :args
 ((:name |face| :type |MaterialFace| :direction :in)
  (:name |mode| :type |PolygonMode| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "PointSize" point-size :return "void" :args
 ((:name |size| :type |CheckedFloat32| :direction :in)) :category
 "drawing-control" :version "1.0") 
(defglfun "Materialiv" material-iv :return "void" :args
 ((:name |face| :type |MaterialFace| :direction :in)
  (:name |pname| :type |MaterialParameter| :direction :in)
  (:name |params| :type |CheckedInt32| :direction :in :array t :size
   (|pname|)))
 :category "drawing-control" :version "1.0") 
(defglfun "Materiali" material-i :return "void" :args
 ((:name |face| :type |MaterialFace| :direction :in)
  (:name |pname| :type |MaterialParameter| :direction :in)
  (:name |param| :type |CheckedInt32| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "Materialfv" material-fv :return "void" :args
 ((:name |face| :type |MaterialFace| :direction :in)
  (:name |pname| :type |MaterialParameter| :direction :in)
  (:name |params| :type |CheckedFloat32| :direction :in :array t :size
   (|pname|)))
 :category "drawing-control" :version "1.0") 
(defglfun "Materialf" material-f :return "void" :args
 ((:name |face| :type |MaterialFace| :direction :in)
  (:name |pname| :type |MaterialParameter| :direction :in)
  (:name |param| :type |CheckedFloat32| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "LineWidth" line-width :return "void" :args
 ((:name |width| :type |CheckedFloat32| :direction :in)) :category
 "drawing-control" :version "1.0") 
(defglfun "LineStipple" line-stipple :return "void" :args
 ((:name |factor| :type |CheckedInt32| :direction :in)
  (:name |pattern| :type |LineStipple| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "LightModeliv" light-model-iv :return "void" :args
 ((:name |pname| :type |LightModelParameter| :direction :in)
  (:name |params| :type |Int32| :direction :in :array t :size (|pname|)))
 :category "drawing-control" :version "1.0") 
(defglfun "LightModeli" light-model-i :return "void" :args
 ((:name |pname| :type |LightModelParameter| :direction :in)
  (:name |param| :type |Int32| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "LightModelfv" light-model-fv :return "void" :args
 ((:name |pname| :type |LightModelParameter| :direction :in)
  (:name |params| :type |Float32| :direction :in :array t :size (|pname|)))
 :category "drawing-control" :version "1.0") 
(defglfun "LightModelf" light-model-f :return "void" :args
 ((:name |pname| :type |LightModelParameter| :direction :in)
  (:name |param| :type |Float32| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "Lightiv" light-iv :return "void" :args
 ((:name |light| :type |LightName| :direction :in)
  (:name |pname| :type |LightParameter| :direction :in)
  (:name |params| :type |CheckedInt32| :direction :in :array t :size
   (|pname|)))
 :category "drawing-control" :version "1.0") 
(defglfun "Lighti" light-i :return "void" :args
 ((:name |light| :type |LightName| :direction :in)
  (:name |pname| :type |LightParameter| :direction :in)
  (:name |param| :type |CheckedInt32| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "Lightfv" light-fv :return "void" :args
 ((:name |light| :type |LightName| :direction :in)
  (:name |pname| :type |LightParameter| :direction :in)
  (:name |params| :type |CheckedFloat32| :direction :in :array t :size
   (|pname|)))
 :category "drawing-control" :version "1.0") 
(defglfun "Lightf" light-f :return "void" :args
 ((:name |light| :type |LightName| :direction :in)
  (:name |pname| :type |LightParameter| :direction :in)
  (:name |param| :type |CheckedFloat32| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "Hint" hint :return "void" :args
 ((:name |target| :type |HintTarget| :direction :in)
  (:name |mode| :type |HintMode| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "FrontFace" front-face :return "void" :args
 ((:name |mode| :type |FrontFaceDirection| :direction :in)) :category
 "drawing-control" :version "1.0") 
(defglfun "Fogiv" fog-iv :return "void" :args
 ((:name |pname| :type |FogParameter| :direction :in)
  (:name |params| :type |CheckedInt32| :direction :in :array t :size
   (|pname|)))
 :category "drawing-control" :version "1.0") 
(defglfun "Fogi" fog-i :return "void" :args
 ((:name |pname| :type |FogParameter| :direction :in)
  (:name |param| :type |CheckedInt32| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "Fogfv" fog-fv :return "void" :args
 ((:name |pname| :type |FogParameter| :direction :in)
  (:name |params| :type |CheckedFloat32| :direction :in :array t :size
   (|pname|)))
 :category "drawing-control" :version "1.0") 
(defglfun "Fogf" fog-f :return "void" :args
 ((:name |pname| :type |FogParameter| :direction :in)
  (:name |param| :type |CheckedFloat32| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "CullFace" cull-face :return "void" :args
 ((:name |mode| :type |CullFaceMode| :direction :in)) :category
 "drawing-control" :version "1.0") 
(defglfun "ColorMaterial" color-material :return "void" :args
 ((:name |face| :type |MaterialFace| :direction :in)
  (:name |mode| :type |ColorMaterialParameter| :direction :in))
 :category "drawing-control" :version "1.0") 
(defglfun "ClipPlane" clip-plane :return "void" :args
 ((:name |plane| :type |ClipPlaneName| :direction :in)
  (:name |equation| :type |Float64| :direction :in :array t :size #x4))
 :category "drawing-control" :version "1.0") 

;;;; }}}

;;;; {{{ feedback

(defglfun "PushName" push-name :return "void" :args
 ((:name |name| :type |SelectName| :direction :in)) :category "feedback"
 :version "1.0") 
(defglfun "PopName" pop-name :return "void" :args nil :category "feedback"
 :version "1.0") 
(defglfun "PassThrough" pass-through :return "void" :args
 ((:name |token| :type |FeedbackElement| :direction :in)) :category "feedback"
 :version "1.0") 
(defglfun "LoadName" load-name :return "void" :args
 ((:name |name| :type |SelectName| :direction :in)) :category "feedback"
 :version "1.0") 
(defglfun "InitNames" init-names :return "void" :args nil :category "feedback"
 :version "1.0") 
(defglfun "RenderMode" render-mode :return "Int32" :args
 ((:name |mode| :type |RenderingMode| :direction :in)) :category "feedback"
 :version "1.0") 
(defglfun "SelectBuffer" select-buffer :return "void" :args
 ((:name |size| :type |SizeI| :direction :in)
  (:name |buffer| :type |SelectName| :direction :out :array t :size size
   :retained t))
 :category "feedback" :version "1.0") 
(defglfun "FeedbackBuffer" feedback-buffer :return "void" :args
 ((:name |size| :type |SizeI| :direction :in)
  (:name |type| :type |FeedbackType| :direction :in)
  (:name |buffer| :type |FeedbackElement| :direction :out :array t :size size
   :retained t))
 :category "feedback" :version "1.0") 

;;;; }}}

;;;; {{{ framebuf

(defglfun "IndexMask" index-mask :return "void" :args
 ((:name |mask| :type |MaskedColorIndexValueI| :direction :in)) :category
 "framebuf" :version "1.0") 
(defglfun "DepthMask" depth-mask :return "void" :args
 ((:name |flag| :type |Boolean| :direction :in)) :category "framebuf" :version
 "1.0") 
(defglfun "ColorMask" color-mask :return "void" :args
 ((:name |red| :type |Boolean| :direction :in)
  (:name |green| :type |Boolean| :direction :in)
  (:name |blue| :type |Boolean| :direction :in)
  (:name |alpha| :type |Boolean| :direction :in))
 :category "framebuf" :version "1.0") 
(defglfun "StencilMask" stencil-mask :return "void" :args
 ((:name |mask| :type |MaskedStencilValue| :direction :in)) :category
 "framebuf" :version "1.0") 
(defglfun "ClearDepth" clear-depth :return "void" :args
 ((:name |depth| :type |ClampedFloat64| :direction :in)) :category "framebuf"
 :version "1.0") 
(defglfun "ClearStencil" clear-stencil :return "void" :args
 ((:name |s| :type |StencilValue| :direction :in)) :category "framebuf"
 :version "1.0") 
(defglfun "ClearColor" clear-color :return "void" :args
 ((:name |red| :type |ClampedColorF| :direction :in)
  (:name |green| :type |ClampedColorF| :direction :in)
  (:name |blue| :type |ClampedColorF| :direction :in)
  (:name |alpha| :type |ClampedColorF| :direction :in))
 :category "framebuf" :version "1.0") 
(defglfun "ClearIndex" clear-index :return "void" :args
 ((:name |c| :type |MaskedColorIndexValueF| :direction :in)) :category
 "framebuf" :version "1.0") 
(defglfun "ClearAccum" clear-accum :return "void" :args
 ((:name |red| :type |Float32| :direction :in)
  (:name |green| :type |Float32| :direction :in)
  (:name |blue| :type |Float32| :direction :in)
  (:name |alpha| :type |Float32| :direction :in))
 :category "framebuf" :version "1.0") 
(defglfun "Clear" clear :return "void" :args
 ((:name |mask| :type |ClearBufferMask| :direction :in)) :category "framebuf"
 :version "1.0") 
(defglfun "DrawBuffer" draw-buffer :return "void" :args
 ((:name |mode| :type |DrawBufferMode| :direction :in)) :category "framebuf"
 :version "1.0") 

;;;; }}}

;;;; {{{ misc

(defglfun "PushAttrib" push-attrib :return "void" :args
 ((:name |mask| :type |AttribMask| :direction :in)) :category "misc" :version
 "1.0") 
(defglfun "PopAttrib" pop-attrib :return "void" :args nil :category "misc"
 :version "1.0") 
(defglfun "Flush" flush :return "void" :args nil :category "misc" :version
 "1.0") 
(defglfun "Finish" finish :return "void" :args nil :category "misc" :version
 "1.0") 
(defglfun "Enable" enable :return "void" :args
 ((:name |cap| :type |EnableCap| :direction :in)) :category "misc" :version
 "1.0") 
(defglfun "Disable" disable :return "void" :args
 ((:name |cap| :type |EnableCap| :direction :in)) :category "misc" :version
 "1.0") 
(defglfun "Accum" accum :return "void" :args
 ((:name |op| :type |AccumOp| :direction :in)
  (:name |value| :type |CoordF| :direction :in))
 :category "misc" :version "1.0") 

;;;; }}}

;;;; {{{ modeling

(defglfun "EvalPoint2" eval-point-2 :return "void" :args
 ((:name |i| :type |CheckedInt32| :direction :in)
  (:name |j| :type |CheckedInt32| :direction :in))
 :category "modeling" :version "1.0") 
(defglfun "EvalMesh2" eval-mesh-2 :return "void" :args
 ((:name |mode| :type |MeshMode2| :direction :in)
  (:name |i1| :type |CheckedInt32| :direction :in)
  (:name |i2| :type |CheckedInt32| :direction :in)
  (:name |j1| :type |CheckedInt32| :direction :in)
  (:name |j2| :type |CheckedInt32| :direction :in))
 :category "modeling" :version "1.0") 
(defglfun "EvalPoint1" eval-point-1 :return "void" :args
 ((:name |i| :type |Int32| :direction :in)) :category "modeling" :version "1.0") 
(defglfun "EvalMesh1" eval-mesh-1 :return "void" :args
 ((:name |mode| :type |MeshMode1| :direction :in)
  (:name |i1| :type |CheckedInt32| :direction :in)
  (:name |i2| :type |CheckedInt32| :direction :in))
 :category "modeling" :version "1.0") 
(defglfun "EvalCoord2fv" eval-coord-2fv :return "void" :args
 ((:name |u| :type |CoordF| :direction :in :array t :size #x2)) :category
 "modeling" :version "1.0") 
(defglfun "EvalCoord2f" eval-coord-2f :return "void" :args
 ((:name |u| :type |CoordF| :direction :in)
  (:name |v| :type |CoordF| :direction :in))
 :category "modeling" :version "1.0") 
(defglfun "EvalCoord2dv" eval-coord-2dv :return "void" :args
 ((:name |u| :type |CoordD| :direction :in :array t :size #x2)) :category
 "modeling" :version "1.0") 
(defglfun "EvalCoord2d" eval-coord-2d :return "void" :args
 ((:name |u| :type |CoordD| :direction :in)
  (:name |v| :type |CoordD| :direction :in))
 :category "modeling" :version "1.0") 
(defglfun "EvalCoord1fv" eval-coord-1fv :return "void" :args
 ((:name |u| :type |CoordF| :direction :in :array t :size #x1)) :category
 "modeling" :version "1.0") 
(defglfun "EvalCoord1f" eval-coord-1f :return "void" :args
 ((:name |u| :type |CoordF| :direction :in)) :category "modeling" :version
 "1.0") 
(defglfun "EvalCoord1dv" eval-coord-1dv :return "void" :args
 ((:name |u| :type |CoordD| :direction :in :array t :size #x1)) :category
 "modeling" :version "1.0") 
(defglfun "EvalCoord1d" eval-coord-1d :return "void" :args
 ((:name |u| :type |CoordD| :direction :in)) :category "modeling" :version
 "1.0") 
(defglfun "MapGrid2f" map-grid-2f :return "void" :args
 ((:name |un| :type |Int32| :direction :in)
  (:name |u1| :type |CoordF| :direction :in)
  (:name |u2| :type |CoordF| :direction :in)
  (:name |vn| :type |Int32| :direction :in)
  (:name |v1| :type |CoordF| :direction :in)
  (:name |v2| :type |CoordF| :direction :in))
 :category "modeling" :version "1.0") 
(defglfun "MapGrid2d" map-grid-2d :return "void" :args
 ((:name |un| :type |Int32| :direction :in)
  (:name |u1| :type |CoordD| :direction :in)
  (:name |u2| :type |CoordD| :direction :in)
  (:name |vn| :type |Int32| :direction :in)
  (:name |v1| :type |CoordD| :direction :in)
  (:name |v2| :type |CoordD| :direction :in))
 :category "modeling" :version "1.0") 
(defglfun "MapGrid1f" map-grid-1f :return "void" :args
 ((:name |un| :type |Int32| :direction :in)
  (:name |u1| :type |CoordF| :direction :in)
  (:name |u2| :type |CoordF| :direction :in))
 :category "modeling" :version "1.0") 
(defglfun "MapGrid1d" map-grid-1d :return "void" :args
 ((:name |un| :type |Int32| :direction :in)
  (:name |u1| :type |CoordD| :direction :in)
  (:name |u2| :type |CoordD| :direction :in))
 :category "modeling" :version "1.0") 
(defglfun "Map2f" map-2f :return "void" :args
 ((:name |target| :type |MapTarget| :direction :in)
  (:name |u1| :type |CoordF| :direction :in)
  (:name |u2| :type |CoordF| :direction :in)
  (:name |ustride| :type |Int32| :direction :in)
  (:name |uorder| :type |CheckedInt32| :direction :in)
  (:name |v1| :type |CoordF| :direction :in)
  (:name |v2| :type |CoordF| :direction :in)
  (:name |vstride| :type |Int32| :direction :in)
  (:name |vorder| :type |CheckedInt32| :direction :in)
  (:name |points| :type |CoordF| :direction :in :array t :size
   (|target| |ustride| |uorder| |vstride| |vorder|)))
 :category "modeling" :version "1.0") 
(defglfun "Map2d" map-2d :return "void" :args
 ((:name |target| :type |MapTarget| :direction :in)
  (:name |u1| :type |CoordD| :direction :in)
  (:name |u2| :type |CoordD| :direction :in)
  (:name |ustride| :type |Int32| :direction :in)
  (:name |uorder| :type |CheckedInt32| :direction :in)
  (:name |v1| :type |CoordD| :direction :in)
  (:name |v2| :type |CoordD| :direction :in)
  (:name |vstride| :type |Int32| :direction :in)
  (:name |vorder| :type |CheckedInt32| :direction :in)
  (:name |points| :type |CoordD| :direction :in :array t :size
   (|target| |ustride| |uorder| |vstride| |vorder|)))
 :category "modeling" :version "1.0") 
(defglfun "Map1f" map-1f :return "void" :args
 ((:name |target| :type |MapTarget| :direction :in)
  (:name |u1| :type |CoordF| :direction :in)
  (:name |u2| :type |CoordF| :direction :in)
  (:name |stride| :type |Int32| :direction :in)
  (:name |order| :type |CheckedInt32| :direction :in)
  (:name |points| :type |CoordF| :direction :in :array t :size
   (|target| |stride| |order|)))
 :category "modeling" :version "1.0") 
(defglfun "Map1d" map-1d :return "void" :args
 ((:name |target| :type |MapTarget| :direction :in)
  (:name |u1| :type |CoordD| :direction :in)
  (:name |u2| :type |CoordD| :direction :in)
  (:name |stride| :type |Int32| :direction :in)
  (:name |order| :type |CheckedInt32| :direction :in)
  (:name |points| :type |CoordD| :direction :in :array t :size
   (|target| |stride| |order|)))
 :category "modeling" :version "1.0") 

;;;; }}}

;;;; {{{ pixel-op

(defglfun "DepthFunc" depth-func :return "void" :args
 ((:name |func| :type |DepthFunction| :direction :in)) :category "pixel-op"
 :version "1.0") 
(defglfun "StencilOp" stencil-op :return "void" :args
 ((:name |fail| :type |StencilOp| :direction :in)
  (:name |zfail| :type |StencilOp| :direction :in)
  (:name |zpass| :type |StencilOp| :direction :in))
 :category "pixel-op" :version "1.0") 
(defglfun "StencilFunc" stencil-func :return "void" :args
 ((:name |func| :type |StencilFunction| :direction :in)
  (:name |ref| :type |ClampedStencilValue| :direction :in)
  (:name |mask| :type |MaskedStencilValue| :direction :in))
 :category "pixel-op" :version "1.0") 
(defglfun "LogicOp" logic-op :return "void" :args
 ((:name |opcode| :type |LogicOp| :direction :in)) :category "pixel-op"
 :version "1.0") 
(defglfun "BlendFunc" blend-func :return "void" :args
 ((:name |sfactor| :type |BlendingFactorSrc| :direction :in)
  (:name |dfactor| :type |BlendingFactorDest| :direction :in))
 :category "pixel-op" :version "1.0") 
(defglfun "AlphaFunc" alpha-func :return "void" :args
 ((:name |func| :type |AlphaFunction| :direction :in)
  (:name |ref| :type |ClampedFloat32| :direction :in))
 :category "pixel-op" :version "1.0") 

;;;; }}}

;;;; {{{ pixel-rw

(defglfun "DrawPixels" draw-pixels :return "void" :args
 ((:name |width| :type |SizeI| :direction :in)
  (:name |height| :type |SizeI| :direction :in)
  (:name |format| :type |PixelFormat| :direction :in)
  (:name |type| :type |PixelType| :direction :in)
  (:name |pixels| :type |Void| :direction :in :array t :size
   (|format| |type| |width| |height|)))
 :category "pixel-rw" :version "1.0") 
(defglfun "ReadPixels" read-pixels :return "void" :args
 ((:name |x| :type |WinCoord| :direction :in)
  (:name |y| :type |WinCoord| :direction :in)
  (:name |width| :type |SizeI| :direction :in)
  (:name |height| :type |SizeI| :direction :in)
  (:name |format| :type |PixelFormat| :direction :in)
  (:name |type| :type |PixelType| :direction :in)
  (:name |pixels| :type |Void| :direction :out :array t :size
   (|format| |type| |width| |height|)))
 :category "pixel-rw" :version "1.0") 
(defglfun "CopyPixels" copy-pixels :return "void" :args
 ((:name |x| :type |WinCoord| :direction :in)
  (:name |y| :type |WinCoord| :direction :in)
  (:name |width| :type |SizeI| :direction :in)
  (:name |height| :type |SizeI| :direction :in)
  (:name |type| :type |PixelCopyType| :direction :in))
 :category "pixel-rw" :version "1.0") 
(defglfun "ReadBuffer" read-buffer :return "void" :args
 ((:name |mode| :type |ReadBufferMode| :direction :in)) :category "pixel-rw"
 :version "1.0") 
(defglfun "PixelMapusv" pixel-map-usv :return "void" :args
 ((:name |map| :type |PixelMap| :direction :in)
  (:name |mapsize| :type |CheckedInt32| :direction :in)
  (:name |values| :type |UInt16| :direction :in :array t :size mapsize))
 :category "pixel-rw" :version "1.0") 
(defglfun "PixelMapuiv" pixel-map-uiv :return "void" :args
 ((:name |map| :type |PixelMap| :direction :in)
  (:name |mapsize| :type |CheckedInt32| :direction :in)
  (:name |values| :type |UInt32| :direction :in :array t :size mapsize))
 :category "pixel-rw" :version "1.0") 
(defglfun "PixelMapfv" pixel-map-fv :return "void" :args
 ((:name |map| :type |PixelMap| :direction :in)
  (:name |mapsize| :type |CheckedInt32| :direction :in)
  (:name |values| :type |Float32| :direction :in :array t :size mapsize))
 :category "pixel-rw" :version "1.0") 
(defglfun "PixelStorei" pixel-store-i :return "void" :args
 ((:name |pname| :type |PixelStoreParameter| :direction :in)
  (:name |param| :type |CheckedInt32| :direction :in))
 :category "pixel-rw" :version "1.0") 
(defglfun "PixelStoref" pixel-store-f :return "void" :args
 ((:name |pname| :type |PixelStoreParameter| :direction :in)
  (:name |param| :type |CheckedFloat32| :direction :in))
 :category "pixel-rw" :version "1.0") 
(defglfun "PixelTransferi" pixel-transfer-i :return "void" :args
 ((:name |pname| :type |PixelTransferParameter| :direction :in)
  (:name |param| :type |CheckedInt32| :direction :in))
 :category "pixel-rw" :version "1.0") 
(defglfun "PixelTransferf" pixel-transfer-f :return "void" :args
 ((:name |pname| :type |PixelTransferParameter| :direction :in)
  (:name |param| :type |CheckedFloat32| :direction :in))
 :category "pixel-rw" :version "1.0") 
(defglfun "PixelZoom" pixel-zoom :return "void" :args
 ((:name |xfactor| :type |Float32| :direction :in)
  (:name |yfactor| :type |Float32| :direction :in))
 :category "pixel-rw" :version "1.0") 

;;;; }}}

;;;; {{{ state-req

(defglfun "IsList" is-list :return "Boolean" :args
 ((:name |list| :type |List| :direction :in)) :category "state-req" :version
 "1.0") 
(defglfun "IsEnabled" is-enabled :return "Boolean" :args
 ((:name |cap| :type |EnableCap| :direction :in)) :category "state-req"
 :version "1.0") 
(defglfun "GetTexLevelParameteriv" get-tex-level-parameter-iv :return "void"
 :args
 ((:name |target| :type |TextureTarget| :direction :in)
  (:name |level| :type |CheckedInt32| :direction :in)
  (:name |pname| :type |GetTextureParameter| :direction :in)
  (:name |params| :type |Int32| :direction :out :array t :size (|pname|)))
 :category "state-req" :version "1.0") 
(defglfun "GetTexLevelParameterfv" get-tex-level-parameter-fv :return "void"
 :args
 ((:name |target| :type |TextureTarget| :direction :in)
  (:name |level| :type |CheckedInt32| :direction :in)
  (:name |pname| :type |GetTextureParameter| :direction :in)
  (:name |params| :type |Float32| :direction :out :array t :size (|pname|)))
 :category "state-req" :version "1.0") 
(defglfun "GetTexParameteriv" get-tex-parameter-iv :return "void" :args
 ((:name |target| :type |TextureTarget| :direction :in)
  (:name |pname| :type |GetTextureParameter| :direction :in)
  (:name |params| :type |Int32| :direction :out :array t :size (|pname|)))
 :category "state-req" :version "1.0") 
(defglfun "GetTexParameterfv" get-tex-parameter-fv :return "void" :args
 ((:name |target| :type |TextureTarget| :direction :in)
  (:name |pname| :type |GetTextureParameter| :direction :in)
  (:name |params| :type |Float32| :direction :out :array t :size (|pname|)))
 :category "state-req" :version "1.0") 
(defglfun "GetTexImage" get-tex-image :return "void" :args
 ((:name |target| :type |TextureTarget| :direction :in)
  (:name |level| :type |CheckedInt32| :direction :in)
  (:name |format| :type |PixelFormat| :direction :in)
  (:name |type| :type |PixelType| :direction :in)
  (:name |pixels| :type |Void| :direction :out :array t :size
   (|target| |level| |format| |type|)))
 :category "state-req" :version "1.0") 
(defglfun "GetTexGeniv" get-tex-gen-iv :return "void" :args
 ((:name |coord| :type |TextureCoordName| :direction :in)
  (:name |pname| :type |TextureGenParameter| :direction :in)
  (:name |params| :type |Int32| :direction :out :array t :size (|pname|)))
 :category "state-req" :version "1.0") 
(defglfun "GetTexGenfv" get-tex-gen-fv :return "void" :args
 ((:name |coord| :type |TextureCoordName| :direction :in)
  (:name |pname| :type |TextureGenParameter| :direction :in)
  (:name |params| :type |Float32| :direction :out :array t :size (|pname|)))
 :category "state-req" :version "1.0") 
(defglfun "GetTexGendv" get-tex-gen-dv :return "void" :args
 ((:name |coord| :type |TextureCoordName| :direction :in)
  (:name |pname| :type |TextureGenParameter| :direction :in)
  (:name |params| :type |Float64| :direction :out :array t :size (|pname|)))
 :category "state-req" :version "1.0") 
(defglfun "GetTexEnviv" get-tex-env-iv :return "void" :args
 ((:name |target| :type |TextureEnvTarget| :direction :in)
  (:name |pname| :type |TextureEnvParameter| :direction :in)
  (:name |params| :type |Int32| :direction :out :array t :size (|pname|)))
 :category "state-req" :version "1.0") 
(defglfun "GetTexEnvfv" get-tex-env-fv :return "void" :args
 ((:name |target| :type |TextureEnvTarget| :direction :in)
  (:name |pname| :type |TextureEnvParameter| :direction :in)
  (:name |params| :type |Float32| :direction :out :array t :size (|pname|)))
 :category "state-req" :version "1.0") 
(defglfun "GetString" get-string :return "String" :args
 ((:name |name| :type |StringName| :direction :in)) :category "state-req"
 :version "1.0") 
(defglfun "GetPolygonStipple" get-polygon-stipple :return "void" :args
 ((:name |mask| :type |UInt8| :direction :out :array t)) :category "state-req"
 :version "1.0") 
(defglfun "GetPixelMapusv" get-pixel-map-usv :return "void" :args
 ((:name |map| :type |PixelMap| :direction :in)
  (:name |values| :type |UInt16| :direction :out :array t :size (|map|)))
 :category "state-req" :version "1.0") 
(defglfun "GetPixelMapuiv" get-pixel-map-uiv :return "void" :args
 ((:name |map| :type |PixelMap| :direction :in)
  (:name |values| :type |UInt32| :direction :out :array t :size (|map|)))
 :category "state-req" :version "1.0") 
(defglfun "GetPixelMapfv" get-pixel-map-fv :return "void" :args
 ((:name |map| :type |PixelMap| :direction :in)
  (:name |values| :type |Float32| :direction :out :array t :size (|map|)))
 :category "state-req" :version "1.0") 
(defglfun "GetMaterialiv" get-material-iv :return "void" :args
 ((:name |face| :type |MaterialFace| :direction :in)
  (:name |pname| :type |MaterialParameter| :direction :in)
  (:name |params| :type |Int32| :direction :out :array t :size (|pname|)))
 :category "state-req" :version "1.0") 
(defglfun "GetMaterialfv" get-material-fv :return "void" :args
 ((:name |face| :type |MaterialFace| :direction :in)
  (:name |pname| :type |MaterialParameter| :direction :in)
  (:name |params| :type |Float32| :direction :out :array t :size (|pname|)))
 :category "state-req" :version "1.0") 
(defglfun "GetMapiv" get-map-iv :return "void" :args
 ((:name |target| :type |MapTarget| :direction :in)
  (:name |query| :type |GetMapQuery| :direction :in)
  (:name |v| :type |Int32| :direction :out :array t :size (|target| |query|)))
 :category "state-req" :version "1.0") 
(defglfun "GetMapfv" get-map-fv :return "void" :args
 ((:name |target| :type |MapTarget| :direction :in)
  (:name |query| :type |GetMapQuery| :direction :in)
  (:name |v| :type |Float32| :direction :out :array t :size
   (|target| |query|)))
 :category "state-req" :version "1.0") 
(defglfun "GetMapdv" get-map-dv :return "void" :args
 ((:name |target| :type |MapTarget| :direction :in)
  (:name |query| :type |GetMapQuery| :direction :in)
  (:name |v| :type |Float64| :direction :out :array t :size
   (|target| |query|)))
 :category "state-req" :version "1.0") 
(defglfun "GetLightiv" get-light-iv :return "void" :args
 ((:name |light| :type |LightName| :direction :in)
  (:name |pname| :type |LightParameter| :direction :in)
  (:name |params| :type |Int32| :direction :out :array t :size (|pname|)))
 :category "state-req" :version "1.0") 
(defglfun "GetLightfv" get-light-fv :return "void" :args
 ((:name |light| :type |LightName| :direction :in)
  (:name |pname| :type |LightParameter| :direction :in)
  (:name |params| :type |Float32| :direction :out :array t :size (|pname|)))
 :category "state-req" :version "1.0") 
(defglfun "GetIntegerv" get-integerv :return "void" :args
 ((:name |pname| :type |GetPName| :direction :in)
  (:name |params| :type |Int32| :direction :out :array t :size (|pname|)))
 :category "state-req" :version "1.0") 
(defglfun "GetFloatv" get-floatv :return "void" :args
 ((:name |pname| :type |GetPName| :direction :in)
  (:name |params| :type |Float32| :direction :out :array t :size (|pname|)))
 :category "state-req" :version "1.0") 
(defglfun "GetError" get-error :return "ErrorCode" :args nil :category
 "state-req" :version "1.0") 
(defglfun "GetDoublev" get-doublev :return "void" :args
 ((:name |pname| :type |GetPName| :direction :in)
  (:name |params| :type |Float64| :direction :out :array t :size (|pname|)))
 :category "state-req" :version "1.0") 
(defglfun "GetClipPlane" get-clip-plane :return "void" :args
 ((:name |plane| :type |ClipPlaneName| :direction :in)
  (:name |equation| :type |Float64| :direction :out :array t :size #x4))
 :category "state-req" :version "1.0") 
(defglfun "GetBooleanv" get-booleanv :return "void" :args
 ((:name |pname| :type |GetPName| :direction :in)
  (:name |params| :type |Boolean| :direction :out :array t :size (|pname|)))
 :category "state-req" :version "1.0") 

;;;; }}}

;;;; {{{ xform

(defglfun "Viewport" viewport :return "void" :args
 ((:name |x| :type |WinCoord| :direction :in)
  (:name |y| :type |WinCoord| :direction :in)
  (:name |width| :type |SizeI| :direction :in)
  (:name |height| :type |SizeI| :direction :in))
 :category "xform" :version "1.0") 
(defglfun "Translatef" translate-f :return "void" :args
 ((:name |x| :type |Float32| :direction :in)
  (:name |y| :type |Float32| :direction :in)
  (:name |z| :type |Float32| :direction :in))
 :category "xform" :version "1.0") 
(defglfun "Translated" translate-d :return "void" :args
 ((:name |x| :type |Float64| :direction :in)
  (:name |y| :type |Float64| :direction :in)
  (:name |z| :type |Float64| :direction :in))
 :category "xform" :version "1.0") 
(defglfun "Scalef" scale-f :return "void" :args
 ((:name |x| :type |Float32| :direction :in)
  (:name |y| :type |Float32| :direction :in)
  (:name |z| :type |Float32| :direction :in))
 :category "xform" :version "1.0") 
(defglfun "Scaled" scale-d :return "void" :args
 ((:name |x| :type |Float64| :direction :in)
  (:name |y| :type |Float64| :direction :in)
  (:name |z| :type |Float64| :direction :in))
 :category "xform" :version "1.0") 
(defglfun "Rotatef" rotate-f :return "void" :args
 ((:name |angle| :type |Float32| :direction :in)
  (:name |x| :type |Float32| :direction :in)
  (:name |y| :type |Float32| :direction :in)
  (:name |z| :type |Float32| :direction :in))
 :category "xform" :version "1.0") 
(defglfun "Rotated" rotate-d :return "void" :args
 ((:name |angle| :type |Float64| :direction :in)
  (:name |x| :type |Float64| :direction :in)
  (:name |y| :type |Float64| :direction :in)
  (:name |z| :type |Float64| :direction :in))
 :category "xform" :version "1.0") 
(defglfun "PushMatrix" push-matrix :return "void" :args nil :category "xform"
 :version "1.0") 
(defglfun "PopMatrix" pop-matrix :return "void" :args nil :category "xform"
 :version "1.0") 
(defglfun "Ortho" ortho :return "void" :args
 ((:name |left| :type |Float64| :direction :in)
  (:name |right| :type |Float64| :direction :in)
  (:name |bottom| :type |Float64| :direction :in)
  (:name |top| :type |Float64| :direction :in)
  (:name |zNear| :type |Float64| :direction :in)
  (:name |zFar| :type |Float64| :direction :in))
 :category "xform" :version "1.0") 
(defglfun "MultMatrixd" mult-matrix-d :return "void" :args
 ((:name |m| :type |Float64| :direction :in :array t :size #x10)) :category
 "xform" :version "1.0") 
(defglfun "MultMatrixf" mult-matrix-f :return "void" :args
 ((:name |m| :type |Float32| :direction :in :array t :size #x10)) :category
 "xform" :version "1.0") 
(defglfun "MatrixMode" matrix-mode :return "void" :args
 ((:name |mode| :type |MatrixMode| :direction :in)) :category "xform" :version
 "1.0") 
(defglfun "LoadMatrixd" load-matrix-d :return "void" :args
 ((:name |m| :type |Float64| :direction :in :array t :size #x10)) :category
 "xform" :version "1.0") 
(defglfun "LoadMatrixf" load-matrix-f :return "void" :args
 ((:name |m| :type |Float32| :direction :in :array t :size #x10)) :category
 "xform" :version "1.0") 
(defglfun "LoadIdentity" load-identity :return "void" :args nil :category
 "xform" :version "1.0") 
(defglfun "Frustum" frustum :return "void" :args
 ((:name |left| :type |Float64| :direction :in)
  (:name |right| :type |Float64| :direction :in)
  (:name |bottom| :type |Float64| :direction :in)
  (:name |top| :type |Float64| :direction :in)
  (:name |zNear| :type |Float64| :direction :in)
  (:name |zFar| :type |Float64| :direction :in))
 :category "xform" :version "1.0") 
(defglfun "DepthRange" depth-range :return "void" :args
 ((:name |near| :type |ClampedFloat64| :direction :in)
  (:name |far| :type |ClampedFloat64| :direction :in))
 :category "xform" :version "1.0") 

;;;; }}}