diff --git a/collects/games/scribblings/games.scrbl b/collects/games/scribblings/games.scrbl index 75dd7284cc..12e4f0592c 100644 --- a/collects/games/scribblings/games.scrbl +++ b/collects/games/scribblings/games.scrbl @@ -5,7 +5,7 @@ games/show-help games/show-scribbling)) -@title{@bold{Games}} +@title{@bold{Games}: Fun Examples} The @exec{PLT Games} executable (or @exec{plt-games} under Unix) lets you select one of the games distributed by PLT or other games diff --git a/collects/scribble/base-render.ss b/collects/scribble/base-render.ss index 3ade2a645c..f4707b887a 100644 --- a/collects/scribble/base-render.ss +++ b/collects/scribble/base-render.ss @@ -407,61 +407,65 @@ ;; ---------------------------------------- - (define/private (do-table-of-contents part ri delta quiet) + (define/private (do-table-of-contents part ri delta quiet depth) (make-table #f (generate-toc part ri (+ delta (length (collected-info-number (part-collected-info part ri)))) #t - quiet))) + quiet + depth))) (define/public (table-of-contents part ri) - (do-table-of-contents part ri -1 not)) + (do-table-of-contents part ri -1 not +inf.0)) - (define/public (local-table-of-contents part ri) - (table-of-contents part ri)) + (define/public (local-table-of-contents part ri style) + (do-table-of-contents part ri -1 not (if (eq? style 'immediate-only) + 1 + +inf.0))) (define/public (quiet-table-of-contents part ri) - (do-table-of-contents part ri 1 (lambda (x) #t))) + (do-table-of-contents part ri 1 (lambda (x) #t) +inf.0)) - (define/private (generate-toc part ri base-len skip? quiet) + (define/private (generate-toc part ri base-len skip? quiet depth) (let* ([number (collected-info-number (part-collected-info part ri))] [subs - (if (quiet (and (part-style? part 'quiet) - (not (= base-len (sub1 (length number)))))) - (apply append (map (lambda (p) - (generate-toc p ri base-len #f quiet)) - (part-parts part))) - null)]) + (if (and (quiet (and (part-style? part 'quiet) + (not (= base-len (sub1 (length number)))))) + (positive? depth)) + (apply append (map (lambda (p) + (generate-toc p ri base-len #f quiet (sub1 depth))) + (part-parts part))) + null)]) (if skip? - subs - (let ([l (cons - (list (make-flow - (list - (make-paragraph + subs + (let ([l (cons + (list (make-flow (list - (make-element - 'hspace - (list (make-string (* 2 (- (length number) - base-len)) - #\space))) - (make-link-element - (if (= 1 (length number)) "toptoclink" "toclink") - (append - (format-number - number - (list (make-element 'hspace '(" ")))) - (or (part-title-content part) '("???"))) - (car (part-tags part)))))))) - subs)]) - (if (and (= 1 (length number)) - (or (not (car number)) ((car number) . > . 1))) - (cons (list (make-flow - (list (make-paragraph - (list (make-element 'hspace (list ""))))))) - l) - l))))) + (make-paragraph + (list + (make-element + 'hspace + (list (make-string (* 2 (- (length number) + base-len)) + #\space))) + (make-link-element + (if (= 1 (length number)) "toptoclink" "toclink") + (append + (format-number + number + (list (make-element 'hspace '(" ")))) + (or (part-title-content part) '("???"))) + (car (part-tags part)))))))) + subs)]) + (if (and (= 1 (length number)) + (or (not (car number)) ((car number) . > . 1))) + (cons (list (make-flow + (list (make-paragraph + (list (make-element 'hspace (list ""))))))) + l) + l))))) ;; ---------------------------------------- diff --git a/collects/scribble/basic.ss b/collects/scribble/basic.ss index bc5e6ed5a0..33e24c4f1c 100644 --- a/collects/scribble/basic.ss +++ b/collects/scribble/basic.ss @@ -170,13 +170,13 @@ (define (clean-up s) ;; Remove leading spaces, which might appear there due to images or something ;; else that gets dropped in string form. - (regexp-replace* #rx"^ +" s "")) + (regexp-replace #rx"^ +" s "")) (define (record-index word-seq element-seq tag content) (make-index-element #f (list (make-target-element #f content `(idx ,tag))) `(idx ,tag) - (map clean-up word-seq) + word-seq element-seq #f)) @@ -191,7 +191,7 @@ (define (as-index . s) (let ([key (make-generated-tag)] [content (decode-content s)]) - (record-index (list (content->string content)) + (record-index (list (clean-up (content->string content))) (if (= 1 (length content)) content (list (make-element #f content))) @@ -294,7 +294,7 @@ (lambda (renderer part ri) (send renderer table-of-contents part ri)))) -(define (local-table-of-contents) +(define (local-table-of-contents #:style [style #f]) (make-delayed-block (lambda (renderer part ri) - (send renderer local-table-of-contents part ri)))) + (send renderer local-table-of-contents part ri style)))) diff --git a/collects/scribble/decode.ss b/collects/scribble/decode.ss index 6388f6b0d2..68ea51033a 100644 --- a/collects/scribble/decode.ss +++ b/collects/scribble/decode.ss @@ -89,7 +89,7 @@ (cons (make-index-element #f null (car tags) (list (regexp-replace - #px"^(?:A|An|The)\\s" (content->string title) "")) + #px"^\\s+(?:(?:A|An|The)\\s)?" (content->string title) "")) (list (make-element #f title)) (make-part-index-desc)) l) diff --git a/collects/scribble/html-render.ss b/collects/scribble/html-render.ss index 85d981ea74..de3fe3e645 100644 --- a/collects/scribble/html-render.ss +++ b/collects/scribble/html-render.ss @@ -889,7 +889,7 @@ (cond [(string? i) (let ([m (and (extra-breaking?) - (regexp-match-positions #rx"[-:/+]" i))]) + (regexp-match-positions #rx"[-:/+_]|[a-z](?=[A-Z])" i))]) (if m (list* (substring i 0 (cdar m)) ;; Most browsers wrap after a hyphen. The diff --git a/collects/scribble/latex-render.ss b/collects/scribble/latex-render.ss index 3eaf7b86fd..dcfd4cc2da 100644 --- a/collects/scribble/latex-render.ss +++ b/collects/scribble/latex-render.ss @@ -382,7 +382,7 @@ ;; FIXME: isn't local to the section (make-toc-paragraph null)) - (define/override (local-table-of-contents part ri) + (define/override (local-table-of-contents part ri style) (make-paragraph null)) ;; ---------------------------------------- diff --git a/collects/scribblings/reference/bytes.scrbl b/collects/scribblings/reference/bytes.scrbl index b675ded282..b4efad7a3d 100644 --- a/collects/scribblings/reference/bytes.scrbl +++ b/collects/scribblings/reference/bytes.scrbl @@ -5,6 +5,8 @@ @guideintro["bytestrings"]{byte strings} +@local-table-of-contents[] + A @pidefterm{byte string} is a fixed-length arary of bytes. A @pidefterm{byte} is an exact integer between @scheme[0] and @scheme[255] inclusive. diff --git a/collects/scribblings/reference/chars.scrbl b/collects/scribblings/reference/chars.scrbl index af6341ed57..ad24b501f7 100644 --- a/collects/scribblings/reference/chars.scrbl +++ b/collects/scribblings/reference/chars.scrbl @@ -7,6 +7,8 @@ @guideintro["characters"]{characters} +@local-table-of-contents[] + MzScheme characters range over Unicode scalar values, which includes characters whose values range from @schemevalfont{#x0} to @schemevalfont{#x10FFFF}, but not including @schemevalfont{#xD800} to diff --git a/collects/scribblings/reference/data.scrbl b/collects/scribblings/reference/data.scrbl index 58f9ac4225..3d8e2a8d0d 100644 --- a/collects/scribblings/reference/data.scrbl +++ b/collects/scribblings/reference/data.scrbl @@ -6,7 +6,7 @@ Each of the built-in datatypes comes with a set of procedures for manipulating members of the datatype. -@local-table-of-contents[] +@local-table-of-contents[#:style 'immediate-only] @; ------------------------------------------------------------ diff --git a/collects/scribblings/reference/numbers.scrbl b/collects/scribblings/reference/numbers.scrbl index f482b3282b..9991c872cf 100644 --- a/collects/scribblings/reference/numbers.scrbl +++ b/collects/scribblings/reference/numbers.scrbl @@ -9,6 +9,8 @@ @guideintro["numbers"]{numbers} +@local-table-of-contents[] + All numbers are @deftech{complex numbers}. Some of them are @deftech{real numbers}, and all of the real numbers that can be represented are also @deftech{rational numbers}, except for diff --git a/collects/scribblings/reference/pairs.scrbl b/collects/scribblings/reference/pairs.scrbl index 80a48a04a8..ec136fd105 100644 --- a/collects/scribblings/reference/pairs.scrbl +++ b/collects/scribblings/reference/pairs.scrbl @@ -44,6 +44,8 @@ @title[#:tag "pairs"]{Pairs and Lists} +@local-table-of-contents[] + A @deftech{pair} combines exactly two values. The first value is accessed with the @scheme[car] procedure, and the second value is accessed with the @scheme[cdr] procedure. Pairs are not mutable (but @@ -532,12 +534,13 @@ must merely start with a chain of at least @scheme[pos] pairs. @; Note: this is exactly the same description as the one for string-append* Like @scheme[append], but the last argument is used as a list of -arguments for @scheme[append], so @scheme[(append* x ... xs)] is the -same as @scheme[(apply append x ... xs)]. In other words, the +arguments for @scheme[append], so @scheme[(append* lst ... lsts)] is the +same as @scheme[(apply append lst ... lsts)]. In other words, the relationship between @scheme[append] and @scheme[append*] is similar to the one between @scheme[list] and @scheme[list*]. @examples[#:eval list-eval + (append* '(a) '(b) '((c) (d))) (cdr (append* (map (lambda (x) (list ", " x)) '("Alpha" "Beta" "Gamma")))) ]} diff --git a/collects/scribblings/reference/regexps.scrbl b/collects/scribblings/reference/regexps.scrbl index 37454e2be4..9083d21ac8 100644 --- a/collects/scribblings/reference/regexps.scrbl +++ b/collects/scribblings/reference/regexps.scrbl @@ -10,6 +10,8 @@ @section-index["strings" "pattern matching"] @section-index["input ports" "pattern matching"] +@local-table-of-contents[] + Regular expressions are specified as strings or byte strings, using the same pattern language as the Unix utility @exec{egrep} or Perl. A string-specified pattern produces a character regexp matcher, and a diff --git a/collects/scribblings/reference/strings.scrbl b/collects/scribblings/reference/strings.scrbl index 3ab50905a9..2c60e7b862 100644 --- a/collects/scribblings/reference/strings.scrbl +++ b/collects/scribblings/reference/strings.scrbl @@ -5,6 +5,8 @@ @guideintro["strings"]{strings} +@local-table-of-contents[] + A @pidefterm{string} is a fixed-length array of @seclink["characters"]{characters}. @@ -365,18 +367,20 @@ allocated string).} @note-lib[scheme/string] @(define string-eval (make-base-eval)) -@interaction-eval[#:eval string-eval (require scheme/string)] +@interaction-eval[#:eval string-eval (require scheme/string scheme/list)] @defproc[(string-append* [str string?] ... [strs (listof string?)]) string?]{ @; Note: this is exactly the same description as the one for append* -Like @scheme[string-append], but the last argument is used as a list of -arguments for @scheme[string-append], so @scheme[(string-append* x ... xs)] is the -same as @scheme[(apply string-append x ... xs)]. In other words, the -relationship between @scheme[string-append] and @scheme[string-append*] is similar -to the one between @scheme[list] and @scheme[list*]. +Like @scheme[string-append], but the last argument is used as a list +of arguments for @scheme[string-append], so @scheme[(string-append* +str ... strs)] is the same as @scheme[(apply string-append str +... strs)]. In other words, the relationship between +@scheme[string-append] and @scheme[string-append*] is similar to the +one between @scheme[list] and @scheme[list*]. @examples[#:eval string-eval + (string-append* "a" "b" '("c" "d")) (string-append* (cdr (append* (map (lambda (x) (list ", " x)) '("Alpha" "Beta" "Gamma"))))) ]} diff --git a/collects/scribblings/slideshow/slides.scrbl b/collects/scribblings/slideshow/slides.scrbl index 0c8ed7feef..e1a3b7b345 100644 --- a/collects/scribblings/slideshow/slides.scrbl +++ b/collects/scribblings/slideshow/slides.scrbl @@ -4,6 +4,8 @@ slideshow/step slideshow/slides-to-picts)) +@(define d=> @elem['rarr]) + @title[#:style 'toc]{Making Slides} @declare-exporting[slideshow/base slideshow] @@ -102,6 +104,7 @@ Creates title text. Returns @scheme[((current-titlet) str)].} @defproc[(para [#:width width real? (current-para-width)] [#:align align (one-of/c 'left 'center 'right) 'left] [#:fill? fill? any/c #t] + [#:decode? decode? any/c #t] [element (flat-rec-contract elem/c (or/c string? pict? (listof elem/c)))] ...) pict?]{ @@ -111,11 +114,23 @@ and that is exactly @scheme[width] units if @scheme[fill?] is true. If @scheme[fill?] is @scheme[#f], then the result pict is as wide as the widest line. -Each list @scheme[element]s are sliced into the sequence of string and -pict elements. Strings are split at spaces for word-wrapping to fit -the page, and a space is added between elements. If a string element -starts with a punctuation mark (e.g., a comma), however, no space is -added before the string. +Each list within @scheme[element]s is spliced into the sequence of +string and pict elements. If @scheme[decode?] is true, then strings +among the @scheme[element]s are decoded by performing the following +substitutions: @litchar["---"] @d=> @litchar["\u2014"], @litchar["--"] +@d=> @litchar["\u2013"], @litchar["``"] @d=> @litchar["\u201C"], +@litchar["''"] @d=> @litchar["\u201D"], @litchar["'"] @d=> +@litchar["\u2019"]. + +Strings are split at spaces for word-wrapping to fit the page, and a +space is added between elements. If a string element starts with one +of the following punctuation marks (after decoding), however, no space +is added before the string: + +@t{ + @hspace[2] @litchar{-} @litchar{'} @litchar{,} @litchar{.} @litchar{ } @litchar{:} + @litchar{;} @litchar{?} @litchar{!} @litchar{)} @litchar["\u201D"] @litchar["\u2019"] +} The @scheme[align] argument specifies how to align lines within the paragraph. @@ -128,6 +143,7 @@ See the spacing between lines is determined by the [#:bullet blt pict? bullet] [#:align align (one-of/c 'left 'center 'right) 'left] [#:fill? fill? any/c #t] + [#:decode? decode? any/c #t] [element (flat-rec-contract elem/c (or/c string? pict? (listof elem/c)))] ...) pict?]{ @@ -143,6 +159,7 @@ paragraph.} [#:bullet blt pict? o-bullet] [#:align align (one-of/c 'left 'center 'right) 'left] [#:fill? fill? any/c #t] + [#:decode? decode? any/c #t] [element (flat-rec-contract elem/c (or/c string? pict? (listof elem/c)))] ...) pict?]{ diff --git a/collects/sgl/doc.txt b/collects/sgl/doc.txt deleted file mode 100644 index 330bf30aba..0000000000 --- a/collects/sgl/doc.txt +++ /dev/null @@ -1,921 +0,0 @@ -_GL_/_OpenGL_ bindings for PLT Scheme - -Sgl provides access to the system's GL library, version 1.5, and GLU library, -version 1.3. The GL API and hence the sgl library do not address system level -concerns, such as the attachment of GL rendering contexts to displays. The -sgl library should work with any PLT Scheme extension that provides GL with -access to the system (such as a binding for glx). DrScheme and mred -automatically attach a GL rendering context to each canvas% object on (at -least) Windows, Linux and OS X systems. Refer to the gears.ss example -(${PLTHOME}/collects/sgl/examples/gears.ss) and the with-gl-context method on -canvas% objects for more information on using the built-in GL rendering -context support. - -Sgl has two layers, gl.ss and sgl.ss. The gl.ss library provides access to -the C-language-style GL API, whereas the sgl.ss library provides a more -Scheme-like interface. The gl.ss library provides a binding for each #defined -constant and for most functions in GL 1.5 and GLU 1.3. The functions perform -comparable checking to their C-language counterparts; they check the types of -their arguments, but do not check the length of array arguments. The sgl.ss -library provides wrappers around many of the functions in the gl.ss library to -present a more Scheme-friendly interface, including function names that follow -Scheme conventions, and checked, symbolic enumeration arguments, and -array-length checks. - -Safety: -GL programming is inherently unsafe, even when using only the sgl.ss library. -Although sgl.ss checks the arguments to each function call, violation of -higher-level assumptions of the system's GL library can cause it to crash, -bringing the entire Scheme system down. For example, sending a large number -of vertices in a single glBegin causes at least some GL implementations to -crash. - -_gl.ss_ - -Use the gl.ss module by adding (require sgl/gl) to your program. -The gl.ss module provides a direct interface to the system's GL library -closely following the conventions of the C-language GL API. It provides a -binding for each #defined constant (these start with GL_) and for the -functions in the GL 1.5 and GLU 1.3 specifications, except for the following. -Vertex arrays (GL 1.5, Section 2.8) -Buffer objects (GL 1.5, Section 2.9) -glGetPointerv (GL 1.5, Section 6.1.11) -Buffer object queries (GL 1.5, Section 6.1.13) -Polygon tessellation (GLU 1.3, Section 5) -gluQuadricCallback (GLU 1.3, Section 6.2) -NURBS (GLU 1.3, Section 7) - -If one of the provided functions is not present on your system (e.g. if your -system supports GL 1.3), the function will raise a run-time exception when -invoked. - -The names exported from "gl.ss" are case-sensitive (e.g. `glBegin' -instead of `glbegin'), so accessing the bindings from case-insensitive -code is difficult. - -Types: -The functions provided by gl.ss perform comparable checking to their -C-language counterparts; they check the types of their arguments, but do not -check the length of array arguments. The following chart details what Scheme -values can be passed in for each primitive GL type. -GLtype Scheme value ------------------------------------------------------------------------------- -GLbyte, GLshort, GLint exact integer in the proper range -GLubyte, GLushort, GLuint non-negative exact integer in the proper range -GLsizei, GLenum, GLbitfield non-negative exact integer in the proper range -GLfloat, GLdouble real number -GLclampf, GLclampd real number -GLboolean Any value, interpreted such that - #f is GL_FALSE and anything else is GL_TRUE - (This means that you should not usually - GL_FALSE or GL_TRUE as arguments, since they - are bound to integers, both will end up being - converted to GL_TRUE.) - -GL functions that take vector arguments accept cvector values. Section 2.4 of -the PLT Foreign Interface Manual describes the functions for creating and -manipulating cvectors (make-cvector, cvector, cvector?, cvector-length, -cvector-type, cvector-ref, cvector-set!, cvector->list, and list->cvector). -The type of the cvector is checked: for example, glVertex3fv expects a vector -of GLfloats, and will only accept a cvector containing GLfloats. The -gl-vector.ss module provides cvector operations that account for the GL type -information. Functions that accept arrays of type void* will accept any -cvector, you must ensure that you supply the proper kind of vector, as in the -C-language GL API. - -The following functions have interfaces that differ from their C-language -counterparts. The function index at the end of this document refers back -to these notes for each function. - -1: glPixelMap - glDeleteTextures - glDeleteQueries -These functions do not take a size argument, it is derived from the length of -the argument vector. - -2: glGenTextures - glGenQueries -These functions do not take vector arguments. Instead, they allocate a vector -of the requested size and return it. - -3: glAreTexturesResident -This function takes in a single uint vector, textures, and returns 2 values: -the specified boolean and a boolean vector residences. - -4: glGetBooleanv - glGetIntegerv - glGetFloatv - glGetDoublev - glGetLight - glGetMaterial - glGetTexEnv - glGetTexGen - glGetTexParameter - glGetTexLevelParameter - glGetPixelMap - glGetMap - glGetBufferParameter - glGetConvolutionParameter - glGetHistogramParameter - glGetMinmaxParameter - glGetQuery - glGetQueryObject -Instead of taking a vector argument, these function take an integer argument -that specifies the size of the vector which is returned. - -5: glGetClipPlane -This function does not take a vector argument and returns a double vector of -length 4. - -6: glGetString - gluCheckExtension - gluErrorString - gluGetString -These functions deal with strings instead of ubyte vectors. - -7: gluProject - gluUnProject - gluUnProject4 -Instead of taking pointers to doubles for return values, these function -directly return double vectors. - -8: glSelectBuffer - glFeedbackBuffer -These functions do not take vectors, instead they return a -selection-buffer-object or feedback-buffer-object. The gl.ss library provides -the functions select-buffer->gl-uint-vector and -feedback-buffer->gl-float-vector to copy the contents of the buffer into a -vector. Because the GL library writes to the buffer-object on GL function -calls after glSelectBuffer or glFeedbackBuffer has returned, if the buffer is -garbage collected before GL is finished writing to it, the entire Scheme -system can crash. The process-selection function in sgl helps interpret the -results of glSelectBuffer in a Scheme-friendly format. - - -Notational Example: -(require sgl/gl - sgl/gl-vectors) -(glBegin GL_TRIANGLES) -(glVertex3i 1 2 3) -(glVertex4fv (gl-float-vector 1 2 3 4)) -(glEnd) - -See alpha.ss in the examples subdirectory of the sgl collection -(${PLTHOME}/collects/sgl/examples/alpha.ss) for a working example. Try -choosing the sk.jpg file in the icons when this example asks you for a file. -You may have to press "t" a few times if the spinning cube is blank. - - -_gl-vectors.ss_ - -The gl-vectors module supports GL programming with cvectors. In this -document, and in the error messages, a gl-vector is just a cvector, from (lib -"foreign.ss"), and a gl--vector is a cvector with an appropriate type. -Use this module by adding (require sgl/gl-vectors) to your -program. I suggest using this module instead of using the cvector function -directly because these functions are specialized to handling the GL typedefs -correctly. - -The gl-vectors.ss module provides the following functions, which are synonyms -for the corresponding cvector functions: -gl-vector->vector -gl-vector->list -gl-vector-length -gl-vector-ref -gl-vector-set! -gl-vector? - -Furthermore, for each in byte, ubyte, short, ushort, int, uint, float, -double, boolean gl-vectors.ss provides the following functions: -gl--vector?: any -> boolean - True when the argument is a gl--vector -make-gl--vector: non-negative-integer -> gl--vector - Makes a gl--vector of the given length -gl--vector: X ... -> gl--vector - Makes a gl--vector from the given arguments -vector->gl--vector: vector -> gl--vector - Converts a Scheme vector into the specified gl--vector -list->gl--vector: vector -> gl--vector - Converts a Scheme list into the specified gl--vector -gl--vector+: gl-vector ... -> gl-type-vector - Computes the element-by-element sum of the given gl-vectors and places the - result into a gl--vector -gl--vector-: gl-vector ... -> gl-type-vector - Computes the element-by-element difference of the given gl-vectors and - places the result into a gl--vector -gl--vector*: real-number gl-vector -> gl-type-vector - Multiplies each element of the given gl-vector by the given number and - places the result into a gl--vector - -Finally, the following functions are also provided. -gl-vector-norm: gl-vector -> real-number - Returns the square root of the sum of the squares of the elements of the - given gl-vector - -_sgl.ss_ - -Use the sgl.ss module by adding (require sgl/sgl) to your program. To get it -with all function names prefixed with "gl-" use (require sgl) (which is -actually sgl/main, reproviding everything from sgl.ss with the prefix). Or you -can also use (require (prefix sgl/sgl)) directly instead. The -sgl.ss module provides a more Scheme-like interface to the GL functions in -gl.ss. - -Functions in sgl.ss take symbols instead of integers for GLenum arguments. -Each function checks that the given symbol is an acceptable argument and -raises an exception if it is not. Given the name of a C-language #define -constant, determine the corresponding symbolic argument by removing the -leading "GL_", converting the letters to lower-case and replacing all -underscores with dashes. For example, GL_TRIANGLES becomes 'triangles and -GL_TRIANGLE_STRIP becomes 'triangle-strip. Additionally, the functions check -the length of any array arguments to ensure that GL does not attempt to write -or read after the array. - -The functions in sgl.ss use Scheme style names instead of C style names. To -convert a C GL name to a Scheme GL name, drop the leading "gl" (use the -require form to choose whatever prefix you desire, as above), separate -adjacent words with hyphens, and convert to all lower case. Functions that -have several variants to accommodate different numbers and types of arguments -are collapsed into one or two functions in sgl.ss. For example, sgl.ss -provides two vertex functions, vertex and vertex-v. The vertex function -accepts 2, 3 or 4 numerical arguments, and the vertex-v function accepts -gl-vectors of length 2, 3 or 4. The C language GL interface has 24 vertex -functions glVertex3i, glVertex4fv, etc. - - -The sgl.ss module is not yet complete and many functions from the gl module do -not yet have counterparts in the sgl.ss module. See the list of functions -below. - -Notational Example: -(require sgl sgl/gl-vectors) -(gl-begin 'triangles) -(gl-vertex 1 2 3) -(gl-vertex-v (gl-float-vector 1 2 3 4)) -(gl-end) - -See gears.ss in the examples subdirectory of the sgl collection -(${PLTHOME}/collects/sgl/examples/gears.ss) for a working example. Also see -the checkers game in ${PLTHOME}/collects/games/checkers/checkers.ss. - -sgl provides the following utility functions that have no OpenGL counterpart: - -process-selection: gl-uint-vector int -> (listof selection-record) -where a selection-record is defined by this exported struct: -(define-struct selection-record (min-z max-z stack)). -process-selection parses the contents of a gl-vector from the format used by -glSelectBuffer. The second argument should be the number of hits as returned -by glRenderMode. - -get-gl-version-number: -> int -Returns the version number as an integer: 10, 11, 12, 13, 14, 15, or 20. - -get-glu-version-number: -> int -Returns the version number as an integer: 10, 11, 12, or 13. - -_bitmap.ss_ - -The "bitmap.ss" library in the "sgl" collection provides a helper -function for converting a MrEd bitmap to a GL list: - -> (bitmap->gl-list bitmap #:with-gl with-gl-proc - #:mask bitmap) - -Converts the given bitmap (an instance of bitmap%) into a GL list that -can be rendered with `call-list' or `glCallList'. The rendered object -is a square on the z=0 plane with corners at (0,0) and (1,1). - -If `with-gl-proc' is provided, it must accept a thunk and call it -while the relevant GL context is selected. Otherwise, the relevant GL -context must be selected already. - -If `mask' is given, it is used as the mask bitmap (for extracting -alpha values). The default is the result of the `get-loaded-mask' -method of `bm'. - -================================================================= -Function indexes -================================================================= - ----------------------------- sgl.ss: ---------------------------- -(struct selection-record (min-z max-z stack)) -accum -active-texture -alpha-func -begin -begin-query -blend-color -blend-equation -blend-func -blend-func-separate -call-list -check-extension -clear -clear-accum -clear-color -clear-depth -clear-index -clear-stencil -clip-plane -color -color-mask -color-material -color-v -copy-pixels -cull-face -cylinder -delete-lists -delete-queries -depth-func -depth-mask -depth-range -disable -disk -edge-flag -enable -end -end-list -end-query -eval-coord -eval-coord-v -eval-mesh -eval-point -feedback-buffer->gl-float-vector -finish -flush -front-face -frustum -gen-lists -gen-queries -get-error -get-string -get-gl-version-number -get-glu-version-number -hint -index -index-mask -index-v -init-names -is-buffer -is-enabled -is-list -is-query -light -light-model -light-model-v -light-v -line-stipple -line-width -list-base -load-identity -load-matrix -load-name -load-transpose-matrix -look-at -map-grid -material -material-v -matrix-mode -mult-matrix -mult-transpose-matrix -multi-tex-coord -multi-tex-coord-v -new-list -new-quadric -normal -normal-v -ortho -ortho-2d -partial-disk -pass-through -perspective -pick-matrix -pixel-store -point-parameter -point-parameter-v -point-size -polygon-mode -polygon-offset -pop-attrib -pop-client-attrib -pop-matrix -pop-name -process-selection -project -push-matrix -push-name -quadric-draw-style -quadric-normals -quadric-orientation -quadric-texture -raster-pos -raster-pos-v -rect -rect-v -render-mode -rotate -sample-coverage -scale -scissor -secondary-color -secondary-color-v -select-buffer->gl-uint-vector -shade-model -sphere -stencil-func -stencil-mask -stencil-op -tex-coord -tex-coord-v -tex-gen -tex-gen-v -translate -u-get-string -un-project -un-project4 -vertex -vertex-v -viewport -window-pos -window-pos-v - ------------------------------ gl.ss: ----------------------------- -glAccum -glActiveTexture -glAlphaFunc -glAreTexturesResident *3 -glBegin -glBeginQuery -glBindTexture -glBitmap -glBlendColor -glBlendEquation -glBlendFunc -glBlendFuncSeparate -glCallList -glCallLists -glClear -glClearAccum -glClearColor -glClearDepth -glClearIndex -glClearStencil -glClipPlane -glColor3b -glColor3bv -glColor3d -glColor3dv -glColor3f -glColor3fv -glColor3i -glColor3iv -glColor3s -glColor3sv -glColor3ub -glColor3ubv -glColor3ui -glColor3uiv -glColor3us -glColor3usv -glColor4b -glColor4bv -glColor4d -glColor4dv -glColor4f -glColor4fv -glColor4i -glColor4iv -glColor4s -glColor4sv -glColor4ub -glColor4ubv -glColor4ui -glColor4uiv -glColor4us -glColor4usv -glColorMask -glColorMaterial -glColorSubTable -glColorTable -glColorTableParameterfv -glColorTableParameteriv -glCompressedTexImage1D -glCompressedTexImage2D -glCompressedTexImage3D -glCompressedTexSubImage1D -glCompressedTexSubImage2D -glCompressedTexSubImage3D -glConvolutionFilter1D -glConvolutionFilter2D -glConvolutionParameterf -glConvolutionParameterfv -glConvolutionParameteri -glConvolutionParameteriv -glCopyColorSubTable -glCopyColorTable -glCopyConvolutionFilter1D -glCopyConvolutionFilter2D -glCopyPixels -glCopyTexImage1D -glCopyTexImage2D -glCopyTexSubImage1D -glCopyTexSubImage2D -glCopyTexSubImage3D -glCullFace -glDeleteLists -glDeleteQueries *1 -glDeleteTextures *1 -glDepthFunc -glDepthMask -glDepthRange -glDisable -glDrawBuffer -glDrawPixels -glEdgeFlag -glEdgeFlagv -glEnable -glEnd -glEndList -glEndQuery -glEvalCoord1d -glEvalCoord1dv -glEvalCoord1f -glEvalCoord1fv -glEvalCoord2d -glEvalCoord2dv -glEvalCoord2f -glEvalCoord2fv -glEvalMesh1 -glEvalMesh2 -glEvalPoint1 -glEvalPoint2 -glFeedbackBuffer *8 -glFinish -glFlush -glFogCoordd -glFogCoorddv -glFogCoordf -glFogCoordfv -glFogf -glFogfv -glFogi -glFogiv -glFrontFace -glFrustum -glGenLists -glGenQueries *2 -glGenTextures *2 -glGetBooleanv *4 -glGetBufferParameteriv *4 -glGetClipPlane *5 -glGetColorTable -glGetCompressedTexImage -glGetConvolutionFilter -glGetConvolutionParameterfv *4 -glGetConvolutionParameteriv *4 -glGetDoublev *4 -glGetError -glGetFloatv *4 -glGetHistogram -glGetHistogramParameterfv *4 -glGetHistogramParameteriv *4 -glGetIntegerv *4 -glGetLightfv *5 -glGetLightiv *5 -glGetMapdv *4 -glGetMapfv *4 -glGetMapiv *4 -glGetMaterialfv *4 -glGetMaterialiv *4 -glGetMinmax -glGetMinmaxParameterfv *4 -glGetMinmaxParameteriv *4 -glGetPixelMapfv *4 -glGetPixelMapuiv *4 -glGetPixelMapusv *4 -glGetPolygonStipple -glGetQueryObjectiv *4 -glGetQueryObjectuiv *4 -glGetQueryiv *4 -glGetSeparableFilter -glGetString *6 -glGetTexEnvfv *4 -glGetTexEnviv *4 -glGetTexGendv *4 -glGetTexGenfv *4 -glGetTexGeniv *4 -glGetTexImage -glGetTexLevelParameterfv *4 -glGetTexLevelParameteriv *4 -glGetTexParameterfv *4 -glGetTexParameteriv *4 -glHint -glHistogram -glIndexMask -glIndexd -glIndexdv -glIndexf -glIndexfv -glIndexi -glIndexiv -glIndexs -glIndexsv -glIndexub -glIndexubv -glInitNames -glIsBuffer -glIsEnabled -glIsList -glIsQuery -glIsTexture -glLightModelf -glLightModelfv -glLightModeli -glLightModeliv -glLightf -glLightfv -glLighti -glLightiv -glLineStipple -glLineWidth -glListBase -glLoadIdentity -glLoadMatrixd -glLoadMatrixf -glLoadName -glLoadTransposeMatrixd -glLoadTransposeMatrixf -glLogicOp -glMap1d -glMap1f -glMap2d -glMap2f -glMapGrid1d -glMapGrid1f -glMapGrid2d -glMapGrid2f -glMaterialf -glMaterialfv -glMateriali -glMaterialiv -glMatrixMode -glMinmax -glMultMatrixd -glMultMatrixf -glMultTransposeMatrixd -glMultTransposeMatrixf -glMultiTexCoord1d -glMultiTexCoord1dv -glMultiTexCoord1f -glMultiTexCoord1fv -glMultiTexCoord1i -glMultiTexCoord1iv -glMultiTexCoord1s -glMultiTexCoord1sv -glMultiTexCoord2d -glMultiTexCoord2dv -glMultiTexCoord2f -glMultiTexCoord2fv -glMultiTexCoord2i -glMultiTexCoord2iv -glMultiTexCoord2s -glMultiTexCoord2sv -glMultiTexCoord3d -glMultiTexCoord3dv -glMultiTexCoord3f -glMultiTexCoord3fv -glMultiTexCoord3i -glMultiTexCoord3iv -glMultiTexCoord3s -glMultiTexCoord3sv -glMultiTexCoord4d -glMultiTexCoord4dv -glMultiTexCoord4f -glMultiTexCoord4fv -glMultiTexCoord4i -glMultiTexCoord4iv -glMultiTexCoord4s -glMultiTexCoord4sv -glNewList -glNormal3b -glNormal3bv -glNormal3d -glNormal3dv -glNormal3f -glNormal3fv -glNormal3i -glNormal3iv -glNormal3s -glNormal3sv -glOrtho -glPassThrough -glPixelMapfv *1 -glPixelMapuiv *1 -glPixelMapusv *1 -glPixelStoref -glPixelStorei -glPixelTransferf -glPixelTransferi -glPixelZoom -glPointParameterf -glPointParameterfv -glPointParameteri -glPointParameteriv -glPointSize -glPolygonMode -glPolygonOffset -glPolygonStipple -glPopAttrib -glPopClientAttrib -glPopMatrix -glPopName -glPushAttrib -glPushClientAttrib -glPushMatrix -glPushName -glRasterPos2d -glRasterPos2dv -glRasterPos2f -glRasterPos2fv -glRasterPos2i -glRasterPos2iv -glRasterPos2s -glRasterPos2sv -glRasterPos3d -glRasterPos3dv -glRasterPos3f -glRasterPos3fv -glRasterPos3i -glRasterPos3iv -glRasterPos3s -glRasterPos3sv -glRasterPos4d -glRasterPos4dv -glRasterPos4f -glRasterPos4fv -glRasterPos4i -glRasterPos4iv -glRasterPos4s -glRasterPos4sv -glReadBuffer -glReadPixels -glRectd -glRectdv -glRectf -glRectfv -glRecti -glRectiv -glRects -glRectsv -glRenderMode -glResetHistogram -glResetMinmax -glRotated -glRotatef -glSampleCoverage -glScaled -glScalef -glScissor -glSecondaryColor3b -glSecondaryColor3bv -glSecondaryColor3d -glSecondaryColor3dv -glSecondaryColor3f -glSecondaryColor3fv -glSecondaryColor3i -glSecondaryColor3iv -glSecondaryColor3s -glSecondaryColor3sv -glSecondaryColor3ub -glSecondaryColor3ubv -glSecondaryColor3ui -glSecondaryColor3uiv -glSecondaryColor3us -glSecondaryColor3usv -glSelectBuffer *8 -glSeparableFilter2D -glShadeModel -glStencilFunc -glStencilMask -glStencilOp -glTexCoord1d -glTexCoord1dv -glTexCoord1f -glTexCoord1fv -glTexCoord1i -glTexCoord1iv -glTexCoord1s -glTexCoord1sv -glTexCoord2d -glTexCoord2dv -glTexCoord2f -glTexCoord2fv -glTexCoord2i -glTexCoord2iv -glTexCoord2s -glTexCoord2sv -glTexCoord3d -glTexCoord3dv -glTexCoord3f -glTexCoord3fv -glTexCoord3i -glTexCoord3iv -glTexCoord3s -glTexCoord3sv -glTexCoord4d -glTexCoord4dv -glTexCoord4f -glTexCoord4fv -glTexCoord4i -glTexCoord4iv -glTexCoord4s -glTexCoord4sv -glTexEnvf -glTexEnvfv -glTexEnvi -glTexEnviv -glTexGend -glTexGendv -glTexGenf -glTexGenfv -glTexGeni -glTexGeniv -glTexImage1D -glTexImage2D -glTexImage3D -glTexParameterf -glTexParameterfv -glTexParameteri -glTexParameteriv -glTexSubImage1D -glTexSubImage2D -glTexSubImage3D -glTranslated -glTranslatef -glVertex2d -glVertex2dv -glVertex2f -glVertex2fv -glVertex2i -glVertex2iv -glVertex2s -glVertex2sv -glVertex3d -glVertex3dv -glVertex3f -glVertex3fv -glVertex3i -glVertex3iv -glVertex3s -glVertex3sv -glVertex4d -glVertex4dv -glVertex4f -glVertex4fv -glVertex4i -glVertex4iv -glVertex4s -glVertex4sv -glViewport -glWindowPos2d -glWindowPos2dv -glWindowPos2f -glWindowPos2fv -glWindowPos2i -glWindowPos2iv -glWindowPos2s -glWindowPos2sv -glWindowPos3d -glWindowPos3dv -glWindowPos3f -glWindowPos3fv -glWindowPos3i -glWindowPos3iv -glWindowPos3s -glWindowPos3sv -gluBuild1DMipmapLevels -gluBuild1DMipmaps -gluBuild2DMipmapLevels -gluBuild2DMipmaps -gluBuild3DMipmapLevels -gluBuild3DMipmaps -gluCheckExtension *6 -gluCylinder -gluDisk -gluErrorString *6 -gluGetString *6 -gluLookAt -gluNewQuadric -gluOrtho2D -gluPartialDisk -gluPerspective -gluPickMatrix -gluProject *7 -gluQuadricDrawStyle -gluQuadricNormals -gluQuadricOrientation -gluQuadricTexture -gluScaleImage -gluSphere -gluUnProject *7 -gluUnProject4 *7 diff --git a/collects/sgl/gl.ss b/collects/sgl/gl.ss index de859755c4..246f4b8a9e 100644 --- a/collects/sgl/gl.ss +++ b/collects/sgl/gl.ss @@ -13,6 +13,10 @@ [(macosx) (ffi-lib "/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGLU")] [else (ffi-lib "libGLU")])) + (define (unavailable name) + (lambda x + (error 'name "unavailable on this system"))) + (define-syntax define-foreign-lib (syntax-rules (->) ((_ lib name type ... ->) @@ -22,10 +26,7 @@ ;(printf "~a~n" 'name) (provide name) (define name - (get-ffi-obj 'name lib (_fun type ...) - (lambda () - (lambda x - (error 'name "unavailable on this system"))))))))) + (get-ffi-obj 'name lib (_fun type ...) (unavailable 'name))))))) (define-syntax define-foreign (syntax-rules () diff --git a/collects/sgl/info.ss b/collects/sgl/info.ss index 5b64a3e521..cdcbbdab56 100644 --- a/collects/sgl/info.ss +++ b/collects/sgl/info.ss @@ -5,3 +5,5 @@ (define clean (list (build-path "compiled" "native" (system-library-subpath)) "compiled")) (define compile-omit-paths '("examples")) + +(define scribblings '(("scribblings/sgl.scrbl" (multi-page)))) diff --git a/collects/sgl/scribblings/bitmap.scrbl b/collects/sgl/scribblings/bitmap.scrbl new file mode 100644 index 0000000000..a016b1e879 --- /dev/null +++ b/collects/sgl/scribblings/bitmap.scrbl @@ -0,0 +1,28 @@ +#lang scribble/doc +@(require "common.ss" + (for-label scheme/class)) + +@title[#:tag "bitmaps"]{Bitmaps} + +@defmodule[sgl/bitmap] + + +@defproc[(bitmap->gl-list [bitmap (is-a?/c bitmap%)] + [#:with-gl with-gl-proc ((-> any) . -> . any) + (lambda (f) (f))] + [#:mask mask (or/c (is-a?/c bitmap%) false/c) + (send bitmap get-loaded-mask)]) + exact-integer?]{ + +Converts the given bitmap into an OpenGL list that can be rendered +with @scheme[gl-call-list] or @scheme[glCallList]. The rendered object +is a square on the @math{z=0} plane with corners at @math{(0,0)} and +@math{(1,1)}. + +The @scheme[with-gl-proc] must accept a thunk and call it while the +relevant OpenGL context is selected. Otherwise, the relevant OpenGL +context must be selected already. + +If @scheme[mask] is not @scheme[#f], it is used as the mask bitmap for +extracting alpha values.} + diff --git a/collects/sgl/scribblings/common.ss b/collects/sgl/scribblings/common.ss new file mode 100644 index 0000000000..66c5178efb --- /dev/null +++ b/collects/sgl/scribblings/common.ss @@ -0,0 +1,20 @@ +#lang scheme/base + + +(require scribble/manual + scribble/bnf + (for-label scheme/base + scheme/contract + scheme/gui/base + (except-in scheme/foreign ->) + sgl + sgl/gl + sgl/gl-vectors)) +(provide (all-from-out scribble/manual) + (for-label (all-from-out scheme/base + scheme/contract + scheme/gui/base + scheme/foreign + sgl + sgl/gl + sgl/gl-vectors))) diff --git a/collects/sgl/scribblings/gl-vectors.scrbl b/collects/sgl/scribblings/gl-vectors.scrbl new file mode 100644 index 0000000000..2dab8fb456 --- /dev/null +++ b/collects/sgl/scribblings/gl-vectors.scrbl @@ -0,0 +1,88 @@ +#lang scribble/doc +@(require "common.ss" + scribble/bnf + (for-syntax scheme/base)) + +@title[#:tag "gl-vectors"]{OpenGL Vectors} + +@defmodule[sgl/gl-vectors] + +The @schememodname[sgl/gl-vectors] module supports OpenGL programming +with @scheme[cvector]s. In this document and in the error messages, a +``gl-vector'' is just a @scheme[cvector], while a +``gl-@nonterm{type}-vector'' is a @scheme[cvector] with an appropriate +type. Using the @schememodname[sgl/gl-vectors] module instead of using +@scheme[cvector] directly because these functions are specialized to +handling the OpenGL types correctly. + +@deftogether[( +@defproc[(gl-vector? [v any/c]) boolean?] +@defproc[(gl-vector->vector [vec cvector?]) vector?] +@defproc[(gl-vector->list [vec cvector?]) list?] +@defproc[(gl-vector-length [vec cvector?]) exact-nonnegative-integer?] +@defproc[(gl-vector-ref [vec cvector?][pos exact-nonnegative-integer?]) any/v] +@defproc[(gl-vector-set! [vec cvector?][pos exact-nonnegative-integer?][v any/v]) void?] +)]{ + +Synonyms for @scheme[cvector?], @scheme[cvector->vector], @scheme[cvector-length], etc.} + +@(define-syntax (define-gl-vector stx) + (syntax-case stx () + [(_ type) + (let ([mk (lambda s + (string->symbol (apply string-append s)))] + [type (symbol->string (syntax-e #'type))] + [locs (lambda (l) + (datum->syntax #'here + (list + (datum->syntax #'here + (car l) + #("?" 1 1 2 1)) + (datum->syntax #'here + (car l) + #("?" 1 3 4 1))) + #("?" 1 0 1 3)))]) + (with-syntax ([ (mk type)] + [? (mk type "?")] + [gl--vector? (mk "gl-" type "-vector?")] + [gl--vector (mk "gl-" type "-vector")] + [make-gl--vector (mk "make-gl-" type "-vector")] + [vector->gl--vector (mk "vector->gl-" type "-vector")] + [list->gl--vector (mk "list->gl-" type "-vector")] + [gl--vector+ (mk "gl-" type "-vector+")] + [gl--vector- (mk "gl-" type "-vector-")] + [gl--vector* (mk "gl-" type "-vector*")] + [vectorof-? (locs `(vectorof ,(mk type "?")))] + [listof-? (locs `(listof ,(mk type "?")))]) + #'(... + @deftogether[( + @defproc[(gl--vector? [v any/c]) boolean?] + @defproc[(make-gl--vector [pos exact-nonnegative-integer?]) gl--vector?] + @defproc[(gl--vector [v ?] ...) gl--vector?] + @defproc[(vector->gl--vector [v vectorof-?] ...) gl--vector?] + @defproc[(list->gl--vector [v listof-?] ...) gl--vector?] + @defproc[(gl--vector+ [vec gl--vector?] ...+) gl--vector?] + @defproc[(gl--vector- [vec gl--vector?] ...+) gl--vector?] + @defproc[(gl--vector* [x real?][vec gl--vector?]) gl--vector?] + )]{ + + Operations on vectors of @scheme[] elements. The @scheme[gl--vector+] + and @scheme[gl--vector-] functions compute the element-by-element sum and + difference of the given vectors, respectively. The @scheme[gl--vector*] function + multiplies each element of @scheme[vec] by @scheme[x].})))])) + +@(define-gl-vector byte) +@(define-gl-vector ubyte) +@(define-gl-vector short) +@(define-gl-vector ushort) +@(define-gl-vector int) +@(define-gl-vector uint) +@(define-gl-vector float) +@(define-gl-vector double) +@(define-gl-vector boolean) + +@defproc[(gl-vector-norm [vec gl-vector?]) real?]{ + +Returns the square root of the sum of the squares of the elements +of @scheme[vec].} + diff --git a/collects/sgl/scribblings/gl.scrbl b/collects/sgl/scribblings/gl.scrbl new file mode 100644 index 0000000000..272eedb08e --- /dev/null +++ b/collects/sgl/scribblings/gl.scrbl @@ -0,0 +1,1641 @@ +#lang scribble/doc +@(require "common.ss" + scribble/bnf + scribble/eval + (for-syntax scheme/base)) + +@title[#:tag "gl"]{C-Style OpenGL} + +@defmodule[sgl/gl] + +The @schememodname[sgl/gl] module provides a direct interface to the +system's GL library closely following the conventions of the +C-language OpenGL API. It provides a binding for each @tt{#defined} +constant (these start with @schemeidfont{GL_}) and for the functions +in the GL 1.5 and GLU 1.3 specifications, except for the following: + +@itemize[#:style "compact" + @item{Vertex arrays (GL 1.5, Section 2.8)} + @item{Buffer objects (GL 1.5, Section 2.9)} + @item{@tt{glGetPointerv} (GL 1.5, Section 6.1.11)} + @item{Buffer object queries (GL 1.5, Section 6.1.13)} + @item{Polygon tessellation (GLU 1.3, Section 5)} + @item{@tt{gluQuadricCallback} (GLU 1.3, Section 6.2)} + @item{NURBS (GLU 1.3, Section 7)} +] + +If one of the provided functions is not present on your system +(e.g. if your system supports only GL 1.3), then the corresponding +@schememodname[sgl/gl] function raises a run-time exception when +invoked. + +The functions provided by @schememodname[sgl/gl] perform comparable +checking to their C-language counterparts; they check the types of +their arguments, but do not check the length of array arguments. The +following details the kinds of Scheme values that can be provided for +each primitive OpenGL type: + +@itemize[ + + @item{@as-index{@tt{GLbyte}}, + @as-index{@tt{GLshort}}, + @as-index{@tt{GLint}}: + exact integer in the proper range} + + @item{@as-index{@tt{GLubyte}}, + @as-index{@tt{GLushort}}, + @as-index{@tt{GLuint}}: + exact non-negative integer in the proper range} + + @item{@as-index{@tt{GLsizei}}, + @as-index{@tt{GLenum}}, + @as-index{@tt{GLbitfield}}: + exact non-negative integer in the proper range} + + @item{@as-index{@tt{GFfloat}}, + @as-index{@tt{GLdouble}}: + real number} + + @item{@as-index{@tt{GFclampf}}, + @as-index{@tt{GLclampd}}: + real number} + + @item{@as-index{@tt{GLboolean}}: any value, where @scheme[#f] means + @as-index{@tt{GL_FALSE}} and all other values mean + @as-index{@tt{GL_TRUE}}; do not use @scheme[GL_FALSE] or + @scheme[GL_TRUE], since they are bound to integers, both will + end up being converted to GL_TRUE.} + +] + +OpenGL functions that take vector arguments accept @scheme[cvector] +values. The type of the @scheme[cvector] is checked; for example, +@tt{glVertex3fv} expects a vector of @tt{GLfloats}, so +@scheme[glVertex3fv] accepts only a @scheme[cvector] containing reals. +See also @schememodname[sgl/gl-vectors]. Functions that accept arrays +of type @tt{void*} accept any @scheme[cvector]; you must ensure that +you supply the proper kind of vector, as in the C-language OpenGL API. + +@as-examples[ +@schemeblock[ +(require sgl/gl + sgl/gl-vectors) +(glBegin GL_TRIANGLES) +(glVertex3i 1 2 3) +(glVertex4fv (gl-float-vector 1 2 3 4)) +(glEnd) +]] + +@(define-syntax-rule (def-C-gl (id ...) body ...) + @deftogether[( + @defthing[id procedure?] ... + ) body ...]) + +@def-C-gl[( + glPixelMapfv + glPixelMapuiv + glPixelMapusv + glDeleteTextures + glDeleteQueries +)]{ + +These functions do not take a size argument, because it is derived +from the length of the argument vector.} + +@def-C-gl[( + glGenTextures + glGenQueries +)]{ + +These functions do not take vector arguments. Instead, they allocate +a vector of the requested size and return it.} + +@def-C-gl[( + glAreTexturesResident +)]{ + +This function takes in a @tt{GLuint} vector and textures, and it +returns 2 values: the specified boolean and a boolean vector of +residences.} + +@def-C-gl[( + glGetBooleanv + glGetIntegerv + glGetFloatv + glGetDoublev + glGetLightfv + glGetLightiv + glGetMaterialfv + glGetMaterialiv + glGetTexEnvfv + glGetTexEnviv + glGetTexGendv + glGetTexGenfv + glGetTexGeniv + glGetTexParameterfv + glGetTexParameteriv + glGetTexLevelParameterfv + glGetTexLevelParameteriv + glGetPixelMapfv + glGetPixelMapuiv + glGetPixelMapusv + glGetMapdv + glGetMapfv + glGetMapiv + glGetBufferParameteriv + glGetConvolutionParameterfv + glGetConvolutionParameteriv + glGetHistogramParameterfv + glGetHistogramParameteriv + glGetMinmaxParameterfv + glGetMinmaxParameteriv + glGetQueryiv + glGetQueryObjectiv + glGetQueryObjectuiv +)]{ + +Instead of taking a vector argument, these function take an integer argument +that specifies the size of the vector that is returned.} + +@def-C-gl[( + glGetClipPlane +)]{ + +This function does not take a vector argument and returns a @tt{GLdouble} vector of +length 4.} + +@def-C-gl[( + glGetString + gluCheckExtension + gluErrorString + gluGetString +)]{ +These functions deal with strings instead of @tt{GLubyte} vectors.} + +@def-C-gl[( + gluProject + gluUnProject + gluUnProject4 +)]{ + +Instead of taking pointers to @tt{GLdoubles} for return values, these +function directly return @tt{GLdouble} vectors.} + +@def-C-gl[( + glSelectBuffer + glFeedbackBuffer +)]{ + +These functions do not take vectors, instead they return a +@scheme[selection-buffer-object] or @scheme[feedback-buffer-object]. +The @scheme[select-buffer->gl-uint-vector] and +@scheme[feedback-buffer->gl-float-vector] functions copy the contents +of the buffer into a vector. Because the OpenGL library writes to the +buffer-object on OpenGL function calls after @tt{glSelectBuffer} or +@tt{glFeedbackBuffer} has returned, if the buffer is garbage collected +before OpenGL is finished writing to it, the entire Scheme system can +crash. The @scheme[gl-process-selection] function in +@schememodname[sgl] helps interpret the results of @tt{glSelectBuffer} +in a Scheme-friendly format.} + +@def-C-gl[( +glAccum +glActiveTexture +glAlphaFunc +glBegin +glBeginQuery +glBindTexture +glBitmap +glBlendColor +glBlendEquation +glBlendFunc +glBlendFuncSeparate +glCallList +glCallLists +glClear +glClearAccum +glClearColor +glClearDepth +glClearIndex +glClearStencil +glClipPlane +glColor3b +glColor3bv +glColor3d +glColor3dv +glColor3f +glColor3fv +glColor3i +glColor3iv +glColor3s +glColor3sv +glColor3ub +glColor3ubv +glColor3ui +glColor3uiv +glColor3us +glColor3usv +glColor4b +glColor4bv +glColor4d +glColor4dv +glColor4f +glColor4fv +glColor4i +glColor4iv +glColor4s +glColor4sv +glColor4ub +glColor4ubv +glColor4ui +glColor4uiv +glColor4us +glColor4usv +glColorMask +glColorMaterial +glColorSubTable +glColorTable +glColorTableParameterfv +glColorTableParameteriv +glCompressedTexImage1D +glCompressedTexImage2D +glCompressedTexImage3D +glCompressedTexSubImage1D +glCompressedTexSubImage2D +glCompressedTexSubImage3D +glConvolutionFilter1D +glConvolutionFilter2D +glConvolutionParameterf +glConvolutionParameterfv +glConvolutionParameteri +glConvolutionParameteriv +glCopyColorSubTable +glCopyColorTable +glCopyConvolutionFilter1D +glCopyConvolutionFilter2D +glCopyPixels +glCopyTexImage1D +glCopyTexImage2D +glCopyTexSubImage1D +glCopyTexSubImage2D +glCopyTexSubImage3D +glCullFace +glDeleteLists +glDepthFunc +glDepthMask +glDepthRange +glDisable +glDrawBuffer +glDrawPixels +glEdgeFlag +glEdgeFlagv +glEnable +glEnd +glEndList +glEndQuery +glEvalCoord1d +glEvalCoord1dv +glEvalCoord1f +glEvalCoord1fv +glEvalCoord2d +glEvalCoord2dv +glEvalCoord2f +glEvalCoord2fv +glEvalMesh1 +glEvalMesh2 +glEvalPoint1 +glEvalPoint2 +glFinish +glFlush +glFogCoordd +glFogCoorddv +glFogCoordf +glFogCoordfv +glFogf +glFogfv +glFogi +glFogiv +glFrontFace +glFrustum +glGenLists +glGetColorTable +glGetCompressedTexImage +glGetConvolutionFilter +glGetError +glGetHistogram +glGetMinmax +glGetPolygonStipple +glGetSeparableFilter +glGetTexImage +glHint +glHistogram +glIndexMask +glIndexd +glIndexdv +glIndexf +glIndexfv +glIndexi +glIndexiv +glIndexs +glIndexsv +glIndexub +glIndexubv +glInitNames +glIsBuffer +glIsEnabled +glIsList +glIsQuery +glIsTexture +glLightModelf +glLightModelfv +glLightModeli +glLightModeliv +glLightf +glLightfv +glLighti +glLightiv +glLineStipple +glLineWidth +glListBase +glLoadIdentity +glLoadMatrixd +glLoadMatrixf +glLoadName +glLoadTransposeMatrixd +glLoadTransposeMatrixf +glLogicOp +glMap1d +glMap1f +glMap2d +glMap2f +glMapGrid1d +glMapGrid1f +glMapGrid2d +glMapGrid2f +glMaterialf +glMaterialfv +glMateriali +glMaterialiv +glMatrixMode +glMinmax +glMultMatrixd +glMultMatrixf +glMultTransposeMatrixd +glMultTransposeMatrixf +glMultiTexCoord1d +glMultiTexCoord1dv +glMultiTexCoord1f +glMultiTexCoord1fv +glMultiTexCoord1i +glMultiTexCoord1iv +glMultiTexCoord1s +glMultiTexCoord1sv +glMultiTexCoord2d +glMultiTexCoord2dv +glMultiTexCoord2f +glMultiTexCoord2fv +glMultiTexCoord2i +glMultiTexCoord2iv +glMultiTexCoord2s +glMultiTexCoord2sv +glMultiTexCoord3d +glMultiTexCoord3dv +glMultiTexCoord3f +glMultiTexCoord3fv +glMultiTexCoord3i +glMultiTexCoord3iv +glMultiTexCoord3s +glMultiTexCoord3sv +glMultiTexCoord4d +glMultiTexCoord4dv +glMultiTexCoord4f +glMultiTexCoord4fv +glMultiTexCoord4i +glMultiTexCoord4iv +glMultiTexCoord4s +glMultiTexCoord4sv +glNewList +glNormal3b +glNormal3bv +glNormal3d +glNormal3dv +glNormal3f +glNormal3fv +glNormal3i +glNormal3iv +glNormal3s +glNormal3sv +glOrtho +glPassThrough +glPixelStoref +glPixelStorei +glPixelTransferf +glPixelTransferi +glPixelZoom +glPointParameterf +glPointParameterfv +glPointParameteri +glPointParameteriv +glPointSize +glPolygonMode +glPolygonOffset +glPolygonStipple +glPopAttrib +glPopClientAttrib +glPopMatrix +glPopName +glPushAttrib +glPushClientAttrib +glPushMatrix +glPushName +glRasterPos2d +glRasterPos2dv +glRasterPos2f +glRasterPos2fv +glRasterPos2i +glRasterPos2iv +glRasterPos2s +glRasterPos2sv +glRasterPos3d +glRasterPos3dv +glRasterPos3f +glRasterPos3fv +glRasterPos3i +glRasterPos3iv +glRasterPos3s +glRasterPos3sv +glRasterPos4d +glRasterPos4dv +glRasterPos4f +glRasterPos4fv +glRasterPos4i +glRasterPos4iv +glRasterPos4s +glRasterPos4sv +glReadBuffer +glReadPixels +glRectd +glRectdv +glRectf +glRectfv +glRecti +glRectiv +glRects +glRectsv +glRenderMode +glResetHistogram +glResetMinmax +glRotated +glRotatef +glSampleCoverage +glScaled +glScalef +glScissor +glSecondaryColor3b +glSecondaryColor3bv +glSecondaryColor3d +glSecondaryColor3dv +glSecondaryColor3f +glSecondaryColor3fv +glSecondaryColor3i +glSecondaryColor3iv +glSecondaryColor3s +glSecondaryColor3sv +glSecondaryColor3ub +glSecondaryColor3ubv +glSecondaryColor3ui +glSecondaryColor3uiv +glSecondaryColor3us +glSecondaryColor3usv +glSeparableFilter2D +glShadeModel +glStencilFunc +glStencilMask +glStencilOp +glTexCoord1d +glTexCoord1dv +glTexCoord1f +glTexCoord1fv +glTexCoord1i +glTexCoord1iv +glTexCoord1s +glTexCoord1sv +glTexCoord2d +glTexCoord2dv +glTexCoord2f +glTexCoord2fv +glTexCoord2i +glTexCoord2iv +glTexCoord2s +glTexCoord2sv +glTexCoord3d +glTexCoord3dv +glTexCoord3f +glTexCoord3fv +glTexCoord3i +glTexCoord3iv +glTexCoord3s +glTexCoord3sv +glTexCoord4d +glTexCoord4dv +glTexCoord4f +glTexCoord4fv +glTexCoord4i +glTexCoord4iv +glTexCoord4s +glTexCoord4sv +glTexEnvf +glTexEnvfv +glTexEnvi +glTexEnviv +glTexGend +glTexGendv +glTexGenf +glTexGenfv +glTexGeni +glTexGeniv +glTexImage1D +glTexImage2D +glTexImage3D +glTexParameterf +glTexParameterfv +glTexParameteri +glTexParameteriv +glTexSubImage1D +glTexSubImage2D +glTexSubImage3D +glTranslated +glTranslatef +glVertex2d +glVertex2dv +glVertex2f +glVertex2fv +glVertex2i +glVertex2iv +glVertex2s +glVertex2sv +glVertex3d +glVertex3dv +glVertex3f +glVertex3fv +glVertex3i +glVertex3iv +glVertex3s +glVertex3sv +glVertex4d +glVertex4dv +glVertex4f +glVertex4fv +glVertex4i +glVertex4iv +glVertex4s +glVertex4sv +glViewport +glWindowPos2d +glWindowPos2dv +glWindowPos2f +glWindowPos2fv +glWindowPos2i +glWindowPos2iv +glWindowPos2s +glWindowPos2sv +glWindowPos3d +glWindowPos3dv +glWindowPos3f +glWindowPos3fv +glWindowPos3i +glWindowPos3iv +glWindowPos3s +glWindowPos3sv +gluBuild1DMipmapLevels +gluBuild1DMipmaps +gluBuild2DMipmapLevels +gluBuild2DMipmaps +gluBuild3DMipmapLevels +gluBuild3DMipmaps +gluCylinder +gluDisk +gluLookAt +gluNewQuadric +gluOrtho2D +gluPartialDisk +gluPerspective +gluPickMatrix +gluQuadricDrawStyle +gluQuadricNormals +gluQuadricOrientation +gluQuadricTexture +gluScaleImage +gluSphere +)]{ + +These functions are all direct translations of the C OpenGL API.} + +@(define-syntax def-one-thing + (syntax-rules () + [(_ [id pred]) @defthing[id pred]] + [(_ id) @defthing[id exact-integer?]])) + +@(define-syntax-rule (def-C-const (decl ...) body ...) + @deftogether[( + @def-one-thing[decl] ... + ) body ...]) + +@def-C-const[( + GL_FALSE + GL_TRUE + GL_BYTE + GL_UNSIGNED_BYTE + GL_SHORT + GL_UNSIGNED_SHORT + GL_INT + GL_UNSIGNED_INT + GL_FLOAT + GL_DOUBLE + GL_2_BYTES + GL_3_BYTES + GL_4_BYTES + GL_POINTS + GL_LINES + GL_LINE_LOOP + GL_LINE_STRIP + GL_TRIANGLES + GL_TRIANGLE_STRIP + GL_TRIANGLE_FAN + GL_QUADS + GL_QUAD_STRIP + GL_POLYGON + GL_VERTEX_ARRAY + GL_NORMAL_ARRAY + GL_COLOR_ARRAY + GL_INDEX_ARRAY + GL_TEXTURE_COORD_ARRAY + GL_EDGE_FLAG_ARRAY + GL_VERTEX_ARRAY_SIZE + GL_VERTEX_ARRAY_TYPE + GL_VERTEX_ARRAY_STRIDE + GL_NORMAL_ARRAY_TYPE + GL_NORMAL_ARRAY_STRIDE + GL_COLOR_ARRAY_SIZE + GL_COLOR_ARRAY_TYPE + GL_COLOR_ARRAY_STRIDE + GL_INDEX_ARRAY_TYPE + GL_INDEX_ARRAY_STRIDE + GL_TEXTURE_COORD_ARRAY_SIZE + GL_TEXTURE_COORD_ARRAY_TYPE + GL_TEXTURE_COORD_ARRAY_STRIDE + GL_EDGE_FLAG_ARRAY_STRIDE + GL_VERTEX_ARRAY_POINTER + GL_NORMAL_ARRAY_POINTER + GL_COLOR_ARRAY_POINTER + GL_INDEX_ARRAY_POINTER + GL_TEXTURE_COORD_ARRAY_POINTER + GL_EDGE_FLAG_ARRAY_POINTER + GL_V2F + GL_V3F + GL_C4UB_V2F + GL_C4UB_V3F + GL_C3F_V3F + GL_N3F_V3F + GL_C4F_N3F_V3F + GL_T2F_V3F + GL_T4F_V4F + GL_T2F_C4UB_V3F + GL_T2F_C3F_V3F + GL_T2F_N3F_V3F + GL_T2F_C4F_N3F_V3F + GL_T4F_C4F_N3F_V4F + GL_MATRIX_MODE + GL_MODELVIEW + GL_PROJECTION + GL_TEXTURE + GL_POINT_SMOOTH + GL_POINT_SIZE + GL_POINT_SIZE_GRANULARITY + GL_POINT_SIZE_RANGE + GL_LINE_SMOOTH + GL_LINE_STIPPLE + GL_LINE_STIPPLE_PATTERN + GL_LINE_STIPPLE_REPEAT + GL_LINE_WIDTH + GL_LINE_WIDTH_GRANULARITY + GL_LINE_WIDTH_RANGE + GL_POINT + GL_LINE + GL_FILL + GL_CW + GL_CCW + GL_FRONT + GL_BACK + GL_POLYGON_MODE + GL_POLYGON_SMOOTH + GL_POLYGON_STIPPLE + GL_EDGE_FLAG + GL_CULL_FACE + GL_CULL_FACE_MODE + GL_FRONT_FACE + GL_POLYGON_OFFSET_FACTOR + GL_POLYGON_OFFSET_UNITS + GL_POLYGON_OFFSET_POINT + GL_POLYGON_OFFSET_LINE + GL_POLYGON_OFFSET_FILL + GL_COMPILE + GL_COMPILE_AND_EXECUTE + GL_LIST_BASE + GL_LIST_INDEX + GL_LIST_MODE + GL_NEVER + GL_LESS + GL_EQUAL + GL_LEQUAL + GL_GREATER + GL_NOTEQUAL + GL_GEQUAL + GL_ALWAYS + GL_DEPTH_TEST + GL_DEPTH_BITS + GL_DEPTH_CLEAR_VALUE + GL_DEPTH_FUNC + GL_DEPTH_RANGE + GL_DEPTH_WRITEMASK + GL_DEPTH_COMPONENT + GL_LIGHTING + GL_LIGHT0 + GL_LIGHT1 + GL_LIGHT2 + GL_LIGHT3 + GL_LIGHT4 + GL_LIGHT5 + GL_LIGHT6 + GL_LIGHT7 + GL_SPOT_EXPONENT + GL_SPOT_CUTOFF + GL_CONSTANT_ATTENUATION + GL_LINEAR_ATTENUATION + GL_QUADRATIC_ATTENUATION + GL_AMBIENT + GL_DIFFUSE + GL_SPECULAR + GL_SHININESS + GL_EMISSION + GL_POSITION + GL_SPOT_DIRECTION + GL_AMBIENT_AND_DIFFUSE + GL_COLOR_INDEXES + GL_LIGHT_MODEL_TWO_SIDE + GL_LIGHT_MODEL_LOCAL_VIEWER + GL_LIGHT_MODEL_AMBIENT + GL_FRONT_AND_BACK + GL_SHADE_MODEL + GL_FLAT + GL_SMOOTH + GL_COLOR_MATERIAL + GL_COLOR_MATERIAL_FACE + GL_COLOR_MATERIAL_PARAMETER + GL_NORMALIZE + GL_CLIP_PLANE0 + GL_CLIP_PLANE1 + GL_CLIP_PLANE2 + GL_CLIP_PLANE3 + GL_CLIP_PLANE4 + GL_CLIP_PLANE5 + GL_ACCUM_RED_BITS + GL_ACCUM_GREEN_BITS + GL_ACCUM_BLUE_BITS + GL_ACCUM_ALPHA_BITS + GL_ACCUM_CLEAR_VALUE + GL_ACCUM + GL_ADD + GL_LOAD + GL_MULT + GL_RETURN + GL_ALPHA_TEST + GL_ALPHA_TEST_REF + GL_ALPHA_TEST_FUNC + GL_BLEND + GL_BLEND_SRC + GL_BLEND_DST + GL_ZERO + GL_ONE + GL_SRC_COLOR + GL_ONE_MINUS_SRC_COLOR + GL_SRC_ALPHA + GL_ONE_MINUS_SRC_ALPHA + GL_DST_ALPHA + GL_ONE_MINUS_DST_ALPHA + GL_DST_COLOR + GL_ONE_MINUS_DST_COLOR + GL_SRC_ALPHA_SATURATE + GL_FEEDBACK + GL_RENDER + GL_SELECT + GL_2D + GL_3D + GL_3D_COLOR + GL_3D_COLOR_TEXTURE + GL_4D_COLOR_TEXTURE + GL_POINT_TOKEN + GL_LINE_TOKEN + GL_LINE_RESET_TOKEN + GL_POLYGON_TOKEN + GL_BITMAP_TOKEN + GL_DRAW_PIXEL_TOKEN + GL_COPY_PIXEL_TOKEN + GL_PASS_THROUGH_TOKEN + GL_FEEDBACK_BUFFER_POINTER + GL_FEEDBACK_BUFFER_SIZE + GL_FEEDBACK_BUFFER_TYPE + GL_SELECTION_BUFFER_POINTER + GL_SELECTION_BUFFER_SIZE + GL_FOG + GL_FOG_MODE + GL_FOG_DENSITY + GL_FOG_COLOR + GL_FOG_INDEX + GL_FOG_START + GL_FOG_END + GL_LINEAR + GL_EXP + GL_EXP2 + GL_LOGIC_OP + GL_INDEX_LOGIC_OP + GL_COLOR_LOGIC_OP + GL_LOGIC_OP_MODE + GL_CLEAR + GL_SET + GL_COPY + GL_COPY_INVERTED + GL_NOOP + GL_INVERT + GL_AND + GL_NAND + GL_OR + GL_NOR + GL_XOR + GL_EQUIV + GL_AND_REVERSE + GL_AND_INVERTED + GL_OR_REVERSE + GL_OR_INVERTED + GL_STENCIL_TEST + GL_STENCIL_WRITEMASK + GL_STENCIL_BITS + GL_STENCIL_FUNC + GL_STENCIL_VALUE_MASK + GL_STENCIL_REF + GL_STENCIL_FAIL + GL_STENCIL_PASS_DEPTH_PASS + GL_STENCIL_PASS_DEPTH_FAIL + GL_STENCIL_CLEAR_VALUE + GL_STENCIL_INDEX + GL_KEEP + GL_REPLACE + GL_INCR + GL_DECR + GL_NONE + GL_LEFT + GL_RIGHT + GL_FRONT_LEFT + GL_FRONT_RIGHT + GL_BACK_LEFT + GL_BACK_RIGHT + GL_AUX0 + GL_AUX1 + GL_AUX2 + GL_AUX3 + GL_COLOR_INDEX + GL_RED + GL_GREEN + GL_BLUE + GL_ALPHA + GL_LUMINANCE + GL_LUMINANCE_ALPHA + GL_ALPHA_BITS + GL_RED_BITS + GL_GREEN_BITS + GL_BLUE_BITS + GL_INDEX_BITS + GL_SUBPIXEL_BITS + GL_AUX_BUFFERS + GL_READ_BUFFER + GL_DRAW_BUFFER + GL_DOUBLEBUFFER + GL_STEREO + GL_BITMAP + GL_COLOR + GL_DEPTH + GL_STENCIL + GL_DITHER + GL_RGB + GL_RGBA + GL_MAX_LIST_NESTING + GL_MAX_ATTRIB_STACK_DEPTH + GL_MAX_MODELVIEW_STACK_DEPTH + GL_MAX_NAME_STACK_DEPTH + GL_MAX_PROJECTION_STACK_DEPTH + GL_MAX_TEXTURE_STACK_DEPTH + GL_MAX_EVAL_ORDER + GL_MAX_LIGHTS + GL_MAX_CLIP_PLANES + GL_MAX_TEXTURE_SIZE + GL_MAX_PIXEL_MAP_TABLE + GL_MAX_VIEWPORT_DIMS + GL_MAX_CLIENT_ATTRIB_STACK_DEPTH + GL_ATTRIB_STACK_DEPTH + GL_CLIENT_ATTRIB_STACK_DEPTH + GL_COLOR_CLEAR_VALUE + GL_COLOR_WRITEMASK + GL_CURRENT_INDEX + GL_CURRENT_COLOR + GL_CURRENT_NORMAL + GL_CURRENT_RASTER_COLOR + GL_CURRENT_RASTER_DISTANCE + GL_CURRENT_RASTER_INDEX + GL_CURRENT_RASTER_POSITION + GL_CURRENT_RASTER_TEXTURE_COORDS + GL_CURRENT_RASTER_POSITION_VALID + GL_CURRENT_TEXTURE_COORDS + GL_INDEX_CLEAR_VALUE + GL_INDEX_MODE + GL_INDEX_WRITEMASK + GL_MODELVIEW_MATRIX + GL_MODELVIEW_STACK_DEPTH + GL_NAME_STACK_DEPTH + GL_PROJECTION_MATRIX + GL_PROJECTION_STACK_DEPTH + GL_RENDER_MODE + GL_RGBA_MODE + GL_TEXTURE_MATRIX + GL_TEXTURE_STACK_DEPTH + GL_VIEWPORT + GL_AUTO_NORMAL + GL_MAP1_COLOR_4 + GL_MAP1_GRID_DOMAIN + GL_MAP1_GRID_SEGMENTS + GL_MAP1_INDEX + GL_MAP1_NORMAL + GL_MAP1_TEXTURE_COORD_1 + GL_MAP1_TEXTURE_COORD_2 + GL_MAP1_TEXTURE_COORD_3 + GL_MAP1_TEXTURE_COORD_4 + GL_MAP1_VERTEX_3 + GL_MAP1_VERTEX_4 + GL_MAP2_COLOR_4 + GL_MAP2_GRID_DOMAIN + GL_MAP2_GRID_SEGMENTS + GL_MAP2_INDEX + GL_MAP2_NORMAL + GL_MAP2_TEXTURE_COORD_1 + GL_MAP2_TEXTURE_COORD_2 + GL_MAP2_TEXTURE_COORD_3 + GL_MAP2_TEXTURE_COORD_4 + GL_MAP2_VERTEX_3 + GL_MAP2_VERTEX_4 + GL_COEFF + GL_DOMAIN + GL_ORDER + GL_FOG_HINT + GL_LINE_SMOOTH_HINT + GL_PERSPECTIVE_CORRECTION_HINT + GL_POINT_SMOOTH_HINT + GL_POLYGON_SMOOTH_HINT + GL_DONT_CARE + GL_FASTEST + GL_NICEST + GL_SCISSOR_TEST + GL_SCISSOR_BOX + GL_MAP_COLOR + GL_MAP_STENCIL + GL_INDEX_SHIFT + GL_INDEX_OFFSET + GL_RED_SCALE + GL_RED_BIAS + GL_GREEN_SCALE + GL_GREEN_BIAS + GL_BLUE_SCALE + GL_BLUE_BIAS + GL_ALPHA_SCALE + GL_ALPHA_BIAS + GL_DEPTH_SCALE + GL_DEPTH_BIAS + GL_PIXEL_MAP_S_TO_S_SIZE + GL_PIXEL_MAP_I_TO_I_SIZE + GL_PIXEL_MAP_I_TO_R_SIZE + GL_PIXEL_MAP_I_TO_G_SIZE + GL_PIXEL_MAP_I_TO_B_SIZE + GL_PIXEL_MAP_I_TO_A_SIZE + GL_PIXEL_MAP_R_TO_R_SIZE + GL_PIXEL_MAP_G_TO_G_SIZE + GL_PIXEL_MAP_B_TO_B_SIZE + GL_PIXEL_MAP_A_TO_A_SIZE + GL_PIXEL_MAP_S_TO_S + GL_PIXEL_MAP_I_TO_I + GL_PIXEL_MAP_I_TO_R + GL_PIXEL_MAP_I_TO_G + GL_PIXEL_MAP_I_TO_B + GL_PIXEL_MAP_I_TO_A + GL_PIXEL_MAP_R_TO_R + GL_PIXEL_MAP_G_TO_G + GL_PIXEL_MAP_B_TO_B + GL_PIXEL_MAP_A_TO_A + GL_PACK_ALIGNMENT + GL_PACK_LSB_FIRST + GL_PACK_ROW_LENGTH + GL_PACK_SKIP_PIXELS + GL_PACK_SKIP_ROWS + GL_PACK_SWAP_BYTES + GL_UNPACK_ALIGNMENT + GL_UNPACK_LSB_FIRST + GL_UNPACK_ROW_LENGTH + GL_UNPACK_SKIP_PIXELS + GL_UNPACK_SKIP_ROWS + GL_UNPACK_SWAP_BYTES + GL_ZOOM_X + GL_ZOOM_Y + GL_TEXTURE_ENV + GL_TEXTURE_ENV_MODE + GL_TEXTURE_1D + GL_TEXTURE_2D + GL_TEXTURE_WRAP_S + GL_TEXTURE_WRAP_T + GL_TEXTURE_MAG_FILTER + GL_TEXTURE_MIN_FILTER + GL_TEXTURE_ENV_COLOR + GL_TEXTURE_GEN_S + GL_TEXTURE_GEN_T + GL_TEXTURE_GEN_MODE + GL_TEXTURE_BORDER_COLOR + GL_TEXTURE_WIDTH + GL_TEXTURE_HEIGHT + GL_TEXTURE_BORDER + GL_TEXTURE_COMPONENTS + GL_TEXTURE_RED_SIZE + GL_TEXTURE_GREEN_SIZE + GL_TEXTURE_BLUE_SIZE + GL_TEXTURE_ALPHA_SIZE + GL_TEXTURE_LUMINANCE_SIZE + GL_TEXTURE_INTENSITY_SIZE + GL_NEAREST_MIPMAP_NEAREST + GL_NEAREST_MIPMAP_LINEAR + GL_LINEAR_MIPMAP_NEAREST + GL_LINEAR_MIPMAP_LINEAR + GL_OBJECT_LINEAR + GL_OBJECT_PLANE + GL_EYE_LINEAR + GL_EYE_PLANE + GL_SPHERE_MAP + GL_DECAL + GL_MODULATE + GL_NEAREST + GL_REPEAT + GL_CLAMP + GL_S + GL_T + GL_R + GL_Q + GL_TEXTURE_GEN_R + GL_TEXTURE_GEN_Q + GL_VENDOR + GL_RENDERER + GL_VERSION + GL_EXTENSIONS + GL_NO_ERROR + GL_INVALID_VALUE + GL_INVALID_ENUM + GL_INVALID_OPERATION + GL_STACK_OVERFLOW + GL_STACK_UNDERFLOW + GL_OUT_OF_MEMORY + GL_CURRENT_BIT + GL_POINT_BIT + GL_LINE_BIT + GL_POLYGON_BIT + GL_POLYGON_STIPPLE_BIT + GL_PIXEL_MODE_BIT + GL_LIGHTING_BIT + GL_FOG_BIT + GL_DEPTH_BUFFER_BIT + GL_ACCUM_BUFFER_BIT + GL_STENCIL_BUFFER_BIT + GL_VIEWPORT_BIT + GL_TRANSFORM_BIT + GL_ENABLE_BIT + GL_COLOR_BUFFER_BIT + GL_HINT_BIT + GL_EVAL_BIT + GL_LIST_BIT + GL_TEXTURE_BIT + GL_SCISSOR_BIT + GL_ALL_ATTRIB_BITS + GL_PROXY_TEXTURE_1D + GL_PROXY_TEXTURE_2D + GL_TEXTURE_PRIORITY + GL_TEXTURE_RESIDENT + GL_TEXTURE_BINDING_1D + GL_TEXTURE_BINDING_2D + GL_TEXTURE_INTERNAL_FORMAT + GL_ALPHA4 + GL_ALPHA8 + GL_ALPHA12 + GL_ALPHA16 + GL_LUMINANCE4 + GL_LUMINANCE8 + GL_LUMINANCE12 + GL_LUMINANCE16 + GL_LUMINANCE4_ALPHA4 + GL_LUMINANCE6_ALPHA2 + GL_LUMINANCE8_ALPHA8 + GL_LUMINANCE12_ALPHA4 + GL_LUMINANCE12_ALPHA12 + GL_LUMINANCE16_ALPHA16 + GL_INTENSITY + GL_INTENSITY4 + GL_INTENSITY8 + GL_INTENSITY12 + GL_INTENSITY16 + GL_R3_G3_B2 + GL_RGB4 + GL_RGB5 + GL_RGB8 + GL_RGB10 + GL_RGB12 + GL_RGB16 + GL_RGBA2 + GL_RGBA4 + GL_RGB5_A1 + GL_RGBA8 + GL_RGB10_A2 + GL_RGBA12 + GL_RGBA16 + GL_CLIENT_PIXEL_STORE_BIT + GL_CLIENT_VERTEX_ARRAY_BIT + GL_ALL_CLIENT_ATTRIB_BITS + GL_CLIENT_ALL_ATTRIB_BITS + + GL_UNSIGNED_BYTE_3_3_2 + GL_UNSIGNED_SHORT_4_4_4_4 + GL_UNSIGNED_SHORT_5_5_5_1 + GL_UNSIGNED_INT_8_8_8_8 + GL_UNSIGNED_INT_10_10_10_2 + GL_RESCALE_NORMAL + GL_TEXTURE_BINDING_3D + GL_PACK_SKIP_IMAGES + GL_PACK_IMAGE_HEIGHT + GL_UNPACK_SKIP_IMAGES + GL_UNPACK_IMAGE_HEIGHT + GL_TEXTURE_3D + GL_PROXY_TEXTURE_3D + GL_TEXTURE_DEPTH + GL_TEXTURE_WRAP_R + GL_MAX_3D_TEXTURE_SIZE + GL_UNSIGNED_BYTE_2_3_3_REV + GL_UNSIGNED_SHORT_5_6_5 + GL_UNSIGNED_SHORT_5_6_5_REV + GL_UNSIGNED_SHORT_4_4_4_4_REV + GL_UNSIGNED_SHORT_1_5_5_5_REV + GL_UNSIGNED_INT_8_8_8_8_REV + GL_UNSIGNED_INT_2_10_10_10_REV + GL_BGR + GL_BGRA + GL_MAX_ELEMENTS_VERTICES + GL_MAX_ELEMENTS_INDICES + GL_CLAMP_TO_EDGE + GL_TEXTURE_MIN_LOD + GL_TEXTURE_MAX_LOD + GL_TEXTURE_BASE_LEVEL + GL_TEXTURE_MAX_LEVEL + GL_LIGHT_MODEL_COLOR_CONTROL + GL_SINGLE_COLOR + GL_SEPARATE_SPECULAR_COLOR + GL_SMOOTH_POINT_SIZE_RANGE + GL_SMOOTH_POINT_SIZE_GRANULARITY + GL_SMOOTH_LINE_WIDTH_RANGE + GL_SMOOTH_LINE_WIDTH_GRANULARITY + GL_ALIASED_POINT_SIZE_RANGE + GL_ALIASED_LINE_WIDTH_RANGE + + GL_CONSTANT_COLOR + GL_ONE_MINUS_CONSTANT_COLOR + GL_CONSTANT_ALPHA + GL_ONE_MINUS_CONSTANT_ALPHA + GL_BLEND_COLOR + GL_FUNC_ADD + GL_MIN + GL_MAX + GL_BLEND_EQUATION + GL_FUNC_SUBTRACT + GL_FUNC_REVERSE_SUBTRACT + GL_CONVOLUTION_1D + GL_CONVOLUTION_2D + GL_SEPARABLE_2D + GL_CONVOLUTION_BORDER_MODE + GL_CONVOLUTION_FILTER_SCALE + GL_CONVOLUTION_FILTER_BIAS + GL_REDUCE + GL_CONVOLUTION_FORMAT + GL_CONVOLUTION_WIDTH + GL_CONVOLUTION_HEIGHT + GL_MAX_CONVOLUTION_WIDTH + GL_MAX_CONVOLUTION_HEIGHT + GL_POST_CONVOLUTION_RED_SCALE + GL_POST_CONVOLUTION_GREEN_SCALE + GL_POST_CONVOLUTION_BLUE_SCALE + GL_POST_CONVOLUTION_ALPHA_SCALE + GL_POST_CONVOLUTION_RED_BIAS + GL_POST_CONVOLUTION_GREEN_BIAS + GL_POST_CONVOLUTION_BLUE_BIAS + GL_POST_CONVOLUTION_ALPHA_BIAS + GL_HISTOGRAM + GL_PROXY_HISTOGRAM + GL_HISTOGRAM_WIDTH + GL_HISTOGRAM_FORMAT + GL_HISTOGRAM_RED_SIZE + GL_HISTOGRAM_GREEN_SIZE + GL_HISTOGRAM_BLUE_SIZE + GL_HISTOGRAM_ALPHA_SIZE + GL_HISTOGRAM_LUMINANCE_SIZE + GL_HISTOGRAM_SINK + GL_MINMAX + GL_MINMAX_FORMAT + GL_MINMAX_SINK + GL_TABLE_TOO_LARGE + GL_COLOR_MATRIX + GL_COLOR_MATRIX_STACK_DEPTH + GL_MAX_COLOR_MATRIX_STACK_DEPTH + GL_POST_COLOR_MATRIX_RED_SCALE + GL_POST_COLOR_MATRIX_GREEN_SCALE + GL_POST_COLOR_MATRIX_BLUE_SCALE + GL_POST_COLOR_MATRIX_ALPHA_SCALE + GL_POST_COLOR_MATRIX_RED_BIAS + GL_POST_COLOR_MATRIX_GREEN_BIAS + GL_POST_COLOR_MATRIX_BLUE_BIAS + GL_POST_COLOR_MATRIX_ALPHA_BIAS + GL_COLOR_TABLE + GL_POST_CONVOLUTION_COLOR_TABLE + GL_POST_COLOR_MATRIX_COLOR_TABLE + GL_PROXY_COLOR_TABLE + GL_PROXY_POST_CONVOLUTION_COLOR_TABLE + GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE + GL_COLOR_TABLE_SCALE + GL_COLOR_TABLE_BIAS + GL_COLOR_TABLE_FORMAT + GL_COLOR_TABLE_WIDTH + GL_COLOR_TABLE_RED_SIZE + GL_COLOR_TABLE_GREEN_SIZE + GL_COLOR_TABLE_BLUE_SIZE + GL_COLOR_TABLE_ALPHA_SIZE + GL_COLOR_TABLE_LUMINANCE_SIZE + GL_COLOR_TABLE_INTENSITY_SIZE + GL_CONSTANT_BORDER + GL_REPLICATE_BORDER + GL_CONVOLUTION_BORDER_COLOR + + GL_TEXTURE0 + GL_TEXTURE1 + GL_TEXTURE2 + GL_TEXTURE3 + GL_TEXTURE4 + GL_TEXTURE5 + GL_TEXTURE6 + GL_TEXTURE7 + GL_TEXTURE8 + GL_TEXTURE9 + GL_TEXTURE10 + GL_TEXTURE11 + GL_TEXTURE12 + GL_TEXTURE13 + GL_TEXTURE14 + GL_TEXTURE15 + GL_TEXTURE16 + GL_TEXTURE17 + GL_TEXTURE18 + GL_TEXTURE19 + GL_TEXTURE20 + GL_TEXTURE21 + GL_TEXTURE22 + GL_TEXTURE23 + GL_TEXTURE24 + GL_TEXTURE25 + GL_TEXTURE26 + GL_TEXTURE27 + GL_TEXTURE28 + GL_TEXTURE29 + GL_TEXTURE30 + GL_TEXTURE31 + GL_ACTIVE_TEXTURE + GL_CLIENT_ACTIVE_TEXTURE + GL_MAX_TEXTURE_UNITS + GL_TRANSPOSE_MODELVIEW_MATRIX + GL_TRANSPOSE_PROJECTION_MATRIX + GL_TRANSPOSE_TEXTURE_MATRIX + GL_TRANSPOSE_COLOR_MATRIX + GL_MULTISAMPLE + GL_SAMPLE_ALPHA_TO_COVERAGE + GL_SAMPLE_ALPHA_TO_ONE + GL_SAMPLE_COVERAGE + GL_SAMPLE_BUFFERS + GL_SAMPLES + GL_SAMPLE_COVERAGE_VALUE + GL_SAMPLE_COVERAGE_INVERT + GL_MULTISAMPLE_BIT + GL_NORMAL_MAP + GL_REFLECTION_MAP + GL_TEXTURE_CUBE_MAP + GL_TEXTURE_BINDING_CUBE_MAP + GL_TEXTURE_CUBE_MAP_POSITIVE_X + GL_TEXTURE_CUBE_MAP_NEGATIVE_X + GL_TEXTURE_CUBE_MAP_POSITIVE_Y + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y + GL_TEXTURE_CUBE_MAP_POSITIVE_Z + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z + GL_PROXY_TEXTURE_CUBE_MAP + GL_MAX_CUBE_MAP_TEXTURE_SIZE + GL_COMPRESSED_ALPHA + GL_COMPRESSED_LUMINANCE + GL_COMPRESSED_LUMINANCE_ALPHA + GL_COMPRESSED_INTENSITY + GL_COMPRESSED_RGB + GL_COMPRESSED_RGBA + GL_TEXTURE_COMPRESSION_HINT + GL_TEXTURE_COMPRESSED_IMAGE_SIZE + GL_TEXTURE_COMPRESSED + GL_NUM_COMPRESSED_TEXTURE_FORMATS + GL_COMPRESSED_TEXTURE_FORMATS + GL_CLAMP_TO_BORDER + GL_COMBINE + GL_COMBINE_RGB + GL_COMBINE_ALPHA + GL_SOURCE0_RGB + GL_SOURCE1_RGB + GL_SOURCE2_RGB + GL_SOURCE0_ALPHA + GL_SOURCE1_ALPHA + GL_SOURCE2_ALPHA + GL_OPERAND0_RGB + GL_OPERAND1_RGB + GL_OPERAND2_RGB + GL_OPERAND0_ALPHA + GL_OPERAND1_ALPHA + GL_OPERAND2_ALPHA + GL_RGB_SCALE + GL_ADD_SIGNED + GL_INTERPOLATE + GL_SUBTRACT + GL_CONSTANT + GL_PRIMARY_COLOR + GL_PREVIOUS + GL_DOT3_RGB + GL_DOT3_RGBA + + GL_BLEND_DST_RGB + GL_BLEND_SRC_RGB + GL_BLEND_DST_ALPHA + GL_BLEND_SRC_ALPHA + GL_POINT_SIZE_MIN + GL_POINT_SIZE_MAX + GL_POINT_FADE_THRESHOLD_SIZE + GL_POINT_DISTANCE_ATTENUATION + GL_GENERATE_MIPMAP + GL_GENERATE_MIPMAP_HINT + GL_DEPTH_COMPONENT16 + GL_DEPTH_COMPONENT24 + GL_DEPTH_COMPONENT32 + GL_MIRRORED_REPEAT + GL_FOG_COORDINATE_SOURCE + GL_FOG_COORDINATE + GL_FRAGMENT_DEPTH + GL_CURRENT_FOG_COORDINATE + GL_FOG_COORDINATE_ARRAY_TYPE + GL_FOG_COORDINATE_ARRAY_STRIDE + GL_FOG_COORDINATE_ARRAY_POINTER + GL_FOG_COORDINATE_ARRAY + GL_COLOR_SUM + GL_CURRENT_SECONDARY_COLOR + GL_SECONDARY_COLOR_ARRAY_SIZE + GL_SECONDARY_COLOR_ARRAY_TYPE + GL_SECONDARY_COLOR_ARRAY_STRIDE + GL_SECONDARY_COLOR_ARRAY_POINTER + GL_SECONDARY_COLOR_ARRAY + GL_MAX_TEXTURE_LOD_BIAS + GL_TEXTURE_FILTER_CONTROL + GL_TEXTURE_LOD_BIAS + GL_INCR_WRAP + GL_DECR_WRAP + GL_TEXTURE_DEPTH_SIZE + GL_DEPTH_TEXTURE_MODE + GL_TEXTURE_COMPARE_MODE + GL_TEXTURE_COMPARE_FUNC + GL_COMPARE_R_TO_TEXTURE + + GL_BUFFER_SIZE + GL_BUFFER_USAGE + GL_QUERY_COUNTER_BITS + GL_CURRENT_QUERY + GL_QUERY_RESULT + GL_QUERY_RESULT_AVAILABLE + GL_ARRAY_BUFFER + GL_ELEMENT_ARRAY_BUFFER + GL_ARRAY_BUFFER_BINDING + GL_ELEMENT_ARRAY_BUFFER_BINDING + GL_VERTEX_ARRAY_BUFFER_BINDING + GL_NORMAL_ARRAY_BUFFER_BINDING + GL_COLOR_ARRAY_BUFFER_BINDING + GL_INDEX_ARRAY_BUFFER_BINDING + GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING + GL_EDGE_FLAG_ARRAY_BUFFER_BINDING + GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING + GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING + GL_WEIGHT_ARRAY_BUFFER_BINDING + GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING + GL_READ_ONLY + GL_WRITE_ONLY + GL_READ_WRITE + GL_BUFFER_ACCESS + GL_BUFFER_MAPPED + GL_BUFFER_MAP_POINTER + GL_STREAM_DRAW + GL_STREAM_READ + GL_STREAM_COPY + GL_STATIC_DRAW + GL_STATIC_READ + GL_STATIC_COPY + GL_DYNAMIC_DRAW + GL_DYNAMIC_READ + GL_DYNAMIC_COPY + GL_SAMPLES_PASSED + GL_FOG_COORD_SRC + GL_FOG_COORD + GL_CURRENT_FOG_COORD + GL_FOG_COORD_ARRAY_TYPE + GL_FOG_COORD_ARRAY_STRIDE + GL_FOG_COORD_ARRAY_POINTER + GL_FOG_COORD_ARRAY + GL_FOG_COORD_ARRAY_BUFFER_BINDING + GL_SRC0_RGB + GL_SRC1_RGB + GL_SRC2_RGB + GL_SRC0_ALPHA + GL_SRC1_ALPHA + GL_SRC2_ALPHA + + GLU_FALSE + GLU_TRUE + GLU_VERSION + GLU_EXTENSIONS + GLU_INVALID_ENUM + GLU_INVALID_VALUE + GLU_OUT_OF_MEMORY + GLU_INVALID_OPERATION + GLU_OUTLINE_POLYGON + GLU_OUTLINE_PATCH + GLU_NURBS_ERROR + GLU_ERROR + GLU_NURBS_BEGIN + GLU_NURBS_BEGIN_EXT + GLU_NURBS_VERTEX + GLU_NURBS_VERTEX_EXT + GLU_NURBS_NORMAL + GLU_NURBS_NORMAL_EXT + GLU_NURBS_COLOR + GLU_NURBS_COLOR_EXT + GLU_NURBS_TEXTURE_COORD + GLU_NURBS_TEX_COORD_EXT + GLU_NURBS_END + GLU_NURBS_END_EXT + GLU_NURBS_BEGIN_DATA + GLU_NURBS_BEGIN_DATA_EXT + GLU_NURBS_VERTEX_DATA + GLU_NURBS_VERTEX_DATA_EXT + GLU_NURBS_NORMAL_DATA + GLU_NURBS_NORMAL_DATA_EXT + GLU_NURBS_COLOR_DATA + GLU_NURBS_COLOR_DATA_EXT + GLU_NURBS_TEXTURE_COORD_DATA + GLU_NURBS_TEX_COORD_DATA_EXT + GLU_NURBS_END_DATA + GLU_NURBS_END_DATA_EXT + GLU_NURBS_ERROR1 + GLU_NURBS_ERROR2 + GLU_NURBS_ERROR3 + GLU_NURBS_ERROR4 + GLU_NURBS_ERROR5 + GLU_NURBS_ERROR6 + GLU_NURBS_ERROR7 + GLU_NURBS_ERROR8 + GLU_NURBS_ERROR9 + GLU_NURBS_ERROR10 + GLU_NURBS_ERROR11 + GLU_NURBS_ERROR12 + GLU_NURBS_ERROR13 + GLU_NURBS_ERROR14 + GLU_NURBS_ERROR15 + GLU_NURBS_ERROR16 + GLU_NURBS_ERROR17 + GLU_NURBS_ERROR18 + GLU_NURBS_ERROR19 + GLU_NURBS_ERROR20 + GLU_NURBS_ERROR21 + GLU_NURBS_ERROR22 + GLU_NURBS_ERROR23 + GLU_NURBS_ERROR24 + GLU_NURBS_ERROR25 + GLU_NURBS_ERROR26 + GLU_NURBS_ERROR27 + GLU_NURBS_ERROR28 + GLU_NURBS_ERROR29 + GLU_NURBS_ERROR30 + GLU_NURBS_ERROR31 + GLU_NURBS_ERROR32 + GLU_NURBS_ERROR33 + GLU_NURBS_ERROR34 + GLU_NURBS_ERROR35 + GLU_NURBS_ERROR36 + GLU_NURBS_ERROR37 + GLU_AUTO_LOAD_MATRIX + GLU_CULLING + GLU_SAMPLING_TOLERANCE + GLU_DISPLAY_MODE + GLU_PARAMETRIC_TOLERANCE + GLU_SAMPLING_METHOD + GLU_U_STEP + GLU_V_STEP + GLU_NURBS_MODE + GLU_NURBS_MODE_EXT + GLU_NURBS_TESSELLATOR + GLU_NURBS_TESSELLATOR_EXT + GLU_NURBS_RENDERER + GLU_NURBS_RENDERER_EXT + GLU_OBJECT_PARAMETRIC_ERROR + GLU_OBJECT_PARAMETRIC_ERROR_EXT + GLU_OBJECT_PATH_LENGTH + GLU_OBJECT_PATH_LENGTH_EXT + GLU_PATH_LENGTH + GLU_PARAMETRIC_ERROR + GLU_DOMAIN_DISTANCE + GLU_MAP1_TRIM_2 + GLU_MAP1_TRIM_3 + GLU_POINT + GLU_LINE + GLU_FILL + GLU_SILHOUETTE + GLU_SMOOTH + GLU_FLAT + GLU_NONE + GLU_OUTSIDE + GLU_INSIDE + GLU_TESS_BEGIN + GLU_BEGIN + GLU_TESS_VERTEX + GLU_VERTEX + GLU_TESS_END + GLU_END + GLU_TESS_ERROR + GLU_TESS_EDGE_FLAG + GLU_EDGE_FLAG + GLU_TESS_COMBINE + GLU_TESS_BEGIN_DATA + GLU_TESS_VERTEX_DATA + GLU_TESS_END_DATA + GLU_TESS_ERROR_DATA + GLU_TESS_EDGE_FLAG_DATA + GLU_TESS_COMBINE_DATA + GLU_CW + GLU_CCW + GLU_INTERIOR + GLU_EXTERIOR + GLU_UNKNOWN + GLU_TESS_WINDING_RULE + GLU_TESS_BOUNDARY_ONLY + GLU_TESS_TOLERANCE + GLU_TESS_ERROR1 + GLU_TESS_ERROR2 + GLU_TESS_ERROR3 + GLU_TESS_ERROR4 + GLU_TESS_ERROR5 + GLU_TESS_ERROR6 + GLU_TESS_ERROR7 + GLU_TESS_ERROR8 + GLU_TESS_MISSING_BEGIN_POLYGON + GLU_TESS_MISSING_BEGIN_CONTOUR + GLU_TESS_MISSING_END_POLYGON + GLU_TESS_MISSING_END_CONTOUR + GLU_TESS_COORD_TOO_LARGE + GLU_TESS_NEED_COMBINE_CALLBACK + GLU_TESS_WINDING_ODD + GLU_TESS_WINDING_NONZERO + GLU_TESS_WINDING_POSITIVE + GLU_TESS_WINDING_NEGATIVE + GLU_TESS_WINDING_ABS_GEQ_TWO + [GLU_TESS_MAX_COORD real?] +)]{ +All OpenGL-defined constants.} + +@defproc[(feedback-buffer->gl-float-vector [buf feedback-buffer-object?]) + gl-float-vector?]{ + +Converts a result from @scheme[glFeedbackBuffer] to a vector.} + +@defproc[(select-buffer->gl-uint-vector [buf select-buffer-object?]) + gl-uint-vector?]{ + +Converts a result from @scheme[glSelectBuffer] to a vector.} diff --git a/collects/sgl/scribblings/main.scrbl b/collects/sgl/scribblings/main.scrbl new file mode 100644 index 0000000000..22b2f4cf44 --- /dev/null +++ b/collects/sgl/scribblings/main.scrbl @@ -0,0 +1,217 @@ +#lang scribble/doc +@(require "common.ss" + scribble/eval + (for-syntax scheme/base)) + +@title[#:tag "main"]{Scheme-Style OpenGL} + +@defmodule[sgl] + +The functions in @schememodname[sgl] use Scheme style names instead of +C style names. To convert a C OpenGL name to a Scheme OpenGL name, +change the @tt{gl} prefix to @schemeidfont{gl-}, separate adjacent +words with hyphens, and convert to all lower case. Functions that +have several variants to accommodate different numbers and types of +arguments are collapsed into one or two functions in +@schememodname[sgl]. For example, @schememodname[sgl] provides two +vertex functions: @scheme[vertex] and @scheme[vertex-v]. The +@scheme[vertex] function accepts 2, 3 or 4 numerical arguments, and +the @scheme[vertex-v] function accepts @scheme[gl-vector]s of length +2, 3 or 4. The C language OpenGL interface, in contrast, has 24 +vertex functions: @tt{glVertex3i}, @tt{glVertex4fv}, etc. + +Functions in @schememodname[sgl] take symbols instead of integers for +@tt{GLenum} arguments. Each function checks that the given symbol is +an acceptable argument and raises an exception if it is not. Given +the name of a C-language @tt{#define} constant, determine the +corresponding symbolic argument by removing the leading @tt{GL_}, +converting the letters to lower-case and replacing each @tt{_} with +@schemeidfont{-}. For example, @tt{GL_TRIANGLES} becomes +@scheme['triangles], and @tt{GL_TRIANGLE_STRIP} becomes +@scheme['triangle-strip]. Additionally, the functions check the +length of any array arguments to ensure that OpenGL does not attempt +to write or read after the array. + +The @schememodname[sgl] module is not as complete as the +@schememodname[sgl/gl] module. + +@as-examples[ +@schemeblock[ +(require sgl sgl/gl-vectors) +(gl-begin 'triangles) +(gl-vertex 1 2 3) +(gl-vertex-v (gl-float-vector 1 2 3 4)) +(gl-end) +]] + +@defstruct[selection-record ([min-z real?] [max-z real?] [stack ....])]{ + +Represents a selection.} + +@(define-syntax-rule (def-scheme-gl (id ...) body ...) + @deftogether[( + @defthing[id procedure?] ... + ) body ...]) + +@def-scheme-gl[( +gl-accum +gl-active-texture +gl-alpha-func +gl-begin +gl-begin-query +gl-blend-color +gl-blend-equation +gl-blend-func +gl-blend-func-separate +gl-call-list +gl-check-extension +gl-clear +gl-clear-accum +gl-clear-color +gl-clear-depth +gl-clear-index +gl-clear-stencil +gl-clip-plane +gl-color +gl-color-mask +gl-color-material +gl-color-v +gl-copy-pixels +gl-cull-face +gl-cylinder +gl-delete-lists +gl-delete-queries +gl-depth-func +gl-depth-mask +gl-depth-range +gl-disable +gl-disk +gl-edge-flag +gl-enable +gl-end +gl-end-list +gl-end-query +gl-eval-coord +gl-eval-coord-v +gl-eval-mesh +gl-eval-point +gl-feedback-buffer->gl-float-vector +gl-finish +gl-flush +gl-front-face +gl-frustum +gl-gen-lists +gl-gen-queries +gl-get-error +gl-get-string +gl-hint +gl-index +gl-index-mask +gl-index-v +gl-init-names +gl-is-buffer +gl-is-enabled +gl-is-list +gl-is-query +gl-light +gl-light-model +gl-light-model-v +gl-light-v +gl-line-stipple +gl-line-width +gl-list-base +gl-load-identity +gl-load-matrix +gl-load-name +gl-load-transpose-matrix +gl-look-at +gl-map-grid +gl-material +gl-material-v +gl-matrix-mode +gl-mult-matrix +gl-mult-transpose-matrix +gl-multi-tex-coord +gl-multi-tex-coord-v +gl-new-list +gl-new-quadric +gl-normal +gl-normal-v +gl-ortho +gl-ortho-2d +gl-partial-disk +gl-pass-through +gl-perspective +gl-pick-matrix +gl-pixel-store +gl-point-parameter +gl-point-parameter-v +gl-point-size +gl-polygon-mode +gl-polygon-offset +gl-pop-attrib +gl-pop-client-attrib +gl-pop-matrix +gl-pop-name +gl-process-selection +gl-project +gl-push-matrix +gl-push-name +gl-quadric-draw-style +gl-quadric-normals +gl-quadric-orientation +gl-quadric-texture +gl-raster-pos +gl-raster-pos-v +gl-rect +gl-rect-v +gl-render-mode +gl-rotate +gl-sample-coverage +gl-scale +gl-scissor +gl-secondary-color +gl-secondary-color-v +gl-select-buffer->gl-uint-vector +gl-shade-model +gl-sphere +gl-stencil-func +gl-stencil-mask +gl-stencil-op +gl-tex-coord +gl-tex-coord-v +gl-tex-gen +gl-tex-gen-v +gl-translate +gl-u-get-string +gl-un-project +gl-un-project4 +gl-vertex +gl-vertex-v +gl-viewport +gl-window-pos +gl-window-pos-v +)]{ + +Scheme-style variants of the OpenGL functions.} + + +@defproc[(process-selection [vec gl-uint-vector?] + [hits exact-nonnegative-integer?]) + (listof selection-record?)]{ + +Parses the contents of @scheme[vec] from the format used by +@scheme[glSelectBuffer]. The second argument should be the number of +hits as returned by @scheme[glRenderMode].} + + +@defproc[(get-gl-version-number) exact-nonnegative-integer?]{ + +Returns the run-time OpenGL version number as an integer: @scheme[10], +@scheme[11], @scheme[12], @scheme[13], @scheme[14], @scheme[15], or +@scheme[20].} + +@defproc[(get-glu-version-number) exact-nonnegative-integer?]{ + +Returns the run-time GLU version number as an integer: @scheme[10], +@scheme[11], @scheme[12], or @scheme[13].} diff --git a/collects/sgl/scribblings/overview.scrbl b/collects/sgl/scribblings/overview.scrbl new file mode 100644 index 0000000000..f8eb4bbc63 --- /dev/null +++ b/collects/sgl/scribblings/overview.scrbl @@ -0,0 +1,31 @@ +#lang scribble/doc +@(require "common.ss") + +@title[#:tag "overview"]{Using OpenGL} + +The @schememodname[sgl/gl] library provides direct access to the +C-style OpenGL API, whereas the @schememodname[sgl] library provides a +more Scheme-like interface. The @schememodname[sgl/gl] library +provides a binding for each @tt{#defined} constant and for most +functions in OpenGL 1.5 and GLU 1.3. The functions perform comparable +checking to their C-language counterparts; they check the types of +their arguments, but do not check the length of array arguments. The +@schememodname[sgl] library provides wrappers around many of the +functions in the @schememodname[sgl/gl] library to present a more +Scheme-friendly interface, including function names that follow Scheme +conventions, and checked, symbolic enumeration arguments, and +array-length checks. + +@bold{Warning on Safety:} OpenGL programming is inherently unsafe, +even when using only the @schememodname[sgl] library. Although +@schememodname[sgl] checks the arguments to each function call, +violation of higher-level assumptions of the system's OpenGL library +can cause it to crash, bringing the entire Scheme system down. For +example, sending a large number of vertices in a single @tt{glBegin} +causes at least some GL implementations to crash. + +Some examples are available in the @filepath{examples} directory of +the @filepath{sgl} collection in the PLT Scheme installation. For +@filepath{alpha.ss}, try choosing the @filepath{sk.jpg} image distritbuted +with PLT Scheme in the @filepath{icons} collection; you may have to +press the ``t'' key a few times if the spinning cube is blank. diff --git a/collects/sgl/scribblings/sgl.scrbl b/collects/sgl/scribblings/sgl.scrbl new file mode 100644 index 0000000000..b2a1bde8db --- /dev/null +++ b/collects/sgl/scribblings/sgl.scrbl @@ -0,0 +1,25 @@ +#lang scribble/doc +@(require "common.ss") + +@title{@bold{GL}: 3-D Graphics} + +The @schememodname[sgl] libraries provide access to the rendering +functions of @as-index{OpenGL} 1.5 and @as-index{GLU} 1.3 +libraries. The @schememodname[sgl] libraries to not address +system-level concerns, such as the attachment of GL rendering contexts +to displays. Instead, the libraries should work with any PLT Scheme +extension that provides GL with access to the system (such as a +binding for @tt{glx}). Notably, the @schememodname[scheme/gui/base] +library provides support for rendering contexts via the +@scheme[canvas%] class and its @method[canvas% with-gl-context] +method. + +@table-of-contents[] + +@include-section["overview.scrbl"] +@include-section["gl.scrbl"] +@include-section["main.scrbl"] +@include-section["gl-vectors.scrbl"] +@include-section["bitmap.scrbl"] + +@index-section[]