id
int64 0
45.1k
| file_name
stringlengths 4
68
| file_path
stringlengths 14
193
| content
stringlengths 32
9.62M
| size
int64 32
9.62M
| language
stringclasses 1
value | extension
stringclasses 6
values | total_lines
int64 1
136k
| avg_line_length
float64 3
903k
| max_line_length
int64 3
4.51M
| alphanum_fraction
float64 0
1
| repo_name
stringclasses 779
values | repo_stars
int64 0
882
| repo_forks
int64 0
108
| repo_open_issues
int64 0
90
| repo_license
stringclasses 8
values | repo_extraction_date
stringclasses 146
values | sha
stringlengths 64
64
| __index_level_0__
int64 0
45.1k
| exdup_ids_cmlisp_stkv2
sequencelengths 1
47
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
30,531 | init.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cffi_0.16.1/libffi/init.lisp | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; init.lisp --- Load libffi and define #'libffi-type-pointer
;;;
;;; Copyright (C) 2009, 2011 Liam M. Healy
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
;;;
(in-package #:cffi)
(define-foreign-library (libffi)
(:darwin (:or "libffi.dylib" "libffi32.dylib" "/usr/lib/libffi.dylib"))
(:solaris (:or "/usr/lib/amd64/libffi.so" "/usr/lib/libffi.so"))
(:openbsd "libffi.so")
(:unix (:or "libffi.so.6" "libffi32.so.6" "libffi.so.5" "libffi32.so.5"))
(:windows (:or "libffi-6.dll" "libffi-5.dll" "libffi.dll"))
(t (:default "libffi")))
(load-foreign-library 'libffi)
(defvar *libffi-type-pointer* (make-hash-table))
(defgeneric libffi-type-pointer (object)
(:documentation "The type pointer defined by libffi.")
(:method ((object symbol))
(libffi-type-pointer (parse-type object)))
(:method (object)
(gethash object *libffi-type-pointer*)))
(defun set-libffi-type-pointer (type pointer)
"Set the hash table entry for the libffi type pointer."
(setf (gethash (if (symbolp type) (parse-type type) type)
*libffi-type-pointer*)
pointer))
| 2,198 | Common Lisp | .lisp | 47 | 44.468085 | 75 | 0.71655 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | f44d3d89eaf7f0ac07056aca2c92c58469e4f3166e6747794312e1c521011983 | 30,531 | [
83708
] |
30,532 | uffi-compat.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cffi_0.16.1/uffi-compat/uffi-compat.lisp | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; uffi-compat.lisp --- UFFI compatibility layer for CFFI.
;;;
;;; Copyright (C) 2005-2006, James Bielman <[email protected]>
;;; Copyright (C) 2005-2007, Luis Oliveira <[email protected]>
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
;;;
;;; Code borrowed from UFFI is Copyright (c) Kevin M. Rosenberg.
(defpackage #:cffi-uffi-compat
(:nicknames #:uffi) ;; is this a good idea?
(:use #:cl)
(:export
;; immediate types
#:def-constant
#:def-foreign-type
#:def-type
#:null-char-p
;; aggregate types
#:def-enum
#:def-struct
#:get-slot-value
#:get-slot-pointer
#:def-array-pointer
#:deref-array
#:def-union
;; objects
#:allocate-foreign-object
#:free-foreign-object
#:with-foreign-object
#:with-foreign-objects
#:size-of-foreign-type
#:pointer-address
#:deref-pointer
#:ensure-char-character
#:ensure-char-integer
#:ensure-char-storable
#:null-pointer-p
#:make-null-pointer
#:make-pointer
#:+null-cstring-pointer+
#:char-array-to-pointer
#:with-cast-pointer
#:def-foreign-var
#:convert-from-foreign-usb8
#:def-pointer-var
;; string functions
#:convert-from-cstring
#:convert-to-cstring
#:free-cstring
#:with-cstring
#:with-cstrings
#:convert-from-foreign-string
#:convert-to-foreign-string
#:allocate-foreign-string
#:with-foreign-string
#:with-foreign-strings
#:foreign-string-length ; not implemented
#:string-to-octets
#:octets-to-string
#:foreign-encoded-octet-count
;; function call
#:def-function
;; libraries
#:find-foreign-library
#:load-foreign-library
#:default-foreign-library-type
#:foreign-library-types
;; os
#:getenv
#:run-shell-command
))
(in-package #:cffi-uffi-compat)
#+clisp
(eval-when (:compile-toplevel :load-toplevel :execute)
(when (equal (machine-type) "POWER MACINTOSH")
(pushnew :ppc *features*)))
(defun convert-uffi-type (uffi-type)
"Convert a UFFI primitive type to a CFFI type."
;; Many CFFI types are the same as UFFI. This list handles the
;; exceptions only.
(case uffi-type
(:cstring :pointer)
(:pointer-void :pointer)
(:pointer-self :pointer)
;; Although UFFI's documentation claims dereferencing :CHAR and
;; :UNSIGNED-CHAR returns characters, it actually returns
;; integers.
(:char :char)
(:unsigned-char :unsigned-char)
(:byte :char)
(:unsigned-byte :unsigned-char)
(t
(if (listp uffi-type)
(case (car uffi-type)
;; this is imho gross but it is what uffi does
(quote (convert-uffi-type (second uffi-type)))
(* :pointer)
(:array `(uffi-array ,(convert-uffi-type (second uffi-type))
,(third uffi-type)))
(:union (second uffi-type))
(:struct (convert-uffi-type (second uffi-type)))
(:struct-pointer :pointer))
uffi-type))))
(cffi:define-foreign-type uffi-array-type ()
;; ELEMENT-TYPE should be /unparsed/, suitable for passing to mem-aref.
((element-type :initform (error "An element-type is required.")
:accessor element-type :initarg :element-type)
(nelems :initform (error "nelems is required.")
:accessor nelems :initarg :nelems))
(:actual-type :pointer)
(:documentation "UFFI's :array type."))
(cffi:define-parse-method uffi-array (element-type count)
(make-instance 'uffi-array-type :element-type element-type
:nelems (or count 1)))
(defmethod cffi:foreign-type-size ((type uffi-array-type))
(* (cffi:foreign-type-size (element-type type)) (nelems type)))
(defmethod cffi::aggregatep ((type uffi-array-type))
t)
;; UFFI's :(unsigned-)char
#+#:ignore
(cffi:define-foreign-type uffi-char ()
())
#+#:ignore
(cffi:define-parse-method uffi-char (base-type)
(make-instance 'uffi-char :actual-type base-type))
#+#:ignore
(defmethod cffi:translate-to-foreign ((value character) (type uffi-char))
(char-code value))
#+#:ignore
(defmethod cffi:translate-from-foreign (obj (type uffi-char))
(code-char obj))
(defmacro def-type (name type)
"Define a Common Lisp type NAME for UFFI type TYPE."
(declare (ignore type))
`(deftype ,name () t))
(defmacro def-foreign-type (name type)
"Define a new foreign type."
`(cffi:defctype ,name ,(convert-uffi-type type)))
(defmacro def-constant (name value &key export)
"Define a constant and conditionally export it."
`(eval-when (:compile-toplevel :load-toplevel :execute)
(defconstant ,name ,value)
,@(when export `((export ',name)))
',name))
(defmacro null-char-p (val)
"Return true if character is null."
`(zerop (char-code ,val)))
(defmacro def-enum (enum-name args &key (separator-string "#"))
"Creates a constants for a C type enum list, symbols are
created in the created in the current package. The symbol is the
concatenation of the enum-name name, separator-string, and
field-name"
(let ((counter 0)
(cmds nil)
(constants nil))
(declare (fixnum counter))
(dolist (arg args)
(let ((name (if (listp arg) (car arg) arg))
(value (if (listp arg)
(prog1
(setq counter (cadr arg))
(incf counter))
(prog1
counter
(incf counter)))))
(setq name (intern (concatenate 'string
(symbol-name enum-name)
separator-string
(symbol-name name))))
(push `(def-constant ,name ,value) constants)))
(setf cmds (append '(progn) `((cffi:defctype ,enum-name :int))
(nreverse constants)))
cmds))
(defmacro def-struct (name &body fields)
"Define a C structure."
`(cffi:defcstruct ,name
,@(loop for (name uffi-type) in fields
for cffi-type = (convert-uffi-type uffi-type)
collect (list name cffi-type))))
;; TODO: figure out why the compiler macro is kicking in before
;; the setf expander.
(defun %foreign-slot-value (obj type field)
(cffi:foreign-slot-value obj `(:struct ,type) field))
(defun (setf %foreign-slot-value) (value obj type field)
(setf (cffi:foreign-slot-value obj `(:struct ,type) field) value))
(defmacro get-slot-value (obj type field)
"Access a slot value from a structure."
`(%foreign-slot-value ,obj ,type ,field))
;; UFFI uses a different function when accessing a slot whose
;; type is a pointer. We don't need that in CFFI so we use
;; foreign-slot-value too.
(defmacro get-slot-pointer (obj type field)
"Access a pointer slot value from a structure."
`(cffi:foreign-slot-value ,obj ,type ,field))
(defmacro def-array-pointer (name type)
"Define a foreign array type."
`(cffi:defctype ,name (uffi-array ,(convert-uffi-type type) 1)))
(defmacro deref-array (array type position)
"Dereference an array."
`(cffi:mem-aref ,array
,(if (constantp type)
`',(element-type (cffi::parse-type
(convert-uffi-type (eval type))))
`(element-type (cffi::parse-type
(convert-uffi-type ,type))))
,position))
;; UFFI's documentation on DEF-UNION is a bit scarce, I'm not sure
;; if DEFCUNION and DEF-UNION are strictly compatible.
(defmacro def-union (name &body fields)
"Define a foreign union type."
`(cffi:defcunion ,name
,@(loop for (name uffi-type) in fields
for cffi-type = (convert-uffi-type uffi-type)
collect (list name cffi-type))))
(defmacro allocate-foreign-object (type &optional (size 1))
"Allocate one or more instance of a foreign type."
`(cffi:foreign-alloc ,(if (constantp type)
`',(convert-uffi-type (eval type))
`(convert-uffi-type ,type))
:count ,size))
(defmacro free-foreign-object (ptr)
"Free a foreign object allocated by ALLOCATE-FOREIGN-OBJECT."
`(cffi:foreign-free ,ptr))
(defmacro with-foreign-object ((var type) &body body)
"Wrap the allocation of a foreign object around BODY."
`(cffi:with-foreign-object (,var (convert-uffi-type ,type))
,@body))
;; Taken from UFFI's src/objects.lisp
(defmacro with-foreign-objects (bindings &rest body)
(if bindings
`(with-foreign-object ,(car bindings)
(with-foreign-objects ,(cdr bindings)
,@body))
`(progn ,@body)))
(defmacro size-of-foreign-type (type)
"Return the size in bytes of a foreign type."
`(cffi:foreign-type-size (convert-uffi-type ,type)))
(defmacro pointer-address (ptr)
"Return the address of a pointer."
`(cffi:pointer-address ,ptr))
(defmacro deref-pointer (ptr type)
"Dereference a pointer."
`(cffi:mem-ref ,ptr (convert-uffi-type ,type)))
(defsetf deref-pointer (ptr type) (value)
`(setf (cffi:mem-ref ,ptr (convert-uffi-type ,type)) ,value))
(defmacro ensure-char-character (obj &environment env)
"Convert OBJ to a character if it is an integer."
(if (constantp obj env)
(if (characterp obj) obj (code-char obj))
(let ((obj-var (gensym)))
`(let ((,obj-var ,obj))
(if (characterp ,obj-var)
,obj-var
(code-char ,obj-var))))))
(defmacro ensure-char-integer (obj &environment env)
"Convert OBJ to an integer if it is a character."
(if (constantp obj env)
(let ((the-obj (eval obj)))
(if (characterp the-obj) (char-code the-obj) the-obj))
(let ((obj-var (gensym)))
`(let ((,obj-var ,obj))
(if (characterp ,obj-var)
(char-code ,obj-var)
,obj-var)))))
(defmacro ensure-char-storable (obj)
"Ensure OBJ is storable as a character."
`(ensure-char-integer ,obj))
(defmacro make-null-pointer (type)
"Create a NULL pointer."
(declare (ignore type))
`(cffi:null-pointer))
(defmacro make-pointer (address type)
"Create a pointer to ADDRESS."
(declare (ignore type))
`(cffi:make-pointer ,address))
(defmacro null-pointer-p (ptr)
"Return true if PTR is a null pointer."
`(cffi:null-pointer-p ,ptr))
(defparameter +null-cstring-pointer+ (cffi:null-pointer)
"A constant NULL string pointer.")
(defmacro char-array-to-pointer (obj)
obj)
(defmacro with-cast-pointer ((var ptr type) &body body)
"Cast a pointer, does nothing in CFFI."
(declare (ignore type))
`(let ((,var ,ptr))
,@body))
(defmacro def-foreign-var (name type module)
"Define a symbol macro to access a foreign variable."
(declare (ignore module))
(flet ((lisp-name (name)
(intern (cffi-sys:canonicalize-symbol-name-case
(substitute #\- #\_ name)))))
`(cffi:defcvar ,(if (listp name)
name
(list name (lisp-name name)))
,(convert-uffi-type type))))
(defmacro def-pointer-var (name value &optional doc)
#-openmcl `(defvar ,name ,value ,@(if doc (list doc)))
#+openmcl `(ccl::defloadvar ,name ,value ,doc))
(defmacro convert-from-cstring (s)
"Convert a cstring to a Lisp string."
(let ((ret (gensym)))
`(let ((,ret (cffi:foreign-string-to-lisp ,s)))
(if (equal ,ret "")
nil
,ret))))
(defmacro convert-to-cstring (obj)
"Convert a Lisp string to a cstring."
(let ((str (gensym)))
`(let ((,str ,obj))
(if (null ,str)
(cffi:null-pointer)
(cffi:foreign-string-alloc ,str)))))
(defmacro free-cstring (ptr)
"Free a cstring."
`(cffi:foreign-string-free ,ptr))
(defmacro with-cstring ((foreign-string lisp-string) &body body)
"Binds a newly creating string."
(let ((str (gensym)) (body-proc (gensym)))
`(flet ((,body-proc (,foreign-string) ,@body))
(let ((,str ,lisp-string))
(if (null ,str)
(,body-proc (cffi:null-pointer))
(cffi:with-foreign-string (,foreign-string ,str)
(,body-proc ,foreign-string)))))))
;; Taken from UFFI's src/strings.lisp
(defmacro with-cstrings (bindings &rest body)
(if bindings
`(with-cstring ,(car bindings)
(with-cstrings ,(cdr bindings)
,@body))
`(progn ,@body)))
(defmacro def-function (name args &key module (returning :void))
"Define a foreign function."
(declare (ignore module))
`(cffi:defcfun ,name ,(convert-uffi-type returning)
,@(loop for (name type) in args
collect `(,name ,(convert-uffi-type type)))))
;;; Taken from UFFI's src/libraries.lisp
(defvar *loaded-libraries* nil
"List of foreign libraries loaded. Used to prevent reloading a library")
(defun default-foreign-library-type ()
"Returns string naming default library type for platform"
#+(or win32 cygwin mswindows) "dll"
#+(or macos macosx darwin ccl-5.0) "dylib"
#-(or win32 cygwin mswindows macos macosx darwin ccl-5.0) "so")
(defun foreign-library-types ()
"Returns list of string naming possible library types for platform,
sorted by preference"
#+(or win32 cygwin mswindows) '("dll" "lib" "so")
#+(or macos macosx darwin ccl-5.0) '("dylib" "bundle")
#-(or win32 cygwin mswindows macos macosx darwin ccl-5.0) '("so" "a" "o"))
(defun find-foreign-library (names directories &key types drive-letters)
"Looks for a foreign library. directories can be a single
string or a list of strings of candidate directories. Use default
library type if type is not specified."
(unless types
(setq types (foreign-library-types)))
(unless (listp types)
(setq types (list types)))
(unless (listp names)
(setq names (list names)))
(unless (listp directories)
(setq directories (list directories)))
#+(or win32 mswindows)
(unless (listp drive-letters)
(setq drive-letters (list drive-letters)))
#-(or win32 mswindows)
(setq drive-letters '(nil))
(dolist (drive-letter drive-letters)
(dolist (name names)
(dolist (dir directories)
(dolist (type types)
(let ((path (make-pathname
#+lispworks :host
#+lispworks (when drive-letter drive-letter)
#-lispworks :device
#-lispworks (when drive-letter drive-letter)
:name name
:type type
:directory
(etypecase dir
(pathname
(pathname-directory dir))
(list
dir)
(string
(pathname-directory
(parse-namestring dir)))))))
(when (probe-file path)
(return-from find-foreign-library path)))))))
nil)
(defun convert-supporting-libraries-to-string (libs)
(let (lib-load-list)
(dolist (lib libs)
(push (format nil "-l~A" lib) lib-load-list))
(nreverse lib-load-list)))
(defun load-foreign-library (filename &key module supporting-libraries
force-load)
#+(or allegro mcl sbcl clisp) (declare (ignore module supporting-libraries))
#+(or cmu scl sbcl) (declare (ignore module))
(when (and filename (or (null (pathname-directory filename))
(probe-file filename)))
(if (pathnamep filename) ;; ensure filename is a string to check if
(setq filename (namestring filename))) ; already loaded
(if (and (not force-load)
(find filename *loaded-libraries* :test #'string-equal))
t ;; return T, but don't reload library
(progn
;; FIXME: Hmm, what are these two for?
#+cmu
(let ((type (pathname-type (parse-namestring filename))))
(if (string-equal type "so")
(sys::load-object-file filename)
(alien:load-foreign filename
:libraries
(convert-supporting-libraries-to-string
supporting-libraries))))
#+scl
(let ((type (pathname-type (parse-namestring filename))))
(if (string-equal type "so")
(sys::load-dynamic-object filename)
(alien:load-foreign filename
:libraries
(convert-supporting-libraries-to-string
supporting-libraries))))
#-(or cmu scl)
(cffi:load-foreign-library filename)
(push filename *loaded-libraries*)
t))))
;; Taken from UFFI's src/os.lisp
(defun getenv (var)
"Return the value of the environment variable."
#+allegro (sys::getenv (string var))
#+clisp (sys::getenv (string var))
#+(or cmu scl) (cdr (assoc (string var) ext:*environment-list* :test #'equalp
:key #'string))
#+(or ecl gcl) (si:getenv (string var))
#+lispworks (lw:environment-variable (string var))
#+lucid (lcl:environment-variable (string var))
#+(or mcl ccl) (ccl::getenv var)
#+sbcl (sb-ext:posix-getenv var)
#-(or allegro clisp cmu ecl scl gcl lispworks lucid mcl ccl sbcl)
(error 'not-implemented :proc (list 'getenv var)))
;; Taken from UFFI's src/os.lisp
;; modified from function ASDF -- Copyright Dan Barlow and Contributors
(defun run-shell-command (control-string &rest args)
"Interpolate ARGS into CONTROL-STRING as if by FORMAT, and
synchronously execute the result using a Bourne-compatible shell, with
output to *trace-output*. Returns the shell's exit code."
(let ((command (apply #'format nil control-string args))
(output *trace-output*))
#+sbcl
(sb-impl::process-exit-code
(sb-ext:run-program
"/bin/sh"
(list "-c" command)
:input nil :output output))
#+(or cmu scl)
(ext:process-exit-code
(ext:run-program
"/bin/sh"
(list "-c" command)
:input nil :output output))
#+allegro
(excl:run-shell-command command :input nil :output output)
#+lispworks
(system:call-system-showing-output
command
:shell-type "/bin/sh"
:output-stream output)
#+clisp ;XXX not exactly *trace-output*, I know
(ext:run-shell-command command :output :terminal :wait t)
#+openmcl
(nth-value 1
(ccl:external-process-status
(ccl:run-program "/bin/sh" (list "-c" command)
:input nil :output output
:wait t)))
#+ecl
(nth-value 1
(ext:run-program
"/bin/sh" (list "-c" command)
:input nil :output output :error nil :wait t))
#-(or openmcl ecl clisp lispworks allegro scl cmu sbcl)
(error "RUN-SHELL-PROGRAM not implemented for this Lisp")
))
;;; Some undocumented UFFI operators...
(defmacro convert-from-foreign-string
(obj &key length (locale :default)
(encoding 'cffi:*default-foreign-encoding*)
(null-terminated-p t))
;; in effect, (eq NULL-TERMINATED-P (null LENGTH)). Hopefully,
;; that's compatible with the intended semantics, which are
;; undocumented. If that's not the case, we can implement
;; NULL-TERMINATED-P in CFFI:FOREIGN-STRING-TO-LISP.
(declare (ignore locale null-terminated-p))
(let ((ret (gensym)))
`(let ((,ret (cffi:foreign-string-to-lisp ,obj
:count ,length
:encoding ,encoding)))
(if (equal ,ret "")
nil
,ret))))
;; What's the difference between this and convert-to-cstring?
(defmacro convert-to-foreign-string
(obj &optional (encoding 'cffi:*default-foreign-encoding*))
(let ((str (gensym)))
`(let ((,str ,obj))
(if (null ,str)
(cffi:null-pointer)
(cffi:foreign-string-alloc ,str :encoding ,encoding)))))
(defmacro allocate-foreign-string (size &key unsigned)
(declare (ignore unsigned))
`(cffi:foreign-alloc :char :count ,size))
;; Ditto.
(defmacro with-foreign-string ((foreign-string lisp-string) &body body)
(let ((str (gensym)))
`(let ((,str ,lisp-string))
(if (null ,str)
(let ((,foreign-string (cffi:null-pointer)))
,@body)
(cffi:with-foreign-string (,foreign-string ,str)
,@body)))))
(defmacro with-foreign-strings (bindings &body body)
`(with-foreign-string ,(car bindings)
,@(if (cdr bindings)
`((with-foreign-strings ,(cdr bindings) ,@body))
body)))
;; This function returns a form? Where is this used in user-code?
(defun foreign-string-length (foreign-string)
(declare (ignore foreign-string))
(error "FOREIGN-STRING-LENGTH not implemented."))
;; This should be optimized.
(defun convert-from-foreign-usb8 (s len)
(let ((a (make-array len :element-type '(unsigned-byte 8))))
(dotimes (i len a)
(setf (aref a i) (cffi:mem-ref s :unsigned-char i)))))
;;;; String Encodings
(defmacro string-to-octets (str &key encoding null-terminate)
`(babel:concatenate-strings-to-octets
(or ,encoding cffi:*default-foreign-encoding*)
,str
(if ,null-terminate
#.(string #\Nul)
"")))
(defmacro octets-to-string (octets &key encoding)
`(babel:octets-to-string ,octets
:encoding (or ,encoding
cffi:*default-foreign-encoding*)))
(defun foreign-encoded-octet-count (str &key encoding)
(babel:string-size-in-octets str
:encoding (or encoding
cffi:*default-foreign-encoding*)))
| 22,634 | Common Lisp | .lisp | 575 | 32.54087 | 79 | 0.634411 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | dcc3701094a00c4df489e8b1026d23f2c1806874bbabe9d052da24eda99b80f0 | 30,532 | [
443025
] |
30,533 | split-sequence.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/split-sequence-1.2/split-sequence.lisp | ;;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; SPLIT-SEQUENCE
;;;
;;; This code was based on Arthur Lemmens' in
;;; <URL:http://groups.google.com/groups?as_umsgid=39F36F1A.B8F19D20%40simplex.nl>;
;;;
;;; changes include:
;;;
;;; * altering the behaviour of the :from-end keyword argument to
;;; return the subsequences in original order, for consistency with
;;; CL:REMOVE, CL:SUBSTITUTE et al. (:from-end being non-NIL only
;;; affects the answer if :count is less than the number of
;;; subsequences, by analogy with the above-referenced functions).
;;;
;;; * changing the :maximum keyword argument to :count, by analogy
;;; with CL:REMOVE, CL:SUBSTITUTE, and so on.
;;;
;;; * naming the function SPLIT-SEQUENCE rather than PARTITION rather
;;; than SPLIT.
;;;
;;; * adding SPLIT-SEQUENCE-IF and SPLIT-SEQUENCE-IF-NOT.
;;;
;;; * The second return value is now an index rather than a copy of a
;;; portion of the sequence; this index is the `right' one to feed to
;;; CL:SUBSEQ for continued processing.
;;; There's a certain amount of code duplication here, which is kept
;;; to illustrate the relationship between the SPLIT-SEQUENCE
;;; functions and the CL:POSITION functions.
(defpackage :split-sequence
(:use :common-lisp)
(:export #:split-sequence
#:split-sequence-if
#:split-sequence-if-not))
(in-package :split-sequence)
(macrolet ((check-bounds (sequence start end)
(let ((length (gensym (string '#:length))))
`(let ((,length (length ,sequence)))
(check-type ,start unsigned-byte "a non-negative integer")
(when ,end (check-type ,end unsigned-byte "a non-negative integer or NIL"))
(unless ,end
(setf ,end ,length))
(unless (<= ,start ,end ,length)
(error "Wrong sequence bounds. start: ~S end: ~S" ,start ,end))))))
(defun split-sequence (delimiter sequence &key (start 0) (end nil) (from-end nil)
(count nil) (remove-empty-subseqs nil)
(test #'eql) (test-not nil) (key #'identity))
"Return a list of subsequences in seq delimited by delimiter.
If :remove-empty-subseqs is NIL, empty subsequences will be included
in the result; otherwise they will be discarded. All other keywords
work analogously to those for CL:SUBSTITUTE. In particular, the
behaviour of :from-end is possibly different from other versions of
this function; :from-end values of NIL and T are equivalent unless
:count is supplied. The second return value is an index suitable as an
argument to CL:SUBSEQ into the sequence indicating where processing
stopped."
(check-bounds sequence start end)
(cond
((and (not from-end) (null test-not))
(split-from-start (lambda (sequence start)
(position delimiter sequence :start start :key key :test test))
sequence start end count remove-empty-subseqs))
((and (not from-end) test-not)
(split-from-start (lambda (sequence start)
(position delimiter sequence :start start :key key :test-not test-not))
sequence start end count remove-empty-subseqs))
((and from-end (null test-not))
(split-from-end (lambda (sequence end)
(position delimiter sequence :end end :from-end t :key key :test test))
sequence start end count remove-empty-subseqs))
((and from-end test-not)
(split-from-end (lambda (sequence end)
(position delimiter sequence :end end :from-end t :key key :test-not test-not))
sequence start end count remove-empty-subseqs))))
(defun split-sequence-if (predicate sequence &key (start 0) (end nil) (from-end nil)
(count nil) (remove-empty-subseqs nil) (key #'identity))
"Return a list of subsequences in seq delimited by items satisfying
predicate.
If :remove-empty-subseqs is NIL, empty subsequences will be included
in the result; otherwise they will be discarded. All other keywords
work analogously to those for CL:SUBSTITUTE-IF. In particular, the
behaviour of :from-end is possibly different from other versions of
this function; :from-end values of NIL and T are equivalent unless
:count is supplied. The second return value is an index suitable as an
argument to CL:SUBSEQ into the sequence indicating where processing
stopped."
(check-bounds sequence start end)
(if from-end
(split-from-end (lambda (sequence end)
(position-if predicate sequence :end end :from-end t :key key))
sequence start end count remove-empty-subseqs)
(split-from-start (lambda (sequence start)
(position-if predicate sequence :start start :key key))
sequence start end count remove-empty-subseqs)))
(defun split-sequence-if-not (predicate sequence &key (count nil) (remove-empty-subseqs nil)
(from-end nil) (start 0) (end nil) (key #'identity))
"Return a list of subsequences in seq delimited by items satisfying
\(CL:COMPLEMENT predicate).
If :remove-empty-subseqs is NIL, empty subsequences will be included
in the result; otherwise they will be discarded. All other keywords
work analogously to those for CL:SUBSTITUTE-IF-NOT. In particular,
the behaviour of :from-end is possibly different from other versions
of this function; :from-end values of NIL and T are equivalent unless
:count is supplied. The second return value is an index suitable as an
argument to CL:SUBSEQ into the sequence indicating where processing
stopped."
(check-bounds sequence start end)
(if from-end
(split-from-end (lambda (sequence end)
(position-if-not predicate sequence :end end :from-end t :key key))
sequence start end count remove-empty-subseqs)
(split-from-start (lambda (sequence start)
(position-if-not predicate sequence :start start :key key))
sequence start end count remove-empty-subseqs))))
(defun split-from-end (position-fn sequence start end count remove-empty-subseqs)
(loop
:for right := end :then left
:for left := (max (or (funcall position-fn sequence right) -1)
(1- start))
:unless (and (= right (1+ left))
remove-empty-subseqs) ; empty subseq we don't want
:if (and count (>= nr-elts count))
;; We can't take any more. Return now.
:return (values (nreverse subseqs) right)
:else
:collect (subseq sequence (1+ left) right) into subseqs
:and :sum 1 :into nr-elts
:until (< left start)
:finally (return (values (nreverse subseqs) (1+ left)))))
(defun split-from-start (position-fn sequence start end count remove-empty-subseqs)
(let ((length (length sequence)))
(loop
:for left := start :then (+ right 1)
:for right := (min (or (funcall position-fn sequence left) length)
end)
:unless (and (= right left)
remove-empty-subseqs) ; empty subseq we don't want
:if (and count (>= nr-elts count))
;; We can't take any more. Return now.
:return (values subseqs left)
:else
:collect (subseq sequence left right) :into subseqs
:and :sum 1 :into nr-elts
:until (>= right end)
:finally (return (values subseqs right)))))
(pushnew :split-sequence *features*)
| 7,630 | Common Lisp | .lisp | 146 | 44.013699 | 104 | 0.654932 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | de7d5baac3be61339022a39619f1f429a455855f0c378fbb926377e92f46eac5 | 30,533 | [
172427
] |
30,534 | tests.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/split-sequence-1.2/tests.lisp | ;;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
(defpackage :split-sequence-tests
(:use :common-lisp :split-sequence :fiveam))
(in-package :split-sequence-tests)
(in-suite* :split-sequence)
;;;; SPLIT-SEQUENCE
(test (split-sequence.1 :compile-at :definition-time)
(is (equalp (split-sequence #\; "a;;b;c")
(values '("a" "" "b" "c") 6))))
(test (split-sequence.2 :compile-at :definition-time)
(is (equalp (split-sequence #\; "a;;b;c" :from-end t)
(values '("a" "" "b" "c") 0))))
(test (split-sequence.3 :compile-at :definition-time)
(is (equalp (split-sequence #\; "a;;b;c" :from-end t :count 1)
(values '("c") 4))))
(test (split-sequence.4 :compile-at :definition-time)
(is (equalp (split-sequence #\; "a;;b;c" :remove-empty-subseqs t)
(values '("a" "b" "c") 6))))
(test (split-sequence.5 :compile-at :definition-time)
(is (equalp (split-sequence #\; ";oo;bar;ba;" :start 1 :end 9)
(values '("oo" "bar" "b") 9))))
(test (split-sequence-if.1 :compile-at :definition-time)
(is (equalp (split-sequence-if (lambda (x) (member x '(#\a #\b))) "abracadabra")
(values '("" "" "r" "c" "d" "" "r" "") 11))))
(test (split-sequence-if-not.1 :compile-at :definition-time)
(is (equalp (split-sequence-if-not (lambda (x) (member x '(#\a #\b))) "abracadabra")
(values '("ab" "a" "a" "ab" "a") 11))))
| 1,408 | Common Lisp | .lisp | 27 | 46.518519 | 86 | 0.580292 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 11737f54805d053908dba3214520a1ef9a7f4afb4436c77732d353cc7f2b33dc | 30,534 | [
381388
] |
30,535 | bindings.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-openal-20150302-git/alc/bindings.lisp | (in-package :%alc)
(define-foreign-library al
(:windows "OpenAL32.dll" :calling-convention :stdcall)
(:darwin (:or (:default "libopenal") (:framework "openal")))
(:unix (:or "libopenal.so" "libopenal.so.1"))
(t (:default "libopenal")))
(use-foreign-library al)
(defcstruct device)
(defcstruct context)
(defctype boolean (:boolean :unsigned-char))
(defcenum attribute
(:frequency #x1007)
(:refresh #x1008)
(:sync #x1009)
(:mono-sources #x1010)
(:stereo-sources #x1011))
(defcenum error
(:no-error #x0000)
(:invalid-device #xA001)
(:invalid-context #xA002)
(:invalid-enum #xA003)
(:invalid-value #xA004)
(:out-of-memory #xA005))
(defcenum enum
(:false #x0000)
(:true #x0001)
(:frequency #x1007)
(:refresh #x1008)
(:sync #x1009)
(:mono-sources #x1010)
(:stereo-sources #x1011)
(:no-error #x0000)
(:invalid-device #xA001)
(:invalid-context #xA002)
(:invalid-enum #xA003)
(:invalid-value #xA004)
(:out-of-memory #xA005)
(:default-device-specifier #x1004)
(:device-specifier #x1005)
(:extensions #x1006)
(:major-version #x1000)
(:minor-version #x1001)
(:attributes-size #x1002)
(:all-attributes #x1003)
(:default-all-devices-specifier #x1012)
(:all-devices-specifier #x1013)
(:capture-device-specifier #x310)
(:capture-default-device-specifier #x311)
(:capture-samples #x312))
;; Context Management
(defcfun ("alcCreateContext" create-context) :pointer (device device) (attrlist (:pointer attribute)))
(defcfun ("alcMakeContextCurrent" make-context-current) :boolean (context context))
(defcfun ("alcProcessContext" process-context) :void (context context))
(defcfun ("alcSuspendContext" suspend-context) :void (context context))
(defcfun ("alcDestroyContext" destroy-context) :void (context context))
(defcfun ("alcGetCurrentContext" get-current-context) context)
(defcfun ("alcGetContextsDevice" get-contexts-device) device (context context))
;; Device Management
(defcfun ("alcOpenDevice" open-device) device (device-name :string))
(defcfun ("alcCloseDevice" close-device) :boolean (device device))
;; Error support
(defcfun ("alcGetError" get-error) error (device device))
;; Extension support
(defcfun ("alcIsExtensionPresent" is-extension-present) :boolean (device device) (extname :string))
(defcfun ("alcGetProcAddress" get-proc-address) :pointer (funcname :string))
(defcfun ("alcGetEnumValue" get-enum-value) enum (device device) (enumname :string))
;; Query functions
(defcfun ("alcGetString" get-string) :string (device device) (param enum))
(defcfun ("alcGetIntegerv" get-integer-v) :void
(device device) (param enum) (size :int) (data :pointer))
;; Capture functions
(defcfun ("alcCaptureOpenDevice" capture-open-device) device
(device-name :string) (frequency :uint) (format enum) (buffer-size :int))
(defcfun ("alcCaptureCloseDevice" capture-close-device) :boolean (device device))
(defcfun ("alcCaptureStart" capture-start) :void (device device))
(defcfun ("alcCaptureStop" capture-stop) :void (device device))
(defcfun ("alcCaptureSamples" capture-samples) :void
(device device) (buffer :pointer) (samples :int))
| 3,122 | Common Lisp | .lisp | 78 | 37.782051 | 102 | 0.740521 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 9c125e4f79180ae38fc66716f87c83d3edb1dc7a37967d9415e9f11790b96d7c | 30,535 | [
-1
] |
30,536 | alc.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-openal-20150302-git/alc/alc.lisp | (in-package :alc)
(defun load-libraries ()
(cffi:define-foreign-library al
(:windows "OpenAL32.dll" :calling-convention :stdcall)
(:darwin (:or (:default "libopenal") (:framework "openal")))
(:unix (:or "libopenal.so" "libopenal.so.1"))
(t (:default "libopenal")))
(cffi:use-foreign-library al))
(defun open-device (&optional device-name)
(let ((foreign-dev (%alc:open-device (or device-name
(cffi:null-pointer)))))
(if (cffi:null-pointer-p foreign-dev)
nil
foreign-dev)))
(defun close-device (device)
(%alc:close-device device))
(defun create-context (device &rest attributes)
(let ((foreign-ctx
(%alc:create-context device
(if attributes
(let ((n (length attributes)))
(cffi:with-foreign-object (attrlist '%alc:attribute n)
(loop for i below n
do (setf (cffi:mem-aref attrlist '%alc:attribute i)
(elt attributes i)))
attrlist))
(cffi:null-pointer)))))
(if (cffi:null-pointer-p foreign-ctx)
nil
foreign-ctx)))
(defun make-context-current (context)
(%alc:make-context-current context))
(defun process-context (context)
(%alc:process-context context))
(defun suspend-context (context)
(%alc:suspend-context context))
(defun destroy-context (context)
(%alc:destroy-context context))
(defun get-current-context ()
(%alc:get-current-context))
(defun get-contexts-device (context)
(%alc:get-contexts-device context))
(defun get-error (device)
(%alc:get-error device))
(defun extension-present-p (device extname)
(%alc:is-extension-present device extname))
(defun get-proc-address (funcname)
(%alc:get-proc-address funcname))
(defun get-enum-value (device enum-name)
(%alc:get-enum-value device enum-name))
(defun get-string (device param)
(%alc:get-string device param))
(defun get-integer (device param)
(cffi:with-foreign-object (size-arr :int 1)
(%alc:get-integer-v device :attributes-size 1 size-arr)
(let ((size (cffi:mem-aref size-arr :int 0)))
(cffi:with-foreign-object (int-list :int size)
(%alc:get-integer-v device param size int-list)
(loop for i below size
collect (cffi:mem-aref int-list :int i))))))
(defun capture-open-device (device-name frequency format buffer-size)
(%alc:capture-open-device device-name
(coerce frequency 'integer)
format
(coerce buffer-size 'integer)))
(defun capture-close-device (device)
(%alc:capture-close-device device))
(defun capture-start (device)
(%alc:capture-start device))
(defun capture-stop (device)
(%alc:capture-stop device))
(defun capture-samples (device samples)
(let ((n-samples (length samples)))
(cffi:with-foreign-object (buffer :pointer n-samples)
(loop for i below n-samples
do (setf (cffi:mem-aref buffer i)
(elt samples i)))
(%alc:capture-samples device buffer n-samples))))
;;;
;;; Helper macros to keep the world tidy.
;;;
(defmacro with-capture-device ((var device-name frequency
format buffer-size) &body body)
`(let ((,var (capture-open-device ,device-name ,frequency
,format ,buffer-size)))
(unwind-protect
(progn
,@body)
(when ,var (capture-close-device ,var)))))
(defmacro with-device ((var &optional (device-name nil)) &body body)
`(let ((,var (open-device ,device-name)))
(unwind-protect
(progn
,@body)
(when ,var (close-device ,var)))))
(defmacro with-context ((var device &rest attributes) &body body)
`(let ((,var ,(if attributes
`(create-context ,device ,@attributes)
`(create-context ,device))))
(unwind-protect
(progn
,@body)
(when ,var
(when (cffi:pointer-eq ,var (get-current-context))
(make-context-current (cffi:null-pointer)))
(destroy-context ,var)))))
| 4,320 | Common Lisp | .lisp | 106 | 31.386792 | 92 | 0.595522 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | eab71fc2f3ceb822782e0b093ebdc9640c2ac82d8c34098faeb47a05c195ef18 | 30,536 | [
-1
] |
30,537 | packages.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-openal-20150302-git/alc/packages.lisp | (defpackage #:alc-cffi-bindings
(:use :cl :cffi)
(:nicknames :%alc)
(:shadow :boolean)
(:export
:attribute :error :enum :device :context :boolean
;; Context management
:create-context :make-context-current :process-context :suspend-context :destroy-context
:get-current-context :get-contexts-device
;; device management
:open-device :close-device
;; errors
:get-error
;; extensions
:is-extension-present :get-proc-address :get-enum-value
;; query functions
:get-string :get-integer-v
;; capture functions
:capture-open-device :capture-close-device :capture-start :capture-stop :capture-samples))
(defpackage #:cl-openal-alc
(:use :cl)
(:nicknames :alc)
(:export
#:load-libraries
:open-device :close-device :create-context :make-context-current :process-context :suspend-context
:destroy-context :get-current-context :get-contexts-device :get-error :extension-present-p
:get-proc-address :get-enum-value :get-string :get-integer :capture-open-device
:capture-close-device :capture-start :capture-stop :capture-samples
:with-device :with-capture-device :with-context)) | 1,144 | Common Lisp | .lisp | 29 | 35.827586 | 101 | 0.734529 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | b76d5e7837905b296c6fc357343d02962e203645b6e225316ec9aab1135627bd | 30,537 | [
-1
] |
30,538 | lesson2.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-openal-20150302-git/examples/lesson2.lisp | ;;;
;;; Lesson 2 - Looping and fadeaway
;;;
;;; Common Lisp adaptation of
;;; http://www.devmaster.net/articles/openal-tutorials/lesson2.php
;;;
;;; (LESSON2) will use about 25 seconds of your time.
;;;
(in-package #:cl-openal-examples)
(export 'lesson2)
(defun init-source-data (sourcepos sourcevel)
(let ((buffer (al:gen-buffer))
(source (al:gen-source))
(data (alut:load-memory-hello-world)))
;; AL:GET-ERROR somewhere about here
;; is generally a good idea.
(al:buffer-data buffer :mono16 data 16356 11025)
(al:source source :buffer buffer)
(al:source source :pitch 1.0)
(al:source source :gain 1.0)
(al:source source :position sourcepos)
(al:source source :velocity sourcevel)
(al:source source :looping t)
;; GET-ERROR to see this all went smooth.
(values buffer source data)))
(defun init-listener ()
(al:listener :position #(0 0 0))
(al:listener :velocity #(0 0 0))
(al:listener :orientation #(0.0 0.0 -1.0
0.0 1.0 0.0)))
(defun lesson2 ()
(let ((sourcepos #(0.0 0.0 0.0))
(sourcevel #(0.0 0.0 0.1)))
(alut:with-init
(multiple-value-bind (buffer source data)
;; m-v-b? I'm worried SBCL will forget about
;; BUFFER and DATA. They're in C space.
(init-source-data sourcepos sourcevel)
(declare (ignore buffer data))
(init-listener)
(al:source-play source)
(dotimes (i 250)
(sleep 0.1)
(setf sourcepos (map 'vector #'+ sourcepos sourcevel))
(al:source source :position sourcepos)))))) ; Move source.
| 1,609 | Common Lisp | .lisp | 45 | 30.644444 | 66 | 0.635022 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 908ce86c4c42441f94721df080fc15b988bf22b720181a755052298f9ce0f521 | 30,538 | [
-1
] |
30,539 | getting-started.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-openal-20150302-git/examples/getting-started.lisp | ;;;
;;; http://www.devmaster.net/articles/openal/
;;;
(in-package #:cl-openal-examples)
(export 'getting-started)
(defun getting-started ()
(let ((data nil))
(alut:with-init
;; Init alut so LOAD-MEMORY-HELLO-WORLD works.
;; But leave alut so we can grab the device using
;; WITH-DEVICE.
;; (setf data (alut:load-memory-from-file "bleep.wav")
;; is a fun alternative!
(setf data (alut:load-memory-hello-world)))
(alc:with-device (device)
;; Here it is appropriate to check so
;; device is actually opened. GET-ERROR
;; for example.
(alc:with-context (context device)
(alc:make-context-current context)
;; Again: GET-ERROR.
(al:with-buffer (buffer)
(al:with-source (source)
(al:buffer-data buffer #x1101 data 16356 11025)
;; How do I know format, size, freq?
;; LOAD-MEMORY-HELLO-WORLD told me.
;; The appropirate thing to do if you don't
;; know these values is m-v-b.
;; Link source to buffer, and place
;; source at (1 1 1).
(al:source source :buffer buffer)
(al:source source :position #(1 1 1))
(al:source source :velocity #(0 0 0))
;; Place listener at (1 1 1), and have it
;; face (0 0 0).
(al:listener :position #(1 1 1))
(al:listener :orientation #(0 0 0
0 0 0))
;; Let the music play...
(al:source source :looping :true)
(al:source-play source)
(sleep 10)
(al:source-stop source)))))))
| 1,668 | Common Lisp | .lisp | 43 | 29.093023 | 60 | 0.552064 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | e6df467af3bea66629e4f17b52cd728a5ce90a4f641e59caed36aab79b7aee37 | 30,539 | [
-1
] |
30,540 | alut-hello-world.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-openal-20150302-git/examples/alut-hello-world.lisp | ;;;
;;; This is the traditional 'Hello, world!' alut style.
;;;
;;; For C version consult
;;; http://connect.creativelabs.com/openal/Documentation/The%20OpenAL%20Utility%20Toolkit.htm
;;;
(in-package #:cl-openal-examples)
(export 'alut-hello-world)
(defun alut-hello-world ()
(alut:with-init
(al:with-source (source)
(let ((buffer (alut:create-buffer-hello-world)))
(al:source source :buffer buffer)
(al:source-play source)
(alut:sleep 1)))))
| 481 | Common Lisp | .lisp | 15 | 28.533333 | 93 | 0.68319 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | c0944664bd66e7a3f13fded8e198a899c259ccf26ae8d14961c702e54bcd9d7b | 30,540 | [
-1
] |
30,541 | bindings.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-openal-20150302-git/al/bindings.lisp | (in-package :%al)
(define-foreign-library al
(:windows "OpenAL32.dll" :calling-convention :stdcall)
(:darwin (:or (:default "libopenal") (:framework "openal")))
(:unix (:or "libopenal.so" "libopenal.so.1"))
(t (:default "libopenal")))
(use-foreign-library al)
(define-foreign-type ensure-integer ()
()
(:actual-type :int)
(:simple-parser ensure-integer))
(defmethod translate-to-foreign (value (type ensure-integer))
(truncate value))
(defmethod expand-to-foreign (value (type ensure-integer))
(if (constantp value)
(truncate (eval value))
`(truncate ,value)))
(define-foreign-type ensure-float ()
()
(:actual-type :float)
(:simple-parser ensure-float))
(defmethod translate-to-foreign (value (type ensure-float))
(cl:float value 1.0))
(defmethod expand-to-foreign (value (type ensure-float))
(if (constantp value)
(cl:float (eval value) 1.0)
`(cl:float ,value 1.0)))
(define-foreign-type ensure-double ()
()
(:actual-type :double)
(:simple-parser ensure-double))
(defmethod translate-to-foreign (value (type ensure-double))
(cl:float value 1.0d0))
(defmethod expand-to-foreign (value (type ensure-double))
(if (constantp value)
(cl:float (eval value) 1.0d0)
`(cl:float ,value 1.0d0)))
(defctype boolean (:boolean :char))
(defctype byte (:char))
(defctype ubyte (:unsigned-char))
(defcenum enum
(:none #x0000)
(:false #x0000)
(:true #x0001)
(:source-relative #x202)
(:cone-inner-angle #x1001)
(:cone-outer-angle #x1002)
(:pitch #x1003)
;; Location
(:position #x1004)
(:direction #x1005)
(:velocity #x1006)
(:looping #x1007)
(:buffer #x1009)
(:gain #x100A)
(:min-gain #x100D)
(:max-gain #x100E)
(:orientation #x100F)
(:source-state #x1010)
(:initial #x1011)
(:playing #x1012)
(:paused #x1013)
(:stopped #x1014)
(:buffers-queued #x1015)
(:buffers-processed #x1016)
(:sec-offset #x1024)
(:sample-offset #x1025)
(:byte-offset #x1026)
;; Source types
(:source-type #x1027)
(:static #x1028)
(:streaming #x1029)
(:undetermined #x1030)
;; sound sample formats
(:mono8 #x1100)
(:mono16 #x1101)
(:stereo8 #x1102)
(:stereo16 #x1103)
;; more sound sample stuff?
(:reference-distance #x1020)
(:rolloff-factor #x1021)
(:cone-outer-gain #x1022)
(:max-distance #x1023)
;; Sound sample frequency
;; Buffer state
(:unused #x2010)
(:pending #x2011)
(:processed #x2012)
;; errors
(:no-error #x0000)
(:invalid-name #xA001)
(:invalid-enum #xA002)
(:invalid-value #xA003)
(:invalid-operation #xA004)
(:out-of-memory #xA005)
;; Context strings: vendor name
(:vendor #xB001)
(:version #xB002)
(:renderer #xB003)
(:extensions #xB004)
;; Global tweakage
(:doppler-factor #xC000)
(:doppler-velocity #xC001)
(:speed-of-sound #xC003)
;; Distance model
(:distance-model #xD000)
(:inverse-distance #xD001)
(:inverse-distance-clamped #xD002)
(:linear-distance #xD003)
(:linear-distance-clamped #xD004)
(:exponent-distance #xD005)
(:exponent-distance-clamped #xD006))
(defcenum format
(:frequency #x2001)
(:bits #x2002)
(:channels #x2003)
(:size #x2004))
;; Renderer State management
(defcfun ("alEnable" enable) :void (capability enum))
(defcfun ("alDisable" disable) :void (capability enum))
(defcfun ("alIsEnabled" is-enabled) :boolean (capability enum))
;; State retrieval
(defcfun ("alGetString" get-string) :string (param enum))
(defcfun ("alGetBooleanv" get-boolean-v) :void (param enum) (data :pointer))
(defcfun ("alGetIntegerv" get-integer-v) :void (param enum) (data :pointer))
(defcfun ("alGetFloatv" get-float-v) :void (param enum) (data :pointer))
(defcfun ("alGetDoublev" get-double-v) :void (param enum) (data :pointer))
(defcfun ("alGetBoolean" get-boolean) :void (param enum))
(defcfun ("alGetInteger" get-integer) :void (param enum))
(defcfun ("alGetFloat" get-float) :void (param enum))
(defcfun ("alGetDouble" get-double) :void (param enum))
;; Error support
(defcfun ("alGetError" get-error) enum)
;; Extension support
(defcfun ("alIsExtensionPresent" is-extension-present) :boolean (extname :string))
(defcfun ("alGetProcAddress" get-proc-address) :void (fname :string))
(defcfun ("alGetEnumValue" get-enum-value) enum (ename :string))
;;;
;;; Listener
;;;
;; Set Listener parameters
(defcfun ("alListenerf" listener-f) :void (param enum) (value :float))
(defcfun ("alListener3f" listener-3f) :void
(param enum) (value1 ensure-float) (value2 ensure-float) (value3 ensure-float))
(defcfun ("alListenerfv" listener-fv) :void (param enum) (values :pointer))
(defcfun ("alListeneri" listener-i) :void (param enum) (value :int))
(defcfun ("alListener3i" listener-3i) :void
(param enum) (value1 :int) (value2 :int) (value3 :int))
(defcfun ("alListeneriv" listener-iv) :void (param enum) (values :pointer))
;; Get Listener parameters
(defcfun ("alGetListenerf" get-listener-f) :void (param enum) (value :pointer))
(defcfun ("alGetListener3f" get-listener-3f) :void
(param enum) (value1 :pointer) (value2 :pointer) (value3 :pointer))
(defcfun ("alGetListenerfv" get-listener-fv) :void (param enum) (values :pointer))
(defcfun ("alGetListeneri" get-listener-i) :void (param enum) (value :pointer))
(defcfun ("alGetListener3i" get-listener-3i) :void
(param enum) (value1 :pointer) (value2 :pointer) (value3 :pointer))
(defcfun ("alGetListeneriv" get-listener-iv) :void (param enum) (values :pointer))
;;;
;;; Sources
;;;
;; Source objects
(defcfun ("alGenSources" gen-sources) :void (n :int) (sources :pointer))
(defcfun ("alDeleteSources" delete-sources) :void (n :int) (sources :pointer))
(defcfun ("alIsSource" is-source) :boolean (sid :uint))
;; Set Source parameters
(defcfun ("alSourcef" source-f) :void (sid :uint) (param enum) (value :float))
(defcfun ("alSource3f" source-3f) :void
(sid :uint) (param enum) (value1 ensure-float) (value2 ensure-float) (value3 ensure-float))
(defcfun ("alSourcefv" source-fv) :void (sid :uint) (param enum) (values :pointer))
(defcfun ("alSourcei" source-i) :void (sid :uint) (param enum) (value :int))
(defcfun ("alSource3i" source-3i) :void
(sid :uint) (param enum) (value1 :int) (value2 :int) (value3 :int))
(defcfun ("alSourceiv" source-iv) :void (sid :uint) (param enum) (values :pointer))
;; Get Source parameters
(defcfun ("alGetSourcef" get-source-f) :void (sid :uint) (param enum) (value :pointer))
(defcfun ("alGetSource3f" get-source-3f) :void
(sid :uint) (param enum) (value1 :pointer) (value2 :pointer) (value3 :pointer))
(defcfun ("alGetSourcefv" get-source-fv) :void (sid :uint) (param enum) (values :pointer))
(defcfun ("alGetSourcei" get-source-i) :void (sid :uint) (param enum) (value :pointer))
(defcfun ("alGetSource3i" get-source-3i) :void
(sid :uint) (param enum) (value1 :pointer) (value2 :pointer) (value3 :pointer))
(defcfun ("alGetSourceiv" get-source-iv) :void (sid :uint) (param enum) (values :pointer))
;;; Playback
;; Source vector based
(defcfun ("alSourcePlayv" source-play-v) :void (ns :int) (sids :pointer))
(defcfun ("alSourceStopv" source-stop-v) :void (ns :int) (sids :pointer))
(defcfun ("alSourceRewindv" source-rewind-v) :void (ns :int) (sids :pointer))
(defcfun ("alSourcePausev" source-pause-v) :void (ns :int) (sids :pointer))
;; Source based
(defcfun ("alSourcePlay" source-play) :void (sid :uint))
(defcfun ("alSourceStop" source-stop) :void (sid :uint))
(defcfun ("alSourceRewind" source-rewind) :void (sid :uint))
(defcfun ("alSourcePause" source-pause) :void (sid :uint))
;; Source Queueing
(defcfun ("alSourceQueueBuffers" source-queue-buffers) :void
(sid :uint) (num-entries :int) (bids :pointer))
(defcfun ("alSourceUnqueueBuffers" source-unqueue-buffers) :void
(sid :uint) (num-entries :int) (bids :pointer))
;;;
;;; Buffer
;;;
;; Buffer objects
(defcfun ("alGenBuffers" gen-buffers) :void (n :int) (buffer-names :pointer))
(defcfun ("alDeleteBuffers" delete-buffers) :void (n :int) (buffer-names :pointer))
(defcfun ("alIsBuffer" is-buffer) :boolean (bid :uint))
(defcfun ("alBufferData" buffer-data) :void
(bid :uint) (format enum) (data :pointer) (size :uint) (freq :int))
;; Set Buffer parameters
(defcfun ("alBufferf" buffer-f) :void (bid :uint) (param enum) (value :float))
(defcfun ("alBuffer3f" buffer-3f) :void
(bid :uint) (param enum) (value1 ensure-float) (value2 ensure-float) (value3 ensure-float))
(defcfun ("alBufferfv" buffer-fv) :void (bid :uint) (param enum) (values :pointer))
(defcfun ("alBufferi" buffer-i) :void (bid :uint) (param enum) (value :int))
(defcfun ("alBuffer3i" buffer-3i) :void
(bid :uint) (param enum) (value1 :int) (value2 :int) (value3 :int))
(defcfun ("alBufferiv" buffer-iv) :void (bid :uint) (param enum) (values :pointer))
;; Get Buffer parameters
(defcfun ("alGetBufferf" get-buffer-f) :void (bid :uint) (param enum) (value :pointer))
(defcfun ("alGetBuffer3f" get-buffer-3f) :void
(bid :uint) (param enum) (value1 :pointer) (value2 :pointer) (value3 :pointer))
(defcfun ("alGetBufferfv" get-buffer-fv) :void (bid :uint) (param enum) (values :pointer))
(defcfun ("alGetBufferi" get-buffer-i) :void (bid :uint) (param format) (value :pointer))
(defcfun ("alGetBuffer3i" get-buffer-3i) :void
(bid :uint) (param enum) (value1 :pointer) (value2 :pointer) (value3 :pointer))
(defcfun ("alGetBufferiv" get-buffer-iv) :void (bid :uint) (param enum) (values :pointer))
;; Global Parameters
(defcfun ("alDopplerFactor" doppler-factor) :void (value ensure-float))
(defcfun ("alDopplerVelocity" doppler-velocity) :void (value ensure-float))
(defcfun ("alSpeedOfSound" speed-of-sound) :void (value ensure-float))
(defcfun ("alDistanceModel" distance-model) :void (distance-model enum))
| 9,699 | Common Lisp | .lisp | 231 | 39.645022 | 93 | 0.707188 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | cc3b59365891283dba4c9740e4e93ae2bd60aada4617deca55b531791d3fa440 | 30,541 | [
-1
] |
30,542 | al.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-openal-20150302-git/al/al.lisp | (in-package :al)
;;;; misc.
(defun load-libraries ()
(cffi:define-foreign-library al
(:windows "OpenAL32.dll" :calling-convention :stdcall)
(:darwin (:or (:default "libopenal") (:framework "openal")))
(:unix (:or "libopenal.so" "libopenal.so.1"))
(t (:default "libopenal")))
(cffi:use-foreign-library al))
;; Renderer State management
(defun enable (capability)
(%al:enable capability))
(defun disable (capability)
(%al:disable capability))
(defun enabledp (capability)
(%al:is-enabled capability))
;; State retrieval
(defun get-string (param)
(%al:get-string param))
(defun get-boolean (param)
(%al:get-boolean param))
(defun get-integer (param)
(%al:get-integer param))
;; Errors
(defun get-error ()
(%al:get-error))
;; Extensions
(defun extension-present-p (extension-string)
(%al:is-extension-present extension-string))
(defun get-proc-address (fname)
(%al:get-proc-address fname))
(defun get-enum-value (enum-name)
(%al:get-enum-value enum-name))
;;;
;;; Listener
;;;
(defun listener (param value)
(ecase param
((:position :velocity)
(assert (= 3 (length value)))
(%al:listener-3f param (elt value 0) (elt value 1) (elt value 2)))
((:orientation)
(assert (= 6 (length value)))
(cffi:with-foreign-object (array :float 6)
(loop for i below 6
doing (setf (cffi:mem-aref array :float i)
(coerce (elt value i) 'float))
finally (%al:listener-fv param array))))
((:gain)
(%al:listener-f param value))))
(defun get-listener (param)
(ecase param
((:gain)
(cffi:with-foreign-object (ptr :float)
(%al:get-listener-f param ptr)
(cffi:mem-ref ptr :float)))
((:orientation)
(cffi:with-foreign-object (listener-array :float 6)
(%al:get-listener-fv param listener-array)
(loop for i below 6
collecting (cffi:mem-aref listener-array :float i))))
((:position :velocity)
(cffi:with-foreign-object (listener-array :float 3)
(%al:get-listener-fv param listener-array)
(loop for i below 3
collect (cffi:mem-aref listener-array :float i))))))
;;;
;;; Sources
;;;
(defun gen-sources (n)
(cffi:with-foreign-object (source-array :uint n)
(%al:gen-sources n source-array)
(loop for i below n
collect (cffi:mem-aref source-array :uint i))))
(defun delete-sources (sources)
(let ((n (length sources)))
(cffi:with-foreign-object (source-array :uint n)
(loop for i below n
do (setf
(cffi:mem-aref source-array :uint i)
(elt sources i)))
(%al:delete-sources n source-array))))
(defun gen-source ()
(car (gen-sources 1)))
(defun delete-source (sid)
(delete-sources (list sid)))
(defun sourcep (sid)
(%al:is-source sid))
(defun source (sid param value)
(ecase param
((:gain :pitch :min-gain :max-gain :reference-distance :rolloff-factor :max-distance
:sec-offset :sample-offset :byte-offset :cone-inner-angle :cone-outer-angle :cone-outer-gain)
(%al:source-f sid param value))
((:looping :source-relative)
(%al:source-i sid param (if value 1 0)))
((:source-type :buffer)
(%al:source-i sid param value))
((:position :velocity :direction)
(assert (= 3 (length value)))
(%al:source-3f sid param (elt value 0) (elt value 1) (elt value 2)))))
(defun get-source (sid param)
(ecase param
((:gain :pitch :min-gain :max-gain :reference-distance
:sec-offset :rolloff-factor :max-distance :cone-inner-angle :cone-outer-angle :cone-outer-gain
:sample-offset :byte-offset)
(cffi:with-foreign-object (ptr :float)
(%al:get-source-f sid param ptr)
(cffi:mem-ref ptr :float)))
((:looping :source-relative)
(cffi:with-foreign-object (ptr :int)
(%al:get-source-i sid param ptr)
(cffi:mem-ref ptr :boolean)))
((:source-type :buffer :buffers-queued :buffers-processed)
(cffi:with-foreign-object (ptr :int)
(%al:get-source-i sid param ptr)
(cffi:mem-ref ptr :int)))
(:source-state
(cffi:with-foreign-object (ptr :int)
(%al:get-source-i sid param ptr)
(cffi:foreign-enum-keyword '%al:enum (cffi:mem-ref ptr :int))))
((:position :velocity :direction)
(cffi:with-foreign-object (source-array :float 3)
(%al:get-source-fv sid param source-array)
(loop for i below 3
collect (cffi:mem-aref source-array :float i))))))
;; Playback
(defun source-play (sid)
(%al:source-play sid))
(defun source-stop (sid)
(%al:source-stop sid))
(defun source-rewind (sid)
(%al:source-rewind sid))
(defun source-pause (sid)
(%al:source-pause sid))
;; queueing
(defun source-queue-buffers (sid buffers)
(let ((n (length buffers)))
(cffi:with-foreign-object (buffer-array :uint n)
(loop for i below n
do (setf (cffi:mem-aref buffer-array :uint i)
(elt buffers i)))
(%al:source-queue-buffers sid n buffer-array))))
(defun source-unqueue-buffers (sid &optional (num-buffers 1))
(cffi:with-foreign-object (buffer-array :uint)
(setf (cffi:mem-ref buffer-array :uint) 0)
(%al:source-unqueue-buffers sid num-buffers buffer-array)
(unless (zerop (cffi:mem-ref buffer-array :uint))
(loop for i below num-buffers
collect (cffi:mem-aref buffer-array :uint i)))))
;;;
;;; Buffers
;;;
(defun gen-buffers (n)
(cffi:with-foreign-object (buffer-array :uint n)
(%al:gen-buffers n buffer-array)
(loop for i below n
collect (cffi:mem-aref buffer-array :uint i))))
(defun delete-buffers (buffers)
(let ((n (length buffers)))
(cffi:with-foreign-object (buffer-array :uint n)
(loop for i below n
do (setf
(cffi:mem-aref buffer-array :uint i)
(elt buffers i)))
(%al:delete-buffers n buffer-array))))
(defun gen-buffer ()
(car (gen-buffers 1)))
(defun delete-buffer (bid)
(delete-buffers (list bid)))
(defun bufferp (buffer-id)
(%al:is-buffer buffer-id))
(defun buffer (bid param value)
(%al:buffer-i bid param value))
(defun buffer-data (bid format data size freq)
(%al:buffer-data bid format data size freq))
(defun get-buffer (bid param)
(cffi:with-foreign-object (ptr :int)
(%al:get-buffer-i bid param ptr)
(cffi:mem-ref ptr :int)))
;;;
;;; Global parameters
;;;
(defun doppler-factor (value)
(%al:doppler-factor value))
(defun doppler-velocity (value)
(%al:doppler-velocity value))
(defun speed-of-sound (value)
(%al:speed-of-sound value))
(defun distance-model (model-param)
(%al:distance-model model-param))
;;;
;;; Helper macros to keep the world tidy.
;;;
(defmacro with-sources ((n var) &body body)
`(let ((,var (gen-sources ,n)))
(unwind-protect
(progn
,@body)
(when ,var (delete-sources ,var)))))
(defmacro with-source ((var) &body body)
`(let ((,var (gen-source)))
(unwind-protect
(progn
,@body)
(when ,var (delete-source ,var)))))
(defmacro with-buffers ((n var) &body body)
`(let ((,var (gen-buffers ,n)))
(unwind-protect
(progn
,@body)
(when ,var (delete-buffers ,var)))))
(defmacro with-buffer ((var) &body body)
`(let ((,var (gen-buffer)))
(unwind-protect
(progn
,@body)
(when ,var (delete-buffer ,var)))))
| 7,382 | Common Lisp | .lisp | 217 | 29.064516 | 106 | 0.643227 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | bd4a1165e260e9de3a90e5edf6f3ef319ec725ee232cc409c85e44d1cf2782b4 | 30,542 | [
-1
] |
30,543 | packages.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-openal-20150302-git/al/packages.lisp | (defpackage #:openal-cffi-bindings
(:use :cl :cffi)
(:nicknames :%al)
(:shadow :boolean :byte)
(:export
:enum :boolean :byte :ubyte :ensure-float :ensure-integer :ensure-double
;; renderer state management
:enable :disable :is-enabled
;; state retrieval
:get-string :get-boolean-v :get-integer-v :get-float-v :get-double-v
:get-boolean :get-integer :get-float :get-double
;; errors
:get-error
;; extensions
:is-extension-present
:get-proc-address
:get-enum-value
;;; listener stuff
;; set
:listener-f :listener-3f :listener-fv :listener-i :listener-3i :listener-iv
;; get
:get-listener-f :get-listener-3f :get-listener-fv :get-listener-i :get-listener-3i :get-listener-iv
;;; sources stuff
;; objects
:gen-sources :delete-sources :is-source
;; set
:source-f :source-3f :source-fv :source-i :source-3i :source-iv
;; get
:get-source-f :get-source-3f :get-source-fv :get-source-i :get-source-3i :get-source-iv
;; playback - vector based
:source-play-v :source-stop-v :source-rewind-v :source-pause-v
;; playback - source based
:source-play :source-stop :source-rewind :source-pause
;; queueing
:source-queue-buffers :source-unqueue-buffers
;;; buffer stuff
;; objects
:gen-buffers :delete-buffers :is-buffer :buffer-data
;; set
:buffer-f :buffer-3f :buffer-fv :buffer-i :buffer-3i :buffer-iv
;; get
:get-buffer-f :get-buffer-3f :get-buffer-fv :get-buffer-i :get-buffer-3i :get-buffer-iv
;;; global parameters
:doppler-factor :doppler-velocity :speed-of-sound :distance-model))
(defpackage #:cl-openal
(:use :cl)
(:nicknames :al)
(:export
:load-libraries
:enable :disable :enabledp :get-string :get-boolean :get-integer :get-error :extension-present-p
:get-proc-address :get-enum-value :listener :get-listener :gen-sources :gen-source :delete-sources
:delete-source :sourcep :source :get-source :source-play :source-stop :source-rewind :source-pause
:source-queue-buffers :source-unqueue-buffers :gen-buffers :gen-buffer :delete-buffers
:delete-buffer :bufferp :buffer :get-buffer :doppler-factor :doppler-velocity :speed-of-sound
:distance-model :buffer-data :with-source :with-sources :with-buffer :with-buffers))
| 2,265 | Common Lisp | .lisp | 55 | 37.4 | 102 | 0.710276 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 0f5c7d8278951c93352cb5ac54336b273ed5f15002d69040ba6dfebff0fa0c98 | 30,543 | [
-1
] |
30,544 | alut.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-openal-20150302-git/alut/alut.lisp | (in-package :alut)
(defun load-libraries ()
(cffi:define-foreign-library alut
(:windows "alut.dll" :calling-convention :stdcall)
(:darwin (:or (:default "libalut") (:framework "alut")))
(:unix (:or "libalut.so" "libalut.so.0" "libalut.so.0.1.0"))
(t (:default ("libalut"))))
(cffi:use-foreign-library alut))
(defun init ()
(%alut:init (cffi:null-pointer) (cffi:null-pointer)))
(defun init-without-context ()
(%alut:init-without-context (cffi:null-pointer) (cffi:null-pointer)))
(defun exit ()
(%alut:exit))
(defun get-error ()
(%alut:get-error))
(defun get-error-string (error-name)
(%alut:get-error-string error-name))
;;;
;;; Creating buffers
;;;
(defun create-buffer-from-file (filename)
(%alut:create-buffer-from-file filename))
(defun create-buffer-from-file-image (data)
(let ((length (length data)))
(cffi:with-foreign-object (data-array :int length)
(loop for i below length
do (setf (cffi:mem-aref data-array :int i)
(elt data i)))
(%alut:create-buffer-from-file-image data-array length))))
(defun create-buffer-hello-world ()
(%alut:create-buffer-hello-world))
(defun create-buffer-waveform (waveshape frequency phase duration)
(%alut:create-buffer-waveform waveshape frequency phase duration))
;;;
;;; Loading memory
;;;
(defun load-memory-from-file (filename)
(cffi:with-foreign-objects ((format '%al:enum)
(size :int)
(frequency '%al:ensure-float))
(values-list
(cons
(%alut:load-memory-from-file filename format size frequency)
(handler-case
(list (cffi:mem-ref format '%al:enum)
(cffi:mem-ref size :int)
(cffi:mem-ref frequency '%al:ensure-float))
(error ()
(error "There was an error loading ~A" filename)))))))
(defun load-memory-from-file-image (data)
(let ((length (length data)))
(cffi:with-foreign-objects ((format '%al:enum)
(size :int)
(frequency '%al:ensure-float)
(data-array :int length))
(loop for i below length
do (setf (cffi:mem-aref data-array :int i)
(elt data i)))
(values-list
(cons
(%alut:load-memory-from-file-image data-array length format size
frequency)
(handler-case
(list (cffi:mem-ref format '%al:enum)
(cffi:mem-ref size :int)
(cffi:mem-ref frequency '%al::ensure-float))
(error ()
(error "There was an error loading data"))))))))
(defun load-memory-hello-world ()
(cffi:with-foreign-objects ((format '%al:enum)
(size :int)
(frequency '%al:ensure-float))
(values-list
(cons
(%alut:load-memory-hello-world format size frequency)
(handler-case
(list (cffi:mem-ref format '%al:enum)
(cffi:mem-ref size :int)
(cffi:mem-ref frequency '%al::ensure-float))
(error ()
(error "There was an error loading memory!")))))))
(defun load-memory-waveform (waveshape frequency phase duration)
(cffi:with-foreign-objects ((format '%al:enum)
(size :int)
(freq '%al:ensure-float))
(values-list
(cons
(%alut:load-memory-waveform waveshape frequency phase duration format
size freq)
(handler-case
(list (cffi:mem-ref format '%al:enum)
(cffi:mem-ref size :int)
(cffi:mem-ref freq '%al::ensure-float))
(error ()
(error "There was an error loading this waveform")))))))
;;;
;;; Misc
;;;
(defun get-mime-types (loader)
(%alut:get-mime-types loader))
(defun get-major-version ()
(%alut:get-major-version))
(defun get-minor-version ()
(%alut:get-minor-version))
(defun sleep (duration)
(%alut:sleep duration))
;;;
;;; Helper macros to keep the world clean.
;;;
(defmacro with-init (&body body)
`(unwind-protect
(init)
(progn
,@body)
(alut:exit)))
| 4,240 | Common Lisp | .lisp | 116 | 27.982759 | 75 | 0.580818 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 28963280acda18e5592581f09bd371a24dc4d58785aeade1b3953322e134f07b | 30,544 | [
-1
] |
30,545 | bindings.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-openal-20150302-git/alut/bindings.lisp | ;; TODO: enums. As usual.
(in-package :%alut)
(define-foreign-library alut
(:windows "alut.dll" :calling-convention :stdcall)
(:darwin (:or (:default "libalut") (:framework "alut")))
(:unix (:or "libalut.so" "libalut.so.0" "libalut.so.0.1.0"))
(t (:default ("libalut"))))
(use-foreign-library alut)
(define-foreign-type ensure-integer ()
()
(:actual-type :int)
(:simple-parser ensure-integer))
(defmethod translate-to-foreign (value (type ensure-integer))
(truncate value))
(defmethod expand-to-foreign (value (type ensure-integer))
(if (constantp value)
(truncate (eval value))
`(truncate ,value)))
(define-foreign-type ensure-float ()
()
(:actual-type :float)
(:simple-parser ensure-float))
(defmethod translate-to-foreign (value (type ensure-float))
(cl:float value 1.0))
(defmethod expand-to-foreign (value (type ensure-float))
(if (constantp value)
(cl:float (eval value) 1.0)
`(cl:float ,value 1.0)))
(define-foreign-type ensure-double ()
()
(:actual-type :double)
(:simple-parser ensure-double))
(defmethod translate-to-foreign (value (type ensure-double))
(cl:float value 1.0d0))
(defmethod expand-to-foreign (value (type ensure-double))
(if (constantp value)
(cl:float (eval value) 1.0d0)
`(cl:float ,value 1.0d0)))
(defcenum api
(:major-version 1)
(:minor-version 1))
(defcenum error
(:no-error 0)
(:out-of-memory #x200)
(:invalid-enum #x201)
(:invalid-value #x202)
(:invalid-operation #x203)
(:no-current-context #x204)
(:al-error-on-entry #x205)
(:alc-error-on-entry #x206)
(:open-device #x207)
(:close-device #x208)
(:create-context #x209)
(:make-context-current #x20A)
(:destroy-context #x20B)
(:gen-buffers #x20C)
(:buffer-data #x20D)
(:io-error #x20E)
(:unsupported-file-type #x20F)
(:unsupported-file-subtype #x210)
(:corrupt-or-truncated-data #x211))
(defcenum waveform
(:sine #x100)
(:square #x101)
(:sawtooth #x102)
(:whitenoise #x103)
(:impulse #x104))
(defcenum loader
(:buffer #x300)
(:memory #x301))
(define-foreign-type pathname-string-type ()
()
(:actual-type :string)
(:simple-parser pathname-string))
(eval-when (:compile-toplevel :load-toplevel)
(defmethod expand-to-foreign-dyn (value var body (type pathname-string-type))
`(with-foreign-string (,var (if (pathnamep ,value) (namestring ,value) ,value))
,@body)))
(defcfun ("alutInit" init) :boolean (argcp :pointer) (argv :pointer))
(defcfun ("alutInitWithoutContext" init-without-context) :boolean
(argcp :pointer) (argv :pointer))
(defcfun ("alutExit" exit) :boolean)
(defcfun ("alutGetError" get-error) error)
(defcfun ("alutGetErrorString" get-error-string) :string (err error))
(defcfun ("alutCreateBufferFromFile" create-buffer-from-file) :uint
(filename pathname-string))
(defcfun ("alutCreateBufferFromFileImage" create-buffer-from-file-image) :uint
(data (:pointer :void)) (length :int))
(defcfun ("alutCreateBufferHelloWorld" create-buffer-hello-world) :uint)
(defcfun ("alutCreateBufferWaveform" create-buffer-waveform) :uint
(waveshape waveform) (frequency ensure-float) (phase ensure-float) (duration ensure-float))
(defcfun ("alutLoadMemoryFromFile" load-memory-from-file) :pointer
(filename pathname-string) (format :pointer) (size :pointer) (frequency :pointer))
(defcfun ("alutLoadMemoryFromFileImage" load-memory-from-file-image) :pointer
(data (:pointer :void)) (length :int) (format :pointer) (size :pointer) (frequency :pointer))
(defcfun ("alutLoadMemoryHelloWorld" load-memory-hello-world) :pointer
(format :pointer) (size :pointer) (frequency :pointer))
(defcfun ("alutLoadMemoryWaveform" load-memory-waveform) :pointer
(waveshape waveform) (frequency :float) (phase :float) (duration :float)
(format :pointer) (size :pointer) (freq :pointer))
(defcfun ("alutGetMIMETypes" get-mime-types) :string
(loader loader))
(defcfun ("alutGetMajorVersion" get-major-version) :int)
(defcfun ("alutGetMinorVersion" get-minor-version) :int)
(defcfun ("alutSleep" sleep) :boolean (duration ensure-float))
| 4,086 | Common Lisp | .lisp | 105 | 36.095238 | 95 | 0.720131 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | b7e28a38af0db270fd2ad1c0eb798a7cd9c36d2779b5f0452a2208a55a19f6e6 | 30,545 | [
-1
] |
30,546 | packages.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-openal-20150302-git/alut/packages.lisp | (defpackage #:alut-cffi-bindings
(:use :cl :cffi)
(:nicknames :%alut)
(:shadow :sleep)
(:export
;; enums
:api :error :waveform :loader
;; funcs
:init :init-without-context :exit
:get-error :get-error-string
:create-buffer-from-file :create-buffer-from-file-image
:create-buffer-hello-world :create-buffer-waveform
:load-memory-from-file :load-memory-from-file-image
:load-memory-hello-world :load-memory-waveform
:get-mime-types :get-major-version :get-minor-version :sleep))
(defpackage #:cl-openal-alut
(:use :cl :al)
(:nicknames :alut)
(:shadow :sleep)
(:export
#:load-libraries
:init :init-without-context :exit :get-error :get-error-string :create-buffer-from-file
:create-buffer-from-file-image :create-buffer-hello-world :create-buffer-waveform
:load-memory-from-file :load-memory-from-file-image :load-memory-hello-world :load-memory-waveform
:get-mime-types :get-major-version :get-minor-version :sleep
:with-init))
| 993 | Common Lisp | .lisp | 26 | 34.576923 | 101 | 0.725104 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 149e328e6b4af5b2474c730d19f557698f54f68d9cf0096c0c3969cc6cb2cfdf | 30,546 | [
-1
] |
30,547 | bitfields.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/tools/bitfields.lisp | (
(:enum-type
"AttribMask"
:deprecated t
:type :bitfield
:used-by
(("AttribMask" "PushAttrib" "mask" 0))
:enums
("ACCUM_BUFFER_BIT"
"COLOR_BUFFER_BIT"
"CURRENT_BIT"
"DEPTH_BUFFER_BIT"
"ENABLE_BIT"
"EVAL_BIT"
"FOG_BIT"
"HINT_BIT"
"LIGHTING_BIT"
"LINE_BIT"
"LIST_BIT"
;; "MISC_BIT_EXT" ;; not in enum*.spec?
"PIXEL_MODE_BIT"
"POINT_BIT"
"POLYGON_BIT"
"POLYGON_STIPPLE_BIT"
"SCISSOR_BIT"
"STENCIL_BUFFER_BIT"
"TEXTURE_BIT"
"TRANSFORM_BIT"
"VIEWPORT_BIT"
"MULTISAMPLE_BIT"
"MULTISAMPLE_BIT_ARB" "MULTISAMPLE_BIT_EXT" "MULTISAMPLE_BIT_3DFX"
;; "MULTISAMPLE_BIT_SGIS" ;; not in enum*.spec?
"ALL_ATTRIB_BITS"))
(:enum-type
"ClearBufferMask"
:deprecated nil
:type :bitfield
:used-by
(("ClearBufferMask" "Clear" "mask" 0)
("ClearBufferMask" "BlitFramebuffer" "mask" 8)
("ClearBufferMask" "BlitFramebufferEXT" "mask" 8))
:enums
("COLOR_BUFFER_BIT"
"ACCUM_BUFFER_BIT"
"DEPTH_BUFFER_BIT"
"STENCIL_BUFFER_BIT"))
(:enum-type "ClientAttribMask"
:deprecated t
:type :bitfield
:used-by
(("ClientAttribMask" "PushClientAttrib" "mask" 0)
("ClientAttribMask" "ClientAttribDefaultEXT" "mask" 0)
("ClientAttribMask" "PushClientAttribDefaultEXT" "mask" 0))
:enums
("CLIENT_ALL_ATTRIB_BITS"
"CLIENT_VERTEX_ARRAY_BIT"
"CLIENT_PIXEL_STORE_BIT"))
(:enum-type "BufferAccessMask"
:deprecated nil
:type :bitfield
:used-by
(("BufferAccessMask" "MapBufferRange" "access" 3))
:enums
("MAP_UNSYNCHRONIZED_BIT"
"MAP_FLUSH_EXPLICIT_BIT"
"MAP_INVALIDATE_BUFFER_BIT"
"MAP_INVALIDATE_RANGE_BIT"
"MAP_WRITE_BIT"
"MAP_READ_BIT"))
)
;;;FfdMaskSGIX,*,*, GLbitfield,*,*
;; ColorFragmentOp[1..3]ATI , AlphaFragmentOp[1..3]ATI:
;;;(:ENUM-NAME "BIAS_BIT_ATI" :VALUE "0x00000008" :ENUMEXT.SPEC T)
;;; (:ENUM-NAME "NEGATE_BIT_ATI" :VALUE "0x00000004" :ENUMEXT.SPEC T)
;;; (:ENUM-NAME "COMP_BIT_ATI" :VALUE "0x00000002" :ENUMEXT.SPEC T)
;;; (:ENUM-NAME "2X_BIT_ATI" :VALUE "0x00000001" :ENUMEXT.SPEC T)
;;; (:ENUM-NAME "SATURATE_BIT_ATI" :VALUE "0x00000040" :ENUMEXT.SPEC T)
;;; (:ENUM-NAME "EIGHTH_BIT_ATI" :VALUE "0x00000020" :ENUMEXT.SPEC T)
;;; (:ENUM-NAME "QUARTER_BIT_ATI" :VALUE "0x00000010" :ENUMEXT.SPEC T)
;;; (:ENUM-NAME "HALF_BIT_ATI" :VALUE "0x00000008" :ENUMEXT.SPEC T)
;;; (:ENUM-NAME "8X_BIT_ATI" :VALUE "0x00000004" :ENUMEXT.SPEC T)
;;; (:ENUM-NAME "4X_BIT_ATI" :VALUE "0x00000002" :ENUMEXT.SPEC T)
;;; (:ENUM-NAME "2X_BIT_ATI" :VALUE "0x00000001" :ENUMEXT.SPEC T)
;;; (:ENUM-NAME "BLUE_BIT_ATI" :VALUE "0x00000004" :ENUMEXT.SPEC T)
;;; (:ENUM-NAME "GREEN_BIT_ATI" :VALUE "0x00000002" :ENUMEXT.SPEC T)
;;; (:ENUM-NAME "RED_BIT_ATI" :VALUE "0x00000001" :ENUMEXT.SPEC T)
;;;
;;;
;;;;;"PGI_vertex_hints"
;;;(:USE "MAP_UNSYNCHRONIZED_BIT" :FROM-TYPE "ARB_map_buffer_range")
;;; (:USE "MAP_FLUSH_EXPLICIT_BIT" :FROM-TYPE "ARB_map_buffer_range")
;;; (:USE "MAP_INVALIDATE_BUFFER_BIT" :FROM-TYPE "ARB_map_buffer_range")
;;; (:USE "MAP_INVALIDATE_RANGE_BIT" :FROM-TYPE "ARB_map_buffer_range")
;;; (:USE "MAP_WRITE_BIT" :FROM-TYPE "ARB_map_buffer_range")
;;; (:USE "MAP_READ_BIT" :FROM-TYPE "ARB_map_buffer_range")
;;;
| 3,323 | Common Lisp | .lisp | 96 | 30.65625 | 76 | 0.641633 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | eb67662998cf09b5f94d872b894989156d2d997648b88beb1fb139a2e723493e | 30,547 | [
311121,
434412
] |
30,548 | special-cases.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/tools/special-cases.lisp | ;;; override values from gl.xml
(:bitfield "ClearBufferMask"
(:color-buffer #x4000)
(:color-buffer-bit #x4000)
(:accum-buffer #x200)
(:accum-buffer-bit #x200)
(:depth-buffer #x100)
(:depth-buffer-bit #x100)
(:stencil-buffer #x400)
(:stencil-buffer-bit #x400))
(:enum "enum"
;; gl and gles have different values for GL_ACTIVE_PROGRAM_EXT
;; so force the GL value (see below for ES value)
(:active-program-ext #x8b8d))
(:enum "GetProgramPipelineExtPname"
;; gles version of EXT_separate_shader_objects
;; uses a different value for GL_ACTIVE_PROGRAM_EXT from normal GL,
;; so define a separate enum for that param
(:active-program-ext #x8259)
(:vertex-shader (:import "ShaderType"))
(:fragment-shader (:import "ShaderType"))
(:validate-status (:import "enum"))
(:info-log-length (:import "enum")))
(:func "glGetProgramPipelineivEXT"
"void"
(:NAME "pipeline" :TYPE "GLuint")
;; one of the possible enums has different values in gl and gles,
;; so use a custom enum for it (see GetProgramPipelineExtPname above)
(:NAME "pname" :TYPE "GetProgramPipelineExtPname")
(:NAME "params" :TYPE "GLint"))
| 1,302 | Common Lisp | .lisp | 30 | 35.366667 | 76 | 0.625394 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 690a21c2b99b7e9e4a23a940c36c35c4750ca9cd75b47b0638659d04efa2786d | 30,548 | [
-1
] |
30,550 | molview.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/examples/misc/molview.lisp | ;; Doug Hoyte, March 2007
;; Assignment 2: Molecule Viewer
;; COSC414 with Dr. Alan Paeth, UBC Okanagan
;; This program is distributed under the terms and
;; conditions of the BSD license:
;; http://www.opensource.org/licenses/bsd-license.php
;; This should be ANSI Common Lisp code that uses the OpenGL
;; libraries through the cl-opengl bindings.
;; Tested with SBCL 1.0.3 and the most recent cl-opengl bindings
;; available here: http://common-lisp.net/project/cl-opengl/
;; Usage:
;; $ sbcl --load molview.lisp
;; ...
;; * (molview ethanol)
;; or
;; * (molview (with-open-file ...))
;; Commands:
;; x/X - Rotate molecule around X axis
;; y/Y - Rotate molecule around Y axis
;; z/Z - Rotate molecule around Z axis
;; t/T - Rotate light source around theta
;; p/P - Rotate light source around phi
;; r/R - Increase/decrease red light component
;; g/G - Increase/decrease green light component
;; b/B - Increase/decrease blue light component
;; s/S - Increase/decrease number of sphere slices
;; w - Toggle "random walk" frame-rate testing mode
;; m - Toggle solid sphere vs wire sphere
;; l - Toggle showing light source
;; We depend on cl-glut (which depends on cl-opengl and cffi)
;;(require :cl-glut)
(defpackage #:cl-glut-examples-molview
(:use :cl)
(:import-from #:cl-glut-examples
#:molview)
(:export #:molview
#:ethanol
#:water))
(in-package #:cl-glut-examples-molview)
;; Hard-coded molecules
(alexandria:define-constant water
'((O 0.000 0.000 0.000)
(H -0.900 0.000 0.000)
(H 0.000 1.000 0.000))
:test 'equal)
(alexandria:define-constant ethanol
'((C -0.426 -0.115 -0.147)
(O -0.599 1.244 -0.481)
(H -0.750 -0.738 -0.981)
(H -1.022 -0.351 0.735)
(H -1.642 1.434 -0.689)
(C 1.047 -0.383 0.147)
(H 1.370 0.240 0.981)
(H 1.642 -0.147 -0.735)
(H 1.180 -1.434 0.405))
:test 'equal)
;; Variables/Constants
(defconstant spin-speed 5)
(defvar slices 40) ; number of hori/verti slices on spheres
(defvar model-type 'solid)
(defvar curr-mol)
(defvar view-rotx 20)
(defvar view-roty 30)
(defvar view-rotz 0)
(defvar show-light-source nil)
(defvar light-theta 0)
(defvar light-phi 0)
(defvar light-dist 5)
(defconstant light-spin-speed .0872664625) ; 5 degrees in radians
(defvar light-r .8)
(defvar light-g .8)
(defvar light-b .8)
(defconstant light-colour-vel .1)
(defvar walk-mode nil)
;; Main function
(defun molview (&optional (mol ethanol))
(setq curr-mol mol)
(glut:display-window (make-instance 'mol-window)))
;; Our molecule viewer class
(defclass mol-window (glut:window)
()
(:default-initargs :title "Doug Hoyte - Molecule Viewer"
:width 500 :height 500 :mode '(:double :rgb :depth)))
(defun draw-light-source ()
(gl:with-pushed-matrix
(gl:material :front :ambient (vector light-r light-g light-b 1))
(gl:translate (* light-dist (cos light-theta) (sin light-phi))
(* light-dist (sin light-theta) (sin light-phi))
(* light-dist (cos light-phi)))
(glut:solid-sphere 0.1 20 20)))
(defun draw-atom (element x y z)
(gl:with-pushed-matrix
(gl:rotate view-rotx 1 0 0)
(gl:rotate view-roty 0 1 0)
(gl:rotate view-rotz 0 0 1)
(gl:material :front :ambient-and-diffuse
(case element
((H) #(0.8 0.8 0.8 1))
((O) #(0.8 0.1 0.0 1))
((C) #(0.2 0.2 0.2 1))))
(gl:translate x y z)
(funcall
(if (eq model-type 'wire) #'glut:wire-sphere #'glut:solid-sphere)
(case element
((H) 0.7)
((O) 1.0)
((C) 1.2))
slices slices)))
(defmethod glut:display ((window mol-window))
(gl:clear :color-buffer-bit :depth-buffer-bit)
(gl:light :light0 :position (vector (* light-dist (cos light-theta) (sin light-phi))
(* light-dist (sin light-theta) (sin light-phi))
(* light-dist (cos light-phi))
0))
(gl:light :light0 :diffuse (vector light-r light-g light-b 1))
(gl:enable :cull-face :lighting :light0 :depth-test)
(if show-light-source (draw-light-source))
(dolist (a curr-mol)
(apply #'draw-atom a))
(glut:swap-buffers))
(defmethod glut:reshape ((w mol-window) width height)
(gl:viewport 0 0 width height)
(gl:matrix-mode :projection)
(gl:load-identity)
(let ((h (/ height width)))
(gl:frustum -1 1 (- h) h 9 50))
(gl:matrix-mode :modelview)
(gl:load-identity)
(gl:translate 0 0 -40))
;; Input methods
(defmacro lim-between (sym bot top)
`(setq ,sym (max ,bot (min ,top ,sym))))
(defmethod glut:keyboard ((window mol-window) key x y)
(declare (ignore x y))
(case (code-char key)
(#\x (incf view-rotx spin-speed))
(#\X (decf view-rotx spin-speed))
(#\y (incf view-roty spin-speed))
(#\Y (decf view-roty spin-speed))
(#\z (incf view-rotz spin-speed))
(#\Z (decf view-rotz spin-speed))
(#\t (incf light-theta light-spin-speed))
(#\T (decf light-theta light-spin-speed))
(#\p (incf light-phi light-spin-speed))
(#\P (decf light-phi light-spin-speed))
(#\r (incf light-r light-colour-vel))
(#\R (decf light-r light-colour-vel))
(#\g (incf light-g light-colour-vel))
(#\G (decf light-g light-colour-vel))
(#\b (incf light-b light-colour-vel))
(#\B (decf light-b light-colour-vel))
(#\w (if walk-mode
(glut:disable-event window :idle)
(glut:enable-event window :idle))
(setq walk-mode (not walk-mode)))
(#\m (setq model-type (if (eq model-type 'wire) 'solid 'wire)))
(#\s (incf slices))
(#\S (decf slices))
(#\l (setq show-light-source (not show-light-source)))
(#\q (glut:destroy-current-window)
(return-from glut:keyboard))
(#\escape
(glut:destroy-current-window)
(return-from glut:keyboard)))
(lim-between light-r 0 1)
(lim-between light-g 0 1)
(lim-between light-b 0 1)
(lim-between slices 1 100)
(glut:post-redisplay))
(defvar origclick)
(defvar origrot)
(defmethod glut:mouse ((window mol-window) button state x y)
(if (eq button :left-button)
(if (eq state :down)
(progn (setf origrot (list view-rotx view-roty))
(setf origclick (list x y)))
(setf origclick ()))))
(defmethod glut:motion ((window mol-window) x y)
(setf view-rotx (+ (car origrot) (- y (cadr origclick))))
(setf view-roty (+ (cadr origrot) (- x (car origclick))))
(glut:post-redisplay))
(defun random-interval (bot top)
(+ (* (- top bot) (/ (random 100000) 100000.0)) bot))
(defvar view-rotx-vel 0)
(defvar view-roty-vel 0)
(defvar view-rotz-vel 0)
(defvar last-update 0)
(defvar counter 0)
(defmethod glut:idle ((window mol-window))
(if walk-mode
(progn
(incf counter)
(if (< (+ last-update internal-time-units-per-second) (get-internal-real-time))
(progn
(format t "~a frames per second with ~a slices.~%" counter slices)
(setq counter 0)
(setq last-update (get-internal-real-time))))
(incf view-rotx-vel (random-interval -.1 .1))
(incf view-roty-vel (random-interval -.1 .1))
(incf view-rotz-vel (random-interval -.1 .1))
(lim-between view-rotx-vel -2 2)
(lim-between view-roty-vel -2 2)
(lim-between view-rotz-vel -2 2)
(incf view-rotx view-rotx-vel)
(incf view-roty view-roty-vel)
(incf view-rotz view-rotz-vel)
(incf light-r (random-interval -.02 .02))
(incf light-g (random-interval -.02 .02))
(incf light-b (random-interval -.02 .02))
(lim-between light-r 0 1)
(lim-between light-g 0 1)
(lim-between light-b 0 1)))
(glut:post-redisplay))
| 7,753 | Common Lisp | .lisp | 213 | 31.525822 | 86 | 0.635477 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | f93fa36c6d5670ebc238651998d1f927a01b5ece0fcf6f68eeb93b24e7c5b019 | 30,550 | [
-1
] |
30,552 | render-to-texture.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/examples/misc/render-to-texture.lisp | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;; render-to-texture.lisp --- Simple usage of the EXT_framebuffer_object extension
(in-package #:cl-glut-examples)
(defclass render-to-texture-window (glut:window)
((texture :accessor texture)
(framebuffer :accessor framebuffer))
(:default-initargs :width 640 :height 480 :title "render-to-texture.lisp"
:mode '(:double :rgb :depth :multisample)))
;;; Do initialization here:
;;;
;;; In order to render to a texture, we need to setup a complete framebuffer,
;;; which consists of color-buffers, a depth-buffer and a stencil-buffer.
;;; In our simple case, we setup a texture as color-buffer and add a 24-bit
;;; depth-buffer so we can render the teapot correctly. We don't attach a
;;; stencil-buffer since it isn't needed in this simple example.
(defmethod glut:display-window :before ((w render-to-texture-window))
(let ((framebuffer (first (gl:gen-framebuffers-ext 1)))
(depthbuffer (first (gl:gen-renderbuffers-ext 1)))
(texture (first (gl:gen-textures 1))))
;; setup framebuffer
(gl:bind-framebuffer-ext :framebuffer-ext framebuffer)
;; setup texture and attach it to the framebuffer
(gl:bind-texture :texture-2d texture)
(gl:tex-parameter :texture-2d :texture-min-filter :linear-mipmap-linear)
(gl:tex-parameter :texture-2d :texture-mag-filter :linear)
(gl:tex-image-2d :texture-2d 0 :rgba 512 512 0 :rgba :unsigned-byte (cffi:null-pointer))
(gl:generate-mipmap-ext :texture-2d)
(gl:bind-texture :texture-2d 0)
(gl:framebuffer-texture-2d-ext :framebuffer-ext
:color-attachment0-ext
:texture-2d
texture
0)
;; setup depth-buffer and attach it to the framebuffer
(gl:bind-renderbuffer-ext :renderbuffer-ext depthbuffer)
(gl:renderbuffer-storage-ext :renderbuffer-ext :depth-component24 512 512)
(gl:framebuffer-renderbuffer-ext :framebuffer-ext
:depth-attachment-ext
:renderbuffer-ext
depthbuffer)
;; validate framebuffer
(let ((framebuffer-status (gl:check-framebuffer-status-ext :framebuffer-ext)))
(unless (gl::enum= framebuffer-status :framebuffer-complete-ext)
(error "Framebuffer not complete: ~A." framebuffer-status)))
(setf (texture w) texture
(framebuffer w) framebuffer))
(gl:enable :depth-test :multisample))
(defmethod glut:display ((window render-to-texture-window))
(gl:load-identity)
;; We render the teapot in the first pass. To do this, we switch to our
;; custom framebuffer, set the viewport to the texture size and render it
;; normally.
(gl:bind-framebuffer-ext :framebuffer-ext (framebuffer window))
(gl:viewport 0 0 512 512)
(gl:matrix-mode :projection)
(gl:load-identity)
(glu:perspective 50 1 0.5 20)
(gl:matrix-mode :modelview)
(draw-teapot)
;; Now that the texture has been updated, we can draw the spinning quad(s) in
;; the second pass. We want to render into the window, so we need to bind to
;; the default framebuffer, which always has the ID 0.
(gl:bind-framebuffer-ext :framebuffer-ext 0)
(gl:viewport 0 0 (glut:width window) (glut:height window))
(gl:matrix-mode :projection)
(gl:load-identity)
(glu:perspective 50 (/ (glut:width window) (glut:height window)) 0.5 20)
(gl:matrix-mode :modelview)
(draw-spinning-quad (texture window))
(glut:swap-buffers))
(defmethod glut:idle ((window render-to-texture-window))
(glut:post-redisplay))
(defmethod glut:reshape ((window render-to-texture-window) width height)
(setf (glut:width window) width
(glut:height window) height))
(defmethod glut:keyboard ((window render-to-texture-window) key x y)
(declare (ignore x y))
(when (eql key #\Esc)
(glut:destroy-current-window)))
(defun render-to-texture ()
(glut:display-window (make-instance 'render-to-texture-window)))
;;; FIXME: the rotations are dependent on the frame rate.
;;; I'd need to calculate the frametime, but I'm too lazy right now.
(defparameter *teapot-rotation-x* 0.0)
(defparameter *teapot-rotation-y* 0.0)
(defparameter *teapot-rotation-z* 0.0)
(defun draw-teapot ()
(gl:clear-color 0 0.3 0.5 1.0)
(gl:clear :color-buffer :depth-buffer)
(gl:disable :blend :texture-2d)
(gl:enable :lighting :light0 :depth-test)
(gl:color-material :front :ambient-and-diffuse)
(gl:light :light0 :position '(0 1 1 0))
(gl:light :light0 :diffuse '(0.2 0.4 0.6 0))
(gl:load-identity)
(gl:translate 0 0 -4)
(gl:rotate *teapot-rotation-x* 1 0 0)
(gl:rotate *teapot-rotation-y* 0 1 0)
(gl:rotate *teapot-rotation-z* 0 0 1)
(gl:color 1 1 1)
(glut:solid-teapot 1.3)
(incf *teapot-rotation-x* 0.01)
(incf *teapot-rotation-y* 0.05)
(incf *teapot-rotation-z* 0.03))
(defparameter *quad-rotation* 0.0)
(defun draw-spinning-quad (texture)
(gl:clear-color 0 0 0 0)
(gl:clear :color-buffer :depth-buffer)
(gl:disable :lighting)
(gl:enable :blend :texture-2d :depth-test)
(gl:blend-func :src-alpha :one)
(gl:load-identity)
(gl:translate 0 -1 -3)
(gl:rotate *quad-rotation* 0 1 0)
(gl:bind-texture :texture-2d texture)
;; the teapot texture gets regenerated every frame, so we also need to
;; recalculate the mipmaps every frame since trilinear filtering is enabled.
(gl:generate-mipmap-ext :texture-2d)
;; draw textured quad
(gl:color 1 1 1)
(gl:with-primitives :quads
(gl:tex-coord 0 1)
(gl:vertex -1 2)
(gl:tex-coord 1 1)
(gl:vertex 1 2)
(gl:tex-coord 1 0)
(gl:vertex 1 0)
(gl:tex-coord 0 0)
(gl:vertex -1 0))
;; draw fake reflection
(gl:with-primitives :quads
(gl:color 1 1 1 0.7)
(gl:tex-coord 0 0)
(gl:vertex -1 0)
(gl:tex-coord 1 0)
(gl:vertex 1 0)
(gl:tex-coord 1 0.5)
(gl:color 1 1 1 0)
(gl:vertex 1 -1)
(gl:tex-coord 0 0.5)
(gl:vertex -1 -1))
(incf *quad-rotation* 0.1))
| 6,077 | Common Lisp | .lisp | 142 | 37.316901 | 92 | 0.676161 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 44b1639c76c8aec4493eed79112518b806cf467fbefd759a7d997c9a785a74b5 | 30,552 | [
-1
] |
30,553 | shader-vao.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/examples/misc/shader-vao.lisp | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;; shader-vao.lisp --- Example usage of vertex and fragment shaders,
;;; vertex buffer objects, and vertex array objects
(in-package #:cl-glut-examples)
(defclass shader-vao-window (glut:window)
((vbuff :accessor vertex-buffer)
(ibuff :accessor index-buffer)
(vs :accessor vertex-shader)
(fs :accessor fragment-shader)
(va :accessor vertex-array)
(program :accessor program)
(angle :accessor angle :initform 0.0))
(:default-initargs :width 500 :height 500 :pos-x 100 :pos-y 100
:mode '(:double :rgb :depth) :title "shader-vao.lisp"
:tick-interval (round 1000 60)))
(defvar *shader-vao-vertex-program*
"#version 330
// The location is 0 because that's the vertex attribute we associate with vertex positions.
layout (location = 0) in vec3 in_Position;
uniform mat4 projectionMatrix;
uniform float angle;
// This is interpolated and used in the fragment shader.
smooth out vec2 pos;
void main()
{
mat2 rotationMatrix = mat2(cos(angle), sin(angle), -sin(angle), cos(angle));
float scaleFactor = 1.0 + 0.5 * sin(1.75 * angle);
vec2 vertPos = scaleFactor * rotationMatrix * in_Position.xy;
pos = vertPos * 5.0;
gl_Position = projectionMatrix * vec4(vertPos, 0.0, 1.0);
}
")
(defvar *shader-vao-fragment-program*
"#version 330
out vec4 out_Color;
smooth in vec2 pos;
uniform float angle;
void main()
{
mat2 rotationMatrix = mat2( cos(angle), sin(angle), -sin(angle), cos(angle) );
vec2 rpos = mod(rotationMatrix * pos, 2.0 );
if ((rpos.x > 1.0 && rpos.y > 1.0 ) || (rpos.x < 1.0 && rpos.y < 1.0))
out_Color = vec4(0.1, 0.1, 0.1, 1.0);
else
out_Color = vec4(0.5, 0.5, 0.7, 1.0);
}
")
;;; Initialization
;;; First, we create buffers for our vertex and index
;;; data. Then, we create the vertex array object that we actually use
;;; for rendering directly. Finally, we load the shader objects.
(defmethod glut:display-window :before ((w shader-vao-window))
;; An array buffer can be used to store verex position, colors,
;; normals, or other data. We need to allocate an GL array, copy the
;; data to the array, and tell OpenGL that the buffers data comes
;; from this GL array. Like most OpenGL state objects, we bind the
;; buffer before we can make changes to its state.
(unless (gl::features-present-p (>= :glsl-version 3.3))
(glut:destroy-current-window)
(return-from glut:display-window nil))
(let ((buffers (gl:gen-buffers 2)))
(setf (vertex-buffer w) (elt buffers 0)
(index-buffer w) (elt buffers 1)))
(gl:bind-buffer :array-buffer (vertex-buffer w))
(let ((arr (gl:alloc-gl-array :float 12))
(verts #(-0.5 -0.5 0.0
-0.5 0.5 0.0
0.5 -0.5 0.0
0.5 0.5 0.0)))
(dotimes (i (length verts))
(setf (gl:glaref arr i) (aref verts i)))
(gl:buffer-data :array-buffer :static-draw arr)
(gl:free-gl-array arr))
;; 0 is always reserved as an unbound object.
(gl:bind-buffer :array-buffer 0)
;; An element array buffer stores vertex indices. We fill it in the
;; same way as an array buffer.
(gl:bind-buffer :element-array-buffer (index-buffer w))
(let ((arr (gl:alloc-gl-array :unsigned-short 6))
(indexes #(0 2 1 1 2 3)))
(dotimes (i (length indexes))
(setf (gl:glaref arr i) (aref indexes i)))
(gl:buffer-data :element-array-buffer :static-draw arr)
(gl:free-gl-array arr))
(gl:bind-buffer :element-array-buffer 0)
;; Vertex array objects manage which vertex attributes are
;; associated with which data buffers.
(setf (vertex-array w) (gl:gen-vertex-array))
(gl:bind-vertex-array (vertex-array w))
;; To associate our VBO data with this VAO, we bind it, specify
;; which vertex attribute we want to associate it with, and specify
;; where the data comes from.
(gl:bind-buffer :array-buffer (vertex-buffer w))
;; In this program, we use attribute 0 for position. If you had
;; per-vertex normals, you could use a different attribute for those
;; as well.
(gl:enable-vertex-attrib-array 0)
;; Using a null pointer as the data source indicates that we want
;; the vertex data to come from the currently bound array-buffer.
(gl:vertex-attrib-pointer 0 3 :float nil 0 (cffi:null-pointer))
;; To associate an element array with this VAO, all we need to do is
;; bind the element array buffer we want to use.
(gl:bind-buffer :element-array-buffer (index-buffer w))
;; Once we're done, we can unbind the VAO, and rebind it when we want to render it.
(gl:bind-vertex-array 0)
;; A program object is a collection of shader objects to be used
;; together in a single pipeline for rendering objects. To create a
;; program, you first create the individual shaders. Then you attach
;; the shaders to the program and link the program together.
(let ((vs (gl:create-shader :vertex-shader))
(fs (gl:create-shader :fragment-shader)))
(setf (vertex-shader w) vs)
(setf (fragment-shader w) fs)
(gl:shader-source vs *shader-vao-vertex-program*)
(gl:compile-shader vs)
(gl:shader-source fs *shader-vao-fragment-program*)
(gl:compile-shader fs)
;; If the shader doesn't compile, you can print errors with:
;; (print (gl:get-shader-info-log vs))
;; (print (gl:get-shader-info-log fs))
(setf (program w) (gl:create-program))
;; You can attach the same shader to multiple different programs.
(gl:attach-shader (program w) vs)
(gl:attach-shader (program w) fs)
;; Don't forget to link the program after attaching the
;; shaders. This step actually puts the attached shader together
;; to form the program.
(gl:link-program (program w))
;; If we want to render using this program object, or add
;; uniforms, we need to use the program. This is similar to
;; binding a buffer.
(gl:use-program (program w))))
(defmethod glut:tick ((w shader-vao-window))
(when (slot-boundp w 'program)
(let ((seconds-per-revolution 6))
(incf (angle w)
(/ (* 2 pi) (* 60 seconds-per-revolution))))
(gl:uniformf (gl:get-uniform-location (program w) "angle") (angle w))
(glut:post-redisplay)))
(defmethod glut:display ((w shader-vao-window))
(gl:clear-color 0.0 0.0 0.2 1.0)
(gl:clear :color-buffer-bit :depth-buffer-bit)
;; Since we never use any other program object, this is unnecessary
;; in this program. Typically, though, you'll have multiple program
;; objects, so you'll need to 'use' each one to activate it.
(gl:use-program (program w))
(gl:bind-vertex-array (vertex-array w))
;; This call actually does the rendering. The vertex data comes from
;; the currently-bound VAO. If the input array is null, the indices
;; will be taken from the element array buffer bound in the current
;; VAO.
(gl:draw-elements :triangles (gl:make-null-gl-array :unsigned-short) :count 6)
(glut:swap-buffers))
(defmethod glut:reshape ((w shader-vao-window) width height)
(gl:viewport 0 0 width height)
(gl:matrix-mode :projection)
(gl:load-identity)
;; Ensure that projection matrix ratio always matches the window size ratio,
;; so the polygon will always look square.
(let ((right (max (float (/ width height)) 1.0))
(top (max (float (/ height width)) 1.0)))
(glu:ortho-2d (- right) right (- top) top))
(when (program w)
(let ((proj-mat (gl:get-float :projection-matrix)))
(gl:uniform-matrix
(gl:get-uniform-location (program w) "projectionMatrix")
4
(vector proj-mat))))
(gl:matrix-mode :modelview)
(gl:load-identity))
(defmethod glut:keyboard ((w shader-vao-window) key x y)
(declare (ignore x y))
(case key
(#\Esc (glut:destroy-current-window))))
;; Cleanup.
;; Most of the objects we created have analogous deletion function.
(defmethod glut:close ((w shader-vao-window))
;; Note: It doesn't matter whether we delete the program or the
;; linked shaders first. If a shader is linked to a program, the
;; shader isn't destroyed until after the program is
;; destroyed. Similarly, if the program is destroyed, the shaders
;; are detached.
(when (slot-boundp w 'vs)
(gl:delete-shader (vertex-shader w)))
(when (slot-boundp w 'fs)
(gl:delete-shader (fragment-shader w)))
(when (slot-boundp w 'program)
(gl:delete-program (program w)))
(when (slot-boundp w 'vbuff)
(gl:delete-buffers (list (vertex-buffer w) (index-buffer w))))
(when (slot-boundp w 'va)
(gl:delete-vertex-arrays (list (vertex-array w)))))
(defun shader-vao ()
(let ((w (make-instance 'shader-vao-window)))
(unwind-protect
(glut:display-window w)
(when (not (glut::destroyed w))
(setf (glut::destroyed w) t)
(glut:destroy-window (glut:id w))))))
| 8,734 | Common Lisp | .lisp | 199 | 40.170854 | 92 | 0.692244 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 5c1a98466641156d913869d62835ef4a8aacec9b25d6b19c4a61d8d654e5854d | 30,553 | [
-1
] |
30,557 | tess-wind.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/examples/redbook/tess-wind.lisp | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;; tess-wind.lisp --- Lisp version of tesswind.c (Red Book examples)
;;;
;;; Original C version contains the following copyright notice:
;;; Copyright (c) 1993-1997, Silicon Graphics, Inc.
;;; ALL RIGHTS RESERVED
(in-package #:cl-glut-examples)
(defclass winding-tessellator (glu:tessellator)
())
(defclass tess-wind-window (glut:window)
((current-winding :accessor current-winding :initform :odd)
(wind-list :accessor wind-list))
(:default-initargs :width 500 :height 500 :title "tess-wind.lisp"
:mode '(:single :rgb)))
(defmethod glut:display-window :before ((window tess-wind-window))
(gl:clear-color 0 0 0 0)
(gl:shade-model :flat)
(setf (wind-list window) (gl:gen-lists 4))
(make-new-lists window))
(defmethod glut:display ((window tess-wind-window))
(gl:clear :color-buffer)
(gl:color 1 1 1)
(gl:with-pushed-matrix
(gl:call-list (wind-list window))
(gl:translate 0 500 0)
(gl:call-list (1+ (wind-list window)))
(gl:translate 500 -500 0)
(gl:call-list (+ 2 (wind-list window)))
(gl:translate 0 500 0)
(gl:call-list (+ 3 (wind-list window))))
(gl:flush))
(defmethod glut:reshape ((w tess-wind-window) width height)
(gl:viewport 0 0 width height)
(gl:matrix-mode :projection)
(gl:load-identity)
(if (<= width height)
(glu:ortho-2d 0 1000 0 (* 1000 (/ height width)))
(glu:ortho-2d 0 (* 1000 (/ width height)) 0 1000))
(gl:matrix-mode :modelview)
(gl:load-identity))
(defmethod glut:keyboard ((window tess-wind-window) key x y)
(case key
((#\w #\W)
(progn
(cond ((equal (current-winding window) :odd)
(setf (current-winding window) :nonzero))
((equal (current-winding window) :nonzero)
(setf (current-winding window) :positive))
((equal (current-winding window) :positive)
(setf (current-winding window) :negative))
((equal (current-winding window) :negative)
(setf (current-winding window) :abs-geq-two))
((equal (current-winding window) :abs-geq-two)
(setf (current-winding window) :odd)))
(make-new-lists window)
(glut:post-redisplay)))
(#\Esc
(glut:destroy-current-window))))
(defmethod glu:vertex-data-callback ((tess winding-tessellator) vertex-data polygon-data)
(gl:vertex (first vertex-data)(second vertex-data)(third vertex-data)))
(defmethod glu:combine-data-callback ((tess winding-tessellator) coords vertex-data weight polygon-data)
(loop for i from 0 below 3
collect (gl:glaref coords i)))
(defun make-new-lists (window)
(let ((tobj (make-instance 'winding-tessellator))
(rects '((50 50 0) (300 50 0)
(300 300 0) (50 300 0)
(100 100 0) (250 100 0)
(250 250 0) (100 250 0)
(150 150 0) (200 150 0)
(200 200 0) (150 200 0)))
(spiral '((400 250 0) (400 50 0)
(50 50 0) (50 400 0)
(350 400 0) (350 100 0)
(100 100 0) (100 350 0)
(300 350 0) (300 150 0)
(150 150 0) (150 300 0)
(250 300 0) (250 200 0)
(200 200 0) (200 250 0)))
(quad1 '((50 150 0) (350 150 0)
(350 200 0) (50 200 0)))
(quad2 '((100 100 0) (300 100 0)
(300 350 0) (100 350 0)))
(tri '((200 50 0) (250 300 0)
(150 300 0))))
(glu:tess-property tobj :winding-rule (current-winding window))
(gl:with-new-list ((wind-list window) :compile)
(glu:with-tess-polygon (tobj)
(glu:with-tess-contour tobj
(loop for i from 0 below 4
do (glu:tess-vertex tobj (nth i rects)(nth i rects))))
(glu:with-tess-contour tobj
(loop for i from 4 below 8
do (glu:tess-vertex tobj (nth i rects)(nth i rects))))
(glu:with-tess-contour tobj
(loop for i from 8 below 12
do (glu:tess-vertex tobj (nth i rects)(nth i rects))))))
(gl:with-new-list ((1+ (wind-list window)) :compile)
(glu:with-tess-polygon (tobj)
(glu:with-tess-contour tobj
(loop for i from 0 below 4
do (glu:tess-vertex tobj (nth i rects)(nth i rects))))
(glu:with-tess-contour tobj
(loop for i from 7 downto 4
do (glu:tess-vertex tobj (nth i rects)(nth i rects))))
(glu:with-tess-contour tobj
(loop for i from 11 downto 8
do (glu:tess-vertex tobj (nth i rects)(nth i rects))))))
(gl:with-new-list ((+ 2 (wind-list window)) :compile)
(glu:with-tess-polygon (tobj)
(glu:with-tess-contour tobj
(loop for coords in spiral
do (glu:tess-vertex tobj coords coords)))))
(gl:with-new-list ((+ 3 (wind-list window)) :compile)
(glu:with-tess-polygon (tobj)
(glu:with-tess-contour tobj
(loop for coords in quad1
do (glu:tess-vertex tobj coords coords)))
(glu:with-tess-contour tobj
(loop for coords in quad2
do (glu:tess-vertex tobj coords coords)))
(glu:with-tess-contour tobj
(loop for coords in tri
do (glu:tess-vertex tobj coords coords)))))
(glu:tess-delete tobj)))
(defun rb-tess-wind ()
(glut:display-window (make-instance 'tess-wind-window))) | 5,189 | Common Lisp | .lisp | 127 | 34.472441 | 104 | 0.626616 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | cad7ce0943971423084fcf1472e7cc0421422e7e7bdbea2db2c6a4c1ea5acda5 | 30,557 | [
263094
] |
30,560 | tess.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/examples/redbook/tess.lisp | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;; tess.lisp --- Lisp version of tess.c (Red Book examples)
;;;
;;; Original C version contains the following copyright notice:
;;; Copyright (c) 1993-1997, Silicon Graphics, Inc.
;;; ALL RIGHTS RESERVED
;;;
;;; This program demonstrates polygon tessellation.
;;; Two tesselated objects are drawn. The first is a
;;; rectangle with a triangular hole. The second is a
;;; smooth shaded, self-intersecting star.
;;;
;;; Note the exterior rectangle is drawn with its vertices
;;; in counter-clockwise order, but its interior clockwise.
;;; Note the combineCallback is needed for the self-intersecting
;;; star. Also note that removing the TessProperty for the
;;; star will make the interior unshaded (WINDING_ODD).
(in-package #:cl-glut-examples)
(defclass tess-window (glut:window)
((start-list :accessor start-list))
(:default-initargs :width 500 :height 500 :title "tess.lisp"
:mode '(:single :rgb)))
(defclass example-tessellator (glu:tessellator)
())
(defclass star-tessellator (glu:tessellator)
())
(defmethod glut:display-window :before ((window tess-window))
(let ((tobj (make-instance 'example-tessellator))
(rect '((50 50 0)
(200 50 0)
(200 200 0)
(50 200 0)))
(tri '((75 75 0)
(125 175 0)
(175 75 0)))
(star '((250 50 0 1 0 1)
(325 200 0 1 1 0)
(400 50 0 0 1 1)
(250 150 0 1 0 0)
(400 150 0 0 1 0))))
(gl:clear-color 0 0 0 0)
(setf (start-list window) (gl:gen-lists 2))
;; need to initialize tess property in case it is messed up
(glu:tess-property tobj :winding-rule :positive)
;;rectangle with triangular hole inside
(gl:with-new-list ((start-list window) :compile)
(gl:shade-model :flat)
(glu:with-tess-polygon (tobj)
(glu:with-tess-contour tobj
(loop for coords in rect
do (glu:tess-vertex tobj coords coords)))
(glu:with-tess-contour tobj
(loop for coords in tri
do (glu:tess-vertex tobj coords coords)))))
(glu:tess-delete tobj)
;;smooth shaded, self-intersecting star
(setf tobj (make-instance 'star-tessellator))
(gl:with-new-list ((1+ (start-list window)) :compile)
(gl:shade-model :smooth)
(glu:tess-property tobj :winding-rule :positive)
(glu:with-tess-polygon (tobj)
(glu:with-tess-contour tobj
(loop for coords in star
do (glu:tess-vertex tobj coords coords)))))
(glu:tess-delete tobj)))
(defmethod glut:display ((window tess-window))
(gl:clear :color-buffer)
(gl:color 1 1 1)
(gl:call-list (start-list window))
(gl:call-list (1+ (start-list window)))
(gl:flush))
(defmethod glut:reshape ((w tess-window) width height)
(gl:viewport 0 0 width height)
(gl:matrix-mode :projection)
(gl:load-identity)
(glu:ortho-2d 0 width 0 height))
(defmethod glut:keyboard ((w tess-window) key x y)
(declare (ignore x y))
(when (eql key #\Esc)
(glut:destroy-current-window)))
(defmethod glu:vertex-data-callback ((tess example-tessellator) vertex-data polygon-data)
(gl:vertex (first vertex-data) (second vertex-data) (third vertex-data)))
(defmethod glu:vertex-data-callback ((tess star-tessellator) vertex-data polygon-data)
(gl:color (fourth vertex-data) (fifth vertex-data) (sixth vertex-data))
(gl:vertex (first vertex-data) (second vertex-data) (third vertex-data)))
(defmethod glu:combine-data-callback ((tess star-tessellator) coords vertex-data weight polygon-data)
(nconc
(loop for i from 0 below 3
collect (gl:glaref coords i))
(loop for i from 3 below 6
collect (+ (* (gl:glaref weight 0)
(nth i (aref vertex-data 0)))
(* (gl:glaref weight 1)
(nth i (aref vertex-data 1)))
(* (gl:glaref weight 2)
(nth i (aref vertex-data 2)))
(* (gl:glaref weight 3)
(nth i (aref vertex-data 3)))))))
(defun rb-tess ()
(glut:display-window (make-instance 'tess-window)))
| 4,232 | Common Lisp | .lisp | 100 | 35.27 | 101 | 0.634343 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 8f301d96d123f7a09121d177734ff99d85485ab8f07117ff41f3cd41b48bc441 | 30,560 | [
432546
] |
30,565 | movelight.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/examples/redbook/movelight.lisp | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;; movelight.lisp --- Lisp version of movelight.c (Red Book examples)
;;;
;;; Original C version contains the following copyright notice:
;;; Copyright (c) 1993-1997, Silicon Graphics, Inc.
;;; ALL RIGHTS RESERVED
;;; This program demonstrates when to issue lighting and
;;; transformation commands to render a model with a light
;;; which is moved by a modeling transformation (rotate or
;;; translate). The light position is reset after the modeling
;;; transformation is called. The eye position does not change.
;;;
;;; A sphere is drawn using a grey material characteristic.
;;; A single light source illuminates the object.
;;;
;;; Interaction: pressing the left mouse button alters
;;; the modeling transformation (x rotation) by 30 degrees.
;;; The scene is then redrawn with the light in a new position.
(in-package #:cl-glut-examples)
(defclass movelight-window (glut:window)
((spin :initform 0))
(:default-initargs :width 500 :height 500 :pos-x 100 :pos-y 100
:mode '(:single :rgb :depth) :title "movelight.lisp"))
(defmethod glut:display-window :before ((w movelight-window))
(gl:clear-color 0 0 0 0)
(gl:shade-model :smooth)
(gl:enable :lighting)
(gl:enable :light0)
(gl:enable :depth-test))
;;; Here is where the light position is reset after the modeling
;;; transformation (GL:ROTATE) is called. This places the
;;; light at a new position in world coordinates. The cube
;;; represents the position of the light.
(defmethod glut:display ((w movelight-window))
(gl:clear :color-buffer :depth-buffer)
(gl:with-pushed-matrix
(glu:look-at 0 0 5 0 0 0 0 1 0)
(gl:with-pushed-matrix
(gl:rotate (slot-value w 'spin) 1 0 0)
(gl:light :light0 :position #(0 0 1.5 1))
(gl:translate 0 0 1.5)
(gl:disable :lighting)
(gl:color 0 1 1)
(glut:wire-cube 0.1)
(gl:enable :lighting))
(glut:solid-torus 0.275 0.85 8 15))
(gl:flush))
(defmethod glut:reshape ((w movelight-window) width height)
(gl:viewport 0 0 width height)
(gl:matrix-mode :projection)
(gl:load-identity)
(glu:perspective 40 (/ width height) 1 20)
(gl:matrix-mode :modelview)
(gl:load-identity))
(defmethod glut:mouse ((w movelight-window) button state x y)
(declare (ignore x y))
(when (and (eq button :left-button) (eq state :down))
(with-slots (spin) w
(setf spin (mod (+ spin 30) 360)))
(glut:post-redisplay)))
(defmethod glut:keyboard ((w movelight-window) key x y)
(declare (ignore x y))
(case key
(#\Esc (glut:destroy-current-window))))
(defun rb-movelight ()
(glut:display-window (make-instance 'movelight-window)))
| 2,688 | Common Lisp | .lisp | 66 | 37.545455 | 75 | 0.698048 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 3eb225df1149355b0d41b21e11c932dda6f02425cebc639070214cfdb6a99fb5 | 30,565 | [
157850
] |
30,566 | quadric.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/examples/redbook/quadric.lisp |
;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;; quadric.lisp --- Lisp version of quadric.c (Red Book examples)
;;;
(in-package #:cl-glut-examples)
(defclass quadric-window (glut:window)
((start-list :accessor start-list))
(:default-initargs :width 500 :height 500 :title "quadric.lisp"
:mode '(:single :rgb :depth)))
(defmethod glut:display-window :before ((window quadric-window))
(let ((quadric-obj)
(mat-ambient '(0.5 0.5 0.5 1.0))
(mat-specular '(1.0 1.0 1.0 1.0))
(mat-shininess 50)
(light-position '(1.0 1.0 1.0 0.0))
(model-ambient '(0.5 0.5 0.5 1.0)))
(gl:clear-color 0 0 0 0)
(gl:material :front :ambient mat-ambient)
(gl:material :front :specular mat-specular)
(gl:material :front :shininess mat-shininess)
(gl:light :light0 :position light-position)
(gl:light-model :light-model-ambient model-ambient)
(gl:enable :lighting)
(gl:enable :light0)
(gl:enable :depth-test)
;; Create 4 display lists, each with a different quadric object.
;; Different drawing styles and surface normal specifications
;; are demonstrated.
(setf (start-list window) (gl:gen-lists 4))
(setf quadric-obj (glu:new-quadric))
;;todo
;; gluQuadricCallback(qobj, GLU_ERROR,
;; (GLvoid (CALLBACK*) ()) errorCallback);
(glu:quadric-draw-style quadric-obj :fill) ;;smooth shaded
(glu:quadric-normals quadric-obj :smooth)
(gl:with-new-list ((start-list window) :compile)
(glu:sphere quadric-obj 0.75 15 10))
(glu:quadric-draw-style quadric-obj :fill) ;;flat shaded
(glu:quadric-normals quadric-obj :flat)
(gl:with-new-list ((1+ (start-list window)) :compile)
(glu:cylinder quadric-obj 0.5 0.3 1 15 5))
(glu:quadric-draw-style quadric-obj :line) ;;all polygons wireframe
(glu:quadric-normals quadric-obj :none)
(gl:with-new-list ((+ 2 (start-list window)) :compile)
(glu:disk quadric-obj 0.25 1 20 4))
(glu:quadric-draw-style quadric-obj :silhouette) ;;boundary only
(glu:quadric-normals quadric-obj :none)
(gl:with-new-list ((+ 3 (start-list window)) :compile)
(glu:partial-disk quadric-obj 0 1 20 4 0 225))
(glu:delete-quadric quadric-obj)))
(defmethod glut:display ((window quadric-window))
(gl:clear :color-buffer :depth-buffer-bit)
(gl:with-pushed-matrix
(gl:enable :lighting)
(gl:shade-model :smooth)
(gl:translate -1.0 -1.0 0.0)
(gl:call-list (start-list window))
(gl:shade-model :flat)
(gl:translate 0.0 2.0 0.0)
(gl:with-pushed-matrix
(gl:rotate 300.0 1.0 0.0 0.0)
(gl:call-list (1+ (start-list window))))
(gl:disable :lighting)
(gl:color 0.0 1.0 1.0)
(gl:translate 2.0 -2.0 0.0)
(gl:call-list (+ 2 (start-list window)))
(gl:color 1.0 1.0 0.0)
(gl:translate 0.0 2.0 0.0)
(gl:call-list (+ 3 (start-list window))))
(gl:flush))
(defmethod glut:reshape ((w quadric-window) width height)
(gl:viewport 0 0 width height)
(gl:matrix-mode :projection)
(gl:load-identity)
(if (<= width height)
(gl:ortho -2.5 2.5 (/ (* -2.5 height) width)
(/ (* 2.5 height) width) -10.0 10.0)
(gl:ortho (/ (* -2.5 width) height) (/ (* 2.5 width) height)
-2.5 2.5 -10 10))
(gl:matrix-mode :modelview)
(gl:load-identity))
(defmethod glut:keyboard ((w quadric-window) key x y)
(declare (ignore x y))
(when (eql key #\Esc)
(glut:destroy-current-window)))
(defun rb-quadric ()
(glut:display-window (make-instance 'quadric-window))) | 3,524 | Common Lisp | .lisp | 86 | 36.313953 | 71 | 0.652798 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 1971b2ea5f46a349398ac1bbd58b43509bcb322c4600184aff474919b3e9bbf3 | 30,566 | [
387153
] |
30,567 | bezcurve.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/examples/redbook/bezcurve.lisp | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;; bezcurve.lisp --- Lisp version of bezcurve.c (Red Book examples)
;;;
;;; This program uses evaluators to draw a Bezier curve.
(in-package #:cl-glut-examples)
(defclass bezcurve-window (glut:window)
((control-points :accessor control-points :initform (make-array '(4 3) :initial-contents
'((-4 -4 0) (-2 4 0)
(2 -4 0) (4 4 0)))))
(:default-initargs :width 500 :height 500 :title "bezcurve.lisp"
:mode '(:single :rgb)))
(defmethod glut:display-window :before ((window bezcurve-window))
(gl:clear-color 0 0 0 0)
(gl:shade-model :flat)
(gl:map1 :map1-vertex-3 0 1 (control-points window))
(gl:enable :map1-vertex-3))
(defmethod glut:display ((window bezcurve-window))
(gl:clear :color-buffer-bit)
(gl:color 1 1 1)
(gl:with-primitive :line-strip
(loop for i from 0 to 30
do (gl:eval-coord-1 (/ i 30))))
;; The following code displays the control points as dots.
(gl:point-size 5)
(gl:color 1 1 0)
(gl:with-primitive :points
(loop for i from 0 below 4
for l = (* 3 i)
do (gl:vertex
(row-major-aref (control-points window) l)
(row-major-aref (control-points window) (+ 1 l))
(row-major-aref (control-points window) (+ 2 l)))))
(gl:flush))
(defmethod glut:reshape ((w bezcurve-window) width height)
(gl:viewport 0 0 width height)
(gl:matrix-mode :projection)
(gl:load-identity)
(if (<= width height)
(gl:ortho -5 5 (/ (* -5 height) width)
(/ (* 5 height) width) -5 5)
(gl:ortho (/ (* -5 width) height) (/ (* 5 width) height)
-5 5 -5 5))
(gl:matrix-mode :modelview)
(gl:load-identity))
(defmethod glut:keyboard ((w bezcurve-window) key x y)
(declare (ignore x y))
(when (eql key #\Esc)
(glut:destroy-current-window)))
(defun rb-bezcurve ()
(glut:display-window (make-instance 'bezcurve-window))) | 2,036 | Common Lisp | .lisp | 50 | 33.76 | 90 | 0.600709 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | b70e16489d79c34255a097545dbafd63803b6d8feae1d7e0022f9db81dc37ea2 | 30,567 | [
156676
] |
30,570 | list.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/examples/redbook/list.lisp | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;; list.lisp --- Lisp version of list.c (Red Book examples)
;;;
;;; Original C version contains the following copyright notice:
;;; Copyright (c) 1993-1997, Silicon Graphics, Inc.
;;; ALL RIGHTS RESERVED
;;; This program demonstrates how to make and execute a
;;; display list. Note that attributes, such as current
;;; color and matrix, are changed.
(in-package #:cl-glut-examples)
(defclass list-window (glut:window)
((list-name :accessor list-name :initform nil))
(:default-initargs
:width 600 :height 50 :title "list.lisp" :mode '(:single :rgb)))
(defmethod glut:display-window :before ((w list-window))
(unless (list-name w)
(setf (list-name w) (gl:gen-lists 1)))
(gl:with-new-list ((list-name w) :compile)
(gl:color 1 0 0) ; red
(gl:with-primitives :triangles
(gl:vertex 0 0)
(gl:vertex 1 0)
(gl:vertex 0 1))
(gl:translate 1.5 0 0)) ; move position
(gl:shade-model :flat))
(defmethod glut:display ((w list-window))
(gl:load-identity)
(gl:clear :color-buffer)
(gl:color 0 1 0) ; current color green
(loop repeat 10 do (gl:call-list (list-name w)))
(gl:with-primitives :lines ; is this line green? NO!
(gl:vertex 0 0.5) ; where is the line drawn?
(gl:vertex 15 0.5))
(gl:flush))
(defmethod glut:reshape ((w list-window) width height)
(gl:viewport 0 0 width height)
(gl:matrix-mode :projection)
(gl:load-identity)
(if (<= width height)
(glu:ortho-2d 0 2 (* -0.5 (/ height width)) (* 1.5 (/ height width)))
(glu:ortho-2d 0 (* 2 (/ width height)) -0.5 1.5))
(gl:matrix-mode :modelview)
(gl:load-identity))
(defmethod glut:keyboard ((w list-window) key x y)
(declare (ignore x y))
(when (eql key #\Esc)
(glut:destroy-current-window)))
(defun rb-list ()
(glut:display-window (make-instance 'list-window)))
| 1,948 | Common Lisp | .lisp | 49 | 36.530612 | 75 | 0.638287 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | fe9ccbffea164bcd944cd8e1b613d2867555208401c10c721641c6077ebc77a4 | 30,570 | [
348609
] |
30,574 | extensions.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/extensions.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; extensions.lisp --- OpenGL extensions.
;;;
;;; Copyright (c) 2006, Oliver Markovic <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; o Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may
;;; be used to endorse or promote products derived from this software
;;; without specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
;;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
;;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
;;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-opengl)
;;;
;;; EXT_framebuffer_object
;;;
(import-export %gl:is-renderbuffer-ext
%gl:bind-renderbuffer-ext
%gl:is-renderbuffer
%gl:bind-renderbuffer)
(defun delete-renderbuffers (renderbuffers)
(with-opengl-sequence (array '%gl:uint renderbuffers)
(%gl:delete-renderbuffers (length renderbuffers) array)))
(defun gen-renderbuffers (count)
(with-foreign-object (renderbuffer-array '%gl:uint count)
(%gl:gen-renderbuffers count renderbuffer-array)
(loop for i below count
collecting (mem-aref renderbuffer-array '%gl:uint i))))
(defun gen-renderbuffer ()
(with-foreign-object (renderbuffer '%gl:uint 1)
(%gl:gen-renderbuffers 1 renderbuffer)
(mem-aref renderbuffer '%gl:uint 0)))
(defun delete-renderbuffers-ext (renderbuffers)
(with-opengl-sequence (array '%gl:uint renderbuffers)
(%gl:delete-renderbuffers-ext (length renderbuffers) array)))
(defun gen-renderbuffers-ext (count)
(with-foreign-object (renderbuffer-array '%gl:uint count)
(%gl:gen-renderbuffers-ext count renderbuffer-array)
(loop for i below count
collecting (mem-aref renderbuffer-array '%gl:uint i))))
(import-export %gl:renderbuffer-storage %gl:renderbuffer-storage-ext)
#+nil
(defun get-renderbuffer-parameter-ext (target pname)
)
(import-export %gl:is-framebuffer %gl:is-framebuffer-ext
%gl:bind-framebuffer %gl:bind-framebuffer-ext)
(defun delete-framebuffers (framebuffers)
(with-opengl-sequence (array '%gl:uint framebuffers)
(%gl:delete-framebuffers (length framebuffers) array)))
(defun gen-framebuffers (count)
(with-foreign-object (framebuffer-array '%gl:uint count)
(%gl:gen-framebuffers count framebuffer-array)
(loop for i below count
collecting (mem-aref framebuffer-array '%gl:uint i))))
(defun gen-framebuffer ()
(with-foreign-object (framebuffer '%gl:uint 1)
(%gl:gen-framebuffers 1 framebuffer)
(mem-aref framebuffer '%gl:uint 0)))
(defun delete-framebuffers-ext (framebuffers)
(with-opengl-sequence (array '%gl:uint framebuffers)
(%gl:delete-framebuffers-ext (length framebuffers) array)))
(defun gen-framebuffers-ext (count)
(with-foreign-object (framebuffer-array '%gl:uint count)
(%gl:gen-framebuffers-ext count framebuffer-array)
(loop for i below count
collecting (mem-aref framebuffer-array '%gl:uint i))))
(import-export %gl:check-framebuffer-status %gl:check-framebuffer-status-ext
%gl:framebuffer-texture-1d %gl:framebuffer-texture-1d-ext
%gl:framebuffer-texture-2d %gl:framebuffer-texture-2d-ext
%gl:framebuffer-texture-3d %gl:framebuffer-texture-3d-ext
%gl:framebuffer-renderbuffer %gl:framebuffer-renderbuffer-ext)
#+nil
(defun get-framebuffer-attachment-parameter-ext (target attachment pname)
(ecase pname
(:framebuffer )))
(import-export %gl:generate-mipmap %gl:generate-mipmap-ext)
;;;
;;; ARB_uniform_buffer_object
;;;
(defun get-uniform-block-index (program uniformblockname)
(with-foreign-string (s uniformblockname)
(%gl:get-uniform-block-index program s)))
| 4,876 | Common Lisp | .lisp | 101 | 44.50495 | 77 | 0.73806 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 0c26be2ae83ca2778fd3ec9038f8226545e344bbca0980754a43179e02d46136 | 30,574 | [
428404
] |
30,575 | opengl.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/opengl.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; Copyright (c) 2004, Oliver Markovic <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions are met:
;;;
;;; o Redistributions of source code must retain the above copyright notice,
;;; this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may be
;;; used to endorse or promote products derived from this software without
;;; specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
;;; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
;;; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
;;; LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
;;; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
;;; SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
;;; CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
;;; ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
;;; POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-opengl)
;;;
;;; Chapter 2 - OpenGL Operation
;;;
;;; 2.5 GL Errors
;;;
(import-export %gl:get-error
%gl:opengl-error
%gl:check-error)
;;;
;;; 2.6 Begin/End Paradigm
;;;
;;; 2.6.1 Begin and End
(import-export %gl:begin %gl:end)
(defmacro with-primitives (mode &body body)
`(prog2
(begin ,mode)
(progn ,@body)
(end)))
;;; synonym for with-primitives.
(defmacro with-primitive (mode &body body)
`(prog2
(begin ,mode)
(progn ,@body)
(end)))
;;; 2.6.2 Polygon Edges
(import-export %gl:edge-flag)
;;;
;;; 2.7 Vertex Specification
;;;
(definline vertex (x y &optional (z 0.0) (w 1.0))
(%gl:vertex-4f x y z w))
(definline tex-coord (s &optional (r 0.0) (t* 0.0) (q 1.0))
(%gl:tex-coord-4f s r t* q))
(definline multi-tex-coord (texture s &optional (t* 0.0) (r 0.0) (q 1.0))
(%gl:multi-tex-coord-4f texture s t* r q))
(definline normal (x y z)
(%gl:normal-3f x y z))
(definline fog-coord (coord)
(%gl:fog-coord-f coord))
(definline color (r g b &optional (a 1.0))
(%gl:color-4f r g b a))
(definline secondary-color (r g b)
(%gl:secondary-color-3f r g b))
(definline index (index)
(%gl:index-i index))
(definline vertex-attrib (index x &optional (y 0.0) (z 0.0) (w 1.0))
(%gl:vertex-attrib-4f index x y z w))
;;;
;;; 2.8 Vertex Arrays
;;;
(import-export %gl:array-element
%gl:enable-client-state
%gl:disable-client-state
%gl:client-active-texture
%gl:enable-vertex-attrib-array
%gl:disable-vertex-attrib-array
%gl:draw-arrays)
(definline draw-elements (mode array &key (count (gl-array-size array))
(offset 0))
;; fix count to whole array size?
;; bounds checking?
(%gl:draw-elements mode count
(cffi-type-to-gl (gl-array-type array))
(gl-array-pointer-offset array offset)))
(import-export %gl:vertex-attrib-pointer
%gl:vertex-attrib-ipointer)
;;;
;;; 2.9 Buffer Objects
;;;
(import-export %gl:bind-buffer)
(defun delete-buffers (buffers)
(with-opengl-sequence (array '%gl:uint buffers)
(%gl:delete-buffers (length buffers) array)))
(defun gen-buffers (count)
(with-foreign-object (buffer-array '%gl:uint count)
(%gl:gen-buffers count buffer-array)
(loop for i below count
collecting (mem-aref buffer-array '%gl:uint i))))
(defun gen-buffer ()
(with-foreign-object (array '%gl:uint 1)
(%gl:gen-buffers 1 array)
(mem-aref array '%gl:uint 0)))
(import-export %gl:map-buffer
%gl:unmap-buffer)
(define-get-function get-buffer-parameter (target pname)
(%gl:get-buffer-parameter-iv :int int)
(%gl:get-buffer-pointer-v :pointer))
;;; Offset is offset in array, buffer-offset in VBO.
(definline buffer-sub-data (target array &key (offset 0) (buffer-offset 0)
(size (gl-array-byte-size array)))
(%gl:buffer-sub-data target buffer-offset size
(gl-array-pointer-offset array offset)))
;;; NOTE: arguments are flipped compared to gl function to allow
;;; optional offset.
(definline buffer-data (target usage array &key (offset 0)
(size (gl-array-byte-size array)))
(%gl:buffer-data target size (gl-array-pointer-offset array offset) usage))
;;; Returns a CFFI:DEFCSTRUCT fragment for CLAUSE.
(defun emit-gl-array-struct-clause (clause)
(destructuring-bind (array-type &key type components &allow-other-keys)
clause
(declare (ignore array-type))
(loop for c in components
collect `(,c ,type))))
;;; Returns a binding form for CLAUSE. This function extracts needed
;;; parameters from CLAUSE and uses OFFSET and STRIDE as memory layout
;;; informations. PSYM is used as symbol for the pointer in the form.
(defun emit-gl-array-bind-clause (clause offset stride psym)
(destructuring-bind (array-type &rest rest &key type components
&allow-other-keys)
clause
(let ((func-name (symbolicate-package '#:%gl array-type '#:-pointer))
(gl-type (cffi-type-to-gl type))
(address-expr `(inc-pointer ,psym ,offset))
(size (length components)))
(ecase array-type
((vertex color secondary-color)
`(,func-name ,size ,gl-type ,stride ,address-expr))
((normal index fog-coord)
`(,func-name ,gl-type ,stride ,address-expr))
(tex-coord
(destructuring-bind (&key (stage :texture0) &allow-other-keys)
rest
`(progn
(client-active-texture ,stage)
(,func-name ,size ,gl-type ,stride ,address-expr))))
(edge-flag ; type is fixed
`(,func-name ,stride ,address-expr))
(vertex-attrib
(destructuring-bind (&key (index 0) (normalized nil) &allow-other-keys)
rest
`(,func-name ,index ,size ,type ,normalized ,stride
,address-expr)))))))
(defmacro define-gl-array-format (name &body clauses)
"Defines a vertex array format spcification. Each clause has
the format (array-type parameter*) where array-type can
currently be one of VERTEX, COLOR, SECONDARY-COLOR, NORMAL,
INDEX, FOG-COORD, TEX-COORD, EDGE-FLAG OR VERTEX-ATTRIB.
Parameters are keyword arguments for the corresponding array
type. The following parameters are supported:
:TYPE -- array element type (all array types)
:COMPONENTS -- list of component (slot) names for this array (all types)
:STAGE -- active texture for the array (TEX-COORD type)
:INDEX -- vertex attribute index (VERTEX-ATTRIB type)
:NORMALIZED -- whether values should be normalized (VERTEX-ATTRIB)
"
`(progn
(defcstruct ,name
,@(mapcan #'emit-gl-array-struct-clause clauses))
(setf (get ',name 'vertex-array-binder)
(compile
nil
`(lambda (p)
,,@(loop with stride = `(foreign-type-size ',name)
for c in clauses
for offset = `(foreign-slot-offset
',name ',(caadr (member :components c)))
collect `(emit-gl-array-bind-clause
',c ,offset ,stride 'p)))))
',name))
;;; Returns the vertex array binder for SYMBOL-OR-FUNCTION. This
;;; function is idempotent.
(defun find-vertex-array-binder (symbol-or-function &optional (errorp t))
(ctypecase symbol-or-function
(function symbol-or-function)
(symbol (or (get symbol-or-function 'vertex-array-binder)
(when errorp
(error "Vertex array format ~A not defined."
symbol-or-function))))))
;;; Sets the vertex array binder of SYMBOL to VALUE. VALUE must be a
;;; function of one argument, the array pointer.
(defun (setf find-vertex-array-binder) (value symbol)
(check-type value function)
(setf (get symbol 'vertex-array-binder) value))
(defstruct (gl-array (:copier nil))
"Pointer to C array with size and type information attached."
(pointer (null-pointer))
(size 0 :type unsigned-byte)
(type nil :type symbol))
(defstruct (gl-vertex-array (:copier nil) (:include gl-array))
"Like GL-ARRAY, but with an aditional vertex array binder."
(binder #'identity :type function))
(defun alloc-gl-array (type count)
(if (get type 'vertex-array-binder)
(make-gl-vertex-array
:pointer (foreign-alloc type :count count)
:size count :type type :binder (get type 'vertex-array-binder))
(make-gl-array :pointer (foreign-alloc type :count count)
:size count :type type)))
(declaim (inline make-gl-array-from-pointer))
(defun make-gl-array-from-pointer (ptr type count)
"Same as ALLOC-GL-ARRAY but uses a supplied pointer instead of
allocating new memory."
(let ((binder (find-vertex-array-binder type nil)))
(if binder
(make-gl-vertex-array :pointer ptr :size count
:type type :binder binder)
(make-gl-array :pointer ptr :size count :type type))))
(defun free-gl-array (array)
"Frees an array allocated by ALLOC-GL-ARRAY."
(foreign-free (gl-array-pointer array)))
(defun make-null-gl-array (type)
"Returns a GL-ARRAY with a size of 0, a null pointer and of type TYPE."
(make-gl-array-from-pointer (null-pointer) type 0))
;;; Returns a pointer to the OFFSET-th element in ARRAY. I think this
;;; is different from mem-aref for simple types.
(declaim (inline gl-array-pointer-offset))
(defun gl-array-pointer-offset (array offset)
(inc-pointer (gl-array-pointer array)
(* (foreign-type-size (gl-array-type array)) offset)))
;;; Returns the number of bytes in the array.
(declaim (inline gl-array-byte-size))
(defun gl-array-byte-size (array)
(* (gl-array-size array) (foreign-type-size (gl-array-type array))))
(defun bind-gl-vertex-array (array &optional (offset 0))
"Binds ARRAY starting at the OFFSET-th element."
(funcall (gl-vertex-array-binder array)
(gl-array-pointer-offset array offset)))
(defmacro with-gl-array ((var type &key count) &body forms)
"Allocates a fresh GL-ARRAY of type TYPE and COUNT elements.
The array will be bound to VAR and is freed when execution moves
outside WITH-GL-ARRAY."
(with-unique-names (ptr)
`(with-foreign-object (,ptr ,type ,count)
(let ((,var (make-gl-array-from-pointer ,ptr ,type ,count)))
(declare (dynamic-extent ,var))
,@forms))))
;;; TODO: find a better name. I keep reading this as
;;; glare-f. [2007-03-14 LO]
(declaim (inline glaref))
(defun glaref (array index &optional (component nil c-p))
"Returns the INDEX-th component of ARRAY. If COMPONENT is
supplied and ARRAY is of a compound type the component named
COMPONENT is returned."
(if c-p
(foreign-slot-value (mem-aref (gl-array-pointer array)
(gl-array-type array)
index)
(gl-array-type array)
component)
(mem-aref (gl-array-pointer array) (gl-array-type array) index)))
(declaim (inline (setf glaref)))
(defun (setf glaref) (value array index &optional (component nil c-p))
"Sets the place (GLAREF ARRAY INDEX [COMPONENT]) to VALUE."
(if c-p
(setf (foreign-slot-value (mem-aref (gl-array-pointer array)
(gl-array-type array)
index)
(gl-array-type array)
component)
value)
(setf (mem-aref (gl-array-pointer array) (gl-array-type array) index)
value)))
(declaim (inline map-buffer-to-gl-array))
(defun map-buffer-to-gl-array (target access type)
"This is like MAP-BUFFER but returns a GL-ARRAY instead of a plain pointer.
Note that you must not call FREE-GL-ARRAY but UNMAP-BUFFER on the
return value."
(make-gl-array-from-pointer
(map-buffer target access)
type
(floor (get-buffer-parameter target :buffer-size :int)
(foreign-type-size type))))
(defmacro with-mapped-buffer ((p target access) &body body)
"Maps the buffer currently bound to TARGET with ACCESS storing
the returned pointer in P. The buffer is unmapped when execution
leaves WITH-MAPPED-BUFFER. Note that this will break when
another buffer is bound within FORMS."
(once-only (target)
`(let ((,p (map-buffer ,target ,access)))
(unwind-protect
(progn ,@body)
(unmap-buffer ,target)))))
(defmacro with-gl-mapped-buffer ((a target access type) &body body)
"This is like WITH-MAPPED-BUFFER, but maps to a GL-ARRAY instead."
`(let ((,a (map-buffer-to-gl-array ,target ,access ,type)))
(declare (dynamic-extent ,a))
(unwind-protect
(progn ,@body)
(unmap-buffer ,target))))
;;;
;;; 2.10 Rectangles
;;;
(definline rect (x1 y1 x2 y2)
(%gl:rect-f x1 y1 x2 y2))
;;;
;;; 2.10 Vertex Array Objects (3.0/ARB_vertex_array_object)
;;;
(defun delete-vertex-arrays (arrays)
(with-opengl-sequence (array '%gl:uint arrays)
(%gl:delete-vertex-arrays (length arrays) array)))
(defun gen-vertex-arrays (count)
(with-foreign-object (array '%gl:uint count)
(%gl:gen-vertex-arrays count array)
(loop for i below count
collecting (mem-aref array '%gl:uint i))))
;; shortcut for the common case where we only want 1
(defun gen-vertex-array ()
(with-foreign-object (array '%gl:uint 1)
(%gl::gen-vertex-arrays 1 array)
(mem-aref array '%gl:uint 0)))
(import-export %gl:bind-vertex-array)
;;;
;;; 2.11 Coordinate Transformations
;;;
;;; 2.11.1 Controlling the Viewport
(import-export %gl:depth-range
%gl:viewport)
;;; 2.11.2 Matrices
(import-export %gl:matrix-mode)
(defmacro with-foreign-matrix ((sym matrix) &body body)
`(with-foreign-object (,sym '%gl:float 16)
(dotimes (i 16)
(setf (mem-aref ,sym '%gl:float i) (row-major-aref ,matrix i)))
,@body))
(defun load-matrix (matrix)
(with-foreign-matrix (foreign-matrix matrix)
(%gl:load-matrix-f foreign-matrix)))
(defun mult-matrix (matrix)
(with-foreign-matrix (foreign-matrix matrix)
(%gl:mult-matrix-f foreign-matrix)))
(defun load-transpose-matrix (matrix)
(with-foreign-matrix (foreign-matrix matrix)
(%gl:load-transpose-matrix-f foreign-matrix)))
(defun mult-transpose-matrix (matrix)
(with-foreign-matrix (foreign-matrix matrix)
(%gl:mult-transpose-matrix-f foreign-matrix)))
(definline rotate (theta x y z)
(%gl:rotate-f theta x y z))
(definline translate (x y z)
(%gl:translate-f x y z))
(definline scale (x y z)
(%gl:scale-f x y z))
(import-export %gl:frustum
%gl:ortho
%gl:active-texture
%gl:load-identity
%gl:push-matrix
%gl:pop-matrix)
(defmacro with-pushed-matrix (&body body)
`(progn
(push-matrix)
(multiple-value-prog1 (progn ,@body)
(pop-matrix))))
(defmacro with-pushed-matrix* ((matrix) &body body)
;; fixme: should once-only matrix, but only if it isn't a keyword
`(progn
(matrix-mode ,matrix)
(push-matrix)
(unwind-protect
(progn ,@body)
(matrix-mode ,matrix)
(pop-matrix))))
(import-export %gl:active-texture)
;;;
;;; 2.11.4 Generating Texture Coordinates
;;;
(defun tex-gen (coord pname param)
(ecase pname
(:texture-gen-mode
(%gl:tex-gen-i coord pname (foreign-enum-value '%gl:enum param)))
((:object-plane :eye-plane)
(with-foreign-object (plane '%gl:float 4)
(dotimes (i 4)
(setf (mem-aref plane '%gl:float i) (float (elt param i))))
(%gl:tex-gen-fv coord pname plane)))))
;;;
;;; 2.12 Clipping
;;;
(defun clip-plane (plane eqn)
(when (< (length eqn) 4)
(error "EQN must have 4 coefficents."))
(with-opengl-sequence (p '%gl:double eqn)
(%gl:clip-plane plane p)))
;;;
;;; 2.13 Current Raster Position
;;;
(definline raster-pos (x y &optional (z 0.0) (w 1.0))
(%gl:raster-pos-4f x y z w))
(definline window-pos (x y &optional (z 0.0))
(%gl:window-pos-3f x y z))
;;;
;;; 2.14 Colors and Coloring
;;;
;;; 2.14.1 Lighting
(import-export %gl:front-face)
;;; 2.14.2 Lighting Parameter Specification
(defun material (face pname param)
(ecase pname
((:ambient :diffuse :ambient-and-diffuse :specular :emission)
(with-foreign-object (p '%gl:float 4)
(dotimes (i 4)
(setf (mem-aref p '%gl:float i) (float (elt param i))))
(%gl:material-fv face pname p)))
(:shininess
(%gl:material-f face pname (float param)))
(:color-indexes
(with-foreign-object (p '%gl:int 3)
(dotimes (i 3)
(setf (mem-aref p '%gl:int i) (elt param i)))
(%gl:material-iv face pname p)))))
(defun light (light pname value)
(ecase pname
((:ambient :diffuse :specular :position)
(with-foreign-object (p '%gl:float 4)
(dotimes (i 4)
(setf (mem-aref p '%gl:float i) (float (elt value i))))
(%gl:light-fv light pname p)))
(:spot-direction
(with-foreign-object (p '%gl:float 3)
(dotimes (i 3)
(setf (mem-aref p '%gl:float i) (float (elt value i))))
(%gl:light-fv light pname p)))
((:spot-exponent :spot-cutoff :constant-attenuation :linear-attenuation
:quadratic-attenuation)
(%gl:light-f light pname (float value)))))
(defun light-model (pname value)
(ecase pname
(:light-model-ambient
(with-foreign-object (p '%gl:float 4)
(dotimes (i 4)
(setf (mem-aref p '%gl:float i) (float (elt value i))))
(%gl:light-model-fv pname p)))
(:light-model-color-control
(%gl:light-model-i pname (foreign-enum-value '%gl:enum value)))
((:light-model-local-viewer :light-model-two-side)
(%gl:light-model-i pname (if value 1 0)))))
;;; 2.14.3 ColorMaterial
(import-export %gl:color-material)
;;; 2.14.7 Flatshading
(import-export %gl:shade-model)
;;;
;;; 2.15 Vertex Shaders
;;;
;;; 2.15.1 Shader Objects
(import-export %gl:create-shader)
(defun shader-source (shader string-list)
(when (stringp string-list) (setf string-list (list string-list)))
(let ((num-lines (length string-list)))
(with-foreign-object (string-array :pointer num-lines)
;; copy the list of Lisp strings into an array of C strings
(loop for line in string-list
count line into i
do (setf (mem-aref string-array :pointer (1- i))
(foreign-string-alloc line)))
;; set the source
(%gl:shader-source shader num-lines string-array (null-pointer))
;; free all allocated strings
(dotimes (i num-lines)
(foreign-string-free (mem-aref string-array :pointer i)))))
string-list)
(import-export %gl:compile-shader
%gl:delete-shader)
;;; 2.15.2 Program Objects
(import-export %gl:create-program
%gl:attach-shader
%gl:detach-shader
%gl:link-program
%gl:use-program
%gl:delete-program)
;;; 2.15.3 Shader Variables
(defun get-active-attrib (program index)
"Returns information about the active attribute variable at index INDEX in
program PROGRAM as multiple values. 1: Size of attribute. 2: Type of attribute.
3: Name of attribute"
(let ((attrib-max-length (get-program program :active-attribute-max-length)))
(with-foreign-objects ((characters-written '%gl:sizei)
(size '%gl:int)
(type '%gl:uint)
(name '%gl:char attrib-max-length))
(%gl:get-active-attrib program index attrib-max-length
characters-written size type name)
(when (< 0 (mem-ref characters-written '%gl:sizei))
(values (mem-ref size '%gl:int)
(or (foreign-enum-keyword '%gl:enum (mem-ref type '%gl:uint)
:errorp nil)
(mem-ref type '%gl:int))
(foreign-string-to-lisp name))))))
;;; TODO: make these use :STRING
(defun get-attrib-location (program name)
(with-foreign-string (s name)
(%gl:get-attrib-location program s)))
(defun bind-attrib-location (program index name)
(with-foreign-string (s name)
(%gl:bind-attrib-location program index s)))
(defun get-uniform-location (program name)
(with-foreign-string (s name)
(%gl:get-uniform-location program s)))
(defun get-active-uniform (program index)
"Returns information about the active uniform attribute at index INDEX in
program PROGRAM as multiple values. 1: Size of attribute. 2: Type of attribute.
3: Name of attribute"
(let ((uniform-max-length (get-program program :active-uniform-max-length)))
(with-foreign-objects ((characters-written '%gl:sizei)
(size '%gl:int)
(type '%gl:uint)
(name '%gl:char uniform-max-length))
(%gl:get-active-uniform program index uniform-max-length
characters-written size type name)
(when (< 0 (mem-ref characters-written '%gl:sizei))
(values (mem-ref size '%gl:int)
(foreign-enum-keyword '%gl:enum (mem-ref type '%gl:uint))
(foreign-string-to-lisp name))))))
(defun uniformi (location x &optional y z w)
(cond
(w (%gl:uniform-4i location x y z w))
(z (%gl:uniform-3i location x y z))
(y (%gl:uniform-2i location x y))
(x (%gl:uniform-1i location x))))
(define-compiler-macro uniformi (&whole form location x &optional y z w)
(declare (ignore form))
(cond
(w `(%gl:uniform-4i ,location ,x ,y ,z ,w))
(z `(%gl:uniform-3i ,location ,x ,y ,z))
(y `(%gl:uniform-2i ,location ,x ,y))
(x `(%gl:uniform-1i ,location ,x))))
(defun uniformf (location x &optional y z w)
(cond
(w (%gl:uniform-4f location (float x) (float y) (float z) (float w)))
(z (%gl:uniform-3f location (float x) (float y) (float z)))
(y (%gl:uniform-2f location (float x) (float y)))
(x (%gl:uniform-1f location (float x)))))
(define-compiler-macro uniformf (&whole form location x &optional y z w)
(declare (ignore form))
(flet ((float* (x)
(if (numberp x)
(float x 1f0)
`(float ,x 1f0))))
(cond
(w `(%gl:uniform-4f ,location ,(float* x) ,(float* y) ,(float* z) ,(float* w)))
(z `(%gl:uniform-3f ,location ,(float* x) ,(float* y) ,(float* z)))
(y `(%gl:uniform-2f ,location ,(float* x) ,(float* y)))
(x `(%gl:uniform-1f ,location ,(float* x))))))
(definline uniformfv (location a)
(case (length a)
(4 (%gl:uniform-4f location (aref a 0) (aref a 1) (aref a 2) (aref a 3)))
(3 (%gl:uniform-3f location (aref a 0) (aref a 1) (aref a 2)))
(2 (%gl:uniform-2f location (aref a 0) (aref a 1)))
(1 (%gl:uniform-1f location (aref a 0)))))
(definline uniformiv (location a)
(case (length a)
(4 (%gl:uniform-4i location (aref a 0) (aref a 1) (aref a 2) (aref a 3)))
(3 (%gl:uniform-3i location (aref a 0) (aref a 1) (aref a 2)))
(2 (%gl:uniform-2i location (aref a 0) (aref a 1)))
(1 (%gl:uniform-1i location (aref a 0)))))
(defun uniform-matrix (location dim matrices &optional (transpose t))
(check-type dim (integer 2 4))
(let ((matrix-count (length matrices))
(matrix-size (* dim dim)))
(with-foreign-object (array '%gl:float (* matrix-count matrix-size))
(dotimes (i matrix-count)
(let ((matrix (aref matrices i)))
(dotimes (j matrix-size)
(setf (mem-aref array '%gl:float (+ j (* i matrix-size)))
(row-major-aref matrix j)))))
(case dim
(2 (%gl:uniform-matrix-2fv
location matrix-count transpose array))
(3 (%gl:uniform-matrix-3fv
location matrix-count transpose array))
(4 (%gl:uniform-matrix-4fv
location matrix-count transpose array))))))
(macrolet ((def (n % comp)
`(defun ,n (location matrices &optional (transpose t))
,(format nil
"Upload a matrix or matrices to uniform LOCATION. MATRICES is a single
matrix in a vector or array, or a vector of matrices in same formats.
Tries to optimize case where matrices are (SIMPLE-ARRAY SINGLE-FLOAT (~s))."
comp)
(assert (or (typep (aref matrices 0) 'number)
(typep (aref matrices 0) 'array)))
#+sbcl
(when (typep matrices '(simple-array single-float (,comp)))
(sb-sys:with-pinned-objects (matrices)
(return-from ,n
(,% location 1 transpose
(sb-sys:vector-sap matrices)))))
#+ccl
(when (typep matrices '(simple-array single-float (,comp)))
;; we need to be a bit more careful with CCL, since
;; CCL:WITH-POINTER-TO-IVECTOR inhibits GC, so we
;; try to avoid signalling an error inside it
(handler-case
(ccl:with-pointer-to-ivector (p matrices)
(return-from ,n
(,% location 1 transpose p)))
;; resignal any errors outside the 'no GC' scope
(error (e) (error e))))
(let* ((matrices (if (typep (aref matrices 0) 'vector)
matrices
(vector matrices)))
(matrix-count (length matrices)))
(with-foreign-object (array '%gl:float (* matrix-count ,comp))
(loop for matrix across matrices
for i from 0
do (when (typep matrix '(simple-array single-float
(,comp)))
(loop for j below ,comp
do (setf (mem-aref array '%gl:float
(+ j (* i ,comp)))
(row-major-aref matrix j)))
(loop for j below ,comp
do (setf (mem-aref array '%gl:float
(+ j (* i ,comp)))
(float (row-major-aref matrix j)
1.0)))))
(,% location matrix-count transpose array)))))
(d (&rest defs)
`(progn
,@(loop for def in defs collect `(def ,@def)))))
(d (uniform-matrix-2fv %gl:uniform-matrix-2fv 4)
(uniform-matrix-2x3-fv %gl:uniform-matrix-2x3-fv 6)
(uniform-matrix-2x4-fv %gl:uniform-matrix-2x4-fv 8)
(uniform-matrix-3x2-fv %gl:uniform-matrix-3x2-fv 6)
(uniform-matrix-3fv %gl:uniform-matrix-3fv 9)
(uniform-matrix-3x4-fv %gl:uniform-matrix-3x4-fv 12)
(uniform-matrix-4x2-fv %gl:uniform-matrix-4x2-fv 8)
(uniform-matrix-4x3-fv %gl:uniform-matrix-4x3-fv 12)
(uniform-matrix-4fv %gl:uniform-matrix-4fv 16)
))
;;; 2.15.4 Shader Execution
(import-export %gl:validate-program)
| 28,055 | Common Lisp | .lisp | 651 | 35.394777 | 85 | 0.62012 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | aa22667aebdcd2c0b6457f08791a78744fe6283a418b99abd086b8355b6f6f85 | 30,575 | [
171977
] |
30,576 | package.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/package.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; Copyright (c) 2004, Oliver Markovic <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions are met:
;;;
;;; o Redistributions of source code must retain the above copyright notice,
;;; this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may be
;;; used to endorse or promote products derived from this software without
;;; specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
;;; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
;;; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
;;; LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
;;; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
;;; SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
;;; CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
;;; ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
;;; POSSIBILITY OF SUCH DAMAGE.
(defpackage #:cl-opengl
(:use #:cl #:cffi)
(:nicknames #:opengl #:gl)
(:import-from #:alexandria
#:once-only
#:symbolicate
#:with-unique-names
#:ensure-list)
(:export
;; 2.5 GL Errors
#:get-error
#:opengl-error
#:opengl-error.error-code
#:check-error
;; 2.6 Begin/End Paradigm
;; 2.6.1 Begin and End
#:begin
#:end
#:with-primitive
#:with-primitives
;; 2.6.2 Polygon Edges
#:edge-flag
;; 2.7 Vertex Specification
#:vertex
#:tex-coord
#:multi-tex-coord
#:normal
#:fog-coord
#:color
#:secondary-color
#:index
#:vertex-attrib
;; 2.8 Vertex Arrays
#:draw-elements
#:alloc-gl-array
#:free-gl-array
#:define-gl-array-format
#:gl-array
#:gl-vertex-array
#:bind-gl-vertex-array
#:with-gl-array
#:glaref
#:map-buffer-to-gl-array
#:with-gl-mapped-buffer
#:with-mapped-buffer
#:make-null-gl-array
#:gl-array-byte-size
;; 2.9 Buffer Objects
#:bind-buffer
#:delete-buffers
#:gen-buffers
#:gen-buffer
#:buffer-data
#:buffer-sub-data
#:map-buffer
#:unmap-buffer
;; 2.10 Rectangles
#:rect
;; 2.10 Vertex Arrays
#:gen-vertex-array
#:gen-vertex-arrays
#:delete-vertex-arrays
#:bind-vertex-array
;; 2.11.1 Controlling the Viewport
#:depth-range
#:viewport
;; 2.11.2 Matrices
#:matrix-mode
#:load-matrix
#:mult-matrix
#:load-transpose-matrix
#:mult-transpose-matrix
#:rotate
#:translate
#:scale
#:frustum
#:ortho
#:active-texture
#:load-identity
#:push-matrix
#:pop-matrix
#:with-pushed-matrix
;; 2.11.4 Generating Texture Coordinates
#:tex-gen
;; 2.12 Clipping
#:clip-plane
;; 2.13 Current Raster Position
#:raster-pos
#:window-pos
;; 2.14.1 Lighting
#:front-face
;; 2.14.2 Lighting Parameter Specification
#:material
#:light
#:light-model
;; 2.14.3 ColorMaterial
#:color-material
;; 2.14.7 Flatshading
#:shade-model
;; 2.15.1 Shader Objects
#:create-shader
#:shader-source
#:compile-shader
#:delete-shader
;; 2.15.2 Program Objects
#:create-program
#:attach-shader
#:detach-shader
#:link-program
#:use-program
#:delete-program
;; 2.15.3 Shader Variables
#:get-active-attrib
#:get-attrib-location
#:bind-attrib-location
#:get-uniform-location
#:get-active-uniform
#:uniformi
#:uniformf
#:uniform-matrix
;; 2.15.4 Shader Execution
#:validate-program
;; 3.3 Points
#:point-size
#:point-parameter
;; 3.4 Line Segments
#:line-width
#:line-stipple
;; 3.5 Polygons
;; 3.5.1 Basic Polygon Rasterization
#:cull-face
;; 3.5.2 Stippling
#:polygon-stipple
;; 3.5.4 Options Controlling Polygon Rasterization
#:polygon-mode
#:polygon-offset
;; 3.6.1 Pixel Storage Modes
#:pixel-store
;; 3.6.3 Pixel Transfer Modes
#:pixel-transfer
#:pixel-map
;; 3.6.4 Pixel Rasterization
#:draw-pixels
;; 3.8.1 Texture Image Specification
#:tex-image-1d
#:tex-image-2d
#:tex-image-3d
;; 3.8.2 Alternate Texture Image Specification Commands
#:copy-tex-image-1d
#:copy-tex-image-2d
#:tex-sub-image-1d
#:tex-sub-image-2d
#:tex-sub-image-3d
#:copy-tex-sub-image-1d
#:copy-tex-sub-image-2d
#:copy-tex-sub-image-3d
;; 3.8.3 Compressed Texture Images
#:compressed-tex-image-1d
#:compressed-tex-image-2d
#:compressed-tex-image-3d
#:compressed-tex-sub-image-1d
#:compressed-tex-sub-image-2d
#:compressed-tex-sub-image-3d
;; 3.8.4 Texture Parameters
#:tex-parameter
;; 3.8.12 Texture Objects
#:bind-texture
#:delete-textures
#:gen-textures
#:gen-texture
#:tex-parameter
#:are-textures-resident
#:prioritize-textures
#:texture-resident-p
#:prioritize-texture
;; 3.8.13 Texture Environments and Texture Functions
#:tex-env
;; 3.10 Fog
#:fog
;; 3.12.2 Shader Execution
#:get-frag-data-location
#:get-frag-data-location-ext
#:bind-frag-data-location
#:bind-frag-data-location-ext
;; 5.4 Display Lists
#:new-list
#:end-list
#:with-new-list
#:call-list
#:call-lists
#:list-base
#:gen-lists
#:display-list-p
#:delete-lists
;; 4.1.2 Scissor Test
#:scissor
;; 4.1.3 Multisample Fragment Operations
#:sample-coverage
;; 4.1.4 Alpha Test
#:alpha-func
;; 4.1.5 Stencil Test
#:stencil-func
#:stencil-func-separate
#:stencil-op
#:stencil-op-separate
;; 4.1.6 Depth Buffer Test
#:depth-func
;; 4.1.7 Occlusion Queries
#:begin-query
#:end-query
#:gen-queries
#:delete-queries
;; 4.1.8 Blending
#:blend-equation
#:blend-equation-separate
#:blend-func
#:blend-func-separate
#:blend-color
;; 4.1.10 Logical Operation
#:logic-op
;; 4.2.1 Selecting a Buffer for Writing
#:draw-buffer
#:draw-buffers
;; 4.2.2 Fine Control of Buffer Updates
#:index-mask
#:color-mask
#:depth-mask
#:stencil-mask
#:stencil-mask-separate
;; 4.2.3 Clearing the Buffers
#:clear
#:clear-color
#:clear-index
#:clear-depth
#:clear-stencil
#:clear-accum
;; 4.2.4 The Accumulation Buffer
#:accum
;; 4.3.2 Reading Pixels
#:read-pixels
#:read-buffer
;; 4.3.3 Copying Pixels
#:copy-pixels
;; 5.1 Evaluation
#:map1
#:map2
#:eval-coord-1
#:eval-coord-2
#:map-grid-1
#:map-grid-2
#:eval-mesh-1
#:eval-mesh-2
#:eval-point-1
#:eval-point-2
;; 5.2 Selection
#:init-names
#:pop-name
#:push-name
#:load-name
#:render-mode
#:select-buffer
;; 5.3 Feedback
#:feedback-buffer
#:pass-through
;; 5.4 Display Lists
#:new-list
#:end-list
#:call-list
#:list-base
#:gen-lists
#:is-list
#:delete-lists
;; 5.5 Flush and Finish
#:flush
#:finish
;; 5.6 Hints
#:hint
;; 6.1.1 Simple Queries
#:get-boolean
#:get-integer
#:get-float
#:get-double
#:get-enum
#:get*
#:enable
#:disable
#:enabledp
;; 6.1.11 Pointer and String Queries
#:get-string
#:gl3-major-version
#:gl3-minor-version
#:gl-version
#:major-version
#:minor-version
#:glsl-version
#:glsl-major-version
#:glsl-minor-version
#:gl3-extension-present-p
#:extension-present-p
;; 6.1.14 Shader and Program Queries
#:is-shader
#:get-shader
#:is-program
#:get-program
#:get-attached-shaders
#:get-shader-info-log
#:get-program-info-log
#:get-shader-source
#:get-active-uniform-block-name
#:get-active-uniform-block
;; 6.1.15 Saving and Restoring State
#:push-attrib
#:push-client-attrib
#:with-pushed-attrib
#:pop-attrib
#:pop-client-attrib
#:with-pushed-client-attrib
;; Sampler
#:delete-samplers
#:gen-samplers
#:gen-sampler
#:sampler-parameter
;; Extensions
#:is-renderbuffer-ext
#:bind-renderbuffer-ext
#:delete-renderbuffers-ext
#:gen-renderbuffers-ext
#:renderbuffer-storage-ext
#:is-framebuffer-ext
#:bind-framebuffer-ext
#:delete-framebuffers-ext
#:gen-framebuffers-ext
#:check-framebuffer-status-ext
#:framebuffer-texture-1d-ext
#:framebuffer-texture-2d-ext
#:framebuffer-texture-3d-ext
#:framebuffer-renderbuffer-ext
#:generate-mipmap-ext
#:with-pushed-matrix*
#:uniformfv
#:get-tex-parameter
#:get-tex-level-parameter
#:gen-framebuffers
#:delete-framebuffers
#:gen-renderbuffers
#:delete-renderbuffers
#:uniform-matrix-2fv
#:uniform-matrix-2x3-fv
#:uniform-matrix-2x4-fv
#:uniform-matrix-3x2-fv
#:uniform-matrix-3fv
#:uniform-matrix-3x4-fv
#:uniform-matrix-4x2-fv
#:uniform-matrix-4x3-fv
#:uniform-matrix-4fv
#:uniformiv
;; ARB_* Extensions
#:get-uniform-block-index
#:gen-framebuffer
#:gen-renderbuffer))
| 9,525 | Common Lisp | .lisp | 388 | 20.64433 | 79 | 0.671264 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 8f93c361e6efc1cf5131e13d44d31a4585c9da41cbb9cab7adc0d461b1fb28d4 | 30,576 | [
272714
] |
30,577 | util.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/util.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; Copyright (c) 2004, Oliver Markovic <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions are met:
;;;
;;; o Redistributions of source code must retain the above copyright notice,
;;; this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may be
;;; used to endorse or promote products derived from this software without
;;; specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
;;; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
;;; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
;;; LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
;;; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
;;; SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
;;; CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
;;; ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
;;; POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-opengl)
;;; the following three where taken from CFFI
(defun symbolic-type->real-type (type)
(ecase type
(:byte '%gl:byte)
(:unsigned-byte '%gl:ubyte)
(:bitmap '%gl:ubyte)
(:short '%gl:short)
(:unsigned-short '%gl:ushort)
(:int '%gl:int)
(:unsigned-int '%gl:uint)
(:float '%gl:float)
(:unsigned-byte-3-3-2 '%gl:ubyte)
(:unsigned-byte-2-3-3-rev '%gl:ubyte)
(:unsigned-short-5-6-5 '%gl:ushort)
(:unsigned-short-5-6-5-rev '%gl:ushort)
(:unsigned-short-4-4-4-4 '%gl:ushort)
(:unsigned-short-4-4-4-4-rev '%gl:ushort)
(:unsigned-short-5-5-5-1 '%gl:ushort)
(:unsigned-short-1-5-5-5-rev '%gl:ushort)
(:unsigned-int-8-8-8-8 '%gl:uint)
(:unsigned-int-8-8-8-8-rev '%gl:uint)
(:unsigned-int-10-10-10-2 '%gl:uint)
(:unsigned-int-5-9-9-9-rev '%gl:uint)
(:unsigned-int-2-10-10-10-rev '%gl:uint)))
;;; Converts a CFFI type to the appropriate GL enum.
(defun cffi-type-to-gl (type)
(ecase type
(:signed-char :byte)
(:unsigned-char :unsigned-byte)
((:short :signed-short) :short)
(:unsigned-short :unsigned-short)
((:int :signed-int) :int)
(:unsigned-int :unsigned-int)
(:float :float)
(:double :double)))
(defmacro with-opengl-array ((var type lisp-array) &body body)
(check-type var symbol)
(let ((count (gensym "COUNT"))
(array (gensym "ARRAY"))
(original-type type))
(once-only (type)
`(let* ((,array ,lisp-array)
(,count (length ,array)))
(with-foreign-object (,var ,type ,count)
;; we need type to be a constant within the loop so cffi can
;; optimize it, so check type outside the loop, and make a
;; copy of the loop for any types we care about
;; (unless we know the type at compile time, in which case only
;; generate code for that type)
,(if (or (keywordp original-type)
(and (consp original-type)
(eq (first original-type) 'quote)))
`(loop for i below ,count
do (setf (mem-aref ,var ,original-type i)
(aref ,array i)))
`(case ,type
,@(loop for ctype in '(%gl:byte %gl:ubyte %gl:short
%gl:ushort %gl:int %gl:uint %gl:float)
collect
`(,ctype
(loop for i below ,count
do (setf (mem-aref ,var ',ctype i) (aref ,array i)))))
(t
(loop for i below ,count
do (setf (mem-aref ,var ,type i) (aref ,array i))))))
,@body)))))
(defmacro with-opengl-arrays (bindings &body body)
(if (null bindings)
`(let nil ,@body)
`(with-opengl-array ,(car bindings)
(with-opengl-arrays ,(cdr bindings)
,@body))))
(defmacro with-pixel-array ((var type lisp-array) &body body)
`(with-opengl-array (,var (symbolic-type->real-type ,type) ,lisp-array)
,@body))
;;; TODO: maybe define opengl-sequence as a CFFI type. possibly something
;;; that would enforce a given length and type.
(defmacro with-opengl-sequence ((var type lisp-sequence) &body body)
(check-type var symbol)
(flet ((converting (form) ; um, assuming type is constant
(case (eval type) ; silly hack.. FIXME
(float `(float ,form))
(double `(float ,form 1.0d0))
(t form))))
(let ((count (gensym "COUNT")))
(once-only (type lisp-sequence)
`(let ((,count (length ,lisp-sequence)))
(with-foreign-object (,var ,type ,count)
(loop for i below ,count
do (setf (mem-aref ,var ,type i)
,(converting `(elt ,lisp-sequence i))))
,@body))))))
;;; The following util was taken from SBCL's
;;; src/code/*-extensions.lisp
(defun symbolicate-package (package &rest things)
"Concatenate together the names of some strings and symbols,
producing a symbol in the current package."
(let* ((length (reduce #'+ things
:key (lambda (x) (length (string x)))))
(name (make-array length :element-type 'character)))
(let ((index 0))
(dolist (thing things (values (intern name package)))
(let* ((x (string thing))
(len (length x)))
(replace name x :start1 index)
(incf index len))))))
;;; Yes, this is somewhat silly since package.lisp interns and exports
;;; the symbols then we unintern, import from %GL and re-export. It,
;;; however, (a) avoids importing the %GL package which shadows some
;;; CL symbols, (b) allows us to keep a full list of exported symbols
;;; in package.lisp, (c) serves as documentation regarding which
;;; functions are being exposed directly and (d) avoids that dreaded
;;; SBCL PACKAGE-AT-VARIANCE warning.
(defmacro import-export (&rest symbols)
`(eval-when (:compile-toplevel :load-toplevel :execute)
;; Unintern first to avoid conflicts.
(dolist (sym ',symbols)
(let ((s (find-symbol (symbol-name sym))))
(when s (unintern s))))
;; Import and re-export.
(import ',symbols)
(export ',symbols)))
(defmacro definline (name args &body body)
`(progn
(declaim (inline ,name))
(defun ,name ,args ,@body)))
;;; A generic generator for all kinds of OpenGL get functions
;;; (define-get-function NAME (ARG1 ARG2 ... ARGn)
;;; (TYPE1 FUNC1)
;;; (TYPE2 FUNC2)
;;; ...)
;;;
;;; defines a function (NAME ARG1 ... ARGn TYPE [COUNT]) which calls
;;; the right FUNCi where TYPEi equals TYPE like (FUNCi ARG1 ... ARGn
;;; P) where P is a pointer to COUNT values of TYPE. when COUNT is
;;; odmitted or 1 a simple value is returned, a list of values
;;; otherwise.
;;;
;;; NOTE: should we drop this function or extend define-query-function
;;; to allow more than one argument? Do we want one function per
;;; return type or the return type as argument (with sane
;;; default? per hashtable lookup? also for count?)
(defmacro define-get-function (name (&rest head-args) &body clauses)
(with-unique-names (return-type return-count p)
`(defun ,name (,@head-args ,return-type &optional (,return-count 1))
(with-foreign-object (,p ,return-type ,return-count)
(ecase ,return-type
,@(loop for (func . types) in clauses
collect `((,@types) (,func ,@head-args ,p))))
(if (= ,return-count 1)
(mem-aref ,p ,return-type 0)
(loop for i from 0 to (1- ,return-count)
collect (mem-aref ,p ,return-type i)))))))
;;; (define-array-pointer NAME BUILTIN-NAME ARG*) defines a very thin
;;; wrapper over BUILTIN-NAME to allow passing a GL-ARRAY,[OFFSET]
;;; last arguments to glFooPointer insteand of a pointer.
(defmacro define-array-pointer (name builtin-name &rest head-args)
(with-unique-names (array offset)
`(definline ,name (,@head-args ,array ,offset)
(,builtin-name ,@head-args (gl-array-pointer-offset ,array ,offset)))))
;;; hack for dealing with duplicate enum values in %gl:enum
;;; todo: &rest ...
(defun enum= (a b)
(= (if (numberp a) a (cffi:foreign-enum-value '%gl:enum a))
(if (numberp b) b (cffi:foreign-enum-value '%gl:enum b))))
(define-compiler-macro enum= (&whole whole a b)
(if (or (constantp a) (constantp b))
`(= ,(if (constantp a)
(if (numberp a) a (cffi:foreign-enum-value '%gl:enum a))
`(if (numberp ,a) ,a (cffi:foreign-enum-value '%gl:enum ,a)))
,(if (constantp b)
(if (numberp b) b (cffi:foreign-enum-value '%gl:enum b))
`(if (numberp ,b) ,b (cffi:foreign-enum-value '%gl:enum ,b))))
whole))
| 9,518 | Common Lisp | .lisp | 203 | 40.083744 | 85 | 0.624973 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 015832f017b768589cbae4f38aff94fff7efe18e05967c9e01a0566feacc5013 | 30,577 | [
298973
] |
30,578 | framebuffer.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/framebuffer.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; Copyright (c) 2004, Oliver Markovic <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions are met:
;;;
;;; o Redistributions of source code must retain the above copyright notice,
;;; this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may be
;;; used to endorse or promote products derived from this software without
;;; specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
;;; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
;;; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
;;; LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
;;; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
;;; SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
;;; CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
;;; ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
;;; POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-opengl)
;;;
;;; Chapter 4 - Per-fragment Operations and the Framebuffer
;;;
;;;
;;; 4.1 Per-fragment Operations
;;;
;;; 4.1.2 Scissor Test
(import-export %gl:scissor)
;;; 4.1.3 Multisample Fragment Operations
(import-export %gl:sample-coverage)
;;; 4.1.4 Alpha Test
(import-export %gl:alpha-func)
;;; 4.1.5 Stencil Test
(import-export %gl:stencil-func
%gl:stencil-func-separate
%gl:stencil-op
%gl:stencil-op-separate)
;;; 4.1.6 Depth Buffer Test
(import-export %gl:depth-func)
;;; 4.1.7 Occlusion Queries
(import-export %gl:begin-query
%gl:end-query)
(defun gen-queries (n)
"Returns N previously unused query object names in a
list. These names are marked as used, but no object is associated
with them until the first time they are used by BEGIN-QUERY."
(with-foreign-object (ids '%gl:uint n)
(%gl:gen-queries n ids)
(loop for i below n
collecting (mem-aref ids '%gl:uint i))))
(defun delete-queries (ids)
"Deletes the names of the query objects contained in the sequence IDS."
(let ((count (length ids)))
(with-foreign-object (id-array '%gl:uint count)
(loop for id in ids
counting id into i
do (setf (mem-aref id-array '%gl:uint (1- i)) id))
(%gl:delete-queries count id-array))))
;;; 4.1.8 Blending
(import-export %gl:blend-equation
%gl:blend-equation-separate
%gl:blend-func
%gl:blend-func-separate
%gl:blend-color)
;;; 4.1.10 Logical Operation
(import-export %gl:logic-op)
;;;
;;; 4.2 Whole Framebuffer Operation
;;;
;;; 4.2.1 Selecting a Buffer for Writing
(import-export %gl:draw-buffer)
(defun draw-buffers (buffers)
(with-opengl-sequence (seq '%gl:enum buffers)
(%gl:draw-buffers (length buffers) seq)))
;;; 4.2.2 Fine Control of Buffer Updates
(import-export %gl:index-mask
%gl:color-mask
%gl:depth-mask
%gl:stencil-mask
%gl:stencil-mask-separate)
;;; 4.2.3 Clearing the Buffers
(definline clear (&rest bufs)
(%gl:clear bufs))
(define-compiler-macro clear (&whole form &rest bufs)
(if (every #'keywordp bufs)
`(%gl:clear ,(foreign-bitfield-value '%gl::ClearBufferMask bufs))
form))
(import-export %gl:clear-color
%gl:clear-index
%gl:clear-depth
%gl:clear-stencil
%gl:clear-accum)
;;; 4.2.4 The Accumulation Buffer
(import-export %gl:accum)
;;;
;;; 4.3 Drawing, Reading and Copying Pixels
;;;
;;; 4.3.2 Reading Pixels
(defun read-pixels (x y width height format type)
(let* ((mult (ecase format
((:red :green :blue :alpha :luminance) 1)
((:depth-component :color-index :stencil-index) 1)
(:luminance-alpha 2)
((:rgb :bgr) 3)
((:rgba :bgra) 4)))
(size (* width height mult))
(result-data (make-sequence 'vector size))
(real-type (symbolic-type->real-type type)))
(with-foreign-object (array real-type size)
(%gl:read-pixels x y width height format type array)
(dotimes (i size result-data)
(setf (svref result-data i)
(mem-aref array real-type i))))))
(import-export %gl:read-buffer)
;;; 4.3.3 Copying Pixels
(import-export %gl:copy-pixels)
| 5,036 | Common Lisp | .lisp | 125 | 35.232 | 79 | 0.675154 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 5b485384b40d01729a7a5cb5066843164a0a1055e7b6123cf5befbd77859530c | 30,578 | [
360178
] |
30,579 | funcs-gl-glcore.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/funcs-gl-glcore.lisp | ;;; this file is automatically generated, do not edit
;;; generated from files with the following copyright:
;;;
;;; Copyright (c) 2013-2015 The Khronos Group Inc.
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining a
;;; copy of this software and/or associated documentation files (the
;;; "Materials"), to deal in the Materials without restriction, including
;;; without limitation the rights to use, copy, modify, merge, publish,
;;; distribute, sublicense, and/or sell copies of the Materials, and to
;;; permit persons to whom the Materials are furnished to do so, subject to
;;; the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be included
;;; in all copies or substantial portions of the Materials.
;;;
;;; THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
;;; IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
;;; CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
;;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
;;; MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
;;;
;;; ------------------------------------------------------------------------
(in-package #:cl-opengl-bindings)
;;; generated 2015-08-30T01:01:50Z
;;; from gl.xml @ svn rev 31811, 2015-08-10T07:01:11.860488Z
(defglextfun ("glFramebufferTexture1D" framebuffer-texture-1d) :void
(target enum)
(attachment enum)
(textarget enum)
(texture uint)
(level int))
(defglextfun ("glFramebufferTexture3D" framebuffer-texture-3d) :void
(target enum)
(attachment enum)
(textarget enum)
(texture uint)
(level int)
(zoffset int))
(defglextfun ("glGetActiveUniformName" get-active-uniform-name) :void
(program uint)
(uniformIndex uint)
(bufSize sizei)
(length (:pointer sizei))
(uniformName (:pointer char)))
(defglextfun ("glMultiDrawElementsBaseVertex" multi-draw-elements-base-vertex) :void
(mode enum)
(count (:pointer sizei))
(type enum)
(indices (:pointer (:pointer :void)))
(drawcount sizei)
(basevertex (:pointer int)))
(defglextfun ("glProvokingVertex" provoking-vertex) :void
(mode enum))
(defglextfun ("glTexImage2DMultisample" tex-image-2d-multisample) :void
(target enum)
(samples sizei)
(internalformat enum)
(width sizei)
(height sizei)
(fixedsamplelocations boolean))
(defglextfun ("glTexImage3DMultisample" tex-image-3d-multisample) :void
(target enum)
(samples sizei)
(internalformat enum)
(width sizei)
(height sizei)
(depth sizei)
(fixedsamplelocations boolean))
(defglextfun ("glBindFragDataLocationIndexed" bind-frag-data-location-indexed) :void
(program uint)
(colorNumber uint)
(index uint)
(name (:pointer char)))
(defglextfun ("glGetFragDataIndex" get-frag-data-index) int
(program uint)
(name (:pointer char)))
(defglextfun ("glQueryCounter" query-counter) :void
(id uint)
(target enum))
(defglextfun ("glGetQueryObjecti64v" get-query-object-i64v) :void
(id uint)
(pname enum)
(params (:pointer int64)))
(defglextfun ("glGetQueryObjectui64v" get-query-object-ui64v) :void
(id uint)
(pname enum)
(params (:pointer uint64)))
(defglextfun ("glVertexAttribP1ui" vertex-attrib-p1ui) :void
(index uint)
(type enum)
(normalized boolean)
(value uint))
(defglextfun ("glVertexAttribP1uiv" vertex-attrib-p1uiv) :void
(index uint)
(type enum)
(normalized boolean)
(value (:pointer uint)))
(defglextfun ("glVertexAttribP2ui" vertex-attrib-p2ui) :void
(index uint)
(type enum)
(normalized boolean)
(value uint))
(defglextfun ("glVertexAttribP2uiv" vertex-attrib-p2uiv) :void
(index uint)
(type enum)
(normalized boolean)
(value (:pointer uint)))
(defglextfun ("glVertexAttribP3ui" vertex-attrib-p3ui) :void
(index uint)
(type enum)
(normalized boolean)
(value uint))
(defglextfun ("glVertexAttribP3uiv" vertex-attrib-p3uiv) :void
(index uint)
(type enum)
(normalized boolean)
(value (:pointer uint)))
(defglextfun ("glVertexAttribP4ui" vertex-attrib-p4ui) :void
(index uint)
(type enum)
(normalized boolean)
(value uint))
(defglextfun ("glVertexAttribP4uiv" vertex-attrib-p4uiv) :void
(index uint)
(type enum)
(normalized boolean)
(value (:pointer uint)))
(defglextfun ("glVertexP2ui" vertex-p2ui) :void
(type enum)
(value uint))
(defglextfun ("glVertexP2uiv" vertex-p2uiv) :void
(type enum)
(value (:pointer uint)))
(defglextfun ("glVertexP3ui" vertex-p3ui) :void
(type enum)
(value uint))
(defglextfun ("glVertexP3uiv" vertex-p3uiv) :void
(type enum)
(value (:pointer uint)))
(defglextfun ("glVertexP4ui" vertex-p4ui) :void
(type enum)
(value uint))
(defglextfun ("glVertexP4uiv" vertex-p4uiv) :void
(type enum)
(value (:pointer uint)))
(defglextfun ("glTexCoordP1ui" tex-coord-p1ui) :void
(type enum)
(coords uint))
(defglextfun ("glTexCoordP1uiv" tex-coord-p1uiv) :void
(type enum)
(coords (:pointer uint)))
(defglextfun ("glTexCoordP2ui" tex-coord-p2ui) :void
(type enum)
(coords uint))
(defglextfun ("glTexCoordP2uiv" tex-coord-p2uiv) :void
(type enum)
(coords (:pointer uint)))
(defglextfun ("glTexCoordP3ui" tex-coord-p3ui) :void
(type enum)
(coords uint))
(defglextfun ("glTexCoordP3uiv" tex-coord-p3uiv) :void
(type enum)
(coords (:pointer uint)))
(defglextfun ("glTexCoordP4ui" tex-coord-p4ui) :void
(type enum)
(coords uint))
(defglextfun ("glTexCoordP4uiv" tex-coord-p4uiv) :void
(type enum)
(coords (:pointer uint)))
(defglextfun ("glMultiTexCoordP1ui" multi-tex-coord-p1ui) :void
(texture enum)
(type enum)
(coords uint))
(defglextfun ("glMultiTexCoordP1uiv" multi-tex-coord-p1uiv) :void
(texture enum)
(type enum)
(coords (:pointer uint)))
(defglextfun ("glMultiTexCoordP2ui" multi-tex-coord-p2ui) :void
(texture enum)
(type enum)
(coords uint))
(defglextfun ("glMultiTexCoordP2uiv" multi-tex-coord-p2uiv) :void
(texture enum)
(type enum)
(coords (:pointer uint)))
(defglextfun ("glMultiTexCoordP3ui" multi-tex-coord-p3ui) :void
(texture enum)
(type enum)
(coords uint))
(defglextfun ("glMultiTexCoordP3uiv" multi-tex-coord-p3uiv) :void
(texture enum)
(type enum)
(coords (:pointer uint)))
(defglextfun ("glMultiTexCoordP4ui" multi-tex-coord-p4ui) :void
(texture enum)
(type enum)
(coords uint))
(defglextfun ("glMultiTexCoordP4uiv" multi-tex-coord-p4uiv) :void
(texture enum)
(type enum)
(coords (:pointer uint)))
(defglextfun ("glNormalP3ui" normal-p3ui) :void
(type enum)
(coords uint))
(defglextfun ("glNormalP3uiv" normal-p3uiv) :void
(type enum)
(coords (:pointer uint)))
(defglextfun ("glColorP3ui" color-p3ui) :void
(type enum)
(color uint))
(defglextfun ("glColorP3uiv" color-p3uiv) :void
(type enum)
(color (:pointer uint)))
(defglextfun ("glColorP4ui" color-p4ui) :void
(type enum)
(color uint))
(defglextfun ("glColorP4uiv" color-p4uiv) :void
(type enum)
(color (:pointer uint)))
(defglextfun ("glSecondaryColorP3ui" secondary-color-p3ui) :void
(type enum)
(color uint))
(defglextfun ("glSecondaryColorP3uiv" secondary-color-p3uiv) :void
(type enum)
(color (:pointer uint)))
(defglextfun ("glUniform1d" uniform-1d) :void
(location int)
(x double))
(defglextfun ("glUniform2d" uniform-2d) :void
(location int)
(x double)
(y double))
(defglextfun ("glUniform3d" uniform-3d) :void
(location int)
(x double)
(y double)
(z double))
(defglextfun ("glUniform4d" uniform-4d) :void
(location int)
(x double)
(y double)
(z double)
(w double))
(defglextfun ("glUniform1dv" uniform-1dv) :void
(location int)
(count sizei)
(value (:pointer double)))
(defglextfun ("glUniform2dv" uniform-2dv) :void
(location int)
(count sizei)
(value (:pointer double)))
(defglextfun ("glUniform3dv" uniform-3dv) :void
(location int)
(count sizei)
(value (:pointer double)))
(defglextfun ("glUniform4dv" uniform-4dv) :void
(location int)
(count sizei)
(value (:pointer double)))
(defglextfun ("glUniformMatrix2dv" uniform-matrix-2dv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glUniformMatrix3dv" uniform-matrix-3dv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glUniformMatrix4dv" uniform-matrix-4dv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glUniformMatrix2x3dv" uniform-matrix-2x3-dv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glUniformMatrix2x4dv" uniform-matrix-2x4-dv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glUniformMatrix3x2dv" uniform-matrix-3x2-dv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glUniformMatrix3x4dv" uniform-matrix-3x4-dv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glUniformMatrix4x2dv" uniform-matrix-4x2-dv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glUniformMatrix4x3dv" uniform-matrix-4x3-dv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glGetUniformdv" get-uniform-dv) :void
(program uint)
(location int)
(params (:pointer double)))
(defglextfun ("glGetSubroutineUniformLocation" get-subroutine-uniform-location) int
(program uint)
(shadertype enum)
(name (:pointer char)))
(defglextfun ("glGetSubroutineIndex" get-subroutine-index) uint
(program uint)
(shadertype enum)
(name (:pointer char)))
(defglextfun ("glGetActiveSubroutineUniformiv" get-active-subroutine-uniform-iv) :void
(program uint)
(shadertype enum)
(index uint)
(pname enum)
(values (:pointer int)))
(defglextfun ("glGetActiveSubroutineUniformName" get-active-subroutine-uniform-name) :void
(program uint)
(shadertype enum)
(index uint)
(bufsize sizei)
(length (:pointer sizei))
(name (:pointer char)))
(defglextfun ("glGetActiveSubroutineName" get-active-subroutine-name) :void
(program uint)
(shadertype enum)
(index uint)
(bufsize sizei)
(length (:pointer sizei))
(name (:pointer char)))
(defglextfun ("glUniformSubroutinesuiv" uniform-subroutines-uiv) :void
(shadertype enum)
(count sizei)
(indices (:pointer uint)))
(defglextfun ("glGetUniformSubroutineuiv" get-uniform-subroutine-uiv) :void
(shadertype enum)
(location int)
(params (:pointer uint)))
(defglextfun ("glGetProgramStageiv" get-program-stage-iv) :void
(program uint)
(shadertype enum)
(pname enum)
(values (:pointer int)))
(defglextfun ("glPatchParameterfv" patch-parameter-fv) :void
(pname enum)
(values (:pointer float)))
(defglextfun ("glDrawTransformFeedback" draw-transform-feedback) :void
(mode enum)
(id uint))
(defglextfun ("glDrawTransformFeedbackStream" draw-transform-feedback-stream) :void
(mode enum)
(id uint)
(stream uint))
(defglextfun ("glBeginQueryIndexed" begin-query-indexed) :void
(target enum)
(index uint)
(id uint))
(defglextfun ("glEndQueryIndexed" end-query-indexed) :void
(target enum)
(index uint))
(defglextfun ("glGetQueryIndexediv" get-query-indexed-iv) :void
(target enum)
(index uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glProgramUniform1d" program-uniform-1d) :void
(program uint)
(location int)
(v0 double))
(defglextfun ("glProgramUniform1dv" program-uniform-1dv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer double)))
(defglextfun ("glProgramUniform2d" program-uniform-2d) :void
(program uint)
(location int)
(v0 double)
(v1 double))
(defglextfun ("glProgramUniform2dv" program-uniform-2dv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer double)))
(defglextfun ("glProgramUniform3d" program-uniform-3d) :void
(program uint)
(location int)
(v0 double)
(v1 double)
(v2 double))
(defglextfun ("glProgramUniform3dv" program-uniform-3dv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer double)))
(defglextfun ("glProgramUniform4d" program-uniform-4d) :void
(program uint)
(location int)
(v0 double)
(v1 double)
(v2 double)
(v3 double))
(defglextfun ("glProgramUniform4dv" program-uniform-4dv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer double)))
(defglextfun ("glProgramUniformMatrix2dv" program-uniform-matrix-2dv) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glProgramUniformMatrix3dv" program-uniform-matrix-3dv) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glProgramUniformMatrix4dv" program-uniform-matrix-4dv) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glProgramUniformMatrix2x3dv" program-uniform-matrix-2x3-dv) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glProgramUniformMatrix3x2dv" program-uniform-matrix-3x2-dv) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glProgramUniformMatrix2x4dv" program-uniform-matrix-2x4-dv) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glProgramUniformMatrix4x2dv" program-uniform-matrix-4x2-dv) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glProgramUniformMatrix3x4dv" program-uniform-matrix-3x4-dv) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glProgramUniformMatrix4x3dv" program-uniform-matrix-4x3-dv) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glVertexAttribL1d" vertex-attrib-l1d) :void
(index uint)
(x double))
(defglextfun ("glVertexAttribL2d" vertex-attrib-l2d) :void
(index uint)
(x double)
(y double))
(defglextfun ("glVertexAttribL3d" vertex-attrib-l3d) :void
(index uint)
(x double)
(y double)
(z double))
(defglextfun ("glVertexAttribL4d" vertex-attrib-l4d) :void
(index uint)
(x double)
(y double)
(z double)
(w double))
(defglextfun ("glVertexAttribL1dv" vertex-attrib-l1dv) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttribL2dv" vertex-attrib-l2dv) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttribL3dv" vertex-attrib-l3dv) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttribL4dv" vertex-attrib-l4dv) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttribLPointer" vertex-attrib-lpointer) :void
(index uint)
(size int)
(type enum)
(stride sizei)
(pointer offset-or-pointer))
(defglextfun ("glGetVertexAttribLdv" get-vertex-attrib-ldv) :void
(index uint)
(pname enum)
(params (:pointer double)))
(defglextfun ("glViewportArrayv" viewport-array-v) :void
(first uint)
(count sizei)
(v (:pointer float)))
(defglextfun ("glViewportIndexedf" viewport-indexed-f) :void
(index uint)
(x float)
(y float)
(w float)
(h float))
(defglextfun ("glViewportIndexedfv" viewport-indexed-fv) :void
(index uint)
(v (:pointer float)))
(defglextfun ("glScissorArrayv" scissor-array-v) :void
(first uint)
(count sizei)
(v (:pointer int)))
(defglextfun ("glScissorIndexed" scissor-indexed) :void
(index uint)
(left int)
(bottom int)
(width sizei)
(height sizei))
(defglextfun ("glScissorIndexedv" scissor-indexed-v) :void
(index uint)
(v (:pointer int)))
(defglextfun ("glDepthRangeArrayv" depth-range-array-v) :void
(first uint)
(count sizei)
(v (:pointer double)))
(defglextfun ("glDepthRangeIndexed" depth-range-indexed) :void
(index uint)
(n double)
(f double))
(defglextfun ("glGetFloati_v" get-float-i-v) :void
(target enum)
(index uint)
(data (:pointer float)))
(defglextfun ("glGetDoublei_v" get-double-i-v) :void
(target enum)
(index uint)
(data (:pointer double)))
(defglextfun ("glDrawArraysInstancedBaseInstance" draw-arrays-instanced-base-instance) :void
(mode enum)
(first int)
(count sizei)
(instancecount sizei)
(baseinstance uint))
(defglextfun ("glDrawElementsInstancedBaseInstance" draw-elements-instanced-base-instance) :void
(mode enum)
(count sizei)
(type enum)
(indices (:pointer :void))
(instancecount sizei)
(baseinstance uint))
(defglextfun ("glDrawElementsInstancedBaseVertexBaseInstance" draw-elements-instanced-base-vertex-base-instance) :void
(mode enum)
(count sizei)
(type enum)
(indices (:pointer :void))
(instancecount sizei)
(basevertex int)
(baseinstance uint))
(defglextfun ("glGetActiveAtomicCounterBufferiv" get-active-atomic-counter-buffer-iv) :void
(program uint)
(bufferIndex uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glTexStorage1D" tex-storage-1d) :void
(target enum)
(levels sizei)
(internalformat enum)
(width sizei))
(defglextfun ("glDrawTransformFeedbackInstanced" draw-transform-feedback-instanced) :void
(mode enum)
(id uint)
(instancecount sizei))
(defglextfun ("glDrawTransformFeedbackStreamInstanced" draw-transform-feedback-stream-instanced) :void
(mode enum)
(id uint)
(stream uint)
(instancecount sizei))
(defglextfun ("glClearBufferData" clear-buffer-data) :void
(target enum)
(internalformat enum)
(format enum)
(type enum)
(data (:pointer :void)))
(defglextfun ("glClearBufferSubData" clear-buffer-sub-data) :void
(target enum)
(internalformat enum)
(offset intptr)
(size sizeiptr)
(format enum)
(type enum)
(data (:pointer :void)))
(defglextfun ("glGetInternalformati64v" get-internalformat-i64v) :void
(target enum)
(internalformat enum)
(pname enum)
(bufSize sizei)
(params (:pointer int64)))
(defglextfun ("glInvalidateTexSubImage" invalidate-tex-sub-image) :void
(texture uint)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei))
(defglextfun ("glInvalidateTexImage" invalidate-tex-image) :void
(texture uint)
(level int))
(defglextfun ("glInvalidateBufferSubData" invalidate-buffer-sub-data) :void
(buffer uint)
(offset intptr)
(length sizeiptr))
(defglextfun ("glInvalidateBufferData" invalidate-buffer-data) :void
(buffer uint))
(defglextfun ("glMultiDrawArraysIndirect" multi-draw-arrays-indirect) :void
(mode enum)
(indirect offset-or-pointer)
(drawcount sizei)
(stride sizei))
(defglextfun ("glMultiDrawElementsIndirect" multi-draw-elements-indirect) :void
(mode enum)
(type enum)
(indirect offset-or-pointer)
(drawcount sizei)
(stride sizei))
(defglextfun ("glGetProgramResourceLocationIndex" get-program-resource-location-index) int
(program uint)
(programInterface enum)
(name (:pointer char)))
(defglextfun ("glShaderStorageBlockBinding" shader-storage-block-binding) :void
(program uint)
(storageBlockIndex uint)
(storageBlockBinding uint))
(defglextfun ("glTextureView" texture-view) :void
(texture uint)
(target enum)
(origtexture uint)
(internalformat enum)
(minlevel uint)
(numlevels uint)
(minlayer uint)
(numlayers uint))
(defglextfun ("glVertexAttribLFormat" vertex-attrib-l-format) :void
(attribindex uint)
(size int)
(type enum)
(relativeoffset uint))
(defglextfun ("glBufferStorage" buffer-storage) :void
(target enum)
(size sizeiptr)
(data (:pointer :void))
(flags bitfield))
(defglextfun ("glClearTexImage" clear-tex-image) :void
(texture uint)
(level int)
(format enum)
(type enum)
(data (:pointer :void)))
(defglextfun ("glClearTexSubImage" clear-tex-sub-image) :void
(texture uint)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei)
(format enum)
(type enum)
(data (:pointer :void)))
(defglextfun ("glBindBuffersBase" bind-buffers-base) :void
(target enum)
(first uint)
(count sizei)
(buffers (:pointer uint)))
(defglextfun ("glBindBuffersRange" bind-buffers-range) :void
(target enum)
(first uint)
(count sizei)
(buffers (:pointer uint))
(offsets (:pointer intptr))
(sizes (:pointer sizeiptr)))
(defglextfun ("glBindTextures" bind-textures) :void
(first uint)
(count sizei)
(textures (:pointer uint)))
(defglextfun ("glBindSamplers" bind-samplers) :void
(first uint)
(count sizei)
(samplers (:pointer uint)))
(defglextfun ("glBindImageTextures" bind-image-textures) :void
(first uint)
(count sizei)
(textures (:pointer uint)))
(defglextfun ("glBindVertexBuffers" bind-vertex-buffers) :void
(first uint)
(count sizei)
(buffers (:pointer uint))
(offsets (:pointer intptr))
(strides (:pointer sizei)))
(defglextfun ("glClipControl" clip-control) :void
(origin enum)
(depth enum))
(defglextfun ("glCreateTransformFeedbacks" create-transform-feedbacks) :void
(n sizei)
(ids (:pointer uint)))
(defglextfun ("glTransformFeedbackBufferBase" transform-feedback-buffer-base) :void
(xfb uint)
(index uint)
(buffer uint))
(defglextfun ("glTransformFeedbackBufferRange" transform-feedback-buffer-range) :void
(xfb uint)
(index uint)
(buffer uint)
(offset intptr)
(size sizeiptr))
(defglextfun ("glGetTransformFeedbackiv" get-transform-feedback-iv) :void
(xfb uint)
(pname enum)
(param (:pointer int)))
(defglextfun ("glGetTransformFeedbacki_v" get-transform-feedback-i-v) :void
(xfb uint)
(pname enum)
(index uint)
(param (:pointer int)))
(defglextfun ("glGetTransformFeedbacki64_v" get-transform-feedback-i64-v) :void
(xfb uint)
(pname enum)
(index uint)
(param (:pointer int64)))
(defglextfun ("glCreateBuffers" create-buffers) :void
(n sizei)
(buffers (:pointer uint)))
(defglextfun ("glNamedBufferStorage" named-buffer-storage) :void
(buffer uint)
(size sizeiptr)
(data (:pointer :void))
(flags bitfield))
(defglextfun ("glNamedBufferData" named-buffer-data) :void
(buffer uint)
(size sizeiptr)
(data (:pointer :void))
(usage enum))
(defglextfun ("glNamedBufferSubData" named-buffer-sub-data) :void
(buffer uint)
(offset intptr)
(size sizeiptr)
(data (:pointer :void)))
(defglextfun ("glCopyNamedBufferSubData" copy-named-buffer-sub-data) :void
(readBuffer uint)
(writeBuffer uint)
(readOffset intptr)
(writeOffset intptr)
(size sizeiptr))
(defglextfun ("glClearNamedBufferData" clear-named-buffer-data) :void
(buffer uint)
(internalformat enum)
(format enum)
(type enum)
(data (:pointer :void)))
(defglextfun ("glClearNamedBufferSubData" clear-named-buffer-sub-data) :void
(buffer uint)
(internalformat enum)
(offset intptr)
(size sizeiptr)
(format enum)
(type enum)
(data (:pointer :void)))
(defglextfun ("glMapNamedBuffer" map-named-buffer) (:pointer :void)
(buffer uint)
(access enum))
(defglextfun ("glMapNamedBufferRange" map-named-buffer-range) (:pointer :void)
(buffer uint)
(offset intptr)
(length sizeiptr)
(access bitfield))
(defglextfun ("glUnmapNamedBuffer" unmap-named-buffer) boolean
(buffer uint))
(defglextfun ("glFlushMappedNamedBufferRange" flush-mapped-named-buffer-range) :void
(buffer uint)
(offset intptr)
(length sizeiptr))
(defglextfun ("glGetNamedBufferParameteriv" get-named-buffer-parameter-iv) :void
(buffer uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetNamedBufferParameteri64v" get-named-buffer-parameter-i64v) :void
(buffer uint)
(pname enum)
(params (:pointer int64)))
(defglextfun ("glGetNamedBufferPointerv" get-named-buffer-pointer-v) :void
(buffer uint)
(pname enum)
(params (:pointer (:pointer :void))))
(defglextfun ("glGetNamedBufferSubData" get-named-buffer-sub-data) :void
(buffer uint)
(offset intptr)
(size sizeiptr)
(data (:pointer :void)))
(defglextfun ("glCreateFramebuffers" create-framebuffers) :void
(n sizei)
(framebuffers (:pointer uint)))
(defglextfun ("glNamedFramebufferRenderbuffer" named-framebuffer-renderbuffer) :void
(framebuffer uint)
(attachment enum)
(renderbuffertarget enum)
(renderbuffer uint))
(defglextfun ("glNamedFramebufferParameteri" named-framebuffer-parameter-i) :void
(framebuffer uint)
(pname enum)
(param int))
(defglextfun ("glNamedFramebufferTexture" named-framebuffer-texture) :void
(framebuffer uint)
(attachment enum)
(texture uint)
(level int))
(defglextfun ("glNamedFramebufferTextureLayer" named-framebuffer-texture-layer) :void
(framebuffer uint)
(attachment enum)
(texture uint)
(level int)
(layer int))
(defglextfun ("glNamedFramebufferDrawBuffer" named-framebuffer-draw-buffer) :void
(framebuffer uint)
(buf enum))
(defglextfun ("glNamedFramebufferDrawBuffers" named-framebuffer-draw-buffers) :void
(framebuffer uint)
(n sizei)
(bufs (:pointer enum)))
(defglextfun ("glNamedFramebufferReadBuffer" named-framebuffer-read-buffer) :void
(framebuffer uint)
(src enum))
(defglextfun ("glInvalidateNamedFramebufferData" invalidate-named-framebuffer-data) :void
(framebuffer uint)
(numAttachments sizei)
(attachments (:pointer enum)))
(defglextfun ("glInvalidateNamedFramebufferSubData" invalidate-named-framebuffer-sub-data) :void
(framebuffer uint)
(numAttachments sizei)
(attachments (:pointer enum))
(x int)
(y int)
(width sizei)
(height sizei))
(defglextfun ("glClearNamedFramebufferiv" clear-named-framebuffer-iv) :void
(framebuffer uint)
(buffer enum)
(drawbuffer int)
(value (:pointer int)))
(defglextfun ("glClearNamedFramebufferuiv" clear-named-framebuffer-uiv) :void
(framebuffer uint)
(buffer enum)
(drawbuffer int)
(value (:pointer uint)))
(defglextfun ("glClearNamedFramebufferfv" clear-named-framebuffer-fv) :void
(framebuffer uint)
(buffer enum)
(drawbuffer int)
(value (:pointer float)))
(defglextfun ("glClearNamedFramebufferfi" clear-named-framebuffer-fi) :void
(framebuffer uint)
(buffer enum)
(depth float)
(stencil int))
(defglextfun ("glBlitNamedFramebuffer" blit-named-framebuffer) :void
(readFramebuffer uint)
(drawFramebuffer uint)
(srcX0 int)
(srcY0 int)
(srcX1 int)
(srcY1 int)
(dstX0 int)
(dstY0 int)
(dstX1 int)
(dstY1 int)
(mask bitfield)
(filter enum))
(defglextfun ("glCheckNamedFramebufferStatus" check-named-framebuffer-status) enum
(framebuffer uint)
(target enum))
(defglextfun ("glGetNamedFramebufferParameteriv" get-named-framebuffer-parameter-iv) :void
(framebuffer uint)
(pname enum)
(param (:pointer int)))
(defglextfun ("glGetNamedFramebufferAttachmentParameteriv" get-named-framebuffer-attachment-parameter-iv) :void
(framebuffer uint)
(attachment enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glCreateRenderbuffers" create-renderbuffers) :void
(n sizei)
(renderbuffers (:pointer uint)))
(defglextfun ("glNamedRenderbufferStorage" named-renderbuffer-storage) :void
(renderbuffer uint)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glNamedRenderbufferStorageMultisample" named-renderbuffer-storage-multisample) :void
(renderbuffer uint)
(samples sizei)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glGetNamedRenderbufferParameteriv" get-named-renderbuffer-parameter-iv) :void
(renderbuffer uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glCreateTextures" create-textures) :void
(target enum)
(n sizei)
(textures (:pointer uint)))
(defglextfun ("glTextureBuffer" texture-buffer) :void
(texture uint)
(internalformat enum)
(buffer uint))
(defglextfun ("glTextureBufferRange" texture-buffer-range) :void
(texture uint)
(internalformat enum)
(buffer uint)
(offset intptr)
(size sizeiptr))
(defglextfun ("glTextureStorage1D" texture-storage-1d) :void
(texture uint)
(levels sizei)
(internalformat enum)
(width sizei))
(defglextfun ("glTextureStorage2D" texture-storage-2d) :void
(texture uint)
(levels sizei)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glTextureStorage3D" texture-storage-3d) :void
(texture uint)
(levels sizei)
(internalformat enum)
(width sizei)
(height sizei)
(depth sizei))
(defglextfun ("glTextureStorage2DMultisample" texture-storage-2d-multisample) :void
(texture uint)
(samples sizei)
(internalformat enum)
(width sizei)
(height sizei)
(fixedsamplelocations boolean))
(defglextfun ("glTextureStorage3DMultisample" texture-storage-3d-multisample) :void
(texture uint)
(samples sizei)
(internalformat enum)
(width sizei)
(height sizei)
(depth sizei)
(fixedsamplelocations boolean))
(defglextfun ("glTextureSubImage1D" texture-sub-image-1d) :void
(texture uint)
(level int)
(xoffset int)
(width sizei)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glTextureSubImage2D" texture-sub-image-2d) :void
(texture uint)
(level int)
(xoffset int)
(yoffset int)
(width sizei)
(height sizei)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glTextureSubImage3D" texture-sub-image-3d) :void
(texture uint)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glCompressedTextureSubImage1D" compressed-texture-sub-image-1d) :void
(texture uint)
(level int)
(xoffset int)
(width sizei)
(format enum)
(imageSize sizei)
(data (:pointer :void)))
(defglextfun ("glCompressedTextureSubImage2D" compressed-texture-sub-image-2d) :void
(texture uint)
(level int)
(xoffset int)
(yoffset int)
(width sizei)
(height sizei)
(format enum)
(imageSize sizei)
(data (:pointer :void)))
(defglextfun ("glCompressedTextureSubImage3D" compressed-texture-sub-image-3d) :void
(texture uint)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei)
(format enum)
(imageSize sizei)
(data (:pointer :void)))
(defglextfun ("glCopyTextureSubImage1D" copy-texture-sub-image-1d) :void
(texture uint)
(level int)
(xoffset int)
(x int)
(y int)
(width sizei))
(defglextfun ("glCopyTextureSubImage2D" copy-texture-sub-image-2d) :void
(texture uint)
(level int)
(xoffset int)
(yoffset int)
(x int)
(y int)
(width sizei)
(height sizei))
(defglextfun ("glCopyTextureSubImage3D" copy-texture-sub-image-3d) :void
(texture uint)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(x int)
(y int)
(width sizei)
(height sizei))
(defglextfun ("glTextureParameterf" texture-parameter-f) :void
(texture uint)
(pname enum)
(param float))
(defglextfun ("glTextureParameterfv" texture-parameter-fv) :void
(texture uint)
(pname enum)
(param (:pointer float)))
(defglextfun ("glTextureParameteri" texture-parameter-i) :void
(texture uint)
(pname enum)
(param int))
(defglextfun ("glTextureParameterIiv" texture-parameter-iiv) :void
(texture uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glTextureParameterIuiv" texture-parameter-iuiv) :void
(texture uint)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glTextureParameteriv" texture-parameter-iv) :void
(texture uint)
(pname enum)
(param (:pointer int)))
(defglextfun ("glGenerateTextureMipmap" generate-texture-mipmap) :void
(texture uint))
(defglextfun ("glBindTextureUnit" bind-texture-unit) :void
(unit uint)
(texture uint))
(defglextfun ("glGetTextureImage" get-texture-image) :void
(texture uint)
(level int)
(format enum)
(type enum)
(bufSize sizei)
(pixels (:pointer :void)))
(defglextfun ("glGetCompressedTextureImage" get-compressed-texture-image) :void
(texture uint)
(level int)
(bufSize sizei)
(pixels (:pointer :void)))
(defglextfun ("glGetTextureLevelParameterfv" get-texture-level-parameter-fv) :void
(texture uint)
(level int)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetTextureLevelParameteriv" get-texture-level-parameter-iv) :void
(texture uint)
(level int)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetTextureParameterfv" get-texture-parameter-fv) :void
(texture uint)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetTextureParameterIiv" get-texture-parameter-iiv) :void
(texture uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetTextureParameterIuiv" get-texture-parameter-iuiv) :void
(texture uint)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glGetTextureParameteriv" get-texture-parameter-iv) :void
(texture uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glCreateVertexArrays" create-vertex-arrays) :void
(n sizei)
(arrays (:pointer uint)))
(defglextfun ("glDisableVertexArrayAttrib" disable-vertex-array-attrib) :void
(vaobj uint)
(index uint))
(defglextfun ("glEnableVertexArrayAttrib" enable-vertex-array-attrib) :void
(vaobj uint)
(index uint))
(defglextfun ("glVertexArrayElementBuffer" vertex-array-element-buffer) :void
(vaobj uint)
(buffer uint))
(defglextfun ("glVertexArrayVertexBuffer" vertex-array-vertex-buffer) :void
(vaobj uint)
(bindingindex uint)
(buffer uint)
(offset intptr)
(stride sizei))
(defglextfun ("glVertexArrayVertexBuffers" vertex-array-vertex-buffers) :void
(vaobj uint)
(first uint)
(count sizei)
(buffers (:pointer uint))
(offsets (:pointer intptr))
(strides (:pointer sizei)))
(defglextfun ("glVertexArrayAttribBinding" vertex-array-attrib-binding) :void
(vaobj uint)
(attribindex uint)
(bindingindex uint))
(defglextfun ("glVertexArrayAttribFormat" vertex-array-attrib-format) :void
(vaobj uint)
(attribindex uint)
(size int)
(type enum)
(normalized boolean)
(relativeoffset uint))
(defglextfun ("glVertexArrayAttribIFormat" vertex-array-attrib-i-format) :void
(vaobj uint)
(attribindex uint)
(size int)
(type enum)
(relativeoffset uint))
(defglextfun ("glVertexArrayAttribLFormat" vertex-array-attrib-l-format) :void
(vaobj uint)
(attribindex uint)
(size int)
(type enum)
(relativeoffset uint))
(defglextfun ("glVertexArrayBindingDivisor" vertex-array-binding-divisor) :void
(vaobj uint)
(bindingindex uint)
(divisor uint))
(defglextfun ("glGetVertexArrayiv" get-vertex-array-iv) :void
(vaobj uint)
(pname enum)
(param (:pointer int)))
(defglextfun ("glGetVertexArrayIndexediv" get-vertex-array-indexed-iv) :void
(vaobj uint)
(index uint)
(pname enum)
(param (:pointer int)))
(defglextfun ("glGetVertexArrayIndexed64iv" get-vertex-array-indexed-64iv) :void
(vaobj uint)
(index uint)
(pname enum)
(param (:pointer int64)))
(defglextfun ("glCreateSamplers" create-samplers) :void
(n sizei)
(samplers (:pointer uint)))
(defglextfun ("glCreateProgramPipelines" create-program-pipelines) :void
(n sizei)
(pipelines (:pointer uint)))
(defglextfun ("glCreateQueries" create-queries) :void
(target enum)
(n sizei)
(ids (:pointer uint)))
(defglextfun ("glGetQueryBufferObjecti64v" get-query-buffer-object-i64v) :void
(id uint)
(buffer uint)
(pname enum)
(offset intptr))
(defglextfun ("glGetQueryBufferObjectiv" get-query-buffer-object-iv) :void
(id uint)
(buffer uint)
(pname enum)
(offset intptr))
(defglextfun ("glGetQueryBufferObjectui64v" get-query-buffer-object-ui64v) :void
(id uint)
(buffer uint)
(pname enum)
(offset intptr))
(defglextfun ("glGetQueryBufferObjectuiv" get-query-buffer-object-uiv) :void
(id uint)
(buffer uint)
(pname enum)
(offset intptr))
(defglextfun ("glGetTextureSubImage" get-texture-sub-image) :void
(texture uint)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei)
(format enum)
(type enum)
(bufSize sizei)
(pixels (:pointer :void)))
(defglextfun ("glGetCompressedTextureSubImage" get-compressed-texture-sub-image) :void
(texture uint)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei)
(bufSize sizei)
(pixels (:pointer :void)))
(defglextfun ("glTextureBarrier" texture-barrier) :void)
(defglextfun ("glGetTextureHandleARB" get-texture-handle-arb) uint64
(texture uint))
(defglextfun ("glGetTextureSamplerHandleARB" get-texture-sampler-handle-arb) uint64
(texture uint)
(sampler uint))
(defglextfun ("glMakeTextureHandleResidentARB" make-texture-handle-resident-arb) :void
(handle uint64))
(defglextfun ("glMakeTextureHandleNonResidentARB" make-texture-handle-non-resident-arb) :void
(handle uint64))
(defglextfun ("glGetImageHandleARB" get-image-handle-arb) uint64
(texture uint)
(level int)
(layered boolean)
(layer int)
(format enum))
(defglextfun ("glMakeImageHandleResidentARB" make-image-handle-resident-arb) :void
(handle uint64)
(access enum))
(defglextfun ("glMakeImageHandleNonResidentARB" make-image-handle-non-resident-arb) :void
(handle uint64))
(defglextfun ("glUniformHandleui64ARB" uniform-handle-ui64-arb) :void
(location int)
(value uint64))
(defglextfun ("glUniformHandleui64vARB" uniform-handle-ui64v-arb) :void
(location int)
(count sizei)
(value (:pointer uint64)))
(defglextfun ("glProgramUniformHandleui64ARB" program-uniform-handle-ui64-arb) :void
(program uint)
(location int)
(value uint64))
(defglextfun ("glProgramUniformHandleui64vARB" program-uniform-handle-ui64v-arb) :void
(program uint)
(location int)
(count sizei)
(values (:pointer uint64)))
(defglextfun ("glIsTextureHandleResidentARB" is-texture-handle-resident-arb) boolean
(handle uint64))
(defglextfun ("glIsImageHandleResidentARB" is-image-handle-resident-arb) boolean
(handle uint64))
(defglextfun ("glVertexAttribL1ui64ARB" vertex-attrib-l1ui64-arb) :void
(index uint)
(x uint64-ext))
(defglextfun ("glVertexAttribL1ui64vARB" vertex-attrib-l1ui64v-arb) :void
(index uint)
(v (:pointer uint64-ext)))
(defglextfun ("glGetVertexAttribLui64vARB" get-vertex-attrib-lui64v-arb) :void
(index uint)
(pname enum)
(params (:pointer uint64-ext)))
(defglextfun ("glCreateSyncFromCLeventARB" create-sync-from-cl-event-arb) sync
(context (:pointer _cl_context))
(event (:pointer _cl_event))
(flags bitfield))
(defglextfun ("glDispatchComputeGroupSizeARB" dispatch-compute-group-size-arb) :void
(num_groups_x uint)
(num_groups_y uint)
(num_groups_z uint)
(group_size_x uint)
(group_size_y uint)
(group_size_z uint))
(defglextfun ("glDebugMessageControlARB" debug-message-control-arb) :void
(source enum)
(type enum)
(severity enum)
(count sizei)
(ids (:pointer uint))
(enabled boolean))
(defglextfun ("glDebugMessageInsertARB" debug-message-insert-arb) :void
(source enum)
(type enum)
(id uint)
(severity enum)
(length sizei)
(buf (:pointer char)))
(defglextfun ("glDebugMessageCallbackARB" debug-message-callback-arb) :void
(callback debugproc-arb)
(userParam (:pointer :void)))
(defglextfun ("glGetDebugMessageLogARB" get-debug-message-log-arb) uint
(count uint)
(bufSize sizei)
(sources (:pointer enum))
(types (:pointer enum))
(ids (:pointer uint))
(severities (:pointer enum))
(lengths (:pointer sizei))
(messageLog (:pointer char)))
(defglextfun ("glBlendEquationiARB" blend-equation-i-arb) :void
(buf uint)
(mode enum))
(defglextfun ("glBlendEquationSeparateiARB" blend-equation-separate-i-arb) :void
(buf uint)
(modeRGB enum)
(modeAlpha enum))
(defglextfun ("glBlendFunciARB" blend-func-i-arb) :void
(buf uint)
(src enum)
(dst enum))
(defglextfun ("glBlendFuncSeparateiARB" blend-func-separate-i-arb) :void
(buf uint)
(srcRGB enum)
(dstRGB enum)
(srcAlpha enum)
(dstAlpha enum))
(defglextfun ("glColorTable" color-table) :void
(target enum)
(internalformat enum)
(width sizei)
(format enum)
(type enum)
(table offset-or-pointer))
(defglextfun ("glColorTableParameterfv" color-table-parameter-fv) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glColorTableParameteriv" color-table-parameter-iv) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glCopyColorTable" copy-color-table) :void
(target enum)
(internalformat enum)
(x int)
(y int)
(width sizei))
(defglextfun ("glGetColorTable" get-color-table) :void
(target enum)
(format enum)
(type enum)
(table offset-or-pointer))
(defglextfun ("glGetColorTableParameterfv" get-color-table-parameter-fv) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetColorTableParameteriv" get-color-table-parameter-iv) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glColorSubTable" color-sub-table) :void
(target enum)
(start sizei)
(count sizei)
(format enum)
(type enum)
(data offset-or-pointer))
(defglextfun ("glCopyColorSubTable" copy-color-sub-table) :void
(target enum)
(start sizei)
(x int)
(y int)
(width sizei))
(defglextfun ("glConvolutionFilter1D" convolution-filter-1d) :void
(target enum)
(internalformat enum)
(width sizei)
(format enum)
(type enum)
(image offset-or-pointer))
(defglextfun ("glConvolutionFilter2D" convolution-filter-2d) :void
(target enum)
(internalformat enum)
(width sizei)
(height sizei)
(format enum)
(type enum)
(image offset-or-pointer))
(defglextfun ("glConvolutionParameterf" convolution-parameter-f) :void
(target enum)
(pname enum)
(params float))
(defglextfun ("glConvolutionParameterfv" convolution-parameter-fv) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glConvolutionParameteri" convolution-parameter-i) :void
(target enum)
(pname enum)
(params int))
(defglextfun ("glConvolutionParameteriv" convolution-parameter-iv) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glCopyConvolutionFilter1D" copy-convolution-filter-1d) :void
(target enum)
(internalformat enum)
(x int)
(y int)
(width sizei))
(defglextfun ("glCopyConvolutionFilter2D" copy-convolution-filter-2d) :void
(target enum)
(internalformat enum)
(x int)
(y int)
(width sizei)
(height sizei))
(defglextfun ("glGetConvolutionFilter" get-convolution-filter) :void
(target enum)
(format enum)
(type enum)
(image offset-or-pointer))
(defglextfun ("glGetConvolutionParameterfv" get-convolution-parameter-fv) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetConvolutionParameteriv" get-convolution-parameter-iv) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetSeparableFilter" get-separable-filter) :void
(target enum)
(format enum)
(type enum)
(row offset-or-pointer)
(column offset-or-pointer)
(span offset-or-pointer))
(defglextfun ("glSeparableFilter2D" separable-filter-2d) :void
(target enum)
(internalformat enum)
(width sizei)
(height sizei)
(format enum)
(type enum)
(row offset-or-pointer)
(column offset-or-pointer))
(defglextfun ("glGetHistogram" get-histogram) :void
(target enum)
(reset boolean)
(format enum)
(type enum)
(values offset-or-pointer))
(defglextfun ("glGetHistogramParameterfv" get-histogram-parameter-fv) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetHistogramParameteriv" get-histogram-parameter-iv) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetMinmax" get-minmax) :void
(target enum)
(reset boolean)
(format enum)
(type enum)
(values offset-or-pointer))
(defglextfun ("glGetMinmaxParameterfv" get-minmax-parameter-fv) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetMinmaxParameteriv" get-minmax-parameter-iv) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glHistogram" histogram) :void
(target enum)
(width sizei)
(internalformat enum)
(sink boolean))
(defglextfun ("glMinmax" minmax) :void
(target enum)
(internalformat enum)
(sink boolean))
(defglextfun ("glResetHistogram" reset-histogram) :void
(target enum))
(defglextfun ("glResetMinmax" reset-minmax) :void
(target enum))
(defglextfun ("glMultiDrawArraysIndirectCountARB" multi-draw-arrays-indirect-count-arb) :void
(mode enum)
(indirect intptr)
(drawcount intptr)
(maxdrawcount sizei)
(stride sizei))
(defglextfun ("glMultiDrawElementsIndirectCountARB" multi-draw-elements-indirect-count-arb) :void
(mode enum)
(type enum)
(indirect intptr)
(drawcount intptr)
(maxdrawcount sizei)
(stride sizei))
(defglextfun ("glGetGraphicsResetStatusARB" get-graphics-reset-status-arb) enum)
(defglextfun ("glGetnTexImageARB" getn-tex-image-arb) :void
(target enum)
(level int)
(format enum)
(type enum)
(bufSize sizei)
(img (:pointer :void)))
(defglextfun ("glReadnPixelsARB" readn-pixels-arb) :void
(x int)
(y int)
(width sizei)
(height sizei)
(format enum)
(type enum)
(bufSize sizei)
(data (:pointer :void)))
(defglextfun ("glGetnCompressedTexImageARB" getn-compressed-tex-image-arb) :void
(target enum)
(lod int)
(bufSize sizei)
(img (:pointer :void)))
(defglextfun ("glGetnUniformfvARB" getn-uniform-fv-arb) :void
(program uint)
(location int)
(bufSize sizei)
(params (:pointer float)))
(defglextfun ("glGetnUniformivARB" getn-uniform-iv-arb) :void
(program uint)
(location int)
(bufSize sizei)
(params (:pointer int)))
(defglextfun ("glGetnUniformuivARB" getn-uniform-uiv-arb) :void
(program uint)
(location int)
(bufSize sizei)
(params (:pointer uint)))
(defglextfun ("glGetnUniformdvARB" getn-uniform-dv-arb) :void
(program uint)
(location int)
(bufSize sizei)
(params (:pointer double)))
(defglextfun ("glGetnMapdvARB" getn-map-dv-arb) :void
(target enum)
(query enum)
(bufSize sizei)
(v (:pointer double)))
(defglextfun ("glGetnMapfvARB" getn-map-fv-arb) :void
(target enum)
(query enum)
(bufSize sizei)
(v (:pointer float)))
(defglextfun ("glGetnMapivARB" getn-map-iv-arb) :void
(target enum)
(query enum)
(bufSize sizei)
(v (:pointer int)))
(defglextfun ("glGetnPixelMapfvARB" getn-pixel-map-fv-arb) :void
(map enum)
(bufSize sizei)
(values (:pointer float)))
(defglextfun ("glGetnPixelMapuivARB" getn-pixel-map-uiv-arb) :void
(map enum)
(bufSize sizei)
(values (:pointer uint)))
(defglextfun ("glGetnPixelMapusvARB" getn-pixel-map-usv-arb) :void
(map enum)
(bufSize sizei)
(values (:pointer ushort)))
(defglextfun ("glGetnPolygonStippleARB" getn-polygon-stipple-arb) :void
(bufSize sizei)
(pattern (:pointer ubyte)))
(defglextfun ("glGetnColorTableARB" getn-color-table-arb) :void
(target enum)
(format enum)
(type enum)
(bufSize sizei)
(table (:pointer :void)))
(defglextfun ("glGetnConvolutionFilterARB" getn-convolution-filter-arb) :void
(target enum)
(format enum)
(type enum)
(bufSize sizei)
(image (:pointer :void)))
(defglextfun ("glGetnSeparableFilterARB" getn-separable-filter-arb) :void
(target enum)
(format enum)
(type enum)
(rowBufSize sizei)
(row (:pointer :void))
(columnBufSize sizei)
(column (:pointer :void))
(span (:pointer :void)))
(defglextfun ("glGetnHistogramARB" getn-histogram-arb) :void
(target enum)
(reset boolean)
(format enum)
(type enum)
(bufSize sizei)
(values (:pointer :void)))
(defglextfun ("glGetnMinmaxARB" getn-minmax-arb) :void
(target enum)
(reset boolean)
(format enum)
(type enum)
(bufSize sizei)
(values (:pointer :void)))
(defglextfun ("glMinSampleShadingARB" min-sample-shading-arb) :void
(value float))
(defglextfun ("glNamedStringARB" named-string-arb) :void
(type enum)
(namelen int)
(name (:pointer char))
(stringlen int)
(string (:pointer char)))
(defglextfun ("glDeleteNamedStringARB" delete-named-string-arb) :void
(namelen int)
(name (:pointer char)))
(defglextfun ("glCompileShaderIncludeARB" compile-shader-include-arb) :void
(shader uint)
(count sizei)
(path (:pointer (:pointer char)))
(length (:pointer int)))
(defglextfun ("glIsNamedStringARB" is-named-string-arb) boolean
(namelen int)
(name (:pointer char)))
(defglextfun ("glGetNamedStringARB" get-named-string-arb) :void
(namelen int)
(name (:pointer char))
(bufSize sizei)
(stringlen (:pointer int))
(string (:pointer char)))
(defglextfun ("glGetNamedStringivARB" get-named-string-iv-arb) :void
(namelen int)
(name (:pointer char))
(pname enum)
(params (:pointer int)))
(defglextfun ("glBufferPageCommitmentARB" buffer-page-commitment-arb) :void
(target enum)
(offset intptr)
(size sizeiptr)
(commit boolean))
(defglextfun ("glNamedBufferPageCommitmentEXT" named-buffer-page-commitment-ext) :void
(buffer uint)
(offset intptr)
(size sizeiptr)
(commit boolean))
(defglextfun ("glNamedBufferPageCommitmentARB" named-buffer-page-commitment-arb) :void
(buffer uint)
(offset intptr)
(size sizeiptr)
(commit boolean))
| 49,619 | Common Lisp | .lisp | 1,674 | 26.875149 | 118 | 0.743861 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 8ebe10161afe7e60c03d6ee880eb657477cd3fa980923cb2ca948e14f3185aa8 | 30,579 | [
162025
] |
30,580 | types.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/types.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; Copyright (c) 2004, Oliver Markovic <[email protected]>
;;; Copyright (c) 2007, Luis Oliveira <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions are met:
;;;
;;; o Redistributions of source code must retain the above copyright notice,
;;; this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may be
;;; used to endorse or promote products derived from this software without
;;; specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
;;; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
;;; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
;;; LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
;;; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
;;; SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
;;; CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
;;; ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
;;; POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-opengl-bindings)
;;;; GL types.
;;; Note: the symbols BOOLEAN, BYTE, FLOAT, CHAR and STRING have been
;;; shadowed from the CL package.
(define-foreign-type ensure-integer ()
()
(:actual-type :int)
(:simple-parser ensure-integer))
(defmethod translate-to-foreign (value (type ensure-integer))
(truncate value))
(defmethod expand-to-foreign (value (type ensure-integer))
(if (constantp value)
(truncate (eval value))
`(truncate ,value)))
(define-foreign-type ensure-float ()
()
(:actual-type :float)
(:simple-parser ensure-float))
(defmethod translate-to-foreign (value (type ensure-float))
(cl:float value 1.0f0))
(defmethod expand-to-foreign (value (type ensure-float))
(if (constantp value)
(cl:float (eval value) 1.0f0)
`(cl:float ,value 1.0f0)))
(define-foreign-type ensure-double ()
()
(:actual-type :double)
(:simple-parser ensure-double))
(defmethod translate-to-foreign (value (type ensure-double))
(cl:float value 1.0d0))
(defmethod expand-to-foreign (value (type ensure-double))
(if (constantp value)
(cl:float (eval value) 1.0d0)
`(cl:float ,value 1.0d0)))
(define-foreign-type offset-or-pointer ()
()
(:actual-type ptrdiff-t)
(:simple-parser offset-or-pointer))
(defmethod translate-to-foreign (value (type offset-or-pointer))
(if (pointerp value)
(pointer-address value)
value))
(defmethod expand-to-foreign (value (type offset-or-pointer))
(cond
((and (constantp value) (pointerp value))
(pointer-address value))
((and (constantp value) (typep value '(integer 0)))
value)
(t
(alexandria:once-only (value)
`(if (pointerp ,value)
(pointer-address ,value)
,value)))))
;;;; Deftypes
(defctype boolean (:boolean :unsigned-char))
(defctype bitfield :unsigned-int)
(defctype char :char)
(defctype char-arb :char)
(defctype handle-arb :unsigned-int)
(defctype byte :char)
(defctype short :short)
(defctype int ensure-integer)
(defctype sizei ensure-integer)
(defctype ubyte :unsigned-char)
(defctype ushort :unsigned-short)
(defctype uint :unsigned-int)
(defctype half :unsigned-short)
(defctype half-arb :unsigned-short)
(defctype half-nv :unsigned-short)
(defctype int64 :int64)
(defctype uint64 :uint64)
(defctype void :void)
(defctype string :string)
;;; XXX these will be broken on 64-bit systems that do not have 64-bit
;;; longs, such as Win64. Need to define this type in CFFI and it may
;;; require some sort of grovelling or guessing.
(defctype ptrdiff-t :unsigned-long)
(defctype intptr ptrdiff-t)
(defctype intptr-arb ptrdiff-t)
(defctype sizeiptr ptrdiff-t)
(defctype sizeiptr-arb ptrdiff-t)
(defctype float ensure-float)
(defctype clampf ensure-float)
(defctype double ensure-double)
(defctype clampd ensure-double)
(defctype clampx :int)
(defctype egl-image-oes (:pointer :void))
(defctype fixed int)
(defctype int64-ext :int64)
(defctype uint64-ext :uint64)
(defctype sync (:pointer)) ;; struct __GLsync *
(defctype vdpau-surface-nv intptr)
;; fixme: should these be here? better name if so?
(defcstruct _cl_context) ; "struct _cl_context"
(defcstruct _cl_event) ; "struct _cl_event"
| 4,921 | Common Lisp | .lisp | 124 | 37.322581 | 79 | 0.738375 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | c8a0ac26dbeb952e2333f89eafb198971fb5d312fa8b7378d519e6825cd75645 | 30,580 | [
-1
] |
30,581 | funcs-gl-gles2.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/funcs-gl-gles2.lisp | ;;; this file is automatically generated, do not edit
;;; generated from files with the following copyright:
;;;
;;; Copyright (c) 2013-2015 The Khronos Group Inc.
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining a
;;; copy of this software and/or associated documentation files (the
;;; "Materials"), to deal in the Materials without restriction, including
;;; without limitation the rights to use, copy, modify, merge, publish,
;;; distribute, sublicense, and/or sell copies of the Materials, and to
;;; permit persons to whom the Materials are furnished to do so, subject to
;;; the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be included
;;; in all copies or substantial portions of the Materials.
;;;
;;; THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
;;; IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
;;; CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
;;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
;;; MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
;;;
;;; ------------------------------------------------------------------------
(in-package #:cl-opengl-bindings)
;;; generated 2015-08-30T01:01:50Z
;;; from gl.xml @ svn rev 31811, 2015-08-10T07:01:11.860488Z
(defglfun ("glReadBuffer" read-buffer) :void
(src enum))
(defglfun ("glGetTexLevelParameterfv" get-tex-level-parameter-fv) :void
(target enum)
(level int)
(pname enum)
(params (:pointer float)))
(defglfun ("glGetTexLevelParameteriv" get-tex-level-parameter-iv) :void
(target enum)
(level int)
(pname enum)
(params (:pointer int)))
(defglextfun ("glDrawRangeElements" draw-range-elements) :void
(mode enum)
(start uint)
(end uint)
(count sizei)
(type enum)
(indices offset-or-pointer))
(defglextfun ("glTexImage3D" tex-image-3d) :void
(target enum)
(level int)
(internalformat int)
(width sizei)
(height sizei)
(depth sizei)
(border int)
(format enum)
(type enum)
(pixels offset-or-pointer))
(defglextfun ("glTexSubImage3D" tex-sub-image-3d) :void
(target enum)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei)
(format enum)
(type enum)
(pixels offset-or-pointer))
(defglextfun ("glCopyTexSubImage3D" copy-tex-sub-image-3d) :void
(target enum)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(x int)
(y int)
(width sizei)
(height sizei))
(defglextfun ("glCompressedTexImage3D" compressed-tex-image-3d) :void
(target enum)
(level int)
(internalformat enum)
(width sizei)
(height sizei)
(depth sizei)
(border int)
(imageSize sizei)
(data offset-or-pointer))
(defglextfun ("glCompressedTexSubImage3D" compressed-tex-sub-image-3d) :void
(target enum)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei)
(format enum)
(imageSize sizei)
(data offset-or-pointer))
(defglextfun ("glBlendFuncSeparate" blend-func-separate) :void
(sfactorRGB enum)
(dfactorRGB enum)
(sfactorAlpha enum)
(dfactorAlpha enum))
(defglextfun ("glGenQueries" gen-queries) :void
(n sizei)
(ids (:pointer uint)))
(defglextfun ("glDeleteQueries" delete-queries) :void
(n sizei)
(ids (:pointer uint)))
(defglextfun ("glIsQuery" is-query) boolean
(id uint))
(defglextfun ("glBeginQuery" begin-query) :void
(target enum)
(id uint))
(defglextfun ("glEndQuery" end-query) :void
(target enum))
(defglextfun ("glGetQueryiv" get-query-iv) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetQueryObjectuiv" get-query-object-uiv) :void
(id uint)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glUnmapBuffer" unmap-buffer) boolean
(target enum))
(defglextfun ("glGetBufferPointerv" get-buffer-pointer-v) :void
(target enum)
(pname enum)
(params (:pointer (:pointer :void))))
(defglextfun ("glBlendEquationSeparate" blend-equation-separate) :void
(modeRGB enum)
(modeAlpha enum))
(defglextfun ("glDrawBuffers" draw-buffers) :void
(n sizei)
(bufs (:pointer enum)))
(defglextfun ("glStencilOpSeparate" stencil-op-separate) :void
(face enum)
(sfail enum)
(dpfail enum)
(dppass enum))
(defglextfun ("glStencilFuncSeparate" stencil-func-separate) :void
(face enum)
(func enum)
(ref int)
(mask uint))
(defglextfun ("glStencilMaskSeparate" stencil-mask-separate) :void
(face enum)
(mask uint))
(defglextfun ("glAttachShader" attach-shader) :void
(program uint)
(shader uint))
(defglextfun ("glBindAttribLocation" bind-attrib-location) :void
(program uint)
(index uint)
(name (:pointer char)))
(defglextfun ("glCompileShader" compile-shader) :void
(shader uint))
(defglextfun ("glCreateProgram" create-program) uint)
(defglextfun ("glCreateShader" create-shader) uint
(type enum))
(defglextfun ("glDeleteProgram" delete-program) :void
(program uint))
(defglextfun ("glDeleteShader" delete-shader) :void
(shader uint))
(defglextfun ("glDetachShader" detach-shader) :void
(program uint)
(shader uint))
(defglextfun ("glDisableVertexAttribArray" disable-vertex-attrib-array) :void
(index uint))
(defglextfun ("glEnableVertexAttribArray" enable-vertex-attrib-array) :void
(index uint))
(defglextfun ("glGetActiveAttrib" get-active-attrib) :void
(program uint)
(index uint)
(bufSize sizei)
(length (:pointer sizei))
(size (:pointer int))
(type (:pointer enum))
(name (:pointer char)))
(defglextfun ("glGetActiveUniform" get-active-uniform) :void
(program uint)
(index uint)
(bufSize sizei)
(length (:pointer sizei))
(size (:pointer int))
(type (:pointer enum))
(name (:pointer char)))
(defglextfun ("glGetAttachedShaders" get-attached-shaders) :void
(program uint)
(maxCount sizei)
(count (:pointer sizei))
(shaders (:pointer uint)))
(defglextfun ("glGetAttribLocation" get-attrib-location) int
(program uint)
(name (:pointer char)))
(defglextfun ("glGetProgramiv" get-program-iv) :void
(program uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetProgramInfoLog" get-program-info-log) :void
(program uint)
(bufSize sizei)
(length (:pointer sizei))
(infoLog (:pointer char)))
(defglextfun ("glGetShaderiv" get-shader-iv) :void
(shader uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetShaderInfoLog" get-shader-info-log) :void
(shader uint)
(bufSize sizei)
(length (:pointer sizei))
(infoLog (:pointer char)))
(defglextfun ("glGetShaderSource" get-shader-source) :void
(shader uint)
(bufSize sizei)
(length (:pointer sizei))
(source (:pointer char)))
(defglextfun ("glGetUniformLocation" get-uniform-location) int
(program uint)
(name (:pointer char)))
(defglextfun ("glGetUniformfv" get-uniform-fv) :void
(program uint)
(location int)
(params (:pointer float)))
(defglextfun ("glGetUniformiv" get-uniform-iv) :void
(program uint)
(location int)
(params (:pointer int)))
(defglextfun ("glGetVertexAttribfv" get-vertex-attrib-fv) :void
(index uint)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetVertexAttribiv" get-vertex-attrib-iv) :void
(index uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetVertexAttribPointerv" get-vertex-attrib-pointer-v) :void
(index uint)
(pname enum)
(pointer (:pointer (:pointer :void))))
(defglextfun ("glIsProgram" is-program) boolean
(program uint))
(defglextfun ("glIsShader" is-shader) boolean
(shader uint))
(defglextfun ("glLinkProgram" link-program) :void
(program uint))
(defglextfun ("glShaderSource" shader-source) :void
(shader uint)
(count sizei)
(string (:pointer (:pointer char)))
(length (:pointer int)))
(defglextfun ("glUseProgram" use-program) :void
(program uint))
(defglextfun ("glUniform1f" uniform-1f) :void
(location int)
(v0 float))
(defglextfun ("glUniform2f" uniform-2f) :void
(location int)
(v0 float)
(v1 float))
(defglextfun ("glUniform3f" uniform-3f) :void
(location int)
(v0 float)
(v1 float)
(v2 float))
(defglextfun ("glUniform4f" uniform-4f) :void
(location int)
(v0 float)
(v1 float)
(v2 float)
(v3 float))
(defglextfun ("glUniform1i" uniform-1i) :void
(location int)
(v0 int))
(defglextfun ("glUniform2i" uniform-2i) :void
(location int)
(v0 int)
(v1 int))
(defglextfun ("glUniform3i" uniform-3i) :void
(location int)
(v0 int)
(v1 int)
(v2 int))
(defglextfun ("glUniform4i" uniform-4i) :void
(location int)
(v0 int)
(v1 int)
(v2 int)
(v3 int))
(defglextfun ("glUniform1fv" uniform-1fv) :void
(location int)
(count sizei)
(value (:pointer float)))
(defglextfun ("glUniform2fv" uniform-2fv) :void
(location int)
(count sizei)
(value (:pointer float)))
(defglextfun ("glUniform3fv" uniform-3fv) :void
(location int)
(count sizei)
(value (:pointer float)))
(defglextfun ("glUniform4fv" uniform-4fv) :void
(location int)
(count sizei)
(value (:pointer float)))
(defglextfun ("glUniform1iv" uniform-1iv) :void
(location int)
(count sizei)
(value (:pointer int)))
(defglextfun ("glUniform2iv" uniform-2iv) :void
(location int)
(count sizei)
(value (:pointer int)))
(defglextfun ("glUniform3iv" uniform-3iv) :void
(location int)
(count sizei)
(value (:pointer int)))
(defglextfun ("glUniform4iv" uniform-4iv) :void
(location int)
(count sizei)
(value (:pointer int)))
(defglextfun ("glUniformMatrix2fv" uniform-matrix-2fv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glUniformMatrix3fv" uniform-matrix-3fv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glUniformMatrix4fv" uniform-matrix-4fv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glValidateProgram" validate-program) :void
(program uint))
(defglextfun ("glVertexAttrib1f" vertex-attrib-1f) :void
(index uint)
(x float))
(defglextfun ("glVertexAttrib1fv" vertex-attrib-1fv) :void
(index uint)
(v (:pointer float)))
(defglextfun ("glVertexAttrib2f" vertex-attrib-2f) :void
(index uint)
(x float)
(y float))
(defglextfun ("glVertexAttrib2fv" vertex-attrib-2fv) :void
(index uint)
(v (:pointer float)))
(defglextfun ("glVertexAttrib3f" vertex-attrib-3f) :void
(index uint)
(x float)
(y float)
(z float))
(defglextfun ("glVertexAttrib3fv" vertex-attrib-3fv) :void
(index uint)
(v (:pointer float)))
(defglextfun ("glVertexAttrib4f" vertex-attrib-4f) :void
(index uint)
(x float)
(y float)
(z float)
(w float))
(defglextfun ("glVertexAttrib4fv" vertex-attrib-4fv) :void
(index uint)
(v (:pointer float)))
(defglextfun ("glVertexAttribPointer" vertex-attrib-pointer) :void
(index uint)
(size int)
(type enum)
(normalized boolean)
(stride sizei)
(pointer offset-or-pointer))
(defglextfun ("glUniformMatrix2x3fv" uniform-matrix-2x3-fv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glUniformMatrix3x2fv" uniform-matrix-3x2-fv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glUniformMatrix2x4fv" uniform-matrix-2x4-fv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glUniformMatrix4x2fv" uniform-matrix-4x2-fv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glUniformMatrix3x4fv" uniform-matrix-3x4-fv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glUniformMatrix4x3fv" uniform-matrix-4x3-fv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glColorMaski" color-mask-i) :void
(index uint)
(r boolean)
(g boolean)
(b boolean)
(a boolean))
(defglextfun ("glGetBooleani_v" get-boolean-i-v) :void
(target enum)
(index uint)
(data (:pointer boolean)))
(defglextfun ("glEnablei" enable-i) :void
(target enum)
(index uint))
(defglextfun ("glDisablei" disable-i) :void
(target enum)
(index uint))
(defglextfun ("glIsEnabledi" is-enabled-i) boolean
(target enum)
(index uint))
(defglextfun ("glBeginTransformFeedback" begin-transform-feedback) :void
(primitiveMode enum))
(defglextfun ("glEndTransformFeedback" end-transform-feedback) :void)
(defglextfun ("glTransformFeedbackVaryings" transform-feedback-varyings) :void
(program uint)
(count sizei)
(varyings (:pointer (:pointer char)))
(bufferMode enum))
(defglextfun ("glGetTransformFeedbackVarying" get-transform-feedback-varying) :void
(program uint)
(index uint)
(bufSize sizei)
(length (:pointer sizei))
(size (:pointer sizei))
(type (:pointer enum))
(name (:pointer char)))
(defglextfun ("glVertexAttribIPointer" vertex-attrib-ipointer) :void
(index uint)
(size int)
(type enum)
(stride sizei)
(pointer offset-or-pointer))
(defglextfun ("glGetVertexAttribIiv" get-vertex-attrib-iiv) :void
(index uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetVertexAttribIuiv" get-vertex-attrib-iuiv) :void
(index uint)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glVertexAttribI4i" vertex-attrib-i4i) :void
(index uint)
(x int)
(y int)
(z int)
(w int))
(defglextfun ("glVertexAttribI4ui" vertex-attrib-i4ui) :void
(index uint)
(x uint)
(y uint)
(z uint)
(w uint))
(defglextfun ("glVertexAttribI4iv" vertex-attrib-i4iv) :void
(index uint)
(v (:pointer int)))
(defglextfun ("glVertexAttribI4uiv" vertex-attrib-i4uiv) :void
(index uint)
(v (:pointer uint)))
(defglextfun ("glGetUniformuiv" get-uniform-uiv) :void
(program uint)
(location int)
(params (:pointer uint)))
(defglextfun ("glGetFragDataLocation" get-frag-data-location) int
(program uint)
(name (:pointer char)))
(defglextfun ("glUniform1ui" uniform-1ui) :void
(location int)
(v0 uint))
(defglextfun ("glUniform2ui" uniform-2ui) :void
(location int)
(v0 uint)
(v1 uint))
(defglextfun ("glUniform3ui" uniform-3ui) :void
(location int)
(v0 uint)
(v1 uint)
(v2 uint))
(defglextfun ("glUniform4ui" uniform-4ui) :void
(location int)
(v0 uint)
(v1 uint)
(v2 uint)
(v3 uint))
(defglextfun ("glUniform1uiv" uniform-1uiv) :void
(location int)
(count sizei)
(value (:pointer uint)))
(defglextfun ("glUniform2uiv" uniform-2uiv) :void
(location int)
(count sizei)
(value (:pointer uint)))
(defglextfun ("glUniform3uiv" uniform-3uiv) :void
(location int)
(count sizei)
(value (:pointer uint)))
(defglextfun ("glUniform4uiv" uniform-4uiv) :void
(location int)
(count sizei)
(value (:pointer uint)))
(defglextfun ("glTexParameterIiv" tex-parameter-iiv) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glTexParameterIuiv" tex-parameter-iuiv) :void
(target enum)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glGetTexParameterIiv" get-tex-parameter-iiv) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetTexParameterIuiv" get-tex-parameter-iuiv) :void
(target enum)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glClearBufferiv" clear-buffer-iv) :void
(buffer enum)
(drawbuffer int)
(value (:pointer int)))
(defglextfun ("glClearBufferuiv" clear-buffer-uiv) :void
(buffer enum)
(drawbuffer int)
(value (:pointer uint)))
(defglextfun ("glClearBufferfv" clear-buffer-fv) :void
(buffer enum)
(drawbuffer int)
(value (:pointer float)))
(defglextfun ("glClearBufferfi" clear-buffer-fi) :void
(buffer enum)
(drawbuffer int)
(depth float)
(stencil int))
(defglextfun ("glGetStringi" get-string-i) string
(name enum)
(index uint))
(defglextfun ("glDrawArraysInstanced" draw-arrays-instanced) :void
(mode enum)
(first int)
(count sizei)
(instancecount sizei))
(defglextfun ("glDrawElementsInstanced" draw-elements-instanced) :void
(mode enum)
(count sizei)
(type enum)
(indices offset-or-pointer)
(instancecount sizei))
(defglextfun ("glTexBuffer" tex-buffer) :void
(target enum)
(internalformat enum)
(buffer uint))
(defglextfun ("glGetInteger64i_v" get-integer-64-i-v) :void
(target enum)
(index uint)
(data (:pointer int64)))
(defglextfun ("glGetBufferParameteri64v" get-buffer-parameter-i64v) :void
(target enum)
(pname enum)
(params (:pointer int64)))
(defglextfun ("glFramebufferTexture" framebuffer-texture) :void
(target enum)
(attachment enum)
(texture uint)
(level int))
(defglextfun ("glVertexAttribDivisor" vertex-attrib-divisor) :void
(index uint)
(divisor uint))
(defglextfun ("glMinSampleShading" min-sample-shading) :void
(value float))
(defglextfun ("glBlendEquationi" blend-equation-i) :void
(buf uint)
(mode enum))
(defglextfun ("glBlendEquationSeparatei" blend-equation-separate-i) :void
(buf uint)
(modeRGB enum)
(modeAlpha enum))
(defglextfun ("glBlendFunci" blend-func-i) :void
(buf uint)
(src enum)
(dst enum))
(defglextfun ("glBlendFuncSeparatei" blend-func-separate-i) :void
(buf uint)
(srcRGB enum)
(dstRGB enum)
(srcAlpha enum)
(dstAlpha enum))
(defglextfun ("glGetPerfMonitorGroupsAMD" get-perf-monitor-groups-amd) :void
(numGroups (:pointer int))
(groupsSize sizei)
(groups (:pointer uint)))
(defglextfun ("glGetPerfMonitorCountersAMD" get-perf-monitor-counters-amd) :void
(group uint)
(numCounters (:pointer int))
(maxActiveCounters (:pointer int))
(counterSize sizei)
(counters (:pointer uint)))
(defglextfun ("glGetPerfMonitorGroupStringAMD" get-perf-monitor-group-string-amd) :void
(group uint)
(bufSize sizei)
(length (:pointer sizei))
(groupString (:pointer char)))
(defglextfun ("glGetPerfMonitorCounterStringAMD" get-perf-monitor-counter-string-amd) :void
(group uint)
(counter uint)
(bufSize sizei)
(length (:pointer sizei))
(counterString (:pointer char)))
(defglextfun ("glGetPerfMonitorCounterInfoAMD" get-perf-monitor-counter-info-amd) :void
(group uint)
(counter uint)
(pname enum)
(data (:pointer :void)))
(defglextfun ("glGenPerfMonitorsAMD" gen-perf-monitors-amd) :void
(n sizei)
(monitors (:pointer uint)))
(defglextfun ("glDeletePerfMonitorsAMD" delete-perf-monitors-amd) :void
(n sizei)
(monitors (:pointer uint)))
(defglextfun ("glSelectPerfMonitorCountersAMD" select-perf-monitor-counters-amd) :void
(monitor uint)
(enable boolean)
(group uint)
(numCounters int)
(counterList (:pointer uint)))
(defglextfun ("glBeginPerfMonitorAMD" begin-perf-monitor-amd) :void
(monitor uint))
(defglextfun ("glEndPerfMonitorAMD" end-perf-monitor-amd) :void
(monitor uint))
(defglextfun ("glGetPerfMonitorCounterDataAMD" get-perf-monitor-counter-data-amd) :void
(monitor uint)
(pname enum)
(dataSize sizei)
(data (:pointer uint))
(bytesWritten (:pointer int)))
(defglextfun ("glLabelObjectEXT" label-object-ext) :void
(type enum)
(object uint)
(length sizei)
(label (:pointer char)))
(defglextfun ("glGetObjectLabelEXT" get-object-label-ext) :void
(type enum)
(object uint)
(bufSize sizei)
(length (:pointer sizei))
(label (:pointer char)))
(defglextfun ("glInsertEventMarkerEXT" insert-event-marker-ext) :void
(length sizei)
(marker (:pointer char)))
(defglextfun ("glPushGroupMarkerEXT" push-group-marker-ext) :void
(length sizei)
(marker (:pointer char)))
(defglextfun ("glPopGroupMarkerEXT" pop-group-marker-ext) :void)
(defglextfun ("glProgramUniform1fEXT" program-uniform-1f-ext) :void
(program uint)
(location int)
(v0 float))
(defglextfun ("glProgramUniform2fEXT" program-uniform-2f-ext) :void
(program uint)
(location int)
(v0 float)
(v1 float))
(defglextfun ("glProgramUniform3fEXT" program-uniform-3f-ext) :void
(program uint)
(location int)
(v0 float)
(v1 float)
(v2 float))
(defglextfun ("glProgramUniform4fEXT" program-uniform-4f-ext) :void
(program uint)
(location int)
(v0 float)
(v1 float)
(v2 float)
(v3 float))
(defglextfun ("glProgramUniform1iEXT" program-uniform-1i-ext) :void
(program uint)
(location int)
(v0 int))
(defglextfun ("glProgramUniform2iEXT" program-uniform-2i-ext) :void
(program uint)
(location int)
(v0 int)
(v1 int))
(defglextfun ("glProgramUniform3iEXT" program-uniform-3i-ext) :void
(program uint)
(location int)
(v0 int)
(v1 int)
(v2 int))
(defglextfun ("glProgramUniform4iEXT" program-uniform-4i-ext) :void
(program uint)
(location int)
(v0 int)
(v1 int)
(v2 int)
(v3 int))
(defglextfun ("glProgramUniform1fvEXT" program-uniform-1fv-ext) :void
(program uint)
(location int)
(count sizei)
(value (:pointer float)))
(defglextfun ("glProgramUniform2fvEXT" program-uniform-2fv-ext) :void
(program uint)
(location int)
(count sizei)
(value (:pointer float)))
(defglextfun ("glProgramUniform3fvEXT" program-uniform-3fv-ext) :void
(program uint)
(location int)
(count sizei)
(value (:pointer float)))
(defglextfun ("glProgramUniform4fvEXT" program-uniform-4fv-ext) :void
(program uint)
(location int)
(count sizei)
(value (:pointer float)))
(defglextfun ("glProgramUniform1ivEXT" program-uniform-1iv-ext) :void
(program uint)
(location int)
(count sizei)
(value (:pointer int)))
(defglextfun ("glProgramUniform2ivEXT" program-uniform-2iv-ext) :void
(program uint)
(location int)
(count sizei)
(value (:pointer int)))
(defglextfun ("glProgramUniform3ivEXT" program-uniform-3iv-ext) :void
(program uint)
(location int)
(count sizei)
(value (:pointer int)))
(defglextfun ("glProgramUniform4ivEXT" program-uniform-4iv-ext) :void
(program uint)
(location int)
(count sizei)
(value (:pointer int)))
(defglextfun ("glProgramUniformMatrix2fvEXT" program-uniform-matrix-2fv-ext) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glProgramUniformMatrix3fvEXT" program-uniform-matrix-3fv-ext) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glProgramUniformMatrix4fvEXT" program-uniform-matrix-4fv-ext) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glProgramUniformMatrix2x3fvEXT" program-uniform-matrix-2x3-fv-ext) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glProgramUniformMatrix3x2fvEXT" program-uniform-matrix-3x2-fv-ext) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glProgramUniformMatrix2x4fvEXT" program-uniform-matrix-2x4-fv-ext) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glProgramUniformMatrix4x2fvEXT" program-uniform-matrix-4x2-fv-ext) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glProgramUniformMatrix3x4fvEXT" program-uniform-matrix-3x4-fv-ext) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glProgramUniformMatrix4x3fvEXT" program-uniform-matrix-4x3-fv-ext) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glProgramUniform1uiEXT" program-uniform-1ui-ext) :void
(program uint)
(location int)
(v0 uint))
(defglextfun ("glProgramUniform2uiEXT" program-uniform-2ui-ext) :void
(program uint)
(location int)
(v0 uint)
(v1 uint))
(defglextfun ("glProgramUniform3uiEXT" program-uniform-3ui-ext) :void
(program uint)
(location int)
(v0 uint)
(v1 uint)
(v2 uint))
(defglextfun ("glProgramUniform4uiEXT" program-uniform-4ui-ext) :void
(program uint)
(location int)
(v0 uint)
(v1 uint)
(v2 uint)
(v3 uint))
(defglextfun ("glProgramUniform1uivEXT" program-uniform-1uiv-ext) :void
(program uint)
(location int)
(count sizei)
(value (:pointer uint)))
(defglextfun ("glProgramUniform2uivEXT" program-uniform-2uiv-ext) :void
(program uint)
(location int)
(count sizei)
(value (:pointer uint)))
(defglextfun ("glProgramUniform3uivEXT" program-uniform-3uiv-ext) :void
(program uint)
(location int)
(count sizei)
(value (:pointer uint)))
(defglextfun ("glProgramUniform4uivEXT" program-uniform-4uiv-ext) :void
(program uint)
(location int)
(count sizei)
(value (:pointer uint)))
(defglextfun ("glGetQueryObjecti64vEXT" get-query-object-i64v-ext) :void
(id uint)
(pname enum)
(params (:pointer int64)))
(defglextfun ("glGetQueryObjectui64vEXT" get-query-object-ui64v-ext) :void
(id uint)
(pname enum)
(params (:pointer uint64)))
(defglextfun ("glDrawArraysInstancedEXT" draw-arrays-instanced-ext) :void
(mode enum)
(start int)
(count sizei)
(primcount sizei))
(defglextfun ("glDrawElementsInstancedEXT" draw-elements-instanced-ext) :void
(mode enum)
(count sizei)
(type enum)
(indices (:pointer :void))
(primcount sizei))
(defglextfun ("glFramebufferTextureEXT" framebuffer-texture-ext) :void
(target enum)
(attachment enum)
(texture uint)
(level int))
(defglextfun ("glProgramParameteriEXT" program-parameter-i-ext) :void
(program uint)
(pname enum)
(value int))
(defglextfun ("glRasterSamplesEXT" raster-samples-ext) :void
(samples uint)
(fixedsamplelocations boolean))
(defglextfun ("glUseShaderProgramEXT" use-shader-program-ext) :void
(type enum)
(program uint))
(defglextfun ("glActiveProgramEXT" active-program-ext) :void
(program uint))
(defglextfun ("glCreateShaderProgramEXT" create-shader-program-ext) uint
(type enum)
(string (:pointer char)))
(defglextfun ("glActiveShaderProgramEXT" active-shader-program-ext) :void
(pipeline uint)
(program uint))
(defglextfun ("glBindProgramPipelineEXT" bind-program-pipeline-ext) :void
(pipeline uint))
(defglextfun ("glCreateShaderProgramvEXT" create-shader-programv-ext) uint
(type enum)
(count sizei)
(strings (:pointer (:pointer char))))
(defglextfun ("glDeleteProgramPipelinesEXT" delete-program-pipelines-ext) :void
(n sizei)
(pipelines (:pointer uint)))
(defglextfun ("glGenProgramPipelinesEXT" gen-program-pipelines-ext) :void
(n sizei)
(pipelines (:pointer uint)))
(defglextfun ("glGetProgramPipelineInfoLogEXT" get-program-pipeline-info-log-ext) :void
(pipeline uint)
(bufSize sizei)
(length (:pointer sizei))
(infoLog (:pointer char)))
(defglextfun ("glGetProgramPipelineivEXT" get-program-pipeline-iv-ext) :void
(pipeline uint)
(pname GetProgramPipelineExtPname)
(params int))
(defglextfun ("glIsProgramPipelineEXT" is-program-pipeline-ext) boolean
(pipeline uint))
(defglextfun ("glUseProgramStagesEXT" use-program-stages-ext) :void
(pipeline uint)
(stages bitfield)
(program uint))
(defglextfun ("glValidateProgramPipelineEXT" validate-program-pipeline-ext) :void
(pipeline uint))
(defglextfun ("glTexParameterIivEXT" tex-parameter-iiv-ext) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glTexParameterIuivEXT" tex-parameter-iuiv-ext) :void
(target enum)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glGetTexParameterIivEXT" get-tex-parameter-iiv-ext) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetTexParameterIuivEXT" get-tex-parameter-iuiv-ext) :void
(target enum)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glTexBufferEXT" tex-buffer-ext) :void
(target enum)
(internalformat enum)
(buffer uint))
(defglextfun ("glApplyFramebufferAttachmentCMAAINTEL" apply-framebuffer-attachment-cmaa-intel) :void)
(defglextfun ("glBeginPerfQueryINTEL" begin-perf-query-intel) :void
(queryHandle uint))
(defglextfun ("glCreatePerfQueryINTEL" create-perf-query-intel) :void
(queryId uint)
(queryHandle (:pointer uint)))
(defglextfun ("glDeletePerfQueryINTEL" delete-perf-query-intel) :void
(queryHandle uint))
(defglextfun ("glEndPerfQueryINTEL" end-perf-query-intel) :void
(queryHandle uint))
(defglextfun ("glGetFirstPerfQueryIdINTEL" get-first-perf-query-id-intel) :void
(queryId (:pointer uint)))
(defglextfun ("glGetNextPerfQueryIdINTEL" get-next-perf-query-id-intel) :void
(queryId uint)
(nextQueryId (:pointer uint)))
(defglextfun ("glGetPerfCounterInfoINTEL" get-perf-counter-info-intel) :void
(queryId uint)
(counterId uint)
(counterNameLength uint)
(counterName (:pointer char))
(counterDescLength uint)
(counterDesc (:pointer char))
(counterOffset (:pointer uint))
(counterDataSize (:pointer uint))
(counterTypeEnum (:pointer uint))
(counterDataTypeEnum (:pointer uint))
(rawCounterMaxValue (:pointer uint64)))
(defglextfun ("glGetPerfQueryDataINTEL" get-perf-query-data-intel) :void
(queryHandle uint)
(flags uint)
(dataSize sizei)
(data (:pointer void))
(bytesWritten (:pointer uint)))
(defglextfun ("glGetPerfQueryIdByNameINTEL" get-perf-query-id-by-name-intel) :void
(queryName (:pointer char))
(queryId (:pointer uint)))
(defglextfun ("glGetPerfQueryInfoINTEL" get-perf-query-info-intel) :void
(queryId uint)
(queryNameLength uint)
(queryName (:pointer char))
(dataSize (:pointer uint))
(noCounters (:pointer uint))
(noInstances (:pointer uint))
(capsMask (:pointer uint)))
(defglextfun ("glBlendBarrierKHR" blend-barrier-khr) :void)
(defglextfun ("glGetTextureHandleNV" get-texture-handle-nv) uint64
(texture uint))
(defglextfun ("glGetTextureSamplerHandleNV" get-texture-sampler-handle-nv) uint64
(texture uint)
(sampler uint))
(defglextfun ("glMakeTextureHandleResidentNV" make-texture-handle-resident-nv) :void
(handle uint64))
(defglextfun ("glMakeTextureHandleNonResidentNV" make-texture-handle-non-resident-nv) :void
(handle uint64))
(defglextfun ("glGetImageHandleNV" get-image-handle-nv) uint64
(texture uint)
(level int)
(layered boolean)
(layer int)
(format enum))
(defglextfun ("glMakeImageHandleResidentNV" make-image-handle-resident-nv) :void
(handle uint64)
(access enum))
(defglextfun ("glMakeImageHandleNonResidentNV" make-image-handle-non-resident-nv) :void
(handle uint64))
(defglextfun ("glUniformHandleui64NV" uniform-handle-ui64-nv) :void
(location int)
(value uint64))
(defglextfun ("glUniformHandleui64vNV" uniform-handle-ui64v-nv) :void
(location int)
(count sizei)
(value (:pointer uint64)))
(defglextfun ("glProgramUniformHandleui64NV" program-uniform-handle-ui64-nv) :void
(program uint)
(location int)
(value uint64))
(defglextfun ("glProgramUniformHandleui64vNV" program-uniform-handle-ui64v-nv) :void
(program uint)
(location int)
(count sizei)
(values (:pointer uint64)))
(defglextfun ("glIsTextureHandleResidentNV" is-texture-handle-resident-nv) boolean
(handle uint64))
(defglextfun ("glIsImageHandleResidentNV" is-image-handle-resident-nv) boolean
(handle uint64))
(defglextfun ("glBlendParameteriNV" blend-parameter-i-nv) :void
(pname enum)
(value int))
(defglextfun ("glBlendBarrierNV" blend-barrier-nv) :void)
(defglextfun ("glBeginConditionalRenderNV" begin-conditional-render-nv) :void
(id uint)
(mode enum))
(defglextfun ("glEndConditionalRenderNV" end-conditional-render-nv) :void)
(defglextfun ("glSubpixelPrecisionBiasNV" subpixel-precision-bias-nv) :void
(xbits uint)
(ybits uint))
(defglextfun ("glFragmentCoverageColorNV" fragment-coverage-color-nv) :void
(color uint))
(defglextfun ("glCoverageModulationTableNV" coverage-modulation-table-nv) :void
(n sizei)
(v (:pointer float)))
(defglextfun ("glGetCoverageModulationTableNV" get-coverage-modulation-table-nv) :void
(bufsize sizei)
(v (:pointer float)))
(defglextfun ("glCoverageModulationNV" coverage-modulation-nv) :void
(components enum))
(defglextfun ("glGetInternalformatSampleivNV" get-internalformat-sample-iv-nv) :void
(target enum)
(internalformat enum)
(samples sizei)
(pname enum)
(bufSize sizei)
(params (:pointer int)))
(defglextfun ("glGenPathsNV" gen-paths-nv) uint
(range sizei))
(defglextfun ("glDeletePathsNV" delete-paths-nv) :void
(path uint)
(range sizei))
(defglextfun ("glIsPathNV" is-path-nv) boolean
(path uint))
(defglextfun ("glPathCommandsNV" path-commands-nv) :void
(path uint)
(numCommands sizei)
(commands (:pointer ubyte))
(numCoords sizei)
(coordType enum)
(coords (:pointer :void)))
(defglextfun ("glPathCoordsNV" path-coords-nv) :void
(path uint)
(numCoords sizei)
(coordType enum)
(coords (:pointer :void)))
(defglextfun ("glPathSubCommandsNV" path-sub-commands-nv) :void
(path uint)
(commandStart sizei)
(commandsToDelete sizei)
(numCommands sizei)
(commands (:pointer ubyte))
(numCoords sizei)
(coordType enum)
(coords (:pointer :void)))
(defglextfun ("glPathSubCoordsNV" path-sub-coords-nv) :void
(path uint)
(coordStart sizei)
(numCoords sizei)
(coordType enum)
(coords (:pointer :void)))
(defglextfun ("glPathStringNV" path-string-nv) :void
(path uint)
(format enum)
(length sizei)
(pathString (:pointer :void)))
(defglextfun ("glPathGlyphsNV" path-glyphs-nv) :void
(firstPathName uint)
(fontTarget enum)
(fontName (:pointer :void))
(fontStyle bitfield)
(numGlyphs sizei)
(type enum)
(charcodes (:pointer :void))
(handleMissingGlyphs enum)
(pathParameterTemplate uint)
(emScale float))
(defglextfun ("glPathGlyphRangeNV" path-glyph-range-nv) :void
(firstPathName uint)
(fontTarget enum)
(fontName (:pointer :void))
(fontStyle bitfield)
(firstGlyph uint)
(numGlyphs sizei)
(handleMissingGlyphs enum)
(pathParameterTemplate uint)
(emScale float))
(defglextfun ("glWeightPathsNV" weight-paths-nv) :void
(resultPath uint)
(numPaths sizei)
(paths (:pointer uint))
(weights (:pointer float)))
(defglextfun ("glCopyPathNV" copy-path-nv) :void
(resultPath uint)
(srcPath uint))
(defglextfun ("glInterpolatePathsNV" interpolate-paths-nv) :void
(resultPath uint)
(pathA uint)
(pathB uint)
(weight float))
(defglextfun ("glTransformPathNV" transform-path-nv) :void
(resultPath uint)
(srcPath uint)
(transformType enum)
(transformValues (:pointer float)))
(defglextfun ("glPathParameterivNV" path-parameter-iv-nv) :void
(path uint)
(pname enum)
(value (:pointer int)))
(defglextfun ("glPathParameteriNV" path-parameter-i-nv) :void
(path uint)
(pname enum)
(value int))
(defglextfun ("glPathParameterfvNV" path-parameter-fv-nv) :void
(path uint)
(pname enum)
(value (:pointer float)))
(defglextfun ("glPathParameterfNV" path-parameter-f-nv) :void
(path uint)
(pname enum)
(value float))
(defglextfun ("glPathDashArrayNV" path-dash-array-nv) :void
(path uint)
(dashCount sizei)
(dashArray (:pointer float)))
(defglextfun ("glPathStencilFuncNV" path-stencil-func-nv) :void
(func enum)
(ref int)
(mask uint))
(defglextfun ("glPathStencilDepthOffsetNV" path-stencil-depth-offset-nv) :void
(factor float)
(units float))
(defglextfun ("glStencilFillPathNV" stencil-fill-path-nv) :void
(path uint)
(fillMode enum)
(mask uint))
(defglextfun ("glStencilStrokePathNV" stencil-stroke-path-nv) :void
(path uint)
(reference int)
(mask uint))
(defglextfun ("glStencilFillPathInstancedNV" stencil-fill-path-instanced-nv) :void
(numPaths sizei)
(pathNameType enum)
(paths (:pointer :void))
(pathBase uint)
(fillMode enum)
(mask uint)
(transformType enum)
(transformValues (:pointer float)))
(defglextfun ("glStencilStrokePathInstancedNV" stencil-stroke-path-instanced-nv) :void
(numPaths sizei)
(pathNameType enum)
(paths (:pointer :void))
(pathBase uint)
(reference int)
(mask uint)
(transformType enum)
(transformValues (:pointer float)))
(defglextfun ("glPathCoverDepthFuncNV" path-cover-depth-func-nv) :void
(func enum))
(defglextfun ("glCoverFillPathNV" cover-fill-path-nv) :void
(path uint)
(coverMode enum))
(defglextfun ("glCoverStrokePathNV" cover-stroke-path-nv) :void
(path uint)
(coverMode enum))
(defglextfun ("glCoverFillPathInstancedNV" cover-fill-path-instanced-nv) :void
(numPaths sizei)
(pathNameType enum)
(paths (:pointer :void))
(pathBase uint)
(coverMode enum)
(transformType enum)
(transformValues (:pointer float)))
(defglextfun ("glCoverStrokePathInstancedNV" cover-stroke-path-instanced-nv) :void
(numPaths sizei)
(pathNameType enum)
(paths (:pointer :void))
(pathBase uint)
(coverMode enum)
(transformType enum)
(transformValues (:pointer float)))
(defglextfun ("glGetPathParameterivNV" get-path-parameter-iv-nv) :void
(path uint)
(pname enum)
(value (:pointer int)))
(defglextfun ("glGetPathParameterfvNV" get-path-parameter-fv-nv) :void
(path uint)
(pname enum)
(value (:pointer float)))
(defglextfun ("glGetPathCommandsNV" get-path-commands-nv) :void
(path uint)
(commands (:pointer ubyte)))
(defglextfun ("glGetPathCoordsNV" get-path-coords-nv) :void
(path uint)
(coords (:pointer float)))
(defglextfun ("glGetPathDashArrayNV" get-path-dash-array-nv) :void
(path uint)
(dashArray (:pointer float)))
(defglextfun ("glGetPathMetricsNV" get-path-metrics-nv) :void
(metricQueryMask bitfield)
(numPaths sizei)
(pathNameType enum)
(paths (:pointer :void))
(pathBase uint)
(stride sizei)
(metrics (:pointer float)))
(defglextfun ("glGetPathMetricRangeNV" get-path-metric-range-nv) :void
(metricQueryMask bitfield)
(firstPathName uint)
(numPaths sizei)
(stride sizei)
(metrics (:pointer float)))
(defglextfun ("glGetPathSpacingNV" get-path-spacing-nv) :void
(pathListMode enum)
(numPaths sizei)
(pathNameType enum)
(paths (:pointer :void))
(pathBase uint)
(advanceScale float)
(kerningScale float)
(transformType enum)
(returnedSpacing (:pointer float)))
(defglextfun ("glIsPointInFillPathNV" is-point-in-fill-path-nv) boolean
(path uint)
(mask uint)
(x float)
(y float))
(defglextfun ("glIsPointInStrokePathNV" is-point-in-stroke-path-nv) boolean
(path uint)
(x float)
(y float))
(defglextfun ("glGetPathLengthNV" get-path-length-nv) float
(path uint)
(startSegment sizei)
(numSegments sizei))
(defglextfun ("glPointAlongPathNV" point-along-path-nv) boolean
(path uint)
(startSegment sizei)
(numSegments sizei)
(distance float)
(x (:pointer float))
(y (:pointer float))
(tangentX (:pointer float))
(tangentY (:pointer float)))
(defglextfun ("glMatrixLoad3x2fNV" matrix-load-3x2-f-nv) :void
(matrixMode enum)
(m (:pointer float)))
(defglextfun ("glMatrixLoad3x3fNV" matrix-load-3x3-f-nv) :void
(matrixMode enum)
(m (:pointer float)))
(defglextfun ("glMatrixLoadTranspose3x3fNV" matrix-load-transpose-3x3-f-nv) :void
(matrixMode enum)
(m (:pointer float)))
(defglextfun ("glMatrixMult3x2fNV" matrix-mult-3x2-f-nv) :void
(matrixMode enum)
(m (:pointer float)))
(defglextfun ("glMatrixMult3x3fNV" matrix-mult-3x3-f-nv) :void
(matrixMode enum)
(m (:pointer float)))
(defglextfun ("glMatrixMultTranspose3x3fNV" matrix-mult-transpose-3x3-f-nv) :void
(matrixMode enum)
(m (:pointer float)))
(defglextfun ("glStencilThenCoverFillPathNV" stencil-then-cover-fill-path-nv) :void
(path uint)
(fillMode enum)
(mask uint)
(coverMode enum))
(defglextfun ("glStencilThenCoverStrokePathNV" stencil-then-cover-stroke-path-nv) :void
(path uint)
(reference int)
(mask uint)
(coverMode enum))
(defglextfun ("glStencilThenCoverFillPathInstancedNV" stencil-then-cover-fill-path-instanced-nv) :void
(numPaths sizei)
(pathNameType enum)
(paths (:pointer :void))
(pathBase uint)
(fillMode enum)
(mask uint)
(coverMode enum)
(transformType enum)
(transformValues (:pointer float)))
(defglextfun ("glStencilThenCoverStrokePathInstancedNV" stencil-then-cover-stroke-path-instanced-nv) :void
(numPaths sizei)
(pathNameType enum)
(paths (:pointer :void))
(pathBase uint)
(reference int)
(mask uint)
(coverMode enum)
(transformType enum)
(transformValues (:pointer float)))
(defglextfun ("glPathGlyphIndexRangeNV" path-glyph-index-range-nv) enum
(fontTarget enum)
(fontName (:pointer :void))
(fontStyle bitfield)
(pathParameterTemplate uint)
(emScale float)
(baseAndCount uint [2]))
(defglextfun ("glPathGlyphIndexArrayNV" path-glyph-index-array-nv) enum
(firstPathName uint)
(fontTarget enum)
(fontName (:pointer :void))
(fontStyle bitfield)
(firstGlyphIndex uint)
(numGlyphs sizei)
(pathParameterTemplate uint)
(emScale float))
(defglextfun ("glPathMemoryGlyphIndexArrayNV" path-memory-glyph-index-array-nv) enum
(firstPathName uint)
(fontTarget enum)
(fontSize sizeiptr)
(fontData (:pointer :void))
(faceIndex sizei)
(firstGlyphIndex uint)
(numGlyphs sizei)
(pathParameterTemplate uint)
(emScale float))
(defglextfun ("glProgramPathFragmentInputGenNV" program-path-fragment-input-gen-nv) :void
(program uint)
(location int)
(genMode enum)
(components int)
(coeffs (:pointer float)))
(defglextfun ("glGetProgramResourcefvNV" get-program-resource-fv-nv) :void
(program uint)
(programInterface enum)
(index uint)
(propCount sizei)
(props (:pointer enum))
(bufSize sizei)
(length (:pointer sizei))
(params (:pointer float)))
(defglextfun ("glPathColorGenNV" path-color-gen-nv) :void
(color enum)
(genMode enum)
(colorFormat enum)
(coeffs (:pointer float)))
(defglextfun ("glPathTexGenNV" path-tex-gen-nv) :void
(texCoordSet enum)
(genMode enum)
(components int)
(coeffs (:pointer float)))
(defglextfun ("glPathFogGenNV" path-fog-gen-nv) :void
(genMode enum))
(defglextfun ("glGetPathColorGenivNV" get-path-color-gen-iv-nv) :void
(color enum)
(pname enum)
(value (:pointer int)))
(defglextfun ("glGetPathColorGenfvNV" get-path-color-gen-fv-nv) :void
(color enum)
(pname enum)
(value (:pointer float)))
(defglextfun ("glGetPathTexGenivNV" get-path-tex-gen-iv-nv) :void
(texCoordSet enum)
(pname enum)
(value (:pointer int)))
(defglextfun ("glGetPathTexGenfvNV" get-path-tex-gen-fv-nv) :void
(texCoordSet enum)
(pname enum)
(value (:pointer float)))
(defglextfun ("glFramebufferSampleLocationsfvNV" framebuffer-sample-locations-fv-nv) :void
(target enum)
(start uint)
(count sizei)
(v (:pointer float)))
(defglextfun ("glNamedFramebufferSampleLocationsfvNV" named-framebuffer-sample-locations-fv-nv) :void
(framebuffer uint)
(start uint)
(count sizei)
(v (:pointer float)))
(defglextfun ("glResolveDepthValuesNV" resolve-depth-values-nv) :void)
(defglextfun ("glFramebufferTextureMultiviewOVR" framebuffer-texture-multiview-ovr) :void
(target enum)
(attachment enum)
(texture uint)
(level int)
(baseViewIndex int)
(numViews sizei))
| 43,189 | Common Lisp | .lisp | 1,408 | 27.933949 | 106 | 0.742433 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 3005edb6adcb311810d13d5dbea9029717ad897b07ab7d1a3c7a52b54ff76af2 | 30,581 | [
329787
] |
30,582 | funcs-gl-gles1.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/funcs-gl-gles1.lisp | ;;; this file is automatically generated, do not edit
;;; generated from files with the following copyright:
;;;
;;; Copyright (c) 2013-2015 The Khronos Group Inc.
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining a
;;; copy of this software and/or associated documentation files (the
;;; "Materials"), to deal in the Materials without restriction, including
;;; without limitation the rights to use, copy, modify, merge, publish,
;;; distribute, sublicense, and/or sell copies of the Materials, and to
;;; permit persons to whom the Materials are furnished to do so, subject to
;;; the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be included
;;; in all copies or substantial portions of the Materials.
;;;
;;; THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
;;; IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
;;; CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
;;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
;;; MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
;;;
;;; ------------------------------------------------------------------------
(in-package #:cl-opengl-bindings)
;;; generated 2015-08-30T01:01:50Z
;;; from gl.xml @ svn rev 31811, 2015-08-10T07:01:11.860488Z
(defglfun ("glPointSize" point-size) :void
(size float))
(defglfun ("glLogicOp" logic-op) :void
(opcode enum))
(defglfun ("glColor4f" color-4f) :void
(red float)
(green float)
(blue float)
(alpha float))
(defglfun ("glColor4ub" color-4ub) :void
(red ubyte)
(green ubyte)
(blue ubyte)
(alpha ubyte))
(defglfun ("glNormal3f" normal-3f) :void
(nx float)
(ny float)
(nz float))
(defglfun ("glFogf" fog-f) :void
(pname enum)
(param float))
(defglfun ("glFogfv" fog-fv) :void
(pname enum)
(params (:pointer float)))
(defglfun ("glLightf" light-f) :void
(light enum)
(pname enum)
(param float))
(defglfun ("glLightfv" light-fv) :void
(light enum)
(pname enum)
(params (:pointer float)))
(defglfun ("glLightModelf" light-model-f) :void
(pname enum)
(param float))
(defglfun ("glLightModelfv" light-model-fv) :void
(pname enum)
(params (:pointer float)))
(defglfun ("glMaterialf" material-f) :void
(face enum)
(pname enum)
(param float))
(defglfun ("glMaterialfv" material-fv) :void
(face enum)
(pname enum)
(params (:pointer float)))
(defglfun ("glShadeModel" shade-model) :void
(mode enum))
(defglfun ("glTexEnvf" tex-env-f) :void
(target enum)
(pname enum)
(param float))
(defglfun ("glTexEnvfv" tex-env-fv) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglfun ("glTexEnvi" tex-env-i) :void
(target enum)
(pname enum)
(param int))
(defglfun ("glTexEnviv" tex-env-iv) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglfun ("glAlphaFunc" alpha-func) :void
(func enum)
(ref float))
(defglfun ("glGetLightfv" get-light-fv) :void
(light enum)
(pname enum)
(params (:pointer float)))
(defglfun ("glGetMaterialfv" get-material-fv) :void
(face enum)
(pname enum)
(params (:pointer float)))
(defglfun ("glGetTexEnvfv" get-tex-env-fv) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglfun ("glGetTexEnviv" get-tex-env-iv) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglfun ("glLoadIdentity" load-identity) :void)
(defglfun ("glLoadMatrixf" load-matrix-f) :void
(m (:pointer float)))
(defglfun ("glMatrixMode" matrix-mode) :void
(mode enum))
(defglfun ("glMultMatrixf" mult-matrix-f) :void
(m (:pointer float)))
(defglfun ("glPopMatrix" pop-matrix) :void)
(defglfun ("glPushMatrix" push-matrix) :void)
(defglfun ("glRotatef" rotate-f) :void
(angle float)
(x float)
(y float)
(z float))
(defglfun ("glScalef" scale-f) :void
(x float)
(y float)
(z float))
(defglfun ("glTranslatef" translate-f) :void
(x float)
(y float)
(z float))
(defglfun ("glColorPointer" color-pointer) :void
(size int)
(type enum)
(stride sizei)
(pointer offset-or-pointer))
(defglfun ("glDisableClientState" disable-client-state) :void
(array enum))
(defglfun ("glEnableClientState" enable-client-state) :void
(array enum))
(defglfun ("glNormalPointer" normal-pointer) :void
(type enum)
(stride sizei)
(pointer offset-or-pointer))
(defglfun ("glTexCoordPointer" tex-coord-pointer) :void
(size int)
(type enum)
(stride sizei)
(pointer offset-or-pointer))
(defglfun ("glVertexPointer" vertex-pointer) :void
(size int)
(type enum)
(stride sizei)
(pointer offset-or-pointer))
(defglextfun ("glClientActiveTexture" client-active-texture) :void
(texture enum))
(defglextfun ("glMultiTexCoord4f" multi-tex-coord-4f) :void
(target enum)
(s float)
(tee float)
(r float)
(q float))
(defglextfun ("glPointParameterf" point-parameter-f) :void
(pname enum)
(param float))
(defglextfun ("glPointParameterfv" point-parameter-fv) :void
(pname enum)
(params (:pointer float)))
(defglextfun ("glMultiTexCoord1bOES" multi-tex-coord-1b-oes) :void
(texture enum)
(s byte))
(defglextfun ("glMultiTexCoord1bvOES" multi-tex-coord-1bv-oes) :void
(texture enum)
(coords (:pointer byte)))
(defglextfun ("glMultiTexCoord2bOES" multi-tex-coord-2b-oes) :void
(texture enum)
(s byte)
(tee byte))
(defglextfun ("glMultiTexCoord2bvOES" multi-tex-coord-2bv-oes) :void
(texture enum)
(coords (:pointer byte)))
(defglextfun ("glMultiTexCoord3bOES" multi-tex-coord-3b-oes) :void
(texture enum)
(s byte)
(tee byte)
(r byte))
(defglextfun ("glMultiTexCoord3bvOES" multi-tex-coord-3bv-oes) :void
(texture enum)
(coords (:pointer byte)))
(defglextfun ("glMultiTexCoord4bOES" multi-tex-coord-4b-oes) :void
(texture enum)
(s byte)
(tee byte)
(r byte)
(q byte))
(defglextfun ("glMultiTexCoord4bvOES" multi-tex-coord-4bv-oes) :void
(texture enum)
(coords (:pointer byte)))
(defglextfun ("glTexCoord1bOES" tex-coord-1b-oes) :void
(s byte))
(defglextfun ("glTexCoord1bvOES" tex-coord-1bv-oes) :void
(coords (:pointer byte)))
(defglextfun ("glTexCoord2bOES" tex-coord-2b-oes) :void
(s byte)
(tee byte))
(defglextfun ("glTexCoord2bvOES" tex-coord-2bv-oes) :void
(coords (:pointer byte)))
(defglextfun ("glTexCoord3bOES" tex-coord-3b-oes) :void
(s byte)
(tee byte)
(r byte))
(defglextfun ("glTexCoord3bvOES" tex-coord-3bv-oes) :void
(coords (:pointer byte)))
(defglextfun ("glTexCoord4bOES" tex-coord-4b-oes) :void
(s byte)
(tee byte)
(r byte)
(q byte))
(defglextfun ("glTexCoord4bvOES" tex-coord-4bv-oes) :void
(coords (:pointer byte)))
(defglextfun ("glVertex2bOES" vertex-2b-oes) :void
(x byte)
(y byte))
(defglextfun ("glVertex2bvOES" vertex-2bv-oes) :void
(coords (:pointer byte)))
(defglextfun ("glVertex3bOES" vertex-3b-oes) :void
(x byte)
(y byte)
(z byte))
(defglextfun ("glVertex3bvOES" vertex-3bv-oes) :void
(coords (:pointer byte)))
(defglextfun ("glVertex4bOES" vertex-4b-oes) :void
(x byte)
(y byte)
(z byte)
(w byte))
(defglextfun ("glVertex4bvOES" vertex-4bv-oes) :void
(coords (:pointer byte)))
(defglextfun ("glAlphaFuncxOES" alpha-func-x-oes) :void
(func enum)
(ref fixed))
(defglextfun ("glClearColorxOES" clear-color-x-oes) :void
(red fixed)
(green fixed)
(blue fixed)
(alpha fixed))
(defglextfun ("glClearDepthxOES" clear-depth-x-oes) :void
(depth fixed))
(defglextfun ("glClipPlanexOES" clip-plane-x-oes) :void
(plane enum)
(equation (:pointer fixed)))
(defglextfun ("glColor4xOES" color-4x-oes) :void
(red fixed)
(green fixed)
(blue fixed)
(alpha fixed))
(defglextfun ("glDepthRangexOES" depth-range-x-oes) :void
(n fixed)
(f fixed))
(defglextfun ("glFogxOES" fog-x-oes) :void
(pname enum)
(param fixed))
(defglextfun ("glFogxvOES" fog-xv-oes) :void
(pname enum)
(param (:pointer fixed)))
(defglextfun ("glFrustumxOES" frustum-x-oes) :void
(l fixed)
(r fixed)
(b fixed)
(tee fixed)
(n fixed)
(f fixed))
(defglextfun ("glGetClipPlanexOES" get-clip-plane-x-oes) :void
(plane enum)
(equation (:pointer fixed)))
(defglextfun ("glGetFixedvOES" get-fixed-v-oes) :void
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glGetTexEnvxvOES" get-tex-env-xv-oes) :void
(target enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glGetTexParameterxvOES" get-tex-parameter-xv-oes) :void
(target enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glLightModelxOES" light-model-x-oes) :void
(pname enum)
(param fixed))
(defglextfun ("glLightModelxvOES" light-model-xv-oes) :void
(pname enum)
(param (:pointer fixed)))
(defglextfun ("glLightxOES" light-x-oes) :void
(light enum)
(pname enum)
(param fixed))
(defglextfun ("glLightxvOES" light-xv-oes) :void
(light enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glLineWidthxOES" line-width-x-oes) :void
(width fixed))
(defglextfun ("glLoadMatrixxOES" load-matrix-x-oes) :void
(m (:pointer fixed)))
(defglextfun ("glMaterialxOES" material-x-oes) :void
(face enum)
(pname enum)
(param fixed))
(defglextfun ("glMaterialxvOES" material-xv-oes) :void
(face enum)
(pname enum)
(param (:pointer fixed)))
(defglextfun ("glMultMatrixxOES" mult-matrix-x-oes) :void
(m (:pointer fixed)))
(defglextfun ("glMultiTexCoord4xOES" multi-tex-coord-4x-oes) :void
(texture enum)
(s fixed)
(tee fixed)
(r fixed)
(q fixed))
(defglextfun ("glNormal3xOES" normal-3x-oes) :void
(nx fixed)
(ny fixed)
(nz fixed))
(defglextfun ("glOrthoxOES" ortho-x-oes) :void
(l fixed)
(r fixed)
(b fixed)
(tee fixed)
(n fixed)
(f fixed))
(defglextfun ("glPointParameterxvOES" point-parameter-xv-oes) :void
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glPointSizexOES" point-size-x-oes) :void
(size fixed))
(defglextfun ("glPolygonOffsetxOES" polygon-offset-x-oes) :void
(factor fixed)
(units fixed))
(defglextfun ("glRotatexOES" rotate-x-oes) :void
(angle fixed)
(x fixed)
(y fixed)
(z fixed))
(defglextfun ("glScalexOES" scale-x-oes) :void
(x fixed)
(y fixed)
(z fixed))
(defglextfun ("glTexEnvxOES" tex-env-x-oes) :void
(target enum)
(pname enum)
(param fixed))
(defglextfun ("glTexEnvxvOES" tex-env-xv-oes) :void
(target enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glTexParameterxOES" tex-parameter-x-oes) :void
(target enum)
(pname enum)
(param fixed))
(defglextfun ("glTexParameterxvOES" tex-parameter-xv-oes) :void
(target enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glTranslatexOES" translate-x-oes) :void
(x fixed)
(y fixed)
(z fixed))
(defglextfun ("glGetLightxvOES" get-light-xv-oes) :void
(light enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glGetMaterialxvOES" get-material-xv-oes) :void
(face enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glPointParameterxOES" point-parameter-x-oes) :void
(pname enum)
(param fixed))
(defglextfun ("glSampleCoveragexOES" sample-coverage-x-oes) :void
(value clampx)
(invert boolean))
(defglextfun ("glAccumxOES" accum-x-oes) :void
(op enum)
(value fixed))
(defglextfun ("glBitmapxOES" bitmap-x-oes) :void
(width sizei)
(height sizei)
(xorig fixed)
(yorig fixed)
(xmove fixed)
(ymove fixed)
(bitmap (:pointer ubyte)))
(defglextfun ("glBlendColorxOES" blend-color-x-oes) :void
(red fixed)
(green fixed)
(blue fixed)
(alpha fixed))
(defglextfun ("glClearAccumxOES" clear-accum-x-oes) :void
(red fixed)
(green fixed)
(blue fixed)
(alpha fixed))
(defglextfun ("glColor3xOES" color-3x-oes) :void
(red fixed)
(green fixed)
(blue fixed))
(defglextfun ("glColor3xvOES" color-3xv-oes) :void
(components (:pointer fixed)))
(defglextfun ("glColor4xvOES" color-4xv-oes) :void
(components (:pointer fixed)))
(defglextfun ("glConvolutionParameterxOES" convolution-parameter-x-oes) :void
(target enum)
(pname enum)
(param fixed))
(defglextfun ("glConvolutionParameterxvOES" convolution-parameter-xv-oes) :void
(target enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glEvalCoord1xOES" eval-coord-1x-oes) :void
(u fixed))
(defglextfun ("glEvalCoord1xvOES" eval-coord-1xv-oes) :void
(coords (:pointer fixed)))
(defglextfun ("glEvalCoord2xOES" eval-coord-2x-oes) :void
(u fixed)
(v fixed))
(defglextfun ("glEvalCoord2xvOES" eval-coord-2xv-oes) :void
(coords (:pointer fixed)))
(defglextfun ("glFeedbackBufferxOES" feedback-buffer-x-oes) :void
(n sizei)
(type enum)
(buffer (:pointer fixed)))
(defglextfun ("glGetConvolutionParameterxvOES" get-convolution-parameter-xv-oes) :void
(target enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glGetHistogramParameterxvOES" get-histogram-parameter-xv-oes) :void
(target enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glGetLightxOES" get-light-x-oes) :void
(light enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glGetMapxvOES" get-map-xv-oes) :void
(target enum)
(query enum)
(v (:pointer fixed)))
(defglextfun ("glGetMaterialxOES" get-material-x-oes) :void
(face enum)
(pname enum)
(param fixed))
(defglextfun ("glGetPixelMapxv" get-pixel-map-xv) :void
(map enum)
(size int)
(values (:pointer fixed)))
(defglextfun ("glGetTexGenxvOES" get-tex-gen-xv-oes) :void
(coord enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glGetTexLevelParameterxvOES" get-tex-level-parameter-xv-oes) :void
(target enum)
(level int)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glIndexxOES" index-x-oes) :void
(component fixed))
(defglextfun ("glIndexxvOES" index-xv-oes) :void
(component (:pointer fixed)))
(defglextfun ("glLoadTransposeMatrixxOES" load-transpose-matrix-x-oes) :void
(m (:pointer fixed)))
(defglextfun ("glMap1xOES" map-1x-oes) :void
(target enum)
(u1 fixed)
(u2 fixed)
(stride int)
(order int)
(points fixed))
(defglextfun ("glMap2xOES" map-2x-oes) :void
(target enum)
(u1 fixed)
(u2 fixed)
(ustride int)
(uorder int)
(v1 fixed)
(v2 fixed)
(vstride int)
(vorder int)
(points fixed))
(defglextfun ("glMapGrid1xOES" map-grid-1x-oes) :void
(n int)
(u1 fixed)
(u2 fixed))
(defglextfun ("glMapGrid2xOES" map-grid-2x-oes) :void
(n int)
(u1 fixed)
(u2 fixed)
(v1 fixed)
(v2 fixed))
(defglextfun ("glMultTransposeMatrixxOES" mult-transpose-matrix-x-oes) :void
(m (:pointer fixed)))
(defglextfun ("glMultiTexCoord1xOES" multi-tex-coord-1x-oes) :void
(texture enum)
(s fixed))
(defglextfun ("glMultiTexCoord1xvOES" multi-tex-coord-1xv-oes) :void
(texture enum)
(coords (:pointer fixed)))
(defglextfun ("glMultiTexCoord2xOES" multi-tex-coord-2x-oes) :void
(texture enum)
(s fixed)
(tee fixed))
(defglextfun ("glMultiTexCoord2xvOES" multi-tex-coord-2xv-oes) :void
(texture enum)
(coords (:pointer fixed)))
(defglextfun ("glMultiTexCoord3xOES" multi-tex-coord-3x-oes) :void
(texture enum)
(s fixed)
(tee fixed)
(r fixed))
(defglextfun ("glMultiTexCoord3xvOES" multi-tex-coord-3xv-oes) :void
(texture enum)
(coords (:pointer fixed)))
(defglextfun ("glMultiTexCoord4xvOES" multi-tex-coord-4xv-oes) :void
(texture enum)
(coords (:pointer fixed)))
(defglextfun ("glNormal3xvOES" normal-3xv-oes) :void
(coords (:pointer fixed)))
(defglextfun ("glPassThroughxOES" pass-through-x-oes) :void
(token fixed))
(defglextfun ("glPixelMapx" pixel-map-x) :void
(map enum)
(size int)
(values (:pointer fixed)))
(defglextfun ("glPixelStorex" pixel-store-x) :void
(pname enum)
(param fixed))
(defglextfun ("glPixelTransferxOES" pixel-transfer-x-oes) :void
(pname enum)
(param fixed))
(defglextfun ("glPixelZoomxOES" pixel-zoom-x-oes) :void
(xfactor fixed)
(yfactor fixed))
(defglextfun ("glPrioritizeTexturesxOES" prioritize-textures-x-oes) :void
(n sizei)
(textures (:pointer uint))
(priorities (:pointer fixed)))
(defglextfun ("glRasterPos2xOES" raster-pos-2x-oes) :void
(x fixed)
(y fixed))
(defglextfun ("glRasterPos2xvOES" raster-pos-2xv-oes) :void
(coords (:pointer fixed)))
(defglextfun ("glRasterPos3xOES" raster-pos-3x-oes) :void
(x fixed)
(y fixed)
(z fixed))
(defglextfun ("glRasterPos3xvOES" raster-pos-3xv-oes) :void
(coords (:pointer fixed)))
(defglextfun ("glRasterPos4xOES" raster-pos-4x-oes) :void
(x fixed)
(y fixed)
(z fixed)
(w fixed))
(defglextfun ("glRasterPos4xvOES" raster-pos-4xv-oes) :void
(coords (:pointer fixed)))
(defglextfun ("glRectxOES" rect-x-oes) :void
(x1 fixed)
(y1 fixed)
(x2 fixed)
(y2 fixed))
(defglextfun ("glRectxvOES" rect-xv-oes) :void
(v1 (:pointer fixed))
(v2 (:pointer fixed)))
(defglextfun ("glTexCoord1xOES" tex-coord-1x-oes) :void
(s fixed))
(defglextfun ("glTexCoord1xvOES" tex-coord-1xv-oes) :void
(coords (:pointer fixed)))
(defglextfun ("glTexCoord2xOES" tex-coord-2x-oes) :void
(s fixed)
(tee fixed))
(defglextfun ("glTexCoord2xvOES" tex-coord-2xv-oes) :void
(coords (:pointer fixed)))
(defglextfun ("glTexCoord3xOES" tex-coord-3x-oes) :void
(s fixed)
(tee fixed)
(r fixed))
(defglextfun ("glTexCoord3xvOES" tex-coord-3xv-oes) :void
(coords (:pointer fixed)))
(defglextfun ("glTexCoord4xOES" tex-coord-4x-oes) :void
(s fixed)
(tee fixed)
(r fixed)
(q fixed))
(defglextfun ("glTexCoord4xvOES" tex-coord-4xv-oes) :void
(coords (:pointer fixed)))
(defglextfun ("glTexGenxOES" tex-gen-x-oes) :void
(coord enum)
(pname enum)
(param fixed))
(defglextfun ("glTexGenxvOES" tex-gen-xv-oes) :void
(coord enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glVertex2xOES" vertex-2x-oes) :void
(x fixed))
(defglextfun ("glVertex2xvOES" vertex-2xv-oes) :void
(coords (:pointer fixed)))
(defglextfun ("glVertex3xOES" vertex-3x-oes) :void
(x fixed)
(y fixed))
(defglextfun ("glVertex3xvOES" vertex-3xv-oes) :void
(coords (:pointer fixed)))
(defglextfun ("glVertex4xOES" vertex-4x-oes) :void
(x fixed)
(y fixed)
(z fixed))
(defglextfun ("glVertex4xvOES" vertex-4xv-oes) :void
(coords (:pointer fixed)))
(defglextfun ("glQueryMatrixxOES" query-matrix-x-oes) bitfield
(mantissa (:pointer fixed))
(exponent (:pointer int)))
(defglextfun ("glClearDepthfOES" clear-depth-f-oes) :void
(depth clampf))
(defglextfun ("glClipPlanefOES" clip-plane-f-oes) :void
(plane enum)
(equation (:pointer float)))
(defglextfun ("glDepthRangefOES" depth-range-f-oes) :void
(n clampf)
(f clampf))
(defglextfun ("glFrustumfOES" frustum-f-oes) :void
(l float)
(r float)
(b float)
(tee float)
(n float)
(f float))
(defglextfun ("glGetClipPlanefOES" get-clip-plane-f-oes) :void
(plane enum)
(equation (:pointer float)))
(defglextfun ("glOrthofOES" ortho-f-oes) :void
(l float)
(r float)
(b float)
(tee float)
(n float)
(f float))
| 19,100 | Common Lisp | .lisp | 647 | 26.877898 | 86 | 0.716232 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | fb3fc7030e6726327f1a125019c193db4645ba4d6878a76dbebad7ff2c4a92f0 | 30,582 | [
285948
] |
30,583 | funcs-gles1-gles2.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/funcs-gles1-gles2.lisp | ;;; this file is automatically generated, do not edit
;;; generated from files with the following copyright:
;;;
;;; Copyright (c) 2013-2015 The Khronos Group Inc.
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining a
;;; copy of this software and/or associated documentation files (the
;;; "Materials"), to deal in the Materials without restriction, including
;;; without limitation the rights to use, copy, modify, merge, publish,
;;; distribute, sublicense, and/or sell copies of the Materials, and to
;;; permit persons to whom the Materials are furnished to do so, subject to
;;; the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be included
;;; in all copies or substantial portions of the Materials.
;;;
;;; THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
;;; IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
;;; CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
;;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
;;; MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
;;;
;;; ------------------------------------------------------------------------
(in-package #:cl-opengl-bindings)
;;; generated 2015-08-30T01:01:50Z
;;; from gl.xml @ svn rev 31811, 2015-08-10T07:01:11.860488Z
(defglextfun ("glCopyTextureLevelsAPPLE" copy-texture-levels-apple) :void
(destinationTexture uint)
(sourceTexture uint)
(sourceBaseLevel int)
(sourceLevelCount sizei))
(defglextfun ("glRenderbufferStorageMultisampleAPPLE" renderbuffer-storage-multisample-apple) :void
(target enum)
(samples sizei)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glResolveMultisampleFramebufferAPPLE" resolve-multisample-framebuffer-apple) :void)
(defglextfun ("glFenceSyncAPPLE" fence-sync-apple) sync
(condition enum)
(flags bitfield))
(defglextfun ("glIsSyncAPPLE" is-sync-apple) boolean
(sync sync))
(defglextfun ("glDeleteSyncAPPLE" delete-sync-apple) :void
(sync sync))
(defglextfun ("glClientWaitSyncAPPLE" client-wait-sync-apple) enum
(sync sync)
(flags bitfield)
(timeout uint64))
(defglextfun ("glWaitSyncAPPLE" wait-sync-apple) :void
(sync sync)
(flags bitfield)
(timeout uint64))
(defglextfun ("glGetInteger64vAPPLE" get-integer-64-v-apple) :void
(pname enum)
(params (:pointer int64)))
(defglextfun ("glGetSyncivAPPLE" get-sync-iv-apple) :void
(sync sync)
(pname enum)
(bufSize sizei)
(length (:pointer sizei))
(values (:pointer int)))
(defglextfun ("glDiscardFramebufferEXT" discard-framebuffer-ext) :void
(target enum)
(numAttachments sizei)
(attachments (:pointer enum)))
(defglextfun ("glMapBufferRangeEXT" map-buffer-range-ext) (:pointer :void)
(target enum)
(offset intptr)
(length sizeiptr)
(access bitfield))
(defglextfun ("glFlushMappedBufferRangeEXT" flush-mapped-buffer-range-ext) :void
(target enum)
(offset intptr)
(length sizeiptr))
(defglextfun ("glFramebufferTexture2DMultisampleEXT" framebuffer-texture-2d-multisample-ext) :void
(target enum)
(attachment enum)
(textarget enum)
(texture uint)
(level int)
(samples sizei))
(defglextfun ("glGetGraphicsResetStatusEXT" get-graphics-reset-status-ext) enum)
(defglextfun ("glReadnPixelsEXT" readn-pixels-ext) :void
(x int)
(y int)
(width sizei)
(height sizei)
(format enum)
(type enum)
(bufSize sizei)
(data (:pointer :void)))
(defglextfun ("glGetnUniformfvEXT" getn-uniformfv-ext) :void
(program uint)
(location int)
(bufSize sizei)
(params (:pointer float)))
(defglextfun ("glGetnUniformivEXT" getn-uniformiv-ext) :void
(program uint)
(location int)
(bufSize sizei)
(params (:pointer int)))
(defglextfun ("glTexStorage1DEXT" tex-storage-1d-ext) :void
(target enum)
(levels sizei)
(internalformat enum)
(width sizei))
(defglextfun ("glTexStorage2DEXT" tex-storage-2d-ext) :void
(target enum)
(levels sizei)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glTexStorage3DEXT" tex-storage-3d-ext) :void
(target enum)
(levels sizei)
(internalformat enum)
(width sizei)
(height sizei)
(depth sizei))
(defglextfun ("glRenderbufferStorageMultisampleIMG" renderbuffer-storage-multisample-img) :void
(target enum)
(samples sizei)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glFramebufferTexture2DMultisampleIMG" framebuffer-texture-2d-multisample-img) :void
(target enum)
(attachment enum)
(textarget enum)
(texture uint)
(level int)
(samples sizei))
(defglextfun ("glEGLImageTargetTexture2DOES" egl-image-target-texture-2d-oes) :void
(target enum)
(image egl-image-oes))
(defglextfun ("glEGLImageTargetRenderbufferStorageOES" egl-image-target-renderbuffer-storage-oes) :void
(target enum)
(image egl-image-oes))
(defglextfun ("glMapBufferOES" map-buffer-oes) (:pointer :void)
(target enum)
(access enum))
(defglextfun ("glUnmapBufferOES" unmap-buffer-oes) boolean
(target enum))
(defglextfun ("glGetBufferPointervOES" get-buffer-pointer-v-oes) :void
(target enum)
(pname enum)
(params (:pointer (:pointer :void))))
(defglextfun ("glBindVertexArrayOES" bind-vertex-array-oes) :void
(array uint))
(defglextfun ("glDeleteVertexArraysOES" delete-vertex-arrays-oes) :void
(n sizei)
(arrays (:pointer uint)))
(defglextfun ("glGenVertexArraysOES" gen-vertex-arrays-oes) :void
(n sizei)
(arrays (:pointer uint)))
(defglextfun ("glIsVertexArrayOES" is-vertex-array-oes) boolean
(array uint))
(defglextfun ("glGetDriverControlsQCOM" get-driver-controls-qcom) :void
(num (:pointer int))
(size sizei)
(driverControls (:pointer uint)))
(defglextfun ("glGetDriverControlStringQCOM" get-driver-control-string-qcom) :void
(driverControl uint)
(bufSize sizei)
(length (:pointer sizei))
(driverControlString (:pointer char)))
(defglextfun ("glEnableDriverControlQCOM" enable-driver-control-qcom) :void
(driverControl uint))
(defglextfun ("glDisableDriverControlQCOM" disable-driver-control-qcom) :void
(driverControl uint))
(defglextfun ("glExtGetTexturesQCOM" ext-get-textures-qcom) :void
(textures (:pointer uint))
(maxTextures int)
(numTextures (:pointer int)))
(defglextfun ("glExtGetBuffersQCOM" ext-get-buffers-qcom) :void
(buffers (:pointer uint))
(maxBuffers int)
(numBuffers (:pointer int)))
(defglextfun ("glExtGetRenderbuffersQCOM" ext-get-renderbuffers-qcom) :void
(renderbuffers (:pointer uint))
(maxRenderbuffers int)
(numRenderbuffers (:pointer int)))
(defglextfun ("glExtGetFramebuffersQCOM" ext-get-framebuffers-qcom) :void
(framebuffers (:pointer uint))
(maxFramebuffers int)
(numFramebuffers (:pointer int)))
(defglextfun ("glExtGetTexLevelParameterivQCOM" ext-get-tex-level-parameter-iv-qcom) :void
(texture uint)
(face enum)
(level int)
(pname enum)
(params (:pointer int)))
(defglextfun ("glExtTexObjectStateOverrideiQCOM" ext-tex-object-state-override-i-qcom) :void
(target enum)
(pname enum)
(param int))
(defglextfun ("glExtGetTexSubImageQCOM" ext-get-tex-sub-image-qcom) :void
(target enum)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei)
(format enum)
(type enum)
(texels (:pointer :void)))
(defglextfun ("glExtGetBufferPointervQCOM" ext-get-buffer-pointer-v-qcom) :void
(target enum)
(params (:pointer (:pointer :void))))
(defglextfun ("glExtGetShadersQCOM" ext-get-shaders-qcom) :void
(shaders (:pointer uint))
(maxShaders int)
(numShaders (:pointer int)))
(defglextfun ("glExtGetProgramsQCOM" ext-get-programs-qcom) :void
(programs (:pointer uint))
(maxPrograms int)
(numPrograms (:pointer int)))
(defglextfun ("glExtIsProgramBinaryQCOM" ext-is-program-binary-qcom) boolean
(program uint))
(defglextfun ("glExtGetProgramBinarySourceQCOM" ext-get-program-binary-source-qcom) :void
(program uint)
(shadertype enum)
(source (:pointer char))
(length (:pointer int)))
(defglextfun ("glStartTilingQCOM" start-tiling-qcom) :void
(x uint)
(y uint)
(width uint)
(height uint)
(preserveMask bitfield))
(defglextfun ("glEndTilingQCOM" end-tiling-qcom) :void
(preserveMask bitfield))
| 8,402 | Common Lisp | .lisp | 237 | 32.886076 | 103 | 0.752835 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 7fc286e59662a0203ed8269d164431fba545a4f1177bade72b1b69a622c26573 | 30,583 | [
118548
] |
30,584 | library.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/library.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; library.lisp --- Foreign library definition
;;;
;;; Copyright (C) 2006-2007, Luis Oliveira <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; o Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may
;;; be used to endorse or promote products derived from this software
;;; without specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
;;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
;;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
;;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-opengl-bindings)
(define-foreign-library opengl
(:darwin (:framework "OpenGL"))
(:windows "opengl32.dll" :convention :stdcall)
(:unix (:or "libGL.so.4" "libGL.so.3" "libGL.so.2" "libGL.so.1" "libGL.so")))
(use-foreign-library opengl)
| 1,990 | Common Lisp | .lisp | 37 | 52.540541 | 79 | 0.750769 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | d5e921d1bdf56706c506d63614a0fab10e6f8c5bb9a84e6eaa01ced9057d2301 | 30,584 | [
-1
] |
30,585 | bindings.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/bindings.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; Copyright (c) 2004, Oliver Markovic <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions are met:
;;;
;;; o Redistributions of source code must retain the above copyright notice,
;;; this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may be
;;; used to endorse or promote products derived from this software without
;;; specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
;;; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
;;; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
;;; LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
;;; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
;;; SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
;;; CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
;;; ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
;;; POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-opengl-bindings)
;;; in case we want to be able to tell whether we are using a cl-opengl with
;;; automatic error checking, push something on *features*
#-cl-opengl-no-check-error(pushnew :cl-opengl-checks-errors *features*)
(define-condition opengl-error (simple-error)
((error-code :initarg :error-code :reader opengl-error.error-code)
(error-context :initform nil :initarg :error-context :reader opengl-error.error-context))
(:report (lambda (c s)
(if (opengl-error.error-context c)
(format s "OpenGL signalled ~A from ~A."
(opengl-error.error-code c)
(opengl-error.error-context c))
(format s "OpenGL signalled ~A."
(opengl-error.error-code c))))))
(defparameter *in-begin* nil)
;; inlining lots of restart-case kills compilation times on SBCL, and doesn't
;; seem to help performance much
;; (declaim (inline check-error))
(defun check-error (&optional context)
(declare (optimize speed))
(unless *in-begin*
(let ((error-code (foreign-funcall ("glGetError" :library opengl)
:unsigned-int)))
(unless (zerop error-code)
(restart-case
(error 'opengl-error
:error-code (cons error-code
(cffi:foreign-enum-keyword '%gl:enum error-code))
:error-context context)
(continue () :report "Continue"))))))
;;; Helper macro to define a GL API function and declare it inline.
(defmacro defglfun ((cname lname) result-type &body body)
`(progn
(declaim (inline ,lname))
#-cl-opengl-no-check-error
(defun ,lname ,(mapcar #'first body)
(multiple-value-prog1
(foreign-funcall (,cname :library opengl)
,@(loop for i in body
collect (second i)
collect (first i))
,result-type)
,@(cond
((string= cname "glGetError") ())
((string= cname "glBegin")
`((setf *in-begin* t)))
((string= cname "glEnd")
`((setf *in-begin* nil)
(check-error ',lname)))
(t
`((check-error ',lname))))))
#+cl-opengl-no-check-error
(defcfun (,cname ,lname :library opengl) ,result-type ,@body)))
;;;; Extensions
;;; TODO: need to handle multiple contexts.
;;;
;;; TODO: probably should have the option of using directly exported
;;; functions on platforms that have them, but that would need
;;; to deal with the possibility of a core being loaded on a
;;; system with different functions exported than the one on
;;; which the core was saved.
;;; Set this to a function which knows how to get a GL extension
;;; pointer from the OS: glutGetProcAddress(), SDL_GL_GetProcAddress(),
;;; wglGetProcAddress(), etc.
(defparameter *gl-get-proc-address* nil)
;;; Fallback get-proc-address bindings which should work for common
;;; configurations
;;; TODO: Darwin
#+(or linux freebsd)
(defcfun ("glXGetProcAddress" glx-get-proc-address) :pointer
(proc-name :string))
#+windows
(defcfun ("wglGetProcAddress" wgl-get-proc-address) :pointer
(proc-name :string))
(defun gl-get-proc-address (name)
(funcall (or *gl-get-proc-address*
#+(or linux freebsd) #'glx-get-proc-address
#+windows #'wgl-get-proc-address
#'cffi:foreign-symbol-pointer)
name))
(eval-when (:load-toplevel :execute)
#+clisp (pushnew 'reset-gl-pointers custom:*fini-hooks*)
#+sbcl (pushnew 'reset-gl-pointers sb-ext:*save-hooks*)
#+cmu (pushnew 'reset-gl-pointers ext:*before-save-initializations*)
;; ECL does not need this since it does not save images
#-(or clisp sbcl cmu ecl)
(warn "Don't know how to setup a hook before saving cores on this Lisp."))
;;;; Bart's version of DEFGLEXTFUN.
#-(and)
(defparameter *gl-extension-resetter-list* nil)
;;; FIXME? There's a possible race condition here, but this function
;;; is intended to be called while saving an image, so if someone is
;;; still calling GL functions we lose anyway...
#-(and)
(defun reset-gl-pointers ()
(format t "~&;; resetting extension pointers...~%")
(mapc #'funcall *gl-extension-resetter-list*)
(setf *gl-extension-resetter-list* nil))
#-(and)
(defmacro defglextfun ((cname lname) return-type &body args)
(with-unique-names (pointer)
`(let ((,pointer (null-pointer)))
(defun ,lname ,(mapcar #'car args)
(when (null-pointer-p ,pointer)
(setf ,pointer (%gl-get-proc-address ,cname))
(assert (not (null-pointer-p ,pointer)) ()
"Couldn't load symbol ~A~%" ,cname)
(format t "Loaded function pointer for ~A: ~A~%" ,cname ,pointer)
(push (lambda () (setf ,pointer (null-pointer)))
*gl-extension-resetter-list*))
(foreign-funcall-pointer
,pointer
(:library opengl)
,@(loop for arg in args collect (second arg) collect (first arg))
,return-type)))))
;;;; Thomas's version of DEFGLEXTFUN.
(defun reset-gl-pointers ()
(do-external-symbols (sym (find-package '#:%gl))
(let ((dummy (get sym 'proc-address-dummy)))
(when dummy
(setf (fdefinition sym) dummy)))))
(defun generate-gl-function (foreign-name lisp-name result-type body &rest args)
(let ((address (gl-get-proc-address foreign-name))
(arg-list (mapcar #'first body)))
(when (or (not (pointerp address)) (null-pointer-p address))
(error "Couldn't find function ~A" foreign-name))
(compile lisp-name
`(lambda ,arg-list
(multiple-value-prog1
(foreign-funcall-pointer
,address
(:library opengl)
,@(loop for i in body
collect (second i)
collect (first i))
,result-type)
#-cl-opengl-no-check-error
(check-error ',lisp-name))))
(apply lisp-name args)))
(defmacro defglextfun ((foreign-name lisp-name) result-type &rest body)
(let ((args-list (mapcar #'first body)))
`(progn
(declaim (notinline ,lisp-name))
(defun ,lisp-name ,args-list
(generate-gl-function ,foreign-name ',lisp-name ',result-type
',body ,@args-list))
(setf (get ',lisp-name 'proc-address-dummy) #',lisp-name)
',lisp-name)))
| 8,311 | Common Lisp | .lisp | 176 | 39.448864 | 92 | 0.634056 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | f0826351589c436db4d33588385a2eb1de4fc1c18703397d9d3fecd02628c77c | 30,585 | [
417771
] |
30,587 | bindings-package.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/bindings-package.lisp | ;;; generated file, do not edit
;;; glext version 20150810 ( 2015-08-10T07:01:11.860488Z )
(defpackage #:cl-opengl-bindings
(:nicknames #:%gl)
(:use #:common-lisp #:cffi)
(:shadow #:char #:float #:byte #:boolean #:string)
(:export
#:*glext-version*
#:*glext-last-updated*
#:*gl-get-proc-address*
#:opengl-error
#:check-error
#:enum
#:AttribMask
#:ClearBufferMask
#:ClientAttribMask
#:BufferAccessMask
;; Types.
#:char #:char-arb #:intptr #:sizeiptr #:intptr-arb #:sizeiptr-arb
#:handle-arb #:half #:half-arb #:half-nv #:int64 #:uint64 #:clampd
#:double #:clampf #:float #:sizei #:uint #:ushort #:ubyte #:int
#:short #:byte #:void #:bitfield #:boolean #:string #:int64-ext
#:uint64-ext
;; Functions.
#:cull-face #:front-face #:hint #:line-width #:point-size
#:polygon-mode #:scissor #:tex-parameter-f #:tex-parameter-fv
#:tex-parameter-i #:tex-parameter-iv #:tex-image-1d #:tex-image-2d
#:draw-buffer #:clear #:clear-color #:clear-stencil #:clear-depth
#:stencil-mask #:color-mask #:depth-mask #:disable #:enable
#:finish #:flush #:blend-func #:logic-op #:stencil-func
#:stencil-op #:depth-func #:pixel-store-f #:pixel-store-i
#:read-buffer #:read-pixels #:get-boolean-v #:get-double-v
#:get-error #:get-float-v #:get-integer-v #:get-string
#:get-tex-image #:get-tex-parameter-fv #:get-tex-parameter-iv
#:get-tex-level-parameter-fv #:get-tex-level-parameter-iv
#:is-enabled #:depth-range #:viewport #:new-list #:end-list
#:call-list #:call-lists #:delete-lists #:gen-lists #:list-base
#:begin #:bitmap #:color-3b #:color-3bv #:color-3d #:color-3dv
#:color-3f #:color-3fv #:color-3i #:color-3iv #:color-3s
#:color-3sv #:color-3ub #:color-3ubv #:color-3ui #:color-3uiv
#:color-3us #:color-3usv #:color-4b #:color-4bv #:color-4d
#:color-4dv #:color-4f #:color-4fv #:color-4i #:color-4iv
#:color-4s #:color-4sv #:color-4ub #:color-4ubv #:color-4ui
#:color-4uiv #:color-4us #:color-4usv #:edge-flag #:edge-flag-v
#:end #:index-d #:index-dv #:index-f #:index-fv #:index-i
#:index-iv #:index-s #:index-sv #:normal-3b #:normal-3bv
#:normal-3d #:normal-3dv #:normal-3f #:normal-3fv #:normal-3i
#:normal-3iv #:normal-3s #:normal-3sv #:raster-pos-2d
#:raster-pos-2dv #:raster-pos-2f #:raster-pos-2fv #:raster-pos-2i
#:raster-pos-2iv #:raster-pos-2s #:raster-pos-2sv #:raster-pos-3d
#:raster-pos-3dv #:raster-pos-3f #:raster-pos-3fv #:raster-pos-3i
#:raster-pos-3iv #:raster-pos-3s #:raster-pos-3sv #:raster-pos-4d
#:raster-pos-4dv #:raster-pos-4f #:raster-pos-4fv #:raster-pos-4i
#:raster-pos-4iv #:raster-pos-4s #:raster-pos-4sv #:rect-d
#:rect-dv #:rect-f #:rect-fv #:rect-i #:rect-iv #:rect-s #:rect-sv
#:tex-coord-1d #:tex-coord-1dv #:tex-coord-1f #:tex-coord-1fv
#:tex-coord-1i #:tex-coord-1iv #:tex-coord-1s #:tex-coord-1sv
#:tex-coord-2d #:tex-coord-2dv #:tex-coord-2f #:tex-coord-2fv
#:tex-coord-2i #:tex-coord-2iv #:tex-coord-2s #:tex-coord-2sv
#:tex-coord-3d #:tex-coord-3dv #:tex-coord-3f #:tex-coord-3fv
#:tex-coord-3i #:tex-coord-3iv #:tex-coord-3s #:tex-coord-3sv
#:tex-coord-4d #:tex-coord-4dv #:tex-coord-4f #:tex-coord-4fv
#:tex-coord-4i #:tex-coord-4iv #:tex-coord-4s #:tex-coord-4sv
#:vertex-2d #:vertex-2dv #:vertex-2f #:vertex-2fv #:vertex-2i
#:vertex-2iv #:vertex-2s #:vertex-2sv #:vertex-3d #:vertex-3dv
#:vertex-3f #:vertex-3fv #:vertex-3i #:vertex-3iv #:vertex-3s
#:vertex-3sv #:vertex-4d #:vertex-4dv #:vertex-4f #:vertex-4fv
#:vertex-4i #:vertex-4iv #:vertex-4s #:vertex-4sv #:clip-plane
#:color-material #:fog-f #:fog-fv #:fog-i #:fog-iv #:light-f
#:light-fv #:light-i #:light-iv #:light-model-f #:light-model-fv
#:light-model-i #:light-model-iv #:line-stipple #:material-f
#:material-fv #:material-i #:material-iv #:polygon-stipple
#:shade-model #:tex-env-f #:tex-env-fv #:tex-env-i #:tex-env-iv
#:tex-gen-d #:tex-gen-dv #:tex-gen-f #:tex-gen-fv #:tex-gen-i
#:tex-gen-iv #:feedback-buffer #:select-buffer #:render-mode
#:init-names #:load-name #:pass-through #:pop-name #:push-name
#:clear-accum #:clear-index #:index-mask #:accum #:pop-attrib
#:push-attrib #:map-1d #:map-1f #:map-2d #:map-2f #:map-grid-1d
#:map-grid-1f #:map-grid-2d #:map-grid-2f #:eval-coord-1d
#:eval-coord-1dv #:eval-coord-1f #:eval-coord-1fv #:eval-coord-2d
#:eval-coord-2dv #:eval-coord-2f #:eval-coord-2fv #:eval-mesh-1
#:eval-point-1 #:eval-mesh-2 #:eval-point-2 #:alpha-func
#:pixel-zoom #:pixel-transfer-f #:pixel-transfer-i #:pixel-map-fv
#:pixel-map-uiv #:pixel-map-usv #:copy-pixels #:draw-pixels
#:get-clip-plane #:get-light-fv #:get-light-iv #:get-map-dv
#:get-map-fv #:get-map-iv #:get-material-fv #:get-material-iv
#:get-pixel-map-fv #:get-pixel-map-uiv #:get-pixel-map-usv
#:get-polygon-stipple #:get-tex-env-fv #:get-tex-env-iv
#:get-tex-gen-dv #:get-tex-gen-fv #:get-tex-gen-iv #:is-list
#:frustum #:load-identity #:load-matrix-f #:load-matrix-d
#:matrix-mode #:mult-matrix-f #:mult-matrix-d #:ortho #:pop-matrix
#:push-matrix #:rotate-d #:rotate-f #:scale-d #:scale-f
#:translate-d #:translate-f #:draw-arrays #:draw-elements
#:get-pointer-v #:polygon-offset #:copy-tex-image-1d
#:copy-tex-image-2d #:copy-tex-sub-image-1d
#:copy-tex-sub-image-2d #:tex-sub-image-1d #:tex-sub-image-2d
#:bind-texture #:delete-textures #:gen-textures #:is-texture
#:array-element #:color-pointer #:disable-client-state
#:edge-flag-pointer #:enable-client-state #:index-pointer
#:interleaved-arrays #:normal-pointer #:tex-coord-pointer
#:vertex-pointer #:are-textures-resident #:prioritize-textures
#:index-ub #:index-ubv #:pop-client-attrib #:push-client-attrib
#:draw-range-elements #:tex-image-3d #:tex-sub-image-3d
#:copy-tex-sub-image-3d #:active-texture #:sample-coverage
#:compressed-tex-image-3d #:compressed-tex-image-2d
#:compressed-tex-image-1d #:compressed-tex-sub-image-3d
#:compressed-tex-sub-image-2d #:compressed-tex-sub-image-1d
#:get-compressed-tex-image #:client-active-texture
#:multi-tex-coord-1d #:multi-tex-coord-1dv #:multi-tex-coord-1f
#:multi-tex-coord-1fv #:multi-tex-coord-1i #:multi-tex-coord-1iv
#:multi-tex-coord-1s #:multi-tex-coord-1sv #:multi-tex-coord-2d
#:multi-tex-coord-2dv #:multi-tex-coord-2f #:multi-tex-coord-2fv
#:multi-tex-coord-2i #:multi-tex-coord-2iv #:multi-tex-coord-2s
#:multi-tex-coord-2sv #:multi-tex-coord-3d #:multi-tex-coord-3dv
#:multi-tex-coord-3f #:multi-tex-coord-3fv #:multi-tex-coord-3i
#:multi-tex-coord-3iv #:multi-tex-coord-3s #:multi-tex-coord-3sv
#:multi-tex-coord-4d #:multi-tex-coord-4dv #:multi-tex-coord-4f
#:multi-tex-coord-4fv #:multi-tex-coord-4i #:multi-tex-coord-4iv
#:multi-tex-coord-4s #:multi-tex-coord-4sv
#:load-transpose-matrix-f #:load-transpose-matrix-d
#:mult-transpose-matrix-f #:mult-transpose-matrix-d
#:blend-func-separate #:multi-draw-arrays #:multi-draw-elements
#:point-parameter-f #:point-parameter-fv #:point-parameter-i
#:point-parameter-iv #:fog-coord-f #:fog-coord-fv #:fog-coord-d
#:fog-coord-dv #:fog-coord-pointer #:secondary-color-3b
#:secondary-color-3bv #:secondary-color-3d #:secondary-color-3dv
#:secondary-color-3f #:secondary-color-3fv #:secondary-color-3i
#:secondary-color-3iv #:secondary-color-3s #:secondary-color-3sv
#:secondary-color-3ub #:secondary-color-3ubv #:secondary-color-3ui
#:secondary-color-3uiv #:secondary-color-3us
#:secondary-color-3usv #:secondary-color-pointer #:window-pos-2d
#:window-pos-2dv #:window-pos-2f #:window-pos-2fv #:window-pos-2i
#:window-pos-2iv #:window-pos-2s #:window-pos-2sv #:window-pos-3d
#:window-pos-3dv #:window-pos-3f #:window-pos-3fv #:window-pos-3i
#:window-pos-3iv #:window-pos-3s #:window-pos-3sv #:blend-color
#:blend-equation #:gen-queries #:delete-queries #:is-query
#:begin-query #:end-query #:get-query-iv #:get-query-object-iv
#:get-query-object-uiv #:bind-buffer #:delete-buffers
#:gen-buffers #:is-buffer #:buffer-data #:buffer-sub-data
#:get-buffer-sub-data #:map-buffer #:unmap-buffer
#:get-buffer-parameter-iv #:get-buffer-pointer-v
#:blend-equation-separate #:draw-buffers #:stencil-op-separate
#:stencil-func-separate #:stencil-mask-separate #:attach-shader
#:bind-attrib-location #:compile-shader #:create-program
#:create-shader #:delete-program #:delete-shader #:detach-shader
#:disable-vertex-attrib-array #:enable-vertex-attrib-array
#:get-active-attrib #:get-active-uniform #:get-attached-shaders
#:get-attrib-location #:get-program-iv #:get-program-info-log
#:get-shader-iv #:get-shader-info-log #:get-shader-source
#:get-uniform-location #:get-uniform-fv #:get-uniform-iv
#:get-vertex-attrib-dv #:get-vertex-attrib-fv
#:get-vertex-attrib-iv #:get-vertex-attrib-pointer-v #:is-program
#:is-shader #:link-program #:shader-source #:use-program
#:uniform-1f #:uniform-2f #:uniform-3f #:uniform-4f #:uniform-1i
#:uniform-2i #:uniform-3i #:uniform-4i #:uniform-1fv #:uniform-2fv
#:uniform-3fv #:uniform-4fv #:uniform-1iv #:uniform-2iv
#:uniform-3iv #:uniform-4iv #:uniform-matrix-2fv
#:uniform-matrix-3fv #:uniform-matrix-4fv #:validate-program
#:vertex-attrib-1d #:vertex-attrib-1dv #:vertex-attrib-1f
#:vertex-attrib-1fv #:vertex-attrib-1s #:vertex-attrib-1sv
#:vertex-attrib-2d #:vertex-attrib-2dv #:vertex-attrib-2f
#:vertex-attrib-2fv #:vertex-attrib-2s #:vertex-attrib-2sv
#:vertex-attrib-3d #:vertex-attrib-3dv #:vertex-attrib-3f
#:vertex-attrib-3fv #:vertex-attrib-3s #:vertex-attrib-3sv
#:vertex-attrib-4nbv #:vertex-attrib-4niv #:vertex-attrib-4nsv
#:vertex-attrib-4nub #:vertex-attrib-4nubv #:vertex-attrib-4nuiv
#:vertex-attrib-4nusv #:vertex-attrib-4bv #:vertex-attrib-4d
#:vertex-attrib-4dv #:vertex-attrib-4f #:vertex-attrib-4fv
#:vertex-attrib-4iv #:vertex-attrib-4s #:vertex-attrib-4sv
#:vertex-attrib-4ubv #:vertex-attrib-4uiv #:vertex-attrib-4usv
#:vertex-attrib-pointer #:uniform-matrix-2x3-fv
#:uniform-matrix-3x2-fv #:uniform-matrix-2x4-fv
#:uniform-matrix-4x2-fv #:uniform-matrix-3x4-fv
#:uniform-matrix-4x3-fv #:color-mask-i #:get-boolean-i-v
#:get-integer-i-v #:enable-i #:disable-i #:is-enabled-i
#:begin-transform-feedback #:end-transform-feedback
#:bind-buffer-range #:bind-buffer-base
#:transform-feedback-varyings #:get-transform-feedback-varying
#:clamp-color #:begin-conditional-render #:end-conditional-render
#:vertex-attrib-ipointer #:get-vertex-attrib-iiv
#:get-vertex-attrib-iuiv #:vertex-attrib-i1i #:vertex-attrib-i2i
#:vertex-attrib-i3i #:vertex-attrib-i4i #:vertex-attrib-i1ui
#:vertex-attrib-i2ui #:vertex-attrib-i3ui #:vertex-attrib-i4ui
#:vertex-attrib-i1iv #:vertex-attrib-i2iv #:vertex-attrib-i3iv
#:vertex-attrib-i4iv #:vertex-attrib-i1uiv #:vertex-attrib-i2uiv
#:vertex-attrib-i3uiv #:vertex-attrib-i4uiv #:vertex-attrib-i4bv
#:vertex-attrib-i4sv #:vertex-attrib-i4ubv #:vertex-attrib-i4usv
#:get-uniform-uiv #:bind-frag-data-location
#:get-frag-data-location #:uniform-1ui #:uniform-2ui #:uniform-3ui
#:uniform-4ui #:uniform-1uiv #:uniform-2uiv #:uniform-3uiv
#:uniform-4uiv #:tex-parameter-iiv #:tex-parameter-iuiv
#:get-tex-parameter-iiv #:get-tex-parameter-iuiv #:clear-buffer-iv
#:clear-buffer-uiv #:clear-buffer-fv #:clear-buffer-fi
#:get-string-i #:is-renderbuffer #:bind-renderbuffer
#:delete-renderbuffers #:gen-renderbuffers #:renderbuffer-storage
#:get-renderbuffer-parameter-iv #:is-framebuffer
#:bind-framebuffer #:delete-framebuffers #:gen-framebuffers
#:check-framebuffer-status #:framebuffer-texture-1d
#:framebuffer-texture-2d #:framebuffer-texture-3d
#:framebuffer-renderbuffer
#:get-framebuffer-attachment-parameter-iv #:generate-mipmap
#:blit-framebuffer #:renderbuffer-storage-multisample
#:framebuffer-texture-layer #:map-buffer-range
#:flush-mapped-buffer-range #:bind-vertex-array
#:delete-vertex-arrays #:gen-vertex-arrays #:is-vertex-array
#:draw-arrays-instanced #:draw-elements-instanced #:tex-buffer
#:primitive-restart-index #:copy-buffer-sub-data
#:get-uniform-indices #:get-active-uniforms-iv
#:get-active-uniform-name #:get-uniform-block-index
#:get-active-uniform-block-iv #:get-active-uniform-block-name
#:uniform-block-binding #:draw-elements-base-vertex
#:draw-range-elements-base-vertex
#:draw-elements-instanced-base-vertex
#:multi-draw-elements-base-vertex #:provoking-vertex #:fence-sync
#:is-sync #:delete-sync #:client-wait-sync #:wait-sync
#:get-integer-64-v #:get-sync-iv #:get-integer-64-i-v
#:get-buffer-parameter-i64v #:framebuffer-texture
#:tex-image-2d-multisample #:tex-image-3d-multisample
#:get-multisample-fv #:sample-mask-i
#:bind-frag-data-location-indexed #:get-frag-data-index
#:gen-samplers #:delete-samplers #:is-sampler #:bind-sampler
#:sampler-parameter-i #:sampler-parameter-iv #:sampler-parameter-f
#:sampler-parameter-fv #:sampler-parameter-iiv
#:sampler-parameter-iuiv #:get-sampler-parameter-iv
#:get-sampler-parameter-iiv #:get-sampler-parameter-fv
#:get-sampler-parameter-iuiv #:query-counter
#:get-query-object-i64v #:get-query-object-ui64v
#:vertex-attrib-divisor #:vertex-attrib-p1ui #:vertex-attrib-p1uiv
#:vertex-attrib-p2ui #:vertex-attrib-p2uiv #:vertex-attrib-p3ui
#:vertex-attrib-p3uiv #:vertex-attrib-p4ui #:vertex-attrib-p4uiv
#:vertex-p2ui #:vertex-p2uiv #:vertex-p3ui #:vertex-p3uiv
#:vertex-p4ui #:vertex-p4uiv #:tex-coord-p1ui #:tex-coord-p1uiv
#:tex-coord-p2ui #:tex-coord-p2uiv #:tex-coord-p3ui
#:tex-coord-p3uiv #:tex-coord-p4ui #:tex-coord-p4uiv
#:multi-tex-coord-p1ui #:multi-tex-coord-p1uiv
#:multi-tex-coord-p2ui #:multi-tex-coord-p2uiv
#:multi-tex-coord-p3ui #:multi-tex-coord-p3uiv
#:multi-tex-coord-p4ui #:multi-tex-coord-p4uiv #:normal-p3ui
#:normal-p3uiv #:color-p3ui #:color-p3uiv #:color-p4ui
#:color-p4uiv #:secondary-color-p3ui #:secondary-color-p3uiv
#:min-sample-shading #:blend-equation-i
#:blend-equation-separate-i #:blend-func-i #:blend-func-separate-i
#:draw-arrays-indirect #:draw-elements-indirect #:uniform-1d
#:uniform-2d #:uniform-3d #:uniform-4d #:uniform-1dv #:uniform-2dv
#:uniform-3dv #:uniform-4dv #:uniform-matrix-2dv
#:uniform-matrix-3dv #:uniform-matrix-4dv #:uniform-matrix-2x3-dv
#:uniform-matrix-2x4-dv #:uniform-matrix-3x2-dv
#:uniform-matrix-3x4-dv #:uniform-matrix-4x2-dv
#:uniform-matrix-4x3-dv #:get-uniform-dv
#:get-subroutine-uniform-location #:get-subroutine-index
#:get-active-subroutine-uniform-iv
#:get-active-subroutine-uniform-name #:get-active-subroutine-name
#:uniform-subroutines-uiv #:get-uniform-subroutine-uiv
#:get-program-stage-iv #:patch-parameter-i #:patch-parameter-fv
#:bind-transform-feedback #:delete-transform-feedbacks
#:gen-transform-feedbacks #:is-transform-feedback
#:pause-transform-feedback #:resume-transform-feedback
#:draw-transform-feedback #:draw-transform-feedback-stream
#:begin-query-indexed #:end-query-indexed #:get-query-indexed-iv
#:release-shader-compiler #:shader-binary
#:get-shader-precision-format #:depth-range-f #:clear-depth-f
#:get-program-binary #:program-binary #:program-parameter-i
#:use-program-stages #:active-shader-program
#:create-shader-program-v #:bind-program-pipeline
#:delete-program-pipelines #:gen-program-pipelines
#:is-program-pipeline #:get-program-pipeline-iv
#:program-uniform-1i #:program-uniform-1iv #:program-uniform-1f
#:program-uniform-1fv #:program-uniform-1d #:program-uniform-1dv
#:program-uniform-1ui #:program-uniform-1uiv #:program-uniform-2i
#:program-uniform-2iv #:program-uniform-2f #:program-uniform-2fv
#:program-uniform-2d #:program-uniform-2dv #:program-uniform-2ui
#:program-uniform-2uiv #:program-uniform-3i #:program-uniform-3iv
#:program-uniform-3f #:program-uniform-3fv #:program-uniform-3d
#:program-uniform-3dv #:program-uniform-3ui #:program-uniform-3uiv
#:program-uniform-4i #:program-uniform-4iv #:program-uniform-4f
#:program-uniform-4fv #:program-uniform-4d #:program-uniform-4dv
#:program-uniform-4ui #:program-uniform-4uiv
#:program-uniform-matrix-2fv #:program-uniform-matrix-3fv
#:program-uniform-matrix-4fv #:program-uniform-matrix-2dv
#:program-uniform-matrix-3dv #:program-uniform-matrix-4dv
#:program-uniform-matrix-2x3-fv #:program-uniform-matrix-3x2-fv
#:program-uniform-matrix-2x4-fv #:program-uniform-matrix-4x2-fv
#:program-uniform-matrix-3x4-fv #:program-uniform-matrix-4x3-fv
#:program-uniform-matrix-2x3-dv #:program-uniform-matrix-3x2-dv
#:program-uniform-matrix-2x4-dv #:program-uniform-matrix-4x2-dv
#:program-uniform-matrix-3x4-dv #:program-uniform-matrix-4x3-dv
#:validate-program-pipeline #:get-program-pipeline-info-log
#:vertex-attrib-l1d #:vertex-attrib-l2d #:vertex-attrib-l3d
#:vertex-attrib-l4d #:vertex-attrib-l1dv #:vertex-attrib-l2dv
#:vertex-attrib-l3dv #:vertex-attrib-l4dv #:vertex-attrib-lpointer
#:get-vertex-attrib-ldv #:viewport-array-v #:viewport-indexed-f
#:viewport-indexed-fv #:scissor-array-v #:scissor-indexed
#:scissor-indexed-v #:depth-range-array-v #:depth-range-indexed
#:get-float-i-v #:get-double-i-v
#:draw-arrays-instanced-base-instance
#:draw-elements-instanced-base-instance
#:draw-elements-instanced-base-vertex-base-instance
#:get-internal-format-iv #:get-active-atomic-counter-buffer-iv
#:bind-image-texture #:memory-barrier #:tex-storage-1d
#:tex-storage-2d #:tex-storage-3d
#:draw-transform-feedback-instanced
#:draw-transform-feedback-stream-instanced #:clear-buffer-data
#:clear-buffer-sub-data #:dispatch-compute
#:dispatch-compute-indirect #:copy-image-sub-data
#:framebuffer-parameter-i #:get-framebuffer-parameter-iv
#:get-internalformat-i64v #:invalidate-tex-sub-image
#:invalidate-tex-image #:invalidate-buffer-sub-data
#:invalidate-buffer-data #:invalidate-framebuffer
#:invalidate-sub-framebuffer #:multi-draw-arrays-indirect
#:multi-draw-elements-indirect #:get-program-interface-iv
#:get-program-resource-index #:get-program-resource-name
#:get-program-resource-iv #:get-program-resource-location
#:get-program-resource-location-index
#:shader-storage-block-binding #:tex-buffer-range
#:tex-storage-2d-multisample #:tex-storage-3d-multisample
#:texture-view #:bind-vertex-buffer #:vertex-attrib-format
#:vertex-attrib-i-format #:vertex-attrib-l-format
#:vertex-attrib-binding #:vertex-binding-divisor
#:debug-message-control #:debug-message-insert
#:debug-message-callback #:get-debug-message-log
#:push-debug-group #:pop-debug-group #:object-label
#:get-object-label #:object-ptr-label #:get-object-ptr-label
#:buffer-storage #:clear-tex-image #:clear-tex-sub-image
#:bind-buffers-base #:bind-buffers-range #:bind-textures
#:bind-samplers #:bind-image-textures #:bind-vertex-buffers
#:clip-control #:create-transform-feedbacks
#:transform-feedback-buffer-base #:transform-feedback-buffer-range
#:get-transform-feedback-iv #:get-transform-feedback-i-v
#:get-transform-feedback-i64-v #:create-buffers
#:named-buffer-storage #:named-buffer-data #:named-buffer-sub-data
#:copy-named-buffer-sub-data #:clear-named-buffer-data
#:clear-named-buffer-sub-data #:map-named-buffer
#:map-named-buffer-range #:unmap-named-buffer
#:flush-mapped-named-buffer-range #:get-named-buffer-parameter-iv
#:get-named-buffer-parameter-i64v #:get-named-buffer-pointer-v
#:get-named-buffer-sub-data #:create-framebuffers
#:named-framebuffer-renderbuffer #:named-framebuffer-parameter-i
#:named-framebuffer-texture #:named-framebuffer-texture-layer
#:named-framebuffer-draw-buffer #:named-framebuffer-draw-buffers
#:named-framebuffer-read-buffer
#:invalidate-named-framebuffer-data
#:invalidate-named-framebuffer-sub-data
#:clear-named-framebuffer-iv #:clear-named-framebuffer-uiv
#:clear-named-framebuffer-fv #:clear-named-framebuffer-fi
#:blit-named-framebuffer #:check-named-framebuffer-status
#:get-named-framebuffer-parameter-iv
#:get-named-framebuffer-attachment-parameter-iv
#:create-renderbuffers #:named-renderbuffer-storage
#:named-renderbuffer-storage-multisample
#:get-named-renderbuffer-parameter-iv #:create-textures
#:texture-buffer #:texture-buffer-range #:texture-storage-1d
#:texture-storage-2d #:texture-storage-3d
#:texture-storage-2d-multisample #:texture-storage-3d-multisample
#:texture-sub-image-1d #:texture-sub-image-2d
#:texture-sub-image-3d #:compressed-texture-sub-image-1d
#:compressed-texture-sub-image-2d
#:compressed-texture-sub-image-3d #:copy-texture-sub-image-1d
#:copy-texture-sub-image-2d #:copy-texture-sub-image-3d
#:texture-parameter-f #:texture-parameter-fv #:texture-parameter-i
#:texture-parameter-iiv #:texture-parameter-iuiv
#:texture-parameter-iv #:generate-texture-mipmap
#:bind-texture-unit #:get-texture-image
#:get-compressed-texture-image #:get-texture-level-parameter-fv
#:get-texture-level-parameter-iv #:get-texture-parameter-fv
#:get-texture-parameter-iiv #:get-texture-parameter-iuiv
#:get-texture-parameter-iv #:create-vertex-arrays
#:disable-vertex-array-attrib #:enable-vertex-array-attrib
#:vertex-array-element-buffer #:vertex-array-vertex-buffer
#:vertex-array-vertex-buffers #:vertex-array-attrib-binding
#:vertex-array-attrib-format #:vertex-array-attrib-i-format
#:vertex-array-attrib-l-format #:vertex-array-binding-divisor
#:get-vertex-array-iv #:get-vertex-array-indexed-iv
#:get-vertex-array-indexed-64iv #:create-samplers
#:create-program-pipelines #:create-queries
#:get-query-buffer-object-i64v #:get-query-buffer-object-iv
#:get-query-buffer-object-ui64v #:get-query-buffer-object-uiv
#:memory-barrier-by-region #:get-texture-sub-image
#:get-compressed-texture-sub-image #:get-graphics-reset-status
#:getn-compressed-tex-image #:getn-tex-image #:getn-uniform-dv
#:getn-uniform-fv #:getn-uniform-iv #:getn-uniform-uiv
#:readn-pixels #:getn-map-dv #:getn-map-fv #:getn-map-iv
#:getn-pixel-map-fv #:getn-pixel-map-uiv #:getn-pixel-map-usv
#:getn-polygon-stipple #:getn-color-table
#:getn-convolution-filter #:getn-separable-filter #:getn-histogram
#:getn-minmax #:texture-barrier #:clip-plane-f #:frustum-f
#:get-clip-plane-f #:ortho-f #:alpha-func-x #:clear-color-x
#:clear-depth-x #:clip-plane-x #:color-4x #:depth-range-x #:fog-x
#:fog-xv #:frustum-x #:get-clip-plane-x #:get-fixed-v
#:get-light-xv #:get-material-xv #:get-tex-env-xv
#:get-tex-parameter-xv #:light-model-x #:light-model-xv #:light-x
#:light-xv #:line-width-x #:load-matrix-x #:material-x
#:material-xv #:mult-matrix-x #:multi-tex-coord-4x #:normal-3x
#:ortho-x #:point-parameter-x #:point-parameter-xv #:point-size-x
#:polygon-offset-x #:rotate-x #:sample-coverage-x #:scale-x
#:tex-env-x #:tex-env-xv #:tex-parameter-x #:tex-parameter-xv
#:translate-x #:blend-barrier #:primitive-bounding-box
#:tbuffer-mask-3dfx #:debug-message-enable-amd
#:debug-message-insert-amd #:debug-message-callback-amd
#:get-debug-message-log-amd #:blend-func-indexed-amd
#:blend-func-separate-indexed-amd #:blend-equation-indexed-amd
#:blend-equation-separate-indexed-amd #:uniform-1i64-nv
#:uniform-2i64-nv #:uniform-3i64-nv #:uniform-4i64-nv
#:uniform-1i64v-nv #:uniform-2i64v-nv #:uniform-3i64v-nv
#:uniform-4i64v-nv #:uniform-1ui64-nv #:uniform-2ui64-nv
#:uniform-3ui64-nv #:uniform-4ui64-nv #:uniform-1ui64v-nv
#:uniform-2ui64v-nv #:uniform-3ui64v-nv #:uniform-4ui64v-nv
#:get-uniform-i64v-nv #:get-uniform-ui64v-nv
#:program-uniform-1i64-nv #:program-uniform-2i64-nv
#:program-uniform-3i64-nv #:program-uniform-4i64-nv
#:program-uniform-1i64v-nv #:program-uniform-2i64v-nv
#:program-uniform-3i64v-nv #:program-uniform-4i64v-nv
#:program-uniform-1ui64-nv #:program-uniform-2ui64-nv
#:program-uniform-3ui64-nv #:program-uniform-4ui64-nv
#:program-uniform-1ui64v-nv #:program-uniform-2ui64v-nv
#:program-uniform-3ui64v-nv #:program-uniform-4ui64v-nv
#:vertex-attrib-parameter-i-amd #:multi-draw-arrays-indirect-amd
#:multi-draw-elements-indirect-amd #:gen-names-amd
#:delete-names-amd #:is-name-amd #:query-object-parameter-ui-amd
#:get-perf-monitor-groups-amd #:get-perf-monitor-counters-amd
#:get-perf-monitor-group-string-amd
#:get-perf-monitor-counter-string-amd
#:get-perf-monitor-counter-info-amd #:gen-perf-monitors-amd
#:delete-perf-monitors-amd #:select-perf-monitor-counters-amd
#:begin-perf-monitor-amd #:end-perf-monitor-amd
#:get-perf-monitor-counter-data-amd #:set-multisample-fv-amd
#:tex-storage-sparse-amd #:texture-storage-sparse-amd
#:stencil-op-value-amd #:tessellation-factor-amd
#:tessellation-mode-amd #:blit-framebuffer-angle
#:renderbuffer-storage-multisample-angle
#:draw-arrays-instanced-angle #:draw-elements-instanced-angle
#:vertex-attrib-divisor-angle #:get-translated-shader-source-angle
#:copy-texture-levels-apple #:element-pointer-apple
#:draw-element-array-apple #:draw-range-element-array-apple
#:multi-draw-element-array-apple
#:multi-draw-range-element-array-apple #:gen-fences-apple
#:delete-fences-apple #:set-fence-apple #:is-fence-apple
#:test-fence-apple #:finish-fence-apple #:test-object-apple
#:finish-object-apple #:buffer-parameter-i-apple
#:flush-mapped-buffer-range-apple
#:renderbuffer-storage-multisample-apple
#:resolve-multisample-framebuffer-apple #:object-purgeable-apple
#:object-unpurgeable-apple #:get-object-parameter-iv-apple
#:fence-sync-apple #:is-sync-apple #:delete-sync-apple
#:client-wait-sync-apple #:wait-sync-apple
#:get-integer-64-v-apple #:get-sync-iv-apple #:texture-range-apple
#:get-tex-parameter-pointer-v-apple #:bind-vertex-array-apple
#:delete-vertex-arrays-apple #:gen-vertex-arrays-apple
#:is-vertex-array-apple #:vertex-array-range-apple
#:flush-vertex-array-range-apple #:vertex-array-parameter-i-apple
#:enable-vertex-attrib-apple #:disable-vertex-attrib-apple
#:is-vertex-attrib-enabled-apple #:map-vertex-attrib-1d-apple
#:map-vertex-attrib-1f-apple #:map-vertex-attrib-2d-apple
#:map-vertex-attrib-2f-apple #:primitive-bounding-box-arb
#:get-texture-handle-arb #:get-texture-sampler-handle-arb
#:make-texture-handle-resident-arb
#:make-texture-handle-non-resident-arb #:get-image-handle-arb
#:make-image-handle-resident-arb
#:make-image-handle-non-resident-arb #:uniform-handle-ui64-arb
#:uniform-handle-ui64v-arb #:program-uniform-handle-ui64-arb
#:program-uniform-handle-ui64v-arb
#:is-texture-handle-resident-arb #:is-image-handle-resident-arb
#:vertex-attrib-l1ui64-arb #:vertex-attrib-l1ui64v-arb
#:get-vertex-attrib-lui64v-arb #:create-sync-from-cl-event-arb
#:clamp-color-arb #:dispatch-compute-group-size-arb
#:debug-message-control-arb #:debug-message-insert-arb
#:debug-message-callback-arb #:get-debug-message-log-arb
#:draw-buffers-arb #:blend-equation-i-arb
#:blend-equation-separate-i-arb #:blend-func-i-arb
#:blend-func-separate-i-arb #:draw-arrays-instanced-arb
#:draw-elements-instanced-arb #:program-string-arb
#:bind-program-arb #:delete-programs-arb #:gen-programs-arb
#:program-env-parameter-4d-arb #:program-env-parameter-4dv-arb
#:program-env-parameter-4f-arb #:program-env-parameter-4fv-arb
#:program-local-parameter-4d-arb #:program-local-parameter-4dv-arb
#:program-local-parameter-4f-arb #:program-local-parameter-4fv-arb
#:get-program-env-parameter-dv-arb
#:get-program-env-parameter-fv-arb
#:get-program-local-parameter-dv-arb
#:get-program-local-parameter-fv-arb #:get-program-iv-arb
#:get-program-string-arb #:is-program-arb
#:program-parameter-i-arb #:framebuffer-texture-arb
#:framebuffer-texture-layer-arb #:framebuffer-texture-face-arb
#:uniform-1i64-arb #:uniform-2i64-arb #:uniform-3i64-arb
#:uniform-4i64-arb #:uniform-1i64v-arb #:uniform-2i64v-arb
#:uniform-3i64v-arb #:uniform-4i64v-arb #:uniform-1ui64-arb
#:uniform-2ui64-arb #:uniform-3ui64-arb #:uniform-4ui64-arb
#:uniform-1ui64v-arb #:uniform-2ui64v-arb #:uniform-3ui64v-arb
#:uniform-4ui64v-arb #:get-uniform-i64v-arb
#:get-uniform-ui64v-arb #:getn-uniform-i64v-arb
#:getn-uniform-ui64v-arb #:program-uniform-1i64-arb
#:program-uniform-2i64-arb #:program-uniform-3i64-arb
#:program-uniform-4i64-arb #:program-uniform-1i64v-arb
#:program-uniform-2i64v-arb #:program-uniform-3i64v-arb
#:program-uniform-4i64v-arb #:program-uniform-1ui64-arb
#:program-uniform-2ui64-arb #:program-uniform-3ui64-arb
#:program-uniform-4ui64-arb #:program-uniform-1ui64v-arb
#:program-uniform-2ui64v-arb #:program-uniform-3ui64v-arb
#:program-uniform-4ui64v-arb #:color-table
#:color-table-parameter-fv #:color-table-parameter-iv
#:copy-color-table #:get-color-table
#:get-color-table-parameter-fv #:get-color-table-parameter-iv
#:color-sub-table #:copy-color-sub-table #:convolution-filter-1d
#:convolution-filter-2d #:convolution-parameter-f
#:convolution-parameter-fv #:convolution-parameter-i
#:convolution-parameter-iv #:copy-convolution-filter-1d
#:copy-convolution-filter-2d #:get-convolution-filter
#:get-convolution-parameter-fv #:get-convolution-parameter-iv
#:get-separable-filter #:separable-filter-2d #:get-histogram
#:get-histogram-parameter-fv #:get-histogram-parameter-iv
#:get-minmax #:get-minmax-parameter-fv #:get-minmax-parameter-iv
#:histogram #:minmax #:reset-histogram #:reset-minmax
#:multi-draw-arrays-indirect-count-arb
#:multi-draw-elements-indirect-count-arb
#:vertex-attrib-divisor-arb #:current-palette-matrix-arb
#:matrix-index-ubv-arb #:matrix-index-usv-arb
#:matrix-index-uiv-arb #:matrix-index-pointer-arb
#:sample-coverage-arb #:active-texture-arb
#:client-active-texture-arb #:multi-tex-coord-1d-arb
#:multi-tex-coord-1dv-arb #:multi-tex-coord-1f-arb
#:multi-tex-coord-1fv-arb #:multi-tex-coord-1i-arb
#:multi-tex-coord-1iv-arb #:multi-tex-coord-1s-arb
#:multi-tex-coord-1sv-arb #:multi-tex-coord-2d-arb
#:multi-tex-coord-2dv-arb #:multi-tex-coord-2f-arb
#:multi-tex-coord-2fv-arb #:multi-tex-coord-2i-arb
#:multi-tex-coord-2iv-arb #:multi-tex-coord-2s-arb
#:multi-tex-coord-2sv-arb #:multi-tex-coord-3d-arb
#:multi-tex-coord-3dv-arb #:multi-tex-coord-3f-arb
#:multi-tex-coord-3fv-arb #:multi-tex-coord-3i-arb
#:multi-tex-coord-3iv-arb #:multi-tex-coord-3s-arb
#:multi-tex-coord-3sv-arb #:multi-tex-coord-4d-arb
#:multi-tex-coord-4dv-arb #:multi-tex-coord-4f-arb
#:multi-tex-coord-4fv-arb #:multi-tex-coord-4i-arb
#:multi-tex-coord-4iv-arb #:multi-tex-coord-4s-arb
#:multi-tex-coord-4sv-arb #:gen-queries-arb #:delete-queries-arb
#:is-query-arb #:begin-query-arb #:end-query-arb
#:get-query-iv-arb #:get-query-object-iv-arb
#:get-query-object-uiv-arb #:max-shader-compiler-threads-arb
#:point-parameter-f-arb #:point-parameter-fv-arb
#:get-graphics-reset-status-arb #:getn-tex-image-arb
#:readn-pixels-arb #:getn-compressed-tex-image-arb
#:getn-uniform-fv-arb #:getn-uniform-iv-arb #:getn-uniform-uiv-arb
#:getn-uniform-dv-arb #:getn-map-dv-arb #:getn-map-fv-arb
#:getn-map-iv-arb #:getn-pixel-map-fv-arb #:getn-pixel-map-uiv-arb
#:getn-pixel-map-usv-arb #:getn-polygon-stipple-arb
#:getn-color-table-arb #:getn-convolution-filter-arb
#:getn-separable-filter-arb #:getn-histogram-arb #:getn-minmax-arb
#:framebuffer-sample-locations-fv-arb
#:named-framebuffer-sample-locations-fv-arb
#:evaluate-depth-values-arb #:min-sample-shading-arb
#:delete-object-arb #:get-handle-arb #:detach-object-arb
#:create-shader-object-arb #:shader-source-arb
#:compile-shader-arb #:create-program-object-arb
#:attach-object-arb #:link-program-arb #:use-program-object-arb
#:validate-program-arb #:uniform-1f-arb #:uniform-2f-arb
#:uniform-3f-arb #:uniform-4f-arb #:uniform-1i-arb
#:uniform-2i-arb #:uniform-3i-arb #:uniform-4i-arb
#:uniform-1fv-arb #:uniform-2fv-arb #:uniform-3fv-arb
#:uniform-4fv-arb #:uniform-1iv-arb #:uniform-2iv-arb
#:uniform-3iv-arb #:uniform-4iv-arb #:uniform-matrix-2fv-arb
#:uniform-matrix-3fv-arb #:uniform-matrix-4fv-arb
#:get-object-parameter-fv-arb #:get-object-parameter-iv-arb
#:get-info-log-arb #:get-attached-objects-arb
#:get-uniform-location-arb #:get-active-uniform-arb
#:get-uniform-fv-arb #:get-uniform-iv-arb #:get-shader-source-arb
#:named-string-arb #:delete-named-string-arb
#:compile-shader-include-arb #:is-named-string-arb
#:get-named-string-arb #:get-named-string-iv-arb
#:buffer-page-commitment-arb #:named-buffer-page-commitment-ext
#:named-buffer-page-commitment-arb #:tex-page-commitment-arb
#:tex-buffer-arb #:compressed-tex-image-3d-arb
#:compressed-tex-image-2d-arb #:compressed-tex-image-1d-arb
#:compressed-tex-sub-image-3d-arb
#:compressed-tex-sub-image-2d-arb
#:compressed-tex-sub-image-1d-arb #:get-compressed-tex-image-arb
#:load-transpose-matrix-f-arb #:load-transpose-matrix-d-arb
#:mult-transpose-matrix-f-arb #:mult-transpose-matrix-d-arb
#:weight-bv-arb #:weight-sv-arb #:weight-iv-arb #:weight-fv-arb
#:weight-dv-arb #:weight-ubv-arb #:weight-usv-arb #:weight-uiv-arb
#:weight-pointer-arb #:vertex-blend-arb #:bind-buffer-arb
#:delete-buffers-arb #:gen-buffers-arb #:is-buffer-arb
#:buffer-data-arb #:buffer-sub-data-arb #:get-buffer-sub-data-arb
#:map-buffer-arb #:unmap-buffer-arb #:get-buffer-parameter-iv-arb
#:get-buffer-pointer-v-arb #:vertex-attrib-1d-arb
#:vertex-attrib-1dv-arb #:vertex-attrib-1f-arb
#:vertex-attrib-1fv-arb #:vertex-attrib-1s-arb
#:vertex-attrib-1sv-arb #:vertex-attrib-2d-arb
#:vertex-attrib-2dv-arb #:vertex-attrib-2f-arb
#:vertex-attrib-2fv-arb #:vertex-attrib-2s-arb
#:vertex-attrib-2sv-arb #:vertex-attrib-3d-arb
#:vertex-attrib-3dv-arb #:vertex-attrib-3f-arb
#:vertex-attrib-3fv-arb #:vertex-attrib-3s-arb
#:vertex-attrib-3sv-arb #:vertex-attrib-4nbv-arb
#:vertex-attrib-4niv-arb #:vertex-attrib-4nsv-arb
#:vertex-attrib-4nub-arb #:vertex-attrib-4nubv-arb
#:vertex-attrib-4nuiv-arb #:vertex-attrib-4nusv-arb
#:vertex-attrib-4bv-arb #:vertex-attrib-4d-arb
#:vertex-attrib-4dv-arb #:vertex-attrib-4f-arb
#:vertex-attrib-4fv-arb #:vertex-attrib-4iv-arb
#:vertex-attrib-4s-arb #:vertex-attrib-4sv-arb
#:vertex-attrib-4ubv-arb #:vertex-attrib-4uiv-arb
#:vertex-attrib-4usv-arb #:vertex-attrib-pointer-arb
#:enable-vertex-attrib-array-arb #:disable-vertex-attrib-array-arb
#:get-vertex-attrib-dv-arb #:get-vertex-attrib-fv-arb
#:get-vertex-attrib-iv-arb #:get-vertex-attrib-pointer-v-arb
#:bind-attrib-location-arb #:get-active-attrib-arb
#:get-attrib-location-arb #:window-pos-2d-arb #:window-pos-2dv-arb
#:window-pos-2f-arb #:window-pos-2fv-arb #:window-pos-2i-arb
#:window-pos-2iv-arb #:window-pos-2s-arb #:window-pos-2sv-arb
#:window-pos-3d-arb #:window-pos-3dv-arb #:window-pos-3f-arb
#:window-pos-3fv-arb #:window-pos-3i-arb #:window-pos-3iv-arb
#:window-pos-3s-arb #:window-pos-3sv-arb #:draw-buffers-ati
#:element-pointer-ati #:draw-element-array-ati
#:draw-range-element-array-ati #:tex-bump-parameter-iv-ati
#:tex-bump-parameter-fv-ati #:get-tex-bump-parameter-iv-ati
#:get-tex-bump-parameter-fv-ati #:gen-fragment-shaders-ati
#:bind-fragment-shader-ati #:delete-fragment-shader-ati
#:begin-fragment-shader-ati #:end-fragment-shader-ati
#:pass-tex-coord-ati #:sample-map-ati #:color-fragment-op-1-ati
#:color-fragment-op-2-ati #:color-fragment-op-3-ati
#:alpha-fragment-op-1-ati #:alpha-fragment-op-2-ati
#:alpha-fragment-op-3-ati #:set-fragment-shader-constant-ati
#:map-object-buffer-ati #:unmap-object-buffer-ati
#:pntriangles-i-ati #:pntriangles-f-ati #:stencil-op-separate-ati
#:stencil-func-separate-ati #:new-object-buffer-ati
#:is-object-buffer-ati #:update-object-buffer-ati
#:get-object-buffer-fv-ati #:get-object-buffer-iv-ati
#:free-object-buffer-ati #:array-object-ati
#:get-array-object-fv-ati #:get-array-object-iv-ati
#:variant-array-object-ati #:get-variant-array-object-fv-ati
#:get-variant-array-object-iv-ati #:vertex-attrib-array-object-ati
#:get-vertex-attrib-array-object-fv-ati
#:get-vertex-attrib-array-object-iv-ati #:vertex-stream-1s-ati
#:vertex-stream-1sv-ati #:vertex-stream-1i-ati
#:vertex-stream-1iv-ati #:vertex-stream-1f-ati
#:vertex-stream-1fv-ati #:vertex-stream-1d-ati
#:vertex-stream-1dv-ati #:vertex-stream-2s-ati
#:vertex-stream-2sv-ati #:vertex-stream-2i-ati
#:vertex-stream-2iv-ati #:vertex-stream-2f-ati
#:vertex-stream-2fv-ati #:vertex-stream-2d-ati
#:vertex-stream-2dv-ati #:vertex-stream-3s-ati
#:vertex-stream-3sv-ati #:vertex-stream-3i-ati
#:vertex-stream-3iv-ati #:vertex-stream-3f-ati
#:vertex-stream-3fv-ati #:vertex-stream-3d-ati
#:vertex-stream-3dv-ati #:vertex-stream-4s-ati
#:vertex-stream-4sv-ati #:vertex-stream-4i-ati
#:vertex-stream-4iv-ati #:vertex-stream-4f-ati
#:vertex-stream-4fv-ati #:vertex-stream-4d-ati
#:vertex-stream-4dv-ati #:normal-stream-3b-ati
#:normal-stream-3bv-ati #:normal-stream-3s-ati
#:normal-stream-3sv-ati #:normal-stream-3i-ati
#:normal-stream-3iv-ati #:normal-stream-3f-ati
#:normal-stream-3fv-ati #:normal-stream-3d-ati
#:normal-stream-3dv-ati #:client-active-vertex-stream-ati
#:vertex-blend-env-i-ati #:vertex-blend-env-f-ati
#:draw-arrays-instanced-base-instance-ext
#:draw-elements-instanced-base-instance-ext
#:draw-elements-instanced-base-vertex-base-instance-ext
#:uniform-buffer-ext #:get-uniform-buffer-size-ext
#:get-uniform-offset-ext #:blend-color-ext
#:blend-equation-separate-ext #:blend-func-separate-ext
#:blend-equation-ext #:buffer-storage-ext #:color-sub-table-ext
#:copy-color-sub-table-ext #:lock-arrays-ext #:unlock-arrays-ext
#:convolution-filter-1d-ext #:convolution-filter-2d-ext
#:convolution-parameter-f-ext #:convolution-parameter-fv-ext
#:convolution-parameter-i-ext #:convolution-parameter-iv-ext
#:copy-convolution-filter-1d-ext #:copy-convolution-filter-2d-ext
#:get-convolution-filter-ext #:get-convolution-parameter-fv-ext
#:get-convolution-parameter-iv-ext #:get-separable-filter-ext
#:separable-filter-2d-ext #:tangent-3b-ext #:tangent-3bv-ext
#:tangent-3d-ext #:tangent-3dv-ext #:tangent-3f-ext
#:tangent-3fv-ext #:tangent-3i-ext #:tangent-3iv-ext
#:tangent-3s-ext #:tangent-3sv-ext #:binormal-3b-ext
#:binormal-3bv-ext #:binormal-3d-ext #:binormal-3dv-ext
#:binormal-3f-ext #:binormal-3fv-ext #:binormal-3i-ext
#:binormal-3iv-ext #:binormal-3s-ext #:binormal-3sv-ext
#:tangent-pointer-ext #:binormal-pointer-ext
#:copy-image-sub-data-ext #:copy-tex-image-1d-ext
#:copy-tex-image-2d-ext #:copy-tex-sub-image-1d-ext
#:copy-tex-sub-image-2d-ext #:copy-tex-sub-image-3d-ext
#:cull-parameter-dv-ext #:cull-parameter-fv-ext #:label-object-ext
#:get-object-label-ext #:insert-event-marker-ext
#:push-group-marker-ext #:pop-group-marker-ext #:depth-bounds-ext
#:matrix-load-f-ext #:matrix-load-d-ext #:matrix-mult-f-ext
#:matrix-mult-d-ext #:matrix-load-identity-ext
#:matrix-rotate-f-ext #:matrix-rotate-d-ext #:matrix-scale-f-ext
#:matrix-scale-d-ext #:matrix-translate-f-ext
#:matrix-translate-d-ext #:matrix-frustum-ext #:matrix-ortho-ext
#:matrix-pop-ext #:matrix-push-ext #:client-attrib-default-ext
#:push-client-attrib-default-ext #:texture-parameter-f-ext
#:texture-parameter-fv-ext #:texture-parameter-i-ext
#:texture-parameter-iv-ext #:texture-image-1d-ext
#:texture-image-2d-ext #:texture-sub-image-1d-ext
#:texture-sub-image-2d-ext #:copy-texture-image-1d-ext
#:copy-texture-image-2d-ext #:copy-texture-sub-image-1d-ext
#:copy-texture-sub-image-2d-ext #:get-texture-image-ext
#:get-texture-parameter-fv-ext #:get-texture-parameter-iv-ext
#:get-texture-level-parameter-fv-ext
#:get-texture-level-parameter-iv-ext #:texture-image-3d-ext
#:texture-sub-image-3d-ext #:copy-texture-sub-image-3d-ext
#:bind-multi-texture-ext #:multi-tex-coord-pointer-ext
#:multi-tex-env-f-ext #:multi-tex-env-fv-ext #:multi-tex-env-i-ext
#:multi-tex-env-iv-ext #:multi-tex-gen-d-ext
#:multi-tex-gen-dv-ext #:multi-tex-gen-f-ext
#:multi-tex-gen-fv-ext #:multi-tex-gen-i-ext
#:multi-tex-gen-iv-ext #:get-multi-tex-env-fv-ext
#:get-multi-tex-env-iv-ext #:get-multi-tex-gen-dv-ext
#:get-multi-tex-gen-fv-ext #:get-multi-tex-gen-iv-ext
#:multi-tex-parameter-i-ext #:multi-tex-parameter-iv-ext
#:multi-tex-parameter-f-ext #:multi-tex-parameter-fv-ext
#:multi-tex-image-1d-ext #:multi-tex-image-2d-ext
#:multi-tex-sub-image-1d-ext #:multi-tex-sub-image-2d-ext
#:copy-multi-tex-image-1d-ext #:copy-multi-tex-image-2d-ext
#:copy-multi-tex-sub-image-1d-ext
#:copy-multi-tex-sub-image-2d-ext #:get-multi-tex-image-ext
#:get-multi-tex-parameter-fv-ext #:get-multi-tex-parameter-iv-ext
#:get-multi-tex-level-parameter-fv-ext
#:get-multi-tex-level-parameter-iv-ext #:multi-tex-image-3d-ext
#:multi-tex-sub-image-3d-ext #:copy-multi-tex-sub-image-3d-ext
#:enable-client-state-indexed-ext
#:disable-client-state-indexed-ext #:get-float-indexed-v-ext
#:get-double-indexed-v-ext #:get-pointer-indexed-v-ext
#:enable-indexed-ext #:disable-indexed-ext
#:is-enabled-indexed-ext #:get-integer-indexed-v-ext
#:get-boolean-indexed-v-ext #:compressed-texture-image-3d-ext
#:compressed-texture-image-2d-ext
#:compressed-texture-image-1d-ext
#:compressed-texture-sub-image-3d-ext
#:compressed-texture-sub-image-2d-ext
#:compressed-texture-sub-image-1d-ext
#:get-compressed-texture-image-ext
#:compressed-multi-tex-image-3d-ext
#:compressed-multi-tex-image-2d-ext
#:compressed-multi-tex-image-1d-ext
#:compressed-multi-tex-sub-image-3d-ext
#:compressed-multi-tex-sub-image-2d-ext
#:compressed-multi-tex-sub-image-1d-ext
#:get-compressed-multi-tex-image-ext #:matrix-load-transpose-f-ext
#:matrix-load-transpose-d-ext #:matrix-mult-transpose-f-ext
#:matrix-mult-transpose-d-ext #:named-buffer-data-ext
#:named-buffer-sub-data-ext #:map-named-buffer-ext
#:unmap-named-buffer-ext #:get-named-buffer-parameter-iv-ext
#:get-named-buffer-pointer-v-ext #:get-named-buffer-sub-data-ext
#:program-uniform-1f-ext #:program-uniform-2f-ext
#:program-uniform-3f-ext #:program-uniform-4f-ext
#:program-uniform-1i-ext #:program-uniform-2i-ext
#:program-uniform-3i-ext #:program-uniform-4i-ext
#:program-uniform-1fv-ext #:program-uniform-2fv-ext
#:program-uniform-3fv-ext #:program-uniform-4fv-ext
#:program-uniform-1iv-ext #:program-uniform-2iv-ext
#:program-uniform-3iv-ext #:program-uniform-4iv-ext
#:program-uniform-matrix-2fv-ext #:program-uniform-matrix-3fv-ext
#:program-uniform-matrix-4fv-ext
#:program-uniform-matrix-2x3-fv-ext
#:program-uniform-matrix-3x2-fv-ext
#:program-uniform-matrix-2x4-fv-ext
#:program-uniform-matrix-4x2-fv-ext
#:program-uniform-matrix-3x4-fv-ext
#:program-uniform-matrix-4x3-fv-ext #:texture-buffer-ext
#:multi-tex-buffer-ext #:texture-parameter-iiv-ext
#:texture-parameter-iuiv-ext #:get-texture-parameter-iiv-ext
#:get-texture-parameter-iuiv-ext #:multi-tex-parameter-iiv-ext
#:multi-tex-parameter-iuiv-ext #:get-multi-tex-parameter-iiv-ext
#:get-multi-tex-parameter-iuiv-ext #:program-uniform-1ui-ext
#:program-uniform-2ui-ext #:program-uniform-3ui-ext
#:program-uniform-4ui-ext #:program-uniform-1uiv-ext
#:program-uniform-2uiv-ext #:program-uniform-3uiv-ext
#:program-uniform-4uiv-ext
#:named-program-local-parameters-4fv-ext
#:named-program-local-parameter-i4i-ext
#:named-program-local-parameter-i4iv-ext
#:named-program-local-parameters-i4iv-ext
#:named-program-local-parameter-i4ui-ext
#:named-program-local-parameter-i4uiv-ext
#:named-program-local-parameters-i4uiv-ext
#:get-named-program-local-parameter-iiv-ext
#:get-named-program-local-parameter-iuiv-ext
#:enable-client-state-i-ext #:disable-client-state-i-ext
#:get-float-i-v-ext #:get-double-i-v-ext #:get-pointer-i-v-ext
#:named-program-string-ext #:named-program-local-parameter-4d-ext
#:named-program-local-parameter-4dv-ext
#:named-program-local-parameter-4f-ext
#:named-program-local-parameter-4fv-ext
#:get-named-program-local-parameter-dv-ext
#:get-named-program-local-parameter-fv-ext
#:get-named-program-iv-ext #:get-named-program-string-ext
#:named-renderbuffer-storage-ext
#:get-named-renderbuffer-parameter-iv-ext
#:named-renderbuffer-storage-multisample-ext
#:named-renderbuffer-storage-multisample-coverage-ext
#:check-named-framebuffer-status-ext
#:named-framebuffer-texture-1d-ext
#:named-framebuffer-texture-2d-ext
#:named-framebuffer-texture-3d-ext
#:named-framebuffer-renderbuffer-ext
#:get-named-framebuffer-attachment-parameter-iv-ext
#:generate-texture-mipmap-ext #:generate-multi-tex-mipmap-ext
#:framebuffer-draw-buffer-ext #:framebuffer-draw-buffers-ext
#:framebuffer-read-buffer-ext #:get-framebuffer-parameter-iv-ext
#:named-copy-buffer-sub-data-ext #:named-framebuffer-texture-ext
#:named-framebuffer-texture-layer-ext
#:named-framebuffer-texture-face-ext #:texture-renderbuffer-ext
#:multi-tex-renderbuffer-ext #:vertex-array-vertex-offset-ext
#:vertex-array-color-offset-ext
#:vertex-array-edge-flag-offset-ext
#:vertex-array-index-offset-ext #:vertex-array-normal-offset-ext
#:vertex-array-tex-coord-offset-ext
#:vertex-array-multi-tex-coord-offset-ext
#:vertex-array-fog-coord-offset-ext
#:vertex-array-secondary-color-offset-ext
#:vertex-array-vertex-attrib-offset-ext
#:vertex-array-vertex-attrib-i-offset-ext
#:enable-vertex-array-ext #:disable-vertex-array-ext
#:enable-vertex-array-attrib-ext #:disable-vertex-array-attrib-ext
#:get-vertex-array-integer-v-ext #:get-vertex-array-pointer-v-ext
#:get-vertex-array-integer-i-v-ext
#:get-vertex-array-pointer-i-v-ext #:map-named-buffer-range-ext
#:flush-mapped-named-buffer-range-ext #:named-buffer-storage-ext
#:clear-named-buffer-data-ext #:clear-named-buffer-sub-data-ext
#:named-framebuffer-parameter-i-ext
#:get-named-framebuffer-parameter-iv-ext #:program-uniform-1d-ext
#:program-uniform-2d-ext #:program-uniform-3d-ext
#:program-uniform-4d-ext #:program-uniform-1dv-ext
#:program-uniform-2dv-ext #:program-uniform-3dv-ext
#:program-uniform-4dv-ext #:program-uniform-matrix-2dv-ext
#:program-uniform-matrix-3dv-ext #:program-uniform-matrix-4dv-ext
#:program-uniform-matrix-2x3-dv-ext
#:program-uniform-matrix-2x4-dv-ext
#:program-uniform-matrix-3x2-dv-ext
#:program-uniform-matrix-3x4-dv-ext
#:program-uniform-matrix-4x2-dv-ext
#:program-uniform-matrix-4x3-dv-ext #:texture-buffer-range-ext
#:texture-storage-1d-ext #:texture-storage-2d-ext
#:texture-storage-3d-ext #:texture-storage-2d-multisample-ext
#:texture-storage-3d-multisample-ext
#:vertex-array-bind-vertex-buffer-ext
#:vertex-array-vertex-attrib-format-ext
#:vertex-array-vertex-attrib-i-format-ext
#:vertex-array-vertex-attrib-l-format-ext
#:vertex-array-vertex-attrib-binding-ext
#:vertex-array-vertex-binding-divisor-ext
#:vertex-array-vertex-attrib-loffset-ext
#:texture-page-commitment-ext
#:vertex-array-vertex-attrib-divisor-ext #:discard-framebuffer-ext
#:gen-queries-ext #:delete-queries-ext #:is-query-ext
#:begin-query-ext #:end-query-ext #:query-counter-ext
#:get-query-iv-ext #:get-query-object-iv-ext
#:get-query-object-uiv-ext #:get-query-object-i64v-ext
#:get-query-object-ui64v-ext #:draw-buffers-ext
#:color-mask-indexed-ext #:enable-i-ext #:disable-i-ext
#:blend-equation-i-ext #:blend-equation-separate-i-ext
#:blend-func-i-ext #:blend-func-separate-i-ext #:color-mask-i-ext
#:is-enabled-i-ext #:draw-elements-base-vertex-ext
#:draw-range-elements-base-vertex-ext
#:draw-elements-instanced-base-vertex-ext
#:multi-draw-elements-base-vertex-ext #:draw-arrays-instanced-ext
#:draw-elements-instanced-ext #:draw-range-elements-ext
#:fog-coord-f-ext #:fog-coord-fv-ext #:fog-coord-d-ext
#:fog-coord-dv-ext #:fog-coord-pointer-ext #:blit-framebuffer-ext
#:renderbuffer-storage-multisample-ext #:is-renderbuffer-ext
#:bind-renderbuffer-ext #:delete-renderbuffers-ext
#:gen-renderbuffers-ext #:renderbuffer-storage-ext
#:get-renderbuffer-parameter-iv-ext #:is-framebuffer-ext
#:bind-framebuffer-ext #:delete-framebuffers-ext
#:gen-framebuffers-ext #:check-framebuffer-status-ext
#:framebuffer-texture-1d-ext #:framebuffer-texture-2d-ext
#:framebuffer-texture-3d-ext #:framebuffer-renderbuffer-ext
#:get-framebuffer-attachment-parameter-iv-ext
#:generate-mipmap-ext #:framebuffer-texture-ext
#:program-parameter-i-ext #:program-env-parameters-4fv-ext
#:program-local-parameters-4fv-ext #:get-uniform-uiv-ext
#:bind-frag-data-location-ext #:get-frag-data-location-ext
#:uniform-1ui-ext #:uniform-2ui-ext #:uniform-3ui-ext
#:uniform-4ui-ext #:uniform-1uiv-ext #:uniform-2uiv-ext
#:uniform-3uiv-ext #:uniform-4uiv-ext #:get-histogram-ext
#:get-histogram-parameter-fv-ext #:get-histogram-parameter-iv-ext
#:get-minmax-ext #:get-minmax-parameter-fv-ext
#:get-minmax-parameter-iv-ext #:histogram-ext #:minmax-ext
#:reset-histogram-ext #:reset-minmax-ext #:index-func-ext
#:index-material-ext #:vertex-attrib-divisor-ext
#:apply-texture-ext #:texture-light-ext #:texture-material-ext
#:map-buffer-range-ext #:flush-mapped-buffer-range-ext
#:multi-draw-arrays-ext #:multi-draw-elements-ext
#:multi-draw-arrays-indirect-ext
#:multi-draw-elements-indirect-ext #:sample-mask-ext
#:sample-pattern-ext #:framebuffer-texture-2d-multisample-ext
#:read-buffer-indexed-ext #:draw-buffers-indexed-ext
#:get-integer-i-v-ext #:color-table-ext #:get-color-table-ext
#:get-color-table-parameter-iv-ext
#:get-color-table-parameter-fv-ext
#:pixel-transform-parameter-i-ext
#:pixel-transform-parameter-f-ext
#:pixel-transform-parameter-iv-ext
#:pixel-transform-parameter-fv-ext
#:get-pixel-transform-parameter-iv-ext
#:get-pixel-transform-parameter-fv-ext #:point-parameter-f-ext
#:point-parameter-fv-ext #:polygon-offset-ext
#:polygon-offset-clamp-ext #:primitive-bounding-box-ext
#:provoking-vertex-ext #:raster-samples-ext
#:get-graphics-reset-status-ext #:readn-pixels-ext
#:getn-uniformfv-ext #:getn-uniformiv-ext #:secondary-color-3b-ext
#:secondary-color-3bv-ext #:secondary-color-3d-ext
#:secondary-color-3dv-ext #:secondary-color-3f-ext
#:secondary-color-3fv-ext #:secondary-color-3i-ext
#:secondary-color-3iv-ext #:secondary-color-3s-ext
#:secondary-color-3sv-ext #:secondary-color-3ub-ext
#:secondary-color-3ubv-ext #:secondary-color-3ui-ext
#:secondary-color-3uiv-ext #:secondary-color-3us-ext
#:secondary-color-3usv-ext #:secondary-color-pointer-ext
#:use-shader-program-ext #:active-program-ext
#:create-shader-program-ext #:active-shader-program-ext
#:bind-program-pipeline-ext #:create-shader-programv-ext
#:delete-program-pipelines-ext #:gen-program-pipelines-ext
#:get-program-pipeline-info-log-ext #:get-program-pipeline-iv-ext
#:is-program-pipeline-ext #:use-program-stages-ext
#:validate-program-pipeline-ext #:bind-image-texture-ext
#:memory-barrier-ext #:stencil-clear-tag-ext
#:active-stencil-face-ext #:tex-sub-image-1d-ext
#:tex-sub-image-2d-ext #:patch-parameter-i-ext #:tex-image-3d-ext
#:tex-sub-image-3d-ext #:framebuffer-texture-layer-ext
#:tex-parameter-iiv-ext #:tex-parameter-iuiv-ext
#:get-tex-parameter-iiv-ext #:get-tex-parameter-iuiv-ext
#:sampler-parameter-iiv-ext #:sampler-parameter-iuiv-ext
#:get-sampler-parameter-iiv-ext #:get-sampler-parameter-iuiv-ext
#:tex-buffer-ext #:tex-buffer-range-ext #:clear-color-ii-ext
#:clear-color-iui-ext #:are-textures-resident-ext
#:bind-texture-ext #:delete-textures-ext #:gen-textures-ext
#:is-texture-ext #:prioritize-textures-ext #:texture-normal-ext
#:tex-storage-1d-ext #:tex-storage-2d-ext #:tex-storage-3d-ext
#:texture-view-ext #:begin-transform-feedback-ext
#:end-transform-feedback-ext #:bind-buffer-range-ext
#:bind-buffer-offset-ext #:bind-buffer-base-ext
#:transform-feedback-varyings-ext
#:get-transform-feedback-varying-ext #:array-element-ext
#:color-pointer-ext #:draw-arrays-ext #:edge-flag-pointer-ext
#:get-pointer-v-ext #:index-pointer-ext #:normal-pointer-ext
#:tex-coord-pointer-ext #:vertex-pointer-ext
#:vertex-attrib-l1d-ext #:vertex-attrib-l2d-ext
#:vertex-attrib-l3d-ext #:vertex-attrib-l4d-ext
#:vertex-attrib-l1dv-ext #:vertex-attrib-l2dv-ext
#:vertex-attrib-l3dv-ext #:vertex-attrib-l4dv-ext
#:vertex-attrib-lpointer-ext #:get-vertex-attrib-ldv-ext
#:begin-vertex-shader-ext #:end-vertex-shader-ext
#:bind-vertex-shader-ext #:gen-vertex-shaders-ext
#:delete-vertex-shader-ext #:shader-op-1-ext #:shader-op-2-ext
#:shader-op-3-ext #:swizzle-ext #:write-mask-ext
#:insert-component-ext #:extract-component-ext #:gen-symbols-ext
#:set-invariant-ext #:set-local-constant-ext #:variant-bv-ext
#:variant-sv-ext #:variant-iv-ext #:variant-fv-ext
#:variant-dv-ext #:variant-ubv-ext #:variant-usv-ext
#:variant-uiv-ext #:variant-pointer-ext
#:enable-variant-client-state-ext
#:disable-variant-client-state-ext #:bind-light-parameter-ext
#:bind-material-parameter-ext #:bind-tex-gen-parameter-ext
#:bind-texture-unit-parameter-ext #:bind-parameter-ext
#:is-variant-enabled-ext #:get-variant-boolean-v-ext
#:get-variant-integer-v-ext #:get-variant-float-v-ext
#:get-variant-pointer-v-ext #:get-invariant-boolean-v-ext
#:get-invariant-integer-v-ext #:get-invariant-float-v-ext
#:get-local-constant-boolean-v-ext
#:get-local-constant-integer-v-ext
#:get-local-constant-float-v-ext #:vertex-weight-f-ext
#:vertex-weight-fv-ext #:vertex-weight-pointer-ext
#:import-sync-ext #:frame-terminator-gremedy
#:string-marker-gremedy #:image-transform-parameter-i-hp
#:image-transform-parameter-f-hp #:image-transform-parameter-iv-hp
#:image-transform-parameter-fv-hp
#:get-image-transform-parameter-iv-hp
#:get-image-transform-parameter-fv-hp #:multi-mode-draw-arrays-ibm
#:multi-mode-draw-elements-ibm #:flush-static-data-ibm
#:color-pointer-list-ibm #:secondary-color-pointer-list-ibm
#:edge-flag-pointer-list-ibm #:fog-coord-pointer-list-ibm
#:index-pointer-list-ibm #:normal-pointer-list-ibm
#:tex-coord-pointer-list-ibm #:vertex-pointer-list-ibm
#:renderbuffer-storage-multisample-img
#:framebuffer-texture-2d-multisample-img #:clip-plane-f-img
#:clip-plane-x-img #:blend-func-separate-ingr
#:apply-framebuffer-attachment-cmaa-intel #:sync-texture-intel
#:unmap-texture-2d-intel #:map-texture-2d-intel
#:vertex-pointer-v-intel #:normal-pointer-v-intel
#:color-pointer-v-intel #:tex-coord-pointer-v-intel
#:begin-perf-query-intel #:create-perf-query-intel
#:delete-perf-query-intel #:end-perf-query-intel
#:get-first-perf-query-id-intel #:get-next-perf-query-id-intel
#:get-perf-counter-info-intel #:get-perf-query-data-intel
#:get-perf-query-id-by-name-intel #:get-perf-query-info-intel
#:blend-barrier-khr #:debug-message-control-khr
#:debug-message-insert-khr #:debug-message-callback-khr
#:get-debug-message-log-khr #:push-debug-group-khr
#:pop-debug-group-khr #:object-label-khr #:get-object-label-khr
#:object-ptr-label-khr #:get-object-ptr-label-khr
#:get-pointer-v-khr #:get-graphics-reset-status-khr
#:readn-pixels-khr #:getn-uniform-fv-khr #:getn-uniform-iv-khr
#:getn-uniform-uiv-khr #:resize-buffers-mesa #:window-pos-2d-mesa
#:window-pos-2dv-mesa #:window-pos-2f-mesa #:window-pos-2fv-mesa
#:window-pos-2i-mesa #:window-pos-2iv-mesa #:window-pos-2s-mesa
#:window-pos-2sv-mesa #:window-pos-3d-mesa #:window-pos-3dv-mesa
#:window-pos-3f-mesa #:window-pos-3fv-mesa #:window-pos-3i-mesa
#:window-pos-3iv-mesa #:window-pos-3s-mesa #:window-pos-3sv-mesa
#:window-pos-4d-mesa #:window-pos-4dv-mesa #:window-pos-4f-mesa
#:window-pos-4fv-mesa #:window-pos-4i-mesa #:window-pos-4iv-mesa
#:window-pos-4s-mesa #:window-pos-4sv-mesa
#:begin-conditional-render-nvx #:end-conditional-render-nvx
#:multi-draw-arrays-indirect-bindless-nv
#:multi-draw-elements-indirect-bindless-nv
#:multi-draw-arrays-indirect-bindless-count-nv
#:multi-draw-elements-indirect-bindless-count-nv
#:get-texture-handle-nv #:get-texture-sampler-handle-nv
#:make-texture-handle-resident-nv
#:make-texture-handle-non-resident-nv #:get-image-handle-nv
#:make-image-handle-resident-nv
#:make-image-handle-non-resident-nv #:uniform-handle-ui64-nv
#:uniform-handle-ui64v-nv #:program-uniform-handle-ui64-nv
#:program-uniform-handle-ui64v-nv #:is-texture-handle-resident-nv
#:is-image-handle-resident-nv #:blend-parameter-i-nv
#:blend-barrier-nv #:create-states-nv #:delete-states-nv
#:is-state-nv #:state-capture-nv #:get-command-header-nv
#:get-stage-index-nv #:draw-commands-nv #:draw-commands-address-nv
#:draw-commands-states-nv #:draw-commands-states-address-nv
#:create-command-lists-nv #:delete-command-lists-nv
#:is-command-list-nv #:list-draw-commands-states-client-nv
#:command-list-segments-nv #:compile-command-list-nv
#:call-command-list-nv #:begin-conditional-render-nv
#:end-conditional-render-nv #:subpixel-precision-bias-nv
#:conservative-raster-parameter-f-nv #:copy-buffer-sub-data-nv
#:copy-image-sub-data-nv #:coverage-mask-nv
#:coverage-operation-nv #:depth-range-d-nv #:clear-depth-d-nv
#:depth-bounds-d-nv #:draw-buffers-nv #:draw-arrays-instanced-nv
#:draw-elements-instanced-nv #:draw-texture-nv
#:map-control-points-nv #:map-parameter-iv-nv
#:map-parameter-fv-nv #:get-map-control-points-nv
#:get-map-parameter-iv-nv #:get-map-parameter-fv-nv
#:get-map-attrib-parameter-iv-nv #:get-map-attrib-parameter-fv-nv
#:eval-maps-nv #:get-multisample-fv-nv #:sample-mask-indexed-nv
#:tex-renderbuffer-nv #:delete-fences-nv #:gen-fences-nv
#:is-fence-nv #:test-fence-nv #:get-fence-iv-nv #:finish-fence-nv
#:set-fence-nv #:fragment-coverage-color-nv
#:program-named-parameter-4f-nv #:program-named-parameter-4fv-nv
#:program-named-parameter-4d-nv #:program-named-parameter-4dv-nv
#:get-program-named-parameter-fv-nv
#:get-program-named-parameter-dv-nv #:blit-framebuffer-nv
#:coverage-modulation-table-nv #:get-coverage-modulation-table-nv
#:coverage-modulation-nv #:renderbuffer-storage-multisample-nv
#:renderbuffer-storage-multisample-coverage-nv
#:program-vertex-limit-nv #:framebuffer-texture-face-ext
#:program-local-parameter-i4i-nv #:program-local-parameter-i4iv-nv
#:program-local-parameters-i4iv-nv
#:program-local-parameter-i4ui-nv
#:program-local-parameter-i4uiv-nv
#:program-local-parameters-i4uiv-nv #:program-env-parameter-i4i-nv
#:program-env-parameter-i4iv-nv #:program-env-parameters-i4iv-nv
#:program-env-parameter-i4ui-nv #:program-env-parameter-i4uiv-nv
#:program-env-parameters-i4uiv-nv
#:get-program-local-parameter-iiv-nv
#:get-program-local-parameter-iuiv-nv
#:get-program-env-parameter-iiv-nv
#:get-program-env-parameter-iuiv-nv
#:program-subroutine-parameters-uiv-nv
#:get-program-subroutine-parameter-uiv-nv #:vertex-2h-nv
#:vertex-2hv-nv #:vertex-3h-nv #:vertex-3hv-nv #:vertex-4h-nv
#:vertex-4hv-nv #:normal-3h-nv #:normal-3hv-nv #:color-3h-nv
#:color-3hv-nv #:color-4h-nv #:color-4hv-nv #:tex-coord-1h-nv
#:tex-coord-1hv-nv #:tex-coord-2h-nv #:tex-coord-2hv-nv
#:tex-coord-3h-nv #:tex-coord-3hv-nv #:tex-coord-4h-nv
#:tex-coord-4hv-nv #:multi-tex-coord-1h-nv
#:multi-tex-coord-1hv-nv #:multi-tex-coord-2h-nv
#:multi-tex-coord-2hv-nv #:multi-tex-coord-3h-nv
#:multi-tex-coord-3hv-nv #:multi-tex-coord-4h-nv
#:multi-tex-coord-4hv-nv #:fog-coord-h-nv #:fog-coord-hv-nv
#:secondary-color-3h-nv #:secondary-color-3hv-nv
#:vertex-weight-h-nv #:vertex-weight-hv-nv #:vertex-attrib-1h-nv
#:vertex-attrib-1hv-nv #:vertex-attrib-2h-nv
#:vertex-attrib-2hv-nv #:vertex-attrib-3h-nv
#:vertex-attrib-3hv-nv #:vertex-attrib-4h-nv
#:vertex-attrib-4hv-nv #:vertex-attribs-1hv-nv
#:vertex-attribs-2hv-nv #:vertex-attribs-3hv-nv
#:vertex-attribs-4hv-nv #:vertex-attrib-divisor-nv
#:get-internalformat-sample-iv-nv #:uniform-matrix-2x3-fv-nv
#:uniform-matrix-3x2-fv-nv #:uniform-matrix-2x4-fv-nv
#:uniform-matrix-4x2-fv-nv #:uniform-matrix-3x4-fv-nv
#:uniform-matrix-4x3-fv-nv #:gen-occlusion-queries-nv
#:delete-occlusion-queries-nv #:is-occlusion-query-nv
#:begin-occlusion-query-nv #:end-occlusion-query-nv
#:get-occlusion-query-iv-nv #:get-occlusion-query-uiv-nv
#:program-buffer-parameters-fv-nv
#:program-buffer-parameters-iiv-nv
#:program-buffer-parameters-iuiv-nv #:gen-paths-nv
#:delete-paths-nv #:is-path-nv #:path-commands-nv #:path-coords-nv
#:path-sub-commands-nv #:path-sub-coords-nv #:path-string-nv
#:path-glyphs-nv #:path-glyph-range-nv #:weight-paths-nv
#:copy-path-nv #:interpolate-paths-nv #:transform-path-nv
#:path-parameter-iv-nv #:path-parameter-i-nv
#:path-parameter-fv-nv #:path-parameter-f-nv #:path-dash-array-nv
#:path-stencil-func-nv #:path-stencil-depth-offset-nv
#:stencil-fill-path-nv #:stencil-stroke-path-nv
#:stencil-fill-path-instanced-nv
#:stencil-stroke-path-instanced-nv #:path-cover-depth-func-nv
#:cover-fill-path-nv #:cover-stroke-path-nv
#:cover-fill-path-instanced-nv #:cover-stroke-path-instanced-nv
#:get-path-parameter-iv-nv #:get-path-parameter-fv-nv
#:get-path-commands-nv #:get-path-coords-nv
#:get-path-dash-array-nv #:get-path-metrics-nv
#:get-path-metric-range-nv #:get-path-spacing-nv
#:is-point-in-fill-path-nv #:is-point-in-stroke-path-nv
#:get-path-length-nv #:point-along-path-nv #:matrix-load-3x2-f-nv
#:matrix-load-3x3-f-nv #:matrix-load-transpose-3x3-f-nv
#:matrix-mult-3x2-f-nv #:matrix-mult-3x3-f-nv
#:matrix-mult-transpose-3x3-f-nv #:stencil-then-cover-fill-path-nv
#:stencil-then-cover-stroke-path-nv
#:stencil-then-cover-fill-path-instanced-nv
#:stencil-then-cover-stroke-path-instanced-nv
#:path-glyph-index-range-nv #:path-glyph-index-array-nv
#:path-memory-glyph-index-array-nv
#:program-path-fragment-input-gen-nv #:get-program-resource-fv-nv
#:path-color-gen-nv #:path-tex-gen-nv #:path-fog-gen-nv
#:get-path-color-gen-iv-nv #:get-path-color-gen-fv-nv
#:get-path-tex-gen-iv-nv #:get-path-tex-gen-fv-nv
#:pixel-data-range-nv #:flush-pixel-data-range-nv
#:point-parameter-i-nv #:point-parameter-iv-nv #:polygon-mode-nv
#:present-frame-keyed-nv #:present-frame-dual-fill-nv
#:get-video-iv-nv #:get-video-uiv-nv #:get-video-i64v-nv
#:get-video-ui64v-nv #:primitive-restart-nv
#:primitive-restart-index-nv #:read-buffer-nv
#:combiner-parameter-fv-nv #:combiner-parameter-f-nv
#:combiner-parameter-iv-nv #:combiner-parameter-i-nv
#:combiner-input-nv #:combiner-output-nv #:final-combiner-input-nv
#:get-combiner-input-parameter-fv-nv
#:get-combiner-input-parameter-iv-nv
#:get-combiner-output-parameter-fv-nv
#:get-combiner-output-parameter-iv-nv
#:get-final-combiner-input-parameter-fv-nv
#:get-final-combiner-input-parameter-iv-nv
#:combiner-stage-parameter-fv-nv
#:get-combiner-stage-parameter-fv-nv
#:framebuffer-sample-locations-fv-nv
#:named-framebuffer-sample-locations-fv-nv
#:resolve-depth-values-nv #:make-buffer-resident-nv
#:make-buffer-non-resident-nv #:is-buffer-resident-nv
#:make-named-buffer-resident-nv
#:make-named-buffer-non-resident-nv #:is-named-buffer-resident-nv
#:get-buffer-parameter-ui64v-nv
#:get-named-buffer-parameter-ui64v-nv #:get-integer-ui64v-nv
#:uniform-ui64-nv #:uniform-ui64v-nv #:program-uniform-ui64-nv
#:program-uniform-ui64v-nv #:texture-barrier-nv
#:tex-image-2d-multisample-coverage-nv
#:tex-image-3d-multisample-coverage-nv
#:texture-image-2d-multisample-nv
#:texture-image-3d-multisample-nv
#:texture-image-2d-multisample-coverage-nv
#:texture-image-3d-multisample-coverage-nv
#:begin-transform-feedback-nv #:end-transform-feedback-nv
#:transform-feedback-attribs-nv #:bind-buffer-range-nv
#:bind-buffer-offset-nv #:bind-buffer-base-nv
#:transform-feedback-varyings-nv #:active-varying-nv
#:get-varying-location-nv #:get-active-varying-nv
#:get-transform-feedback-varying-nv
#:transform-feedback-stream-attribs-nv
#:bind-transform-feedback-nv #:delete-transform-feedbacks-nv
#:gen-transform-feedbacks-nv #:is-transform-feedback-nv
#:pause-transform-feedback-nv #:resume-transform-feedback-nv
#:draw-transform-feedback-nv #:vdpau-init-nv #:vdpau-fini-nv
#:vdpau-register-video-surface-nv
#:vdpau-register-output-surface-nv #:vdpau-is-surface-nv
#:vdpau-unregister-surface-nv #:vdpau-get-surface-iv-nv
#:vdpau-surface-access-nv #:vdpau-map-surfaces-nv
#:vdpau-unmap-surfaces-nv #:flush-vertex-array-range-nv
#:vertex-array-range-nv #:vertex-attrib-l1i64-nv
#:vertex-attrib-l2i64-nv #:vertex-attrib-l3i64-nv
#:vertex-attrib-l4i64-nv #:vertex-attrib-l1i64v-nv
#:vertex-attrib-l2i64v-nv #:vertex-attrib-l3i64v-nv
#:vertex-attrib-l4i64v-nv #:vertex-attrib-l1ui64-nv
#:vertex-attrib-l2ui64-nv #:vertex-attrib-l3ui64-nv
#:vertex-attrib-l4ui64-nv #:vertex-attrib-l1ui64v-nv
#:vertex-attrib-l2ui64v-nv #:vertex-attrib-l3ui64v-nv
#:vertex-attrib-l4ui64v-nv #:get-vertex-attrib-li64v-nv
#:get-vertex-attrib-lui64v-nv #:vertex-attrib-l-format-nv
#:buffer-address-range-nv #:vertex-format-nv #:normal-format-nv
#:color-format-nv #:index-format-nv #:tex-coord-format-nv
#:edge-flag-format-nv #:secondary-color-format-nv
#:fog-coord-format-nv #:vertex-attrib-format-nv
#:vertex-attrib-i-format-nv #:get-integer-ui64i-v-nv
#:are-programs-resident-nv #:bind-program-nv #:delete-programs-nv
#:execute-program-nv #:gen-programs-nv
#:get-program-parameter-dv-nv #:get-program-parameter-fv-nv
#:get-program-iv-nv #:get-program-string-nv
#:get-track-matrix-iv-nv #:get-vertex-attrib-dv-nv
#:get-vertex-attrib-fv-nv #:get-vertex-attrib-iv-nv
#:get-vertex-attrib-pointer-v-nv #:is-program-nv #:load-program-nv
#:program-parameter-4d-nv #:program-parameter-4dv-nv
#:program-parameter-4f-nv #:program-parameter-4fv-nv
#:program-parameters-4dv-nv #:program-parameters-4fv-nv
#:request-resident-programs-nv #:track-matrix-nv
#:vertex-attrib-pointer-nv #:vertex-attrib-1d-nv
#:vertex-attrib-1dv-nv #:vertex-attrib-1f-nv
#:vertex-attrib-1fv-nv #:vertex-attrib-1s-nv
#:vertex-attrib-1sv-nv #:vertex-attrib-2d-nv
#:vertex-attrib-2dv-nv #:vertex-attrib-2f-nv
#:vertex-attrib-2fv-nv #:vertex-attrib-2s-nv
#:vertex-attrib-2sv-nv #:vertex-attrib-3d-nv
#:vertex-attrib-3dv-nv #:vertex-attrib-3f-nv
#:vertex-attrib-3fv-nv #:vertex-attrib-3s-nv
#:vertex-attrib-3sv-nv #:vertex-attrib-4d-nv
#:vertex-attrib-4dv-nv #:vertex-attrib-4f-nv
#:vertex-attrib-4fv-nv #:vertex-attrib-4s-nv
#:vertex-attrib-4sv-nv #:vertex-attrib-4ub-nv
#:vertex-attrib-4ubv-nv #:vertex-attribs-1dv-nv
#:vertex-attribs-1fv-nv #:vertex-attribs-1sv-nv
#:vertex-attribs-2dv-nv #:vertex-attribs-2fv-nv
#:vertex-attribs-2sv-nv #:vertex-attribs-3dv-nv
#:vertex-attribs-3fv-nv #:vertex-attribs-3sv-nv
#:vertex-attribs-4dv-nv #:vertex-attribs-4fv-nv
#:vertex-attribs-4sv-nv #:vertex-attribs-4ubv-nv
#:vertex-attrib-i1i-ext #:vertex-attrib-i2i-ext
#:vertex-attrib-i3i-ext #:vertex-attrib-i4i-ext
#:vertex-attrib-i1ui-ext #:vertex-attrib-i2ui-ext
#:vertex-attrib-i3ui-ext #:vertex-attrib-i4ui-ext
#:vertex-attrib-i1iv-ext #:vertex-attrib-i2iv-ext
#:vertex-attrib-i3iv-ext #:vertex-attrib-i4iv-ext
#:vertex-attrib-i1uiv-ext #:vertex-attrib-i2uiv-ext
#:vertex-attrib-i3uiv-ext #:vertex-attrib-i4uiv-ext
#:vertex-attrib-i4bv-ext #:vertex-attrib-i4sv-ext
#:vertex-attrib-i4ubv-ext #:vertex-attrib-i4usv-ext
#:vertex-attrib-ipointer-ext #:get-vertex-attrib-iiv-ext
#:get-vertex-attrib-iuiv-ext #:begin-video-capture-nv
#:bind-video-capture-stream-buffer-nv
#:bind-video-capture-stream-texture-nv #:end-video-capture-nv
#:get-video-capture-iv-nv #:get-video-capture-stream-iv-nv
#:get-video-capture-stream-fv-nv #:get-video-capture-stream-dv-nv
#:video-capture-nv #:video-capture-stream-parameter-iv-nv
#:video-capture-stream-parameter-fv-nv
#:video-capture-stream-parameter-dv-nv #:viewport-array-v-nv
#:viewport-indexed-f-nv #:viewport-indexed-fv-nv
#:scissor-array-v-nv #:scissor-indexed-nv #:scissor-indexed-v-nv
#:depth-range-array-fv-nv #:depth-range-indexed-f-nv
#:get-float-i-v-nv #:enable-i-nv #:disable-i-nv #:is-enabled-i-nv
#:egl-image-target-texture-2d-oes
#:egl-image-target-renderbuffer-storage-oes
#:blend-equation-separate-oes #:blend-func-separate-oes
#:blend-equation-oes #:multi-tex-coord-1b-oes
#:multi-tex-coord-1bv-oes #:multi-tex-coord-2b-oes
#:multi-tex-coord-2bv-oes #:multi-tex-coord-3b-oes
#:multi-tex-coord-3bv-oes #:multi-tex-coord-4b-oes
#:multi-tex-coord-4bv-oes #:tex-coord-1b-oes #:tex-coord-1bv-oes
#:tex-coord-2b-oes #:tex-coord-2bv-oes #:tex-coord-3b-oes
#:tex-coord-3bv-oes #:tex-coord-4b-oes #:tex-coord-4bv-oes
#:vertex-2b-oes #:vertex-2bv-oes #:vertex-3b-oes #:vertex-3bv-oes
#:vertex-4b-oes #:vertex-4bv-oes #:copy-image-sub-data-oes
#:enable-i-oes #:disable-i-oes #:blend-equation-i-oes
#:blend-equation-separate-i-oes #:blend-func-i-oes
#:blend-func-separate-i-oes #:color-mask-i-oes #:is-enabled-i-oes
#:draw-elements-base-vertex-oes
#:draw-range-elements-base-vertex-oes
#:draw-elements-instanced-base-vertex-oes
#:multi-draw-elements-base-vertex-oes #:draw-tex-s-oes
#:draw-tex-i-oes #:draw-tex-x-oes #:draw-tex-sv-oes
#:draw-tex-iv-oes #:draw-tex-xv-oes #:draw-tex-f-oes
#:draw-tex-fv-oes #:alpha-func-x-oes #:clear-color-x-oes
#:clear-depth-x-oes #:clip-plane-x-oes #:color-4x-oes
#:depth-range-x-oes #:fog-x-oes #:fog-xv-oes #:frustum-x-oes
#:get-clip-plane-x-oes #:get-fixed-v-oes #:get-tex-env-xv-oes
#:get-tex-parameter-xv-oes #:light-model-x-oes
#:light-model-xv-oes #:light-x-oes #:light-xv-oes
#:line-width-x-oes #:load-matrix-x-oes #:material-x-oes
#:material-xv-oes #:mult-matrix-x-oes #:multi-tex-coord-4x-oes
#:normal-3x-oes #:ortho-x-oes #:point-parameter-xv-oes
#:point-size-x-oes #:polygon-offset-x-oes #:rotate-x-oes
#:scale-x-oes #:tex-env-x-oes #:tex-env-xv-oes
#:tex-parameter-x-oes #:tex-parameter-xv-oes #:translate-x-oes
#:get-light-xv-oes #:get-material-xv-oes #:point-parameter-x-oes
#:sample-coverage-x-oes #:accum-x-oes #:bitmap-x-oes
#:blend-color-x-oes #:clear-accum-x-oes #:color-3x-oes
#:color-3xv-oes #:color-4xv-oes #:convolution-parameter-x-oes
#:convolution-parameter-xv-oes #:eval-coord-1x-oes
#:eval-coord-1xv-oes #:eval-coord-2x-oes #:eval-coord-2xv-oes
#:feedback-buffer-x-oes #:get-convolution-parameter-xv-oes
#:get-histogram-parameter-xv-oes #:get-light-x-oes
#:get-map-xv-oes #:get-material-x-oes #:get-pixel-map-xv
#:get-tex-gen-xv-oes #:get-tex-level-parameter-xv-oes
#:index-x-oes #:index-xv-oes #:load-transpose-matrix-x-oes
#:map-1x-oes #:map-2x-oes #:map-grid-1x-oes #:map-grid-2x-oes
#:mult-transpose-matrix-x-oes #:multi-tex-coord-1x-oes
#:multi-tex-coord-1xv-oes #:multi-tex-coord-2x-oes
#:multi-tex-coord-2xv-oes #:multi-tex-coord-3x-oes
#:multi-tex-coord-3xv-oes #:multi-tex-coord-4xv-oes
#:normal-3xv-oes #:pass-through-x-oes #:pixel-map-x
#:pixel-store-x #:pixel-transfer-x-oes #:pixel-zoom-x-oes
#:prioritize-textures-x-oes #:raster-pos-2x-oes
#:raster-pos-2xv-oes #:raster-pos-3x-oes #:raster-pos-3xv-oes
#:raster-pos-4x-oes #:raster-pos-4xv-oes #:rect-x-oes
#:rect-xv-oes #:tex-coord-1x-oes #:tex-coord-1xv-oes
#:tex-coord-2x-oes #:tex-coord-2xv-oes #:tex-coord-3x-oes
#:tex-coord-3xv-oes #:tex-coord-4x-oes #:tex-coord-4xv-oes
#:tex-gen-x-oes #:tex-gen-xv-oes #:vertex-2x-oes #:vertex-2xv-oes
#:vertex-3x-oes #:vertex-3xv-oes #:vertex-4x-oes #:vertex-4xv-oes
#:is-renderbuffer-oes #:bind-renderbuffer-oes
#:delete-renderbuffers-oes #:gen-renderbuffers-oes
#:renderbuffer-storage-oes #:get-renderbuffer-parameter-iv-oes
#:is-framebuffer-oes #:bind-framebuffer-oes
#:delete-framebuffers-oes #:gen-framebuffers-oes
#:check-framebuffer-status-oes #:framebuffer-renderbuffer-oes
#:framebuffer-texture-2d-oes
#:get-framebuffer-attachment-parameter-iv-oes
#:generate-mipmap-oes #:framebuffer-texture-oes
#:get-program-binary-oes #:program-binary-oes #:map-buffer-oes
#:unmap-buffer-oes #:get-buffer-pointer-v-oes
#:current-palette-matrix-oes
#:load-palette-from-model-view-matrix-oes
#:matrix-index-pointer-oes #:weight-pointer-oes
#:point-size-pointer-oes #:primitive-bounding-box-oes
#:query-matrix-x-oes #:min-sample-shading-oes #:clear-depth-f-oes
#:clip-plane-f-oes #:depth-range-f-oes #:frustum-f-oes
#:get-clip-plane-f-oes #:ortho-f-oes #:patch-parameter-i-oes
#:tex-image-3d-oes #:tex-sub-image-3d-oes
#:copy-tex-sub-image-3d-oes #:compressed-tex-image-3d-oes
#:compressed-tex-sub-image-3d-oes #:framebuffer-texture-3d-oes
#:tex-parameter-iiv-oes #:tex-parameter-iuiv-oes
#:get-tex-parameter-iiv-oes #:get-tex-parameter-iuiv-oes
#:sampler-parameter-iiv-oes #:sampler-parameter-iuiv-oes
#:get-sampler-parameter-iiv-oes #:get-sampler-parameter-iuiv-oes
#:tex-buffer-oes #:tex-buffer-range-oes #:tex-gen-f-oes
#:tex-gen-fv-oes #:tex-gen-i-oes #:tex-gen-iv-oes
#:get-tex-gen-fv-oes #:get-tex-gen-iv-oes
#:tex-storage-3d-multisample-oes #:texture-view-oes
#:bind-vertex-array-oes #:delete-vertex-arrays-oes
#:gen-vertex-arrays-oes #:is-vertex-array-oes
#:framebuffer-texture-multiview-ovr #:hint-pgi #:alpha-func-qcom
#:get-driver-controls-qcom #:get-driver-control-string-qcom
#:enable-driver-control-qcom #:disable-driver-control-qcom
#:ext-get-textures-qcom #:ext-get-buffers-qcom
#:ext-get-renderbuffers-qcom #:ext-get-framebuffers-qcom
#:ext-get-tex-level-parameter-iv-qcom
#:ext-tex-object-state-override-i-qcom
#:ext-get-tex-sub-image-qcom #:ext-get-buffer-pointer-v-qcom
#:ext-get-shaders-qcom #:ext-get-programs-qcom
#:ext-is-program-binary-qcom #:ext-get-program-binary-source-qcom
#:start-tiling-qcom #:end-tiling-qcom #:detail-tex-func-sgis
#:get-detail-tex-func-sgis #:fog-func-sgis #:get-fog-func-sgis
#:sample-mask-sgis #:sample-pattern-sgis
#:pixel-tex-gen-parameter-i-sgis #:pixel-tex-gen-parameter-iv-sgis
#:pixel-tex-gen-parameter-f-sgis #:pixel-tex-gen-parameter-fv-sgis
#:get-pixel-tex-gen-parameter-iv-sgis
#:get-pixel-tex-gen-parameter-fv-sgis #:point-parameter-f-sgis
#:point-parameter-fv-sgis #:sharpen-tex-func-sgis
#:get-sharpen-tex-func-sgis #:tex-image-4d-sgis
#:tex-sub-image-4d-sgis #:texture-color-mask-sgis
#:get-tex-filter-func-sgis #:tex-filter-func-sgis
#:async-marker-sgix #:finish-async-sgix #:poll-async-sgix
#:gen-async-markers-sgix #:delete-async-markers-sgix
#:is-async-marker-sgix #:flush-raster-sgix
#:fragment-color-material-sgix #:fragment-light-f-sgix
#:fragment-light-fv-sgix #:fragment-light-i-sgix
#:fragment-light-iv-sgix #:fragment-light-model-f-sgix
#:fragment-light-model-fv-sgix #:fragment-light-model-i-sgix
#:fragment-light-model-iv-sgix #:fragment-material-f-sgix
#:fragment-material-fv-sgix #:fragment-material-i-sgix
#:fragment-material-iv-sgix #:get-fragment-light-fv-sgix
#:get-fragment-light-iv-sgix #:get-fragment-material-fv-sgix
#:get-fragment-material-iv-sgix #:light-env-i-sgix
#:frame-zoom-sgix #:igloo-interface-sgix #:get-instruments-sgix
#:instruments-buffer-sgix #:poll-instruments-sgix
#:read-instruments-sgix #:start-instruments-sgix
#:stop-instruments-sgix #:get-list-parameter-fv-sgix
#:get-list-parameter-iv-sgix #:list-parameter-f-sgix
#:list-parameter-fv-sgix #:list-parameter-i-sgix
#:list-parameter-iv-sgix #:pixel-tex-gen-sgix
#:deformation-map-3d-sgix #:deformation-map-3f-sgix #:deform-sgix
#:load-identity-deformation-map-sgix #:reference-plane-sgix
#:sprite-parameter-f-sgix #:sprite-parameter-fv-sgix
#:sprite-parameter-i-sgix #:sprite-parameter-iv-sgix
#:tag-sample-buffer-sgix #:color-table-sgi
#:color-table-parameter-fv-sgi #:color-table-parameter-iv-sgi
#:copy-color-table-sgi #:get-color-table-sgi
#:get-color-table-parameter-fv-sgi
#:get-color-table-parameter-iv-sgi #:finish-texture-sunx
#:global-alpha-factor-b-sun #:global-alpha-factor-s-sun
#:global-alpha-factor-i-sun #:global-alpha-factor-f-sun
#:global-alpha-factor-d-sun #:global-alpha-factor-ub-sun
#:global-alpha-factor-us-sun #:global-alpha-factor-ui-sun
#:draw-mesh-arrays-sun #:replacement-code-ui-sun
#:replacement-code-us-sun #:replacement-code-ub-sun
#:replacement-code-uiv-sun #:replacement-code-usv-sun
#:replacement-code-ubv-sun #:replacement-code-pointer-sun
#:color-4ub-vertex-2f-sun #:color-4ub-vertex-2fv-sun
#:color-4ub-vertex-3f-sun #:color-4ub-vertex-3fv-sun
#:color-3f-vertex-3f-sun #:color-3f-vertex-3fv-sun
#:normal-3f-vertex-3f-sun #:normal-3f-vertex-3fv-sun
#:color-4f-normal-3f-vertex-3f-sun
#:color-4f-normal-3f-vertex-3fv-sun #:tex-coord-2f-vertex-3f-sun
#:tex-coord-2f-vertex-3fv-sun #:tex-coord-4f-vertex-4f-sun
#:tex-coord-4f-vertex-4fv-sun
#:tex-coord-2f-color-4ub-vertex-3f-sun
#:tex-coord-2f-color-4ub-vertex-3fv-sun
#:tex-coord-2f-color-3f-vertex-3f-sun
#:tex-coord-2f-color-3f-vertex-3fv-sun
#:tex-coord-2f-normal-3f-vertex-3f-sun
#:tex-coord-2f-normal-3f-vertex-3fv-sun
#:tex-coord-2f-color-4f-normal-3f-vertex-3f-sun
#:tex-coord-2f-color-4f-normal-3f-vertex-3fv-sun
#:tex-coord-4f-color-4f-normal-3f-vertex-4f-sun
#:tex-coord-4f-color-4f-normal-3f-vertex-4fv-sun
#:replacement-code-ui-vertex-3f-sun
#:replacement-code-ui-vertex-3fv-sun
#:replacement-code-ui-color-4ub-vertex-3f-sun
#:replacement-code-ui-color-4ub-vertex-3fv-sun
#:replacement-code-ui-color-3f-vertex-3f-sun
#:replacement-code-ui-color-3f-vertex-3fv-sun
#:replacement-code-ui-normal-3f-vertex-3f-sun
#:replacement-code-ui-normal-3f-vertex-3fv-sun
#:replacement-code-ui-color-4f-normal-3f-vertex-3f-sun
#:replacement-code-ui-color-4f-normal-3f-vertex-3fv-sun
#:replacement-code-ui-tex-coord-2f-vertex-3f-sun
#:replacement-code-ui-tex-coord-2f-vertex-3fv-sun
#:replacement-code-ui-tex-coord-2f-normal-3f-vertex-3f-sun
#:replacement-code-ui-tex-coord-2f-normal-3f-vertex-3fv-sun
#:replacement-code-ui-tex-coord-2f-color-4f-normal-3f-vertex-3f-sun
#:replacement-code-ui-tex-coord-2f-color-4f-normal-3f-vertex-3fv-sun))
| 78,015 | Common Lisp | .lisp | 1,415 | 52.128622 | 72 | 0.73966 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 316c7fb6aeeb4eb4fce2293780d7bcaa8bbe241b8a5cefbe0a38f504cb6c1e75 | 30,587 | [
93268
] |
30,588 | funcs-gl.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/funcs-gl.lisp | ;;; this file is automatically generated, do not edit
;;; generated from files with the following copyright:
;;;
;;; Copyright (c) 2013-2015 The Khronos Group Inc.
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining a
;;; copy of this software and/or associated documentation files (the
;;; "Materials"), to deal in the Materials without restriction, including
;;; without limitation the rights to use, copy, modify, merge, publish,
;;; distribute, sublicense, and/or sell copies of the Materials, and to
;;; permit persons to whom the Materials are furnished to do so, subject to
;;; the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be included
;;; in all copies or substantial portions of the Materials.
;;;
;;; THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
;;; IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
;;; CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
;;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
;;; MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
;;;
;;; ------------------------------------------------------------------------
(in-package #:cl-opengl-bindings)
;;; generated 2015-08-30T01:01:50Z
;;; from gl.xml @ svn rev 31811, 2015-08-10T07:01:11.860488Z
(defglfun ("glPolygonMode" polygon-mode) :void
(face enum)
(mode enum))
(defglfun ("glTexImage1D" tex-image-1d) :void
(target enum)
(level int)
(internalformat int)
(width sizei)
(border int)
(format enum)
(type enum)
(pixels offset-or-pointer))
(defglfun ("glDrawBuffer" draw-buffer) :void
(buf enum))
(defglfun ("glClearDepth" clear-depth) :void
(depth double))
(defglfun ("glPixelStoref" pixel-store-f) :void
(pname enum)
(param float))
(defglfun ("glGetDoublev" get-double-v) :void
(pname enum)
(data (:pointer double)))
(defglfun ("glGetTexImage" get-tex-image) :void
(target enum)
(level int)
(format enum)
(type enum)
(pixels offset-or-pointer))
(defglfun ("glDepthRange" depth-range) :void
(near double)
(far double))
(defglfun ("glNewList" new-list) :void
(list uint)
(mode enum))
(defglfun ("glEndList" end-list) :void)
(defglfun ("glCallList" call-list) :void
(list uint))
(defglfun ("glCallLists" call-lists) :void
(n sizei)
(type enum)
(lists (:pointer :void)))
(defglfun ("glDeleteLists" delete-lists) :void
(list uint)
(range sizei))
(defglfun ("glGenLists" gen-lists) uint
(range sizei))
(defglfun ("glListBase" list-base) :void
(base uint))
(defglfun ("glBegin" begin) :void
(mode enum))
(defglfun ("glBitmap" bitmap) :void
(width sizei)
(height sizei)
(xorig float)
(yorig float)
(xmove float)
(ymove float)
(bitmap offset-or-pointer))
(defglfun ("glColor3b" color-3b) :void
(red byte)
(green byte)
(blue byte))
(defglfun ("glColor3bv" color-3bv) :void
(v (:pointer byte)))
(defglfun ("glColor3d" color-3d) :void
(red double)
(green double)
(blue double))
(defglfun ("glColor3dv" color-3dv) :void
(v (:pointer double)))
(defglfun ("glColor3f" color-3f) :void
(red float)
(green float)
(blue float))
(defglfun ("glColor3fv" color-3fv) :void
(v (:pointer float)))
(defglfun ("glColor3i" color-3i) :void
(red int)
(green int)
(blue int))
(defglfun ("glColor3iv" color-3iv) :void
(v (:pointer int)))
(defglfun ("glColor3s" color-3s) :void
(red short)
(green short)
(blue short))
(defglfun ("glColor3sv" color-3sv) :void
(v (:pointer short)))
(defglfun ("glColor3ub" color-3ub) :void
(red ubyte)
(green ubyte)
(blue ubyte))
(defglfun ("glColor3ubv" color-3ubv) :void
(v (:pointer ubyte)))
(defglfun ("glColor3ui" color-3ui) :void
(red uint)
(green uint)
(blue uint))
(defglfun ("glColor3uiv" color-3uiv) :void
(v (:pointer uint)))
(defglfun ("glColor3us" color-3us) :void
(red ushort)
(green ushort)
(blue ushort))
(defglfun ("glColor3usv" color-3usv) :void
(v (:pointer ushort)))
(defglfun ("glColor4b" color-4b) :void
(red byte)
(green byte)
(blue byte)
(alpha byte))
(defglfun ("glColor4bv" color-4bv) :void
(v (:pointer byte)))
(defglfun ("glColor4d" color-4d) :void
(red double)
(green double)
(blue double)
(alpha double))
(defglfun ("glColor4dv" color-4dv) :void
(v (:pointer double)))
(defglfun ("glColor4fv" color-4fv) :void
(v (:pointer float)))
(defglfun ("glColor4i" color-4i) :void
(red int)
(green int)
(blue int)
(alpha int))
(defglfun ("glColor4iv" color-4iv) :void
(v (:pointer int)))
(defglfun ("glColor4s" color-4s) :void
(red short)
(green short)
(blue short)
(alpha short))
(defglfun ("glColor4sv" color-4sv) :void
(v (:pointer short)))
(defglfun ("glColor4ubv" color-4ubv) :void
(v (:pointer ubyte)))
(defglfun ("glColor4ui" color-4ui) :void
(red uint)
(green uint)
(blue uint)
(alpha uint))
(defglfun ("glColor4uiv" color-4uiv) :void
(v (:pointer uint)))
(defglfun ("glColor4us" color-4us) :void
(red ushort)
(green ushort)
(blue ushort)
(alpha ushort))
(defglfun ("glColor4usv" color-4usv) :void
(v (:pointer ushort)))
(defglfun ("glEdgeFlag" edge-flag) :void
(flag boolean))
(defglfun ("glEdgeFlagv" edge-flag-v) :void
(flag (:pointer boolean)))
(defglfun ("glEnd" end) :void)
(defglfun ("glIndexd" index-d) :void
(c double))
(defglfun ("glIndexdv" index-dv) :void
(c (:pointer double)))
(defglfun ("glIndexf" index-f) :void
(c float))
(defglfun ("glIndexfv" index-fv) :void
(c (:pointer float)))
(defglfun ("glIndexi" index-i) :void
(c int))
(defglfun ("glIndexiv" index-iv) :void
(c (:pointer int)))
(defglfun ("glIndexs" index-s) :void
(c short))
(defglfun ("glIndexsv" index-sv) :void
(c (:pointer short)))
(defglfun ("glNormal3b" normal-3b) :void
(nx byte)
(ny byte)
(nz byte))
(defglfun ("glNormal3bv" normal-3bv) :void
(v (:pointer byte)))
(defglfun ("glNormal3d" normal-3d) :void
(nx double)
(ny double)
(nz double))
(defglfun ("glNormal3dv" normal-3dv) :void
(v (:pointer double)))
(defglfun ("glNormal3fv" normal-3fv) :void
(v (:pointer float)))
(defglfun ("glNormal3i" normal-3i) :void
(nx int)
(ny int)
(nz int))
(defglfun ("glNormal3iv" normal-3iv) :void
(v (:pointer int)))
(defglfun ("glNormal3s" normal-3s) :void
(nx short)
(ny short)
(nz short))
(defglfun ("glNormal3sv" normal-3sv) :void
(v (:pointer short)))
(defglfun ("glRasterPos2d" raster-pos-2d) :void
(x double)
(y double))
(defglfun ("glRasterPos2dv" raster-pos-2dv) :void
(v (:pointer double)))
(defglfun ("glRasterPos2f" raster-pos-2f) :void
(x float)
(y float))
(defglfun ("glRasterPos2fv" raster-pos-2fv) :void
(v (:pointer float)))
(defglfun ("glRasterPos2i" raster-pos-2i) :void
(x int)
(y int))
(defglfun ("glRasterPos2iv" raster-pos-2iv) :void
(v (:pointer int)))
(defglfun ("glRasterPos2s" raster-pos-2s) :void
(x short)
(y short))
(defglfun ("glRasterPos2sv" raster-pos-2sv) :void
(v (:pointer short)))
(defglfun ("glRasterPos3d" raster-pos-3d) :void
(x double)
(y double)
(z double))
(defglfun ("glRasterPos3dv" raster-pos-3dv) :void
(v (:pointer double)))
(defglfun ("glRasterPos3f" raster-pos-3f) :void
(x float)
(y float)
(z float))
(defglfun ("glRasterPos3fv" raster-pos-3fv) :void
(v (:pointer float)))
(defglfun ("glRasterPos3i" raster-pos-3i) :void
(x int)
(y int)
(z int))
(defglfun ("glRasterPos3iv" raster-pos-3iv) :void
(v (:pointer int)))
(defglfun ("glRasterPos3s" raster-pos-3s) :void
(x short)
(y short)
(z short))
(defglfun ("glRasterPos3sv" raster-pos-3sv) :void
(v (:pointer short)))
(defglfun ("glRasterPos4d" raster-pos-4d) :void
(x double)
(y double)
(z double)
(w double))
(defglfun ("glRasterPos4dv" raster-pos-4dv) :void
(v (:pointer double)))
(defglfun ("glRasterPos4f" raster-pos-4f) :void
(x float)
(y float)
(z float)
(w float))
(defglfun ("glRasterPos4fv" raster-pos-4fv) :void
(v (:pointer float)))
(defglfun ("glRasterPos4i" raster-pos-4i) :void
(x int)
(y int)
(z int)
(w int))
(defglfun ("glRasterPos4iv" raster-pos-4iv) :void
(v (:pointer int)))
(defglfun ("glRasterPos4s" raster-pos-4s) :void
(x short)
(y short)
(z short)
(w short))
(defglfun ("glRasterPos4sv" raster-pos-4sv) :void
(v (:pointer short)))
(defglfun ("glRectd" rect-d) :void
(x1 double)
(y1 double)
(x2 double)
(y2 double))
(defglfun ("glRectdv" rect-dv) :void
(v1 (:pointer double))
(v2 (:pointer double)))
(defglfun ("glRectf" rect-f) :void
(x1 float)
(y1 float)
(x2 float)
(y2 float))
(defglfun ("glRectfv" rect-fv) :void
(v1 (:pointer float))
(v2 (:pointer float)))
(defglfun ("glRecti" rect-i) :void
(x1 int)
(y1 int)
(x2 int)
(y2 int))
(defglfun ("glRectiv" rect-iv) :void
(v1 (:pointer int))
(v2 (:pointer int)))
(defglfun ("glRects" rect-s) :void
(x1 short)
(y1 short)
(x2 short)
(y2 short))
(defglfun ("glRectsv" rect-sv) :void
(v1 (:pointer short))
(v2 (:pointer short)))
(defglfun ("glTexCoord1d" tex-coord-1d) :void
(s double))
(defglfun ("glTexCoord1dv" tex-coord-1dv) :void
(v (:pointer double)))
(defglfun ("glTexCoord1f" tex-coord-1f) :void
(s float))
(defglfun ("glTexCoord1fv" tex-coord-1fv) :void
(v (:pointer float)))
(defglfun ("glTexCoord1i" tex-coord-1i) :void
(s int))
(defglfun ("glTexCoord1iv" tex-coord-1iv) :void
(v (:pointer int)))
(defglfun ("glTexCoord1s" tex-coord-1s) :void
(s short))
(defglfun ("glTexCoord1sv" tex-coord-1sv) :void
(v (:pointer short)))
(defglfun ("glTexCoord2d" tex-coord-2d) :void
(s double)
(tee double))
(defglfun ("glTexCoord2dv" tex-coord-2dv) :void
(v (:pointer double)))
(defglfun ("glTexCoord2f" tex-coord-2f) :void
(s float)
(tee float))
(defglfun ("glTexCoord2fv" tex-coord-2fv) :void
(v (:pointer float)))
(defglfun ("glTexCoord2i" tex-coord-2i) :void
(s int)
(tee int))
(defglfun ("glTexCoord2iv" tex-coord-2iv) :void
(v (:pointer int)))
(defglfun ("glTexCoord2s" tex-coord-2s) :void
(s short)
(tee short))
(defglfun ("glTexCoord2sv" tex-coord-2sv) :void
(v (:pointer short)))
(defglfun ("glTexCoord3d" tex-coord-3d) :void
(s double)
(tee double)
(r double))
(defglfun ("glTexCoord3dv" tex-coord-3dv) :void
(v (:pointer double)))
(defglfun ("glTexCoord3f" tex-coord-3f) :void
(s float)
(tee float)
(r float))
(defglfun ("glTexCoord3fv" tex-coord-3fv) :void
(v (:pointer float)))
(defglfun ("glTexCoord3i" tex-coord-3i) :void
(s int)
(tee int)
(r int))
(defglfun ("glTexCoord3iv" tex-coord-3iv) :void
(v (:pointer int)))
(defglfun ("glTexCoord3s" tex-coord-3s) :void
(s short)
(tee short)
(r short))
(defglfun ("glTexCoord3sv" tex-coord-3sv) :void
(v (:pointer short)))
(defglfun ("glTexCoord4d" tex-coord-4d) :void
(s double)
(tee double)
(r double)
(q double))
(defglfun ("glTexCoord4dv" tex-coord-4dv) :void
(v (:pointer double)))
(defglfun ("glTexCoord4f" tex-coord-4f) :void
(s float)
(tee float)
(r float)
(q float))
(defglfun ("glTexCoord4fv" tex-coord-4fv) :void
(v (:pointer float)))
(defglfun ("glTexCoord4i" tex-coord-4i) :void
(s int)
(tee int)
(r int)
(q int))
(defglfun ("glTexCoord4iv" tex-coord-4iv) :void
(v (:pointer int)))
(defglfun ("glTexCoord4s" tex-coord-4s) :void
(s short)
(tee short)
(r short)
(q short))
(defglfun ("glTexCoord4sv" tex-coord-4sv) :void
(v (:pointer short)))
(defglfun ("glVertex2d" vertex-2d) :void
(x double)
(y double))
(defglfun ("glVertex2dv" vertex-2dv) :void
(v (:pointer double)))
(defglfun ("glVertex2f" vertex-2f) :void
(x float)
(y float))
(defglfun ("glVertex2fv" vertex-2fv) :void
(v (:pointer float)))
(defglfun ("glVertex2i" vertex-2i) :void
(x int)
(y int))
(defglfun ("glVertex2iv" vertex-2iv) :void
(v (:pointer int)))
(defglfun ("glVertex2s" vertex-2s) :void
(x short)
(y short))
(defglfun ("glVertex2sv" vertex-2sv) :void
(v (:pointer short)))
(defglfun ("glVertex3d" vertex-3d) :void
(x double)
(y double)
(z double))
(defglfun ("glVertex3dv" vertex-3dv) :void
(v (:pointer double)))
(defglfun ("glVertex3f" vertex-3f) :void
(x float)
(y float)
(z float))
(defglfun ("glVertex3fv" vertex-3fv) :void
(v (:pointer float)))
(defglfun ("glVertex3i" vertex-3i) :void
(x int)
(y int)
(z int))
(defglfun ("glVertex3iv" vertex-3iv) :void
(v (:pointer int)))
(defglfun ("glVertex3s" vertex-3s) :void
(x short)
(y short)
(z short))
(defglfun ("glVertex3sv" vertex-3sv) :void
(v (:pointer short)))
(defglfun ("glVertex4d" vertex-4d) :void
(x double)
(y double)
(z double)
(w double))
(defglfun ("glVertex4dv" vertex-4dv) :void
(v (:pointer double)))
(defglfun ("glVertex4f" vertex-4f) :void
(x float)
(y float)
(z float)
(w float))
(defglfun ("glVertex4fv" vertex-4fv) :void
(v (:pointer float)))
(defglfun ("glVertex4i" vertex-4i) :void
(x int)
(y int)
(z int)
(w int))
(defglfun ("glVertex4iv" vertex-4iv) :void
(v (:pointer int)))
(defglfun ("glVertex4s" vertex-4s) :void
(x short)
(y short)
(z short)
(w short))
(defglfun ("glVertex4sv" vertex-4sv) :void
(v (:pointer short)))
(defglfun ("glClipPlane" clip-plane) :void
(plane enum)
(equation (:pointer double)))
(defglfun ("glColorMaterial" color-material) :void
(face enum)
(mode enum))
(defglfun ("glFogi" fog-i) :void
(pname enum)
(param int))
(defglfun ("glFogiv" fog-iv) :void
(pname enum)
(params (:pointer int)))
(defglfun ("glLighti" light-i) :void
(light enum)
(pname enum)
(param int))
(defglfun ("glLightiv" light-iv) :void
(light enum)
(pname enum)
(params (:pointer int)))
(defglfun ("glLightModeli" light-model-i) :void
(pname enum)
(param int))
(defglfun ("glLightModeliv" light-model-iv) :void
(pname enum)
(params (:pointer int)))
(defglfun ("glLineStipple" line-stipple) :void
(factor int)
(pattern ushort))
(defglfun ("glMateriali" material-i) :void
(face enum)
(pname enum)
(param int))
(defglfun ("glMaterialiv" material-iv) :void
(face enum)
(pname enum)
(params (:pointer int)))
(defglfun ("glPolygonStipple" polygon-stipple) :void
(mask offset-or-pointer))
(defglfun ("glTexGend" tex-gen-d) :void
(coord enum)
(pname enum)
(param double))
(defglfun ("glTexGendv" tex-gen-dv) :void
(coord enum)
(pname enum)
(params (:pointer double)))
(defglfun ("glTexGenf" tex-gen-f) :void
(coord enum)
(pname enum)
(param float))
(defglfun ("glTexGenfv" tex-gen-fv) :void
(coord enum)
(pname enum)
(params (:pointer float)))
(defglfun ("glTexGeni" tex-gen-i) :void
(coord enum)
(pname enum)
(param int))
(defglfun ("glTexGeniv" tex-gen-iv) :void
(coord enum)
(pname enum)
(params (:pointer int)))
(defglfun ("glFeedbackBuffer" feedback-buffer) :void
(size sizei)
(type enum)
(buffer (:pointer float)))
(defglfun ("glSelectBuffer" select-buffer) :void
(size sizei)
(buffer (:pointer uint)))
(defglfun ("glRenderMode" render-mode) int
(mode enum))
(defglfun ("glInitNames" init-names) :void)
(defglfun ("glLoadName" load-name) :void
(name uint))
(defglfun ("glPassThrough" pass-through) :void
(token float))
(defglfun ("glPopName" pop-name) :void)
(defglfun ("glPushName" push-name) :void
(name uint))
(defglfun ("glClearAccum" clear-accum) :void
(red float)
(green float)
(blue float)
(alpha float))
(defglfun ("glClearIndex" clear-index) :void
(c float))
(defglfun ("glIndexMask" index-mask) :void
(mask uint))
(defglfun ("glAccum" accum) :void
(op enum)
(value float))
(defglfun ("glPopAttrib" pop-attrib) :void)
(defglfun ("glPushAttrib" push-attrib) :void
(mask AttribMask))
(defglfun ("glMap1d" map-1d) :void
(target enum)
(u1 double)
(u2 double)
(stride int)
(order int)
(points (:pointer double)))
(defglfun ("glMap1f" map-1f) :void
(target enum)
(u1 float)
(u2 float)
(stride int)
(order int)
(points (:pointer float)))
(defglfun ("glMap2d" map-2d) :void
(target enum)
(u1 double)
(u2 double)
(ustride int)
(uorder int)
(v1 double)
(v2 double)
(vstride int)
(vorder int)
(points (:pointer double)))
(defglfun ("glMap2f" map-2f) :void
(target enum)
(u1 float)
(u2 float)
(ustride int)
(uorder int)
(v1 float)
(v2 float)
(vstride int)
(vorder int)
(points (:pointer float)))
(defglfun ("glMapGrid1d" map-grid-1d) :void
(un int)
(u1 double)
(u2 double))
(defglfun ("glMapGrid1f" map-grid-1f) :void
(un int)
(u1 float)
(u2 float))
(defglfun ("glMapGrid2d" map-grid-2d) :void
(un int)
(u1 double)
(u2 double)
(vn int)
(v1 double)
(v2 double))
(defglfun ("glMapGrid2f" map-grid-2f) :void
(un int)
(u1 float)
(u2 float)
(vn int)
(v1 float)
(v2 float))
(defglfun ("glEvalCoord1d" eval-coord-1d) :void
(u double))
(defglfun ("glEvalCoord1dv" eval-coord-1dv) :void
(u (:pointer double)))
(defglfun ("glEvalCoord1f" eval-coord-1f) :void
(u float))
(defglfun ("glEvalCoord1fv" eval-coord-1fv) :void
(u (:pointer float)))
(defglfun ("glEvalCoord2d" eval-coord-2d) :void
(u double)
(v double))
(defglfun ("glEvalCoord2dv" eval-coord-2dv) :void
(u (:pointer double)))
(defglfun ("glEvalCoord2f" eval-coord-2f) :void
(u float)
(v float))
(defglfun ("glEvalCoord2fv" eval-coord-2fv) :void
(u (:pointer float)))
(defglfun ("glEvalMesh1" eval-mesh-1) :void
(mode enum)
(i1 int)
(i2 int))
(defglfun ("glEvalPoint1" eval-point-1) :void
(i int))
(defglfun ("glEvalMesh2" eval-mesh-2) :void
(mode enum)
(i1 int)
(i2 int)
(j1 int)
(j2 int))
(defglfun ("glEvalPoint2" eval-point-2) :void
(i int)
(j int))
(defglfun ("glPixelZoom" pixel-zoom) :void
(xfactor float)
(yfactor float))
(defglfun ("glPixelTransferf" pixel-transfer-f) :void
(pname enum)
(param float))
(defglfun ("glPixelTransferi" pixel-transfer-i) :void
(pname enum)
(param int))
(defglfun ("glPixelMapfv" pixel-map-fv) :void
(map enum)
(mapsize sizei)
(values offset-or-pointer))
(defglfun ("glPixelMapuiv" pixel-map-uiv) :void
(map enum)
(mapsize sizei)
(values offset-or-pointer))
(defglfun ("glPixelMapusv" pixel-map-usv) :void
(map enum)
(mapsize sizei)
(values offset-or-pointer))
(defglfun ("glCopyPixels" copy-pixels) :void
(x int)
(y int)
(width sizei)
(height sizei)
(type enum))
(defglfun ("glDrawPixels" draw-pixels) :void
(width sizei)
(height sizei)
(format enum)
(type enum)
(pixels offset-or-pointer))
(defglfun ("glGetClipPlane" get-clip-plane) :void
(plane enum)
(equation (:pointer double)))
(defglfun ("glGetLightiv" get-light-iv) :void
(light enum)
(pname enum)
(params (:pointer int)))
(defglfun ("glGetMapdv" get-map-dv) :void
(target enum)
(query enum)
(v (:pointer double)))
(defglfun ("glGetMapfv" get-map-fv) :void
(target enum)
(query enum)
(v (:pointer float)))
(defglfun ("glGetMapiv" get-map-iv) :void
(target enum)
(query enum)
(v (:pointer int)))
(defglfun ("glGetMaterialiv" get-material-iv) :void
(face enum)
(pname enum)
(params (:pointer int)))
(defglfun ("glGetPixelMapfv" get-pixel-map-fv) :void
(map enum)
(values offset-or-pointer))
(defglfun ("glGetPixelMapuiv" get-pixel-map-uiv) :void
(map enum)
(values offset-or-pointer))
(defglfun ("glGetPixelMapusv" get-pixel-map-usv) :void
(map enum)
(values offset-or-pointer))
(defglfun ("glGetPolygonStipple" get-polygon-stipple) :void
(mask offset-or-pointer))
(defglfun ("glGetTexGendv" get-tex-gen-dv) :void
(coord enum)
(pname enum)
(params (:pointer double)))
(defglfun ("glGetTexGenfv" get-tex-gen-fv) :void
(coord enum)
(pname enum)
(params (:pointer float)))
(defglfun ("glGetTexGeniv" get-tex-gen-iv) :void
(coord enum)
(pname enum)
(params (:pointer int)))
(defglfun ("glIsList" is-list) boolean
(list uint))
(defglfun ("glFrustum" frustum) :void
(left double)
(right double)
(bottom double)
(top double)
(zNear double)
(zFar double))
(defglfun ("glLoadMatrixd" load-matrix-d) :void
(m (:pointer double)))
(defglfun ("glMultMatrixd" mult-matrix-d) :void
(m (:pointer double)))
(defglfun ("glOrtho" ortho) :void
(left double)
(right double)
(bottom double)
(top double)
(zNear double)
(zFar double))
(defglfun ("glRotated" rotate-d) :void
(angle double)
(x double)
(y double)
(z double))
(defglfun ("glScaled" scale-d) :void
(x double)
(y double)
(z double))
(defglfun ("glTranslated" translate-d) :void
(x double)
(y double)
(z double))
(defglfun ("glCopyTexImage1D" copy-tex-image-1d) :void
(target enum)
(level int)
(internalformat enum)
(x int)
(y int)
(width sizei)
(border int))
(defglfun ("glCopyTexSubImage1D" copy-tex-sub-image-1d) :void
(target enum)
(level int)
(xoffset int)
(x int)
(y int)
(width sizei))
(defglfun ("glTexSubImage1D" tex-sub-image-1d) :void
(target enum)
(level int)
(xoffset int)
(width sizei)
(format enum)
(type enum)
(pixels offset-or-pointer))
(defglfun ("glArrayElement" array-element) :void
(i int))
(defglfun ("glEdgeFlagPointer" edge-flag-pointer) :void
(stride sizei)
(pointer offset-or-pointer))
(defglfun ("glIndexPointer" index-pointer) :void
(type enum)
(stride sizei)
(pointer offset-or-pointer))
(defglfun ("glInterleavedArrays" interleaved-arrays) :void
(format enum)
(stride sizei)
(pointer (:pointer :void)))
(defglfun ("glAreTexturesResident" are-textures-resident) boolean
(n sizei)
(textures (:pointer uint))
(residences (:pointer boolean)))
(defglfun ("glPrioritizeTextures" prioritize-textures) :void
(n sizei)
(textures (:pointer uint))
(priorities (:pointer float)))
(defglfun ("glIndexub" index-ub) :void
(c ubyte))
(defglfun ("glIndexubv" index-ubv) :void
(c (:pointer ubyte)))
(defglfun ("glPopClientAttrib" pop-client-attrib) :void)
(defglfun ("glPushClientAttrib" push-client-attrib) :void
(mask ClientAttribMask))
(defglextfun ("glCompressedTexImage1D" compressed-tex-image-1d) :void
(target enum)
(level int)
(internalformat enum)
(width sizei)
(border int)
(imageSize sizei)
(data offset-or-pointer))
(defglextfun ("glCompressedTexSubImage1D" compressed-tex-sub-image-1d) :void
(target enum)
(level int)
(xoffset int)
(width sizei)
(format enum)
(imageSize sizei)
(data offset-or-pointer))
(defglextfun ("glGetCompressedTexImage" get-compressed-tex-image) :void
(target enum)
(level int)
(img offset-or-pointer))
(defglextfun ("glMultiTexCoord1d" multi-tex-coord-1d) :void
(target enum)
(s double))
(defglextfun ("glMultiTexCoord1dv" multi-tex-coord-1dv) :void
(target enum)
(v (:pointer double)))
(defglextfun ("glMultiTexCoord1f" multi-tex-coord-1f) :void
(target enum)
(s float))
(defglextfun ("glMultiTexCoord1fv" multi-tex-coord-1fv) :void
(target enum)
(v (:pointer float)))
(defglextfun ("glMultiTexCoord1i" multi-tex-coord-1i) :void
(target enum)
(s int))
(defglextfun ("glMultiTexCoord1iv" multi-tex-coord-1iv) :void
(target enum)
(v (:pointer int)))
(defglextfun ("glMultiTexCoord1s" multi-tex-coord-1s) :void
(target enum)
(s short))
(defglextfun ("glMultiTexCoord1sv" multi-tex-coord-1sv) :void
(target enum)
(v (:pointer short)))
(defglextfun ("glMultiTexCoord2d" multi-tex-coord-2d) :void
(target enum)
(s double)
(tee double))
(defglextfun ("glMultiTexCoord2dv" multi-tex-coord-2dv) :void
(target enum)
(v (:pointer double)))
(defglextfun ("glMultiTexCoord2f" multi-tex-coord-2f) :void
(target enum)
(s float)
(tee float))
(defglextfun ("glMultiTexCoord2fv" multi-tex-coord-2fv) :void
(target enum)
(v (:pointer float)))
(defglextfun ("glMultiTexCoord2i" multi-tex-coord-2i) :void
(target enum)
(s int)
(tee int))
(defglextfun ("glMultiTexCoord2iv" multi-tex-coord-2iv) :void
(target enum)
(v (:pointer int)))
(defglextfun ("glMultiTexCoord2s" multi-tex-coord-2s) :void
(target enum)
(s short)
(tee short))
(defglextfun ("glMultiTexCoord2sv" multi-tex-coord-2sv) :void
(target enum)
(v (:pointer short)))
(defglextfun ("glMultiTexCoord3d" multi-tex-coord-3d) :void
(target enum)
(s double)
(tee double)
(r double))
(defglextfun ("glMultiTexCoord3dv" multi-tex-coord-3dv) :void
(target enum)
(v (:pointer double)))
(defglextfun ("glMultiTexCoord3f" multi-tex-coord-3f) :void
(target enum)
(s float)
(tee float)
(r float))
(defglextfun ("glMultiTexCoord3fv" multi-tex-coord-3fv) :void
(target enum)
(v (:pointer float)))
(defglextfun ("glMultiTexCoord3i" multi-tex-coord-3i) :void
(target enum)
(s int)
(tee int)
(r int))
(defglextfun ("glMultiTexCoord3iv" multi-tex-coord-3iv) :void
(target enum)
(v (:pointer int)))
(defglextfun ("glMultiTexCoord3s" multi-tex-coord-3s) :void
(target enum)
(s short)
(tee short)
(r short))
(defglextfun ("glMultiTexCoord3sv" multi-tex-coord-3sv) :void
(target enum)
(v (:pointer short)))
(defglextfun ("glMultiTexCoord4d" multi-tex-coord-4d) :void
(target enum)
(s double)
(tee double)
(r double)
(q double))
(defglextfun ("glMultiTexCoord4dv" multi-tex-coord-4dv) :void
(target enum)
(v (:pointer double)))
(defglextfun ("glMultiTexCoord4fv" multi-tex-coord-4fv) :void
(target enum)
(v (:pointer float)))
(defglextfun ("glMultiTexCoord4i" multi-tex-coord-4i) :void
(target enum)
(s int)
(tee int)
(r int)
(q int))
(defglextfun ("glMultiTexCoord4iv" multi-tex-coord-4iv) :void
(target enum)
(v (:pointer int)))
(defglextfun ("glMultiTexCoord4s" multi-tex-coord-4s) :void
(target enum)
(s short)
(tee short)
(r short)
(q short))
(defglextfun ("glMultiTexCoord4sv" multi-tex-coord-4sv) :void
(target enum)
(v (:pointer short)))
(defglextfun ("glLoadTransposeMatrixf" load-transpose-matrix-f) :void
(m (:pointer float)))
(defglextfun ("glLoadTransposeMatrixd" load-transpose-matrix-d) :void
(m (:pointer double)))
(defglextfun ("glMultTransposeMatrixf" mult-transpose-matrix-f) :void
(m (:pointer float)))
(defglextfun ("glMultTransposeMatrixd" mult-transpose-matrix-d) :void
(m (:pointer double)))
(defglextfun ("glMultiDrawArrays" multi-draw-arrays) :void
(mode enum)
(first (:pointer int))
(count (:pointer sizei))
(drawcount sizei))
(defglextfun ("glMultiDrawElements" multi-draw-elements) :void
(mode enum)
(count (:pointer sizei))
(type enum)
(indices (:pointer (:pointer :void)))
(drawcount sizei))
(defglextfun ("glPointParameteri" point-parameter-i) :void
(pname enum)
(param int))
(defglextfun ("glPointParameteriv" point-parameter-iv) :void
(pname enum)
(params (:pointer int)))
(defglextfun ("glFogCoordf" fog-coord-f) :void
(coord float))
(defglextfun ("glFogCoordfv" fog-coord-fv) :void
(coord (:pointer float)))
(defglextfun ("glFogCoordd" fog-coord-d) :void
(coord double))
(defglextfun ("glFogCoorddv" fog-coord-dv) :void
(coord (:pointer double)))
(defglextfun ("glFogCoordPointer" fog-coord-pointer) :void
(type enum)
(stride sizei)
(pointer offset-or-pointer))
(defglextfun ("glSecondaryColor3b" secondary-color-3b) :void
(red byte)
(green byte)
(blue byte))
(defglextfun ("glSecondaryColor3bv" secondary-color-3bv) :void
(v (:pointer byte)))
(defglextfun ("glSecondaryColor3d" secondary-color-3d) :void
(red double)
(green double)
(blue double))
(defglextfun ("glSecondaryColor3dv" secondary-color-3dv) :void
(v (:pointer double)))
(defglextfun ("glSecondaryColor3f" secondary-color-3f) :void
(red float)
(green float)
(blue float))
(defglextfun ("glSecondaryColor3fv" secondary-color-3fv) :void
(v (:pointer float)))
(defglextfun ("glSecondaryColor3i" secondary-color-3i) :void
(red int)
(green int)
(blue int))
(defglextfun ("glSecondaryColor3iv" secondary-color-3iv) :void
(v (:pointer int)))
(defglextfun ("glSecondaryColor3s" secondary-color-3s) :void
(red short)
(green short)
(blue short))
(defglextfun ("glSecondaryColor3sv" secondary-color-3sv) :void
(v (:pointer short)))
(defglextfun ("glSecondaryColor3ub" secondary-color-3ub) :void
(red ubyte)
(green ubyte)
(blue ubyte))
(defglextfun ("glSecondaryColor3ubv" secondary-color-3ubv) :void
(v (:pointer ubyte)))
(defglextfun ("glSecondaryColor3ui" secondary-color-3ui) :void
(red uint)
(green uint)
(blue uint))
(defglextfun ("glSecondaryColor3uiv" secondary-color-3uiv) :void
(v (:pointer uint)))
(defglextfun ("glSecondaryColor3us" secondary-color-3us) :void
(red ushort)
(green ushort)
(blue ushort))
(defglextfun ("glSecondaryColor3usv" secondary-color-3usv) :void
(v (:pointer ushort)))
(defglextfun ("glSecondaryColorPointer" secondary-color-pointer) :void
(size int)
(type enum)
(stride sizei)
(pointer offset-or-pointer))
(defglextfun ("glWindowPos2d" window-pos-2d) :void
(x double)
(y double))
(defglextfun ("glWindowPos2dv" window-pos-2dv) :void
(v (:pointer double)))
(defglextfun ("glWindowPos2f" window-pos-2f) :void
(x float)
(y float))
(defglextfun ("glWindowPos2fv" window-pos-2fv) :void
(v (:pointer float)))
(defglextfun ("glWindowPos2i" window-pos-2i) :void
(x int)
(y int))
(defglextfun ("glWindowPos2iv" window-pos-2iv) :void
(v (:pointer int)))
(defglextfun ("glWindowPos2s" window-pos-2s) :void
(x short)
(y short))
(defglextfun ("glWindowPos2sv" window-pos-2sv) :void
(v (:pointer short)))
(defglextfun ("glWindowPos3d" window-pos-3d) :void
(x double)
(y double)
(z double))
(defglextfun ("glWindowPos3dv" window-pos-3dv) :void
(v (:pointer double)))
(defglextfun ("glWindowPos3f" window-pos-3f) :void
(x float)
(y float)
(z float))
(defglextfun ("glWindowPos3fv" window-pos-3fv) :void
(v (:pointer float)))
(defglextfun ("glWindowPos3i" window-pos-3i) :void
(x int)
(y int)
(z int))
(defglextfun ("glWindowPos3iv" window-pos-3iv) :void
(v (:pointer int)))
(defglextfun ("glWindowPos3s" window-pos-3s) :void
(x short)
(y short)
(z short))
(defglextfun ("glWindowPos3sv" window-pos-3sv) :void
(v (:pointer short)))
(defglextfun ("glGetQueryObjectiv" get-query-object-iv) :void
(id uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetBufferSubData" get-buffer-sub-data) :void
(target enum)
(offset intptr)
(size sizeiptr)
(data (:pointer :void)))
(defglextfun ("glMapBuffer" map-buffer) (:pointer :void)
(target enum)
(access enum))
(defglextfun ("glGetVertexAttribdv" get-vertex-attrib-dv) :void
(index uint)
(pname enum)
(params (:pointer double)))
(defglextfun ("glVertexAttrib1d" vertex-attrib-1d) :void
(index uint)
(x double))
(defglextfun ("glVertexAttrib1dv" vertex-attrib-1dv) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttrib1s" vertex-attrib-1s) :void
(index uint)
(x short))
(defglextfun ("glVertexAttrib1sv" vertex-attrib-1sv) :void
(index uint)
(v (:pointer short)))
(defglextfun ("glVertexAttrib2d" vertex-attrib-2d) :void
(index uint)
(x double)
(y double))
(defglextfun ("glVertexAttrib2dv" vertex-attrib-2dv) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttrib2s" vertex-attrib-2s) :void
(index uint)
(x short)
(y short))
(defglextfun ("glVertexAttrib2sv" vertex-attrib-2sv) :void
(index uint)
(v (:pointer short)))
(defglextfun ("glVertexAttrib3d" vertex-attrib-3d) :void
(index uint)
(x double)
(y double)
(z double))
(defglextfun ("glVertexAttrib3dv" vertex-attrib-3dv) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttrib3s" vertex-attrib-3s) :void
(index uint)
(x short)
(y short)
(z short))
(defglextfun ("glVertexAttrib3sv" vertex-attrib-3sv) :void
(index uint)
(v (:pointer short)))
(defglextfun ("glVertexAttrib4Nbv" vertex-attrib-4nbv) :void
(index uint)
(v (:pointer byte)))
(defglextfun ("glVertexAttrib4Niv" vertex-attrib-4niv) :void
(index uint)
(v (:pointer int)))
(defglextfun ("glVertexAttrib4Nsv" vertex-attrib-4nsv) :void
(index uint)
(v (:pointer short)))
(defglextfun ("glVertexAttrib4Nub" vertex-attrib-4nub) :void
(index uint)
(x ubyte)
(y ubyte)
(z ubyte)
(w ubyte))
(defglextfun ("glVertexAttrib4Nubv" vertex-attrib-4nubv) :void
(index uint)
(v (:pointer ubyte)))
(defglextfun ("glVertexAttrib4Nuiv" vertex-attrib-4nuiv) :void
(index uint)
(v (:pointer uint)))
(defglextfun ("glVertexAttrib4Nusv" vertex-attrib-4nusv) :void
(index uint)
(v (:pointer ushort)))
(defglextfun ("glVertexAttrib4bv" vertex-attrib-4bv) :void
(index uint)
(v (:pointer byte)))
(defglextfun ("glVertexAttrib4d" vertex-attrib-4d) :void
(index uint)
(x double)
(y double)
(z double)
(w double))
(defglextfun ("glVertexAttrib4dv" vertex-attrib-4dv) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttrib4iv" vertex-attrib-4iv) :void
(index uint)
(v (:pointer int)))
(defglextfun ("glVertexAttrib4s" vertex-attrib-4s) :void
(index uint)
(x short)
(y short)
(z short)
(w short))
(defglextfun ("glVertexAttrib4sv" vertex-attrib-4sv) :void
(index uint)
(v (:pointer short)))
(defglextfun ("glVertexAttrib4ubv" vertex-attrib-4ubv) :void
(index uint)
(v (:pointer ubyte)))
(defglextfun ("glVertexAttrib4uiv" vertex-attrib-4uiv) :void
(index uint)
(v (:pointer uint)))
(defglextfun ("glVertexAttrib4usv" vertex-attrib-4usv) :void
(index uint)
(v (:pointer ushort)))
(defglextfun ("glClampColor" clamp-color) :void
(target enum)
(clamp enum))
(defglextfun ("glBeginConditionalRender" begin-conditional-render) :void
(id uint)
(mode enum))
(defglextfun ("glEndConditionalRender" end-conditional-render) :void)
(defglextfun ("glVertexAttribI1i" vertex-attrib-i1i) :void
(index uint)
(x int))
(defglextfun ("glVertexAttribI2i" vertex-attrib-i2i) :void
(index uint)
(x int)
(y int))
(defglextfun ("glVertexAttribI3i" vertex-attrib-i3i) :void
(index uint)
(x int)
(y int)
(z int))
(defglextfun ("glVertexAttribI1ui" vertex-attrib-i1ui) :void
(index uint)
(x uint))
(defglextfun ("glVertexAttribI2ui" vertex-attrib-i2ui) :void
(index uint)
(x uint)
(y uint))
(defglextfun ("glVertexAttribI3ui" vertex-attrib-i3ui) :void
(index uint)
(x uint)
(y uint)
(z uint))
(defglextfun ("glVertexAttribI1iv" vertex-attrib-i1iv) :void
(index uint)
(v (:pointer int)))
(defglextfun ("glVertexAttribI2iv" vertex-attrib-i2iv) :void
(index uint)
(v (:pointer int)))
(defglextfun ("glVertexAttribI3iv" vertex-attrib-i3iv) :void
(index uint)
(v (:pointer int)))
(defglextfun ("glVertexAttribI1uiv" vertex-attrib-i1uiv) :void
(index uint)
(v (:pointer uint)))
(defglextfun ("glVertexAttribI2uiv" vertex-attrib-i2uiv) :void
(index uint)
(v (:pointer uint)))
(defglextfun ("glVertexAttribI3uiv" vertex-attrib-i3uiv) :void
(index uint)
(v (:pointer uint)))
(defglextfun ("glVertexAttribI4bv" vertex-attrib-i4bv) :void
(index uint)
(v (:pointer byte)))
(defglextfun ("glVertexAttribI4sv" vertex-attrib-i4sv) :void
(index uint)
(v (:pointer short)))
(defglextfun ("glVertexAttribI4ubv" vertex-attrib-i4ubv) :void
(index uint)
(v (:pointer ubyte)))
(defglextfun ("glVertexAttribI4usv" vertex-attrib-i4usv) :void
(index uint)
(v (:pointer ushort)))
(defglextfun ("glBindFragDataLocation" bind-frag-data-location) :void
(program uint)
(color uint)
(name (:pointer char)))
(defglextfun ("glPrimitiveRestartIndex" primitive-restart-index) :void
(index uint))
(defglextfun ("glGetnCompressedTexImage" getn-compressed-tex-image) :void
(target enum)
(lod int)
(bufSize sizei)
(pixels (:pointer :void)))
(defglextfun ("glGetnTexImage" getn-tex-image) :void
(target enum)
(level int)
(format enum)
(type enum)
(bufSize sizei)
(pixels (:pointer :void)))
(defglextfun ("glGetnUniformdv" getn-uniform-dv) :void
(program uint)
(location int)
(bufSize sizei)
(params (:pointer double)))
(defglextfun ("glGetnMapdv" getn-map-dv) :void
(target enum)
(query enum)
(bufSize sizei)
(v (:pointer double)))
(defglextfun ("glGetnMapfv" getn-map-fv) :void
(target enum)
(query enum)
(bufSize sizei)
(v (:pointer float)))
(defglextfun ("glGetnMapiv" getn-map-iv) :void
(target enum)
(query enum)
(bufSize sizei)
(v (:pointer int)))
(defglextfun ("glGetnPixelMapfv" getn-pixel-map-fv) :void
(map enum)
(bufSize sizei)
(values (:pointer float)))
(defglextfun ("glGetnPixelMapuiv" getn-pixel-map-uiv) :void
(map enum)
(bufSize sizei)
(values (:pointer uint)))
(defglextfun ("glGetnPixelMapusv" getn-pixel-map-usv) :void
(map enum)
(bufSize sizei)
(values (:pointer ushort)))
(defglextfun ("glGetnPolygonStipple" getn-polygon-stipple) :void
(bufSize sizei)
(pattern (:pointer ubyte)))
(defglextfun ("glGetnColorTable" getn-color-table) :void
(target enum)
(format enum)
(type enum)
(bufSize sizei)
(table (:pointer :void)))
(defglextfun ("glGetnConvolutionFilter" getn-convolution-filter) :void
(target enum)
(format enum)
(type enum)
(bufSize sizei)
(image (:pointer :void)))
(defglextfun ("glGetnSeparableFilter" getn-separable-filter) :void
(target enum)
(format enum)
(type enum)
(rowBufSize sizei)
(row (:pointer :void))
(columnBufSize sizei)
(column (:pointer :void))
(span (:pointer :void)))
(defglextfun ("glGetnHistogram" getn-histogram) :void
(target enum)
(reset boolean)
(format enum)
(type enum)
(bufSize sizei)
(values (:pointer :void)))
(defglextfun ("glGetnMinmax" getn-minmax) :void
(target enum)
(reset boolean)
(format enum)
(type enum)
(bufSize sizei)
(values (:pointer :void)))
(defglextfun ("glTbufferMask3DFX" tbuffer-mask-3dfx) :void
(mask uint))
(defglextfun ("glDebugMessageEnableAMD" debug-message-enable-amd) :void
(category enum)
(severity enum)
(count sizei)
(ids (:pointer uint))
(enabled boolean))
(defglextfun ("glDebugMessageInsertAMD" debug-message-insert-amd) :void
(category enum)
(severity enum)
(id uint)
(length sizei)
(buf (:pointer char)))
(defglextfun ("glDebugMessageCallbackAMD" debug-message-callback-amd) :void
(callback debugproc-amd)
(userParam (:pointer :void)))
(defglextfun ("glGetDebugMessageLogAMD" get-debug-message-log-amd) uint
(count uint)
(bufsize sizei)
(categories (:pointer enum))
(severities (:pointer uint))
(ids (:pointer uint))
(lengths (:pointer sizei))
(message (:pointer char)))
(defglextfun ("glBlendFuncIndexedAMD" blend-func-indexed-amd) :void
(buf uint)
(src enum)
(dst enum))
(defglextfun ("glBlendFuncSeparateIndexedAMD" blend-func-separate-indexed-amd) :void
(buf uint)
(srcRGB enum)
(dstRGB enum)
(srcAlpha enum)
(dstAlpha enum))
(defglextfun ("glBlendEquationIndexedAMD" blend-equation-indexed-amd) :void
(buf uint)
(mode enum))
(defglextfun ("glBlendEquationSeparateIndexedAMD" blend-equation-separate-indexed-amd) :void
(buf uint)
(modeRGB enum)
(modeAlpha enum))
(defglextfun ("glUniform1i64NV" uniform-1i64-nv) :void
(location int)
(x int64-ext))
(defglextfun ("glUniform2i64NV" uniform-2i64-nv) :void
(location int)
(x int64-ext)
(y int64-ext))
(defglextfun ("glUniform3i64NV" uniform-3i64-nv) :void
(location int)
(x int64-ext)
(y int64-ext)
(z int64-ext))
(defglextfun ("glUniform4i64NV" uniform-4i64-nv) :void
(location int)
(x int64-ext)
(y int64-ext)
(z int64-ext)
(w int64-ext))
(defglextfun ("glUniform1i64vNV" uniform-1i64v-nv) :void
(location int)
(count sizei)
(value (:pointer int64-ext)))
(defglextfun ("glUniform2i64vNV" uniform-2i64v-nv) :void
(location int)
(count sizei)
(value (:pointer int64-ext)))
(defglextfun ("glUniform3i64vNV" uniform-3i64v-nv) :void
(location int)
(count sizei)
(value (:pointer int64-ext)))
(defglextfun ("glUniform4i64vNV" uniform-4i64v-nv) :void
(location int)
(count sizei)
(value (:pointer int64-ext)))
(defglextfun ("glUniform1ui64NV" uniform-1ui64-nv) :void
(location int)
(x uint64-ext))
(defglextfun ("glUniform2ui64NV" uniform-2ui64-nv) :void
(location int)
(x uint64-ext)
(y uint64-ext))
(defglextfun ("glUniform3ui64NV" uniform-3ui64-nv) :void
(location int)
(x uint64-ext)
(y uint64-ext)
(z uint64-ext))
(defglextfun ("glUniform4ui64NV" uniform-4ui64-nv) :void
(location int)
(x uint64-ext)
(y uint64-ext)
(z uint64-ext)
(w uint64-ext))
(defglextfun ("glUniform1ui64vNV" uniform-1ui64v-nv) :void
(location int)
(count sizei)
(value (:pointer uint64-ext)))
(defglextfun ("glUniform2ui64vNV" uniform-2ui64v-nv) :void
(location int)
(count sizei)
(value (:pointer uint64-ext)))
(defglextfun ("glUniform3ui64vNV" uniform-3ui64v-nv) :void
(location int)
(count sizei)
(value (:pointer uint64-ext)))
(defglextfun ("glUniform4ui64vNV" uniform-4ui64v-nv) :void
(location int)
(count sizei)
(value (:pointer uint64-ext)))
(defglextfun ("glGetUniformi64vNV" get-uniform-i64v-nv) :void
(program uint)
(location int)
(params (:pointer int64-ext)))
(defglextfun ("glGetUniformui64vNV" get-uniform-ui64v-nv) :void
(program uint)
(location int)
(params (:pointer uint64-ext)))
(defglextfun ("glProgramUniform1i64NV" program-uniform-1i64-nv) :void
(program uint)
(location int)
(x int64-ext))
(defglextfun ("glProgramUniform2i64NV" program-uniform-2i64-nv) :void
(program uint)
(location int)
(x int64-ext)
(y int64-ext))
(defglextfun ("glProgramUniform3i64NV" program-uniform-3i64-nv) :void
(program uint)
(location int)
(x int64-ext)
(y int64-ext)
(z int64-ext))
(defglextfun ("glProgramUniform4i64NV" program-uniform-4i64-nv) :void
(program uint)
(location int)
(x int64-ext)
(y int64-ext)
(z int64-ext)
(w int64-ext))
(defglextfun ("glProgramUniform1i64vNV" program-uniform-1i64v-nv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer int64-ext)))
(defglextfun ("glProgramUniform2i64vNV" program-uniform-2i64v-nv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer int64-ext)))
(defglextfun ("glProgramUniform3i64vNV" program-uniform-3i64v-nv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer int64-ext)))
(defglextfun ("glProgramUniform4i64vNV" program-uniform-4i64v-nv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer int64-ext)))
(defglextfun ("glProgramUniform1ui64NV" program-uniform-1ui64-nv) :void
(program uint)
(location int)
(x uint64-ext))
(defglextfun ("glProgramUniform2ui64NV" program-uniform-2ui64-nv) :void
(program uint)
(location int)
(x uint64-ext)
(y uint64-ext))
(defglextfun ("glProgramUniform3ui64NV" program-uniform-3ui64-nv) :void
(program uint)
(location int)
(x uint64-ext)
(y uint64-ext)
(z uint64-ext))
(defglextfun ("glProgramUniform4ui64NV" program-uniform-4ui64-nv) :void
(program uint)
(location int)
(x uint64-ext)
(y uint64-ext)
(z uint64-ext)
(w uint64-ext))
(defglextfun ("glProgramUniform1ui64vNV" program-uniform-1ui64v-nv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer uint64-ext)))
(defglextfun ("glProgramUniform2ui64vNV" program-uniform-2ui64v-nv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer uint64-ext)))
(defglextfun ("glProgramUniform3ui64vNV" program-uniform-3ui64v-nv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer uint64-ext)))
(defglextfun ("glProgramUniform4ui64vNV" program-uniform-4ui64v-nv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer uint64-ext)))
(defglextfun ("glVertexAttribParameteriAMD" vertex-attrib-parameter-i-amd) :void
(index uint)
(pname enum)
(param int))
(defglextfun ("glMultiDrawArraysIndirectAMD" multi-draw-arrays-indirect-amd) :void
(mode enum)
(indirect (:pointer :void))
(primcount sizei)
(stride sizei))
(defglextfun ("glMultiDrawElementsIndirectAMD" multi-draw-elements-indirect-amd) :void
(mode enum)
(type enum)
(indirect (:pointer :void))
(primcount sizei)
(stride sizei))
(defglextfun ("glGenNamesAMD" gen-names-amd) :void
(identifier enum)
(num uint)
(names (:pointer uint)))
(defglextfun ("glDeleteNamesAMD" delete-names-amd) :void
(identifier enum)
(num uint)
(names (:pointer uint)))
(defglextfun ("glIsNameAMD" is-name-amd) boolean
(identifier enum)
(name uint))
(defglextfun ("glQueryObjectParameteruiAMD" query-object-parameter-ui-amd) :void
(target enum)
(id uint)
(pname enum)
(param uint))
(defglextfun ("glSetMultisamplefvAMD" set-multisample-fv-amd) :void
(pname enum)
(index uint)
(val (:pointer float)))
(defglextfun ("glTexStorageSparseAMD" tex-storage-sparse-amd) :void
(target enum)
(internalFormat enum)
(width sizei)
(height sizei)
(depth sizei)
(layers sizei)
(flags bitfield))
(defglextfun ("glTextureStorageSparseAMD" texture-storage-sparse-amd) :void
(texture uint)
(target enum)
(internalFormat enum)
(width sizei)
(height sizei)
(depth sizei)
(layers sizei)
(flags bitfield))
(defglextfun ("glStencilOpValueAMD" stencil-op-value-amd) :void
(face enum)
(value uint))
(defglextfun ("glTessellationFactorAMD" tessellation-factor-amd) :void
(factor float))
(defglextfun ("glTessellationModeAMD" tessellation-mode-amd) :void
(mode enum))
(defglextfun ("glElementPointerAPPLE" element-pointer-apple) :void
(type enum)
(pointer (:pointer :void)))
(defglextfun ("glDrawElementArrayAPPLE" draw-element-array-apple) :void
(mode enum)
(first int)
(count sizei))
(defglextfun ("glDrawRangeElementArrayAPPLE" draw-range-element-array-apple) :void
(mode enum)
(start uint)
(end uint)
(first int)
(count sizei))
(defglextfun ("glMultiDrawElementArrayAPPLE" multi-draw-element-array-apple) :void
(mode enum)
(first (:pointer int))
(count (:pointer sizei))
(primcount sizei))
(defglextfun ("glMultiDrawRangeElementArrayAPPLE" multi-draw-range-element-array-apple) :void
(mode enum)
(start uint)
(end uint)
(first (:pointer int))
(count (:pointer sizei))
(primcount sizei))
(defglextfun ("glGenFencesAPPLE" gen-fences-apple) :void
(n sizei)
(fences (:pointer uint)))
(defglextfun ("glDeleteFencesAPPLE" delete-fences-apple) :void
(n sizei)
(fences (:pointer uint)))
(defglextfun ("glSetFenceAPPLE" set-fence-apple) :void
(fence uint))
(defglextfun ("glIsFenceAPPLE" is-fence-apple) boolean
(fence uint))
(defglextfun ("glTestFenceAPPLE" test-fence-apple) boolean
(fence uint))
(defglextfun ("glFinishFenceAPPLE" finish-fence-apple) :void
(fence uint))
(defglextfun ("glTestObjectAPPLE" test-object-apple) boolean
(object enum)
(name uint))
(defglextfun ("glFinishObjectAPPLE" finish-object-apple) :void
(object enum)
(name int))
(defglextfun ("glBufferParameteriAPPLE" buffer-parameter-i-apple) :void
(target enum)
(pname enum)
(param int))
(defglextfun ("glFlushMappedBufferRangeAPPLE" flush-mapped-buffer-range-apple) :void
(target enum)
(offset intptr)
(size sizeiptr))
(defglextfun ("glObjectPurgeableAPPLE" object-purgeable-apple) enum
(objectType enum)
(name uint)
(option enum))
(defglextfun ("glObjectUnpurgeableAPPLE" object-unpurgeable-apple) enum
(objectType enum)
(name uint)
(option enum))
(defglextfun ("glGetObjectParameterivAPPLE" get-object-parameter-iv-apple) :void
(objectType enum)
(name uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glTextureRangeAPPLE" texture-range-apple) :void
(target enum)
(length sizei)
(pointer (:pointer :void)))
(defglextfun ("glGetTexParameterPointervAPPLE" get-tex-parameter-pointer-v-apple) :void
(target enum)
(pname enum)
(params (:pointer (:pointer :void))))
(defglextfun ("glBindVertexArrayAPPLE" bind-vertex-array-apple) :void
(array uint))
(defglextfun ("glDeleteVertexArraysAPPLE" delete-vertex-arrays-apple) :void
(n sizei)
(arrays (:pointer uint)))
(defglextfun ("glGenVertexArraysAPPLE" gen-vertex-arrays-apple) :void
(n sizei)
(arrays (:pointer uint)))
(defglextfun ("glIsVertexArrayAPPLE" is-vertex-array-apple) boolean
(array uint))
(defglextfun ("glVertexArrayRangeAPPLE" vertex-array-range-apple) :void
(length sizei)
(pointer (:pointer :void)))
(defglextfun ("glFlushVertexArrayRangeAPPLE" flush-vertex-array-range-apple) :void
(length sizei)
(pointer (:pointer :void)))
(defglextfun ("glVertexArrayParameteriAPPLE" vertex-array-parameter-i-apple) :void
(pname enum)
(param int))
(defglextfun ("glEnableVertexAttribAPPLE" enable-vertex-attrib-apple) :void
(index uint)
(pname enum))
(defglextfun ("glDisableVertexAttribAPPLE" disable-vertex-attrib-apple) :void
(index uint)
(pname enum))
(defglextfun ("glIsVertexAttribEnabledAPPLE" is-vertex-attrib-enabled-apple) boolean
(index uint)
(pname enum))
(defglextfun ("glMapVertexAttrib1dAPPLE" map-vertex-attrib-1d-apple) :void
(index uint)
(size uint)
(u1 double)
(u2 double)
(stride int)
(order int)
(points (:pointer double)))
(defglextfun ("glMapVertexAttrib1fAPPLE" map-vertex-attrib-1f-apple) :void
(index uint)
(size uint)
(u1 float)
(u2 float)
(stride int)
(order int)
(points (:pointer float)))
(defglextfun ("glMapVertexAttrib2dAPPLE" map-vertex-attrib-2d-apple) :void
(index uint)
(size uint)
(u1 double)
(u2 double)
(ustride int)
(uorder int)
(v1 double)
(v2 double)
(vstride int)
(vorder int)
(points (:pointer double)))
(defglextfun ("glMapVertexAttrib2fAPPLE" map-vertex-attrib-2f-apple) :void
(index uint)
(size uint)
(u1 float)
(u2 float)
(ustride int)
(uorder int)
(v1 float)
(v2 float)
(vstride int)
(vorder int)
(points (:pointer float)))
(defglextfun ("glPrimitiveBoundingBoxARB" primitive-bounding-box-arb) :void
(minX float)
(minY float)
(minZ float)
(minW float)
(maxX float)
(maxY float)
(maxZ float)
(maxW float))
(defglextfun ("glClampColorARB" clamp-color-arb) :void
(target enum)
(clamp enum))
(defglextfun ("glDrawBuffersARB" draw-buffers-arb) :void
(n sizei)
(bufs (:pointer enum)))
(defglextfun ("glDrawArraysInstancedARB" draw-arrays-instanced-arb) :void
(mode enum)
(first int)
(count sizei)
(primcount sizei))
(defglextfun ("glDrawElementsInstancedARB" draw-elements-instanced-arb) :void
(mode enum)
(count sizei)
(type enum)
(indices (:pointer :void))
(primcount sizei))
(defglextfun ("glProgramStringARB" program-string-arb) :void
(target enum)
(format enum)
(len sizei)
(string (:pointer :void)))
(defglextfun ("glBindProgramARB" bind-program-arb) :void
(target enum)
(program uint))
(defglextfun ("glDeleteProgramsARB" delete-programs-arb) :void
(n sizei)
(programs (:pointer uint)))
(defglextfun ("glGenProgramsARB" gen-programs-arb) :void
(n sizei)
(programs (:pointer uint)))
(defglextfun ("glProgramEnvParameter4dARB" program-env-parameter-4d-arb) :void
(target enum)
(index uint)
(x double)
(y double)
(z double)
(w double))
(defglextfun ("glProgramEnvParameter4dvARB" program-env-parameter-4dv-arb) :void
(target enum)
(index uint)
(params (:pointer double)))
(defglextfun ("glProgramEnvParameter4fARB" program-env-parameter-4f-arb) :void
(target enum)
(index uint)
(x float)
(y float)
(z float)
(w float))
(defglextfun ("glProgramEnvParameter4fvARB" program-env-parameter-4fv-arb) :void
(target enum)
(index uint)
(params (:pointer float)))
(defglextfun ("glProgramLocalParameter4dARB" program-local-parameter-4d-arb) :void
(target enum)
(index uint)
(x double)
(y double)
(z double)
(w double))
(defglextfun ("glProgramLocalParameter4dvARB" program-local-parameter-4dv-arb) :void
(target enum)
(index uint)
(params (:pointer double)))
(defglextfun ("glProgramLocalParameter4fARB" program-local-parameter-4f-arb) :void
(target enum)
(index uint)
(x float)
(y float)
(z float)
(w float))
(defglextfun ("glProgramLocalParameter4fvARB" program-local-parameter-4fv-arb) :void
(target enum)
(index uint)
(params (:pointer float)))
(defglextfun ("glGetProgramEnvParameterdvARB" get-program-env-parameter-dv-arb) :void
(target enum)
(index uint)
(params (:pointer double)))
(defglextfun ("glGetProgramEnvParameterfvARB" get-program-env-parameter-fv-arb) :void
(target enum)
(index uint)
(params (:pointer float)))
(defglextfun ("glGetProgramLocalParameterdvARB" get-program-local-parameter-dv-arb) :void
(target enum)
(index uint)
(params (:pointer double)))
(defglextfun ("glGetProgramLocalParameterfvARB" get-program-local-parameter-fv-arb) :void
(target enum)
(index uint)
(params (:pointer float)))
(defglextfun ("glGetProgramivARB" get-program-iv-arb) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetProgramStringARB" get-program-string-arb) :void
(target enum)
(pname enum)
(string (:pointer :void)))
(defglextfun ("glIsProgramARB" is-program-arb) boolean
(program uint))
(defglextfun ("glProgramParameteriARB" program-parameter-i-arb) :void
(program uint)
(pname enum)
(value int))
(defglextfun ("glFramebufferTextureARB" framebuffer-texture-arb) :void
(target enum)
(attachment enum)
(texture uint)
(level int))
(defglextfun ("glFramebufferTextureLayerARB" framebuffer-texture-layer-arb) :void
(target enum)
(attachment enum)
(texture uint)
(level int)
(layer int))
(defglextfun ("glFramebufferTextureFaceARB" framebuffer-texture-face-arb) :void
(target enum)
(attachment enum)
(texture uint)
(level int)
(face enum))
(defglextfun ("glUniform1i64ARB" uniform-1i64-arb) :void
(location int)
(x int64))
(defglextfun ("glUniform2i64ARB" uniform-2i64-arb) :void
(location int)
(x int64)
(y int64))
(defglextfun ("glUniform3i64ARB" uniform-3i64-arb) :void
(location int)
(x int64)
(y int64)
(z int64))
(defglextfun ("glUniform4i64ARB" uniform-4i64-arb) :void
(location int)
(x int64)
(y int64)
(z int64)
(w int64))
(defglextfun ("glUniform1i64vARB" uniform-1i64v-arb) :void
(location int)
(count sizei)
(value (:pointer int64)))
(defglextfun ("glUniform2i64vARB" uniform-2i64v-arb) :void
(location int)
(count sizei)
(value (:pointer int64)))
(defglextfun ("glUniform3i64vARB" uniform-3i64v-arb) :void
(location int)
(count sizei)
(value (:pointer int64)))
(defglextfun ("glUniform4i64vARB" uniform-4i64v-arb) :void
(location int)
(count sizei)
(value (:pointer int64)))
(defglextfun ("glUniform1ui64ARB" uniform-1ui64-arb) :void
(location int)
(x uint64))
(defglextfun ("glUniform2ui64ARB" uniform-2ui64-arb) :void
(location int)
(x uint64)
(y uint64))
(defglextfun ("glUniform3ui64ARB" uniform-3ui64-arb) :void
(location int)
(x uint64)
(y uint64)
(z uint64))
(defglextfun ("glUniform4ui64ARB" uniform-4ui64-arb) :void
(location int)
(x uint64)
(y uint64)
(z uint64)
(w uint64))
(defglextfun ("glUniform1ui64vARB" uniform-1ui64v-arb) :void
(location int)
(count sizei)
(value (:pointer uint64)))
(defglextfun ("glUniform2ui64vARB" uniform-2ui64v-arb) :void
(location int)
(count sizei)
(value (:pointer uint64)))
(defglextfun ("glUniform3ui64vARB" uniform-3ui64v-arb) :void
(location int)
(count sizei)
(value (:pointer uint64)))
(defglextfun ("glUniform4ui64vARB" uniform-4ui64v-arb) :void
(location int)
(count sizei)
(value (:pointer uint64)))
(defglextfun ("glGetUniformi64vARB" get-uniform-i64v-arb) :void
(program uint)
(location int)
(params (:pointer int64)))
(defglextfun ("glGetUniformui64vARB" get-uniform-ui64v-arb) :void
(program uint)
(location int)
(params (:pointer uint64)))
(defglextfun ("glGetnUniformi64vARB" getn-uniform-i64v-arb) :void
(program uint)
(location int)
(bufSize sizei)
(params (:pointer int64)))
(defglextfun ("glGetnUniformui64vARB" getn-uniform-ui64v-arb) :void
(program uint)
(location int)
(bufSize sizei)
(params (:pointer uint64)))
(defglextfun ("glProgramUniform1i64ARB" program-uniform-1i64-arb) :void
(program uint)
(location int)
(x int64))
(defglextfun ("glProgramUniform2i64ARB" program-uniform-2i64-arb) :void
(program uint)
(location int)
(x int64)
(y int64))
(defglextfun ("glProgramUniform3i64ARB" program-uniform-3i64-arb) :void
(program uint)
(location int)
(x int64)
(y int64)
(z int64))
(defglextfun ("glProgramUniform4i64ARB" program-uniform-4i64-arb) :void
(program uint)
(location int)
(x int64)
(y int64)
(z int64)
(w int64))
(defglextfun ("glProgramUniform1i64vARB" program-uniform-1i64v-arb) :void
(program uint)
(location int)
(count sizei)
(value (:pointer int64)))
(defglextfun ("glProgramUniform2i64vARB" program-uniform-2i64v-arb) :void
(program uint)
(location int)
(count sizei)
(value (:pointer int64)))
(defglextfun ("glProgramUniform3i64vARB" program-uniform-3i64v-arb) :void
(program uint)
(location int)
(count sizei)
(value (:pointer int64)))
(defglextfun ("glProgramUniform4i64vARB" program-uniform-4i64v-arb) :void
(program uint)
(location int)
(count sizei)
(value (:pointer int64)))
(defglextfun ("glProgramUniform1ui64ARB" program-uniform-1ui64-arb) :void
(program uint)
(location int)
(x uint64))
(defglextfun ("glProgramUniform2ui64ARB" program-uniform-2ui64-arb) :void
(program uint)
(location int)
(x uint64)
(y uint64))
(defglextfun ("glProgramUniform3ui64ARB" program-uniform-3ui64-arb) :void
(program uint)
(location int)
(x uint64)
(y uint64)
(z uint64))
(defglextfun ("glProgramUniform4ui64ARB" program-uniform-4ui64-arb) :void
(program uint)
(location int)
(x uint64)
(y uint64)
(z uint64)
(w uint64))
(defglextfun ("glProgramUniform1ui64vARB" program-uniform-1ui64v-arb) :void
(program uint)
(location int)
(count sizei)
(value (:pointer uint64)))
(defglextfun ("glProgramUniform2ui64vARB" program-uniform-2ui64v-arb) :void
(program uint)
(location int)
(count sizei)
(value (:pointer uint64)))
(defglextfun ("glProgramUniform3ui64vARB" program-uniform-3ui64v-arb) :void
(program uint)
(location int)
(count sizei)
(value (:pointer uint64)))
(defglextfun ("glProgramUniform4ui64vARB" program-uniform-4ui64v-arb) :void
(program uint)
(location int)
(count sizei)
(value (:pointer uint64)))
(defglextfun ("glVertexAttribDivisorARB" vertex-attrib-divisor-arb) :void
(index uint)
(divisor uint))
(defglextfun ("glCurrentPaletteMatrixARB" current-palette-matrix-arb) :void
(index int))
(defglextfun ("glMatrixIndexubvARB" matrix-index-ubv-arb) :void
(size int)
(indices (:pointer ubyte)))
(defglextfun ("glMatrixIndexusvARB" matrix-index-usv-arb) :void
(size int)
(indices (:pointer ushort)))
(defglextfun ("glMatrixIndexuivARB" matrix-index-uiv-arb) :void
(size int)
(indices (:pointer uint)))
(defglextfun ("glMatrixIndexPointerARB" matrix-index-pointer-arb) :void
(size int)
(type enum)
(stride sizei)
(pointer (:pointer :void)))
(defglextfun ("glSampleCoverageARB" sample-coverage-arb) :void
(value float)
(invert boolean))
(defglextfun ("glActiveTextureARB" active-texture-arb) :void
(texture enum))
(defglextfun ("glClientActiveTextureARB" client-active-texture-arb) :void
(texture enum))
(defglextfun ("glMultiTexCoord1dARB" multi-tex-coord-1d-arb) :void
(target enum)
(s double))
(defglextfun ("glMultiTexCoord1dvARB" multi-tex-coord-1dv-arb) :void
(target enum)
(v (:pointer double)))
(defglextfun ("glMultiTexCoord1fARB" multi-tex-coord-1f-arb) :void
(target enum)
(s float))
(defglextfun ("glMultiTexCoord1fvARB" multi-tex-coord-1fv-arb) :void
(target enum)
(v (:pointer float)))
(defglextfun ("glMultiTexCoord1iARB" multi-tex-coord-1i-arb) :void
(target enum)
(s int))
(defglextfun ("glMultiTexCoord1ivARB" multi-tex-coord-1iv-arb) :void
(target enum)
(v (:pointer int)))
(defglextfun ("glMultiTexCoord1sARB" multi-tex-coord-1s-arb) :void
(target enum)
(s short))
(defglextfun ("glMultiTexCoord1svARB" multi-tex-coord-1sv-arb) :void
(target enum)
(v (:pointer short)))
(defglextfun ("glMultiTexCoord2dARB" multi-tex-coord-2d-arb) :void
(target enum)
(s double)
(tee double))
(defglextfun ("glMultiTexCoord2dvARB" multi-tex-coord-2dv-arb) :void
(target enum)
(v (:pointer double)))
(defglextfun ("glMultiTexCoord2fARB" multi-tex-coord-2f-arb) :void
(target enum)
(s float)
(tee float))
(defglextfun ("glMultiTexCoord2fvARB" multi-tex-coord-2fv-arb) :void
(target enum)
(v (:pointer float)))
(defglextfun ("glMultiTexCoord2iARB" multi-tex-coord-2i-arb) :void
(target enum)
(s int)
(tee int))
(defglextfun ("glMultiTexCoord2ivARB" multi-tex-coord-2iv-arb) :void
(target enum)
(v (:pointer int)))
(defglextfun ("glMultiTexCoord2sARB" multi-tex-coord-2s-arb) :void
(target enum)
(s short)
(tee short))
(defglextfun ("glMultiTexCoord2svARB" multi-tex-coord-2sv-arb) :void
(target enum)
(v (:pointer short)))
(defglextfun ("glMultiTexCoord3dARB" multi-tex-coord-3d-arb) :void
(target enum)
(s double)
(tee double)
(r double))
(defglextfun ("glMultiTexCoord3dvARB" multi-tex-coord-3dv-arb) :void
(target enum)
(v (:pointer double)))
(defglextfun ("glMultiTexCoord3fARB" multi-tex-coord-3f-arb) :void
(target enum)
(s float)
(tee float)
(r float))
(defglextfun ("glMultiTexCoord3fvARB" multi-tex-coord-3fv-arb) :void
(target enum)
(v (:pointer float)))
(defglextfun ("glMultiTexCoord3iARB" multi-tex-coord-3i-arb) :void
(target enum)
(s int)
(tee int)
(r int))
(defglextfun ("glMultiTexCoord3ivARB" multi-tex-coord-3iv-arb) :void
(target enum)
(v (:pointer int)))
(defglextfun ("glMultiTexCoord3sARB" multi-tex-coord-3s-arb) :void
(target enum)
(s short)
(tee short)
(r short))
(defglextfun ("glMultiTexCoord3svARB" multi-tex-coord-3sv-arb) :void
(target enum)
(v (:pointer short)))
(defglextfun ("glMultiTexCoord4dARB" multi-tex-coord-4d-arb) :void
(target enum)
(s double)
(tee double)
(r double)
(q double))
(defglextfun ("glMultiTexCoord4dvARB" multi-tex-coord-4dv-arb) :void
(target enum)
(v (:pointer double)))
(defglextfun ("glMultiTexCoord4fARB" multi-tex-coord-4f-arb) :void
(target enum)
(s float)
(tee float)
(r float)
(q float))
(defglextfun ("glMultiTexCoord4fvARB" multi-tex-coord-4fv-arb) :void
(target enum)
(v (:pointer float)))
(defglextfun ("glMultiTexCoord4iARB" multi-tex-coord-4i-arb) :void
(target enum)
(s int)
(tee int)
(r int)
(q int))
(defglextfun ("glMultiTexCoord4ivARB" multi-tex-coord-4iv-arb) :void
(target enum)
(v (:pointer int)))
(defglextfun ("glMultiTexCoord4sARB" multi-tex-coord-4s-arb) :void
(target enum)
(s short)
(tee short)
(r short)
(q short))
(defglextfun ("glMultiTexCoord4svARB" multi-tex-coord-4sv-arb) :void
(target enum)
(v (:pointer short)))
(defglextfun ("glGenQueriesARB" gen-queries-arb) :void
(n sizei)
(ids (:pointer uint)))
(defglextfun ("glDeleteQueriesARB" delete-queries-arb) :void
(n sizei)
(ids (:pointer uint)))
(defglextfun ("glIsQueryARB" is-query-arb) boolean
(id uint))
(defglextfun ("glBeginQueryARB" begin-query-arb) :void
(target enum)
(id uint))
(defglextfun ("glEndQueryARB" end-query-arb) :void
(target enum))
(defglextfun ("glGetQueryivARB" get-query-iv-arb) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetQueryObjectivARB" get-query-object-iv-arb) :void
(id uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetQueryObjectuivARB" get-query-object-uiv-arb) :void
(id uint)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glMaxShaderCompilerThreadsARB" max-shader-compiler-threads-arb) :void
(count uint))
(defglextfun ("glPointParameterfARB" point-parameter-f-arb) :void
(pname enum)
(param float))
(defglextfun ("glPointParameterfvARB" point-parameter-fv-arb) :void
(pname enum)
(params (:pointer float)))
(defglextfun ("glFramebufferSampleLocationsfvARB" framebuffer-sample-locations-fv-arb) :void
(target enum)
(start uint)
(count sizei)
(v (:pointer float)))
(defglextfun ("glNamedFramebufferSampleLocationsfvARB" named-framebuffer-sample-locations-fv-arb) :void
(framebuffer uint)
(start uint)
(count sizei)
(v (:pointer float)))
(defglextfun ("glEvaluateDepthValuesARB" evaluate-depth-values-arb) :void)
(defglextfun ("glDeleteObjectARB" delete-object-arb) :void
(obj handle-arb))
(defglextfun ("glGetHandleARB" get-handle-arb) handle-arb
(pname enum))
(defglextfun ("glDetachObjectARB" detach-object-arb) :void
(containerObj handle-arb)
(attachedObj handle-arb))
(defglextfun ("glCreateShaderObjectARB" create-shader-object-arb) handle-arb
(shaderType enum))
(defglextfun ("glShaderSourceARB" shader-source-arb) :void
(shaderObj handle-arb)
(count sizei)
(string (:pointer (:pointer char-arb)))
(length (:pointer int)))
(defglextfun ("glCompileShaderARB" compile-shader-arb) :void
(shaderObj handle-arb))
(defglextfun ("glCreateProgramObjectARB" create-program-object-arb) handle-arb)
(defglextfun ("glAttachObjectARB" attach-object-arb) :void
(containerObj handle-arb)
(obj handle-arb))
(defglextfun ("glLinkProgramARB" link-program-arb) :void
(programObj handle-arb))
(defglextfun ("glUseProgramObjectARB" use-program-object-arb) :void
(programObj handle-arb))
(defglextfun ("glValidateProgramARB" validate-program-arb) :void
(programObj handle-arb))
(defglextfun ("glUniform1fARB" uniform-1f-arb) :void
(location int)
(v0 float))
(defglextfun ("glUniform2fARB" uniform-2f-arb) :void
(location int)
(v0 float)
(v1 float))
(defglextfun ("glUniform3fARB" uniform-3f-arb) :void
(location int)
(v0 float)
(v1 float)
(v2 float))
(defglextfun ("glUniform4fARB" uniform-4f-arb) :void
(location int)
(v0 float)
(v1 float)
(v2 float)
(v3 float))
(defglextfun ("glUniform1iARB" uniform-1i-arb) :void
(location int)
(v0 int))
(defglextfun ("glUniform2iARB" uniform-2i-arb) :void
(location int)
(v0 int)
(v1 int))
(defglextfun ("glUniform3iARB" uniform-3i-arb) :void
(location int)
(v0 int)
(v1 int)
(v2 int))
(defglextfun ("glUniform4iARB" uniform-4i-arb) :void
(location int)
(v0 int)
(v1 int)
(v2 int)
(v3 int))
(defglextfun ("glUniform1fvARB" uniform-1fv-arb) :void
(location int)
(count sizei)
(value (:pointer float)))
(defglextfun ("glUniform2fvARB" uniform-2fv-arb) :void
(location int)
(count sizei)
(value (:pointer float)))
(defglextfun ("glUniform3fvARB" uniform-3fv-arb) :void
(location int)
(count sizei)
(value (:pointer float)))
(defglextfun ("glUniform4fvARB" uniform-4fv-arb) :void
(location int)
(count sizei)
(value (:pointer float)))
(defglextfun ("glUniform1ivARB" uniform-1iv-arb) :void
(location int)
(count sizei)
(value (:pointer int)))
(defglextfun ("glUniform2ivARB" uniform-2iv-arb) :void
(location int)
(count sizei)
(value (:pointer int)))
(defglextfun ("glUniform3ivARB" uniform-3iv-arb) :void
(location int)
(count sizei)
(value (:pointer int)))
(defglextfun ("glUniform4ivARB" uniform-4iv-arb) :void
(location int)
(count sizei)
(value (:pointer int)))
(defglextfun ("glUniformMatrix2fvARB" uniform-matrix-2fv-arb) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glUniformMatrix3fvARB" uniform-matrix-3fv-arb) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glUniformMatrix4fvARB" uniform-matrix-4fv-arb) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glGetObjectParameterfvARB" get-object-parameter-fv-arb) :void
(obj handle-arb)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetObjectParameterivARB" get-object-parameter-iv-arb) :void
(obj handle-arb)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetInfoLogARB" get-info-log-arb) :void
(obj handle-arb)
(maxLength sizei)
(length (:pointer sizei))
(infoLog (:pointer char-arb)))
(defglextfun ("glGetAttachedObjectsARB" get-attached-objects-arb) :void
(containerObj handle-arb)
(maxCount sizei)
(count (:pointer sizei))
(obj (:pointer handle-arb)))
(defglextfun ("glGetUniformLocationARB" get-uniform-location-arb) int
(programObj handle-arb)
(name (:pointer char-arb)))
(defglextfun ("glGetActiveUniformARB" get-active-uniform-arb) :void
(programObj handle-arb)
(index uint)
(maxLength sizei)
(length (:pointer sizei))
(size (:pointer int))
(type (:pointer enum))
(name (:pointer char-arb)))
(defglextfun ("glGetUniformfvARB" get-uniform-fv-arb) :void
(programObj handle-arb)
(location int)
(params (:pointer float)))
(defglextfun ("glGetUniformivARB" get-uniform-iv-arb) :void
(programObj handle-arb)
(location int)
(params (:pointer int)))
(defglextfun ("glGetShaderSourceARB" get-shader-source-arb) :void
(obj handle-arb)
(maxLength sizei)
(length (:pointer sizei))
(source (:pointer char-arb)))
(defglextfun ("glTexBufferARB" tex-buffer-arb) :void
(target enum)
(internalformat enum)
(buffer uint))
(defglextfun ("glCompressedTexImage3DARB" compressed-tex-image-3d-arb) :void
(target enum)
(level int)
(internalformat enum)
(width sizei)
(height sizei)
(depth sizei)
(border int)
(imageSize sizei)
(data (:pointer :void)))
(defglextfun ("glCompressedTexImage2DARB" compressed-tex-image-2d-arb) :void
(target enum)
(level int)
(internalformat enum)
(width sizei)
(height sizei)
(border int)
(imageSize sizei)
(data (:pointer :void)))
(defglextfun ("glCompressedTexImage1DARB" compressed-tex-image-1d-arb) :void
(target enum)
(level int)
(internalformat enum)
(width sizei)
(border int)
(imageSize sizei)
(data (:pointer :void)))
(defglextfun ("glCompressedTexSubImage3DARB" compressed-tex-sub-image-3d-arb) :void
(target enum)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei)
(format enum)
(imageSize sizei)
(data (:pointer :void)))
(defglextfun ("glCompressedTexSubImage2DARB" compressed-tex-sub-image-2d-arb) :void
(target enum)
(level int)
(xoffset int)
(yoffset int)
(width sizei)
(height sizei)
(format enum)
(imageSize sizei)
(data (:pointer :void)))
(defglextfun ("glCompressedTexSubImage1DARB" compressed-tex-sub-image-1d-arb) :void
(target enum)
(level int)
(xoffset int)
(width sizei)
(format enum)
(imageSize sizei)
(data (:pointer :void)))
(defglextfun ("glGetCompressedTexImageARB" get-compressed-tex-image-arb) :void
(target enum)
(level int)
(img (:pointer :void)))
(defglextfun ("glLoadTransposeMatrixfARB" load-transpose-matrix-f-arb) :void
(m (:pointer float)))
(defglextfun ("glLoadTransposeMatrixdARB" load-transpose-matrix-d-arb) :void
(m (:pointer double)))
(defglextfun ("glMultTransposeMatrixfARB" mult-transpose-matrix-f-arb) :void
(m (:pointer float)))
(defglextfun ("glMultTransposeMatrixdARB" mult-transpose-matrix-d-arb) :void
(m (:pointer double)))
(defglextfun ("glWeightbvARB" weight-bv-arb) :void
(size int)
(weights (:pointer byte)))
(defglextfun ("glWeightsvARB" weight-sv-arb) :void
(size int)
(weights (:pointer short)))
(defglextfun ("glWeightivARB" weight-iv-arb) :void
(size int)
(weights (:pointer int)))
(defglextfun ("glWeightfvARB" weight-fv-arb) :void
(size int)
(weights (:pointer float)))
(defglextfun ("glWeightdvARB" weight-dv-arb) :void
(size int)
(weights (:pointer double)))
(defglextfun ("glWeightubvARB" weight-ubv-arb) :void
(size int)
(weights (:pointer ubyte)))
(defglextfun ("glWeightusvARB" weight-usv-arb) :void
(size int)
(weights (:pointer ushort)))
(defglextfun ("glWeightuivARB" weight-uiv-arb) :void
(size int)
(weights (:pointer uint)))
(defglextfun ("glWeightPointerARB" weight-pointer-arb) :void
(size int)
(type enum)
(stride sizei)
(pointer (:pointer :void)))
(defglextfun ("glVertexBlendARB" vertex-blend-arb) :void
(count int))
(defglextfun ("glBindBufferARB" bind-buffer-arb) :void
(target enum)
(buffer uint))
(defglextfun ("glDeleteBuffersARB" delete-buffers-arb) :void
(n sizei)
(buffers (:pointer uint)))
(defglextfun ("glGenBuffersARB" gen-buffers-arb) :void
(n sizei)
(buffers (:pointer uint)))
(defglextfun ("glIsBufferARB" is-buffer-arb) boolean
(buffer uint))
(defglextfun ("glBufferDataARB" buffer-data-arb) :void
(target enum)
(size sizeiptr-arb)
(data (:pointer :void))
(usage enum))
(defglextfun ("glBufferSubDataARB" buffer-sub-data-arb) :void
(target enum)
(offset intptr-arb)
(size sizeiptr-arb)
(data (:pointer :void)))
(defglextfun ("glGetBufferSubDataARB" get-buffer-sub-data-arb) :void
(target enum)
(offset intptr-arb)
(size sizeiptr-arb)
(data (:pointer :void)))
(defglextfun ("glMapBufferARB" map-buffer-arb) (:pointer :void)
(target enum)
(access enum))
(defglextfun ("glUnmapBufferARB" unmap-buffer-arb) boolean
(target enum))
(defglextfun ("glGetBufferParameterivARB" get-buffer-parameter-iv-arb) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetBufferPointervARB" get-buffer-pointer-v-arb) :void
(target enum)
(pname enum)
(params (:pointer (:pointer :void))))
(defglextfun ("glVertexAttrib1dARB" vertex-attrib-1d-arb) :void
(index uint)
(x double))
(defglextfun ("glVertexAttrib1dvARB" vertex-attrib-1dv-arb) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttrib1fARB" vertex-attrib-1f-arb) :void
(index uint)
(x float))
(defglextfun ("glVertexAttrib1fvARB" vertex-attrib-1fv-arb) :void
(index uint)
(v (:pointer float)))
(defglextfun ("glVertexAttrib1sARB" vertex-attrib-1s-arb) :void
(index uint)
(x short))
(defglextfun ("glVertexAttrib1svARB" vertex-attrib-1sv-arb) :void
(index uint)
(v (:pointer short)))
(defglextfun ("glVertexAttrib2dARB" vertex-attrib-2d-arb) :void
(index uint)
(x double)
(y double))
(defglextfun ("glVertexAttrib2dvARB" vertex-attrib-2dv-arb) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttrib2fARB" vertex-attrib-2f-arb) :void
(index uint)
(x float)
(y float))
(defglextfun ("glVertexAttrib2fvARB" vertex-attrib-2fv-arb) :void
(index uint)
(v (:pointer float)))
(defglextfun ("glVertexAttrib2sARB" vertex-attrib-2s-arb) :void
(index uint)
(x short)
(y short))
(defglextfun ("glVertexAttrib2svARB" vertex-attrib-2sv-arb) :void
(index uint)
(v (:pointer short)))
(defglextfun ("glVertexAttrib3dARB" vertex-attrib-3d-arb) :void
(index uint)
(x double)
(y double)
(z double))
(defglextfun ("glVertexAttrib3dvARB" vertex-attrib-3dv-arb) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttrib3fARB" vertex-attrib-3f-arb) :void
(index uint)
(x float)
(y float)
(z float))
(defglextfun ("glVertexAttrib3fvARB" vertex-attrib-3fv-arb) :void
(index uint)
(v (:pointer float)))
(defglextfun ("glVertexAttrib3sARB" vertex-attrib-3s-arb) :void
(index uint)
(x short)
(y short)
(z short))
(defglextfun ("glVertexAttrib3svARB" vertex-attrib-3sv-arb) :void
(index uint)
(v (:pointer short)))
(defglextfun ("glVertexAttrib4NbvARB" vertex-attrib-4nbv-arb) :void
(index uint)
(v (:pointer byte)))
(defglextfun ("glVertexAttrib4NivARB" vertex-attrib-4niv-arb) :void
(index uint)
(v (:pointer int)))
(defglextfun ("glVertexAttrib4NsvARB" vertex-attrib-4nsv-arb) :void
(index uint)
(v (:pointer short)))
(defglextfun ("glVertexAttrib4NubARB" vertex-attrib-4nub-arb) :void
(index uint)
(x ubyte)
(y ubyte)
(z ubyte)
(w ubyte))
(defglextfun ("glVertexAttrib4NubvARB" vertex-attrib-4nubv-arb) :void
(index uint)
(v (:pointer ubyte)))
(defglextfun ("glVertexAttrib4NuivARB" vertex-attrib-4nuiv-arb) :void
(index uint)
(v (:pointer uint)))
(defglextfun ("glVertexAttrib4NusvARB" vertex-attrib-4nusv-arb) :void
(index uint)
(v (:pointer ushort)))
(defglextfun ("glVertexAttrib4bvARB" vertex-attrib-4bv-arb) :void
(index uint)
(v (:pointer byte)))
(defglextfun ("glVertexAttrib4dARB" vertex-attrib-4d-arb) :void
(index uint)
(x double)
(y double)
(z double)
(w double))
(defglextfun ("glVertexAttrib4dvARB" vertex-attrib-4dv-arb) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttrib4fARB" vertex-attrib-4f-arb) :void
(index uint)
(x float)
(y float)
(z float)
(w float))
(defglextfun ("glVertexAttrib4fvARB" vertex-attrib-4fv-arb) :void
(index uint)
(v (:pointer float)))
(defglextfun ("glVertexAttrib4ivARB" vertex-attrib-4iv-arb) :void
(index uint)
(v (:pointer int)))
(defglextfun ("glVertexAttrib4sARB" vertex-attrib-4s-arb) :void
(index uint)
(x short)
(y short)
(z short)
(w short))
(defglextfun ("glVertexAttrib4svARB" vertex-attrib-4sv-arb) :void
(index uint)
(v (:pointer short)))
(defglextfun ("glVertexAttrib4ubvARB" vertex-attrib-4ubv-arb) :void
(index uint)
(v (:pointer ubyte)))
(defglextfun ("glVertexAttrib4uivARB" vertex-attrib-4uiv-arb) :void
(index uint)
(v (:pointer uint)))
(defglextfun ("glVertexAttrib4usvARB" vertex-attrib-4usv-arb) :void
(index uint)
(v (:pointer ushort)))
(defglextfun ("glVertexAttribPointerARB" vertex-attrib-pointer-arb) :void
(index uint)
(size int)
(type enum)
(normalized boolean)
(stride sizei)
(pointer (:pointer :void)))
(defglextfun ("glEnableVertexAttribArrayARB" enable-vertex-attrib-array-arb) :void
(index uint))
(defglextfun ("glDisableVertexAttribArrayARB" disable-vertex-attrib-array-arb) :void
(index uint))
(defglextfun ("glGetVertexAttribdvARB" get-vertex-attrib-dv-arb) :void
(index uint)
(pname enum)
(params (:pointer double)))
(defglextfun ("glGetVertexAttribfvARB" get-vertex-attrib-fv-arb) :void
(index uint)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetVertexAttribivARB" get-vertex-attrib-iv-arb) :void
(index uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetVertexAttribPointervARB" get-vertex-attrib-pointer-v-arb) :void
(index uint)
(pname enum)
(pointer (:pointer (:pointer :void))))
(defglextfun ("glBindAttribLocationARB" bind-attrib-location-arb) :void
(programObj handle-arb)
(index uint)
(name (:pointer char-arb)))
(defglextfun ("glGetActiveAttribARB" get-active-attrib-arb) :void
(programObj handle-arb)
(index uint)
(maxLength sizei)
(length (:pointer sizei))
(size (:pointer int))
(type (:pointer enum))
(name (:pointer char-arb)))
(defglextfun ("glGetAttribLocationARB" get-attrib-location-arb) int
(programObj handle-arb)
(name (:pointer char-arb)))
(defglextfun ("glWindowPos2dARB" window-pos-2d-arb) :void
(x double)
(y double))
(defglextfun ("glWindowPos2dvARB" window-pos-2dv-arb) :void
(v (:pointer double)))
(defglextfun ("glWindowPos2fARB" window-pos-2f-arb) :void
(x float)
(y float))
(defglextfun ("glWindowPos2fvARB" window-pos-2fv-arb) :void
(v (:pointer float)))
(defglextfun ("glWindowPos2iARB" window-pos-2i-arb) :void
(x int)
(y int))
(defglextfun ("glWindowPos2ivARB" window-pos-2iv-arb) :void
(v (:pointer int)))
(defglextfun ("glWindowPos2sARB" window-pos-2s-arb) :void
(x short)
(y short))
(defglextfun ("glWindowPos2svARB" window-pos-2sv-arb) :void
(v (:pointer short)))
(defglextfun ("glWindowPos3dARB" window-pos-3d-arb) :void
(x double)
(y double)
(z double))
(defglextfun ("glWindowPos3dvARB" window-pos-3dv-arb) :void
(v (:pointer double)))
(defglextfun ("glWindowPos3fARB" window-pos-3f-arb) :void
(x float)
(y float)
(z float))
(defglextfun ("glWindowPos3fvARB" window-pos-3fv-arb) :void
(v (:pointer float)))
(defglextfun ("glWindowPos3iARB" window-pos-3i-arb) :void
(x int)
(y int)
(z int))
(defglextfun ("glWindowPos3ivARB" window-pos-3iv-arb) :void
(v (:pointer int)))
(defglextfun ("glWindowPos3sARB" window-pos-3s-arb) :void
(x short)
(y short)
(z short))
(defglextfun ("glWindowPos3svARB" window-pos-3sv-arb) :void
(v (:pointer short)))
(defglextfun ("glDrawBuffersATI" draw-buffers-ati) :void
(n sizei)
(bufs (:pointer enum)))
(defglextfun ("glElementPointerATI" element-pointer-ati) :void
(type enum)
(pointer (:pointer :void)))
(defglextfun ("glDrawElementArrayATI" draw-element-array-ati) :void
(mode enum)
(count sizei))
(defglextfun ("glDrawRangeElementArrayATI" draw-range-element-array-ati) :void
(mode enum)
(start uint)
(end uint)
(count sizei))
(defglextfun ("glTexBumpParameterivATI" tex-bump-parameter-iv-ati) :void
(pname enum)
(param (:pointer int)))
(defglextfun ("glTexBumpParameterfvATI" tex-bump-parameter-fv-ati) :void
(pname enum)
(param (:pointer float)))
(defglextfun ("glGetTexBumpParameterivATI" get-tex-bump-parameter-iv-ati) :void
(pname enum)
(param (:pointer int)))
(defglextfun ("glGetTexBumpParameterfvATI" get-tex-bump-parameter-fv-ati) :void
(pname enum)
(param (:pointer float)))
(defglextfun ("glGenFragmentShadersATI" gen-fragment-shaders-ati) uint
(range uint))
(defglextfun ("glBindFragmentShaderATI" bind-fragment-shader-ati) :void
(id uint))
(defglextfun ("glDeleteFragmentShaderATI" delete-fragment-shader-ati) :void
(id uint))
(defglextfun ("glBeginFragmentShaderATI" begin-fragment-shader-ati) :void)
(defglextfun ("glEndFragmentShaderATI" end-fragment-shader-ati) :void)
(defglextfun ("glPassTexCoordATI" pass-tex-coord-ati) :void
(dst uint)
(coord uint)
(swizzle enum))
(defglextfun ("glSampleMapATI" sample-map-ati) :void
(dst uint)
(interp uint)
(swizzle enum))
(defglextfun ("glColorFragmentOp1ATI" color-fragment-op-1-ati) :void
(op enum)
(dst uint)
(dstMask uint)
(dstMod uint)
(arg1 uint)
(arg1Rep uint)
(arg1Mod uint))
(defglextfun ("glColorFragmentOp2ATI" color-fragment-op-2-ati) :void
(op enum)
(dst uint)
(dstMask uint)
(dstMod uint)
(arg1 uint)
(arg1Rep uint)
(arg1Mod uint)
(arg2 uint)
(arg2Rep uint)
(arg2Mod uint))
(defglextfun ("glColorFragmentOp3ATI" color-fragment-op-3-ati) :void
(op enum)
(dst uint)
(dstMask uint)
(dstMod uint)
(arg1 uint)
(arg1Rep uint)
(arg1Mod uint)
(arg2 uint)
(arg2Rep uint)
(arg2Mod uint)
(arg3 uint)
(arg3Rep uint)
(arg3Mod uint))
(defglextfun ("glAlphaFragmentOp1ATI" alpha-fragment-op-1-ati) :void
(op enum)
(dst uint)
(dstMod uint)
(arg1 uint)
(arg1Rep uint)
(arg1Mod uint))
(defglextfun ("glAlphaFragmentOp2ATI" alpha-fragment-op-2-ati) :void
(op enum)
(dst uint)
(dstMod uint)
(arg1 uint)
(arg1Rep uint)
(arg1Mod uint)
(arg2 uint)
(arg2Rep uint)
(arg2Mod uint))
(defglextfun ("glAlphaFragmentOp3ATI" alpha-fragment-op-3-ati) :void
(op enum)
(dst uint)
(dstMod uint)
(arg1 uint)
(arg1Rep uint)
(arg1Mod uint)
(arg2 uint)
(arg2Rep uint)
(arg2Mod uint)
(arg3 uint)
(arg3Rep uint)
(arg3Mod uint))
(defglextfun ("glSetFragmentShaderConstantATI" set-fragment-shader-constant-ati) :void
(dst uint)
(value (:pointer float)))
(defglextfun ("glMapObjectBufferATI" map-object-buffer-ati) (:pointer :void)
(buffer uint))
(defglextfun ("glUnmapObjectBufferATI" unmap-object-buffer-ati) :void
(buffer uint))
(defglextfun ("glPNTrianglesiATI" pntriangles-i-ati) :void
(pname enum)
(param int))
(defglextfun ("glPNTrianglesfATI" pntriangles-f-ati) :void
(pname enum)
(param float))
(defglextfun ("glStencilOpSeparateATI" stencil-op-separate-ati) :void
(face enum)
(sfail enum)
(dpfail enum)
(dppass enum))
(defglextfun ("glStencilFuncSeparateATI" stencil-func-separate-ati) :void
(frontfunc enum)
(backfunc enum)
(ref int)
(mask uint))
(defglextfun ("glNewObjectBufferATI" new-object-buffer-ati) uint
(size sizei)
(pointer (:pointer :void))
(usage enum))
(defglextfun ("glIsObjectBufferATI" is-object-buffer-ati) boolean
(buffer uint))
(defglextfun ("glUpdateObjectBufferATI" update-object-buffer-ati) :void
(buffer uint)
(offset uint)
(size sizei)
(pointer (:pointer :void))
(preserve enum))
(defglextfun ("glGetObjectBufferfvATI" get-object-buffer-fv-ati) :void
(buffer uint)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetObjectBufferivATI" get-object-buffer-iv-ati) :void
(buffer uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glFreeObjectBufferATI" free-object-buffer-ati) :void
(buffer uint))
(defglextfun ("glArrayObjectATI" array-object-ati) :void
(array enum)
(size int)
(type enum)
(stride sizei)
(buffer uint)
(offset uint))
(defglextfun ("glGetArrayObjectfvATI" get-array-object-fv-ati) :void
(array enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetArrayObjectivATI" get-array-object-iv-ati) :void
(array enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glVariantArrayObjectATI" variant-array-object-ati) :void
(id uint)
(type enum)
(stride sizei)
(buffer uint)
(offset uint))
(defglextfun ("glGetVariantArrayObjectfvATI" get-variant-array-object-fv-ati) :void
(id uint)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetVariantArrayObjectivATI" get-variant-array-object-iv-ati) :void
(id uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glVertexAttribArrayObjectATI" vertex-attrib-array-object-ati) :void
(index uint)
(size int)
(type enum)
(normalized boolean)
(stride sizei)
(buffer uint)
(offset uint))
(defglextfun ("glGetVertexAttribArrayObjectfvATI" get-vertex-attrib-array-object-fv-ati) :void
(index uint)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetVertexAttribArrayObjectivATI" get-vertex-attrib-array-object-iv-ati) :void
(index uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glVertexStream1sATI" vertex-stream-1s-ati) :void
(stream enum)
(x short))
(defglextfun ("glVertexStream1svATI" vertex-stream-1sv-ati) :void
(stream enum)
(coords (:pointer short)))
(defglextfun ("glVertexStream1iATI" vertex-stream-1i-ati) :void
(stream enum)
(x int))
(defglextfun ("glVertexStream1ivATI" vertex-stream-1iv-ati) :void
(stream enum)
(coords (:pointer int)))
(defglextfun ("glVertexStream1fATI" vertex-stream-1f-ati) :void
(stream enum)
(x float))
(defglextfun ("glVertexStream1fvATI" vertex-stream-1fv-ati) :void
(stream enum)
(coords (:pointer float)))
(defglextfun ("glVertexStream1dATI" vertex-stream-1d-ati) :void
(stream enum)
(x double))
(defglextfun ("glVertexStream1dvATI" vertex-stream-1dv-ati) :void
(stream enum)
(coords (:pointer double)))
(defglextfun ("glVertexStream2sATI" vertex-stream-2s-ati) :void
(stream enum)
(x short)
(y short))
(defglextfun ("glVertexStream2svATI" vertex-stream-2sv-ati) :void
(stream enum)
(coords (:pointer short)))
(defglextfun ("glVertexStream2iATI" vertex-stream-2i-ati) :void
(stream enum)
(x int)
(y int))
(defglextfun ("glVertexStream2ivATI" vertex-stream-2iv-ati) :void
(stream enum)
(coords (:pointer int)))
(defglextfun ("glVertexStream2fATI" vertex-stream-2f-ati) :void
(stream enum)
(x float)
(y float))
(defglextfun ("glVertexStream2fvATI" vertex-stream-2fv-ati) :void
(stream enum)
(coords (:pointer float)))
(defglextfun ("glVertexStream2dATI" vertex-stream-2d-ati) :void
(stream enum)
(x double)
(y double))
(defglextfun ("glVertexStream2dvATI" vertex-stream-2dv-ati) :void
(stream enum)
(coords (:pointer double)))
(defglextfun ("glVertexStream3sATI" vertex-stream-3s-ati) :void
(stream enum)
(x short)
(y short)
(z short))
(defglextfun ("glVertexStream3svATI" vertex-stream-3sv-ati) :void
(stream enum)
(coords (:pointer short)))
(defglextfun ("glVertexStream3iATI" vertex-stream-3i-ati) :void
(stream enum)
(x int)
(y int)
(z int))
(defglextfun ("glVertexStream3ivATI" vertex-stream-3iv-ati) :void
(stream enum)
(coords (:pointer int)))
(defglextfun ("glVertexStream3fATI" vertex-stream-3f-ati) :void
(stream enum)
(x float)
(y float)
(z float))
(defglextfun ("glVertexStream3fvATI" vertex-stream-3fv-ati) :void
(stream enum)
(coords (:pointer float)))
(defglextfun ("glVertexStream3dATI" vertex-stream-3d-ati) :void
(stream enum)
(x double)
(y double)
(z double))
(defglextfun ("glVertexStream3dvATI" vertex-stream-3dv-ati) :void
(stream enum)
(coords (:pointer double)))
(defglextfun ("glVertexStream4sATI" vertex-stream-4s-ati) :void
(stream enum)
(x short)
(y short)
(z short)
(w short))
(defglextfun ("glVertexStream4svATI" vertex-stream-4sv-ati) :void
(stream enum)
(coords (:pointer short)))
(defglextfun ("glVertexStream4iATI" vertex-stream-4i-ati) :void
(stream enum)
(x int)
(y int)
(z int)
(w int))
(defglextfun ("glVertexStream4ivATI" vertex-stream-4iv-ati) :void
(stream enum)
(coords (:pointer int)))
(defglextfun ("glVertexStream4fATI" vertex-stream-4f-ati) :void
(stream enum)
(x float)
(y float)
(z float)
(w float))
(defglextfun ("glVertexStream4fvATI" vertex-stream-4fv-ati) :void
(stream enum)
(coords (:pointer float)))
(defglextfun ("glVertexStream4dATI" vertex-stream-4d-ati) :void
(stream enum)
(x double)
(y double)
(z double)
(w double))
(defglextfun ("glVertexStream4dvATI" vertex-stream-4dv-ati) :void
(stream enum)
(coords (:pointer double)))
(defglextfun ("glNormalStream3bATI" normal-stream-3b-ati) :void
(stream enum)
(nx byte)
(ny byte)
(nz byte))
(defglextfun ("glNormalStream3bvATI" normal-stream-3bv-ati) :void
(stream enum)
(coords (:pointer byte)))
(defglextfun ("glNormalStream3sATI" normal-stream-3s-ati) :void
(stream enum)
(nx short)
(ny short)
(nz short))
(defglextfun ("glNormalStream3svATI" normal-stream-3sv-ati) :void
(stream enum)
(coords (:pointer short)))
(defglextfun ("glNormalStream3iATI" normal-stream-3i-ati) :void
(stream enum)
(nx int)
(ny int)
(nz int))
(defglextfun ("glNormalStream3ivATI" normal-stream-3iv-ati) :void
(stream enum)
(coords (:pointer int)))
(defglextfun ("glNormalStream3fATI" normal-stream-3f-ati) :void
(stream enum)
(nx float)
(ny float)
(nz float))
(defglextfun ("glNormalStream3fvATI" normal-stream-3fv-ati) :void
(stream enum)
(coords (:pointer float)))
(defglextfun ("glNormalStream3dATI" normal-stream-3d-ati) :void
(stream enum)
(nx double)
(ny double)
(nz double))
(defglextfun ("glNormalStream3dvATI" normal-stream-3dv-ati) :void
(stream enum)
(coords (:pointer double)))
(defglextfun ("glClientActiveVertexStreamATI" client-active-vertex-stream-ati) :void
(stream enum))
(defglextfun ("glVertexBlendEnviATI" vertex-blend-env-i-ati) :void
(pname enum)
(param int))
(defglextfun ("glVertexBlendEnvfATI" vertex-blend-env-f-ati) :void
(pname enum)
(param float))
(defglextfun ("glUniformBufferEXT" uniform-buffer-ext) :void
(program uint)
(location int)
(buffer uint))
(defglextfun ("glGetUniformBufferSizeEXT" get-uniform-buffer-size-ext) int
(program uint)
(location int))
(defglextfun ("glGetUniformOffsetEXT" get-uniform-offset-ext) intptr
(program uint)
(location int))
(defglextfun ("glBlendColorEXT" blend-color-ext) :void
(red float)
(green float)
(blue float)
(alpha float))
(defglextfun ("glBlendEquationSeparateEXT" blend-equation-separate-ext) :void
(modeRGB enum)
(modeAlpha enum))
(defglextfun ("glBlendFuncSeparateEXT" blend-func-separate-ext) :void
(sfactorRGB enum)
(dfactorRGB enum)
(sfactorAlpha enum)
(dfactorAlpha enum))
(defglextfun ("glColorSubTableEXT" color-sub-table-ext) :void
(target enum)
(start sizei)
(count sizei)
(format enum)
(type enum)
(data (:pointer :void)))
(defglextfun ("glCopyColorSubTableEXT" copy-color-sub-table-ext) :void
(target enum)
(start sizei)
(x int)
(y int)
(width sizei))
(defglextfun ("glLockArraysEXT" lock-arrays-ext) :void
(first int)
(count sizei))
(defglextfun ("glUnlockArraysEXT" unlock-arrays-ext) :void)
(defglextfun ("glConvolutionFilter1DEXT" convolution-filter-1d-ext) :void
(target enum)
(internalformat enum)
(width sizei)
(format enum)
(type enum)
(image (:pointer :void)))
(defglextfun ("glConvolutionFilter2DEXT" convolution-filter-2d-ext) :void
(target enum)
(internalformat enum)
(width sizei)
(height sizei)
(format enum)
(type enum)
(image (:pointer :void)))
(defglextfun ("glConvolutionParameterfEXT" convolution-parameter-f-ext) :void
(target enum)
(pname enum)
(params float))
(defglextfun ("glConvolutionParameterfvEXT" convolution-parameter-fv-ext) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glConvolutionParameteriEXT" convolution-parameter-i-ext) :void
(target enum)
(pname enum)
(params int))
(defglextfun ("glConvolutionParameterivEXT" convolution-parameter-iv-ext) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glCopyConvolutionFilter1DEXT" copy-convolution-filter-1d-ext) :void
(target enum)
(internalformat enum)
(x int)
(y int)
(width sizei))
(defglextfun ("glCopyConvolutionFilter2DEXT" copy-convolution-filter-2d-ext) :void
(target enum)
(internalformat enum)
(x int)
(y int)
(width sizei)
(height sizei))
(defglextfun ("glGetConvolutionFilterEXT" get-convolution-filter-ext) :void
(target enum)
(format enum)
(type enum)
(image (:pointer :void)))
(defglextfun ("glGetConvolutionParameterfvEXT" get-convolution-parameter-fv-ext) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetConvolutionParameterivEXT" get-convolution-parameter-iv-ext) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetSeparableFilterEXT" get-separable-filter-ext) :void
(target enum)
(format enum)
(type enum)
(row (:pointer :void))
(column (:pointer :void))
(span (:pointer :void)))
(defglextfun ("glSeparableFilter2DEXT" separable-filter-2d-ext) :void
(target enum)
(internalformat enum)
(width sizei)
(height sizei)
(format enum)
(type enum)
(row (:pointer :void))
(column (:pointer :void)))
(defglextfun ("glTangent3bEXT" tangent-3b-ext) :void
(tx byte)
(ty byte)
(tz byte))
(defglextfun ("glTangent3bvEXT" tangent-3bv-ext) :void
(v (:pointer byte)))
(defglextfun ("glTangent3dEXT" tangent-3d-ext) :void
(tx double)
(ty double)
(tz double))
(defglextfun ("glTangent3dvEXT" tangent-3dv-ext) :void
(v (:pointer double)))
(defglextfun ("glTangent3fEXT" tangent-3f-ext) :void
(tx float)
(ty float)
(tz float))
(defglextfun ("glTangent3fvEXT" tangent-3fv-ext) :void
(v (:pointer float)))
(defglextfun ("glTangent3iEXT" tangent-3i-ext) :void
(tx int)
(ty int)
(tz int))
(defglextfun ("glTangent3ivEXT" tangent-3iv-ext) :void
(v (:pointer int)))
(defglextfun ("glTangent3sEXT" tangent-3s-ext) :void
(tx short)
(ty short)
(tz short))
(defglextfun ("glTangent3svEXT" tangent-3sv-ext) :void
(v (:pointer short)))
(defglextfun ("glBinormal3bEXT" binormal-3b-ext) :void
(bx byte)
(by byte)
(bz byte))
(defglextfun ("glBinormal3bvEXT" binormal-3bv-ext) :void
(v (:pointer byte)))
(defglextfun ("glBinormal3dEXT" binormal-3d-ext) :void
(bx double)
(by double)
(bz double))
(defglextfun ("glBinormal3dvEXT" binormal-3dv-ext) :void
(v (:pointer double)))
(defglextfun ("glBinormal3fEXT" binormal-3f-ext) :void
(bx float)
(by float)
(bz float))
(defglextfun ("glBinormal3fvEXT" binormal-3fv-ext) :void
(v (:pointer float)))
(defglextfun ("glBinormal3iEXT" binormal-3i-ext) :void
(bx int)
(by int)
(bz int))
(defglextfun ("glBinormal3ivEXT" binormal-3iv-ext) :void
(v (:pointer int)))
(defglextfun ("glBinormal3sEXT" binormal-3s-ext) :void
(bx short)
(by short)
(bz short))
(defglextfun ("glBinormal3svEXT" binormal-3sv-ext) :void
(v (:pointer short)))
(defglextfun ("glTangentPointerEXT" tangent-pointer-ext) :void
(type enum)
(stride sizei)
(pointer (:pointer :void)))
(defglextfun ("glBinormalPointerEXT" binormal-pointer-ext) :void
(type enum)
(stride sizei)
(pointer (:pointer :void)))
(defglextfun ("glCopyTexImage1DEXT" copy-tex-image-1d-ext) :void
(target enum)
(level int)
(internalformat enum)
(x int)
(y int)
(width sizei)
(border int))
(defglextfun ("glCopyTexImage2DEXT" copy-tex-image-2d-ext) :void
(target enum)
(level int)
(internalformat enum)
(x int)
(y int)
(width sizei)
(height sizei)
(border int))
(defglextfun ("glCopyTexSubImage1DEXT" copy-tex-sub-image-1d-ext) :void
(target enum)
(level int)
(xoffset int)
(x int)
(y int)
(width sizei))
(defglextfun ("glCopyTexSubImage2DEXT" copy-tex-sub-image-2d-ext) :void
(target enum)
(level int)
(xoffset int)
(yoffset int)
(x int)
(y int)
(width sizei)
(height sizei))
(defglextfun ("glCopyTexSubImage3DEXT" copy-tex-sub-image-3d-ext) :void
(target enum)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(x int)
(y int)
(width sizei)
(height sizei))
(defglextfun ("glCullParameterdvEXT" cull-parameter-dv-ext) :void
(pname enum)
(params (:pointer double)))
(defglextfun ("glCullParameterfvEXT" cull-parameter-fv-ext) :void
(pname enum)
(params (:pointer float)))
(defglextfun ("glDepthBoundsEXT" depth-bounds-ext) :void
(zmin clampd)
(zmax clampd))
(defglextfun ("glMatrixLoadfEXT" matrix-load-f-ext) :void
(mode enum)
(m (:pointer float)))
(defglextfun ("glMatrixLoaddEXT" matrix-load-d-ext) :void
(mode enum)
(m (:pointer double)))
(defglextfun ("glMatrixMultfEXT" matrix-mult-f-ext) :void
(mode enum)
(m (:pointer float)))
(defglextfun ("glMatrixMultdEXT" matrix-mult-d-ext) :void
(mode enum)
(m (:pointer double)))
(defglextfun ("glMatrixLoadIdentityEXT" matrix-load-identity-ext) :void
(mode enum))
(defglextfun ("glMatrixRotatefEXT" matrix-rotate-f-ext) :void
(mode enum)
(angle float)
(x float)
(y float)
(z float))
(defglextfun ("glMatrixRotatedEXT" matrix-rotate-d-ext) :void
(mode enum)
(angle double)
(x double)
(y double)
(z double))
(defglextfun ("glMatrixScalefEXT" matrix-scale-f-ext) :void
(mode enum)
(x float)
(y float)
(z float))
(defglextfun ("glMatrixScaledEXT" matrix-scale-d-ext) :void
(mode enum)
(x double)
(y double)
(z double))
(defglextfun ("glMatrixTranslatefEXT" matrix-translate-f-ext) :void
(mode enum)
(x float)
(y float)
(z float))
(defglextfun ("glMatrixTranslatedEXT" matrix-translate-d-ext) :void
(mode enum)
(x double)
(y double)
(z double))
(defglextfun ("glMatrixFrustumEXT" matrix-frustum-ext) :void
(mode enum)
(left double)
(right double)
(bottom double)
(top double)
(zNear double)
(zFar double))
(defglextfun ("glMatrixOrthoEXT" matrix-ortho-ext) :void
(mode enum)
(left double)
(right double)
(bottom double)
(top double)
(zNear double)
(zFar double))
(defglextfun ("glMatrixPopEXT" matrix-pop-ext) :void
(mode enum))
(defglextfun ("glMatrixPushEXT" matrix-push-ext) :void
(mode enum))
(defglextfun ("glClientAttribDefaultEXT" client-attrib-default-ext) :void
(mask ClientAttribMask))
(defglextfun ("glPushClientAttribDefaultEXT" push-client-attrib-default-ext) :void
(mask ClientAttribMask))
(defglextfun ("glTextureParameterfEXT" texture-parameter-f-ext) :void
(texture uint)
(target enum)
(pname enum)
(param float))
(defglextfun ("glTextureParameterfvEXT" texture-parameter-fv-ext) :void
(texture uint)
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glTextureParameteriEXT" texture-parameter-i-ext) :void
(texture uint)
(target enum)
(pname enum)
(param int))
(defglextfun ("glTextureParameterivEXT" texture-parameter-iv-ext) :void
(texture uint)
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glTextureImage1DEXT" texture-image-1d-ext) :void
(texture uint)
(target enum)
(level int)
(internalformat int)
(width sizei)
(border int)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glTextureImage2DEXT" texture-image-2d-ext) :void
(texture uint)
(target enum)
(level int)
(internalformat int)
(width sizei)
(height sizei)
(border int)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glTextureSubImage1DEXT" texture-sub-image-1d-ext) :void
(texture uint)
(target enum)
(level int)
(xoffset int)
(width sizei)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glTextureSubImage2DEXT" texture-sub-image-2d-ext) :void
(texture uint)
(target enum)
(level int)
(xoffset int)
(yoffset int)
(width sizei)
(height sizei)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glCopyTextureImage1DEXT" copy-texture-image-1d-ext) :void
(texture uint)
(target enum)
(level int)
(internalformat enum)
(x int)
(y int)
(width sizei)
(border int))
(defglextfun ("glCopyTextureImage2DEXT" copy-texture-image-2d-ext) :void
(texture uint)
(target enum)
(level int)
(internalformat enum)
(x int)
(y int)
(width sizei)
(height sizei)
(border int))
(defglextfun ("glCopyTextureSubImage1DEXT" copy-texture-sub-image-1d-ext) :void
(texture uint)
(target enum)
(level int)
(xoffset int)
(x int)
(y int)
(width sizei))
(defglextfun ("glCopyTextureSubImage2DEXT" copy-texture-sub-image-2d-ext) :void
(texture uint)
(target enum)
(level int)
(xoffset int)
(yoffset int)
(x int)
(y int)
(width sizei)
(height sizei))
(defglextfun ("glGetTextureImageEXT" get-texture-image-ext) :void
(texture uint)
(target enum)
(level int)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glGetTextureParameterfvEXT" get-texture-parameter-fv-ext) :void
(texture uint)
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetTextureParameterivEXT" get-texture-parameter-iv-ext) :void
(texture uint)
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetTextureLevelParameterfvEXT" get-texture-level-parameter-fv-ext) :void
(texture uint)
(target enum)
(level int)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetTextureLevelParameterivEXT" get-texture-level-parameter-iv-ext) :void
(texture uint)
(target enum)
(level int)
(pname enum)
(params (:pointer int)))
(defglextfun ("glTextureImage3DEXT" texture-image-3d-ext) :void
(texture uint)
(target enum)
(level int)
(internalformat int)
(width sizei)
(height sizei)
(depth sizei)
(border int)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glTextureSubImage3DEXT" texture-sub-image-3d-ext) :void
(texture uint)
(target enum)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glCopyTextureSubImage3DEXT" copy-texture-sub-image-3d-ext) :void
(texture uint)
(target enum)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(x int)
(y int)
(width sizei)
(height sizei))
(defglextfun ("glBindMultiTextureEXT" bind-multi-texture-ext) :void
(texunit enum)
(target enum)
(texture uint))
(defglextfun ("glMultiTexCoordPointerEXT" multi-tex-coord-pointer-ext) :void
(texunit enum)
(size int)
(type enum)
(stride sizei)
(pointer (:pointer :void)))
(defglextfun ("glMultiTexEnvfEXT" multi-tex-env-f-ext) :void
(texunit enum)
(target enum)
(pname enum)
(param float))
(defglextfun ("glMultiTexEnvfvEXT" multi-tex-env-fv-ext) :void
(texunit enum)
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glMultiTexEnviEXT" multi-tex-env-i-ext) :void
(texunit enum)
(target enum)
(pname enum)
(param int))
(defglextfun ("glMultiTexEnvivEXT" multi-tex-env-iv-ext) :void
(texunit enum)
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glMultiTexGendEXT" multi-tex-gen-d-ext) :void
(texunit enum)
(coord enum)
(pname enum)
(param double))
(defglextfun ("glMultiTexGendvEXT" multi-tex-gen-dv-ext) :void
(texunit enum)
(coord enum)
(pname enum)
(params (:pointer double)))
(defglextfun ("glMultiTexGenfEXT" multi-tex-gen-f-ext) :void
(texunit enum)
(coord enum)
(pname enum)
(param float))
(defglextfun ("glMultiTexGenfvEXT" multi-tex-gen-fv-ext) :void
(texunit enum)
(coord enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glMultiTexGeniEXT" multi-tex-gen-i-ext) :void
(texunit enum)
(coord enum)
(pname enum)
(param int))
(defglextfun ("glMultiTexGenivEXT" multi-tex-gen-iv-ext) :void
(texunit enum)
(coord enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetMultiTexEnvfvEXT" get-multi-tex-env-fv-ext) :void
(texunit enum)
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetMultiTexEnvivEXT" get-multi-tex-env-iv-ext) :void
(texunit enum)
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetMultiTexGendvEXT" get-multi-tex-gen-dv-ext) :void
(texunit enum)
(coord enum)
(pname enum)
(params (:pointer double)))
(defglextfun ("glGetMultiTexGenfvEXT" get-multi-tex-gen-fv-ext) :void
(texunit enum)
(coord enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetMultiTexGenivEXT" get-multi-tex-gen-iv-ext) :void
(texunit enum)
(coord enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glMultiTexParameteriEXT" multi-tex-parameter-i-ext) :void
(texunit enum)
(target enum)
(pname enum)
(param int))
(defglextfun ("glMultiTexParameterivEXT" multi-tex-parameter-iv-ext) :void
(texunit enum)
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glMultiTexParameterfEXT" multi-tex-parameter-f-ext) :void
(texunit enum)
(target enum)
(pname enum)
(param float))
(defglextfun ("glMultiTexParameterfvEXT" multi-tex-parameter-fv-ext) :void
(texunit enum)
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glMultiTexImage1DEXT" multi-tex-image-1d-ext) :void
(texunit enum)
(target enum)
(level int)
(internalformat int)
(width sizei)
(border int)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glMultiTexImage2DEXT" multi-tex-image-2d-ext) :void
(texunit enum)
(target enum)
(level int)
(internalformat int)
(width sizei)
(height sizei)
(border int)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glMultiTexSubImage1DEXT" multi-tex-sub-image-1d-ext) :void
(texunit enum)
(target enum)
(level int)
(xoffset int)
(width sizei)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glMultiTexSubImage2DEXT" multi-tex-sub-image-2d-ext) :void
(texunit enum)
(target enum)
(level int)
(xoffset int)
(yoffset int)
(width sizei)
(height sizei)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glCopyMultiTexImage1DEXT" copy-multi-tex-image-1d-ext) :void
(texunit enum)
(target enum)
(level int)
(internalformat enum)
(x int)
(y int)
(width sizei)
(border int))
(defglextfun ("glCopyMultiTexImage2DEXT" copy-multi-tex-image-2d-ext) :void
(texunit enum)
(target enum)
(level int)
(internalformat enum)
(x int)
(y int)
(width sizei)
(height sizei)
(border int))
(defglextfun ("glCopyMultiTexSubImage1DEXT" copy-multi-tex-sub-image-1d-ext) :void
(texunit enum)
(target enum)
(level int)
(xoffset int)
(x int)
(y int)
(width sizei))
(defglextfun ("glCopyMultiTexSubImage2DEXT" copy-multi-tex-sub-image-2d-ext) :void
(texunit enum)
(target enum)
(level int)
(xoffset int)
(yoffset int)
(x int)
(y int)
(width sizei)
(height sizei))
(defglextfun ("glGetMultiTexImageEXT" get-multi-tex-image-ext) :void
(texunit enum)
(target enum)
(level int)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glGetMultiTexParameterfvEXT" get-multi-tex-parameter-fv-ext) :void
(texunit enum)
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetMultiTexParameterivEXT" get-multi-tex-parameter-iv-ext) :void
(texunit enum)
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetMultiTexLevelParameterfvEXT" get-multi-tex-level-parameter-fv-ext) :void
(texunit enum)
(target enum)
(level int)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetMultiTexLevelParameterivEXT" get-multi-tex-level-parameter-iv-ext) :void
(texunit enum)
(target enum)
(level int)
(pname enum)
(params (:pointer int)))
(defglextfun ("glMultiTexImage3DEXT" multi-tex-image-3d-ext) :void
(texunit enum)
(target enum)
(level int)
(internalformat int)
(width sizei)
(height sizei)
(depth sizei)
(border int)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glMultiTexSubImage3DEXT" multi-tex-sub-image-3d-ext) :void
(texunit enum)
(target enum)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glCopyMultiTexSubImage3DEXT" copy-multi-tex-sub-image-3d-ext) :void
(texunit enum)
(target enum)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(x int)
(y int)
(width sizei)
(height sizei))
(defglextfun ("glEnableClientStateIndexedEXT" enable-client-state-indexed-ext) :void
(array enum)
(index uint))
(defglextfun ("glDisableClientStateIndexedEXT" disable-client-state-indexed-ext) :void
(array enum)
(index uint))
(defglextfun ("glGetFloatIndexedvEXT" get-float-indexed-v-ext) :void
(target enum)
(index uint)
(data (:pointer float)))
(defglextfun ("glGetDoubleIndexedvEXT" get-double-indexed-v-ext) :void
(target enum)
(index uint)
(data (:pointer double)))
(defglextfun ("glGetPointerIndexedvEXT" get-pointer-indexed-v-ext) :void
(target enum)
(index uint)
(data (:pointer (:pointer :void))))
(defglextfun ("glEnableIndexedEXT" enable-indexed-ext) :void
(target enum)
(index uint))
(defglextfun ("glDisableIndexedEXT" disable-indexed-ext) :void
(target enum)
(index uint))
(defglextfun ("glIsEnabledIndexedEXT" is-enabled-indexed-ext) boolean
(target enum)
(index uint))
(defglextfun ("glGetIntegerIndexedvEXT" get-integer-indexed-v-ext) :void
(target enum)
(index uint)
(data (:pointer int)))
(defglextfun ("glGetBooleanIndexedvEXT" get-boolean-indexed-v-ext) :void
(target enum)
(index uint)
(data (:pointer boolean)))
(defglextfun ("glCompressedTextureImage3DEXT" compressed-texture-image-3d-ext) :void
(texture uint)
(target enum)
(level int)
(internalformat enum)
(width sizei)
(height sizei)
(depth sizei)
(border int)
(imageSize sizei)
(bits (:pointer :void)))
(defglextfun ("glCompressedTextureImage2DEXT" compressed-texture-image-2d-ext) :void
(texture uint)
(target enum)
(level int)
(internalformat enum)
(width sizei)
(height sizei)
(border int)
(imageSize sizei)
(bits (:pointer :void)))
(defglextfun ("glCompressedTextureImage1DEXT" compressed-texture-image-1d-ext) :void
(texture uint)
(target enum)
(level int)
(internalformat enum)
(width sizei)
(border int)
(imageSize sizei)
(bits (:pointer :void)))
(defglextfun ("glCompressedTextureSubImage3DEXT" compressed-texture-sub-image-3d-ext) :void
(texture uint)
(target enum)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei)
(format enum)
(imageSize sizei)
(bits (:pointer :void)))
(defglextfun ("glCompressedTextureSubImage2DEXT" compressed-texture-sub-image-2d-ext) :void
(texture uint)
(target enum)
(level int)
(xoffset int)
(yoffset int)
(width sizei)
(height sizei)
(format enum)
(imageSize sizei)
(bits (:pointer :void)))
(defglextfun ("glCompressedTextureSubImage1DEXT" compressed-texture-sub-image-1d-ext) :void
(texture uint)
(target enum)
(level int)
(xoffset int)
(width sizei)
(format enum)
(imageSize sizei)
(bits (:pointer :void)))
(defglextfun ("glGetCompressedTextureImageEXT" get-compressed-texture-image-ext) :void
(texture uint)
(target enum)
(lod int)
(img (:pointer :void)))
(defglextfun ("glCompressedMultiTexImage3DEXT" compressed-multi-tex-image-3d-ext) :void
(texunit enum)
(target enum)
(level int)
(internalformat enum)
(width sizei)
(height sizei)
(depth sizei)
(border int)
(imageSize sizei)
(bits (:pointer :void)))
(defglextfun ("glCompressedMultiTexImage2DEXT" compressed-multi-tex-image-2d-ext) :void
(texunit enum)
(target enum)
(level int)
(internalformat enum)
(width sizei)
(height sizei)
(border int)
(imageSize sizei)
(bits (:pointer :void)))
(defglextfun ("glCompressedMultiTexImage1DEXT" compressed-multi-tex-image-1d-ext) :void
(texunit enum)
(target enum)
(level int)
(internalformat enum)
(width sizei)
(border int)
(imageSize sizei)
(bits (:pointer :void)))
(defglextfun ("glCompressedMultiTexSubImage3DEXT" compressed-multi-tex-sub-image-3d-ext) :void
(texunit enum)
(target enum)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei)
(format enum)
(imageSize sizei)
(bits (:pointer :void)))
(defglextfun ("glCompressedMultiTexSubImage2DEXT" compressed-multi-tex-sub-image-2d-ext) :void
(texunit enum)
(target enum)
(level int)
(xoffset int)
(yoffset int)
(width sizei)
(height sizei)
(format enum)
(imageSize sizei)
(bits (:pointer :void)))
(defglextfun ("glCompressedMultiTexSubImage1DEXT" compressed-multi-tex-sub-image-1d-ext) :void
(texunit enum)
(target enum)
(level int)
(xoffset int)
(width sizei)
(format enum)
(imageSize sizei)
(bits (:pointer :void)))
(defglextfun ("glGetCompressedMultiTexImageEXT" get-compressed-multi-tex-image-ext) :void
(texunit enum)
(target enum)
(lod int)
(img (:pointer :void)))
(defglextfun ("glMatrixLoadTransposefEXT" matrix-load-transpose-f-ext) :void
(mode enum)
(m (:pointer float)))
(defglextfun ("glMatrixLoadTransposedEXT" matrix-load-transpose-d-ext) :void
(mode enum)
(m (:pointer double)))
(defglextfun ("glMatrixMultTransposefEXT" matrix-mult-transpose-f-ext) :void
(mode enum)
(m (:pointer float)))
(defglextfun ("glMatrixMultTransposedEXT" matrix-mult-transpose-d-ext) :void
(mode enum)
(m (:pointer double)))
(defglextfun ("glNamedBufferDataEXT" named-buffer-data-ext) :void
(buffer uint)
(size sizeiptr)
(data (:pointer :void))
(usage enum))
(defglextfun ("glNamedBufferSubDataEXT" named-buffer-sub-data-ext) :void
(buffer uint)
(offset intptr)
(size sizeiptr)
(data (:pointer :void)))
(defglextfun ("glMapNamedBufferEXT" map-named-buffer-ext) (:pointer :void)
(buffer uint)
(access enum))
(defglextfun ("glUnmapNamedBufferEXT" unmap-named-buffer-ext) boolean
(buffer uint))
(defglextfun ("glGetNamedBufferParameterivEXT" get-named-buffer-parameter-iv-ext) :void
(buffer uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetNamedBufferPointervEXT" get-named-buffer-pointer-v-ext) :void
(buffer uint)
(pname enum)
(params (:pointer (:pointer :void))))
(defglextfun ("glGetNamedBufferSubDataEXT" get-named-buffer-sub-data-ext) :void
(buffer uint)
(offset intptr)
(size sizeiptr)
(data (:pointer :void)))
(defglextfun ("glTextureBufferEXT" texture-buffer-ext) :void
(texture uint)
(target enum)
(internalformat enum)
(buffer uint))
(defglextfun ("glMultiTexBufferEXT" multi-tex-buffer-ext) :void
(texunit enum)
(target enum)
(internalformat enum)
(buffer uint))
(defglextfun ("glTextureParameterIivEXT" texture-parameter-iiv-ext) :void
(texture uint)
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glTextureParameterIuivEXT" texture-parameter-iuiv-ext) :void
(texture uint)
(target enum)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glGetTextureParameterIivEXT" get-texture-parameter-iiv-ext) :void
(texture uint)
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetTextureParameterIuivEXT" get-texture-parameter-iuiv-ext) :void
(texture uint)
(target enum)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glMultiTexParameterIivEXT" multi-tex-parameter-iiv-ext) :void
(texunit enum)
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glMultiTexParameterIuivEXT" multi-tex-parameter-iuiv-ext) :void
(texunit enum)
(target enum)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glGetMultiTexParameterIivEXT" get-multi-tex-parameter-iiv-ext) :void
(texunit enum)
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetMultiTexParameterIuivEXT" get-multi-tex-parameter-iuiv-ext) :void
(texunit enum)
(target enum)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glNamedProgramLocalParameters4fvEXT" named-program-local-parameters-4fv-ext) :void
(program uint)
(target enum)
(index uint)
(count sizei)
(params (:pointer float)))
(defglextfun ("glNamedProgramLocalParameterI4iEXT" named-program-local-parameter-i4i-ext) :void
(program uint)
(target enum)
(index uint)
(x int)
(y int)
(z int)
(w int))
(defglextfun ("glNamedProgramLocalParameterI4ivEXT" named-program-local-parameter-i4iv-ext) :void
(program uint)
(target enum)
(index uint)
(params (:pointer int)))
(defglextfun ("glNamedProgramLocalParametersI4ivEXT" named-program-local-parameters-i4iv-ext) :void
(program uint)
(target enum)
(index uint)
(count sizei)
(params (:pointer int)))
(defglextfun ("glNamedProgramLocalParameterI4uiEXT" named-program-local-parameter-i4ui-ext) :void
(program uint)
(target enum)
(index uint)
(x uint)
(y uint)
(z uint)
(w uint))
(defglextfun ("glNamedProgramLocalParameterI4uivEXT" named-program-local-parameter-i4uiv-ext) :void
(program uint)
(target enum)
(index uint)
(params (:pointer uint)))
(defglextfun ("glNamedProgramLocalParametersI4uivEXT" named-program-local-parameters-i4uiv-ext) :void
(program uint)
(target enum)
(index uint)
(count sizei)
(params (:pointer uint)))
(defglextfun ("glGetNamedProgramLocalParameterIivEXT" get-named-program-local-parameter-iiv-ext) :void
(program uint)
(target enum)
(index uint)
(params (:pointer int)))
(defglextfun ("glGetNamedProgramLocalParameterIuivEXT" get-named-program-local-parameter-iuiv-ext) :void
(program uint)
(target enum)
(index uint)
(params (:pointer uint)))
(defglextfun ("glEnableClientStateiEXT" enable-client-state-i-ext) :void
(array enum)
(index uint))
(defglextfun ("glDisableClientStateiEXT" disable-client-state-i-ext) :void
(array enum)
(index uint))
(defglextfun ("glGetFloati_vEXT" get-float-i-v-ext) :void
(pname enum)
(index uint)
(params (:pointer float)))
(defglextfun ("glGetDoublei_vEXT" get-double-i-v-ext) :void
(pname enum)
(index uint)
(params (:pointer double)))
(defglextfun ("glGetPointeri_vEXT" get-pointer-i-v-ext) :void
(pname enum)
(index uint)
(params (:pointer (:pointer :void))))
(defglextfun ("glNamedProgramStringEXT" named-program-string-ext) :void
(program uint)
(target enum)
(format enum)
(len sizei)
(string (:pointer :void)))
(defglextfun ("glNamedProgramLocalParameter4dEXT" named-program-local-parameter-4d-ext) :void
(program uint)
(target enum)
(index uint)
(x double)
(y double)
(z double)
(w double))
(defglextfun ("glNamedProgramLocalParameter4dvEXT" named-program-local-parameter-4dv-ext) :void
(program uint)
(target enum)
(index uint)
(params (:pointer double)))
(defglextfun ("glNamedProgramLocalParameter4fEXT" named-program-local-parameter-4f-ext) :void
(program uint)
(target enum)
(index uint)
(x float)
(y float)
(z float)
(w float))
(defglextfun ("glNamedProgramLocalParameter4fvEXT" named-program-local-parameter-4fv-ext) :void
(program uint)
(target enum)
(index uint)
(params (:pointer float)))
(defglextfun ("glGetNamedProgramLocalParameterdvEXT" get-named-program-local-parameter-dv-ext) :void
(program uint)
(target enum)
(index uint)
(params (:pointer double)))
(defglextfun ("glGetNamedProgramLocalParameterfvEXT" get-named-program-local-parameter-fv-ext) :void
(program uint)
(target enum)
(index uint)
(params (:pointer float)))
(defglextfun ("glGetNamedProgramivEXT" get-named-program-iv-ext) :void
(program uint)
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetNamedProgramStringEXT" get-named-program-string-ext) :void
(program uint)
(target enum)
(pname enum)
(string (:pointer :void)))
(defglextfun ("glNamedRenderbufferStorageEXT" named-renderbuffer-storage-ext) :void
(renderbuffer uint)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glGetNamedRenderbufferParameterivEXT" get-named-renderbuffer-parameter-iv-ext) :void
(renderbuffer uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glNamedRenderbufferStorageMultisampleEXT" named-renderbuffer-storage-multisample-ext) :void
(renderbuffer uint)
(samples sizei)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glNamedRenderbufferStorageMultisampleCoverageEXT" named-renderbuffer-storage-multisample-coverage-ext) :void
(renderbuffer uint)
(coverageSamples sizei)
(colorSamples sizei)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glCheckNamedFramebufferStatusEXT" check-named-framebuffer-status-ext) enum
(framebuffer uint)
(target enum))
(defglextfun ("glNamedFramebufferTexture1DEXT" named-framebuffer-texture-1d-ext) :void
(framebuffer uint)
(attachment enum)
(textarget enum)
(texture uint)
(level int))
(defglextfun ("glNamedFramebufferTexture2DEXT" named-framebuffer-texture-2d-ext) :void
(framebuffer uint)
(attachment enum)
(textarget enum)
(texture uint)
(level int))
(defglextfun ("glNamedFramebufferTexture3DEXT" named-framebuffer-texture-3d-ext) :void
(framebuffer uint)
(attachment enum)
(textarget enum)
(texture uint)
(level int)
(zoffset int))
(defglextfun ("glNamedFramebufferRenderbufferEXT" named-framebuffer-renderbuffer-ext) :void
(framebuffer uint)
(attachment enum)
(renderbuffertarget enum)
(renderbuffer uint))
(defglextfun ("glGetNamedFramebufferAttachmentParameterivEXT" get-named-framebuffer-attachment-parameter-iv-ext) :void
(framebuffer uint)
(attachment enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGenerateTextureMipmapEXT" generate-texture-mipmap-ext) :void
(texture uint)
(target enum))
(defglextfun ("glGenerateMultiTexMipmapEXT" generate-multi-tex-mipmap-ext) :void
(texunit enum)
(target enum))
(defglextfun ("glFramebufferDrawBufferEXT" framebuffer-draw-buffer-ext) :void
(framebuffer uint)
(mode enum))
(defglextfun ("glFramebufferDrawBuffersEXT" framebuffer-draw-buffers-ext) :void
(framebuffer uint)
(n sizei)
(bufs (:pointer enum)))
(defglextfun ("glFramebufferReadBufferEXT" framebuffer-read-buffer-ext) :void
(framebuffer uint)
(mode enum))
(defglextfun ("glGetFramebufferParameterivEXT" get-framebuffer-parameter-iv-ext) :void
(framebuffer uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glNamedCopyBufferSubDataEXT" named-copy-buffer-sub-data-ext) :void
(readBuffer uint)
(writeBuffer uint)
(readOffset intptr)
(writeOffset intptr)
(size sizeiptr))
(defglextfun ("glNamedFramebufferTextureEXT" named-framebuffer-texture-ext) :void
(framebuffer uint)
(attachment enum)
(texture uint)
(level int))
(defglextfun ("glNamedFramebufferTextureLayerEXT" named-framebuffer-texture-layer-ext) :void
(framebuffer uint)
(attachment enum)
(texture uint)
(level int)
(layer int))
(defglextfun ("glNamedFramebufferTextureFaceEXT" named-framebuffer-texture-face-ext) :void
(framebuffer uint)
(attachment enum)
(texture uint)
(level int)
(face enum))
(defglextfun ("glTextureRenderbufferEXT" texture-renderbuffer-ext) :void
(texture uint)
(target enum)
(renderbuffer uint))
(defglextfun ("glMultiTexRenderbufferEXT" multi-tex-renderbuffer-ext) :void
(texunit enum)
(target enum)
(renderbuffer uint))
(defglextfun ("glVertexArrayVertexOffsetEXT" vertex-array-vertex-offset-ext) :void
(vaobj uint)
(buffer uint)
(size int)
(type enum)
(stride sizei)
(offset intptr))
(defglextfun ("glVertexArrayColorOffsetEXT" vertex-array-color-offset-ext) :void
(vaobj uint)
(buffer uint)
(size int)
(type enum)
(stride sizei)
(offset intptr))
(defglextfun ("glVertexArrayEdgeFlagOffsetEXT" vertex-array-edge-flag-offset-ext) :void
(vaobj uint)
(buffer uint)
(stride sizei)
(offset intptr))
(defglextfun ("glVertexArrayIndexOffsetEXT" vertex-array-index-offset-ext) :void
(vaobj uint)
(buffer uint)
(type enum)
(stride sizei)
(offset intptr))
(defglextfun ("glVertexArrayNormalOffsetEXT" vertex-array-normal-offset-ext) :void
(vaobj uint)
(buffer uint)
(type enum)
(stride sizei)
(offset intptr))
(defglextfun ("glVertexArrayTexCoordOffsetEXT" vertex-array-tex-coord-offset-ext) :void
(vaobj uint)
(buffer uint)
(size int)
(type enum)
(stride sizei)
(offset intptr))
(defglextfun ("glVertexArrayMultiTexCoordOffsetEXT" vertex-array-multi-tex-coord-offset-ext) :void
(vaobj uint)
(buffer uint)
(texunit enum)
(size int)
(type enum)
(stride sizei)
(offset intptr))
(defglextfun ("glVertexArrayFogCoordOffsetEXT" vertex-array-fog-coord-offset-ext) :void
(vaobj uint)
(buffer uint)
(type enum)
(stride sizei)
(offset intptr))
(defglextfun ("glVertexArraySecondaryColorOffsetEXT" vertex-array-secondary-color-offset-ext) :void
(vaobj uint)
(buffer uint)
(size int)
(type enum)
(stride sizei)
(offset intptr))
(defglextfun ("glVertexArrayVertexAttribOffsetEXT" vertex-array-vertex-attrib-offset-ext) :void
(vaobj uint)
(buffer uint)
(index uint)
(size int)
(type enum)
(normalized boolean)
(stride sizei)
(offset intptr))
(defglextfun ("glVertexArrayVertexAttribIOffsetEXT" vertex-array-vertex-attrib-i-offset-ext) :void
(vaobj uint)
(buffer uint)
(index uint)
(size int)
(type enum)
(stride sizei)
(offset intptr))
(defglextfun ("glEnableVertexArrayEXT" enable-vertex-array-ext) :void
(vaobj uint)
(array enum))
(defglextfun ("glDisableVertexArrayEXT" disable-vertex-array-ext) :void
(vaobj uint)
(array enum))
(defglextfun ("glEnableVertexArrayAttribEXT" enable-vertex-array-attrib-ext) :void
(vaobj uint)
(index uint))
(defglextfun ("glDisableVertexArrayAttribEXT" disable-vertex-array-attrib-ext) :void
(vaobj uint)
(index uint))
(defglextfun ("glGetVertexArrayIntegervEXT" get-vertex-array-integer-v-ext) :void
(vaobj uint)
(pname enum)
(param (:pointer int)))
(defglextfun ("glGetVertexArrayPointervEXT" get-vertex-array-pointer-v-ext) :void
(vaobj uint)
(pname enum)
(param (:pointer (:pointer :void))))
(defglextfun ("glGetVertexArrayIntegeri_vEXT" get-vertex-array-integer-i-v-ext) :void
(vaobj uint)
(index uint)
(pname enum)
(param (:pointer int)))
(defglextfun ("glGetVertexArrayPointeri_vEXT" get-vertex-array-pointer-i-v-ext) :void
(vaobj uint)
(index uint)
(pname enum)
(param (:pointer (:pointer :void))))
(defglextfun ("glMapNamedBufferRangeEXT" map-named-buffer-range-ext) (:pointer :void)
(buffer uint)
(offset intptr)
(length sizeiptr)
(access bitfield))
(defglextfun ("glFlushMappedNamedBufferRangeEXT" flush-mapped-named-buffer-range-ext) :void
(buffer uint)
(offset intptr)
(length sizeiptr))
(defglextfun ("glNamedBufferStorageEXT" named-buffer-storage-ext) :void
(buffer uint)
(size sizeiptr)
(data (:pointer :void))
(flags bitfield))
(defglextfun ("glClearNamedBufferDataEXT" clear-named-buffer-data-ext) :void
(buffer uint)
(internalformat enum)
(format enum)
(type enum)
(data (:pointer :void)))
(defglextfun ("glClearNamedBufferSubDataEXT" clear-named-buffer-sub-data-ext) :void
(buffer uint)
(internalformat enum)
(offset sizeiptr)
(size sizeiptr)
(format enum)
(type enum)
(data (:pointer :void)))
(defglextfun ("glNamedFramebufferParameteriEXT" named-framebuffer-parameter-i-ext) :void
(framebuffer uint)
(pname enum)
(param int))
(defglextfun ("glGetNamedFramebufferParameterivEXT" get-named-framebuffer-parameter-iv-ext) :void
(framebuffer uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glProgramUniform1dEXT" program-uniform-1d-ext) :void
(program uint)
(location int)
(x double))
(defglextfun ("glProgramUniform2dEXT" program-uniform-2d-ext) :void
(program uint)
(location int)
(x double)
(y double))
(defglextfun ("glProgramUniform3dEXT" program-uniform-3d-ext) :void
(program uint)
(location int)
(x double)
(y double)
(z double))
(defglextfun ("glProgramUniform4dEXT" program-uniform-4d-ext) :void
(program uint)
(location int)
(x double)
(y double)
(z double)
(w double))
(defglextfun ("glProgramUniform1dvEXT" program-uniform-1dv-ext) :void
(program uint)
(location int)
(count sizei)
(value (:pointer double)))
(defglextfun ("glProgramUniform2dvEXT" program-uniform-2dv-ext) :void
(program uint)
(location int)
(count sizei)
(value (:pointer double)))
(defglextfun ("glProgramUniform3dvEXT" program-uniform-3dv-ext) :void
(program uint)
(location int)
(count sizei)
(value (:pointer double)))
(defglextfun ("glProgramUniform4dvEXT" program-uniform-4dv-ext) :void
(program uint)
(location int)
(count sizei)
(value (:pointer double)))
(defglextfun ("glProgramUniformMatrix2dvEXT" program-uniform-matrix-2dv-ext) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glProgramUniformMatrix3dvEXT" program-uniform-matrix-3dv-ext) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glProgramUniformMatrix4dvEXT" program-uniform-matrix-4dv-ext) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glProgramUniformMatrix2x3dvEXT" program-uniform-matrix-2x3-dv-ext) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glProgramUniformMatrix2x4dvEXT" program-uniform-matrix-2x4-dv-ext) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glProgramUniformMatrix3x2dvEXT" program-uniform-matrix-3x2-dv-ext) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glProgramUniformMatrix3x4dvEXT" program-uniform-matrix-3x4-dv-ext) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glProgramUniformMatrix4x2dvEXT" program-uniform-matrix-4x2-dv-ext) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glProgramUniformMatrix4x3dvEXT" program-uniform-matrix-4x3-dv-ext) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer double)))
(defglextfun ("glTextureBufferRangeEXT" texture-buffer-range-ext) :void
(texture uint)
(target enum)
(internalformat enum)
(buffer uint)
(offset intptr)
(size sizeiptr))
(defglextfun ("glTextureStorage2DMultisampleEXT" texture-storage-2d-multisample-ext) :void
(texture uint)
(target enum)
(samples sizei)
(internalformat enum)
(width sizei)
(height sizei)
(fixedsamplelocations boolean))
(defglextfun ("glTextureStorage3DMultisampleEXT" texture-storage-3d-multisample-ext) :void
(texture uint)
(target enum)
(samples sizei)
(internalformat enum)
(width sizei)
(height sizei)
(depth sizei)
(fixedsamplelocations boolean))
(defglextfun ("glVertexArrayBindVertexBufferEXT" vertex-array-bind-vertex-buffer-ext) :void
(vaobj uint)
(bindingindex uint)
(buffer uint)
(offset intptr)
(stride sizei))
(defglextfun ("glVertexArrayVertexAttribFormatEXT" vertex-array-vertex-attrib-format-ext) :void
(vaobj uint)
(attribindex uint)
(size int)
(type enum)
(normalized boolean)
(relativeoffset uint))
(defglextfun ("glVertexArrayVertexAttribIFormatEXT" vertex-array-vertex-attrib-i-format-ext) :void
(vaobj uint)
(attribindex uint)
(size int)
(type enum)
(relativeoffset uint))
(defglextfun ("glVertexArrayVertexAttribLFormatEXT" vertex-array-vertex-attrib-l-format-ext) :void
(vaobj uint)
(attribindex uint)
(size int)
(type enum)
(relativeoffset uint))
(defglextfun ("glVertexArrayVertexAttribBindingEXT" vertex-array-vertex-attrib-binding-ext) :void
(vaobj uint)
(attribindex uint)
(bindingindex uint))
(defglextfun ("glVertexArrayVertexBindingDivisorEXT" vertex-array-vertex-binding-divisor-ext) :void
(vaobj uint)
(bindingindex uint)
(divisor uint))
(defglextfun ("glVertexArrayVertexAttribLOffsetEXT" vertex-array-vertex-attrib-loffset-ext) :void
(vaobj uint)
(buffer uint)
(index uint)
(size int)
(type enum)
(stride sizei)
(offset intptr))
(defglextfun ("glTexturePageCommitmentEXT" texture-page-commitment-ext) :void
(texture uint)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei)
(commit boolean))
(defglextfun ("glVertexArrayVertexAttribDivisorEXT" vertex-array-vertex-attrib-divisor-ext) :void
(vaobj uint)
(index uint)
(divisor uint))
(defglextfun ("glColorMaskIndexedEXT" color-mask-indexed-ext) :void
(index uint)
(r boolean)
(g boolean)
(b boolean)
(a boolean))
(defglextfun ("glDrawRangeElementsEXT" draw-range-elements-ext) :void
(mode enum)
(start uint)
(end uint)
(count sizei)
(type enum)
(indices (:pointer :void)))
(defglextfun ("glFogCoordfEXT" fog-coord-f-ext) :void
(coord float))
(defglextfun ("glFogCoordfvEXT" fog-coord-fv-ext) :void
(coord (:pointer float)))
(defglextfun ("glFogCoorddEXT" fog-coord-d-ext) :void
(coord double))
(defglextfun ("glFogCoorddvEXT" fog-coord-dv-ext) :void
(coord (:pointer double)))
(defglextfun ("glFogCoordPointerEXT" fog-coord-pointer-ext) :void
(type enum)
(stride sizei)
(pointer (:pointer :void)))
(defglextfun ("glBlitFramebufferEXT" blit-framebuffer-ext) :void
(srcX0 int)
(srcY0 int)
(srcX1 int)
(srcY1 int)
(dstX0 int)
(dstY0 int)
(dstX1 int)
(dstY1 int)
(mask ClearBufferMask)
(filter enum))
(defglextfun ("glIsRenderbufferEXT" is-renderbuffer-ext) boolean
(renderbuffer uint))
(defglextfun ("glBindRenderbufferEXT" bind-renderbuffer-ext) :void
(target enum)
(renderbuffer uint))
(defglextfun ("glDeleteRenderbuffersEXT" delete-renderbuffers-ext) :void
(n sizei)
(renderbuffers (:pointer uint)))
(defglextfun ("glGenRenderbuffersEXT" gen-renderbuffers-ext) :void
(n sizei)
(renderbuffers (:pointer uint)))
(defglextfun ("glRenderbufferStorageEXT" renderbuffer-storage-ext) :void
(target enum)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glGetRenderbufferParameterivEXT" get-renderbuffer-parameter-iv-ext) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glIsFramebufferEXT" is-framebuffer-ext) boolean
(framebuffer uint))
(defglextfun ("glBindFramebufferEXT" bind-framebuffer-ext) :void
(target enum)
(framebuffer uint))
(defglextfun ("glDeleteFramebuffersEXT" delete-framebuffers-ext) :void
(n sizei)
(framebuffers (:pointer uint)))
(defglextfun ("glGenFramebuffersEXT" gen-framebuffers-ext) :void
(n sizei)
(framebuffers (:pointer uint)))
(defglextfun ("glCheckFramebufferStatusEXT" check-framebuffer-status-ext) enum
(target enum))
(defglextfun ("glFramebufferTexture1DEXT" framebuffer-texture-1d-ext) :void
(target enum)
(attachment enum)
(textarget enum)
(texture uint)
(level int))
(defglextfun ("glFramebufferTexture2DEXT" framebuffer-texture-2d-ext) :void
(target enum)
(attachment enum)
(textarget enum)
(texture uint)
(level int))
(defglextfun ("glFramebufferTexture3DEXT" framebuffer-texture-3d-ext) :void
(target enum)
(attachment enum)
(textarget enum)
(texture uint)
(level int)
(zoffset int))
(defglextfun ("glFramebufferRenderbufferEXT" framebuffer-renderbuffer-ext) :void
(target enum)
(attachment enum)
(renderbuffertarget enum)
(renderbuffer uint))
(defglextfun ("glGetFramebufferAttachmentParameterivEXT" get-framebuffer-attachment-parameter-iv-ext) :void
(target enum)
(attachment enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGenerateMipmapEXT" generate-mipmap-ext) :void
(target enum))
(defglextfun ("glProgramEnvParameters4fvEXT" program-env-parameters-4fv-ext) :void
(target enum)
(index uint)
(count sizei)
(params (:pointer float)))
(defglextfun ("glProgramLocalParameters4fvEXT" program-local-parameters-4fv-ext) :void
(target enum)
(index uint)
(count sizei)
(params (:pointer float)))
(defglextfun ("glGetUniformuivEXT" get-uniform-uiv-ext) :void
(program uint)
(location int)
(params (:pointer uint)))
(defglextfun ("glBindFragDataLocationEXT" bind-frag-data-location-ext) :void
(program uint)
(color uint)
(name (:pointer char)))
(defglextfun ("glGetFragDataLocationEXT" get-frag-data-location-ext) int
(program uint)
(name (:pointer char)))
(defglextfun ("glUniform1uiEXT" uniform-1ui-ext) :void
(location int)
(v0 uint))
(defglextfun ("glUniform2uiEXT" uniform-2ui-ext) :void
(location int)
(v0 uint)
(v1 uint))
(defglextfun ("glUniform3uiEXT" uniform-3ui-ext) :void
(location int)
(v0 uint)
(v1 uint)
(v2 uint))
(defglextfun ("glUniform4uiEXT" uniform-4ui-ext) :void
(location int)
(v0 uint)
(v1 uint)
(v2 uint)
(v3 uint))
(defglextfun ("glUniform1uivEXT" uniform-1uiv-ext) :void
(location int)
(count sizei)
(value (:pointer uint)))
(defglextfun ("glUniform2uivEXT" uniform-2uiv-ext) :void
(location int)
(count sizei)
(value (:pointer uint)))
(defglextfun ("glUniform3uivEXT" uniform-3uiv-ext) :void
(location int)
(count sizei)
(value (:pointer uint)))
(defglextfun ("glUniform4uivEXT" uniform-4uiv-ext) :void
(location int)
(count sizei)
(value (:pointer uint)))
(defglextfun ("glGetHistogramEXT" get-histogram-ext) :void
(target enum)
(reset boolean)
(format enum)
(type enum)
(values (:pointer :void)))
(defglextfun ("glGetHistogramParameterfvEXT" get-histogram-parameter-fv-ext) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetHistogramParameterivEXT" get-histogram-parameter-iv-ext) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetMinmaxEXT" get-minmax-ext) :void
(target enum)
(reset boolean)
(format enum)
(type enum)
(values (:pointer :void)))
(defglextfun ("glGetMinmaxParameterfvEXT" get-minmax-parameter-fv-ext) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetMinmaxParameterivEXT" get-minmax-parameter-iv-ext) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glHistogramEXT" histogram-ext) :void
(target enum)
(width sizei)
(internalformat enum)
(sink boolean))
(defglextfun ("glMinmaxEXT" minmax-ext) :void
(target enum)
(internalformat enum)
(sink boolean))
(defglextfun ("glResetHistogramEXT" reset-histogram-ext) :void
(target enum))
(defglextfun ("glResetMinmaxEXT" reset-minmax-ext) :void
(target enum))
(defglextfun ("glIndexFuncEXT" index-func-ext) :void
(func enum)
(ref clampf))
(defglextfun ("glIndexMaterialEXT" index-material-ext) :void
(face enum)
(mode enum))
(defglextfun ("glApplyTextureEXT" apply-texture-ext) :void
(mode enum))
(defglextfun ("glTextureLightEXT" texture-light-ext) :void
(pname enum))
(defglextfun ("glTextureMaterialEXT" texture-material-ext) :void
(face enum)
(mode enum))
(defglextfun ("glSampleMaskEXT" sample-mask-ext) :void
(value clampf)
(invert boolean))
(defglextfun ("glSamplePatternEXT" sample-pattern-ext) :void
(pattern enum))
(defglextfun ("glColorTableEXT" color-table-ext) :void
(target enum)
(internalFormat enum)
(width sizei)
(format enum)
(type enum)
(table (:pointer :void)))
(defglextfun ("glGetColorTableEXT" get-color-table-ext) :void
(target enum)
(format enum)
(type enum)
(data (:pointer :void)))
(defglextfun ("glGetColorTableParameterivEXT" get-color-table-parameter-iv-ext) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetColorTableParameterfvEXT" get-color-table-parameter-fv-ext) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glPixelTransformParameteriEXT" pixel-transform-parameter-i-ext) :void
(target enum)
(pname enum)
(param int))
(defglextfun ("glPixelTransformParameterfEXT" pixel-transform-parameter-f-ext) :void
(target enum)
(pname enum)
(param float))
(defglextfun ("glPixelTransformParameterivEXT" pixel-transform-parameter-iv-ext) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glPixelTransformParameterfvEXT" pixel-transform-parameter-fv-ext) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetPixelTransformParameterivEXT" get-pixel-transform-parameter-iv-ext) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetPixelTransformParameterfvEXT" get-pixel-transform-parameter-fv-ext) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glPointParameterfEXT" point-parameter-f-ext) :void
(pname enum)
(param float))
(defglextfun ("glPointParameterfvEXT" point-parameter-fv-ext) :void
(pname enum)
(params (:pointer float)))
(defglextfun ("glPolygonOffsetEXT" polygon-offset-ext) :void
(factor float)
(bias float))
(defglextfun ("glPolygonOffsetClampEXT" polygon-offset-clamp-ext) :void
(factor float)
(units float)
(clamp float))
(defglextfun ("glProvokingVertexEXT" provoking-vertex-ext) :void
(mode enum))
(defglextfun ("glSecondaryColor3bEXT" secondary-color-3b-ext) :void
(red byte)
(green byte)
(blue byte))
(defglextfun ("glSecondaryColor3bvEXT" secondary-color-3bv-ext) :void
(v (:pointer byte)))
(defglextfun ("glSecondaryColor3dEXT" secondary-color-3d-ext) :void
(red double)
(green double)
(blue double))
(defglextfun ("glSecondaryColor3dvEXT" secondary-color-3dv-ext) :void
(v (:pointer double)))
(defglextfun ("glSecondaryColor3fEXT" secondary-color-3f-ext) :void
(red float)
(green float)
(blue float))
(defglextfun ("glSecondaryColor3fvEXT" secondary-color-3fv-ext) :void
(v (:pointer float)))
(defglextfun ("glSecondaryColor3iEXT" secondary-color-3i-ext) :void
(red int)
(green int)
(blue int))
(defglextfun ("glSecondaryColor3ivEXT" secondary-color-3iv-ext) :void
(v (:pointer int)))
(defglextfun ("glSecondaryColor3sEXT" secondary-color-3s-ext) :void
(red short)
(green short)
(blue short))
(defglextfun ("glSecondaryColor3svEXT" secondary-color-3sv-ext) :void
(v (:pointer short)))
(defglextfun ("glSecondaryColor3ubEXT" secondary-color-3ub-ext) :void
(red ubyte)
(green ubyte)
(blue ubyte))
(defglextfun ("glSecondaryColor3ubvEXT" secondary-color-3ubv-ext) :void
(v (:pointer ubyte)))
(defglextfun ("glSecondaryColor3uiEXT" secondary-color-3ui-ext) :void
(red uint)
(green uint)
(blue uint))
(defglextfun ("glSecondaryColor3uivEXT" secondary-color-3uiv-ext) :void
(v (:pointer uint)))
(defglextfun ("glSecondaryColor3usEXT" secondary-color-3us-ext) :void
(red ushort)
(green ushort)
(blue ushort))
(defglextfun ("glSecondaryColor3usvEXT" secondary-color-3usv-ext) :void
(v (:pointer ushort)))
(defglextfun ("glSecondaryColorPointerEXT" secondary-color-pointer-ext) :void
(size int)
(type enum)
(stride sizei)
(pointer (:pointer :void)))
(defglextfun ("glBindImageTextureEXT" bind-image-texture-ext) :void
(index uint)
(texture uint)
(level int)
(layered boolean)
(layer int)
(access enum)
(format int))
(defglextfun ("glMemoryBarrierEXT" memory-barrier-ext) :void
(barriers bitfield))
(defglextfun ("glStencilClearTagEXT" stencil-clear-tag-ext) :void
(stencilTagBits sizei)
(stencilClearTag uint))
(defglextfun ("glActiveStencilFaceEXT" active-stencil-face-ext) :void
(face enum))
(defglextfun ("glTexSubImage1DEXT" tex-sub-image-1d-ext) :void
(target enum)
(level int)
(xoffset int)
(width sizei)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glTexSubImage2DEXT" tex-sub-image-2d-ext) :void
(target enum)
(level int)
(xoffset int)
(yoffset int)
(width sizei)
(height sizei)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glTexImage3DEXT" tex-image-3d-ext) :void
(target enum)
(level int)
(internalformat enum)
(width sizei)
(height sizei)
(depth sizei)
(border int)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glTexSubImage3DEXT" tex-sub-image-3d-ext) :void
(target enum)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glFramebufferTextureLayerEXT" framebuffer-texture-layer-ext) :void
(target enum)
(attachment enum)
(texture uint)
(level int)
(layer int))
(defglextfun ("glClearColorIiEXT" clear-color-ii-ext) :void
(red int)
(green int)
(blue int)
(alpha int))
(defglextfun ("glClearColorIuiEXT" clear-color-iui-ext) :void
(red uint)
(green uint)
(blue uint)
(alpha uint))
(defglextfun ("glAreTexturesResidentEXT" are-textures-resident-ext) boolean
(n sizei)
(textures (:pointer uint))
(residences (:pointer boolean)))
(defglextfun ("glBindTextureEXT" bind-texture-ext) :void
(target enum)
(texture uint))
(defglextfun ("glDeleteTexturesEXT" delete-textures-ext) :void
(n sizei)
(textures (:pointer uint)))
(defglextfun ("glGenTexturesEXT" gen-textures-ext) :void
(n sizei)
(textures (:pointer uint)))
(defglextfun ("glIsTextureEXT" is-texture-ext) boolean
(texture uint))
(defglextfun ("glPrioritizeTexturesEXT" prioritize-textures-ext) :void
(n sizei)
(textures (:pointer uint))
(priorities (:pointer clampf)))
(defglextfun ("glTextureNormalEXT" texture-normal-ext) :void
(mode enum))
(defglextfun ("glBeginTransformFeedbackEXT" begin-transform-feedback-ext) :void
(primitiveMode enum))
(defglextfun ("glEndTransformFeedbackEXT" end-transform-feedback-ext) :void)
(defglextfun ("glBindBufferRangeEXT" bind-buffer-range-ext) :void
(target enum)
(index uint)
(buffer uint)
(offset intptr)
(size sizeiptr))
(defglextfun ("glBindBufferOffsetEXT" bind-buffer-offset-ext) :void
(target enum)
(index uint)
(buffer uint)
(offset intptr))
(defglextfun ("glBindBufferBaseEXT" bind-buffer-base-ext) :void
(target enum)
(index uint)
(buffer uint))
(defglextfun ("glTransformFeedbackVaryingsEXT" transform-feedback-varyings-ext) :void
(program uint)
(count sizei)
(varyings (:pointer (:pointer char)))
(bufferMode enum))
(defglextfun ("glGetTransformFeedbackVaryingEXT" get-transform-feedback-varying-ext) :void
(program uint)
(index uint)
(bufSize sizei)
(length (:pointer sizei))
(size (:pointer sizei))
(type (:pointer enum))
(name (:pointer char)))
(defglextfun ("glArrayElementEXT" array-element-ext) :void
(i int))
(defglextfun ("glColorPointerEXT" color-pointer-ext) :void
(size int)
(type enum)
(stride sizei)
(count sizei)
(pointer (:pointer :void)))
(defglextfun ("glDrawArraysEXT" draw-arrays-ext) :void
(mode enum)
(first int)
(count sizei))
(defglextfun ("glEdgeFlagPointerEXT" edge-flag-pointer-ext) :void
(stride sizei)
(count sizei)
(pointer (:pointer boolean)))
(defglextfun ("glGetPointervEXT" get-pointer-v-ext) :void
(pname enum)
(params (:pointer (:pointer :void))))
(defglextfun ("glIndexPointerEXT" index-pointer-ext) :void
(type enum)
(stride sizei)
(count sizei)
(pointer (:pointer :void)))
(defglextfun ("glNormalPointerEXT" normal-pointer-ext) :void
(type enum)
(stride sizei)
(count sizei)
(pointer (:pointer :void)))
(defglextfun ("glTexCoordPointerEXT" tex-coord-pointer-ext) :void
(size int)
(type enum)
(stride sizei)
(count sizei)
(pointer (:pointer :void)))
(defglextfun ("glVertexPointerEXT" vertex-pointer-ext) :void
(size int)
(type enum)
(stride sizei)
(count sizei)
(pointer (:pointer :void)))
(defglextfun ("glVertexAttribL1dEXT" vertex-attrib-l1d-ext) :void
(index uint)
(x double))
(defglextfun ("glVertexAttribL2dEXT" vertex-attrib-l2d-ext) :void
(index uint)
(x double)
(y double))
(defglextfun ("glVertexAttribL3dEXT" vertex-attrib-l3d-ext) :void
(index uint)
(x double)
(y double)
(z double))
(defglextfun ("glVertexAttribL4dEXT" vertex-attrib-l4d-ext) :void
(index uint)
(x double)
(y double)
(z double)
(w double))
(defglextfun ("glVertexAttribL1dvEXT" vertex-attrib-l1dv-ext) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttribL2dvEXT" vertex-attrib-l2dv-ext) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttribL3dvEXT" vertex-attrib-l3dv-ext) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttribL4dvEXT" vertex-attrib-l4dv-ext) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttribLPointerEXT" vertex-attrib-lpointer-ext) :void
(index uint)
(size int)
(type enum)
(stride sizei)
(pointer (:pointer :void)))
(defglextfun ("glGetVertexAttribLdvEXT" get-vertex-attrib-ldv-ext) :void
(index uint)
(pname enum)
(params (:pointer double)))
(defglextfun ("glBeginVertexShaderEXT" begin-vertex-shader-ext) :void)
(defglextfun ("glEndVertexShaderEXT" end-vertex-shader-ext) :void)
(defglextfun ("glBindVertexShaderEXT" bind-vertex-shader-ext) :void
(id uint))
(defglextfun ("glGenVertexShadersEXT" gen-vertex-shaders-ext) uint
(range uint))
(defglextfun ("glDeleteVertexShaderEXT" delete-vertex-shader-ext) :void
(id uint))
(defglextfun ("glShaderOp1EXT" shader-op-1-ext) :void
(op enum)
(res uint)
(arg1 uint))
(defglextfun ("glShaderOp2EXT" shader-op-2-ext) :void
(op enum)
(res uint)
(arg1 uint)
(arg2 uint))
(defglextfun ("glShaderOp3EXT" shader-op-3-ext) :void
(op enum)
(res uint)
(arg1 uint)
(arg2 uint)
(arg3 uint))
(defglextfun ("glSwizzleEXT" swizzle-ext) :void
(res uint)
(in uint)
(outX enum)
(outY enum)
(outZ enum)
(outW enum))
(defglextfun ("glWriteMaskEXT" write-mask-ext) :void
(res uint)
(in uint)
(outX enum)
(outY enum)
(outZ enum)
(outW enum))
(defglextfun ("glInsertComponentEXT" insert-component-ext) :void
(res uint)
(src uint)
(num uint))
(defglextfun ("glExtractComponentEXT" extract-component-ext) :void
(res uint)
(src uint)
(num uint))
(defglextfun ("glGenSymbolsEXT" gen-symbols-ext) uint
(datatype enum)
(storagetype enum)
(range enum)
(components uint))
(defglextfun ("glSetInvariantEXT" set-invariant-ext) :void
(id uint)
(type enum)
(addr (:pointer :void)))
(defglextfun ("glSetLocalConstantEXT" set-local-constant-ext) :void
(id uint)
(type enum)
(addr (:pointer :void)))
(defglextfun ("glVariantbvEXT" variant-bv-ext) :void
(id uint)
(addr (:pointer byte)))
(defglextfun ("glVariantsvEXT" variant-sv-ext) :void
(id uint)
(addr (:pointer short)))
(defglextfun ("glVariantivEXT" variant-iv-ext) :void
(id uint)
(addr (:pointer int)))
(defglextfun ("glVariantfvEXT" variant-fv-ext) :void
(id uint)
(addr (:pointer float)))
(defglextfun ("glVariantdvEXT" variant-dv-ext) :void
(id uint)
(addr (:pointer double)))
(defglextfun ("glVariantubvEXT" variant-ubv-ext) :void
(id uint)
(addr (:pointer ubyte)))
(defglextfun ("glVariantusvEXT" variant-usv-ext) :void
(id uint)
(addr (:pointer ushort)))
(defglextfun ("glVariantuivEXT" variant-uiv-ext) :void
(id uint)
(addr (:pointer uint)))
(defglextfun ("glVariantPointerEXT" variant-pointer-ext) :void
(id uint)
(type enum)
(stride uint)
(addr (:pointer :void)))
(defglextfun ("glEnableVariantClientStateEXT" enable-variant-client-state-ext) :void
(id uint))
(defglextfun ("glDisableVariantClientStateEXT" disable-variant-client-state-ext) :void
(id uint))
(defglextfun ("glBindLightParameterEXT" bind-light-parameter-ext) uint
(light enum)
(value enum))
(defglextfun ("glBindMaterialParameterEXT" bind-material-parameter-ext) uint
(face enum)
(value enum))
(defglextfun ("glBindTexGenParameterEXT" bind-tex-gen-parameter-ext) uint
(unit enum)
(coord enum)
(value enum))
(defglextfun ("glBindTextureUnitParameterEXT" bind-texture-unit-parameter-ext) uint
(unit enum)
(value enum))
(defglextfun ("glBindParameterEXT" bind-parameter-ext) uint
(value enum))
(defglextfun ("glIsVariantEnabledEXT" is-variant-enabled-ext) boolean
(id uint)
(cap enum))
(defglextfun ("glGetVariantBooleanvEXT" get-variant-boolean-v-ext) :void
(id uint)
(value enum)
(data (:pointer boolean)))
(defglextfun ("glGetVariantIntegervEXT" get-variant-integer-v-ext) :void
(id uint)
(value enum)
(data (:pointer int)))
(defglextfun ("glGetVariantFloatvEXT" get-variant-float-v-ext) :void
(id uint)
(value enum)
(data (:pointer float)))
(defglextfun ("glGetVariantPointervEXT" get-variant-pointer-v-ext) :void
(id uint)
(value enum)
(data (:pointer (:pointer :void))))
(defglextfun ("glGetInvariantBooleanvEXT" get-invariant-boolean-v-ext) :void
(id uint)
(value enum)
(data (:pointer boolean)))
(defglextfun ("glGetInvariantIntegervEXT" get-invariant-integer-v-ext) :void
(id uint)
(value enum)
(data (:pointer int)))
(defglextfun ("glGetInvariantFloatvEXT" get-invariant-float-v-ext) :void
(id uint)
(value enum)
(data (:pointer float)))
(defglextfun ("glGetLocalConstantBooleanvEXT" get-local-constant-boolean-v-ext) :void
(id uint)
(value enum)
(data (:pointer boolean)))
(defglextfun ("glGetLocalConstantIntegervEXT" get-local-constant-integer-v-ext) :void
(id uint)
(value enum)
(data (:pointer int)))
(defglextfun ("glGetLocalConstantFloatvEXT" get-local-constant-float-v-ext) :void
(id uint)
(value enum)
(data (:pointer float)))
(defglextfun ("glVertexWeightfEXT" vertex-weight-f-ext) :void
(weight float))
(defglextfun ("glVertexWeightfvEXT" vertex-weight-fv-ext) :void
(weight (:pointer float)))
(defglextfun ("glVertexWeightPointerEXT" vertex-weight-pointer-ext) :void
(size int)
(type enum)
(stride sizei)
(pointer (:pointer :void)))
(defglextfun ("glImportSyncEXT" import-sync-ext) sync
(external_sync_type enum)
(external_sync intptr)
(flags bitfield))
(defglextfun ("glFrameTerminatorGREMEDY" frame-terminator-gremedy) :void)
(defglextfun ("glStringMarkerGREMEDY" string-marker-gremedy) :void
(len sizei)
(string (:pointer :void)))
(defglextfun ("glImageTransformParameteriHP" image-transform-parameter-i-hp) :void
(target enum)
(pname enum)
(param int))
(defglextfun ("glImageTransformParameterfHP" image-transform-parameter-f-hp) :void
(target enum)
(pname enum)
(param float))
(defglextfun ("glImageTransformParameterivHP" image-transform-parameter-iv-hp) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glImageTransformParameterfvHP" image-transform-parameter-fv-hp) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetImageTransformParameterivHP" get-image-transform-parameter-iv-hp) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetImageTransformParameterfvHP" get-image-transform-parameter-fv-hp) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glMultiModeDrawArraysIBM" multi-mode-draw-arrays-ibm) :void
(mode (:pointer enum))
(first (:pointer int))
(count (:pointer sizei))
(primcount sizei)
(modestride int))
(defglextfun ("glMultiModeDrawElementsIBM" multi-mode-draw-elements-ibm) :void
(mode (:pointer enum))
(count (:pointer sizei))
(type enum)
(indices (:pointer (:pointer :void)))
(primcount sizei)
(modestride int))
(defglextfun ("glFlushStaticDataIBM" flush-static-data-ibm) :void
(target enum))
(defglextfun ("glColorPointerListIBM" color-pointer-list-ibm) :void
(size int)
(type enum)
(stride int)
(pointer (:pointer (:pointer :void)))
(ptrstride int))
(defglextfun ("glSecondaryColorPointerListIBM" secondary-color-pointer-list-ibm) :void
(size int)
(type enum)
(stride int)
(pointer (:pointer (:pointer :void)))
(ptrstride int))
(defglextfun ("glEdgeFlagPointerListIBM" edge-flag-pointer-list-ibm) :void
(stride int)
(pointer (:pointer (:pointer boolean)))
(ptrstride int))
(defglextfun ("glFogCoordPointerListIBM" fog-coord-pointer-list-ibm) :void
(type enum)
(stride int)
(pointer (:pointer (:pointer :void)))
(ptrstride int))
(defglextfun ("glIndexPointerListIBM" index-pointer-list-ibm) :void
(type enum)
(stride int)
(pointer (:pointer (:pointer :void)))
(ptrstride int))
(defglextfun ("glNormalPointerListIBM" normal-pointer-list-ibm) :void
(type enum)
(stride int)
(pointer (:pointer (:pointer :void)))
(ptrstride int))
(defglextfun ("glTexCoordPointerListIBM" tex-coord-pointer-list-ibm) :void
(size int)
(type enum)
(stride int)
(pointer (:pointer (:pointer :void)))
(ptrstride int))
(defglextfun ("glVertexPointerListIBM" vertex-pointer-list-ibm) :void
(size int)
(type enum)
(stride int)
(pointer (:pointer (:pointer :void)))
(ptrstride int))
(defglextfun ("glBlendFuncSeparateINGR" blend-func-separate-ingr) :void
(sfactorRGB enum)
(dfactorRGB enum)
(sfactorAlpha enum)
(dfactorAlpha enum))
(defglextfun ("glSyncTextureINTEL" sync-texture-intel) :void
(texture uint))
(defglextfun ("glUnmapTexture2DINTEL" unmap-texture-2d-intel) :void
(texture uint)
(level int))
(defglextfun ("glMapTexture2DINTEL" map-texture-2d-intel) (:pointer :void)
(texture uint)
(level int)
(access bitfield)
(stride (:pointer int))
(layout (:pointer enum)))
(defglextfun ("glVertexPointervINTEL" vertex-pointer-v-intel) :void
(size int)
(type enum)
(pointer (:pointer (:pointer :void))))
(defglextfun ("glNormalPointervINTEL" normal-pointer-v-intel) :void
(type enum)
(pointer (:pointer (:pointer :void))))
(defglextfun ("glColorPointervINTEL" color-pointer-v-intel) :void
(size int)
(type enum)
(pointer (:pointer (:pointer :void))))
(defglextfun ("glTexCoordPointervINTEL" tex-coord-pointer-v-intel) :void
(size int)
(type enum)
(pointer (:pointer (:pointer :void))))
(defglextfun ("glResizeBuffersMESA" resize-buffers-mesa) :void)
(defglextfun ("glWindowPos2dMESA" window-pos-2d-mesa) :void
(x double)
(y double))
(defglextfun ("glWindowPos2dvMESA" window-pos-2dv-mesa) :void
(v (:pointer double)))
(defglextfun ("glWindowPos2fMESA" window-pos-2f-mesa) :void
(x float)
(y float))
(defglextfun ("glWindowPos2fvMESA" window-pos-2fv-mesa) :void
(v (:pointer float)))
(defglextfun ("glWindowPos2iMESA" window-pos-2i-mesa) :void
(x int)
(y int))
(defglextfun ("glWindowPos2ivMESA" window-pos-2iv-mesa) :void
(v (:pointer int)))
(defglextfun ("glWindowPos2sMESA" window-pos-2s-mesa) :void
(x short)
(y short))
(defglextfun ("glWindowPos2svMESA" window-pos-2sv-mesa) :void
(v (:pointer short)))
(defglextfun ("glWindowPos3dMESA" window-pos-3d-mesa) :void
(x double)
(y double)
(z double))
(defglextfun ("glWindowPos3dvMESA" window-pos-3dv-mesa) :void
(v (:pointer double)))
(defglextfun ("glWindowPos3fMESA" window-pos-3f-mesa) :void
(x float)
(y float)
(z float))
(defglextfun ("glWindowPos3fvMESA" window-pos-3fv-mesa) :void
(v (:pointer float)))
(defglextfun ("glWindowPos3iMESA" window-pos-3i-mesa) :void
(x int)
(y int)
(z int))
(defglextfun ("glWindowPos3ivMESA" window-pos-3iv-mesa) :void
(v (:pointer int)))
(defglextfun ("glWindowPos3sMESA" window-pos-3s-mesa) :void
(x short)
(y short)
(z short))
(defglextfun ("glWindowPos3svMESA" window-pos-3sv-mesa) :void
(v (:pointer short)))
(defglextfun ("glWindowPos4dMESA" window-pos-4d-mesa) :void
(x double)
(y double)
(z double)
(w double))
(defglextfun ("glWindowPos4dvMESA" window-pos-4dv-mesa) :void
(v (:pointer double)))
(defglextfun ("glWindowPos4fMESA" window-pos-4f-mesa) :void
(x float)
(y float)
(z float)
(w float))
(defglextfun ("glWindowPos4fvMESA" window-pos-4fv-mesa) :void
(v (:pointer float)))
(defglextfun ("glWindowPos4iMESA" window-pos-4i-mesa) :void
(x int)
(y int)
(z int)
(w int))
(defglextfun ("glWindowPos4ivMESA" window-pos-4iv-mesa) :void
(v (:pointer int)))
(defglextfun ("glWindowPos4sMESA" window-pos-4s-mesa) :void
(x short)
(y short)
(z short)
(w short))
(defglextfun ("glWindowPos4svMESA" window-pos-4sv-mesa) :void
(v (:pointer short)))
(defglextfun ("glBeginConditionalRenderNVX" begin-conditional-render-nvx) :void
(id uint))
(defglextfun ("glEndConditionalRenderNVX" end-conditional-render-nvx) :void)
(defglextfun ("glMultiDrawArraysIndirectBindlessNV" multi-draw-arrays-indirect-bindless-nv) :void
(mode enum)
(indirect (:pointer :void))
(drawCount sizei)
(stride sizei)
(vertexBufferCount int))
(defglextfun ("glMultiDrawElementsIndirectBindlessNV" multi-draw-elements-indirect-bindless-nv) :void
(mode enum)
(type enum)
(indirect (:pointer :void))
(drawCount sizei)
(stride sizei)
(vertexBufferCount int))
(defglextfun ("glMultiDrawArraysIndirectBindlessCountNV" multi-draw-arrays-indirect-bindless-count-nv) :void
(mode enum)
(indirect (:pointer :void))
(drawCount sizei)
(maxDrawCount sizei)
(stride sizei)
(vertexBufferCount int))
(defglextfun ("glMultiDrawElementsIndirectBindlessCountNV" multi-draw-elements-indirect-bindless-count-nv) :void
(mode enum)
(type enum)
(indirect (:pointer :void))
(drawCount sizei)
(maxDrawCount sizei)
(stride sizei)
(vertexBufferCount int))
(defglextfun ("glCreateStatesNV" create-states-nv) :void
(n sizei)
(states (:pointer uint)))
(defglextfun ("glDeleteStatesNV" delete-states-nv) :void
(n sizei)
(states (:pointer uint)))
(defglextfun ("glIsStateNV" is-state-nv) boolean
(state uint))
(defglextfun ("glStateCaptureNV" state-capture-nv) :void
(state uint)
(mode enum))
(defglextfun ("glGetCommandHeaderNV" get-command-header-nv) uint
(tokenID enum)
(size uint))
(defglextfun ("glGetStageIndexNV" get-stage-index-nv) ushort
(shadertype enum))
(defglextfun ("glDrawCommandsNV" draw-commands-nv) :void
(primitiveMode enum)
(buffer uint)
(indirects (:pointer intptr))
(sizes (:pointer sizei))
(count uint))
(defglextfun ("glDrawCommandsAddressNV" draw-commands-address-nv) :void
(primitiveMode enum)
(indirects (:pointer uint64))
(sizes (:pointer sizei))
(count uint))
(defglextfun ("glDrawCommandsStatesNV" draw-commands-states-nv) :void
(buffer uint)
(indirects (:pointer intptr))
(sizes (:pointer sizei))
(states (:pointer uint))
(fbos (:pointer uint))
(count uint))
(defglextfun ("glDrawCommandsStatesAddressNV" draw-commands-states-address-nv) :void
(indirects (:pointer uint64))
(sizes (:pointer sizei))
(states (:pointer uint))
(fbos (:pointer uint))
(count uint))
(defglextfun ("glCreateCommandListsNV" create-command-lists-nv) :void
(n sizei)
(lists (:pointer uint)))
(defglextfun ("glDeleteCommandListsNV" delete-command-lists-nv) :void
(n sizei)
(lists (:pointer uint)))
(defglextfun ("glIsCommandListNV" is-command-list-nv) boolean
(list uint))
(defglextfun ("glListDrawCommandsStatesClientNV" list-draw-commands-states-client-nv) :void
(list uint)
(segment uint)
(indirects (:pointer (:pointer :void)))
(sizes (:pointer sizei))
(states (:pointer uint))
(fbos (:pointer uint))
(count uint))
(defglextfun ("glCommandListSegmentsNV" command-list-segments-nv) :void
(list uint)
(segments uint))
(defglextfun ("glCompileCommandListNV" compile-command-list-nv) :void
(list uint))
(defglextfun ("glCallCommandListNV" call-command-list-nv) :void
(list uint))
(defglextfun ("glConservativeRasterParameterfNV" conservative-raster-parameter-f-nv) :void
(pname enum)
(value float))
(defglextfun ("glCopyImageSubDataNV" copy-image-sub-data-nv) :void
(srcName uint)
(srcTarget enum)
(srcLevel int)
(srcX int)
(srcY int)
(srcZ int)
(dstName uint)
(dstTarget enum)
(dstLevel int)
(dstX int)
(dstY int)
(dstZ int)
(width sizei)
(height sizei)
(depth sizei))
(defglextfun ("glDepthRangedNV" depth-range-d-nv) :void
(zNear double)
(zFar double))
(defglextfun ("glClearDepthdNV" clear-depth-d-nv) :void
(depth double))
(defglextfun ("glDepthBoundsdNV" depth-bounds-d-nv) :void
(zmin double)
(zmax double))
(defglextfun ("glDrawTextureNV" draw-texture-nv) :void
(texture uint)
(sampler uint)
(x0 float)
(y0 float)
(x1 float)
(y1 float)
(z float)
(s0 float)
(t0 float)
(s1 float)
(t1 float))
(defglextfun ("glMapControlPointsNV" map-control-points-nv) :void
(target enum)
(index uint)
(type enum)
(ustride sizei)
(vstride sizei)
(uorder int)
(vorder int)
(packed boolean)
(points (:pointer :void)))
(defglextfun ("glMapParameterivNV" map-parameter-iv-nv) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glMapParameterfvNV" map-parameter-fv-nv) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetMapControlPointsNV" get-map-control-points-nv) :void
(target enum)
(index uint)
(type enum)
(ustride sizei)
(vstride sizei)
(packed boolean)
(points (:pointer :void)))
(defglextfun ("glGetMapParameterivNV" get-map-parameter-iv-nv) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetMapParameterfvNV" get-map-parameter-fv-nv) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetMapAttribParameterivNV" get-map-attrib-parameter-iv-nv) :void
(target enum)
(index uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetMapAttribParameterfvNV" get-map-attrib-parameter-fv-nv) :void
(target enum)
(index uint)
(pname enum)
(params (:pointer float)))
(defglextfun ("glEvalMapsNV" eval-maps-nv) :void
(target enum)
(mode enum))
(defglextfun ("glGetMultisamplefvNV" get-multisample-fv-nv) :void
(pname enum)
(index uint)
(val (:pointer float)))
(defglextfun ("glSampleMaskIndexedNV" sample-mask-indexed-nv) :void
(index uint)
(mask bitfield))
(defglextfun ("glTexRenderbufferNV" tex-renderbuffer-nv) :void
(target enum)
(renderbuffer uint))
(defglextfun ("glProgramNamedParameter4fNV" program-named-parameter-4f-nv) :void
(id uint)
(len sizei)
(name (:pointer ubyte))
(x float)
(y float)
(z float)
(w float))
(defglextfun ("glProgramNamedParameter4fvNV" program-named-parameter-4fv-nv) :void
(id uint)
(len sizei)
(name (:pointer ubyte))
(v (:pointer float)))
(defglextfun ("glProgramNamedParameter4dNV" program-named-parameter-4d-nv) :void
(id uint)
(len sizei)
(name (:pointer ubyte))
(x double)
(y double)
(z double)
(w double))
(defglextfun ("glProgramNamedParameter4dvNV" program-named-parameter-4dv-nv) :void
(id uint)
(len sizei)
(name (:pointer ubyte))
(v (:pointer double)))
(defglextfun ("glGetProgramNamedParameterfvNV" get-program-named-parameter-fv-nv) :void
(id uint)
(len sizei)
(name (:pointer ubyte))
(params (:pointer float)))
(defglextfun ("glGetProgramNamedParameterdvNV" get-program-named-parameter-dv-nv) :void
(id uint)
(len sizei)
(name (:pointer ubyte))
(params (:pointer double)))
(defglextfun ("glRenderbufferStorageMultisampleCoverageNV" renderbuffer-storage-multisample-coverage-nv) :void
(target enum)
(coverageSamples sizei)
(colorSamples sizei)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glProgramVertexLimitNV" program-vertex-limit-nv) :void
(target enum)
(limit int))
(defglextfun ("glFramebufferTextureFaceEXT" framebuffer-texture-face-ext) :void
(target enum)
(attachment enum)
(texture uint)
(level int)
(face enum))
(defglextfun ("glProgramLocalParameterI4iNV" program-local-parameter-i4i-nv) :void
(target enum)
(index uint)
(x int)
(y int)
(z int)
(w int))
(defglextfun ("glProgramLocalParameterI4ivNV" program-local-parameter-i4iv-nv) :void
(target enum)
(index uint)
(params (:pointer int)))
(defglextfun ("glProgramLocalParametersI4ivNV" program-local-parameters-i4iv-nv) :void
(target enum)
(index uint)
(count sizei)
(params (:pointer int)))
(defglextfun ("glProgramLocalParameterI4uiNV" program-local-parameter-i4ui-nv) :void
(target enum)
(index uint)
(x uint)
(y uint)
(z uint)
(w uint))
(defglextfun ("glProgramLocalParameterI4uivNV" program-local-parameter-i4uiv-nv) :void
(target enum)
(index uint)
(params (:pointer uint)))
(defglextfun ("glProgramLocalParametersI4uivNV" program-local-parameters-i4uiv-nv) :void
(target enum)
(index uint)
(count sizei)
(params (:pointer uint)))
(defglextfun ("glProgramEnvParameterI4iNV" program-env-parameter-i4i-nv) :void
(target enum)
(index uint)
(x int)
(y int)
(z int)
(w int))
(defglextfun ("glProgramEnvParameterI4ivNV" program-env-parameter-i4iv-nv) :void
(target enum)
(index uint)
(params (:pointer int)))
(defglextfun ("glProgramEnvParametersI4ivNV" program-env-parameters-i4iv-nv) :void
(target enum)
(index uint)
(count sizei)
(params (:pointer int)))
(defglextfun ("glProgramEnvParameterI4uiNV" program-env-parameter-i4ui-nv) :void
(target enum)
(index uint)
(x uint)
(y uint)
(z uint)
(w uint))
(defglextfun ("glProgramEnvParameterI4uivNV" program-env-parameter-i4uiv-nv) :void
(target enum)
(index uint)
(params (:pointer uint)))
(defglextfun ("glProgramEnvParametersI4uivNV" program-env-parameters-i4uiv-nv) :void
(target enum)
(index uint)
(count sizei)
(params (:pointer uint)))
(defglextfun ("glGetProgramLocalParameterIivNV" get-program-local-parameter-iiv-nv) :void
(target enum)
(index uint)
(params (:pointer int)))
(defglextfun ("glGetProgramLocalParameterIuivNV" get-program-local-parameter-iuiv-nv) :void
(target enum)
(index uint)
(params (:pointer uint)))
(defglextfun ("glGetProgramEnvParameterIivNV" get-program-env-parameter-iiv-nv) :void
(target enum)
(index uint)
(params (:pointer int)))
(defglextfun ("glGetProgramEnvParameterIuivNV" get-program-env-parameter-iuiv-nv) :void
(target enum)
(index uint)
(params (:pointer uint)))
(defglextfun ("glProgramSubroutineParametersuivNV" program-subroutine-parameters-uiv-nv) :void
(target enum)
(count sizei)
(params (:pointer uint)))
(defglextfun ("glGetProgramSubroutineParameteruivNV" get-program-subroutine-parameter-uiv-nv) :void
(target enum)
(index uint)
(param (:pointer uint)))
(defglextfun ("glVertex2hNV" vertex-2h-nv) :void
(x half-nv)
(y half-nv))
(defglextfun ("glVertex2hvNV" vertex-2hv-nv) :void
(v (:pointer half-nv)))
(defglextfun ("glVertex3hNV" vertex-3h-nv) :void
(x half-nv)
(y half-nv)
(z half-nv))
(defglextfun ("glVertex3hvNV" vertex-3hv-nv) :void
(v (:pointer half-nv)))
(defglextfun ("glVertex4hNV" vertex-4h-nv) :void
(x half-nv)
(y half-nv)
(z half-nv)
(w half-nv))
(defglextfun ("glVertex4hvNV" vertex-4hv-nv) :void
(v (:pointer half-nv)))
(defglextfun ("glNormal3hNV" normal-3h-nv) :void
(nx half-nv)
(ny half-nv)
(nz half-nv))
(defglextfun ("glNormal3hvNV" normal-3hv-nv) :void
(v (:pointer half-nv)))
(defglextfun ("glColor3hNV" color-3h-nv) :void
(red half-nv)
(green half-nv)
(blue half-nv))
(defglextfun ("glColor3hvNV" color-3hv-nv) :void
(v (:pointer half-nv)))
(defglextfun ("glColor4hNV" color-4h-nv) :void
(red half-nv)
(green half-nv)
(blue half-nv)
(alpha half-nv))
(defglextfun ("glColor4hvNV" color-4hv-nv) :void
(v (:pointer half-nv)))
(defglextfun ("glTexCoord1hNV" tex-coord-1h-nv) :void
(s half-nv))
(defglextfun ("glTexCoord1hvNV" tex-coord-1hv-nv) :void
(v (:pointer half-nv)))
(defglextfun ("glTexCoord2hNV" tex-coord-2h-nv) :void
(s half-nv)
(tee half-nv))
(defglextfun ("glTexCoord2hvNV" tex-coord-2hv-nv) :void
(v (:pointer half-nv)))
(defglextfun ("glTexCoord3hNV" tex-coord-3h-nv) :void
(s half-nv)
(tee half-nv)
(r half-nv))
(defglextfun ("glTexCoord3hvNV" tex-coord-3hv-nv) :void
(v (:pointer half-nv)))
(defglextfun ("glTexCoord4hNV" tex-coord-4h-nv) :void
(s half-nv)
(tee half-nv)
(r half-nv)
(q half-nv))
(defglextfun ("glTexCoord4hvNV" tex-coord-4hv-nv) :void
(v (:pointer half-nv)))
(defglextfun ("glMultiTexCoord1hNV" multi-tex-coord-1h-nv) :void
(target enum)
(s half-nv))
(defglextfun ("glMultiTexCoord1hvNV" multi-tex-coord-1hv-nv) :void
(target enum)
(v (:pointer half-nv)))
(defglextfun ("glMultiTexCoord2hNV" multi-tex-coord-2h-nv) :void
(target enum)
(s half-nv)
(tee half-nv))
(defglextfun ("glMultiTexCoord2hvNV" multi-tex-coord-2hv-nv) :void
(target enum)
(v (:pointer half-nv)))
(defglextfun ("glMultiTexCoord3hNV" multi-tex-coord-3h-nv) :void
(target enum)
(s half-nv)
(tee half-nv)
(r half-nv))
(defglextfun ("glMultiTexCoord3hvNV" multi-tex-coord-3hv-nv) :void
(target enum)
(v (:pointer half-nv)))
(defglextfun ("glMultiTexCoord4hNV" multi-tex-coord-4h-nv) :void
(target enum)
(s half-nv)
(tee half-nv)
(r half-nv)
(q half-nv))
(defglextfun ("glMultiTexCoord4hvNV" multi-tex-coord-4hv-nv) :void
(target enum)
(v (:pointer half-nv)))
(defglextfun ("glFogCoordhNV" fog-coord-h-nv) :void
(fog half-nv))
(defglextfun ("glFogCoordhvNV" fog-coord-hv-nv) :void
(fog (:pointer half-nv)))
(defglextfun ("glSecondaryColor3hNV" secondary-color-3h-nv) :void
(red half-nv)
(green half-nv)
(blue half-nv))
(defglextfun ("glSecondaryColor3hvNV" secondary-color-3hv-nv) :void
(v (:pointer half-nv)))
(defglextfun ("glVertexWeighthNV" vertex-weight-h-nv) :void
(weight half-nv))
(defglextfun ("glVertexWeighthvNV" vertex-weight-hv-nv) :void
(weight (:pointer half-nv)))
(defglextfun ("glVertexAttrib1hNV" vertex-attrib-1h-nv) :void
(index uint)
(x half-nv))
(defglextfun ("glVertexAttrib1hvNV" vertex-attrib-1hv-nv) :void
(index uint)
(v (:pointer half-nv)))
(defglextfun ("glVertexAttrib2hNV" vertex-attrib-2h-nv) :void
(index uint)
(x half-nv)
(y half-nv))
(defglextfun ("glVertexAttrib2hvNV" vertex-attrib-2hv-nv) :void
(index uint)
(v (:pointer half-nv)))
(defglextfun ("glVertexAttrib3hNV" vertex-attrib-3h-nv) :void
(index uint)
(x half-nv)
(y half-nv)
(z half-nv))
(defglextfun ("glVertexAttrib3hvNV" vertex-attrib-3hv-nv) :void
(index uint)
(v (:pointer half-nv)))
(defglextfun ("glVertexAttrib4hNV" vertex-attrib-4h-nv) :void
(index uint)
(x half-nv)
(y half-nv)
(z half-nv)
(w half-nv))
(defglextfun ("glVertexAttrib4hvNV" vertex-attrib-4hv-nv) :void
(index uint)
(v (:pointer half-nv)))
(defglextfun ("glVertexAttribs1hvNV" vertex-attribs-1hv-nv) :void
(index uint)
(n sizei)
(v (:pointer half-nv)))
(defglextfun ("glVertexAttribs2hvNV" vertex-attribs-2hv-nv) :void
(index uint)
(n sizei)
(v (:pointer half-nv)))
(defglextfun ("glVertexAttribs3hvNV" vertex-attribs-3hv-nv) :void
(index uint)
(n sizei)
(v (:pointer half-nv)))
(defglextfun ("glVertexAttribs4hvNV" vertex-attribs-4hv-nv) :void
(index uint)
(n sizei)
(v (:pointer half-nv)))
(defglextfun ("glGenOcclusionQueriesNV" gen-occlusion-queries-nv) :void
(n sizei)
(ids (:pointer uint)))
(defglextfun ("glDeleteOcclusionQueriesNV" delete-occlusion-queries-nv) :void
(n sizei)
(ids (:pointer uint)))
(defglextfun ("glIsOcclusionQueryNV" is-occlusion-query-nv) boolean
(id uint))
(defglextfun ("glBeginOcclusionQueryNV" begin-occlusion-query-nv) :void
(id uint))
(defglextfun ("glEndOcclusionQueryNV" end-occlusion-query-nv) :void)
(defglextfun ("glGetOcclusionQueryivNV" get-occlusion-query-iv-nv) :void
(id uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetOcclusionQueryuivNV" get-occlusion-query-uiv-nv) :void
(id uint)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glProgramBufferParametersfvNV" program-buffer-parameters-fv-nv) :void
(target enum)
(bindingIndex uint)
(wordIndex uint)
(count sizei)
(params (:pointer float)))
(defglextfun ("glProgramBufferParametersIivNV" program-buffer-parameters-iiv-nv) :void
(target enum)
(bindingIndex uint)
(wordIndex uint)
(count sizei)
(params (:pointer int)))
(defglextfun ("glProgramBufferParametersIuivNV" program-buffer-parameters-iuiv-nv) :void
(target enum)
(bindingIndex uint)
(wordIndex uint)
(count sizei)
(params (:pointer uint)))
(defglextfun ("glPixelDataRangeNV" pixel-data-range-nv) :void
(target enum)
(length sizei)
(pointer (:pointer :void)))
(defglextfun ("glFlushPixelDataRangeNV" flush-pixel-data-range-nv) :void
(target enum))
(defglextfun ("glPointParameteriNV" point-parameter-i-nv) :void
(pname enum)
(param int))
(defglextfun ("glPointParameterivNV" point-parameter-iv-nv) :void
(pname enum)
(params (:pointer int)))
(defglextfun ("glPresentFrameKeyedNV" present-frame-keyed-nv) :void
(video_slot uint)
(minPresentTime uint64-ext)
(beginPresentTimeId uint)
(presentDurationId uint)
(type enum)
(target0 enum)
(fill0 uint)
(key0 uint)
(target1 enum)
(fill1 uint)
(key1 uint))
(defglextfun ("glPresentFrameDualFillNV" present-frame-dual-fill-nv) :void
(video_slot uint)
(minPresentTime uint64-ext)
(beginPresentTimeId uint)
(presentDurationId uint)
(type enum)
(target0 enum)
(fill0 uint)
(target1 enum)
(fill1 uint)
(target2 enum)
(fill2 uint)
(target3 enum)
(fill3 uint))
(defglextfun ("glGetVideoivNV" get-video-iv-nv) :void
(video_slot uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetVideouivNV" get-video-uiv-nv) :void
(video_slot uint)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glGetVideoi64vNV" get-video-i64v-nv) :void
(video_slot uint)
(pname enum)
(params (:pointer int64-ext)))
(defglextfun ("glGetVideoui64vNV" get-video-ui64v-nv) :void
(video_slot uint)
(pname enum)
(params (:pointer uint64-ext)))
(defglextfun ("glPrimitiveRestartNV" primitive-restart-nv) :void)
(defglextfun ("glPrimitiveRestartIndexNV" primitive-restart-index-nv) :void
(index uint))
(defglextfun ("glCombinerParameterfvNV" combiner-parameter-fv-nv) :void
(pname enum)
(params (:pointer float)))
(defglextfun ("glCombinerParameterfNV" combiner-parameter-f-nv) :void
(pname enum)
(param float))
(defglextfun ("glCombinerParameterivNV" combiner-parameter-iv-nv) :void
(pname enum)
(params (:pointer int)))
(defglextfun ("glCombinerParameteriNV" combiner-parameter-i-nv) :void
(pname enum)
(param int))
(defglextfun ("glCombinerInputNV" combiner-input-nv) :void
(stage enum)
(portion enum)
(variable enum)
(input enum)
(mapping enum)
(componentUsage enum))
(defglextfun ("glCombinerOutputNV" combiner-output-nv) :void
(stage enum)
(portion enum)
(abOutput enum)
(cdOutput enum)
(sumOutput enum)
(scale enum)
(bias enum)
(abDotProduct boolean)
(cdDotProduct boolean)
(muxSum boolean))
(defglextfun ("glFinalCombinerInputNV" final-combiner-input-nv) :void
(variable enum)
(input enum)
(mapping enum)
(componentUsage enum))
(defglextfun ("glGetCombinerInputParameterfvNV" get-combiner-input-parameter-fv-nv) :void
(stage enum)
(portion enum)
(variable enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetCombinerInputParameterivNV" get-combiner-input-parameter-iv-nv) :void
(stage enum)
(portion enum)
(variable enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetCombinerOutputParameterfvNV" get-combiner-output-parameter-fv-nv) :void
(stage enum)
(portion enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetCombinerOutputParameterivNV" get-combiner-output-parameter-iv-nv) :void
(stage enum)
(portion enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetFinalCombinerInputParameterfvNV" get-final-combiner-input-parameter-fv-nv) :void
(variable enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetFinalCombinerInputParameterivNV" get-final-combiner-input-parameter-iv-nv) :void
(variable enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glCombinerStageParameterfvNV" combiner-stage-parameter-fv-nv) :void
(stage enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetCombinerStageParameterfvNV" get-combiner-stage-parameter-fv-nv) :void
(stage enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glMakeBufferResidentNV" make-buffer-resident-nv) :void
(target enum)
(access enum))
(defglextfun ("glMakeBufferNonResidentNV" make-buffer-non-resident-nv) :void
(target enum))
(defglextfun ("glIsBufferResidentNV" is-buffer-resident-nv) boolean
(target enum))
(defglextfun ("glMakeNamedBufferResidentNV" make-named-buffer-resident-nv) :void
(buffer uint)
(access enum))
(defglextfun ("glMakeNamedBufferNonResidentNV" make-named-buffer-non-resident-nv) :void
(buffer uint))
(defglextfun ("glIsNamedBufferResidentNV" is-named-buffer-resident-nv) boolean
(buffer uint))
(defglextfun ("glGetBufferParameterui64vNV" get-buffer-parameter-ui64v-nv) :void
(target enum)
(pname enum)
(params (:pointer uint64-ext)))
(defglextfun ("glGetNamedBufferParameterui64vNV" get-named-buffer-parameter-ui64v-nv) :void
(buffer uint)
(pname enum)
(params (:pointer uint64-ext)))
(defglextfun ("glGetIntegerui64vNV" get-integer-ui64v-nv) :void
(value enum)
(result (:pointer uint64-ext)))
(defglextfun ("glUniformui64NV" uniform-ui64-nv) :void
(location int)
(value uint64-ext))
(defglextfun ("glUniformui64vNV" uniform-ui64v-nv) :void
(location int)
(count sizei)
(value (:pointer uint64-ext)))
(defglextfun ("glProgramUniformui64NV" program-uniform-ui64-nv) :void
(program uint)
(location int)
(value uint64-ext))
(defglextfun ("glProgramUniformui64vNV" program-uniform-ui64v-nv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer uint64-ext)))
(defglextfun ("glTextureBarrierNV" texture-barrier-nv) :void)
(defglextfun ("glTexImage2DMultisampleCoverageNV" tex-image-2d-multisample-coverage-nv) :void
(target enum)
(coverageSamples sizei)
(colorSamples sizei)
(internalFormat int)
(width sizei)
(height sizei)
(fixedSampleLocations boolean))
(defglextfun ("glTexImage3DMultisampleCoverageNV" tex-image-3d-multisample-coverage-nv) :void
(target enum)
(coverageSamples sizei)
(colorSamples sizei)
(internalFormat int)
(width sizei)
(height sizei)
(depth sizei)
(fixedSampleLocations boolean))
(defglextfun ("glTextureImage2DMultisampleNV" texture-image-2d-multisample-nv) :void
(texture uint)
(target enum)
(samples sizei)
(internalFormat int)
(width sizei)
(height sizei)
(fixedSampleLocations boolean))
(defglextfun ("glTextureImage3DMultisampleNV" texture-image-3d-multisample-nv) :void
(texture uint)
(target enum)
(samples sizei)
(internalFormat int)
(width sizei)
(height sizei)
(depth sizei)
(fixedSampleLocations boolean))
(defglextfun ("glTextureImage2DMultisampleCoverageNV" texture-image-2d-multisample-coverage-nv) :void
(texture uint)
(target enum)
(coverageSamples sizei)
(colorSamples sizei)
(internalFormat int)
(width sizei)
(height sizei)
(fixedSampleLocations boolean))
(defglextfun ("glTextureImage3DMultisampleCoverageNV" texture-image-3d-multisample-coverage-nv) :void
(texture uint)
(target enum)
(coverageSamples sizei)
(colorSamples sizei)
(internalFormat int)
(width sizei)
(height sizei)
(depth sizei)
(fixedSampleLocations boolean))
(defglextfun ("glBeginTransformFeedbackNV" begin-transform-feedback-nv) :void
(primitiveMode enum))
(defglextfun ("glEndTransformFeedbackNV" end-transform-feedback-nv) :void)
(defglextfun ("glTransformFeedbackAttribsNV" transform-feedback-attribs-nv) :void
(count sizei)
(attribs (:pointer int))
(bufferMode enum))
(defglextfun ("glBindBufferRangeNV" bind-buffer-range-nv) :void
(target enum)
(index uint)
(buffer uint)
(offset intptr)
(size sizeiptr))
(defglextfun ("glBindBufferOffsetNV" bind-buffer-offset-nv) :void
(target enum)
(index uint)
(buffer uint)
(offset intptr))
(defglextfun ("glBindBufferBaseNV" bind-buffer-base-nv) :void
(target enum)
(index uint)
(buffer uint))
(defglextfun ("glTransformFeedbackVaryingsNV" transform-feedback-varyings-nv) :void
(program uint)
(count sizei)
(locations (:pointer int))
(bufferMode enum))
(defglextfun ("glActiveVaryingNV" active-varying-nv) :void
(program uint)
(name (:pointer char)))
(defglextfun ("glGetVaryingLocationNV" get-varying-location-nv) int
(program uint)
(name (:pointer char)))
(defglextfun ("glGetActiveVaryingNV" get-active-varying-nv) :void
(program uint)
(index uint)
(bufSize sizei)
(length (:pointer sizei))
(size (:pointer sizei))
(type (:pointer enum))
(name (:pointer char)))
(defglextfun ("glGetTransformFeedbackVaryingNV" get-transform-feedback-varying-nv) :void
(program uint)
(index uint)
(location (:pointer int)))
(defglextfun ("glTransformFeedbackStreamAttribsNV" transform-feedback-stream-attribs-nv) :void
(count sizei)
(attribs (:pointer int))
(nbuffers sizei)
(bufstreams (:pointer int))
(bufferMode enum))
(defglextfun ("glBindTransformFeedbackNV" bind-transform-feedback-nv) :void
(target enum)
(id uint))
(defglextfun ("glDeleteTransformFeedbacksNV" delete-transform-feedbacks-nv) :void
(n sizei)
(ids (:pointer uint)))
(defglextfun ("glGenTransformFeedbacksNV" gen-transform-feedbacks-nv) :void
(n sizei)
(ids (:pointer uint)))
(defglextfun ("glIsTransformFeedbackNV" is-transform-feedback-nv) boolean
(id uint))
(defglextfun ("glPauseTransformFeedbackNV" pause-transform-feedback-nv) :void)
(defglextfun ("glResumeTransformFeedbackNV" resume-transform-feedback-nv) :void)
(defglextfun ("glDrawTransformFeedbackNV" draw-transform-feedback-nv) :void
(mode enum)
(id uint))
(defglextfun ("glVDPAUInitNV" vdpau-init-nv) :void
(vdpDevice (:pointer :void))
(getProcAddress (:pointer :void)))
(defglextfun ("glVDPAUFiniNV" vdpau-fini-nv) :void)
(defglextfun ("glVDPAURegisterVideoSurfaceNV" vdpau-register-video-surface-nv) vdpau-surface-nv
(vdpSurface (:pointer :void))
(target enum)
(numTextureNames sizei)
(textureNames (:pointer uint)))
(defglextfun ("glVDPAURegisterOutputSurfaceNV" vdpau-register-output-surface-nv) vdpau-surface-nv
(vdpSurface (:pointer :void))
(target enum)
(numTextureNames sizei)
(textureNames (:pointer uint)))
(defglextfun ("glVDPAUIsSurfaceNV" vdpau-is-surface-nv) boolean
(surface vdpau-surface-nv))
(defglextfun ("glVDPAUUnregisterSurfaceNV" vdpau-unregister-surface-nv) :void
(surface vdpau-surface-nv))
(defglextfun ("glVDPAUGetSurfaceivNV" vdpau-get-surface-iv-nv) :void
(surface vdpau-surface-nv)
(pname enum)
(bufSize sizei)
(length (:pointer sizei))
(values (:pointer int)))
(defglextfun ("glVDPAUSurfaceAccessNV" vdpau-surface-access-nv) :void
(surface vdpau-surface-nv)
(access enum))
(defglextfun ("glVDPAUMapSurfacesNV" vdpau-map-surfaces-nv) :void
(numSurfaces sizei)
(surfaces (:pointer vdpau-surface-nv)))
(defglextfun ("glVDPAUUnmapSurfacesNV" vdpau-unmap-surfaces-nv) :void
(numSurface sizei)
(surfaces (:pointer vdpau-surface-nv)))
(defglextfun ("glFlushVertexArrayRangeNV" flush-vertex-array-range-nv) :void)
(defglextfun ("glVertexArrayRangeNV" vertex-array-range-nv) :void
(length sizei)
(pointer (:pointer :void)))
(defglextfun ("glVertexAttribL1i64NV" vertex-attrib-l1i64-nv) :void
(index uint)
(x int64-ext))
(defglextfun ("glVertexAttribL2i64NV" vertex-attrib-l2i64-nv) :void
(index uint)
(x int64-ext)
(y int64-ext))
(defglextfun ("glVertexAttribL3i64NV" vertex-attrib-l3i64-nv) :void
(index uint)
(x int64-ext)
(y int64-ext)
(z int64-ext))
(defglextfun ("glVertexAttribL4i64NV" vertex-attrib-l4i64-nv) :void
(index uint)
(x int64-ext)
(y int64-ext)
(z int64-ext)
(w int64-ext))
(defglextfun ("glVertexAttribL1i64vNV" vertex-attrib-l1i64v-nv) :void
(index uint)
(v (:pointer int64-ext)))
(defglextfun ("glVertexAttribL2i64vNV" vertex-attrib-l2i64v-nv) :void
(index uint)
(v (:pointer int64-ext)))
(defglextfun ("glVertexAttribL3i64vNV" vertex-attrib-l3i64v-nv) :void
(index uint)
(v (:pointer int64-ext)))
(defglextfun ("glVertexAttribL4i64vNV" vertex-attrib-l4i64v-nv) :void
(index uint)
(v (:pointer int64-ext)))
(defglextfun ("glVertexAttribL1ui64NV" vertex-attrib-l1ui64-nv) :void
(index uint)
(x uint64-ext))
(defglextfun ("glVertexAttribL2ui64NV" vertex-attrib-l2ui64-nv) :void
(index uint)
(x uint64-ext)
(y uint64-ext))
(defglextfun ("glVertexAttribL3ui64NV" vertex-attrib-l3ui64-nv) :void
(index uint)
(x uint64-ext)
(y uint64-ext)
(z uint64-ext))
(defglextfun ("glVertexAttribL4ui64NV" vertex-attrib-l4ui64-nv) :void
(index uint)
(x uint64-ext)
(y uint64-ext)
(z uint64-ext)
(w uint64-ext))
(defglextfun ("glVertexAttribL1ui64vNV" vertex-attrib-l1ui64v-nv) :void
(index uint)
(v (:pointer uint64-ext)))
(defglextfun ("glVertexAttribL2ui64vNV" vertex-attrib-l2ui64v-nv) :void
(index uint)
(v (:pointer uint64-ext)))
(defglextfun ("glVertexAttribL3ui64vNV" vertex-attrib-l3ui64v-nv) :void
(index uint)
(v (:pointer uint64-ext)))
(defglextfun ("glVertexAttribL4ui64vNV" vertex-attrib-l4ui64v-nv) :void
(index uint)
(v (:pointer uint64-ext)))
(defglextfun ("glGetVertexAttribLi64vNV" get-vertex-attrib-li64v-nv) :void
(index uint)
(pname enum)
(params (:pointer int64-ext)))
(defglextfun ("glGetVertexAttribLui64vNV" get-vertex-attrib-lui64v-nv) :void
(index uint)
(pname enum)
(params (:pointer uint64-ext)))
(defglextfun ("glVertexAttribLFormatNV" vertex-attrib-l-format-nv) :void
(index uint)
(size int)
(type enum)
(stride sizei))
(defglextfun ("glBufferAddressRangeNV" buffer-address-range-nv) :void
(pname enum)
(index uint)
(address uint64-ext)
(length sizeiptr))
(defglextfun ("glVertexFormatNV" vertex-format-nv) :void
(size int)
(type enum)
(stride sizei))
(defglextfun ("glNormalFormatNV" normal-format-nv) :void
(type enum)
(stride sizei))
(defglextfun ("glColorFormatNV" color-format-nv) :void
(size int)
(type enum)
(stride sizei))
(defglextfun ("glIndexFormatNV" index-format-nv) :void
(type enum)
(stride sizei))
(defglextfun ("glTexCoordFormatNV" tex-coord-format-nv) :void
(size int)
(type enum)
(stride sizei))
(defglextfun ("glEdgeFlagFormatNV" edge-flag-format-nv) :void
(stride sizei))
(defglextfun ("glSecondaryColorFormatNV" secondary-color-format-nv) :void
(size int)
(type enum)
(stride sizei))
(defglextfun ("glFogCoordFormatNV" fog-coord-format-nv) :void
(type enum)
(stride sizei))
(defglextfun ("glVertexAttribFormatNV" vertex-attrib-format-nv) :void
(index uint)
(size int)
(type enum)
(normalized boolean)
(stride sizei))
(defglextfun ("glVertexAttribIFormatNV" vertex-attrib-i-format-nv) :void
(index uint)
(size int)
(type enum)
(stride sizei))
(defglextfun ("glGetIntegerui64i_vNV" get-integer-ui64i-v-nv) :void
(value enum)
(index uint)
(result (:pointer uint64-ext)))
(defglextfun ("glAreProgramsResidentNV" are-programs-resident-nv) boolean
(n sizei)
(programs (:pointer uint))
(residences (:pointer boolean)))
(defglextfun ("glBindProgramNV" bind-program-nv) :void
(target enum)
(id uint))
(defglextfun ("glDeleteProgramsNV" delete-programs-nv) :void
(n sizei)
(programs (:pointer uint)))
(defglextfun ("glExecuteProgramNV" execute-program-nv) :void
(target enum)
(id uint)
(params (:pointer float)))
(defglextfun ("glGenProgramsNV" gen-programs-nv) :void
(n sizei)
(programs (:pointer uint)))
(defglextfun ("glGetProgramParameterdvNV" get-program-parameter-dv-nv) :void
(target enum)
(index uint)
(pname enum)
(params (:pointer double)))
(defglextfun ("glGetProgramParameterfvNV" get-program-parameter-fv-nv) :void
(target enum)
(index uint)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetProgramivNV" get-program-iv-nv) :void
(id uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetProgramStringNV" get-program-string-nv) :void
(id uint)
(pname enum)
(program (:pointer ubyte)))
(defglextfun ("glGetTrackMatrixivNV" get-track-matrix-iv-nv) :void
(target enum)
(address uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetVertexAttribdvNV" get-vertex-attrib-dv-nv) :void
(index uint)
(pname enum)
(params (:pointer double)))
(defglextfun ("glGetVertexAttribfvNV" get-vertex-attrib-fv-nv) :void
(index uint)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetVertexAttribivNV" get-vertex-attrib-iv-nv) :void
(index uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetVertexAttribPointervNV" get-vertex-attrib-pointer-v-nv) :void
(index uint)
(pname enum)
(pointer (:pointer (:pointer :void))))
(defglextfun ("glIsProgramNV" is-program-nv) boolean
(id uint))
(defglextfun ("glLoadProgramNV" load-program-nv) :void
(target enum)
(id uint)
(len sizei)
(program (:pointer ubyte)))
(defglextfun ("glProgramParameter4dNV" program-parameter-4d-nv) :void
(target enum)
(index uint)
(x double)
(y double)
(z double)
(w double))
(defglextfun ("glProgramParameter4dvNV" program-parameter-4dv-nv) :void
(target enum)
(index uint)
(v (:pointer double)))
(defglextfun ("glProgramParameter4fNV" program-parameter-4f-nv) :void
(target enum)
(index uint)
(x float)
(y float)
(z float)
(w float))
(defglextfun ("glProgramParameter4fvNV" program-parameter-4fv-nv) :void
(target enum)
(index uint)
(v (:pointer float)))
(defglextfun ("glProgramParameters4dvNV" program-parameters-4dv-nv) :void
(target enum)
(index uint)
(count sizei)
(v (:pointer double)))
(defglextfun ("glProgramParameters4fvNV" program-parameters-4fv-nv) :void
(target enum)
(index uint)
(count sizei)
(v (:pointer float)))
(defglextfun ("glRequestResidentProgramsNV" request-resident-programs-nv) :void
(n sizei)
(programs (:pointer uint)))
(defglextfun ("glTrackMatrixNV" track-matrix-nv) :void
(target enum)
(address uint)
(matrix enum)
(transform enum))
(defglextfun ("glVertexAttribPointerNV" vertex-attrib-pointer-nv) :void
(index uint)
(fsize int)
(type enum)
(stride sizei)
(pointer (:pointer :void)))
(defglextfun ("glVertexAttrib1dNV" vertex-attrib-1d-nv) :void
(index uint)
(x double))
(defglextfun ("glVertexAttrib1dvNV" vertex-attrib-1dv-nv) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttrib1fNV" vertex-attrib-1f-nv) :void
(index uint)
(x float))
(defglextfun ("glVertexAttrib1fvNV" vertex-attrib-1fv-nv) :void
(index uint)
(v (:pointer float)))
(defglextfun ("glVertexAttrib1sNV" vertex-attrib-1s-nv) :void
(index uint)
(x short))
(defglextfun ("glVertexAttrib1svNV" vertex-attrib-1sv-nv) :void
(index uint)
(v (:pointer short)))
(defglextfun ("glVertexAttrib2dNV" vertex-attrib-2d-nv) :void
(index uint)
(x double)
(y double))
(defglextfun ("glVertexAttrib2dvNV" vertex-attrib-2dv-nv) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttrib2fNV" vertex-attrib-2f-nv) :void
(index uint)
(x float)
(y float))
(defglextfun ("glVertexAttrib2fvNV" vertex-attrib-2fv-nv) :void
(index uint)
(v (:pointer float)))
(defglextfun ("glVertexAttrib2sNV" vertex-attrib-2s-nv) :void
(index uint)
(x short)
(y short))
(defglextfun ("glVertexAttrib2svNV" vertex-attrib-2sv-nv) :void
(index uint)
(v (:pointer short)))
(defglextfun ("glVertexAttrib3dNV" vertex-attrib-3d-nv) :void
(index uint)
(x double)
(y double)
(z double))
(defglextfun ("glVertexAttrib3dvNV" vertex-attrib-3dv-nv) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttrib3fNV" vertex-attrib-3f-nv) :void
(index uint)
(x float)
(y float)
(z float))
(defglextfun ("glVertexAttrib3fvNV" vertex-attrib-3fv-nv) :void
(index uint)
(v (:pointer float)))
(defglextfun ("glVertexAttrib3sNV" vertex-attrib-3s-nv) :void
(index uint)
(x short)
(y short)
(z short))
(defglextfun ("glVertexAttrib3svNV" vertex-attrib-3sv-nv) :void
(index uint)
(v (:pointer short)))
(defglextfun ("glVertexAttrib4dNV" vertex-attrib-4d-nv) :void
(index uint)
(x double)
(y double)
(z double)
(w double))
(defglextfun ("glVertexAttrib4dvNV" vertex-attrib-4dv-nv) :void
(index uint)
(v (:pointer double)))
(defglextfun ("glVertexAttrib4fNV" vertex-attrib-4f-nv) :void
(index uint)
(x float)
(y float)
(z float)
(w float))
(defglextfun ("glVertexAttrib4fvNV" vertex-attrib-4fv-nv) :void
(index uint)
(v (:pointer float)))
(defglextfun ("glVertexAttrib4sNV" vertex-attrib-4s-nv) :void
(index uint)
(x short)
(y short)
(z short)
(w short))
(defglextfun ("glVertexAttrib4svNV" vertex-attrib-4sv-nv) :void
(index uint)
(v (:pointer short)))
(defglextfun ("glVertexAttrib4ubNV" vertex-attrib-4ub-nv) :void
(index uint)
(x ubyte)
(y ubyte)
(z ubyte)
(w ubyte))
(defglextfun ("glVertexAttrib4ubvNV" vertex-attrib-4ubv-nv) :void
(index uint)
(v (:pointer ubyte)))
(defglextfun ("glVertexAttribs1dvNV" vertex-attribs-1dv-nv) :void
(index uint)
(count sizei)
(v (:pointer double)))
(defglextfun ("glVertexAttribs1fvNV" vertex-attribs-1fv-nv) :void
(index uint)
(count sizei)
(v (:pointer float)))
(defglextfun ("glVertexAttribs1svNV" vertex-attribs-1sv-nv) :void
(index uint)
(count sizei)
(v (:pointer short)))
(defglextfun ("glVertexAttribs2dvNV" vertex-attribs-2dv-nv) :void
(index uint)
(count sizei)
(v (:pointer double)))
(defglextfun ("glVertexAttribs2fvNV" vertex-attribs-2fv-nv) :void
(index uint)
(count sizei)
(v (:pointer float)))
(defglextfun ("glVertexAttribs2svNV" vertex-attribs-2sv-nv) :void
(index uint)
(count sizei)
(v (:pointer short)))
(defglextfun ("glVertexAttribs3dvNV" vertex-attribs-3dv-nv) :void
(index uint)
(count sizei)
(v (:pointer double)))
(defglextfun ("glVertexAttribs3fvNV" vertex-attribs-3fv-nv) :void
(index uint)
(count sizei)
(v (:pointer float)))
(defglextfun ("glVertexAttribs3svNV" vertex-attribs-3sv-nv) :void
(index uint)
(count sizei)
(v (:pointer short)))
(defglextfun ("glVertexAttribs4dvNV" vertex-attribs-4dv-nv) :void
(index uint)
(count sizei)
(v (:pointer double)))
(defglextfun ("glVertexAttribs4fvNV" vertex-attribs-4fv-nv) :void
(index uint)
(count sizei)
(v (:pointer float)))
(defglextfun ("glVertexAttribs4svNV" vertex-attribs-4sv-nv) :void
(index uint)
(count sizei)
(v (:pointer short)))
(defglextfun ("glVertexAttribs4ubvNV" vertex-attribs-4ubv-nv) :void
(index uint)
(count sizei)
(v (:pointer ubyte)))
(defglextfun ("glVertexAttribI1iEXT" vertex-attrib-i1i-ext) :void
(index uint)
(x int))
(defglextfun ("glVertexAttribI2iEXT" vertex-attrib-i2i-ext) :void
(index uint)
(x int)
(y int))
(defglextfun ("glVertexAttribI3iEXT" vertex-attrib-i3i-ext) :void
(index uint)
(x int)
(y int)
(z int))
(defglextfun ("glVertexAttribI4iEXT" vertex-attrib-i4i-ext) :void
(index uint)
(x int)
(y int)
(z int)
(w int))
(defglextfun ("glVertexAttribI1uiEXT" vertex-attrib-i1ui-ext) :void
(index uint)
(x uint))
(defglextfun ("glVertexAttribI2uiEXT" vertex-attrib-i2ui-ext) :void
(index uint)
(x uint)
(y uint))
(defglextfun ("glVertexAttribI3uiEXT" vertex-attrib-i3ui-ext) :void
(index uint)
(x uint)
(y uint)
(z uint))
(defglextfun ("glVertexAttribI4uiEXT" vertex-attrib-i4ui-ext) :void
(index uint)
(x uint)
(y uint)
(z uint)
(w uint))
(defglextfun ("glVertexAttribI1ivEXT" vertex-attrib-i1iv-ext) :void
(index uint)
(v (:pointer int)))
(defglextfun ("glVertexAttribI2ivEXT" vertex-attrib-i2iv-ext) :void
(index uint)
(v (:pointer int)))
(defglextfun ("glVertexAttribI3ivEXT" vertex-attrib-i3iv-ext) :void
(index uint)
(v (:pointer int)))
(defglextfun ("glVertexAttribI4ivEXT" vertex-attrib-i4iv-ext) :void
(index uint)
(v (:pointer int)))
(defglextfun ("glVertexAttribI1uivEXT" vertex-attrib-i1uiv-ext) :void
(index uint)
(v (:pointer uint)))
(defglextfun ("glVertexAttribI2uivEXT" vertex-attrib-i2uiv-ext) :void
(index uint)
(v (:pointer uint)))
(defglextfun ("glVertexAttribI3uivEXT" vertex-attrib-i3uiv-ext) :void
(index uint)
(v (:pointer uint)))
(defglextfun ("glVertexAttribI4uivEXT" vertex-attrib-i4uiv-ext) :void
(index uint)
(v (:pointer uint)))
(defglextfun ("glVertexAttribI4bvEXT" vertex-attrib-i4bv-ext) :void
(index uint)
(v (:pointer byte)))
(defglextfun ("glVertexAttribI4svEXT" vertex-attrib-i4sv-ext) :void
(index uint)
(v (:pointer short)))
(defglextfun ("glVertexAttribI4ubvEXT" vertex-attrib-i4ubv-ext) :void
(index uint)
(v (:pointer ubyte)))
(defglextfun ("glVertexAttribI4usvEXT" vertex-attrib-i4usv-ext) :void
(index uint)
(v (:pointer ushort)))
(defglextfun ("glVertexAttribIPointerEXT" vertex-attrib-ipointer-ext) :void
(index uint)
(size int)
(type enum)
(stride sizei)
(pointer (:pointer :void)))
(defglextfun ("glGetVertexAttribIivEXT" get-vertex-attrib-iiv-ext) :void
(index uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetVertexAttribIuivEXT" get-vertex-attrib-iuiv-ext) :void
(index uint)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glBeginVideoCaptureNV" begin-video-capture-nv) :void
(video_capture_slot uint))
(defglextfun ("glBindVideoCaptureStreamBufferNV" bind-video-capture-stream-buffer-nv) :void
(video_capture_slot uint)
(stream uint)
(frame_region enum)
(offset intptr-arb))
(defglextfun ("glBindVideoCaptureStreamTextureNV" bind-video-capture-stream-texture-nv) :void
(video_capture_slot uint)
(stream uint)
(frame_region enum)
(target enum)
(texture uint))
(defglextfun ("glEndVideoCaptureNV" end-video-capture-nv) :void
(video_capture_slot uint))
(defglextfun ("glGetVideoCaptureivNV" get-video-capture-iv-nv) :void
(video_capture_slot uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetVideoCaptureStreamivNV" get-video-capture-stream-iv-nv) :void
(video_capture_slot uint)
(stream uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetVideoCaptureStreamfvNV" get-video-capture-stream-fv-nv) :void
(video_capture_slot uint)
(stream uint)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetVideoCaptureStreamdvNV" get-video-capture-stream-dv-nv) :void
(video_capture_slot uint)
(stream uint)
(pname enum)
(params (:pointer double)))
(defglextfun ("glVideoCaptureNV" video-capture-nv) enum
(video_capture_slot uint)
(sequence_num (:pointer uint))
(capture_time (:pointer uint64-ext)))
(defglextfun ("glVideoCaptureStreamParameterivNV" video-capture-stream-parameter-iv-nv) :void
(video_capture_slot uint)
(stream uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glVideoCaptureStreamParameterfvNV" video-capture-stream-parameter-fv-nv) :void
(video_capture_slot uint)
(stream uint)
(pname enum)
(params (:pointer float)))
(defglextfun ("glVideoCaptureStreamParameterdvNV" video-capture-stream-parameter-dv-nv) :void
(video_capture_slot uint)
(stream uint)
(pname enum)
(params (:pointer double)))
(defglextfun ("glHintPGI" hint-pgi) :void
(target enum)
(mode int))
(defglextfun ("glDetailTexFuncSGIS" detail-tex-func-sgis) :void
(target enum)
(n sizei)
(points (:pointer float)))
(defglextfun ("glGetDetailTexFuncSGIS" get-detail-tex-func-sgis) :void
(target enum)
(points (:pointer float)))
(defglextfun ("glFogFuncSGIS" fog-func-sgis) :void
(n sizei)
(points (:pointer float)))
(defglextfun ("glGetFogFuncSGIS" get-fog-func-sgis) :void
(points (:pointer float)))
(defglextfun ("glSampleMaskSGIS" sample-mask-sgis) :void
(value clampf)
(invert boolean))
(defglextfun ("glSamplePatternSGIS" sample-pattern-sgis) :void
(pattern enum))
(defglextfun ("glPixelTexGenParameteriSGIS" pixel-tex-gen-parameter-i-sgis) :void
(pname enum)
(param int))
(defglextfun ("glPixelTexGenParameterivSGIS" pixel-tex-gen-parameter-iv-sgis) :void
(pname enum)
(params (:pointer int)))
(defglextfun ("glPixelTexGenParameterfSGIS" pixel-tex-gen-parameter-f-sgis) :void
(pname enum)
(param float))
(defglextfun ("glPixelTexGenParameterfvSGIS" pixel-tex-gen-parameter-fv-sgis) :void
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetPixelTexGenParameterivSGIS" get-pixel-tex-gen-parameter-iv-sgis) :void
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetPixelTexGenParameterfvSGIS" get-pixel-tex-gen-parameter-fv-sgis) :void
(pname enum)
(params (:pointer float)))
(defglextfun ("glPointParameterfSGIS" point-parameter-f-sgis) :void
(pname enum)
(param float))
(defglextfun ("glPointParameterfvSGIS" point-parameter-fv-sgis) :void
(pname enum)
(params (:pointer float)))
(defglextfun ("glSharpenTexFuncSGIS" sharpen-tex-func-sgis) :void
(target enum)
(n sizei)
(points (:pointer float)))
(defglextfun ("glGetSharpenTexFuncSGIS" get-sharpen-tex-func-sgis) :void
(target enum)
(points (:pointer float)))
(defglextfun ("glTexImage4DSGIS" tex-image-4d-sgis) :void
(target enum)
(level int)
(internalformat enum)
(width sizei)
(height sizei)
(depth sizei)
(size4d sizei)
(border int)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glTexSubImage4DSGIS" tex-sub-image-4d-sgis) :void
(target enum)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(woffset int)
(width sizei)
(height sizei)
(depth sizei)
(size4d sizei)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glTextureColorMaskSGIS" texture-color-mask-sgis) :void
(red boolean)
(green boolean)
(blue boolean)
(alpha boolean))
(defglextfun ("glGetTexFilterFuncSGIS" get-tex-filter-func-sgis) :void
(target enum)
(filter enum)
(weights (:pointer float)))
(defglextfun ("glTexFilterFuncSGIS" tex-filter-func-sgis) :void
(target enum)
(filter enum)
(n sizei)
(weights (:pointer float)))
(defglextfun ("glAsyncMarkerSGIX" async-marker-sgix) :void
(marker uint))
(defglextfun ("glFinishAsyncSGIX" finish-async-sgix) int
(markerp (:pointer uint)))
(defglextfun ("glPollAsyncSGIX" poll-async-sgix) int
(markerp (:pointer uint)))
(defglextfun ("glGenAsyncMarkersSGIX" gen-async-markers-sgix) uint
(range sizei))
(defglextfun ("glDeleteAsyncMarkersSGIX" delete-async-markers-sgix) :void
(marker uint)
(range sizei))
(defglextfun ("glIsAsyncMarkerSGIX" is-async-marker-sgix) boolean
(marker uint))
(defglextfun ("glFlushRasterSGIX" flush-raster-sgix) :void)
(defglextfun ("glFragmentColorMaterialSGIX" fragment-color-material-sgix) :void
(face enum)
(mode enum))
(defglextfun ("glFragmentLightfSGIX" fragment-light-f-sgix) :void
(light enum)
(pname enum)
(param float))
(defglextfun ("glFragmentLightfvSGIX" fragment-light-fv-sgix) :void
(light enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glFragmentLightiSGIX" fragment-light-i-sgix) :void
(light enum)
(pname enum)
(param int))
(defglextfun ("glFragmentLightivSGIX" fragment-light-iv-sgix) :void
(light enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glFragmentLightModelfSGIX" fragment-light-model-f-sgix) :void
(pname enum)
(param float))
(defglextfun ("glFragmentLightModelfvSGIX" fragment-light-model-fv-sgix) :void
(pname enum)
(params (:pointer float)))
(defglextfun ("glFragmentLightModeliSGIX" fragment-light-model-i-sgix) :void
(pname enum)
(param int))
(defglextfun ("glFragmentLightModelivSGIX" fragment-light-model-iv-sgix) :void
(pname enum)
(params (:pointer int)))
(defglextfun ("glFragmentMaterialfSGIX" fragment-material-f-sgix) :void
(face enum)
(pname enum)
(param float))
(defglextfun ("glFragmentMaterialfvSGIX" fragment-material-fv-sgix) :void
(face enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glFragmentMaterialiSGIX" fragment-material-i-sgix) :void
(face enum)
(pname enum)
(param int))
(defglextfun ("glFragmentMaterialivSGIX" fragment-material-iv-sgix) :void
(face enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetFragmentLightfvSGIX" get-fragment-light-fv-sgix) :void
(light enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetFragmentLightivSGIX" get-fragment-light-iv-sgix) :void
(light enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetFragmentMaterialfvSGIX" get-fragment-material-fv-sgix) :void
(face enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetFragmentMaterialivSGIX" get-fragment-material-iv-sgix) :void
(face enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glLightEnviSGIX" light-env-i-sgix) :void
(pname enum)
(param int))
(defglextfun ("glFrameZoomSGIX" frame-zoom-sgix) :void
(factor int))
(defglextfun ("glIglooInterfaceSGIX" igloo-interface-sgix) :void
(pname enum)
(params (:pointer :void)))
(defglextfun ("glGetInstrumentsSGIX" get-instruments-sgix) int)
(defglextfun ("glInstrumentsBufferSGIX" instruments-buffer-sgix) :void
(size sizei)
(buffer (:pointer int)))
(defglextfun ("glPollInstrumentsSGIX" poll-instruments-sgix) int
(marker_p (:pointer int)))
(defglextfun ("glReadInstrumentsSGIX" read-instruments-sgix) :void
(marker int))
(defglextfun ("glStartInstrumentsSGIX" start-instruments-sgix) :void)
(defglextfun ("glStopInstrumentsSGIX" stop-instruments-sgix) :void
(marker int))
(defglextfun ("glGetListParameterfvSGIX" get-list-parameter-fv-sgix) :void
(list uint)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetListParameterivSGIX" get-list-parameter-iv-sgix) :void
(list uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glListParameterfSGIX" list-parameter-f-sgix) :void
(list uint)
(pname enum)
(param float))
(defglextfun ("glListParameterfvSGIX" list-parameter-fv-sgix) :void
(list uint)
(pname enum)
(params (:pointer float)))
(defglextfun ("glListParameteriSGIX" list-parameter-i-sgix) :void
(list uint)
(pname enum)
(param int))
(defglextfun ("glListParameterivSGIX" list-parameter-iv-sgix) :void
(list uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glPixelTexGenSGIX" pixel-tex-gen-sgix) :void
(mode enum))
(defglextfun ("glDeformationMap3dSGIX" deformation-map-3d-sgix) :void
(target enum)
(u1 double)
(u2 double)
(ustride int)
(uorder int)
(v1 double)
(v2 double)
(vstride int)
(vorder int)
(w1 double)
(w2 double)
(wstride int)
(worder int)
(points (:pointer double)))
(defglextfun ("glDeformationMap3fSGIX" deformation-map-3f-sgix) :void
(target enum)
(u1 float)
(u2 float)
(ustride int)
(uorder int)
(v1 float)
(v2 float)
(vstride int)
(vorder int)
(w1 float)
(w2 float)
(wstride int)
(worder int)
(points (:pointer float)))
(defglextfun ("glDeformSGIX" deform-sgix) :void
(mask FfdMaskSGIX))
(defglextfun ("glLoadIdentityDeformationMapSGIX" load-identity-deformation-map-sgix) :void
(mask FfdMaskSGIX))
(defglextfun ("glReferencePlaneSGIX" reference-plane-sgix) :void
(equation (:pointer double)))
(defglextfun ("glSpriteParameterfSGIX" sprite-parameter-f-sgix) :void
(pname enum)
(param float))
(defglextfun ("glSpriteParameterfvSGIX" sprite-parameter-fv-sgix) :void
(pname enum)
(params (:pointer float)))
(defglextfun ("glSpriteParameteriSGIX" sprite-parameter-i-sgix) :void
(pname enum)
(param int))
(defglextfun ("glSpriteParameterivSGIX" sprite-parameter-iv-sgix) :void
(pname enum)
(params (:pointer int)))
(defglextfun ("glTagSampleBufferSGIX" tag-sample-buffer-sgix) :void)
(defglextfun ("glColorTableSGI" color-table-sgi) :void
(target enum)
(internalformat enum)
(width sizei)
(format enum)
(type enum)
(table (:pointer :void)))
(defglextfun ("glColorTableParameterfvSGI" color-table-parameter-fv-sgi) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glColorTableParameterivSGI" color-table-parameter-iv-sgi) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glCopyColorTableSGI" copy-color-table-sgi) :void
(target enum)
(internalformat enum)
(x int)
(y int)
(width sizei))
(defglextfun ("glGetColorTableSGI" get-color-table-sgi) :void
(target enum)
(format enum)
(type enum)
(table (:pointer :void)))
(defglextfun ("glGetColorTableParameterfvSGI" get-color-table-parameter-fv-sgi) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetColorTableParameterivSGI" get-color-table-parameter-iv-sgi) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glFinishTextureSUNX" finish-texture-sunx) :void)
(defglextfun ("glGlobalAlphaFactorbSUN" global-alpha-factor-b-sun) :void
(factor byte))
(defglextfun ("glGlobalAlphaFactorsSUN" global-alpha-factor-s-sun) :void
(factor short))
(defglextfun ("glGlobalAlphaFactoriSUN" global-alpha-factor-i-sun) :void
(factor int))
(defglextfun ("glGlobalAlphaFactorfSUN" global-alpha-factor-f-sun) :void
(factor float))
(defglextfun ("glGlobalAlphaFactordSUN" global-alpha-factor-d-sun) :void
(factor double))
(defglextfun ("glGlobalAlphaFactorubSUN" global-alpha-factor-ub-sun) :void
(factor ubyte))
(defglextfun ("glGlobalAlphaFactorusSUN" global-alpha-factor-us-sun) :void
(factor ushort))
(defglextfun ("glGlobalAlphaFactoruiSUN" global-alpha-factor-ui-sun) :void
(factor uint))
(defglextfun ("glDrawMeshArraysSUN" draw-mesh-arrays-sun) :void
(mode enum)
(first int)
(count sizei)
(width sizei))
(defglextfun ("glReplacementCodeuiSUN" replacement-code-ui-sun) :void
(code uint))
(defglextfun ("glReplacementCodeusSUN" replacement-code-us-sun) :void
(code ushort))
(defglextfun ("glReplacementCodeubSUN" replacement-code-ub-sun) :void
(code ubyte))
(defglextfun ("glReplacementCodeuivSUN" replacement-code-uiv-sun) :void
(code (:pointer uint)))
(defglextfun ("glReplacementCodeusvSUN" replacement-code-usv-sun) :void
(code (:pointer ushort)))
(defglextfun ("glReplacementCodeubvSUN" replacement-code-ubv-sun) :void
(code (:pointer ubyte)))
(defglextfun ("glReplacementCodePointerSUN" replacement-code-pointer-sun) :void
(type enum)
(stride sizei)
(pointer (:pointer (:pointer :void))))
(defglextfun ("glColor4ubVertex2fSUN" color-4ub-vertex-2f-sun) :void
(r ubyte)
(g ubyte)
(b ubyte)
(a ubyte)
(x float)
(y float))
(defglextfun ("glColor4ubVertex2fvSUN" color-4ub-vertex-2fv-sun) :void
(c (:pointer ubyte))
(v (:pointer float)))
(defglextfun ("glColor4ubVertex3fSUN" color-4ub-vertex-3f-sun) :void
(r ubyte)
(g ubyte)
(b ubyte)
(a ubyte)
(x float)
(y float)
(z float))
(defglextfun ("glColor4ubVertex3fvSUN" color-4ub-vertex-3fv-sun) :void
(c (:pointer ubyte))
(v (:pointer float)))
(defglextfun ("glColor3fVertex3fSUN" color-3f-vertex-3f-sun) :void
(r float)
(g float)
(b float)
(x float)
(y float)
(z float))
(defglextfun ("glColor3fVertex3fvSUN" color-3f-vertex-3fv-sun) :void
(c (:pointer float))
(v (:pointer float)))
(defglextfun ("glNormal3fVertex3fSUN" normal-3f-vertex-3f-sun) :void
(nx float)
(ny float)
(nz float)
(x float)
(y float)
(z float))
(defglextfun ("glNormal3fVertex3fvSUN" normal-3f-vertex-3fv-sun) :void
(n (:pointer float))
(v (:pointer float)))
(defglextfun ("glColor4fNormal3fVertex3fSUN" color-4f-normal-3f-vertex-3f-sun) :void
(r float)
(g float)
(b float)
(a float)
(nx float)
(ny float)
(nz float)
(x float)
(y float)
(z float))
(defglextfun ("glColor4fNormal3fVertex3fvSUN" color-4f-normal-3f-vertex-3fv-sun) :void
(c (:pointer float))
(n (:pointer float))
(v (:pointer float)))
(defglextfun ("glTexCoord2fVertex3fSUN" tex-coord-2f-vertex-3f-sun) :void
(s float)
(tee float)
(x float)
(y float)
(z float))
(defglextfun ("glTexCoord2fVertex3fvSUN" tex-coord-2f-vertex-3fv-sun) :void
(tc (:pointer float))
(v (:pointer float)))
(defglextfun ("glTexCoord4fVertex4fSUN" tex-coord-4f-vertex-4f-sun) :void
(s float)
(tee float)
(p float)
(q float)
(x float)
(y float)
(z float)
(w float))
(defglextfun ("glTexCoord4fVertex4fvSUN" tex-coord-4f-vertex-4fv-sun) :void
(tc (:pointer float))
(v (:pointer float)))
(defglextfun ("glTexCoord2fColor4ubVertex3fSUN" tex-coord-2f-color-4ub-vertex-3f-sun) :void
(s float)
(tee float)
(r ubyte)
(g ubyte)
(b ubyte)
(a ubyte)
(x float)
(y float)
(z float))
(defglextfun ("glTexCoord2fColor4ubVertex3fvSUN" tex-coord-2f-color-4ub-vertex-3fv-sun) :void
(tc (:pointer float))
(c (:pointer ubyte))
(v (:pointer float)))
(defglextfun ("glTexCoord2fColor3fVertex3fSUN" tex-coord-2f-color-3f-vertex-3f-sun) :void
(s float)
(tee float)
(r float)
(g float)
(b float)
(x float)
(y float)
(z float))
(defglextfun ("glTexCoord2fColor3fVertex3fvSUN" tex-coord-2f-color-3f-vertex-3fv-sun) :void
(tc (:pointer float))
(c (:pointer float))
(v (:pointer float)))
(defglextfun ("glTexCoord2fNormal3fVertex3fSUN" tex-coord-2f-normal-3f-vertex-3f-sun) :void
(s float)
(tee float)
(nx float)
(ny float)
(nz float)
(x float)
(y float)
(z float))
(defglextfun ("glTexCoord2fNormal3fVertex3fvSUN" tex-coord-2f-normal-3f-vertex-3fv-sun) :void
(tc (:pointer float))
(n (:pointer float))
(v (:pointer float)))
(defglextfun ("glTexCoord2fColor4fNormal3fVertex3fSUN" tex-coord-2f-color-4f-normal-3f-vertex-3f-sun) :void
(s float)
(tee float)
(r float)
(g float)
(b float)
(a float)
(nx float)
(ny float)
(nz float)
(x float)
(y float)
(z float))
(defglextfun ("glTexCoord2fColor4fNormal3fVertex3fvSUN" tex-coord-2f-color-4f-normal-3f-vertex-3fv-sun) :void
(tc (:pointer float))
(c (:pointer float))
(n (:pointer float))
(v (:pointer float)))
(defglextfun ("glTexCoord4fColor4fNormal3fVertex4fSUN" tex-coord-4f-color-4f-normal-3f-vertex-4f-sun) :void
(s float)
(tee float)
(p float)
(q float)
(r float)
(g float)
(b float)
(a float)
(nx float)
(ny float)
(nz float)
(x float)
(y float)
(z float)
(w float))
(defglextfun ("glTexCoord4fColor4fNormal3fVertex4fvSUN" tex-coord-4f-color-4f-normal-3f-vertex-4fv-sun) :void
(tc (:pointer float))
(c (:pointer float))
(n (:pointer float))
(v (:pointer float)))
(defglextfun ("glReplacementCodeuiVertex3fSUN" replacement-code-ui-vertex-3f-sun) :void
(rc uint)
(x float)
(y float)
(z float))
(defglextfun ("glReplacementCodeuiVertex3fvSUN" replacement-code-ui-vertex-3fv-sun) :void
(rc (:pointer uint))
(v (:pointer float)))
(defglextfun ("glReplacementCodeuiColor4ubVertex3fSUN" replacement-code-ui-color-4ub-vertex-3f-sun) :void
(rc uint)
(r ubyte)
(g ubyte)
(b ubyte)
(a ubyte)
(x float)
(y float)
(z float))
(defglextfun ("glReplacementCodeuiColor4ubVertex3fvSUN" replacement-code-ui-color-4ub-vertex-3fv-sun) :void
(rc (:pointer uint))
(c (:pointer ubyte))
(v (:pointer float)))
(defglextfun ("glReplacementCodeuiColor3fVertex3fSUN" replacement-code-ui-color-3f-vertex-3f-sun) :void
(rc uint)
(r float)
(g float)
(b float)
(x float)
(y float)
(z float))
(defglextfun ("glReplacementCodeuiColor3fVertex3fvSUN" replacement-code-ui-color-3f-vertex-3fv-sun) :void
(rc (:pointer uint))
(c (:pointer float))
(v (:pointer float)))
(defglextfun ("glReplacementCodeuiNormal3fVertex3fSUN" replacement-code-ui-normal-3f-vertex-3f-sun) :void
(rc uint)
(nx float)
(ny float)
(nz float)
(x float)
(y float)
(z float))
(defglextfun ("glReplacementCodeuiNormal3fVertex3fvSUN" replacement-code-ui-normal-3f-vertex-3fv-sun) :void
(rc (:pointer uint))
(n (:pointer float))
(v (:pointer float)))
(defglextfun ("glReplacementCodeuiColor4fNormal3fVertex3fSUN" replacement-code-ui-color-4f-normal-3f-vertex-3f-sun) :void
(rc uint)
(r float)
(g float)
(b float)
(a float)
(nx float)
(ny float)
(nz float)
(x float)
(y float)
(z float))
(defglextfun ("glReplacementCodeuiColor4fNormal3fVertex3fvSUN" replacement-code-ui-color-4f-normal-3f-vertex-3fv-sun) :void
(rc (:pointer uint))
(c (:pointer float))
(n (:pointer float))
(v (:pointer float)))
(defglextfun ("glReplacementCodeuiTexCoord2fVertex3fSUN" replacement-code-ui-tex-coord-2f-vertex-3f-sun) :void
(rc uint)
(s float)
(tee float)
(x float)
(y float)
(z float))
(defglextfun ("glReplacementCodeuiTexCoord2fVertex3fvSUN" replacement-code-ui-tex-coord-2f-vertex-3fv-sun) :void
(rc (:pointer uint))
(tc (:pointer float))
(v (:pointer float)))
(defglextfun ("glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN" replacement-code-ui-tex-coord-2f-normal-3f-vertex-3f-sun) :void
(rc uint)
(s float)
(tee float)
(nx float)
(ny float)
(nz float)
(x float)
(y float)
(z float))
(defglextfun ("glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN" replacement-code-ui-tex-coord-2f-normal-3f-vertex-3fv-sun) :void
(rc (:pointer uint))
(tc (:pointer float))
(n (:pointer float))
(v (:pointer float)))
(defglextfun ("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN" replacement-code-ui-tex-coord-2f-color-4f-normal-3f-vertex-3f-sun) :void
(rc uint)
(s float)
(tee float)
(r float)
(g float)
(b float)
(a float)
(nx float)
(ny float)
(nz float)
(x float)
(y float)
(z float))
(defglextfun ("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN" replacement-code-ui-tex-coord-2f-color-4f-normal-3f-vertex-3fv-sun) :void
(rc (:pointer uint))
(tc (:pointer float))
(c (:pointer float))
(n (:pointer float))
(v (:pointer float)))
| 223,125 | Common Lisp | .lisp | 7,504 | 26.980677 | 146 | 0.733618 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 53a13df05a36429263bbf3cb71494f073264e79162b9adc4219ff1877c95bdc3 | 30,588 | [
235271
] |
30,589 | funcs-gl-glcore-gles1-gles2.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/funcs-gl-glcore-gles1-gles2.lisp | ;;; this file is automatically generated, do not edit
;;; generated from files with the following copyright:
;;;
;;; Copyright (c) 2013-2015 The Khronos Group Inc.
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining a
;;; copy of this software and/or associated documentation files (the
;;; "Materials"), to deal in the Materials without restriction, including
;;; without limitation the rights to use, copy, modify, merge, publish,
;;; distribute, sublicense, and/or sell copies of the Materials, and to
;;; permit persons to whom the Materials are furnished to do so, subject to
;;; the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be included
;;; in all copies or substantial portions of the Materials.
;;;
;;; THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
;;; IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
;;; CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
;;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
;;; MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
;;;
;;; ------------------------------------------------------------------------
(in-package #:cl-opengl-bindings)
;;; generated 2015-08-30T01:01:50Z
;;; from gl.xml @ svn rev 31811, 2015-08-10T07:01:11.860488Z
(defparameter *glext-version* 20150810)
(defparameter *glext-last-updated* "2015-08-10T07:01:11.860488Z")
(defglfun ("glGetPointerv" get-pointer-v) :void
(pname enum)
(params (:pointer (:pointer :void))))
(defglextfun ("glDepthRangef" depth-range-f) :void
(n float)
(f float))
(defglextfun ("glClearDepthf" clear-depth-f) :void
(d float))
| 1,841 | Common Lisp | .lisp | 38 | 47 | 76 | 0.72216 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 349e88171c781ccf134fd2f44232d3e50cb63f8e0d759db96bc5a58418356bf9 | 30,589 | [
490674
] |
30,590 | state.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/state.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; Copyright (c) 2004, Oliver Markovic <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions are met:
;;;
;;; o Redistributions of source code must retain the above copyright notice,
;;; this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may be
;;; used to endorse or promote products derived from this software without
;;; specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
;;; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
;;; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
;;; LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
;;; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
;;; SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
;;; CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
;;; ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
;;; POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-opengl)
;;;
;;; Chapter 6 - State and State Requests
;;;
;;; 6.1 Querying GL State
;;;
;;; 6.1.1 Simple queries
;;; Association list mapping enums for known queries to the number and type of
;;; values returned by the query. To perform a query that is not
;;; known in this table, the number of return values must be specified
;;; explicitly in the call to GET-*.
;;; size can be a keyword, in which case actual size is (get-integer size 1)
;; (name type count &optional max)
;; NAME is enum to query
;; TYPE is things like :integer, :float, etc possibly with -i or /i suffix
;; to indicate indexed variants (-i is for indexed queries only, /i
;; for queries that can be used with or without an index)
;; COUNT is number of values expected (returned as an array if more than 1)
;; MAX is optional value or enum to query to determine highest valid
;; index for -i variants (not used currently, but useful fo dumping
;; current state for debugging, or possible future function to retrieve
;; all values for a -i query at once)
(defparameter *query-enum-sizes*
'(;; 6.8 (table # from opengl 4.2 compat profile spec)
(:current-color :float 4)
(:current-secondary-color :float 4)
(:current-index :integer 1)
(:current-texture-coords :float 4)
(:current-normal :float 3)
(:current-fog-coordinate :float 1)
(:current-raster-position :float 4)
(:current-raster-distance :float 1)
(:current-raster-color :float 4)
(:current-raster-secondary-color :float 4)
(:current-raster-index :integer 1)
(:current-raster-texture-coords :float 4)
(:current-raster-position-valid :boolean 1)
(:edge-flag :boolean 1)
(:patch-vertices :integer 1)
(:patch-default-outer-level :float 4)
(:patch-default-inner-level :float 2)
;; 6.9
(:vertex-array :enable 1)
(:vertex-array-size :integer 1)
(:vertex-array-type :enum 1)
(:vertex-array-stride :integer 1)
(:vertex-array-pointer :pointer 1)
(:normal-array :enable 1)
(:normal-array-type :enum 1)
(:normal-array-stride :integer 1)
(:normal-array-pointer :pointer 1)
(:fog-coordinate-array :enable 1)
(:fog-coordinate-array-type :enum 1)
(:fog-coordinate-array-stride :integer 1)
(:fog-coordinate-array-pointer :pointer 1)
(:color-array :enable 1)
(:color-array-size :integer 1)
(:color-array-type :enum 1)
(:color-array-stride :integer 1)
(:color-array-pointer :pointer 1)
;; 6.10
(:secondary-color-array :enable 1)
(:secondary-color-array-size :integer 1)
(:secondary-color-array-type :enum 1)
(:secondary-color-array-stride :integer 1)
(:secondary-color-array-pointer :pointer 1)
(:index-array :enable 1)
(:index-array-type :enum 1)
(:index-array-stride :integer 1)
(:index-array-pointer :pointer 1)
(:texture-coord-array :enable 1)
(:texture-coord-array-size :integer 1)
(:texture-coord-array-type :enum 1)
(:texture-coord-array-stride :integer 1)
(:texture-coord-array-pointer :pointer 1)
;; 6.11
(:vertex-attrib-array-enabled :vertex-attrib-boolean 1 :max-vertex-attribs)
(:vertex-attrib-array-size :vertex-attrib-integer 1 :max-vertex-attribs)
(:vertex-attrib-array-stride :vertex-attrib-integer 1 :max-vertex-attribs)
(:vertex-attrib-array-type :vertex-attrib-enum 1 :max-vertex-attribs)
(:vertex-attrib-array-normalized :vertex-attrib-boolean 1 :max-vertex-attribs)
(:vertex-attrib-array-integer :vertex-attrib-boolean 1 :max-vertex-attribs)
(:vertex-attrib-array-divisor :vertex-attrib-integer 1 :max-vertex-attribs)
(:vertex-attrib-array-pointer :vertex-attrib-pointer 1 :max-vertex-attribs)
(:edge-flag-array :enable 1)
(:edge-flag-array-stride :integer 1)
(:edge-flag-array-pointer :pointer 1)
;; 6.12
(:vertex-array-buffer-binding :integer 1)
(:normal-array-buffer-binding :integer 1)
(:color-array-buffer-binding :integer 1)
(:index-array-buffer-binding :integer 1)
(:texture-coord-array-buffer-binding :integer 1)
(:edge-flag-array-buffer-binding :integer 1)
(:secondary-color-array-buffer-binding :integer 1)
(:fog-coordinate-array-buffer-binding :integer 1)
(:element-array-buffer-binding :integer 1)
(:vertex-attrib-array-buffer-binding :vertex-attrib-integer 1)
;; 6.13
(:client-active-texture :enum 1)
(:array-buffer-binding :integer 1)
(:draw-indirect-buffer-binding :integer 1)
(:vertex-array-binding :integer 1)
(:primitive-restart :enable 1)
(:primitive-restart-index :integer 1)
;; 6.14
;; 6.15
(:color-matrix :float 16)
(:transpose-color-matrix :float 16)
(:modelview-matrix :float 16)
(:transpose-modelview-matrix :float 16)
(:projection-matrix :float 16)
(:transpose-projection-matrix :float 16)
(:texture-matrix :float 16)
(:transpose-texture-matrix :float 16)
(:viewport :float/i 4 :max-viewports)
(:depth-range :float/i 2 :max-viewports)
(:color-matrix-stack-depth :integer 1)
(:modelview-stack-depth :integer 1)
(:projection-stack-depth :integer 1)
(:texture-stack-depth :integer 1)
(:matrix-mode :enum 1)
(:normalize :enable 1)
(:rescale-normal :enable 1)
(:clip-plane :clip-plane-i 4 :max-clip-planes)
(:clip-plane0 :clip-plane 4)
(:clip-plane1 :clip-plane 4)
(:clip-plane2 :clip-plane 4)
(:clip-plane3 :clip-plane 4)
(:clip-plane4 :clip-plane 4)
(:clip-plane5 :clip-plane 4)
(:clip-distance :clip-distance-i 1 :max-clip-distances)
(:clip-distance0 :enable 1)
(:clip-distance1 :enable 1)
(:clip-distance2 :enable 1)
(:clip-distance3 :enable 1)
(:clip-distance4 :enable 1)
(:clip-distance5 :enable 1)
(:clip-distance6 :enable 1)
(:clip-distance7 :enable 1)
(:depth-clamp :enable 1)
(:transform-feedback-binding :integer 1)
;; 6.16
(:fog-color :float 4)
(:fog-index :float 1)
(:fog-density :float 1)
(:fog-start :float 1)
(:fog-end :float 1)
(:fog-mode :enum 1)
(:fog :enable 1)
(:fog-coordinate-source :enum 1)
(:color-sum :enable 1)
(:shade-model :enum 1)
(:clamp-vertex-color :enum 1)
(:clamp-fragment-color :enum 1)
(:clamp-read-color :enum 1)
(:provoking-vertex :enum 1)
;; 6.17
(:lighting :enable 1)
(:color-material :enable 1)
(:color-material-parameter :enum 1)
(:color-material-face :enum 1)
;; :ambient, :diffuse, etc. getMaterialfv need param
(:light-model-ambient :float 4)
(:light-model-local-viewer :boolean 1)
(:light-model-two-side :boolean 1)
(:light-model-color-control :enum 1)
;; 6.18
;; :ambient, :diffuse, etc. getLightfv need param (and conflict
;; with getMaterialfv)
(:light :light-enable-i 1 :max-lights)
(:light0 :enable 1)
(:light1 :enable 1)
(:light2 :enable 1)
(:light3 :enable 1)
(:light4 :enable 1)
(:light5 :enable 1)
(:light6 :enable 1)
(:light7 :enable 1)
;; :color-indexes from getMaterialfv needs extra arg
;; 6.19
(:rasterizer-discard :enable 1)
(:point-size :float 1)
(:point-smooth :enable 1)
(:point-sprite :enable 1)
(:point-size-min :float 1)
(:point-size-max :float 1)
(:point-fade-threshold-size :float 1)
(:point-distance-attenuation :float 3)
(:point-sprite-coord-origin :enum 1)
(:line-width :float 1)
(:line-smooth :enable 1)
(:line-stipple-pattern :integer 1)
(:line-stipple-repeat :integer 1)
(:line-stipple :enable 1)
;; 6.20
(:cull-face :enable 1)
(:cull-face-mode :enum 1)
(:front-face :enum 1)
(:polygon-smooth :enable 1)
(:polygon-mode :enum 2)
(:polygon-offset-factor :float 1)
(:polygon-offset-units :float 1)
(:polygon-offset-point :enable 1)
(:polygon-offset-line :enable 1)
(:polygon-offset-fill :enable 1)
(:polygon-stipple :enable 1)
;; 6.21
(:multisample :enable 1)
(:sample-alpha-to-coverage :enable 1)
(:sample-alpha-to-one :enable 1)
(:sample-coverage :enable 1)
(:sample-coverage-value :float 1)
(:sample-coverage-invert :boolean 1)
(:sample-shading :enable 1)
(:min-sample-shading-value :float 1)
(:sample-mask :enable 1)
(:sample-mask-value :integer-i 1 :max-sample-mask-words)
;; 6.22
(:texture-1d :enable 1)
(:texture-2d :enable 1)
(:texture-3d :enable 1)
(:texture-cube-map :enable 1)
(:texture-binding-1d :integer 1)
(:texture-binding-2d :integer 1)
(:texture-binding-3d :integer 1)
(:texture-binding-1d-array :integer 1)
(:texture-binding-2d-array :integer 1)
(:texture-binding-cube-map-array :integer 1)
(:texture-binding-rectangle :integer 1)
(:texture-binding-buffer :integer 1)
(:texture-binding-cube-map :integer 1)
(:texture-binding-2d-multisample :integer 1)
(:texture-binding-2d-multisample-array :integer 1)
;; 6.23
(:sampler-binding :integer 1)
;; get-tex-image stuff needs extra args
;; 6.24
;; get-tex-parameter stuff needs extra args
;; 6.25
;; get-tex-level-parameter stuff needs extra args
;; 6.26
;; get-sampler-parameter stuff needs extra args
;; 6.27
(:active-texture :enum 1)
;; get-tex-env stuff needs extra args
(:texture-gen-q :enable 1)
(:texture-gen-r :enable 1)
(:texture-gen-s :enable 1)
(:texture-gen-t :enable 1)
;; get-tex-gen stuff needs extra args
;; 6.28
;; get-tex-env needs extra args
;; 6.29
(:scissor-test :enable/i 1 :max-viewports)
(:scissor-box :integer/i 4 :max-viewports)
(:alpha-test :enable 1)
(:alpha-test-func :enum 1)
(:alpha-test-ref :integer 1)
(:stencil-test :enable 1)
(:stencil-func :enum 1)
(:stencil-value-mask :integer 1)
(:stencil-ref :integer 1)
(:stencil-fail :enum 1)
(:stencil-pass-depth-fail :enum 1)
(:stencil-pass-depth-pass :enum 1)
(:stencil-back-func :enum 1)
(:stencil-back-value-mask :integer 1)
(:stencil-back-ref :integer 1)
(:stencil-back-fail :enum 1)
(:stencil-back-pass-depth-fail :enum 1)
(:stencil-back-pass-depth-pass :enum 1)
(:depth-test :enable 1)
(:depth-func :enum 1)
;; 6.30
(:blend :enable/i 1 :max-draw-buffers)
;; ? (:blend-src :enum 1)
(:blend-src-rgb :enum/i 1 :max-draw-buffers)
(:blend-src-alpha :enum/i 1 :max-draw-buffers)
;; ? (:blend-dst :enum 1)
(:blend-dst-rgb :enum/i 1 :max-draw-buffers)
(:blend-dst-alpha :enum/i 1 :max-draw-buffers)
(:blend-equation-rgb :enum/i 1 :max-draw-buffers)
(:blend-equation-alpha :enum/i 1 :max-draw-buffers)
(:blend-color :float 4)
(:framebuffer-srgb :enable 1)
(:dither :enable 1)
(:index-logic-op :enable 1)
(:color-logic-op :enable 1)
(:logic-op-mode :enum 1)
;; 6.31
(:index-writemask :integer 1)
(:color-writemask :boolean/i 4 :max-draw-buffers)
(:depth-writemask :boolean 1)
(:stencil-writemask :integer 1)
(:stencil-back-writemask :integer 1)
(:color-clear-value :float 4)
(:index-clear-value :float 1) ;;integer?
(:depth-clear-value :float 1)
(:stencil-clear-value :integer 1)
(:accum-clear-value :float 4)
;; 6.32
(:draw-framebuffer-binding :integer 1)
(:read-framebuffer-binding :integer 1)
;; 6.33
(:draw-buffer :draw-buffer/i 1 :max-draw-buffers)
(:draw-buffer0 :enum 1)
(:draw-buffer1 :enum 1)
(:draw-buffer2 :enum 1)
(:draw-buffer3 :enum 1)
(:draw-buffer4 :enum 1)
(:draw-buffer5 :enum 1)
(:draw-buffer6 :enum 1)
(:draw-buffer7 :enum 1)
(:draw-buffer8 :enum 1)
(:draw-buffer9 :enum 1)
(:draw-buffer10 :enum 1)
(:draw-buffer11 :enum 1)
(:draw-buffer12 :enum 1)
(:draw-buffer13 :enum 1)
(:draw-buffer14 :enum 1)
(:draw-buffer15 :enum 1)
(:read-buffer :enum 1)
;; 6.34
;; get-framebuffer-attachment-parameter-iv need extra args
;; 6.35
(:renderbuffer-binding :integer 1)
;; 6.36
;; get-renderbuffer-parameter-iv need extra args
;; 6.37
(:unpack-swap-bytes :boolean 1)
(:unpack-lsb-first :boolean 1)
(:unpack-image-height :integer 1)
(:unpack-skip-images :integer 1)
(:unpack-row-length :integer 1)
(:unpack-skip-rows :integer 1)
(:unpack-skip-pixels :integer 1)
(:unpack-alignment :integer 1)
(:unpack-compressed-block-width :integer 1)
(:unpack-compressed-block-height :integer 1)
(:unpack-compressed-block-depth :integer 1)
(:unpack-compressed-block-size :integer 1)
(:pixel-unpack-buffer-binding :integer 1)
;; 6.38
(:pack-swap-bytes :boolean 1)
(:pack-lsb-first :boolean 1)
(:pack-image-height :integer 1)
(:pack-skip-images :integer 1)
(:pack-row-length :integer 1)
(:pack-skip-rows :integer 1)
(:pack-skip-pixels :integer 1)
(:pack-alignment :integer 1)
(:pack-compressed-block-width :integer 1)
(:pack-compressed-block-height :integer 1)
(:pack-compressed-block-depth :integer 1)
(:pack-compressed-block-size :integer 1)
(:pixel-pack-buffer-binding :integer 1)
(:pixel-unpack-buffer-binding :integer 1)
(:map-color :boolean 1)
(:map-stencil :boolean 1)
(:index-shift :integer 1)
(:index-offset :integer 1)
(:red-scale :float 1)
(:green-scale :float 1)
(:blue-scale :float 1)
(:alpha-scale :float 1)
(:depth-scale :float 1)
(:red-bias :float 1)
(:green-bias :float 1)
(:blue-bias :float 1)
(:alpha-bias :float 1)
(:depth-bias :float 1)
;; 6.39
(:color-table :enable 1)
(:post-convolution-color-table :enable 1)
(:post-color-matrix-color-table :enable 1)
;; get-color-table, get-color-table-parameter ...
;; 6.40
(:convolution-1d :enable 1)
(:convolution-2d :enable 1)
(:separable-2d :enable 1)
;; 6.41
(:post-convolution-red-scale :float 1)
(:post-convolution-green-scale :float 1)
(:post-convolution-blue-scale :float 1)
(:post-convolution-alpha-scale :float 1)
(:post-convolution-red-bias :float 1)
(:post-convolution-green-bias :float 1)
(:post-convolution-blue-bias :float 1)
(:post-convolution-alpha-bias :float 1)
(:post-color-matrix-red-scale :float 1)
(:post-color-matrix-green-scale :float 1)
(:post-color-matrix-blue-scale :float 1)
(:post-color-matrix-alpha-scale :float 1)
(:post-color-matrix-red-bias :float 1)
(:post-color-matrix-green-bias :float 1)
(:post-color-matrix-blue-bias :float 1)
(:post-color-matrix-alpha-bias :float 1)
(:histogram :enable 1)
;; 6.42
(:minmax :enable 1)
(:zoom-x :float 1)
(:zoom-y :float 1)
(:pixel-map-i-to-i-size :integer 1)
(:pixel-map-s-to-s-size :integer 1)
(:pixel-map-i-to-r-size :integer 1)
(:pixel-map-i-to-g-size :integer 1)
(:pixel-map-i-to-b-size :integer 1)
(:pixel-map-i-to-a-size :integer 1)
(:pixel-map-r-to-r-size :integer 1)
(:pixel-map-g-to-g-size :integer 1)
(:pixel-map-b-to-b-size :integer 1)
(:pixel-map-a-to-a-size :integer 1)
;; 6.43
(:map1-vertex-3 :enable 1)
(:map1-vertex-4 :enable 1)
(:map1-index :enable 1)
(:map1-color-4 :enable 1)
(:map1-normal :enable 1)
(:map1-texture-coord-1 :enable 1)
(:map1-texture-coord-2 :enable 1)
(:map1-texture-coord-3 :enable 1)
(:map1-texture-coord-4 :enable 1)
(:map2-vertex-3 :enable 1)
(:map2-vertex-4 :enable 1)
(:map2-index :enable 1)
(:map2-color-4 :enable 1)
(:map2-normal :enable 1)
(:map2-texture-coord-1 :enable 1)
(:map2-texture-coord-2 :enable 1)
(:map2-texture-coord-3 :enable 1)
(:map2-texture-coord-4 :enable 1)
(:map1-grid-domain :float 2)
(:map2-grid-domain :float 4)
(:map1-grid-segments :float 1)
(:map2-grid-segments :float 2)
(:auto-normal :enable 1)
;; 6.44
;; get-shader-iv, get-shader-info-log, get-shader-source, need extra args
;; 6.45
;; get-program-pipeline-iv get-program-pipeline-info-log need extra args
;; 6,46
(:current-program :integer 1)
(:program-pipeline-binding :integer 1)
;; get-program-iv etc need extra args
;; 6.47
;; 6.48
;; 6.49
(:uniform-buffer-binding :integer/i 1 :max-uniform-buffer-bindings)
(:uniform-buffer-start :integer64-i 1 :max-uniform-buffer-bindings)
(:uniform-buffer-size :integer64-i 1 :max-uniform-buffer-bindings)
;; get-program, get-active-uniforms, get-active-uniform-block
;; 6.50
;; 6.51
;; 6.52
;; get-program-stage, get-active-subroutine-uniform,
;; get-active-subroutine-name,
;; 6.53
;; get-active-atomic-counter-buffer-bindings, ...
;; 6.54
(:vertex-program-two-side :enable 1)
(:current-vertex-attrib :vertex-attrib-float 4 :max-vertex-attribs)
(:program-point-size :enable 1)
;; 6.55
;; get-query-object
;; 6.56
(:image-binding-name :integer-i 1 :max-image-units)
(:image-binding-level :integer-i 1 :max-image-units)
(:image-binding-layered :boolean-i 1 :max-image-units)
(:image-binding-layer :integer-i 1 :max-image-units)
(:image-binding-access :enum-i 1 :max-image-units)
(:image-binding-format :enum-i 1 :max-image-units)
;; 6.57
(:transform-feedback-buffer-binding :integer/i 1 :max-transform-feedback-buffers)
(:transform-feedback-buffer-start :integer64-i 1 :max-transform-feedback-buffers)
(:transform-feedback-buffer-size :integer64-i 1 :max-transform-feedback-buffers)
(:transform-feedback-buffer-paused :boolean 1)
(:transform-feedback-buffer-active :boolean 1)
;; 6.58
(:atomic-counter-buffer-binding :integer/i 1 :max-atomic-counter-buffer-bindings)
(:atomic-counter-buffer-start :integer64-i 1 :max-atomic-counter-buffer-bindings)
(:atomic-counter-buffer-size :integer64-i 1 :max-atomic-counter-buffer-bindings)
;; 6.59
;; get-sync
;; 6.60
(:perspective-correction-hint :enum 1)
(:point-smooth-hint :enum 1)
(:line-smooth-hint :enum 1)
(:polygon-smooth-hint :enum 1)
(:fog-hint :enum 1)
(:generate-mipmap-hint :enum 1)
(:texture-compression-hint :enum 1)
(:fragment-shader-derivative-hint :enum 1)
;; 6.61
(:max-lights :integer 1)
(:max-clip-distances :integer 1)
(:max-cull-distances :integer 1)
(:max-combined-clip-and-cull-distances :integer 1)
(:max-clip-planes :integer 1)
(:max-color-matrix-stack-depth :integer 1)
(:max-modelview-stack-depth :integer 1)
(:max-projection-stack-depth :integer 1)
(:max-texture-stack-depth :integer 1)
(:subpixel-bits :integer 1)
(:primitive-restart-for-patches-supported :boolean 1)
(:max-3d-texture-size :integer 1)
(:max-texture-size :integer 1)
(:max-array-texture-layers :integer 1)
(:max-texture-lod-bias :float 1)
(:max-cube-map-texture-size :integer 1)
(:max-renderbuffer-size :integer 1)
;; 6.62
(:max-pixel-map-table :integer 1)
(:max-name-stack-depth :integer 1)
(:max-list-nesting :integer 1)
(:max-eval-order :integer 1)
(:max-viewport-dims :float 2)
(:max-viewports :integer 1)
(:viewport-subpixel-bits :integer 1)
(:viewport-bounds-range :float 2)
(:layer-provoking-vertex :enum 1)
(:viewport-index-provoking-vertex :enum 1)
(:max-attrib-stack-depth :integer 1)
(:max-client-attrib-stack-depth :integer 1)
(:aliased-point-size-range :float 2)
(:point-size-range :float 2)
(:point-size-granularity :float 1)
;; ?
(:smooth-point-size-range :float 2) ;?
(:smooth-point-size-granularity :float 1)
(:line-width-range :float 2)
(:line-width-granularity :float 1)
;; 6.63
(:aliased-line-width-range :float 2)
(:smooth-line-width-range :float 2)
(:smooth-line-width-granularity :float 1)
;; get-convolution-parameter
(:max-elements-indices :integer 1)
(:max-elements-vertices :integer 1)
(:max-vertex-attrib-relative-offset :integer 1)
(:max-vertex-attrib-bindings :integer 1)
(:max-vertex-attrib-stride :integer 1)
(:compressed-texture-formats :enum :num-compressed-texture-formats)
(:num-compressed-texture-formats :integer 1)
(:max-texture-buffer-size :integer 1)
(:max-rectangle-texture-size :integer 1)
(:program-binary-formats :enum :num-program-binary-formats)
(:num-program-binary-formats :integer 1)
(:shader-binary-formats :enum :num-shader-binary-formats)
(:num-shader-binary-formats :integer 1)
(:shader-compiler :boolean 1)
(:min-map-buffer-alignment :integer 1)
(:texture-buffer-offset-alignment :integer 1)
;; 6.64
(:extensions :extensions/i 1 :num-extensions)
(:num-extensions :integer 1)
(:major-version :integer 1)
(:minor-version :integer 1)
(:context-flags :integer 1)
(:renderer :string 1)
(:shading-language-version :string 1)
(:num-shading-language-versions :integer 1)
(:vendor :string 1)
(:version :string 1)
;; ?
(:max-texture-units :integer 1)
;; 6.65
(:max-vertex-attribs :integer 1)
(:max-vertex-uniform-components :integer 1)
(:max-vertex-uniform-vectors :integer 1)
(:max-vertex-uniform-blocks :integer 1)
(:max-vertex-output-components :integer 1)
(:max-vertex-texture-image-units :integer 1)
(:max-vertex-atomic-counter-buffers :integer 1)
(:max-vertex-atomic-counters :integer 1)
(:max-vertex-shader-storage-blocks :integer 1)
;; 6.66
(:max-tess-gen-level :integer 1)
(:max-patch-vertices :integer 1)
(:max-tess-control-uniform-components :integer 1)
(:max-tess-evaluation-uniform-components :integer 1)
(:max-tess-control-texture-image-units :integer 1)
(:max-tess-evaluation-texture-image-units :integer 1)
(:max-tess-control-output-components :integer 1)
(:max-tess-patch-components :integer 1)
(:max-tess-control-total-output-components :integer 1)
(:max-tess-evaluation-output-components :integer 1)
(:max-tess-control-input-components :integer 1)
(:max-tess-evaluation-input-components :integer 1)
(:max-tess-control-uniform-blocks :integer 1)
(:max-tess-evaluation-uniform-blocks :integer 1)
(:max-tess-control-atomic-counter-buffers :integer 1)
(:max-tess-evaluation-atomic-counter-buffers :integer 1)
(:max-tess-control-atomic-counters :integer 1)
(:max-tess-evaluation-atomic-counters :integer 1)
(:max-tess-control-shader-storage-blocks :integer 1)
(:max-tess-evaluation-shader-storage-blocks :integer 1)
;; 6.67
(:max-geometry-uniform-components :integer 1)
(:max-geometry-uniform-blocks :integer 1)
(:max-geometry-input-components :integer 1)
(:max-geometry-output-components :integer 1)
(:max-geometry-output-vertices :integer 1)
(:max-geometry-total-output-components :integer 1)
(:max-geometry-texture-image-units :integer 1)
(:max-geometry-shader-invocations :integer 1)
(:max-vertex-streams :integer 1)
(:max-geometry-atomic-counter-buffers :integer 1)
(:max-geometry-atomic-counters :integer 1)
(:max-geometry-shader-storage-blocks :integer 1)
;; 6.68
(:max-fragment-uniform-components :integer 1)
(:max-fragment-uniform-vectors :integer 1)
(:max-fragment-uniform-blocks :integer 1)
(:max-fragment-input-components :integer 1)
(:max-texture-image-units :integer 1)
(:min-program-texture-gather-offset :integer 1)
(:max-program-texture-gather-offset :integer 1)
(:max-texture-units :integer 1)
(:max-texture-coords :integer 1)
(:max-fragment-atomic-counter-buffers :integer 1)
(:max-fragment-atomic-counters :integer 1)
(:max-fragment-shader-storage-blocks :integer 1)
;; 6.69
(:min-program-texel-offset :integer 1)
(:max-program-texel-offset :integer 1)
(:max-uniform-buffer-bindings :integer 1)
(:max-uniform-block-size :integer 1)
(:uniform-buffer-offset-alignment :integer 1)
(:max-combined-uniform-blocks :integer 1)
(:max-varying-components :integer 1)
(:max-varying-vectors :integer 1)
(:max-combined-texture-image-units :integer 1)
(:max-subroutines :integer 1)
(:max-subroutine-uniform-locations :integer 1)
(:max-uniform-locations :integer 1)
(:max-atomic-counter-buffer-bindings :integer 1)
(:max-atomic-counter-buffer-size :integer 1)
(:max-combined-atomic-counter-buffers :integer 1)
(:max-combined-atomic-counters :integer 1)
(:max-shader-storage-buffer-bindings :integer 1)
(:max-shader-storage-block-size :integer64 1)
(:max-combined-shader-storage-blocks :integer 1)
(:shader-storage-buffer-offset-alignment :integer 1)
;; 6.70
(:max-image-units :integer 1)
(:max-combined-shader-output-resources :integer 1)
(:max-combined-image-units-and-fragment-outputs :integer 1)
(:max-image-samples :integer 1)
(:max-vertex-image-uniforms :integer 1)
(:max-tess-control-image-uniforms :integer 1)
(:max-tess-evaluation-image-uniforms :integer 1)
(:max-geometry-image-uniforms :integer 1)
(:max-fragment-image-uniforms :integer 1)
(:max-combined-image-uniforms :integer 1)
(:max-combined-vertex-uniform-components :integer 1)
(:max-combined-geometry-uniform-components :integer 1)
(:max-combined-tess-control-uniform-components :integer 1)
(:max-combined-tess-evaluation-uniform-components :integer 1)
(:max-combined-fragment-uniform-components :integer 1)
;; 6.71
(:max-sample-mask-words :integer 1)
(:max-samples :integer 1)
(:max-color-texture-samples :integer 1)
(:max-depth-texture-samples :integer 1)
(:max-integer-samples :integer 1)
(:quads-follow-provoking-vertex-convention :boolean 1)
;; (:query-counter-bits :... 1) ;; %gl:get-query-iv
(:max-server-wait-timeout :integer64 1)
(:min-fragment-interpolation-offset :float 1)
(:max-fragment-interpolation-offset :float 1)
(:fragment-interpolation-offset-bits :integer 1)
;; 6.72
;; get-internal-format-iv
;; 6.73
(:max-transform-feedback-interleaved-components :integer 1)
(:max-transform-feedback-separate-attribs :integer 1)
(:max-transform-feedback-separate-components :integer 1)
(:max-transform-feedback-buffers :integer 1)
;; 6.74
(:aux-buffers :integer 1)
(:max-draw-buffers :integer 1)
(:max-dual-source-draw-buffers :integer 1)
(:rgba-mode :boolean 1)
(:index-mode :boolean 1)
(:doublebuffer :boolean 1)
(:stereo :boolean 1)
(:sample-buffers :integer 1)
(:samples :integer 1)
(:sample-position :multisample-i 2 :samples)
(:max-color-attachments :integer 1)
(:red-bits :integer 1)
(:green-bits :integer 1)
(:blue-bits :integer 1)
(:alpha-bits :integer 1)
(:index-bits :integer 1)
(:depth-bits :integer 1)
(:stencil-bits :integer 1)
(:accum-red-bits :integer 1)
(:accum-green-bits :integer 1)
(:accum-blue-bits :integer 1)
(:accum-alpha-bits :integer 1)
(:implementation-color-read-type :enum 1)
(:implementation-color-read-format :enum 1)
;; 6.75
(:list-base :integer 1)
(:list-index :integer 1)
(:list-mode :enum 1)
(:attrib-stack-depth :integer 1)
(:client-attrib-stack-depth :integer 1)
(:name-stack-depth :integer 1)
(:render-mode :enum 1)
(:selection-buffer-pointer :pointer 1)
(:selection-buffer-size :integer 1)
(:feedback-buffer-pointer :pointer 1)
(:feedback-buffer-size :integer 1)
(:feedback-buffer-type :enum 1)
(:error :error 1)
;; getQueryiv
(:copy-read-buffer :integer 1)
(:copy-write-buffer :integer 1)
(:texture-cube-map-seamless :enable 1)
;; #15 ARB_vertex_blend has state, but is ancient, skipping for now...
;; #26 ARB_vertex_program, also ancient...
;; #39 ARB_color_buffer_float
(:rgba-float-mode-arb :boolean 1)
;; #51 ARB_texture_buffer_object core in 3.1
(:texture-buffer-data-store-binding-arb :integer 1) ;; uses get-tex-level-parameter in core version
(:texture-buffer-format-arb :enum 1)
(:texture-buffer-arb :integer 1)
;; #104 ARB_debug_output
;; (probably requires a debug context to get support for extension)
(:debug-callback-function-arb :pointer 1)
(:debug-callback-user-param-arb :pointer 1)
(:debug-logged-messages-arb :integer 1)
(:debug-next-logged-message-length-arb :integer 1)
(:debug-output-synchronous-arb :enable 1)
(:max-debug-message-length-arb :integer 1)
(:max-debug-logged-messages-arb :integer 1)
;; #105 ARB_robustness
(:reset-notification-strategy-arb :enum 1)
;; 4.3 - table 23.61 / 4.5 - table 23.74
(:max-compute-work-group-count :integer-i 3)
(:max-compute-work-group-size :integer-i 3)
(:max-compute-work-group-invocations :integer 1) ;; not in .spec files?
(:max-compute-local-invocations :integer 1) ;; not documented?
(:max-compute-uniform-blocks :integer 1)
(:max-compute-texture-image-units :integer 1)
(:max-compute-atomic-counter-buffers :integer 1)
(:max-compute-atomic-counters :integer 1)
(:max-compute-shared-memory-size :integer 1)
(:max-compute-uniform-components :integer 1)
(:max-compute-image-uniforms :integer 1)
(:max-combined-compute-uniform-components :integer 1)
(:max-compute-shader-storage-blocks :integer 1)
;; 4.5 - table 23.80
(:max-debug-message-length :integer 1)
(:max-debug-logged-messages :integer 1)
(:max-debug-group-stack-depth :integer 1)
(:max-label-length :integer 1)
;; 4.5 - table 23.81
(:max-framebuffer-width :integer 1)
(:max-framebuffer-height :integer 1)
(:max-framebuffer-layers :integer 1)
(:max-framebuffer-samples :integer 1)
;; (:query-counter-bits :query ?) getQueryiv
;;
(:timestamp :integer64 1)
))
;;; Return the default array size for a state query enum.
(defun query-enum-size (value)
(let ((count (or (third (assoc value *query-enum-sizes*))
(error "Unknown query enum: ~A" value))))
(if (keywordp count)
(get-integer count 1)
count)))
;;; Define a query function NAME that calls the OpenGL function FN,
;;; passing an array of foreign type TYPE. The elements of the
;;; foreign array are converted back to Lisp values by first
;;; dereferencing the buffer.
(defmacro define-query-function (name fn type &optional (lisp-type t))
`(defun ,name (value &optional (count (query-enum-size value)))
(declare (fixnum count))
(with-foreign-object (buf ',type count)
(,fn value buf)
(if (> count 1)
(let ((result (make-array count :element-type ',lisp-type)))
(dotimes (i count)
(setf (aref result i) (mem-aref buf ',type i)))
result)
(mem-ref buf ',type)))))
;;; Define query functions for the basic types.
(define-query-function get-boolean %gl:get-boolean-v %gl:boolean)
(define-query-function get-integer %gl:get-integer-v %gl:int)
(define-query-function get-integer-64 %gl:get-integer-64-v %gl:int64)
(define-query-function get-float %gl:get-float-v %gl:float single-float)
(define-query-function get-double %gl:get-double-v %gl:double double-float)
(define-query-function get-pointer %gl:get-pointer-v :pointer)
;;; Define an indexed query function NAME that calls the OpenGL
;;; function FN, passing an array of foreign type TYPE. The elements
;;; of the foreign array are converted back to Lisp values by first
;;; dereferencing the buffer.
(defmacro define-indexed-query-function (name fn type &optional (lisp-type t))
`(defun ,name (value index &optional (count (query-enum-size value)))
(declare (fixnum count))
(with-foreign-object (buf ',type count)
(,fn value index buf)
(if (> count 1)
(let ((result (make-array count :element-type ',lisp-type)))
(dotimes (i count)
(setf (aref result i) (mem-aref buf ',type i)))
result)
(mem-ref buf ',type)))))
;;; Define query functions for the basic types.
;;; fixme: should these be named get-*-indexed instead of get-*-i?
(define-indexed-query-function get-boolean-i %gl:get-boolean-i-v %gl:boolean)
(define-indexed-query-function get-integer-i %gl:get-integer-i-v %gl:int)
(define-indexed-query-function get-integer-64-i %gl:get-integer-64-i-v %gl:int64)
(define-indexed-query-function get-float-i %gl:get-float-i-v %gl:float single-float)
(define-indexed-query-function get-double-i %gl:get-double-i-v %gl:double double-float)
(defmacro define-vertex-attrib-query-function (name fn type &optional (lisp-type t))
`(defun ,name (index pname &optional (count (query-enum-size pname)))
(declare (fixnum count))
(with-foreign-object (buf ',type count)
(,fn index pname buf)
(if (> count 1)
(let ((result (make-array count :element-type ',lisp-type)))
(dotimes (i count)
(setf (aref result i) (mem-aref buf ',type i)))
result)
(mem-ref buf ',type)))))
(define-vertex-attrib-query-function get-vertex-attrib-boolean
%gl:get-vertex-attrib-iv %gl:boolean)
(define-vertex-attrib-query-function get-vertex-attrib-integer
%gl:get-vertex-attrib-iv %gl:int)
(define-vertex-attrib-query-function get-vertex-attrib-float
%gl:get-vertex-attrib-fv %gl:float single-float)
(define-vertex-attrib-query-function get-vertex-attrib-pointer
%gl:get-vertex-attrib-pointer-v :pointer)
(defun try-to-parse-enum (value)
(or (foreign-enum-keyword '%gl:enum value :errorp nil)
value))
;;; Wrapper around GET-INTEGER when the result should be interpreted
;;; as an enumerated constant.
(defun get-enum (value &optional (count (query-enum-size value)))
(let ((result (get-integer value count)))
(if (vectorp result)
(map 'vector #'try-to-parse-enum result)
(try-to-parse-enum result))))
(defun get-enum-i (value index &optional (count (query-enum-size value)))
(let ((result (get-integer-i value index count)))
(if (vectorp result)
(map 'vector #'try-to-parse-enum result)
(try-to-parse-enum result))))
(defun get-vertex-attrib-enum (index pname
&optional (count (query-enum-size pname)))
(let ((result (get-vertex-attrib-integer index pname count)))
(if (vectorp result)
(map 'vector #'try-to-parse-enum result)
(try-to-parse-enum result))))
(import-export %gl:get-string)
(import-export %gl:get-string-i)
(defun get-clip-plane (plane)
(with-foreign-object (buf '%gl:double 4)
(%gl:get-clip-plane plane buf)
(let ((result (make-array 4 :element-type 'double-float)))
(dotimes (i 4)
(setf (aref result i) (mem-aref buf '%gl:double i)))
result)))
(defun get-multisample (pname index)
(with-foreign-object (buf '%gl:float 2)
(%gl:get-multisample-fv pname index buf)
(let ((result (make-array 2 :element-type 'single-float)))
(dotimes (i 2)
(setf (aref result i) (mem-aref buf '%gl:float i)))
result)))
;;; generic get that handles type and number of values for known enums
;;; fixme: better name?
(defun get* (name &optional (index 0 indexp))
(destructuring-bind (enum type size &optional max)
(assoc name *query-enum-sizes*)
(declare (ignore enum max))
(when (keywordp size)
(setf size (get-integer size 1)))
(when (plusp size)
(ecase type
(:boolean (get-boolean name size))
(:integer (get-integer name size))
(:integer64 (get-integer-64 name size))
(:float (get-float name size))
(:enable (enabledp name))
(:enum (get-enum name size))
(:string (get-string name))
(:pointer (get-pointer name size))
(:error (get-error))
(:clip-plane (get-clip-plane name))
;; queries that can be used indexed or unindexed
;; (indexed version usually needs newer GL version, so
;; don't want to just call the indexed query with 0
;; when no index was provided)
(:integer/i (if indexp
(get-integer-i name index size)
(get-integer name size)))
(:integer64/i (if indexp
(get-integer-64-i name index size)
(get-integer-64 name size)))
(:float/i (if indexp
(get-float-i name index size)
(get-float name size)))
(:enable/i (if indexp
(enabledp-i name index)
(enabledp name)))
(:enum/i (if indexp
(get-enum-i name index size)
(get-enum name size)))
(:boolean/i (if indexp
(get-boolean-i name index size)
(get-boolean name size)))
(:extensions/i (if indexp
(get-string-i name index)
(get-string name)))
(:draw-buffer/i
(if indexp
(get-enum (+ (foreign-enum-value '%gl:enum :draw-buffer0) index)
size)
(get-enum name size)))
;; queries that require an index (but default to 0)
(:integer-i (get-integer-i name index size))
(:integer64-i (get-integer-64-i name index size))
(:enum-i (get-enum-i name index size))
(:boolean-i (get-boolean-i name index size))
(:string-i (get-string-i name index))
(:multisample-i (get-multisample name index))
(:vertex-attrib-integer (get-vertex-attrib-integer index name size))
(:vertex-attrib-enum (get-vertex-attrib-enum index name size))
(:vertex-attrib-boolean (get-vertex-attrib-boolean index name size))
(:vertex-attrib-pointer (get-vertex-attrib-pointer index name size))
(:vertex-attrib-float (get-vertex-attrib-float index name size))
;; some fake 'indexed' queries for queries that usually use a set of
;; :foo0 .. :fooN enums, which can also be used as :foo0 + N
(:clip-plane-i
(get-clip-plane (+ (foreign-enum-value '%gl:enum :clip-plane0)
index)))
(:clip-distance-i
(enabledp (+ (foreign-enum-value '%gl:enum :clip-distance0) index))
size)
(:light-enable-i (enabledp (+ (foreign-enum-value '%gl:enum :light0)
index))
size)))))
;;; compiler macro to open code values for enums known at compile time
(define-compiler-macro get* (&whole form name &optional (index 0 indexp))
(if (and (constantp name) (keywordp name)
(assoc name *query-enum-sizes*))
(destructuring-bind (enum type size &optional max)
(assoc name *query-enum-sizes*)
(declare (ignore enum max))
`(let ((size ,(if (keywordp size) `(get-integer ,size 1) size)))
(declare (ignorable size))
;; fixme: get rid of this duplicated code somehow?
,(ecase type
(:boolean `(get-boolean ,name size))
(:integer `(get-integer ,name size))
(:integer64 `(get-integer-64 ,name size))
(:float `(get-float ,name size))
(:enable `(enabledp ,name))
(:enum `(get-enum ,name size))
(:string `(get-string ,name))
(:pointer `(get-pointer ,name size))
(:error `(get-error))
(:clip-plane `(get-clip-plane ,name))
;; queries that can be used indexed or unindexed
;; (indexed version usually needs newer GL version, so
;; don't want to just call the indexed query with 0
;; when no index was provided)
(:integer/i (if indexp
`(get-integer-i name ,index size)
`(get-integer ,name size)))
(:integer64/i (if indexp
`(get-integer-64-i ,name ,index size)
`(get-integer-64 ,name size)))
(:float/i (if indexp
`(get-float-i ,name ,index size)
`(get-float ,name size)))
(:enable/i (if indexp
`(enabledp-i ,name ,index)
`(enabledp ,name)))
(:enum/i (if indexp
`(get-enum-i ,name ,index size)
`(get-enum ,name size)))
(:boolean/i (if indexp
`(get-boolean-i ,name ,index size)
`(get-boolean ,name size)))
(:extensions/i (if indexp
`(get-string-i ,name ,index)
`(get-string ,name)))
(:draw-buffer/i
(if indexp
`(get-enum `(+ ,(foreign-enum-value '%gl:enum :draw-buffer0) index)
size)
`(get-enum ,name size)))
;; queries that require an index (but default to 0)
(:integer-i `(get-integer-i ,name ,index size))
(:integer64-i `(get-integer-64-i ,name ,index size))
(:enum-i `(get-enum-i ,name ,index size))
(:boolean-i `(get-boolean-i ,name ,index size))
(:string-i `(get-string-i ,name ,index))
(:multisample-i `(get-multisample ,name ,index))
(:vertex-attrib-integer `(get-vertex-attrib-integer ,index ,name size))
(:vertex-attrib-enum `(get-vertex-attrib-enum ,index ,name size))
(:vertex-attrib-boolean `(get-vertex-attrib-boolean ,index ,name size))
(:vertex-attrib-pointer `(get-vertex-attrib-pointer ,index ,name size))
(:vertex-attrib-float `(get-vertex-attrib-float ,index ,name size))
;; some fake 'indexed' queries for queries that usually use a set of
;; :foo0 .. :fooN enums, which can also be used as :foo0 + N
(:clip-plane-i
`(get-clip-plane (+ ,(foreign-enum-value '%gl:enum :clip-plane0)
,index)))
(:clip-distance-i
`(enabledp (+ ,(foreign-enum-value '%gl:enum :clip-distance0)
,index))
size)
(:light-enable-i `(enabledp (+ ,(foreign-enum-value '%gl:enum :light0)
,index))
size))))
form))
;;; FIXME: Enable/Disable do not belong here, but I can't find the proper
;;; place to put them. They appear the first time in 2.11.3, but that's
;;; about normal transformations.
;; external
(defun enable (&rest caps)
(declare (dynamic-extent caps))
(dolist (cap caps)
(%gl:enable cap)))
(define-compiler-macro enable (&rest caps)
`(progn
,@(loop for cap in caps
for v = (when (keywordp cap)
(foreign-enum-value '%gl:enum cap :errorp nil))
when v collect `(%gl:enable ,v)
else collect `(%gl:enable ,cap))))
;; external
(defun disable (&rest caps)
(declare (dynamic-extent caps))
(dolist (cap caps)
(%gl:disable cap)))
(define-compiler-macro disable (&rest caps)
`(progn
,@(loop for cap in caps
for v = (when (keywordp cap)
(foreign-enum-value '%gl:enum cap :errorp nil))
when v collect `(%gl:disable ,v)
else collect `(%gl:disable ,cap))))
;; external
(definline enabledp (cap)
(%gl:is-enabled cap))
(definline enabledp-i (cap index)
(%gl:is-enabled-i cap index))
;;; 6.1.11 Pointer and String Queries
;;; FIXME: missing glGetPointer
;(import-export %gl:get-string)
;; external
(defun gl3-major-version ()
(get-integer :major-version))
;; external
(defun gl3-minor-version ()
(get-integer :minor-version))
(defun parse-gl-version-string-values (string)
;; major version is integer value up to first #\.
;; minor version is integer from first #\. to a #\. or #\space
(let ((dot (position #\. string)))
(values
(values (parse-integer string :end dot :junk-allowed t)) ; major
(if dot ; minor
(values (parse-integer string :start (1+ dot) :junk-allowed t))
0))))
(defun parse-gl-version-string-float (string)
(let* ((dot nil)
(end (position-if-not (lambda (c) (or (digit-char-p c)
(and (char= c #\.)
(not dot)
(setf dot t))))
string)))
(values (read-from-string string nil 0.0 :end end))))
;; external
(defun gl-version ()
(parse-gl-version-string-float (get-string :version)))
;; external
(defun major-version ()
(values (parse-gl-version-string-values (get-string :version))))
;; external
(defun minor-version ()
(nth-value 1 (parse-gl-version-string-values (get-string :version))))
;; external
(defun glsl-version ()
(parse-gl-version-string-float (get-string :shading-language-version)))
;; external
(defun glsl-major-version ()
(values (parse-gl-version-string-values (get-string :shading-language-version))))
;; external
(defun glsl-minor-version ()
(nth-value 1 (parse-gl-version-string-values (get-string :shading-language-version))))
;; external
(defun gl3-extension-present-p (name)
"Check for presence of extension NAME useing only non-deprecated gl3
functionality. Currently not implemented for speed, so don't use in
inner loops."
(loop for i below (get-integer :num-extensions)
when (string= name (%gl:get-string-i :extensions i))
return t
finally (return nil)))
;; external
(defun extension-present-p (name)
"Check for presence of extension NAME in gl extension list, not
currently implemented for speed, so avoid in inner loops"
;; gl3 deprecates the :extensions argument to get-string, so we
;; use the new gl3 methods in a gl3+ context
(if (>= (major-version) 3)
(gl3-extension-present-p name)
;; we can't just search here, since we don't want to match substrings
;; it would possibly be cleaner to split up the extension list and
;; cache it if there is a good way to tell when to invalidate the
;; cache
(unless (find #\space name)
(let* ((extension-string (get-string :extensions))
(start (search name extension-string))
(end (when start (+ start (length name)))))
(and start
(or (zerop start)
(char= #\space (char extension-string (1- start))))
(or (= end (length extension-string))
(and (< end (length extension-string))
(char= #\space (char extension-string end)))))))))
;;; 6.1.14 Shader and Program Queries
(import-export %gl:is-shader)
(define-get-function get-shader-aux (shader pname)
(%gl:get-shader-iv :int int))
(defun get-shader (shader pname)
(case pname
((:delete-status :compile-status)
;; Return a boolean for these.
(plusp (get-shader-aux shader pname :int)))
(otherwise
(get-shader-aux shader pname :int))))
(import-export %gl:is-program)
(define-get-function get-program-aux (program pname)
(%gl:get-program-iv :int int))
(defun get-program (program pname)
(case pname
((:delete-status :link-status :validate-status)
;; Return a boolean for these.
(plusp (get-program-aux program pname :int)))
(otherwise
(get-program-aux program pname :int))))
(define-get-function get-active-uniform-block-aux
(program uniformblockindex pname)
(%gl:get-active-uniform-block-iv :int int))
(defun get-active-uniform-block (program block-index pname)
(case pname
((:uniform-block-referenced-by-vertex-shader
:uniform-block-referenced-by-fragment-shader
:uniform-block-referenced-by-geometry-shader
:uniform-block-referenced-by-tess-control-shader
:uniform-block-referenced-by-tess-evaluation-shader)
(plusp (get-active-uniform-block-aux program block-index pname :int)))
((:uniform-block-active-uniform-indices)
(let ((i-count (get-active-uniform-block-aux
program block-index :uniform-block-active-uniforms
:int)))
(ensure-list (get-active-uniform-block-aux program block-index
pname :int i-count))))
(otherwise
(get-active-uniform-block-aux program block-index pname :int))))
(defun get-active-uniform-block-name (program block-index)
(let ((name-length (get-active-uniform-block program block-index
:uniform-block-name-length)))
(with-foreign-objects ((characters-written '%gl:sizei)
(name '%gl:char name-length))
(%gl:get-active-uniform-block-name program block-index name-length
characters-written name)
(when (< 0 (mem-ref characters-written '%gl:sizei))
(foreign-string-to-lisp name)))))
(defun get-attached-shaders (program)
"Returns a list of the shaders attached to PROGRAM"
(let ((max-shaders (get-program program :attached-shaders)))
(with-foreign-object (shaders '%gl:uint max-shaders)
(%gl:get-attached-shaders program max-shaders (null-pointer) shaders)
(loop for i below max-shaders
collecting (mem-aref shaders '%gl:uint i)))))
(defun get-shader-info-log (shader)
"Returns as a string the entire info log for SHADER"
(let ((info-log-length (get-shader shader :info-log-length)))
(if (zerop info-log-length)
""
(with-foreign-object (info-log '%gl:char info-log-length)
(%gl:get-shader-info-log shader info-log-length (null-pointer)
info-log)
(foreign-string-to-lisp info-log)))))
(defun get-program-info-log (program)
"Returns as a string the entire info log for PROGRAM"
(let ((info-log-length (get-program program :info-log-length)))
(if (zerop info-log-length)
""
(with-foreign-object (info-log '%gl:char info-log-length)
(%gl:get-program-info-log program info-log-length (null-pointer)
info-log)
(foreign-string-to-lisp info-log)))))
(defun get-shader-source (shader)
"Returns as a string the entire source of SHADER"
(let ((source-length (get-shader shader :shader-source-length)))
(if (zerop source-length)
""
(with-foreign-object (source '%gl:char source-length)
(%gl:get-shader-source shader source-length (null-pointer) source)
(foreign-string-to-lisp source)))))
;;; 6.1.15 Saving and Restoring State
;;not used anymore?
;;(defun make-bitfield (enum-name attributes)
;; (apply #'logior 0 (mapcar (lambda (x)
;; (foreign-enum-value enum-name x))
;; attributes)))
;; external
(defun push-attrib (&rest attributes)
(declare (dynamic-extent attributes))
(%gl:push-attrib attributes))
(define-compiler-macro push-attrib (&whole form &rest attributes)
(if (every #'keywordp attributes)
`(%gl:push-attrib ,(foreign-bitfield-value '%gl:AttribMask attributes))
form))
(import-export %gl:pop-attrib)
(defmacro with-pushed-attrib ((&rest attributes) &body body)
`(progn
(push-attrib ,@attributes)
(multiple-value-prog1 (progn ,@body)
(pop-attrib))))
;; external
(defun push-client-attrib (&rest attributes)
(declare (dynamic-extent attributes))
(%gl:push-client-attrib attributes))
(define-compiler-macro push-client-attrib (&whole form &rest attributes)
(if (every #'keywordp attributes)
`(%gl:push-client-attrib ,(foreign-bitfield-value '%gl:ClientAttribMask attributes))
form))
(import-export %gl:pop-client-attrib)
(defmacro with-pushed-client-attrib ((&rest attributes) &body body)
`(progn
(push-client-attrib ,attributes)
(multiple-value-prog1 (progn ,@body)
(pop-client-attrib))))
;;; not sure these are actually useful, so not exported for now...
(defmacro features-present-p (&body options)
"Returns true if any of the forms in body are true after substitution for
:major :minor as major and minor version, and \"ARB_foo\" for presence of
named GL extension
ex: (features-present-p (> :major 3) (and (> :major 2) \"ARB_texture_rg\"))"
(labels ((build-tests (list)
(mapcar (lambda (x)
(cond
((stringp x) `(extension-present-p ,x))
((eq x :major-version) `(major-version))
((eq x :minor-version) `(minor-version))
((eq x :gl-version) `(gl-version))
((eq x :glsl-version) `(glsl-version))
((listp x) (build-tests x))
(t x)))
list)))
`(or ,@(build-tests options))))
;;; throw an error if gl version isn't high enough, or required
;;; extensions are missing
;;; fixme: need better error msg, either as argument, or from parsing options?
(defmacro ensure-features (&body options)
`(unless (features-present-p ,@options)
(error "GL implementation doesn't meet minimum requirements, need~% ~s" '(or ,@options))))
;;(features-present-p (> :major-version 3) (and (> :major-version 2) "ARB_texture_rg"))
| 55,118 | Common Lisp | .lisp | 1,301 | 35.825519 | 103 | 0.645444 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 273a3bfd18718b7a1517e94b7fc9022d330adba9a9675eecbc5c0fb38f46963e | 30,590 | [
268466
] |
30,591 | funcs-gl-gles1-gles2.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/funcs-gl-gles1-gles2.lisp | ;;; this file is automatically generated, do not edit
;;; generated from files with the following copyright:
;;;
;;; Copyright (c) 2013-2015 The Khronos Group Inc.
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining a
;;; copy of this software and/or associated documentation files (the
;;; "Materials"), to deal in the Materials without restriction, including
;;; without limitation the rights to use, copy, modify, merge, publish,
;;; distribute, sublicense, and/or sell copies of the Materials, and to
;;; permit persons to whom the Materials are furnished to do so, subject to
;;; the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be included
;;; in all copies or substantial portions of the Materials.
;;;
;;; THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
;;; IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
;;; CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
;;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
;;; MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
;;;
;;; ------------------------------------------------------------------------
(in-package #:cl-opengl-bindings)
;;; generated 2015-08-30T01:01:50Z
;;; from gl.xml @ svn rev 31811, 2015-08-10T07:01:11.860488Z
(defglfun ("glCullFace" cull-face) :void
(mode enum))
(defglfun ("glFrontFace" front-face) :void
(mode enum))
(defglfun ("glHint" hint) :void
(target enum)
(mode enum))
(defglfun ("glLineWidth" line-width) :void
(width float))
(defglfun ("glScissor" scissor) :void
(x int)
(y int)
(width sizei)
(height sizei))
(defglfun ("glTexParameterf" tex-parameter-f) :void
(target enum)
(pname enum)
(param float))
(defglfun ("glTexParameterfv" tex-parameter-fv) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglfun ("glTexParameteri" tex-parameter-i) :void
(target enum)
(pname enum)
(param int))
(defglfun ("glTexParameteriv" tex-parameter-iv) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglfun ("glTexImage2D" tex-image-2d) :void
(target enum)
(level int)
(internalformat int)
(width sizei)
(height sizei)
(border int)
(format enum)
(type enum)
(pixels offset-or-pointer))
(defglfun ("glClear" clear) :void
(mask ClearBufferMask))
(defglfun ("glClearColor" clear-color) :void
(red float)
(green float)
(blue float)
(alpha float))
(defglfun ("glClearStencil" clear-stencil) :void
(s int))
(defglfun ("glStencilMask" stencil-mask) :void
(mask uint))
(defglfun ("glColorMask" color-mask) :void
(red boolean)
(green boolean)
(blue boolean)
(alpha boolean))
(defglfun ("glDepthMask" depth-mask) :void
(flag boolean))
(defglfun ("glDisable" disable) :void
(cap enum))
(defglfun ("glEnable" enable) :void
(cap enum))
(defglfun ("glFinish" finish) :void)
(defglfun ("glFlush" flush) :void)
(defglfun ("glBlendFunc" blend-func) :void
(sfactor enum)
(dfactor enum))
(defglfun ("glStencilFunc" stencil-func) :void
(func enum)
(ref int)
(mask uint))
(defglfun ("glStencilOp" stencil-op) :void
(fail enum)
(zfail enum)
(zpass enum))
(defglfun ("glDepthFunc" depth-func) :void
(func enum))
(defglfun ("glPixelStorei" pixel-store-i) :void
(pname enum)
(param int))
(defglfun ("glReadPixels" read-pixels) :void
(x int)
(y int)
(width sizei)
(height sizei)
(format enum)
(type enum)
(pixels offset-or-pointer))
(defglfun ("glGetBooleanv" get-boolean-v) :void
(pname enum)
(data (:pointer boolean)))
(defglfun ("glGetError" get-error) enum)
(defglfun ("glGetFloatv" get-float-v) :void
(pname enum)
(data (:pointer float)))
(defglfun ("glGetIntegerv" get-integer-v) :void
(pname enum)
(data (:pointer int)))
(defglfun ("glGetString" get-string) string
(name enum))
(defglfun ("glGetTexParameterfv" get-tex-parameter-fv) :void
(target enum)
(pname enum)
(params (:pointer float)))
(defglfun ("glGetTexParameteriv" get-tex-parameter-iv) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglfun ("glIsEnabled" is-enabled) boolean
(cap enum))
(defglfun ("glViewport" viewport) :void
(x int)
(y int)
(width sizei)
(height sizei))
(defglfun ("glDrawArrays" draw-arrays) :void
(mode enum)
(first int)
(count sizei))
(defglfun ("glDrawElements" draw-elements) :void
(mode enum)
(count sizei)
(type enum)
(indices offset-or-pointer))
(defglfun ("glPolygonOffset" polygon-offset) :void
(factor float)
(units float))
(defglfun ("glCopyTexImage2D" copy-tex-image-2d) :void
(target enum)
(level int)
(internalformat enum)
(x int)
(y int)
(width sizei)
(height sizei)
(border int))
(defglfun ("glCopyTexSubImage2D" copy-tex-sub-image-2d) :void
(target enum)
(level int)
(xoffset int)
(yoffset int)
(x int)
(y int)
(width sizei)
(height sizei))
(defglfun ("glTexSubImage2D" tex-sub-image-2d) :void
(target enum)
(level int)
(xoffset int)
(yoffset int)
(width sizei)
(height sizei)
(format enum)
(type enum)
(pixels offset-or-pointer))
(defglfun ("glBindTexture" bind-texture) :void
(target enum)
(texture uint))
(defglfun ("glDeleteTextures" delete-textures) :void
(n sizei)
(textures (:pointer uint)))
(defglfun ("glGenTextures" gen-textures) :void
(n sizei)
(textures (:pointer uint)))
(defglfun ("glIsTexture" is-texture) boolean
(texture uint))
(defglextfun ("glActiveTexture" active-texture) :void
(texture enum))
(defglextfun ("glSampleCoverage" sample-coverage) :void
(value float)
(invert boolean))
(defglextfun ("glCompressedTexImage2D" compressed-tex-image-2d) :void
(target enum)
(level int)
(internalformat enum)
(width sizei)
(height sizei)
(border int)
(imageSize sizei)
(data offset-or-pointer))
(defglextfun ("glCompressedTexSubImage2D" compressed-tex-sub-image-2d) :void
(target enum)
(level int)
(xoffset int)
(yoffset int)
(width sizei)
(height sizei)
(format enum)
(imageSize sizei)
(data offset-or-pointer))
(defglextfun ("glBindBuffer" bind-buffer) :void
(target enum)
(buffer uint))
(defglextfun ("glDeleteBuffers" delete-buffers) :void
(n sizei)
(buffers (:pointer uint)))
(defglextfun ("glGenBuffers" gen-buffers) :void
(n sizei)
(buffers (:pointer uint)))
(defglextfun ("glIsBuffer" is-buffer) boolean
(buffer uint))
(defglextfun ("glBufferData" buffer-data) :void
(target enum)
(size sizeiptr)
(data (:pointer :void))
(usage enum))
(defglextfun ("glBufferSubData" buffer-sub-data) :void
(target enum)
(offset intptr)
(size sizeiptr)
(data (:pointer :void)))
(defglextfun ("glGetBufferParameteriv" get-buffer-parameter-iv) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glBlendEquationEXT" blend-equation-ext) :void
(mode enum))
(defglextfun ("glTextureStorage1DEXT" texture-storage-1d-ext) :void
(texture uint)
(target enum)
(levels sizei)
(internalformat enum)
(width sizei))
(defglextfun ("glTextureStorage2DEXT" texture-storage-2d-ext) :void
(texture uint)
(target enum)
(levels sizei)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glTextureStorage3DEXT" texture-storage-3d-ext) :void
(texture uint)
(target enum)
(levels sizei)
(internalformat enum)
(width sizei)
(height sizei)
(depth sizei))
(defglextfun ("glRenderbufferStorageMultisampleEXT" renderbuffer-storage-multisample-ext) :void
(target enum)
(samples sizei)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glMultiDrawArraysEXT" multi-draw-arrays-ext) :void
(mode enum)
(first (:pointer int))
(count (:pointer sizei))
(primcount sizei))
(defglextfun ("glMultiDrawElementsEXT" multi-draw-elements-ext) :void
(mode enum)
(count (:pointer sizei))
(type enum)
(indices (:pointer (:pointer :void)))
(primcount sizei))
(defglextfun ("glDeleteFencesNV" delete-fences-nv) :void
(n sizei)
(fences (:pointer uint)))
(defglextfun ("glGenFencesNV" gen-fences-nv) :void
(n sizei)
(fences (:pointer uint)))
(defglextfun ("glIsFenceNV" is-fence-nv) boolean
(fence uint))
(defglextfun ("glTestFenceNV" test-fence-nv) boolean
(fence uint))
(defglextfun ("glGetFenceivNV" get-fence-iv-nv) :void
(fence uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glFinishFenceNV" finish-fence-nv) :void
(fence uint))
(defglextfun ("glSetFenceNV" set-fence-nv) :void
(fence uint)
(condition enum))
| 8,705 | Common Lisp | .lisp | 302 | 26.231788 | 95 | 0.719808 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 278725a6e0003e65eaabed3b88d5a01aa1c961bf40f1df1bc6abc0b3786cdcb1 | 30,591 | [
243868
] |
30,592 | constants.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/constants.lisp | ;;; this file is automatically generated, do not edit
(in-package #:cl-opengl-bindings)
(defbitfield (AttribMask :unsigned-int)
(:current-bit #x1)
(:current #x1)
(:point-bit #x2)
(:point #x2)
(:line-bit #x4)
(:line #x4)
(:polygon-bit #x8)
(:polygon #x8)
(:polygon-stipple-bit #x10)
(:polygon-stipple #x10)
(:pixel-mode-bit #x20)
(:pixel-mode #x20)
(:lighting-bit #x40)
(:lighting #x40)
(:fog-bit #x80)
(:fog #x80)
(:depth-buffer-bit #x100)
(:depth-buffer #x100)
(:accum-buffer-bit #x200)
(:accum-buffer #x200)
(:stencil-buffer-bit #x400)
(:stencil-buffer #x400)
(:viewport-bit #x800)
(:viewport #x800)
(:transform-bit #x1000)
(:transform #x1000)
(:enable-bit #x2000)
(:enable #x2000)
(:color-buffer-bit #x4000)
(:color-buffer #x4000)
(:hint-bit #x8000)
(:hint #x8000)
(:eval-bit #x10000)
(:eval #x10000)
(:list-bit #x20000)
(:list #x20000)
(:texture-bit #x40000)
(:texture #x40000)
(:scissor-bit #x80000)
(:scissor #x80000)
(:multisample-bit-3dfx #x20000000)
(:multisample-bit-ext #x20000000)
(:multisample-bit-arb #x20000000)
(:multisample-bit #x20000000)
(:multisample #x20000000)
(:all-attrib-bits #xFFFFFFFF)
(:all-attrib #xFFFFFFFF))
(defbitfield (BufferBitQCOM :unsigned-int)
(:color-buffer-bit0-qcom #x1)
(:color-buffer-bit1-qcom #x2)
(:color-buffer-bit2-qcom #x4)
(:color-buffer-bit3-qcom #x8)
(:color-buffer-bit4-qcom #x10)
(:color-buffer-bit5-qcom #x20)
(:color-buffer-bit6-qcom #x40)
(:color-buffer-bit7-qcom #x80)
(:depth-buffer-bit0-qcom #x100)
(:depth-buffer-bit1-qcom #x200)
(:depth-buffer-bit2-qcom #x400)
(:depth-buffer-bit3-qcom #x800)
(:depth-buffer-bit4-qcom #x1000)
(:depth-buffer-bit5-qcom #x2000)
(:depth-buffer-bit6-qcom #x4000)
(:depth-buffer-bit7-qcom #x8000)
(:stencil-buffer-bit0-qcom #x10000)
(:stencil-buffer-bit1-qcom #x20000)
(:stencil-buffer-bit2-qcom #x40000)
(:stencil-buffer-bit3-qcom #x80000)
(:stencil-buffer-bit4-qcom #x100000)
(:stencil-buffer-bit5-qcom #x200000)
(:stencil-buffer-bit6-qcom #x400000)
(:stencil-buffer-bit7-qcom #x800000)
(:multisample-buffer-bit0-qcom #x1000000)
(:multisample-buffer-bit1-qcom #x2000000)
(:multisample-buffer-bit2-qcom #x4000000)
(:multisample-buffer-bit3-qcom #x8000000)
(:multisample-buffer-bit4-qcom #x10000000)
(:multisample-buffer-bit5-qcom #x20000000)
(:multisample-buffer-bit6-qcom #x40000000)
(:multisample-buffer-bit7-qcom #x80000000))
(defbitfield (ClearBufferMask :unsigned-int)
(:depth-buffer-bit #x100)
(:depth-buffer #x100)
(:accum-buffer-bit #x200)
(:accum-buffer #x200)
(:stencil-buffer-bit #x400)
(:stencil-buffer #x400)
(:color-buffer-bit #x4000)
(:color-buffer #x4000)
(:coverage-buffer-bit-nv #x8000))
(defbitfield (ClientAttribMask :unsigned-int)
(:client-pixel-store-bit #x1)
(:client-pixel-store #x1)
(:client-vertex-array-bit #x2)
(:client-vertex-array #x2)
(:client-all-attrib-bits #xFFFFFFFF)
(:client-all-attrib #xFFFFFFFF))
(defbitfield (ContextFlagMask :unsigned-int)
(:context-flag-forward-compatible-bit #x1)
(:context-flag-forward-compatible #x1)
(:context-flag-debug-bit-khr #x2)
(:context-flag-debug-bit #x2)
(:context-flag-debug #x2)
(:context-flag-robust-access-bit-arb #x4)
(:context-flag-robust-access-bit #x4)
(:context-flag-robust-access #x4)
(:context-flag-no-error-bit-khr #x8))
(defbitfield (ContextProfileMask :unsigned-int)
(:context-core-profile-bit #x1)
(:context-core-profile #x1)
(:context-compatibility-profile-bit #x2)
(:context-compatibility-profile #x2))
(defbitfield (FfdMaskSGIX :unsigned-int)
(:texture-deformation-bit-sgix #x1)
(:geometry-deformation-bit-sgix #x2))
(defbitfield (FragmentShaderColorModMaskATI :unsigned-int)
(:comp-bit-ati #x2)
(:negate-bit-ati #x4)
(:bias-bit-ati #x8))
(defbitfield (FragmentShaderDestMaskATI :unsigned-int)
(:red-bit-ati #x1)
(:green-bit-ati #x2)
(:blue-bit-ati #x4))
(defbitfield (FragmentShaderDestModMaskATI :unsigned-int)
(:2x-bit-ati #x1)
(:4x-bit-ati #x2)
(:8x-bit-ati #x4)
(:half-bit-ati #x8)
(:quarter-bit-ati #x10)
(:eighth-bit-ati #x20)
(:saturate-bit-ati #x40))
(defbitfield (MapBufferUsageMask :unsigned-int)
(:map-read-bit-ext #x1)
(:map-read-bit #x1)
(:map-read #x1)
(:map-write-bit-ext #x2)
(:map-write-bit #x2)
(:map-write #x2)
(:map-invalidate-range-bit-ext #x4)
(:map-invalidate-range-bit #x4)
(:map-invalidate-range #x4)
(:map-invalidate-buffer-bit-ext #x8)
(:map-invalidate-buffer-bit #x8)
(:map-invalidate-buffer #x8)
(:map-flush-explicit-bit-ext #x10)
(:map-flush-explicit-bit #x10)
(:map-flush-explicit #x10)
(:map-unsynchronized-bit-ext #x20)
(:map-unsynchronized-bit #x20)
(:map-unsynchronized #x20)
(:map-persistent-bit-ext #x40)
(:map-persistent-bit #x40)
(:map-persistent #x40)
(:map-coherent-bit-ext #x80)
(:map-coherent-bit #x80)
(:map-coherent #x80)
(:dynamic-storage-bit-ext #x100)
(:dynamic-storage-bit #x100)
(:dynamic-storage #x100)
(:client-storage-bit-ext #x200)
(:client-storage-bit #x200)
(:client-storage #x200)
(:sparse-storage-bit-arb #x400))
(defbitfield (MemoryBarrierMask :unsigned-int)
(:vertex-attrib-array-barrier-bit-ext #x1)
(:vertex-attrib-array-barrier-bit #x1)
(:vertex-attrib-array-barrier #x1)
(:element-array-barrier-bit-ext #x2)
(:element-array-barrier-bit #x2)
(:element-array-barrier #x2)
(:uniform-barrier-bit-ext #x4)
(:uniform-barrier-bit #x4)
(:uniform-barrier #x4)
(:texture-fetch-barrier-bit-ext #x8)
(:texture-fetch-barrier-bit #x8)
(:texture-fetch-barrier #x8)
(:shader-global-access-barrier-bit-nv #x10)
(:shader-image-access-barrier-bit-ext #x20)
(:shader-image-access-barrier-bit #x20)
(:shader-image-access-barrier #x20)
(:command-barrier-bit-ext #x40)
(:command-barrier-bit #x40)
(:command-barrier #x40)
(:pixel-buffer-barrier-bit-ext #x80)
(:pixel-buffer-barrier-bit #x80)
(:pixel-buffer-barrier #x80)
(:texture-update-barrier-bit-ext #x100)
(:texture-update-barrier-bit #x100)
(:texture-update-barrier #x100)
(:buffer-update-barrier-bit-ext #x200)
(:buffer-update-barrier-bit #x200)
(:buffer-update-barrier #x200)
(:framebuffer-barrier-bit-ext #x400)
(:framebuffer-barrier-bit #x400)
(:framebuffer-barrier #x400)
(:transform-feedback-barrier-bit-ext #x800)
(:transform-feedback-barrier-bit #x800)
(:transform-feedback-barrier #x800)
(:atomic-counter-barrier-bit-ext #x1000)
(:atomic-counter-barrier-bit #x1000)
(:atomic-counter-barrier #x1000)
(:shader-storage-barrier-bit #x2000)
(:shader-storage-barrier #x2000)
(:client-mapped-buffer-barrier-bit-ext #x4000)
(:client-mapped-buffer-barrier-bit #x4000)
(:client-mapped-buffer-barrier #x4000)
(:query-buffer-barrier-bit #x8000)
(:query-buffer-barrier #x8000)
(:all-barrier-bits-ext #xFFFFFFFF)
(:all-barrier-bits #xFFFFFFFF)
(:all-barrier #xFFFFFFFF))
(defbitfield (PathRenderingMaskNV :unsigned-int)
(:glyph-width-bit-nv #x1)
(:bold-bit-nv #x1)
(:glyph-height-bit-nv #x2)
(:italic-bit-nv #x2)
(:glyph-horizontal-bearing-x-bit-nv #x4)
(:glyph-horizontal-bearing-y-bit-nv #x8)
(:glyph-horizontal-bearing-advance-bit-nv #x10)
(:glyph-vertical-bearing-x-bit-nv #x20)
(:glyph-vertical-bearing-y-bit-nv #x40)
(:glyph-vertical-bearing-advance-bit-nv #x80)
(:glyph-has-kerning-bit-nv #x100)
(:font-x-min-bounds-bit-nv #x10000)
(:font-y-min-bounds-bit-nv #x20000)
(:font-x-max-bounds-bit-nv #x40000)
(:font-y-max-bounds-bit-nv #x80000)
(:font-units-per-em-bit-nv #x100000)
(:font-ascender-bit-nv #x200000)
(:font-descender-bit-nv #x400000)
(:font-height-bit-nv #x800000)
(:font-max-advance-width-bit-nv #x1000000)
(:font-max-advance-height-bit-nv #x2000000)
(:font-underline-position-bit-nv #x4000000)
(:font-underline-thickness-bit-nv #x8000000)
(:font-has-kerning-bit-nv #x10000000)
(:font-num-glyph-indices-bit-nv #x20000000))
(defbitfield (PerformanceQueryCapsMaskINTEL :unsigned-int)
(:perfquery-single-context-intel #x0)
(:perfquery-global-context-intel #x1))
(defbitfield (SyncObjectMask :unsigned-int)
(:sync-flush-commands-bit-apple #x1)
(:sync-flush-commands-bit #x1)
(:sync-flush-commands #x1))
(defbitfield (TextureStorageMaskAMD :unsigned-int)
(:texture-storage-sparse-bit-amd #x1))
(defbitfield (TraceMaskMESA :unsigned-int)
(:trace-operations-bit-mesa #x1)
(:trace-primitives-bit-mesa #x2)
(:trace-arrays-bit-mesa #x4)
(:trace-textures-bit-mesa #x8)
(:trace-pixels-bit-mesa #x10)
(:trace-errors-bit-mesa #x20)
(:trace-all-bits-mesa #xFFFF))
(defbitfield (UseProgramStageMask :unsigned-int)
(:vertex-shader-bit-ext #x1)
(:vertex-shader-bit #x1)
(:vertex-shader #x1)
(:fragment-shader-bit-ext #x2)
(:fragment-shader-bit #x2)
(:fragment-shader #x2)
(:geometry-shader-bit-oes #x4)
(:geometry-shader-bit-ext #x4)
(:geometry-shader-bit #x4)
(:geometry-shader #x4)
(:tess-control-shader-bit-oes #x8)
(:tess-control-shader-bit-ext #x8)
(:tess-control-shader-bit #x8)
(:tess-control-shader #x8)
(:tess-evaluation-shader-bit-oes #x10)
(:tess-evaluation-shader-bit-ext #x10)
(:tess-evaluation-shader-bit #x10)
(:tess-evaluation-shader #x10)
(:compute-shader-bit #x20)
(:compute-shader #x20)
(:all-shader-bits-ext #xFFFFFFFF)
(:all-shader-bits #xFFFFFFFF)
(:all-shader #xFFFFFFFF))
(defbitfield (VertexHintsMaskPGI :unsigned-int)
(:vertex23-bit-pgi #x4)
(:vertex4-bit-pgi #x8)
(:color3-bit-pgi #x10000)
(:color4-bit-pgi #x20000)
(:edgeflag-bit-pgi #x40000)
(:index-bit-pgi #x80000)
(:mat-ambient-bit-pgi #x100000)
(:mat-ambient-and-diffuse-bit-pgi #x200000)
(:mat-diffuse-bit-pgi #x400000)
(:mat-emission-bit-pgi #x800000)
(:mat-color-indexes-bit-pgi #x1000000)
(:mat-shininess-bit-pgi #x2000000)
(:mat-specular-bit-pgi #x4000000)
(:normal-bit-pgi #x8000000)
(:texcoord1-bit-pgi #x10000000)
(:texcoord2-bit-pgi #x20000000)
(:texcoord3-bit-pgi #x40000000)
(:texcoord4-bit-pgi #x80000000))
(defcenum (attribute-type :unsigned-int)
(:bool #x8B56)
(:bool-arb #x8B56)
(:bool-vec2 #x8B57)
(:bool-vec2-arb #x8B57)
(:bool-vec3 #x8B58)
(:bool-vec3-arb #x8B58)
(:bool-vec4 #x8B59)
(:bool-vec4-arb #x8B59)
(:float-mat2 #x8B5A)
(:float-mat2-arb #x8B5A)
(:float-mat2x3 #x8B65)
(:float-mat2x3-nv #x8B65)
(:float-mat2x4 #x8B66)
(:float-mat2x4-nv #x8B66)
(:float-mat3 #x8B5B)
(:float-mat3-arb #x8B5B)
(:float-mat3x2 #x8B67)
(:float-mat3x2-nv #x8B67)
(:float-mat3x4 #x8B68)
(:float-mat3x4-nv #x8B68)
(:float-mat4 #x8B5C)
(:float-mat4-arb #x8B5C)
(:float-mat4x2 #x8B69)
(:float-mat4x2-nv #x8B69)
(:float-mat4x3 #x8B6A)
(:float-mat4x3-nv #x8B6A)
(:float-vec2 #x8B50)
(:float-vec2-arb #x8B50)
(:float-vec3 #x8B51)
(:float-vec3-arb #x8B51)
(:float-vec4 #x8B52)
(:float-vec4-arb #x8B52)
(:int-vec2 #x8B53)
(:int-vec2-arb #x8B53)
(:int-vec3 #x8B54)
(:int-vec3-arb #x8B54)
(:int-vec4 #x8B55)
(:int-vec4-arb #x8B55)
(:sampler-1d #x8B5D)
(:sampler-1d-arb #x8B5D)
(:sampler-1d-shadow #x8B61)
(:sampler-1d-shadow-arb #x8B61)
(:sampler-2d #x8B5E)
(:sampler-2d-arb #x8B5E)
(:sampler-2d-rect #x8B63)
(:sampler-2d-rect-arb #x8B63)
(:sampler-2d-rect-shadow #x8B64)
(:sampler-2d-rect-shadow-arb #x8B64)
(:sampler-2d-shadow #x8B62)
(:sampler-2d-shadow-arb #x8B62)
(:sampler-2d-shadow-ext #x8B62)
(:sampler-3d #x8B5F)
(:sampler-3d-arb #x8B5F)
(:sampler-3d-oes #x8B5F)
(:sampler-cube #x8B60)
(:sampler-cube-arb #x8B60))
(defcenum (command-opcodes-nv :unsigned-int)
(:alpha-ref-command-nv #xF)
(:attribute-address-command-nv #x9)
(:blend-color-command-nv #xB)
(:draw-arrays-command-nv #x3)
(:draw-arrays-instanced-command-nv #x7)
(:draw-arrays-strip-command-nv #x5)
(:draw-elements-command-nv #x2)
(:draw-elements-instanced-command-nv #x6)
(:draw-elements-strip-command-nv #x4)
(:element-address-command-nv #x8)
(:front-face-command-nv #x12)
(:line-width-command-nv #xD)
(:nop-command-nv #x1)
(:polygon-offset-command-nv #xE)
(:scissor-command-nv #x11)
(:stencil-ref-command-nv #xC)
(:terminate-sequence-command-nv #x0)
(:uniform-address-command-nv #xA)
(:viewport-command-nv #x10))
(defcenum (container-type :unsigned-int)
(:program-object-arb #x8B40)
(:program-object-ext #x8B40))
(defcenum (get-program-pipeline-ext-pname :unsigned-int)
(:active-program-ext #x8259)
(:fragment-shader #x8B30)
(:info-log-length #x8B84)
(:validate-status #x8B83)
(:vertex-shader #x8B31))
(defcenum (map-texture-format-intel :unsigned-int)
(:layout-default-intel #x0)
(:layout-linear-cpu-cached-intel #x2)
(:layout-linear-intel #x1))
(defcenum (path-rendering-token-nv :unsigned-int)
(:arc-to-nv #xFE)
(:circular-ccw-arc-to-nv #xF8)
(:circular-cw-arc-to-nv #xFA)
(:circular-tangent-arc-to-nv #xFC)
(:close-path-nv #x0)
(:conic-curve-to-nv #x1A)
(:cubic-curve-to-nv #xC)
(:dup-first-cubic-curve-to-nv #xF2)
(:dup-last-cubic-curve-to-nv #xF4)
(:horizontal-line-to-nv #x6)
(:large-ccw-arc-to-nv #x16)
(:large-cw-arc-to-nv #x18)
(:line-to-nv #x4)
(:move-to-nv #x2)
(:quadratic-curve-to-nv #xA)
(:rect-nv #xF6)
(:relative-arc-to-nv #xFF)
(:relative-conic-curve-to-nv #x1B)
(:relative-cubic-curve-to-nv #xD)
(:relative-horizontal-line-to-nv #x7)
(:relative-large-ccw-arc-to-nv #x17)
(:relative-large-cw-arc-to-nv #x19)
(:relative-line-to-nv #x5)
(:relative-move-to-nv #x3)
(:relative-quadratic-curve-to-nv #xB)
(:relative-rect-nv #xF7)
(:relative-rounded-rect-nv #xE9)
(:relative-rounded-rect2-nv #xEB)
(:relative-rounded-rect4-nv #xED)
(:relative-rounded-rect8-nv #xEF)
(:relative-small-ccw-arc-to-nv #x13)
(:relative-small-cw-arc-to-nv #x15)
(:relative-smooth-cubic-curve-to-nv #x11)
(:relative-smooth-quadratic-curve-to-nv #xF)
(:relative-vertical-line-to-nv #x9)
(:restart-path-nv #xF0)
(:rounded-rect-nv #xE8)
(:rounded-rect2-nv #xEA)
(:rounded-rect4-nv #xEC)
(:rounded-rect8-nv #xEE)
(:shared-edge-nv #xC0)
(:small-ccw-arc-to-nv #x12)
(:small-cw-arc-to-nv #x14)
(:smooth-cubic-curve-to-nv #x10)
(:smooth-quadratic-curve-to-nv #xE)
(:vertical-line-to-nv #x8))
(defcenum (register-combiner-pname :unsigned-int)
(:add-signed #x8574)
(:add-signed-arb #x8574)
(:add-signed-ext #x8574)
(:combine #x8570)
(:combine-alpha #x8572)
(:combine-alpha-arb #x8572)
(:combine-alpha-ext #x8572)
(:combine-arb #x8570)
(:combine-ext #x8570)
(:combine-rgb #x8571)
(:combine-rgb-arb #x8571)
(:combine-rgb-ext #x8571)
(:constant #x8576)
(:constant-arb #x8576)
(:constant-ext #x8576)
(:constant-nv #x8576)
(:interpolate #x8575)
(:interpolate-arb #x8575)
(:interpolate-ext #x8575)
(:operand0-alpha #x8598)
(:operand0-alpha-arb #x8598)
(:operand0-alpha-ext #x8598)
(:operand0-rgb #x8590)
(:operand0-rgb-arb #x8590)
(:operand0-rgb-ext #x8590)
(:operand1-alpha #x8599)
(:operand1-alpha-arb #x8599)
(:operand1-alpha-ext #x8599)
(:operand1-rgb #x8591)
(:operand1-rgb-arb #x8591)
(:operand1-rgb-ext #x8591)
(:operand2-alpha #x859A)
(:operand2-alpha-arb #x859A)
(:operand2-alpha-ext #x859A)
(:operand2-rgb #x8592)
(:operand2-rgb-arb #x8592)
(:operand2-rgb-ext #x8592)
(:operand3-alpha-nv #x859B)
(:operand3-rgb-nv #x8593)
(:previous #x8578)
(:previous-arb #x8578)
(:previous-ext #x8578)
(:primary-color #x8577)
(:primary-color-arb #x8577)
(:primary-color-ext #x8577)
(:rgb-scale #x8573)
(:rgb-scale-arb #x8573)
(:rgb-scale-ext #x8573)
(:source0-alpha #x8588)
(:source0-alpha-arb #x8588)
(:source0-alpha-ext #x8588)
(:source0-rgb #x8580)
(:source0-rgb-arb #x8580)
(:source0-rgb-ext #x8580)
(:source1-alpha #x8589)
(:source1-alpha-arb #x8589)
(:source1-alpha-ext #x8589)
(:source1-rgb #x8581)
(:source1-rgb-arb #x8581)
(:source1-rgb-ext #x8581)
(:source2-alpha #x858A)
(:source2-alpha-arb #x858A)
(:source2-alpha-ext #x858A)
(:source2-rgb #x8582)
(:source2-rgb-arb #x8582)
(:source2-rgb-ext #x8582)
(:source3-alpha-nv #x858B)
(:source3-rgb-nv #x8583)
(:src0-alpha #x8588)
(:src0-rgb #x8580)
(:src1-alpha #x8589)
(:src1-rgb #x8581)
(:src2-alpha #x858A)
(:src2-rgb #x8582))
(defcenum (shader-type :unsigned-int)
(:fragment-shader #x8B30)
(:fragment-shader-arb #x8B30)
(:vertex-shader #x8B31)
(:vertex-shader-arb #x8B31))
(defcenum (transform-feedback-token-nv :unsigned-int)
(:next-buffer-nv #x-2)
(:skip-components1-nv #x-6)
(:skip-components2-nv #x-5)
(:skip-components3-nv #x-4)
(:skip-components4-nv #x-3))
(defcenum (triangle-list-sun :unsigned-int)
(:replace-middle-sun #x2)
(:replace-oldest-sun #x3)
(:restart-sun #x1))
(defcenum (enum :unsigned-int)
(:1pass-ext #x80A1)
(:1pass-sgis #x80A1)
(:2-bytes #x1407)
(:2-bytes-nv #x1407)
(:2d #x600)
(:2pass-0-ext #x80A2)
(:2pass-0-sgis #x80A2)
(:2pass-1-ext #x80A3)
(:2pass-1-sgis #x80A3)
(:2x-bit-ati #x1)
(:3-bytes #x1408)
(:3-bytes-nv #x1408)
(:3d #x601)
(:3d-color #x602)
(:3d-color-texture #x603)
(:3dc-x-amd #x87F9)
(:3dc-xy-amd #x87FA)
(:4-bytes #x1409)
(:4-bytes-nv #x1409)
(:422-average-ext #x80CE)
(:422-ext #x80CC)
(:422-rev-average-ext #x80CF)
(:422-rev-ext #x80CD)
(:4d-color-texture #x604)
(:4pass-0-ext #x80A4)
(:4pass-0-sgis #x80A4)
(:4pass-1-ext #x80A5)
(:4pass-1-sgis #x80A5)
(:4pass-2-ext #x80A6)
(:4pass-2-sgis #x80A6)
(:4pass-3-ext #x80A7)
(:4pass-3-sgis #x80A7)
(:4x-bit-ati #x2)
(:8x-bit-ati #x4)
(:abgr-ext #x8000)
(:accum #x100)
(:accum-adjacent-pairs-nv #x90AD)
(:accum-alpha-bits #xD5B)
(:accum-blue-bits #xD5A)
(:accum-buffer-bit #x200)
(:accum-clear-value #xB80)
(:accum-green-bits #xD59)
(:accum-red-bits #xD58)
(:active-atomic-counter-buffers #x92D9)
(:active-attribute-max-length #x8B8A)
(:active-attributes #x8B89)
(:active-program #x8259)
(:active-program-ext #x8B8D)
(:active-resources #x92F5)
(:active-stencil-face-ext #x8911)
(:active-subroutine-max-length #x8E48)
(:active-subroutine-uniform-locations #x8E47)
(:active-subroutine-uniform-max-length #x8E49)
(:active-subroutine-uniforms #x8DE6)
(:active-subroutines #x8DE5)
(:active-texture #x84E0)
(:active-texture-arb #x84E0)
(:active-uniform-block-max-name-length #x8A35)
(:active-uniform-blocks #x8A36)
(:active-uniform-max-length #x8B87)
(:active-uniforms #x8B86)
(:active-variables #x9305)
(:active-varying-max-length-nv #x8C82)
(:active-varyings-nv #x8C81)
(:active-vertex-units-arb #x86A5)
(:add #x104)
(:add-ati #x8963)
(:add-blend-img #x8C09)
(:add-signed #x8574)
(:add-signed-arb #x8574)
(:add-signed-ext #x8574)
(:adjacent-pairs-nv #x90AE)
(:affine-2d-nv #x9092)
(:affine-3d-nv #x9094)
(:aliased-line-width-range #x846E)
(:aliased-point-size-range #x846D)
(:all-attrib-bits #xFFFFFFFF)
(:all-barrier-bits #xFFFFFFFF)
(:all-barrier-bits-ext #xFFFFFFFF)
(:all-completed-nv #x84F2)
(:all-shader-bits #xFFFFFFFF)
(:all-shader-bits-ext #xFFFFFFFF)
(:all-static-data-ibm #x19294)
(:allow-draw-frg-hint-pgi #x1A210)
(:allow-draw-mem-hint-pgi #x1A211)
(:allow-draw-obj-hint-pgi #x1A20E)
(:allow-draw-win-hint-pgi #x1A20F)
(:alpha #x1906)
(:alpha-bias #xD1D)
(:alpha-bits #xD55)
(:alpha-float16-apple #x881C)
(:alpha-float16-ati #x881C)
(:alpha-float32-apple #x8816)
(:alpha-float32-ati #x8816)
(:alpha-integer #x8D97)
(:alpha-integer-ext #x8D97)
(:alpha-max-clamp-ingr #x8567)
(:alpha-max-sgix #x8321)
(:alpha-min-clamp-ingr #x8563)
(:alpha-min-sgix #x8320)
(:alpha-ref-command-nv #xF)
(:alpha-scale #xD1C)
(:alpha-snorm #x9010)
(:alpha-test #xBC0)
(:alpha-test-func #xBC1)
(:alpha-test-func-qcom #xBC1)
(:alpha-test-qcom #xBC0)
(:alpha-test-ref #xBC2)
(:alpha-test-ref-qcom #xBC2)
(:alpha12 #x803D)
(:alpha12-ext #x803D)
(:alpha16 #x803E)
(:alpha16-ext #x803E)
(:alpha16-snorm #x9018)
(:alpha16f-arb #x881C)
(:alpha16f-ext #x881C)
(:alpha16i-ext #x8D8A)
(:alpha16ui-ext #x8D78)
(:alpha32f-arb #x8816)
(:alpha32f-ext #x8816)
(:alpha32i-ext #x8D84)
(:alpha32ui-ext #x8D72)
(:alpha4 #x803B)
(:alpha4-ext #x803B)
(:alpha8 #x803C)
(:alpha8-ext #x803C)
(:alpha8-oes #x803C)
(:alpha8-snorm #x9014)
(:alpha8i-ext #x8D90)
(:alpha8ui-ext #x8D7E)
(:already-signaled #x911A)
(:already-signaled-apple #x911A)
(:always #x207)
(:always-fast-hint-pgi #x1A20C)
(:always-soft-hint-pgi #x1A20D)
(:ambient #x1200)
(:ambient-and-diffuse #x1602)
(:and #x1501)
(:and-inverted #x1504)
(:and-reverse #x1502)
(:any-samples-passed #x8C2F)
(:any-samples-passed-conservative #x8D6A)
(:any-samples-passed-conservative-ext #x8D6A)
(:any-samples-passed-ext #x8C2F)
(:arc-to-nv #xFE)
(:array-buffer #x8892)
(:array-buffer-arb #x8892)
(:array-buffer-binding #x8894)
(:array-buffer-binding-arb #x8894)
(:array-element-lock-count-ext #x81A9)
(:array-element-lock-first-ext #x81A8)
(:array-object-buffer-ati #x8766)
(:array-object-offset-ati #x8767)
(:array-size #x92FB)
(:array-stride #x92FE)
(:async-draw-pixels-sgix #x835D)
(:async-histogram-sgix #x832C)
(:async-marker-sgix #x8329)
(:async-read-pixels-sgix #x835E)
(:async-tex-image-sgix #x835C)
(:atc-rgb-amd #x8C92)
(:atc-rgba-explicit-alpha-amd #x8C93)
(:atc-rgba-interpolated-alpha-amd #x87EE)
(:atomic-counter-barrier-bit #x1000)
(:atomic-counter-barrier-bit-ext #x1000)
(:atomic-counter-buffer #x92C0)
(:atomic-counter-buffer-active-atomic-counter-indices #x92C6)
(:atomic-counter-buffer-active-atomic-counters #x92C5)
(:atomic-counter-buffer-binding #x92C1)
(:atomic-counter-buffer-data-size #x92C4)
(:atomic-counter-buffer-index #x9301)
(:atomic-counter-buffer-referenced-by-compute-shader #x90ED)
(:atomic-counter-buffer-referenced-by-fragment-shader #x92CB)
(:atomic-counter-buffer-referenced-by-geometry-shader #x92CA)
(:atomic-counter-buffer-referenced-by-tess-control-shader #x92C8)
(:atomic-counter-buffer-referenced-by-tess-evaluation-shader #x92C9)
(:atomic-counter-buffer-referenced-by-vertex-shader #x92C7)
(:atomic-counter-buffer-size #x92C3)
(:atomic-counter-buffer-start #x92C2)
(:attached-shaders #x8B85)
(:attenuation-ext #x834D)
(:attrib-array-pointer-nv #x8645)
(:attrib-array-size-nv #x8623)
(:attrib-array-stride-nv #x8624)
(:attrib-array-type-nv #x8625)
(:attrib-stack-depth #xBB0)
(:attribute-address-command-nv #x9)
(:auto-generate-mipmap #x8295)
(:auto-normal #xD80)
(:aux-buffers #xC00)
(:aux-depth-stencil-apple #x8A14)
(:aux0 #x409)
(:aux1 #x40A)
(:aux2 #x40B)
(:aux3 #x40C)
(:average-ext #x8335)
(:average-hp #x8160)
(:back #x405)
(:back-left #x402)
(:back-normals-hint-pgi #x1A223)
(:back-primary-color-nv #x8C77)
(:back-right #x403)
(:back-secondary-color-nv #x8C78)
(:bevel-nv #x90A6)
(:bgr #x80E0)
(:bgr-ext #x80E0)
(:bgr-integer #x8D9A)
(:bgr-integer-ext #x8D9A)
(:bgra #x80E1)
(:bgra-ext #x80E1)
(:bgra-img #x80E1)
(:bgra-integer #x8D9B)
(:bgra-integer-ext #x8D9B)
(:bgra8-ext #x93A1)
(:bias-bit-ati #x8)
(:bias-by-negative-one-half-nv #x8541)
(:binning-control-hint-qcom #x8FB0)
(:binormal-array-ext #x843A)
(:binormal-array-pointer-ext #x8443)
(:binormal-array-stride-ext #x8441)
(:binormal-array-type-ext #x8440)
(:bitmap #x1A00)
(:bitmap-token #x704)
(:blend #xBE2)
(:blend-advanced-coherent-khr #x9285)
(:blend-advanced-coherent-nv #x9285)
(:blend-color #x8005)
(:blend-color-command-nv #xB)
(:blend-color-ext #x8005)
(:blend-dst #xBE0)
(:blend-dst-alpha #x80CA)
(:blend-dst-alpha-ext #x80CA)
(:blend-dst-alpha-oes #x80CA)
(:blend-dst-rgb #x80C8)
(:blend-dst-rgb-ext #x80C8)
(:blend-dst-rgb-oes #x80C8)
(:blend-equation #x8009)
(:blend-equation-alpha #x883D)
(:blend-equation-alpha-ext #x883D)
(:blend-equation-alpha-oes #x883D)
(:blend-equation-ext #x8009)
(:blend-equation-oes #x8009)
(:blend-equation-rgb #x8009)
(:blend-equation-rgb-ext #x8009)
(:blend-equation-rgb-oes #x8009)
(:blend-overlap-nv #x9281)
(:blend-premultiplied-src-nv #x9280)
(:blend-src #xBE1)
(:blend-src-alpha #x80CB)
(:blend-src-alpha-ext #x80CB)
(:blend-src-alpha-oes #x80CB)
(:blend-src-rgb #x80C9)
(:blend-src-rgb-ext #x80C9)
(:blend-src-rgb-oes #x80C9)
(:block-index #x92FD)
(:blue #x1905)
(:blue-bias #xD1B)
(:blue-bit-ati #x4)
(:blue-bits #xD54)
(:blue-integer #x8D96)
(:blue-integer-ext #x8D96)
(:blue-max-clamp-ingr #x8566)
(:blue-min-clamp-ingr #x8562)
(:blue-nv #x1905)
(:blue-scale #xD1A)
(:bold-bit-nv #x1)
(:bool #x8B56)
(:bool-arb #x8B56)
(:bool-vec2 #x8B57)
(:bool-vec2-arb #x8B57)
(:bool-vec3 #x8B58)
(:bool-vec3-arb #x8B58)
(:bool-vec4 #x8B59)
(:bool-vec4-arb #x8B59)
(:bounding-box-nv #x908D)
(:bounding-box-of-bounding-boxes-nv #x909C)
(:browser-default-webgl #x9244)
(:buffer #x82E0)
(:buffer-access #x88BB)
(:buffer-access-arb #x88BB)
(:buffer-access-flags #x911F)
(:buffer-access-oes #x88BB)
(:buffer-binding #x9302)
(:buffer-data-size #x9303)
(:buffer-flushing-unmap-apple #x8A13)
(:buffer-gpu-address-nv #x8F1D)
(:buffer-immutable-storage #x821F)
(:buffer-immutable-storage-ext #x821F)
(:buffer-khr #x82E0)
(:buffer-map-length #x9120)
(:buffer-map-offset #x9121)
(:buffer-map-pointer #x88BD)
(:buffer-map-pointer-arb #x88BD)
(:buffer-map-pointer-oes #x88BD)
(:buffer-mapped #x88BC)
(:buffer-mapped-arb #x88BC)
(:buffer-mapped-oes #x88BC)
(:buffer-object-apple #x85B3)
(:buffer-object-ext #x9151)
(:buffer-serialized-modify-apple #x8A12)
(:buffer-size #x8764)
(:buffer-size-arb #x8764)
(:buffer-storage-flags #x8220)
(:buffer-storage-flags-ext #x8220)
(:buffer-update-barrier-bit #x200)
(:buffer-update-barrier-bit-ext #x200)
(:buffer-usage #x8765)
(:buffer-usage-arb #x8765)
(:buffer-variable #x92E5)
(:bump-envmap-ati #x877B)
(:bump-num-tex-units-ati #x8777)
(:bump-rot-matrix-ati #x8775)
(:bump-rot-matrix-size-ati #x8776)
(:bump-target-ati #x877C)
(:bump-tex-units-ati #x8778)
(:byte #x1400)
(:c3f-v3f #x2A24)
(:c4f-n3f-v3f #x2A26)
(:c4ub-v2f #x2A22)
(:c4ub-v3f #x2A23)
(:calligraphic-fragment-sgix #x8183)
(:caveat-support #x82B8)
(:ccw #x901)
(:circular-ccw-arc-to-nv #xF8)
(:circular-cw-arc-to-nv #xFA)
(:circular-tangent-arc-to-nv #xFC)
(:clamp #x2900)
(:clamp-fragment-color #x891B)
(:clamp-fragment-color-arb #x891B)
(:clamp-read-color #x891C)
(:clamp-read-color-arb #x891C)
(:clamp-to-border #x812D)
(:clamp-to-border-arb #x812D)
(:clamp-to-border-ext #x812D)
(:clamp-to-border-nv #x812D)
(:clamp-to-border-oes #x812D)
(:clamp-to-border-sgis #x812D)
(:clamp-to-edge #x812F)
(:clamp-to-edge-sgis #x812F)
(:clamp-vertex-color #x891A)
(:clamp-vertex-color-arb #x891A)
(:clear #x1500)
(:clear-buffer #x82B4)
(:clear-texture #x9365)
(:client-active-texture #x84E1)
(:client-active-texture-arb #x84E1)
(:client-all-attrib-bits #xFFFFFFFF)
(:client-attrib-stack-depth #xBB1)
(:client-mapped-buffer-barrier-bit #x4000)
(:client-mapped-buffer-barrier-bit-ext #x4000)
(:client-pixel-store-bit #x1)
(:client-storage-bit #x200)
(:client-storage-bit-ext #x200)
(:client-vertex-array-bit #x2)
(:clip-depth-mode #x935D)
(:clip-distance-nv #x8C7A)
(:clip-distance0 #x3000)
(:clip-distance0-apple #x3000)
(:clip-distance1 #x3001)
(:clip-distance1-apple #x3001)
(:clip-distance2 #x3002)
(:clip-distance2-apple #x3002)
(:clip-distance3 #x3003)
(:clip-distance3-apple #x3003)
(:clip-distance4 #x3004)
(:clip-distance4-apple #x3004)
(:clip-distance5 #x3005)
(:clip-distance5-apple #x3005)
(:clip-distance6 #x3006)
(:clip-distance6-apple #x3006)
(:clip-distance7 #x3007)
(:clip-distance7-apple #x3007)
(:clip-far-hint-pgi #x1A221)
(:clip-near-hint-pgi #x1A220)
(:clip-origin #x935C)
(:clip-plane0 #x3000)
(:clip-plane0-img #x3000)
(:clip-plane1 #x3001)
(:clip-plane1-img #x3001)
(:clip-plane2 #x3002)
(:clip-plane2-img #x3002)
(:clip-plane3 #x3003)
(:clip-plane3-img #x3003)
(:clip-plane4 #x3004)
(:clip-plane4-img #x3004)
(:clip-plane5 #x3005)
(:clip-plane5-img #x3005)
(:clip-volume-clipping-hint-ext #x80F0)
(:clipping-input-primitives-arb #x82F6)
(:clipping-output-primitives-arb #x82F7)
(:close-path-nv #x0)
(:cmyk-ext #x800C)
(:cmyka-ext #x800D)
(:cnd-ati #x896A)
(:cnd0-ati #x896B)
(:coeff #xA00)
(:color #x1800)
(:color-alpha-pairing-ati #x8975)
(:color-array #x8076)
(:color-array-address-nv #x8F23)
(:color-array-buffer-binding #x8898)
(:color-array-buffer-binding-arb #x8898)
(:color-array-count-ext #x8084)
(:color-array-ext #x8076)
(:color-array-length-nv #x8F2D)
(:color-array-list-ibm #x192A0)
(:color-array-list-stride-ibm #x192AA)
(:color-array-parallel-pointers-intel #x83F7)
(:color-array-pointer #x8090)
(:color-array-pointer-ext #x8090)
(:color-array-size #x8081)
(:color-array-size-ext #x8081)
(:color-array-stride #x8083)
(:color-array-stride-ext #x8083)
(:color-array-type #x8082)
(:color-array-type-ext #x8082)
(:color-attachment-ext #x90F0)
(:color-attachment0 #x8CE0)
(:color-attachment0-ext #x8CE0)
(:color-attachment0-nv #x8CE0)
(:color-attachment0-oes #x8CE0)
(:color-attachment1 #x8CE1)
(:color-attachment1-ext #x8CE1)
(:color-attachment1-nv #x8CE1)
(:color-attachment10 #x8CEA)
(:color-attachment10-ext #x8CEA)
(:color-attachment10-nv #x8CEA)
(:color-attachment11 #x8CEB)
(:color-attachment11-ext #x8CEB)
(:color-attachment11-nv #x8CEB)
(:color-attachment12 #x8CEC)
(:color-attachment12-ext #x8CEC)
(:color-attachment12-nv #x8CEC)
(:color-attachment13 #x8CED)
(:color-attachment13-ext #x8CED)
(:color-attachment13-nv #x8CED)
(:color-attachment14 #x8CEE)
(:color-attachment14-ext #x8CEE)
(:color-attachment14-nv #x8CEE)
(:color-attachment15 #x8CEF)
(:color-attachment15-ext #x8CEF)
(:color-attachment15-nv #x8CEF)
(:color-attachment16 #x8CF0)
(:color-attachment17 #x8CF1)
(:color-attachment18 #x8CF2)
(:color-attachment19 #x8CF3)
(:color-attachment2 #x8CE2)
(:color-attachment2-ext #x8CE2)
(:color-attachment2-nv #x8CE2)
(:color-attachment20 #x8CF4)
(:color-attachment21 #x8CF5)
(:color-attachment22 #x8CF6)
(:color-attachment23 #x8CF7)
(:color-attachment24 #x8CF8)
(:color-attachment25 #x8CF9)
(:color-attachment26 #x8CFA)
(:color-attachment27 #x8CFB)
(:color-attachment28 #x8CFC)
(:color-attachment29 #x8CFD)
(:color-attachment3 #x8CE3)
(:color-attachment3-ext #x8CE3)
(:color-attachment3-nv #x8CE3)
(:color-attachment30 #x8CFE)
(:color-attachment31 #x8CFF)
(:color-attachment4 #x8CE4)
(:color-attachment4-ext #x8CE4)
(:color-attachment4-nv #x8CE4)
(:color-attachment5 #x8CE5)
(:color-attachment5-ext #x8CE5)
(:color-attachment5-nv #x8CE5)
(:color-attachment6 #x8CE6)
(:color-attachment6-ext #x8CE6)
(:color-attachment6-nv #x8CE6)
(:color-attachment7 #x8CE7)
(:color-attachment7-ext #x8CE7)
(:color-attachment7-nv #x8CE7)
(:color-attachment8 #x8CE8)
(:color-attachment8-ext #x8CE8)
(:color-attachment8-nv #x8CE8)
(:color-attachment9 #x8CE9)
(:color-attachment9-ext #x8CE9)
(:color-attachment9-nv #x8CE9)
(:color-buffer-bit #x4000)
(:color-buffer-bit0-qcom #x1)
(:color-buffer-bit1-qcom #x2)
(:color-buffer-bit2-qcom #x4)
(:color-buffer-bit3-qcom #x8)
(:color-buffer-bit4-qcom #x10)
(:color-buffer-bit5-qcom #x20)
(:color-buffer-bit6-qcom #x40)
(:color-buffer-bit7-qcom #x80)
(:color-clear-unclamped-value-ati #x8835)
(:color-clear-value #xC22)
(:color-components #x8283)
(:color-encoding #x8296)
(:color-ext #x1800)
(:color-float-apple #x8A0F)
(:color-index #x1900)
(:color-index1-ext #x80E2)
(:color-index12-ext #x80E6)
(:color-index16-ext #x80E7)
(:color-index2-ext #x80E3)
(:color-index4-ext #x80E4)
(:color-index8-ext #x80E5)
(:color-indexes #x1603)
(:color-logic-op #xBF2)
(:color-material #xB57)
(:color-material-face #xB55)
(:color-material-parameter #xB56)
(:color-matrix #x80B1)
(:color-matrix-sgi #x80B1)
(:color-matrix-stack-depth #x80B2)
(:color-matrix-stack-depth-sgi #x80B2)
(:color-renderable #x8286)
(:color-samples-nv #x8E20)
(:color-sum #x8458)
(:color-sum-arb #x8458)
(:color-sum-clamp-nv #x854F)
(:color-sum-ext #x8458)
(:color-table #x80D0)
(:color-table-alpha-size #x80DD)
(:color-table-alpha-size-sgi #x80DD)
(:color-table-bias #x80D7)
(:color-table-bias-sgi #x80D7)
(:color-table-blue-size #x80DC)
(:color-table-blue-size-sgi #x80DC)
(:color-table-format #x80D8)
(:color-table-format-sgi #x80D8)
(:color-table-green-size #x80DB)
(:color-table-green-size-sgi #x80DB)
(:color-table-intensity-size #x80DF)
(:color-table-intensity-size-sgi #x80DF)
(:color-table-luminance-size #x80DE)
(:color-table-luminance-size-sgi #x80DE)
(:color-table-red-size #x80DA)
(:color-table-red-size-sgi #x80DA)
(:color-table-scale #x80D6)
(:color-table-scale-sgi #x80D6)
(:color-table-sgi #x80D0)
(:color-table-width #x80D9)
(:color-table-width-sgi #x80D9)
(:color-writemask #xC23)
(:color3-bit-pgi #x10000)
(:color4-bit-pgi #x20000)
(:colorburn #x929A)
(:colorburn-khr #x929A)
(:colorburn-nv #x929A)
(:colordodge #x9299)
(:colordodge-khr #x9299)
(:colordodge-nv #x9299)
(:combine #x8570)
(:combine-alpha #x8572)
(:combine-alpha-arb #x8572)
(:combine-alpha-ext #x8572)
(:combine-arb #x8570)
(:combine-ext #x8570)
(:combine-rgb #x8571)
(:combine-rgb-arb #x8571)
(:combine-rgb-ext #x8571)
(:combine4-nv #x8503)
(:combiner-ab-dot-product-nv #x8545)
(:combiner-ab-output-nv #x854A)
(:combiner-bias-nv #x8549)
(:combiner-cd-dot-product-nv #x8546)
(:combiner-cd-output-nv #x854B)
(:combiner-component-usage-nv #x8544)
(:combiner-input-nv #x8542)
(:combiner-mapping-nv #x8543)
(:combiner-mux-sum-nv #x8547)
(:combiner-scale-nv #x8548)
(:combiner-sum-output-nv #x854C)
(:combiner0-nv #x8550)
(:combiner1-nv #x8551)
(:combiner2-nv #x8552)
(:combiner3-nv #x8553)
(:combiner4-nv #x8554)
(:combiner5-nv #x8555)
(:combiner6-nv #x8556)
(:combiner7-nv #x8557)
(:command-barrier-bit #x40)
(:command-barrier-bit-ext #x40)
(:comp-bit-ati #x2)
(:compare-r-to-texture #x884E)
(:compare-r-to-texture-arb #x884E)
(:compare-ref-depth-to-texture-ext #x884E)
(:compare-ref-to-texture #x884E)
(:compare-ref-to-texture-ext #x884E)
(:compatible-subroutines #x8E4B)
(:compile #x1300)
(:compile-and-execute #x1301)
(:compile-status #x8B81)
(:completion-status-arb #x91B1)
(:compressed-alpha #x84E9)
(:compressed-alpha-arb #x84E9)
(:compressed-intensity #x84EC)
(:compressed-intensity-arb #x84EC)
(:compressed-luminance #x84EA)
(:compressed-luminance-alpha #x84EB)
(:compressed-luminance-alpha-3dc-ati #x8837)
(:compressed-luminance-alpha-arb #x84EB)
(:compressed-luminance-alpha-latc2-ext #x8C72)
(:compressed-luminance-arb #x84EA)
(:compressed-luminance-latc1-ext #x8C70)
(:compressed-r11-eac #x9270)
(:compressed-r11-eac-oes #x9270)
(:compressed-red #x8225)
(:compressed-red-green-rgtc2-ext #x8DBD)
(:compressed-red-rgtc1 #x8DBB)
(:compressed-red-rgtc1-ext #x8DBB)
(:compressed-rg #x8226)
(:compressed-rg-rgtc2 #x8DBD)
(:compressed-rg11-eac #x9272)
(:compressed-rg11-eac-oes #x9272)
(:compressed-rgb #x84ED)
(:compressed-rgb-arb #x84ED)
(:compressed-rgb-bptc-signed-float #x8E8E)
(:compressed-rgb-bptc-signed-float-arb #x8E8E)
(:compressed-rgb-bptc-unsigned-float #x8E8F)
(:compressed-rgb-bptc-unsigned-float-arb #x8E8F)
(:compressed-rgb-fxt1-3dfx #x86B0)
(:compressed-rgb-pvrtc-2bppv1-img #x8C01)
(:compressed-rgb-pvrtc-4bppv1-img #x8C00)
(:compressed-rgb-s3tc-dxt1-ext #x83F0)
(:compressed-rgb8-etc2 #x9274)
(:compressed-rgb8-etc2-oes #x9274)
(:compressed-rgb8-punchthrough-alpha1-etc2 #x9276)
(:compressed-rgb8-punchthrough-alpha1-etc2-oes #x9276)
(:compressed-rgba #x84EE)
(:compressed-rgba-arb #x84EE)
(:compressed-rgba-astc-10x10 #x93BB)
(:compressed-rgba-astc-10x10-khr #x93BB)
(:compressed-rgba-astc-10x5 #x93B8)
(:compressed-rgba-astc-10x5-khr #x93B8)
(:compressed-rgba-astc-10x6 #x93B9)
(:compressed-rgba-astc-10x6-khr #x93B9)
(:compressed-rgba-astc-10x8 #x93BA)
(:compressed-rgba-astc-10x8-khr #x93BA)
(:compressed-rgba-astc-12x10 #x93BC)
(:compressed-rgba-astc-12x10-khr #x93BC)
(:compressed-rgba-astc-12x12 #x93BD)
(:compressed-rgba-astc-12x12-khr #x93BD)
(:compressed-rgba-astc-3x3x3-oes #x93C0)
(:compressed-rgba-astc-4x3x3-oes #x93C1)
(:compressed-rgba-astc-4x4 #x93B0)
(:compressed-rgba-astc-4x4-khr #x93B0)
(:compressed-rgba-astc-4x4x3-oes #x93C2)
(:compressed-rgba-astc-4x4x4-oes #x93C3)
(:compressed-rgba-astc-5x4 #x93B1)
(:compressed-rgba-astc-5x4-khr #x93B1)
(:compressed-rgba-astc-5x4x4-oes #x93C4)
(:compressed-rgba-astc-5x5 #x93B2)
(:compressed-rgba-astc-5x5-khr #x93B2)
(:compressed-rgba-astc-5x5x4-oes #x93C5)
(:compressed-rgba-astc-5x5x5-oes #x93C6)
(:compressed-rgba-astc-6x5 #x93B3)
(:compressed-rgba-astc-6x5-khr #x93B3)
(:compressed-rgba-astc-6x5x5-oes #x93C7)
(:compressed-rgba-astc-6x6 #x93B4)
(:compressed-rgba-astc-6x6-khr #x93B4)
(:compressed-rgba-astc-6x6x5-oes #x93C8)
(:compressed-rgba-astc-6x6x6-oes #x93C9)
(:compressed-rgba-astc-8x5 #x93B5)
(:compressed-rgba-astc-8x5-khr #x93B5)
(:compressed-rgba-astc-8x6 #x93B6)
(:compressed-rgba-astc-8x6-khr #x93B6)
(:compressed-rgba-astc-8x8 #x93B7)
(:compressed-rgba-astc-8x8-khr #x93B7)
(:compressed-rgba-bptc-unorm #x8E8C)
(:compressed-rgba-bptc-unorm-arb #x8E8C)
(:compressed-rgba-fxt1-3dfx #x86B1)
(:compressed-rgba-pvrtc-2bppv1-img #x8C03)
(:compressed-rgba-pvrtc-2bppv2-img #x9137)
(:compressed-rgba-pvrtc-4bppv1-img #x8C02)
(:compressed-rgba-pvrtc-4bppv2-img #x9138)
(:compressed-rgba-s3tc-dxt1-ext #x83F1)
(:compressed-rgba-s3tc-dxt3-angle #x83F2)
(:compressed-rgba-s3tc-dxt3-ext #x83F2)
(:compressed-rgba-s3tc-dxt5-angle #x83F3)
(:compressed-rgba-s3tc-dxt5-ext #x83F3)
(:compressed-rgba8-etc2-eac #x9278)
(:compressed-rgba8-etc2-eac-oes #x9278)
(:compressed-signed-luminance-alpha-latc2-ext #x8C73)
(:compressed-signed-luminance-latc1-ext #x8C71)
(:compressed-signed-r11-eac #x9271)
(:compressed-signed-r11-eac-oes #x9271)
(:compressed-signed-red-green-rgtc2-ext #x8DBE)
(:compressed-signed-red-rgtc1 #x8DBC)
(:compressed-signed-red-rgtc1-ext #x8DBC)
(:compressed-signed-rg-rgtc2 #x8DBE)
(:compressed-signed-rg11-eac #x9273)
(:compressed-signed-rg11-eac-oes #x9273)
(:compressed-sluminance #x8C4A)
(:compressed-sluminance-alpha #x8C4B)
(:compressed-sluminance-alpha-ext #x8C4B)
(:compressed-sluminance-ext #x8C4A)
(:compressed-srgb #x8C48)
(:compressed-srgb-alpha #x8C49)
(:compressed-srgb-alpha-bptc-unorm #x8E8D)
(:compressed-srgb-alpha-bptc-unorm-arb #x8E8D)
(:compressed-srgb-alpha-ext #x8C49)
(:compressed-srgb-alpha-pvrtc-2bppv1-ext #x8A56)
(:compressed-srgb-alpha-pvrtc-2bppv2-img #x93F0)
(:compressed-srgb-alpha-pvrtc-4bppv1-ext #x8A57)
(:compressed-srgb-alpha-pvrtc-4bppv2-img #x93F1)
(:compressed-srgb-alpha-s3tc-dxt1-ext #x8C4D)
(:compressed-srgb-alpha-s3tc-dxt1-nv #x8C4D)
(:compressed-srgb-alpha-s3tc-dxt3-ext #x8C4E)
(:compressed-srgb-alpha-s3tc-dxt3-nv #x8C4E)
(:compressed-srgb-alpha-s3tc-dxt5-ext #x8C4F)
(:compressed-srgb-alpha-s3tc-dxt5-nv #x8C4F)
(:compressed-srgb-ext #x8C48)
(:compressed-srgb-pvrtc-2bppv1-ext #x8A54)
(:compressed-srgb-pvrtc-4bppv1-ext #x8A55)
(:compressed-srgb-s3tc-dxt1-ext #x8C4C)
(:compressed-srgb-s3tc-dxt1-nv #x8C4C)
(:compressed-srgb8-alpha8-astc-10x10 #x93DB)
(:compressed-srgb8-alpha8-astc-10x10-khr #x93DB)
(:compressed-srgb8-alpha8-astc-10x5 #x93D8)
(:compressed-srgb8-alpha8-astc-10x5-khr #x93D8)
(:compressed-srgb8-alpha8-astc-10x6 #x93D9)
(:compressed-srgb8-alpha8-astc-10x6-khr #x93D9)
(:compressed-srgb8-alpha8-astc-10x8 #x93DA)
(:compressed-srgb8-alpha8-astc-10x8-khr #x93DA)
(:compressed-srgb8-alpha8-astc-12x10 #x93DC)
(:compressed-srgb8-alpha8-astc-12x10-khr #x93DC)
(:compressed-srgb8-alpha8-astc-12x12 #x93DD)
(:compressed-srgb8-alpha8-astc-12x12-khr #x93DD)
(:compressed-srgb8-alpha8-astc-3x3x3-oes #x93E0)
(:compressed-srgb8-alpha8-astc-4x3x3-oes #x93E1)
(:compressed-srgb8-alpha8-astc-4x4 #x93D0)
(:compressed-srgb8-alpha8-astc-4x4-khr #x93D0)
(:compressed-srgb8-alpha8-astc-4x4x3-oes #x93E2)
(:compressed-srgb8-alpha8-astc-4x4x4-oes #x93E3)
(:compressed-srgb8-alpha8-astc-5x4 #x93D1)
(:compressed-srgb8-alpha8-astc-5x4-khr #x93D1)
(:compressed-srgb8-alpha8-astc-5x4x4-oes #x93E4)
(:compressed-srgb8-alpha8-astc-5x5 #x93D2)
(:compressed-srgb8-alpha8-astc-5x5-khr #x93D2)
(:compressed-srgb8-alpha8-astc-5x5x4-oes #x93E5)
(:compressed-srgb8-alpha8-astc-5x5x5-oes #x93E6)
(:compressed-srgb8-alpha8-astc-6x5 #x93D3)
(:compressed-srgb8-alpha8-astc-6x5-khr #x93D3)
(:compressed-srgb8-alpha8-astc-6x5x5-oes #x93E7)
(:compressed-srgb8-alpha8-astc-6x6 #x93D4)
(:compressed-srgb8-alpha8-astc-6x6-khr #x93D4)
(:compressed-srgb8-alpha8-astc-6x6x5-oes #x93E8)
(:compressed-srgb8-alpha8-astc-6x6x6-oes #x93E9)
(:compressed-srgb8-alpha8-astc-8x5 #x93D5)
(:compressed-srgb8-alpha8-astc-8x5-khr #x93D5)
(:compressed-srgb8-alpha8-astc-8x6 #x93D6)
(:compressed-srgb8-alpha8-astc-8x6-khr #x93D6)
(:compressed-srgb8-alpha8-astc-8x8 #x93D7)
(:compressed-srgb8-alpha8-astc-8x8-khr #x93D7)
(:compressed-srgb8-alpha8-etc2-eac #x9279)
(:compressed-srgb8-alpha8-etc2-eac-oes #x9279)
(:compressed-srgb8-etc2 #x9275)
(:compressed-srgb8-etc2-oes #x9275)
(:compressed-srgb8-punchthrough-alpha1-etc2 #x9277)
(:compressed-srgb8-punchthrough-alpha1-etc2-oes #x9277)
(:compressed-texture-formats #x86A3)
(:compressed-texture-formats-arb #x86A3)
(:compute-program-nv #x90FB)
(:compute-program-parameter-buffer-nv #x90FC)
(:compute-shader #x91B9)
(:compute-shader-bit #x20)
(:compute-shader-invocations-arb #x82F5)
(:compute-subroutine #x92ED)
(:compute-subroutine-uniform #x92F3)
(:compute-texture #x82A0)
(:compute-work-group-size #x8267)
(:con-0-ati #x8941)
(:con-1-ati #x8942)
(:con-10-ati #x894B)
(:con-11-ati #x894C)
(:con-12-ati #x894D)
(:con-13-ati #x894E)
(:con-14-ati #x894F)
(:con-15-ati #x8950)
(:con-16-ati #x8951)
(:con-17-ati #x8952)
(:con-18-ati #x8953)
(:con-19-ati #x8954)
(:con-2-ati #x8943)
(:con-20-ati #x8955)
(:con-21-ati #x8956)
(:con-22-ati #x8957)
(:con-23-ati #x8958)
(:con-24-ati #x8959)
(:con-25-ati #x895A)
(:con-26-ati #x895B)
(:con-27-ati #x895C)
(:con-28-ati #x895D)
(:con-29-ati #x895E)
(:con-3-ati #x8944)
(:con-30-ati #x895F)
(:con-31-ati #x8960)
(:con-4-ati #x8945)
(:con-5-ati #x8946)
(:con-6-ati #x8947)
(:con-7-ati #x8948)
(:con-8-ati #x8949)
(:con-9-ati #x894A)
(:condition-satisfied #x911C)
(:condition-satisfied-apple #x911C)
(:conformant-nv #x9374)
(:conic-curve-to-nv #x1A)
(:conjoint-nv #x9284)
(:conservative-raster-dilate-granularity-nv #x937B)
(:conservative-raster-dilate-nv #x9379)
(:conservative-raster-dilate-range-nv #x937A)
(:conservative-rasterization-nv #x9346)
(:conserve-memory-hint-pgi #x1A1FD)
(:const-eye-nv #x86E5)
(:constant #x8576)
(:constant-alpha #x8003)
(:constant-alpha-ext #x8003)
(:constant-arb #x8576)
(:constant-attenuation #x1207)
(:constant-border #x8151)
(:constant-border-hp #x8151)
(:constant-color #x8001)
(:constant-color-ext #x8001)
(:constant-color0-nv #x852A)
(:constant-color1-nv #x852B)
(:constant-ext #x8576)
(:constant-nv #x8576)
(:context-compatibility-profile-bit #x2)
(:context-core-profile-bit #x1)
(:context-flag-debug-bit #x2)
(:context-flag-debug-bit-khr #x2)
(:context-flag-forward-compatible-bit #x1)
(:context-flag-no-error-bit-khr #x8)
(:context-flag-robust-access-bit #x4)
(:context-flag-robust-access-bit-arb #x4)
(:context-flags #x821E)
(:context-lost #x507)
(:context-lost-khr #x507)
(:context-lost-webgl #x9242)
(:context-profile-mask #x9126)
(:context-release-behavior #x82FB)
(:context-release-behavior-flush #x82FC)
(:context-release-behavior-flush-khr #x82FC)
(:context-release-behavior-khr #x82FB)
(:context-robust-access #x90F3)
(:context-robust-access-ext #x90F3)
(:context-robust-access-khr #x90F3)
(:continuous-amd #x9007)
(:contrast-nv #x92A1)
(:convex-hull-nv #x908B)
(:convolution-1d #x8010)
(:convolution-1d-ext #x8010)
(:convolution-2d #x8011)
(:convolution-2d-ext #x8011)
(:convolution-border-color #x8154)
(:convolution-border-color-hp #x8154)
(:convolution-border-mode #x8013)
(:convolution-border-mode-ext #x8013)
(:convolution-filter-bias #x8015)
(:convolution-filter-bias-ext #x8015)
(:convolution-filter-scale #x8014)
(:convolution-filter-scale-ext #x8014)
(:convolution-format #x8017)
(:convolution-format-ext #x8017)
(:convolution-height #x8019)
(:convolution-height-ext #x8019)
(:convolution-hint-sgix #x8316)
(:convolution-width #x8018)
(:convolution-width-ext #x8018)
(:coord-replace #x8862)
(:coord-replace-arb #x8862)
(:coord-replace-nv #x8862)
(:coord-replace-oes #x8862)
(:copy #x1503)
(:copy-inverted #x150C)
(:copy-pixel-token #x706)
(:copy-read-buffer #x8F36)
(:copy-read-buffer-binding #x8F36)
(:copy-read-buffer-nv #x8F36)
(:copy-write-buffer #x8F37)
(:copy-write-buffer-binding #x8F37)
(:copy-write-buffer-nv #x8F37)
(:count-down-nv #x9089)
(:count-up-nv #x9088)
(:counter-range-amd #x8BC1)
(:counter-type-amd #x8BC0)
(:coverage-all-fragments-nv #x8ED5)
(:coverage-attachment-nv #x8ED2)
(:coverage-automatic-nv #x8ED7)
(:coverage-buffer-bit-nv #x8000)
(:coverage-buffers-nv #x8ED3)
(:coverage-component-nv #x8ED0)
(:coverage-component4-nv #x8ED1)
(:coverage-edge-fragments-nv #x8ED6)
(:coverage-modulation-nv #x9332)
(:coverage-modulation-table-nv #x9331)
(:coverage-modulation-table-size-nv #x9333)
(:coverage-samples-nv #x8ED4)
(:cpu-optimized-qcom #x8FB1)
(:cubic-curve-to-nv #xC)
(:cubic-ext #x8334)
(:cubic-hp #x815F)
(:cull-face #xB44)
(:cull-face-mode #xB45)
(:cull-fragment-nv #x86E7)
(:cull-modes-nv #x86E0)
(:cull-vertex-ext #x81AA)
(:cull-vertex-eye-position-ext #x81AB)
(:cull-vertex-ibm #x1928A)
(:cull-vertex-object-position-ext #x81AC)
(:current-attrib-nv #x8626)
(:current-binormal-ext #x843C)
(:current-bit #x1)
(:current-color #xB00)
(:current-fog-coord #x8453)
(:current-fog-coordinate #x8453)
(:current-fog-coordinate-ext #x8453)
(:current-index #xB01)
(:current-matrix-arb #x8641)
(:current-matrix-index-arb #x8845)
(:current-matrix-nv #x8641)
(:current-matrix-stack-depth-arb #x8640)
(:current-matrix-stack-depth-nv #x8640)
(:current-normal #xB02)
(:current-occlusion-query-id-nv #x8865)
(:current-palette-matrix-arb #x8843)
(:current-palette-matrix-oes #x8843)
(:current-program #x8B8D)
(:current-query #x8865)
(:current-query-arb #x8865)
(:current-query-ext #x8865)
(:current-raster-color #xB04)
(:current-raster-distance #xB09)
(:current-raster-index #xB05)
(:current-raster-normal-sgix #x8406)
(:current-raster-position #xB07)
(:current-raster-position-valid #xB08)
(:current-raster-secondary-color #x845F)
(:current-raster-texture-coords #xB06)
(:current-secondary-color #x8459)
(:current-secondary-color-ext #x8459)
(:current-tangent-ext #x843B)
(:current-texture-coords #xB03)
(:current-time-nv #x8E28)
(:current-vertex-attrib #x8626)
(:current-vertex-attrib-arb #x8626)
(:current-vertex-ext #x87E2)
(:current-vertex-weight-ext #x850B)
(:current-weight-arb #x86A8)
(:cw #x900)
(:darken #x9297)
(:darken-khr #x9297)
(:darken-nv #x9297)
(:data-buffer-amd #x9151)
(:debug-assert-mesa #x875B)
(:debug-callback-function #x8244)
(:debug-callback-function-arb #x8244)
(:debug-callback-function-khr #x8244)
(:debug-callback-user-param #x8245)
(:debug-callback-user-param-arb #x8245)
(:debug-callback-user-param-khr #x8245)
(:debug-category-api-error-amd #x9149)
(:debug-category-application-amd #x914F)
(:debug-category-deprecation-amd #x914B)
(:debug-category-other-amd #x9150)
(:debug-category-performance-amd #x914D)
(:debug-category-shader-compiler-amd #x914E)
(:debug-category-undefined-behavior-amd #x914C)
(:debug-category-window-system-amd #x914A)
(:debug-group-stack-depth #x826D)
(:debug-group-stack-depth-khr #x826D)
(:debug-logged-messages #x9145)
(:debug-logged-messages-amd #x9145)
(:debug-logged-messages-arb #x9145)
(:debug-logged-messages-khr #x9145)
(:debug-next-logged-message-length #x8243)
(:debug-next-logged-message-length-arb #x8243)
(:debug-next-logged-message-length-khr #x8243)
(:debug-object-mesa #x8759)
(:debug-output #x92E0)
(:debug-output-khr #x92E0)
(:debug-output-synchronous #x8242)
(:debug-output-synchronous-arb #x8242)
(:debug-output-synchronous-khr #x8242)
(:debug-print-mesa #x875A)
(:debug-severity-high #x9146)
(:debug-severity-high-amd #x9146)
(:debug-severity-high-arb #x9146)
(:debug-severity-high-khr #x9146)
(:debug-severity-low #x9148)
(:debug-severity-low-amd #x9148)
(:debug-severity-low-arb #x9148)
(:debug-severity-low-khr #x9148)
(:debug-severity-medium #x9147)
(:debug-severity-medium-amd #x9147)
(:debug-severity-medium-arb #x9147)
(:debug-severity-medium-khr #x9147)
(:debug-severity-notification #x826B)
(:debug-severity-notification-khr #x826B)
(:debug-source-api #x8246)
(:debug-source-api-arb #x8246)
(:debug-source-api-khr #x8246)
(:debug-source-application #x824A)
(:debug-source-application-arb #x824A)
(:debug-source-application-khr #x824A)
(:debug-source-other #x824B)
(:debug-source-other-arb #x824B)
(:debug-source-other-khr #x824B)
(:debug-source-shader-compiler #x8248)
(:debug-source-shader-compiler-arb #x8248)
(:debug-source-shader-compiler-khr #x8248)
(:debug-source-third-party #x8249)
(:debug-source-third-party-arb #x8249)
(:debug-source-third-party-khr #x8249)
(:debug-source-window-system #x8247)
(:debug-source-window-system-arb #x8247)
(:debug-source-window-system-khr #x8247)
(:debug-type-deprecated-behavior #x824D)
(:debug-type-deprecated-behavior-arb #x824D)
(:debug-type-deprecated-behavior-khr #x824D)
(:debug-type-error #x824C)
(:debug-type-error-arb #x824C)
(:debug-type-error-khr #x824C)
(:debug-type-marker #x8268)
(:debug-type-marker-khr #x8268)
(:debug-type-other #x8251)
(:debug-type-other-arb #x8251)
(:debug-type-other-khr #x8251)
(:debug-type-performance #x8250)
(:debug-type-performance-arb #x8250)
(:debug-type-performance-khr #x8250)
(:debug-type-pop-group #x826A)
(:debug-type-pop-group-khr #x826A)
(:debug-type-portability #x824F)
(:debug-type-portability-arb #x824F)
(:debug-type-portability-khr #x824F)
(:debug-type-push-group #x8269)
(:debug-type-push-group-khr #x8269)
(:debug-type-undefined-behavior #x824E)
(:debug-type-undefined-behavior-arb #x824E)
(:debug-type-undefined-behavior-khr #x824E)
(:decal #x2101)
(:decode-ext #x8A49)
(:decr #x1E03)
(:decr-wrap #x8508)
(:decr-wrap-ext #x8508)
(:decr-wrap-oes #x8508)
(:deformations-mask-sgix #x8196)
(:delete-status #x8B80)
(:dependent-ar-texture-2d-nv #x86E9)
(:dependent-gb-texture-2d-nv #x86EA)
(:dependent-hilo-texture-2d-nv #x8858)
(:dependent-rgb-texture-3d-nv #x8859)
(:dependent-rgb-texture-cube-map-nv #x885A)
(:depth #x1801)
(:depth-attachment #x8D00)
(:depth-attachment-ext #x8D00)
(:depth-attachment-oes #x8D00)
(:depth-bias #xD1F)
(:depth-bits #xD56)
(:depth-bounds-ext #x8891)
(:depth-bounds-test-ext #x8890)
(:depth-buffer-bit #x100)
(:depth-buffer-bit0-qcom #x100)
(:depth-buffer-bit1-qcom #x200)
(:depth-buffer-bit2-qcom #x400)
(:depth-buffer-bit3-qcom #x800)
(:depth-buffer-bit4-qcom #x1000)
(:depth-buffer-bit5-qcom #x2000)
(:depth-buffer-bit6-qcom #x4000)
(:depth-buffer-bit7-qcom #x8000)
(:depth-buffer-float-mode-nv #x8DAF)
(:depth-clamp #x864F)
(:depth-clamp-far-amd #x901F)
(:depth-clamp-near-amd #x901E)
(:depth-clamp-nv #x864F)
(:depth-clear-value #xB73)
(:depth-component #x1902)
(:depth-component16 #x81A5)
(:depth-component16-arb #x81A5)
(:depth-component16-nonlinear-nv #x8E2C)
(:depth-component16-oes #x81A5)
(:depth-component16-sgix #x81A5)
(:depth-component24 #x81A6)
(:depth-component24-arb #x81A6)
(:depth-component24-oes #x81A6)
(:depth-component24-sgix #x81A6)
(:depth-component32 #x81A7)
(:depth-component32-arb #x81A7)
(:depth-component32-oes #x81A7)
(:depth-component32-sgix #x81A7)
(:depth-component32f #x8CAC)
(:depth-component32f-nv #x8DAB)
(:depth-components #x8284)
(:depth-ext #x1801)
(:depth-func #xB74)
(:depth-pass-instrument-counters-sgix #x8311)
(:depth-pass-instrument-max-sgix #x8312)
(:depth-pass-instrument-sgix #x8310)
(:depth-range #xB70)
(:depth-renderable #x8287)
(:depth-samples-nv #x932D)
(:depth-scale #xD1E)
(:depth-stencil #x84F9)
(:depth-stencil-attachment #x821A)
(:depth-stencil-ext #x84F9)
(:depth-stencil-mesa #x8750)
(:depth-stencil-nv #x84F9)
(:depth-stencil-oes #x84F9)
(:depth-stencil-texture-mode #x90EA)
(:depth-stencil-to-bgra-nv #x886F)
(:depth-stencil-to-rgba-nv #x886E)
(:depth-test #xB71)
(:depth-texture-mode #x884B)
(:depth-texture-mode-arb #x884B)
(:depth-writemask #xB72)
(:depth24-stencil8 #x88F0)
(:depth24-stencil8-ext #x88F0)
(:depth24-stencil8-oes #x88F0)
(:depth32f-stencil8 #x8CAD)
(:depth32f-stencil8-nv #x8DAC)
(:detail-texture-2d-binding-sgis #x8096)
(:detail-texture-2d-sgis #x8095)
(:detail-texture-func-points-sgis #x809C)
(:detail-texture-level-sgis #x809A)
(:detail-texture-mode-sgis #x809B)
(:difference #x929E)
(:difference-khr #x929E)
(:difference-nv #x929E)
(:diffuse #x1201)
(:discard-ati #x8763)
(:discard-nv #x8530)
(:discrete-amd #x9006)
(:disjoint-nv #x9283)
(:dispatch-indirect-buffer #x90EE)
(:dispatch-indirect-buffer-binding #x90EF)
(:display-list #x82E7)
(:distance-attenuation-ext #x8129)
(:distance-attenuation-sgis #x8129)
(:dither #xBD0)
(:dmp-program-binary-dmp #x9253)
(:domain #xA02)
(:dont-care #x1100)
(:dot-product-affine-depth-replace-nv #x885D)
(:dot-product-const-eye-reflect-cube-map-nv #x86F3)
(:dot-product-depth-replace-nv #x86ED)
(:dot-product-diffuse-cube-map-nv #x86F1)
(:dot-product-nv #x86EC)
(:dot-product-pass-through-nv #x885B)
(:dot-product-reflect-cube-map-nv #x86F2)
(:dot-product-texture-1d-nv #x885C)
(:dot-product-texture-2d-nv #x86EE)
(:dot-product-texture-3d-nv #x86EF)
(:dot-product-texture-cube-map-nv #x86F0)
(:dot-product-texture-rectangle-nv #x864E)
(:dot2-add-ati #x896C)
(:dot3-ati #x8966)
(:dot3-rgb #x86AE)
(:dot3-rgb-arb #x86AE)
(:dot3-rgb-ext #x8740)
(:dot3-rgba #x86AF)
(:dot3-rgba-arb #x86AF)
(:dot3-rgba-ext #x8741)
(:dot3-rgba-img #x86AF)
(:dot4-ati #x8967)
(:double #x140A)
(:double-ext #x140A)
(:double-mat2 #x8F46)
(:double-mat2-ext #x8F46)
(:double-mat2x3 #x8F49)
(:double-mat2x3-ext #x8F49)
(:double-mat2x4 #x8F4A)
(:double-mat2x4-ext #x8F4A)
(:double-mat3 #x8F47)
(:double-mat3-ext #x8F47)
(:double-mat3x2 #x8F4B)
(:double-mat3x2-ext #x8F4B)
(:double-mat3x4 #x8F4C)
(:double-mat3x4-ext #x8F4C)
(:double-mat4 #x8F48)
(:double-mat4-ext #x8F48)
(:double-mat4x2 #x8F4D)
(:double-mat4x2-ext #x8F4D)
(:double-mat4x3 #x8F4E)
(:double-mat4x3-ext #x8F4E)
(:double-vec2 #x8FFC)
(:double-vec2-ext #x8FFC)
(:double-vec3 #x8FFD)
(:double-vec3-ext #x8FFD)
(:double-vec4 #x8FFE)
(:double-vec4-ext #x8FFE)
(:doublebuffer #xC32)
(:draw-arrays-command-nv #x3)
(:draw-arrays-instanced-command-nv #x7)
(:draw-arrays-strip-command-nv #x5)
(:draw-buffer #xC01)
(:draw-buffer-ext #xC01)
(:draw-buffer0 #x8825)
(:draw-buffer0-arb #x8825)
(:draw-buffer0-ati #x8825)
(:draw-buffer0-ext #x8825)
(:draw-buffer0-nv #x8825)
(:draw-buffer1 #x8826)
(:draw-buffer1-arb #x8826)
(:draw-buffer1-ati #x8826)
(:draw-buffer1-ext #x8826)
(:draw-buffer1-nv #x8826)
(:draw-buffer10 #x882F)
(:draw-buffer10-arb #x882F)
(:draw-buffer10-ati #x882F)
(:draw-buffer10-ext #x882F)
(:draw-buffer10-nv #x882F)
(:draw-buffer11 #x8830)
(:draw-buffer11-arb #x8830)
(:draw-buffer11-ati #x8830)
(:draw-buffer11-ext #x8830)
(:draw-buffer11-nv #x8830)
(:draw-buffer12 #x8831)
(:draw-buffer12-arb #x8831)
(:draw-buffer12-ati #x8831)
(:draw-buffer12-ext #x8831)
(:draw-buffer12-nv #x8831)
(:draw-buffer13 #x8832)
(:draw-buffer13-arb #x8832)
(:draw-buffer13-ati #x8832)
(:draw-buffer13-ext #x8832)
(:draw-buffer13-nv #x8832)
(:draw-buffer14 #x8833)
(:draw-buffer14-arb #x8833)
(:draw-buffer14-ati #x8833)
(:draw-buffer14-ext #x8833)
(:draw-buffer14-nv #x8833)
(:draw-buffer15 #x8834)
(:draw-buffer15-arb #x8834)
(:draw-buffer15-ati #x8834)
(:draw-buffer15-ext #x8834)
(:draw-buffer15-nv #x8834)
(:draw-buffer2 #x8827)
(:draw-buffer2-arb #x8827)
(:draw-buffer2-ati #x8827)
(:draw-buffer2-ext #x8827)
(:draw-buffer2-nv #x8827)
(:draw-buffer3 #x8828)
(:draw-buffer3-arb #x8828)
(:draw-buffer3-ati #x8828)
(:draw-buffer3-ext #x8828)
(:draw-buffer3-nv #x8828)
(:draw-buffer4 #x8829)
(:draw-buffer4-arb #x8829)
(:draw-buffer4-ati #x8829)
(:draw-buffer4-ext #x8829)
(:draw-buffer4-nv #x8829)
(:draw-buffer5 #x882A)
(:draw-buffer5-arb #x882A)
(:draw-buffer5-ati #x882A)
(:draw-buffer5-ext #x882A)
(:draw-buffer5-nv #x882A)
(:draw-buffer6 #x882B)
(:draw-buffer6-arb #x882B)
(:draw-buffer6-ati #x882B)
(:draw-buffer6-ext #x882B)
(:draw-buffer6-nv #x882B)
(:draw-buffer7 #x882C)
(:draw-buffer7-arb #x882C)
(:draw-buffer7-ati #x882C)
(:draw-buffer7-ext #x882C)
(:draw-buffer7-nv #x882C)
(:draw-buffer8 #x882D)
(:draw-buffer8-arb #x882D)
(:draw-buffer8-ati #x882D)
(:draw-buffer8-ext #x882D)
(:draw-buffer8-nv #x882D)
(:draw-buffer9 #x882E)
(:draw-buffer9-arb #x882E)
(:draw-buffer9-ati #x882E)
(:draw-buffer9-ext #x882E)
(:draw-buffer9-nv #x882E)
(:draw-elements-command-nv #x2)
(:draw-elements-instanced-command-nv #x6)
(:draw-elements-strip-command-nv #x4)
(:draw-framebuffer #x8CA9)
(:draw-framebuffer-angle #x8CA9)
(:draw-framebuffer-apple #x8CA9)
(:draw-framebuffer-binding #x8CA6)
(:draw-framebuffer-binding-angle #x8CA6)
(:draw-framebuffer-binding-apple #x8CA6)
(:draw-framebuffer-binding-ext #x8CA6)
(:draw-framebuffer-binding-nv #x8CA6)
(:draw-framebuffer-ext #x8CA9)
(:draw-framebuffer-nv #x8CA9)
(:draw-indirect-address-nv #x8F41)
(:draw-indirect-buffer #x8F3F)
(:draw-indirect-buffer-binding #x8F43)
(:draw-indirect-length-nv #x8F42)
(:draw-indirect-unified-nv #x8F40)
(:draw-pixel-token #x705)
(:draw-pixels-apple #x8A0A)
(:ds-bias-nv #x8716)
(:ds-scale-nv #x8710)
(:dsdt-mag-intensity-nv #x86DC)
(:dsdt-mag-nv #x86F6)
(:dsdt-mag-vib-nv #x86F7)
(:dsdt-nv #x86F5)
(:dsdt8-mag8-intensity8-nv #x870B)
(:dsdt8-mag8-nv #x870A)
(:dsdt8-nv #x8709)
(:dst-alpha #x304)
(:dst-atop-nv #x928F)
(:dst-color #x306)
(:dst-in-nv #x928B)
(:dst-nv #x9287)
(:dst-out-nv #x928D)
(:dst-over-nv #x9289)
(:dt-bias-nv #x8717)
(:dt-scale-nv #x8711)
(:du8dv8-ati #x877A)
(:dual-alpha12-sgis #x8112)
(:dual-alpha16-sgis #x8113)
(:dual-alpha4-sgis #x8110)
(:dual-alpha8-sgis #x8111)
(:dual-intensity12-sgis #x811A)
(:dual-intensity16-sgis #x811B)
(:dual-intensity4-sgis #x8118)
(:dual-intensity8-sgis #x8119)
(:dual-luminance-alpha4-sgis #x811C)
(:dual-luminance-alpha8-sgis #x811D)
(:dual-luminance12-sgis #x8116)
(:dual-luminance16-sgis #x8117)
(:dual-luminance4-sgis #x8114)
(:dual-luminance8-sgis #x8115)
(:dual-texture-select-sgis #x8124)
(:dudv-ati #x8779)
(:dup-first-cubic-curve-to-nv #xF2)
(:dup-last-cubic-curve-to-nv #xF4)
(:dynamic-ati #x8761)
(:dynamic-copy #x88EA)
(:dynamic-copy-arb #x88EA)
(:dynamic-draw #x88E8)
(:dynamic-draw-arb #x88E8)
(:dynamic-read #x88E9)
(:dynamic-read-arb #x88E9)
(:dynamic-storage-bit #x100)
(:dynamic-storage-bit-ext #x100)
(:e-times-f-nv #x8531)
(:edge-flag #xB43)
(:edge-flag-array #x8079)
(:edge-flag-array-address-nv #x8F26)
(:edge-flag-array-buffer-binding #x889B)
(:edge-flag-array-buffer-binding-arb #x889B)
(:edge-flag-array-count-ext #x808D)
(:edge-flag-array-ext #x8079)
(:edge-flag-array-length-nv #x8F30)
(:edge-flag-array-list-ibm #x192A3)
(:edge-flag-array-list-stride-ibm #x192AD)
(:edge-flag-array-pointer #x8093)
(:edge-flag-array-pointer-ext #x8093)
(:edge-flag-array-stride #x808C)
(:edge-flag-array-stride-ext #x808C)
(:edgeflag-bit-pgi #x40000)
(:effective-raster-samples-ext #x932C)
(:eighth-bit-ati #x20)
(:element-address-command-nv #x8)
(:element-array-address-nv #x8F29)
(:element-array-apple #x8A0C)
(:element-array-ati #x8768)
(:element-array-barrier-bit #x2)
(:element-array-barrier-bit-ext #x2)
(:element-array-buffer #x8893)
(:element-array-buffer-arb #x8893)
(:element-array-buffer-binding #x8895)
(:element-array-buffer-binding-arb #x8895)
(:element-array-length-nv #x8F33)
(:element-array-pointer-apple #x8A0E)
(:element-array-pointer-ati #x876A)
(:element-array-type-apple #x8A0D)
(:element-array-type-ati #x8769)
(:element-array-unified-nv #x8F1F)
(:emboss-constant-nv #x855E)
(:emboss-light-nv #x855D)
(:emboss-map-nv #x855F)
(:emission #x1600)
(:enable-bit #x2000)
(:equal #x202)
(:equiv #x1509)
(:etc1-rgb8-oes #x8D64)
(:etc1-srgb8-nv #x88EE)
(:eval-2d-nv #x86C0)
(:eval-bit #x10000)
(:eval-fractional-tessellation-nv #x86C5)
(:eval-triangular-2d-nv #x86C1)
(:eval-vertex-attrib0-nv #x86C6)
(:eval-vertex-attrib1-nv #x86C7)
(:eval-vertex-attrib10-nv #x86D0)
(:eval-vertex-attrib11-nv #x86D1)
(:eval-vertex-attrib12-nv #x86D2)
(:eval-vertex-attrib13-nv #x86D3)
(:eval-vertex-attrib14-nv #x86D4)
(:eval-vertex-attrib15-nv #x86D5)
(:eval-vertex-attrib2-nv #x86C8)
(:eval-vertex-attrib3-nv #x86C9)
(:eval-vertex-attrib4-nv #x86CA)
(:eval-vertex-attrib5-nv #x86CB)
(:eval-vertex-attrib6-nv #x86CC)
(:eval-vertex-attrib7-nv #x86CD)
(:eval-vertex-attrib8-nv #x86CE)
(:eval-vertex-attrib9-nv #x86CF)
(:exclusion #x92A0)
(:exclusion-khr #x92A0)
(:exclusion-nv #x92A0)
(:exp #x800)
(:exp2 #x801)
(:expand-negate-nv #x8539)
(:expand-normal-nv #x8538)
(:extensions #x1F03)
(:external-virtual-memory-buffer-amd #x9160)
(:eye-distance-to-line-sgis #x81F2)
(:eye-distance-to-point-sgis #x81F0)
(:eye-line-sgis #x81F6)
(:eye-linear #x2400)
(:eye-linear-nv #x2400)
(:eye-plane #x2502)
(:eye-plane-absolute-nv #x855C)
(:eye-point-sgis #x81F4)
(:eye-radial-nv #x855B)
(:factor-alpha-modulate-img #x8C07)
(:factor-max-amd #x901D)
(:factor-min-amd #x901C)
(:failure-nv #x9030)
(:false #x0)
(:fastest #x1101)
(:feedback #x1C01)
(:feedback-buffer-pointer #xDF0)
(:feedback-buffer-size #xDF1)
(:feedback-buffer-type #xDF2)
(:fence-apple #x8A0B)
(:fence-condition-nv #x84F4)
(:fence-status-nv #x84F3)
(:fetch-per-sample-arm #x8F65)
(:field-lower-nv #x9023)
(:field-upper-nv #x9022)
(:fields-nv #x8E27)
(:file-name-nv #x9074)
(:fill #x1B02)
(:fill-nv #x1B02)
(:fill-rectangle-nv #x933C)
(:filter #x829A)
(:filter4-sgis #x8146)
(:first-to-rest-nv #x90AF)
(:first-vertex-convention #x8E4D)
(:first-vertex-convention-ext #x8E4D)
(:first-vertex-convention-oes #x8E4D)
(:fixed #x140C)
(:fixed-oes #x140C)
(:fixed-only #x891D)
(:fixed-only-arb #x891D)
(:flat #x1D00)
(:float #x1406)
(:float-32-unsigned-int-24-8-rev #x8DAD)
(:float-32-unsigned-int-24-8-rev-nv #x8DAD)
(:float-clear-color-value-nv #x888D)
(:float-mat2 #x8B5A)
(:float-mat2-arb #x8B5A)
(:float-mat2x3 #x8B65)
(:float-mat2x3-nv #x8B65)
(:float-mat2x4 #x8B66)
(:float-mat2x4-nv #x8B66)
(:float-mat3 #x8B5B)
(:float-mat3-arb #x8B5B)
(:float-mat3x2 #x8B67)
(:float-mat3x2-nv #x8B67)
(:float-mat3x4 #x8B68)
(:float-mat3x4-nv #x8B68)
(:float-mat4 #x8B5C)
(:float-mat4-arb #x8B5C)
(:float-mat4x2 #x8B69)
(:float-mat4x2-nv #x8B69)
(:float-mat4x3 #x8B6A)
(:float-mat4x3-nv #x8B6A)
(:float-r-nv #x8880)
(:float-r16-nv #x8884)
(:float-r32-nv #x8885)
(:float-rg-nv #x8881)
(:float-rg16-nv #x8886)
(:float-rg32-nv #x8887)
(:float-rgb-nv #x8882)
(:float-rgb16-nv #x8888)
(:float-rgb32-nv #x8889)
(:float-rgba-mode-nv #x888E)
(:float-rgba-nv #x8883)
(:float-rgba16-nv #x888A)
(:float-rgba32-nv #x888B)
(:float-vec2 #x8B50)
(:float-vec2-arb #x8B50)
(:float-vec3 #x8B51)
(:float-vec3-arb #x8B51)
(:float-vec4 #x8B52)
(:float-vec4-arb #x8B52)
(:float16-nv #x8FF8)
(:float16-vec2-nv #x8FF9)
(:float16-vec3-nv #x8FFA)
(:float16-vec4-nv #x8FFB)
(:fog #xB60)
(:fog-bit #x80)
(:fog-color #xB66)
(:fog-coord #x8451)
(:fog-coord-array #x8457)
(:fog-coord-array-address-nv #x8F28)
(:fog-coord-array-buffer-binding #x889D)
(:fog-coord-array-length-nv #x8F32)
(:fog-coord-array-pointer #x8456)
(:fog-coord-array-stride #x8455)
(:fog-coord-array-type #x8454)
(:fog-coord-src #x8450)
(:fog-coordinate #x8451)
(:fog-coordinate-array #x8457)
(:fog-coordinate-array-buffer-binding #x889D)
(:fog-coordinate-array-buffer-binding-arb #x889D)
(:fog-coordinate-array-ext #x8457)
(:fog-coordinate-array-list-ibm #x192A4)
(:fog-coordinate-array-list-stride-ibm #x192AE)
(:fog-coordinate-array-pointer #x8456)
(:fog-coordinate-array-pointer-ext #x8456)
(:fog-coordinate-array-stride #x8455)
(:fog-coordinate-array-stride-ext #x8455)
(:fog-coordinate-array-type #x8454)
(:fog-coordinate-array-type-ext #x8454)
(:fog-coordinate-ext #x8451)
(:fog-coordinate-source #x8450)
(:fog-coordinate-source-ext #x8450)
(:fog-density #xB62)
(:fog-distance-mode-nv #x855A)
(:fog-end #xB64)
(:fog-func-points-sgis #x812B)
(:fog-func-sgis #x812A)
(:fog-hint #xC54)
(:fog-index #xB61)
(:fog-mode #xB65)
(:fog-offset-sgix #x8198)
(:fog-offset-value-sgix #x8199)
(:fog-specular-texture-win #x80EC)
(:fog-start #xB63)
(:font-ascender-bit-nv #x200000)
(:font-descender-bit-nv #x400000)
(:font-glyphs-available-nv #x9368)
(:font-has-kerning-bit-nv #x10000000)
(:font-height-bit-nv #x800000)
(:font-max-advance-height-bit-nv #x2000000)
(:font-max-advance-width-bit-nv #x1000000)
(:font-num-glyph-indices-bit-nv #x20000000)
(:font-target-unavailable-nv #x9369)
(:font-unavailable-nv #x936A)
(:font-underline-position-bit-nv #x4000000)
(:font-underline-thickness-bit-nv #x8000000)
(:font-unintelligible-nv #x936B)
(:font-units-per-em-bit-nv #x100000)
(:font-x-max-bounds-bit-nv #x40000)
(:font-x-min-bounds-bit-nv #x10000)
(:font-y-max-bounds-bit-nv #x80000)
(:font-y-min-bounds-bit-nv #x20000)
(:force-blue-to-one-nv #x8860)
(:format-subsample-24-24-oml #x8982)
(:format-subsample-244-244-oml #x8983)
(:fractional-even #x8E7C)
(:fractional-even-ext #x8E7C)
(:fractional-even-oes #x8E7C)
(:fractional-odd #x8E7B)
(:fractional-odd-ext #x8E7B)
(:fractional-odd-oes #x8E7B)
(:fragment-alpha-modulate-img #x8C08)
(:fragment-color-ext #x834C)
(:fragment-color-material-face-sgix #x8402)
(:fragment-color-material-parameter-sgix #x8403)
(:fragment-color-material-sgix #x8401)
(:fragment-coverage-color-nv #x92DE)
(:fragment-coverage-to-color-nv #x92DD)
(:fragment-depth #x8452)
(:fragment-depth-ext #x8452)
(:fragment-input-nv #x936D)
(:fragment-interpolation-offset-bits #x8E5D)
(:fragment-interpolation-offset-bits-oes #x8E5D)
(:fragment-light-model-ambient-sgix #x840A)
(:fragment-light-model-local-viewer-sgix #x8408)
(:fragment-light-model-normal-interpolation-sgix #x840B)
(:fragment-light-model-two-side-sgix #x8409)
(:fragment-light0-sgix #x840C)
(:fragment-light1-sgix #x840D)
(:fragment-light2-sgix #x840E)
(:fragment-light3-sgix #x840F)
(:fragment-light4-sgix #x8410)
(:fragment-light5-sgix #x8411)
(:fragment-light6-sgix #x8412)
(:fragment-light7-sgix #x8413)
(:fragment-lighting-sgix #x8400)
(:fragment-material-ext #x8349)
(:fragment-normal-ext #x834A)
(:fragment-program-arb #x8804)
(:fragment-program-binding-nv #x8873)
(:fragment-program-callback-data-mesa #x8BB3)
(:fragment-program-callback-func-mesa #x8BB2)
(:fragment-program-callback-mesa #x8BB1)
(:fragment-program-interpolation-offset-bits-nv #x8E5D)
(:fragment-program-nv #x8870)
(:fragment-program-parameter-buffer-nv #x8DA4)
(:fragment-program-position-mesa #x8BB0)
(:fragment-shader #x8B30)
(:fragment-shader-arb #x8B30)
(:fragment-shader-ati #x8920)
(:fragment-shader-bit #x2)
(:fragment-shader-bit-ext #x2)
(:fragment-shader-derivative-hint #x8B8B)
(:fragment-shader-derivative-hint-arb #x8B8B)
(:fragment-shader-derivative-hint-oes #x8B8B)
(:fragment-shader-discards-samples-ext #x8A52)
(:fragment-shader-framebuffer-fetch-mrt-arm #x8F66)
(:fragment-shader-invocations-arb #x82F4)
(:fragment-subroutine #x92EC)
(:fragment-subroutine-uniform #x92F2)
(:fragment-texture #x829F)
(:fragments-instrument-counters-sgix #x8314)
(:fragments-instrument-max-sgix #x8315)
(:fragments-instrument-sgix #x8313)
(:frame-nv #x8E26)
(:framebuffer #x8D40)
(:framebuffer-attachment-alpha-size #x8215)
(:framebuffer-attachment-angle #x93A3)
(:framebuffer-attachment-blue-size #x8214)
(:framebuffer-attachment-color-encoding #x8210)
(:framebuffer-attachment-color-encoding-ext #x8210)
(:framebuffer-attachment-component-type #x8211)
(:framebuffer-attachment-component-type-ext #x8211)
(:framebuffer-attachment-depth-size #x8216)
(:framebuffer-attachment-green-size #x8213)
(:framebuffer-attachment-layered #x8DA7)
(:framebuffer-attachment-layered-arb #x8DA7)
(:framebuffer-attachment-layered-ext #x8DA7)
(:framebuffer-attachment-layered-oes #x8DA7)
(:framebuffer-attachment-object-name #x8CD1)
(:framebuffer-attachment-object-name-ext #x8CD1)
(:framebuffer-attachment-object-name-oes #x8CD1)
(:framebuffer-attachment-object-type #x8CD0)
(:framebuffer-attachment-object-type-ext #x8CD0)
(:framebuffer-attachment-object-type-oes #x8CD0)
(:framebuffer-attachment-red-size #x8212)
(:framebuffer-attachment-stencil-size #x8217)
(:framebuffer-attachment-texture-3d-zoffset-ext #x8CD4)
(:framebuffer-attachment-texture-3d-zoffset-oes #x8CD4)
(:framebuffer-attachment-texture-base-view-index-ovr #x9632)
(:framebuffer-attachment-texture-cube-map-face #x8CD3)
(:framebuffer-attachment-texture-cube-map-face-ext #x8CD3)
(:framebuffer-attachment-texture-cube-map-face-oes #x8CD3)
(:framebuffer-attachment-texture-layer #x8CD4)
(:framebuffer-attachment-texture-layer-ext #x8CD4)
(:framebuffer-attachment-texture-level #x8CD2)
(:framebuffer-attachment-texture-level-ext #x8CD2)
(:framebuffer-attachment-texture-level-oes #x8CD2)
(:framebuffer-attachment-texture-num-views-ovr #x9630)
(:framebuffer-attachment-texture-samples-ext #x8D6C)
(:framebuffer-barrier-bit #x400)
(:framebuffer-barrier-bit-ext #x400)
(:framebuffer-binding #x8CA6)
(:framebuffer-binding-angle #x8CA6)
(:framebuffer-binding-ext #x8CA6)
(:framebuffer-binding-oes #x8CA6)
(:framebuffer-blend #x828B)
(:framebuffer-complete #x8CD5)
(:framebuffer-complete-ext #x8CD5)
(:framebuffer-complete-oes #x8CD5)
(:framebuffer-default #x8218)
(:framebuffer-default-fixed-sample-locations #x9314)
(:framebuffer-default-height #x9311)
(:framebuffer-default-layers #x9312)
(:framebuffer-default-layers-ext #x9312)
(:framebuffer-default-layers-oes #x9312)
(:framebuffer-default-samples #x9313)
(:framebuffer-default-width #x9310)
(:framebuffer-ext #x8D40)
(:framebuffer-incomplete-attachment #x8CD6)
(:framebuffer-incomplete-attachment-ext #x8CD6)
(:framebuffer-incomplete-attachment-oes #x8CD6)
(:framebuffer-incomplete-dimensions #x8CD9)
(:framebuffer-incomplete-dimensions-ext #x8CD9)
(:framebuffer-incomplete-dimensions-oes #x8CD9)
(:framebuffer-incomplete-draw-buffer #x8CDB)
(:framebuffer-incomplete-draw-buffer-ext #x8CDB)
(:framebuffer-incomplete-draw-buffer-oes #x8CDB)
(:framebuffer-incomplete-formats-ext #x8CDA)
(:framebuffer-incomplete-formats-oes #x8CDA)
(:framebuffer-incomplete-layer-count-arb #x8DA9)
(:framebuffer-incomplete-layer-count-ext #x8DA9)
(:framebuffer-incomplete-layer-targets #x8DA8)
(:framebuffer-incomplete-layer-targets-arb #x8DA8)
(:framebuffer-incomplete-layer-targets-ext #x8DA8)
(:framebuffer-incomplete-layer-targets-oes #x8DA8)
(:framebuffer-incomplete-missing-attachment #x8CD7)
(:framebuffer-incomplete-missing-attachment-ext #x8CD7)
(:framebuffer-incomplete-missing-attachment-oes #x8CD7)
(:framebuffer-incomplete-multisample #x8D56)
(:framebuffer-incomplete-multisample-angle #x8D56)
(:framebuffer-incomplete-multisample-apple #x8D56)
(:framebuffer-incomplete-multisample-ext #x8D56)
(:framebuffer-incomplete-multisample-img #x9134)
(:framebuffer-incomplete-multisample-nv #x8D56)
(:framebuffer-incomplete-read-buffer #x8CDC)
(:framebuffer-incomplete-read-buffer-ext #x8CDC)
(:framebuffer-incomplete-read-buffer-oes #x8CDC)
(:framebuffer-oes #x8D40)
(:framebuffer-programmable-sample-locations-arb #x9342)
(:framebuffer-programmable-sample-locations-nv #x9342)
(:framebuffer-renderable #x8289)
(:framebuffer-renderable-layered #x828A)
(:framebuffer-sample-location-pixel-grid-arb #x9343)
(:framebuffer-sample-location-pixel-grid-nv #x9343)
(:framebuffer-srgb #x8DB9)
(:framebuffer-srgb-capable-ext #x8DBA)
(:framebuffer-srgb-ext #x8DB9)
(:framebuffer-undefined #x8219)
(:framebuffer-undefined-oes #x8219)
(:framebuffer-unsupported #x8CDD)
(:framebuffer-unsupported-ext #x8CDD)
(:framebuffer-unsupported-oes #x8CDD)
(:framezoom-factor-sgix #x818C)
(:framezoom-sgix #x818B)
(:front #x404)
(:front-and-back #x408)
(:front-face #xB46)
(:front-face-command-nv #x12)
(:front-left #x400)
(:front-right #x401)
(:full-range-ext #x87E1)
(:full-stipple-hint-pgi #x1A219)
(:full-support #x82B7)
(:func-add #x8006)
(:func-add-ext #x8006)
(:func-add-oes #x8006)
(:func-reverse-subtract #x800B)
(:func-reverse-subtract-ext #x800B)
(:func-reverse-subtract-oes #x800B)
(:func-subtract #x800A)
(:func-subtract-ext #x800A)
(:func-subtract-oes #x800A)
(:gccso-shader-binary-fj #x9260)
(:generate-mipmap #x8191)
(:generate-mipmap-hint #x8192)
(:generate-mipmap-hint-sgis #x8192)
(:generate-mipmap-sgis #x8191)
(:generic-attrib-nv #x8C7D)
(:geometry-deformation-bit-sgix #x2)
(:geometry-deformation-sgix #x8194)
(:geometry-input-type #x8917)
(:geometry-input-type-arb #x8DDB)
(:geometry-input-type-ext #x8DDB)
(:geometry-linked-input-type-ext #x8917)
(:geometry-linked-input-type-oes #x8917)
(:geometry-linked-output-type-ext #x8918)
(:geometry-linked-output-type-oes #x8918)
(:geometry-linked-vertices-out-ext #x8916)
(:geometry-linked-vertices-out-oes #x8916)
(:geometry-output-type #x8918)
(:geometry-output-type-arb #x8DDC)
(:geometry-output-type-ext #x8DDC)
(:geometry-program-nv #x8C26)
(:geometry-program-parameter-buffer-nv #x8DA3)
(:geometry-shader #x8DD9)
(:geometry-shader-arb #x8DD9)
(:geometry-shader-bit #x4)
(:geometry-shader-bit-ext #x4)
(:geometry-shader-bit-oes #x4)
(:geometry-shader-ext #x8DD9)
(:geometry-shader-invocations #x887F)
(:geometry-shader-invocations-ext #x887F)
(:geometry-shader-invocations-oes #x887F)
(:geometry-shader-oes #x8DD9)
(:geometry-shader-primitives-emitted-arb #x82F3)
(:geometry-subroutine #x92EB)
(:geometry-subroutine-uniform #x92F1)
(:geometry-texture #x829E)
(:geometry-vertices-out #x8916)
(:geometry-vertices-out-arb #x8DDA)
(:geometry-vertices-out-ext #x8DDA)
(:gequal #x206)
(:get-texture-image-format #x8291)
(:get-texture-image-type #x8292)
(:global-alpha-factor-sun #x81DA)
(:global-alpha-sun #x81D9)
(:glyph-has-kerning-bit-nv #x100)
(:glyph-height-bit-nv #x2)
(:glyph-horizontal-bearing-advance-bit-nv #x10)
(:glyph-horizontal-bearing-x-bit-nv #x4)
(:glyph-horizontal-bearing-y-bit-nv #x8)
(:glyph-vertical-bearing-advance-bit-nv #x80)
(:glyph-vertical-bearing-x-bit-nv #x20)
(:glyph-vertical-bearing-y-bit-nv #x40)
(:glyph-width-bit-nv #x1)
(:gpu-address-nv #x8F34)
(:gpu-disjoint-ext #x8FBB)
(:gpu-memory-info-current-available-vidmem-nvx #x9049)
(:gpu-memory-info-dedicated-vidmem-nvx #x9047)
(:gpu-memory-info-evicted-memory-nvx #x904B)
(:gpu-memory-info-eviction-count-nvx #x904A)
(:gpu-memory-info-total-available-memory-nvx #x9048)
(:gpu-optimized-qcom #x8FB2)
(:greater #x204)
(:green #x1904)
(:green-bias #xD19)
(:green-bit-ati #x2)
(:green-bits #xD53)
(:green-integer #x8D95)
(:green-integer-ext #x8D95)
(:green-max-clamp-ingr #x8565)
(:green-min-clamp-ingr #x8561)
(:green-nv #x1904)
(:green-scale #xD18)
(:gs-program-binary-mtk #x9641)
(:gs-shader-binary-mtk #x9640)
(:guilty-context-reset #x8253)
(:guilty-context-reset-arb #x8253)
(:guilty-context-reset-ext #x8253)
(:guilty-context-reset-khr #x8253)
(:half-apple #x140B)
(:half-bias-negate-nv #x853B)
(:half-bias-normal-nv #x853A)
(:half-bit-ati #x8)
(:half-float #x140B)
(:half-float-arb #x140B)
(:half-float-nv #x140B)
(:half-float-oes #x8D61)
(:hardlight #x929B)
(:hardlight-khr #x929B)
(:hardlight-nv #x929B)
(:hardmix-nv #x92A9)
(:hi-bias-nv #x8714)
(:hi-scale-nv #x870E)
(:high-float #x8DF2)
(:high-int #x8DF5)
(:hilo-nv #x86F4)
(:hilo16-nv #x86F8)
(:hilo8-nv #x885E)
(:hint-bit #x8000)
(:histogram #x8024)
(:histogram-alpha-size #x802B)
(:histogram-alpha-size-ext #x802B)
(:histogram-blue-size #x802A)
(:histogram-blue-size-ext #x802A)
(:histogram-ext #x8024)
(:histogram-format #x8027)
(:histogram-format-ext #x8027)
(:histogram-green-size #x8029)
(:histogram-green-size-ext #x8029)
(:histogram-luminance-size #x802C)
(:histogram-luminance-size-ext #x802C)
(:histogram-red-size #x8028)
(:histogram-red-size-ext #x8028)
(:histogram-sink #x802D)
(:histogram-sink-ext #x802D)
(:histogram-width #x8026)
(:histogram-width-ext #x8026)
(:horizontal-line-to-nv #x6)
(:hsl-color #x92AF)
(:hsl-color-khr #x92AF)
(:hsl-color-nv #x92AF)
(:hsl-hue #x92AD)
(:hsl-hue-khr #x92AD)
(:hsl-hue-nv #x92AD)
(:hsl-luminosity #x92B0)
(:hsl-luminosity-khr #x92B0)
(:hsl-luminosity-nv #x92B0)
(:hsl-saturation #x92AE)
(:hsl-saturation-khr #x92AE)
(:hsl-saturation-nv #x92AE)
(:identity-nv #x862A)
(:ignore-border-hp #x8150)
(:image-1d #x904C)
(:image-1d-array #x9052)
(:image-1d-array-ext #x9052)
(:image-1d-ext #x904C)
(:image-2d #x904D)
(:image-2d-array #x9053)
(:image-2d-array-ext #x9053)
(:image-2d-ext #x904D)
(:image-2d-multisample #x9055)
(:image-2d-multisample-array #x9056)
(:image-2d-multisample-array-ext #x9056)
(:image-2d-multisample-ext #x9055)
(:image-2d-rect #x904F)
(:image-2d-rect-ext #x904F)
(:image-3d #x904E)
(:image-3d-ext #x904E)
(:image-binding-access #x8F3E)
(:image-binding-access-ext #x8F3E)
(:image-binding-format #x906E)
(:image-binding-format-ext #x906E)
(:image-binding-layer #x8F3D)
(:image-binding-layer-ext #x8F3D)
(:image-binding-layered #x8F3C)
(:image-binding-layered-ext #x8F3C)
(:image-binding-level #x8F3B)
(:image-binding-level-ext #x8F3B)
(:image-binding-name #x8F3A)
(:image-binding-name-ext #x8F3A)
(:image-buffer #x9051)
(:image-buffer-ext #x9051)
(:image-buffer-oes #x9051)
(:image-class-1-x-16 #x82BE)
(:image-class-1-x-32 #x82BB)
(:image-class-1-x-8 #x82C1)
(:image-class-10-10-10-2 #x82C3)
(:image-class-11-11-10 #x82C2)
(:image-class-2-x-16 #x82BD)
(:image-class-2-x-32 #x82BA)
(:image-class-2-x-8 #x82C0)
(:image-class-4-x-16 #x82BC)
(:image-class-4-x-32 #x82B9)
(:image-class-4-x-8 #x82BF)
(:image-compatibility-class #x82A8)
(:image-cube #x9050)
(:image-cube-ext #x9050)
(:image-cube-map-array #x9054)
(:image-cube-map-array-ext #x9054)
(:image-cube-map-array-oes #x9054)
(:image-cubic-weight-hp #x815E)
(:image-format-compatibility-by-class #x90C9)
(:image-format-compatibility-by-size #x90C8)
(:image-format-compatibility-type #x90C7)
(:image-mag-filter-hp #x815C)
(:image-min-filter-hp #x815D)
(:image-pixel-format #x82A9)
(:image-pixel-type #x82AA)
(:image-rotate-angle-hp #x8159)
(:image-rotate-origin-x-hp #x815A)
(:image-rotate-origin-y-hp #x815B)
(:image-scale-x-hp #x8155)
(:image-scale-y-hp #x8156)
(:image-texel-size #x82A7)
(:image-transform-2d-hp #x8161)
(:image-translate-x-hp #x8157)
(:image-translate-y-hp #x8158)
(:implementation-color-read-format #x8B9B)
(:implementation-color-read-format-oes #x8B9B)
(:implementation-color-read-type #x8B9A)
(:implementation-color-read-type-oes #x8B9A)
(:incr #x1E02)
(:incr-wrap #x8507)
(:incr-wrap-ext #x8507)
(:incr-wrap-oes #x8507)
(:index #x8222)
(:index-array #x8077)
(:index-array-address-nv #x8F24)
(:index-array-buffer-binding #x8899)
(:index-array-buffer-binding-arb #x8899)
(:index-array-count-ext #x8087)
(:index-array-ext #x8077)
(:index-array-length-nv #x8F2E)
(:index-array-list-ibm #x192A1)
(:index-array-list-stride-ibm #x192AB)
(:index-array-pointer #x8091)
(:index-array-pointer-ext #x8091)
(:index-array-stride #x8086)
(:index-array-stride-ext #x8086)
(:index-array-type #x8085)
(:index-array-type-ext #x8085)
(:index-bit-pgi #x80000)
(:index-bits #xD51)
(:index-clear-value #xC20)
(:index-logic-op #xBF1)
(:index-material-ext #x81B8)
(:index-material-face-ext #x81BA)
(:index-material-parameter-ext #x81B9)
(:index-mode #xC30)
(:index-offset #xD13)
(:index-shift #xD12)
(:index-test-ext #x81B5)
(:index-test-func-ext #x81B6)
(:index-test-ref-ext #x81B7)
(:index-writemask #xC21)
(:info-log-length #x8B84)
(:innocent-context-reset #x8254)
(:innocent-context-reset-arb #x8254)
(:innocent-context-reset-ext #x8254)
(:innocent-context-reset-khr #x8254)
(:instrument-buffer-pointer-sgix #x8180)
(:instrument-measurements-sgix #x8181)
(:int #x1404)
(:int-10-10-10-2-oes #x8DF7)
(:int-2-10-10-10-rev #x8D9F)
(:int-image-1d #x9057)
(:int-image-1d-array #x905D)
(:int-image-1d-array-ext #x905D)
(:int-image-1d-ext #x9057)
(:int-image-2d #x9058)
(:int-image-2d-array #x905E)
(:int-image-2d-array-ext #x905E)
(:int-image-2d-ext #x9058)
(:int-image-2d-multisample #x9060)
(:int-image-2d-multisample-array #x9061)
(:int-image-2d-multisample-array-ext #x9061)
(:int-image-2d-multisample-ext #x9060)
(:int-image-2d-rect #x905A)
(:int-image-2d-rect-ext #x905A)
(:int-image-3d #x9059)
(:int-image-3d-ext #x9059)
(:int-image-buffer #x905C)
(:int-image-buffer-ext #x905C)
(:int-image-buffer-oes #x905C)
(:int-image-cube #x905B)
(:int-image-cube-ext #x905B)
(:int-image-cube-map-array #x905F)
(:int-image-cube-map-array-ext #x905F)
(:int-image-cube-map-array-oes #x905F)
(:int-sampler-1d #x8DC9)
(:int-sampler-1d-array #x8DCE)
(:int-sampler-1d-array-ext #x8DCE)
(:int-sampler-1d-ext #x8DC9)
(:int-sampler-2d #x8DCA)
(:int-sampler-2d-array #x8DCF)
(:int-sampler-2d-array-ext #x8DCF)
(:int-sampler-2d-ext #x8DCA)
(:int-sampler-2d-multisample #x9109)
(:int-sampler-2d-multisample-array #x910C)
(:int-sampler-2d-multisample-array-oes #x910C)
(:int-sampler-2d-rect #x8DCD)
(:int-sampler-2d-rect-ext #x8DCD)
(:int-sampler-3d #x8DCB)
(:int-sampler-3d-ext #x8DCB)
(:int-sampler-buffer #x8DD0)
(:int-sampler-buffer-amd #x9002)
(:int-sampler-buffer-ext #x8DD0)
(:int-sampler-buffer-oes #x8DD0)
(:int-sampler-cube #x8DCC)
(:int-sampler-cube-ext #x8DCC)
(:int-sampler-cube-map-array #x900E)
(:int-sampler-cube-map-array-arb #x900E)
(:int-sampler-cube-map-array-ext #x900E)
(:int-sampler-cube-map-array-oes #x900E)
(:int-sampler-renderbuffer-nv #x8E57)
(:int-vec2 #x8B53)
(:int-vec2-arb #x8B53)
(:int-vec3 #x8B54)
(:int-vec3-arb #x8B54)
(:int-vec4 #x8B55)
(:int-vec4-arb #x8B55)
(:int16-nv #x8FE4)
(:int16-vec2-nv #x8FE5)
(:int16-vec3-nv #x8FE6)
(:int16-vec4-nv #x8FE7)
(:int64-arb #x140E)
(:int64-nv #x140E)
(:int64-vec2-arb #x8FE9)
(:int64-vec2-nv #x8FE9)
(:int64-vec3-arb #x8FEA)
(:int64-vec3-nv #x8FEA)
(:int64-vec4-arb #x8FEB)
(:int64-vec4-nv #x8FEB)
(:int8-nv #x8FE0)
(:int8-vec2-nv #x8FE1)
(:int8-vec3-nv #x8FE2)
(:int8-vec4-nv #x8FE3)
(:intensity #x8049)
(:intensity-ext #x8049)
(:intensity-float16-apple #x881D)
(:intensity-float16-ati #x881D)
(:intensity-float32-apple #x8817)
(:intensity-float32-ati #x8817)
(:intensity-snorm #x9013)
(:intensity12 #x804C)
(:intensity12-ext #x804C)
(:intensity16 #x804D)
(:intensity16-ext #x804D)
(:intensity16-snorm #x901B)
(:intensity16f-arb #x881D)
(:intensity16i-ext #x8D8B)
(:intensity16ui-ext #x8D79)
(:intensity32f-arb #x8817)
(:intensity32i-ext #x8D85)
(:intensity32ui-ext #x8D73)
(:intensity4 #x804A)
(:intensity4-ext #x804A)
(:intensity8 #x804B)
(:intensity8-ext #x804B)
(:intensity8-snorm #x9017)
(:intensity8i-ext #x8D91)
(:intensity8ui-ext #x8D7F)
(:interlace-oml #x8980)
(:interlace-read-ingr #x8568)
(:interlace-read-oml #x8981)
(:interlace-sgix #x8094)
(:interleaved-attribs #x8C8C)
(:interleaved-attribs-ext #x8C8C)
(:interleaved-attribs-nv #x8C8C)
(:internalformat-alpha-size #x8274)
(:internalformat-alpha-type #x827B)
(:internalformat-blue-size #x8273)
(:internalformat-blue-type #x827A)
(:internalformat-depth-size #x8275)
(:internalformat-depth-type #x827C)
(:internalformat-green-size #x8272)
(:internalformat-green-type #x8279)
(:internalformat-preferred #x8270)
(:internalformat-red-size #x8271)
(:internalformat-red-type #x8278)
(:internalformat-shared-size #x8277)
(:internalformat-stencil-size #x8276)
(:internalformat-stencil-type #x827D)
(:internalformat-supported #x826F)
(:interpolate #x8575)
(:interpolate-arb #x8575)
(:interpolate-ext #x8575)
(:invalid-enum #x500)
(:invalid-framebuffer-operation #x506)
(:invalid-framebuffer-operation-ext #x506)
(:invalid-framebuffer-operation-oes #x506)
(:invalid-index #xFFFFFFFF)
(:invalid-operation #x502)
(:invalid-value #x501)
(:invariant-datatype-ext #x87EB)
(:invariant-ext #x87C2)
(:invariant-value-ext #x87EA)
(:inverse-nv #x862B)
(:inverse-transpose-nv #x862D)
(:invert #x150A)
(:invert-ovg-nv #x92B4)
(:invert-rgb-nv #x92A3)
(:inverted-screen-w-rend #x8491)
(:ir-instrument1-sgix #x817F)
(:is-per-patch #x92E7)
(:is-per-patch-ext #x92E7)
(:is-per-patch-oes #x92E7)
(:is-row-major #x9300)
(:isolines #x8E7A)
(:isolines-ext #x8E7A)
(:isolines-oes #x8E7A)
(:italic-bit-nv #x2)
(:iui-n3f-v2f-ext #x81AF)
(:iui-n3f-v3f-ext #x81B0)
(:iui-v2f-ext #x81AD)
(:iui-v3f-ext #x81AE)
(:keep #x1E00)
(:large-ccw-arc-to-nv #x16)
(:large-cw-arc-to-nv #x18)
(:last-vertex-convention #x8E4E)
(:last-vertex-convention-ext #x8E4E)
(:last-vertex-convention-oes #x8E4E)
(:last-video-capture-status-nv #x9027)
(:layer-nv #x8DAA)
(:layer-provoking-vertex #x825E)
(:layer-provoking-vertex-ext #x825E)
(:layer-provoking-vertex-oes #x825E)
(:layout-default-intel #x0)
(:layout-linear-cpu-cached-intel #x2)
(:layout-linear-intel #x1)
(:left #x406)
(:lequal #x203)
(:lerp-ati #x8969)
(:less #x201)
(:light-env-mode-sgix #x8407)
(:light-model-ambient #xB53)
(:light-model-color-control #x81F8)
(:light-model-color-control-ext #x81F8)
(:light-model-local-viewer #xB51)
(:light-model-specular-vector-apple #x85B0)
(:light-model-two-side #xB52)
(:light0 #x4000)
(:light1 #x4001)
(:light2 #x4002)
(:light3 #x4003)
(:light4 #x4004)
(:light5 #x4005)
(:light6 #x4006)
(:light7 #x4007)
(:lighten #x9298)
(:lighten-khr #x9298)
(:lighten-nv #x9298)
(:lighting #xB50)
(:lighting-bit #x40)
(:line #x1B01)
(:line-bit #x4)
(:line-loop #x2)
(:line-nv #x1B01)
(:line-quality-hint-sgix #x835B)
(:line-reset-token #x707)
(:line-smooth #xB20)
(:line-smooth-hint #xC52)
(:line-stipple #xB24)
(:line-stipple-pattern #xB25)
(:line-stipple-repeat #xB26)
(:line-strip #x3)
(:line-strip-adjacency #xB)
(:line-strip-adjacency-arb #xB)
(:line-strip-adjacency-ext #xB)
(:line-strip-adjacency-oes #xB)
(:line-to-nv #x4)
(:line-token #x702)
(:line-width #xB21)
(:line-width-command-nv #xD)
(:line-width-granularity #xB23)
(:line-width-range #xB22)
(:linear #x2601)
(:linear-attenuation #x1208)
(:linear-clipmap-linear-sgix #x8170)
(:linear-clipmap-nearest-sgix #x844F)
(:linear-detail-alpha-sgis #x8098)
(:linear-detail-color-sgis #x8099)
(:linear-detail-sgis #x8097)
(:linear-mipmap-linear #x2703)
(:linear-mipmap-nearest #x2701)
(:linear-sharpen-alpha-sgis #x80AE)
(:linear-sharpen-color-sgis #x80AF)
(:linear-sharpen-sgis #x80AD)
(:linearburn-nv #x92A5)
(:lineardodge-nv #x92A4)
(:linearlight-nv #x92A7)
(:lines #x1)
(:lines-adjacency #xA)
(:lines-adjacency-arb #xA)
(:lines-adjacency-ext #xA)
(:lines-adjacency-oes #xA)
(:link-status #x8B82)
(:list-base #xB32)
(:list-bit #x20000)
(:list-index #xB33)
(:list-mode #xB30)
(:list-priority-sgix #x8182)
(:lo-bias-nv #x8715)
(:lo-scale-nv #x870F)
(:load #x101)
(:local-constant-datatype-ext #x87ED)
(:local-constant-ext #x87C3)
(:local-constant-value-ext #x87EC)
(:local-ext #x87C4)
(:location #x930E)
(:location-component #x934A)
(:location-index #x930F)
(:logic-op #xBF1)
(:logic-op-mode #xBF0)
(:lose-context-on-reset #x8252)
(:lose-context-on-reset-arb #x8252)
(:lose-context-on-reset-ext #x8252)
(:lose-context-on-reset-khr #x8252)
(:low-float #x8DF0)
(:low-int #x8DF3)
(:lower-left #x8CA1)
(:luminance #x1909)
(:luminance-alpha #x190A)
(:luminance-alpha-float16-apple #x881F)
(:luminance-alpha-float16-ati #x881F)
(:luminance-alpha-float32-apple #x8819)
(:luminance-alpha-float32-ati #x8819)
(:luminance-alpha-integer-ext #x8D9D)
(:luminance-alpha-snorm #x9012)
(:luminance-alpha16f-arb #x881F)
(:luminance-alpha16f-ext #x881F)
(:luminance-alpha16i-ext #x8D8D)
(:luminance-alpha16ui-ext #x8D7B)
(:luminance-alpha32f-arb #x8819)
(:luminance-alpha32f-ext #x8819)
(:luminance-alpha32i-ext #x8D87)
(:luminance-alpha32ui-ext #x8D75)
(:luminance-alpha8i-ext #x8D93)
(:luminance-alpha8ui-ext #x8D81)
(:luminance-float16-apple #x881E)
(:luminance-float16-ati #x881E)
(:luminance-float32-apple #x8818)
(:luminance-float32-ati #x8818)
(:luminance-integer-ext #x8D9C)
(:luminance-snorm #x9011)
(:luminance12 #x8041)
(:luminance12-alpha12 #x8047)
(:luminance12-alpha12-ext #x8047)
(:luminance12-alpha4 #x8046)
(:luminance12-alpha4-ext #x8046)
(:luminance12-ext #x8041)
(:luminance16 #x8042)
(:luminance16-alpha16 #x8048)
(:luminance16-alpha16-ext #x8048)
(:luminance16-alpha16-snorm #x901A)
(:luminance16-ext #x8042)
(:luminance16-snorm #x9019)
(:luminance16f-arb #x881E)
(:luminance16f-ext #x881E)
(:luminance16i-ext #x8D8C)
(:luminance16ui-ext #x8D7A)
(:luminance32f-arb #x8818)
(:luminance32f-ext #x8818)
(:luminance32i-ext #x8D86)
(:luminance32ui-ext #x8D74)
(:luminance4 #x803F)
(:luminance4-alpha4 #x8043)
(:luminance4-alpha4-ext #x8043)
(:luminance4-alpha4-oes #x8043)
(:luminance4-ext #x803F)
(:luminance6-alpha2 #x8044)
(:luminance6-alpha2-ext #x8044)
(:luminance8 #x8040)
(:luminance8-alpha8 #x8045)
(:luminance8-alpha8-ext #x8045)
(:luminance8-alpha8-oes #x8045)
(:luminance8-alpha8-snorm #x9016)
(:luminance8-ext #x8040)
(:luminance8-oes #x8040)
(:luminance8-snorm #x9015)
(:luminance8i-ext #x8D92)
(:luminance8ui-ext #x8D80)
(:mad-ati #x8968)
(:magnitude-bias-nv #x8718)
(:magnitude-scale-nv #x8712)
(:major-version #x821B)
(:mali-program-binary-arm #x8F61)
(:mali-shader-binary-arm #x8F60)
(:manual-generate-mipmap #x8294)
(:map-attrib-u-order-nv #x86C3)
(:map-attrib-v-order-nv #x86C4)
(:map-coherent-bit #x80)
(:map-coherent-bit-ext #x80)
(:map-color #xD10)
(:map-flush-explicit-bit #x10)
(:map-flush-explicit-bit-ext #x10)
(:map-invalidate-buffer-bit #x8)
(:map-invalidate-buffer-bit-ext #x8)
(:map-invalidate-range-bit #x4)
(:map-invalidate-range-bit-ext #x4)
(:map-persistent-bit #x40)
(:map-persistent-bit-ext #x40)
(:map-read-bit #x1)
(:map-read-bit-ext #x1)
(:map-stencil #xD11)
(:map-tessellation-nv #x86C2)
(:map-unsynchronized-bit #x20)
(:map-unsynchronized-bit-ext #x20)
(:map-write-bit #x2)
(:map-write-bit-ext #x2)
(:map1-binormal-ext #x8446)
(:map1-color-4 #xD90)
(:map1-grid-domain #xDD0)
(:map1-grid-segments #xDD1)
(:map1-index #xD91)
(:map1-normal #xD92)
(:map1-tangent-ext #x8444)
(:map1-texture-coord-1 #xD93)
(:map1-texture-coord-2 #xD94)
(:map1-texture-coord-3 #xD95)
(:map1-texture-coord-4 #xD96)
(:map1-vertex-3 #xD97)
(:map1-vertex-4 #xD98)
(:map1-vertex-attrib0-4-nv #x8660)
(:map1-vertex-attrib1-4-nv #x8661)
(:map1-vertex-attrib10-4-nv #x866A)
(:map1-vertex-attrib11-4-nv #x866B)
(:map1-vertex-attrib12-4-nv #x866C)
(:map1-vertex-attrib13-4-nv #x866D)
(:map1-vertex-attrib14-4-nv #x866E)
(:map1-vertex-attrib15-4-nv #x866F)
(:map1-vertex-attrib2-4-nv #x8662)
(:map1-vertex-attrib3-4-nv #x8663)
(:map1-vertex-attrib4-4-nv #x8664)
(:map1-vertex-attrib5-4-nv #x8665)
(:map1-vertex-attrib6-4-nv #x8666)
(:map1-vertex-attrib7-4-nv #x8667)
(:map1-vertex-attrib8-4-nv #x8668)
(:map1-vertex-attrib9-4-nv #x8669)
(:map2-binormal-ext #x8447)
(:map2-color-4 #xDB0)
(:map2-grid-domain #xDD2)
(:map2-grid-segments #xDD3)
(:map2-index #xDB1)
(:map2-normal #xDB2)
(:map2-tangent-ext #x8445)
(:map2-texture-coord-1 #xDB3)
(:map2-texture-coord-2 #xDB4)
(:map2-texture-coord-3 #xDB5)
(:map2-texture-coord-4 #xDB6)
(:map2-vertex-3 #xDB7)
(:map2-vertex-4 #xDB8)
(:map2-vertex-attrib0-4-nv #x8670)
(:map2-vertex-attrib1-4-nv #x8671)
(:map2-vertex-attrib10-4-nv #x867A)
(:map2-vertex-attrib11-4-nv #x867B)
(:map2-vertex-attrib12-4-nv #x867C)
(:map2-vertex-attrib13-4-nv #x867D)
(:map2-vertex-attrib14-4-nv #x867E)
(:map2-vertex-attrib15-4-nv #x867F)
(:map2-vertex-attrib2-4-nv #x8672)
(:map2-vertex-attrib3-4-nv #x8673)
(:map2-vertex-attrib4-4-nv #x8674)
(:map2-vertex-attrib5-4-nv #x8675)
(:map2-vertex-attrib6-4-nv #x8676)
(:map2-vertex-attrib7-4-nv #x8677)
(:map2-vertex-attrib8-4-nv #x8678)
(:map2-vertex-attrib9-4-nv #x8679)
(:mat-ambient-and-diffuse-bit-pgi #x200000)
(:mat-ambient-bit-pgi #x100000)
(:mat-color-indexes-bit-pgi #x1000000)
(:mat-diffuse-bit-pgi #x400000)
(:mat-emission-bit-pgi #x800000)
(:mat-shininess-bit-pgi #x2000000)
(:mat-specular-bit-pgi #x4000000)
(:material-side-hint-pgi #x1A22C)
(:matrix-ext #x87C0)
(:matrix-index-array-arb #x8844)
(:matrix-index-array-buffer-binding-oes #x8B9E)
(:matrix-index-array-oes #x8844)
(:matrix-index-array-pointer-arb #x8849)
(:matrix-index-array-pointer-oes #x8849)
(:matrix-index-array-size-arb #x8846)
(:matrix-index-array-size-oes #x8846)
(:matrix-index-array-stride-arb #x8848)
(:matrix-index-array-stride-oes #x8848)
(:matrix-index-array-type-arb #x8847)
(:matrix-index-array-type-oes #x8847)
(:matrix-mode #xBA0)
(:matrix-palette-arb #x8840)
(:matrix-palette-oes #x8840)
(:matrix-stride #x92FF)
(:matrix0-arb #x88C0)
(:matrix0-nv #x8630)
(:matrix1-arb #x88C1)
(:matrix1-nv #x8631)
(:matrix10-arb #x88CA)
(:matrix11-arb #x88CB)
(:matrix12-arb #x88CC)
(:matrix13-arb #x88CD)
(:matrix14-arb #x88CE)
(:matrix15-arb #x88CF)
(:matrix16-arb #x88D0)
(:matrix17-arb #x88D1)
(:matrix18-arb #x88D2)
(:matrix19-arb #x88D3)
(:matrix2-arb #x88C2)
(:matrix2-nv #x8632)
(:matrix20-arb #x88D4)
(:matrix21-arb #x88D5)
(:matrix22-arb #x88D6)
(:matrix23-arb #x88D7)
(:matrix24-arb #x88D8)
(:matrix25-arb #x88D9)
(:matrix26-arb #x88DA)
(:matrix27-arb #x88DB)
(:matrix28-arb #x88DC)
(:matrix29-arb #x88DD)
(:matrix3-arb #x88C3)
(:matrix3-nv #x8633)
(:matrix30-arb #x88DE)
(:matrix31-arb #x88DF)
(:matrix4-arb #x88C4)
(:matrix4-nv #x8634)
(:matrix5-arb #x88C5)
(:matrix5-nv #x8635)
(:matrix6-arb #x88C6)
(:matrix6-nv #x8636)
(:matrix7-arb #x88C7)
(:matrix7-nv #x8637)
(:matrix8-arb #x88C8)
(:matrix9-arb #x88C9)
(:max #x8008)
(:max-3d-texture-size #x8073)
(:max-3d-texture-size-ext #x8073)
(:max-3d-texture-size-oes #x8073)
(:max-4d-texture-size-sgis #x8138)
(:max-active-lights-sgix #x8405)
(:max-array-texture-layers #x88FF)
(:max-array-texture-layers-ext #x88FF)
(:max-async-draw-pixels-sgix #x8360)
(:max-async-histogram-sgix #x832D)
(:max-async-read-pixels-sgix #x8361)
(:max-async-tex-image-sgix #x835F)
(:max-atomic-counter-buffer-bindings #x92DC)
(:max-atomic-counter-buffer-size #x92D8)
(:max-attrib-stack-depth #xD35)
(:max-bindable-uniform-size-ext #x8DED)
(:max-client-attrib-stack-depth #xD3B)
(:max-clip-distances #xD32)
(:max-clip-distances-apple #xD32)
(:max-clip-planes #xD32)
(:max-clip-planes-img #xD32)
(:max-clipmap-depth-sgix #x8177)
(:max-clipmap-virtual-depth-sgix #x8178)
(:max-color-attachments #x8CDF)
(:max-color-attachments-ext #x8CDF)
(:max-color-attachments-nv #x8CDF)
(:max-color-matrix-stack-depth #x80B3)
(:max-color-matrix-stack-depth-sgi #x80B3)
(:max-color-texture-samples #x910E)
(:max-combined-atomic-counter-buffers #x92D1)
(:max-combined-atomic-counters #x92D7)
(:max-combined-clip-and-cull-distances #x82FA)
(:max-combined-compute-uniform-components #x8266)
(:max-combined-dimensions #x8282)
(:max-combined-fragment-uniform-components #x8A33)
(:max-combined-geometry-uniform-components #x8A32)
(:max-combined-geometry-uniform-components-ext #x8A32)
(:max-combined-geometry-uniform-components-oes #x8A32)
(:max-combined-image-uniforms #x90CF)
(:max-combined-image-units-and-fragment-outputs #x8F39)
(:max-combined-image-units-and-fragment-outputs-ext #x8F39)
(:max-combined-shader-output-resources #x8F39)
(:max-combined-shader-storage-blocks #x90DC)
(:max-combined-tess-control-uniform-components #x8E1E)
(:max-combined-tess-control-uniform-components-ext #x8E1E)
(:max-combined-tess-control-uniform-components-oes #x8E1E)
(:max-combined-tess-evaluation-uniform-components #x8E1F)
(:max-combined-tess-evaluation-uniform-components-ext #x8E1F)
(:max-combined-tess-evaluation-uniform-components-oes #x8E1F)
(:max-combined-texture-image-units #x8B4D)
(:max-combined-texture-image-units-arb #x8B4D)
(:max-combined-uniform-blocks #x8A2E)
(:max-combined-vertex-uniform-components #x8A31)
(:max-compute-atomic-counter-buffers #x8264)
(:max-compute-atomic-counters #x8265)
(:max-compute-fixed-group-invocations-arb #x90EB)
(:max-compute-fixed-group-size-arb #x91BF)
(:max-compute-image-uniforms #x91BD)
(:max-compute-shader-storage-blocks #x90DB)
(:max-compute-shared-memory-size #x8262)
(:max-compute-texture-image-units #x91BC)
(:max-compute-uniform-blocks #x91BB)
(:max-compute-uniform-components #x8263)
(:max-compute-variable-group-invocations-arb #x9344)
(:max-compute-variable-group-size-arb #x9345)
(:max-compute-work-group-count #x91BE)
(:max-compute-work-group-invocations #x90EB)
(:max-compute-work-group-size #x91BF)
(:max-convolution-height #x801B)
(:max-convolution-height-ext #x801B)
(:max-convolution-width #x801A)
(:max-convolution-width-ext #x801A)
(:max-cube-map-texture-size #x851C)
(:max-cube-map-texture-size-arb #x851C)
(:max-cube-map-texture-size-ext #x851C)
(:max-cube-map-texture-size-oes #x851C)
(:max-cull-distances #x82F9)
(:max-debug-group-stack-depth #x826C)
(:max-debug-group-stack-depth-khr #x826C)
(:max-debug-logged-messages #x9144)
(:max-debug-logged-messages-amd #x9144)
(:max-debug-logged-messages-arb #x9144)
(:max-debug-logged-messages-khr #x9144)
(:max-debug-message-length #x9143)
(:max-debug-message-length-amd #x9143)
(:max-debug-message-length-arb #x9143)
(:max-debug-message-length-khr #x9143)
(:max-deep-3d-texture-depth-nv #x90D1)
(:max-deep-3d-texture-width-height-nv #x90D0)
(:max-deformation-order-sgix #x8197)
(:max-depth #x8280)
(:max-depth-texture-samples #x910F)
(:max-draw-buffers #x8824)
(:max-draw-buffers-arb #x8824)
(:max-draw-buffers-ati #x8824)
(:max-draw-buffers-ext #x8824)
(:max-draw-buffers-nv #x8824)
(:max-dual-source-draw-buffers #x88FC)
(:max-element-index #x8D6B)
(:max-elements-indices #x80E9)
(:max-elements-indices-ext #x80E9)
(:max-elements-vertices #x80E8)
(:max-elements-vertices-ext #x80E8)
(:max-eval-order #xD30)
(:max-ext #x8008)
(:max-fog-func-points-sgis #x812C)
(:max-fragment-atomic-counter-buffers #x92D0)
(:max-fragment-atomic-counters #x92D6)
(:max-fragment-bindable-uniforms-ext #x8DE3)
(:max-fragment-image-uniforms #x90CE)
(:max-fragment-input-components #x9125)
(:max-fragment-interpolation-offset #x8E5C)
(:max-fragment-interpolation-offset-nv #x8E5C)
(:max-fragment-interpolation-offset-oes #x8E5C)
(:max-fragment-lights-sgix #x8404)
(:max-fragment-program-local-parameters-nv #x8868)
(:max-fragment-shader-storage-blocks #x90DA)
(:max-fragment-uniform-blocks #x8A2D)
(:max-fragment-uniform-components #x8B49)
(:max-fragment-uniform-components-arb #x8B49)
(:max-fragment-uniform-vectors #x8DFD)
(:max-framebuffer-height #x9316)
(:max-framebuffer-layers #x9317)
(:max-framebuffer-layers-ext #x9317)
(:max-framebuffer-layers-oes #x9317)
(:max-framebuffer-samples #x9318)
(:max-framebuffer-width #x9315)
(:max-framezoom-factor-sgix #x818D)
(:max-general-combiners-nv #x854D)
(:max-geometry-atomic-counter-buffers #x92CF)
(:max-geometry-atomic-counter-buffers-ext #x92CF)
(:max-geometry-atomic-counter-buffers-oes #x92CF)
(:max-geometry-atomic-counters #x92D5)
(:max-geometry-atomic-counters-ext #x92D5)
(:max-geometry-atomic-counters-oes #x92D5)
(:max-geometry-bindable-uniforms-ext #x8DE4)
(:max-geometry-image-uniforms #x90CD)
(:max-geometry-image-uniforms-ext #x90CD)
(:max-geometry-image-uniforms-oes #x90CD)
(:max-geometry-input-components #x9123)
(:max-geometry-input-components-ext #x9123)
(:max-geometry-input-components-oes #x9123)
(:max-geometry-output-components #x9124)
(:max-geometry-output-components-ext #x9124)
(:max-geometry-output-components-oes #x9124)
(:max-geometry-output-vertices #x8DE0)
(:max-geometry-output-vertices-arb #x8DE0)
(:max-geometry-output-vertices-ext #x8DE0)
(:max-geometry-output-vertices-oes #x8DE0)
(:max-geometry-program-invocations-nv #x8E5A)
(:max-geometry-shader-invocations #x8E5A)
(:max-geometry-shader-invocations-ext #x8E5A)
(:max-geometry-shader-invocations-oes #x8E5A)
(:max-geometry-shader-storage-blocks #x90D7)
(:max-geometry-shader-storage-blocks-ext #x90D7)
(:max-geometry-shader-storage-blocks-oes #x90D7)
(:max-geometry-texture-image-units #x8C29)
(:max-geometry-texture-image-units-arb #x8C29)
(:max-geometry-texture-image-units-ext #x8C29)
(:max-geometry-texture-image-units-oes #x8C29)
(:max-geometry-total-output-components #x8DE1)
(:max-geometry-total-output-components-arb #x8DE1)
(:max-geometry-total-output-components-ext #x8DE1)
(:max-geometry-total-output-components-oes #x8DE1)
(:max-geometry-uniform-blocks #x8A2C)
(:max-geometry-uniform-blocks-ext #x8A2C)
(:max-geometry-uniform-blocks-oes #x8A2C)
(:max-geometry-uniform-components #x8DDF)
(:max-geometry-uniform-components-arb #x8DDF)
(:max-geometry-uniform-components-ext #x8DDF)
(:max-geometry-uniform-components-oes #x8DDF)
(:max-geometry-varying-components-arb #x8DDD)
(:max-geometry-varying-components-ext #x8DDD)
(:max-height #x827F)
(:max-image-samples #x906D)
(:max-image-samples-ext #x906D)
(:max-image-units #x8F38)
(:max-image-units-ext #x8F38)
(:max-integer-samples #x9110)
(:max-label-length #x82E8)
(:max-label-length-khr #x82E8)
(:max-layers #x8281)
(:max-lights #xD31)
(:max-list-nesting #xB31)
(:max-map-tessellation-nv #x86D6)
(:max-matrix-palette-stack-depth-arb #x8841)
(:max-modelview-stack-depth #xD36)
(:max-multisample-coverage-modes-nv #x8E11)
(:max-multiview-buffers-ext #x90F2)
(:max-name-length #x92F6)
(:max-name-stack-depth #xD37)
(:max-num-active-variables #x92F7)
(:max-num-compatible-subroutines #x92F8)
(:max-optimized-vertex-shader-instructions-ext #x87CA)
(:max-optimized-vertex-shader-invariants-ext #x87CD)
(:max-optimized-vertex-shader-local-constants-ext #x87CC)
(:max-optimized-vertex-shader-locals-ext #x87CE)
(:max-optimized-vertex-shader-variants-ext #x87CB)
(:max-palette-matrices-arb #x8842)
(:max-palette-matrices-oes #x8842)
(:max-patch-vertices #x8E7D)
(:max-patch-vertices-ext #x8E7D)
(:max-patch-vertices-oes #x8E7D)
(:max-pixel-map-table #xD34)
(:max-pixel-transform-2d-stack-depth-ext #x8337)
(:max-pn-triangles-tesselation-level-ati #x87F1)
(:max-program-address-registers-arb #x88B1)
(:max-program-alu-instructions-arb #x880B)
(:max-program-attrib-components-nv #x8908)
(:max-program-attribs-arb #x88AD)
(:max-program-call-depth-nv #x88F5)
(:max-program-env-parameters-arb #x88B5)
(:max-program-exec-instructions-nv #x88F4)
(:max-program-generic-attribs-nv #x8DA5)
(:max-program-generic-results-nv #x8DA6)
(:max-program-if-depth-nv #x88F6)
(:max-program-instructions-arb #x88A1)
(:max-program-local-parameters-arb #x88B4)
(:max-program-loop-count-nv #x88F8)
(:max-program-loop-depth-nv #x88F7)
(:max-program-matrices-arb #x862F)
(:max-program-matrix-stack-depth-arb #x862E)
(:max-program-native-address-registers-arb #x88B3)
(:max-program-native-alu-instructions-arb #x880E)
(:max-program-native-attribs-arb #x88AF)
(:max-program-native-instructions-arb #x88A3)
(:max-program-native-parameters-arb #x88AB)
(:max-program-native-temporaries-arb #x88A7)
(:max-program-native-tex-indirections-arb #x8810)
(:max-program-native-tex-instructions-arb #x880F)
(:max-program-output-vertices-nv #x8C27)
(:max-program-parameter-buffer-bindings-nv #x8DA0)
(:max-program-parameter-buffer-size-nv #x8DA1)
(:max-program-parameters-arb #x88A9)
(:max-program-patch-attribs-nv #x86D8)
(:max-program-result-components-nv #x8909)
(:max-program-subroutine-num-nv #x8F45)
(:max-program-subroutine-parameters-nv #x8F44)
(:max-program-temporaries-arb #x88A5)
(:max-program-tex-indirections-arb #x880D)
(:max-program-tex-instructions-arb #x880C)
(:max-program-texel-offset #x8905)
(:max-program-texel-offset-ext #x8905)
(:max-program-texel-offset-nv #x8905)
(:max-program-texture-gather-components-arb #x8F9F)
(:max-program-texture-gather-offset #x8E5F)
(:max-program-texture-gather-offset-arb #x8E5F)
(:max-program-texture-gather-offset-nv #x8E5F)
(:max-program-total-output-components-nv #x8C28)
(:max-projection-stack-depth #xD38)
(:max-raster-samples-ext #x9329)
(:max-rational-eval-order-nv #x86D7)
(:max-rectangle-texture-size #x84F8)
(:max-rectangle-texture-size-arb #x84F8)
(:max-rectangle-texture-size-nv #x84F8)
(:max-renderbuffer-size #x84E8)
(:max-renderbuffer-size-ext #x84E8)
(:max-renderbuffer-size-oes #x84E8)
(:max-sample-mask-words #x8E59)
(:max-sample-mask-words-nv #x8E59)
(:max-samples #x8D57)
(:max-samples-angle #x8D57)
(:max-samples-apple #x8D57)
(:max-samples-ext #x8D57)
(:max-samples-img #x9135)
(:max-samples-nv #x8D57)
(:max-server-wait-timeout #x9111)
(:max-server-wait-timeout-apple #x9111)
(:max-shader-buffer-address-nv #x8F35)
(:max-shader-compiler-threads-arb #x91B0)
(:max-shader-pixel-local-storage-fast-size-ext #x8F63)
(:max-shader-pixel-local-storage-size-ext #x8F67)
(:max-shader-storage-block-size #x90DE)
(:max-shader-storage-buffer-bindings #x90DD)
(:max-shininess-nv #x8504)
(:max-sparse-3d-texture-size-amd #x9199)
(:max-sparse-3d-texture-size-arb #x9199)
(:max-sparse-3d-texture-size-ext #x9199)
(:max-sparse-array-texture-layers #x919A)
(:max-sparse-array-texture-layers-arb #x919A)
(:max-sparse-array-texture-layers-ext #x919A)
(:max-sparse-texture-size-amd #x9198)
(:max-sparse-texture-size-arb #x9198)
(:max-sparse-texture-size-ext #x9198)
(:max-spot-exponent-nv #x8505)
(:max-subpixel-precision-bias-bits-nv #x9349)
(:max-subroutine-uniform-locations #x8DE8)
(:max-subroutines #x8DE7)
(:max-tess-control-atomic-counter-buffers #x92CD)
(:max-tess-control-atomic-counter-buffers-ext #x92CD)
(:max-tess-control-atomic-counter-buffers-oes #x92CD)
(:max-tess-control-atomic-counters #x92D3)
(:max-tess-control-atomic-counters-ext #x92D3)
(:max-tess-control-atomic-counters-oes #x92D3)
(:max-tess-control-image-uniforms #x90CB)
(:max-tess-control-image-uniforms-ext #x90CB)
(:max-tess-control-image-uniforms-oes #x90CB)
(:max-tess-control-input-components #x886C)
(:max-tess-control-input-components-ext #x886C)
(:max-tess-control-input-components-oes #x886C)
(:max-tess-control-output-components #x8E83)
(:max-tess-control-output-components-ext #x8E83)
(:max-tess-control-output-components-oes #x8E83)
(:max-tess-control-shader-storage-blocks #x90D8)
(:max-tess-control-shader-storage-blocks-ext #x90D8)
(:max-tess-control-shader-storage-blocks-oes #x90D8)
(:max-tess-control-texture-image-units #x8E81)
(:max-tess-control-texture-image-units-ext #x8E81)
(:max-tess-control-texture-image-units-oes #x8E81)
(:max-tess-control-total-output-components #x8E85)
(:max-tess-control-total-output-components-ext #x8E85)
(:max-tess-control-total-output-components-oes #x8E85)
(:max-tess-control-uniform-blocks #x8E89)
(:max-tess-control-uniform-blocks-ext #x8E89)
(:max-tess-control-uniform-blocks-oes #x8E89)
(:max-tess-control-uniform-components #x8E7F)
(:max-tess-control-uniform-components-ext #x8E7F)
(:max-tess-control-uniform-components-oes #x8E7F)
(:max-tess-evaluation-atomic-counter-buffers #x92CE)
(:max-tess-evaluation-atomic-counter-buffers-ext #x92CE)
(:max-tess-evaluation-atomic-counter-buffers-oes #x92CE)
(:max-tess-evaluation-atomic-counters #x92D4)
(:max-tess-evaluation-atomic-counters-ext #x92D4)
(:max-tess-evaluation-atomic-counters-oes #x92D4)
(:max-tess-evaluation-image-uniforms #x90CC)
(:max-tess-evaluation-image-uniforms-ext #x90CC)
(:max-tess-evaluation-image-uniforms-oes #x90CC)
(:max-tess-evaluation-input-components #x886D)
(:max-tess-evaluation-input-components-ext #x886D)
(:max-tess-evaluation-input-components-oes #x886D)
(:max-tess-evaluation-output-components #x8E86)
(:max-tess-evaluation-output-components-ext #x8E86)
(:max-tess-evaluation-output-components-oes #x8E86)
(:max-tess-evaluation-shader-storage-blocks #x90D9)
(:max-tess-evaluation-shader-storage-blocks-ext #x90D9)
(:max-tess-evaluation-shader-storage-blocks-oes #x90D9)
(:max-tess-evaluation-texture-image-units #x8E82)
(:max-tess-evaluation-texture-image-units-ext #x8E82)
(:max-tess-evaluation-texture-image-units-oes #x8E82)
(:max-tess-evaluation-uniform-blocks #x8E8A)
(:max-tess-evaluation-uniform-blocks-ext #x8E8A)
(:max-tess-evaluation-uniform-blocks-oes #x8E8A)
(:max-tess-evaluation-uniform-components #x8E80)
(:max-tess-evaluation-uniform-components-ext #x8E80)
(:max-tess-evaluation-uniform-components-oes #x8E80)
(:max-tess-gen-level #x8E7E)
(:max-tess-gen-level-ext #x8E7E)
(:max-tess-gen-level-oes #x8E7E)
(:max-tess-patch-components #x8E84)
(:max-tess-patch-components-ext #x8E84)
(:max-tess-patch-components-oes #x8E84)
(:max-texture-buffer-size #x8C2B)
(:max-texture-buffer-size-arb #x8C2B)
(:max-texture-buffer-size-ext #x8C2B)
(:max-texture-buffer-size-oes #x8C2B)
(:max-texture-coords #x8871)
(:max-texture-coords-arb #x8871)
(:max-texture-coords-nv #x8871)
(:max-texture-image-units #x8872)
(:max-texture-image-units-arb #x8872)
(:max-texture-image-units-nv #x8872)
(:max-texture-lod-bias #x84FD)
(:max-texture-lod-bias-ext #x84FD)
(:max-texture-max-anisotropy-ext #x84FF)
(:max-texture-size #xD33)
(:max-texture-stack-depth #xD39)
(:max-texture-units #x84E2)
(:max-texture-units-arb #x84E2)
(:max-track-matrices-nv #x862F)
(:max-track-matrix-stack-depth-nv #x862E)
(:max-transform-feedback-buffers #x8E70)
(:max-transform-feedback-interleaved-components #x8C8A)
(:max-transform-feedback-interleaved-components-ext #x8C8A)
(:max-transform-feedback-interleaved-components-nv #x8C8A)
(:max-transform-feedback-separate-attribs #x8C8B)
(:max-transform-feedback-separate-attribs-ext #x8C8B)
(:max-transform-feedback-separate-attribs-nv #x8C8B)
(:max-transform-feedback-separate-components #x8C80)
(:max-transform-feedback-separate-components-ext #x8C80)
(:max-transform-feedback-separate-components-nv #x8C80)
(:max-uniform-block-size #x8A30)
(:max-uniform-buffer-bindings #x8A2F)
(:max-uniform-locations #x826E)
(:max-varying-components #x8B4B)
(:max-varying-components-ext #x8B4B)
(:max-varying-floats #x8B4B)
(:max-varying-floats-arb #x8B4B)
(:max-varying-vectors #x8DFC)
(:max-vertex-array-range-element-nv #x8520)
(:max-vertex-atomic-counter-buffers #x92CC)
(:max-vertex-atomic-counters #x92D2)
(:max-vertex-attrib-bindings #x82DA)
(:max-vertex-attrib-relative-offset #x82D9)
(:max-vertex-attrib-stride #x82E5)
(:max-vertex-attribs #x8869)
(:max-vertex-attribs-arb #x8869)
(:max-vertex-bindable-uniforms-ext #x8DE2)
(:max-vertex-hint-pgi #x1A22D)
(:max-vertex-image-uniforms #x90CA)
(:max-vertex-output-components #x9122)
(:max-vertex-shader-instructions-ext #x87C5)
(:max-vertex-shader-invariants-ext #x87C7)
(:max-vertex-shader-local-constants-ext #x87C8)
(:max-vertex-shader-locals-ext #x87C9)
(:max-vertex-shader-storage-blocks #x90D6)
(:max-vertex-shader-variants-ext #x87C6)
(:max-vertex-streams #x8E71)
(:max-vertex-streams-ati #x876B)
(:max-vertex-texture-image-units #x8B4C)
(:max-vertex-texture-image-units-arb #x8B4C)
(:max-vertex-uniform-blocks #x8A2B)
(:max-vertex-uniform-components #x8B4A)
(:max-vertex-uniform-components-arb #x8B4A)
(:max-vertex-uniform-vectors #x8DFB)
(:max-vertex-units-arb #x86A4)
(:max-vertex-units-oes #x86A4)
(:max-vertex-varying-components-arb #x8DDE)
(:max-vertex-varying-components-ext #x8DDE)
(:max-viewport-dims #xD3A)
(:max-viewports #x825B)
(:max-viewports-nv #x825B)
(:max-views-ovr #x9631)
(:max-width #x827E)
(:medium-float #x8DF1)
(:medium-int #x8DF4)
(:min #x8007)
(:min-ext #x8007)
(:min-fragment-interpolation-offset #x8E5B)
(:min-fragment-interpolation-offset-nv #x8E5B)
(:min-fragment-interpolation-offset-oes #x8E5B)
(:min-lod-warning-amd #x919C)
(:min-map-buffer-alignment #x90BC)
(:min-program-texel-offset #x8904)
(:min-program-texel-offset-ext #x8904)
(:min-program-texel-offset-nv #x8904)
(:min-program-texture-gather-offset #x8E5E)
(:min-program-texture-gather-offset-arb #x8E5E)
(:min-program-texture-gather-offset-nv #x8E5E)
(:min-sample-shading-value #x8C37)
(:min-sample-shading-value-arb #x8C37)
(:min-sample-shading-value-oes #x8C37)
(:min-sparse-level-amd #x919B)
(:minmax #x802E)
(:minmax-ext #x802E)
(:minmax-format #x802F)
(:minmax-format-ext #x802F)
(:minmax-sink #x8030)
(:minmax-sink-ext #x8030)
(:minor-version #x821C)
(:minus-clamped-nv #x92B3)
(:minus-nv #x929F)
(:mipmap #x8293)
(:mirror-clamp-ati #x8742)
(:mirror-clamp-ext #x8742)
(:mirror-clamp-to-border-ext #x8912)
(:mirror-clamp-to-edge #x8743)
(:mirror-clamp-to-edge-ati #x8743)
(:mirror-clamp-to-edge-ext #x8743)
(:mirrored-repeat #x8370)
(:mirrored-repeat-arb #x8370)
(:mirrored-repeat-ibm #x8370)
(:mirrored-repeat-oes #x8370)
(:miter-revert-nv #x90A7)
(:miter-truncate-nv #x90A8)
(:mixed-depth-samples-supported-nv #x932F)
(:mixed-stencil-samples-supported-nv #x9330)
(:modelview #x1700)
(:modelview-matrix #xBA6)
(:modelview-matrix-float-as-int-bits-oes #x898D)
(:modelview-projection-nv #x8629)
(:modelview-stack-depth #xBA3)
(:modelview0-arb #x1700)
(:modelview0-ext #x1700)
(:modelview0-matrix-ext #xBA6)
(:modelview0-stack-depth-ext #xBA3)
(:modelview1-arb #x850A)
(:modelview1-ext #x850A)
(:modelview1-matrix-ext #x8506)
(:modelview1-stack-depth-ext #x8502)
(:modelview10-arb #x872A)
(:modelview11-arb #x872B)
(:modelview12-arb #x872C)
(:modelview13-arb #x872D)
(:modelview14-arb #x872E)
(:modelview15-arb #x872F)
(:modelview16-arb #x8730)
(:modelview17-arb #x8731)
(:modelview18-arb #x8732)
(:modelview19-arb #x8733)
(:modelview2-arb #x8722)
(:modelview20-arb #x8734)
(:modelview21-arb #x8735)
(:modelview22-arb #x8736)
(:modelview23-arb #x8737)
(:modelview24-arb #x8738)
(:modelview25-arb #x8739)
(:modelview26-arb #x873A)
(:modelview27-arb #x873B)
(:modelview28-arb #x873C)
(:modelview29-arb #x873D)
(:modelview3-arb #x8723)
(:modelview30-arb #x873E)
(:modelview31-arb #x873F)
(:modelview4-arb #x8724)
(:modelview5-arb #x8725)
(:modelview6-arb #x8726)
(:modelview7-arb #x8727)
(:modelview8-arb #x8728)
(:modelview9-arb #x8729)
(:modulate #x2100)
(:modulate-add-ati #x8744)
(:modulate-color-img #x8C04)
(:modulate-signed-add-ati #x8745)
(:modulate-subtract-ati #x8746)
(:mov-ati #x8961)
(:move-to-continues-nv #x90B6)
(:move-to-nv #x2)
(:move-to-resets-nv #x90B5)
(:mul-ati #x8964)
(:mult #x103)
(:multiply #x9294)
(:multiply-khr #x9294)
(:multiply-nv #x9294)
(:multisample #x809D)
(:multisample-3dfx #x86B2)
(:multisample-arb #x809D)
(:multisample-bit #x20000000)
(:multisample-bit-3dfx #x20000000)
(:multisample-bit-arb #x20000000)
(:multisample-bit-ext #x20000000)
(:multisample-buffer-bit0-qcom #x1000000)
(:multisample-buffer-bit1-qcom #x2000000)
(:multisample-buffer-bit2-qcom #x4000000)
(:multisample-buffer-bit3-qcom #x8000000)
(:multisample-buffer-bit4-qcom #x10000000)
(:multisample-buffer-bit5-qcom #x20000000)
(:multisample-buffer-bit6-qcom #x40000000)
(:multisample-buffer-bit7-qcom #x80000000)
(:multisample-coverage-modes-nv #x8E12)
(:multisample-ext #x809D)
(:multisample-filter-hint-nv #x8534)
(:multisample-line-width-granularity #x9382)
(:multisample-line-width-granularity-arb #x9382)
(:multisample-line-width-range #x9381)
(:multisample-line-width-range-arb #x9381)
(:multisample-rasterization-allowed-ext #x932B)
(:multisample-sgis #x809D)
(:multisamples-nv #x9371)
(:multiview-ext #x90F1)
(:mvp-matrix-ext #x87E3)
(:n3f-v3f #x2A25)
(:name-length #x92F9)
(:name-stack-depth #xD70)
(:named-string-length-arb #x8DE9)
(:named-string-type-arb #x8DEA)
(:nand #x150E)
(:native-graphics-begin-hint-pgi #x1A203)
(:native-graphics-end-hint-pgi #x1A204)
(:native-graphics-handle-pgi #x1A202)
(:nearest #x2600)
(:nearest-clipmap-linear-sgix #x844E)
(:nearest-clipmap-nearest-sgix #x844D)
(:nearest-mipmap-linear #x2702)
(:nearest-mipmap-nearest #x2700)
(:negate-bit-ati #x4)
(:negative-one-ext #x87DF)
(:negative-one-to-one #x935E)
(:negative-w-ext #x87DC)
(:negative-x-ext #x87D9)
(:negative-y-ext #x87DA)
(:negative-z-ext #x87DB)
(:never #x200)
(:next-buffer-nv #x-2)
(:next-video-capture-buffer-status-nv #x9025)
(:nicest #x1102)
(:no-error #x0)
(:no-reset-notification #x8261)
(:no-reset-notification-arb #x8261)
(:no-reset-notification-ext #x8261)
(:no-reset-notification-khr #x8261)
(:none #x0)
(:none-oes #x0)
(:noop #x1505)
(:nop-command-nv #x1)
(:nor #x1508)
(:normal-array #x8075)
(:normal-array-address-nv #x8F22)
(:normal-array-buffer-binding #x8897)
(:normal-array-buffer-binding-arb #x8897)
(:normal-array-count-ext #x8080)
(:normal-array-ext #x8075)
(:normal-array-length-nv #x8F2C)
(:normal-array-list-ibm #x1929F)
(:normal-array-list-stride-ibm #x192A9)
(:normal-array-parallel-pointers-intel #x83F6)
(:normal-array-pointer #x808F)
(:normal-array-pointer-ext #x808F)
(:normal-array-stride #x807F)
(:normal-array-stride-ext #x807F)
(:normal-array-type #x807E)
(:normal-array-type-ext #x807E)
(:normal-bit-pgi #x8000000)
(:normal-map #x8511)
(:normal-map-arb #x8511)
(:normal-map-ext #x8511)
(:normal-map-nv #x8511)
(:normal-map-oes #x8511)
(:normalize #xBA1)
(:normalized-range-ext #x87E0)
(:notequal #x205)
(:num-active-variables #x9304)
(:num-compatible-subroutines #x8E4A)
(:num-compressed-texture-formats #x86A2)
(:num-compressed-texture-formats-arb #x86A2)
(:num-extensions #x821D)
(:num-fill-streams-nv #x8E29)
(:num-fragment-constants-ati #x896F)
(:num-fragment-registers-ati #x896E)
(:num-general-combiners-nv #x854E)
(:num-input-interpolator-components-ati #x8973)
(:num-instructions-per-pass-ati #x8971)
(:num-instructions-total-ati #x8972)
(:num-loopback-components-ati #x8974)
(:num-passes-ati #x8970)
(:num-program-binary-formats #x87FE)
(:num-program-binary-formats-oes #x87FE)
(:num-sample-counts #x9380)
(:num-shader-binary-formats #x8DF9)
(:num-shading-language-versions #x82E9)
(:num-sparse-levels-arb #x91AA)
(:num-sparse-levels-ext #x91AA)
(:num-video-capture-streams-nv #x9024)
(:num-virtual-page-sizes-arb #x91A8)
(:num-virtual-page-sizes-ext #x91A8)
(:object-active-attribute-max-length-arb #x8B8A)
(:object-active-attributes-arb #x8B89)
(:object-active-uniform-max-length-arb #x8B87)
(:object-active-uniforms-arb #x8B86)
(:object-attached-objects-arb #x8B85)
(:object-buffer-size-ati #x8764)
(:object-buffer-usage-ati #x8765)
(:object-compile-status-arb #x8B81)
(:object-delete-status-arb #x8B80)
(:object-distance-to-line-sgis #x81F3)
(:object-distance-to-point-sgis #x81F1)
(:object-info-log-length-arb #x8B84)
(:object-line-sgis #x81F7)
(:object-linear #x2401)
(:object-linear-nv #x2401)
(:object-link-status-arb #x8B82)
(:object-plane #x2501)
(:object-point-sgis #x81F5)
(:object-shader-source-length-arb #x8B88)
(:object-subtype-arb #x8B4F)
(:object-type #x9112)
(:object-type-apple #x9112)
(:object-type-arb #x8B4E)
(:object-validate-status-arb #x8B83)
(:occlusion-query-event-mask-amd #x874F)
(:occlusion-test-hp #x8165)
(:occlusion-test-result-hp #x8166)
(:offset #x92FC)
(:offset-hilo-projective-texture-2d-nv #x8856)
(:offset-hilo-projective-texture-rectangle-nv #x8857)
(:offset-hilo-texture-2d-nv #x8854)
(:offset-hilo-texture-rectangle-nv #x8855)
(:offset-projective-texture-2d-nv #x8850)
(:offset-projective-texture-2d-scale-nv #x8851)
(:offset-projective-texture-rectangle-nv #x8852)
(:offset-projective-texture-rectangle-scale-nv #x8853)
(:offset-texture-2d-bias-nv #x86E3)
(:offset-texture-2d-matrix-nv #x86E1)
(:offset-texture-2d-nv #x86E8)
(:offset-texture-2d-scale-nv #x86E2)
(:offset-texture-bias-nv #x86E3)
(:offset-texture-matrix-nv #x86E1)
(:offset-texture-rectangle-nv #x864C)
(:offset-texture-rectangle-scale-nv #x864D)
(:offset-texture-scale-nv #x86E2)
(:one #x1)
(:one-ext #x87DE)
(:one-minus-constant-alpha #x8004)
(:one-minus-constant-alpha-ext #x8004)
(:one-minus-constant-color #x8002)
(:one-minus-constant-color-ext #x8002)
(:one-minus-dst-alpha #x305)
(:one-minus-dst-color #x307)
(:one-minus-src-alpha #x303)
(:one-minus-src-color #x301)
(:one-minus-src1-alpha #x88FB)
(:one-minus-src1-color #x88FA)
(:op-add-ext #x8787)
(:op-clamp-ext #x878E)
(:op-cross-product-ext #x8797)
(:op-dot3-ext #x8784)
(:op-dot4-ext #x8785)
(:op-exp-base-2-ext #x8791)
(:op-floor-ext #x878F)
(:op-frac-ext #x8789)
(:op-index-ext #x8782)
(:op-log-base-2-ext #x8792)
(:op-madd-ext #x8788)
(:op-max-ext #x878A)
(:op-min-ext #x878B)
(:op-mov-ext #x8799)
(:op-mul-ext #x8786)
(:op-multiply-matrix-ext #x8798)
(:op-negate-ext #x8783)
(:op-power-ext #x8793)
(:op-recip-ext #x8794)
(:op-recip-sqrt-ext #x8795)
(:op-round-ext #x8790)
(:op-set-ge-ext #x878C)
(:op-set-lt-ext #x878D)
(:op-sub-ext #x8796)
(:operand0-alpha #x8598)
(:operand0-alpha-arb #x8598)
(:operand0-alpha-ext #x8598)
(:operand0-rgb #x8590)
(:operand0-rgb-arb #x8590)
(:operand0-rgb-ext #x8590)
(:operand1-alpha #x8599)
(:operand1-alpha-arb #x8599)
(:operand1-alpha-ext #x8599)
(:operand1-rgb #x8591)
(:operand1-rgb-arb #x8591)
(:operand1-rgb-ext #x8591)
(:operand2-alpha #x859A)
(:operand2-alpha-arb #x859A)
(:operand2-alpha-ext #x859A)
(:operand2-rgb #x8592)
(:operand2-rgb-arb #x8592)
(:operand2-rgb-ext #x8592)
(:operand3-alpha-nv #x859B)
(:operand3-rgb-nv #x8593)
(:or #x1507)
(:or-inverted #x150D)
(:or-reverse #x150B)
(:order #xA01)
(:out-of-memory #x505)
(:output-color0-ext #x879B)
(:output-color1-ext #x879C)
(:output-fog-ext #x87BD)
(:output-texture-coord0-ext #x879D)
(:output-texture-coord1-ext #x879E)
(:output-texture-coord10-ext #x87A7)
(:output-texture-coord11-ext #x87A8)
(:output-texture-coord12-ext #x87A9)
(:output-texture-coord13-ext #x87AA)
(:output-texture-coord14-ext #x87AB)
(:output-texture-coord15-ext #x87AC)
(:output-texture-coord16-ext #x87AD)
(:output-texture-coord17-ext #x87AE)
(:output-texture-coord18-ext #x87AF)
(:output-texture-coord19-ext #x87B0)
(:output-texture-coord2-ext #x879F)
(:output-texture-coord20-ext #x87B1)
(:output-texture-coord21-ext #x87B2)
(:output-texture-coord22-ext #x87B3)
(:output-texture-coord23-ext #x87B4)
(:output-texture-coord24-ext #x87B5)
(:output-texture-coord25-ext #x87B6)
(:output-texture-coord26-ext #x87B7)
(:output-texture-coord27-ext #x87B8)
(:output-texture-coord28-ext #x87B9)
(:output-texture-coord29-ext #x87BA)
(:output-texture-coord3-ext #x87A0)
(:output-texture-coord30-ext #x87BB)
(:output-texture-coord31-ext #x87BC)
(:output-texture-coord4-ext #x87A1)
(:output-texture-coord5-ext #x87A2)
(:output-texture-coord6-ext #x87A3)
(:output-texture-coord7-ext #x87A4)
(:output-texture-coord8-ext #x87A5)
(:output-texture-coord9-ext #x87A6)
(:output-vertex-ext #x879A)
(:overlay #x9296)
(:overlay-khr #x9296)
(:overlay-nv #x9296)
(:pack-alignment #xD05)
(:pack-cmyk-hint-ext #x800E)
(:pack-compressed-block-depth #x912D)
(:pack-compressed-block-height #x912C)
(:pack-compressed-block-size #x912E)
(:pack-compressed-block-width #x912B)
(:pack-compressed-size-sgix #x831C)
(:pack-image-depth-sgis #x8131)
(:pack-image-height #x806C)
(:pack-image-height-ext #x806C)
(:pack-invert-mesa #x8758)
(:pack-lsb-first #xD01)
(:pack-max-compressed-size-sgix #x831B)
(:pack-resample-oml #x8984)
(:pack-resample-sgix #x842E)
(:pack-reverse-row-order-angle #x93A4)
(:pack-row-bytes-apple #x8A15)
(:pack-row-length #xD02)
(:pack-skip-images #x806B)
(:pack-skip-images-ext #x806B)
(:pack-skip-pixels #xD04)
(:pack-skip-rows #xD03)
(:pack-skip-volumes-sgis #x8130)
(:pack-subsample-rate-sgix #x85A0)
(:pack-swap-bytes #xD00)
(:palette4-r5-g6-b5-oes #x8B92)
(:palette4-rgb5-a1-oes #x8B94)
(:palette4-rgb8-oes #x8B90)
(:palette4-rgba4-oes #x8B93)
(:palette4-rgba8-oes #x8B91)
(:palette8-r5-g6-b5-oes #x8B97)
(:palette8-rgb5-a1-oes #x8B99)
(:palette8-rgb8-oes #x8B95)
(:palette8-rgba4-oes #x8B98)
(:palette8-rgba8-oes #x8B96)
(:parallel-arrays-intel #x83F4)
(:parameter-buffer-arb #x80EE)
(:parameter-buffer-binding-arb #x80EF)
(:partial-success-nv #x902E)
(:pass-through-nv #x86E6)
(:pass-through-token #x700)
(:patch-default-inner-level #x8E73)
(:patch-default-inner-level-ext #x8E73)
(:patch-default-outer-level #x8E74)
(:patch-default-outer-level-ext #x8E74)
(:patch-vertices #x8E72)
(:patch-vertices-ext #x8E72)
(:patch-vertices-oes #x8E72)
(:patches #xE)
(:patches-ext #xE)
(:patches-oes #xE)
(:path-client-length-nv #x907F)
(:path-command-count-nv #x909D)
(:path-computed-length-nv #x90A0)
(:path-coord-count-nv #x909E)
(:path-cover-depth-func-nv #x90BF)
(:path-dash-array-count-nv #x909F)
(:path-dash-caps-nv #x907B)
(:path-dash-offset-nv #x907E)
(:path-dash-offset-reset-nv #x90B4)
(:path-end-caps-nv #x9076)
(:path-error-position-nv #x90AB)
(:path-fill-bounding-box-nv #x90A1)
(:path-fill-cover-mode-nv #x9082)
(:path-fill-mask-nv #x9081)
(:path-fill-mode-nv #x9080)
(:path-fog-gen-mode-nv #x90AC)
(:path-format-ps-nv #x9071)
(:path-format-svg-nv #x9070)
(:path-gen-coeff-nv #x90B1)
(:path-gen-color-format-nv #x90B2)
(:path-gen-components-nv #x90B3)
(:path-gen-mode-nv #x90B0)
(:path-initial-dash-cap-nv #x907C)
(:path-initial-end-cap-nv #x9077)
(:path-join-style-nv #x9079)
(:path-max-modelview-stack-depth-nv #xD36)
(:path-max-projection-stack-depth-nv #xD38)
(:path-miter-limit-nv #x907A)
(:path-modelview-matrix-nv #xBA6)
(:path-modelview-nv #x1700)
(:path-modelview-stack-depth-nv #xBA3)
(:path-object-bounding-box-nv #x908A)
(:path-projection-matrix-nv #xBA7)
(:path-projection-nv #x1701)
(:path-projection-stack-depth-nv #xBA4)
(:path-stencil-depth-offset-factor-nv #x90BD)
(:path-stencil-depth-offset-units-nv #x90BE)
(:path-stencil-func-nv #x90B7)
(:path-stencil-ref-nv #x90B8)
(:path-stencil-value-mask-nv #x90B9)
(:path-stroke-bounding-box-nv #x90A2)
(:path-stroke-cover-mode-nv #x9083)
(:path-stroke-mask-nv #x9084)
(:path-stroke-width-nv #x9075)
(:path-terminal-dash-cap-nv #x907D)
(:path-terminal-end-cap-nv #x9078)
(:path-transpose-modelview-matrix-nv #x84E3)
(:path-transpose-projection-matrix-nv #x84E4)
(:per-stage-constants-nv #x8535)
(:percentage-amd #x8BC3)
(:perfmon-global-mode-qcom #x8FA0)
(:perfmon-result-amd #x8BC6)
(:perfmon-result-available-amd #x8BC4)
(:perfmon-result-size-amd #x8BC5)
(:performance-monitor-amd #x9152)
(:perfquery-counter-data-bool32-intel #x94FC)
(:perfquery-counter-data-double-intel #x94FB)
(:perfquery-counter-data-float-intel #x94FA)
(:perfquery-counter-data-uint32-intel #x94F8)
(:perfquery-counter-data-uint64-intel #x94F9)
(:perfquery-counter-desc-length-max-intel #x94FF)
(:perfquery-counter-duration-norm-intel #x94F1)
(:perfquery-counter-duration-raw-intel #x94F2)
(:perfquery-counter-event-intel #x94F0)
(:perfquery-counter-name-length-max-intel #x94FE)
(:perfquery-counter-raw-intel #x94F4)
(:perfquery-counter-throughput-intel #x94F3)
(:perfquery-counter-timestamp-intel #x94F5)
(:perfquery-donot-flush-intel #x83F9)
(:perfquery-flush-intel #x83FA)
(:perfquery-global-context-intel #x1)
(:perfquery-gpa-extended-counters-intel #x9500)
(:perfquery-query-name-length-max-intel #x94FD)
(:perfquery-single-context-intel #x0)
(:perfquery-wait-intel #x83FB)
(:perspective-correction-hint #xC50)
(:perturb-ext #x85AE)
(:phong-hint-win #x80EB)
(:phong-win #x80EA)
(:pinlight-nv #x92A8)
(:pixel-buffer-barrier-bit #x80)
(:pixel-buffer-barrier-bit-ext #x80)
(:pixel-count-available-nv #x8867)
(:pixel-count-nv #x8866)
(:pixel-counter-bits-nv #x8864)
(:pixel-cubic-weight-ext #x8333)
(:pixel-fragment-alpha-source-sgis #x8355)
(:pixel-fragment-rgb-source-sgis #x8354)
(:pixel-group-color-sgis #x8356)
(:pixel-mag-filter-ext #x8331)
(:pixel-map-a-to-a #xC79)
(:pixel-map-a-to-a-size #xCB9)
(:pixel-map-b-to-b #xC78)
(:pixel-map-b-to-b-size #xCB8)
(:pixel-map-g-to-g #xC77)
(:pixel-map-g-to-g-size #xCB7)
(:pixel-map-i-to-a #xC75)
(:pixel-map-i-to-a-size #xCB5)
(:pixel-map-i-to-b #xC74)
(:pixel-map-i-to-b-size #xCB4)
(:pixel-map-i-to-g #xC73)
(:pixel-map-i-to-g-size #xCB3)
(:pixel-map-i-to-i #xC70)
(:pixel-map-i-to-i-size #xCB0)
(:pixel-map-i-to-r #xC72)
(:pixel-map-i-to-r-size #xCB2)
(:pixel-map-r-to-r #xC76)
(:pixel-map-r-to-r-size #xCB6)
(:pixel-map-s-to-s #xC71)
(:pixel-map-s-to-s-size #xCB1)
(:pixel-min-filter-ext #x8332)
(:pixel-mode-bit #x20)
(:pixel-pack-buffer #x88EB)
(:pixel-pack-buffer-arb #x88EB)
(:pixel-pack-buffer-binding #x88ED)
(:pixel-pack-buffer-binding-arb #x88ED)
(:pixel-pack-buffer-binding-ext #x88ED)
(:pixel-pack-buffer-ext #x88EB)
(:pixel-subsample-2424-sgix #x85A3)
(:pixel-subsample-4242-sgix #x85A4)
(:pixel-subsample-4444-sgix #x85A2)
(:pixel-tex-gen-alpha-ls-sgix #x8189)
(:pixel-tex-gen-alpha-ms-sgix #x818A)
(:pixel-tex-gen-alpha-no-replace-sgix #x8188)
(:pixel-tex-gen-alpha-replace-sgix #x8187)
(:pixel-tex-gen-mode-sgix #x832B)
(:pixel-tex-gen-q-ceiling-sgix #x8184)
(:pixel-tex-gen-q-floor-sgix #x8186)
(:pixel-tex-gen-q-round-sgix #x8185)
(:pixel-tex-gen-sgix #x8139)
(:pixel-texture-sgis #x8353)
(:pixel-tile-best-alignment-sgix #x813E)
(:pixel-tile-cache-increment-sgix #x813F)
(:pixel-tile-cache-size-sgix #x8145)
(:pixel-tile-grid-depth-sgix #x8144)
(:pixel-tile-grid-height-sgix #x8143)
(:pixel-tile-grid-width-sgix #x8142)
(:pixel-tile-height-sgix #x8141)
(:pixel-tile-width-sgix #x8140)
(:pixel-transform-2d-ext #x8330)
(:pixel-transform-2d-matrix-ext #x8338)
(:pixel-transform-2d-stack-depth-ext #x8336)
(:pixel-unpack-buffer #x88EC)
(:pixel-unpack-buffer-arb #x88EC)
(:pixel-unpack-buffer-binding #x88EF)
(:pixel-unpack-buffer-binding-arb #x88EF)
(:pixel-unpack-buffer-binding-ext #x88EF)
(:pixel-unpack-buffer-ext #x88EC)
(:plus-clamped-alpha-nv #x92B2)
(:plus-clamped-nv #x92B1)
(:plus-darker-nv #x9292)
(:plus-nv #x9291)
(:pn-triangles-ati #x87F0)
(:pn-triangles-normal-mode-ati #x87F3)
(:pn-triangles-normal-mode-linear-ati #x87F7)
(:pn-triangles-normal-mode-quadratic-ati #x87F8)
(:pn-triangles-point-mode-ati #x87F2)
(:pn-triangles-point-mode-cubic-ati #x87F6)
(:pn-triangles-point-mode-linear-ati #x87F5)
(:pn-triangles-tesselation-level-ati #x87F4)
(:point #x1B00)
(:point-bit #x2)
(:point-distance-attenuation #x8129)
(:point-distance-attenuation-arb #x8129)
(:point-fade-threshold-size #x8128)
(:point-fade-threshold-size-arb #x8128)
(:point-fade-threshold-size-ext #x8128)
(:point-fade-threshold-size-sgis #x8128)
(:point-nv #x1B00)
(:point-size #xB11)
(:point-size-array-buffer-binding-oes #x8B9F)
(:point-size-array-oes #x8B9C)
(:point-size-array-pointer-oes #x898C)
(:point-size-array-stride-oes #x898B)
(:point-size-array-type-oes #x898A)
(:point-size-granularity #xB13)
(:point-size-max #x8127)
(:point-size-max-arb #x8127)
(:point-size-max-ext #x8127)
(:point-size-max-sgis #x8127)
(:point-size-min #x8126)
(:point-size-min-arb #x8126)
(:point-size-min-ext #x8126)
(:point-size-min-sgis #x8126)
(:point-size-range #xB12)
(:point-smooth #xB10)
(:point-smooth-hint #xC51)
(:point-sprite #x8861)
(:point-sprite-arb #x8861)
(:point-sprite-coord-origin #x8CA0)
(:point-sprite-nv #x8861)
(:point-sprite-oes #x8861)
(:point-sprite-r-mode-nv #x8863)
(:point-token #x701)
(:points #x0)
(:polygon #x9)
(:polygon-bit #x8)
(:polygon-mode #xB40)
(:polygon-mode-nv #xB40)
(:polygon-offset-bias-ext #x8039)
(:polygon-offset-clamp-ext #x8E1B)
(:polygon-offset-command-nv #xE)
(:polygon-offset-ext #x8037)
(:polygon-offset-factor #x8038)
(:polygon-offset-factor-ext #x8038)
(:polygon-offset-fill #x8037)
(:polygon-offset-line #x2A02)
(:polygon-offset-line-nv #x2A02)
(:polygon-offset-point #x2A01)
(:polygon-offset-point-nv #x2A01)
(:polygon-offset-units #x2A00)
(:polygon-smooth #xB41)
(:polygon-smooth-hint #xC53)
(:polygon-stipple #xB42)
(:polygon-stipple-bit #x10)
(:polygon-token #x703)
(:position #x1203)
(:post-color-matrix-alpha-bias #x80BB)
(:post-color-matrix-alpha-bias-sgi #x80BB)
(:post-color-matrix-alpha-scale #x80B7)
(:post-color-matrix-alpha-scale-sgi #x80B7)
(:post-color-matrix-blue-bias #x80BA)
(:post-color-matrix-blue-bias-sgi #x80BA)
(:post-color-matrix-blue-scale #x80B6)
(:post-color-matrix-blue-scale-sgi #x80B6)
(:post-color-matrix-color-table #x80D2)
(:post-color-matrix-color-table-sgi #x80D2)
(:post-color-matrix-green-bias #x80B9)
(:post-color-matrix-green-bias-sgi #x80B9)
(:post-color-matrix-green-scale #x80B5)
(:post-color-matrix-green-scale-sgi #x80B5)
(:post-color-matrix-red-bias #x80B8)
(:post-color-matrix-red-bias-sgi #x80B8)
(:post-color-matrix-red-scale #x80B4)
(:post-color-matrix-red-scale-sgi #x80B4)
(:post-convolution-alpha-bias #x8023)
(:post-convolution-alpha-bias-ext #x8023)
(:post-convolution-alpha-scale #x801F)
(:post-convolution-alpha-scale-ext #x801F)
(:post-convolution-blue-bias #x8022)
(:post-convolution-blue-bias-ext #x8022)
(:post-convolution-blue-scale #x801E)
(:post-convolution-blue-scale-ext #x801E)
(:post-convolution-color-table #x80D1)
(:post-convolution-color-table-sgi #x80D1)
(:post-convolution-green-bias #x8021)
(:post-convolution-green-bias-ext #x8021)
(:post-convolution-green-scale #x801D)
(:post-convolution-green-scale-ext #x801D)
(:post-convolution-red-bias #x8020)
(:post-convolution-red-bias-ext #x8020)
(:post-convolution-red-scale #x801C)
(:post-convolution-red-scale-ext #x801C)
(:post-image-transform-color-table-hp #x8162)
(:post-texture-filter-bias-range-sgix #x817B)
(:post-texture-filter-bias-sgix #x8179)
(:post-texture-filter-scale-range-sgix #x817C)
(:post-texture-filter-scale-sgix #x817A)
(:prefer-doublebuffer-hint-pgi #x1A1F8)
(:present-duration-nv #x8E2B)
(:present-time-nv #x8E2A)
(:preserve-ati #x8762)
(:previous #x8578)
(:previous-arb #x8578)
(:previous-ext #x8578)
(:previous-texture-input-nv #x86E4)
(:primary-color #x8577)
(:primary-color-arb #x8577)
(:primary-color-ext #x8577)
(:primary-color-nv #x852C)
(:primitive-bounding-box #x92BE)
(:primitive-bounding-box-arb #x92BE)
(:primitive-bounding-box-ext #x92BE)
(:primitive-bounding-box-oes #x92BE)
(:primitive-id-nv #x8C7C)
(:primitive-restart #x8F9D)
(:primitive-restart-fixed-index #x8D69)
(:primitive-restart-for-patches-supported #x8221)
(:primitive-restart-for-patches-supported-oes #x8221)
(:primitive-restart-index #x8F9E)
(:primitive-restart-index-nv #x8559)
(:primitive-restart-nv #x8558)
(:primitives-generated #x8C87)
(:primitives-generated-ext #x8C87)
(:primitives-generated-nv #x8C87)
(:primitives-generated-oes #x8C87)
(:primitives-submitted-arb #x82EF)
(:program #x82E2)
(:program-address-registers-arb #x88B0)
(:program-alu-instructions-arb #x8805)
(:program-attrib-components-nv #x8906)
(:program-attribs-arb #x88AC)
(:program-binary-angle #x93A6)
(:program-binary-formats #x87FF)
(:program-binary-formats-oes #x87FF)
(:program-binary-length #x8741)
(:program-binary-length-oes #x8741)
(:program-binary-retrievable-hint #x8257)
(:program-binding-arb #x8677)
(:program-error-position-arb #x864B)
(:program-error-position-nv #x864B)
(:program-error-string-arb #x8874)
(:program-error-string-nv #x8874)
(:program-format-arb #x8876)
(:program-format-ascii-arb #x8875)
(:program-input #x92E3)
(:program-instructions-arb #x88A0)
(:program-khr #x82E2)
(:program-length-arb #x8627)
(:program-length-nv #x8627)
(:program-matrix-ext #x8E2D)
(:program-matrix-stack-depth-ext #x8E2F)
(:program-native-address-registers-arb #x88B2)
(:program-native-alu-instructions-arb #x8808)
(:program-native-attribs-arb #x88AE)
(:program-native-instructions-arb #x88A2)
(:program-native-parameters-arb #x88AA)
(:program-native-temporaries-arb #x88A6)
(:program-native-tex-indirections-arb #x880A)
(:program-native-tex-instructions-arb #x8809)
(:program-object-arb #x8B40)
(:program-object-ext #x8B40)
(:program-output #x92E4)
(:program-parameter-nv #x8644)
(:program-parameters-arb #x88A8)
(:program-pipeline #x82E4)
(:program-pipeline-binding #x825A)
(:program-pipeline-binding-ext #x825A)
(:program-pipeline-khr #x82E4)
(:program-pipeline-object-ext #x8A4F)
(:program-point-size #x8642)
(:program-point-size-arb #x8642)
(:program-point-size-ext #x8642)
(:program-resident-nv #x8647)
(:program-result-components-nv #x8907)
(:program-separable #x8258)
(:program-separable-ext #x8258)
(:program-string-arb #x8628)
(:program-string-nv #x8628)
(:program-target-nv #x8646)
(:program-temporaries-arb #x88A4)
(:program-tex-indirections-arb #x8807)
(:program-tex-instructions-arb #x8806)
(:program-under-native-limits-arb #x88B6)
(:programmable-sample-location-arb #x9341)
(:programmable-sample-location-nv #x9341)
(:programmable-sample-location-table-size-arb #x9340)
(:programmable-sample-location-table-size-nv #x9340)
(:projection #x1701)
(:projection-matrix #xBA7)
(:projection-matrix-float-as-int-bits-oes #x898E)
(:projection-stack-depth #xBA4)
(:provoking-vertex #x8E4F)
(:provoking-vertex-ext #x8E4F)
(:proxy-color-table #x80D3)
(:proxy-color-table-sgi #x80D3)
(:proxy-histogram #x8025)
(:proxy-histogram-ext #x8025)
(:proxy-post-color-matrix-color-table #x80D5)
(:proxy-post-color-matrix-color-table-sgi #x80D5)
(:proxy-post-convolution-color-table #x80D4)
(:proxy-post-convolution-color-table-sgi #x80D4)
(:proxy-post-image-transform-color-table-hp #x8163)
(:proxy-texture-1d #x8063)
(:proxy-texture-1d-array #x8C19)
(:proxy-texture-1d-array-ext #x8C19)
(:proxy-texture-1d-ext #x8063)
(:proxy-texture-1d-stack-mesax #x875B)
(:proxy-texture-2d #x8064)
(:proxy-texture-2d-array #x8C1B)
(:proxy-texture-2d-array-ext #x8C1B)
(:proxy-texture-2d-ext #x8064)
(:proxy-texture-2d-multisample #x9101)
(:proxy-texture-2d-multisample-array #x9103)
(:proxy-texture-2d-stack-mesax #x875C)
(:proxy-texture-3d #x8070)
(:proxy-texture-3d-ext #x8070)
(:proxy-texture-4d-sgis #x8135)
(:proxy-texture-color-table-sgi #x80BD)
(:proxy-texture-cube-map #x851B)
(:proxy-texture-cube-map-arb #x851B)
(:proxy-texture-cube-map-array #x900B)
(:proxy-texture-cube-map-array-arb #x900B)
(:proxy-texture-cube-map-ext #x851B)
(:proxy-texture-rectangle #x84F7)
(:proxy-texture-rectangle-arb #x84F7)
(:proxy-texture-rectangle-nv #x84F7)
(:purgeable-apple #x8A1D)
(:q #x2003)
(:quad-alpha4-sgis #x811E)
(:quad-alpha8-sgis #x811F)
(:quad-intensity4-sgis #x8122)
(:quad-intensity8-sgis #x8123)
(:quad-luminance4-sgis #x8120)
(:quad-luminance8-sgis #x8121)
(:quad-mesh-sun #x8614)
(:quad-strip #x8)
(:quad-texture-select-sgis #x8125)
(:quadratic-attenuation #x1209)
(:quadratic-curve-to-nv #xA)
(:quads #x7)
(:quads-ext #x7)
(:quads-follow-provoking-vertex-convention #x8E4C)
(:quads-follow-provoking-vertex-convention-ext #x8E4C)
(:quads-oes #x7)
(:quarter-bit-ati #x10)
(:query #x82E3)
(:query-all-event-bits-amd #xFFFFFFFF)
(:query-buffer #x9192)
(:query-buffer-amd #x9192)
(:query-buffer-barrier-bit #x8000)
(:query-buffer-binding #x9193)
(:query-buffer-binding-amd #x9193)
(:query-by-region-no-wait #x8E16)
(:query-by-region-no-wait-inverted #x8E1A)
(:query-by-region-no-wait-nv #x8E16)
(:query-by-region-wait #x8E15)
(:query-by-region-wait-inverted #x8E19)
(:query-by-region-wait-nv #x8E15)
(:query-counter-bits #x8864)
(:query-counter-bits-arb #x8864)
(:query-counter-bits-ext #x8864)
(:query-depth-bounds-fail-event-bit-amd #x8)
(:query-depth-fail-event-bit-amd #x2)
(:query-depth-pass-event-bit-amd #x1)
(:query-khr #x82E3)
(:query-no-wait #x8E14)
(:query-no-wait-inverted #x8E18)
(:query-no-wait-nv #x8E14)
(:query-object-amd #x9153)
(:query-object-ext #x9153)
(:query-result #x8866)
(:query-result-arb #x8866)
(:query-result-available #x8867)
(:query-result-available-arb #x8867)
(:query-result-available-ext #x8867)
(:query-result-ext #x8866)
(:query-result-no-wait #x9194)
(:query-result-no-wait-amd #x9194)
(:query-stencil-fail-event-bit-amd #x4)
(:query-target #x82EA)
(:query-wait #x8E13)
(:query-wait-inverted #x8E17)
(:query-wait-nv #x8E13)
(:r #x2002)
(:r11f-g11f-b10f #x8C3A)
(:r11f-g11f-b10f-apple #x8C3A)
(:r11f-g11f-b10f-ext #x8C3A)
(:r16 #x822A)
(:r16-ext #x822A)
(:r16-snorm #x8F98)
(:r16-snorm-ext #x8F98)
(:r16f #x822D)
(:r16f-ext #x822D)
(:r16i #x8233)
(:r16ui #x8234)
(:r1ui-c3f-v3f-sun #x85C6)
(:r1ui-c4f-n3f-v3f-sun #x85C8)
(:r1ui-c4ub-v3f-sun #x85C5)
(:r1ui-n3f-v3f-sun #x85C7)
(:r1ui-t2f-c4f-n3f-v3f-sun #x85CB)
(:r1ui-t2f-n3f-v3f-sun #x85CA)
(:r1ui-t2f-v3f-sun #x85C9)
(:r1ui-v3f-sun #x85C4)
(:r3-g3-b2 #x2A10)
(:r32f #x822E)
(:r32f-ext #x822E)
(:r32i #x8235)
(:r32ui #x8236)
(:r8 #x8229)
(:r8-ext #x8229)
(:r8-snorm #x8F94)
(:r8i #x8231)
(:r8ui #x8232)
(:raster-fixed-sample-locations-ext #x932A)
(:raster-multisample-ext #x9327)
(:raster-position-unclipped-ibm #x19262)
(:raster-samples-ext #x9328)
(:rasterizer-discard #x8C89)
(:rasterizer-discard-ext #x8C89)
(:rasterizer-discard-nv #x8C89)
(:read-buffer #xC02)
(:read-buffer-ext #xC02)
(:read-buffer-nv #xC02)
(:read-framebuffer #x8CA8)
(:read-framebuffer-angle #x8CA8)
(:read-framebuffer-apple #x8CA8)
(:read-framebuffer-binding #x8CAA)
(:read-framebuffer-binding-angle #x8CAA)
(:read-framebuffer-binding-apple #x8CAA)
(:read-framebuffer-binding-ext #x8CAA)
(:read-framebuffer-binding-nv #x8CAA)
(:read-framebuffer-ext #x8CA8)
(:read-framebuffer-nv #x8CA8)
(:read-only #x88B8)
(:read-only-arb #x88B8)
(:read-pixel-data-range-length-nv #x887B)
(:read-pixel-data-range-nv #x8879)
(:read-pixel-data-range-pointer-nv #x887D)
(:read-pixels #x828C)
(:read-pixels-format #x828D)
(:read-pixels-type #x828E)
(:read-write #x88BA)
(:read-write-arb #x88BA)
(:recip-add-signed-alpha-img #x8C05)
(:reclaim-memory-hint-pgi #x1A1FE)
(:rect-nv #xF6)
(:red #x1903)
(:red-bias #xD15)
(:red-bit-ati #x1)
(:red-bits #xD52)
(:red-ext #x1903)
(:red-integer #x8D94)
(:red-integer-ext #x8D94)
(:red-max-clamp-ingr #x8564)
(:red-min-clamp-ingr #x8560)
(:red-nv #x1903)
(:red-scale #xD14)
(:red-snorm #x8F90)
(:reduce #x8016)
(:reduce-ext #x8016)
(:reference-plane-equation-sgix #x817E)
(:reference-plane-sgix #x817D)
(:referenced-by-compute-shader #x930B)
(:referenced-by-fragment-shader #x930A)
(:referenced-by-geometry-shader #x9309)
(:referenced-by-geometry-shader-ext #x9309)
(:referenced-by-geometry-shader-oes #x9309)
(:referenced-by-tess-control-shader #x9307)
(:referenced-by-tess-control-shader-ext #x9307)
(:referenced-by-tess-control-shader-oes #x9307)
(:referenced-by-tess-evaluation-shader #x9308)
(:referenced-by-tess-evaluation-shader-ext #x9308)
(:referenced-by-tess-evaluation-shader-oes #x9308)
(:referenced-by-vertex-shader #x9306)
(:reflection-map #x8512)
(:reflection-map-arb #x8512)
(:reflection-map-ext #x8512)
(:reflection-map-nv #x8512)
(:reflection-map-oes #x8512)
(:reg-0-ati #x8921)
(:reg-1-ati #x8922)
(:reg-10-ati #x892B)
(:reg-11-ati #x892C)
(:reg-12-ati #x892D)
(:reg-13-ati #x892E)
(:reg-14-ati #x892F)
(:reg-15-ati #x8930)
(:reg-16-ati #x8931)
(:reg-17-ati #x8932)
(:reg-18-ati #x8933)
(:reg-19-ati #x8934)
(:reg-2-ati #x8923)
(:reg-20-ati #x8935)
(:reg-21-ati #x8936)
(:reg-22-ati #x8937)
(:reg-23-ati #x8938)
(:reg-24-ati #x8939)
(:reg-25-ati #x893A)
(:reg-26-ati #x893B)
(:reg-27-ati #x893C)
(:reg-28-ati #x893D)
(:reg-29-ati #x893E)
(:reg-3-ati #x8924)
(:reg-30-ati #x893F)
(:reg-31-ati #x8940)
(:reg-4-ati #x8925)
(:reg-5-ati #x8926)
(:reg-6-ati #x8927)
(:reg-7-ati #x8928)
(:reg-8-ati #x8929)
(:reg-9-ati #x892A)
(:register-combiners-nv #x8522)
(:relative-arc-to-nv #xFF)
(:relative-conic-curve-to-nv #x1B)
(:relative-cubic-curve-to-nv #xD)
(:relative-horizontal-line-to-nv #x7)
(:relative-large-ccw-arc-to-nv #x17)
(:relative-large-cw-arc-to-nv #x19)
(:relative-line-to-nv #x5)
(:relative-move-to-nv #x3)
(:relative-quadratic-curve-to-nv #xB)
(:relative-rect-nv #xF7)
(:relative-rounded-rect-nv #xE9)
(:relative-rounded-rect2-nv #xEB)
(:relative-rounded-rect4-nv #xED)
(:relative-rounded-rect8-nv #xEF)
(:relative-small-ccw-arc-to-nv #x13)
(:relative-small-cw-arc-to-nv #x15)
(:relative-smooth-cubic-curve-to-nv #x11)
(:relative-smooth-quadratic-curve-to-nv #xF)
(:relative-vertical-line-to-nv #x9)
(:released-apple #x8A19)
(:render #x1C00)
(:render-direct-to-framebuffer-qcom #x8FB3)
(:render-mode #xC40)
(:renderbuffer #x8D41)
(:renderbuffer-alpha-size #x8D53)
(:renderbuffer-alpha-size-ext #x8D53)
(:renderbuffer-alpha-size-oes #x8D53)
(:renderbuffer-binding #x8CA7)
(:renderbuffer-binding-angle #x8CA7)
(:renderbuffer-binding-ext #x8CA7)
(:renderbuffer-binding-oes #x8CA7)
(:renderbuffer-blue-size #x8D52)
(:renderbuffer-blue-size-ext #x8D52)
(:renderbuffer-blue-size-oes #x8D52)
(:renderbuffer-color-samples-nv #x8E10)
(:renderbuffer-coverage-samples-nv #x8CAB)
(:renderbuffer-depth-size #x8D54)
(:renderbuffer-depth-size-ext #x8D54)
(:renderbuffer-depth-size-oes #x8D54)
(:renderbuffer-ext #x8D41)
(:renderbuffer-free-memory-ati #x87FD)
(:renderbuffer-green-size #x8D51)
(:renderbuffer-green-size-ext #x8D51)
(:renderbuffer-green-size-oes #x8D51)
(:renderbuffer-height #x8D43)
(:renderbuffer-height-ext #x8D43)
(:renderbuffer-height-oes #x8D43)
(:renderbuffer-internal-format #x8D44)
(:renderbuffer-internal-format-ext #x8D44)
(:renderbuffer-internal-format-oes #x8D44)
(:renderbuffer-oes #x8D41)
(:renderbuffer-red-size #x8D50)
(:renderbuffer-red-size-ext #x8D50)
(:renderbuffer-red-size-oes #x8D50)
(:renderbuffer-samples #x8CAB)
(:renderbuffer-samples-angle #x8CAB)
(:renderbuffer-samples-apple #x8CAB)
(:renderbuffer-samples-ext #x8CAB)
(:renderbuffer-samples-img #x9133)
(:renderbuffer-samples-nv #x8CAB)
(:renderbuffer-stencil-size #x8D55)
(:renderbuffer-stencil-size-ext #x8D55)
(:renderbuffer-stencil-size-oes #x8D55)
(:renderbuffer-width #x8D42)
(:renderbuffer-width-ext #x8D42)
(:renderbuffer-width-oes #x8D42)
(:renderer #x1F01)
(:repeat #x2901)
(:replace #x1E01)
(:replace-ext #x8062)
(:replace-middle-sun #x2)
(:replace-oldest-sun #x3)
(:replace-value-amd #x874B)
(:replacement-code-array-pointer-sun #x85C3)
(:replacement-code-array-stride-sun #x85C2)
(:replacement-code-array-sun #x85C0)
(:replacement-code-array-type-sun #x85C1)
(:replacement-code-sun #x81D8)
(:replicate-border #x8153)
(:replicate-border-hp #x8153)
(:required-texture-image-units-oes #x8D68)
(:resample-average-oml #x8988)
(:resample-decimate-oml #x8989)
(:resample-decimate-sgix #x8430)
(:resample-replicate-oml #x8986)
(:resample-replicate-sgix #x8433)
(:resample-zero-fill-oml #x8987)
(:resample-zero-fill-sgix #x8434)
(:rescale-normal #x803A)
(:rescale-normal-ext #x803A)
(:reset-notification-strategy #x8256)
(:reset-notification-strategy-arb #x8256)
(:reset-notification-strategy-ext #x8256)
(:reset-notification-strategy-khr #x8256)
(:restart-path-nv #xF0)
(:restart-sun #x1)
(:retained-apple #x8A1B)
(:return #x102)
(:rg #x8227)
(:rg-ext #x8227)
(:rg-integer #x8228)
(:rg-snorm #x8F91)
(:rg16 #x822C)
(:rg16-ext #x822C)
(:rg16-snorm #x8F99)
(:rg16-snorm-ext #x8F99)
(:rg16f #x822F)
(:rg16f-ext #x822F)
(:rg16i #x8239)
(:rg16ui #x823A)
(:rg32f #x8230)
(:rg32f-ext #x8230)
(:rg32i #x823B)
(:rg32ui #x823C)
(:rg8 #x822B)
(:rg8-ext #x822B)
(:rg8-snorm #x8F95)
(:rg8i #x8237)
(:rg8ui #x8238)
(:rgb #x1907)
(:rgb-422-apple #x8A1F)
(:rgb-float16-apple #x881B)
(:rgb-float16-ati #x881B)
(:rgb-float32-apple #x8815)
(:rgb-float32-ati #x8815)
(:rgb-integer #x8D98)
(:rgb-integer-ext #x8D98)
(:rgb-raw-422-apple #x8A51)
(:rgb-s3tc #x83A0)
(:rgb-scale #x8573)
(:rgb-scale-arb #x8573)
(:rgb-scale-ext #x8573)
(:rgb-snorm #x8F92)
(:rgb10 #x8052)
(:rgb10-a2 #x8059)
(:rgb10-a2-ext #x8059)
(:rgb10-a2ui #x906F)
(:rgb10-ext #x8052)
(:rgb12 #x8053)
(:rgb12-ext #x8053)
(:rgb16 #x8054)
(:rgb16-ext #x8054)
(:rgb16-snorm #x8F9A)
(:rgb16-snorm-ext #x8F9A)
(:rgb16f #x881B)
(:rgb16f-arb #x881B)
(:rgb16f-ext #x881B)
(:rgb16i #x8D89)
(:rgb16i-ext #x8D89)
(:rgb16ui #x8D77)
(:rgb16ui-ext #x8D77)
(:rgb2-ext #x804E)
(:rgb32f #x8815)
(:rgb32f-arb #x8815)
(:rgb32f-ext #x8815)
(:rgb32i #x8D83)
(:rgb32i-ext #x8D83)
(:rgb32ui #x8D71)
(:rgb32ui-ext #x8D71)
(:rgb4 #x804F)
(:rgb4-ext #x804F)
(:rgb4-s3tc #x83A1)
(:rgb5 #x8050)
(:rgb5-a1 #x8057)
(:rgb5-a1-ext #x8057)
(:rgb5-a1-oes #x8057)
(:rgb5-ext #x8050)
(:rgb565 #x8D62)
(:rgb565-oes #x8D62)
(:rgb8 #x8051)
(:rgb8-ext #x8051)
(:rgb8-oes #x8051)
(:rgb8-snorm #x8F96)
(:rgb8i #x8D8F)
(:rgb8i-ext #x8D8F)
(:rgb8ui #x8D7D)
(:rgb8ui-ext #x8D7D)
(:rgb9-e5 #x8C3D)
(:rgb9-e5-apple #x8C3D)
(:rgb9-e5-ext #x8C3D)
(:rgba #x1908)
(:rgba-dxt5-s3tc #x83A4)
(:rgba-float-mode-arb #x8820)
(:rgba-float-mode-ati #x8820)
(:rgba-float16-apple #x881A)
(:rgba-float16-ati #x881A)
(:rgba-float32-apple #x8814)
(:rgba-float32-ati #x8814)
(:rgba-integer #x8D99)
(:rgba-integer-ext #x8D99)
(:rgba-integer-mode-ext #x8D9E)
(:rgba-mode #xC31)
(:rgba-s3tc #x83A2)
(:rgba-signed-components-ext #x8C3C)
(:rgba-snorm #x8F93)
(:rgba-unsigned-dot-product-mapping-nv #x86D9)
(:rgba12 #x805A)
(:rgba12-ext #x805A)
(:rgba16 #x805B)
(:rgba16-ext #x805B)
(:rgba16-snorm #x8F9B)
(:rgba16-snorm-ext #x8F9B)
(:rgba16f #x881A)
(:rgba16f-arb #x881A)
(:rgba16f-ext #x881A)
(:rgba16i #x8D88)
(:rgba16i-ext #x8D88)
(:rgba16ui #x8D76)
(:rgba16ui-ext #x8D76)
(:rgba2 #x8055)
(:rgba2-ext #x8055)
(:rgba32f #x8814)
(:rgba32f-arb #x8814)
(:rgba32f-ext #x8814)
(:rgba32i #x8D82)
(:rgba32i-ext #x8D82)
(:rgba32ui #x8D70)
(:rgba32ui-ext #x8D70)
(:rgba4 #x8056)
(:rgba4-dxt5-s3tc #x83A5)
(:rgba4-ext #x8056)
(:rgba4-oes #x8056)
(:rgba4-s3tc #x83A3)
(:rgba8 #x8058)
(:rgba8-ext #x8058)
(:rgba8-oes #x8058)
(:rgba8-snorm #x8F97)
(:rgba8i #x8D8E)
(:rgba8i-ext #x8D8E)
(:rgba8ui #x8D7C)
(:rgba8ui-ext #x8D7C)
(:right #x407)
(:round-nv #x90A4)
(:rounded-rect-nv #xE8)
(:rounded-rect2-nv #xEA)
(:rounded-rect4-nv #xEC)
(:rounded-rect8-nv #xEE)
(:s #x2000)
(:sample-alpha-to-coverage #x809E)
(:sample-alpha-to-coverage-arb #x809E)
(:sample-alpha-to-mask-ext #x809E)
(:sample-alpha-to-mask-sgis #x809E)
(:sample-alpha-to-one #x809F)
(:sample-alpha-to-one-arb #x809F)
(:sample-alpha-to-one-ext #x809F)
(:sample-alpha-to-one-sgis #x809F)
(:sample-buffers #x80A8)
(:sample-buffers-3dfx #x86B3)
(:sample-buffers-arb #x80A8)
(:sample-buffers-ext #x80A8)
(:sample-buffers-sgis #x80A8)
(:sample-coverage #x80A0)
(:sample-coverage-arb #x80A0)
(:sample-coverage-invert #x80AB)
(:sample-coverage-invert-arb #x80AB)
(:sample-coverage-value #x80AA)
(:sample-coverage-value-arb #x80AA)
(:sample-location-arb #x8E50)
(:sample-location-nv #x8E50)
(:sample-location-pixel-grid-height-arb #x933F)
(:sample-location-pixel-grid-height-nv #x933F)
(:sample-location-pixel-grid-width-arb #x933E)
(:sample-location-pixel-grid-width-nv #x933E)
(:sample-location-subpixel-bits-arb #x933D)
(:sample-location-subpixel-bits-nv #x933D)
(:sample-mask #x8E51)
(:sample-mask-ext #x80A0)
(:sample-mask-invert-ext #x80AB)
(:sample-mask-invert-sgis #x80AB)
(:sample-mask-nv #x8E51)
(:sample-mask-sgis #x80A0)
(:sample-mask-value #x8E52)
(:sample-mask-value-ext #x80AA)
(:sample-mask-value-nv #x8E52)
(:sample-mask-value-sgis #x80AA)
(:sample-pattern-ext #x80AC)
(:sample-pattern-sgis #x80AC)
(:sample-position #x8E50)
(:sample-position-nv #x8E50)
(:sample-shading #x8C36)
(:sample-shading-arb #x8C36)
(:sample-shading-oes #x8C36)
(:sampler #x82E6)
(:sampler-1d #x8B5D)
(:sampler-1d-arb #x8B5D)
(:sampler-1d-array #x8DC0)
(:sampler-1d-array-ext #x8DC0)
(:sampler-1d-array-shadow #x8DC3)
(:sampler-1d-array-shadow-ext #x8DC3)
(:sampler-1d-shadow #x8B61)
(:sampler-1d-shadow-arb #x8B61)
(:sampler-2d #x8B5E)
(:sampler-2d-arb #x8B5E)
(:sampler-2d-array #x8DC1)
(:sampler-2d-array-ext #x8DC1)
(:sampler-2d-array-shadow #x8DC4)
(:sampler-2d-array-shadow-ext #x8DC4)
(:sampler-2d-array-shadow-nv #x8DC4)
(:sampler-2d-multisample #x9108)
(:sampler-2d-multisample-array #x910B)
(:sampler-2d-multisample-array-oes #x910B)
(:sampler-2d-rect #x8B63)
(:sampler-2d-rect-arb #x8B63)
(:sampler-2d-rect-shadow #x8B64)
(:sampler-2d-rect-shadow-arb #x8B64)
(:sampler-2d-shadow #x8B62)
(:sampler-2d-shadow-arb #x8B62)
(:sampler-2d-shadow-ext #x8B62)
(:sampler-3d #x8B5F)
(:sampler-3d-arb #x8B5F)
(:sampler-3d-oes #x8B5F)
(:sampler-binding #x8919)
(:sampler-buffer #x8DC2)
(:sampler-buffer-amd #x9001)
(:sampler-buffer-ext #x8DC2)
(:sampler-buffer-oes #x8DC2)
(:sampler-cube #x8B60)
(:sampler-cube-arb #x8B60)
(:sampler-cube-map-array #x900C)
(:sampler-cube-map-array-arb #x900C)
(:sampler-cube-map-array-ext #x900C)
(:sampler-cube-map-array-oes #x900C)
(:sampler-cube-map-array-shadow #x900D)
(:sampler-cube-map-array-shadow-arb #x900D)
(:sampler-cube-map-array-shadow-ext #x900D)
(:sampler-cube-map-array-shadow-oes #x900D)
(:sampler-cube-shadow #x8DC5)
(:sampler-cube-shadow-ext #x8DC5)
(:sampler-cube-shadow-nv #x8DC5)
(:sampler-external-2d-y2y-ext #x8BE7)
(:sampler-external-oes #x8D66)
(:sampler-khr #x82E6)
(:sampler-object-amd #x9155)
(:sampler-renderbuffer-nv #x8E56)
(:samples #x80A9)
(:samples-3dfx #x86B4)
(:samples-arb #x80A9)
(:samples-ext #x80A9)
(:samples-passed #x8914)
(:samples-passed-arb #x8914)
(:samples-sgis #x80A9)
(:saturate-bit-ati #x40)
(:scalar-ext #x87BE)
(:scale-by-four-nv #x853F)
(:scale-by-one-half-nv #x8540)
(:scale-by-two-nv #x853E)
(:scalebias-hint-sgix #x8322)
(:scaled-resolve-fastest-ext #x90BA)
(:scaled-resolve-nicest-ext #x90BB)
(:scissor-bit #x80000)
(:scissor-box #xC10)
(:scissor-command-nv #x11)
(:scissor-test #xC11)
(:screen #x9295)
(:screen-coordinates-rend #x8490)
(:screen-khr #x9295)
(:screen-nv #x9295)
(:secondary-color-array #x845E)
(:secondary-color-array-address-nv #x8F27)
(:secondary-color-array-buffer-binding #x889C)
(:secondary-color-array-buffer-binding-arb #x889C)
(:secondary-color-array-ext #x845E)
(:secondary-color-array-length-nv #x8F31)
(:secondary-color-array-list-ibm #x192A5)
(:secondary-color-array-list-stride-ibm #x192AF)
(:secondary-color-array-pointer #x845D)
(:secondary-color-array-pointer-ext #x845D)
(:secondary-color-array-size #x845A)
(:secondary-color-array-size-ext #x845A)
(:secondary-color-array-stride #x845C)
(:secondary-color-array-stride-ext #x845C)
(:secondary-color-array-type #x845B)
(:secondary-color-array-type-ext #x845B)
(:secondary-color-nv #x852D)
(:secondary-interpolator-ati #x896D)
(:select #x1C02)
(:selection-buffer-pointer #xDF3)
(:selection-buffer-size #xDF4)
(:separable-2d #x8012)
(:separable-2d-ext #x8012)
(:separate-attribs #x8C8D)
(:separate-attribs-ext #x8C8D)
(:separate-attribs-nv #x8C8D)
(:separate-specular-color #x81FA)
(:separate-specular-color-ext #x81FA)
(:set #x150F)
(:set-amd #x874A)
(:sgx-binary-img #x8C0A)
(:sgx-program-binary-img #x9130)
(:shade-model #xB54)
(:shader #x82E1)
(:shader-binary-dmp #x9250)
(:shader-binary-formats #x8DF8)
(:shader-binary-viv #x8FC4)
(:shader-compiler #x8DFA)
(:shader-consistent-nv #x86DD)
(:shader-global-access-barrier-bit-nv #x10)
(:shader-image-access-barrier-bit #x20)
(:shader-image-access-barrier-bit-ext #x20)
(:shader-image-atomic #x82A6)
(:shader-image-load #x82A4)
(:shader-image-store #x82A5)
(:shader-include-arb #x8DAE)
(:shader-khr #x82E1)
(:shader-object-arb #x8B48)
(:shader-object-ext #x8B48)
(:shader-operation-nv #x86DF)
(:shader-pixel-local-storage-ext #x8F64)
(:shader-source-length #x8B88)
(:shader-storage-barrier-bit #x2000)
(:shader-storage-block #x92E6)
(:shader-storage-buffer #x90D2)
(:shader-storage-buffer-binding #x90D3)
(:shader-storage-buffer-offset-alignment #x90DF)
(:shader-storage-buffer-size #x90D5)
(:shader-storage-buffer-start #x90D4)
(:shader-type #x8B4F)
(:shading-language-version #x8B8C)
(:shading-language-version-arb #x8B8C)
(:shadow-ambient-sgix #x80BF)
(:shadow-attenuation-ext #x834E)
(:shared-edge-nv #xC0)
(:shared-texture-palette-ext #x81FB)
(:sharpen-texture-func-points-sgis #x80B0)
(:shininess #x1601)
(:short #x1402)
(:signaled #x9119)
(:signaled-apple #x9119)
(:signed-alpha-nv #x8705)
(:signed-alpha8-nv #x8706)
(:signed-hilo-nv #x86F9)
(:signed-hilo16-nv #x86FA)
(:signed-hilo8-nv #x885F)
(:signed-identity-nv #x853C)
(:signed-intensity-nv #x8707)
(:signed-intensity8-nv #x8708)
(:signed-luminance-alpha-nv #x8703)
(:signed-luminance-nv #x8701)
(:signed-luminance8-alpha8-nv #x8704)
(:signed-luminance8-nv #x8702)
(:signed-negate-nv #x853D)
(:signed-normalized #x8F9C)
(:signed-rgb-nv #x86FE)
(:signed-rgb-unsigned-alpha-nv #x870C)
(:signed-rgb8-nv #x86FF)
(:signed-rgb8-unsigned-alpha8-nv #x870D)
(:signed-rgba-nv #x86FB)
(:signed-rgba8-nv #x86FC)
(:simultaneous-texture-and-depth-test #x82AC)
(:simultaneous-texture-and-depth-write #x82AE)
(:simultaneous-texture-and-stencil-test #x82AD)
(:simultaneous-texture-and-stencil-write #x82AF)
(:single-color #x81F9)
(:single-color-ext #x81F9)
(:skip-components1-nv #x-6)
(:skip-components2-nv #x-5)
(:skip-components3-nv #x-4)
(:skip-components4-nv #x-3)
(:skip-decode-ext #x8A4A)
(:skip-missing-glyph-nv #x90A9)
(:slice-accum-sun #x85CC)
(:slim10u-sgix #x831E)
(:slim12s-sgix #x831F)
(:slim8u-sgix #x831D)
(:sluminance #x8C46)
(:sluminance-alpha #x8C44)
(:sluminance-alpha-ext #x8C44)
(:sluminance-alpha-nv #x8C44)
(:sluminance-ext #x8C46)
(:sluminance-nv #x8C46)
(:sluminance8 #x8C47)
(:sluminance8-alpha8 #x8C45)
(:sluminance8-alpha8-ext #x8C45)
(:sluminance8-alpha8-nv #x8C45)
(:sluminance8-ext #x8C47)
(:sluminance8-nv #x8C47)
(:sm-count-nv #x933B)
(:small-ccw-arc-to-nv #x12)
(:small-cw-arc-to-nv #x14)
(:smaphs-program-binary-dmp #x9252)
(:smaphs30-program-binary-dmp #x9251)
(:smooth #x1D01)
(:smooth-cubic-curve-to-nv #x10)
(:smooth-line-width-granularity #xB23)
(:smooth-line-width-range #xB22)
(:smooth-point-size-granularity #xB13)
(:smooth-point-size-range #xB12)
(:smooth-quadratic-curve-to-nv #xE)
(:softlight #x929C)
(:softlight-khr #x929C)
(:softlight-nv #x929C)
(:source0-alpha #x8588)
(:source0-alpha-arb #x8588)
(:source0-alpha-ext #x8588)
(:source0-rgb #x8580)
(:source0-rgb-arb #x8580)
(:source0-rgb-ext #x8580)
(:source1-alpha #x8589)
(:source1-alpha-arb #x8589)
(:source1-alpha-ext #x8589)
(:source1-rgb #x8581)
(:source1-rgb-arb #x8581)
(:source1-rgb-ext #x8581)
(:source2-alpha #x858A)
(:source2-alpha-arb #x858A)
(:source2-alpha-ext #x858A)
(:source2-rgb #x8582)
(:source2-rgb-arb #x8582)
(:source2-rgb-ext #x8582)
(:source3-alpha-nv #x858B)
(:source3-rgb-nv #x8583)
(:spare0-nv #x852E)
(:spare0-plus-secondary-color-nv #x8532)
(:spare1-nv #x852F)
(:sparse-buffer-page-size-arb #x82F8)
(:sparse-storage-bit-arb #x400)
(:sparse-texture-full-array-cube-mipmaps-arb #x91A9)
(:sparse-texture-full-array-cube-mipmaps-ext #x91A9)
(:specular #x1202)
(:sphere-map #x2402)
(:spot-cutoff #x1206)
(:spot-direction #x1204)
(:spot-exponent #x1205)
(:sprite-axial-sgix #x814C)
(:sprite-axis-sgix #x814A)
(:sprite-eye-aligned-sgix #x814E)
(:sprite-mode-sgix #x8149)
(:sprite-object-aligned-sgix #x814D)
(:sprite-sgix #x8148)
(:sprite-translation-sgix #x814B)
(:square-nv #x90A3)
(:sr8-ext #x8FBD)
(:src-alpha #x302)
(:src-alpha-saturate #x308)
(:src-atop-nv #x928E)
(:src-color #x300)
(:src-in-nv #x928A)
(:src-nv #x9286)
(:src-out-nv #x928C)
(:src-over-nv #x9288)
(:src0-alpha #x8588)
(:src0-rgb #x8580)
(:src1-alpha #x8589)
(:src1-color #x88F9)
(:src1-rgb #x8581)
(:src2-alpha #x858A)
(:src2-rgb #x8582)
(:srg8-ext #x8FBE)
(:srgb #x8C40)
(:srgb-alpha #x8C42)
(:srgb-alpha-ext #x8C42)
(:srgb-decode-arb #x8299)
(:srgb-ext #x8C40)
(:srgb-read #x8297)
(:srgb-write #x8298)
(:srgb8 #x8C41)
(:srgb8-alpha8 #x8C43)
(:srgb8-alpha8-ext #x8C43)
(:srgb8-ext #x8C41)
(:srgb8-nv #x8C41)
(:stack-overflow #x503)
(:stack-overflow-khr #x503)
(:stack-underflow #x504)
(:stack-underflow-khr #x504)
(:standard-font-format-nv #x936C)
(:standard-font-name-nv #x9072)
(:state-restore #x8BDC)
(:static-ati #x8760)
(:static-copy #x88E6)
(:static-copy-arb #x88E6)
(:static-draw #x88E4)
(:static-draw-arb #x88E4)
(:static-read #x88E5)
(:static-read-arb #x88E5)
(:static-vertex-array-ibm #x19295)
(:stencil #x1802)
(:stencil-attachment #x8D20)
(:stencil-attachment-ext #x8D20)
(:stencil-attachment-oes #x8D20)
(:stencil-back-fail #x8801)
(:stencil-back-fail-ati #x8801)
(:stencil-back-func #x8800)
(:stencil-back-func-ati #x8800)
(:stencil-back-op-value-amd #x874D)
(:stencil-back-pass-depth-fail #x8802)
(:stencil-back-pass-depth-fail-ati #x8802)
(:stencil-back-pass-depth-pass #x8803)
(:stencil-back-pass-depth-pass-ati #x8803)
(:stencil-back-ref #x8CA3)
(:stencil-back-value-mask #x8CA4)
(:stencil-back-writemask #x8CA5)
(:stencil-bits #xD57)
(:stencil-buffer-bit #x400)
(:stencil-buffer-bit0-qcom #x10000)
(:stencil-buffer-bit1-qcom #x20000)
(:stencil-buffer-bit2-qcom #x40000)
(:stencil-buffer-bit3-qcom #x80000)
(:stencil-buffer-bit4-qcom #x100000)
(:stencil-buffer-bit5-qcom #x200000)
(:stencil-buffer-bit6-qcom #x400000)
(:stencil-buffer-bit7-qcom #x800000)
(:stencil-clear-tag-value-ext #x88F3)
(:stencil-clear-value #xB91)
(:stencil-components #x8285)
(:stencil-ext #x1802)
(:stencil-fail #xB94)
(:stencil-func #xB92)
(:stencil-index #x1901)
(:stencil-index-oes #x1901)
(:stencil-index1 #x8D46)
(:stencil-index1-ext #x8D46)
(:stencil-index1-oes #x8D46)
(:stencil-index16 #x8D49)
(:stencil-index16-ext #x8D49)
(:stencil-index4 #x8D47)
(:stencil-index4-ext #x8D47)
(:stencil-index4-oes #x8D47)
(:stencil-index8 #x8D48)
(:stencil-index8-ext #x8D48)
(:stencil-index8-oes #x8D48)
(:stencil-op-value-amd #x874C)
(:stencil-pass-depth-fail #xB95)
(:stencil-pass-depth-pass #xB96)
(:stencil-ref #xB97)
(:stencil-ref-command-nv #xC)
(:stencil-renderable #x8288)
(:stencil-samples-nv #x932E)
(:stencil-tag-bits-ext #x88F2)
(:stencil-test #xB90)
(:stencil-test-two-side-ext #x8910)
(:stencil-value-mask #xB93)
(:stencil-writemask #xB98)
(:stereo #xC33)
(:storage-cached-apple #x85BE)
(:storage-client-apple #x85B4)
(:storage-private-apple #x85BD)
(:storage-shared-apple #x85BF)
(:stream-copy #x88E2)
(:stream-copy-arb #x88E2)
(:stream-draw #x88E0)
(:stream-draw-arb #x88E0)
(:stream-rasterization-amd #x91A0)
(:stream-read #x88E1)
(:stream-read-arb #x88E1)
(:strict-depthfunc-hint-pgi #x1A216)
(:strict-lighting-hint-pgi #x1A217)
(:strict-scissor-hint-pgi #x1A218)
(:sub-ati #x8965)
(:subpixel-bits #xD50)
(:subpixel-precision-bias-x-bits-nv #x9347)
(:subpixel-precision-bias-y-bits-nv #x9348)
(:subsample-distance-amd #x883F)
(:subtract #x84E7)
(:subtract-arb #x84E7)
(:success-nv #x902F)
(:supersample-scale-x-nv #x9372)
(:supersample-scale-y-nv #x9373)
(:surface-mapped-nv #x8700)
(:surface-registered-nv #x86FD)
(:surface-state-nv #x86EB)
(:swizzle-stq-ati #x8977)
(:swizzle-stq-dq-ati #x8979)
(:swizzle-str-ati #x8976)
(:swizzle-str-dr-ati #x8978)
(:swizzle-strq-ati #x897A)
(:swizzle-strq-dq-ati #x897B)
(:sync-cl-event-arb #x8240)
(:sync-cl-event-complete-arb #x8241)
(:sync-condition #x9113)
(:sync-condition-apple #x9113)
(:sync-fence #x9116)
(:sync-fence-apple #x9116)
(:sync-flags #x9115)
(:sync-flags-apple #x9115)
(:sync-flush-commands-bit #x1)
(:sync-flush-commands-bit-apple #x1)
(:sync-gpu-commands-complete #x9117)
(:sync-gpu-commands-complete-apple #x9117)
(:sync-object-apple #x8A53)
(:sync-status #x9114)
(:sync-status-apple #x9114)
(:sync-x11-fence-ext #x90E1)
(:system-font-name-nv #x9073)
(:t #x2001)
(:t2f-c3f-v3f #x2A2A)
(:t2f-c4f-n3f-v3f #x2A2C)
(:t2f-c4ub-v3f #x2A29)
(:t2f-iui-n3f-v2f-ext #x81B3)
(:t2f-iui-n3f-v3f-ext #x81B4)
(:t2f-iui-v2f-ext #x81B1)
(:t2f-iui-v3f-ext #x81B2)
(:t2f-n3f-v3f #x2A2B)
(:t2f-v3f #x2A27)
(:t4f-c4f-n3f-v4f #x2A2D)
(:t4f-v4f #x2A28)
(:table-too-large #x8031)
(:table-too-large-ext #x8031)
(:tangent-array-ext #x8439)
(:tangent-array-pointer-ext #x8442)
(:tangent-array-stride-ext #x843F)
(:tangent-array-type-ext #x843E)
(:terminate-sequence-command-nv #x0)
(:tess-control-output-vertices #x8E75)
(:tess-control-output-vertices-ext #x8E75)
(:tess-control-output-vertices-oes #x8E75)
(:tess-control-program-nv #x891E)
(:tess-control-program-parameter-buffer-nv #x8C74)
(:tess-control-shader #x8E88)
(:tess-control-shader-bit #x8)
(:tess-control-shader-bit-ext #x8)
(:tess-control-shader-bit-oes #x8)
(:tess-control-shader-ext #x8E88)
(:tess-control-shader-oes #x8E88)
(:tess-control-shader-patches-arb #x82F1)
(:tess-control-subroutine #x92E9)
(:tess-control-subroutine-uniform #x92EF)
(:tess-control-texture #x829C)
(:tess-evaluation-program-nv #x891F)
(:tess-evaluation-program-parameter-buffer-nv #x8C75)
(:tess-evaluation-shader #x8E87)
(:tess-evaluation-shader-bit #x10)
(:tess-evaluation-shader-bit-ext #x10)
(:tess-evaluation-shader-bit-oes #x10)
(:tess-evaluation-shader-ext #x8E87)
(:tess-evaluation-shader-invocations-arb #x82F2)
(:tess-evaluation-shader-oes #x8E87)
(:tess-evaluation-subroutine #x92EA)
(:tess-evaluation-subroutine-uniform #x92F0)
(:tess-evaluation-texture #x829D)
(:tess-gen-mode #x8E76)
(:tess-gen-mode-ext #x8E76)
(:tess-gen-mode-oes #x8E76)
(:tess-gen-point-mode #x8E79)
(:tess-gen-point-mode-ext #x8E79)
(:tess-gen-point-mode-oes #x8E79)
(:tess-gen-spacing #x8E77)
(:tess-gen-spacing-ext #x8E77)
(:tess-gen-spacing-oes #x8E77)
(:tess-gen-vertex-order #x8E78)
(:tess-gen-vertex-order-ext #x8E78)
(:tess-gen-vertex-order-oes #x8E78)
(:tessellation-factor-amd #x9005)
(:tessellation-mode-amd #x9004)
(:texcoord1-bit-pgi #x10000000)
(:texcoord2-bit-pgi #x20000000)
(:texcoord3-bit-pgi #x40000000)
(:texcoord4-bit-pgi #x80000000)
(:text-fragment-shader-ati #x8200)
(:texture #x1702)
(:texture-1d #xDE0)
(:texture-1d-array #x8C18)
(:texture-1d-array-ext #x8C18)
(:texture-1d-binding-ext #x8068)
(:texture-1d-stack-binding-mesax #x875D)
(:texture-1d-stack-mesax #x8759)
(:texture-2d #xDE1)
(:texture-2d-array #x8C1A)
(:texture-2d-array-ext #x8C1A)
(:texture-2d-binding-ext #x8069)
(:texture-2d-multisample #x9100)
(:texture-2d-multisample-array #x9102)
(:texture-2d-multisample-array-oes #x9102)
(:texture-2d-stack-binding-mesax #x875E)
(:texture-2d-stack-mesax #x875A)
(:texture-3d #x806F)
(:texture-3d-binding-ext #x806A)
(:texture-3d-binding-oes #x806A)
(:texture-3d-ext #x806F)
(:texture-3d-oes #x806F)
(:texture-4d-binding-sgis #x814F)
(:texture-4d-sgis #x8134)
(:texture-4dsize-sgis #x8136)
(:texture-alpha-modulate-img #x8C06)
(:texture-alpha-size #x805F)
(:texture-alpha-size-ext #x805F)
(:texture-alpha-type #x8C13)
(:texture-alpha-type-arb #x8C13)
(:texture-application-mode-ext #x834F)
(:texture-base-level #x813C)
(:texture-base-level-sgis #x813C)
(:texture-binding-1d #x8068)
(:texture-binding-1d-array #x8C1C)
(:texture-binding-1d-array-ext #x8C1C)
(:texture-binding-2d #x8069)
(:texture-binding-2d-array #x8C1D)
(:texture-binding-2d-array-ext #x8C1D)
(:texture-binding-2d-multisample #x9104)
(:texture-binding-2d-multisample-array #x9105)
(:texture-binding-2d-multisample-array-oes #x9105)
(:texture-binding-3d #x806A)
(:texture-binding-3d-oes #x806A)
(:texture-binding-buffer #x8C2C)
(:texture-binding-buffer-arb #x8C2C)
(:texture-binding-buffer-ext #x8C2C)
(:texture-binding-buffer-oes #x8C2C)
(:texture-binding-cube-map #x8514)
(:texture-binding-cube-map-arb #x8514)
(:texture-binding-cube-map-array #x900A)
(:texture-binding-cube-map-array-arb #x900A)
(:texture-binding-cube-map-array-ext #x900A)
(:texture-binding-cube-map-array-oes #x900A)
(:texture-binding-cube-map-ext #x8514)
(:texture-binding-cube-map-oes #x8514)
(:texture-binding-external-oes #x8D67)
(:texture-binding-rectangle #x84F6)
(:texture-binding-rectangle-arb #x84F6)
(:texture-binding-rectangle-nv #x84F6)
(:texture-binding-renderbuffer-nv #x8E53)
(:texture-bit #x40000)
(:texture-blue-size #x805E)
(:texture-blue-size-ext #x805E)
(:texture-blue-type #x8C12)
(:texture-blue-type-arb #x8C12)
(:texture-border #x1005)
(:texture-border-color #x1004)
(:texture-border-color-ext #x1004)
(:texture-border-color-nv #x1004)
(:texture-border-color-oes #x1004)
(:texture-border-values-nv #x871A)
(:texture-buffer #x8C2A)
(:texture-buffer-arb #x8C2A)
(:texture-buffer-binding #x8C2A)
(:texture-buffer-binding-ext #x8C2A)
(:texture-buffer-binding-oes #x8C2A)
(:texture-buffer-data-store-binding #x8C2D)
(:texture-buffer-data-store-binding-arb #x8C2D)
(:texture-buffer-data-store-binding-ext #x8C2D)
(:texture-buffer-data-store-binding-oes #x8C2D)
(:texture-buffer-ext #x8C2A)
(:texture-buffer-format-arb #x8C2E)
(:texture-buffer-format-ext #x8C2E)
(:texture-buffer-oes #x8C2A)
(:texture-buffer-offset #x919D)
(:texture-buffer-offset-alignment #x919F)
(:texture-buffer-offset-alignment-ext #x919F)
(:texture-buffer-offset-alignment-oes #x919F)
(:texture-buffer-offset-ext #x919D)
(:texture-buffer-offset-oes #x919D)
(:texture-buffer-size #x919E)
(:texture-buffer-size-ext #x919E)
(:texture-buffer-size-oes #x919E)
(:texture-clipmap-center-sgix #x8171)
(:texture-clipmap-depth-sgix #x8176)
(:texture-clipmap-frame-sgix #x8172)
(:texture-clipmap-lod-offset-sgix #x8175)
(:texture-clipmap-offset-sgix #x8173)
(:texture-clipmap-virtual-depth-sgix #x8174)
(:texture-color-samples-nv #x9046)
(:texture-color-table-sgi #x80BC)
(:texture-color-writemask-sgis #x81EF)
(:texture-compare-fail-value-arb #x80BF)
(:texture-compare-func #x884D)
(:texture-compare-func-arb #x884D)
(:texture-compare-func-ext #x884D)
(:texture-compare-mode #x884C)
(:texture-compare-mode-arb #x884C)
(:texture-compare-mode-ext #x884C)
(:texture-compare-operator-sgix #x819B)
(:texture-compare-sgix #x819A)
(:texture-components #x1003)
(:texture-compressed #x86A1)
(:texture-compressed-arb #x86A1)
(:texture-compressed-block-height #x82B2)
(:texture-compressed-block-size #x82B3)
(:texture-compressed-block-width #x82B1)
(:texture-compressed-image-size #x86A0)
(:texture-compressed-image-size-arb #x86A0)
(:texture-compression-hint #x84EF)
(:texture-compression-hint-arb #x84EF)
(:texture-constant-data-sunx #x81D6)
(:texture-coord-array #x8078)
(:texture-coord-array-address-nv #x8F25)
(:texture-coord-array-buffer-binding #x889A)
(:texture-coord-array-buffer-binding-arb #x889A)
(:texture-coord-array-count-ext #x808B)
(:texture-coord-array-ext #x8078)
(:texture-coord-array-length-nv #x8F2F)
(:texture-coord-array-list-ibm #x192A2)
(:texture-coord-array-list-stride-ibm #x192AC)
(:texture-coord-array-parallel-pointers-intel #x83F8)
(:texture-coord-array-pointer #x8092)
(:texture-coord-array-pointer-ext #x8092)
(:texture-coord-array-size #x8088)
(:texture-coord-array-size-ext #x8088)
(:texture-coord-array-stride #x808A)
(:texture-coord-array-stride-ext #x808A)
(:texture-coord-array-type #x8089)
(:texture-coord-array-type-ext #x8089)
(:texture-coord-nv #x8C79)
(:texture-coverage-samples-nv #x9045)
(:texture-crop-rect-oes #x8B9D)
(:texture-cube-map #x8513)
(:texture-cube-map-arb #x8513)
(:texture-cube-map-array #x9009)
(:texture-cube-map-array-arb #x9009)
(:texture-cube-map-array-ext #x9009)
(:texture-cube-map-array-oes #x9009)
(:texture-cube-map-ext #x8513)
(:texture-cube-map-negative-x #x8516)
(:texture-cube-map-negative-x-arb #x8516)
(:texture-cube-map-negative-x-ext #x8516)
(:texture-cube-map-negative-x-oes #x8516)
(:texture-cube-map-negative-y #x8518)
(:texture-cube-map-negative-y-arb #x8518)
(:texture-cube-map-negative-y-ext #x8518)
(:texture-cube-map-negative-y-oes #x8518)
(:texture-cube-map-negative-z #x851A)
(:texture-cube-map-negative-z-arb #x851A)
(:texture-cube-map-negative-z-ext #x851A)
(:texture-cube-map-negative-z-oes #x851A)
(:texture-cube-map-oes #x8513)
(:texture-cube-map-positive-x #x8515)
(:texture-cube-map-positive-x-arb #x8515)
(:texture-cube-map-positive-x-ext #x8515)
(:texture-cube-map-positive-x-oes #x8515)
(:texture-cube-map-positive-y #x8517)
(:texture-cube-map-positive-y-arb #x8517)
(:texture-cube-map-positive-y-ext #x8517)
(:texture-cube-map-positive-y-oes #x8517)
(:texture-cube-map-positive-z #x8519)
(:texture-cube-map-positive-z-arb #x8519)
(:texture-cube-map-positive-z-ext #x8519)
(:texture-cube-map-positive-z-oes #x8519)
(:texture-cube-map-seamless #x884F)
(:texture-deformation-bit-sgix #x1)
(:texture-deformation-sgix #x8195)
(:texture-depth #x8071)
(:texture-depth-ext #x8071)
(:texture-depth-qcom #x8BD4)
(:texture-depth-size #x884A)
(:texture-depth-size-arb #x884A)
(:texture-depth-type #x8C16)
(:texture-depth-type-arb #x8C16)
(:texture-ds-size-nv #x871D)
(:texture-dt-size-nv #x871E)
(:texture-env #x2300)
(:texture-env-bias-sgix #x80BE)
(:texture-env-color #x2201)
(:texture-env-mode #x2200)
(:texture-external-oes #x8D65)
(:texture-fetch-barrier-bit #x8)
(:texture-fetch-barrier-bit-ext #x8)
(:texture-filter-control #x8500)
(:texture-filter-control-ext #x8500)
(:texture-filter4-size-sgis #x8147)
(:texture-fixed-sample-locations #x9107)
(:texture-float-components-nv #x888C)
(:texture-format-qcom #x8BD6)
(:texture-free-memory-ati #x87FC)
(:texture-gather #x82A2)
(:texture-gather-shadow #x82A3)
(:texture-gen-mode #x2500)
(:texture-gen-mode-oes #x2500)
(:texture-gen-q #xC63)
(:texture-gen-r #xC62)
(:texture-gen-s #xC60)
(:texture-gen-str-oes #x8D60)
(:texture-gen-t #xC61)
(:texture-gequal-r-sgix #x819D)
(:texture-green-size #x805D)
(:texture-green-size-ext #x805D)
(:texture-green-type #x8C11)
(:texture-green-type-arb #x8C11)
(:texture-height #x1001)
(:texture-height-qcom #x8BD3)
(:texture-hi-size-nv #x871B)
(:texture-image-format #x828F)
(:texture-image-type #x8290)
(:texture-image-valid-qcom #x8BD8)
(:texture-immutable-format #x912F)
(:texture-immutable-format-ext #x912F)
(:texture-immutable-levels #x82DF)
(:texture-index-size-ext #x80ED)
(:texture-intensity-size #x8061)
(:texture-intensity-size-ext #x8061)
(:texture-intensity-type #x8C15)
(:texture-intensity-type-arb #x8C15)
(:texture-internal-format #x1003)
(:texture-internal-format-qcom #x8BD5)
(:texture-lequal-r-sgix #x819C)
(:texture-light-ext #x8350)
(:texture-lighting-mode-hp #x8167)
(:texture-lo-size-nv #x871C)
(:texture-lod-bias #x8501)
(:texture-lod-bias-ext #x8501)
(:texture-lod-bias-r-sgix #x8190)
(:texture-lod-bias-s-sgix #x818E)
(:texture-lod-bias-t-sgix #x818F)
(:texture-luminance-size #x8060)
(:texture-luminance-size-ext #x8060)
(:texture-luminance-type #x8C14)
(:texture-luminance-type-arb #x8C14)
(:texture-mag-filter #x2800)
(:texture-mag-size-nv #x871F)
(:texture-material-face-ext #x8351)
(:texture-material-parameter-ext #x8352)
(:texture-matrix #xBA8)
(:texture-matrix-float-as-int-bits-oes #x898F)
(:texture-max-anisotropy-ext #x84FE)
(:texture-max-clamp-r-sgix #x836B)
(:texture-max-clamp-s-sgix #x8369)
(:texture-max-clamp-t-sgix #x836A)
(:texture-max-level #x813D)
(:texture-max-level-apple #x813D)
(:texture-max-level-sgis #x813D)
(:texture-max-lod #x813B)
(:texture-max-lod-sgis #x813B)
(:texture-memory-layout-intel #x83FF)
(:texture-min-filter #x2801)
(:texture-min-lod #x813A)
(:texture-min-lod-sgis #x813A)
(:texture-multi-buffer-hint-sgix #x812E)
(:texture-normal-ext #x85AF)
(:texture-num-levels-qcom #x8BD9)
(:texture-object-valid-qcom #x8BDB)
(:texture-post-specular-hp #x8168)
(:texture-pre-specular-hp #x8169)
(:texture-priority #x8066)
(:texture-priority-ext #x8066)
(:texture-range-length-apple #x85B7)
(:texture-range-pointer-apple #x85B8)
(:texture-rectangle #x84F5)
(:texture-rectangle-arb #x84F5)
(:texture-rectangle-nv #x84F5)
(:texture-red-size #x805C)
(:texture-red-size-ext #x805C)
(:texture-red-type #x8C10)
(:texture-red-type-arb #x8C10)
(:texture-reduction-mode-arb #x9366)
(:texture-renderbuffer-data-store-binding-nv #x8E54)
(:texture-renderbuffer-nv #x8E55)
(:texture-resident #x8067)
(:texture-resident-ext #x8067)
(:texture-samples #x9106)
(:texture-samples-img #x9136)
(:texture-shader-nv #x86DE)
(:texture-shadow #x82A1)
(:texture-shared-size #x8C3F)
(:texture-shared-size-ext #x8C3F)
(:texture-sparse-arb #x91A6)
(:texture-sparse-ext #x91A6)
(:texture-srgb-decode-ext #x8A48)
(:texture-stack-depth #xBA5)
(:texture-stencil-size #x88F1)
(:texture-stencil-size-ext #x88F1)
(:texture-storage-hint-apple #x85BC)
(:texture-storage-sparse-bit-amd #x1)
(:texture-swizzle-a #x8E45)
(:texture-swizzle-a-ext #x8E45)
(:texture-swizzle-b #x8E44)
(:texture-swizzle-b-ext #x8E44)
(:texture-swizzle-g #x8E43)
(:texture-swizzle-g-ext #x8E43)
(:texture-swizzle-r #x8E42)
(:texture-swizzle-r-ext #x8E42)
(:texture-swizzle-rgba #x8E46)
(:texture-swizzle-rgba-ext #x8E46)
(:texture-target #x1006)
(:texture-target-qcom #x8BDA)
(:texture-too-large-ext #x8065)
(:texture-type-qcom #x8BD7)
(:texture-unsigned-remap-mode-nv #x888F)
(:texture-update-barrier-bit #x100)
(:texture-update-barrier-bit-ext #x100)
(:texture-usage-angle #x93A2)
(:texture-view #x82B5)
(:texture-view-min-layer #x82DD)
(:texture-view-min-layer-ext #x82DD)
(:texture-view-min-layer-oes #x82DD)
(:texture-view-min-level #x82DB)
(:texture-view-min-level-ext #x82DB)
(:texture-view-min-level-oes #x82DB)
(:texture-view-num-layers #x82DE)
(:texture-view-num-layers-ext #x82DE)
(:texture-view-num-layers-oes #x82DE)
(:texture-view-num-levels #x82DC)
(:texture-view-num-levels-ext #x82DC)
(:texture-view-num-levels-oes #x82DC)
(:texture-width #x1000)
(:texture-width-qcom #x8BD2)
(:texture-wrap-q-sgis #x8137)
(:texture-wrap-r #x8072)
(:texture-wrap-r-ext #x8072)
(:texture-wrap-r-oes #x8072)
(:texture-wrap-s #x2802)
(:texture-wrap-t #x2803)
(:texture0 #x84C0)
(:texture0-arb #x84C0)
(:texture1 #x84C1)
(:texture1-arb #x84C1)
(:texture10 #x84CA)
(:texture10-arb #x84CA)
(:texture11 #x84CB)
(:texture11-arb #x84CB)
(:texture12 #x84CC)
(:texture12-arb #x84CC)
(:texture13 #x84CD)
(:texture13-arb #x84CD)
(:texture14 #x84CE)
(:texture14-arb #x84CE)
(:texture15 #x84CF)
(:texture15-arb #x84CF)
(:texture16 #x84D0)
(:texture16-arb #x84D0)
(:texture17 #x84D1)
(:texture17-arb #x84D1)
(:texture18 #x84D2)
(:texture18-arb #x84D2)
(:texture19 #x84D3)
(:texture19-arb #x84D3)
(:texture2 #x84C2)
(:texture2-arb #x84C2)
(:texture20 #x84D4)
(:texture20-arb #x84D4)
(:texture21 #x84D5)
(:texture21-arb #x84D5)
(:texture22 #x84D6)
(:texture22-arb #x84D6)
(:texture23 #x84D7)
(:texture23-arb #x84D7)
(:texture24 #x84D8)
(:texture24-arb #x84D8)
(:texture25 #x84D9)
(:texture25-arb #x84D9)
(:texture26 #x84DA)
(:texture26-arb #x84DA)
(:texture27 #x84DB)
(:texture27-arb #x84DB)
(:texture28 #x84DC)
(:texture28-arb #x84DC)
(:texture29 #x84DD)
(:texture29-arb #x84DD)
(:texture3 #x84C3)
(:texture3-arb #x84C3)
(:texture30 #x84DE)
(:texture30-arb #x84DE)
(:texture31 #x84DF)
(:texture31-arb #x84DF)
(:texture4 #x84C4)
(:texture4-arb #x84C4)
(:texture5 #x84C5)
(:texture5-arb #x84C5)
(:texture6 #x84C6)
(:texture6-arb #x84C6)
(:texture7 #x84C7)
(:texture7-arb #x84C7)
(:texture8 #x84C8)
(:texture8-arb #x84C8)
(:texture9 #x84C9)
(:texture9-arb #x84C9)
(:time-elapsed #x88BF)
(:time-elapsed-ext #x88BF)
(:timeout-expired #x911B)
(:timeout-expired-apple #x911B)
(:timeout-ignored #xFFFFFFFFFFFFFFFF)
(:timeout-ignored-apple #xFFFFFFFFFFFFFFFF)
(:timestamp #x8E28)
(:timestamp-ext #x8E28)
(:top-level-array-size #x930C)
(:top-level-array-stride #x930D)
(:trace-all-bits-mesa #xFFFF)
(:trace-arrays-bit-mesa #x4)
(:trace-errors-bit-mesa #x20)
(:trace-mask-mesa #x8755)
(:trace-name-mesa #x8756)
(:trace-operations-bit-mesa #x1)
(:trace-pixels-bit-mesa #x10)
(:trace-primitives-bit-mesa #x2)
(:trace-textures-bit-mesa #x8)
(:track-matrix-nv #x8648)
(:track-matrix-transform-nv #x8649)
(:transform-bit #x1000)
(:transform-feedback #x8E22)
(:transform-feedback-active #x8E24)
(:transform-feedback-attribs-nv #x8C7E)
(:transform-feedback-barrier-bit #x800)
(:transform-feedback-barrier-bit-ext #x800)
(:transform-feedback-binding #x8E25)
(:transform-feedback-binding-nv #x8E25)
(:transform-feedback-buffer #x8C8E)
(:transform-feedback-buffer-active #x8E24)
(:transform-feedback-buffer-active-nv #x8E24)
(:transform-feedback-buffer-binding #x8C8F)
(:transform-feedback-buffer-binding-ext #x8C8F)
(:transform-feedback-buffer-binding-nv #x8C8F)
(:transform-feedback-buffer-ext #x8C8E)
(:transform-feedback-buffer-index #x934B)
(:transform-feedback-buffer-mode #x8C7F)
(:transform-feedback-buffer-mode-ext #x8C7F)
(:transform-feedback-buffer-mode-nv #x8C7F)
(:transform-feedback-buffer-nv #x8C8E)
(:transform-feedback-buffer-paused #x8E23)
(:transform-feedback-buffer-paused-nv #x8E23)
(:transform-feedback-buffer-size #x8C85)
(:transform-feedback-buffer-size-ext #x8C85)
(:transform-feedback-buffer-size-nv #x8C85)
(:transform-feedback-buffer-start #x8C84)
(:transform-feedback-buffer-start-ext #x8C84)
(:transform-feedback-buffer-start-nv #x8C84)
(:transform-feedback-buffer-stride #x934C)
(:transform-feedback-nv #x8E22)
(:transform-feedback-overflow-arb #x82EC)
(:transform-feedback-paused #x8E23)
(:transform-feedback-primitives-written #x8C88)
(:transform-feedback-primitives-written-ext #x8C88)
(:transform-feedback-primitives-written-nv #x8C88)
(:transform-feedback-record-nv #x8C86)
(:transform-feedback-stream-overflow-arb #x82ED)
(:transform-feedback-varying #x92F4)
(:transform-feedback-varying-max-length #x8C76)
(:transform-feedback-varying-max-length-ext #x8C76)
(:transform-feedback-varyings #x8C83)
(:transform-feedback-varyings-ext #x8C83)
(:transform-feedback-varyings-nv #x8C83)
(:transform-hint-apple #x85B1)
(:translate-2d-nv #x9090)
(:translate-3d-nv #x9091)
(:translate-x-nv #x908E)
(:translate-y-nv #x908F)
(:translated-shader-source-length-angle #x93A0)
(:transpose-affine-2d-nv #x9096)
(:transpose-affine-3d-nv #x9098)
(:transpose-color-matrix #x84E6)
(:transpose-color-matrix-arb #x84E6)
(:transpose-current-matrix-arb #x88B7)
(:transpose-modelview-matrix #x84E3)
(:transpose-modelview-matrix-arb #x84E3)
(:transpose-nv #x862C)
(:transpose-program-matrix-ext #x8E2E)
(:transpose-projection-matrix #x84E4)
(:transpose-projection-matrix-arb #x84E4)
(:transpose-texture-matrix #x84E5)
(:transpose-texture-matrix-arb #x84E5)
(:triangle-fan #x6)
(:triangle-list-sun #x81D7)
(:triangle-mesh-sun #x8615)
(:triangle-strip #x5)
(:triangle-strip-adjacency #xD)
(:triangle-strip-adjacency-arb #xD)
(:triangle-strip-adjacency-ext #xD)
(:triangle-strip-adjacency-oes #xD)
(:triangles #x4)
(:triangles-adjacency #xC)
(:triangles-adjacency-arb #xC)
(:triangles-adjacency-ext #xC)
(:triangles-adjacency-oes #xC)
(:triangular-nv #x90A5)
(:true #x1)
(:type #x92FA)
(:uncorrelated-nv #x9282)
(:undefined-apple #x8A1C)
(:undefined-vertex #x8260)
(:undefined-vertex-ext #x8260)
(:undefined-vertex-oes #x8260)
(:uniform #x92E1)
(:uniform-address-command-nv #xA)
(:uniform-array-stride #x8A3C)
(:uniform-atomic-counter-buffer-index #x92DA)
(:uniform-barrier-bit #x4)
(:uniform-barrier-bit-ext #x4)
(:uniform-block #x92E2)
(:uniform-block-active-uniform-indices #x8A43)
(:uniform-block-active-uniforms #x8A42)
(:uniform-block-binding #x8A3F)
(:uniform-block-data-size #x8A40)
(:uniform-block-index #x8A3A)
(:uniform-block-name-length #x8A41)
(:uniform-block-referenced-by-compute-shader #x90EC)
(:uniform-block-referenced-by-fragment-shader #x8A46)
(:uniform-block-referenced-by-geometry-shader #x8A45)
(:uniform-block-referenced-by-tess-control-shader #x84F0)
(:uniform-block-referenced-by-tess-evaluation-shader #x84F1)
(:uniform-block-referenced-by-vertex-shader #x8A44)
(:uniform-buffer #x8A11)
(:uniform-buffer-address-nv #x936F)
(:uniform-buffer-binding #x8A28)
(:uniform-buffer-binding-ext #x8DEF)
(:uniform-buffer-ext #x8DEE)
(:uniform-buffer-length-nv #x9370)
(:uniform-buffer-offset-alignment #x8A34)
(:uniform-buffer-size #x8A2A)
(:uniform-buffer-start #x8A29)
(:uniform-buffer-unified-nv #x936E)
(:uniform-is-row-major #x8A3E)
(:uniform-matrix-stride #x8A3D)
(:uniform-name-length #x8A39)
(:uniform-offset #x8A3B)
(:uniform-size #x8A38)
(:uniform-type #x8A37)
(:unknown-context-reset #x8255)
(:unknown-context-reset-arb #x8255)
(:unknown-context-reset-ext #x8255)
(:unknown-context-reset-khr #x8255)
(:unpack-alignment #xCF5)
(:unpack-client-storage-apple #x85B2)
(:unpack-cmyk-hint-ext #x800F)
(:unpack-colorspace-conversion-webgl #x9243)
(:unpack-compressed-block-depth #x9129)
(:unpack-compressed-block-height #x9128)
(:unpack-compressed-block-size #x912A)
(:unpack-compressed-block-width #x9127)
(:unpack-compressed-size-sgix #x831A)
(:unpack-constant-data-sunx #x81D5)
(:unpack-flip-y-webgl #x9240)
(:unpack-image-depth-sgis #x8133)
(:unpack-image-height #x806E)
(:unpack-image-height-ext #x806E)
(:unpack-lsb-first #xCF1)
(:unpack-premultiply-alpha-webgl #x9241)
(:unpack-resample-oml #x8985)
(:unpack-resample-sgix #x842F)
(:unpack-row-bytes-apple #x8A16)
(:unpack-row-length #xCF2)
(:unpack-row-length-ext #xCF2)
(:unpack-skip-images #x806D)
(:unpack-skip-images-ext #x806D)
(:unpack-skip-pixels #xCF4)
(:unpack-skip-pixels-ext #xCF4)
(:unpack-skip-rows #xCF3)
(:unpack-skip-rows-ext #xCF3)
(:unpack-skip-volumes-sgis #x8132)
(:unpack-subsample-rate-sgix #x85A1)
(:unpack-swap-bytes #xCF0)
(:unsignaled #x9118)
(:unsignaled-apple #x9118)
(:unsigned-byte #x1401)
(:unsigned-byte-2-3-3-rev #x8362)
(:unsigned-byte-2-3-3-rev-ext #x8362)
(:unsigned-byte-3-3-2 #x8032)
(:unsigned-byte-3-3-2-ext #x8032)
(:unsigned-identity-nv #x8536)
(:unsigned-int #x1405)
(:unsigned-int-10-10-10-2 #x8036)
(:unsigned-int-10-10-10-2-ext #x8036)
(:unsigned-int-10-10-10-2-oes #x8DF6)
(:unsigned-int-10f-11f-11f-rev #x8C3B)
(:unsigned-int-10f-11f-11f-rev-apple #x8C3B)
(:unsigned-int-10f-11f-11f-rev-ext #x8C3B)
(:unsigned-int-2-10-10-10-rev #x8368)
(:unsigned-int-2-10-10-10-rev-ext #x8368)
(:unsigned-int-24-8 #x84FA)
(:unsigned-int-24-8-ext #x84FA)
(:unsigned-int-24-8-mesa #x8751)
(:unsigned-int-24-8-nv #x84FA)
(:unsigned-int-24-8-oes #x84FA)
(:unsigned-int-5-9-9-9-rev #x8C3E)
(:unsigned-int-5-9-9-9-rev-apple #x8C3E)
(:unsigned-int-5-9-9-9-rev-ext #x8C3E)
(:unsigned-int-8-24-rev-mesa #x8752)
(:unsigned-int-8-8-8-8 #x8035)
(:unsigned-int-8-8-8-8-ext #x8035)
(:unsigned-int-8-8-8-8-rev #x8367)
(:unsigned-int-8-8-8-8-rev-ext #x8367)
(:unsigned-int-8-8-s8-s8-rev-nv #x86DB)
(:unsigned-int-atomic-counter #x92DB)
(:unsigned-int-image-1d #x9062)
(:unsigned-int-image-1d-array #x9068)
(:unsigned-int-image-1d-array-ext #x9068)
(:unsigned-int-image-1d-ext #x9062)
(:unsigned-int-image-2d #x9063)
(:unsigned-int-image-2d-array #x9069)
(:unsigned-int-image-2d-array-ext #x9069)
(:unsigned-int-image-2d-ext #x9063)
(:unsigned-int-image-2d-multisample #x906B)
(:unsigned-int-image-2d-multisample-array #x906C)
(:unsigned-int-image-2d-multisample-array-ext #x906C)
(:unsigned-int-image-2d-multisample-ext #x906B)
(:unsigned-int-image-2d-rect #x9065)
(:unsigned-int-image-2d-rect-ext #x9065)
(:unsigned-int-image-3d #x9064)
(:unsigned-int-image-3d-ext #x9064)
(:unsigned-int-image-buffer #x9067)
(:unsigned-int-image-buffer-ext #x9067)
(:unsigned-int-image-buffer-oes #x9067)
(:unsigned-int-image-cube #x9066)
(:unsigned-int-image-cube-ext #x9066)
(:unsigned-int-image-cube-map-array #x906A)
(:unsigned-int-image-cube-map-array-ext #x906A)
(:unsigned-int-image-cube-map-array-oes #x906A)
(:unsigned-int-s8-s8-8-8-nv #x86DA)
(:unsigned-int-sampler-1d #x8DD1)
(:unsigned-int-sampler-1d-array #x8DD6)
(:unsigned-int-sampler-1d-array-ext #x8DD6)
(:unsigned-int-sampler-1d-ext #x8DD1)
(:unsigned-int-sampler-2d #x8DD2)
(:unsigned-int-sampler-2d-array #x8DD7)
(:unsigned-int-sampler-2d-array-ext #x8DD7)
(:unsigned-int-sampler-2d-ext #x8DD2)
(:unsigned-int-sampler-2d-multisample #x910A)
(:unsigned-int-sampler-2d-multisample-array #x910D)
(:unsigned-int-sampler-2d-multisample-array-oes #x910D)
(:unsigned-int-sampler-2d-rect #x8DD5)
(:unsigned-int-sampler-2d-rect-ext #x8DD5)
(:unsigned-int-sampler-3d #x8DD3)
(:unsigned-int-sampler-3d-ext #x8DD3)
(:unsigned-int-sampler-buffer #x8DD8)
(:unsigned-int-sampler-buffer-amd #x9003)
(:unsigned-int-sampler-buffer-ext #x8DD8)
(:unsigned-int-sampler-buffer-oes #x8DD8)
(:unsigned-int-sampler-cube #x8DD4)
(:unsigned-int-sampler-cube-ext #x8DD4)
(:unsigned-int-sampler-cube-map-array #x900F)
(:unsigned-int-sampler-cube-map-array-arb #x900F)
(:unsigned-int-sampler-cube-map-array-ext #x900F)
(:unsigned-int-sampler-cube-map-array-oes #x900F)
(:unsigned-int-sampler-renderbuffer-nv #x8E58)
(:unsigned-int-vec2 #x8DC6)
(:unsigned-int-vec2-ext #x8DC6)
(:unsigned-int-vec3 #x8DC7)
(:unsigned-int-vec3-ext #x8DC7)
(:unsigned-int-vec4 #x8DC8)
(:unsigned-int-vec4-ext #x8DC8)
(:unsigned-int16-nv #x8FF0)
(:unsigned-int16-vec2-nv #x8FF1)
(:unsigned-int16-vec3-nv #x8FF2)
(:unsigned-int16-vec4-nv #x8FF3)
(:unsigned-int64-amd #x8BC2)
(:unsigned-int64-arb #x140F)
(:unsigned-int64-nv #x140F)
(:unsigned-int64-vec2-arb #x8FF5)
(:unsigned-int64-vec2-nv #x8FF5)
(:unsigned-int64-vec3-arb #x8FF6)
(:unsigned-int64-vec3-nv #x8FF6)
(:unsigned-int64-vec4-arb #x8FF7)
(:unsigned-int64-vec4-nv #x8FF7)
(:unsigned-int8-nv #x8FEC)
(:unsigned-int8-vec2-nv #x8FED)
(:unsigned-int8-vec3-nv #x8FEE)
(:unsigned-int8-vec4-nv #x8FEF)
(:unsigned-invert-nv #x8537)
(:unsigned-normalized #x8C17)
(:unsigned-normalized-arb #x8C17)
(:unsigned-normalized-ext #x8C17)
(:unsigned-short #x1403)
(:unsigned-short-1-15-rev-mesa #x8754)
(:unsigned-short-1-5-5-5-rev #x8366)
(:unsigned-short-1-5-5-5-rev-ext #x8366)
(:unsigned-short-15-1-mesa #x8753)
(:unsigned-short-4-4-4-4 #x8033)
(:unsigned-short-4-4-4-4-ext #x8033)
(:unsigned-short-4-4-4-4-rev #x8365)
(:unsigned-short-4-4-4-4-rev-ext #x8365)
(:unsigned-short-4-4-4-4-rev-img #x8365)
(:unsigned-short-5-5-5-1 #x8034)
(:unsigned-short-5-5-5-1-ext #x8034)
(:unsigned-short-5-6-5 #x8363)
(:unsigned-short-5-6-5-ext #x8363)
(:unsigned-short-5-6-5-rev #x8364)
(:unsigned-short-5-6-5-rev-ext #x8364)
(:unsigned-short-8-8-apple #x85BA)
(:unsigned-short-8-8-mesa #x85BA)
(:unsigned-short-8-8-rev-apple #x85BB)
(:unsigned-short-8-8-rev-mesa #x85BB)
(:upper-left #x8CA2)
(:use-missing-glyph-nv #x90AA)
(:utf16-nv #x909B)
(:utf8-nv #x909A)
(:v2f #x2A20)
(:v3f #x2A21)
(:validate-status #x8B83)
(:variable-a-nv #x8523)
(:variable-b-nv #x8524)
(:variable-c-nv #x8525)
(:variable-d-nv #x8526)
(:variable-e-nv #x8527)
(:variable-f-nv #x8528)
(:variable-g-nv #x8529)
(:variant-array-ext #x87E8)
(:variant-array-pointer-ext #x87E9)
(:variant-array-stride-ext #x87E6)
(:variant-array-type-ext #x87E7)
(:variant-datatype-ext #x87E5)
(:variant-ext #x87C1)
(:variant-value-ext #x87E4)
(:vbo-free-memory-ati #x87FB)
(:vector-ext #x87BF)
(:vendor #x1F00)
(:version #x1F02)
(:version-es-cl-1-0 #x1)
(:version-es-cl-1-1 #x1)
(:version-es-cm-1-1 #x1)
(:vertex-array #x8074)
(:vertex-array-address-nv #x8F21)
(:vertex-array-binding #x85B5)
(:vertex-array-binding-apple #x85B5)
(:vertex-array-binding-oes #x85B5)
(:vertex-array-buffer-binding #x8896)
(:vertex-array-buffer-binding-arb #x8896)
(:vertex-array-count-ext #x807D)
(:vertex-array-ext #x8074)
(:vertex-array-khr #x8074)
(:vertex-array-length-nv #x8F2B)
(:vertex-array-list-ibm #x1929E)
(:vertex-array-list-stride-ibm #x192A8)
(:vertex-array-object-amd #x9154)
(:vertex-array-object-ext #x9154)
(:vertex-array-parallel-pointers-intel #x83F5)
(:vertex-array-pointer #x808E)
(:vertex-array-pointer-ext #x808E)
(:vertex-array-range-apple #x851D)
(:vertex-array-range-length-apple #x851E)
(:vertex-array-range-length-nv #x851E)
(:vertex-array-range-nv #x851D)
(:vertex-array-range-pointer-apple #x8521)
(:vertex-array-range-pointer-nv #x8521)
(:vertex-array-range-valid-nv #x851F)
(:vertex-array-range-without-flush-nv #x8533)
(:vertex-array-size #x807A)
(:vertex-array-size-ext #x807A)
(:vertex-array-storage-hint-apple #x851F)
(:vertex-array-stride #x807C)
(:vertex-array-stride-ext #x807C)
(:vertex-array-type #x807B)
(:vertex-array-type-ext #x807B)
(:vertex-attrib-array-address-nv #x8F20)
(:vertex-attrib-array-barrier-bit #x1)
(:vertex-attrib-array-barrier-bit-ext #x1)
(:vertex-attrib-array-buffer-binding #x889F)
(:vertex-attrib-array-buffer-binding-arb #x889F)
(:vertex-attrib-array-divisor #x88FE)
(:vertex-attrib-array-divisor-angle #x88FE)
(:vertex-attrib-array-divisor-arb #x88FE)
(:vertex-attrib-array-divisor-ext #x88FE)
(:vertex-attrib-array-divisor-nv #x88FE)
(:vertex-attrib-array-enabled #x8622)
(:vertex-attrib-array-enabled-arb #x8622)
(:vertex-attrib-array-integer #x88FD)
(:vertex-attrib-array-integer-ext #x88FD)
(:vertex-attrib-array-integer-nv #x88FD)
(:vertex-attrib-array-length-nv #x8F2A)
(:vertex-attrib-array-long #x874E)
(:vertex-attrib-array-normalized #x886A)
(:vertex-attrib-array-normalized-arb #x886A)
(:vertex-attrib-array-pointer #x8645)
(:vertex-attrib-array-pointer-arb #x8645)
(:vertex-attrib-array-size #x8623)
(:vertex-attrib-array-size-arb #x8623)
(:vertex-attrib-array-stride #x8624)
(:vertex-attrib-array-stride-arb #x8624)
(:vertex-attrib-array-type #x8625)
(:vertex-attrib-array-type-arb #x8625)
(:vertex-attrib-array-unified-nv #x8F1E)
(:vertex-attrib-array0-nv #x8650)
(:vertex-attrib-array1-nv #x8651)
(:vertex-attrib-array10-nv #x865A)
(:vertex-attrib-array11-nv #x865B)
(:vertex-attrib-array12-nv #x865C)
(:vertex-attrib-array13-nv #x865D)
(:vertex-attrib-array14-nv #x865E)
(:vertex-attrib-array15-nv #x865F)
(:vertex-attrib-array2-nv #x8652)
(:vertex-attrib-array3-nv #x8653)
(:vertex-attrib-array4-nv #x8654)
(:vertex-attrib-array5-nv #x8655)
(:vertex-attrib-array6-nv #x8656)
(:vertex-attrib-array7-nv #x8657)
(:vertex-attrib-array8-nv #x8658)
(:vertex-attrib-array9-nv #x8659)
(:vertex-attrib-binding #x82D4)
(:vertex-attrib-map1-apple #x8A00)
(:vertex-attrib-map1-coeff-apple #x8A03)
(:vertex-attrib-map1-domain-apple #x8A05)
(:vertex-attrib-map1-order-apple #x8A04)
(:vertex-attrib-map1-size-apple #x8A02)
(:vertex-attrib-map2-apple #x8A01)
(:vertex-attrib-map2-coeff-apple #x8A07)
(:vertex-attrib-map2-domain-apple #x8A09)
(:vertex-attrib-map2-order-apple #x8A08)
(:vertex-attrib-map2-size-apple #x8A06)
(:vertex-attrib-relative-offset #x82D5)
(:vertex-binding-buffer #x8F4F)
(:vertex-binding-divisor #x82D6)
(:vertex-binding-offset #x82D7)
(:vertex-binding-stride #x82D8)
(:vertex-blend-arb #x86A7)
(:vertex-consistent-hint-pgi #x1A22B)
(:vertex-data-hint-pgi #x1A22A)
(:vertex-element-swizzle-amd #x91A4)
(:vertex-id-nv #x8C7B)
(:vertex-id-swizzle-amd #x91A5)
(:vertex-preclip-hint-sgix #x83EF)
(:vertex-preclip-sgix #x83EE)
(:vertex-program-arb #x8620)
(:vertex-program-binding-nv #x864A)
(:vertex-program-callback-data-mesa #x8BB7)
(:vertex-program-callback-func-mesa #x8BB6)
(:vertex-program-callback-mesa #x8BB5)
(:vertex-program-nv #x8620)
(:vertex-program-parameter-buffer-nv #x8DA2)
(:vertex-program-point-size #x8642)
(:vertex-program-point-size-arb #x8642)
(:vertex-program-point-size-nv #x8642)
(:vertex-program-position-mesa #x8BB4)
(:vertex-program-two-side #x8643)
(:vertex-program-two-side-arb #x8643)
(:vertex-program-two-side-nv #x8643)
(:vertex-shader #x8B31)
(:vertex-shader-arb #x8B31)
(:vertex-shader-binding-ext #x8781)
(:vertex-shader-bit #x1)
(:vertex-shader-bit-ext #x1)
(:vertex-shader-ext #x8780)
(:vertex-shader-instructions-ext #x87CF)
(:vertex-shader-invariants-ext #x87D1)
(:vertex-shader-invocations-arb #x82F0)
(:vertex-shader-local-constants-ext #x87D2)
(:vertex-shader-locals-ext #x87D3)
(:vertex-shader-optimized-ext #x87D4)
(:vertex-shader-variants-ext #x87D0)
(:vertex-source-ati #x8774)
(:vertex-state-program-nv #x8621)
(:vertex-stream0-ati #x876C)
(:vertex-stream1-ati #x876D)
(:vertex-stream2-ati #x876E)
(:vertex-stream3-ati #x876F)
(:vertex-stream4-ati #x8770)
(:vertex-stream5-ati #x8771)
(:vertex-stream6-ati #x8772)
(:vertex-stream7-ati #x8773)
(:vertex-subroutine #x92E8)
(:vertex-subroutine-uniform #x92EE)
(:vertex-texture #x829B)
(:vertex-weight-array-ext #x850C)
(:vertex-weight-array-pointer-ext #x8510)
(:vertex-weight-array-size-ext #x850D)
(:vertex-weight-array-stride-ext #x850F)
(:vertex-weight-array-type-ext #x850E)
(:vertex-weighting-ext #x8509)
(:vertex23-bit-pgi #x4)
(:vertex4-bit-pgi #x8)
(:vertical-line-to-nv #x8)
(:vertices-submitted-arb #x82EE)
(:vibrance-bias-nv #x8719)
(:vibrance-scale-nv #x8713)
(:video-buffer-binding-nv #x9021)
(:video-buffer-internal-format-nv #x902D)
(:video-buffer-nv #x9020)
(:video-buffer-pitch-nv #x9028)
(:video-capture-field-lower-height-nv #x903B)
(:video-capture-field-upper-height-nv #x903A)
(:video-capture-frame-height-nv #x9039)
(:video-capture-frame-width-nv #x9038)
(:video-capture-surface-origin-nv #x903C)
(:video-capture-to-422-supported-nv #x9026)
(:video-color-conversion-matrix-nv #x9029)
(:video-color-conversion-max-nv #x902A)
(:video-color-conversion-min-nv #x902B)
(:video-color-conversion-offset-nv #x902C)
(:view-class-128-bits #x82C4)
(:view-class-16-bits #x82CA)
(:view-class-24-bits #x82C9)
(:view-class-32-bits #x82C8)
(:view-class-48-bits #x82C7)
(:view-class-64-bits #x82C6)
(:view-class-8-bits #x82CB)
(:view-class-96-bits #x82C5)
(:view-class-bptc-float #x82D3)
(:view-class-bptc-unorm #x82D2)
(:view-class-rgtc1-red #x82D0)
(:view-class-rgtc2-rg #x82D1)
(:view-class-s3tc-dxt1-rgb #x82CC)
(:view-class-s3tc-dxt1-rgba #x82CD)
(:view-class-s3tc-dxt3-rgba #x82CE)
(:view-class-s3tc-dxt5-rgba #x82CF)
(:view-compatibility-class #x82B6)
(:viewport #xBA2)
(:viewport-bit #x800)
(:viewport-bounds-range #x825D)
(:viewport-bounds-range-ext #x825D)
(:viewport-bounds-range-nv #x825D)
(:viewport-command-nv #x10)
(:viewport-index-provoking-vertex #x825F)
(:viewport-index-provoking-vertex-ext #x825F)
(:viewport-index-provoking-vertex-nv #x825F)
(:viewport-subpixel-bits #x825C)
(:viewport-subpixel-bits-ext #x825C)
(:viewport-subpixel-bits-nv #x825C)
(:virtual-page-size-index-arb #x91A7)
(:virtual-page-size-index-ext #x91A7)
(:virtual-page-size-x-amd #x9195)
(:virtual-page-size-x-arb #x9195)
(:virtual-page-size-x-ext #x9195)
(:virtual-page-size-y-amd #x9196)
(:virtual-page-size-y-arb #x9196)
(:virtual-page-size-y-ext #x9196)
(:virtual-page-size-z-amd #x9197)
(:virtual-page-size-z-arb #x9197)
(:virtual-page-size-z-ext #x9197)
(:vividlight-nv #x92A6)
(:volatile-apple #x8A1A)
(:w-ext #x87D8)
(:wait-failed #x911D)
(:wait-failed-apple #x911D)
(:warp-size-nv #x9339)
(:warps-per-sm-nv #x933A)
(:weight-array-arb #x86AD)
(:weight-array-buffer-binding #x889E)
(:weight-array-buffer-binding-arb #x889E)
(:weight-array-buffer-binding-oes #x889E)
(:weight-array-oes #x86AD)
(:weight-array-pointer-arb #x86AC)
(:weight-array-pointer-oes #x86AC)
(:weight-array-size-arb #x86AB)
(:weight-array-size-oes #x86AB)
(:weight-array-stride-arb #x86AA)
(:weight-array-stride-oes #x86AA)
(:weight-array-type-arb #x86A9)
(:weight-array-type-oes #x86A9)
(:weight-sum-unity-arb #x86A6)
(:weighted-average-arb #x9367)
(:wide-line-hint-pgi #x1A222)
(:wrap-border-sun #x81D4)
(:write-discard-nv #x88BE)
(:write-only #x88B9)
(:write-only-arb #x88B9)
(:write-only-oes #x88B9)
(:write-pixel-data-range-length-nv #x887A)
(:write-pixel-data-range-nv #x8878)
(:write-pixel-data-range-pointer-nv #x887C)
(:writeonly-rendering-qcom #x8823)
(:x-ext #x87D5)
(:xor #x1506)
(:xor-nv #x1506)
(:y-ext #x87D6)
(:ycbaycr8a-4224-nv #x9032)
(:ycbcr-422-apple #x85B9)
(:ycbcr-mesa #x8757)
(:ycbycr8-422-nv #x9031)
(:ycrcb-422-sgix #x81BB)
(:ycrcb-444-sgix #x81BC)
(:ycrcb-sgix #x8318)
(:ycrcba-sgix #x8319)
(:z-ext #x87D7)
(:z400-binary-amd #x8740)
(:z4y12z4cb12z4a12z4y12z4cr12z4a12-4224-nv #x9036)
(:z4y12z4cb12z4cr12-444-nv #x9037)
(:z4y12z4cb12z4y12z4cr12-422-nv #x9035)
(:z6y10z6cb10z6a10z6y10z6cr10z6a10-4224-nv #x9034)
(:z6y10z6cb10z6y10z6cr10-422-nv #x9033)
(:zero #x0)
(:zero-ext #x87DD)
(:zero-to-one #x935F)
(:zoom-x #xD16)
(:zoom-y #xD17))
| 205,952 | Common Lisp | .lisp | 6,125 | 30.630204 | 70 | 0.707917 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | a5fdb0f2e5207d31afede1d0e23eb961a88808f81e135c643f658771fd9a89d1 | 30,592 | [
462635
] |
30,593 | rasterization.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/rasterization.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; Copyright (c) 2004, Oliver Markovic <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions are met:
;;;
;;; o Redistributions of source code must retain the above copyright notice,
;;; this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may be
;;; used to endorse or promote products derived from this software without
;;; specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
;;; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
;;; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
;;; LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
;;; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
;;; SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
;;; CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
;;; ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
;;; POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-opengl)
;;;
;;; Chapter 3 - Rasterization
;;;
;;;
;;; 3.3 Points
;;;
(import-export %gl:point-size)
(defun point-parameter (pname value)
(ecase pname
((:point-size-min :point-size-max :point-fade-threshold-size)
(%gl:point-parameter-f pname value))
(:point-sprite-coord-origin
(%gl:point-parameter-i pname (foreign-enum-value '%gl:enum value)))
(:point-distance-attenuation
(with-foreign-object (p '%gl:float 3)
(dotimes (i 3)
(setf (mem-aref p '%gl:float i) (elt value i)))
(%gl:point-parameter-fv pname p)))))
;;;
;;; 3.4 Line Segments
;;;
(import-export %gl:line-width
%gl:line-stipple)
;;;
;;; 3.5 Polygons
;;;
;;; 3.5.1 Basic Polygon Rasterization
(import-export %gl:cull-face)
;;; 3.5.2 Stippling
(defun polygon-stipple (pattern)
(with-opengl-sequence (p '%gl:ubyte pattern)
(%gl:polygon-stipple p)))
;;; 3.5.4 Options Controlling Polygon Rasterization
(import-export %gl:polygon-mode %gl:polygon-offset)
;;;
;;; 3.6 Pixel Rectangles
;;;
;;; 3.6.1 Pixel Storage Modes
(defun pixel-store (pname value)
(ecase pname
((:unpack-swap-bytes :unpack-lsb-first
:pack-swap-bytes :pack-lsb-first)
(%gl:pixel-store-i pname (if value 1 0)))
((:unpack-row-length :unpack-skip-rows :unpack-skip-pixels
:unpack-alignment :unpack-image-height :unpack-skip-images
:pack-row-length :pack-skip-rows :pack-skip-pixels
:pack-alignment :pack-image-height :pack-skip-images)
(%gl:pixel-store-i pname value))))
;;; 3.6.3 Pixel Transfer Modes
(defun pixel-transfer (pname value)
(case pname
((:map-color :map-stencil)
(%gl:pixel-transfer-i pname (if value 1 0)))
((:index-shift :index-offset)
(%gl:pixel-transfer-i pname value))
(t
(%gl:pixel-transfer-f pname value))))
(defun pixel-map (map values)
(let ((n (length values)))
(with-foreign-object (p '%gl:float n)
(dotimes (i n)
(setf (mem-aref p '%gl:float i) (elt values i)))
(%gl:pixel-map-fv map n p))))
;;; 3.6.4 Rasterization of Pixel Rectangles
(defun draw-pixels (width height format type data)
(with-pixel-array (array type data)
(%gl:draw-pixels width height format type array)))
;;;
;;; 3.8 Texturing
;;;
;;; 3.8.1 Texture image specification
(defun internal-format->int (format)
(if (keywordp format)
(foreign-enum-value '%gl:enum format)
(if (and (numberp format) (< 0 format 5))
format
(error "Internal format must be either a keyword or an integer ~
in the range [1,4]."))))
(defun tex-image-3d (target level internal-format width height depth border
format type data)
(let ((internal-size (internal-format->int internal-format)))
(if (pointerp data)
(%gl:tex-image-3d
target level internal-size width height depth border format type data)
(if data
(with-pixel-array (array type data)
(%gl:tex-image-3d target level internal-size width
height depth border format type array))
(%gl:tex-image-3d target level internal-size width height
depth border format type (cffi:null-pointer))))))
(defun tex-image-2d (target level internal-format width height border format
type data &key raw)
;; if RAW is true, assume DATA is an (UNSIGNED-BYTE 8) vector containing
;; appropriately formatted data for specified TYPE
(let ((internal-size (internal-format->int internal-format)))
(cond
((pointerp data)
(%gl:tex-image-2d target level internal-size width height border format
type data))
((and data raw)
(check-type data (simple-array (unsigned-byte 8) (*)))
(with-pixel-array (array :unsigned-byte data)
(%gl:tex-image-2d target level internal-size width height border
format type array)))
(data
(with-pixel-array (array type data)
(%gl:tex-image-2d target level internal-size width height border
format type array)))
(t
(%gl:tex-image-2d target level internal-size width height border
format type (cffi:null-pointer))))))
(defun tex-image-1d (target level internal-format width border format type data)
(let ((internal-size (internal-format->int internal-format)))
(if (pointerp data)
(%gl:tex-image-1d target level internal-size width border format
type data)
(if data
(with-pixel-array (array type data)
(%gl:tex-image-1d target level internal-size width border format
type array))
(%gl:tex-image-1d target level internal-size width border format
type (cffi:null-pointer))))))
;;; 3.8.2 Alternate Texture Image Specification Commands
(defun copy-tex-image-2d (target level internal-format x y width height border)
(%gl:copy-tex-image-2d target level (internal-format->int internal-format)
x y width height border))
(defun copy-tex-image-1d (target level internal-format x y width border)
(%gl:copy-tex-image-1d target level (internal-format->int internal-format)
x y width border))
(defun tex-sub-image-1d (target level xoffset width format type data)
(if (pointerp data)
(%gl:tex-sub-image-1d target level xoffset width format type data)
(with-pixel-array (array type data)
(%gl:tex-sub-image-1d target level xoffset width format type array))))
(defun tex-sub-image-2d (target level xoffset yoffset width height format type
data)
(if (pointerp data)
(%gl:tex-sub-image-2d target level xoffset yoffset width height format
type data)
(with-pixel-array (array type data)
(%gl:tex-sub-image-2d target level xoffset yoffset width height format
type array))))
(defun tex-sub-image-3d (target level xoffset yoffset zoffset width height
depth format type data)
(if (pointerp data)
(%gl:tex-sub-image-3d target level xoffset yoffset zoffset width height
depth format type data)
(with-pixel-array (array type data)
(%gl:tex-sub-image-3d target level xoffset yoffset zoffset width
height depth format type array))))
(import-export %gl:copy-tex-sub-image-1d
%gl:copy-tex-sub-image-2d
%gl:copy-tex-sub-image-3d)
;;; 3.8.3 Compressed Texture Images
(defun compressed-tex-image-1d (target level internal-format width border
data &optional (image-size (length data)))
(if (pointerp data)
(%gl:compressed-tex-image-1d target level internal-format
width border image-size data)
(with-pixel-array (array :unsigned-byte data)
(%gl:compressed-tex-image-1d target level internal-format
width border image-size array))))
(defun compressed-tex-image-2d (target level internal-format width height border
data &optional (image-size (length data)))
(if (pointerp data)
(%gl:compressed-tex-image-2d target level internal-format
width height border image-size data)
(with-pixel-array (array :unsigned-byte data)
(%gl:compressed-tex-image-2d target level internal-format
width height border image-size array))))
(defun compressed-tex-image-3d (target level internal-format width height depth
border data &optional (image-size (length data)))
(if (pointerp data)
(%gl:compressed-tex-image-3d target level internal-format width
height depth border image-size data)
(with-pixel-array (array :unsigned-byte data)
(%gl:compressed-tex-image-3d target level internal-format width
height depth border image-size array))))
(defun compressed-tex-sub-image-1d (target level xoffset width format
data &optional (image-size (length data)))
(if (pointerp data)
(%gl:compressed-tex-sub-image-1d target level xoffset width
format image-size data)
(with-pixel-array (array :unsigned-byte data)
(%gl:compressed-tex-sub-image-1d target level xoffset width
format image-size array))))
(defun compressed-tex-sub-image-2d (target level xoffset yoffset width height
format data &optional (image-size (length data)))
(if (pointerp data)
(%gl:compressed-tex-sub-image-2d target level xoffset yoffset width height
format image-size data)
(with-pixel-array (array :unsigned-byte data)
(%gl:compressed-tex-sub-image-2d target level xoffset yoffset width height
format image-size array))))
(defun compressed-tex-sub-image-3d (target level xoffset yoffset zoffset width height
depth format data &optional (image-size (length data)))
(if (pointerp data)
(%gl:compressed-tex-sub-image-3d target level xoffset yoffset zoffset width
height depth format image-size data)
(with-pixel-array (array :unsigned-byte data)
(%gl:compressed-tex-sub-image-3d target level xoffset yoffset zoffset width
height depth format image-size array))))
;;; 3.8.4 Texture parameters
(macrolet ((body (target i f fv &optional tex)
`(ecase pname
;; valid for both
((:texture-wrap-s :texture-wrap-t :texture-wrap-r)
(,i ,target pname (foreign-enum-value '%gl:enum param)))
((:texture-min-filter :texture-mag-filter)
(,i ,target pname (foreign-enum-value '%gl:enum param)))
(:texture-border-color
(with-foreign-object (array '%gl:float 4)
(dotimes (i 4)
(setf (mem-aref array '%gl:float i) (elt param i)))
(,fv ,target pname array)))
((:texture-min-lod :texture-max-lod)
(,f ,target pname param))
((:texture-lod-bias)
(,i ,target pname (truncate param)))
(:depth-texture-mode
(,i ,target pname (foreign-enum-value '%gl:enum param)))
((:texture-compare-mode :texture-compare-func)
(,i ,target pname (foreign-enum-value '%gl:enum param)))
(:texture-max-anisotropy-ext
(,f ,target pname param))
;; tex only
,@(when tex
`(((:texture-base-level :texture-max-level)
(,i ,target pname (truncate param)))
(:generate-mipmap
(,i ,target pname (if param 1 0)))
((:texture-priority )
(,f ,target pname param))))
)))
(defun tex-parameter (target pname param)
(body target %gl:tex-parameter-i %gl:tex-parameter-f %gl:tex-parameter-fv
t))
(defun sampler-parameter (sampler pname param)
(body sampler
%gl:sampler-parameter-i %gl:sampler-parameter-f %gl:sampler-parameter-fv)))
;;; 3.8.12 Texture Objects
(import-export %gl:bind-texture)
(defun delete-textures (textures)
(with-opengl-sequence (array '%gl:uint textures)
(%gl:delete-textures (length textures) array)))
(defun gen-textures (count)
(with-foreign-object (texture-array '%gl:uint count)
(%gl:gen-textures count texture-array)
(loop for i below count
collecting (mem-aref texture-array '%gl:uint i))))
(defun gen-texture ()
(with-foreign-object (array '%gl:uint 1)
(%gl:gen-textures 1 array)
(mem-aref array '%gl:uint 0)))
(import-export %gl:bind-sampler)
(defun delete-sampler (samplers)
(with-opengl-sequence (array '%gl:uint samplers)
(%gl:delete-samplers (length samplers) array)))
(defun gen-samplers (count)
(with-foreign-object (sampler-array '%gl:uint count)
(%gl:gen-samplers count sampler-array)
(loop for i below count
collecting (mem-aref sampler-array '%gl:uint i))))
(defun gen-sampler ()
(with-foreign-object (array '%gl:uint 1)
(%gl:gen-samplers 1 array)
(mem-aref array '%gl:uint 0)))
;;; The following two functions look awkward to use, so we'll provide the two
;;; lispier functions TEXTURE-RESIDENT-P and PRIORITIZE-TEXTURE, which can be
;;; used in mapping functions or like (every #'texture-resident-p texture-list).
;;; TODO: check whether the new gl:boolean semantics didn't break
;;; these functions.
(defun are-textures-resident (textures)
(let ((count (length textures)))
(with-opengl-sequence (texture-array '%gl:uint textures)
(with-foreign-object (residence-array '%gl:boolean count)
(if (%gl:are-textures-resident count texture-array residence-array)
(loop for i below count
collecting (mem-aref residence-array '%gl:boolean i))
t)))))
(defun prioritize-textures (textures priorities)
(let ((texture-count (length textures))
(priority-count (length priorities)))
(when (/= texture-count priority-count)
(error "There needs to be an equal number of textures and priorities."))
(with-opengl-sequence (texture-array '%gl:uint textures)
(with-opengl-sequence (priority-array '%gl:clampf priorities)
(%gl:prioritize-textures texture-count texture-array priority-array)))))
(defun texture-resident-p (texture)
(with-foreign-objects ((texture-pointer '%gl:uint)
(residence-pointer '%gl:boolean))
(setf (mem-ref texture-pointer '%gl:uint) texture)
(%gl:are-textures-resident 1 texture-pointer residence-pointer)))
(defun prioritize-texture (texture priority)
(with-foreign-objects ((texture-pointer '%gl:uint)
(priority-pointer '%gl:clampf))
(setf (mem-ref texture-pointer '%gl:uint) texture
(mem-ref priority-pointer '%gl:clampf) priority)
(%gl:prioritize-textures 1 texture-pointer priority-pointer)))
;;; 3.8.13 Texture Environments and Texture Functions
;;; Ye gods, have mercy!
(defun tex-env (target pname value)
(let (pname-value)
(ecase target
(:texture-filter-control
(setf pname-value (foreign-enum-value '%gl:enum pname))
(ecase pname
(:texture-lod-bias (%gl:tex-env-f target pname-value value))))
(:texture-env
(setf pname-value (foreign-enum-value '%gl:enum pname))
(ecase pname
(:texture-env-mode
(%gl:tex-env-i target pname-value
(foreign-enum-value '%gl:enum value)))
(:texture-env-color
(with-foreign-object (p '%gl:float 4)
(dotimes (i 4)
(setf (mem-aref p '%gl:float i) (elt value i)))
(%gl:tex-env-fv target pname-value p)))
(:combine-rgb
(%gl:tex-env-i target pname-value
(foreign-enum-value '%gl:enum value)))
(:combine-alpha
(%gl:tex-env-i target pname-value
(foreign-enum-value '%gl:enum value)))))
(:point-sprite
(setf pname-value (foreign-enum-value '%gl:enum pname))
(ecase pname
(:coord-replace (%gl:tex-env-i target pname-value (if value 1 0))))))))
;;; texture queries
(defun get-tex-parameter (target pname)
(macrolet ((floats (c)
`(with-foreign-object (buf '%gl:float ,c)
(%gl:get-tex-parameter-fv target pname buf)
,(if (= c 1)
`(mem-aref buf '%gl:float 0)
`(loop for i below ,c
collect (mem-aref buf '%gl:float i)))))
(ints (c)
`(with-foreign-object (buf '%gl:int ,c)
(%gl:get-tex-parameter-iv target pname buf)
,(if (= c 1)
`(mem-aref buf '%gl:int 0)
`(loop for i below ,c
collect (mem-aref buf '%gl:int i)))))
(enums (c)
`(with-foreign-object (buf '%gl:enum ,c)
(%gl:get-tex-parameter-iv target pname buf)
,(if (= c 1)
`(mem-aref buf '%gl:enum 0)
`(loop for i below ,c
collect (mem-aref buf '%gl:enum i))))))
(ecase pname
((:depth-stencil-texture-mode
:texture-mag-filter :texture-min-filter
:texture-swizzle-r :texture-swizzle-g
:texture-swizzle-b :texture-swizzle-a
:texture-wrap-s :texture-wrap-t :texture-wrap-r
:texture-compare-mode :texture-compare-func
:texture-immutable-format)
(enums 1))
((:texture-swizzle-rgba)
(enums 4))
((:texture-base-level :texture-max-level
:texture-view-min-level :texture-view-num-levels
:texture-view-min-layer :texture-view-num-layers
:texture-immutable-levels)
(ints 1))
((:texture-min-lod :texture-max-lod)
(floats 1))
((:texture-border-color)
(floats 4)))))
(defun get-tex-level-parameter (target level pname)
(macrolet ((floats (c)
`(with-foreign-object (buf '%gl:float ,c)
(%gl:get-tex-level-parameter-fv target level pname buf)
,(if (= c 1)
`(mem-aref buf '%gl:float 0)
`(loop for i below ,c
collect (mem-aref buf '%gl:float i)))))
(ints (c)
`(with-foreign-object (buf '%gl:int ,c)
(%gl:get-tex-level-parameter-iv target level pname buf)
,(if (= c 1)
`(mem-aref buf '%gl:int 0)
`(loop for i below ,c
collect (mem-aref buf '%gl:int i)))))
(enums (c)
`(with-foreign-object (buf '%gl:enum ,c)
(%gl:get-tex-level-parameter-iv target level pname buf)
,(if (= c 1)
`(mem-aref buf '%gl:enum 0)
`(loop for i below ,c
collect (mem-aref buf '%gl:enum i)))))
(bool (c)
`(with-foreign-object (buf '%gl:int ,c)
(%gl:get-tex-level-parameter-iv target level pname buf)
,(if (= c 1)
`(not (zerop (mem-aref buf '%gl:int 0)))
`(loop for i below ,c
collect (not (zerop (mem-aref buf '%gl:int i))))))))
(ecase pname
(:texture-internal-format
(let ((a (ints 1)))
(if (<= a 4)
a
(cffi:foreign-enum-keyword '%gl::enum a))))
((:texture-red-type :texture-green-type :texture-blue-type
:texture-alpha-type :texture-depth-type)
(enums 1))
((:texture-compressed)
(bool 1))
((:texture-width :texture-height :texture-depth
:texture-red-size :texture-green-size :texture-blue-size
:texture-alpha-size :texture-depth-size
:texture-compressed-image-size
:texture-buffer-offset :texture-buffer-size)
(ints 1)))))
;;;
;;; 3.10 Fog
;;;
(defun fog (pname param)
(ecase pname
(:fog-color
(with-foreign-object (c '%gl:float 4)
(dotimes (i 4)
(setf (mem-aref c '%gl:float i) (elt param i)))
(%gl:fog-fv pname c)))
(:fog-mode
(%gl:fog-i pname (foreign-enum-value '%gl:enum param)))
(:fog-coord-src
(%gl:fog-i pname (foreign-enum-value '%gl:enum param)))
((:fog-density :fog-start :fog-end)
(%gl:fog-f pname param))))
;;; 3.12.2 Shader Execution
;;; TODO: make these use :STRING
(defun get-frag-data-location (program name)
(with-foreign-string (s name)
(%gl:get-frag-data-location program s)))
(defun bind-frag-data-location (program color name)
(with-foreign-string (s name)
(%gl:bind-frag-data-location program color s)))
(defun get-frag-data-location-ext (program name)
(with-foreign-string (s name)
(%gl:get-frag-data-location-ext program s)))
(defun bind-frag-data-location-ext (program color name)
(with-foreign-string (s name)
(%gl:bind-frag-data-location-ext program color s)))
| 22,446 | Common Lisp | .lisp | 477 | 36.989518 | 91 | 0.606515 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 547b9e7bbe8827cf0faf3849260a93c47bd23fdeb8859aff6801fa4aafa1ac5d | 30,593 | [
185893
] |
30,594 | funcs-gles1.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/funcs-gles1.lisp | ;;; this file is automatically generated, do not edit
;;; generated from files with the following copyright:
;;;
;;; Copyright (c) 2013-2015 The Khronos Group Inc.
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining a
;;; copy of this software and/or associated documentation files (the
;;; "Materials"), to deal in the Materials without restriction, including
;;; without limitation the rights to use, copy, modify, merge, publish,
;;; distribute, sublicense, and/or sell copies of the Materials, and to
;;; permit persons to whom the Materials are furnished to do so, subject to
;;; the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be included
;;; in all copies or substantial portions of the Materials.
;;;
;;; THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
;;; IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
;;; CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
;;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
;;; MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
;;;
;;; ------------------------------------------------------------------------
(in-package #:cl-opengl-bindings)
;;; generated 2015-08-30T01:01:50Z
;;; from gl.xml @ svn rev 31811, 2015-08-10T07:01:11.860488Z
(defglextfun ("glClipPlanef" clip-plane-f) :void
(p enum)
(eqn (:pointer float)))
(defglextfun ("glFrustumf" frustum-f) :void
(l float)
(r float)
(b float)
(tee float)
(n float)
(f float))
(defglextfun ("glGetClipPlanef" get-clip-plane-f) :void
(plane enum)
(equation (:pointer float)))
(defglextfun ("glOrthof" ortho-f) :void
(l float)
(r float)
(b float)
(tee float)
(n float)
(f float))
(defglextfun ("glAlphaFuncx" alpha-func-x) :void
(func enum)
(ref fixed))
(defglextfun ("glClearColorx" clear-color-x) :void
(red fixed)
(green fixed)
(blue fixed)
(alpha fixed))
(defglextfun ("glClearDepthx" clear-depth-x) :void
(depth fixed))
(defglextfun ("glClipPlanex" clip-plane-x) :void
(plane enum)
(equation (:pointer fixed)))
(defglextfun ("glColor4x" color-4x) :void
(red fixed)
(green fixed)
(blue fixed)
(alpha fixed))
(defglextfun ("glDepthRangex" depth-range-x) :void
(n fixed)
(f fixed))
(defglextfun ("glFogx" fog-x) :void
(pname enum)
(param fixed))
(defglextfun ("glFogxv" fog-xv) :void
(pname enum)
(param (:pointer fixed)))
(defglextfun ("glFrustumx" frustum-x) :void
(l fixed)
(r fixed)
(b fixed)
(tee fixed)
(n fixed)
(f fixed))
(defglextfun ("glGetClipPlanex" get-clip-plane-x) :void
(plane enum)
(equation (:pointer fixed)))
(defglextfun ("glGetFixedv" get-fixed-v) :void
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glGetLightxv" get-light-xv) :void
(light enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glGetMaterialxv" get-material-xv) :void
(face enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glGetTexEnvxv" get-tex-env-xv) :void
(target enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glGetTexParameterxv" get-tex-parameter-xv) :void
(target enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glLightModelx" light-model-x) :void
(pname enum)
(param fixed))
(defglextfun ("glLightModelxv" light-model-xv) :void
(pname enum)
(param (:pointer fixed)))
(defglextfun ("glLightx" light-x) :void
(light enum)
(pname enum)
(param fixed))
(defglextfun ("glLightxv" light-xv) :void
(light enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glLineWidthx" line-width-x) :void
(width fixed))
(defglextfun ("glLoadMatrixx" load-matrix-x) :void
(m (:pointer fixed)))
(defglextfun ("glMaterialx" material-x) :void
(face enum)
(pname enum)
(param fixed))
(defglextfun ("glMaterialxv" material-xv) :void
(face enum)
(pname enum)
(param (:pointer fixed)))
(defglextfun ("glMultMatrixx" mult-matrix-x) :void
(m (:pointer fixed)))
(defglextfun ("glMultiTexCoord4x" multi-tex-coord-4x) :void
(texture enum)
(s fixed)
(tee fixed)
(r fixed)
(q fixed))
(defglextfun ("glNormal3x" normal-3x) :void
(nx fixed)
(ny fixed)
(nz fixed))
(defglextfun ("glOrthox" ortho-x) :void
(l fixed)
(r fixed)
(b fixed)
(tee fixed)
(n fixed)
(f fixed))
(defglextfun ("glPointParameterx" point-parameter-x) :void
(pname enum)
(param fixed))
(defglextfun ("glPointParameterxv" point-parameter-xv) :void
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glPointSizex" point-size-x) :void
(size fixed))
(defglextfun ("glPolygonOffsetx" polygon-offset-x) :void
(factor fixed)
(units fixed))
(defglextfun ("glRotatex" rotate-x) :void
(angle fixed)
(x fixed)
(y fixed)
(z fixed))
(defglextfun ("glSampleCoveragex" sample-coverage-x) :void
(value clampx)
(invert boolean))
(defglextfun ("glScalex" scale-x) :void
(x fixed)
(y fixed)
(z fixed))
(defglextfun ("glTexEnvx" tex-env-x) :void
(target enum)
(pname enum)
(param fixed))
(defglextfun ("glTexEnvxv" tex-env-xv) :void
(target enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glTexParameterx" tex-parameter-x) :void
(target enum)
(pname enum)
(param fixed))
(defglextfun ("glTexParameterxv" tex-parameter-xv) :void
(target enum)
(pname enum)
(params (:pointer fixed)))
(defglextfun ("glTranslatex" translate-x) :void
(x fixed)
(y fixed)
(z fixed))
(defglextfun ("glClipPlanefIMG" clip-plane-f-img) :void
(p enum)
(eqn (:pointer float)))
(defglextfun ("glClipPlanexIMG" clip-plane-x-img) :void
(p enum)
(eqn (:pointer fixed)))
(defglextfun ("glBlendEquationSeparateOES" blend-equation-separate-oes) :void
(modeRGB enum)
(modeAlpha enum))
(defglextfun ("glBlendFuncSeparateOES" blend-func-separate-oes) :void
(srcRGB enum)
(dstRGB enum)
(srcAlpha enum)
(dstAlpha enum))
(defglextfun ("glBlendEquationOES" blend-equation-oes) :void
(mode enum))
(defglextfun ("glDrawTexsOES" draw-tex-s-oes) :void
(x short)
(y short)
(z short)
(width short)
(height short))
(defglextfun ("glDrawTexiOES" draw-tex-i-oes) :void
(x int)
(y int)
(z int)
(width int)
(height int))
(defglextfun ("glDrawTexxOES" draw-tex-x-oes) :void
(x fixed)
(y fixed)
(z fixed)
(width fixed)
(height fixed))
(defglextfun ("glDrawTexsvOES" draw-tex-sv-oes) :void
(coords (:pointer short)))
(defglextfun ("glDrawTexivOES" draw-tex-iv-oes) :void
(coords (:pointer int)))
(defglextfun ("glDrawTexxvOES" draw-tex-xv-oes) :void
(coords (:pointer fixed)))
(defglextfun ("glDrawTexfOES" draw-tex-f-oes) :void
(x float)
(y float)
(z float)
(width float)
(height float))
(defglextfun ("glDrawTexfvOES" draw-tex-fv-oes) :void
(coords (:pointer float)))
(defglextfun ("glIsRenderbufferOES" is-renderbuffer-oes) boolean
(renderbuffer uint))
(defglextfun ("glBindRenderbufferOES" bind-renderbuffer-oes) :void
(target enum)
(renderbuffer uint))
(defglextfun ("glDeleteRenderbuffersOES" delete-renderbuffers-oes) :void
(n sizei)
(renderbuffers (:pointer uint)))
(defglextfun ("glGenRenderbuffersOES" gen-renderbuffers-oes) :void
(n sizei)
(renderbuffers (:pointer uint)))
(defglextfun ("glRenderbufferStorageOES" renderbuffer-storage-oes) :void
(target enum)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glGetRenderbufferParameterivOES" get-renderbuffer-parameter-iv-oes) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glIsFramebufferOES" is-framebuffer-oes) boolean
(framebuffer uint))
(defglextfun ("glBindFramebufferOES" bind-framebuffer-oes) :void
(target enum)
(framebuffer uint))
(defglextfun ("glDeleteFramebuffersOES" delete-framebuffers-oes) :void
(n sizei)
(framebuffers (:pointer uint)))
(defglextfun ("glGenFramebuffersOES" gen-framebuffers-oes) :void
(n sizei)
(framebuffers (:pointer uint)))
(defglextfun ("glCheckFramebufferStatusOES" check-framebuffer-status-oes) enum
(target enum))
(defglextfun ("glFramebufferRenderbufferOES" framebuffer-renderbuffer-oes) :void
(target enum)
(attachment enum)
(renderbuffertarget enum)
(renderbuffer uint))
(defglextfun ("glFramebufferTexture2DOES" framebuffer-texture-2d-oes) :void
(target enum)
(attachment enum)
(textarget enum)
(texture uint)
(level int))
(defglextfun ("glGetFramebufferAttachmentParameterivOES" get-framebuffer-attachment-parameter-iv-oes) :void
(target enum)
(attachment enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGenerateMipmapOES" generate-mipmap-oes) :void
(target enum))
(defglextfun ("glCurrentPaletteMatrixOES" current-palette-matrix-oes) :void
(matrixpaletteindex uint))
(defglextfun ("glLoadPaletteFromModelViewMatrixOES" load-palette-from-model-view-matrix-oes) :void)
(defglextfun ("glMatrixIndexPointerOES" matrix-index-pointer-oes) :void
(size int)
(type enum)
(stride sizei)
(pointer (:pointer :void)))
(defglextfun ("glWeightPointerOES" weight-pointer-oes) :void
(size int)
(type enum)
(stride sizei)
(pointer (:pointer :void)))
(defglextfun ("glPointSizePointerOES" point-size-pointer-oes) :void
(type enum)
(stride sizei)
(pointer (:pointer :void)))
(defglextfun ("glTexGenfOES" tex-gen-f-oes) :void
(coord enum)
(pname enum)
(param float))
(defglextfun ("glTexGenfvOES" tex-gen-fv-oes) :void
(coord enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glTexGeniOES" tex-gen-i-oes) :void
(coord enum)
(pname enum)
(param int))
(defglextfun ("glTexGenivOES" tex-gen-iv-oes) :void
(coord enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetTexGenfvOES" get-tex-gen-fv-oes) :void
(coord enum)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetTexGenivOES" get-tex-gen-iv-oes) :void
(coord enum)
(pname enum)
(params (:pointer int)))
| 10,088 | Common Lisp | .lisp | 332 | 27.792169 | 107 | 0.723607 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | c26bb2021c5137649eff1088ca07cc157ca94d3c7b6d5b9daa5ec6593391fb85 | 30,594 | [
359922
] |
30,595 | funcs-gl-glcore-gles2.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/funcs-gl-glcore-gles2.lisp | ;;; this file is automatically generated, do not edit
;;; generated from files with the following copyright:
;;;
;;; Copyright (c) 2013-2015 The Khronos Group Inc.
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining a
;;; copy of this software and/or associated documentation files (the
;;; "Materials"), to deal in the Materials without restriction, including
;;; without limitation the rights to use, copy, modify, merge, publish,
;;; distribute, sublicense, and/or sell copies of the Materials, and to
;;; permit persons to whom the Materials are furnished to do so, subject to
;;; the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be included
;;; in all copies or substantial portions of the Materials.
;;;
;;; THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
;;; IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
;;; CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
;;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
;;; MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
;;;
;;; ------------------------------------------------------------------------
(in-package #:cl-opengl-bindings)
;;; generated 2015-08-30T01:01:50Z
;;; from gl.xml @ svn rev 31811, 2015-08-10T07:01:11.860488Z
(defglextfun ("glBlendColor" blend-color) :void
(red float)
(green float)
(blue float)
(alpha float))
(defglextfun ("glBlendEquation" blend-equation) :void
(mode enum))
(defglextfun ("glGetIntegeri_v" get-integer-i-v) :void
(target enum)
(index uint)
(data (:pointer int)))
(defglextfun ("glBindBufferRange" bind-buffer-range) :void
(target enum)
(index uint)
(buffer uint)
(offset intptr)
(size sizeiptr))
(defglextfun ("glBindBufferBase" bind-buffer-base) :void
(target enum)
(index uint)
(buffer uint))
(defglextfun ("glIsRenderbuffer" is-renderbuffer) boolean
(renderbuffer uint))
(defglextfun ("glBindRenderbuffer" bind-renderbuffer) :void
(target enum)
(renderbuffer uint))
(defglextfun ("glDeleteRenderbuffers" delete-renderbuffers) :void
(n sizei)
(renderbuffers (:pointer uint)))
(defglextfun ("glGenRenderbuffers" gen-renderbuffers) :void
(n sizei)
(renderbuffers (:pointer uint)))
(defglextfun ("glRenderbufferStorage" renderbuffer-storage) :void
(target enum)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glGetRenderbufferParameteriv" get-renderbuffer-parameter-iv) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glIsFramebuffer" is-framebuffer) boolean
(framebuffer uint))
(defglextfun ("glBindFramebuffer" bind-framebuffer) :void
(target enum)
(framebuffer uint))
(defglextfun ("glDeleteFramebuffers" delete-framebuffers) :void
(n sizei)
(framebuffers (:pointer uint)))
(defglextfun ("glGenFramebuffers" gen-framebuffers) :void
(n sizei)
(framebuffers (:pointer uint)))
(defglextfun ("glCheckFramebufferStatus" check-framebuffer-status) enum
(target enum))
(defglextfun ("glFramebufferTexture2D" framebuffer-texture-2d) :void
(target enum)
(attachment enum)
(textarget enum)
(texture uint)
(level int))
(defglextfun ("glFramebufferRenderbuffer" framebuffer-renderbuffer) :void
(target enum)
(attachment enum)
(renderbuffertarget enum)
(renderbuffer uint))
(defglextfun ("glGetFramebufferAttachmentParameteriv" get-framebuffer-attachment-parameter-iv) :void
(target enum)
(attachment enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGenerateMipmap" generate-mipmap) :void
(target enum))
(defglextfun ("glBlitFramebuffer" blit-framebuffer) :void
(srcX0 int)
(srcY0 int)
(srcX1 int)
(srcY1 int)
(dstX0 int)
(dstY0 int)
(dstX1 int)
(dstY1 int)
(mask ClearBufferMask)
(filter enum))
(defglextfun ("glRenderbufferStorageMultisample" renderbuffer-storage-multisample) :void
(target enum)
(samples sizei)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glFramebufferTextureLayer" framebuffer-texture-layer) :void
(target enum)
(attachment enum)
(texture uint)
(level int)
(layer int))
(defglextfun ("glMapBufferRange" map-buffer-range) (:pointer :void)
(target enum)
(offset intptr)
(length sizeiptr)
(access bitfield))
(defglextfun ("glFlushMappedBufferRange" flush-mapped-buffer-range) :void
(target enum)
(offset intptr)
(length sizeiptr))
(defglextfun ("glBindVertexArray" bind-vertex-array) :void
(array uint))
(defglextfun ("glDeleteVertexArrays" delete-vertex-arrays) :void
(n sizei)
(arrays (:pointer uint)))
(defglextfun ("glGenVertexArrays" gen-vertex-arrays) :void
(n sizei)
(arrays (:pointer uint)))
(defglextfun ("glIsVertexArray" is-vertex-array) boolean
(array uint))
(defglextfun ("glCopyBufferSubData" copy-buffer-sub-data) :void
(readTarget enum)
(writeTarget enum)
(readOffset intptr)
(writeOffset intptr)
(size sizeiptr))
(defglextfun ("glGetUniformIndices" get-uniform-indices) :void
(program uint)
(uniformCount sizei)
(uniformNames (:pointer (:pointer char)))
(uniformIndices (:pointer uint)))
(defglextfun ("glGetActiveUniformsiv" get-active-uniforms-iv) :void
(program uint)
(uniformCount sizei)
(uniformIndices (:pointer uint))
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetUniformBlockIndex" get-uniform-block-index) uint
(program uint)
(uniformBlockName (:pointer char)))
(defglextfun ("glGetActiveUniformBlockiv" get-active-uniform-block-iv) :void
(program uint)
(uniformBlockIndex uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetActiveUniformBlockName" get-active-uniform-block-name) :void
(program uint)
(uniformBlockIndex uint)
(bufSize sizei)
(length (:pointer sizei))
(uniformBlockName (:pointer char)))
(defglextfun ("glUniformBlockBinding" uniform-block-binding) :void
(program uint)
(uniformBlockIndex uint)
(uniformBlockBinding uint))
(defglextfun ("glDrawElementsBaseVertex" draw-elements-base-vertex) :void
(mode enum)
(count sizei)
(type enum)
(indices offset-or-pointer)
(basevertex int))
(defglextfun ("glDrawRangeElementsBaseVertex" draw-range-elements-base-vertex) :void
(mode enum)
(start uint)
(end uint)
(count sizei)
(type enum)
(indices offset-or-pointer)
(basevertex int))
(defglextfun ("glDrawElementsInstancedBaseVertex" draw-elements-instanced-base-vertex) :void
(mode enum)
(count sizei)
(type enum)
(indices offset-or-pointer)
(instancecount sizei)
(basevertex int))
(defglextfun ("glFenceSync" fence-sync) sync
(condition enum)
(flags bitfield))
(defglextfun ("glIsSync" is-sync) boolean
(sync sync))
(defglextfun ("glDeleteSync" delete-sync) :void
(sync sync))
(defglextfun ("glClientWaitSync" client-wait-sync) enum
(sync sync)
(flags bitfield)
(timeout uint64))
(defglextfun ("glWaitSync" wait-sync) :void
(sync sync)
(flags bitfield)
(timeout uint64))
(defglextfun ("glGetInteger64v" get-integer-64-v) :void
(pname enum)
(data (:pointer int64)))
(defglextfun ("glGetSynciv" get-sync-iv) :void
(sync sync)
(pname enum)
(bufSize sizei)
(length (:pointer sizei))
(values (:pointer int)))
(defglextfun ("glGetMultisamplefv" get-multisample-fv) :void
(pname enum)
(index uint)
(val (:pointer float)))
(defglextfun ("glSampleMaski" sample-mask-i) :void
(maskNumber uint)
(mask bitfield))
(defglextfun ("glGenSamplers" gen-samplers) :void
(count sizei)
(samplers (:pointer uint)))
(defglextfun ("glDeleteSamplers" delete-samplers) :void
(count sizei)
(samplers (:pointer uint)))
(defglextfun ("glIsSampler" is-sampler) boolean
(sampler uint))
(defglextfun ("glBindSampler" bind-sampler) :void
(unit uint)
(sampler uint))
(defglextfun ("glSamplerParameteri" sampler-parameter-i) :void
(sampler uint)
(pname enum)
(param int))
(defglextfun ("glSamplerParameteriv" sampler-parameter-iv) :void
(sampler uint)
(pname enum)
(param (:pointer int)))
(defglextfun ("glSamplerParameterf" sampler-parameter-f) :void
(sampler uint)
(pname enum)
(param float))
(defglextfun ("glSamplerParameterfv" sampler-parameter-fv) :void
(sampler uint)
(pname enum)
(param (:pointer float)))
(defglextfun ("glSamplerParameterIiv" sampler-parameter-iiv) :void
(sampler uint)
(pname enum)
(param (:pointer int)))
(defglextfun ("glSamplerParameterIuiv" sampler-parameter-iuiv) :void
(sampler uint)
(pname enum)
(param (:pointer uint)))
(defglextfun ("glGetSamplerParameteriv" get-sampler-parameter-iv) :void
(sampler uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetSamplerParameterIiv" get-sampler-parameter-iiv) :void
(sampler uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetSamplerParameterfv" get-sampler-parameter-fv) :void
(sampler uint)
(pname enum)
(params (:pointer float)))
(defglextfun ("glGetSamplerParameterIuiv" get-sampler-parameter-iuiv) :void
(sampler uint)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glDrawArraysIndirect" draw-arrays-indirect) :void
(mode enum)
(indirect offset-or-pointer))
(defglextfun ("glDrawElementsIndirect" draw-elements-indirect) :void
(mode enum)
(type enum)
(indirect offset-or-pointer))
(defglextfun ("glPatchParameteri" patch-parameter-i) :void
(pname enum)
(value int))
(defglextfun ("glBindTransformFeedback" bind-transform-feedback) :void
(target enum)
(id uint))
(defglextfun ("glDeleteTransformFeedbacks" delete-transform-feedbacks) :void
(n sizei)
(ids (:pointer uint)))
(defglextfun ("glGenTransformFeedbacks" gen-transform-feedbacks) :void
(n sizei)
(ids (:pointer uint)))
(defglextfun ("glIsTransformFeedback" is-transform-feedback) boolean
(id uint))
(defglextfun ("glPauseTransformFeedback" pause-transform-feedback) :void)
(defglextfun ("glResumeTransformFeedback" resume-transform-feedback) :void)
(defglextfun ("glReleaseShaderCompiler" release-shader-compiler) :void)
(defglextfun ("glShaderBinary" shader-binary) :void
(count sizei)
(shaders (:pointer uint))
(binaryformat enum)
(binary (:pointer :void))
(length sizei))
(defglextfun ("glGetShaderPrecisionFormat" get-shader-precision-format) :void
(shadertype enum)
(precisiontype enum)
(range (:pointer int))
(precision (:pointer int)))
(defglextfun ("glGetProgramBinary" get-program-binary) :void
(program uint)
(bufSize sizei)
(length (:pointer sizei))
(binaryFormat (:pointer enum))
(binary (:pointer :void)))
(defglextfun ("glProgramBinary" program-binary) :void
(program uint)
(binaryFormat enum)
(binary (:pointer :void))
(length sizei))
(defglextfun ("glProgramParameteri" program-parameter-i) :void
(program uint)
(pname enum)
(value int))
(defglextfun ("glUseProgramStages" use-program-stages) :void
(pipeline uint)
(stages bitfield)
(program uint))
(defglextfun ("glActiveShaderProgram" active-shader-program) :void
(pipeline uint)
(program uint))
(defglextfun ("glCreateShaderProgramv" create-shader-program-v) uint
(type enum)
(count sizei)
(strings (:pointer (:pointer char))))
(defglextfun ("glBindProgramPipeline" bind-program-pipeline) :void
(pipeline uint))
(defglextfun ("glDeleteProgramPipelines" delete-program-pipelines) :void
(n sizei)
(pipelines (:pointer uint)))
(defglextfun ("glGenProgramPipelines" gen-program-pipelines) :void
(n sizei)
(pipelines (:pointer uint)))
(defglextfun ("glIsProgramPipeline" is-program-pipeline) boolean
(pipeline uint))
(defglextfun ("glGetProgramPipelineiv" get-program-pipeline-iv) :void
(pipeline uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glProgramUniform1i" program-uniform-1i) :void
(program uint)
(location int)
(v0 int))
(defglextfun ("glProgramUniform1iv" program-uniform-1iv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer int)))
(defglextfun ("glProgramUniform1f" program-uniform-1f) :void
(program uint)
(location int)
(v0 float))
(defglextfun ("glProgramUniform1fv" program-uniform-1fv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer float)))
(defglextfun ("glProgramUniform1ui" program-uniform-1ui) :void
(program uint)
(location int)
(v0 uint))
(defglextfun ("glProgramUniform1uiv" program-uniform-1uiv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer uint)))
(defglextfun ("glProgramUniform2i" program-uniform-2i) :void
(program uint)
(location int)
(v0 int)
(v1 int))
(defglextfun ("glProgramUniform2iv" program-uniform-2iv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer int)))
(defglextfun ("glProgramUniform2f" program-uniform-2f) :void
(program uint)
(location int)
(v0 float)
(v1 float))
(defglextfun ("glProgramUniform2fv" program-uniform-2fv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer float)))
(defglextfun ("glProgramUniform2ui" program-uniform-2ui) :void
(program uint)
(location int)
(v0 uint)
(v1 uint))
(defglextfun ("glProgramUniform2uiv" program-uniform-2uiv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer uint)))
(defglextfun ("glProgramUniform3i" program-uniform-3i) :void
(program uint)
(location int)
(v0 int)
(v1 int)
(v2 int))
(defglextfun ("glProgramUniform3iv" program-uniform-3iv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer int)))
(defglextfun ("glProgramUniform3f" program-uniform-3f) :void
(program uint)
(location int)
(v0 float)
(v1 float)
(v2 float))
(defglextfun ("glProgramUniform3fv" program-uniform-3fv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer float)))
(defglextfun ("glProgramUniform3ui" program-uniform-3ui) :void
(program uint)
(location int)
(v0 uint)
(v1 uint)
(v2 uint))
(defglextfun ("glProgramUniform3uiv" program-uniform-3uiv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer uint)))
(defglextfun ("glProgramUniform4i" program-uniform-4i) :void
(program uint)
(location int)
(v0 int)
(v1 int)
(v2 int)
(v3 int))
(defglextfun ("glProgramUniform4iv" program-uniform-4iv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer int)))
(defglextfun ("glProgramUniform4f" program-uniform-4f) :void
(program uint)
(location int)
(v0 float)
(v1 float)
(v2 float)
(v3 float))
(defglextfun ("glProgramUniform4fv" program-uniform-4fv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer float)))
(defglextfun ("glProgramUniform4ui" program-uniform-4ui) :void
(program uint)
(location int)
(v0 uint)
(v1 uint)
(v2 uint)
(v3 uint))
(defglextfun ("glProgramUniform4uiv" program-uniform-4uiv) :void
(program uint)
(location int)
(count sizei)
(value (:pointer uint)))
(defglextfun ("glProgramUniformMatrix2fv" program-uniform-matrix-2fv) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glProgramUniformMatrix3fv" program-uniform-matrix-3fv) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glProgramUniformMatrix4fv" program-uniform-matrix-4fv) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glProgramUniformMatrix2x3fv" program-uniform-matrix-2x3-fv) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glProgramUniformMatrix3x2fv" program-uniform-matrix-3x2-fv) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glProgramUniformMatrix2x4fv" program-uniform-matrix-2x4-fv) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glProgramUniformMatrix4x2fv" program-uniform-matrix-4x2-fv) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glProgramUniformMatrix3x4fv" program-uniform-matrix-3x4-fv) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glProgramUniformMatrix4x3fv" program-uniform-matrix-4x3-fv) :void
(program uint)
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glValidateProgramPipeline" validate-program-pipeline) :void
(pipeline uint))
(defglextfun ("glGetProgramPipelineInfoLog" get-program-pipeline-info-log) :void
(pipeline uint)
(bufSize sizei)
(length (:pointer sizei))
(infoLog (:pointer char)))
(defglextfun ("glGetInternalformativ" get-internal-format-iv) :void
(target enum)
(internalformat enum)
(pname enum)
(bufSize sizei)
(params (:pointer int)))
(defglextfun ("glBindImageTexture" bind-image-texture) :void
(unit uint)
(texture uint)
(level int)
(layered boolean)
(layer int)
(access enum)
(format enum))
(defglextfun ("glMemoryBarrier" memory-barrier) :void
(barriers bitfield))
(defglextfun ("glTexStorage2D" tex-storage-2d) :void
(target enum)
(levels sizei)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glTexStorage3D" tex-storage-3d) :void
(target enum)
(levels sizei)
(internalformat enum)
(width sizei)
(height sizei)
(depth sizei))
(defglextfun ("glDispatchCompute" dispatch-compute) :void
(num_groups_x uint)
(num_groups_y uint)
(num_groups_z uint))
(defglextfun ("glDispatchComputeIndirect" dispatch-compute-indirect) :void
(indirect intptr))
(defglextfun ("glCopyImageSubData" copy-image-sub-data) :void
(srcName uint)
(srcTarget enum)
(srcLevel int)
(srcX int)
(srcY int)
(srcZ int)
(dstName uint)
(dstTarget enum)
(dstLevel int)
(dstX int)
(dstY int)
(dstZ int)
(srcWidth sizei)
(srcHeight sizei)
(srcDepth sizei))
(defglextfun ("glFramebufferParameteri" framebuffer-parameter-i) :void
(target enum)
(pname enum)
(param int))
(defglextfun ("glGetFramebufferParameteriv" get-framebuffer-parameter-iv) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glInvalidateFramebuffer" invalidate-framebuffer) :void
(target enum)
(numAttachments sizei)
(attachments (:pointer enum)))
(defglextfun ("glInvalidateSubFramebuffer" invalidate-sub-framebuffer) :void
(target enum)
(numAttachments sizei)
(attachments (:pointer enum))
(x int)
(y int)
(width sizei)
(height sizei))
(defglextfun ("glGetProgramInterfaceiv" get-program-interface-iv) :void
(program uint)
(programInterface enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetProgramResourceIndex" get-program-resource-index) uint
(program uint)
(programInterface enum)
(name (:pointer char)))
(defglextfun ("glGetProgramResourceName" get-program-resource-name) :void
(program uint)
(programInterface enum)
(index uint)
(bufSize sizei)
(length (:pointer sizei))
(name (:pointer char)))
(defglextfun ("glGetProgramResourceiv" get-program-resource-iv) :void
(program uint)
(programInterface enum)
(index uint)
(propCount sizei)
(props (:pointer enum))
(bufSize sizei)
(length (:pointer sizei))
(params (:pointer int)))
(defglextfun ("glGetProgramResourceLocation" get-program-resource-location) int
(program uint)
(programInterface enum)
(name (:pointer char)))
(defglextfun ("glTexBufferRange" tex-buffer-range) :void
(target enum)
(internalformat enum)
(buffer uint)
(offset intptr)
(size sizeiptr))
(defglextfun ("glTexStorage2DMultisample" tex-storage-2d-multisample) :void
(target enum)
(samples sizei)
(internalformat enum)
(width sizei)
(height sizei)
(fixedsamplelocations boolean))
(defglextfun ("glTexStorage3DMultisample" tex-storage-3d-multisample) :void
(target enum)
(samples sizei)
(internalformat enum)
(width sizei)
(height sizei)
(depth sizei)
(fixedsamplelocations boolean))
(defglextfun ("glBindVertexBuffer" bind-vertex-buffer) :void
(bindingindex uint)
(buffer uint)
(offset intptr)
(stride sizei))
(defglextfun ("glVertexAttribFormat" vertex-attrib-format) :void
(attribindex uint)
(size int)
(type enum)
(normalized boolean)
(relativeoffset uint))
(defglextfun ("glVertexAttribIFormat" vertex-attrib-i-format) :void
(attribindex uint)
(size int)
(type enum)
(relativeoffset uint))
(defglextfun ("glVertexAttribBinding" vertex-attrib-binding) :void
(attribindex uint)
(bindingindex uint))
(defglextfun ("glVertexBindingDivisor" vertex-binding-divisor) :void
(bindingindex uint)
(divisor uint))
(defglextfun ("glDebugMessageControl" debug-message-control) :void
(source enum)
(type enum)
(severity enum)
(count sizei)
(ids (:pointer uint))
(enabled boolean))
(defglextfun ("glDebugMessageInsert" debug-message-insert) :void
(source enum)
(type enum)
(id uint)
(severity enum)
(length sizei)
(buf (:pointer char)))
(defglextfun ("glDebugMessageCallback" debug-message-callback) :void
(callback debugproc)
(userParam (:pointer :void)))
(defglextfun ("glGetDebugMessageLog" get-debug-message-log) uint
(count uint)
(bufSize sizei)
(sources (:pointer enum))
(types (:pointer enum))
(ids (:pointer uint))
(severities (:pointer enum))
(lengths (:pointer sizei))
(messageLog (:pointer char)))
(defglextfun ("glPushDebugGroup" push-debug-group) :void
(source enum)
(id uint)
(length sizei)
(message (:pointer char)))
(defglextfun ("glPopDebugGroup" pop-debug-group) :void)
(defglextfun ("glObjectLabel" object-label) :void
(identifier enum)
(name uint)
(length sizei)
(label (:pointer char)))
(defglextfun ("glGetObjectLabel" get-object-label) :void
(identifier enum)
(name uint)
(bufSize sizei)
(length (:pointer sizei))
(label (:pointer char)))
(defglextfun ("glObjectPtrLabel" object-ptr-label) :void
(ptr (:pointer :void))
(length sizei)
(label (:pointer char)))
(defglextfun ("glGetObjectPtrLabel" get-object-ptr-label) :void
(ptr (:pointer :void))
(bufSize sizei)
(length (:pointer sizei))
(label (:pointer char)))
(defglextfun ("glMemoryBarrierByRegion" memory-barrier-by-region) :void
(barriers bitfield))
(defglextfun ("glGetGraphicsResetStatus" get-graphics-reset-status) enum)
(defglextfun ("glGetnUniformfv" getn-uniform-fv) :void
(program uint)
(location int)
(bufSize sizei)
(params (:pointer float)))
(defglextfun ("glGetnUniformiv" getn-uniform-iv) :void
(program uint)
(location int)
(bufSize sizei)
(params (:pointer int)))
(defglextfun ("glGetnUniformuiv" getn-uniform-uiv) :void
(program uint)
(location int)
(bufSize sizei)
(params (:pointer uint)))
(defglextfun ("glReadnPixels" readn-pixels) :void
(x int)
(y int)
(width sizei)
(height sizei)
(format enum)
(type enum)
(bufSize sizei)
(data (:pointer :void)))
(defglextfun ("glTexPageCommitmentARB" tex-page-commitment-arb) :void
(target enum)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei)
(commit boolean))
(defglextfun ("glDebugMessageControlKHR" debug-message-control-khr) :void
(source enum)
(type enum)
(severity enum)
(count sizei)
(ids (:pointer uint))
(enabled boolean))
(defglextfun ("glDebugMessageInsertKHR" debug-message-insert-khr) :void
(source enum)
(type enum)
(id uint)
(severity enum)
(length sizei)
(buf (:pointer char)))
(defglextfun ("glDebugMessageCallbackKHR" debug-message-callback-khr) :void
(callback debugprockhr)
(userParam (:pointer :void)))
(defglextfun ("glGetDebugMessageLogKHR" get-debug-message-log-khr) uint
(count uint)
(bufSize sizei)
(sources (:pointer enum))
(types (:pointer enum))
(ids (:pointer uint))
(severities (:pointer enum))
(lengths (:pointer sizei))
(messageLog (:pointer char)))
(defglextfun ("glPushDebugGroupKHR" push-debug-group-khr) :void
(source enum)
(id uint)
(length sizei)
(message (:pointer char)))
(defglextfun ("glPopDebugGroupKHR" pop-debug-group-khr) :void)
(defglextfun ("glObjectLabelKHR" object-label-khr) :void
(identifier enum)
(name uint)
(length sizei)
(label (:pointer char)))
(defglextfun ("glGetObjectLabelKHR" get-object-label-khr) :void
(identifier enum)
(name uint)
(bufSize sizei)
(length (:pointer sizei))
(label (:pointer char)))
(defglextfun ("glObjectPtrLabelKHR" object-ptr-label-khr) :void
(ptr (:pointer :void))
(length sizei)
(label (:pointer char)))
(defglextfun ("glGetObjectPtrLabelKHR" get-object-ptr-label-khr) :void
(ptr (:pointer :void))
(bufSize sizei)
(length (:pointer sizei))
(label (:pointer char)))
(defglextfun ("glGetPointervKHR" get-pointer-v-khr) :void
(pname enum)
(params (:pointer (:pointer :void))))
(defglextfun ("glGetGraphicsResetStatusKHR" get-graphics-reset-status-khr) enum)
(defglextfun ("glReadnPixelsKHR" readn-pixels-khr) :void
(x int)
(y int)
(width sizei)
(height sizei)
(format enum)
(type enum)
(bufSize sizei)
(data (:pointer :void)))
(defglextfun ("glGetnUniformfvKHR" getn-uniform-fv-khr) :void
(program uint)
(location int)
(bufSize sizei)
(params (:pointer float)))
(defglextfun ("glGetnUniformivKHR" getn-uniform-iv-khr) :void
(program uint)
(location int)
(bufSize sizei)
(params (:pointer int)))
(defglextfun ("glGetnUniformuivKHR" getn-uniform-uiv-khr) :void
(program uint)
(location int)
(bufSize sizei)
(params (:pointer uint)))
| 25,867 | Common Lisp | .lisp | 854 | 27.559719 | 100 | 0.74404 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 1e17e860cfaca6a0df289d3ad31adaa8bee8a7a65a971ee43639432362493bd9 | 30,595 | [
19788
] |
30,596 | funcs-gles2.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/gl/funcs-gles2.lisp | ;;; this file is automatically generated, do not edit
;;; generated from files with the following copyright:
;;;
;;; Copyright (c) 2013-2015 The Khronos Group Inc.
;;;
;;; Permission is hereby granted, free of charge, to any person obtaining a
;;; copy of this software and/or associated documentation files (the
;;; "Materials"), to deal in the Materials without restriction, including
;;; without limitation the rights to use, copy, modify, merge, publish,
;;; distribute, sublicense, and/or sell copies of the Materials, and to
;;; permit persons to whom the Materials are furnished to do so, subject to
;;; the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be included
;;; in all copies or substantial portions of the Materials.
;;;
;;; THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
;;; IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
;;; CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
;;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
;;; MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
;;;
;;; ------------------------------------------------------------------------
(in-package #:cl-opengl-bindings)
;;; generated 2015-08-30T01:01:50Z
;;; from gl.xml @ svn rev 31811, 2015-08-10T07:01:11.860488Z
(defglextfun ("glBlendBarrier" blend-barrier) :void)
(defglextfun ("glPrimitiveBoundingBox" primitive-bounding-box) :void
(minX float)
(minY float)
(minZ float)
(minW float)
(maxX float)
(maxY float)
(maxZ float)
(maxW float))
(defglextfun ("glBlitFramebufferANGLE" blit-framebuffer-angle) :void
(srcX0 int)
(srcY0 int)
(srcX1 int)
(srcY1 int)
(dstX0 int)
(dstY0 int)
(dstX1 int)
(dstY1 int)
(mask bitfield)
(filter enum))
(defglextfun ("glRenderbufferStorageMultisampleANGLE" renderbuffer-storage-multisample-angle) :void
(target enum)
(samples sizei)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glDrawArraysInstancedANGLE" draw-arrays-instanced-angle) :void
(mode enum)
(first int)
(count sizei)
(primcount sizei))
(defglextfun ("glDrawElementsInstancedANGLE" draw-elements-instanced-angle) :void
(mode enum)
(count sizei)
(type enum)
(indices (:pointer :void))
(primcount sizei))
(defglextfun ("glVertexAttribDivisorANGLE" vertex-attrib-divisor-angle) :void
(index uint)
(divisor uint))
(defglextfun ("glGetTranslatedShaderSourceANGLE" get-translated-shader-source-angle) :void
(shader uint)
(bufsize sizei)
(length (:pointer sizei))
(source (:pointer char)))
(defglextfun ("glDrawArraysInstancedBaseInstanceEXT" draw-arrays-instanced-base-instance-ext) :void
(mode enum)
(first int)
(count sizei)
(instancecount sizei)
(baseinstance uint))
(defglextfun ("glDrawElementsInstancedBaseInstanceEXT" draw-elements-instanced-base-instance-ext) :void
(mode enum)
(count sizei)
(type enum)
(indices (:pointer :void))
(instancecount sizei)
(baseinstance uint))
(defglextfun ("glDrawElementsInstancedBaseVertexBaseInstanceEXT" draw-elements-instanced-base-vertex-base-instance-ext) :void
(mode enum)
(count sizei)
(type enum)
(indices (:pointer :void))
(instancecount sizei)
(basevertex int)
(baseinstance uint))
(defglextfun ("glBufferStorageEXT" buffer-storage-ext) :void
(target enum)
(size sizeiptr)
(data (:pointer :void))
(flags bitfield))
(defglextfun ("glCopyImageSubDataEXT" copy-image-sub-data-ext) :void
(srcName uint)
(srcTarget enum)
(srcLevel int)
(srcX int)
(srcY int)
(srcZ int)
(dstName uint)
(dstTarget enum)
(dstLevel int)
(dstX int)
(dstY int)
(dstZ int)
(srcWidth sizei)
(srcHeight sizei)
(srcDepth sizei))
(defglextfun ("glGenQueriesEXT" gen-queries-ext) :void
(n sizei)
(ids (:pointer uint)))
(defglextfun ("glDeleteQueriesEXT" delete-queries-ext) :void
(n sizei)
(ids (:pointer uint)))
(defglextfun ("glIsQueryEXT" is-query-ext) boolean
(id uint))
(defglextfun ("glBeginQueryEXT" begin-query-ext) :void
(target enum)
(id uint))
(defglextfun ("glEndQueryEXT" end-query-ext) :void
(target enum))
(defglextfun ("glQueryCounterEXT" query-counter-ext) :void
(id uint)
(target enum))
(defglextfun ("glGetQueryivEXT" get-query-iv-ext) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetQueryObjectivEXT" get-query-object-iv-ext) :void
(id uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetQueryObjectuivEXT" get-query-object-uiv-ext) :void
(id uint)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glDrawBuffersEXT" draw-buffers-ext) :void
(n sizei)
(bufs (:pointer enum)))
(defglextfun ("glEnableiEXT" enable-i-ext) :void
(target enum)
(index uint))
(defglextfun ("glDisableiEXT" disable-i-ext) :void
(target enum)
(index uint))
(defglextfun ("glBlendEquationiEXT" blend-equation-i-ext) :void
(buf uint)
(mode enum))
(defglextfun ("glBlendEquationSeparateiEXT" blend-equation-separate-i-ext) :void
(buf uint)
(modeRGB enum)
(modeAlpha enum))
(defglextfun ("glBlendFunciEXT" blend-func-i-ext) :void
(buf uint)
(src enum)
(dst enum))
(defglextfun ("glBlendFuncSeparateiEXT" blend-func-separate-i-ext) :void
(buf uint)
(srcRGB enum)
(dstRGB enum)
(srcAlpha enum)
(dstAlpha enum))
(defglextfun ("glColorMaskiEXT" color-mask-i-ext) :void
(index uint)
(r boolean)
(g boolean)
(b boolean)
(a boolean))
(defglextfun ("glIsEnablediEXT" is-enabled-i-ext) boolean
(target enum)
(index uint))
(defglextfun ("glDrawElementsBaseVertexEXT" draw-elements-base-vertex-ext) :void
(mode enum)
(count sizei)
(type enum)
(indices (:pointer :void))
(basevertex int))
(defglextfun ("glDrawRangeElementsBaseVertexEXT" draw-range-elements-base-vertex-ext) :void
(mode enum)
(start uint)
(end uint)
(count sizei)
(type enum)
(indices (:pointer :void))
(basevertex int))
(defglextfun ("glDrawElementsInstancedBaseVertexEXT" draw-elements-instanced-base-vertex-ext) :void
(mode enum)
(count sizei)
(type enum)
(indices (:pointer :void))
(instancecount sizei)
(basevertex int))
(defglextfun ("glMultiDrawElementsBaseVertexEXT" multi-draw-elements-base-vertex-ext) :void
(mode enum)
(count (:pointer sizei))
(type enum)
(indices (:pointer (:pointer :void)))
(primcount sizei)
(basevertex (:pointer int)))
(defglextfun ("glVertexAttribDivisorEXT" vertex-attrib-divisor-ext) :void
(index uint)
(divisor uint))
(defglextfun ("glMultiDrawArraysIndirectEXT" multi-draw-arrays-indirect-ext) :void
(mode enum)
(indirect (:pointer :void))
(drawcount sizei)
(stride sizei))
(defglextfun ("glMultiDrawElementsIndirectEXT" multi-draw-elements-indirect-ext) :void
(mode enum)
(type enum)
(indirect (:pointer :void))
(drawcount sizei)
(stride sizei))
(defglextfun ("glReadBufferIndexedEXT" read-buffer-indexed-ext) :void
(src enum)
(index int))
(defglextfun ("glDrawBuffersIndexedEXT" draw-buffers-indexed-ext) :void
(n int)
(location (:pointer enum))
(indices (:pointer int)))
(defglextfun ("glGetIntegeri_vEXT" get-integer-i-v-ext) :void
(target enum)
(index uint)
(data (:pointer int)))
(defglextfun ("glPrimitiveBoundingBoxEXT" primitive-bounding-box-ext) :void
(minX float)
(minY float)
(minZ float)
(minW float)
(maxX float)
(maxY float)
(maxZ float)
(maxW float))
(defglextfun ("glPatchParameteriEXT" patch-parameter-i-ext) :void
(pname enum)
(value int))
(defglextfun ("glSamplerParameterIivEXT" sampler-parameter-iiv-ext) :void
(sampler uint)
(pname enum)
(param (:pointer int)))
(defglextfun ("glSamplerParameterIuivEXT" sampler-parameter-iuiv-ext) :void
(sampler uint)
(pname enum)
(param (:pointer uint)))
(defglextfun ("glGetSamplerParameterIivEXT" get-sampler-parameter-iiv-ext) :void
(sampler uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetSamplerParameterIuivEXT" get-sampler-parameter-iuiv-ext) :void
(sampler uint)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glTexBufferRangeEXT" tex-buffer-range-ext) :void
(target enum)
(internalformat enum)
(buffer uint)
(offset intptr)
(size sizeiptr))
(defglextfun ("glTextureViewEXT" texture-view-ext) :void
(texture uint)
(target enum)
(origtexture uint)
(internalformat enum)
(minlevel uint)
(numlevels uint)
(minlayer uint)
(numlayers uint))
(defglextfun ("glCopyBufferSubDataNV" copy-buffer-sub-data-nv) :void
(readTarget enum)
(writeTarget enum)
(readOffset intptr)
(writeOffset intptr)
(size sizeiptr))
(defglextfun ("glCoverageMaskNV" coverage-mask-nv) :void
(mask boolean))
(defglextfun ("glCoverageOperationNV" coverage-operation-nv) :void
(operation enum))
(defglextfun ("glDrawBuffersNV" draw-buffers-nv) :void
(n sizei)
(bufs (:pointer enum)))
(defglextfun ("glDrawArraysInstancedNV" draw-arrays-instanced-nv) :void
(mode enum)
(first int)
(count sizei)
(primcount sizei))
(defglextfun ("glDrawElementsInstancedNV" draw-elements-instanced-nv) :void
(mode enum)
(count sizei)
(type enum)
(indices (:pointer :void))
(primcount sizei))
(defglextfun ("glBlitFramebufferNV" blit-framebuffer-nv) :void
(srcX0 int)
(srcY0 int)
(srcX1 int)
(srcY1 int)
(dstX0 int)
(dstY0 int)
(dstX1 int)
(dstY1 int)
(mask bitfield)
(filter enum))
(defglextfun ("glRenderbufferStorageMultisampleNV" renderbuffer-storage-multisample-nv) :void
(target enum)
(samples sizei)
(internalformat enum)
(width sizei)
(height sizei))
(defglextfun ("glVertexAttribDivisorNV" vertex-attrib-divisor-nv) :void
(index uint)
(divisor uint))
(defglextfun ("glUniformMatrix2x3fvNV" uniform-matrix-2x3-fv-nv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glUniformMatrix3x2fvNV" uniform-matrix-3x2-fv-nv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glUniformMatrix2x4fvNV" uniform-matrix-2x4-fv-nv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glUniformMatrix4x2fvNV" uniform-matrix-4x2-fv-nv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glUniformMatrix3x4fvNV" uniform-matrix-3x4-fv-nv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glUniformMatrix4x3fvNV" uniform-matrix-4x3-fv-nv) :void
(location int)
(count sizei)
(transpose boolean)
(value (:pointer float)))
(defglextfun ("glPolygonModeNV" polygon-mode-nv) :void
(face enum)
(mode enum))
(defglextfun ("glReadBufferNV" read-buffer-nv) :void
(mode enum))
(defglextfun ("glViewportArrayvNV" viewport-array-v-nv) :void
(first uint)
(count sizei)
(v (:pointer float)))
(defglextfun ("glViewportIndexedfNV" viewport-indexed-f-nv) :void
(index uint)
(x float)
(y float)
(w float)
(h float))
(defglextfun ("glViewportIndexedfvNV" viewport-indexed-fv-nv) :void
(index uint)
(v (:pointer float)))
(defglextfun ("glScissorArrayvNV" scissor-array-v-nv) :void
(first uint)
(count sizei)
(v (:pointer int)))
(defglextfun ("glScissorIndexedNV" scissor-indexed-nv) :void
(index uint)
(left int)
(bottom int)
(width sizei)
(height sizei))
(defglextfun ("glScissorIndexedvNV" scissor-indexed-v-nv) :void
(index uint)
(v (:pointer int)))
(defglextfun ("glDepthRangeArrayfvNV" depth-range-array-fv-nv) :void
(first uint)
(count sizei)
(v (:pointer float)))
(defglextfun ("glDepthRangeIndexedfNV" depth-range-indexed-f-nv) :void
(index uint)
(n float)
(f float))
(defglextfun ("glGetFloati_vNV" get-float-i-v-nv) :void
(target enum)
(index uint)
(data (:pointer float)))
(defglextfun ("glEnableiNV" enable-i-nv) :void
(target enum)
(index uint))
(defglextfun ("glDisableiNV" disable-i-nv) :void
(target enum)
(index uint))
(defglextfun ("glIsEnablediNV" is-enabled-i-nv) boolean
(target enum)
(index uint))
(defglextfun ("glCopyImageSubDataOES" copy-image-sub-data-oes) :void
(srcName uint)
(srcTarget enum)
(srcLevel int)
(srcX int)
(srcY int)
(srcZ int)
(dstName uint)
(dstTarget enum)
(dstLevel int)
(dstX int)
(dstY int)
(dstZ int)
(srcWidth sizei)
(srcHeight sizei)
(srcDepth sizei))
(defglextfun ("glEnableiOES" enable-i-oes) :void
(target enum)
(index uint))
(defglextfun ("glDisableiOES" disable-i-oes) :void
(target enum)
(index uint))
(defglextfun ("glBlendEquationiOES" blend-equation-i-oes) :void
(buf uint)
(mode enum))
(defglextfun ("glBlendEquationSeparateiOES" blend-equation-separate-i-oes) :void
(buf uint)
(modeRGB enum)
(modeAlpha enum))
(defglextfun ("glBlendFunciOES" blend-func-i-oes) :void
(buf uint)
(src enum)
(dst enum))
(defglextfun ("glBlendFuncSeparateiOES" blend-func-separate-i-oes) :void
(buf uint)
(srcRGB enum)
(dstRGB enum)
(srcAlpha enum)
(dstAlpha enum))
(defglextfun ("glColorMaskiOES" color-mask-i-oes) :void
(index uint)
(r boolean)
(g boolean)
(b boolean)
(a boolean))
(defglextfun ("glIsEnablediOES" is-enabled-i-oes) boolean
(target enum)
(index uint))
(defglextfun ("glDrawElementsBaseVertexOES" draw-elements-base-vertex-oes) :void
(mode enum)
(count sizei)
(type enum)
(indices (:pointer :void))
(basevertex int))
(defglextfun ("glDrawRangeElementsBaseVertexOES" draw-range-elements-base-vertex-oes) :void
(mode enum)
(start uint)
(end uint)
(count sizei)
(type enum)
(indices (:pointer :void))
(basevertex int))
(defglextfun ("glDrawElementsInstancedBaseVertexOES" draw-elements-instanced-base-vertex-oes) :void
(mode enum)
(count sizei)
(type enum)
(indices (:pointer :void))
(instancecount sizei)
(basevertex int))
(defglextfun ("glMultiDrawElementsBaseVertexOES" multi-draw-elements-base-vertex-oes) :void
(mode enum)
(count (:pointer sizei))
(type enum)
(indices (:pointer (:pointer :void)))
(primcount sizei)
(basevertex (:pointer int)))
(defglextfun ("glFramebufferTextureOES" framebuffer-texture-oes) :void
(target enum)
(attachment enum)
(texture uint)
(level int))
(defglextfun ("glGetProgramBinaryOES" get-program-binary-oes) :void
(program uint)
(bufSize sizei)
(length (:pointer sizei))
(binaryFormat (:pointer enum))
(binary (:pointer :void)))
(defglextfun ("glProgramBinaryOES" program-binary-oes) :void
(program uint)
(binaryFormat enum)
(binary (:pointer :void))
(length int))
(defglextfun ("glPrimitiveBoundingBoxOES" primitive-bounding-box-oes) :void
(minX float)
(minY float)
(minZ float)
(minW float)
(maxX float)
(maxY float)
(maxZ float)
(maxW float))
(defglextfun ("glMinSampleShadingOES" min-sample-shading-oes) :void
(value float))
(defglextfun ("glPatchParameteriOES" patch-parameter-i-oes) :void
(pname enum)
(value int))
(defglextfun ("glTexImage3DOES" tex-image-3d-oes) :void
(target enum)
(level int)
(internalformat enum)
(width sizei)
(height sizei)
(depth sizei)
(border int)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glTexSubImage3DOES" tex-sub-image-3d-oes) :void
(target enum)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei)
(format enum)
(type enum)
(pixels (:pointer :void)))
(defglextfun ("glCopyTexSubImage3DOES" copy-tex-sub-image-3d-oes) :void
(target enum)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(x int)
(y int)
(width sizei)
(height sizei))
(defglextfun ("glCompressedTexImage3DOES" compressed-tex-image-3d-oes) :void
(target enum)
(level int)
(internalformat enum)
(width sizei)
(height sizei)
(depth sizei)
(border int)
(imageSize sizei)
(data (:pointer :void)))
(defglextfun ("glCompressedTexSubImage3DOES" compressed-tex-sub-image-3d-oes) :void
(target enum)
(level int)
(xoffset int)
(yoffset int)
(zoffset int)
(width sizei)
(height sizei)
(depth sizei)
(format enum)
(imageSize sizei)
(data (:pointer :void)))
(defglextfun ("glFramebufferTexture3DOES" framebuffer-texture-3d-oes) :void
(target enum)
(attachment enum)
(textarget enum)
(texture uint)
(level int)
(zoffset int))
(defglextfun ("glTexParameterIivOES" tex-parameter-iiv-oes) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glTexParameterIuivOES" tex-parameter-iuiv-oes) :void
(target enum)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glGetTexParameterIivOES" get-tex-parameter-iiv-oes) :void
(target enum)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetTexParameterIuivOES" get-tex-parameter-iuiv-oes) :void
(target enum)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glSamplerParameterIivOES" sampler-parameter-iiv-oes) :void
(sampler uint)
(pname enum)
(param (:pointer int)))
(defglextfun ("glSamplerParameterIuivOES" sampler-parameter-iuiv-oes) :void
(sampler uint)
(pname enum)
(param (:pointer uint)))
(defglextfun ("glGetSamplerParameterIivOES" get-sampler-parameter-iiv-oes) :void
(sampler uint)
(pname enum)
(params (:pointer int)))
(defglextfun ("glGetSamplerParameterIuivOES" get-sampler-parameter-iuiv-oes) :void
(sampler uint)
(pname enum)
(params (:pointer uint)))
(defglextfun ("glTexBufferOES" tex-buffer-oes) :void
(target enum)
(internalformat enum)
(buffer uint))
(defglextfun ("glTexBufferRangeOES" tex-buffer-range-oes) :void
(target enum)
(internalformat enum)
(buffer uint)
(offset intptr)
(size sizeiptr))
(defglextfun ("glTexStorage3DMultisampleOES" tex-storage-3d-multisample-oes) :void
(target enum)
(samples sizei)
(internalformat enum)
(width sizei)
(height sizei)
(depth sizei)
(fixedsamplelocations boolean))
(defglextfun ("glTextureViewOES" texture-view-oes) :void
(texture uint)
(target enum)
(origtexture uint)
(internalformat enum)
(minlevel uint)
(numlevels uint)
(minlayer uint)
(numlayers uint))
(defglextfun ("glAlphaFuncQCOM" alpha-func-qcom) :void
(func enum)
(ref clampf))
| 18,382 | Common Lisp | .lisp | 631 | 26.399366 | 125 | 0.735991 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 3cf0247b772e5fe58bef5f00e43f4bb47b02adb2bac32b280b3379e6069a6d34 | 30,596 | [
154350
] |
30,597 | glu.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/glu/glu.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; glu.lisp --- Bindings to GLU routines.
;;;
;;; Copyright (c) 2006, Luis Oliveira <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; o Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may
;;; be used to endorse or promote products derived from this software
;;; without specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
;;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
;;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
;;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-glu)
;;;; Types
(defcenum (string-name %gl:enum)
(:version 100800)
:extensions)
;;; Some GLU functions return an integer error code indicating success
;;; or failure. When the error code is zero, we can use glGetError to
;;; obtain the actual error that occurred. This type adds a
;;; translation to signal GLU-ERROR conditions for these errors.
(defctype glu-result %gl:int)
(define-foreign-type glu-result ()
()
(:actual-type %gl:int)
(:simple-parser glu-result))
;;; Check GLU result codes and signal errors on zero values.
(defmethod translate-from-foreign (value (type glu-result))
(when (zerop value)
(gl:check-error))
value)
;;;; 2. Initialization
(defcfun ("gluGetString" get-string) :string
(name-keyword string-name))
#-windows
(defcfun ("gluCheckExtension" check-extension) %gl:boolean
(extension-name :string)
(extension-string :string))
;;;; 3. Mipmapping
;;; TODO: make this struct or an object
;;;; 3.1 Image Scaling
(defcfun ("gluScaleImage" %gluScaleImage) :int
(format %gl:enum)
(width-in %gl:sizei)
(height-in %gl:sizei)
(type-in %gl:enum)
(data-in :pointer)
(width-out %gl:sizei)
(height-out %gl:sizei)
(type-out %gl:enum)
(data-out :pointer))
;;(defun scale-image (format width-in height-in type-in data-in
;; or just a glu:image object, instead of all these
;; arguments.
;; width-out height-out type-out)
;; allocate data-out
;; call gluScaleImage(), check for errors
;;)
;;;; 3.2 Automatic Mipmapping
;;; TODO: gluBuild{1,3}DMipmaps; gluBuild{1,2,3}DMipmapLevels
(defcfun ("gluBuild2DMipmaps" %GluBuild2DMipmaps) :void
(target %gl:enum)
(internalformat %gl:int)
(width %gl:sizei)
(height %gl:sizei)
(format %gl:enum)
(type %gl:enum)
(data :pointer))
(defun build-2d-mipmaps (target internal-format width height format type data)
(let ((internal-size (gl::internal-format->int internal-format)))
(if (pointerp data)
(%gluBuild2dMipmaps target internal-size width height format type data)
(gl::with-pixel-array (array type data)
(%gluBuild2dMipmaps target internal-size
width height format type array)))))
;;;; 4. Matrix Manipulation
;;;; 4.1 Matrix Setup
(defcfun ("gluOrtho2D" ortho-2d) :void
(left %gl:double)
(right %gl:double)
(bottom %gl:double)
(top %gl:double))
(defcfun ("gluPerspective" perspective) :void
(fov-y %gl:double)
(aspect %gl:double)
(zNear %gl:double)
(zFar %gl:double))
(defcfun ("gluLookAt" look-at) :void
(eye-x %gl:double)
(eye-y %gl:double)
(eye-z %gl:double)
(center-x %gl:double)
(center-y %gl:double)
(center-z %gl:double)
(up-x %gl:double)
(up-y %gl:double)
(up-z %gl:double))
(defcfun ("gluPickMatrix" %gluPickMatrix) :void
(x %gl:double)
(y %gl:double)
(delta-x %gl:double)
(delta-y %gl:double)
(viewport :pointer))
(defun pick-matrix (x y delta-x delta-y viewport)
(assert (= (length viewport) 4))
(gl::with-opengl-sequence (array '%gl:int viewport)
(%gluPickMatrix x y delta-x delta-y array)))
;;;; 4.2 Coordinate Projection
(defcfun ("gluProject" %gluProject) glu-result
(obj-x %gl:double)
(obj-y %gl:double)
(obj-z %gl:double)
(modelview (:pointer %gl:double))
(projection (:pointer %gl:double))
(viewport (:pointer %gl:int))
(win-x (:pointer %gl:double))
(win-y (:pointer %gl:double))
(win-z (:pointer %gl:double)))
(defcfun ("gluUnProject" %gluUnProject) glu-result
(win-x %gl:double)
(win-y %gl:double)
(win-z %gl:double)
(modelview (:pointer %gl:double))
(projection (:pointer %gl:double))
(viewport (:pointer %gl:int))
(obj-x (:pointer %gl:double))
(obj-y (:pointer %gl:double))
(obj-z (:pointer %gl:double)))
#-cffi-features:windows
(defcfun ("gluUnProject4" %gluUnProject4) glu-result
(win-x %gl:double)
(win-y %gl:double)
(win-z %gl:double)
(clip-w %gl:double)
(modelview (:pointer %gl:double))
(projection (:pointer %gl:double))
(viewport (:pointer %gl:int))
(near %gl:double)
(far %gl:double)
(obj-x (:pointer %gl:double))
(obj-y (:pointer %gl:double))
(obj-z (:pointer %gl:double))
(obj-w (:pointer %gl:double)))
;;; Bind each symbol in NAMES to a foreign double float allocated with
;;; dynamic-extent, returing the final value of each of them as
;;; multiple values. The return value of BODY is ignored.
(defmacro with-double-floats/values (names &body body)
`(with-foreign-objects (,@(mapcar (lambda (name)
`(,name '%gl:double)) names))
,@body
(values ,@(mapcar (lambda (name)
`(mem-ref ,name '%gl:double)) names))))
;;; Rebind MODEL, PROJ, and VIEWPORT to foreign arrays of the
;;; appropriate type to contain the modelview matrix, projection
;;; matrix, and viewport for calls to GLU projection functions.
(defmacro with-projection-arrays ((model proj viewport) &body body)
`(progn
(assert (= (length ,model) 16))
(assert (= (length ,proj) 16))
(assert (= (length ,viewport) 4))
(gl::with-opengl-arrays ((,model '%gl:double ,model)
(,proj '%gl:double ,proj)
(,viewport '%gl:int ,viewport))
,@body)))
;;; Map object coordinates to window coordinates. The MODELVIEW
;;; matrix, PROJECTION matrix, and VIEWPORT dimensions will be queried
;;; from the OpenGL state if not supplied. Returns the window X, Y,
;;; and Z as multiple values.
(defun project (obj-x obj-y obj-z &key
(modelview (gl:get-double :modelview-matrix))
(projection (gl:get-double :projection-matrix))
(viewport (gl:get-integer :viewport)))
(with-projection-arrays (modelview projection viewport)
(with-double-floats/values (x y z)
(%gluProject obj-x obj-y obj-z modelview projection viewport x y z))))
;;; Map window coordinates to object coordinates. The MODELVIEW
;;; matrix, PROJECTION matrix, and VIEWPORT dimensions will be queried
;;; from the OpenGL state if not supplied. Returns the object X, Y,
;;; and Z as multiple values.
(defun un-project (win-x win-y win-z &key
(modelview (gl:get-double :modelview-matrix))
(projection (gl:get-double :projection-matrix))
(viewport (gl:get-integer :viewport)))
(with-projection-arrays (modelview projection viewport)
(with-double-floats/values (x y z)
(%gluUnProject win-x win-y win-z modelview projection viewport x y z))))
;;; Map window and clip coordinates to object coordinates. The
;;; MODELVIEW matrix, PROJECTION matrix, and VIEWPORT dimensions will
;;; be queried from the OpenGL state if not supplied. Returns the
;;; object X, Y, Z, and W as multiple values.
(defun un-project4 (win-x win-y win-z clip-w &key
(near 0.0d0)
(far 1.0d0)
(modelview (gl:get-double :modelview-matrix))
(projection (gl:get-double :projection-matrix))
(viewport (gl:get-integer :viewport)))
(with-projection-arrays (modelview projection viewport)
(with-double-floats/values (x y z w)
(%gluUnProject4 win-x win-y win-z clip-w modelview projection
viewport near far x y z w))))
;;;; 5. Polygon Tessellation
;;;; 5.1 The Tessellation Object
(defctype tess-pointer :pointer)
(defcfun ("gluNewTess" glu-new-tess) tess-pointer)
(defcfun ("gluDeleteTess" glu-delete-tess) :void
(tess-obj tess-pointer))
;;;; 5.2 Polygon Definition
(defcfun ("gluTessBeginPolygon" glu-tess-begin-polygon) :void
(tess tess-pointer)
(polygon-data :pointer))
(defcfun ("gluTessBeginContour" glu-tess-begin-contour) :void
(tess tess-pointer))
(defcfun ("gluTessVertex" glu-tess-vertex) :void
(tess tess-pointer)
(coords :pointer) ; GLdouble coords[3]
(vertex-data :pointer))
(defcfun ("gluTessEndContour" glu-tess-end-contour) :void
(tess tess-pointer))
(defcfun ("gluTessEndPolygon" glu-tess-end-polygon) :void
(tess tess-pointer))
;;;; 5.3 Callbacks
(defcenum (tessellation-type %gl:enum)
(:begin 100100)
:vertex
:end
:error
:edge-flag
:combine
:begin-data
:vertex-data
:end-data
:error-data
:edge-flag-data
:combine-data)
(defcfun ("gluTessCallback" glu-tess-callback) :void
(tess tess-pointer) (type tessellation-type) (callback :pointer))
;;;; 5.4 Control Over Tessellation
(defcenum (tess-property %gl:enum)
(:winding-rule 100140)
:boundary-only
:tolerance)
(defcenum (tess-winding-rule %gl:double)
(:odd 100130)
:nonzero
:positive
:negative
:abs-geq-two)
(defcfun ("gluTessProperty" %glu-tess-property) :void
(tess tess-pointer)
(which tess-property)
(value %gl:double))
(defun glu-tess-property (tess which value)
(let ((cffi-value
(ecase which
(:winding-rule (cffi:foreign-enum-value 'tess-winding-rule value))
(:boundary-only (cffi:foreign-enum-value '%gl:boolean value))
(:tolerance value))))
(%glu-tess-property tess which cffi-value)))
;;;; 5.7 Backwards Compatibility
;;; We don't bother defining gluBeginPolygon(), gluNextContour() and
;;; gluEndPolygon().
;;;; 6. Quadrics
;;;; 6.1 The Quadrics Object
;;; TODO: make a clos class for these too
(defctype quadric-obj :pointer)
(defcfun ("gluNewQuadric" new-quadric) quadric-obj)
(defcfun ("gluDeleteQuadric" delete-quadric) :void
(quadric-object quadric-obj))
;;;; 6.2 Callbacks
;;; TODO
;;(defcfun ("gluQuadricCallback" quadric-callback) :void
;; (quadric-object quadric-obj)
;; ...)
;;;; 6.3 Rendering Styles
(defcfun ("gluQuadricTexture" quadric-texture) :void
(quadric-object quadric-obj)
(texture-coords %gl:boolean))
(defcenum glu-orientation
(:outside #x186B4)
(:inside #x186B5))
(defcfun ("gluQuadricOrientation" quadric-orientation) :void
(quadric-object quadric-obj)
(orientation glu-orientation))
(defcenum glu-normals
(:smooth #x186A0)
(:flat #x186A1)
(:none #x186A2))
(defcfun ("gluQuadricNormals" quadric-normals) :void
(quadric-object quadric-obj)
(normals glu-normals))
(defcenum draw-styles
(:point #x186AA)
:line
:fill
:silhouette)
(defcfun ("gluQuadricDrawStyle" quadric-draw-style) :void
(quadric-object quadric-obj)
(draw-style draw-styles))
;;;; 6.4 Quadrics Primitives
(defcfun ("gluSphere" sphere) :void
(quadric-object quadric-obj)
(radius %gl:double)
(slices %gl:int)
(stacks %gl:int))
(defcfun ("gluCylinder" cylinder) :void
(quadric-object quadric-obj)
(base-radius %gl:double)
(top-radius %gl:double)
(height %gl:double)
(slices %gl:int)
(stacks %gl:int))
(defcfun ("gluDisk" disk) :void
(quadric-object quadric-obj)
(inner-radius %gl:double)
(outer-radius %gl:double)
(slices %gl:int)
(loops %gl:int))
(defcfun ("gluPartialDisk" partial-disk) :void
(quadric-object quadric-obj)
(inner-radius %gl:double)
(outer-radius %gl:double)
(slices %gl:int)
(loops %gl:int)
(start-angle %gl:double)
(sweep-angle %gl:double))
;;;; 7. NURBS
;;;; 7.1 The NURBS Object
(defctype nurbs-obj :pointer)
(defcfun ("gluNewNurbsRenderer" new-nurbs-renderer) nurbs-obj)
(defcfun ("gluDeleteNurbsRenderer" delete-nurbs-renderer) :void
(nurbs-object nurbs-obj))
;;;; 7.2 Callbacks
;;; TODO
;;(defcfun ("gluNurbsCallback" nurbs-callback) :void
;; )
;;;; 7.3 NURBS Curves
(defcfun ("gluBeginCurve" begin-curve) :void
(nurbs-object nurbs-obj))
;; (defcfun ("gluNurbsCurve" nurbs-curve) :void
;; (nurbs-object nurbs-obj)
;; (n-knots %gl:int)
;; ...)
;;; 7.4 NURBS Surfaces
(defcfun ("gluBeginSurface" begin-surface) :void
(nurbs-object nurbs-obj))
;;(defcfun ("gluNurbsSurface" nurbs-surface) :void
;; ...)
(defcfun ("gluEndSurface" end-surface) :void
(nurbs-object nurbs-obj))
;;;; 7.5 Trimming
(defcfun ("gluBeginTrim" begin-trim) :void
(nurbs-object nurbs-obj))
;;(defcfun ("gluPwlCurve" pwl-curve) :void
;; ...)
;;(defcfun ("gluNurbsCurve" nurbs-curve) :void
;; ...)
(defcfun ("gluEndTrim" end-trim) :void
(nurbs-object nurbs-obj))
;;;; 7.6 NURBS Properties
;;(defcfun ("gluNurbsProperty" nurbs-property) :void
;; ...)
;;(defcfun ("gluLoadSamplingMatrices" load-sampling-matrices) :void
;; ...)
;;(defcfun ("gluGetNurbsProperty" get-nurbs-property) :void
;; (nurbs-object nurbs-obj)
;; ...)
;;;; 8. Errors
;; maybe this could be a subclass of opengl-error?
(define-condition glu-error (simple-error)
((error-message :initarg :message))
(:report (lambda (c s)
(write-string (slot-value c 'error-message) s))))
(defcenum (error-codes %gl:enum)
(:invalid-enum 100900)
:invalid-value
:out-of-memory
:incompatible-gl-version
:invalid-operation
;;Tesselation errors
(:tess-missing-begin-polygon 100151)
(:tess-missing-begin-contour 100152)
(:tess-missing-end-polygon 100153)
(:tess-missing-end-contour 100154)
(:tess-coord-too-large 100155)
(:tess-need-combine-callback 100156)
;; plus NURBS, Quadrics
;; probably not necessary
)
(defcfun ("gluErrorString" error-string) :string
(error-code %gl:enum))
| 14,916 | Common Lisp | .lisp | 409 | 32.748166 | 79 | 0.694323 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | d7bc2872800e9f96ae183ba7f07431456a78bbc8b57639c54de723644ff0aaf8 | 30,597 | [
-1
] |
30,598 | package.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/glu/package.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; package.lisp --- Package definition for cl-glu.
;;;
;;; Copyright (c) 2006, Luis Oliveira <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; o Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may
;;; be used to endorse or promote products derived from this software
;;; without specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
;;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
;;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
;;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-user)
(defpackage #:cl-glu
(:nicknames #:glu)
(:use #:cl #:cffi)
(:export
;;# Functions
#:quadric-texture
#:quadric-orientation
#:quadric-normals
#:quadric-draw-style
#:new-quadric
#:delete-quadric
#:quadric-normals
#:sphere
#:cylinder
#:disk
#:partial-disk
#:build-2d-mipmaps
#:get-string
#:check-extension
#:scale-image
#:ortho-2d
#:perspective
#:look-at
#:pick-matrix
#:project
#:un-project
#:un-project4
;; Tessellation
#:tessellator
#:tess-delete
;; Tessellator methods
#:tess-begin-polygon
#:tess-begin-contour
#:tess-vertex
#:tess-end-contour
#:tess-end-polygon
#:tess-begin
#:tess-error
#:tess-end
#:tess-property
;; Tessellator callbacks
#:begin-data-callback
#:edge-flag-data-callback
#:end-data-callback
#:vertex-data-callback
#:error-data-callback
#:combine-data-callback
;; Tessellator macros
#:with-tess-polygon
#:with-tess-contour))
| 2,739 | Common Lisp | .lisp | 82 | 30.621951 | 75 | 0.722411 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | e0e4a8a39c0969cf0b3d89e67dac09526a96ef13d754bcef363573d67561cd0d | 30,598 | [
-1
] |
30,600 | interface.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/glu/interface.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; interface.lisp --- CLOS interface to GLU routines.
;;;
;;; Copyright (c) 2010, Boian Tzonev <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; o Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may
;;; be used to endorse or promote products derived from this software
;;; without specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
;;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
;;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
;;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-glu)
;;;; Polygon Tessellation
(defparameter *tessellators* (make-hash-table))
(defparameter *tess-callbacks* '())
(defstruct tess-callback name generic-function callback callback-type arg-count)
(defmacro init-tessellation-callback (name callback-type arg-count)
(let ((tessellation-callback (gl::symbolicate "%" name))
(tessellation-name (intern (symbol-name name) '#:keyword)))
`(push (make-tess-callback :name ,tessellation-name :generic-function #',name
:callback ',tessellation-callback :callback-type ,callback-type
:arg-count ,arg-count)
*tess-callbacks*)))
(defmacro init-tessellation-callbacks (&body callback-specs)
`(progn
(setq *tess-callbacks* '())
,@(loop for (name callback-type args) in callback-specs
collect `(init-tessellation-callback ,name ,callback-type ,args))))
(defmacro with-tess-polygon ((tess-obj &optional (polygon-data nil)) &body body)
`(progn (tess-begin-polygon ,tess-obj ,polygon-data)
(unwind-protect (progn ,@body)
(tess-end-polygon ,tess-obj))))
(defmacro with-tess-contour (tess-obj &body body)
`(progn (tess-begin-contour ,tess-obj)
(unwind-protect (progn ,@body)
(tess-end-contour ,tess-obj))))
(defclass tessellator ()
((glu-tessellator :reader glu-tessellator)
(id :reader id)
(data-to-free :accessor data :initform '())
(vertex-data :accessor vertex-data :initform (make-hash-table))
(polygon-data :accessor polygon-data :initform (make-hash-table))))
;;methods
(defgeneric tess-delete (tessellator))
(defgeneric tess-begin-polygon (tessellator &optional polygon-data))
(defgeneric tess-begin-contour (tessellator))
(defgeneric tess-vertex (tessellator coords &optional vertex-data))
(defgeneric tess-end-contour (tessellator))
(defgeneric tess-end-polygon (tessellator))
(defgeneric tess-property (tessellator which value))
;;callbacks
(defgeneric begin-data-callback (tessellator type polygon-data))
(defgeneric edge-flag-data-callback (tessellator flag polygon-data))
(defgeneric end-data-callback (tessellator polygon-data))
(defgeneric vertex-data-callback (tessellator vertex-data polygon-data))
(defgeneric error-data-callback (tessellator error-number polygon-data))
(defgeneric combine-data-callback (tessellator coords vertex-data weight polygon-data))
(defmethod initialize-instance :after ((obj tessellator) &key)
(let ((tess (glu-new-tess)))
(if (null-pointer-p tess)
(error "Error creating tessellator object")
(progn
(let ((tessellator-id (pointer-address tess)))
(setf (slot-value obj 'glu-tessellator) tess)
(setf (slot-value obj 'id) tessellator-id)
;;put the tessellator object in the table of known tessellators
;;key of the tessellator is the pointer address of its corresponding glu-tessellator
(when (nth-value 1 (gethash tessellator-id *tessellators*))
(warn "A tessellator with this id is already registred"))
(setf (gethash tessellator-id *tessellators*) obj))
(register-callbacks obj)))))
(defmethod tess-delete ((tess tessellator))
(remhash (id tess) *tessellators*)
(free-tess-data tess)
(glu-delete-tess (glu-tessellator tess)))
(defmethod tess-begin-polygon ((tess tessellator) &optional (polygon-data nil))
(let* ((polygon-data-id
(or (loop for value being the hash-values of (polygon-data tess)
using (hash-key key)
when (eq value polygon-data)
return key)
(hash-table-count (polygon-data tess))))
(foreign-key (foreign-alloc :uint64 :initial-contents (list (id tess) polygon-data-id))))
(setf (gethash polygon-data-id (polygon-data tess)) polygon-data)
(save-data-to-free foreign-key tess)
(glu-tess-begin-polygon (glu-tessellator tess) foreign-key)))
(defmethod tess-begin-contour ((tess tessellator))
(glu-tess-begin-contour (glu-tessellator tess)))
(defmethod tess-vertex ((tess tessellator) coords &optional vertex-data)
(let* ((coords-data (coords-to-pointer coords))
(vertex-data-pointer (vertex-data-to-pointer tess vertex-data)))
(save-data-to-free coords-data tess)
(glu-tess-vertex (glu-tessellator tess) coords-data vertex-data-pointer)))
(defmethod tess-end-contour ((tess tessellator))
(glu-tess-end-contour (glu-tessellator tess)))
(defmethod tess-end-polygon ((tess tessellator))
(glu-tess-end-polygon (glu-tessellator tess))
(free-tess-data tess))
(defmethod tess-property ((tess tessellator) which value)
(glu-tess-property (glu-tessellator tess) which value))
;;;; Callbacks
(defmethod begin-data-callback ((tess tessellator) which polygon-data)
(declare (ignore polygon-data))
(gl:begin which))
(defmethod error-data-callback ((tess tessellator) error-code polygon-data)
(declare (ignore polygon-data))
(free-tess-data tess)
(error "Tessellation error: ~A~%" (error-string error-code)))
(defmethod end-data-callback ((tess tessellator) polygon-data)
(declare (ignore polygon-data))
(gl:end))
(defcallback %begin-data-callback :void ((type :unsigned-int) (polygon-data-pointer :pointer))
(let* ((tess (get-tessellator polygon-data-pointer))
(polygon-data (get-polygon-data tess polygon-data-pointer)))
(begin-data-callback tess type polygon-data)))
(defcallback %edge-flag-data-callback :void ((flag %gl:boolean) (polygon-data-pointer :pointer))
(let* ((tess (get-tessellator polygon-data-pointer))
(polygon-data (get-polygon-data tess polygon-data-pointer)))
(edge-flag-data-callback tess flag polygon-data)))
(defcallback %end-data-callback :void ((polygon-data-pointer :pointer))
(let* ((tess (get-tessellator polygon-data-pointer))
(polygon-data (get-polygon-data tess polygon-data-pointer)))
(end-data-callback tess polygon-data)))
(defcallback %vertex-data-callback :void ((vertex-data-pointer :pointer) (polygon-data-pointer :pointer))
(let* ((tess (get-tessellator polygon-data-pointer))
(polygon-data (get-polygon-data tess polygon-data-pointer))
(vertex-data (get-vertex-data tess vertex-data-pointer)))
(vertex-data-callback tess vertex-data polygon-data)))
(defcallback %error-data-callback :void ((error-number :unsigned-int) (polygon-data-pointer :pointer))
(let* ((tess (get-tessellator polygon-data-pointer))
(polygon-data (get-polygon-data tess polygon-data-pointer)))
(error-data-callback tess error-number polygon-data)))
(defcallback %combine-data-callback :void ((coords (:pointer %gl:double)) (vertex-data-pointer :pointer) (weight (:pointer %gl:float)) (out-data :pointer) (polygon-data-pointer :pointer))
(let* ((tess (get-tessellator polygon-data-pointer))
(polygon-data (get-polygon-data tess polygon-data-pointer))
(coords-array (gl::make-gl-array-from-pointer coords '%gl:double 3))
(vertex-data-array (->combine-vertex-data-array tess vertex-data-pointer))
(weight-array (gl::make-gl-array-from-pointer weight '%gl:float 4))
(combined-result (combine-data-callback tess coords-array vertex-data-array weight-array polygon-data))
(combined-result-pointer (vertex-data-to-pointer tess combined-result)))
(setf (cffi:mem-ref out-data :pointer) combined-result-pointer)))
;;;; Functions
(defun register-callbacks (tess)
"When creating an object instance check what methods it specializes and regiser appropriate callbacks for each of them."
(loop for tess-callback in *tess-callbacks*
when (compute-applicable-methods
(tess-callback-generic-function tess-callback)
(cons tess (loop repeat (tess-callback-arg-count tess-callback) collect t)))
do (glu-tess-callback (glu-tessellator tess)
(tess-callback-callback-type tess-callback)
(get-callback (tess-callback-callback tess-callback)))))
(defun save-data-to-free (data-to-free tess)
(when (and (pointerp data-to-free)
(not (null-pointer-p data-to-free)))
(push data-to-free (data tess))))
(defun free-tess-data (tess)
"Free data allocated with tess-vertex and tess-combine-callback"
(loop for pointer in (data tess)
when (and (pointerp pointer)
(not (null-pointer-p pointer)))
do (foreign-free pointer))
(setf (data tess) nil)
(clrhash (vertex-data tess))
(clrhash (polygon-data tess)))
(defun vertex-data-to-pointer (tess vertex-data)
(let* ((vertex-data-id
(or (loop for value being the hash-values of (vertex-data tess)
using (hash-key key)
when (eq value vertex-data)
return key)
(hash-table-count (vertex-data tess))))
(vertex-data-pointer (foreign-alloc :uint64 :initial-element vertex-data-id)))
(setf (gethash vertex-data-id (vertex-data tess)) vertex-data)
(save-data-to-free vertex-data-pointer tess)
vertex-data-pointer))
(defun ->combine-vertex-data-array (tess vertex-data)
(let ((result (make-array 4)))
(loop for i from 0 below 4
do (setf (aref result i)
(get-vertex-data tess (mem-aref vertex-data ':pointer i))))
result))
(defun coords-to-pointer (coords)
(etypecase coords
(sequence
(let* ((coords-length (length coords))
(pointer (foreign-alloc '%gl:double :count coords-length)))
(etypecase coords
(list
(loop for elt in coords
for i from 0
do (setf (mem-aref pointer '%gl:double i)
(float elt))))
(vector
(loop for elt across coords
for i from 0
do (setf (mem-aref pointer '%gl:double i)
(float elt)))))
pointer))
(gl:gl-array
(if (not (equal (gl::gl-array-type coords) '%gl:double))
(error "Coordinates must have type gl:double")
(gl::gl-array-pointer coords)))))
(defun get-tessellator (polygon-data-pointer)
(unless (null-pointer-p polygon-data-pointer)
(let ((tessellator-id (mem-aref polygon-data-pointer :uint64 0)))
(or
(gethash tessellator-id *tessellators*)
(error "Unable to get tessellator with id ~a" tessellator-id)))))
(defun get-polygon-data (tess polygon-data-pointer)
(unless (null-pointer-p polygon-data-pointer)
(let ((polygon-data-id (mem-aref polygon-data-pointer :uint64 1)))
(gethash polygon-data-id (polygon-data tess)))))
(defun get-vertex-data (tess vertex-data-pointer)
(unless (null-pointer-p vertex-data-pointer)
(let ((vertex-data-id (mem-ref vertex-data-pointer :uint64)))
(gethash vertex-data-id (vertex-data tess)))))
;;Initialize information about defined callbacks. The actual definition is handled separately.
(init-tessellation-callbacks
(begin-data-callback :begin-data 2)
(edge-flag-data-callback :edge-flag-data 2)
(end-data-callback :end-data 1)
(vertex-data-callback :vertex-data 2)
(error-data-callback :error-data 2)
(combine-data-callback :combine-data 4)) | 12,913 | Common Lisp | .lisp | 244 | 47.086066 | 187 | 0.701443 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | bcb34694f8b2b26ea91b7d1c3c892a8948b13415b878df28e1768f3160676812 | 30,600 | [
-1
] |
30,601 | package.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/glut/package.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; package.lisp --- cl-glut package definition.
;;;
;;; Copyright (c) 2006, Luis Oliveira <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; o Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may
;;; be used to endorse or promote products derived from this software
;;; without specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
;;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
;;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
;;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-user)
(defpackage #:cl-glut
(:nicknames #:glut)
(:use #:cl #:cffi)
(:import-from #:alexandria #:deletef #:emptyp)
;; interface.lisp stuff
(:shadow #:special #:close)
(:export
;; events / GFs
#:idle
#:keyboard
#:special
#:reshape
#:visibility
#:display
#:mouse
#:motion
#:passive-motion
#:entry
#:menu-state
#:spaceball-motion
#:spaceball-rotate
#:spaceball-button
#:button-box
#:dials
#:tablet-motion
#:tablet-button
#:menu-status
#:overlay-display
#:window-status
#:keyboard-up
#:special-up
#:joystick
#:mouse-wheel
#:close
#:wm-close
#:menu-destroy
#:enable-event
#:disable-event
#:display-window
#:tick
;; classes
#:base-window
#:window
#:sub-window
;; accessors
#:title
#:name
#:id
#:events
#:parent
#:pos-x
#:pos-y
#:width
#:height
#:mode
#:game-mode
;; other functions and macros
#:display-window
#:find-window
#:with-window
#:destroy-current-window
#:schedule-timer
#:enable-tick
#:disable-tick
;; specials
#:*run-main-loop-after-display*)
;; everything else
(:shadow #:get)
(:export
;; Enums and Bitfields
#:cursor
#:device-get-param
#:display-mode
#:entry-state
#:color-component
#:game-mode-param
#:get-param
#:layer-get-param
#:layer-type
#:menu-state
#:modifiers
#:video-resize-param
#:mouse-button
#:mouse-button-state
#:key-repeat-mode
#:rendering-context
#:rendering-context-options
#:joystick-buttons
#:special-keys
#:visibility-state
#:options ; freeglut ext
#:window-close-behaviour ; freeglut ext
#:window-status
;; initialization api
#:init
#:init-display-mode
#:init-display-string
#:init-window-size
#:init-window-position
;; event loop api
#:main-loop
#:main-loop-event
#:leave-main-loop
;; window api
#:create-window
#:create-sub-window
#:destroy-window
#:set-window
#:get-window
#:set-window-title
#:set-icon-title
#:reshape-window
#:position-window
#:show-window
#:hide-window
#:iconify-window
#:push-window
#:pop-window
#:full-screen
#:post-window-redisplay
#:post-redisplay
#:swap-buffers
#:warp-pointer
#:set-cursor
;; overlay management api
#:establish-overlay
#:remove-overlay
#:use-layer
#:post-overlay-redisplay
#:post-window-overlay-redisplay
#:show-overlay
#:hide-overlay
;; menu management api
#:create-menu
#:destroy-menu
#:get-menu
#:set-menu
#:add-menu-entry
#:add-sub-menu
#:change-to-menu-entry
#:change-to-sub-menu
#:remove-menu-item
#:attach-menu
#:detach-menu
;; window callback api
#:timer-func
#:idle-func
#:keyboard-func
#:special-func
#:reshape-func
#:visibility-func
#:display-func
#:mouse-func
#:motion-func
#:passive-motion-func
#:entry-func
#:menu-state-func
#:spaceball-motion-func
#:spaceball-rotate-func
#:spaceball-button-func
#:button-box-func
#:dials-func
#:tablet-motion-func
#:tablet-button-func
#:dials-func
#:menu-status-func
#:overlay-display-func
#:window-status-func
#:keyboard-up-func
#:special-up-func
#:joystick-func
#:mouse-wheel-func ; freeglut ext
#:close-func ; freeglut ext
#:wm-close-func ; freeglut ext
#:menu-destroy-func ; freeglut ext
;; state api
#:set-option ; freeglut ext
#:set-display-mode
#:set-action-on-window-close
#:set-rendering-context
#:set-direct-rendering
#:get
#:getp
#:get-window-cursor
#:get-init-display-mode
#:device-get
#:device-getp
#:layer-get
#:layer-getp
#:get-layer-in-use
#:get-modifiers
#:get-modifier-values
#:extension-supported-p
#:get-proc-address
;; font rendering api
#:+stroke-roman+
#:+stroke-mono-roman+
#:+bitmap-9-by-15+
#:+bitmap-8-by-13+
#:+bitmap-times-roman-10+
#:+bitmap-times-roman-24+
#:+bitmap-helvetica-10+
#:+bitmap-helvetica-12+
#:+bitmap-helvetica-18+
#:bitmap-character
#:bitmap-width
#:stroke-character
#:stroke-width
#:bitmap-length ; freeglut ext?
#:stroke-length ; freeglut ext?
#:bitmap-height ; freeglut ext
#:stroke-height ; freeglut ext
#:bitmap-string ; freeglut ext
#:stroke-string ; freeglut ext
;; geometry api
#:wire-cube
#:solid-cube
#:wire-sphere
#:solid-sphere
#:wire-cone
#:solid-cone
#:wire-torus
#:solid-torus
#:wire-dodecahedron
#:solid-dodecahedron
#:wire-octahedron
#:solid-octahedron
#:wire-tetrahedron
#:solid-tetrahedron
#:wire-icosahedron
#:solid-icosahedron
#:wire-teapot
#:solid-teapot
#:wire-rhombic-dodecahedron ; freeglut ext
#:solid-rhombic-dodecahedron ; freeglut ext
#:wire-sierpinski-sponge ; freeglut ext
#:solid-sierpinski-sponge ; freeglut ext
#:wire-cylinder ; freeglut ext
#:solid-cylinder ; freeglut ext
;; game mode api
#:game-mode-string
#:enter-game-mode
#:leave-game-mode
#:game-mode-get
#:game-mode-getp
;; video resize api (unimplemented by freeglut)
#:video-resize-get
#:setup-video-resizing
#:stop-video-resizing
#:video-resize
#:video-pan
;; misc
#:set-color
#:get-color
#:copy-colormap
#:ignore-key-repeat
#:set-key-repeat
#:force-joystick-func
#:report-errors
))
| 7,519 | Common Lisp | .lisp | 292 | 22.071918 | 75 | 0.648413 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | d26c5501405cc7f51bc19ba294bfd5d739186d8ac3f54c9c84f876ede136bf98 | 30,601 | [
-1
] |
30,603 | callbacks.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/glut/callbacks.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; callbacks.lisp --- GLUT Callback Registration API.
;;;
;;; Copyright (c) 2006, Luis Oliveira <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; o Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may
;;; be used to endorse or promote products derived from this software
;;; without specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
;;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
;;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
;;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-glut)
;;; Low-level functions (exported nevertheless)
(defcfun ("glutTimerFunc" timer-func) :void
(millis :unsigned-int)
(callback-pointer :pointer) ; void (*func)(int value)
(value :int))
(defcfun ("glutIdleFunc" idle-func) :void
;; void (*func)(void)
(callback-pointer :pointer))
(defcfun ("glutKeyboardFunc" keyboard-func) :void
;; void (*func)(unsigned char int, int x, int y)
(callback-pointer :pointer))
(defcfun ("glutSpecialFunc" special-func) :void
;; void (*func)(int key, int x, int y)
(callback-pointer :pointer))
(defcfun ("glutReshapeFunc" reshape-func) :void
;; void (*func)(int width, int height)
(callback-pointer :pointer))
(defcfun ("glutVisibilityFunc" visibility-func) :void
;; void (*func)(int state)
(callback-pointer :pointer))
(defcfun ("glutDisplayFunc" display-func) :void
;; void (*func)(void)
(callback-pointer :pointer))
(defcfun ("glutMouseFunc" mouse-func) :void
;; void (*func)(int button, int state, int x, int y)
(callback-pointer :pointer))
(defcfun ("glutMotionFunc" motion-func) :void
;; void (*func)(int x, int y)
(callback-pointer :pointer))
(defcfun ("glutPassiveMotionFunc" passive-motion-func) :void
;; void (*func)(int x, int y)
(callback-pointer :pointer))
(defcfun ("glutEntryFunc" entry-func) :void
;; void (*func)(int state)
(callback-pointer :pointer))
(defcfun ("glutMenuStateFunc" menu-state-func) :void
;; void (*func)(int state)
(callback-pointer :pointer))
(defcfun ("glutSpaceballMotionFunc" spaceball-motion-func) :void
;; void (*func)(int x, int y, int z)
(callback-pointer :pointer))
(defcfun ("glutSpaceballRotateFunc" spaceball-rotate-func) :void
;; void (*func)(int x, int y, int z)
(callback-pointer :pointer))
(defcfun ("glutSpaceballButtonFunc" spaceball-button-func) :void
;; void (*func)(int button, int state)
(callback-pointer :pointer))
(defcfun ("glutButtonBoxFunc" button-box-func) :void
;; void (*func)(int button, int state)
(callback-pointer :pointer))
(defcfun ("glutDialsFunc" dials-func) :void
;; void (*func)(int dial, int value)
(callback-pointer :pointer))
(defcfun ("glutTabletMotionFunc" tablet-motion-func) :void
;; void (*func)(int x, int y)
(callback-pointer :pointer))
(defcfun ("glutTabletButtonFunc" tablet-button-func) :void
;; void (*func)(int button, int state, int x, int y)
(callback-pointer :pointer))
(defcfun ("glutMenuStatusFunc" menu-status-func) :void
;; void (*func)(int status, int x, int y)
(callback-pointer :pointer))
(defcfun ("glutOverlayDisplayFunc" overlay-display-func) :void
;; void (*func)(void)
(callback-pointer :pointer))
(defcfun ("glutWindowStatusFunc" window-status-func) :void
;; void (*func)(int state)
(callback-pointer :pointer))
(defcfun ("glutKeyboardUpFunc" keyboard-up-func) :void
;; void (*func)(unsigned char key, int x, int y)
(callback-pointer :pointer))
(defcfun ("glutSpecialUpFunc" special-up-func) :void
;; void (*func)(int key, int x, int y)
(callback-pointer :pointer))
(defcfun ("glutJoystickFunc" joystick-func) :void
;; void (*func)(unsigned int buttonMask, int x, int y, int z)
(callback-pointer :pointer)
(poll-interval :int))
;; freeglut ext
#-darwin
(defcfun ("glutMouseWheelFunc" mouse-wheel-func) :void
;; void (*func)(int button, int pressed, int x, int y)
(callback-pointer :pointer))
;; freeglut/GLUT.framework ext
(defcfun (#-darwin "glutCloseFunc"
#+darwin "glutWMCloseFunc" close-func) :void
;; void (*func)(void)
(callback-pointer :pointer))
;; freeglut ext
(defcfun ("glutWMCloseFunc" wm-close-func) :void
;; void (*func)(void)
(callback-pointer :pointer))
;; freeglut ext
#-darwin
(defcfun ("glutMenuDestroyFunc" menu-destroy-func) :void
;; void (*func)(void)
(callback-pointer :pointer))
;;;; Types used for callbacks.
(defcenum entry-state
:left
:entered)
(defbitfield (joystick-buttons :unsigned-int)
(:joystick-button-a 1)
(:joystick-button-b 2)
(:joystick-button-c 4)
(:joystick-button-d 8))
(defcenum menu-state
:menu-not-in-use
:menu-in-use)
(defbitfield modifiers
(:active-shift 1)
(:active-ctrl 2)
(:active-alt 4))
(defcenum mouse-button
:left-button
:middle-button
:right-button
:wheel-up
:wheel-down
:button4
:button5
:button6
:button7
:button8
:button9
:button10
:button11
:button12
:button13
:button14
:button15
:button16
:button17
:button18
:button19
:button20
:button21
:button22
:button23
:button24
:button25
:button26
:button27
:button28
:button29
:button30
:button31
:button32)
(defcenum mouse-button-state
(:wheel-down -1)
:down
:up)
(defcenum special-keys
;; Function keys.
(:key-f1 1)
:key-f2
:key-f3
:key-f4
:key-f5
:key-f6
:key-f7
:key-f8
:key-f9
:key-f10
:key-f11
:key-f12
;; Directional keys.
(:key-left 100)
:key-up
:key-right
:key-down
:key-page-up
:key-page-down
:key-home
:key-end
:key-insert
;; Modifiers keys
(:key-left-shift 112)
:key-right-shift
:key-left-ctrl
:key-right-ctrl
:key-left-alt
:key-right-alt)
(defcenum visibility-state
:not-visible
:visible)
(defcenum window-status
:hidden
:fully-retained
:partially-retained
:fully-covered)
| 7,016 | Common Lisp | .lisp | 223 | 28.932735 | 75 | 0.722008 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 77a7121b07a73f06ca5f5592f00d3af28d8e19ca202429c9b1848767f03e6cb2 | 30,603 | [
-1
] |
30,605 | library.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/glut/library.lisp | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; library.lisp --- GLUT foreign library definition.
;;;
;;; Copyright (c) 2006, Luis Oliveira <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; o Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may
;;; be used to endorse or promote products derived from this software
;;; without specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
;;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
;;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
;;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package :cl-glut)
(define-foreign-library glut
(:darwin (:framework "GLUT"))
(:windows (:or "freeglut.dll" "libglut.dll" "libglut-0.dll" "libfreeglut.dll"))
(:unix (:or "libglut.so" "libglut.so.3")))
(use-foreign-library glut)
| 1,971 | Common Lisp | .lisp | 37 | 52.027027 | 81 | 0.749871 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 73a396078140313a6d1a3c6db43a4c148c878306330a829727b510200be72ca6 | 30,605 | [
-1
] |
30,606 | main.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/glut/main.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; main.lisp --- GLUT Event Processing API.
;;;
;;; Copyright (c) 2006, Luis Oliveira <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; o Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may
;;; be used to endorse or promote products derived from this software
;;; without specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
;;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
;;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
;;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-glut)
(defcfun ("glutMainLoop" %glutMainLoop) :void)
#+darwin
(defcfun ("glutCheckLoop" check-loop) :void)
#-darwin
(defun main-loop ()
(without-fp-traps
(%glutMainLoop))
(init))
#+darwin
(let ((darwin-run-main-loop-p t))
(defun main-loop ()
(flet ((%loop ()
(without-fp-traps
(loop while darwin-run-main-loop-p do (check-loop)))
(init)
(setf darwin-run-main-loop-p t)))
(%loop)))
(defun leave-main-loop ()
(setf darwin-run-main-loop-p nil)))
#-darwin (defcfun ("glutMainLoopEvent" main-loop-event) :void)
#-darwin (defcfun ("glutLeaveMainLoop" leave-main-loop) :void)
| 2,393 | Common Lisp | .lisp | 53 | 42.528302 | 75 | 0.722793 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 12323a1686f1e99205fdd1a74c8034cbc0253ed1c88ffa73ff0fb6aa36efe906 | 30,606 | [
-1
] |
30,607 | fonts.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/glut/fonts.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; fonts.lisp --- GLUT Font Rendering API.
;;;
;;; Copyright (c) 2006, Luis Oliveira <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; o Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may
;;; be used to endorse or promote products derived from this software
;;; without specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
;;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
;;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
;;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-glut)
;;; Erm, should we want CLISP cross-platform fasl portability I think
;;; those conditionals should be changed to calls to FEATURE-P.
;;; Ugh, freeglut's font macros seem to expand into a pointer to
;;; to a couple of global variables that point somewhere else.
;;; Unless it's windows, in which case it's a sort of enum-as-pointer
;;; thing. "So here it goes:"
(defvar +stroke-roman+)
(defvar +stroke-mono-roman+)
(defvar +bitmap-9-by-15+)
(defvar +bitmap-8-by-13+)
(defvar +bitmap-times-roman-10+)
(defvar +bitmap-times-roman-24+)
(defvar +bitmap-helvetica-10+)
(defvar +bitmap-helvetica-12+)
(defvar +bitmap-helvetica-18+)
;; we need to be able to reinitialize the pointers after loading a
;; saved core, so move it to a separate function...
(defun init-font-pointers ()
(setf +stroke-roman+
#+windows (make-pointer 0)
#-windows (foreign-symbol-pointer "glutStrokeRoman"))
(setf +stroke-mono-roman+
#+windows (make-pointer 1)
#-windows (foreign-symbol-pointer "glutStrokeMonoRoman"))
(setf +bitmap-9-by-15+
#+windows (make-pointer 2)
#-windows (foreign-symbol-pointer "glutBitmap9By15"))
(setf +bitmap-8-by-13+
#+windows (make-pointer 3)
#-windows (foreign-symbol-pointer "glutBitmap8By13"))
(setf +bitmap-times-roman-10+
#+windows (make-pointer 4)
#-windows (foreign-symbol-pointer "glutBitmapTimesRoman10"))
(setf +bitmap-times-roman-24+
#+windows (make-pointer 5)
#-windows (foreign-symbol-pointer "glutBitmapTimesRoman24"))
(setf +bitmap-helvetica-10+
#+windows (make-pointer 6)
#-windows (foreign-symbol-pointer "glutBitmapHelvetica10"))
(setf +bitmap-helvetica-12+
#+windows (make-pointer 7)
#-windows (foreign-symbol-pointer "glutBitmapHelvetica12"))
(setf +bitmap-helvetica-18+
#+windows (make-pointer 8)
#-windows (foreign-symbol-pointer "glutBitmapHelvetica18")))
(init-font-pointers)
;;; Functions
;;; Do we want CHAR-CODE conversion here?
(defcfun ("glutBitmapCharacter" bitmap-character) :void
(font :pointer)
(character :int))
(defcfun ("glutBitmapWidth" bitmap-width) :int
(font :pointer)
(character :int))
(defcfun ("glutStrokeCharacter" stroke-character) :void
(font :pointer)
(character :int))
(defcfun ("glutStrokeWidth" stroke-width) :int
(font :pointer)
(character :int))
;; freeglut ext?
(defcfun ("glutBitmapLength" bitmap-length) :int
(font :pointer)
(string :string))
;; freeglut ext?
(defcfun ("glutStrokeLength" stroke-length) :int
(font :pointer)
(string :string))
;; freeglut ext
#-darwin
(defcfun ("glutBitmapHeight" bitmap-height) :int
(font :pointer))
;; freeglut ext
#-darwin
(defcfun ("glutStrokeHeight" stroke-height) %gl:float
(font :pointer))
;; freeglut ext
#-darwin
(defcfun ("glutBitmapString" bitmap-string) :void
(font :pointer)
(string :string))
;; freeglut ext
#-darwin
(defcfun ("glutStrokeString" stroke-string) :void
(font :pointer)
(string :string)) | 4,767 | Common Lisp | .lisp | 118 | 37.508475 | 75 | 0.72686 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 291a317aeeb62484425ee958b79fcbeecf88a84d9d6a8f83a351e8ad874b8051 | 30,607 | [
-1
] |
30,609 | state.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/glut/state.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; state.lisp --- GLUT Window state setting and retrieval API.
;;;
;;; Copyright (c) 2006, Alexey Dvoychenkov
;;; Copyright (c) 2006, Luis Oliveira <[email protected]>
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; o Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may
;;; be used to endorse or promote products derived from this software
;;; without specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
;;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
;;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
;;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-glut)
;;; Unimplemented freeglut extensions:
;;;
;;; FGAPI void* FGAPIENTRY glutGetWindowData( void );
;;; FGAPI void FGAPIENTRY glutSetWindowData(void* data);
;;; FGAPI void* FGAPIENTRY glutGetMenuData( void );
;;; FGAPI void FGAPIENTRY glutSetMenuData(void* data);
;;; Setting Options
(defparameter *window-close-action* nil)
;; freeglut ext
(defcenum (options %gl:enum)
(:init-window-x #x01F4)
:init-window-y
:init-window-width
:init-window-height
:init-display-mode
:action-on-window-close
(:rendering-context #x01FD)
:direct-rendering
(:window-cursor #x007A))
;;; freeglut ext
#-darwin
(defcfun ("glutSetOption" set-option) :void
(option options)
(value :int))
#+darwin
(defun set-option (val1 val2)
(declare (ignore val1 val2))
(warn "GLUT:SET-OPTION not supported in GLUT.framework"))
;;; Also provide some utility functions around glutSetOption().
;; freeglut ext
(defcenum rendering-context
:create-new-context
:use-current-context)
;; freeglut ext
(defcenum rendering-context-options
:force-indirect-context
:allow-direct-context
:try-direct-context
:force-direct-context)
;; freeglut ext
(defcenum window-close-behaviour
:action-exit
:action-glutmainloop-returns
:action-continue-execution)
(defbitfield (display-mode :unsigned-int)
(:rgb 0)
(:rgba 0)
(:index 1)
(:single 0)
(:double 2)
(:accum 4)
(:alpha 8)
(:depth 16)
(:stencil 32)
(:multisample 128)
(:stereo 256)
(:luminance 512)
(:aux1 #x1000) ; freeglut ext
(:aux2 #x2000) ; freeglut ext
(:aux3 #x4000) ; freeglut ext
(:aux4 #x8000)) ; freeglut ext
(defun set-display-mode (&rest options)
(set-option :init-display-mode
(foreign-bitfield-value 'display-mode options)))
(defun set-action-on-window-close (action)
#-darwin
(set-option :action-on-window-close
(foreign-enum-value 'window-close-behaviour action))
(setf *window-close-action* action))
(defun set-rendering-context (option)
(set-option :rendering-context
(foreign-enum-value 'rendering-context option)))
(defun set-direct-rendering (option)
(set-option :direct-rendering
(foreign-enum-value 'rendering-context-options option)))
;;; Getting Options
(defcenum (get-param %gl:enum)
(:window-x #x0064)
:window-y
:window-width
:window-height
:window-buffer-size
:window-stencil-size
:window-depth-size
:window-red-size
:window-green-size
:window-blue-size
:window-alpha-size
:window-accum-red-size
:window-accum-green-size
:window-accum-blue-size
:window-accum-alpha-size
:window-doublebuffer
:window-rgba
:window-parent
:window-num-children
:window-colormap-size
:window-num-samples
:window-stereo
:window-cursor
(:screen-width #x00C8)
:screen-height
:screen-width-mm
:screen-height-mm
(:menu-num-items #x012C)
(:display-mode-possible #x0190)
(:init-window-x #x01F4)
:init-window-y
:init-window-width
:init-window-height
:init-display-mode
(:elapsed-time #x02BC)
(:window-format-id #x007B)
:init-state
(:action-on-window-close #x01F9) ; freeglut ext
:window-border-width ; freeglut ext
:window-header-height ; freeglut ext
:version ; freeglut ext
#-darwin :rendering-context ; freeglut ext
:direct-rendering)
(defcfun ("glutGet" get) :int
(query get-param))
;;; Utility functions around glutGet().
(defun getp (query)
(if (= (get query) 0)
nil
t))
(defun get-window-cursor ()
(foreign-enum-keyword 'cursor (get :window-cursor)))
(defun get-init-display-mode ()
(foreign-bitfield-symbols 'display-mode (get :init-display-mode)))
;;; Other Getters
(defcenum (device-get-param %gl:enum)
(:has-keyboard #x0258)
:has-mouse
:has-spaceball
:has-dial-and-button-box
:has-tablet
:num-mouse-buttons
:num-spaceball-buttons
:num-button-box-buttons
:num-dials
:num-tablet-buttons
:device-ignore-key-repeat
:device-key-repeat
:has-joystick
:owns-joystick
:joystick-buttons
:joystick-axes
:joystick-poll-rate)
(defcfun ("glutDeviceGet" device-get) :int
(query device-get-param))
(defun device-getp (query)
(if (= (device-get query) 0)
nil
t))
(defcenum (layer-get-param %gl:enum)
(:overlay-possible #x0320)
:layer-in-use
:has-overlay
:transparent-index
:normal-damaged
:overlay-damaged)
(defcfun ("glutLayerGet" layer-get) :int
(query layer-get-param))
(defun layer-getp (query)
(if (= (layer-get query) 0)
nil
t))
(defun get-layer-in-use ()
(foreign-enum-keyword 'layer-type (layer-get :layer-in-use)))
(defcfun ("glutGetModifiers" %glutGetModifiers) :int)
(declaim (inline get-modifiers))
(defun get-modifiers ()
(foreign-bitfield-symbols 'modifiers (%glutGetModifiers)))
;;; No idea if this is more efficient space-wise...
(declaim (inline get-modifier-values))
(defun get-modifier-values ()
(let ((mask (%glutGetModifiers)))
(values (= 1 (logand mask 1)) ; shift
(= 2 (logand mask 2)) ; ctrl
(= 4 (logand mask 4))))) ; alt
(defcfun ("glutExtensionSupported" extension-supported-p) :boolean
(extension-name :string))
;;; freeglut ext
(defcfun ("glutGetProcAddress" get-proc-address) :pointer
(proc-name :string)) | 7,185 | Common Lisp | .lisp | 219 | 29.977169 | 75 | 0.707834 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | b3a5bdf2ea14f28f7940fd233358204e1ff388c3b025ae4054368fd21ef5eaff | 30,609 | [
401448
] |
30,610 | interface.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/glut/interface.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; interface.lisp --- CLOS interface to the GLUT API.
;;;
;;; Copyright (c) 2006, Luis Oliveira <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; o Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may
;;; be used to endorse or promote products derived from this software
;;; without specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
;;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
;;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
;;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-glut)
;;; This an experimental interface to GLUT. The main goal of this interface
;;; is to provide an easy, flexible way to explore OpenGL. GLUT is not very
;;; helpful in achieving this goal (even though Freeglut is much better than
;;; the original GLUT in this aspect).
;;;
;;; At the moment, not all of GLUT's capabilities are accessible when
;;; using this high-level interface *exclusively*. Patches and
;;; suggestions are most welcome!
(defvar *id->window* (make-array 0 :adjustable t)
"Mapping of GLUT window IDs to instances of the BASE-WINDOW class.")
(defvar *windows-with-idle-event* '())
;;;; Timers
(defparameter *timer-functions* nil)
(defcallback timer-cb :void ((id :int))
(let ((function (cdr (assoc id *timer-functions*))))
(when function
(funcall function))))
(defvar *timer-id-counter* 0)
(defun schedule-timer (millis function)
(setf *timer-id-counter* (logand (1+ *timer-id-counter*) #xFFFFFFFF))
(push (cons *timer-id-counter* function) *timer-functions*)
(timer-func millis (callback timer-cb) *timer-id-counter*))
;;;; Events
;;; One callback is defined for each GLUT event. Enabling an event for
;;; a given window means registering the respective shared callback
;;; for its window id (using the *-func GLUT functions).
;;;
;;; There is one generic function for each event which is called by
;;; the shared callback to dispatch to the correct method based on the
;;; window (and possibly the other arguments).
;;;
;;; Ugh, some of these event are not implemented by Freeglut, which
;;; is what we care about... Better remove them?
;;;
;;; TODO: The JOYSTICK event has parameters, meaning a way to accept
;;; parameters eg: (:joystick n m) when enabling an event is
;;; necessary. Unlikely to be implemented anytime soon; I
;;; haven't seen a joystick in years.
(defparameter *events* '())
(defstruct event name gf cb func arg-count)
(defun find-event-or-lose (event-name)
(or (find event-name *events* :key #'event-name)
(error "No such event: ~A" event-name)))
(defgeneric enable-event (window event-name))
(defgeneric disable-event (window event-name))
(defmacro when-current-window-exists (&body body)
"Evals BODY when GLUT's current window exists in *ID->WINDOW*.
Lexically binds CURRENT-WINDOW to the respective object."
(let ((id (gensym)))
`(let ((,id (get-window)))
(when (> (length *id->window*) ,id)
(let ((current-window (aref *id->window* ,id)))
(unless (null current-window)
;;(format t "glut callback: ~A -> ~A~%" ,id current-window)
,@body))))))
(define-foreign-type ascii-to-char ()
()
(:actual-type :unsigned-char)
(:simple-parser ascii-to-char))
;;; Without this EVAL-WHEN, the type expansion wouldn't be visible to
;;; the DEFCALLBACKs generated by DEFINE-GLUT-EVENTS.
(eval-when (:compile-toplevel :load-toplevel :execute)
(defmethod expand-from-foreign (value (type ascii-to-char))
`(code-char ,value)))
;;; The first element in ARGS is a dummy name for the first argument
;;; in the event's generic function, the window.
(defmacro define-glut-event (name args &body callback-body)
(let ((arg-names (mapcar #'car (cdr args)))
(event-cb (gl::symbolicate "%" name))
(event-func (gl::symbolicate name '#:-func))
(event-name (intern (symbol-name name) '#:keyword)))
`(progn
(defgeneric ,name (,(car args) ,@arg-names))
(defcallback ,event-cb :void ,(cdr args)
,@callback-body)
;; When we put #'foo-func instead of 'foo-func in the
;; FUNC slot weird stuff happens. No idea why.
(push (make-event :name ,event-name :gf #',name :cb ',event-cb
:func ',event-func :arg-count ,(length arg-names))
*events*))))
(defmacro define-glut-events (&body event-specs)
`(progn
(setq *events* '())
,@(loop for (name args) in event-specs collect
`(define-glut-event ,name ,args
(when-current-window-exists
(,name current-window ,@(mapcar #'car (cdr args))))))))
(define-glut-events
;; (idle (window))
(keyboard (window (key ascii-to-char) (x :int) (y :int)))
(special (window (special-key special-keys) (x :int) (y :int)))
(reshape (window (width :int) (height :int)))
(visibility (window (state visibility-state)))
(display (window))
(mouse (window (button mouse-button) (state mouse-button-state)
(x :int) (y :int)))
(motion (window (x :int) (y :int)))
(passive-motion (window (x :int) (y :int)))
(entry (window (state entry-state)))
(menu-state (window (state menu-state)))
(spaceball-motion (window (x :int) (y :int) (z :int)))
(spaceball-rotate (window (x :int) (y :int) (z :int)))
(spaceball-button (window (button :int) (state :int)))
(button-box (window (button :int) (state :int)))
(dials (window (dial :int) (value :int)))
(tablet-motion (window (x :int) (y :int)))
(tablet-button (window (button :int) (state :int) (x :int) (y :int)))
(menu-status (window (status menu-state) (x :int) (y :int)))
(overlay-display (window))
(window-status (window (state window-status)))
(keyboard-up (window (key ascii-to-char) (x :int) (y :int)))
(special-up (window (special-key special-keys) (x :int) (y :int)))
;; (joystick (window (buttons joystick-buttons) (x :int) (y :int)
;; (z :int)))
(mouse-wheel (window (button mouse-button) (pressed mouse-button-state)
(x :int) (y :int)))
;; (close (window))
(menu-destroy (window)))
;;; These two functions should not be called directly and are called
;;; by ENABLE-EVENT and DISABLE-EVENT. See below.
(defun register-callback (event)
(funcall (event-func event) (get-callback (event-cb event))))
(defun unregister-callback (event)
(funcall (event-func event) (null-pointer)))
;;;; Windows
;;; The WINDOW (top-level windows) and SUB-WINDOW (those pseudo-windows
;;; that live inside top-level windows and have their own GL context)
;;; classes inherit BASE-WINDOW.
;;;
;;; See DISPLAY-WINDOW's documentation.
(defparameter +default-title+
(concatenate 'string (lisp-implementation-type) " "
(lisp-implementation-version)))
(defvar *run-main-loop-after-display* t
"This special variable controls whether the DISPLAY-WINDOW
method specialized on GLUT:WINDOW will call GLUT:MAIN-LOOP.")
(defclass base-window ()
((name :reader name :initarg :name :initform (gensym "GLUT-WINDOW"))
(id :reader id)
(destroyed :accessor destroyed :initform nil)
(pos-x :accessor pos-x :initarg :pos-x)
(pos-y :accessor pos-y :initarg :pos-y)
(height :accessor height :initarg :height)
(width :accessor width :initarg :width)
(title :accessor title :initarg :title)
(tick-interval :accessor tick-interval :initarg :tick-interval)
;; When this slot unbound, DISPLAY-WINDOW calls
;; FIND-APPLICABLE-EVENTS to populate it.
(events :accessor events :initarg :events))
(:default-initargs :pos-x -1 :pos-y -1 :height 300 :width 300
:title +default-title+ :tick-interval nil))
(defmethod initialize-instance :before
((win base-window) &key name &allow-other-keys)
(declare (ignore win name))
(glut:init))
(defgeneric display-window (window)
(:documentation
"Creates the underlying GLUT window structures and displays
WINDOW. The creation takes place in :AROUND methods so the
user can define :before methods on DISPLAY-WINDOW and do
OpenGL stuff with it, for example."))
(defun find-window (name)
(loop for window across *id->window*
when (and (not (null window)) (eq (name window) name))
do (return window)))
(defmacro with-window (window &body body)
(let ((current-id (gensym)))
`(let ((,current-id (get-window)))
(unwind-protect
(progn
(set-window (id ,window))
,@body)
(set-window ,current-id)))))
;;; We do some extra stuff to provide an IDLE event per-window since
;;; GLUT's IDLE event is global.
(define-glut-event idle (window)
(loop for win in *windows-with-idle-event*
do (with-window win
(idle win))))
(defun %close (window)
(when (member :close (events window) :key #'event-name)
(close window))
(setf (aref *id->window* (id window)) nil)
(deletef *windows-with-idle-event* window)
#+darwin
(when (not (destroyed window))
(setf (destroyed window) t)
;; Apple's GLUT doesn't actually close the window when its close
;; button is pressed. So we ensure it's destroyed, otherwise it'll
;; hang around indefinitely not listening to events.
(destroy-window (id window)))
(when (null *windows-with-idle-event*)
(unregister-callback (find-event-or-lose :idle)))
#+darwin
(progn
(when (emptyp (remove-if #'null *id->window*))
;; We want to leave the glut event loop if all glut windows are
;; closed, even when :action-continue-execution is set.
(leave-main-loop))
(ecase *window-close-action*
;; :action-exit is probably unnecessary, as it should never be used.
(:action-exit
#+sbcl (sb-ext:quit)
#+ccl (ccl:quit)
#-(or sbcl ccl) (warn "Don't know how to quit."))
(:action-glutmainloop-returns
(leave-main-loop))
(:action-continue-execution
nil))))
(define-glut-event close (window)
(when-current-window-exists
(%close current-window)))
(defun find-applicable-events (window)
(loop for event in *events*
when (compute-applicable-methods
(event-gf event)
(cons window (loop repeat (event-arg-count event) collect t)))
collect event))
(defun enable-tick (window millis)
(setf (tick-interval window) millis)
(timer-func millis (callback tick-timer-cb) (id window)))
(defun disable-tick (window)
(setf (tick-interval window) nil))
(defmethod display-window :around ((win base-window))
(unless (slot-boundp win 'events)
(setf (events win) (find-applicable-events win)))
(with-window win
(glut:position-window (pos-x win) (pos-y win))
(glut:reshape-window (width win) (height win))
(glut:set-window-title (title win))
(dolist (event (events win))
(register-callback event))
;; we always want to enable the CLOSE event since we need it for
;; bookkeeping purposes.
(register-callback (find-event-or-lose :close)))
(when (member :idle (events win) :key #'event-name)
(push win *windows-with-idle-event*))
;; save window in the *id->window* array.
(when (<= (length *id->window*) (id win))
(setq *id->window*
(adjust-array *id->window* (1+ (id win)) :initial-element nil)))
(setf (aref *id->window* (id win)) win)
;; setup tick timer.
(when (tick-interval win)
(enable-tick win (tick-interval win)))
(call-next-method))
(defmethod display-window ((win base-window))
(values))
(defmethod enable-event ((window base-window) event-name)
(let ((event (find-event-or-lose event-name)))
(when (not (find event (events window)))
(with-window window
(register-callback event))
(push event (events window))
(when (eq event-name :idle)
(push window *windows-with-idle-event*)))))
(defmethod disable-event ((window base-window) event-name)
(if (eq event-name :display)
(warn "GLUT would be upset if we set the DISPLAY callback to NULL. ~
So we won't do that.")
(let ((event (find-event-or-lose event-name)))
(when (find event (events window))
;; We don't actually disable the CLOSE event since we need it
;; for bookkeeping. See the CLOSE event definiton.
(unless (or (eq event-name :idle)
(eq event-name :close))
(with-window window
(unregister-callback event)))
(setf (events window) (delete event (events window)))
(when (eq event-name :idle)
(setq *windows-with-idle-event*
(delete window *windows-with-idle-event*))
;; We need to disable the idle callback here too in
;; addition to close.
(when (null *windows-with-idle-event*)
(unregister-callback event)))))))
(defun destroy-current-window ()
(when-current-window-exists
(cond
((game-mode current-window)
(leave-game-mode))
(t
(when (not (destroyed current-window))
(setf (destroyed current-window) t)
(destroy-window (id current-window)))
#+darwin
(%close current-window)))))
(defgeneric tick (window))
(defcallback tick-timer-cb :void ((id :int))
(when (> (length *id->window*) id)
(let ((window (aref *id->window* id)))
(unless (null window)
(tick window)
(when (tick-interval window)
(timer-func (tick-interval window)
(callback tick-timer-cb) id))))))
;;;; Top-level Windows
(defclass window (base-window)
((sub-windows :accessor sub-windows :initform nil)
;; Can sub-windows have a different display mode?
(mode :initarg :mode :initform nil)
(game-mode :initarg :game-mode :accessor game-mode :initform nil)))
(defmethod (setf title) :before (string (win window))
(when (slot-boundp win 'id)
(with-window win
(set-window-title string))))
(defun setup-game-mode (win)
(let ((width (get :screen-width))
(height (get :screen-height)))
(setf (pos-x win) 0
(pos-y win) 0
(width win) width
(height win) height)
(game-mode-string (format nil "~Dx~D" width height))))
(defmethod display-window :around ((win window))
(when (game-mode win)
(setup-game-mode win))
(init-window-position (pos-x win) (pos-y win))
(init-window-size (width win) (height win))
(without-fp-traps
(apply #'init-display-mode (slot-value win 'mode))
(setf (slot-value win 'id)
(if (game-mode win)
(enter-game-mode)
(create-window (title win))))
(call-next-method)
(when *run-main-loop-after-display*
(glut:main-loop))))
;;;; Sub-windows
(defclass sub-window (base-window)
((parent :reader parent
:initform (error "Must specify a PARENT window."))))
(defmethod initialize-instance :after ((win sub-window) &key parent
&allow-other-keys)
(let ((parent-window (typecase parent
(window parent)
(symbol (find-window parent)))))
(check-type parent-window window)
(setf (slot-value win 'parent) parent-window)
(push win (sub-windows parent-window))))
(defmethod display-window :around ((win sub-window))
(setf (slot-value win 'id) (create-sub-window (id (parent win)) 0 0 0 0))
(call-next-method))
| 16,739 | Common Lisp | .lisp | 375 | 39.570667 | 78 | 0.6589 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 952261ae9ef9ba9fe2d26c87da99aa2cf4ea1c1177b3423b466d69e8e3246669 | 30,610 | [
144377
] |
30,611 | geometry.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/glut/geometry.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; geometry.lisp --- GLUT Geometric Object Rendering API.
;;;
;;; Copyright (c) 2006, Luis Oliveira <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; o Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may
;;; be used to endorse or promote products derived from this software
;;; without specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
;;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
;;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
;;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-glut)
;;; Functions.
(defcfun ("glutWireCube" wire-cube) :void
(size %gl:double))
(defcfun ("glutSolidCube" solid-cube) :void
(size %gl:double))
(defcfun ("glutWireSphere" wire-sphere) :void
(radius %gl:double)
(slices %gl:int)
(stacks %gl:int))
(defcfun ("glutSolidSphere" solid-sphere) :void
(radius %gl:double)
(slices %gl:int)
(stacks %gl:int))
(defcfun ("glutWireCone" wire-cone) :void
(base %gl:double)
(height %gl:double)
(slices %gl:int)
(stacks %gl:int))
(defcfun ("glutSolidCone" solid-cone) :void
(base %gl:double)
(height %gl:double)
(slices %gl:int)
(stacks %gl:int))
(defcfun ("glutWireTorus" wire-torus) :void
(inner-radius %gl:double)
(outer-radius %gl:double)
(slices %gl:int)
(rings %gl:int))
(defcfun ("glutSolidTorus" solid-torus) :void
(inner-radius %gl:double)
(outer-radius %gl:double)
(slices %gl:int)
(rings %gl:int))
(defcfun ("glutWireDodecahedron" wire-dodecahedron) :void)
(defcfun ("glutWireOctahedron" wire-octahedron) :void)
(defcfun ("glutWireTetrahedron" wire-tetrahedron) :void)
(defcfun ("glutWireIcosahedron" wire-icosahedron) :void)
(defcfun ("glutSolidDodecahedron" solid-dodecahedron) :void)
(defcfun ("glutSolidOctahedron" solid-octahedron) :void)
(defcfun ("glutSolidTetrahedron" solid-tetrahedron) :void)
(defcfun ("glutSolidIcosahedron" solid-icosahedron) :void)
(defcfun ("glutWireTeapot" wire-teapot) :void
(size %gl:double))
(defcfun ("glutSolidTeapot" solid-teapot) :void
(size %gl:double))
;;; The following are freeglut extensions:
#-darwin
(defcfun ("glutWireRhombicDodecahedron" wire-rhombic-dodecahedron) :void)
#-darwin
(defcfun ("glutSolidRhombicDodecahedron" solid-rhombic-dodecahedron) :void)
#-darwin
(defcfun ("glutWireSierpinskiSponge" %glutWireSierpinskiSponge) :void
(num-levels :int)
(offset-seq :pointer) ; GLdouble offset[3]
(scale %gl:double))
#-darwin
(defun wire-sierpinski-sponge (num-levels offset-seq scale)
(gl::with-opengl-sequence (offset '%gl:double offset-seq)
(%glutWireSierpinskiSponge num-levels offset scale)))
#-darwin
(defcfun ("glutSolidSierpinskiSponge" %glutSolidSierpinskiSponge) :void
(num-levels :int)
(offset-seq :pointer) ; GLdouble offset[3]
(scale %gl:double))
#-darwin
(defun solid-sierpinski-sponge (num-levels offset-seq scale)
(gl::with-opengl-sequence (offset '%gl:double offset-seq)
(%glutSolidSierpinskiSponge num-levels offset scale)))
#-darwin
(defcfun ("glutWireCylinder" wire-cylinder) :void
(radius %gl:double)
(height %gl:double)
(slices %gl:int)
(stacks %gl:int))
#-darwin
(defcfun ("glutSolidCylinder" solid-cylinder) :void
(radius %gl:double)
(height %gl:double)
(slices %gl:int)
(stacks %gl:int)) | 4,472 | Common Lisp | .lisp | 112 | 37.910714 | 75 | 0.748732 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 12a17af490b873241ee2d0baf7e588a64e157fd886da5f040bb855fa5eb7e51a | 30,611 | [
-1
] |
30,612 | misc.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/glut/misc.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; misc.lisp --- Misc functions from the GLUT API.
;;;
;;; Copyright (c) 2006, Luis Oliveira <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; o Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may
;;; be used to endorse or promote products derived from this software
;;; without specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
;;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
;;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
;;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-glut)
;;; Color API
(defcfun ("glutSetColor" set-color) :void
(ndx :int)
(red %gl:float)
(green %gl:float)
(blue %gl:float))
(defcenum color-component
:red
:green
:blue)
(defcfun ("glutGetColor" get-color) %gl:float
(color :int)
(component color-component))
(defcfun ("glutCopyColormap" copy-colormap) :void
(window-id :int))
;;; Misc keyboard and joystick functions.
(defcfun ("glutIgnoreKeyRepeat" ignore-key-repeat) :void
(ignore :int))
(defcenum key-repeat-mode
:key-repeat-off
:key-repeat-on
:key-repeat-default)
(defcfun ("glutSetKeyRepeat" set-key-repeat) :void
(repeat-mode key-repeat-mode))
(defcfun ("glutForceJoystickFunc" force-joystick-func) :void)
(defcfun ("glutReportErrors" report-errors) :void)
;;; Game Mode API
(defcfun ("glutGameModeString" game-mode-string) :void
(string :string))
(defcfun ("glutEnterGameMode" enter-game-mode) #-darwin :int #+darwin :void)
(defcfun ("glutLeaveGameMode" leave-game-mode) :void)
(defcenum (game-mode-param %gl:enum)
:game-mode-active
:game-mode-possible
:game-mode-width
:game-mode-height
:game-mode-pixel-depth
:game-mode-refresh-rate
:game-mode-display-changed)
(defcfun ("glutGameModeGet" game-mode-get) :int
(query game-mode-param))
(defcfun ("glutGameModeGet" game-mode-getp) :boolean
(query game-mode-param))
;;; Video API
;;; freeglut doesn't implement any of these
(defcenum (video-resize-param %gl:enum)
(:video-resize-possible #x0384)
:video-resize-in-use
:video-resize-x-delta
:video-resize-y-delta
:video-resize-width-delta
:video-resize-height-delta
:video-resize-x
:video-resize-y
:video-resize-width
:video-resize-height)
(defcfun ("glutVideoResizeGet" video-resize-get) :int
(query video-resize-param))
(defcfun ("glutVideoResizeGet" video-resize-getp) :boolean
(query video-resize-param))
(defcfun ("glutSetupVideoResizing" setup-video-resizing) :void)
(defcfun ("glutStopVideoResizing" stop-video-resizing) :void)
(defcfun ("glutVideoResize" video-resize) :void
(x :int)
(y :int)
(width :int)
(height :int))
(defcfun ("glutVideoPan" video-pan) :void
(x :int)
(y :int)
(width :int)
(height :int)) | 3,934 | Common Lisp | .lisp | 104 | 35.730769 | 76 | 0.745139 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 70352093666ab74189d7a3e8eb717beb11d8433b7aceb1289ec86bbd84620a0d | 30,612 | [
-1
] |
30,613 | init.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/cl-opengl-20150923-git/glut/init.lisp | ;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; init.lisp --- GLUT Initialization API.
;;;
;;; Copyright (c) 2006, Luis Oliveira <[email protected]>
;;; All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; o Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;; o Redistributions in binary form must reproduce the above copyright
;;; notice, this list of conditions and the following disclaimer in the
;;; documentation and/or other materials provided with the distribution.
;;; o Neither the name of the author nor the names of the contributors may
;;; be used to endorse or promote products derived from this software
;;; without specific prior written permission.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
;;; "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
;;; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
;;; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
;;; OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
;;; SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
;;; LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
;;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
;;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
;;; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
(in-package #:cl-glut)
(defcfun ("glutInit" %glutInit) :void
(argcp :pointer) ; int*
(argv :pointer)) ; char**
(defmacro without-fp-traps (&body body)
#+(and sbcl (or x86 x86-64))
`(sb-int:with-float-traps-masked (:invalid :divide-by-zero)
,@body)
#-(and sbcl (or x86 x86-64))
`(progn ,@body))
(defparameter *glut-initialized-p* nil)
(defun %init (program-name)
(with-foreign-objects ((argcp :int) (argv :pointer))
(setf (mem-ref argcp :int) 1)
(with-foreign-string (str program-name)
(setf (mem-ref argv :pointer) str)
(%glutInit argcp argv)
(init-font-pointers)
(setf *glut-initialized-p* t)))
;; By default, we choose the saner option to return from the event
;; loop on window close instead of exit()ing.
(set-action-on-window-close :action-continue-execution)
;; this probably doesn't play well with other toolkits
(setq %gl:*gl-get-proc-address* 'get-proc-address)
(values))
(defun init (&optional (program-name (lisp-implementation-type)))
(without-fp-traps
;; freeglut will exit() if we try to call initGlut() when
;; things are already initialized.
#-darwin
(unless (getp :init-state)
(%init program-name))
#+darwin
(unless *glut-initialized-p*
(%init program-name)))
(values))
;; We call init at load-time in order to ensure a usable glut as often
;; as possible. Also, we call init when the main event loop returns in
;; main.lisp and some other places. We do this to avoid having
;; freeglut call exit() when performing some operation that needs
;; previous initialization.
;; -- this is causing problems in other situations (loading without X
;; available for example, possibly also making the OSX threading stuff
;; worse), so disabling for now.
;; (init)
;;; The display-mode bitfield is defined in state.lisp
(defcfun ("glutInitDisplayMode" %glutInitDisplayMode) :void
(mode display-mode))
;;; freeglut_ext.h says: "Only one GLUT_AUXn bit may be used at a time."
(defun init-display-mode (&rest options)
(declare (dynamic-extent options))
(%glutInitDisplayMode options))
;;; useless?
(defcfun ("glutInitDisplayString" init-display-string) :void
(display-mode :string))
(defcfun ("glutInitWindowPosition" init-window-position) :void
(x :int)
(y :int))
(defcfun ("glutInitWindowSize" init-window-size) :void
(width :int)
(height :int))
| 4,109 | Common Lisp | .lisp | 92 | 42.23913 | 75 | 0.728589 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | bb44259f1ca2c8b044eaedc8e2faf27f9b07cdf9ee1c5ecf02af19a78e36306c | 30,613 | [
-1
] |
30,614 | enc-jpn.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/babel-20150608-git/src/enc-jpn.lisp | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; enc-jpn.lisp --- Japanese encodings.
;;;
(in-package #:babel-encodings)
;;;; helper functions
(defvar *eucjp-to-ucs-hash* (make-hash-table))
(defvar *ucs-to-eucjp-hash* (make-hash-table))
(defvar *cp932-to-ucs-hash* (make-hash-table))
(defvar *ucs-to-cp932-hash* (make-hash-table))
(dolist (i `((,*cp932-only*
,*cp932-to-ucs-hash*
,*ucs-to-cp932-hash*)
(,*eucjp-only*
,*eucjp-to-ucs-hash*
,*ucs-to-eucjp-hash*)
(,*eucjp*
,*eucjp-to-ucs-hash*
,*ucs-to-eucjp-hash*)))
(dolist (j (first i))
(setf (gethash (car j) (second i)) (cadr j))
(setf (gethash (cadr j) (third i)) (car j))))
(flet ((euc-cp932 (x)
(let ((high (ash x -16))
(mid (logand (ash x -8) 255))
(low (logand x 255)))
(cond ((not (zerop high))
nil)
((= mid #x8e)
(logand x 255))
((zerop mid)
x)
((decf mid #xa1)
(decf low #x80)
(incf low (if (zerop (logand mid 1)) #x1f #x7e))
(incf low (if (<= #x7f low #x9d) 1 0))
(setq mid (ash mid -1))
(incf mid (if (<= mid #x1e) #x81 #xc1))
(+ (ash mid 8) low))))))
(dolist (i *eucjp*)
(let ((cp932 (euc-cp932 (first i))))
(when cp932
(setf (gethash cp932 *cp932-to-ucs-hash*) (second i))
(setf (gethash (second i) *ucs-to-cp932-hash*) cp932)))))
;ascii
(loop for i from #x00 to #x7f do
(setf (gethash i *cp932-to-ucs-hash*) i)
(setf (gethash i *eucjp-to-ucs-hash*) i)
(setf (gethash i *ucs-to-eucjp-hash*) i)
(setf (gethash i *ucs-to-cp932-hash*) i))
;half-width katakana
(loop for i from #xa1 to #xdf do
(setf (gethash i *cp932-to-ucs-hash*) (+ #xff61 #x-a1 i))
(setf (gethash (+ #xff61 #x-a1 i) *ucs-to-cp932-hash*) i)
(setf (gethash (+ #x8e00 i) *eucjp-to-ucs-hash*) (+ #xff61 #x-a1 i))
(setf (gethash (+ #xff61 #x-a1 i) *ucs-to-eucjp-hash*) (+ #x8e00 i)))
;; This is quoted from https://support.microsoft.com/en-us/kb/170559/en-us
(let ((kb170559 "0x8790 -> U+2252 -> 0x81e0 Approximately Equal To Or The Image Of
0x8791 -> U+2261 -> 0x81df Identical To
0x8792 -> U+222b -> 0x81e7 Integral
0x8795 -> U+221a -> 0x81e3 Square Root
0x8796 -> U+22a5 -> 0x81db Up Tack
0x8797 -> U+2220 -> 0x81da Angle
0x879a -> U+2235 -> 0x81e6 Because
0x879b -> U+2229 -> 0x81bf Intersection
0x879c -> U+222a -> 0x81be Union
0xed40 -> U+7e8a -> 0xfa5c CJK Unified Ideograph
0xed41 -> U+891c -> 0xfa5d CJK Unified Ideograph
0xed42 -> U+9348 -> 0xfa5e CJK Unified Ideograph
0xed43 -> U+9288 -> 0xfa5f CJK Unified Ideograph
0xed44 -> U+84dc -> 0xfa60 CJK Unified Ideograph
0xed45 -> U+4fc9 -> 0xfa61 CJK Unified Ideograph
0xed46 -> U+70bb -> 0xfa62 CJK Unified Ideograph
0xed47 -> U+6631 -> 0xfa63 CJK Unified Ideograph
0xed48 -> U+68c8 -> 0xfa64 CJK Unified Ideograph
0xed49 -> U+92f9 -> 0xfa65 CJK Unified Ideograph
0xed4a -> U+66fb -> 0xfa66 CJK Unified Ideograph
0xed4b -> U+5f45 -> 0xfa67 CJK Unified Ideograph
0xed4c -> U+4e28 -> 0xfa68 CJK Unified Ideograph
0xed4d -> U+4ee1 -> 0xfa69 CJK Unified Ideograph
0xed4e -> U+4efc -> 0xfa6a CJK Unified Ideograph
0xed4f -> U+4f00 -> 0xfa6b CJK Unified Ideograph
0xed50 -> U+4f03 -> 0xfa6c CJK Unified Ideograph
0xed51 -> U+4f39 -> 0xfa6d CJK Unified Ideograph
0xed52 -> U+4f56 -> 0xfa6e CJK Unified Ideograph
0xed53 -> U+4f92 -> 0xfa6f CJK Unified Ideograph
0xed54 -> U+4f8a -> 0xfa70 CJK Unified Ideograph
0xed55 -> U+4f9a -> 0xfa71 CJK Unified Ideograph
0xed56 -> U+4f94 -> 0xfa72 CJK Unified Ideograph
0xed57 -> U+4fcd -> 0xfa73 CJK Unified Ideograph
0xed58 -> U+5040 -> 0xfa74 CJK Unified Ideograph
0xed59 -> U+5022 -> 0xfa75 CJK Unified Ideograph
0xed5a -> U+4fff -> 0xfa76 CJK Unified Ideograph
0xed5b -> U+501e -> 0xfa77 CJK Unified Ideograph
0xed5c -> U+5046 -> 0xfa78 CJK Unified Ideograph
0xed5d -> U+5070 -> 0xfa79 CJK Unified Ideograph
0xed5e -> U+5042 -> 0xfa7a CJK Unified Ideograph
0xed5f -> U+5094 -> 0xfa7b CJK Unified Ideograph
0xed60 -> U+50f4 -> 0xfa7c CJK Unified Ideograph
0xed61 -> U+50d8 -> 0xfa7d CJK Unified Ideograph
0xed62 -> U+514a -> 0xfa7e CJK Unified Ideograph
0xed63 -> U+5164 -> 0xfa80 CJK Unified Ideograph
0xed64 -> U+519d -> 0xfa81 CJK Unified Ideograph
0xed65 -> U+51be -> 0xfa82 CJK Unified Ideograph
0xed66 -> U+51ec -> 0xfa83 CJK Unified Ideograph
0xed67 -> U+5215 -> 0xfa84 CJK Unified Ideograph
0xed68 -> U+529c -> 0xfa85 CJK Unified Ideograph
0xed69 -> U+52a6 -> 0xfa86 CJK Unified Ideograph
0xed6a -> U+52c0 -> 0xfa87 CJK Unified Ideograph
0xed6b -> U+52db -> 0xfa88 CJK Unified Ideograph
0xed6c -> U+5300 -> 0xfa89 CJK Unified Ideograph
0xed6d -> U+5307 -> 0xfa8a CJK Unified Ideograph
0xed6e -> U+5324 -> 0xfa8b CJK Unified Ideograph
0xed6f -> U+5372 -> 0xfa8c CJK Unified Ideograph
0xed70 -> U+5393 -> 0xfa8d CJK Unified Ideograph
0xed71 -> U+53b2 -> 0xfa8e CJK Unified Ideograph
0xed72 -> U+53dd -> 0xfa8f CJK Unified Ideograph
0xed73 -> U+fa0e -> 0xfa90 CJK compatibility Ideograph
0xed74 -> U+549c -> 0xfa91 CJK Unified Ideograph
0xed75 -> U+548a -> 0xfa92 CJK Unified Ideograph
0xed76 -> U+54a9 -> 0xfa93 CJK Unified Ideograph
0xed77 -> U+54ff -> 0xfa94 CJK Unified Ideograph
0xed78 -> U+5586 -> 0xfa95 CJK Unified Ideograph
0xed79 -> U+5759 -> 0xfa96 CJK Unified Ideograph
0xed7a -> U+5765 -> 0xfa97 CJK Unified Ideograph
0xed7b -> U+57ac -> 0xfa98 CJK Unified Ideograph
0xed7c -> U+57c8 -> 0xfa99 CJK Unified Ideograph
0xed7d -> U+57c7 -> 0xfa9a CJK Unified Ideograph
0xed7e -> U+fa0f -> 0xfa9b CJK compatibility Ideograph
0xed80 -> U+fa10 -> 0xfa9c CJK compatibility Ideograph
0xed81 -> U+589e -> 0xfa9d CJK Unified Ideograph
0xed82 -> U+58b2 -> 0xfa9e CJK Unified Ideograph
0xed83 -> U+590b -> 0xfa9f CJK Unified Ideograph
0xed84 -> U+5953 -> 0xfaa0 CJK Unified Ideograph
0xed85 -> U+595b -> 0xfaa1 CJK Unified Ideograph
0xed86 -> U+595d -> 0xfaa2 CJK Unified Ideograph
0xed87 -> U+5963 -> 0xfaa3 CJK Unified Ideograph
0xed88 -> U+59a4 -> 0xfaa4 CJK Unified Ideograph
0xed89 -> U+59ba -> 0xfaa5 CJK Unified Ideograph
0xed8a -> U+5b56 -> 0xfaa6 CJK Unified Ideograph
0xed8b -> U+5bc0 -> 0xfaa7 CJK Unified Ideograph
0xed8c -> U+752f -> 0xfaa8 CJK Unified Ideograph
0xed8d -> U+5bd8 -> 0xfaa9 CJK Unified Ideograph
0xed8e -> U+5bec -> 0xfaaa CJK Unified Ideograph
0xed8f -> U+5c1e -> 0xfaab CJK Unified Ideograph
0xed90 -> U+5ca6 -> 0xfaac CJK Unified Ideograph
0xed91 -> U+5cba -> 0xfaad CJK Unified Ideograph
0xed92 -> U+5cf5 -> 0xfaae CJK Unified Ideograph
0xed93 -> U+5d27 -> 0xfaaf CJK Unified Ideograph
0xed94 -> U+5d53 -> 0xfab0 CJK Unified Ideograph
0xed95 -> U+fa11 -> 0xfab1 CJK compatibility Ideograph
0xed96 -> U+5d42 -> 0xfab2 CJK Unified Ideograph
0xed97 -> U+5d6d -> 0xfab3 CJK Unified Ideograph
0xed98 -> U+5db8 -> 0xfab4 CJK Unified Ideograph
0xed99 -> U+5db9 -> 0xfab5 CJK Unified Ideograph
0xed9a -> U+5dd0 -> 0xfab6 CJK Unified Ideograph
0xed9b -> U+5f21 -> 0xfab7 CJK Unified Ideograph
0xed9c -> U+5f34 -> 0xfab8 CJK Unified Ideograph
0xed9d -> U+5f67 -> 0xfab9 CJK Unified Ideograph
0xed9e -> U+5fb7 -> 0xfaba CJK Unified Ideograph
0xed9f -> U+5fde -> 0xfabb CJK Unified Ideograph
0xeda0 -> U+605d -> 0xfabc CJK Unified Ideograph
0xeda1 -> U+6085 -> 0xfabd CJK Unified Ideograph
0xeda2 -> U+608a -> 0xfabe CJK Unified Ideograph
0xeda3 -> U+60de -> 0xfabf CJK Unified Ideograph
0xeda4 -> U+60d5 -> 0xfac0 CJK Unified Ideograph
0xeda5 -> U+6120 -> 0xfac1 CJK Unified Ideograph
0xeda6 -> U+60f2 -> 0xfac2 CJK Unified Ideograph
0xeda7 -> U+6111 -> 0xfac3 CJK Unified Ideograph
0xeda8 -> U+6137 -> 0xfac4 CJK Unified Ideograph
0xeda9 -> U+6130 -> 0xfac5 CJK Unified Ideograph
0xedaa -> U+6198 -> 0xfac6 CJK Unified Ideograph
0xedab -> U+6213 -> 0xfac7 CJK Unified Ideograph
0xedac -> U+62a6 -> 0xfac8 CJK Unified Ideograph
0xedad -> U+63f5 -> 0xfac9 CJK Unified Ideograph
0xedae -> U+6460 -> 0xfaca CJK Unified Ideograph
0xedaf -> U+649d -> 0xfacb CJK Unified Ideograph
0xedb0 -> U+64ce -> 0xfacc CJK Unified Ideograph
0xedb1 -> U+654e -> 0xfacd CJK Unified Ideograph
0xedb2 -> U+6600 -> 0xface CJK Unified Ideograph
0xedb3 -> U+6615 -> 0xfacf CJK Unified Ideograph
0xedb4 -> U+663b -> 0xfad0 CJK Unified Ideograph
0xedb5 -> U+6609 -> 0xfad1 CJK Unified Ideograph
0xedb6 -> U+662e -> 0xfad2 CJK Unified Ideograph
0xedb7 -> U+661e -> 0xfad3 CJK Unified Ideograph
0xedb8 -> U+6624 -> 0xfad4 CJK Unified Ideograph
0xedb9 -> U+6665 -> 0xfad5 CJK Unified Ideograph
0xedba -> U+6657 -> 0xfad6 CJK Unified Ideograph
0xedbb -> U+6659 -> 0xfad7 CJK Unified Ideograph
0xedbc -> U+fa12 -> 0xfad8 CJK compatibility Ideograph
0xedbd -> U+6673 -> 0xfad9 CJK Unified Ideograph
0xedbe -> U+6699 -> 0xfada CJK Unified Ideograph
0xedbf -> U+66a0 -> 0xfadb CJK Unified Ideograph
0xedc0 -> U+66b2 -> 0xfadc CJK Unified Ideograph
0xedc1 -> U+66bf -> 0xfadd CJK Unified Ideograph
0xedc2 -> U+66fa -> 0xfade CJK Unified Ideograph
0xedc3 -> U+670e -> 0xfadf CJK Unified Ideograph
0xedc4 -> U+f929 -> 0xfae0 CJK compatibility Ideograph
0xedc5 -> U+6766 -> 0xfae1 CJK Unified Ideograph
0xedc6 -> U+67bb -> 0xfae2 CJK Unified Ideograph
0xedc7 -> U+6852 -> 0xfae3 CJK Unified Ideograph
0xedc8 -> U+67c0 -> 0xfae4 CJK Unified Ideograph
0xedc9 -> U+6801 -> 0xfae5 CJK Unified Ideograph
0xedca -> U+6844 -> 0xfae6 CJK Unified Ideograph
0xedcb -> U+68cf -> 0xfae7 CJK Unified Ideograph
0xedcc -> U+fa13 -> 0xfae8 CJK compatibility Ideograph
0xedcd -> U+6968 -> 0xfae9 CJK Unified Ideograph
0xedce -> U+fa14 -> 0xfaea CJK compatibility Ideograph
0xedcf -> U+6998 -> 0xfaeb CJK Unified Ideograph
0xedd0 -> U+69e2 -> 0xfaec CJK Unified Ideograph
0xedd1 -> U+6a30 -> 0xfaed CJK Unified Ideograph
0xedd2 -> U+6a6b -> 0xfaee CJK Unified Ideograph
0xedd3 -> U+6a46 -> 0xfaef CJK Unified Ideograph
0xedd4 -> U+6a73 -> 0xfaf0 CJK Unified Ideograph
0xedd5 -> U+6a7e -> 0xfaf1 CJK Unified Ideograph
0xedd6 -> U+6ae2 -> 0xfaf2 CJK Unified Ideograph
0xedd7 -> U+6ae4 -> 0xfaf3 CJK Unified Ideograph
0xedd8 -> U+6bd6 -> 0xfaf4 CJK Unified Ideograph
0xedd9 -> U+6c3f -> 0xfaf5 CJK Unified Ideograph
0xedda -> U+6c5c -> 0xfaf6 CJK Unified Ideograph
0xeddb -> U+6c86 -> 0xfaf7 CJK Unified Ideograph
0xeddc -> U+6c6f -> 0xfaf8 CJK Unified Ideograph
0xeddd -> U+6cda -> 0xfaf9 CJK Unified Ideograph
0xedde -> U+6d04 -> 0xfafa CJK Unified Ideograph
0xeddf -> U+6d87 -> 0xfafb CJK Unified Ideograph
0xede0 -> U+6d6f -> 0xfafc CJK Unified Ideograph
0xede1 -> U+6d96 -> 0xfb40 CJK Unified Ideograph
0xede2 -> U+6dac -> 0xfb41 CJK Unified Ideograph
0xede3 -> U+6dcf -> 0xfb42 CJK Unified Ideograph
0xede4 -> U+6df8 -> 0xfb43 CJK Unified Ideograph
0xede5 -> U+6df2 -> 0xfb44 CJK Unified Ideograph
0xede6 -> U+6dfc -> 0xfb45 CJK Unified Ideograph
0xede7 -> U+6e39 -> 0xfb46 CJK Unified Ideograph
0xede8 -> U+6e5c -> 0xfb47 CJK Unified Ideograph
0xede9 -> U+6e27 -> 0xfb48 CJK Unified Ideograph
0xedea -> U+6e3c -> 0xfb49 CJK Unified Ideograph
0xedeb -> U+6ebf -> 0xfb4a CJK Unified Ideograph
0xedec -> U+6f88 -> 0xfb4b CJK Unified Ideograph
0xeded -> U+6fb5 -> 0xfb4c CJK Unified Ideograph
0xedee -> U+6ff5 -> 0xfb4d CJK Unified Ideograph
0xedef -> U+7005 -> 0xfb4e CJK Unified Ideograph
0xedf0 -> U+7007 -> 0xfb4f CJK Unified Ideograph
0xedf1 -> U+7028 -> 0xfb50 CJK Unified Ideograph
0xedf2 -> U+7085 -> 0xfb51 CJK Unified Ideograph
0xedf3 -> U+70ab -> 0xfb52 CJK Unified Ideograph
0xedf4 -> U+710f -> 0xfb53 CJK Unified Ideograph
0xedf5 -> U+7104 -> 0xfb54 CJK Unified Ideograph
0xedf6 -> U+715c -> 0xfb55 CJK Unified Ideograph
0xedf7 -> U+7146 -> 0xfb56 CJK Unified Ideograph
0xedf8 -> U+7147 -> 0xfb57 CJK Unified Ideograph
0xedf9 -> U+fa15 -> 0xfb58 CJK compatibility Ideograph
0xedfa -> U+71c1 -> 0xfb59 CJK Unified Ideograph
0xedfb -> U+71fe -> 0xfb5a CJK Unified Ideograph
0xedfc -> U+72b1 -> 0xfb5b CJK Unified Ideograph
0xee40 -> U+72be -> 0xfb5c CJK Unified Ideograph
0xee41 -> U+7324 -> 0xfb5d CJK Unified Ideograph
0xee42 -> U+fa16 -> 0xfb5e CJK compatibility Ideograph
0xee43 -> U+7377 -> 0xfb5f CJK Unified Ideograph
0xee44 -> U+73bd -> 0xfb60 CJK Unified Ideograph
0xee45 -> U+73c9 -> 0xfb61 CJK Unified Ideograph
0xee46 -> U+73d6 -> 0xfb62 CJK Unified Ideograph
0xee47 -> U+73e3 -> 0xfb63 CJK Unified Ideograph
0xee48 -> U+73d2 -> 0xfb64 CJK Unified Ideograph
0xee49 -> U+7407 -> 0xfb65 CJK Unified Ideograph
0xee4a -> U+73f5 -> 0xfb66 CJK Unified Ideograph
0xee4b -> U+7426 -> 0xfb67 CJK Unified Ideograph
0xee4c -> U+742a -> 0xfb68 CJK Unified Ideograph
0xee4d -> U+7429 -> 0xfb69 CJK Unified Ideograph
0xee4e -> U+742e -> 0xfb6a CJK Unified Ideograph
0xee4f -> U+7462 -> 0xfb6b CJK Unified Ideograph
0xee50 -> U+7489 -> 0xfb6c CJK Unified Ideograph
0xee51 -> U+749f -> 0xfb6d CJK Unified Ideograph
0xee52 -> U+7501 -> 0xfb6e CJK Unified Ideograph
0xee53 -> U+756f -> 0xfb6f CJK Unified Ideograph
0xee54 -> U+7682 -> 0xfb70 CJK Unified Ideograph
0xee55 -> U+769c -> 0xfb71 CJK Unified Ideograph
0xee56 -> U+769e -> 0xfb72 CJK Unified Ideograph
0xee57 -> U+769b -> 0xfb73 CJK Unified Ideograph
0xee58 -> U+76a6 -> 0xfb74 CJK Unified Ideograph
0xee59 -> U+fa17 -> 0xfb75 CJK compatibility Ideograph
0xee5a -> U+7746 -> 0xfb76 CJK Unified Ideograph
0xee5b -> U+52af -> 0xfb77 CJK Unified Ideograph
0xee5c -> U+7821 -> 0xfb78 CJK Unified Ideograph
0xee5d -> U+784e -> 0xfb79 CJK Unified Ideograph
0xee5e -> U+7864 -> 0xfb7a CJK Unified Ideograph
0xee5f -> U+787a -> 0xfb7b CJK Unified Ideograph
0xee60 -> U+7930 -> 0xfb7c CJK Unified Ideograph
0xee61 -> U+fa18 -> 0xfb7d CJK compatibility Ideograph
0xee62 -> U+fa19 -> 0xfb7e CJK compatibility Ideograph
0xee63 -> U+fa1a -> 0xfb80 CJK compatibility Ideograph
0xee64 -> U+7994 -> 0xfb81 CJK Unified Ideograph
0xee65 -> U+fa1b -> 0xfb82 CJK compatibility Ideograph
0xee66 -> U+799b -> 0xfb83 CJK Unified Ideograph
0xee67 -> U+7ad1 -> 0xfb84 CJK Unified Ideograph
0xee68 -> U+7ae7 -> 0xfb85 CJK Unified Ideograph
0xee69 -> U+fa1c -> 0xfb86 CJK compatibility Ideograph
0xee6a -> U+7aeb -> 0xfb87 CJK Unified Ideograph
0xee6b -> U+7b9e -> 0xfb88 CJK Unified Ideograph
0xee6c -> U+fa1d -> 0xfb89 CJK compatibility Ideograph
0xee6d -> U+7d48 -> 0xfb8a CJK Unified Ideograph
0xee6e -> U+7d5c -> 0xfb8b CJK Unified Ideograph
0xee6f -> U+7db7 -> 0xfb8c CJK Unified Ideograph
0xee70 -> U+7da0 -> 0xfb8d CJK Unified Ideograph
0xee71 -> U+7dd6 -> 0xfb8e CJK Unified Ideograph
0xee72 -> U+7e52 -> 0xfb8f CJK Unified Ideograph
0xee73 -> U+7f47 -> 0xfb90 CJK Unified Ideograph
0xee74 -> U+7fa1 -> 0xfb91 CJK Unified Ideograph
0xee75 -> U+fa1e -> 0xfb92 CJK compatibility Ideograph
0xee76 -> U+8301 -> 0xfb93 CJK Unified Ideograph
0xee77 -> U+8362 -> 0xfb94 CJK Unified Ideograph
0xee78 -> U+837f -> 0xfb95 CJK Unified Ideograph
0xee79 -> U+83c7 -> 0xfb96 CJK Unified Ideograph
0xee7a -> U+83f6 -> 0xfb97 CJK Unified Ideograph
0xee7b -> U+8448 -> 0xfb98 CJK Unified Ideograph
0xee7c -> U+84b4 -> 0xfb99 CJK Unified Ideograph
0xee7d -> U+8553 -> 0xfb9a CJK Unified Ideograph
0xee7e -> U+8559 -> 0xfb9b CJK Unified Ideograph
0xee80 -> U+856b -> 0xfb9c CJK Unified Ideograph
0xee81 -> U+fa1f -> 0xfb9d CJK compatibility Ideograph
0xee82 -> U+85b0 -> 0xfb9e CJK Unified Ideograph
0xee83 -> U+fa20 -> 0xfb9f CJK compatibility Ideograph
0xee84 -> U+fa21 -> 0xfba0 CJK compatibility Ideograph
0xee85 -> U+8807 -> 0xfba1 CJK Unified Ideograph
0xee86 -> U+88f5 -> 0xfba2 CJK Unified Ideograph
0xee87 -> U+8a12 -> 0xfba3 CJK Unified Ideograph
0xee88 -> U+8a37 -> 0xfba4 CJK Unified Ideograph
0xee89 -> U+8a79 -> 0xfba5 CJK Unified Ideograph
0xee8a -> U+8aa7 -> 0xfba6 CJK Unified Ideograph
0xee8b -> U+8abe -> 0xfba7 CJK Unified Ideograph
0xee8c -> U+8adf -> 0xfba8 CJK Unified Ideograph
0xee8d -> U+fa22 -> 0xfba9 CJK compatibility Ideograph
0xee8e -> U+8af6 -> 0xfbaa CJK Unified Ideograph
0xee8f -> U+8b53 -> 0xfbab CJK Unified Ideograph
0xee90 -> U+8b7f -> 0xfbac CJK Unified Ideograph
0xee91 -> U+8cf0 -> 0xfbad CJK Unified Ideograph
0xee92 -> U+8cf4 -> 0xfbae CJK Unified Ideograph
0xee93 -> U+8d12 -> 0xfbaf CJK Unified Ideograph
0xee94 -> U+8d76 -> 0xfbb0 CJK Unified Ideograph
0xee95 -> U+fa23 -> 0xfbb1 CJK compatibility Ideograph
0xee96 -> U+8ecf -> 0xfbb2 CJK Unified Ideograph
0xee97 -> U+fa24 -> 0xfbb3 CJK compatibility Ideograph
0xee98 -> U+fa25 -> 0xfbb4 CJK compatibility Ideograph
0xee99 -> U+9067 -> 0xfbb5 CJK Unified Ideograph
0xee9a -> U+90de -> 0xfbb6 CJK Unified Ideograph
0xee9b -> U+fa26 -> 0xfbb7 CJK compatibility Ideograph
0xee9c -> U+9115 -> 0xfbb8 CJK Unified Ideograph
0xee9d -> U+9127 -> 0xfbb9 CJK Unified Ideograph
0xee9e -> U+91da -> 0xfbba CJK Unified Ideograph
0xee9f -> U+91d7 -> 0xfbbb CJK Unified Ideograph
0xeea0 -> U+91de -> 0xfbbc CJK Unified Ideograph
0xeea1 -> U+91ed -> 0xfbbd CJK Unified Ideograph
0xeea2 -> U+91ee -> 0xfbbe CJK Unified Ideograph
0xeea3 -> U+91e4 -> 0xfbbf CJK Unified Ideograph
0xeea4 -> U+91e5 -> 0xfbc0 CJK Unified Ideograph
0xeea5 -> U+9206 -> 0xfbc1 CJK Unified Ideograph
0xeea6 -> U+9210 -> 0xfbc2 CJK Unified Ideograph
0xeea7 -> U+920a -> 0xfbc3 CJK Unified Ideograph
0xeea8 -> U+923a -> 0xfbc4 CJK Unified Ideograph
0xeea9 -> U+9240 -> 0xfbc5 CJK Unified Ideograph
0xeeaa -> U+923c -> 0xfbc6 CJK Unified Ideograph
0xeeab -> U+924e -> 0xfbc7 CJK Unified Ideograph
0xeeac -> U+9259 -> 0xfbc8 CJK Unified Ideograph
0xeead -> U+9251 -> 0xfbc9 CJK Unified Ideograph
0xeeae -> U+9239 -> 0xfbca CJK Unified Ideograph
0xeeaf -> U+9267 -> 0xfbcb CJK Unified Ideograph
0xeeb0 -> U+92a7 -> 0xfbcc CJK Unified Ideograph
0xeeb1 -> U+9277 -> 0xfbcd CJK Unified Ideograph
0xeeb2 -> U+9278 -> 0xfbce CJK Unified Ideograph
0xeeb3 -> U+92e7 -> 0xfbcf CJK Unified Ideograph
0xeeb4 -> U+92d7 -> 0xfbd0 CJK Unified Ideograph
0xeeb5 -> U+92d9 -> 0xfbd1 CJK Unified Ideograph
0xeeb6 -> U+92d0 -> 0xfbd2 CJK Unified Ideograph
0xeeb7 -> U+fa27 -> 0xfbd3 CJK compatibility Ideograph
0xeeb8 -> U+92d5 -> 0xfbd4 CJK Unified Ideograph
0xeeb9 -> U+92e0 -> 0xfbd5 CJK Unified Ideograph
0xeeba -> U+92d3 -> 0xfbd6 CJK Unified Ideograph
0xeebb -> U+9325 -> 0xfbd7 CJK Unified Ideograph
0xeebc -> U+9321 -> 0xfbd8 CJK Unified Ideograph
0xeebd -> U+92fb -> 0xfbd9 CJK Unified Ideograph
0xeebe -> U+fa28 -> 0xfbda CJK compatibility Ideograph
0xeebf -> U+931e -> 0xfbdb CJK Unified Ideograph
0xeec0 -> U+92ff -> 0xfbdc CJK Unified Ideograph
0xeec1 -> U+931d -> 0xfbdd CJK Unified Ideograph
0xeec2 -> U+9302 -> 0xfbde CJK Unified Ideograph
0xeec3 -> U+9370 -> 0xfbdf CJK Unified Ideograph
0xeec4 -> U+9357 -> 0xfbe0 CJK Unified Ideograph
0xeec5 -> U+93a4 -> 0xfbe1 CJK Unified Ideograph
0xeec6 -> U+93c6 -> 0xfbe2 CJK Unified Ideograph
0xeec7 -> U+93de -> 0xfbe3 CJK Unified Ideograph
0xeec8 -> U+93f8 -> 0xfbe4 CJK Unified Ideograph
0xeec9 -> U+9431 -> 0xfbe5 CJK Unified Ideograph
0xeeca -> U+9445 -> 0xfbe6 CJK Unified Ideograph
0xeecb -> U+9448 -> 0xfbe7 CJK Unified Ideograph
0xeecc -> U+9592 -> 0xfbe8 CJK Unified Ideograph
0xeecd -> U+f9dc -> 0xfbe9 CJK compatibility Ideograph
0xeece -> U+fa29 -> 0xfbea CJK compatibility Ideograph
0xeecf -> U+969d -> 0xfbeb CJK Unified Ideograph
0xeed0 -> U+96af -> 0xfbec CJK Unified Ideograph
0xeed1 -> U+9733 -> 0xfbed CJK Unified Ideograph
0xeed2 -> U+973b -> 0xfbee CJK Unified Ideograph
0xeed3 -> U+9743 -> 0xfbef CJK Unified Ideograph
0xeed4 -> U+974d -> 0xfbf0 CJK Unified Ideograph
0xeed5 -> U+974f -> 0xfbf1 CJK Unified Ideograph
0xeed6 -> U+9751 -> 0xfbf2 CJK Unified Ideograph
0xeed7 -> U+9755 -> 0xfbf3 CJK Unified Ideograph
0xeed8 -> U+9857 -> 0xfbf4 CJK Unified Ideograph
0xeed9 -> U+9865 -> 0xfbf5 CJK Unified Ideograph
0xeeda -> U+fa2a -> 0xfbf6 CJK compatibility Ideograph
0xeedb -> U+fa2b -> 0xfbf7 CJK compatibility Ideograph
0xeedc -> U+9927 -> 0xfbf8 CJK Unified Ideograph
0xeedd -> U+fa2c -> 0xfbf9 CJK compatibility Ideograph
0xeede -> U+999e -> 0xfbfa CJK Unified Ideograph
0xeedf -> U+9a4e -> 0xfbfb CJK Unified Ideograph
0xeee0 -> U+9ad9 -> 0xfbfc CJK Unified Ideograph
0xeee1 -> U+9adc -> 0xfc40 CJK Unified Ideograph
0xeee2 -> U+9b75 -> 0xfc41 CJK Unified Ideograph
0xeee3 -> U+9b72 -> 0xfc42 CJK Unified Ideograph
0xeee4 -> U+9b8f -> 0xfc43 CJK Unified Ideograph
0xeee5 -> U+9bb1 -> 0xfc44 CJK Unified Ideograph
0xeee6 -> U+9bbb -> 0xfc45 CJK Unified Ideograph
0xeee7 -> U+9c00 -> 0xfc46 CJK Unified Ideograph
0xeee8 -> U+9d70 -> 0xfc47 CJK Unified Ideograph
0xeee9 -> U+9d6b -> 0xfc48 CJK Unified Ideograph
0xeeea -> U+fa2d -> 0xfc49 CJK compatibility Ideograph
0xeeeb -> U+9e19 -> 0xfc4a CJK Unified Ideograph
0xeeec -> U+9ed1 -> 0xfc4b CJK Unified Ideograph
0xeeef -> U+2170 -> 0xfa40 Small Roman Numeral One
0xeef0 -> U+2171 -> 0xfa41 Small Roman Numeral Two
0xeef1 -> U+2172 -> 0xfa42 Small Roman Numeral Three
0xeef2 -> U+2173 -> 0xfa43 Small Roman Numeral Four
0xeef3 -> U+2174 -> 0xfa44 Small Roman Numeral Five
0xeef4 -> U+2175 -> 0xfa45 Small Roman Numeral Six
0xeef5 -> U+2176 -> 0xfa46 Small Roman Numeral Seven
0xeef6 -> U+2177 -> 0xfa47 Small Roman Numeral Eight
0xeef7 -> U+2178 -> 0xfa48 Small Roman Numeral Nine
0xeef8 -> U+2179 -> 0xfa49 Small Roman Numeral Ten
0xeef9 -> U+ffe2 -> 0x81ca Fullwidth Not Sign
0xeefa -> U+ffe4 -> 0xfa55 Fullwidth Broken Bar
0xeefb -> U+ff07 -> 0xfa56 Fullwidth Apostrophe
0xeefc -> U+ff02 -> 0xfa57 Fullwidth Quotation Mark
0xfa4a -> U+2160 -> 0x8754 Roman Numeral One
0xfa4b -> U+2161 -> 0x8755 Roman Numeral Two
0xfa4c -> U+2162 -> 0x8756 Roman Numeral Three
0xfa4d -> U+2163 -> 0x8757 Roman Numeral Four
0xfa4e -> U+2164 -> 0x8758 Roman Numeral Five
0xfa4f -> U+2165 -> 0x8759 Roman Numeral Six
0xfa50 -> U+2166 -> 0x875a Roman Numeral Seven
0xfa51 -> U+2167 -> 0x875b Roman Numeral Eight
0xfa52 -> U+2168 -> 0x875c Roman Numeral Nine
0xfa53 -> U+2169 -> 0x875d Roman Numeral Ten
0xfa54 -> U+ffe2 -> 0x81ca Fullwidth Not Sign
0xfa58 -> U+3231 -> 0x878a Parenthesized Ideograph Stock
0xfa59 -> U+2116 -> 0x8782 Numero Sign
0xfa5a -> U+2121 -> 0x8784 Telephone Sign
0xfa5b -> U+2235 -> 0x81e6 Because"))
(with-input-from-string (s kb170559)
(loop for line = (read-line s nil) until (null line)
do (let ((ucs (parse-integer (subseq line 14 18) :radix 16))
(cp932 (parse-integer (subseq line 26 30) :radix 16)))
(setf (gethash ucs *ucs-to-cp932-hash*) cp932)))))
(defun eucjp-to-ucs (code)
(values (gethash code *eucjp-to-ucs-hash*)))
(defun ucs-to-eucjp (code)
(values (gethash code *ucs-to-eucjp-hash*)))
(defun cp932-to-ucs (code)
(values (gethash code *cp932-to-ucs-hash*)))
(defun ucs-to-cp932 (code)
(values (gethash code *ucs-to-cp932-hash*)))
;;;; EUC-JP
(define-character-encoding :eucjp
"An 8-bit, variable-length character encoding in which
character code points in the range #x00-#x7f can be encoded in a
single octet; characters with larger code values can be encoded
in 2 to 3 bytes."
:max-units-per-char 3
:literal-char-code-limit #x80)
(define-octet-counter :eucjp (getter type)
`(named-lambda eucjp-octet-counter (seq start end max)
(declare (type ,type seq) (fixnum start end max))
(loop with noctets fixnum = 0
for i fixnum from start below end
for code of-type code-point = (,getter seq i)
do (let* ((c (ucs-to-eucjp code))
(new (+ (cond ((< #xffff c) 3)
((< #xff c) 2)
(t 1))
noctets)))
(if (and (plusp max) (> new max))
(loop-finish)
(setq noctets new)))
finally (return (values noctets i)))))
(define-code-point-counter :eucjp (getter type)
`(named-lambda eucjp-code-point-counter (seq start end max)
(declare (type ,type seq) (fixnum start end max))
(loop with nchars fixnum = 0
with i fixnum = start
while (< i end) do
(let* ((octet (,getter seq i))
(next-i (+ i (cond ((= #x8f octet) 3)
((or (< #xa0 octet #xff)
(= #x8e octet)) 2)
(t 1)))))
(declare (type ub8 octet) (fixnum next-i))
(cond ((> next-i end)
;; Should we add restarts to this error, we'll have
;; to figure out a way to communicate with the
;; decoder since we probably want to do something
;; about it right here when we have a chance to
;; change the count or something. (Like an
;; alternative replacement character or perhaps the
;; existence of this error so that the decoder
;; doesn't have to check for it on every iteration
;; like we do.)
;;
;; FIXME: The data for this error is not right.
(decoding-error (vector octet) :eucjp seq i
nil 'end-of-input-in-character)
(return (values (1+ nchars) end)))
(t
(setq nchars (1+ nchars)
i next-i)
(when (and (plusp max) (= nchars max))
(return (values nchars i))))))
finally (progn (assert (= i end))
(return (values nchars i))))))
(define-encoder :eucjp (getter src-type setter dest-type)
`(named-lambda eucjp-encoder (src start end dest d-start)
(declare (type ,src-type src)
(type ,dest-type dest)
(fixnum start end d-start))
(loop with di fixnum = d-start
for i fixnum from start below end
for code of-type code-point = (,getter src i)
for eucjp of-type code-point
= (ucs-to-eucjp code) do
(macrolet ((set-octet (offset value)
`(,',setter ,value dest (the fixnum (+ di ,offset)))))
(cond
;; 1 octet
((< eucjp #x100)
(set-octet 0 eucjp)
(incf di))
;; 2 octets
((< eucjp #x10000)
(set-octet 0 (f-logand #xff (f-ash eucjp -8)))
(set-octet 1 (logand eucjp #xff))
(incf di 2))
;; 3 octets
(t
(set-octet 0 (f-logand #xff (f-ash eucjp -16)))
(set-octet 1 (f-logand #xff (f-ash eucjp -8)))
(set-octet 2 (logand eucjp #xff))
(incf di 3))
))
finally (return (the fixnum (- di d-start))))))
(define-decoder :eucjp (getter src-type setter dest-type)
`(named-lambda eucjp-decoder (src start end dest d-start)
(declare (type ,src-type src)
(type ,dest-type dest)
(fixnum start end d-start))
(let ((u2 0))
(declare (type ub8 u2))
(loop for di fixnum from d-start
for i fixnum from start below end
for u1 of-type ub8 = (,getter src i) do
;; Note: CONSUME-OCTET doesn't check if I is being
;; incremented past END. We're assuming that END has
;; been calculated with the CODE-POINT-POINTER above that
;; checks this.
(macrolet
((consume-octet ()
`(let ((next-i (incf i)))
(if (= next-i end)
;; FIXME: data for this error is incomplete.
;; and signalling this error twice
(return-from setter-block
(decoding-error nil :eucjp src i +repl+
'end-of-input-in-character))
(,',getter src next-i))))
(handle-error (n &optional (c 'character-decoding-error))
`(decoding-error
(vector ,@(subseq '(u1 u2) 0 n))
:eucjp src (1+ (- i ,n)) +repl+ ',c))
(handle-error-if-icb (var n)
`(when (not (< #x7f ,var #xc0))
(decf i)
(return-from setter-block
(handle-error ,n invalid-utf8-continuation-byte)))))
(,setter
(block setter-block
(cond
;; 3 octets
((= u1 #x8f)
(setq u2 (consume-octet))
(eucjp-to-ucs (logior #x8f0000
(f-ash u2 8)
(consume-octet))))
;; 2 octets
((or (= u1 #x8e)
(< #xa0 u1 #xff))
(eucjp-to-ucs (logior (f-ash u1 8)
(consume-octet))))
;; 1 octet
(t
(eucjp-to-ucs u1))))
dest di))
finally (return (the fixnum (- di d-start)))))))
;;;; CP932
(define-character-encoding :cp932
"An 8-bit, variable-length character encoding in which
character code points in the range #x00-#x7f can be encoded in a
single octet; characters with larger code values can be encoded
in 2 bytes."
:max-units-per-char 2
:literal-char-code-limit #x80)
(define-octet-counter :cp932 (getter type)
`(named-lambda cp932-octet-counter (seq start end max)
(declare (type ,type seq) (fixnum start end max))
(loop with noctets fixnum = 0
for i fixnum from start below end
for code of-type code-point = (,getter seq i)
do (let* ((c (ucs-to-cp932 code))
(new (+ (cond ((< #xff c) 2)
(t 1))
noctets)))
(if (and (plusp max) (> new max))
(loop-finish)
(setq noctets new)))
finally (return (values noctets i)))))
(define-code-point-counter :cp932 (getter type)
`(named-lambda cp932-code-point-counter (seq start end max)
(declare (type ,type seq) (fixnum start end max))
(loop with nchars fixnum = 0
with i fixnum = start
while (< i end) do
(let* ((octet (,getter seq i))
(next-i (+ i (cond ((or (<= #x81 octet #x9f)
(<= #xe0 octet #xfc))
2)
(t 1)))))
(declare (type ub8 octet) (fixnum next-i))
(cond ((> next-i end)
;; Should we add restarts to this error, we'll have
;; to figure out a way to communicate with the
;; decoder since we probably want to do something
;; about it right here when we have a chance to
;; change the count or something. (Like an
;; alternative replacement character or perhaps the
;; existence of this error so that the decoder
;; doesn't have to check for it on every iteration
;; like we do.)
;;
;; FIXME: The data for this error is not right.
(decoding-error (vector octet) :cp932 seq i
nil 'end-of-input-in-character)
(return (values (1+ nchars) end)))
(t
(setq nchars (1+ nchars)
i next-i)
(when (and (plusp max) (= nchars max))
(return (values nchars i))))))
finally (progn (assert (= i end))
(return (values nchars i))))))
(define-encoder :cp932 (getter src-type setter dest-type)
`(named-lambda cp932-encoder (src start end dest d-start)
(declare (type ,src-type src)
(type ,dest-type dest)
(fixnum start end d-start))
(loop with di fixnum = d-start
for i fixnum from start below end
for code of-type code-point = (,getter src i)
for cp932 of-type code-point
= (ucs-to-cp932 code) do
(macrolet ((set-octet (offset value)
`(,',setter ,value dest (the fixnum (+ di ,offset)))))
(cond
;; 1 octet
((< cp932 #x100)
(set-octet 0 cp932)
(incf di))
;; 2 octets
((< cp932 #x10000)
(set-octet 0 (f-logand #xff (f-ash cp932 -8)))
(set-octet 1 (logand cp932 #xff))
(incf di 2))
;; 3 octets
(t
(set-octet 0 (f-logand #xff (f-ash cp932 -16)))
(set-octet 1 (f-logand #xff (f-ash cp932 -8)))
(set-octet 2 (logand cp932 #xff))
(incf di 3))
))
finally (return (the fixnum (- di d-start))))))
(define-decoder :cp932 (getter src-type setter dest-type)
`(named-lambda cp932-decoder (src start end dest d-start)
(declare (type ,src-type src)
(type ,dest-type dest)
(fixnum start end d-start))
(let ((u2 0))
(declare (type ub8 u2))
(loop for di fixnum from d-start
for i fixnum from start below end
for u1 of-type ub8 = (,getter src i) do
;; Note: CONSUME-OCTET doesn't check if I is being
;; incremented past END. We're assuming that END has
;; been calculated with the CODE-POINT-POINTER above that
;; checks this.
(macrolet
((consume-octet ()
`(let ((next-i (incf i)))
(if (= next-i end)
;; FIXME: data for this error is incomplete.
;; and signalling this error twice
(return-from setter-block
(decoding-error nil :cp932 src i +repl+
'end-of-input-in-character))
(,',getter src next-i))))
(handle-error (n &optional (c 'character-decoding-error))
`(decoding-error
(vector ,@(subseq '(u1 u2) 0 n))
:cp932 src (1+ (- i ,n)) +repl+ ',c))
(handle-error-if-icb (var n)
`(when (not (< #x7f ,var #xc0))
(decf i)
(return-from setter-block
(handle-error ,n invalid-utf8-continuation-byte)))))
(,setter
(block setter-block
(cond
;; 2 octets
((or (<= #x81 u1 #x9f)
(<= #xe0 u1 #xfc))
(setq u2 (consume-octet))
(cp932-to-ucs (logior (f-ash u1 8)
u2)))
;; 1 octet
(t
(cp932-to-ucs u1))))
dest di))
finally (return (the fixnum (- di d-start)))))))
| 37,967 | Common Lisp | .lisp | 740 | 43.089189 | 88 | 0.580161 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | b6100a38c0563993985e66bedda753e332d158c7aab2601afd05bfffa89bc4e1 | 30,614 | [
233385
] |
30,619 | enc-koi8.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/babel-20150608-git/src/enc-koi8.lisp | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; enc-cp1251.lisp --- Implementation of the CP1251 character encoding.
;;;
;;; Copyright (C) 2009, Andrey Moskvitin
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
(in-package #:babel-encodings)
(define-character-encoding :koi8-ru
"An 8-bit, fixed-width character Russian encoding."
:literal-char-code-limit #x80)
(define-constant +koi8-ru-to-unicode+
#(#x2500 #x2502 #x250C #x2510 #x2514 #x2518 #x251C #x2524
#x252C #x2534 #x253C #x2580 #x2584 #x2588 #x258C #x2590
#x2591 #x2592 #x2593 #x2320 #x25A0 #x2219 #x221A #x2248
#x2264 #x2265 #x00A0 #x2321 #x00B0 #x00B2 #x00B7 #x00F7
#x2550 #x2551 #x2552 #x0451 #x0454 #x2554 #x0456 #x0457
#x2557 #x2558 #x2559 #x255A #x255B #x0491 #x045E #x255E
#x255F #x2560 #x2561 #x0401 #x0404 #x2563 #x0406 #x0407
#x2566 #x2567 #x2568 #x2569 #x256A #x0490 #x040E #x00A9
#x044E #x0430 #x0431 #x0446 #x0434 #x0435 #x0444 #x0433
#x0445 #x0438 #x0439 #x043A #x043B #x043C #x043D #x043E
#x043F #x044F #x0440 #x0441 #x0442 #x0443 #x0436 #x0432
#x044C #x044B #x0437 #x0448 #x044D #x0449 #x0447 #x044A
#x042E #x0410 #x0411 #x0426 #x0414 #x0415 #x0424 #x0413
#x0425 #x0418 #x0419 #x041A #x041B #x041C #x041D #x041E
#x041F #x042F #x0420 #x0421 #x0422 #x0423 #x0416 #x0412
#x042C #x042B #x0417 #x0428 #x042D #x0429 #x0427 #x042A)
:test #'equalp)
(define-unibyte-decoder :koi8-ru (octet)
(if (< octet #x80)
octet
(svref +koi8-ru-to-unicode+ (the ub8 (- octet #x80)))))
(define-constant +unicode-04->koi8-ru+
#(#x7f #x79 #x78 #x7c #x60 #x71 #x41 #x42 #x57 #x47 #x44 #x45 #x56 #x5a
#x49 #x4a #x4b #x4c #x4d #x4e #x4f #x50 #x52 #x53 #x54 #x55 #x46 #x48
#x43 #x5e #x5b #x5d #x5f #x59 #x58 #x5c #x40 #x51 nil #x23 nil nil #x24
nil #x26 #x27 nil nil nil nil nil nil #x2e nil nil nil nil nil nil nil
nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil
nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil
nil nil nil nil nil nil #x3d #x2d)
:test 'equalp)
(define-unibyte-encoder :koi8-ru (code)
(or (and (< code #x80) code)
(let ((hi (ldb (byte 8 8) code))
(lo (ldb (byte 8 0) code)))
(case hi
(#x4
(case lo
(#x1 #xb3)
(#x4 #xb4)
(#x6 #xb6)
(#x7 #xb7)
(#xe #xbe)
(#x10 #xe1)
(#x11 #xe2)
(#x12 #xf7)
(#x13 #xe7)
(#x14 #xe4)
(#x15 #xe5)
(#x16 #xf6)
(#x17 #xfa)
(#x18 #xe9)
(#x19 #xea)
(#x1a #xeb)
(#x1b #xec)
(#x1c #xed)
(#x1d #xee)
(#x1e #xef)
(#x1f #xf0)
(#x20 #xf2)
(#x21 #xf3)
(#x22 #xf4)
(#x23 #xf5)
(#x24 #xe6)
(#x25 #xe8)
(#x26 #xe3)
(#x27 #xfe)
(#x28 #xfb)
(#x29 #xfd)
(#x2a #xff)
(#x2b #xf9)
(#x2c #xf8)
(#x2d #xfc)
(#x2e #xe0)
(#x2f #xf1)
(#x30 #xc1)
(#x31 #xc2)
(#x32 #xd7)
(#x33 #xc7)
(#x34 #xc4)
(#x35 #xc5)
(#x36 #xd6)
(#x37 #xda)
(#x38 #xc9)
(#x39 #xca)
(#x3a #xcb)
(#x3b #xcc)
(#x3c #xcd)
(#x3d #xce)
(#x3e #xcf)
(#x3f #xd0)
(#x40 #xd2)
(#x41 #xd3)
(#x42 #xd4)
(#x43 #xd5)
(#x44 #xc6)
(#x45 #xc8)
(#x46 #xc3)
(#x47 #xde)
(#x48 #xdb)
(#x49 #xdd)
(#x4a #xdf)
(#x4b #xd9)
(#x4c #xd8)
(#x4d #xdc)
(#x4e #xc0)
(#x4f #xd1)
(#x51 #xa3)
(#x54 #xa4)
(#x56 #xa6)
(#x57 #xa7)
(#x5e #xae)
(#x90 #xbd)
(#x91 #xad)))
(#x0
(case lo
(#xa0 #x9a)
(#xa9 #xbf)
(#xb0 #x9c)
(#xb2 #x9d)
(#xb7 #x9e)
(#xf7 #x9f)))
(#x22 (case lo (#x19 #x95) (#x1a #x96) (#x48 #x97) (#x64 #x98) (#x65 #x99)))
(#x23 (case lo (#x20 #x93) (#x21 #x9b)))
(#x25
(case lo
(#x0 #x80)
(#x2 #x81)
(#xc #x82)
(#x10 #x83)
(#x14 #x84)
(#x18 #x85)
(#x1c #x86)
(#x24 #x87)
(#x2c #x88)
(#x34 #x89)
(#x3c #x8a)
(#x50 #xa0)
(#x51 #xa1)
(#x52 #xa2)
(#x54 #xa5)
(#x57 #xa8)
(#x58 #xa9)
(#x59 #xaa)
(#x5a #xab)
(#x5b #xac)
(#x5e #xaf)
(#x5f #xb0)
(#x60 #xb1)
(#x61 #xb2)
(#x63 #xb5)
(#x66 #xb8)
(#x67 #xb9)
(#x68 #xba)
(#x69 #xbb)
(#x6a #xbc)
(#x80 #x8b)
(#x84 #x8c)
(#x88 #x8d)
(#x8c #x8e)
(#x90 #x8f)
(#x91 #x90)
(#x92 #x91)
(#x93 #x92)
(#xa0 #x94)))))
(handle-error)))
(define-character-encoding :koi8-r
"An 8-bit, fixed-width character Russian encoding."
:literal-char-code-limit #x80)
(define-constant +koi8-r-to-unicode+
#(#x2500 #x2502 #x250C #x2510 #x2514 #x2518 #x251C #x2524
#x252C #x2534 #x253C #x2580 #x2584 #x2588 #x258C #x2590
#x2591 #x2592 #x2593 #x2320 #x25A0 #x2219 #x221A #x2248
#x2264 #x2265 #x00A0 #x2321 #x00B0 #x00B2 #x00B7 #x00F7
#x2550 #x2551 #x2552 #x0451 #x2553 #x2554 #x2555 #x2556
#x2557 #x2558 #x2559 #x255A #x255B #x255C #x255D #x255E
#x255F #x2560 #x2561 #x0401 #x2562 #x2563 #x2564 #x2565
#x2566 #x2567 #x2568 #x2569 #x256A #x256B #x256C #x00A9
#x044E #x0430 #x0431 #x0446 #x0434 #x0435 #x0444 #x0433
#x0445 #x0438 #x0439 #x043A #x043B #x043C #x043D #x043E
#x043F #x044F #x0440 #x0441 #x0442 #x0443 #x0436 #x0432
#x044C #x044B #x0437 #x0448 #x044D #x0449 #x0447 #x044A
#x042E #x0410 #x0411 #x0426 #x0414 #x0415 #x0424 #x0413
#x0425 #x0418 #x0419 #x041A #x041B #x041C #x041D #x041E
#x041F #x042F #x0420 #x0421 #x0422 #x0423 #x0416 #x0412
#x042C #x042B #x0417 #x0428 #x042D #x0429 #x0427 #x042A)
:test #'equalp)
(define-unibyte-decoder :koi8-r (octet)
(if (< octet #x80)
octet
(svref +koi8-r-to-unicode+ (the ub8 (- octet #x80)))))
(define-constant +unicode-x04->koi8-r+
#(nil #x33 nil nil nil nil nil nil nil nil nil nil nil nil nil nil #x61
#x62 #x77 #x67 #x64 #x65 #x76 #x7a #x69 #x6a #x6b #x6c #x6d #x6e #x6f
#x70 #x72 #x73 #x74 #x75 #x66 #x68 #x63 #x7e #x7b #x7d #x7f #x79 #x78
#x7c #x60 #x71 #x41 #x42 #x57 #x47 #x44 #x45 #x56 #x5a #x49 #x4a #x4b
#x4c #x4d #x4e #x4f #x50 #x52 #x53 #x54 #x55 #x46 #x48 #x43 #x5e #x5b
#x5d #x5f #x59 #x58 #x5c #x40 #x51 nil #x23)
:test 'equalp)
(define-constant +unicode-x25->koi8-r+
#(#x0 nil #x1 nil nil nil nil nil nil nil nil nil #x2 nil nil nil #x3 nil
nil nil #x4 nil nil nil #x5 nil nil nil #x6 nil nil nil nil nil nil nil
#x7 nil nil nil nil nil nil nil #x8 nil nil nil nil nil nil nil #x9 nil
nil nil nil nil nil nil #xa nil nil nil nil nil nil nil nil nil nil nil
nil nil nil nil nil nil nil nil #x20 #x21 #x22 #x24 #x25 #x26 #x27 #x28
#x29 #x2a #x2b #x2c #x2d #x2e #x2f #x30 #x31 #x32 #x34 #x35 #x36 #x37
#x38 #x39 #x3a #x3b #x3c #x3d #x3e nil nil nil nil nil nil nil nil nil
nil nil nil nil nil nil nil nil nil nil #xb nil nil nil #xc nil nil nil
#xd nil nil nil #xe nil nil nil #xf #x10 #x11 #x12 nil nil nil nil nil
nil nil nil nil nil nil nil #x14)
:test 'equalp)
(define-unibyte-encoder :koi8-r (code)
(or (and (< code #x80) code)
(let ((hi (ldb (byte 8 8) code))
(lo (ldb (byte 8 0) code)))
(case hi
(#x4
(case lo
(#x1 #xb3)
(#x10 #xe1)
(#x11 #xe2)
(#x12 #xf7)
(#x13 #xe7)
(#x14 #xe4)
(#x15 #xe5)
(#x16 #xf6)
(#x17 #xfa)
(#x18 #xe9)
(#x19 #xea)
(#x1a #xeb)
(#x1b #xec)
(#x1c #xed)
(#x1d #xee)
(#x1e #xef)
(#x1f #xf0)
(#x20 #xf2)
(#x21 #xf3)
(#x22 #xf4)
(#x23 #xf5)
(#x24 #xe6)
(#x25 #xe8)
(#x26 #xe3)
(#x27 #xfe)
(#x28 #xfb)
(#x29 #xfd)
(#x2a #xff)
(#x2b #xf9)
(#x2c #xf8)
(#x2d #xfc)
(#x2e #xe0)
(#x2f #xf1)
(#x30 #xc1)
(#x31 #xc2)
(#x32 #xd7)
(#x33 #xc7)
(#x34 #xc4)
(#x35 #xc5)
(#x36 #xd6)
(#x37 #xda)
(#x38 #xc9)
(#x39 #xca)
(#x3a #xcb)
(#x3b #xcc)
(#x3c #xcd)
(#x3d #xce)
(#x3e #xcf)
(#x3f #xd0)
(#x40 #xd2)
(#x41 #xd3)
(#x42 #xd4)
(#x43 #xd5)
(#x44 #xc6)
(#x45 #xc8)
(#x46 #xc3)
(#x47 #xde)
(#x48 #xdb)
(#x49 #xdd)
(#x4a #xdf)
(#x4b #xd9)
(#x4c #xd8)
(#x4d #xdc)
(#x4e #xc0)
(#x4f #xd1)
(#x51 #xa3)))
(#x0
(case lo
(#xa0 #x9a)
(#xa9 #xbf)
(#xb0 #x9c)
(#xb2 #x9d)
(#xb7 #x9e)
(#xf7 #x9f)))
(#x22 (case lo (#x19 #x95) (#x1a #x96) (#x48 #x97) (#x64 #x98) (#x65 #x99)))
(#x23 (case lo (#x20 #x93) (#x21 #x9b)))
(#x25
(case lo
(#x0 #x80)
(#x2 #x81)
(#xc #x82)
(#x10 #x83)
(#x14 #x84)
(#x18 #x85)
(#x1c #x86)
(#x24 #x87)
(#x2c #x88)
(#x34 #x89)
(#x3c #x8a)
(#x50 #xa0)
(#x51 #xa1)
(#x52 #xa2)
(#x53 #xa4)
(#x54 #xa5)
(#x55 #xa6)
(#x56 #xa7)
(#x57 #xa8)
(#x58 #xa9)
(#x59 #xaa)
(#x5a #xab)
(#x5b #xac)
(#x5c #xad)
(#x5d #xae)
(#x5e #xaf)
(#x5f #xb0)
(#x60 #xb1)
(#x61 #xb2)
(#x62 #xb4)
(#x63 #xb5)
(#x64 #xb6)
(#x65 #xb7)
(#x66 #xb8)
(#x67 #xb9)
(#x68 #xba)
(#x69 #xbb)
(#x6a #xbc)
(#x6b #xbd)
(#x6c #xbe)
(#x80 #x8b)
(#x84 #x8c)
(#x88 #x8d)
(#x8c #x8e)
(#x90 #x8f)
(#x91 #x90)
(#x92 #x91)
(#x93 #x92)
(#xa0 #x94)))))
(handle-error)))
(define-character-encoding :koi8-u
"An 8-bit, fixed-width character Ukranian encoding."
:literal-char-code-limit #x80)
(define-constant +koi8-u-to-unicode+
#(#x2500 #x2502 #x250C #x2510 #x2514 #x2518 #x251C #x2524
#x252C #x2534 #x253C #x2580 #x2584 #x2588 #x258C #x2590
#x2591 #x2592 #x2593 #x2320 #x25A0 #x2219 #x221A #x2248
#x2264 #x2265 #x00A0 #x2321 #x00B0 #x00B2 #x00B7 #x00F7
#x2550 #x2551 #x2552 #x0451 #x0454 #x2554 #x0456 #x0457
#x2557 #x2558 #x2559 #x255A #x255B #x0491 #x255D #x255E
#x255F #x2560 #x2561 #x0401 #x0404 #x2563 #x0406 #x0407
#x2566 #x2567 #x2568 #x2569 #x256A #x0490 #x256C #x00A9
#x044E #x0430 #x0431 #x0446 #x0434 #x0435 #x0444 #x0433
#x0445 #x0438 #x0439 #x043A #x043B #x043C #x043D #x043E
#x043F #x044F #x0440 #x0441 #x0442 #x0443 #x0436 #x0432
#x044C #x044B #x0437 #x0448 #x044D #x0449 #x0447 #x044A
#x042E #x0410 #x0411 #x0426 #x0414 #x0415 #x0424 #x0413
#x0425 #x0418 #x0419 #x041A #x041B #x041C #x041D #x041E
#x041F #x042F #x0420 #x0421 #x0422 #x0423 #x0416 #x0412
#x042C #x042B #x0417 #x0428 #x042D #x0429 #x0427 #x042A )
:test #'equalp)
(define-unibyte-decoder :koi8-u (octet)
(if (< octet #x80)
octet
(svref +koi8-u-to-unicode+ (the ub8 (- octet #x80)))))
(define-constant +unicode-x04->koi8-u+
#(nil #x33 nil nil #x34 nil #x36 #x37 nil nil nil nil nil nil nil nil #x61
#x62 #x77 #x67 #x64 #x65 #x76 #x7a #x69 #x6a #x6b #x6c #x6d #x6e #x6f
#x70 #x72 #x73 #x74 #x75 #x66 #x68 #x63 #x7e #x7b #x7d #x7f #x79 #x78
#x7c #x60 #x71 #x41 #x42 #x57 #x47 #x44 #x45 #x56 #x5a #x49 #x4a #x4b
#x4c #x4d #x4e #x4f #x50 #x52 #x53 #x54 #x55 #x46 #x48 #x43 #x5e #x5b
#x5d #x5f #x59 #x58 #x5c #x40 #x51 nil #x23 nil nil #x24 nil #x26 #x27
nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil
nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil
nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil
nil nil #x3d #x2d)
:test 'equalp)
(define-constant +unicode-x25->koi8-u+
#(#x0 nil #x1 nil nil nil nil nil nil nil nil nil #x2 nil nil nil #x3 nil
nil nil #x4 nil nil nil #x5 nil nil nil #x6 nil nil nil nil nil nil nil
#x7 nil nil nil nil nil nil nil #x8 nil nil nil nil nil nil nil #x9 nil
nil nil nil nil nil nil #xa nil nil nil nil nil nil nil nil nil nil nil
nil nil nil nil nil nil nil nil #x20 #x21 #x22 nil #x25 nil nil #x28
#x29 #x2a #x2b #x2c nil #x2e #x2f #x30 #x31 #x32 nil #x35 nil nil #x38
#x39 #x3a #x3b #x3c nil #x3e nil nil nil nil nil nil nil nil nil nil nil
nil nil nil nil nil nil nil nil #xb nil nil nil #xc nil nil nil #xd nil
nil nil #xe nil nil nil #xf #x10 #x11 #x12 nil nil nil nil nil nil nil
nil nil nil nil nil #x14)
:test 'equalp)
(define-unibyte-encoder :koi8-u (code)
(or (and (< code #x80) code)
(let ((hi (ldb (byte 8 8) code))
(lo (ldb (byte 8 0) code)))
(case hi
(#x4
(case lo
(#x1 #xb3)
(#x4 #xb4)
(#x6 #xb6)
(#x7 #xb7)
(#x10 #xe1)
(#x11 #xe2)
(#x12 #xf7)
(#x13 #xe7)
(#x14 #xe4)
(#x15 #xe5)
(#x16 #xf6)
(#x17 #xfa)
(#x18 #xe9)
(#x19 #xea)
(#x1a #xeb)
(#x1b #xec)
(#x1c #xed)
(#x1d #xee)
(#x1e #xef)
(#x1f #xf0)
(#x20 #xf2)
(#x21 #xf3)
(#x22 #xf4)
(#x23 #xf5)
(#x24 #xe6)
(#x25 #xe8)
(#x26 #xe3)
(#x27 #xfe)
(#x28 #xfb)
(#x29 #xfd)
(#x2a #xff)
(#x2b #xf9)
(#x2c #xf8)
(#x2d #xfc)
(#x2e #xe0)
(#x2f #xf1)
(#x30 #xc1)
(#x31 #xc2)
(#x32 #xd7)
(#x33 #xc7)
(#x34 #xc4)
(#x35 #xc5)
(#x36 #xd6)
(#x37 #xda)
(#x38 #xc9)
(#x39 #xca)
(#x3a #xcb)
(#x3b #xcc)
(#x3c #xcd)
(#x3d #xce)
(#x3e #xcf)
(#x3f #xd0)
(#x40 #xd2)
(#x41 #xd3)
(#x42 #xd4)
(#x43 #xd5)
(#x44 #xc6)
(#x45 #xc8)
(#x46 #xc3)
(#x47 #xde)
(#x48 #xdb)
(#x49 #xdd)
(#x4a #xdf)
(#x4b #xd9)
(#x4c #xd8)
(#x4d #xdc)
(#x4e #xc0)
(#x4f #xd1)
(#x51 #xa3)
(#x54 #xa4)
(#x56 #xa6)
(#x57 #xa7)
(#x90 #xbd)
(#x91 #xad)))
(#x0
(case lo
(#xa0 #x9a)
(#xa9 #xbf)
(#xb0 #x9c)
(#xb2 #x9d)
(#xb7 #x9e)
(#xf7 #x9f)))
(#x22 (case lo (#x19 #x95) (#x1a #x96) (#x48 #x97) (#x64 #x98) (#x65 #x99)))
(#x23 (case lo (#x20 #x93) (#x21 #x9b)))
(#x25
(case lo
(#x0 #x80)
(#x2 #x81)
(#xc #x82)
(#x10 #x83)
(#x14 #x84)
(#x18 #x85)
(#x1c #x86)
(#x24 #x87)
(#x2c #x88)
(#x34 #x89)
(#x3c #x8a)
(#x50 #xa0)
(#x51 #xa1)
(#x52 #xa2)
(#x54 #xa5)
(#x57 #xa8)
(#x58 #xa9)
(#x59 #xaa)
(#x5a #xab)
(#x5b #xac)
(#x5d #xae)
(#x5e #xaf)
(#x5f #xb0)
(#x60 #xb1)
(#x61 #xb2)
(#x63 #xb5)
(#x66 #xb8)
(#x67 #xb9)
(#x68 #xba)
(#x69 #xbb)
(#x6a #xbc)
(#x6c #xbe)
(#x80 #x8b)
(#x84 #x8c)
(#x88 #x8d)
(#x8c #x8e)
(#x90 #x8f)
(#x91 #x90)
(#x92 #x91)
(#x93 #x92)
(#xa0 #x94)))))
(handle-error)))
| 19,034 | Common Lisp | .lisp | 559 | 22.849732 | 86 | 0.451265 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | af7989b3b989ed64c9f03642804a95fe5044e4ec6c2b99e75694f4303f4fc8c3 | 30,619 | [
420451
] |
30,621 | enc-gbk.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/babel-20150608-git/src/enc-gbk.lisp | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; enc-gbk.lisp --- GBK encodings.
;;;
;;; Copyright (C) 2011, Li Wenpeng <[email protected]>
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
(in-package #:babel-encodings)
;; populated in gbk-map.lisp
(defvar *gbk-unicode-mapping*)
(defconstant +gbk2-offset+ 0)
(defconstant +gbk3-offset+ 6763)
(defconstant +gbk4-offset+ (+ 6763 6080))
(defconstant +gbk1-offset+ 20902)
(defconstant +gbk5-offset+ (+ 20902 846))
(define-character-encoding :gbk
"GBK is an extension of the GB2312 character set for simplified
Chinese characters, used in the People's Republic of China."
:max-units-per-char 4
:literal-char-code-limit #x80)
(define-condition invalid-gbk-byte (character-decoding-error)
()
(:documentation "Signalled when an invalid GBK byte is found."))
(define-condition invalid-gbk-character (character-encoding-error)
()
(:documentation "Signalled when an invalid GBK character is found."))
(define-octet-counter :gbk (getter type)
`(lambda (seq start end max)
(declare (type ,type seq) (fixnum start end max))
(let ((noctets 0))
(loop for i from start below end
for u1 of-type code-point = (,getter seq i)
do (cond ((< u1 #x80) (incf noctets))
(t (incf noctets 2)))
(when (and (plusp max) (= noctets max))
(return (values noctets i)))
finally (return (values noctets i))))))
(define-code-point-counter :gbk (getter type)
`(lambda (seq start end max)
(declare (type ,type seq))
(let (u1 (noctets 0))
(loop with i = start
while (< i end)
do (setf u1 (,getter seq i))
(cond
((eq 0 (logand u1 #x80)) (incf i))
(t (incf i 2)))
(incf noctets)
(when (and (plusp max) (= noctets max))
(return (values noctets i)))
finally (return (values noctets i))))))
(define-encoder :gbk (getter src-type setter dest-type)
`(lambda (src start end dest d-start)
(declare (type ,src-type src)
(type ,dest-type dest)
(fixnum start end d-start))
(macrolet
((do-encoding (index)
`(let ((u1 0) (u2 0))
(cond
((<= +gbk2-offset+ ,index (- +gbk3-offset+ 1)) ; gbk/2
(setf u1 (+ #xB0 (truncate (/ ,index 94))))
(setf u2 (+ #xA1 (mod ,index 94))))
((<= +gbk3-offset+ ,index (- +gbk4-offset+ 1)) ; gbk/3
(setf index (- ,index +gbk3-offset+))
(setf u1 (+ #x81 (truncate (/ ,index 190))))
(setf u2 (+ #x40 (mod ,index 190)))
(if (>= u2 #x7F) (incf u2)))
((<= +gbk4-offset+ ,index (- +gbk1-offset+ 1)) ; gbk/4
(setf index (- ,index +gbk4-offset+))
(setf u1 (+ #xAA (truncate (/ ,index 96))))
(setf u2 (+ #x40 (mod ,index 96)))
(if (>= u2 #x7F) (incf u2)))
((<= +gbk1-offset+ ,index (- +gbk5-offset+ 1)) ; gbk/1
(setf index (- ,index +gbk1-offset+))
(setf u1 (+ #xA1 (truncate (/ ,index 94))))
(setf u2 (+ #xA1 (mod ,index 94))))
((<= +gbk5-offset+ ,index (length *gbk-unicode-mapping*)) ; gbk/5
(setf index (- ,index +gbk5-offset+))
(setf u1 (+ #xA8 (truncate (/ ,index 96))))
(setf u2 (+ #x40 (mod ,index 96)))
(if (>= u2 #x7F) (incf u2))))
(values u1 u2))))
(let ((c 0) index (noctets 0))
(loop for i from start below end
for code of-type code-point = (,getter src i)
do (macrolet
((handle-error (&optional (c 'character-encoding-error))
`(encoding-error code :gbk src i +repl+ ',c)))
(setf c (code-char code))
(cond
((< code #x80) ; ascii
(,setter code dest noctets)
(incf noctets))
(t ; gbk
(setf index
(position c *gbk-unicode-mapping*))
(if (not index)
(handle-error invalid-gbk-character))
(multiple-value-bind (uh ul) (do-encoding index)
(,setter uh dest noctets)
(,setter ul dest (+ 1 noctets))
(incf noctets 2)))))
finally (return (the fixnum (- noctets d-start))))))))
(define-decoder :gbk (getter src-type setter dest-type)
`(lambda (src start end dest d-start)
(declare (type ,src-type src)
(type ,dest-type dest))
(let ((u1 0) (u2 0) (index 0) (tmp 0) (noctets 0))
(loop with i = start
while (< i end)
do (macrolet
((handle-error (&optional (c 'character-decoding-error))
`(decoding-error #(u1 u2) :gbk src i +repl+ ',c)))
(setf u1 (,getter src i))
(incf i)
(cond
((eq 0 (logand u1 #x80))
(,setter u1 dest noctets))
(t
(setf u2 (,getter src i))
(incf i)
(setf index
(block setter-block
(cond
((and (<= #xB0 u1 #xF7) (<= #xA1 u2 #xFE))
(+ +gbk2-offset+ (+ (* 94 (- u1 #xB0)) (- u2 #xA1))))
((and (<= #x81 u1 #xA0) (<= #x40 u2 #xFE))
(cond ((> u2 #x7F) (setf tmp 1))
(t (setf tmp 0)))
(+ +gbk3-offset+ (* 190 (- u1 #x81)) (- u2 #x40 tmp)))
((and (<= #xAA u1 #xFE) (<= #x40 #xA0))
(cond ((> u2 #x7F) (setf tmp 1))
(t (setf tmp 0)))
(+ +gbk4-offset+ (* 96 (- u1 #xAA)) (- u2 #x40 tmp)))
((and (<= #xA1 u1 #xA9) (<= #xA1 u2 #xFE))
(+ +gbk1-offset+ (* 94 (- u1 #xA1)) (- u2 #xA1)))
((and (<= #xA8 u1 #xA9) (<= #x40 #xA0))
(cond ((> u2 #x7F) (setf tmp 1))
(t (setf tmp 0)))
(+ +gbk5-offset+ (* 96 (- u1 #xA8)) (- u2 #x40 tmp)))
(t
(handle-error invalid-gbk-byte)))))
(when (>= index (length *gbk-unicode-mapping*))
(handle-error invalid-gbk-byte))
(,setter (char-code
(elt *gbk-unicode-mapping* index))
dest noctets)))
(incf noctets))
finally (return (the fixnum (- noctets d-start)))))))
| 8,297 | Common Lisp | .lisp | 168 | 34.654762 | 86 | 0.481696 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | f7fc0a0b9ef42990371a72f6e5333c71e8920debf924788b7828680c7d7abe03 | 30,621 | [
445749
] |
30,623 | enc-ebcdic-int.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/babel-20150608-git/src/enc-ebcdic-int.lisp | (in-package #:babel-encodings)
(define-character-encoding :ebcdic-international
"An 8-bit, fixed-width character encoding from IBM.")
(defparameter +ebcdic-int-to-unicode+
#(0 1 2 3 156 9 134 127 151 141 142 11 12 13 14 15 16 17 18 19 157 133 8 135
24 25 146 143 28 29 30 31 128 129 130 65535 132 10 23 27 65535 65535 138 139
65535 5 6 7 65535 65535 22 65535 148 149 150 4 65535 65535 65535 155 20 21
65535 26 32 65535 65535 65535 65535 65535 65535 65535 65535 65535 91 46 60
40 43 33 38 65535 65535 65535 65535 65535 65535 65535 65535 65535 93 164 42
41 59 172 45 47 65535 65535 65535 65535 65535 65535 65535 65535 124 44 37 95
62 63 65535 65535 65535 65535 65535 65535 1102 1072 1073 96 58 35 64 39 61
34 1094 97 98 99 100 101 102 103 104 105 1076 1077 1092 1075 1093 1080 1081
106 107 108 109 110 111 112 113 114 1082 1083 1084 1085 1086 1087 1103 126
115 116 117 118 119 120 121 122 1088 1089 1090 1091 1078 1074 1100 1099 1079
1096 1101 1097 1095 1098 1070 1040 1041 1062 1044 1045 1060 1043 123 65 66
67 68 69 70 71 72 73 1061 1048 1049 1050 1051 1052 125 74 75 76 77 78 79 80
81 82 1053 1054 1055 1071 1056 1057 92 65535 83 84 85 86 87 88 89 90 1058
1059 1046 1042 1068 1067 48 49 50 51 52 53 54 55 56 57 1047 1064 1069 1065
1063 159))
(defparameter +unicode-upto-ac-ebcdic-int+
#(0 1 2 3 55 45 46 47 22 5 37 11 12 13 14 15 16 17 18 19 60 61 50 38 24 25 63
39 28 29 30 31 64 79 127 123 0 108 80 125 77 93 92 78 107 96 75 97 240 241
242 243 244 245 246 247 248 249 122 94 76 126 110 111 124 193 194 195 196
197 198 199 200 201 209 210 211 212 213 214 215 216 217 226 227 228 229 230
231 232 233 74 224 90 0 109 121 129 130 131 132 133 134 135 136 137 145 146
147 148 149 150 151 152 153 162 163 164 165 166 167 168 169 192 106 208 161
7 32 33 34 0 36 21 6 23 0 0 42 43 0 9 10 27 0 0 26 0 52 53 54 8 0 0 0 59 4
20 0 255 0 0 0 0 91 0 0 0 0 0 0 0 95))
(defparameter +unicode-0410-0450-ebcdic-int+
#(185 186 237 191 188 189 236 250 203 204 205 206 207 218 219 220 222 223 234
235 190 202 187 254 251 253 0 239 238 252 184 221 119 120 175 141 138 139
174 178 143 144 154 155 156 157 158 159 170 171 172 173 140 142 128 182 179
181 183 177 176 180 118 160))
(define-unibyte-decoder :ebcdic-international (octet)
(svref +ebcdic-int-to-unicode+ (the ub8 octet)))
(define-unibyte-encoder :ebcdic-international (code)
(let ((result (cond
((<= code 172) (svref +unicode-upto-ac-ebcdic-int+ code))
((<= #x0410 code #x0450) (svref +unicode-0410-0450-ebcdic-int+
(- code #x0410))))))
(prog1 result
(when (and (zerop result) (plusp code))
(handle-error)))))
| 2,769 | Common Lisp | .lisp | 43 | 58.27907 | 80 | 0.687868 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 71a8065926e2ef82297b14c53dba705c8e69692d12d6f2ac70371721aaad2f80 | 30,623 | [
130918,
201479
] |
30,627 | streams.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/babel-20150608-git/src/streams.lisp | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; streams.lisp --- Conversions between strings and UB8 vectors.
;;;
;;; Copyright (c) 2005-2007, Dr. Edmund Weitz. All rights reserved.
;;; Copyright (c) 2008, Attila Lendvai. All rights reserved.
;;;
;;; Redistribution and use in source and binary forms, with or without
;;; modification, are permitted provided that the following conditions
;;; are met:
;;;
;;; * Redistributions of source code must retain the above copyright
;;; notice, this list of conditions and the following disclaimer.
;;;
;;; * Redistributions in binary form must reproduce the above
;;; copyright notice, this list of conditions and the following
;;; disclaimer in the documentation and/or other materials
;;; provided with the distribution.
;;;
;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
;;; STATUS
;;;
;;; - in-memory output streams support binary/bivalent/character
;;; element-types and file-position
;;; TODO
;;;
;;; - filter-stream types/mixins that can wrap a binary stream and
;;; turn it into a bivalent/character stream
;;; - in-memory input streams with file-position similar to in-memory
;;; output streams
;;; - in-memory input/output streams?
(in-package #:babel)
(defpackage #:babel-streams
(:use #:common-lisp #:babel #:trivial-gray-streams #:alexandria)
(:export
#:in-memory-stream
#:vector-output-stream
#:vector-input-stream
#:make-in-memory-output-stream
#:make-in-memory-input-stream
#:get-output-stream-sequence
#:with-output-to-sequence
#:with-input-from-sequence))
(in-package :babel-streams)
(declaim (inline check-if-open check-if-accepts-octets
check-if-accepts-characters stream-accepts-characters?
stream-accepts-octets? vector-extend
extend-vector-output-stream-buffer))
(defgeneric get-output-stream-sequence (stream &key &allow-other-keys))
;;;; Some utilities (on top due to inlining)
(defun vector-extend (extension vector &key (start 0) (end (length extension)))
;; copied over from cl-quasi-quote
(declare (optimize speed)
(type vector extension vector)
(type array-index start end))
(let* ((original-length (length vector))
(extension-length (- end start))
(new-length (+ original-length extension-length))
(original-dimension (array-dimension vector 0)))
(when (< original-dimension new-length)
(setf vector
(adjust-array vector (max (* 2 original-dimension) new-length))))
(setf (fill-pointer vector) new-length)
(replace vector extension :start1 original-length :start2 start :end2 end)
vector))
(defclass in-memory-stream (trivial-gray-stream-mixin)
((element-type ; :default means bivalent
:initform :default :initarg :element-type :accessor element-type-of)
(external-format
:initform (ensure-external-format *default-character-encoding*)
:initarg :external-format :accessor external-format-of)
#+cmu
(open-p
:initform t :accessor in-memory-stream-open-p
:documentation "For CMUCL we have to keep track of this manually."))
(:documentation "An IN-MEMORY-STREAM is a binary stream that reads octets
from or writes octets to a sequence in RAM."))
(defmethod stream-element-type ((self in-memory-stream))
;; stream-element-type is a CL symbol, we may not install an accessor on it.
;; so, go through this extra step.
(element-type-of self))
(defun stream-accepts-octets? (stream)
(let ((element-type (element-type-of stream)))
(or (eq element-type :default)
(equal element-type '(unsigned-byte 8))
(subtypep element-type '(unsigned-byte 8)))))
(defun stream-accepts-characters? (stream)
(let ((element-type (element-type-of stream)))
(member element-type '(:default character base-char))))
(defclass in-memory-input-stream (in-memory-stream fundamental-binary-input-stream)
()
(:documentation "An IN-MEMORY-INPUT-STREAM is a binary stream that reads
octets from a sequence in RAM."))
#+cmu
(defmethod output-stream-p ((stream in-memory-input-stream))
"Explicitly states whether this is an output stream."
(declare (optimize speed))
nil)
(defclass in-memory-output-stream (in-memory-stream
fundamental-binary-output-stream)
()
(:documentation "An IN-MEMORY-OUTPUT-STREAM is a binary stream that
writes octets to a sequence in RAM."))
#+cmu
(defmethod input-stream-p ((stream in-memory-output-stream))
"Explicitly states whether this is an input stream."
(declare (optimize speed))
nil)
(defun make-in-memory-output-stream (&key (element-type :default)
external-format
initial-buffer-size)
"Returns a binary output stream which accepts objects of type
ELEMENT-TYPE \(a subtype of OCTET) and makes available a sequence that
contains the octes that were actually output."
(declare (optimize speed))
(unless external-format
(setf external-format *default-character-encoding*))
(when (eq element-type :bivalent)
(setf element-type :default))
(make-instance 'vector-output-stream
:vector (make-vector-stream-buffer
:element-type
(cond
((or (eq element-type :default)
(equal element-type '(unsigned-byte 8)))
'(unsigned-byte 8))
((eq element-type 'character)
'character)
((subtypep element-type '(unsigned-byte 8))
'(unsigned-byte 8))
(t (error "Illegal element-type ~S" element-type)))
:initial-size initial-buffer-size)
:element-type element-type
:external-format (ensure-external-format external-format)))
(defun make-in-memory-input-stream (data &key (element-type :default)
external-format)
"Returns a binary input stream which provides the elements of DATA when read."
(declare (optimize speed))
(unless external-format
(setf external-format *default-character-encoding*))
(when (eq element-type :bivalent)
(setf element-type :default))
(make-instance 'vector-input-stream
:vector data
:element-type element-type
:end (length data)
:external-format (ensure-external-format external-format)))
(defclass vector-stream ()
((vector
:initarg :vector :accessor vector-stream-vector
:documentation "The underlying vector of the stream which \(for output)
must always be adjustable and have a fill pointer.")
(index
:initform 0 :initarg :index :accessor vector-stream-index
:type (integer 0 #.array-dimension-limit)
:documentation "An index into the underlying vector denoting the
current position."))
(:documentation
"A VECTOR-STREAM is a mixin for IN-MEMORY streams where the underlying
sequence is a vector."))
(defclass vector-input-stream (vector-stream in-memory-input-stream)
((end
:initarg :end :accessor vector-stream-end
:type (integer 0 #.array-dimension-limit)
:documentation "An index into the underlying vector denoting the end
of the available data."))
(:documentation "A binary input stream that gets its data from an
associated vector of octets."))
(defclass vector-output-stream (vector-stream in-memory-output-stream)
()
(:documentation
"A binary output stream that writes its data to an associated vector."))
(define-condition in-memory-stream-error (stream-error)
()
(:documentation "Superclass for all errors related to IN-MEMORY streams."))
(define-condition in-memory-stream-closed-error (in-memory-stream-error)
()
(:report (lambda (condition stream)
(format stream "~S is closed."
(stream-error-stream condition))))
(:documentation "An error that is signalled when someone is trying to read
from or write to a closed IN-MEMORY stream."))
(define-condition wrong-element-type-stream-error (stream-error)
((expected-type :accessor expected-type-of :initarg :expected-type))
(:report (lambda (condition output)
(let ((stream (stream-error-stream condition)))
(format output "The element-type of ~S is ~S while expecting ~
a stream that accepts ~S."
stream (element-type-of stream)
(expected-type-of condition))))))
(defun wrong-element-type-stream-error (stream expected-type)
(error 'wrong-element-type-stream-error
:stream stream :expected-type expected-type))
#+cmu
(defmethod open-stream-p ((stream in-memory-stream))
"Returns a true value if STREAM is open. See ANSI standard."
(declare (optimize speed))
(in-memory-stream-open-p stream))
#+cmu
(defmethod close ((stream in-memory-stream) &key abort)
"Closes the stream STREAM. See ANSI standard."
(declare (ignore abort) (optimize speed))
(prog1
(in-memory-stream-open-p stream)
(setf (in-memory-stream-open-p stream) nil)))
(defun check-if-open (stream)
"Checks if STREAM is open and signals an error otherwise."
(declare (optimize speed))
(unless (open-stream-p stream)
(error 'in-memory-stream-closed-error :stream stream)))
(defun check-if-accepts-octets (stream)
(declare (optimize speed))
(unless (stream-accepts-octets? stream)
(wrong-element-type-stream-error stream '(unsigned-byte 8))))
(defun check-if-accepts-characters (stream)
(declare (optimize speed))
(unless (stream-accepts-characters? stream)
(wrong-element-type-stream-error stream 'character)))
(defmethod stream-read-byte ((stream vector-input-stream))
"Reads one byte and increments INDEX pointer unless we're beyond END pointer."
(declare (optimize speed))
(check-if-open stream)
(let ((index (vector-stream-index stream)))
(cond ((< index (vector-stream-end stream))
(incf (vector-stream-index stream))
(aref (vector-stream-vector stream) index))
(t :eof))))
#+#:ignore
(defmethod stream-read-char ((stream vector-input-stream))
;; TODO
)
(defmethod stream-listen ((stream vector-input-stream))
"Checking whether INDEX is beyond END."
(declare (optimize speed))
(check-if-open stream)
(< (vector-stream-index stream) (vector-stream-end stream)))
(defmethod stream-read-sequence ((stream vector-input-stream)
sequence start end &key)
(declare (optimize speed) (type array-index start end))
;; TODO check the sequence type, assert for the element-type and use
;; the external-format.
(loop with vector-end of-type array-index = (vector-stream-end stream)
with vector = (vector-stream-vector stream)
for index from start below end
for vector-index of-type array-index = (vector-stream-index stream)
while (< vector-index vector-end)
do (setf (elt sequence index)
(aref vector vector-index))
(incf (vector-stream-index stream))
finally (return index)))
(defmethod stream-write-byte ((stream vector-output-stream) byte)
"Writes a byte \(octet) by extending the underlying vector."
(declare (optimize speed))
(check-if-open stream)
(check-if-accepts-octets stream)
(vector-push-extend byte (vector-stream-vector stream))
(incf (vector-stream-index stream))
byte)
(defun extend-vector-output-stream-buffer (extension stream &key (start 0)
(end (length extension)))
(declare (optimize speed)
(type array-index start end)
(type vector extension))
(vector-extend extension (vector-stream-vector stream) :start start :end end)
(incf (vector-stream-index stream) (- end start))
(values))
(defmethod stream-write-char ((stream vector-output-stream) char)
(declare (optimize speed))
(check-if-open stream)
(check-if-accepts-characters stream)
;; TODO this is naiive here, there's room for optimization
(let ((octets (string-to-octets (string char)
:encoding (external-format-of stream))))
(extend-vector-output-stream-buffer octets stream))
char)
(defmethod stream-write-sequence ((stream vector-output-stream)
sequence start end &key)
"Just calls VECTOR-PUSH-EXTEND repeatedly."
(declare (optimize speed)
(type array-index start end))
(etypecase sequence
(string
(if (stream-accepts-octets? stream)
;; TODO this is naiive here, there's room for optimization
(let ((octets (string-to-octets sequence
:encoding (external-format-of stream)
:start start
:end end)))
(extend-vector-output-stream-buffer octets stream))
(progn
(assert (stream-accepts-characters? stream))
(extend-vector-output-stream-buffer sequence stream
:start start :end end))))
((vector (unsigned-byte 8))
;; specialized branch to help inlining
(check-if-accepts-octets stream)
(extend-vector-output-stream-buffer sequence stream :start start :end end))
(vector
(check-if-accepts-octets stream)
(extend-vector-output-stream-buffer sequence stream :start start :end end)))
sequence)
(defmethod stream-write-string ((stream vector-output-stream)
string &optional (start 0) (end (length string)))
(stream-write-sequence stream string start (or end (length string))))
(defmethod stream-line-column ((stream vector-output-stream))
"Dummy line-column method that always returns NIL. Needed for
character output streams."
nil)
(defmethod stream-file-position ((stream vector-stream))
"Simply returns the index into the underlying vector."
(declare (optimize speed))
(vector-stream-index stream))
(defun make-vector-stream-buffer (&key (element-type '(unsigned-byte 8))
initial-size)
"Creates and returns an array which can be used as the underlying vector
for a VECTOR-OUTPUT-STREAM."
(declare (optimize speed)
(type (or null array-index) initial-size))
(make-array (the array-index (or initial-size 32))
:adjustable t
:fill-pointer 0
:element-type element-type))
(defmethod get-output-stream-sequence ((stream in-memory-output-stream) &key (return-as 'vector))
"Returns a vector containing, in order, all the octets that have
been output to the IN-MEMORY stream STREAM. This operation clears any
octets on STREAM, so the vector contains only those octets which have
been output since the last call to GET-OUTPUT-STREAM-SEQUENCE or since
the creation of the stream, whichever occurred most recently. If
AS-LIST is true the return value is coerced to a list."
(declare (optimize speed))
(prog1
(ecase return-as
(vector (vector-stream-vector stream))
(string (octets-to-string (vector-stream-vector stream)
:encoding (external-format-of stream)))
(list (coerce (vector-stream-vector stream) 'list)))
(setf (vector-stream-vector stream) (make-vector-stream-buffer))))
(defmacro with-output-to-sequence
((var &key (return-as ''vector) (element-type '':default)
(external-format '*default-character-encoding*) initial-buffer-size)
&body body)
"Creates an IN-MEMORY output stream, binds VAR to this stream and
then executes the code in BODY. The stream stores data of type
ELEMENT-TYPE \(a subtype of OCTET). The stream is automatically closed
on exit from WITH-OUTPUT-TO-SEQUENCE, no matter whether the exit is
normal or abnormal. The return value of this macro is a vector \(or a
list if AS-LIST is true) containing the octets that were sent to the
stream within BODY."
(multiple-value-bind (body declarations) (parse-body body)
;; this is here to stop SBCL complaining about binding them to NIL
`(let ((,var (make-in-memory-output-stream
:element-type ,element-type
:external-format ,external-format
:initial-buffer-size ,initial-buffer-size)))
,@declarations
(unwind-protect
(progn
,@body
(get-output-stream-sequence ,var :return-as ,return-as))
(close ,var)))))
(defmacro with-input-from-sequence
((var data &key (element-type '':default)
(external-format '*default-character-encoding*))
&body body)
"Creates an IN-MEMORY input stream that will return the values
available in DATA, binds VAR to this stream and then executes the code
in BODY. The stream stores data of type ELEMENT-TYPE \(a subtype of
OCTET). The stream is automatically closed on exit from
WITH-INPUT-FROM-SEQUENCE, no matter whether the exit is normal or
abnormal. The return value of this macro is the return value of BODY."
(multiple-value-bind (body declarations) (parse-body body)
;; this is here to stop SBCL complaining about binding them to NIL
`(let ((,var (make-in-memory-input-stream
,data :element-type ,element-type
:external-format ,external-format)))
,@declarations
(unwind-protect
(progn
,@body)
(close ,var)))))
| 18,456 | Common Lisp | .lisp | 390 | 40.046154 | 97 | 0.674029 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 1ebd9026fa123646c122982e410895917f8e7e21e49ab1944cec6252db6a43e9 | 30,627 | [
158420,
395502
] |
30,628 | enc-unicode.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/babel-20150608-git/src/enc-unicode.lisp | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; enc-unicode.lisp --- Unicode encodings.
;;;
;;; Copyright (C) 2007, Luis Oliveira <[email protected]>
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
;;; This implementation is largely based on OpenMCL's l1-unicode.lisp
;;; Copyright (C) 2006 Clozure Associates and contributors.
(in-package #:babel-encodings)
(eval-when (:compile-toplevel :load-toplevel :execute)
(defconstant +repl+ #xfffd "Unicode replacement character code point.")
(defconstant +byte-order-mark-code+ #xfeff)
(defconstant +swapped-byte-order-mark-code+ #xfffe)
(defconstant +swapped-byte-order-mark-code-32+ #xfffe0000))
;;; Some convenience macros adding FIXNUM declarations.
(defmacro f-ash (integer count) `(the fixnum (ash ,integer ,count)))
(defmacro f-logior (&rest integers) `(the fixnum (logior ,@integers)))
(defmacro f-logand (&rest integers) `(the fixnum (logand ,@integers)))
(defmacro f-logxor (&rest integers) `(the fixnum (logxor ,@integers)))
;;;; UTF-8
(define-character-encoding :utf-8
"An 8-bit, variable-length character encoding in which
character code points in the range #x00-#x7f can be encoded in a
single octet; characters with larger code values can be encoded
in 2 to 4 bytes."
:max-units-per-char 4
:literal-char-code-limit #x80
:bom-encoding #(#xef #xbb #xbf)
:default-replacement #xfffd)
(define-condition invalid-utf8-starter-byte (character-decoding-error)
()
(:documentation "Signalled when an invalid UTF-8 starter byte is found."))
(define-condition invalid-utf8-continuation-byte (character-decoding-error)
()
(:documentation
"Signalled when an invalid UTF-8 continuation byte is found."))
(define-condition overlong-utf8-sequence (character-decoding-error)
()
(:documentation "Signalled upon overlong UTF-8 sequences."))
(define-octet-counter :utf-8 (getter type)
`(named-lambda utf-8-octet-counter (seq start end max)
(declare (type ,type seq) (fixnum start end max))
(loop with noctets fixnum = 0
for i fixnum from start below end
for code of-type code-point = (,getter seq i) do
(let ((new (+ (cond ((< code #x80) 1)
((< code #x800) 2)
((< code #x10000) 3)
(t 4))
noctets)))
(if (and (plusp max) (> new max))
(loop-finish)
(setq noctets new)))
finally (return (values noctets i)))))
(define-code-point-counter :utf-8 (getter type)
`(named-lambda utf-8-code-point-counter (seq start end max)
(declare (type ,type seq) (fixnum start end max))
(loop with nchars fixnum = 0
with i fixnum = start
while (< i end) do
;; check for invalid continuation bytes
(macrolet ((invalid-cb-p (n)
`(and (< (+ i ,n) end)
(not (< #x7f (,',getter seq (+ i ,n)) #xc0)))))
;; wrote this code with LET instead of FOR because CLISP's
;; LOOP doesn't like WHILE clauses before FOR clauses.
(let* ((octet (,getter seq i))
(next-i (+ i (cond ((or (< octet #xc0) (invalid-cb-p 1)) 1)
((or (< octet #xe0) (invalid-cb-p 2)) 2)
((or (< octet #xf0) (invalid-cb-p 3)) 3)
((or (< octet #xf8) (invalid-cb-p 4)) 4)
((or (< octet #xfc) (invalid-cb-p 5)) 5)
(t 6)))))
(declare (type ub8 octet) (fixnum next-i))
(cond
((> next-i end)
;; Should we add restarts to this error, we'll have
;; to figure out a way to communicate with the
;; decoder since we probably want to do something
;; about it right here when we have a chance to
;; change the count or something. (Like an
;; alternative replacement character or perhaps the
;; existence of this error so that the decoder
;; doesn't have to check for it on every iteration
;; like we do.)
;;
;; FIXME: The data for this error is not right.
(decoding-error (vector octet) :utf-8 seq i
nil 'end-of-input-in-character)
(return (values (1+ nchars) end)))
(t
(setq nchars (1+ nchars)
i next-i)
(when (and (plusp max) (= nchars max))
(return (values nchars i)))))))
finally (progn
(assert (= i end))
(return (values nchars i))))))
(define-encoder :utf-8 (getter src-type setter dest-type)
`(named-lambda utf-8-encoder (src start end dest d-start)
(declare (type ,src-type src)
(type ,dest-type dest)
(fixnum start end d-start))
(loop with di fixnum = d-start
for i fixnum from start below end
for code of-type code-point = (,getter src i) do
(macrolet ((set-octet (offset value)
`(,',setter ,value dest (the fixnum (+ di ,offset)))))
(cond
;; 1 octet
((< code #x80)
(set-octet 0 code)
(incf di))
;; 2 octets
((< code #x800)
(set-octet 0 (logior #xc0 (f-ash code -6)))
(set-octet 1 (logior #x80 (f-logand code #x3f)))
(incf di 2))
;; 3 octets
((< code #x10000)
(set-octet 0 (logior #xe0 (f-ash code -12)))
(set-octet 1 (logior #x80 (f-logand #x3f (f-ash code -6))))
(set-octet 2 (logior #x80 (f-logand code #x3f)))
(incf di 3))
;; 4 octets
(t
(set-octet 0 (logior #xf0 (f-logand #x07 (f-ash code -18))))
(set-octet 1 (logior #x80 (f-logand #x3f (f-ash code -12))))
(set-octet 2 (logior #x80 (f-logand #x3f (f-ash code -6))))
(set-octet 3 (logior #x80 (logand code #x3f)))
(incf di 4))))
finally (return (the fixnum (- di d-start))))))
(define-decoder :utf-8 (getter src-type setter dest-type)
`(named-lambda utf-8-decoder (src start end dest d-start)
(declare (type ,src-type src)
(type ,dest-type dest)
(fixnum start end d-start))
(let ((u2 0) (u3 0) (u4 0) (u5 0) (u6 0))
(declare (type ub8 u2 u3 u4 u5 u6))
(loop for di fixnum from d-start
for i fixnum from start below end
for u1 of-type ub8 = (,getter src i) do
;; Note: CONSUME-OCTET doesn't check if I is being
;; incremented past END. We're assuming that END has
;; been calculated with the CODE-POINT-POINTER above that
;; checks this.
(macrolet
((consume-octet ()
`(let ((next-i (incf i)))
(if (= next-i end)
;; FIXME: data for this error is incomplete.
;; and signalling this error twice
(return-from setter-block
(decoding-error nil :utf-8 src i +repl+
'end-of-input-in-character))
(,',getter src next-i))))
(handle-error (n &optional (c 'character-decoding-error))
`(decoding-error
(vector ,@(subseq '(u1 u2 u3 u4 u5 u6) 0 n))
:utf-8 src (1+ (- i ,n)) +repl+ ',c))
(handle-error-if-icb (var n)
`(when (not (< #x7f ,var #xc0))
(decf i)
(return-from setter-block
(handle-error ,n invalid-utf8-continuation-byte)))))
(,setter
(block setter-block
(cond
((< u1 #x80) u1) ; 1 octet
((< u1 #xc0)
(handle-error 1 invalid-utf8-starter-byte))
(t
(setq u2 (consume-octet))
(handle-error-if-icb u2 1)
(cond
((< u1 #xc2)
(handle-error 2 overlong-utf8-sequence))
((< u1 #xe0) ; 2 octets
(logior (f-ash (f-logand #x1f u1) 6)
(f-logxor u2 #x80)))
(t
(setq u3 (consume-octet))
(handle-error-if-icb u3 2)
(cond
((and (= u1 #xe0) (< u2 #xa0))
(handle-error 3 overlong-utf8-sequence))
((< u1 #xf0) ; 3 octets
(let ((start (f-logior (f-ash (f-logand u1 #x0f) 12)
(f-ash (f-logand u2 #x3f) 6))))
(if (<= #xd800 start #xdfc0)
(handle-error 3 character-out-of-range)
(logior start (f-logand u3 #x3f)))))
(t ; 4 octets
(setq u4 (consume-octet))
(handle-error-if-icb u4 3)
(cond
((and (= u1 #xf0) (< u2 #x90))
(handle-error 4 overlong-utf8-sequence))
((< u1 #xf8)
(if (or (> u1 #xf4) (and (= u1 #xf4) (> u2 #x8f)))
(handle-error 4 character-out-of-range)
(f-logior (f-ash (f-logand u1 7) 18)
(f-ash (f-logxor u2 #x80) 12)
(f-ash (f-logxor u3 #x80) 6)
(f-logxor u4 #x80))))
;; from here on we'll be getting either
;; invalid continuation bytes or overlong
;; 5-byte or 6-byte sequences.
(t
(setq u5 (consume-octet))
(handle-error-if-icb u5 4)
(cond
((and (= u1 #xf8) (< u2 #x88))
(handle-error 5 overlong-utf8-sequence))
((< u1 #xfc)
(handle-error 5 character-out-of-range))
(t
(setq u6 (consume-octet))
(handle-error-if-icb u6 5)
(cond
((and (= u1 #xfc) (< u2 #x84))
(handle-error 6 overlong-utf8-sequence))
(t
(handle-error 6 character-out-of-range)
)))))))))))))
dest di))
finally (return (the fixnum (- di d-start)))))))
;;;; UTF-8B
;;; The following excerpt from a linux-utf8 message by Markus Kuhn is
;;; the closest thing to a UTF-8B specification:
;;;
;;; <http://mail.nl.linux.org/linux-utf8/2000-07/msg00040.html>
;;;
;;; "D) Emit a malformed UTF-16 sequence for every byte in a malformed
;;; UTF-8 sequence
;;;
;;; All the previous options for converting malformed UTF-8 sequences
;;; to UTF-16 destroy information. This can be highly undesirable in
;;; applications such as text file editors, where guaranteed binary
;;; transparency is a desireable feature. (E.g., I frequently edit
;;; executable code or graphic files with the Emacs text editor and I
;;; hate the idea that my editor might automatically make U+FFFD
;;; substitutions at locations that I haven't even edited when I save
;;; the file again.)
;;;
;;; I therefore suggested 1999-11-02 on the unicode@xxxxxxxxxxx
;;; mailing list the following approach. Instead of using U+FFFD,
;;; simply encode malformed UTF-8 sequences as malformed UTF-16
;;; sequences. Malformed UTF-8 sequences consist excludively of the
;;; bytes 0x80 - 0xff, and each of these bytes can be represented
;;; using a 16-bit value from the UTF-16 low-half surrogate zone
;;; U+DC80 to U+DCFF. Thus, the overlong "K" (U+004B) 0xc1 0x8b from
;;; the above example would be represented in UTF-16 as U+DCC1
;;; U+DC8B. If we simply make sure that every UTF-8 encoded surrogate
;;; character is also treated like a malformed sequence, then there
;;; is no way that a single high-half surrogate could precede the
;;; encoded malformed sequence and cause a valid UTF-16 sequence to
;;; emerge.
;;;
;;; This way 100% binary transparent UTF-8 -> UTF-16 -> UTF-8
;;; round-trip compatibility can be achieved quite easily.
;;;
;;; On an output device, a lonely low-half surrogate character should
;;; be treated just like a character outside the adopted subset of
;;; representable characters, that is for the end user, the display
;;; would look exactly like with semantics B), i.e. one symbol per
;;; byte of a malformed sequence. However in contrast to semantics
;;; B), no information is thrown away, and a cut&paste in an editor
;;; or terminal emulator will be guaranteed to reconstruct the
;;; original byte sequence. This should greatly reduce the incidence
;;; of accidental corruption of binary data by UTF-8 -> UTF-16 ->
;;; UTF-8 conversion round trips."
(define-character-encoding :utf-8b
"An 8-bit, variable-length character encoding in which
character code points in the range #x00-#x7f can be encoded in a
single octet; characters with larger code values can be encoded
in 2 to 4 bytes. Invalid UTF-8 sequences are encoded with #xDCXX
code points for each invalid byte."
:max-units-per-char 4
:literal-char-code-limit #x80
:bom-encoding #(#xef #xbb #xbf)
:default-replacement nil)
;;; TODO: reuse the :UTF-8 octet counter through a simple macro.
(define-octet-counter :utf-8b (getter type)
`(named-lambda utf-8b-octet-counter (seq start end max)
(declare (type ,type seq) (fixnum start end max))
(loop with noctets fixnum = 0
for i fixnum from start below end
for code of-type code-point = (,getter seq i) do
(let ((new (+ (cond ((< code #x80) 1)
((< code #x800) 2)
((<= #xdc80 code #xdcff) 1)
((< code #x10000) 3)
(t 4))
noctets)))
(if (and (plusp max) (> new max))
(loop-finish)
(setq noctets new)))
finally (return (values noctets i)))))
(define-code-point-counter :utf-8b (getter type)
`(named-lambda utf-8b-code-point-counter (seq start end max)
(declare (type ,type seq) (fixnum start end max))
(loop with nchars fixnum = 0
with i fixnum = start
while (< i end) do
;; wrote this code with LET instead of FOR because CLISP's
;; LOOP doesn't like WHILE clauses before FOR clauses.
(let* ((octet (,getter seq i))
(noctets (cond ((< octet #x80) 1)
((< octet #xe0) 2)
((< octet #xf0) 3)
(t 4))))
(declare (type ub8 octet) (fixnum noctets))
(cond
((> (+ i noctets) end)
;; If this error is suppressed these last few bytes
;; will be encoded as raw bytes later.
(decoding-error (vector octet) :utf-8 seq i
nil 'end-of-input-in-character)
(return (values (+ nchars (- end i)) end)))
(t
;; FIXME: clean this mess up.
(let* ((u1 octet)
(u2 (if (>= noctets 2) (,getter seq (1+ i)) 0))
(u3 (if (>= noctets 3) (,getter seq (+ i 2)) 0))
(u4 (if (= noctets 4) (,getter seq (+ i 3)) 0))
(inc (or (and (> noctets 1)
(< u1 #xc2))
(and (= noctets 2)
(not (logior u2 #x40)))
(and (= noctets 3)
(not (and (< (f-logxor u2 #x80) #x40)
(< (f-logxor u3 #x80) #x40)
(or (>= u1 #xe1) (>= u2 #xa0))
(or (/= u1 #xed) (< u2 #xa0) (> u2 #xbf)))))
(and (= noctets 4)
(not
(and (< (f-logxor u2 #x80) #x40)
(< (f-logxor u3 #x80) #x40)
(< (f-logxor u4 #x80) #x40)
(or (>= u1 #xf1) (>= u2 #x90))))))))
(let ((new-nchars (if inc (+ nchars noctets) (1+ nchars))))
(when (and (plusp max) (> new-nchars max))
(return (values nchars i)))
(incf i noctets)
(setq nchars new-nchars))))))
finally (progn
(assert (= i end))
(return (values nchars i))))))
;;; TODO: reuse the :UTF-8 encoder with through a simple macro.
(define-encoder :utf-8b (getter src-type setter dest-type)
`(named-lambda utf-8b-encoder (src start end dest d-start)
(declare (type ,src-type src)
(type ,dest-type dest)
(fixnum start end d-start))
(loop with di fixnum = d-start
for i fixnum from start below end
for code of-type code-point = (,getter src i) do
(macrolet ((set-octet (offset value)
`(,',setter ,value dest (the fixnum (+ di ,offset)))))
(cond
;; 1 octet
((< code #x80)
(set-octet 0 code)
(incf di))
;; 2 octets
((< code #x800)
(set-octet 0 (logior #xc0 (f-ash code -6)))
(set-octet 1 (logior #x80 (f-logand code #x3f)))
(incf di 2))
;; 1 octet (invalid octet)
((<= #xdc80 code #xdcff)
(set-octet 0 (f-logand code #xff))
(incf di))
;; 3 octets
((< code #x10000)
(set-octet 0 (logior #xe0 (f-ash code -12)))
(set-octet 1 (logior #x80 (f-logand #x3f (f-ash code -6))))
(set-octet 2 (logior #x80 (f-logand code #x3f)))
(incf di 3))
;; 4 octets
(t
(set-octet 0 (logior #xf0 (f-logand #x07 (f-ash code -18))))
(set-octet 1 (logior #x80 (f-logand #x3f (f-ash code -12))))
(set-octet 2 (logior #x80 (f-logand #x3f (f-ash code -6))))
(set-octet 3 (logand #x3f code))
(incf di 4))))
finally (return (the fixnum (- di d-start))))))
(define-decoder :utf-8b (getter src-type setter dest-type)
`(named-lambda utf-8b-decoder (src start end dest d-start)
(declare (type ,src-type src)
(type ,dest-type dest)
(fixnum start end d-start))
(let ((u2 0) (u3 0) (u4 0))
(declare (type ub8 u2 u3 u4))
(loop for di fixnum from d-start
for i fixnum from start below end
for u1 of-type ub8 = (,getter src i) do
;; Unlike the UTF-8 version, this version of
;; CONSUME-OCTET needs to check if I is being incremented
;; past END because we might have trailing binary
;; garbage.
(macrolet
((consume-octet (n)
`(if (= i (1- end))
(encode-raw-octets ,n)
(,',getter src (incf i))))
(encode-raw-octets (n)
`(progn
,@(loop for i below n and var in '(u1 u2 u3 u4)
collect `(,',setter (logior #xdc00 ,var) dest di)
unless (= i (1- n))
collect '(incf di))
(return-from set-body))))
(block set-body
(,setter (cond
((< u1 #x80) ; 1 octet
u1)
((>= u1 #xc2)
(setq u2 (consume-octet 1))
(cond
((< u1 #xe0) ; 2 octets
(if (< (f-logxor u2 #x80) #x40)
(logior (f-ash (f-logand #x1f u1) 6)
(f-logxor u2 #x80))
(encode-raw-octets 2)))
(t
(setq u3 (consume-octet 2))
(cond
((< u1 #xf0) ; 3 octets
(if (and (< (f-logxor u2 #x80) #x40)
(< (f-logxor u3 #x80) #x40)
(or (>= u1 #xe1) (>= u2 #xa0)))
(let ((start (f-logior (f-ash (f-logand u1 #x0f) 12)
(f-ash (f-logand u2 #x3f) 6))))
(if (<= #xd800 start #xdfc0)
(encode-raw-octets 3)
(logior start (f-logand u3 #x3f))))
(encode-raw-octets 3)))
(t ; 4 octets
(setq u4 (consume-octet 3))
(if (and (< (f-logxor u2 #x80) #x40)
(< (f-logxor u3 #x80) #x40)
(< (f-logxor u4 #x80) #x40)
(or (>= u1 #xf1) (>= u2 #x90)))
(logior
(f-logior (f-ash (f-logand u1 7) 18)
(f-ash (f-logxor u2 #x80) 12))
(f-logior (f-ash (f-logxor u3 #x80) 6)
(f-logxor u4 #x80)))
(encode-raw-octets 4)))))))
(t (encode-raw-octets 1)))
dest di)))
finally (return (the fixnum (- di d-start)))))))
;;;; UTF-16
;;; TODO: add a way to pass some info at compile-time telling us that,
;;; for example, the maximum code-point will always be < #x10000 in
;;; which case we could simply return (* 2 (- end start)).
(defmacro utf16-octet-counter (getter type)
`(named-lambda utf-16-octet-counter (seq start end max)
(declare (type ,type seq) (fixnum start end max))
(loop with noctets fixnum = 0
for i fixnum from start below end
for code of-type code-point = (,getter seq i)
do (let ((new (the fixnum (+ (if (< code #x10000) 2 4) noctets))))
(if (and (plusp max) (> new max))
(loop-finish)
(setq noctets new)))
finally (return (values noctets i)))))
(defmacro utf-16-combine-surrogate-pairs (u1 u2)
`(the (unsigned-byte 21)
(+ #x10000
(the (unsigned-byte 20)
(logior
(the (unsigned-byte 20)
(ash (the (unsigned-byte 10) (- ,u1 #xd800)) 10))
(the (unsigned-byte 10)
(- ,u2 #xdc00)))))))
(defmacro define-utf-16 (name &optional endianness)
(check-type endianness (or null (eql :be) (eql :le)))
(check-type name keyword)
(let ((swap-var (gensym "SWAP"))
(code-point-counter-name
(format-symbol t '#:~a-code-point-counter (string name)))
(encoder-name (format-symbol t '#:~a-encoder (string name)))
(decoder-name (format-symbol t '#:~a-decoder (string name))))
(labels ((make-bom-check-form (end start getter seq)
(if (null endianness)
``((,',swap-var
(when (> ,,end ,,start)
(case (,,getter ,,seq ,,start 2 :ne)
(#.+byte-order-mark-code+ (incf ,,start 2) nil)
(#.+swapped-byte-order-mark-code+ (incf ,,start 2) t)
(t #+little-endian t)))))
'()))
(make-getter-form (getter src i)
(case endianness
(:le ``(,,getter ,,src ,,i 2 :le))
(:be ``(,,getter ,,src ,,i 2 :be))
(t ``(if ,',swap-var
(,,getter ,,src ,,i 2 :re)
(,,getter ,,src ,,i 2 :ne)))))
(make-setter-form (setter code dest di)
(case endianness
(:be ``(,,setter ,,code ,,dest ,,di 2 :be))
(:le ``(,,setter ,,code ,,dest ,,di 2 :le))
(t ``(,,setter ,,code ,,dest ,,di 2 :ne)))))
`(progn
(define-octet-counter ,name (getter type)
`(utf16-octet-counter ,getter ,type))
(define-code-point-counter ,name (getter type)
`(named-lambda ,',code-point-counter-name (seq start end max)
(declare (type ,type seq) (fixnum start end max))
(let* ,,(make-bom-check-form ''end ''start 'getter ''seq)
(loop with count fixnum = 0
with i fixnum = start
while (<= i (- end 2)) do
(let* ((code ,,(make-getter-form 'getter ''seq ''i))
(next-i (+ i (if (or (< code #xd800) (>= code #xdc00))
2
4))))
(declare (type (unsigned-byte 16) code) (fixnum next-i))
(cond
((> next-i end)
(decoding-error
(vector (,getter seq i) (,getter seq (1+ i)))
,',name seq i nil 'end-of-input-in-character)
(return (values count i)))
(t
(setq i next-i
count (1+ count))
(when (and (plusp max) (= count max))
(return (values count i))))))
finally (progn
(assert (= i end))
(return (values count i)))))))
(define-encoder ,name (getter src-type setter dest-type)
`(named-lambda ,',encoder-name (src start end dest d-start)
(declare (type ,src-type src)
(type ,dest-type dest)
(fixnum start end d-start))
(loop with di fixnum = d-start
for i fixnum from start below end
for code of-type code-point = (,getter src i)
for high-bits fixnum = (- code #x10000) do
(cond ((< high-bits 0)
,,(make-setter-form 'setter ''code ''dest ''di)
(incf di 2))
(t
,,(make-setter-form
'setter ''(logior #xd800 (f-ash high-bits -10))
''dest ''di)
,,(make-setter-form
'setter ''(logior #xdc00 (f-logand high-bits #x3ff))
''dest ''(+ di 2))
(incf di 4)))
finally (return (the fixnum (- di d-start))))))
(define-decoder ,name (getter src-type setter dest-type)
`(named-lambda ,',decoder-name (src start end dest d-start)
(declare (type ,src-type src)
(type ,dest-type dest)
(fixnum start end d-start))
(let ,,(make-bom-check-form ''end ''start 'getter ''src)
(loop with i fixnum = start
for di fixnum from d-start
until (= i end) do
(let ((u1 ,,(make-getter-form 'getter ''src ''i)))
(declare (type (unsigned-byte 16) u1))
(incf i 2)
(,setter (cond
((or (< u1 #xd800) (>= u1 #xe000)) ; 2 octets
u1)
((< u1 #xdc00) ; 4 octets
(let ((u2 ,,(make-getter-form 'getter ''src ''i)))
(declare (type (unsigned-byte 16) u2))
(incf i 2)
(if (and (>= u2 #xdc00) (< u2 #xe000))
(utf-16-combine-surrogate-pairs u1 u2)
(decoding-error
(vector (,getter src (- i 4))
(,getter src (- i 3))
(,getter src (- i 2))
(,getter src (- i 1)))
,',name src i +repl+))))
(t
(decoding-error (vector (,getter src (- i 2))
(,getter src (- i 1)))
,',name src i +repl+)))
dest di))
finally (return (the fixnum (- di d-start)))))))
',name))))
(define-character-encoding :utf-16
"A 16-bit, variable-length encoding in which characters with
code points less than #x10000 can be encoded in a single 16-bit
word and characters with larger codes can be encoded in a pair of
16-bit words. The endianness of the encoded data is indicated by
the endianness of a byte-order-mark character (#\u+feff)
prepended to the data; in the absence of such a character on
input, the data is assumed to be in big-endian order. Output is
written in native byte-order with a leading byte-order mark."
:max-units-per-char 2
:code-unit-size 16
:native-endianness t ; not necessarily true when decoding
:decode-literal-code-unit-limit #xd800
:encode-literal-code-unit-limit #x10000
:use-bom #+big-endian :utf-16be #+little-endian :utf-16le
:bom-encoding #+big-endian #(#xfe #xff) #+little-endian #(#xff #xfe)
:nul-encoding #(0 0)
:default-replacement #xfffd
:ambiguous #+little-endian t #+big-endian nil)
(define-utf-16 :utf-16)
(define-character-encoding :utf-16le
"A 16-bit, variable-length encoding in which characters with
code points less than #x10000 can be encoded in a single 16-bit
word and characters with larger codes can be encoded in a pair of
16-bit words. The data is assumed to be in little-endian order. Output is
written in little-endian byte-order without a leading byte-order mark."
:aliases '(:utf-16/le)
:max-units-per-char 2
:code-unit-size 16
:native-endianness #+little-endian t #+big-endian nil
:decode-literal-code-unit-limit #xd800
:encode-literal-code-unit-limit #x10000
:nul-encoding #(0 0)
:default-replacement #xfffd)
(define-utf-16 :utf-16le :le)
(define-character-encoding :utf-16be
"A 16-bit, variable-length encoding in which characters with
code points less than #x10000 can be encoded in a single 16-bit
word and characters with larger codes can be encoded in a pair of
16-bit words. The data is assumed to be in big-endian order. Output is
written in big-endian byte-order without a leading byte-order mark."
:aliases '(:utf-16/be)
:max-units-per-char 2
:code-unit-size 16
:native-endianness #+little-endian nil #+big-endian t
:decode-literal-code-unit-limit #xd800
:encode-literal-code-unit-limit #x10000
:nul-encoding #(0 0)
:default-replacement #xfffd)
(define-utf-16 :utf-16be :be)
(defmacro define-ucs (name bytes &optional endianness (limit #x110000))
(check-type name keyword)
(check-type bytes (or (eql 2) (eql 4)))
(check-type endianness (or null (eql :le) (eql :be)))
(let ((swap-var (gensym "SWAP"))
(code-point-counter-name
(format-symbol t '#:~a-code-point-counter (string name)))
(encoder-name
(format-symbol t '#:~a-encoder (string name)))
(decoder-name
(format-symbol t '#:~a-decoder (string name))))
(labels ((make-bom-check-form (end start getter src)
(if (null endianness)
``(when (not (zerop (- ,,end ,,start)))
(case (,,getter ,,src 0 ,',bytes :ne)
(#.+byte-order-mark-code+
(incf ,,start ,',bytes) nil)
(#.+swapped-byte-order-mark-code-32+
(incf ,,start ,',bytes) t)
(t #+little-endian t)))
'()))
(make-setter-form (setter code dest di)
``(,,setter ,,code ,,dest ,,di ,',bytes
,',(or endianness :ne)))
(make-getter-form (getter src i)
(if (null endianness)
``(if ,',swap-var
(,,getter ,,src ,,i ,',bytes :re)
(,,getter ,,src ,,i ,',bytes :ne))
``(,,getter ,,src ,,i ,',bytes ,',endianness))))
`(progn
(define-code-point-counter ,name (getter type)
`(named-lambda ,',code-point-counter-name (seq start end max)
(declare (type ,type seq) (fixnum start end max))
;; check for bom
,,(make-bom-check-form ''end ''start 'getter ''seq)
(multiple-value-bind (count rem)
(floor (- end start) ,',bytes)
(cond
((and (plusp max) (> count max))
(values max (the fixnum (+ start (* ,',bytes max)))))
(t
;; check for incomplete last character
(unless (zerop rem)
(let ((vector (make-array ,',bytes :fill-pointer 0)))
(dotimes (i rem)
(vector-push (,getter seq (+ i (- end rem))) vector))
(decoding-error vector ,',name seq (the fixnum (- end rem)) nil
'end-of-input-in-character)
(decf end rem)))
(values count end))))))
(define-encoder ,name (getter src-type setter dest-type)
`(named-lambda ,',encoder-name (src start end dest d-start)
(declare (type ,src-type src)
(type ,dest-type dest)
(fixnum start end d-start))
(loop for i fixnum from start below end
and di fixnum from d-start by ,',bytes
for code of-type code-point = (,getter src i)
do (if (>= code ,',limit)
(encoding-error code ,',name src i +repl+)
,,(make-setter-form 'setter ''code ''dest ''di))
finally (return (the fixnum (- di d-start))))))
(define-decoder ,name (getter src-type setter dest-type)
`(named-lambda ,',decoder-name (src start end dest d-start)
(declare (type ,src-type src)
(type ,dest-type dest)
(fixnum start end d-start))
(let ((,',swap-var ,,(make-bom-check-form ''end ''start 'getter ''src)))
(declare (ignorable ,',swap-var))
(loop for i fixnum from start below end by ,',bytes
and di from d-start
do (,setter (let ((unit ,,(make-getter-form 'getter ''src ''i)))
(if (>= unit ,',limit)
(decoding-error
(vector (,getter src i)
(,getter src (+ i 1))
,@,(if (= bytes 4)
``((,getter src (+ i 2))
(,getter src (+ i 3)))))
,',name src i +repl+
'character-out-of-range)
unit))
dest di)
finally (return (the fixnum (- di d-start)))))))
',name))))
;;;; UTF-32
(define-character-encoding :utf-32
"A 32-bit, fixed-length encoding in which all Unicode
characters can be encoded in a single 32-bit word. The
endianness of the encoded data is indicated by the endianness of
a byte-order-mark character (#\u+feff) prepended to the data; in
the absence of such a character on input, input data is assumed
to be in big-endian order. Output is written in native byte
order with a leading byte-order mark."
:aliases '(:ucs-4)
:max-units-per-char 1
:code-unit-size 32
:native-endianness t ; not necessarily true when decoding
:literal-char-code-limit #x110000
:use-bom #+little-endian :utf-32le #+big-endian :utf-32be
:bom-encoding
#+big-endian #(#x00 #x00 #xfe #xff)
#+little-endian #(#xff #xfe #x00 #x00)
:nul-encoding #(0 0 0 0)
:ambiguous #+little-endian t #+big-endian nil)
(define-ucs :utf-32 4)
(define-character-encoding :utf-32le
"A 32-bit, fixed-length encoding in which all Unicode
characters can be encoded in a single 32-bit word. Input data is assumed
to be in little-endian order. Output is also written in little-endian byte
order without a leading byte-order mark."
:max-units-per-char 1
:code-unit-size 32
:aliases '(:utf-32/le :ucs-4le :ucs-4/le)
:native-endianness #+little-endian t #+big-endian nil
:literal-char-code-limit #x110000
:nul-encoding #(0 0 0 0))
(define-ucs :utf-32le 4 :le)
(define-character-encoding :utf-32be
"A 32-bit, fixed-length encoding in which all Unicode
characters can be encoded in a single 32-bit word. Input data is assumed
to be in big-endian order. Output is also written in big-endian byte
order without a leading byte-order mark."
:max-units-per-char 1
:code-unit-size 32
:aliases '(:utf-32/be :ucs-4be :ucs-4/be)
:native-endianness #+little-endian nil #+big-endian t
:literal-char-code-limit #x110000
:nul-encoding #(0 0 0 0))
(define-ucs :utf-32be 4 :be)
;; UCS-2
(define-character-encoding :ucs-2
"A 16-bit, fixed-length encoding in which all Unicode
characters can be encoded in a single 16-bit word. The
endianness of the encoded data is indicated by the endianness of
a byte-order-mark character (#\u+feff) prepended to the data; in
the absence of such a character on input, input data is assumed
to be in big-endian order. Output is written in native byte
order with a leading byte-order mark."
:aliases '(:ucs-2)
:max-units-per-char 1
:code-unit-size 16
:native-endianness t ; not necessarily true when decoding
:literal-char-code-limit #x10000
:use-bom #+little-endian :ucs-2le #+big-endian :ucs-2be
:bom-encoding
#+big-endian #(#xfe #xff)
#+little-endian #(#xff #xfe)
:nul-encoding #(0 0)
:ambiguous #+little-endian t #+big-endian nil)
(define-ucs :ucs-2 2 nil #x10000)
(define-character-encoding :ucs-2le
"A 16-bit, fixed-length encoding in which all Unicode
characters can be encoded in a single 16-bit word. Input data is assumed
to be in little-endian order. Output is also written in little-endian byte
order without a leading byte-order mark."
:max-units-per-char 1
:code-unit-size 16
:aliases '(:ucs-2/le)
:native-endianness #+little-endian t #+big-endian nil
:literal-char-code-limit #x10000
:nul-encoding #(0 0))
(define-ucs :ucs-2le 2 :le #x10000)
(define-character-encoding :ucs-2be
"A 16-bit, fixed-length encoding in which all Unicode
characters can be encoded in a single 16-bit word. Input data is assumed
to be in big-endian order. Output is also written in big-endian byte
order without a leading byte-order mark."
:max-units-per-char 1
:code-unit-size 16
:aliases '(:ucs-2/be)
:native-endianness #+little-endian nil #+big-endian t
:literal-char-code-limit #x10000
:nul-encoding #(0 0))
(define-ucs :ucs-2be 2 :be #x10000)
| 42,416 | Common Lisp | .lisp | 836 | 35.07177 | 93 | 0.496617 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 3fb152273f3a3a7597bc3b77e8847508105bccd732d198ffe07429dea6f056ee | 30,628 | [
90815
] |
30,631 | tests.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/babel-20150608-git/tests/tests.lisp | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; tests.lisp --- Unit and regression tests for Babel.
;;;
;;; Copyright (C) 2007-2009, Luis Oliveira <[email protected]>
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
(in-package #:cl-user)
(defpackage #:babel-tests
(:use #:common-lisp #:babel #:babel-encodings #:hu.dwim.stefil)
(:import-from #:alexandria #:ignore-some-conditions)
(:export #:run))
(in-package #:babel-tests)
(defun indented-format (level stream format-control &rest format-arguments)
(let ((line-prefix (make-string level :initial-element #\Space)))
(let ((output (format nil "~?~%" format-control format-arguments)))
(with-input-from-string (s output)
(loop for line = (read-line s nil nil) until (null line)
do (format stream "~A~A~%" line-prefix line))))))
;; adapted from https://github.com/luismbo/stefil/blob/master/source/suite.lisp
(defun describe-failed-tests (&key (result *last-test-result*) (stream t))
"Prints out a report for RESULT in STREAM.
RESULT defaults to `*last-test-result*' and STREAM defaults to t"
(let ((descs (hu.dwim.stefil::failure-descriptions-of result)))
(cond ((zerop (length descs))
(format stream "~&~%[no failures!]"))
(t
(format stream "~&~%Test failures:~%")
(dotimes (i (length descs))
(let ((desc (aref descs i))
format-control format-arguments)
;; XXX: most of Stefil's conditions specialise DESCRIBE-OBJECT
;; with nice human-readable messages. We should add any missing
;; ones (like UNEXPECTED-ERROR) and ditch this code.
(etypecase desc
(hu.dwim.stefil::unexpected-error
(let ((c (hu.dwim.stefil::condition-of desc)))
(typecase c
(simple-condition
(setf format-control (simple-condition-format-control c))
(setf format-arguments
(simple-condition-format-arguments c)))
(t
(setf format-control "~S"
format-arguments (list c))))))
(hu.dwim.stefil::failed-assertion
(setf format-control (hu.dwim.stefil::format-control-of desc)
format-arguments (hu.dwim.stefil::format-arguments-of desc)))
(hu.dwim.stefil::missing-condition
(setf format-control "~A"
format-arguments (list (with-output-to-string (stream)
(describe desc stream)))))
(null
(setf format-control "Test succeeded!")))
(format stream "~%Failure ~A: ~A when running ~S~%~%"
(1+ i)
(type-of desc)
(hu.dwim.stefil::name-of (hu.dwim.stefil::test-of (first (hu.dwim.stefil::test-context-backtrace-of desc)))))
(indented-format 4 stream "~?" format-control format-arguments)))))))
(defun run ()
(let ((test-run (without-debugging (babel-tests))))
(print test-run)
(describe-failed-tests :result test-run)
(values (zerop (length (hu.dwim.stefil::failure-descriptions-of test-run)))
test-run)))
(defsuite* (babel-tests :in root-suite))
(defun ub8v (&rest contents)
(make-array (length contents) :element-type '(unsigned-byte 8)
:initial-contents contents))
(defun make-ub8-vector (size)
(make-array size :element-type '(unsigned-byte 8)
:initial-element 0))
(defmacro returns (form &rest values)
"Asserts, through EQUALP, that FORM returns VALUES."
`(is (equalp (multiple-value-list ,form) (list ,@values))))
(defmacro defstest (name form &body return-values)
"Similar to RT's DEFTEST."
`(deftest ,name ()
(returns ,form ,@(mapcar (lambda (x) `',x) return-values))))
(defun fail (control-string &rest arguments)
(hu.dwim.stefil::record/failure 'hu.dwim.stefil::failed-assertion
:format-control control-string
:format-arguments arguments))
(defun expected (expected &key got)
(fail "expected ~A, got ~A instead" expected got))
(enable-sharp-backslash-syntax)
;;;; Simple tests using ASCII
(defstest enc.ascii.1
(string-to-octets "abc" :encoding :ascii)
#(97 98 99))
(defstest enc.ascii.2
(string-to-octets (string #\uED) :encoding :ascii :errorp nil)
#(#x1a))
(deftest enc.ascii.3 ()
(handler-case
(string-to-octets (string #\uED) :encoding :ascii :errorp t)
(character-encoding-error (c)
(is (eql 0 (character-coding-error-position c)))
(is (eq :ascii (character-coding-error-encoding c)))
(is (eql #xed (character-encoding-error-code c))))
(:no-error (result)
(expected 'character-encoding-error :got result))))
(defstest dec.ascii.1
(octets-to-string (ub8v 97 98 99) :encoding :ascii)
"abc")
(deftest dec.ascii.2 ()
(handler-case
(octets-to-string (ub8v 97 128 99) :encoding :ascii :errorp t)
(character-decoding-error (c)
(is (equalp #(128) (character-decoding-error-octets c)))
(is (eql 1 (character-coding-error-position c)))
(is (eq :ascii (character-coding-error-encoding c))))
(:no-error (result)
(expected 'character-decoding-error :got result))))
(defstest dec.ascii.3
(octets-to-string (ub8v 97 255 98 99) :encoding :ascii :errorp nil)
#(#\a #\Sub #\b #\c))
(defstest oct-count.ascii.1
(string-size-in-octets "abc" :encoding :ascii)
3 3)
(defstest char-count.ascii.1
(vector-size-in-chars (ub8v 97 98 99) :encoding :ascii)
3 3)
;;;; UTF-8
(defstest char-count.utf-8.1
;; "ni hao" in hanzi with the last octet missing
(vector-size-in-chars (ub8v 228 189 160 229 165) :errorp nil)
2 5)
(deftest char-count.utf-8.2 ()
;; same as above with the last 2 octets missing
(handler-case
(vector-size-in-chars (ub8v 228 189 160 229) :errorp t)
(end-of-input-in-character (c)
(is (equalp #(229) (character-decoding-error-octets c)))
(is (eql 3 (character-coding-error-position c)))
(is (eq :utf-8 (character-coding-error-encoding c))))
(:no-error (result)
(expected 'end-of-input-in-character :got result))))
;;; Lispworks bug?
;; #+lispworks
;; (pushnew 'dec.utf-8.1 rtest::*expected-failures*)
(defstest dec.utf-8.1
(octets-to-string (ub8v 228 189 160 229) :errorp nil)
#(#\u4f60 #\ufffd))
(deftest dec.utf-8.2 ()
(handler-case
(octets-to-string (ub8v 228 189 160 229) :errorp t)
(end-of-input-in-character (c)
(is (equalp #(229) (character-decoding-error-octets c)))
(is (eql 3 (character-coding-error-position c)))
(is (eq :utf-8 (character-coding-error-encoding c))))
(:no-error (result)
(expected 'end-of-input-in-character :got result))))
;;;; UTF-16
;;; Test that the BOM is not being counted as a character.
(deftest char-count.utf-16.bom ()
(is (eql (vector-size-in-chars (ub8v #xfe #xff #x00 #x55 #x00 #x54 #x00 #x46)
:encoding :utf-16)
3))
(is (eql (vector-size-in-chars (ub8v #xff #xfe #x00 #x55 #x00 #x54 #x00 #x46)
:encoding :utf-16)
3)))
;;;; UTF-32
;;; RT: check that UTF-32 characters without a BOM are treated as
;;; little-endian.
(deftest endianness.utf-32.no-bom ()
(is (string= "a" (octets-to-string (ub8v 0 0 0 97) :encoding :utf-32))))
;;;; MORE TESTS
(defparameter *standard-characters*
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!$\"'(),_-./:;?+<=>#%&*@[\\]{|}`^~")
;;; Testing consistency by encoding and decoding a simple string for
;;; all character encodings.
(deftest rw-equiv.1 ()
(let ((compatible-encodings (remove :ebcdic-international (list-character-encodings))))
(dolist (*default-character-encoding* compatible-encodings)
(let ((octets (string-to-octets *standard-characters*)))
(is (string= (octets-to-string octets) *standard-characters*))))))
;;; FIXME: assumes little-endianness. Easily fixable when we
;;; implement the BE and LE variants of :UTF-16.
(deftest concatenate-strings-to-octets-equiv.1 ()
(let ((foo (octets-to-string (ub8v 102 195 186 195 186)
:encoding :utf-8))
(bar (octets-to-string (ub8v 98 195 161 114)
:encoding :utf-8)))
;; note: FOO and BAR are not ascii
(is (equalp (concatenate-strings-to-octets :utf-8 foo bar)
(ub8v 102 195 186 195 186 98 195 161 114)))
(is (equalp (concatenate-strings-to-octets :utf-16 foo bar)
(ub8v 102 0 250 0 250 0 98 0 225 0 114 0)))))
;;;; Testing against files generated by GNU iconv.
(defun test-file (name type)
(let ((sys-pn (truename
(asdf:system-definition-pathname
(asdf:find-system 'babel-tests)))))
(make-pathname :name name :type type
:directory (append (pathname-directory sys-pn)
'("tests"))
:defaults sys-pn)))
(defun read-test-file (name type)
(with-open-file (in (test-file name type) :element-type '(unsigned-byte 8))
(let* ((data (loop for byte = (read-byte in nil nil)
until (null byte) collect byte)))
(make-array (length data) :element-type '(unsigned-byte 8)
:initial-contents data))))
(deftest test-encoding (enc &optional input-enc-name)
(let* ((*default-character-encoding* enc)
(enc-name (string-downcase (symbol-name enc)))
(utf8-octets (read-test-file enc-name "txt-utf8"))
(foo-octets (read-test-file (or input-enc-name enc-name) "txt"))
(utf8-string (octets-to-string utf8-octets :encoding :utf-8 :errorp t))
(foo-string (octets-to-string foo-octets :errorp t)))
(is (string= utf8-string foo-string))
(is (= (length foo-string) (vector-size-in-chars foo-octets :errorp t)))
(unless (member enc '(:utf-16 :utf-32))
;; FIXME: skipping UTF-16 and UTF-32 because of the BOMs and
;; because the input might not be in native-endian order so the
;; comparison will fail there.
(let ((new-octets (string-to-octets foo-string :errorp t)))
(is (equalp new-octets foo-octets))
(is (eql (length foo-octets)
(string-size-in-octets foo-string :errorp t)))))))
(deftest iconv-test ()
(dolist (enc '(:ascii :ebcdic-us :utf-8 :utf-16 :utf-32))
(case enc
(:utf-16 (test-encoding :utf-16 "utf-16-with-le-bom"))
(:utf-32 (test-encoding :utf-32 "utf-32-with-le-bom")))
(test-encoding enc)))
;;; RT: accept encoding objects in LOOKUP-MAPPING etc.
(defstest encoding-objects.1
(string-to-octets "abc" :encoding (get-character-encoding :ascii))
#(97 98 99))
(defmacro with-sharp-backslash-syntax (&body body)
`(let ((*readtable* (copy-readtable *readtable*)))
(set-sharp-backslash-syntax-in-readtable)
,@body))
(defstest sharp-backslash.1
(with-sharp-backslash-syntax
(loop for string in '("#\\a" "#\\u" "#\\ued")
collect (char-code (read-from-string string))))
(97 117 #xed))
(deftest sharp-backslash.2 ()
(signals reader-error (with-sharp-backslash-syntax
(read-from-string "#\\u12zz"))))
(deftest test-read-from-string (string object position)
"Test that (read-from-string STRING) returns values OBJECT and POSITION."
(multiple-value-bind (obj pos)
(read-from-string string)
(is (eql object obj))
(is (eql position pos))))
;;; RT: our #\ reader didn't honor *READ-SUPPRESS*.
(deftest sharp-backslash.3 ()
(with-sharp-backslash-syntax
(let ((*read-suppress* t))
(test-read-from-string "#\\ujunk" nil 7)
(test-read-from-string "#\\u12zz" nil 7))))
;;; RT: the slow implementation of with-simple-vector was buggy.
(defstest string-to-octets.1
(code-char (aref (string-to-octets "abc" :start 1 :end 2) 0))
#\b)
(defstest simple-base-string.1
(string-to-octets (coerce "abc" 'base-string) :encoding :ascii)
#(97 98 99))
;;; For now, disable this tests for Lisps that are strict about
;;; non-character code points. In the future, simply mark them as
;;; expected failures.
#-(or abcl ccl)
(progn
(defstest utf-8b.1
(string-to-octets (coerce #(#\a #\b #\udcf0) 'unicode-string)
:encoding :utf-8b)
#(97 98 #xf0))
#+#:temporarily-disabled
(defstest utf-8b.2
(octets-to-string (ub8v 97 98 #xcd) :encoding :utf-8b)
#(#\a #\b #\udccd))
(defstest utf-8b.3
(octets-to-string (ub8v 97 #xf0 #xf1 #xff #x01) :encoding :utf-8b)
#(#\a #\udcf0 #\udcf1 #\udcff #\udc01))
(deftest utf-8b.4 ()
(let* ((octets (coerce (loop repeat 8192 collect (random (+ #x82)))
'(array (unsigned-byte 8) (*))))
(string (octets-to-string octets :encoding :utf-8b)))
(is (equalp octets (string-to-octets string :encoding :utf-8b))))))
;;; The following tests have been adapted from SBCL's
;;; tests/octets.pure.lisp file.
(deftest ensure-roundtrip-ascii ()
(let ((octets (make-ub8-vector 128)))
(dotimes (i 128)
(setf (aref octets i) i))
(let* ((str (octets-to-string octets :encoding :ascii))
(oct2 (string-to-octets str :encoding :ascii)))
(is (= (length octets) (length oct2)))
(is (every #'= octets oct2)))))
(deftest test-8bit-roundtrip (enc)
(let ((octets (make-ub8-vector 256)))
(dotimes (i 256)
(setf (aref octets i) i))
(let* ((str (octets-to-string octets :encoding enc)))
;; remove the undefined code-points because they translate
;; to #xFFFD and string-to-octets raises an error when
;; encoding #xFFFD
(multiple-value-bind (filtered-str filtered-octets)
(let ((s (make-array 0 :element-type 'character
:adjustable t :fill-pointer 0))
(o (make-array 0 :element-type '(unsigned-byte 16)
:adjustable t :fill-pointer 0)))
(loop for i below 256
for c = (aref str i)
when (/= (char-code c) #xFFFD)
do (vector-push-extend c s)
(vector-push-extend (aref octets i) o))
(values s o))
(let ((oct2 (string-to-octets filtered-str :encoding enc)))
(is (eql (length filtered-octets) (length oct2)))
(is (every #'eql filtered-octets oct2)))))))
(defparameter *iso-8859-charsets*
'(:iso-8859-1 :iso-8859-2 :iso-8859-3 :iso-8859-4 :iso-8859-5 :iso-8859-6
:iso-8859-7 :iso-8859-8 :iso-8859-9 :iso-8859-10 :iso-8859-11 :iso-8859-13
:iso-8859-14 :iso-8859-15 :iso-8859-16))
;;; Don't actually see what comes out, but there shouldn't be any
;;; errors.
(deftest iso-8859-roundtrip-no-checking ()
(loop for enc in *iso-8859-charsets* do (test-8bit-roundtrip enc)))
(deftest ensure-roundtrip-latin ()
(loop for enc in '(:latin1 :latin9) do (test-8bit-roundtrip enc)))
;;; Latin-9 chars; the previous test checked roundtrip from
;;; octets->char and back, now test that the latin-9 characters did in
;;; fact appear during that trip.
(deftest ensure-roundtrip-latin9 ()
(let ((l9c (map 'string #'code-char '(8364 352 353 381 382 338 339 376))))
(is (string= (octets-to-string (string-to-octets l9c :encoding :latin9)
:encoding :latin9)
l9c))))
;; Expected to fail on Lisps that are strict about non-character code
;; points. Mark this as an expected failure when Stefil supports such
;; a feature.
#-(or abcl ccl)
(deftest code-char-nilness ()
(is (loop for i below unicode-char-code-limit
never (null (code-char i)))))
(deftest test-unicode-roundtrip (enc)
(let ((string (make-string unicode-char-code-limit)))
(dotimes (i unicode-char-code-limit)
(setf (char string i)
(if (or (<= #xD800 i #xDFFF)
(<= #xFDD0 i #xFDEF)
(eql (logand i #xFFFF) #xFFFF)
(eql (logand i #xFFFF) #xFFFE))
#\? ; don't try to encode non-characters.
(code-char i))))
(let ((string2 (octets-to-string
(string-to-octets string :encoding enc :errorp t)
:encoding enc :errorp t)))
(is (eql (length string2) (length string)))
(is (string= string string2)))))
(deftest ensure-roundtrip.utf8 ()
(test-unicode-roundtrip :utf-8))
(deftest ensure-roundtrip.utf16 ()
(test-unicode-roundtrip :utf-16))
(deftest ensure-roundtrip.utf32 ()
(test-unicode-roundtrip :utf-32))
#+sbcl
(progn
(deftest test-encode-against-sbcl (enc)
(let ((string (make-string unicode-char-code-limit)))
(dotimes (i unicode-char-code-limit)
(setf (char string i) (code-char i)))
(loop for ch across string
for babel = (string-to-octets (string ch) :encoding enc)
for sbcl = (sb-ext:string-to-octets (string ch)
:external-format enc)
do (is (equalp babel sbcl)))))
;; not run automatically because it's a bit slow (1114112 assertions)
(deftest (test-encode-against-sbcl.utf-8 :auto-call nil) ()
(test-encode-against-sbcl :utf-8)))
(deftest non-ascii-bytes ()
(let ((octets (make-array 128
:element-type '(unsigned-byte 8)
:initial-contents (loop for i from 128 below 256
collect i))))
(is (string= (octets-to-string octets :encoding :ascii :errorp nil)
(make-string 128 :initial-element #\Sub)))))
(deftest non-ascii-chars ()
(let ((string (make-array 128
:element-type 'character
:initial-contents (loop for i from 128 below 256
collect (code-char i)))))
(is (equalp (string-to-octets string :encoding :ascii :errorp nil)
(make-array 128 :initial-element (char-code #\Sub))))))
;;;; The following UTF-8 decoding tests are adapted from
;;;; <http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt>.
(deftest utf8-decode-test (octets expected-results expected-errors)
(let ((string (octets-to-string (coerce octets '(vector (unsigned-byte 8) *))
:encoding :utf-8 :errorp nil)))
(is (string= expected-results string))
(is (= (count #\ufffd string) expected-errors))))
(deftest utf8-decode-tests (octets expected-results)
(let ((expected-errors (count #\? expected-results))
(expected-results (substitute #\ufffd #\? expected-results)))
(utf8-decode-test octets expected-results expected-errors)
(utf8-decode-test (concatenate 'vector '(34) octets '(34))
(format nil "\"~A\"" expected-results)
expected-errors)))
(deftest utf8-too-big-characters ()
(utf8-decode-tests #(#xf4 #x90 #x80 #x80) "?") ; #x110000
(utf8-decode-tests #(#xf7 #xbf #xbf #xbf) "?") ; #x1fffff
(utf8-decode-tests #(#xf8 #x88 #x80 #x80 #x80) "?") ; #x200000
(utf8-decode-tests #(#xfb #xbf #xbf #xbf #xbf) "?") ; #x3ffffff
(utf8-decode-tests #(#xfc #x84 #x80 #x80 #x80 #x80) "?") ; #x4000000e
(utf8-decode-tests #(#xfd #xbf #xbf #xbf #xbf #xbf) "?")) ; #x7fffffff
(deftest utf8-unexpected-continuation-bytes ()
(utf8-decode-tests #(#x80) "?")
(utf8-decode-tests #(#xbf) "?")
(utf8-decode-tests #(#x80 #xbf) "??")
(utf8-decode-tests #(#x80 #xbf #x80) "???")
(utf8-decode-tests #(#x80 #xbf #x80 #xbf) "????")
(utf8-decode-tests #(#x80 #xbf #x80 #xbf #x80) "?????")
(utf8-decode-tests #(#x80 #xbf #x80 #xbf #x80 #xbf) "??????")
(utf8-decode-tests #(#x80 #xbf #x80 #xbf #x80 #xbf #x80) "???????"))
;;; All 64 continuation bytes in a row.
(deftest utf8-continuation-bytes ()
(apply #'utf8-decode-tests
(loop for i from #x80 to #xbf
collect i into bytes
collect #\? into chars
finally (return (list bytes
(coerce chars 'string))))))
(deftest utf8-lonely-start-characters ()
(flet ((lsc (first last)
(apply #'utf8-decode-tests
(loop for i from first to last
nconc (list i 32) into bytes
nconc (list #\? #\Space) into chars
finally (return (list bytes (coerce chars 'string)))))
(apply #'utf8-decode-tests
(loop for i from first to last
collect i into bytes
collect #\? into chars
finally (return
(list bytes (coerce chars 'string)))))))
(lsc #xc0 #xdf) ; 2-byte sequence start chars
(lsc #xe0 #xef) ; 3-byte
(lsc #xf0 #xf7) ; 4-byte
(lsc #xf8 #xfb) ; 5-byte
(lsc #xfc #xfd))) ; 6-byte
;;; Otherwise incomplete sequences (last continuation byte missing)
(deftest utf8-incomplete-sequences ()
(utf8-decode-tests #0=#(#xc0) "?")
(utf8-decode-tests #1=#(#xe0 #x80) "?")
(utf8-decode-tests #2=#(#xf0 #x80 #x80) "?")
(utf8-decode-tests #3=#(#xf8 #x80 #x80 #x80) "?")
(utf8-decode-tests #4=#(#xfc #x80 #x80 #x80 #x80) "?")
(utf8-decode-tests #5=#(#xdf) "?")
(utf8-decode-tests #6=#(#xef #xbf) "?")
(utf8-decode-tests #7=#(#xf7 #xbf #xbf) "?")
(utf8-decode-tests #8=#(#xfb #xbf #xbf #xbf) "?")
(utf8-decode-tests #9=#(#xfd #xbf #xbf #xbf #xbf) "?")
;; All ten previous tests concatenated
(utf8-decode-tests (concatenate 'vector
#0# #1# #2# #3# #4# #5# #6# #7# #8# #9#)
"??????????"))
(deftest utf8-random-impossible-bytes ()
(utf8-decode-tests #(#xfe) "?")
(utf8-decode-tests #(#xff) "?")
(utf8-decode-tests #(#xfe #xfe #xff #xff) "????"))
(deftest utf8-overlong-sequences-/ ()
(utf8-decode-tests #(#xc0 #xaf) "?")
(utf8-decode-tests #(#xe0 #x80 #xaf) "?")
(utf8-decode-tests #(#xf0 #x80 #x80 #xaf) "?")
(utf8-decode-tests #(#xf8 #x80 #x80 #x80 #xaf) "?")
(utf8-decode-tests #(#xfc #x80 #x80 #x80 #x80 #xaf) "?"))
(deftest utf8-overlong-sequences-rubout ()
(utf8-decode-tests #(#xc1 #xbf) "?")
(utf8-decode-tests #(#xe0 #x9f #xbf) "?")
(utf8-decode-tests #(#xf0 #x8f #xbf #xbf) "?")
(utf8-decode-tests #(#xf8 #x87 #xbf #xbf #xbf) "?")
(utf8-decode-tests #(#xfc #x83 #xbf #xbf #xbf #xbf) "?"))
(deftest utf8-overlong-sequences-null ()
(utf8-decode-tests #(#xc0 #x80) "?")
(utf8-decode-tests #(#xe0 #x80 #x80) "?")
(utf8-decode-tests #(#xf0 #x80 #x80 #x80) "?")
(utf8-decode-tests #(#xf8 #x80 #x80 #x80 #x80) "?")
(utf8-decode-tests #(#xfc #x80 #x80 #x80 #x80 #x80) "?"))
;;;; End of adapted SBCL tests.
;;; Expected to fail, for now.
#+#:ignore
(deftest utf8-illegal-code-positions ()
;; single UTF-16 surrogates
(utf8-decode-tests #(#xed #xa0 #x80) "?")
(utf8-decode-tests #(#xed #xad #xbf) "?")
(utf8-decode-tests #(#xed #xae #x80) "?")
(utf8-decode-tests #(#xed #xaf #xbf) "?")
(utf8-decode-tests #(#xed #xb0 #x80) "?")
(utf8-decode-tests #(#xed #xbe #x80) "?")
(utf8-decode-tests #(#xed #xbf #xbf) "?")
;; paired UTF-16 surrogates
(utf8-decode-tests #(ed a0 80 ed b0 80) "??")
(utf8-decode-tests #(ed a0 80 ed bf bf) "??")
(utf8-decode-tests #(ed ad bf ed b0 80) "??")
(utf8-decode-tests #(ed ad bf ed bf bf) "??")
(utf8-decode-tests #(ed ae 80 ed b0 80) "??")
(utf8-decode-tests #(ed ae 80 ed bf bf) "??")
(utf8-decode-tests #(ed af bf ed b0 80) "??")
(utf8-decode-tests #(ed af bf ed bf bf) "??")
;; other illegal code positions
(utf8-decode-tests #(#xef #xbf #xbe) "?") ; #\uFFFE
(utf8-decode-tests #(#xef #xbf #xbf) "?")) ; #\uFFFF
;;; A list of the ISO-8859 encodings where each element is a cons with
;;; the car being a keyword denoting the encoding and the cdr being a
;;; vector enumerating the corresponding character codes.
;;;
;;; It was auto-generated from files which can be found at
;;; <ftp://ftp.unicode.org/Public/MAPPINGS/ISO8859/>.
;;;
;;; Taken from flexi-streams.
(defparameter *iso-8859-tables*
'((:iso-8859-1 .
#(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
243 244 245 246 247 248 249 250 251 252 253 254 255))
(:iso-8859-2 .
#(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
153 154 155 156 157 158 159 160 260 728 321 164 317 346 167 168 352 350
356 377 173 381 379 176 261 731 322 180 318 347 711 184 353 351 357 378
733 382 380 340 193 194 258 196 313 262 199 268 201 280 203 282 205 206
270 272 323 327 211 212 336 214 215 344 366 218 368 220 221 354 223 341
225 226 259 228 314 263 231 269 233 281 235 283 237 238 271 273 324 328
243 244 337 246 247 345 367 250 369 252 253 355 729))
(:iso-8859-3 .
#(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
153 154 155 156 157 158 159 160 294 728 163 164 65533 292 167 168 304
350 286 308 173 65533 379 176 295 178 179 180 181 293 183 184 305 351
287 309 189 65533 380 192 193 194 65533 196 266 264 199 200 201 202 203
204 205 206 207 65533 209 210 211 212 288 214 215 284 217 218 219 220
364 348 223 224 225 226 65533 228 267 265 231 232 233 234 235 236 237
238 239 65533 241 242 243 244 289 246 247 285 249 250 251 252 365 349
729))
(:iso-8859-4 .
#(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
153 154 155 156 157 158 159 160 260 312 342 164 296 315 167 168 352 274
290 358 173 381 175 176 261 731 343 180 297 316 711 184 353 275 291 359
330 382 331 256 193 194 195 196 197 198 302 268 201 280 203 278 205 206
298 272 325 332 310 212 213 214 215 216 370 218 219 220 360 362 223 257
225 226 227 228 229 230 303 269 233 281 235 279 237 238 299 273 326 333
311 244 245 246 247 248 371 250 251 252 361 363 729))
(:iso-8859-5 .
#(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
153 154 155 156 157 158 159 160 1025 1026 1027 1028 1029 1030 1031 1032
1033 1034 1035 1036 173 1038 1039 1040 1041 1042 1043 1044 1045 1046
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088
1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102
1103 8470 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116
167 1118 1119))
(:iso-8859-6 .
#(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
153 154 155 156 157 158 159 160 65533 65533 65533 164 65533 65533 65533
65533 65533 65533 65533 1548 173 65533 65533 65533 65533 65533 65533
65533 65533 65533 65533 65533 65533 65533 1563 65533 65533 65533 1567
65533 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581
1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 65533
65533 65533 65533 65533 1600 1601 1602 1603 1604 1605 1606 1607 1608
1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 65533 65533 65533
65533 65533 65533 65533 65533 65533 65533 65533 65533 65533))
(:iso-8859-7 .
#(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
153 154 155 156 157 158 159 160 8216 8217 163 8364 8367 166 167 168 169
890 171 172 173 65533 8213 176 177 178 179 900 901 902 183 904 905 906
187 908 189 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924
925 926 927 928 929 65533 931 932 933 934 935 936 937 938 939 940 941
942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959
960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 65533))
(:iso-8859-8 .
#(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
153 154 155 156 157 158 159 160 65533 162 163 164 165 166 167 168 169
215 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 247 187
188 189 190 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533
65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533
65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 8215 1488
1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502
1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 65533 65533
8206 8207 65533))
(:iso-8859-9 .
#(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
207 286 209 210 211 212 213 214 215 216 217 218 219 220 304 350 223 224
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 287 241 242
243 244 245 246 247 248 249 250 251 252 305 351 255))
(:iso-8859-10 .
#(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
153 154 155 156 157 158 159 160 260 274 290 298 296 310 167 315 272 352
358 381 173 362 330 176 261 275 291 299 297 311 183 316 273 353 359 382
8213 363 331 256 193 194 195 196 197 198 302 268 201 280 203 278 205 206
207 208 325 332 211 212 213 214 360 216 370 218 219 220 221 222 223 257
225 226 227 228 229 230 303 269 233 281 235 279 237 238 239 240 326 333
243 244 245 246 361 248 371 250 251 252 253 254 312))
(:iso-8859-11 .
#(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
153 154 155 156 157 158 159 160 3585 3586 3587 3588 3589 3590 3591 3592
3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606
3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620
3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634
3635 3636 3637 3638 3639 3640 3641 3642 65533 65533 65533 65533 3647
3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661
3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675
65533 65533 65533 65533))
(:iso-8859-13 .
#(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
153 154 155 156 157 158 159 160 8221 162 163 164 8222 166 167 216 169
342 171 172 173 174 198 176 177 178 179 8220 181 182 183 248 185 343 187
188 189 190 230 260 302 256 262 196 197 280 274 268 201 377 278 290 310
298 315 352 323 325 211 332 213 214 215 370 321 346 362 220 379 381 223
261 303 257 263 228 229 281 275 269 233 378 279 291 311 299 316 353 324
326 243 333 245 246 247 371 322 347 363 252 380 382 8217))
(:iso-8859-14 .
#(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
153 154 155 156 157 158 159 160 7682 7683 163 266 267 7690 167 7808 169
7810 7691 7922 173 174 376 7710 7711 288 289 7744 7745 182 7766 7809
7767 7811 7776 7923 7812 7813 7777 192 193 194 195 196 197 198 199 200
201 202 203 204 205 206 207 372 209 210 211 212 213 214 7786 216 217 218
219 220 221 374 223 224 225 226 227 228 229 230 231 232 233 234 235 236
237 238 239 373 241 242 243 244 245 246 7787 248 249 250 251 252 253 375
255))
(:iso-8859-15 .
#(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
153 154 155 156 157 158 159 160 161 162 163 8364 165 352 167 353 169 170
171 172 173 174 175 176 177 178 179 381 181 182 183 382 185 186 187 338
339 376 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242
243 244 245 246 247 248 249 250 251 252 253 254 255))
(:iso-8859-16 .
#(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
153 154 155 156 157 158 159 160 260 261 321 8364 8222 352 167 353 169
536 171 377 173 378 379 176 177 268 322 381 8221 182 183 382 269 537 187
338 339 376 380 192 193 194 258 196 262 198 199 200 201 202 203 204 205
206 207 272 323 210 211 212 336 214 346 368 217 218 219 220 280 538 223
224 225 226 259 228 263 230 231 232 233 234 235 236 237 238 239 273 324
242 243 244 337 246 347 369 249 250 251 252 281 539 255))))
(deftest iso-8859-decode-check ()
(loop for enc in *iso-8859-charsets*
for octets = (let ((octets (make-ub8-vector 256)))
(dotimes (i 256 octets)
(setf (aref octets i) i)))
for string = (octets-to-string octets :encoding enc)
do (is (equalp (map 'vector #'char-code string)
(cdr (assoc enc *iso-8859-tables*))))))
(deftest character-out-of-range.utf-32 ()
(signals character-out-of-range
(octets-to-string (ub8v 0 0 #xfe #xff 0 #x11 0 0)
:encoding :utf-32 :errorp t)))
;;; RT: encoders and decoders were returning bogus values.
(deftest encoder/decoder-retvals (encoding &optional (test-string "abc"))
(let* ((mapping (lookup-mapping babel::*string-vector-mappings* encoding))
(strlen (length test-string))
;; encoding
(octet-precount (funcall (octet-counter mapping)
test-string 0 strlen -1))
(array (make-array octet-precount :element-type '(unsigned-byte 8)))
(encoded-octet-count (funcall (encoder mapping)
test-string 0 strlen array 0))
;; decoding
(string (make-string strlen))
(char-precount (funcall (code-point-counter mapping)
array 0 octet-precount -1))
(char-count (funcall (decoder mapping)
array 0 octet-precount string 0)))
(is (= octet-precount encoded-octet-count))
(is (= char-precount char-count))
(is (string= test-string string))))
(deftest encoder-and-decoder-return-values ()
(mapcar 'encoder/decoder-retvals
(remove-if 'ambiguous-encoding-p
(list-character-encodings))))
(deftest code-point-sweep (encoding)
(finishes
(dotimes (i char-code-limit)
(let ((char (ignore-errors (code-char i))))
(when char
(ignore-some-conditions (character-encoding-error)
(string-to-octets (string char) :encoding encoding)))))))
#+enable-slow-babel-tests
(deftest code-point-sweep-all-encodings ()
(mapc #'code-point-sweep (list-character-encodings)))
(deftest octet-sweep (encoding)
(finishes
(loop for b1 upto #xff do
(loop for b2 upto #xff do
(loop for b3 upto #xff do
(loop for b4 upto #xff do
(ignore-some-conditions (character-decoding-error)
(octets-to-string (ub8v b1 b2 b3 b4) :encoding encoding))))))))
#+enable-slow-babel-tests
(deftest octet-sweep-all-encodings ()
(mapc #'octet-sweep (list-character-encodings)))
| 44,104 | Common Lisp | .lisp | 810 | 46.688889 | 132 | 0.62955 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 83661733f4912abcd3b1e55aee47a37efb0ca365259152d7a4c677eb31cd211a | 30,631 | [
471700
] |
30,633 | streams.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/babel-20150608-git/tests/streams.lisp | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; streams.lisp --- Unit and regression tests for Babel streams.
;;;
;;; Copyright (C) 2007, Attila Lendva <[email protected]>
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
(in-package #:babel-tests)
(eval-when (:compile-toplevel :load-toplevel :execute)
(use-package :babel-streams))
(deftest in-memory-vector-stream
(with-output-to-sequence (output)
;; TODO use a better test lib and inject asserts for the file position
;(print (file-position output))
(write-sequence "éáőűú" output)
;(print (file-position output))
(write-char #\ű output)
;(print (file-position output))
(write-byte 12 output)
(write-sequence (string-to-octets "körte") output)
(write-string "körte" output)
;(print (file-position output))
)
#(195 169 195 161 197 145 197 177 195 186 197 177 12 107 195 182 114 116 101))
| 1,968 | Common Lisp | .lisp | 42 | 44.404762 | 80 | 0.732115 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 047fa253296b64ca6a5da907bf1099114e1f200a6e95df654e5dfedda09162b2 | 30,633 | [
36318,
130816
] |
30,634 | release.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/babel-20150608-git/scripts/release.lisp | #!/usr/bin/env clisp
;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
(defpackage :release-script (:use #:cl #:regexp))
(in-package :release-script)
;;;; Configuration ------------------------------------------------------------
(defparameter *project-name* "babel")
(defparameter *asdf-file* (format nil "~A.asd" *project-name*))
(defparameter *host* "common-lisp.net")
(defparameter *release-dir*
(format nil "/project/~A/public_html/releases" *project-name*))
(defparameter *version-file* "VERSION")
(defparameter *version-file-dir*
(format nil "/project/~A/public_html" *project-name*))
;;;; --------------------------------------------------------------------------
;;;; Utilities
(defun ensure-list (x)
(if (listp x) x (list x)))
(defmacro string-case (expression &body clauses)
`(let ((it ,expression)) ; yes, anaphoric, deal with it.
(cond
,@(loop for clause in clauses collect
`((or ,@(loop for alternative in (ensure-list (first clause))
collect (or (eq t alternative)
`(string= it ,alternative))))
,@(rest clause))))))
(defparameter *development-mode* nil)
(defun die (format-control &rest format-args)
(format *error-output* "~?" format-control format-args)
(if *development-mode*
(cerror "continue" "die")
(ext:quit 1)))
(defun numeric-split (string)
(if (digit-char-p (char string 0))
(multiple-value-bind (number next-position)
(parse-integer string :junk-allowed t)
(cons number (when (< next-position (length string))
(numeric-split (subseq string next-position)))))
(let ((next-digit-position (position-if #'digit-char-p string)))
(if next-digit-position
(cons (subseq string 0 next-digit-position)
(numeric-split (subseq string next-digit-position)))
(list string)))))
(defun natural-string-< (s1 s2)
(labels ((aux< (l1 l2)
(cond ((null l1) (not (null l2)))
((null l2) nil)
(t (destructuring-bind (x . xs) l1
(destructuring-bind (y . ys) l2
(cond ((and (numberp x) (stringp y))
t)
((and (numberp y) (stringp x))
nil)
((and (numberp x) (numberp y))
(or (< x y) (and (= x y) (aux< xs ys))))
(t
(or (string-lessp x y)
(and (string-equal x y)
(aux< xs ys)))))))))))
(aux< (numeric-split s1)
(numeric-split s2))))
;;;; Running commands
(defparameter *dry-run* nil)
(defun cmd? (format-control &rest format-args)
(let ((cmd (format nil "~?" format-control format-args)))
(with-open-stream (s1 (ext:run-shell-command cmd :output :stream))
(loop for line = (read-line s1 nil nil)
while line
collect line))))
;; XXX: quote arguments.
(defun cmd (format-control &rest format-args)
(when *development-mode*
(format *debug-io* "CMD: ~?~%" format-control format-args))
(let ((ret (ext:run-shell-command (format nil "~?" format-control format-args))))
(or (null ret)
(zerop ret))))
(defun cmd! (format-control &rest format-args)
(or (apply #'cmd format-control format-args)
(die "cmd '~?' failed." format-control format-args)))
(defun maybe-cmd! (format-control &rest format-args)
(if *dry-run*
(format t "SUPPRESSING: ~?~%" format-control format-args)
(apply #'cmd! format-control format-args)))
;;;;
(defun find-current-version ()
(subseq (reduce (lambda (x y) (if (natural-string-< x y) y x))
(or (cmd? "git tag -l v\\*")
(die "no version tags found. Please specify initial version.")))
1))
(defun parse-version (string)
(mapcar (lambda (x)
(parse-integer x :junk-allowed t))
(loop repeat 3 ; XXX: parameterize
for el in (regexp-split "\\." (find-current-version))
collect el)))
(defun check-for-unrecorded-changes (&optional force)
(unless (cmd "git diff --exit-code")
(write-line "Unrecorded changes.")
(if force
(write-line "Continuing anyway.")
(die "Aborting.~@
Use -f or --force if you want to make a release anyway."))))
(defun new-version-number-candidates (current-version)
(let ((current-version (parse-version current-version)))
(labels ((alternatives (before after)
(when after
(cons (append before (list (1+ (first after)))
(mapcar (constantly 0) (rest after)))
(alternatives (append before (list (first after)))
(rest after))))))
(loop for alt in (alternatives nil current-version)
collect (reduce (lambda (acc next)
(format nil "~a.~a" acc next))
alt)))))
(defun ask-user-for-version (current-version next-versions)
(format *query-io* "Current version is ~A. Which will be the next one?~%"
current-version)
(loop for i from 1 and version in next-versions
do (format *query-io* "~T~A) ~A~%" i version))
(format *query-io* "? ")
(finish-output *query-io*)
(nth (1- (parse-integer (read-line) :junk-allowed t))
next-versions))
(defun git-tag-tree (version)
(write-line "Tagging the tree...")
(maybe-cmd! "git tag \"v~A\"" version))
(defun add-version-to-system-file (version path-in path-out)
(with-open-file (in path-in :direction :input)
(with-open-file (out path-out :direction :output)
(loop for line = (read-line in nil nil) while line
do (write-line line out)
when (string= #1="(defsystem " line
:end2 (min (length #1#) (length line)))
do (format out " :version ~s~%" version)))))
(defun create-dist (version distname)
(write-line "Creating distribution...")
(cmd! "mkdir \"~a\"" distname)
(cmd! "git archive master | tar xC \"~A\"" distname)
(format t "Updating ~A with new version: ~A~%" *asdf-file* version)
(let* ((asdf-file-path (format nil "~A/~A" distname *asdf-file*))
(tmp-asdf-file-path (format nil "~a.tmp" asdf-file-path)))
(add-version-to-system-file version asdf-file-path tmp-asdf-file-path)
(cmd! "mv \"~a\" \"~a\"" tmp-asdf-file-path asdf-file-path)))
(defun tar-and-sign (distname tarball)
(write-line "Creating and signing tarball...")
(cmd! "tar czf \"~a\" \"~a\"" tarball distname)
(cmd! "gpg -b -a \"~a\"" tarball))
(defparameter *remote-directory* (format nil "~A:~A" *host* *release-dir*))
(defun upload-tarball (tarball signature remote-directory)
(write-line "Copying tarball to web server...")
(maybe-cmd! "scp \"~A\" \"~A\" \"~A\"" tarball signature remote-directory)
(format t "Uploaded ~A and ~A.~%" tarball signature))
(defun update-remote-links (tarball signature host release-dir project-name)
(format t "Updating ~A_latest links...~%" project-name)
(maybe-cmd! "ssh \"~A\" ln -sf \"~A\" \"~A/~A_latest.tar.gz\""
host tarball release-dir project-name)
(maybe-cmd! "ssh \"~A\" ln -sf \"~A\" \"~A/~A_latest.tar.gz.asc\""
host signature release-dir project-name))
(defun upload-version-file (version version-file host version-file-dir)
(format t "Uploading ~A...~%" version-file)
(with-open-file (out version-file :direction :output)
(write-string version out))
(maybe-cmd! "scp \"~A\" \"~A\":\"~A\"" version-file host version-file-dir)
(maybe-cmd! "rm \"~A\"" version-file))
(defun maybe-clean-things-up (tarball signature)
(when (y-or-n-p "Clean local tarball and signature?")
(cmd! "rm \"~A\" \"~A\"" tarball signature)))
(defun run (force version)
(check-for-unrecorded-changes force)
;; figure out what version we'll be preparing.
(unless version
(let* ((current-version (find-current-version))
(next-versions (new-version-number-candidates current-version)))
(setf version (or (ask-user-for-version current-version next-versions)
(die "invalid selection.")))))
(git-tag-tree version)
(let* ((distname (format nil "~A_~A" *project-name* version))
(tarball (format nil "~A.tar.gz" distname))
(signature (format nil "~A.asc" tarball)))
;; package things up.
(create-dist version distname)
(tar-and-sign distname tarball)
;; upload.
(upload-tarball tarball signature *remote-directory*)
(update-remote-links tarball signature *host* *release-dir* *project-name*)
(when *version-file*
(upload-version-file version *version-file* *host* *version-file-dir*))
;; clean up.
(maybe-clean-things-up tarball signature)
;; documentation.
;; (write-line "Building and uploading documentation...")
;; (maybe-cmd! "make -C doc upload-docs")
;; push tags and any outstanding changes.
(write-line "Pushing tags and changes...")
(maybe-cmd! "git push --tags origin master")))
;;;; Do it to it
(let ((force nil)
(version nil)
(args ext:*args*))
(loop while args
do (string-case (pop args)
(("-h" "--help")
(write-line "No help, sorry. Read the source.")
(ext:quit 0))
(("-f" "--force")
(setf force t))
(("-v" "--version")
(setf version (pop args)))
(("-n" "--dry-run")
(setf *dry-run* t))
(t
(die "Unrecognized argument '~a'" it))))
(run force version))
| 9,849 | Common Lisp | .lisp | 212 | 37.65566 | 86 | 0.576102 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 73a8e7c50c61c96779da1caa5e00902a21b6cc0495703d3510e7f3f2365b92ed | 30,634 | [
147445
] |
30,635 | bordeaux-threads-test.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/bordeaux-threads-0.8.3/test/bordeaux-threads-test.lisp | #|
Copyright 2006,2007 Greg Pfeil
Distributed under the MIT license (see LICENSE file)
|#
(defpackage bordeaux-threads-test
(:use #:cl #:bordeaux-threads #:fiveam)
(:shadow #:with-timeout))
(in-package #:bordeaux-threads-test)
(def-suite :bordeaux-threads)
(def-fixture using-lock ()
(let ((lock (make-lock)))
(&body)))
(in-suite :bordeaux-threads)
(test should-have-current-thread
(is (current-thread)))
(test current-thread-identity
(let* ((box (list nil))
(thread (make-thread (lambda ()
(setf (car box) (current-thread))))))
(join-thread thread)
(is (eql (car box) thread))))
(test join-thread-return-value
(is (eql 0 (join-thread (make-thread (lambda () 0))))))
(test should-identify-threads-correctly
(is (threadp (current-thread)))
(is (threadp (make-thread (lambda () t) :name "foo")))
(is (not (threadp (make-lock)))))
(test should-retrieve-thread-name
(is (equal "foo" (thread-name (make-thread (lambda () t) :name "foo")))))
(test interrupt-thread
(let* ((box (list nil))
(thread (make-thread (lambda ()
(setf (car box)
(catch 'new-thread
(sleep 60)
'not-interrupted))))))
(sleep 1)
(interrupt-thread thread (lambda ()
(throw 'new-thread 'interrupted)))
(join-thread thread)
(is (eql 'interrupted (car box)))))
(test should-lock-without-contention
(with-fixture using-lock ()
(is (acquire-lock lock t))
(release-lock lock)
(is (acquire-lock lock nil))
(release-lock lock)))
(defun set-equal (set-a set-b)
(and (null (set-difference set-a set-b))
(null (set-difference set-b set-a))))
(test default-special-bindings
(locally (declare (special *a* *c*))
(let* ((the-as 50) (the-bs 150) (*b* 42)
some-a some-b some-other-a some-other-b
(*default-special-bindings*
`((*a* . (funcall ,(lambda () (incf the-as))))
(*b* . (funcall ,(lambda () (incf the-bs))))
,@*default-special-bindings*))
(threads (list (make-thread
(lambda ()
(setf some-a *a* some-b *b*)))
(make-thread
(lambda ()
(setf some-other-a *a*
some-other-b *b*))))))
(declare (special *b*))
(thread-yield)
(is (not (boundp '*a*)))
(loop while (some #'thread-alive-p threads)
do (thread-yield))
(is (set-equal (list some-a some-other-a) '(51 52)))
(is (set-equal (list some-b some-other-b) '(151 152)))
(is (not (boundp '*a*))))))
(defparameter *shared* 0)
(defparameter *lock* (make-lock))
(test should-have-thread-interaction
;; this simple test generates N process. Each process grabs and
;; releases the lock until SHARED has some value, it then
;; increments SHARED. the outer code first sets shared 1 which
;; gets the thing running and then waits for SHARED to reach some
;; value. this should, i think, stress test locks.
(setf *shared* 0)
(flet ((worker (i)
(loop
do (with-lock-held (*lock*)
(when (= i *shared*)
(incf *shared*)
(return)))
(sleep 0.001))))
(let* ((procs (loop
for i from 1 upto 2
;; create a new binding to protect against implementations that
;; mutate instead of binding the loop variable
collect (let ((i i))
(make-thread (lambda ()
(funcall #'worker i))
:name (format nil "Proc #~D" i))))))
(with-lock-held (*lock*)
(incf *shared*))
(block test
(loop
until (with-lock-held (*lock*)
(= (1+ (length procs)) *shared*))
do (with-lock-held (*lock*)
(is (>= (1+ (length procs)) *shared*)))
(sleep 0.001))))))
(defparameter *condition-variable* (make-condition-variable))
(test condition-variable
(setf *shared* 0)
(flet ((worker (i)
(with-lock-held (*lock*)
(loop
until (= i *shared*)
do (condition-wait *condition-variable* *lock*))
(incf *shared*))
(condition-notify *condition-variable*)))
(let ((num-procs 100))
(dotimes (i num-procs)
;; create a new binding to protect against implementations that
;; mutate instead of binding the loop variable
(let ((i i))
(make-thread (lambda ()
(funcall #'worker i))
:name (format nil "Proc #~D" i))))
(with-lock-held (*lock*)
(loop
until (= num-procs *shared*)
do (condition-wait *condition-variable* *lock*)))
(is (equal num-procs *shared*)))))
;; Generally safe sanity check for the locks and single-notify
#+(and lispworks (not lispworks6))
(test condition-variable-lw
(let ((condition-variable (make-condition-variable :name "Test"))
(test-lock (make-lock))
(completed nil))
(dotimes (id 6)
(let ((id id))
(make-thread (lambda ()
(with-lock-held (test-lock)
(condition-wait condition-variable test-lock)
(push id completed)
(condition-notify condition-variable))))))
(sleep 2)
(if completed
(print "Failed: Premature passage through condition-wait")
(print "Successfully waited on condition"))
(condition-notify condition-variable)
(sleep 2)
(if (and completed
(eql (length completed) 6)
(equal (sort completed #'<)
(loop for id from 0 to 5 collect id)))
(print "Success: All elements notified")
(print (format nil "Failed: Of 6 expected elements, only ~A proceeded" completed)))
(bt::with-cv-access condition-variable
(if (and
(not (or (car wait-tlist) (cdr wait-tlist)))
(zerop (hash-table-count wait-hash))
(zerop (hash-table-count unconsumed-notifications)))
(print "Success: condition variable restored to initial state")
(print "Error: condition variable retains residue from completed waiters")))
(setq completed nil)
(dotimes (id 6)
(let ((id id))
(make-thread (lambda ()
(with-lock-held (test-lock)
(condition-wait condition-variable test-lock)
(push id completed))))))
(sleep 2)
(condition-notify condition-variable)
(sleep 2)
(if (= (length completed) 1)
(print "Success: Notify-single only notified a single waiter to restart")
(format t "Failure: Notify-single restarted ~A items" (length completed)))
(condition-notify condition-variable)
(sleep 2)
(if (= (length completed) 2)
(print "Success: second Notify-single only notified a single waiter to restart")
(format t "Failure: Two Notify-singles restarted ~A items" (length completed)))
(loop for i from 0 to 5 do (condition-notify condition-variable))
(print "Note: In the case of any failures, assume there are outstanding waiting threads")
(values)))
| 7,598 | Common Lisp | .lisp | 182 | 31.192308 | 94 | 0.554489 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 749d5e1c7ee6fc146c6edb74e305f470a31ed6952087f939ea2031c7bd9d38d1 | 30,635 | [
33206
] |
30,636 | impl-clisp.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/bordeaux-threads-0.8.3/src/impl-clisp.lisp | ;;;; -*- indent-tabs-mode: nil -*-
#|
Copyright 2006, 2007 Greg Pfeil
Distributed under the MIT license (see LICENSE file)
|#
(in-package #:bordeaux-threads)
(deftype thread ()
'mt:thread)
;;; Thread Creation
(defun %make-thread (function name)
(mt:make-thread function
:name name
:initial-bindings mt:*default-special-bindings*))
(defun current-thread ()
(mt:current-thread))
(defun threadp (object)
(mt:threadp object))
(defun thread-name (thread)
(mt:thread-name thread))
;;; Resource contention: locks and recursive locks
(defun make-lock (&optional name)
(mt:make-mutex :name (or name "Anonymous lock")))
(defun acquire-lock (lock &optional (wait-p t))
(mt:mutex-lock lock :timeout (if wait-p nil 0)))
(defun release-lock (lock)
(mt:mutex-unlock lock))
(defmacro with-lock-held ((place) &body body)
`(mt:with-mutex-lock (,place) ,@body))
(defun make-recursive-lock (&optional name)
(mt:make-mutex :name (or name "Anonymous recursive lock")
:recursive-p t))
(defmacro with-recursive-lock-held ((place) &body body)
`(mt:with-mutex-lock (,place) ,@body))
;;; Resource contention: condition variables
(defun make-condition-variable (&key name)
(mt:make-exemption :name (or name "Anonymous condition variable")))
(defun condition-wait (condition-variable lock)
(mt:exemption-wait condition-variable lock))
(defun condition-notify (condition-variable)
(mt:exemption-signal condition-variable))
(defun thread-yield ()
(mt:thread-yield))
;;; Timeouts
(defmacro with-timeout ((timeout) &body body)
(once-only (timeout)
`(mt:with-timeout (,timeout (error 'timeout :length ,timeout))
,@body)))
;;; Introspection/debugging
;;; VTZ: mt:list-threads returns all threads that are not garbage collected.
(defun all-threads ()
(delete-if-not #'mt:thread-active-p (mt:list-threads)))
(defun interrupt-thread (thread function &rest args)
(mt:thread-interrupt thread :function function :arguments args))
(defun destroy-thread (thread)
;;; VTZ: actually we can kill ourselelf.
;;; suicide is part of our contemporary life :)
(signal-error-if-current-thread thread)
(mt:thread-interrupt thread :function t))
(defun thread-alive-p (thread)
(mt:thread-active-p thread))
(defun join-thread (thread)
(mt:thread-join thread))
(mark-supported)
| 2,362 | Common Lisp | .lisp | 63 | 34.253968 | 76 | 0.720264 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 4745d1dbaa7b0914578da54b2f3efcea60d5ff6a83a63c71d62b4981c54398ee | 30,636 | [
126717,
335973
] |
30,637 | condition-variables.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/bordeaux-threads-0.8.3/src/condition-variables.lisp | ;;;; -*- indent-tabs-mode: nil -*-
#|
Copyright 2006, 2007 Greg Pfeil
Distributed under the MIT license (see LICENSE file)
|#
(in-package #:bordeaux-threads)
;;; This file provides a portable implementation of condition
;;; variables (given a working WITH-LOCK-HELD and THREAD-YIELD), and
;;; should be used if there is no condition variable implementation in
;;; the host Lisp.
(defstruct condition-var
name
lock
active)
(defun condition-wait (condition-variable lock)
(check-type condition-variable condition-var)
(setf (condition-var-active condition-variable) nil)
(release-lock lock)
(do ()
((when (condition-var-active condition-variable)
(acquire-lock lock)
t))
(thread-yield)))
(defun condition-notify (condition-variable)
(check-type condition-variable condition-var)
(with-lock-held ((condition-var-lock condition-variable))
(setf (condition-var-active condition-variable) t)))
| 945 | Common Lisp | .lisp | 27 | 31.888889 | 70 | 0.740944 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | cfc08e5db9f3a4a436dc97f2bd734be68a6846285ba3781f6dd7ef77db96ec52 | 30,637 | [
304958,
322263
] |
30,638 | impl-lispworks.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/bordeaux-threads-0.8.3/src/impl-lispworks.lisp | ;;;; -*- indent-tabs-mode: nil -*-
#|
Copyright 2006, 2007 Greg Pfeil
Distributed under the MIT license (see LICENSE file)
|#
(in-package #:bordeaux-threads)
;;; documentation on the LispWorks Multiprocessing interface can be found at
;;; http://www.lispworks.com/documentation/lw445/LWUG/html/lwuser-156.htm
(deftype thread ()
'mp:process)
;;; Thread Creation
(defun start-multiprocessing ()
(mp:initialize-multiprocessing))
(defun %make-thread (function name)
(mp:process-run-function
name nil
(lambda ()
(let ((return-values
(multiple-value-list (funcall function))))
(setf (mp:process-property 'return-values)
return-values)
(values-list return-values)))))
(defun current-thread ()
#-#.(cl:if (cl:find-symbol (cl:string '#:get-current-process) :mp) '(and) '(or))
mp:*current-process*
;; introduced in LispWorks 5.1
#+#.(cl:if (cl:find-symbol (cl:string '#:get-current-process) :mp) '(and) '(or))
(mp:get-current-process))
(defun threadp (object)
(mp:process-p object))
(defun thread-name (thread)
(mp:process-name thread))
;;; Resource contention: locks and recursive locks
(defun make-lock (&optional name)
(mp:make-lock :name (or name "Anonymous lock")
#-(or lispworks4 lispworks5) :recursivep
#-(or lispworks4 lispworks5) nil))
(defun acquire-lock (lock &optional (wait-p t))
(mp:process-lock lock nil
(cond ((null wait-p) 0)
((numberp wait-p) wait-p)
(t nil))))
(defun release-lock (lock)
(mp:process-unlock lock))
(defmacro with-lock-held ((place) &body body)
`(mp:with-lock (,place) ,@body))
(defun make-recursive-lock (&optional name)
(mp:make-lock :name (or name "Anonymous recursive lock")
#-(or lispworks4 lispworks5) :recursivep
#-(or lispworks4 lispworks5) t))
(defun acquire-recursive-lock (lock &optional (wait-p t))
(acquire-lock lock wait-p))
(defun release-recursive-lock (lock)
(release-lock lock))
(defmacro with-recursive-lock-held ((place) &body body)
`(mp:with-lock (,place) ,@body))
;;; Resource contention: condition variables
#+(or lispworks6)
(defun make-condition-variable (&key name)
(mp:make-condition-variable :name (or name "Anonymous condition variable")))
#+(or lispworks6)
(defun condition-wait (condition-variable lock)
(mp:condition-variable-wait condition-variable lock))
#+(or lispworks6)
(defun condition-notify (condition-variable)
(mp:condition-variable-signal condition-variable))
(defun thread-yield ()
(mp:process-allow-scheduling))
;;; Introspection/debugging
(defun all-threads ()
(mp:list-all-processes))
(defun interrupt-thread (thread function &rest args)
(apply #'mp:process-interrupt thread function args))
(defun destroy-thread (thread)
(signal-error-if-current-thread thread)
(mp:process-kill thread))
(defun thread-alive-p (thread)
(mp:process-alive-p thread))
(declaim (inline %join-thread))
(defun %join-thread (thread)
#-#.(cl:if (cl:find-symbol (cl:string '#:process-join) :mp) '(and) '(or))
(mp:process-wait (format nil "Waiting for thread ~A to complete" thread)
(complement #'mp:process-alive-p)
thread)
#+#.(cl:if (cl:find-symbol (cl:string '#:process-join) :mp) '(and) '(or))
(mp:process-join thread))
(defun join-thread (thread)
(%join-thread thread)
(let ((return-values
(mp:process-property 'return-values thread)))
(values-list return-values)))
(mark-supported)
| 3,594 | Common Lisp | .lisp | 92 | 34.423913 | 82 | 0.677429 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 7ec8765d3caf7176f72e4c2d947cac4ac60866426e085b1fc15b7b95fe600225 | 30,638 | [
102690,
452771
] |
30,639 | impl-ecl.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/bordeaux-threads-0.8.3/src/impl-ecl.lisp | ;;;; -*- indent-tabs-mode: nil -*-
#|
Copyright 2006, 2007 Greg Pfeil
Distributed under the MIT license (see LICENSE file)
|#
(in-package #:bordeaux-threads)
;;; documentation on the ECL Multiprocessing interface can be found at
;;; http://ecls.sourceforge.net/cgi-bin/view/Main/MultiProcessing
(deftype thread ()
'mp:process)
;;; Thread Creation
(defun %make-thread (function name)
(mp:process-run-function name function))
(defun current-thread ()
mp::*current-process*)
(defun threadp (object)
(typep object 'mp:process))
(defun thread-name (thread)
(mp:process-name thread))
;;; Resource contention: locks and recursive locks
(defun make-lock (&optional name)
(mp:make-lock :name (or name "Anonymous lock")))
(defun acquire-lock (lock &optional (wait-p t))
(mp:get-lock lock wait-p))
(defun release-lock (lock)
(mp:giveup-lock lock))
(defmacro with-lock-held ((place) &body body)
`(mp:with-lock (,place) ,@body))
(defun make-recursive-lock (&optional name)
(mp:make-lock :name (or name "Anonymous recursive lock") :recursive t))
(defun acquire-recursive-lock (lock &optional (wait-p t))
(mp:get-lock lock wait-p))
(defun release-recursive-lock (lock)
(mp:giveup-lock lock))
(defmacro with-recursive-lock-held ((place) &body body)
`(mp:with-lock (,place) ,@body))
;;; Resource contention: condition variables
(defun make-condition-variable (&key name)
(declare (ignore name))
(mp:make-condition-variable))
(defun condition-wait (condition-variable lock)
(mp:condition-variable-wait condition-variable lock))
(defun condition-notify (condition-variable)
(mp:condition-variable-signal condition-variable))
(defun thread-yield ()
(mp:process-yield))
;;; Introspection/debugging
(defun all-threads ()
(mp:all-processes))
(defun interrupt-thread (thread function &rest args)
(flet ((apply-function ()
(if args
(lambda () (apply function args))
function)))
(declare (dynamic-extent #'apply-function))
(mp:interrupt-process thread (apply-function))))
(defun destroy-thread (thread)
(signal-error-if-current-thread thread)
(mp:process-kill thread))
(defun thread-alive-p (thread)
(mp:process-active-p thread))
(defun join-thread (thread)
(mp:process-join thread))
(mark-supported)
| 2,303 | Common Lisp | .lisp | 64 | 32.984375 | 73 | 0.727808 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 8caac0f0147abcff4d905c1dd2b6e47368bc71c17d746576d4e686edcbb36479 | 30,639 | [
138089,
328228
] |
30,640 | impl-sbcl.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/bordeaux-threads-0.8.3/src/impl-sbcl.lisp | ;;;; -*- indent-tabs-mode: nil -*-
#|
Copyright 2006, 2007 Greg Pfeil
Distributed under the MIT license (see LICENSE file)
|#
(in-package #:bordeaux-threads)
;;; documentation on the SBCL Threads interface can be found at
;;; http://www.sbcl.org/manual/Threading.html
(deftype thread ()
'sb-thread:thread)
;;; Thread Creation
(defun %make-thread (function name)
(sb-thread:make-thread function :name name))
(defun current-thread ()
sb-thread:*current-thread*)
(defun threadp (object)
(typep object 'sb-thread:thread))
(defun thread-name (thread)
(sb-thread:thread-name thread))
;;; Resource contention: locks and recursive locks
(defun make-lock (&optional name)
(sb-thread:make-mutex :name (or name "Anonymous lock")))
(defun acquire-lock (lock &optional (wait-p t))
#+#.(cl:if (cl:find-symbol (cl:string '#:grab-mutex) :sb-thread) '(and) '(or))
(sb-thread:grab-mutex lock :waitp wait-p)
#-#.(cl:if (cl:find-symbol (cl:string '#:grab-mutex) :sb-thread) '(and) '(or))
(sb-thread:get-mutex lock nil wait-p))
(defun release-lock (lock)
(sb-thread:release-mutex lock))
(defmacro with-lock-held ((place) &body body)
`(sb-thread:with-mutex (,place) ,@body))
(defun make-recursive-lock (&optional name)
(sb-thread:make-mutex :name (or name "Anonymous recursive lock")))
;;; XXX acquire-recursive-lock and release-recursive-lock are actually
;;; complicated because we can't use control stack tricks. We need to
;;; actually count something to check that the acquire/releases are
;;; balanced
(defmacro with-recursive-lock-held ((place) &body body)
`(sb-thread:with-recursive-lock (,place)
,@body))
;;; Resource contention: condition variables
(defun make-condition-variable (&key name)
(sb-thread:make-waitqueue :name (or name "Anonymous condition variable")))
(defun condition-wait (condition-variable lock)
(sb-thread:condition-wait condition-variable lock))
(defun condition-notify (condition-variable)
(sb-thread:condition-notify condition-variable))
(defun thread-yield ()
(sb-thread:release-foreground))
;;; Timeouts
(deftype timeout ()
'sb-ext:timeout)
(defmacro with-timeout ((timeout) &body body)
`(sb-ext:with-timeout ,timeout
,@body))
;;; Introspection/debugging
(defun all-threads ()
(sb-thread:list-all-threads))
(defun interrupt-thread (thread function &rest args)
(flet ((apply-function ()
(if args
(lambda () (apply function args))
function)))
(declare (dynamic-extent #'apply-function))
(sb-thread:interrupt-thread thread (apply-function))))
(defun destroy-thread (thread)
(signal-error-if-current-thread thread)
(sb-thread:terminate-thread thread))
(defun thread-alive-p (thread)
(sb-thread:thread-alive-p thread))
(defun join-thread (thread)
(sb-thread:join-thread thread))
(mark-supported)
| 2,849 | Common Lisp | .lisp | 73 | 36.054795 | 80 | 0.724754 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | d2c5148d15f2ac163c0e22ff2a6eaf20e93430675b7bb2b781a4f145e5604bd4 | 30,640 | [
228665,
345930
] |
30,641 | impl-lispworks-condition-variables.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/bordeaux-threads-0.8.3/src/impl-lispworks-condition-variables.lisp | ;;;; -*- indent-tabs-mode: nil -*-
;; Lispworks condition support is simulated, albeit via a lightweight wrapper over
;; its own polling-based wait primitive. Waiters register with the condition variable,
;; and use MP:process-wait which queries for permission to proceed at its own (usspecified) interval.
;; http://www.lispworks.com/documentation/lw51/LWRM/html/lwref-445.htm
;; A wakeup callback (on notify) is provided to lighten this query to not have to do a hash lookup
;; on every poll (or have to serialize on the condition variable) and a mechanism is put
;; in place to unregister any waiter that exits wait for other reasons,
;; and to resend any (single) notification that may have been consumed before this (corner
;; case). Much of the complexity present is to support single notification (as recommended in
;; the spec); but a distinct condition-notify-all is provided for reference.
;; Single-notification follows a first-in first-out ordering
;;
;; Performance: With 1000 threads waiting on one condition-variable, the steady-state hit (at least
;; as tested on a 3GHz Win32 box) is noise - hovering at 0% on Task manager.
;; While not true zero like a true native solution, the use of the Lispworks native checks appear
;; fast enough to be an equivalent substitute (thread count will cause issue before the
;; waiting overhead becomes significant)
(defstruct (condition-variable (:constructor make-lw-condition (name)))
name
(lock (mp:make-lock :name "For condition-variable") :type mp:lock :read-only t)
(wait-tlist (cons nil nil) :type cons :read-only t)
(wait-hash (make-hash-table :test 'eq) :type hash-table :read-only t)
;; unconsumed-notifications is to track :remove-from-consideration
;; for entries that may have exited prematurely - notification is sent through
;; to someone else, and offender is removed from hash and list
(unconsumed-notifications (make-hash-table :test 'eq) :type hash-table :read-only t))
(defun make-condition-variable (&key name)
(make-lw-condition name))
(defmacro with-cv-access (condition-variable &body body)
(let ((cv-sym (gensym))
(slots '(lock wait-tlist wait-hash unconsumed-notifications)))
`(let ((,cv-sym ,condition-variable))
(with-slots ,slots
,cv-sym
(macrolet ((locked (&body body) `(mp:with-lock (lock) ,@body)))
(labels ((,(gensym) () ,@slots))) ; Trigger expansion of the symbol-macrolets to ignore
,@body)))))
(defmacro defcvfun (function-name (condition-variable &rest args) &body body)
`(defun ,function-name (,condition-variable ,@args)
(with-cv-access ,condition-variable
,@body)))
#+lispworks (editor:setup-indent "defcvfun" 2 2 7) ; indent defcvfun
; utility function thath assumes process is locked on condition-variable's lock.
(defcvfun do-notify-single (condition-variable) ; assumes already locked
(let ((id (caar wait-tlist)))
(when id
(pop (car wait-tlist))
(unless (car wait-tlist) ; check for empty
(setf (cdr wait-tlist) nil))
(funcall (gethash id wait-hash)) ; call waiter-wakeup
(remhash id wait-hash) ; absence of entry = permission to proceed
(setf (gethash id unconsumed-notifications) t))))
;; Added for completeness/to show how it's done in this paradigm; but
;; The symbol for this call is not exposed in the api
(defcvfun condition-notify-all (condition-variable)
(locked
(loop for waiter-wakeup being the hash-values in wait-hash do (funcall waiter-wakeup))
(clrhash wait-hash)
(clrhash unconsumed-notifications) ; don't care as everyone just got notified
(setf (car wait-tlist) nil)
(setf (cdr wait-tlist) nil)))
;; Currently implemented so as to notify only one waiting thread
(defcvfun condition-notify (condition-variable)
(locked (do-notify-single condition-variable)))
(defun delete-from-tlist (tlist element)
(let ((deleter
(lambda ()
(setf (car tlist) (cdar tlist))
(unless (car tlist)
(setf (cdr tlist) nil)))))
(loop for cons in (car tlist) do
(if (eq element (car cons))
(progn
(funcall deleter)
(return nil))
(let ((cons cons))
(setq deleter
(lambda ()
(setf (cdr cons) (cddr cons))
(unless (cdr cons)
(setf (cdr tlist) cons)))))))))
(defun add-to-tlist-tail (tlist element)
(let ((new-link (cons element nil)))
(cond
((car tlist)
(setf (cddr tlist) new-link)
(setf (cdr tlist) new-link))
(t
(setf (car tlist) new-link)
(setf (cdr tlist) new-link)))))
(defcvfun condition-wait (condition-variable lock-)
(mp:process-unlock lock-)
(unwind-protect ; for the re-taking of the lock. Guarding all of the code
(let ((wakeup-allowed-to-proceed nil)
(wakeup-lock (mp:make-lock :name "wakeup lock for condition-wait")))
;; wakeup-allowed-to-proceed is an optimisation to avoid having to serialize all waiters and
;; search the hashtable. That it is locked is for safety/completeness, although
;; as wakeup-allowed-to-proceed only transitions nil -> t, and that missing it once or twice is
;; moot in this situation, it would be redundant even if ever a Lispworks implementation ever became
;; non-atomic in its assigments
(let ((id (cons nil nil))
(clean-exit nil))
(locked
(add-to-tlist-tail wait-tlist id)
(setf (gethash id wait-hash) (lambda () (mp:with-lock (wakeup-lock) (setq wakeup-allowed-to-proceed t)))))
(unwind-protect
(progn
(mp:process-wait
"Waiting for notification"
(lambda ()
(when (mp:with-lock (wakeup-lock) wakeup-allowed-to-proceed)
(locked (not (gethash id wait-hash))))))
(locked (remhash id unconsumed-notifications))
(setq clean-exit t)) ; Notification was consumed
;; Have to call remove-from-consideration just in case process was interrupted
;; rather than having condition met
(unless clean-exit ; clean-exit is just an optimization
(locked
(when (gethash id wait-hash) ; not notified - must have been interrupted
;; Have to unsubscribe
(remhash id wait-hash)
(delete-from-tlist wait-tlist id))
;; note - it's possible to be removed from wait-hash/wait-tlist (in notify-single); but still have an unconsumed notification!
(when (gethash id unconsumed-notifications) ; Must have exited for reasons unrelated to notification
(remhash id unconsumed-notifications) ; Have to pass on the notification to an eligible waiter
(do-notify-single condition-variable)))))))
(mp:process-lock lock-)))
| 6,999 | Common Lisp | .lisp | 128 | 46.851563 | 141 | 0.666521 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | a13751d3317f98eadaf57cadc79f0ccaaf418521b74fdf348972608f6fd4de7f | 30,641 | [
255929,
285870
] |
30,642 | impl-corman.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/bordeaux-threads-0.8.3/src/impl-corman.lisp | ;;;; -*- indent-tabs-mode: nil -*-
#|
Copyright 2006, 2007 Greg Pfeil
Distributed under the MIT license (see LICENSE file)
|#
(in-package #:bordeaux-threads)
;;; Thread Creation
(defun %make-thread (function name)
(declare (ignore name))
(threads:create-thread function))
(defun current-thread ()
threads:*current-thread*)
;;; Introspection/debugging
(defun destroy-thread (thread)
(signal-error-if-current-thread thread)
(threads:terminate-thread thread))
(mark-supported)
| 493 | Common Lisp | .lisp | 17 | 26.882353 | 52 | 0.753747 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | dfb7eec5b70cea2e31faa097d4724ab8285739a338255942a6330c43f9d75328 | 30,642 | [
419180,
478577
] |
30,643 | impl-abcl.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/bordeaux-threads-0.8.3/src/impl-abcl.lisp | ;;;; -*- indent-tabs-mode: nil -*-
#|
Copyright 2006, 2007 Greg Pfeil
Reimplemented with java.util.concurrent.locks.ReentrantLock by Mark Evenson 2011.
Distributed under the MIT license (see LICENSE file)
|#
(in-package #:bordeaux-threads)
;;; the implementation of the Armed Bear thread interface can be found in
;;; src/org/armedbear/lisp/LispThread.java
(deftype thread ()
'threads:thread)
;;; Thread Creation
(defun %make-thread (function name)
(threads:make-thread function :name name))
(defun current-thread ()
(threads:current-thread))
(defun thread-name (thread)
(threads:thread-name thread))
(defun threadp (object)
(typep object 'thread))
;;; Resource contention: locks and recursive locks
(defstruct mutex name lock)
(defstruct (mutex-recursive (:include mutex)))
;; Making methods constants in this manner avoids the runtime expense of
;; introspection involved in JCALL with string arguments.
(defconstant +lock+
(jmethod "java.util.concurrent.locks.ReentrantLock" "lock"))
(defconstant +try-lock+
(jmethod "java.util.concurrent.locks.ReentrantLock" "tryLock"))
(defconstant +is-held-by-current-thread+
(jmethod "java.util.concurrent.locks.ReentrantLock" "isHeldByCurrentThread"))
(defconstant +unlock+
(jmethod "java.util.concurrent.locks.ReentrantLock" "unlock"))
(defconstant +get-hold-count+
(jmethod "java.util.concurrent.locks.ReentrantLock" "getHoldCount"))
(defun make-lock (&optional name)
(make-mutex
:name (or name "Anonymous lock")
:lock (jnew "java.util.concurrent.locks.ReentrantLock")))
(defun acquire-lock (lock &optional (wait-p t))
(check-type lock mutex)
(when (jcall +is-held-by-current-thread+ (mutex-lock lock))
(error "Non-recursive lock being reacquired by owner."))
(cond
(wait-p
(jcall +lock+ (mutex-lock lock))
t)
(t (jcall +try-lock+ (mutex-lock lock)))))
(defun release-lock (lock)
(check-type lock mutex)
(unless (jcall +is-held-by-current-thread+ (mutex-lock lock))
(error "Attempt to release lock not held by calling thread."))
(jcall +unlock+ (mutex-lock lock))
(values))
(defun make-recursive-lock (&optional name)
(make-mutex-recursive
:name (or name "Anonymous lock")
:lock (jnew "java.util.concurrent.locks.ReentrantLock")))
(defun acquire-recursive-lock (lock &optional (wait-p t))
(check-type lock mutex-recursive)
(cond
(wait-p
(jcall +lock+ (mutex-recursive-lock lock))
t)
(t (jcall +try-lock+ (mutex-recursive-lock lock)))))
(defun release-recursive-lock (lock)
(check-type lock mutex-recursive)
(unless (jcall +is-held-by-current-thread+ (mutex-lock lock))
(error "Attempt to release lock not held by calling thread."))
(jcall +unlock+ (mutex-lock lock))
(values))
;;; Resource contention: condition variables
(defun thread-yield ()
(sleep 0.01))
(defstruct condition-variable
(name "Anonymous condition variable"))
(defun condition-wait (condition lock)
(threads:synchronized-on condition
(release-lock lock)
(threads:object-wait condition))
(acquire-lock lock))
(defun condition-notify (condition)
(threads:synchronized-on condition
(threads:object-notify condition)))
;;; Introspection/debugging
(defun all-threads ()
(let ((threads ()))
(threads:mapcar-threads (lambda (thread)
(push thread threads)))
(reverse threads)))
(defun interrupt-thread (thread function &rest args)
(apply #'threads:interrupt-thread thread function args))
(defun destroy-thread (thread)
(signal-error-if-current-thread thread)
(threads:destroy-thread thread))
(defun thread-alive-p (thread)
(threads:thread-alive-p thread))
(defun join-thread (thread)
(threads:thread-join thread))
(mark-supported)
| 3,735 | Common Lisp | .lisp | 100 | 34.35 | 81 | 0.739661 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 201aaa09b29d473c549ba9ae4d8056276bfdcce17e214d45e049663a3bdecaf8 | 30,643 | [
33434,
406296
] |
30,644 | impl-scl.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/bordeaux-threads-0.8.3/src/impl-scl.lisp | ;;;; -*- indent-tabs-mode: nil -*-
#|
Copyright 2008 Scieneer Pty Ltd
Distributed under the MIT license (see LICENSE file)
|#
(in-package #:bordeaux-threads)
(deftype thread ()
'thread:thread)
(defun %make-thread (function name)
(thread:thread-create function :name name))
(defun current-thread ()
thread:*thread*)
(defun threadp (object)
(typep object 'thread:thread))
(defun thread-name (thread)
(thread:thread-name thread))
;;; Resource contention: locks and recursive locks
(defun make-lock (&optional name)
(thread:make-lock (or name "Anonymous lock")))
(defun acquire-lock (lock &optional (wait-p t))
(thread::acquire-lock lock nil wait-p))
(defun release-lock (lock)
(thread::release-lock lock))
(defmacro with-lock-held ((place) &body body)
`(thread:with-lock-held (,place) ,@body))
(defun make-recursive-lock (&optional name)
(thread:make-lock (or name "Anonymous recursive lock")
:type :recursive))
;;; XXX acquire-recursive-lock and release-recursive-lock are actually
;;; complicated because we can't use control stack tricks. We need to
;;; actually count something to check that the acquire/releases are
;;; balanced
(defmacro with-recursive-lock-held ((place) &body body)
`(thread:with-lock-held (,place)
,@body))
;;; Resource contention: condition variables
(defun make-condition-variable (&key name)
(thread:make-cond-var (or name "Anonymous condition variable")))
(defun condition-wait (condition-variable lock)
(thread:cond-var-wait condition-variable lock))
(defun condition-notify (condition-variable)
(thread:cond-var-broadcast condition-variable))
(defun thread-yield ()
(mp:process-yield))
;;; Introspection/debugging
(defun all-threads ()
(mp:all-processes))
(defun interrupt-thread (thread function &rest args)
(flet ((apply-function ()
(if args
(lambda () (apply function args))
function)))
(declare (dynamic-extent #'apply-function))
(thread:thread-interrupt thread (apply-function))))
(defun destroy-thread (thread)
(thread:destroy-thread thread))
(defun thread-alive-p (thread)
(mp:process-alive-p thread))
(defun join-thread (thread)
(mp:process-wait (format nil "Waiting for thread ~A to complete" thread)
(lambda () (not (mp:process-alive-p thread)))))
(mark-supported)
| 2,365 | Common Lisp | .lisp | 62 | 34.548387 | 74 | 0.719121 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | ead6bcbd886a5285272050de0967842c988940591ebbda4c1cb8fc12d9ccbdb9 | 30,644 | [
84979,
472471
] |
30,645 | impl-clozure.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/bordeaux-threads-0.8.3/src/impl-clozure.lisp | ;;;; -*- indent-tabs-mode: nil -*-
#|
Copyright 2006, 2007 Greg Pfeil
Distributed under the MIT license (see LICENSE file)
|#
(in-package #:bordeaux-threads)
;;; documentation on the OpenMCL Threads interface can be found at
;;; http://openmcl.clozure.com/Doc/Programming-with-Threads.html
(deftype thread ()
'ccl:process)
;;; Thread Creation
(defun %make-thread (function name)
(ccl:process-run-function name function))
(defun current-thread ()
ccl:*current-process*)
(defun threadp (object)
(typep object 'ccl:process))
(defun thread-name (thread)
(ccl:process-name thread))
;;; Resource contention: locks and recursive locks
(defun make-lock (&optional name)
(ccl:make-lock (or name "Anonymous lock")))
(defun acquire-lock (lock &optional (wait-p t))
(if wait-p
(ccl:grab-lock lock)
(ccl:try-lock lock)))
(defun release-lock (lock)
(ccl:release-lock lock))
(defmacro with-lock-held ((place) &body body)
`(ccl:with-lock-grabbed (,place)
,@body))
(defun make-recursive-lock (&optional name)
(ccl:make-lock (or name "Anonymous recursive lock")))
(defun acquire-recursive-lock (lock)
(ccl:grab-lock lock))
(defun release-recursive-lock (lock)
(ccl:release-lock lock))
(defmacro with-recursive-lock-held ((place) &body body)
`(ccl:with-lock-grabbed (,place)
,@body))
;;; Resource contention: condition variables
(defun make-condition-variable (&key name)
(declare (ignore name))
(ccl:make-semaphore))
(defun condition-wait (condition-variable lock)
(release-lock lock)
(unwind-protect
(ccl:wait-on-semaphore condition-variable)
(acquire-lock lock t)))
(defun condition-notify (condition-variable)
(ccl:signal-semaphore condition-variable))
(defun thread-yield ()
(ccl:process-allow-schedule))
;;; Introspection/debugging
(defun all-threads ()
(ccl:all-processes))
(defun interrupt-thread (thread function &rest args)
(declare (dynamic-extent args))
(apply #'ccl:process-interrupt thread function args))
(defun destroy-thread (thread)
(signal-error-if-current-thread thread)
(ccl:process-kill thread))
(defun thread-alive-p (thread)
(ccl::process-active-p thread))
(defun join-thread (thread)
(ccl:join-process thread))
(mark-supported)
| 2,250 | Common Lisp | .lisp | 67 | 30.850746 | 66 | 0.737918 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 5d5bca208aed536c033d8d17efcd911a8856c90a2c61534498ba9432580af933 | 30,645 | [
61331,
293252
] |
30,646 | impl-allegro.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/bordeaux-threads-0.8.3/src/impl-allegro.lisp | ;;;; -*- indent-tabs-mode: nil -*-
#|
Copyright 2006, 2007 Greg Pfeil
Distributed under the MIT license (see LICENSE file)
|#
(in-package #:bordeaux-threads)
;;; documentation on the Allegro Multiprocessing interface can be found at
;;; http://www.franz.com/support/documentation/8.1/doc/multiprocessing.htm
;;; Resource contention: locks and recursive locks
(defun make-lock (&optional name)
(mp:make-process-lock :name (or name "Anonymous lock")))
(defun make-recursive-lock (&optional name)
(mp:make-process-lock :name (or name "Anonymous recursive lock")))
(defun acquire-lock (lock &optional (wait-p t))
(mp:process-lock lock mp:*current-process* "Lock" (if wait-p nil 0)))
(defun release-lock (lock)
(mp:process-unlock lock))
(defmacro with-lock-held ((place) &body body)
`(mp:with-process-lock (,place :norecursive t)
,@body))
(defmacro with-recursive-lock-held ((place &key timeout) &body body)
`(mp:with-process-lock (,place :timeout ,timeout)
,@body))
;;; Resource contention: condition variables
(defun make-condition-variable (&key name)
(mp:make-condition-variable :name name))
(defun condition-wait (condition-variable lock)
(mp:condition-variable-wait condition-variable lock))
(defun condition-notify (condition-variable)
(mp:condition-variable-signal condition-variable))
(defun thread-yield ()
(mp:process-allow-schedule))
(deftype thread ()
'mp:process)
;;; Thread Creation
(defun start-multiprocessing ()
(mp:start-scheduler))
(defun %make-thread (function name)
#+smp
(mp:process-run-function name function)
#-smp
(mp:process-run-function
name
(lambda ()
(let ((return-values
(multiple-value-list (funcall function))))
(setf (getf (mp:process-property-list mp:*current-process*)
'return-values)
return-values)
(values-list return-values)))))
(defun current-thread ()
mp:*current-process*)
(defun threadp (object)
(typep object 'mp:process))
(defun thread-name (thread)
(mp:process-name thread))
;;; Timeouts
(defmacro with-timeout ((timeout) &body body)
(once-only (timeout)
`(mp:with-timeout (,timeout (error 'timeout :length ,timeout))
,@body)))
;;; Introspection/debugging
(defun all-threads ()
mp:*all-processes*)
(defun interrupt-thread (thread function &rest args)
(apply #'mp:process-interrupt thread function args))
(defun destroy-thread (thread)
(signal-error-if-current-thread thread)
(mp:process-kill thread))
(defun thread-alive-p (thread)
(mp:process-alive-p thread))
(defun join-thread (thread)
#+smp
(mp:process-join thread)
#-smp
(progn
(mp:process-wait (format nil "Waiting for thread ~A to complete" thread)
(complement #'mp:process-alive-p)
thread)
(let ((return-values
(getf (mp:process-property-list thread) 'return-values)))
(values-list return-values))))
(mark-supported)
| 2,965 | Common Lisp | .lisp | 83 | 31.722892 | 76 | 0.705965 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | f74284adf472f48a2671c9b1db9205f7821bee9555d5b87fc3b8897bd5bda86b | 30,646 | [
13349,
223254
] |
30,647 | pkgdcl.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/bordeaux-threads-0.8.3/src/pkgdcl.lisp | ;;;; -*- indent-tabs-mode: nil -*-
(cl:defpackage bordeaux-threads
(:nicknames #:bt)
(:use #:cl #:alexandria)
#+abcl
(:import-from :java #:jnew #:jcall #:jmethod)
(:export #:thread #:make-thread #:current-thread #:threadp #:thread-name
#:start-multiprocessing
#:*default-special-bindings* #:*standard-io-bindings*
#:*supports-threads-p*
#:make-lock #:acquire-lock #:release-lock #:with-lock-held
#:make-recursive-lock #:acquire-recursive-lock
#:release-recursive-lock #:with-recursive-lock-held
#:make-condition-variable #:condition-wait #:condition-notify
#:with-timeout #:timeout
#:all-threads #:interrupt-thread #:destroy-thread #:thread-alive-p
#:join-thread #:thread-yield)
(:documentation "BORDEAUX-THREADS is a proposed standard for a minimal
MP/threading interface. It is similar to the CLIM-SYS threading and
lock support, but for the following broad differences:
1) Some behaviours are defined in additional detail: attention has
been given to special variable interaction, whether and when
cleanup forms are run. Some behaviours are defined in less
detail: an implementation that does not support multiple
threads is not required to use a new list (nil) for a lock, for
example.
2) Many functions which would be difficult, dangerous or inefficient
to provide on some implementations have been removed. Chiefly
these are functions such as thread-wait which expect for
efficiency that the thread scheduler is written in Lisp and
'hookable', which can't sensibly be done if the scheduler is
external to the Lisp image, or the system has more than one CPU.
3) Unbalanced ACQUIRE-LOCK and RELEASE-LOCK functions have been
added.
4) Posix-style condition variables have been added, as it's not
otherwise possible to implement them correctly using the other
operations that are specified.
Threads may be implemented using whatever applicable techniques are
provided by the operating system: user-space scheduling,
kernel-based LWPs or anything else that does the job.
Some parts of this specification can also be implemented in a Lisp
that does not support multiple threads. Thread creation and some
thread inspection operations will not work, but the locking
functions are still present (though they may do nothing) so that
thread-safe code can be compiled on both multithread and
single-thread implementations without need of conditionals.
To avoid conflict with existing MP/threading interfaces in
implementations, these symbols live in the BORDEAUX-THREADS package.
Implementations and/or users may also make them visible or exported
in other more traditionally named packages."))
| 2,826 | Common Lisp | .lisp | 50 | 50.78 | 77 | 0.743849 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | d3023fda5b437f30a1e1692b85f14faa26e34354ece4e1a29773b04b244ac0ad | 30,647 | [
2297,
3522
] |
30,648 | impl-mkcl.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/bordeaux-threads-0.8.3/src/impl-mkcl.lisp | ;;;; -*- indent-tabs-mode: nil -*-
#|
Copyright 2006, 2007 Greg Pfeil
Copyright 2010 Jean-Claude Beaudoin.
Distributed under the MIT license (see LICENSE file)
|#
(in-package #:bordeaux-threads)
(deftype thread ()
'mt:thread)
;;; Thread Creation
(defun %make-thread (function name)
(mt:thread-run-function name function))
(defun current-thread ()
mt::*thread*)
(defun threadp (object)
(typep object 'mt:thread))
(defun thread-name (thread)
(mt:thread-name thread))
;;; Resource contention: locks and recursive locks
(defun make-lock (&optional name)
(mt:make-lock :name (or name "Anonymous lock")))
(defun acquire-lock (lock &optional (wait-p t))
(mt:get-lock lock wait-p))
(defun release-lock (lock)
(mt:giveup-lock lock))
(defmacro with-lock-held ((place) &body body)
`(mt:with-lock (,place) ,@body))
(defun make-recursive-lock (&optional name)
(mt:make-lock :name (or name "Anonymous recursive lock") :recursive t))
(defun acquire-recursive-lock (lock &optional (wait-p t))
(mt:get-lock lock wait-p))
(defun release-recursive-lock (lock)
(mt:giveup-lock lock))
(defmacro with-recursive-lock-held ((place) &body body)
`(mt:with-lock (,place) ,@body))
;;; Resource contention: condition variables
(defun make-condition-variable (&key name)
(declare (ignore name))
(mt:make-condition-variable))
(defun condition-wait (condition-variable lock)
(mt:condition-wait condition-variable lock))
(defun condition-notify (condition-variable)
(mt:condition-signal condition-variable))
(defun thread-yield ()
(mt:thread-yield))
;;; Introspection/debugging
(defun all-threads ()
(mt:all-threads))
(defun interrupt-thread (thread function &rest args)
(flet ((apply-function ()
(if args
(lambda () (apply function args))
function)))
(declare (dynamic-extent #'apply-function))
(mt:interrupt-thread thread (apply-function))))
(defun destroy-thread (thread)
(signal-error-if-current-thread thread)
(mt:thread-kill thread))
(defun thread-alive-p (thread)
(mt:thread-active-p thread))
(defun join-thread (thread)
(mt:thread-join thread))
(mark-supported)
| 2,164 | Common Lisp | .lisp | 63 | 31.333333 | 73 | 0.721873 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 73ac6e10dac1cd1c09bdf0e7bcdd5670f0ba9970b6a2383abce49abf61cf35c2 | 30,648 | [
68601,
155471
] |
30,649 | bordeaux-threads.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/bordeaux-threads-0.8.3/src/bordeaux-threads.lisp | ;;;; -*- indent-tabs-mode: nil -*-
#|
Copyright 2006, 2007 Greg Pfeil
Distributed under the MIT license (see LICENSE file)
|#
(in-package #:bordeaux-threads)
(defvar *supports-threads-p* nil
"This should be set to T if the running instance has thread support.")
(defun mark-supported ()
(setf *supports-threads-p* t)
(pushnew :bordeaux-threads *features*))
(define-condition bordeaux-mp-condition (error)
((message :initarg :message :reader message))
(:report (lambda (condition stream)
(format stream (message condition)))))
(defgeneric make-threading-support-error ()
(:documentation "Creates a BORDEAUX-THREADS condition which specifies
whether there is no BORDEAUX-THREADS support for the implementation, no
threads enabled for the system, or no support for a particular
function.")
(:method ()
(make-condition
'bordeaux-mp-condition
:message (if *supports-threads-p*
"There is no support for this method on this implementation."
"There is no thread support in this instance."))))
#-sbcl
(define-condition timeout (serious-condition)
((length :initform nil
:initarg :length
:reader timeout-length))
(:report (lambda (c s)
(if (timeout-length c)
(format s "A timeout set to ~A seconds occurred."
(timeout-length c))
(format s "A timeout occurred.")))))
;;; Thread Creation
;;; See default-implementations.lisp for MAKE-THREAD.
;; Forms are evaluated in the new thread or in the calling thread?
(defvar *default-special-bindings* nil
"This variable holds an alist associating special variable symbols
to forms to evaluate. Special variables named in this list will
be locally bound in the new thread before it begins executing user code.
This variable may be rebound around calls to MAKE-THREAD to
add/alter default bindings. The effect of mutating this list is
undefined, but earlier forms take precedence over later forms for
the same symbol, so defaults may be overridden by consing to the
head of the list.")
(defmacro defbindings (name docstring &body initforms)
(check-type docstring string)
`(defparameter ,name
(list
,@(loop for (special form) in initforms
collect `(cons ',special ',form)))
,docstring))
;; Forms are evaluated in the new thread or in the calling thread?
(defbindings *standard-io-bindings*
"Standard bindings of printer/reader control variables as per CL:WITH-STANDARD-IO-SYNTAX."
(*package* (find-package :common-lisp-user))
(*print-array* t)
(*print-base* 10)
(*print-case* :upcase)
(*print-circle* nil)
(*print-escape* t)
(*print-gensym* t)
(*print-length* nil)
(*print-level* nil)
(*print-lines* nil)
(*print-miser-width* nil)
(*print-pprint-dispatch* (copy-pprint-dispatch nil))
(*print-pretty* nil)
(*print-radix* nil)
(*print-readably* t)
(*print-right-margin* nil)
(*read-base* 10)
(*read-default-float-format* 'single-float)
(*read-eval* t)
(*read-suppress* nil)
(*readtable* (copy-readtable nil)))
(defun binding-default-specials (function special-bindings)
"Return a closure that binds the symbols in SPECIAL-BINDINGS and calls
FUNCTION."
(let ((specials (remove-duplicates special-bindings :from-end t :key #'car)))
(lambda ()
(progv (mapcar #'car specials)
(loop for (nil . form) in specials collect (eval form))
(funcall function)))))
;;; FIXME: This test won't work if CURRENT-THREAD
;;; conses a new object each time
(defun signal-error-if-current-thread (thread)
(when (eq thread (current-thread))
(error 'bordeaux-mp-condition
:message "Cannot destroy the current thread")))
| 4,032 | Common Lisp | .lisp | 93 | 38.645161 | 92 | 0.653748 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 10daa803f3c826617af249a589bfaccf73847ffa5f4a52b7b45d4e11b33890be | 30,649 | [
50991,
169083
] |
30,650 | impl-cmucl.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/bordeaux-threads-0.8.3/src/impl-cmucl.lisp | ;;;; -*- indent-tabs-mode: nil -*-
#|
Copyright 2006, 2007 Greg Pfeil
Distributed under the MIT license (see LICENSE file)
|#
(in-package #:bordeaux-threads)
(deftype thread ()
'mp::process)
;;; Thread Creation
(defun start-multiprocessing ()
(mp::startup-idle-and-top-level-loops))
(defun %make-thread (function name)
#+#.(cl:if (cl:find-symbol (cl:string '#:process-join) :mp) '(and) '(or))
(mp:make-process function :name name)
#-#.(cl:if (cl:find-symbol (cl:string '#:process-join) :mp) '(and) '(or))
(mp:make-process (lambda ()
(let ((return-values
(multiple-value-list (funcall function))))
(setf (getf (mp:process-property-list mp:*current-process*)
'return-values)
return-values)
(values-list return-values)))
:name name))
(defun current-thread ()
mp:*current-process*)
(defmethod threadp (object)
(mp:processp object))
(defun thread-name (thread)
(mp:process-name thread))
;;; Resource contention: locks and recursive locks
(defun make-lock (&optional name)
(mp:make-lock (or name "Anonymous lock")))
(defun acquire-lock (lock &optional (wait-p t))
(if wait-p
(mp::lock-wait lock "Lock")
(mp::lock-wait-with-timeout lock "Lock" 0)))
(defun release-lock (lock)
(setf (mp::lock-process lock) nil))
(defmacro with-lock-held ((place) &body body)
`(mp:with-lock-held (,place) ,@body))
(defmacro with-recursive-lock-held ((place &key timeout) &body body)
`(mp:with-lock-held (,place "Lock Wait" :timeout ,timeout) ,@body))
;;; Note that the locks _are_ recursive, but not "balanced", and only
;;; checked if they are being held by the same process by with-lock-held.
;;; The default with-lock-held in bordeaux-mp.lisp sort of works, in that
;;; it will wait for recursive locks by the same process as well.
;;; Resource contention: condition variables
;;; There's some stuff in x86-vm.lisp that might be worth investigating
;;; whether to build on. There's also process-wait and friends.
(defstruct condition-var
"CMUCL doesn't have conditions, so we need to create our own type."
name
lock
active)
(defun make-condition-variable (&key name)
(make-condition-var :lock (make-lock)
:name (or name "Anonymous condition variable")))
(defun condition-wait (condition-variable lock)
(check-type condition-variable condition-var)
(with-lock-held ((condition-var-lock condition-variable))
(setf (condition-var-active condition-variable) nil))
(release-lock lock)
(mp:process-wait "Condition Wait"
#'(lambda () (condition-var-active condition-variable)))
(acquire-lock lock)
t)
(defun condition-notify (condition-variable)
(check-type condition-variable condition-var)
(with-lock-held ((condition-var-lock condition-variable))
(setf (condition-var-active condition-variable) t))
(thread-yield))
(defun thread-yield ()
(mp:process-yield))
;;; Timeouts
(defmacro with-timeout ((timeout) &body body)
(once-only (timeout)
`(mp:with-timeout (,timeout (error 'timeout :length ,timeout))
,@body)))
;;; Introspection/debugging
(defun all-threads ()
(mp:all-processes))
(defun interrupt-thread (thread function &rest args)
(flet ((apply-function ()
(if args
(lambda () (apply function args))
function)))
(declare (dynamic-extent #'apply-function))
(mp:process-interrupt thread (apply-function))))
(defun destroy-thread (thread)
(signal-error-if-current-thread thread)
(mp:destroy-process thread))
(defun thread-alive-p (thread)
(mp:process-active-p thread))
(defun join-thread (thread)
#+#.(cl:if (cl:find-symbol (cl:string '#:process-join) :mp) '(and) '(or))
(mp:process-join thread)
#-#.(cl:if (cl:find-symbol (cl:string '#:process-join) :mp) '(and) '(or))
(progn
(mp:process-wait (format nil "Waiting for thread ~A to complete" thread)
(lambda () (not (mp:process-alive-p thread))))
(let ((return-values
(getf (mp:process-property-list thread) 'return-values)))
(values-list return-values))))
(mark-supported)
| 4,256 | Common Lisp | .lisp | 104 | 35.519231 | 82 | 0.665696 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 1aba283060d7f9d7dd20821caf88503570c855dd73af3aa913f0b612661ec963 | 30,650 | [
261992,
431971
] |
30,651 | default-implementations.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/bordeaux-threads-0.8.3/src/default-implementations.lisp | ;;;; -*- indent-tabs-mode: nil -*-
(in-package #:bordeaux-threads)
;;; Helper macros
(defmacro defdfun (name args doc &body body)
`(eval-when (:compile-toplevel :load-toplevel :execute)
(unless (fboundp ',name)
(defun ,name ,args ,@body))
(setf (documentation ',name 'function)
(or (documentation ',name 'function) ,doc))))
(defmacro defdmacro (name args doc &body body)
`(eval-when (:compile-toplevel :load-toplevel :execute)
(unless (fboundp ',name)
(defmacro ,name ,args ,@body))
(setf (documentation ',name 'function)
(or (documentation ',name 'function) ,doc))))
;;; Thread Creation
(defdfun start-multiprocessing ()
"If the host implementation uses user-level threads, start the
scheduler and multiprocessing, otherwise do nothing.
It is safe to call repeatedly."
nil)
(defdfun make-thread (function &key name
(initial-bindings *default-special-bindings*))
"Creates and returns a thread named NAME, which will call the
function FUNCTION with no arguments: when FUNCTION returns, the
thread terminates. NAME defaults to \"Anonymous thread\" if unsupplied.
On systems that do not support multi-threading, MAKE-THREAD will
signal an error.
The interaction between threads and dynamic variables is in some
cases complex, and depends on whether the variable has only a global
binding (as established by e.g. DEFVAR/DEFPARAMETER/top-level SETQ)
or has been bound locally (e.g. with LET or LET*) in the calling
thread.
- Global bindings are shared between threads: the initial value of a
global variable in the new thread will be the same as in the
parent, and an assignment to such a variable in any thread will be
visible to all threads in which the global binding is visible.
- Local bindings, such as the ones introduced by INITIAL-BINDINGS,
are local to the thread they are introduced in, except that
- Local bindings in the the caller of MAKE-THREAD may or may not be
shared with the new thread that it creates: this is
implementation-defined. Portable code should not depend on
particular behaviour in this case, nor should it assign to such
variables without first rebinding them in the new thread."
(%make-thread (binding-default-specials function initial-bindings)
(or name "Anonymous thread")))
(defdfun %make-thread (function name)
"The actual implementation-dependent function that creates threads."
(declare (ignore function name))
(error (make-threading-support-error)))
(defdfun current-thread ()
"Returns the thread object for the calling
thread. This is the same kind of object as would be returned by
MAKE-THREAD."
nil)
(defdfun threadp (object)
"Returns true if object is a thread, otherwise NIL."
(declare (ignore object))
nil)
(defdfun thread-name (thread)
"Returns the name of the thread, as supplied to MAKE-THREAD."
(declare (ignore thread))
"Main thread")
;;; Resource contention: locks and recursive locks
(defdfun make-lock (&optional name)
"Creates a lock (a mutex) whose name is NAME. If the system does not
support multiple threads this will still return some object, but it
may not be used for very much."
;; In CLIM-SYS this is a freshly consed list (NIL). I don't know if
;; there's some good reason it should be said structure or that it
;; be freshly consed - EQ comparison of locks?
(declare (ignore name))
(list nil))
(defdfun acquire-lock (lock &optional wait-p)
"Acquire the lock LOCK for the calling thread.
WAIT-P governs what happens if the lock is not available: if WAIT-P
is true, the calling thread will wait until the lock is available
and then acquire it; if WAIT-P is NIL, ACQUIRE-LOCK will return
immediately. ACQUIRE-LOCK returns true if the lock was acquired and
NIL otherwise.
This specification does not define what happens if a thread
attempts to acquire a lock that it already holds. For applications
that require locks to be safe when acquired recursively, see instead
MAKE-RECURSIVE-LOCK and friends."
(declare (ignore lock wait-p))
t)
(defdfun release-lock (lock)
"Release LOCK. It is an error to call this unless
the lock has previously been acquired (and not released) by the same
thread. If other threads are waiting for the lock, the
ACQUIRE-LOCK call in one of them will now be able to continue.
This function has no interesting return value."
(declare (ignore lock))
(values))
(defdmacro with-lock-held ((place) &body body)
"Evaluates BODY with the lock named by PLACE, the value of which
is a lock created by MAKE-LOCK. Before the forms in BODY are
evaluated, the lock is acquired as if by using ACQUIRE-LOCK. After the
forms in BODY have been evaluated, or if a non-local control transfer
is caused (e.g. by THROW or SIGNAL), the lock is released as if by
RELEASE-LOCK.
Note that if the debugger is entered, it is unspecified whether the
lock is released at debugger entry or at debugger exit when execution
is restarted."
`(when (acquire-lock ,place t)
(unwind-protect
(locally ,@body)
(release-lock ,place))))
(defdfun make-recursive-lock (&optional name)
"Create and return a recursive lock whose name is NAME. A recursive
lock differs from an ordinary lock in that a thread that already
holds the recursive lock can acquire it again without blocking. The
thread must then release the lock twice before it becomes available
for another thread."
(declare (ignore name))
(list nil))
(defdfun acquire-recursive-lock (lock)
"As for ACQUIRE-LOCK, but for recursive locks."
(declare (ignore lock))
t)
(defdfun release-recursive-lock (lock)
"Release the recursive LOCK. The lock will only
become free after as many Release operations as there have been
Acquire operations. See RELEASE-LOCK for other information."
(declare (ignore lock))
(values))
(defdmacro with-recursive-lock-held ((place &key timeout) &body body)
"Evaluates BODY with the recursive lock named by PLACE, which is a
reference to a recursive lock created by MAKE-RECURSIVE-LOCK. See
WITH-LOCK-HELD etc etc"
(declare (ignore timeout))
`(when (acquire-recursive-lock ,place)
(unwind-protect
(locally ,@body)
(release-recursive-lock ,place))))
;;; Resource contention: condition variables
;;; A condition variable provides a mechanism for threads to put
;;; themselves to sleep while waiting for the state of something to
;;; change, then to be subsequently woken by another thread which has
;;; changed the state.
;;;
;;; A condition variable must be used in conjunction with a lock to
;;; protect access to the state of the object of interest. The
;;; procedure is as follows:
;;;
;;; Suppose two threads A and B, and some kind of notional event
;;; channel C. A is consuming events in C, and B is producing them.
;;; CV is a condition-variable
;;;
;;; 1) A acquires the lock that safeguards access to C
;;; 2) A threads and removes all events that are available in C
;;; 3) When C is empty, A calls CONDITION-WAIT, which atomically
;;; releases the lock and puts A to sleep on CV
;;; 4) Wait to be notified; CONDITION-WAIT will acquire the lock again
;;; before returning
;;; 5) Loop back to step 2, for as long as threading should continue
;;;
;;; When B generates an event E, it
;;; 1) acquires the lock guarding C
;;; 2) adds E to the channel
;;; 3) calls CONDITION-NOTIFY on CV to wake any sleeping thread
;;; 4) releases the lock
;;;
;;; To avoid the "lost wakeup" problem, the implementation must
;;; guarantee that CONDITION-WAIT in thread A atomically releases the
;;; lock and sleeps. If this is not guaranteed there is the
;;; possibility that thread B can add an event and call
;;; CONDITION-NOTIFY between the lock release and the sleep - in this
;;; case the notify call would not see A, which would be left sleeping
;;; despite there being an event available.
(defdfun thread-yield ()
"Allows other threads to run. It may be necessary or desirable to
call this periodically in some implementations; others may schedule
threads automatically. On systems that do not support
multi-threading, this does nothing."
(values))
(defdfun make-condition-variable (&key name)
"Returns a new condition-variable object for use
with CONDITION-WAIT and CONDITION-NOTIFY."
(declare (ignore name))
nil)
(defdfun condition-wait (condition-variable lock)
"Atomically release LOCK and enqueue the calling
thread waiting for CONDITION-VARIABLE. The thread will resume when
another thread has notified it using CONDITION-NOTIFY; it may also
resume if interrupted by some external event or in other
implementation-dependent circumstances: the caller must always test
on waking that there is threading to be done, instead of assuming
that it can go ahead.
However and for whatever reason the thread is resumed, the system
always reacquires LOCK before returning to the caller. It is an
error to call this unless from the thread that holds LOCK.
In an implementation that does not support multiple threads, this
function signals an error."
(declare (ignore condition-variable lock))
(error (make-threading-support-error)))
(defdfun condition-notify (condition-variable)
"Notify at least one of the threads waiting for
CONDITION-VARIABLE. It is implementation-dependent whether one or
more than one (and possibly all) threads are woken, but if the
implementation is capable of waking only a single thread (not all
are) this is probably preferable for efficiency reasons. The order
of wakeup is unspecified and does not necessarily relate to the
order that the threads went to sleep in.
CONDITION-NOTIFY has no useful return value. In an implementation
that does not support multiple threads, it has no effect."
(declare (ignore condition-variable))
(values))
;;; Timeouts
(defdmacro with-timeout ((timeout) &body body)
"Execute `BODY' and signal a condition of type TIMEOUT if the execution of
BODY does not complete within `TIMEOUT' seconds. On implementations which do not
support WITH-TIMEOUT natively and don't support threads either it has no effect."
(declare (ignorable timeout))
#+thread-support
(let ((ok-tag (gensym "OK"))
(timeout-tag (gensym "TIMEOUT"))
(caller (gensym "CALLER"))
(sleeper (gensym "SLEEPER")))
(once-only (timeout)
`(let (,sleeper)
(multiple-value-prog1
(catch ',ok-tag
(catch ',timeout-tag
(let ((,caller (current-thread)))
(setf ,sleeper
(make-thread #'(lambda ()
(sleep ,timeout)
(interrupt-thread ,caller
#'(lambda ()
(ignore-errors
(throw ',timeout-tag nil)))))
:name (format nil "WITH-TIMEOUT thread serving: ~S."
(thread-name ,caller))))
(throw ',ok-tag (progn ,@body))))
(error 'timeout :length ,timeout))
(when (thread-alive-p ,sleeper)
(destroy-thread ,sleeper))))))
#-thread-support
`(progn
,@body))
;;; Introspection/debugging
;;; The following functions may be provided for debugging purposes,
;;; but are not advised to be called from normal user code.
(defdfun all-threads ()
"Returns a sequence of all of the threads. This may not
be freshly-allocated, so the caller should not modify it."
(error (make-threading-support-error)))
(defdfun interrupt-thread (thread function)
"Interrupt THREAD and cause it to evaluate FUNCTION
before continuing with the interrupted path of execution. This may
not be a good idea if THREAD is holding locks or doing anything
important. On systems that do not support multiple threads, this
function signals an error."
(declare (ignore thread function))
(error (make-threading-support-error)))
(defdfun destroy-thread (thread)
"Terminates the thread THREAD, which is an object
as returned by MAKE-THREAD. This should be used with caution: it is
implementation-defined whether the thread runs cleanup forms or
releases its locks first.
Destroying the calling thread is an error."
(declare (ignore thread))
(error (make-threading-support-error)))
(defdfun thread-alive-p (thread)
"Returns true if THREAD is alive, that is, if
DESTROY-THREAD has not been called on it."
(declare (ignore thread))
(error (make-threading-support-error)))
(defdfun join-thread (thread)
"Wait until THREAD terminates. If THREAD
has already terminated, return immediately."
(declare (ignore thread))
(error (make-threading-support-error)))
| 12,993 | Common Lisp | .lisp | 274 | 42.485401 | 95 | 0.72167 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 365f9220a8a4ad3bf9ab383c690dccb25ac21bdf64a88b10de1a0957d7ea3b23 | 30,651 | [
16726,
390953
] |
30,652 | impl-mcl.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/bordeaux-threads-0.8.3/src/impl-mcl.lisp | ;;;; -*- indent-tabs-mode: nil -*-
#|
Copyright 2006, 2007 Greg Pfeil
Distributed under the MIT license (see LICENSE file)
|#
(in-package #:bordeaux-threads)
(deftype thread ()
'ccl::process)
;;; Thread Creation
(defun %make-thread (function name)
(ccl:process-run-function name function))
(defun current-thread ()
ccl:*current-process*)
(defun threadp (object)
(ccl::processp object))
(defun thread-name (thread)
(ccl:process-name thread))
;;; Resource contention: locks and recursive locks
(defun make-lock (&optional name)
(ccl:make-lock (or name "Anonymous lock")))
(defun acquire-lock (lock &optional (wait-p t))
(if wait-p
(ccl:process-lock lock ccl:*current-process*)
;; this is broken, but it's better than a no-op
(ccl:without-interrupts
(when (null (ccl::lock.value lock))
(ccl:process-lock lock ccl:*current-process*)))))
(defun release-lock (lock)
(ccl:process-unlock lock))
(defmacro with-lock-held ((place) &body body)
`(ccl:with-lock-grabbed (,place) ,@body))
(defun thread-yield ()
(ccl:process-allow-schedule))
;;; Introspection/debugging
(defun all-threads ()
ccl:*all-processes*)
(defun interrupt-thread (thread function &rest args)
(declare (dynamic-extent args))
(apply #'ccl:process-interrupt thread function args))
(defun destroy-thread (thread)
(signal-error-if-current-thread thread)
(ccl:process-kill thread))
(mark-supported)
| 1,427 | Common Lisp | .lisp | 43 | 30.465116 | 56 | 0.725073 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 6350ef1ec18e7784f2015f8e23a6c39fb005c71e8f0b79516b9ed45a66cda9ae | 30,652 | [
52128,
465259
] |
30,654 | types.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/alexandria-20150505-git/types.lisp | (in-package :alexandria)
(deftype array-index (&optional (length (1- array-dimension-limit)))
"Type designator for an index into array of LENGTH: an integer between
0 (inclusive) and LENGTH (exclusive). LENGTH defaults to one less than
ARRAY-DIMENSION-LIMIT."
`(integer 0 (,length)))
(deftype array-length (&optional (length (1- array-dimension-limit)))
"Type designator for a dimension of an array of LENGTH: an integer between
0 (inclusive) and LENGTH (inclusive). LENGTH defaults to one less than
ARRAY-DIMENSION-LIMIT."
`(integer 0 ,length))
;; This MACROLET will generate most of CDR5 (http://cdr.eurolisp.org/document/5/)
;; except the RATIO related definitions and ARRAY-INDEX.
(macrolet
((frob (type &optional (base-type type))
(let ((subtype-names (list))
(predicate-names (list)))
(flet ((make-subtype-name (format-control)
(let ((result (format-symbol :alexandria format-control
(symbol-name type))))
(push result subtype-names)
result))
(make-predicate-name (sybtype-name)
(let ((result (format-symbol :alexandria '#:~A-p
(symbol-name sybtype-name))))
(push result predicate-names)
result))
(make-docstring (range-beg range-end range-type)
(let ((inf (ecase range-type (:negative "-inf") (:positive "+inf"))))
(format nil "Type specifier denoting the ~(~A~) range from ~A to ~A."
type
(if (equal range-beg ''*) inf (ensure-car range-beg))
(if (equal range-end ''*) inf (ensure-car range-end))))))
(let* ((negative-name (make-subtype-name '#:negative-~a))
(non-positive-name (make-subtype-name '#:non-positive-~a))
(non-negative-name (make-subtype-name '#:non-negative-~a))
(positive-name (make-subtype-name '#:positive-~a))
(negative-p-name (make-predicate-name negative-name))
(non-positive-p-name (make-predicate-name non-positive-name))
(non-negative-p-name (make-predicate-name non-negative-name))
(positive-p-name (make-predicate-name positive-name))
(negative-extremum)
(positive-extremum)
(below-zero)
(above-zero)
(zero))
(setf (values negative-extremum below-zero
above-zero positive-extremum zero)
(ecase type
(fixnum (values 'most-negative-fixnum -1 1 'most-positive-fixnum 0))
(integer (values ''* -1 1 ''* 0))
(rational (values ''* '(0) '(0) ''* 0))
(real (values ''* '(0) '(0) ''* 0))
(float (values ''* '(0.0E0) '(0.0E0) ''* 0.0E0))
(short-float (values ''* '(0.0S0) '(0.0S0) ''* 0.0S0))
(single-float (values ''* '(0.0F0) '(0.0F0) ''* 0.0F0))
(double-float (values ''* '(0.0D0) '(0.0D0) ''* 0.0D0))
(long-float (values ''* '(0.0L0) '(0.0L0) ''* 0.0L0))))
`(progn
(deftype ,negative-name ()
,(make-docstring negative-extremum below-zero :negative)
`(,',base-type ,,negative-extremum ,',below-zero))
(deftype ,non-positive-name ()
,(make-docstring negative-extremum zero :negative)
`(,',base-type ,,negative-extremum ,',zero))
(deftype ,non-negative-name ()
,(make-docstring zero positive-extremum :positive)
`(,',base-type ,',zero ,,positive-extremum))
(deftype ,positive-name ()
,(make-docstring above-zero positive-extremum :positive)
`(,',base-type ,',above-zero ,,positive-extremum))
(declaim (inline ,@predicate-names))
(defun ,negative-p-name (n)
(and (typep n ',type)
(< n ,zero)))
(defun ,non-positive-p-name (n)
(and (typep n ',type)
(<= n ,zero)))
(defun ,non-negative-p-name (n)
(and (typep n ',type)
(<= ,zero n)))
(defun ,positive-p-name (n)
(and (typep n ',type)
(< ,zero n)))))))))
(frob fixnum integer)
(frob integer)
(frob rational)
(frob real)
(frob float)
(frob short-float)
(frob single-float)
(frob double-float)
(frob long-float))
(defun of-type (type)
"Returns a function of one argument, which returns true when its argument is
of TYPE."
(lambda (thing) (typep thing type)))
(define-compiler-macro of-type (&whole form type &environment env)
;; This can yeild a big benefit, but no point inlining the function
;; all over the place if TYPE is not constant.
(if (constantp type env)
(with-gensyms (thing)
`(lambda (,thing)
(typep ,thing ,type)))
form))
(declaim (inline type=))
(defun type= (type1 type2)
"Returns a primary value of T is TYPE1 and TYPE2 are the same type,
and a secondary value that is true is the type equality could be reliably
determined: primary value of NIL and secondary value of T indicates that the
types are not equivalent."
(multiple-value-bind (sub ok) (subtypep type1 type2)
(cond ((and ok sub)
(subtypep type2 type1))
(ok
(values nil ok))
(t
(multiple-value-bind (sub ok) (subtypep type2 type1)
(declare (ignore sub))
(values nil ok))))))
(define-modify-macro coercef (type-spec) coerce
"Modify-macro for COERCE.")
| 5,864 | Common Lisp | .lisp | 122 | 36.483607 | 95 | 0.550375 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 4c3778d2d4231939c35b875981fc5b1c8b59f3d365d07047817d6e17853a56ad | 30,654 | [
308086
] |
30,659 | tests.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/alexandria-20150505-git/tests.lisp | (in-package :cl-user)
(defpackage :alexandria-tests
(:use :cl :alexandria #+sbcl :sb-rt #-sbcl :rtest)
(:import-from #+sbcl :sb-rt #-sbcl :rtest
#:*compile-tests* #:*expected-failures*))
(in-package :alexandria-tests)
(defun run-tests (&key ((:compiled *compile-tests*)))
(do-tests))
(defun hash-table-test-name (name)
;; Workaround for Clisp calling EQL in a hash-table FASTHASH-EQL.
(hash-table-test (make-hash-table :test name)))
;;;; Arrays
(deftest copy-array.1
(let* ((orig (vector 1 2 3))
(copy (copy-array orig)))
(values (eq orig copy) (equalp orig copy)))
nil t)
(deftest copy-array.2
(let ((orig (make-array 1024 :fill-pointer 0)))
(vector-push-extend 1 orig)
(vector-push-extend 2 orig)
(vector-push-extend 3 orig)
(let ((copy (copy-array orig)))
(values (eq orig copy) (equalp orig copy)
(array-has-fill-pointer-p copy)
(eql (fill-pointer orig) (fill-pointer copy)))))
nil t t t)
(deftest copy-array.3
(let* ((orig (vector 1 2 3))
(copy (copy-array orig)))
(typep copy 'simple-array))
t)
(deftest copy-array.4
(let ((orig (make-array 21
:adjustable t
:fill-pointer 0)))
(dotimes (n 42)
(vector-push-extend n orig))
(let ((copy (copy-array orig
:adjustable nil
:fill-pointer nil)))
(typep copy 'simple-array)))
t)
(deftest array-index.1
(typep 0 'array-index)
t)
;;;; Conditions
(deftest unwind-protect-case.1
(let (result)
(unwind-protect-case ()
(random 10)
(:normal (push :normal result))
(:abort (push :abort result))
(:always (push :always result)))
result)
(:always :normal))
(deftest unwind-protect-case.2
(let (result)
(unwind-protect-case ()
(random 10)
(:always (push :always result))
(:normal (push :normal result))
(:abort (push :abort result)))
result)
(:normal :always))
(deftest unwind-protect-case.3
(let (result1 result2 result3)
(ignore-errors
(unwind-protect-case ()
(error "FOOF!")
(:normal (push :normal result1))
(:abort (push :abort result1))
(:always (push :always result1))))
(catch 'foof
(unwind-protect-case ()
(throw 'foof 42)
(:normal (push :normal result2))
(:abort (push :abort result2))
(:always (push :always result2))))
(block foof
(unwind-protect-case ()
(return-from foof 42)
(:normal (push :normal result3))
(:abort (push :abort result3))
(:always (push :always result3))))
(values result1 result2 result3))
(:always :abort)
(:always :abort)
(:always :abort))
(deftest unwind-protect-case.4
(let (result)
(unwind-protect-case (aborted-p)
(random 42)
(:always (setq result aborted-p)))
result)
nil)
(deftest unwind-protect-case.5
(let (result)
(block foof
(unwind-protect-case (aborted-p)
(return-from foof)
(:always (setq result aborted-p))))
result)
t)
;;;; Control flow
(deftest switch.1
(switch (13 :test =)
(12 :oops)
(13.0 :yay))
:yay)
(deftest switch.2
(switch (13)
((+ 12 2) :oops)
((- 13 1) :oops2)
(t :yay))
:yay)
(deftest eswitch.1
(let ((x 13))
(eswitch (x :test =)
(12 :oops)
(13.0 :yay)))
:yay)
(deftest eswitch.2
(let ((x 13))
(eswitch (x :key 1+)
(11 :oops)
(14 :yay)))
:yay)
(deftest cswitch.1
(cswitch (13 :test =)
(12 :oops)
(13.0 :yay))
:yay)
(deftest cswitch.2
(cswitch (13 :key 1-)
(12 :yay)
(13.0 :oops))
:yay)
(deftest multiple-value-prog2.1
(multiple-value-prog2
(values 1 1 1)
(values 2 20 200)
(values 3 3 3))
2 20 200)
(deftest nth-value-or.1
(multiple-value-bind (a b c)
(nth-value-or 1
(values 1 nil 1)
(values 2 2 2))
(= a b c 2))
t)
(deftest whichever.1
(let ((x (whichever 1 2 3)))
(and (member x '(1 2 3)) t))
t)
(deftest whichever.2
(let* ((a 1)
(b 2)
(c 3)
(x (whichever a b c)))
(and (member x '(1 2 3)) t))
t)
(deftest xor.1
(xor nil nil 1 nil)
1
t)
(deftest xor.2
(xor nil nil 1 2)
nil
nil)
(deftest xor.3
(xor nil nil nil)
nil
t)
;;;; Definitions
(deftest define-constant.1
(let ((name (gensym)))
(eval `(define-constant ,name "FOO" :test 'equal))
(eval `(define-constant ,name "FOO" :test 'equal))
(values (equal "FOO" (symbol-value name))
(constantp name)))
t
t)
(deftest define-constant.2
(let ((name (gensym)))
(eval `(define-constant ,name 13))
(eval `(define-constant ,name 13))
(values (eql 13 (symbol-value name))
(constantp name)))
t
t)
;;;; Errors
;;; TYPEP is specified to return a generalized boolean and, for
;;; example, ECL exploits this by returning the superclasses of ERROR
;;; in this case.
(defun errorp (x)
(not (null (typep x 'error))))
(deftest required-argument.1
(multiple-value-bind (res err)
(ignore-errors (required-argument))
(errorp err))
t)
;;;; Hash tables
(deftest ensure-gethash.1
(let ((table (make-hash-table))
(x (list 1)))
(multiple-value-bind (value already-there)
(ensure-gethash x table 42)
(and (= value 42)
(not already-there)
(= 42 (gethash x table))
(multiple-value-bind (value2 already-there2)
(ensure-gethash x table 13)
(and (= value2 42)
already-there2
(= 42 (gethash x table)))))))
t)
(deftest ensure-gethash.2
(let ((table (make-hash-table))
(count 0))
(multiple-value-call #'values
(ensure-gethash (progn (incf count) :foo)
(progn (incf count) table)
(progn (incf count) :bar))
(gethash :foo table)
count))
:bar nil :bar t 3)
(deftest copy-hash-table.1
(let ((orig (make-hash-table :test 'eq :size 123))
(foo "foo"))
(setf (gethash orig orig) t
(gethash foo orig) t)
(let ((eq-copy (copy-hash-table orig))
(eql-copy (copy-hash-table orig :test 'eql))
(equal-copy (copy-hash-table orig :test 'equal))
(equalp-copy (copy-hash-table orig :test 'equalp)))
(list (eql (hash-table-size eq-copy) (hash-table-size orig))
(eql (hash-table-rehash-size eq-copy)
(hash-table-rehash-size orig))
(hash-table-count eql-copy)
(gethash orig eq-copy)
(gethash (copy-seq foo) eql-copy)
(gethash foo eql-copy)
(gethash (copy-seq foo) equal-copy)
(gethash "FOO" equal-copy)
(gethash "FOO" equalp-copy))))
(t t 2 t nil t t nil t))
(deftest copy-hash-table.2
(let ((ht (make-hash-table))
(list (list :list (vector :A :B :C))))
(setf (gethash 'list ht) list)
(let* ((shallow-copy (copy-hash-table ht))
(deep1-copy (copy-hash-table ht :key 'copy-list))
(list (gethash 'list ht))
(shallow-list (gethash 'list shallow-copy))
(deep1-list (gethash 'list deep1-copy)))
(list (eq ht shallow-copy)
(eq ht deep1-copy)
(eq list shallow-list)
(eq list deep1-list) ; outer list was copied.
(eq (second list) (second shallow-list))
(eq (second list) (second deep1-list)) ; inner vector wasn't copied.
)))
(nil nil t nil t t))
(deftest maphash-keys.1
(let ((keys nil)
(table (make-hash-table)))
(declare (notinline maphash-keys))
(dotimes (i 10)
(setf (gethash i table) t))
(maphash-keys (lambda (k) (push k keys)) table)
(set-equal keys '(0 1 2 3 4 5 6 7 8 9)))
t)
(deftest maphash-values.1
(let ((vals nil)
(table (make-hash-table)))
(declare (notinline maphash-values))
(dotimes (i 10)
(setf (gethash i table) (- i)))
(maphash-values (lambda (v) (push v vals)) table)
(set-equal vals '(0 -1 -2 -3 -4 -5 -6 -7 -8 -9)))
t)
(deftest hash-table-keys.1
(let ((table (make-hash-table)))
(dotimes (i 10)
(setf (gethash i table) t))
(set-equal (hash-table-keys table) '(0 1 2 3 4 5 6 7 8 9)))
t)
(deftest hash-table-values.1
(let ((table (make-hash-table)))
(dotimes (i 10)
(setf (gethash (gensym) table) i))
(set-equal (hash-table-values table) '(0 1 2 3 4 5 6 7 8 9)))
t)
(deftest hash-table-alist.1
(let ((table (make-hash-table)))
(dotimes (i 10)
(setf (gethash i table) (- i)))
(let ((alist (hash-table-alist table)))
(list (length alist)
(assoc 0 alist)
(assoc 3 alist)
(assoc 9 alist)
(assoc nil alist))))
(10 (0 . 0) (3 . -3) (9 . -9) nil))
(deftest hash-table-plist.1
(let ((table (make-hash-table)))
(dotimes (i 10)
(setf (gethash i table) (- i)))
(let ((plist (hash-table-plist table)))
(list (length plist)
(getf plist 0)
(getf plist 2)
(getf plist 7)
(getf plist nil))))
(20 0 -2 -7 nil))
(deftest alist-hash-table.1
(let* ((alist '((0 a) (1 b) (2 c)))
(table (alist-hash-table alist)))
(list (hash-table-count table)
(gethash 0 table)
(gethash 1 table)
(gethash 2 table)
(eq (hash-table-test-name 'eql)
(hash-table-test table))))
(3 (a) (b) (c) t))
(deftest plist-hash-table.1
(let* ((plist '(:a 1 :b 2 :c 3))
(table (plist-hash-table plist :test 'eq)))
(list (hash-table-count table)
(gethash :a table)
(gethash :b table)
(gethash :c table)
(gethash 2 table)
(gethash nil table)
(eq (hash-table-test-name 'eq)
(hash-table-test table))))
(3 1 2 3 nil nil t))
;;;; Functions
(deftest disjoin.1
(let ((disjunction (disjoin (lambda (x)
(and (consp x) :cons))
(lambda (x)
(and (stringp x) :string)))))
(list (funcall disjunction 'zot)
(funcall disjunction '(foo bar))
(funcall disjunction "test")))
(nil :cons :string))
(deftest disjoin.2
(let ((disjunction (disjoin #'zerop)))
(list (funcall disjunction 0)
(funcall disjunction 1)))
(t nil))
(deftest conjoin.1
(let ((conjunction (conjoin #'consp
(lambda (x)
(stringp (car x)))
(lambda (x)
(char (car x) 0)))))
(list (funcall conjunction 'zot)
(funcall conjunction '(foo))
(funcall conjunction '("foo"))))
(nil nil #\f))
(deftest conjoin.2
(let ((conjunction (conjoin #'zerop)))
(list (funcall conjunction 0)
(funcall conjunction 1)))
(t nil))
(deftest compose.1
(let ((composite (compose '1+
(lambda (x)
(* x 2))
#'read-from-string)))
(funcall composite "1"))
3)
(deftest compose.2
(let ((composite
(locally (declare (notinline compose))
(compose '1+
(lambda (x)
(* x 2))
#'read-from-string))))
(funcall composite "2"))
5)
(deftest compose.3
(let ((compose-form (funcall (compiler-macro-function 'compose)
'(compose '1+
(lambda (x)
(* x 2))
#'read-from-string)
nil)))
(let ((fun (funcall (compile nil `(lambda () ,compose-form)))))
(funcall fun "3")))
7)
(deftest compose.4
(let ((composite (compose #'zerop)))
(list (funcall composite 0)
(funcall composite 1)))
(t nil))
(deftest multiple-value-compose.1
(let ((composite (multiple-value-compose
#'truncate
(lambda (x y)
(values y x))
(lambda (x)
(with-input-from-string (s x)
(values (read s) (read s)))))))
(multiple-value-list (funcall composite "2 7")))
(3 1))
(deftest multiple-value-compose.2
(let ((composite (locally (declare (notinline multiple-value-compose))
(multiple-value-compose
#'truncate
(lambda (x y)
(values y x))
(lambda (x)
(with-input-from-string (s x)
(values (read s) (read s))))))))
(multiple-value-list (funcall composite "2 11")))
(5 1))
(deftest multiple-value-compose.3
(let ((compose-form (funcall (compiler-macro-function 'multiple-value-compose)
'(multiple-value-compose
#'truncate
(lambda (x y)
(values y x))
(lambda (x)
(with-input-from-string (s x)
(values (read s) (read s)))))
nil)))
(let ((fun (funcall (compile nil `(lambda () ,compose-form)))))
(multiple-value-list (funcall fun "2 9"))))
(4 1))
(deftest multiple-value-compose.4
(let ((composite (multiple-value-compose #'truncate)))
(multiple-value-list (funcall composite 9 2)))
(4 1))
(deftest curry.1
(let ((curried (curry '+ 3)))
(funcall curried 1 5))
9)
(deftest curry.2
(let ((curried (locally (declare (notinline curry))
(curry '* 2 3))))
(funcall curried 7))
42)
(deftest curry.3
(let ((curried-form (funcall (compiler-macro-function 'curry)
'(curry '/ 8)
nil)))
(let ((fun (funcall (compile nil `(lambda () ,curried-form)))))
(funcall fun 2)))
4)
(deftest curry.4
(let* ((x 1)
(curried (curry (progn
(incf x)
(lambda (y z) (* x y z)))
3)))
(list (funcall curried 7)
(funcall curried 7)
x))
(42 42 2))
(deftest rcurry.1
(let ((r (rcurry '/ 2)))
(funcall r 8))
4)
(deftest rcurry.2
(let* ((x 1)
(curried (rcurry (progn
(incf x)
(lambda (y z) (* x y z)))
3)))
(list (funcall curried 7)
(funcall curried 7)
x))
(42 42 2))
(deftest named-lambda.1
(let ((fac (named-lambda fac (x)
(if (> x 1)
(* x (fac (- x 1)))
x))))
(funcall fac 5))
120)
(deftest named-lambda.2
(let ((fac (named-lambda fac (&key x)
(if (> x 1)
(* x (fac :x (- x 1)))
x))))
(funcall fac :x 5))
120)
;;;; Lists
(deftest alist-plist.1
(alist-plist '((a . 1) (b . 2) (c . 3)))
(a 1 b 2 c 3))
(deftest plist-alist.1
(plist-alist '(a 1 b 2 c 3))
((a . 1) (b . 2) (c . 3)))
(deftest unionf.1
(let* ((list (list 1 2 3))
(orig list))
(unionf list (list 1 2 4))
(values (equal orig (list 1 2 3))
(eql (length list) 4)
(set-difference list (list 1 2 3 4))
(set-difference (list 1 2 3 4) list)))
t
t
nil
nil)
(deftest nunionf.1
(let ((list (list 1 2 3)))
(nunionf list (list 1 2 4))
(values (eql (length list) 4)
(set-difference (list 1 2 3 4) list)
(set-difference list (list 1 2 3 4))))
t
nil
nil)
(deftest appendf.1
(let* ((list (list 1 2 3))
(orig list))
(appendf list '(4 5 6) '(7 8))
(list list (eq list orig)))
((1 2 3 4 5 6 7 8) nil))
(deftest nconcf.1
(let ((list1 (list 1 2 3))
(list2 (list 4 5 6)))
(nconcf list1 list2 (list 7 8 9))
list1)
(1 2 3 4 5 6 7 8 9))
(deftest circular-list.1
(let ((circle (circular-list 1 2 3)))
(list (first circle)
(second circle)
(third circle)
(fourth circle)
(eq circle (nthcdr 3 circle))))
(1 2 3 1 t))
(deftest circular-list-p.1
(let* ((circle (circular-list 1 2 3 4))
(tree (list circle circle))
(dotted (cons circle t))
(proper (list 1 2 3 circle))
(tailcirc (list* 1 2 3 circle)))
(list (circular-list-p circle)
(circular-list-p tree)
(circular-list-p dotted)
(circular-list-p proper)
(circular-list-p tailcirc)))
(t nil nil nil t))
(deftest circular-list-p.2
(circular-list-p 'foo)
nil)
(deftest circular-tree-p.1
(let* ((circle (circular-list 1 2 3 4))
(tree1 (list circle circle))
(tree2 (let* ((level2 (list 1 nil 2))
(level1 (list level2)))
(setf (second level2) level1)
level1))
(dotted (cons circle t))
(proper (list 1 2 3 circle))
(tailcirc (list* 1 2 3 circle))
(quite-proper (list 1 2 3))
(quite-dotted (list 1 (cons 2 3))))
(list (circular-tree-p circle)
(circular-tree-p tree1)
(circular-tree-p tree2)
(circular-tree-p dotted)
(circular-tree-p proper)
(circular-tree-p tailcirc)
(circular-tree-p quite-proper)
(circular-tree-p quite-dotted)))
(t t t t t t nil nil))
(deftest circular-tree-p.2
(alexandria:circular-tree-p '#1=(#1#))
t)
(deftest proper-list-p.1
(let ((l1 (list 1))
(l2 (list 1 2))
(l3 (cons 1 2))
(l4 (list (cons 1 2) 3))
(l5 (circular-list 1 2)))
(list (proper-list-p l1)
(proper-list-p l2)
(proper-list-p l3)
(proper-list-p l4)
(proper-list-p l5)))
(t t nil t nil))
(deftest proper-list-p.2
(proper-list-p '(1 2 . 3))
nil)
(deftest proper-list.type.1
(let ((l1 (list 1))
(l2 (list 1 2))
(l3 (cons 1 2))
(l4 (list (cons 1 2) 3))
(l5 (circular-list 1 2)))
(list (typep l1 'proper-list)
(typep l2 'proper-list)
(typep l3 'proper-list)
(typep l4 'proper-list)
(typep l5 'proper-list)))
(t t nil t nil))
(deftest proper-list-length.1
(values
(proper-list-length nil)
(proper-list-length (list 1))
(proper-list-length (list 2 2))
(proper-list-length (list 3 3 3))
(proper-list-length (list 4 4 4 4))
(proper-list-length (list 5 5 5 5 5))
(proper-list-length (list 6 6 6 6 6 6))
(proper-list-length (list 7 7 7 7 7 7 7))
(proper-list-length (list 8 8 8 8 8 8 8 8))
(proper-list-length (list 9 9 9 9 9 9 9 9 9)))
0 1 2 3 4 5 6 7 8 9)
(deftest proper-list-length.2
(flet ((plength (x)
(handler-case
(proper-list-length x)
(type-error ()
:ok))))
(values
(plength (list* 1))
(plength (list* 2 2))
(plength (list* 3 3 3))
(plength (list* 4 4 4 4))
(plength (list* 5 5 5 5 5))
(plength (list* 6 6 6 6 6 6))
(plength (list* 7 7 7 7 7 7 7))
(plength (list* 8 8 8 8 8 8 8 8))
(plength (list* 9 9 9 9 9 9 9 9 9))))
:ok :ok :ok
:ok :ok :ok
:ok :ok :ok)
(deftest lastcar.1
(let ((l1 (list 1))
(l2 (list 1 2)))
(list (lastcar l1)
(lastcar l2)))
(1 2))
(deftest lastcar.error.2
(handler-case
(progn
(lastcar (circular-list 1 2 3))
nil)
(error ()
t))
t)
(deftest setf-lastcar.1
(let ((l (list 1 2 3 4)))
(values (lastcar l)
(progn
(setf (lastcar l) 42)
(lastcar l))))
4
42)
(deftest setf-lastcar.2
(let ((l (circular-list 1 2 3)))
(multiple-value-bind (res err)
(ignore-errors (setf (lastcar l) 4))
(typep err 'type-error)))
t)
(deftest make-circular-list.1
(let ((l (make-circular-list 3 :initial-element :x)))
(setf (car l) :y)
(list (eq l (nthcdr 3 l))
(first l)
(second l)
(third l)
(fourth l)))
(t :y :x :x :y))
(deftest circular-list.type.1
(let* ((l1 (list 1 2 3))
(l2 (circular-list 1 2 3))
(l3 (list* 1 2 3 l2)))
(list (typep l1 'circular-list)
(typep l2 'circular-list)
(typep l3 'circular-list)))
(nil t t))
(deftest ensure-list.1
(let ((x (list 1))
(y 2))
(list (ensure-list x)
(ensure-list y)))
((1) (2)))
(deftest ensure-cons.1
(let ((x (cons 1 2))
(y nil)
(z "foo"))
(values (ensure-cons x)
(ensure-cons y)
(ensure-cons z)))
(1 . 2)
(nil)
("foo"))
(deftest setp.1
(setp '(1))
t)
(deftest setp.2
(setp nil)
t)
(deftest setp.3
(setp "foo")
nil)
(deftest setp.4
(setp '(1 2 3 1))
nil)
(deftest setp.5
(setp '(1 2 3))
t)
(deftest setp.6
(setp '(a :a))
t)
(deftest setp.7
(setp '(a :a) :key 'character)
nil)
(deftest setp.8
(setp '(a :a) :key 'character :test (constantly nil))
t)
(deftest set-equal.1
(set-equal '(1 2 3) '(3 1 2))
t)
(deftest set-equal.2
(set-equal '("Xa") '("Xb")
:test (lambda (a b) (eql (char a 0) (char b 0))))
t)
(deftest set-equal.3
(set-equal '(1 2) '(4 2))
nil)
(deftest set-equal.4
(set-equal '(a b c) '(:a :b :c) :key 'string :test 'equal)
t)
(deftest set-equal.5
(set-equal '(a d c) '(:a :b :c) :key 'string :test 'equal)
nil)
(deftest set-equal.6
(set-equal '(a b c) '(a b c d))
nil)
(deftest map-product.1
(map-product 'cons '(2 3) '(1 4))
((2 . 1) (2 . 4) (3 . 1) (3 . 4)))
(deftest map-product.2
(map-product #'cons '(2 3) '(1 4))
((2 . 1) (2 . 4) (3 . 1) (3 . 4)))
(deftest flatten.1
(flatten '((1) 2 (((3 4))) ((((5)) 6)) 7))
(1 2 3 4 5 6 7))
(deftest remove-from-plist.1
(let ((orig '(a 1 b 2 c 3 d 4)))
(list (remove-from-plist orig 'a 'c)
(remove-from-plist orig 'b 'd)
(remove-from-plist orig 'b)
(remove-from-plist orig 'a)
(remove-from-plist orig 'd 42 "zot")
(remove-from-plist orig 'a 'b 'c 'd)
(remove-from-plist orig 'a 'b 'c 'd 'x)
(equal orig '(a 1 b 2 c 3 d 4))))
((b 2 d 4)
(a 1 c 3)
(a 1 c 3 d 4)
(b 2 c 3 d 4)
(a 1 b 2 c 3)
nil
nil
t))
(deftest delete-from-plist.1
(let ((orig '(a 1 b 2 c 3 d 4 d 5)))
(list (delete-from-plist (copy-list orig) 'a 'c)
(delete-from-plist (copy-list orig) 'b 'd)
(delete-from-plist (copy-list orig) 'b)
(delete-from-plist (copy-list orig) 'a)
(delete-from-plist (copy-list orig) 'd 42 "zot")
(delete-from-plist (copy-list orig) 'a 'b 'c 'd)
(delete-from-plist (copy-list orig) 'a 'b 'c 'd 'x)
(equal orig (delete-from-plist orig))
(eq orig (delete-from-plist orig))))
((b 2 d 4 d 5)
(a 1 c 3)
(a 1 c 3 d 4 d 5)
(b 2 c 3 d 4 d 5)
(a 1 b 2 c 3)
nil
nil
t
t))
(deftest mappend.1
(mappend (compose 'list '*) '(1 2 3) '(1 2 3))
(1 4 9))
(deftest assoc-value.1
(let ((key1 '(complex key))
(key2 'simple-key)
(alist '())
(result '()))
(push 1 (assoc-value alist key1 :test #'equal))
(push 2 (assoc-value alist key1 :test 'equal))
(push 42 (assoc-value alist key2))
(push 43 (assoc-value alist key2 :test 'eq))
(push (assoc-value alist key1 :test #'equal) result)
(push (assoc-value alist key2) result)
(push 'very (rassoc-value alist (list 2 1) :test #'equal))
(push (cdr (assoc '(very complex key) alist :test #'equal)) result)
result)
((2 1) (43 42) (2 1)))
;;;; Numbers
(deftest clamp.1
(list (clamp 1.5 1 2)
(clamp 2.0 1 2)
(clamp 1.0 1 2)
(clamp 3 1 2)
(clamp 0 1 2))
(1.5 2.0 1.0 2 1))
(deftest gaussian-random.1
(let ((min -0.2)
(max +0.2))
(multiple-value-bind (g1 g2)
(gaussian-random min max)
(values (<= min g1 max)
(<= min g2 max)
(/= g1 g2) ;uh
)))
t
t
t)
#+sbcl
(deftest gaussian-random.2
(handler-case
(sb-ext:with-timeout 2
(progn
(loop
:repeat 10000
:do (gaussian-random 0 nil))
'done))
(sb-ext:timeout ()
'timed-out))
done)
(deftest iota.1
(iota 3)
(0 1 2))
(deftest iota.2
(iota 3 :start 0.0d0)
(0.0d0 1.0d0 2.0d0))
(deftest iota.3
(iota 3 :start 2 :step 3.0)
(2.0 5.0 8.0))
(deftest map-iota.1
(let (all)
(declare (notinline map-iota))
(values (map-iota (lambda (x) (push x all))
3
:start 2
:step 1.1d0)
all))
3
(4.2d0 3.1d0 2.0d0))
(deftest lerp.1
(lerp 0.5 1 2)
1.5)
(deftest lerp.2
(lerp 0.1 1 2)
1.1)
(deftest mean.1
(mean '(1 2 3))
2)
(deftest mean.2
(mean '(1 2 3 4))
5/2)
(deftest mean.3
(mean '(1 2 10))
13/3)
(deftest median.1
(median '(100 0 99 1 98 2 97))
97)
(deftest median.2
(median '(100 0 99 1 98 2 97 96))
193/2)
(deftest variance.1
(variance (list 1 2 3))
2/3)
(deftest standard-deviation.1
(< 0 (standard-deviation (list 1 2 3)) 1)
t)
(deftest maxf.1
(let ((x 1))
(maxf x 2)
x)
2)
(deftest maxf.2
(let ((x 1))
(maxf x 0)
x)
1)
(deftest maxf.3
(let ((x 1)
(c 0))
(maxf x (incf c))
(list x c))
(1 1))
(deftest maxf.4
(let ((xv (vector 0 0 0))
(p 0))
(maxf (svref xv (incf p)) (incf p))
(list p xv))
(2 #(0 2 0)))
(deftest minf.1
(let ((y 1))
(minf y 0)
y)
0)
(deftest minf.2
(let ((xv (vector 10 10 10))
(p 0))
(minf (svref xv (incf p)) (incf p))
(list p xv))
(2 #(10 2 10)))
(deftest subfactorial.1
(mapcar #'subfactorial (iota 22))
(1
0
1
2
9
44
265
1854
14833
133496
1334961
14684570
176214841
2290792932
32071101049
481066515734
7697064251745
130850092279664
2355301661033953
44750731559645106
895014631192902121
18795307255050944540))
;;;; Arrays
#+nil
(deftest array-index.type)
#+nil
(deftest copy-array)
;;;; Sequences
(deftest rotate.1
(list (rotate (list 1 2 3) 0)
(rotate (list 1 2 3) 1)
(rotate (list 1 2 3) 2)
(rotate (list 1 2 3) 3)
(rotate (list 1 2 3) 4))
((1 2 3)
(3 1 2)
(2 3 1)
(1 2 3)
(3 1 2)))
(deftest rotate.2
(list (rotate (vector 1 2 3 4) 0)
(rotate (vector 1 2 3 4))
(rotate (vector 1 2 3 4) 2)
(rotate (vector 1 2 3 4) 3)
(rotate (vector 1 2 3 4) 4)
(rotate (vector 1 2 3 4) 5))
(#(1 2 3 4)
#(4 1 2 3)
#(3 4 1 2)
#(2 3 4 1)
#(1 2 3 4)
#(4 1 2 3)))
(deftest rotate.3
(list (rotate (list 1 2 3) 0)
(rotate (list 1 2 3) -1)
(rotate (list 1 2 3) -2)
(rotate (list 1 2 3) -3)
(rotate (list 1 2 3) -4))
((1 2 3)
(2 3 1)
(3 1 2)
(1 2 3)
(2 3 1)))
(deftest rotate.4
(list (rotate (vector 1 2 3 4) 0)
(rotate (vector 1 2 3 4) -1)
(rotate (vector 1 2 3 4) -2)
(rotate (vector 1 2 3 4) -3)
(rotate (vector 1 2 3 4) -4)
(rotate (vector 1 2 3 4) -5))
(#(1 2 3 4)
#(2 3 4 1)
#(3 4 1 2)
#(4 1 2 3)
#(1 2 3 4)
#(2 3 4 1)))
(deftest rotate.5
(values (rotate (list 1) 17)
(rotate (list 1) -5))
(1)
(1))
(deftest shuffle.1
(let ((s (shuffle (iota 100))))
(list (equal s (iota 100))
(every (lambda (x)
(member x s))
(iota 100))
(every (lambda (x)
(typep x '(integer 0 99)))
s)))
(nil t t))
(deftest shuffle.2
(let ((s (shuffle (coerce (iota 100) 'vector))))
(list (equal s (coerce (iota 100) 'vector))
(every (lambda (x)
(find x s))
(iota 100))
(every (lambda (x)
(typep x '(integer 0 99)))
s)))
(nil t t))
(deftest shuffle.3
(let* ((orig (coerce (iota 21) 'vector))
(copy (copy-seq orig)))
(shuffle copy :start 10 :end 15)
(list (every #'eql (subseq copy 0 10) (subseq orig 0 10))
(every #'eql (subseq copy 15) (subseq orig 15))))
(t t))
(deftest random-elt.1
(let ((s1 #(1 2 3 4))
(s2 '(1 2 3 4)))
(list (dotimes (i 1000 nil)
(unless (member (random-elt s1) s2)
(return nil))
(when (/= (random-elt s1) (random-elt s1))
(return t)))
(dotimes (i 1000 nil)
(unless (member (random-elt s2) s2)
(return nil))
(when (/= (random-elt s2) (random-elt s2))
(return t)))))
(t t))
(deftest removef.1
(let* ((x '(1 2 3))
(x* x)
(y #(1 2 3))
(y* y))
(removef x 1)
(removef y 3)
(list x x* y y*))
((2 3)
(1 2 3)
#(1 2)
#(1 2 3)))
(deftest deletef.1
(let* ((x (list 1 2 3))
(x* x)
(y (vector 1 2 3)))
(deletef x 2)
(deletef y 1)
(list x x* y))
((1 3)
(1 3)
#(2 3)))
(deftest map-permutations.1
(let ((seq (list 1 2 3))
(seen nil)
(ok t))
(map-permutations (lambda (s)
(unless (set-equal s seq)
(setf ok nil))
(when (member s seen :test 'equal)
(setf ok nil))
(push s seen))
seq
:copy t)
(values ok (length seen)))
t
6)
(deftest proper-sequence.type.1
(mapcar (lambda (x)
(typep x 'proper-sequence))
(list (list 1 2 3)
(vector 1 2 3)
#2a((1 2) (3 4))
(circular-list 1 2 3 4)))
(t t nil nil))
(deftest emptyp.1
(mapcar #'emptyp
(list (list 1)
(circular-list 1)
nil
(vector)
(vector 1)))
(nil nil t t nil))
(deftest sequence-of-length-p.1
(mapcar #'sequence-of-length-p
(list nil
#()
(list 1)
(vector 1)
(list 1 2)
(vector 1 2)
(list 1 2)
(vector 1 2)
(list 1 2)
(vector 1 2))
(list 0
0
1
1
2
2
1
1
4
4))
(t t t t t t nil nil nil nil))
(deftest length=.1
(mapcar #'length=
(list nil
#()
(list 1)
(vector 1)
(list 1 2)
(vector 1 2)
(list 1 2)
(vector 1 2)
(list 1 2)
(vector 1 2))
(list 0
0
1
1
2
2
1
1
4
4))
(t t t t t t nil nil nil nil))
(deftest length=.2
;; test the compiler macro
(macrolet ((x (&rest args)
(funcall
(compile nil
`(lambda ()
(length= ,@args))))))
(list (x 2 '(1 2))
(x '(1 2) '(3 4))
(x '(1 2) 2)
(x '(1 2) 2 '(3 4))
(x 1 2 3)))
(t t t t nil))
(deftest copy-sequence.1
(let ((l (list 1 2 3))
(v (vector #\a #\b #\c)))
(declare (notinline copy-sequence))
(let ((l.list (copy-sequence 'list l))
(l.vector (copy-sequence 'vector l))
(l.spec-v (copy-sequence '(vector fixnum) l))
(v.vector (copy-sequence 'vector v))
(v.list (copy-sequence 'list v))
(v.string (copy-sequence 'string v)))
(list (member l (list l.list l.vector l.spec-v))
(member v (list v.vector v.list v.string))
(equal l.list l)
(equalp l.vector #(1 2 3))
(type= (upgraded-array-element-type 'fixnum)
(array-element-type l.spec-v))
(equalp v.vector v)
(equal v.list '(#\a #\b #\c))
(equal "abc" v.string))))
(nil nil t t t t t t))
(deftest first-elt.1
(mapcar #'first-elt
(list (list 1 2 3)
"abc"
(vector :a :b :c)))
(1 #\a :a))
(deftest first-elt.error.1
(mapcar (lambda (x)
(handler-case
(first-elt x)
(type-error ()
:type-error)))
(list nil
#()
12
:zot))
(:type-error
:type-error
:type-error
:type-error))
(deftest setf-first-elt.1
(let ((l (list 1 2 3))
(s (copy-seq "foobar"))
(v (vector :a :b :c)))
(setf (first-elt l) -1
(first-elt s) #\x
(first-elt v) 'zot)
(values l s v))
(-1 2 3)
"xoobar"
#(zot :b :c))
(deftest setf-first-elt.error.1
(let ((l 'foo))
(multiple-value-bind (res err)
(ignore-errors (setf (first-elt l) 4))
(typep err 'type-error)))
t)
(deftest last-elt.1
(mapcar #'last-elt
(list (list 1 2 3)
(vector :a :b :c)
"FOOBAR"
#*001
#*010))
(3 :c #\R 1 0))
(deftest last-elt.error.1
(mapcar (lambda (x)
(handler-case
(last-elt x)
(type-error ()
:type-error)))
(list nil
#()
12
:zot
(circular-list 1 2 3)
(list* 1 2 3 (circular-list 4 5))))
(:type-error
:type-error
:type-error
:type-error
:type-error
:type-error))
(deftest setf-last-elt.1
(let ((l (list 1 2 3))
(s (copy-seq "foobar"))
(b (copy-seq #*010101001)))
(setf (last-elt l) '???
(last-elt s) #\?
(last-elt b) 0)
(values l s b))
(1 2 ???)
"fooba?"
#*010101000)
(deftest setf-last-elt.error.1
(handler-case
(setf (last-elt 'foo) 13)
(type-error ()
:type-error))
:type-error)
(deftest starts-with.1
(list (starts-with 1 '(1 2 3))
(starts-with 1 #(1 2 3))
(starts-with #\x "xyz")
(starts-with 2 '(1 2 3))
(starts-with 3 #(1 2 3))
(starts-with 1 1)
(starts-with nil nil))
(t t t nil nil nil nil))
(deftest starts-with.2
(values (starts-with 1 '(-1 2 3) :key '-)
(starts-with "foo" '("foo" "bar") :test 'equal)
(starts-with "f" '(#\f) :key 'string :test 'equal)
(starts-with -1 '(0 1 2) :key #'1+)
(starts-with "zot" '("ZOT") :test 'equal))
t
t
t
nil
nil)
(deftest ends-with.1
(list (ends-with 3 '(1 2 3))
(ends-with 3 #(1 2 3))
(ends-with #\z "xyz")
(ends-with 2 '(1 2 3))
(ends-with 1 #(1 2 3))
(ends-with 1 1)
(ends-with nil nil))
(t t t nil nil nil nil))
(deftest ends-with.2
(values (ends-with 2 '(0 13 1) :key '1+)
(ends-with "foo" (vector "bar" "foo") :test 'equal)
(ends-with "X" (vector 1 2 #\X) :key 'string :test 'equal)
(ends-with "foo" "foo" :test 'equal))
t
t
t
nil)
(deftest ends-with.error.1
(handler-case
(ends-with 3 (circular-list 3 3 3 1 3 3))
(type-error ()
:type-error))
:type-error)
(deftest sequences.passing-improper-lists
(macrolet ((signals-error-p (form)
`(handler-case
(progn ,form nil)
(type-error (e)
t)))
(cut (fn &rest args)
(with-gensyms (arg)
(print`(lambda (,arg)
(apply ,fn (list ,@(substitute arg '_ args))))))))
(let ((circular-list (make-circular-list 5 :initial-element :foo))
(dotted-list (list* 'a 'b 'c 'd)))
(loop for nth from 0
for fn in (list
(cut #'lastcar _)
(cut #'rotate _ 3)
(cut #'rotate _ -3)
(cut #'shuffle _)
(cut #'random-elt _)
(cut #'last-elt _)
(cut #'ends-with :foo _))
nconcing
(let ((on-circular-p (signals-error-p (funcall fn circular-list)))
(on-dotted-p (signals-error-p (funcall fn dotted-list))))
(when (or (not on-circular-p) (not on-dotted-p))
(append
(unless on-circular-p
(let ((*print-circle* t))
(list
(format nil
"No appropriate error signalled when passing ~S to ~Ath entry."
circular-list nth))))
(unless on-dotted-p
(list
(format nil
"No appropriate error signalled when passing ~S to ~Ath entry."
dotted-list nth)))))))))
nil)
(deftest with-unique-names.1
(let ((*gensym-counter* 0))
(let ((syms (with-unique-names (foo bar quux)
(list foo bar quux))))
(list (find-if #'symbol-package syms)
(equal '("FOO0" "BAR1" "QUUX2")
(mapcar #'symbol-name syms)))))
(nil t))
(deftest with-unique-names.2
(let ((*gensym-counter* 0))
(let ((syms (with-unique-names ((foo "_foo_") (bar -bar-) (quux #\q))
(list foo bar quux))))
(list (find-if #'symbol-package syms)
(equal '("_foo_0" "-BAR-1" "q2")
(mapcar #'symbol-name syms)))))
(nil t))
(deftest with-unique-names.3
(let ((*gensym-counter* 0))
(multiple-value-bind (res err)
(ignore-errors
(eval
'(let ((syms
(with-unique-names ((foo "_foo_") (bar -bar-) (quux 42))
(list foo bar quux))))
(list (find-if #'symbol-package syms)
(equal '("_foo_0" "-BAR-1" "q2")
(mapcar #'symbol-name syms))))))
(errorp err)))
t)
(deftest once-only.1
(macrolet ((cons1.good (x)
(once-only (x)
`(cons ,x ,x)))
(cons1.bad (x)
`(cons ,x ,x)))
(let ((y 0))
(list (cons1.good (incf y))
y
(cons1.bad (incf y))
y)))
((1 . 1) 1 (2 . 3) 3))
(deftest once-only.2
(macrolet ((cons1 (x)
(once-only ((y x))
`(cons ,y ,y))))
(let ((z 0))
(list (cons1 (incf z))
z
(cons1 (incf z)))))
((1 . 1) 1 (2 . 2)))
(deftest parse-body.1
(parse-body '("doc" "body") :documentation t)
("body")
nil
"doc")
(deftest parse-body.2
(parse-body '("body") :documentation t)
("body")
nil
nil)
(deftest parse-body.3
(parse-body '("doc" "body"))
("doc" "body")
nil
nil)
(deftest parse-body.4
(parse-body '((declare (foo)) "doc" (declare (bar)) body) :documentation t)
(body)
((declare (foo)) (declare (bar)))
"doc")
(deftest parse-body.5
(parse-body '((declare (foo)) "doc" (declare (bar)) body))
("doc" (declare (bar)) body)
((declare (foo)))
nil)
(deftest parse-body.6
(multiple-value-bind (res err)
(ignore-errors
(parse-body '("foo" "bar" "quux")
:documentation t))
(errorp err))
t)
;;;; Symbols
(deftest ensure-symbol.1
(ensure-symbol :cons :cl)
cons
:external)
(deftest ensure-symbol.2
(ensure-symbol "CONS" :alexandria)
cons
:inherited)
(deftest ensure-symbol.3
(ensure-symbol 'foo :keyword)
:foo
:external)
(deftest ensure-symbol.4
(ensure-symbol #\* :alexandria)
*
:inherited)
(deftest format-symbol.1
(let ((s (format-symbol nil '#:x-~d 13)))
(list (symbol-package s)
(string= (string '#:x-13) (symbol-name s))))
(nil t))
(deftest format-symbol.2
(format-symbol :keyword '#:sym-~a (string :bolic))
:sym-bolic)
(deftest format-symbol.3
(let ((*package* (find-package :cl)))
(format-symbol t '#:find-~a (string 'package)))
find-package)
(deftest make-keyword.1
(list (make-keyword 'zot)
(make-keyword "FOO")
(make-keyword #\Q))
(:zot :foo :q))
(deftest make-gensym-list.1
(let ((*gensym-counter* 0))
(let ((syms (make-gensym-list 3 "FOO")))
(list (find-if 'symbol-package syms)
(equal '("FOO0" "FOO1" "FOO2")
(mapcar 'symbol-name syms)))))
(nil t))
(deftest make-gensym-list.2
(let ((*gensym-counter* 0))
(let ((syms (make-gensym-list 3)))
(list (find-if 'symbol-package syms)
(equal '("G0" "G1" "G2")
(mapcar 'symbol-name syms)))))
(nil t))
;;;; Type-system
(deftest of-type.1
(locally
(declare (notinline of-type))
(let ((f (of-type 'string)))
(list (funcall f "foo")
(funcall f 'bar))))
(t nil))
(deftest type=.1
(type= 'string 'string)
t
t)
(deftest type=.2
(type= 'list '(or null cons))
t
t)
(deftest type=.3
(type= 'null '(and symbol list))
t
t)
(deftest type=.4
(type= 'string '(satisfies emptyp))
nil
nil)
(deftest type=.5
(type= 'string 'list)
nil
t)
(macrolet
((test (type numbers)
`(deftest ,(format-symbol t '#:cdr5.~a (string type))
(let ((numbers ,numbers))
(values (mapcar (of-type ',(format-symbol t '#:negative-~a (string type))) numbers)
(mapcar (of-type ',(format-symbol t '#:non-positive-~a (string type))) numbers)
(mapcar (of-type ',(format-symbol t '#:non-negative-~a (string type))) numbers)
(mapcar (of-type ',(format-symbol t '#:positive-~a (string type))) numbers)))
(t t t nil nil nil nil)
(t t t t nil nil nil)
(nil nil nil t t t t)
(nil nil nil nil t t t))))
(test fixnum (list most-negative-fixnum -42 -1 0 1 42 most-positive-fixnum))
(test integer (list (1- most-negative-fixnum) -42 -1 0 1 42 (1+ most-positive-fixnum)))
(test rational (list (1- most-negative-fixnum) -42/13 -1 0 1 42/13 (1+ most-positive-fixnum)))
(test real (list most-negative-long-float -42/13 -1 0 1 42/13 most-positive-long-float))
(test float (list most-negative-short-float -42.02 -1.0 0.0 1.0 42.02 most-positive-short-float))
(test short-float (list most-negative-short-float -42.02s0 -1.0s0 0.0s0 1.0s0 42.02s0 most-positive-short-float))
(test single-float (list most-negative-single-float -42.02f0 -1.0f0 0.0f0 1.0f0 42.02f0 most-positive-single-float))
(test double-float (list most-negative-double-float -42.02d0 -1.0d0 0.0d0 1.0d0 42.02d0 most-positive-double-float))
(test long-float (list most-negative-long-float -42.02l0 -1.0l0 0.0l0 1.0l0 42.02l0 most-positive-long-float)))
;;;; Bindings
(declaim (notinline opaque))
(defun opaque (x)
x)
(deftest if-let.1
(if-let (x (opaque :ok))
x
:bad)
:ok)
(deftest if-let.2
(if-let (x (opaque nil))
:bad
(and (not x) :ok))
:ok)
(deftest if-let.3
(let ((x 1))
(if-let ((x 2)
(y x))
(+ x y)
:oops))
3)
(deftest if-let.4
(if-let ((x 1)
(y nil))
:oops
(and (not y) x))
1)
(deftest if-let.5
(if-let (x)
:oops
(not x))
t)
(deftest if-let.error.1
(handler-case
(eval '(if-let x
:oops
:oops))
(type-error ()
:type-error))
:type-error)
(deftest when-let.1
(when-let (x (opaque :ok))
(setf x (cons x x))
x)
(:ok . :ok))
(deftest when-let.2
(when-let ((x 1)
(y nil)
(z 3))
:oops)
nil)
(deftest when-let.3
(let ((x 1))
(when-let ((x 2)
(y x))
(+ x y)))
3)
(deftest when-let.error.1
(handler-case
(eval '(when-let x :oops))
(type-error ()
:type-error))
:type-error)
(deftest when-let*.1
(let ((x 1))
(when-let* ((x 2)
(y x))
(+ x y)))
4)
(deftest when-let*.2
(let ((y 1))
(when-let* (x y)
(1+ x)))
2)
(deftest when-let*.3
(when-let* ((x t)
(y (consp x))
(z (error "OOPS")))
t)
nil)
(deftest when-let*.error.1
(handler-case
(eval '(when-let* x :oops))
(type-error ()
:type-error))
:type-error)
(deftest doplist.1
(let (keys values)
(doplist (k v '(a 1 b 2 c 3) (values t (reverse keys) (reverse values) k v))
(push k keys)
(push v values)))
t
(a b c)
(1 2 3)
nil
nil)
(deftest count-permutations.1
(values (count-permutations 31 7)
(count-permutations 1 1)
(count-permutations 2 1)
(count-permutations 2 2)
(count-permutations 3 2)
(count-permutations 3 1))
13253058000
1
2
2
6
3)
(deftest binomial-coefficient.1
(alexandria:binomial-coefficient 1239 139)
28794902202288970200771694600561826718847179309929858835480006683522184441358211423695124921058123706380656375919763349913245306834194782172712255592710204598527867804110129489943080460154)
;; Exercise bignum case (at least on x86).
(deftest binomial-coefficient.2
(alexandria:binomial-coefficient 2000000000000 20)
430998041177272843950422879590338454856322722740402365741730748431530623813012487773080486408378680853987520854296499536311275320016878730999689934464711239072435565454954447356845336730100919970769793030177499999999900000000000)
(deftest copy-stream.1
(let ((data "sdkfjhsakfh weior763495ewofhsdfk sdfadlkfjhsadf woif sdlkjfhslkdfh sdklfjh"))
(values (equal data
(with-input-from-string (in data)
(with-output-to-string (out)
(alexandria:copy-stream in out))))
(equal (subseq data 10 20)
(with-input-from-string (in data)
(with-output-to-string (out)
(alexandria:copy-stream in out :start 10 :end 20))))
(equal (subseq data 10)
(with-input-from-string (in data)
(with-output-to-string (out)
(alexandria:copy-stream in out :start 10))))
(equal (subseq data 0 20)
(with-input-from-string (in data)
(with-output-to-string (out)
(alexandria:copy-stream in out :end 20))))))
t
t
t
t)
(deftest extremum.1
(let ((n 0))
(dotimes (i 10)
(let ((data (shuffle (coerce (iota 10000 :start i) 'vector)))
(ok t))
(unless (eql i (extremum data #'<))
(setf ok nil))
(unless (eql i (extremum (coerce data 'list) #'<))
(setf ok nil))
(unless (eql (+ 9999 i) (extremum data #'>))
(setf ok nil))
(unless (eql (+ 9999 i) (extremum (coerce data 'list) #'>))
(setf ok nil))
(when ok
(incf n))))
(when (eql 10 (extremum #(100 1 10 1000) #'> :start 1 :end 3))
(incf n))
(when (eql -1000 (extremum #(100 1 10 -1000) #'> :key 'abs))
(incf n))
(when (eq nil (extremum "" (lambda (a b) (error "wtf? ~S, ~S" a b))))
(incf n))
n)
13)
(deftest starts-with-subseq.start1
(starts-with-subseq "foo" "oop" :start1 1)
t
nil)
(deftest starts-with-subseq.start2
(starts-with-subseq "foo" "xfoop" :start2 1)
t
nil)
(deftest format-symbol.print-case-bound
(let ((upper (intern "FOO-BAR"))
(lower (intern "foo-bar"))
(*print-escape* nil))
(values
(let ((*print-case* :downcase))
(and (eq upper (format-symbol t "~A" upper))
(eq lower (format-symbol t "~A" lower))))
(let ((*print-case* :upcase))
(and (eq upper (format-symbol t "~A" upper))
(eq lower (format-symbol t "~A" lower))))
(let ((*print-case* :capitalize))
(and (eq upper (format-symbol t "~A" upper))
(eq lower (format-symbol t "~A" lower))))))
t
t
t)
(deftest iota.fp-start-and-complex-integer-step
(equal '(#C(0.0 0.0) #C(0.0 2.0) #C(0.0 4.0))
(iota 3 :start 0.0 :step #C(0 2)))
t)
(deftest parse-ordinary-lambda-list.1
(multiple-value-bind (req opt rest keys allowp aux keyp)
(parse-ordinary-lambda-list '(a b c &optional d &key))
(and (equal '(a b c) req)
(equal '((d nil nil)) opt)
(equal '() keys)
(not allowp)
(not aux)
(eq t keyp)))
t)
| 51,095 | Common Lisp | .lisp | 1,714 | 21.000583 | 231 | 0.494618 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 2a764d757b8251da9bece742bab8eaaee52fb3457c4af3b3ed43244ca0f439c0 | 30,659 | [
367105
] |
30,662 | numbers.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/alexandria-20150505-git/numbers.lisp | (in-package :alexandria)
(declaim (inline clamp))
(defun clamp (number min max)
"Clamps the NUMBER into [min, max] range. Returns MIN if NUMBER is lesser then
MIN and MAX if NUMBER is greater then MAX, otherwise returns NUMBER."
(if (< number min)
min
(if (> number max)
max
number)))
(defun gaussian-random (&optional min max)
"Returns two gaussian random double floats as the primary and secondary value,
optionally constrained by MIN and MAX. Gaussian random numbers form a standard
normal distribution around 0.0d0.
Sufficiently positive MIN or negative MAX will cause the algorithm used to
take a very long time. If MIN is positive it should be close to zero, and
similarly if MAX is negative it should be close to zero."
(macrolet
((valid (x)
`(<= (or min ,x) ,x (or max ,x)) ))
(labels
((gauss ()
(loop
for x1 = (- (random 2.0d0) 1.0d0)
for x2 = (- (random 2.0d0) 1.0d0)
for w = (+ (expt x1 2) (expt x2 2))
when (< w 1.0d0)
do (let ((v (sqrt (/ (* -2.0d0 (log w)) w))))
(return (values (* x1 v) (* x2 v))))))
(guard (x)
(unless (valid x)
(tagbody
:retry
(multiple-value-bind (x1 x2) (gauss)
(when (valid x1)
(setf x x1)
(go :done))
(when (valid x2)
(setf x x2)
(go :done))
(go :retry))
:done))
x))
(multiple-value-bind
(g1 g2) (gauss)
(values (guard g1) (guard g2))))))
(declaim (inline iota))
(defun iota (n &key (start 0) (step 1))
"Return a list of n numbers, starting from START (with numeric contagion
from STEP applied), each consequtive number being the sum of the previous one
and STEP. START defaults to 0 and STEP to 1.
Examples:
(iota 4) => (0 1 2 3)
(iota 3 :start 1 :step 1.0) => (1.0 2.0 3.0)
(iota 3 :start -1 :step -1/2) => (-1 -3/2 -2)
"
(declare (type (integer 0) n) (number start step))
(loop repeat n
;; KLUDGE: get numeric contagion right for the first element too
for i = (+ (- (+ start step) step)) then (+ i step)
collect i))
(declaim (inline map-iota))
(defun map-iota (function n &key (start 0) (step 1))
"Calls FUNCTION with N numbers, starting from START (with numeric contagion
from STEP applied), each consequtive number being the sum of the previous one
and STEP. START defaults to 0 and STEP to 1. Returns N.
Examples:
(map-iota #'print 3 :start 1 :step 1.0) => 3
;;; 1.0
;;; 2.0
;;; 3.0
"
(declare (type (integer 0) n) (number start step))
(loop repeat n
;; KLUDGE: get numeric contagion right for the first element too
for i = (+ start (- step step)) then (+ i step)
do (funcall function i))
n)
(declaim (inline lerp))
(defun lerp (v a b)
"Returns the result of linear interpolation between A and B, using the
interpolation coefficient V."
(+ a (* v (- b a))))
(declaim (inline mean))
(defun mean (sample)
"Returns the mean of SAMPLE. SAMPLE must be a sequence of numbers."
(/ (reduce #'+ sample) (length sample)))
(declaim (inline median))
(defun median (sample)
"Returns median of SAMPLE. SAMPLE must be a sequence of real numbers."
(let* ((vector (sort (copy-sequence 'vector sample) #'<))
(length (length vector))
(middle (truncate length 2)))
(if (oddp length)
(aref vector middle)
(/ (+ (aref vector middle) (aref vector (1- middle))) 2))))
(declaim (inline variance))
(defun variance (sample &key (biased t))
"Variance of SAMPLE. Returns the biased variance if BIASED is true (the default),
and the unbiased estimator of variance if BIASED is false. SAMPLE must be a
sequence of numbers."
(let ((mean (mean sample)))
(/ (reduce (lambda (a b)
(+ a (expt (- b mean) 2)))
sample
:initial-value 0)
(- (length sample) (if biased 0 1)))))
(declaim (inline standard-deviation))
(defun standard-deviation (sample &key (biased t))
"Standard deviation of SAMPLE. Returns the biased standard deviation if
BIASED is true (the default), and the square root of the unbiased estimator
for variance if BIASED is false (which is not the same as the unbiased
estimator for standard deviation). SAMPLE must be a sequence of numbers."
(sqrt (variance sample :biased biased)))
(define-modify-macro maxf (&rest numbers) max
"Modify-macro for MAX. Sets place designated by the first argument to the
maximum of its original value and NUMBERS.")
(define-modify-macro minf (&rest numbers) min
"Modify-macro for MIN. Sets place designated by the first argument to the
minimum of its original value and NUMBERS.")
;;;; Factorial
;;; KLUDGE: This is really dependant on the numbers in question: for
;;; small numbers this is larger, and vice versa. Ideally instead of a
;;; constant we would have RANGE-FAST-TO-MULTIPLY-DIRECTLY-P.
(defconstant +factorial-bisection-range-limit+ 8)
;;; KLUDGE: This is really platform dependant: ideally we would use
;;; (load-time-value (find-good-direct-multiplication-limit)) instead.
(defconstant +factorial-direct-multiplication-limit+ 13)
(defun %multiply-range (i j)
;; We use a a bit of cleverness here:
;;
;; 1. For large factorials we bisect in order to avoid expensive bignum
;; multiplications: 1 x 2 x 3 x ... runs into bignums pretty soon,
;; and once it does that all further multiplications will be with bignums.
;;
;; By instead doing the multiplication in a tree like
;; ((1 x 2) x (3 x 4)) x ((5 x 6) x (7 x 8))
;; we manage to get less bignums.
;;
;; 2. Division isn't exactly free either, however, so we don't bisect
;; all the way down, but multiply ranges of integers close to each
;; other directly.
;;
;; For even better results it should be possible to use prime
;; factorization magic, but Nikodemus ran out of steam.
;;
;; KLUDGE: We support factorials of bignums, but it seems quite
;; unlikely anyone would ever be able to use them on a modern lisp,
;; since the resulting numbers are unlikely to fit in memory... but
;; it would be extremely unelegant to define FACTORIAL only on
;; fixnums, _and_ on lisps with 16 bit fixnums this can actually be
;; needed.
(labels ((bisect (j k)
(declare (type (integer 1 #.most-positive-fixnum) j k))
(if (< (- k j) +factorial-bisection-range-limit+)
(multiply-range j k)
(let ((middle (+ j (truncate (- k j) 2))))
(* (bisect j middle)
(bisect (+ middle 1) k)))))
(bisect-big (j k)
(declare (type (integer 1) j k))
(if (= j k)
j
(let ((middle (+ j (truncate (- k j) 2))))
(* (if (<= middle most-positive-fixnum)
(bisect j middle)
(bisect-big j middle))
(bisect-big (+ middle 1) k)))))
(multiply-range (j k)
(declare (type (integer 1 #.most-positive-fixnum) j k))
(do ((f k (* f m))
(m (1- k) (1- m)))
((< m j) f)
(declare (type (integer 0 (#.most-positive-fixnum)) m)
(type unsigned-byte f)))))
(if (and (typep i 'fixnum) (typep j 'fixnum))
(bisect i j)
(bisect-big i j))))
(declaim (inline factorial))
(defun %factorial (n)
(if (< n 2)
1
(%multiply-range 1 n)))
(defun factorial (n)
"Factorial of non-negative integer N."
(check-type n (integer 0))
(%factorial n))
;;;; Combinatorics
(defun binomial-coefficient (n k)
"Binomial coefficient of N and K, also expressed as N choose K. This is the
number of K element combinations given N choises. N must be equal to or
greater then K."
(check-type n (integer 0))
(check-type k (integer 0))
(assert (>= n k))
(if (or (zerop k) (= n k))
1
(let ((n-k (- n k)))
;; Swaps K and N-K if K < N-K because the algorithm
;; below is faster for bigger K and smaller N-K
(when (< k n-k)
(rotatef k n-k))
(if (= 1 n-k)
n
;; General case, avoid computing the 1x...xK twice:
;;
;; N! 1x...xN (K+1)x...xN
;; -------- = ---------------- = ------------, N>1
;; K!(N-K)! 1x...xK x (N-K)! (N-K)!
(/ (%multiply-range (+ k 1) n)
(%factorial n-k))))))
(defun subfactorial (n)
"Subfactorial of the non-negative integer N."
(check-type n (integer 0))
(if (zerop n)
1
(do ((x 1 (1+ x))
(a 0 (* x (+ a b)))
(b 1 a))
((= n x) a))))
(defun count-permutations (n &optional (k n))
"Number of K element permutations for a sequence of N objects.
K defaults to N"
(check-type n (integer 0))
(check-type k (integer 0))
(assert (>= n k))
(%multiply-range (1+ (- n k)) n))
| 9,234 | Common Lisp | .lisp | 227 | 33.735683 | 83 | 0.59303 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | cefd89fa7473f12bddd0a0090cdaa6f2776a9f450ed6e33947f0f597e880ad9a | 30,662 | [
265448
] |
30,663 | hash-tables.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/alexandria-20150505-git/hash-tables.lisp | (in-package :alexandria)
(defun copy-hash-table (table &key key test size
rehash-size rehash-threshold)
"Returns a copy of hash table TABLE, with the same keys and values
as the TABLE. The copy has the same properties as the original, unless
overridden by the keyword arguments.
Before each of the original values is set into the new hash-table, KEY
is invoked on the value. As KEY defaults to CL:IDENTITY, a shallow
copy is returned by default."
(setf key (or key 'identity))
(setf test (or test (hash-table-test table)))
(setf size (or size (hash-table-size table)))
(setf rehash-size (or rehash-size (hash-table-rehash-size table)))
(setf rehash-threshold (or rehash-threshold (hash-table-rehash-threshold table)))
(let ((copy (make-hash-table :test test :size size
:rehash-size rehash-size
:rehash-threshold rehash-threshold)))
(maphash (lambda (k v)
(setf (gethash k copy) (funcall key v)))
table)
copy))
(declaim (inline maphash-keys))
(defun maphash-keys (function table)
"Like MAPHASH, but calls FUNCTION with each key in the hash table TABLE."
(maphash (lambda (k v)
(declare (ignore v))
(funcall function k))
table))
(declaim (inline maphash-values))
(defun maphash-values (function table)
"Like MAPHASH, but calls FUNCTION with each value in the hash table TABLE."
(maphash (lambda (k v)
(declare (ignore k))
(funcall function v))
table))
(defun hash-table-keys (table)
"Returns a list containing the keys of hash table TABLE."
(let ((keys nil))
(maphash-keys (lambda (k)
(push k keys))
table)
keys))
(defun hash-table-values (table)
"Returns a list containing the values of hash table TABLE."
(let ((values nil))
(maphash-values (lambda (v)
(push v values))
table)
values))
(defun hash-table-alist (table)
"Returns an association list containing the keys and values of hash table
TABLE."
(let ((alist nil))
(maphash (lambda (k v)
(push (cons k v) alist))
table)
alist))
(defun hash-table-plist (table)
"Returns a property list containing the keys and values of hash table
TABLE."
(let ((plist nil))
(maphash (lambda (k v)
(setf plist (list* k v plist)))
table)
plist))
(defun alist-hash-table (alist &rest hash-table-initargs)
"Returns a hash table containing the keys and values of the association list
ALIST. Hash table is initialized using the HASH-TABLE-INITARGS."
(let ((table (apply #'make-hash-table hash-table-initargs)))
(dolist (cons alist)
(setf (gethash (car cons) table) (cdr cons)))
table))
(defun plist-hash-table (plist &rest hash-table-initargs)
"Returns a hash table containing the keys and values of the property list
PLIST. Hash table is initialized using the HASH-TABLE-INITARGS."
(let ((table (apply #'make-hash-table hash-table-initargs)))
(do ((tail plist (cddr tail)))
((not tail))
(setf (gethash (car tail) table) (cadr tail)))
table))
(defmacro ensure-gethash (key hash-table &optional default)
"Like GETHASH, but if KEY is not found in the HASH-TABLE saves the DEFAULT
under key before returning it. Secondary return value is true if key was
already in the table."
(once-only (key hash-table)
(with-unique-names (value presentp)
`(multiple-value-bind (,value ,presentp) (gethash ,key ,hash-table)
(if ,presentp
(values ,value ,presentp)
(values (setf (gethash ,key ,hash-table) ,default) nil))))))
| 3,755 | Common Lisp | .lisp | 90 | 34.977778 | 83 | 0.656267 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 52482584403f3439ba8588929a4266b67415decf80cb2c76c1be70419b781c92 | 30,663 | [
60420
] |
30,667 | lists.lisp | johncorn271828_X_Orrery/dists/quicklisp/software/alexandria-20150505-git/lists.lisp | (in-package :alexandria)
(declaim (inline safe-endp))
(defun safe-endp (x)
(declare (optimize safety))
(endp x))
(defun alist-plist (alist)
"Returns a property list containing the same keys and values as the
association list ALIST in the same order."
(let (plist)
(dolist (pair alist)
(push (car pair) plist)
(push (cdr pair) plist))
(nreverse plist)))
(defun plist-alist (plist)
"Returns an association list containing the same keys and values as the
property list PLIST in the same order."
(let (alist)
(do ((tail plist (cddr tail)))
((safe-endp tail) (nreverse alist))
(push (cons (car tail) (cadr tail)) alist))))
(declaim (inline racons))
(defun racons (key value ralist)
(acons value key ralist))
(macrolet
((define-alist-get (name get-entry get-value-from-entry add doc)
`(progn
(declaim (inline ,name))
(defun ,name (alist key &key (test 'eql))
,doc
(let ((entry (,get-entry key alist :test test)))
(values (,get-value-from-entry entry) entry)))
(define-setf-expander ,name (place key &key (test ''eql)
&environment env)
(multiple-value-bind
(temporary-variables initforms newvals setter getter)
(get-setf-expansion place env)
(when (cdr newvals)
(error "~A cannot store multiple values in one place" ',name))
(with-unique-names (new-value key-val test-val alist entry)
(values
(append temporary-variables
(list alist
key-val
test-val
entry))
(append initforms
(list getter
key
test
`(,',get-entry ,key-val ,alist :test ,test-val)))
`(,new-value)
`(cond
(,entry
(setf (,',get-value-from-entry ,entry) ,new-value))
(t
(let ,newvals
(setf ,(first newvals) (,',add ,key ,new-value ,alist))
,setter
,new-value)))
`(,',get-value-from-entry ,entry))))))))
(define-alist-get assoc-value assoc cdr acons
"ASSOC-VALUE is an alist accessor very much like ASSOC, but it can
be used with SETF.")
(define-alist-get rassoc-value rassoc car racons
"RASSOC-VALUE is an alist accessor very much like RASSOC, but it can
be used with SETF."))
(defun malformed-plist (plist)
(error "Malformed plist: ~S" plist))
(defmacro doplist ((key val plist &optional values) &body body)
"Iterates over elements of PLIST. BODY can be preceded by
declarations, and is like a TAGBODY. RETURN may be used to terminate
the iteration early. If RETURN is not used, returns VALUES."
(multiple-value-bind (forms declarations) (parse-body body)
(with-gensyms (tail loop results)
`(block nil
(flet ((,results ()
(let (,key ,val)
(declare (ignorable ,key ,val))
(return ,values))))
(let* ((,tail ,plist)
(,key (if ,tail
(pop ,tail)
(,results)))
(,val (if ,tail
(pop ,tail)
(malformed-plist ',plist))))
(declare (ignorable ,key ,val))
,@declarations
(tagbody
,loop
,@forms
(setf ,key (if ,tail
(pop ,tail)
(,results))
,val (if ,tail
(pop ,tail)
(malformed-plist ',plist)))
(go ,loop))))))))
(define-modify-macro appendf (&rest lists) append
"Modify-macro for APPEND. Appends LISTS to the place designated by the first
argument.")
(define-modify-macro nconcf (&rest lists) nconc
"Modify-macro for NCONC. Concatenates LISTS to place designated by the first
argument.")
(define-modify-macro unionf (list &rest args) union
"Modify-macro for UNION. Saves the union of LIST and the contents of the
place designated by the first argument to the designated place.")
(define-modify-macro nunionf (list &rest args) nunion
"Modify-macro for NUNION. Saves the union of LIST and the contents of the
place designated by the first argument to the designated place. May modify
either argument.")
(define-modify-macro reversef () reverse
"Modify-macro for REVERSE. Copies and reverses the list stored in the given
place and saves back the result into the place.")
(define-modify-macro nreversef () nreverse
"Modify-macro for NREVERSE. Reverses the list stored in the given place by
destructively modifying it and saves back the result into the place.")
(defun circular-list (&rest elements)
"Creates a circular list of ELEMENTS."
(let ((cycle (copy-list elements)))
(nconc cycle cycle)))
(defun circular-list-p (object)
"Returns true if OBJECT is a circular list, NIL otherwise."
(and (listp object)
(do ((fast object (cddr fast))
(slow (cons (car object) (cdr object)) (cdr slow)))
(nil)
(unless (and (consp fast) (listp (cdr fast)))
(return nil))
(when (eq fast slow)
(return t)))))
(defun circular-tree-p (object)
"Returns true if OBJECT is a circular tree, NIL otherwise."
(labels ((circularp (object seen)
(and (consp object)
(do ((fast (cons (car object) (cdr object)) (cddr fast))
(slow object (cdr slow)))
(nil)
(when (or (eq fast slow) (member slow seen))
(return-from circular-tree-p t))
(when (or (not (consp fast)) (not (consp (cdr slow))))
(return
(do ((tail object (cdr tail)))
((not (consp tail))
nil)
(let ((elt (car tail)))
(circularp elt (cons object seen))))))))))
(circularp object nil)))
(defun proper-list-p (object)
"Returns true if OBJECT is a proper list."
(cond ((not object)
t)
((consp object)
(do ((fast object (cddr fast))
(slow (cons (car object) (cdr object)) (cdr slow)))
(nil)
(unless (and (listp fast) (consp (cdr fast)))
(return (and (listp fast) (not (cdr fast)))))
(when (eq fast slow)
(return nil))))
(t
nil)))
(deftype proper-list ()
"Type designator for proper lists. Implemented as a SATISFIES type, hence
not recommended for performance intensive use. Main usefullness as a type
designator of the expected type in a TYPE-ERROR."
`(and list (satisfies proper-list-p)))
(defun circular-list-error (list)
(error 'type-error
:datum list
:expected-type '(and list (not circular-list))))
(macrolet ((def (name lambda-list doc step declare ret1 ret2)
(assert (member 'list lambda-list))
`(defun ,name ,lambda-list
,doc
(do ((last list fast)
(fast list (cddr fast))
(slow (cons (car list) (cdr list)) (cdr slow))
,@(when step (list step)))
(nil)
(declare (dynamic-extent slow) ,@(when declare (list declare))
(ignorable last))
(when (safe-endp fast)
(return ,ret1))
(when (safe-endp (cdr fast))
(return ,ret2))
(when (eq fast slow)
(circular-list-error list))))))
(def proper-list-length (list)
"Returns length of LIST, signalling an error if it is not a proper list."
(n 1 (+ n 2))
;; KLUDGE: Most implementations don't actually support lists with bignum
;; elements -- and this is WAY faster on most implementations then declaring
;; N to be an UNSIGNED-BYTE.
(fixnum n)
(1- n)
n)
(def lastcar (list)
"Returns the last element of LIST. Signals a type-error if LIST is not a
proper list."
nil
nil
(cadr last)
(car fast))
(def (setf lastcar) (object list)
"Sets the last element of LIST. Signals a type-error if LIST is not a proper
list."
nil
nil
(setf (cadr last) object)
(setf (car fast) object)))
(defun make-circular-list (length &key initial-element)
"Creates a circular list of LENGTH with the given INITIAL-ELEMENT."
(let ((cycle (make-list length :initial-element initial-element)))
(nconc cycle cycle)))
(deftype circular-list ()
"Type designator for circular lists. Implemented as a SATISFIES type, so not
recommended for performance intensive use. Main usefullness as the
expected-type designator of a TYPE-ERROR."
`(satisfies circular-list-p))
(defun ensure-car (thing)
"If THING is a CONS, its CAR is returned. Otherwise THING is returned."
(if (consp thing)
(car thing)
thing))
(defun ensure-cons (cons)
"If CONS is a cons, it is returned. Otherwise returns a fresh cons with CONS
in the car, and NIL in the cdr."
(if (consp cons)
cons
(cons cons nil)))
(defun ensure-list (list)
"If LIST is a list, it is returned. Otherwise returns the list designated by LIST."
(if (listp list)
list
(list list)))
(defun remove-from-plist (plist &rest keys)
"Returns a propery-list with same keys and values as PLIST, except that keys
in the list designated by KEYS and values corresponding to them are removed.
The returned property-list may share structure with the PLIST, but PLIST is
not destructively modified. Keys are compared using EQ."
(declare (optimize (speed 3)))
;; FIXME: possible optimization: (remove-from-plist '(:x 0 :a 1 :b 2) :a)
;; could return the tail without consing up a new list.
(loop for (key . rest) on plist by #'cddr
do (assert rest () "Expected a proper plist, got ~S" plist)
unless (member key keys :test #'eq)
collect key and collect (first rest)))
(defun delete-from-plist (plist &rest keys)
"Just like REMOVE-FROM-PLIST, but this version may destructively modify the
provided plist."
(declare (optimize speed))
(loop with head = plist
with tail = nil ; a nil tail means an empty result so far
for (key . rest) on plist by #'cddr
do (assert rest () "Expected a proper plist, got ~S" plist)
(if (member key keys :test #'eq)
;; skip over this pair
(let ((next (cdr rest)))
(if tail
(setf (cdr tail) next)
(setf head next)))
;; keep this pair
(setf tail rest))
finally (return head)))
(define-modify-macro remove-from-plistf (&rest keys) remove-from-plist
"Modify macro for REMOVE-FROM-PLIST.")
(define-modify-macro delete-from-plistf (&rest keys) delete-from-plist
"Modify macro for DELETE-FROM-PLIST.")
(declaim (inline sans))
(defun sans (plist &rest keys)
"Alias of REMOVE-FROM-PLIST for backward compatibility."
(apply #'remove-from-plist plist keys))
(defun mappend (function &rest lists)
"Applies FUNCTION to respective element(s) of each LIST, appending all the
all the result list to a single list. FUNCTION must return a list."
(loop for results in (apply #'mapcar function lists)
append results))
(defun setp (object &key (test #'eql) (key #'identity))
"Returns true if OBJECT is a list that denotes a set, NIL otherwise. A list
denotes a set if each element of the list is unique under KEY and TEST."
(and (listp object)
(let (seen)
(dolist (elt object t)
(let ((key (funcall key elt)))
(if (member key seen :test test)
(return nil)
(push key seen)))))))
(defun set-equal (list1 list2 &key (test #'eql) (key nil keyp))
"Returns true if every element of LIST1 matches some element of LIST2 and
every element of LIST2 matches some element of LIST1. Otherwise returns false."
(let ((keylist1 (if keyp (mapcar key list1) list1))
(keylist2 (if keyp (mapcar key list2) list2)))
(and (dolist (elt keylist1 t)
(or (member elt keylist2 :test test)
(return nil)))
(dolist (elt keylist2 t)
(or (member elt keylist1 :test test)
(return nil))))))
(defun map-product (function list &rest more-lists)
"Returns a list containing the results of calling FUNCTION with one argument
from LIST, and one from each of MORE-LISTS for each combination of arguments.
In other words, returns the product of LIST and MORE-LISTS using FUNCTION.
Example:
(map-product 'list '(1 2) '(3 4) '(5 6))
=> ((1 3 5) (1 3 6) (1 4 5) (1 4 6)
(2 3 5) (2 3 6) (2 4 5) (2 4 6))
"
(labels ((%map-product (f lists)
(let ((more (cdr lists))
(one (car lists)))
(if (not more)
(mapcar f one)
(mappend (lambda (x)
(%map-product (curry f x) more))
one)))))
(%map-product (ensure-function function) (cons list more-lists))))
(defun flatten (tree)
"Traverses the tree in order, collecting non-null leaves into a list."
(let (list)
(labels ((traverse (subtree)
(when subtree
(if (consp subtree)
(progn
(traverse (car subtree))
(traverse (cdr subtree)))
(push subtree list)))))
(traverse tree))
(nreverse list)))
| 14,051 | Common Lisp | .lisp | 329 | 32.699088 | 85 | 0.584113 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 6adacffd2c1f26899fd5c15fa51db6c20cd5591552bc103edfff6a8b9aaa4ecd | 30,667 | [
202303,
323451
] |
30,672 | parse-number.asd | johncorn271828_X_Orrery/dists/quicklisp/software/parse-number-1.4/parse-number.asd | ;; -*- Lisp -*-
(defsystem :parse-number
:author "Matthew Danish <[email protected]>"
:maintainer "Sharp Lispers <[email protected]>"
:description "Number parsing library"
:license "public domain"
:version #.(with-open-file (f (merge-pathnames "version.lisp-expr"
(or *compile-file-pathname*
*load-truename*)))
(read f))
:components ((:file "parse-number"))
:in-order-to ((asdf:test-op (asdf:load-op :parse-number-tests)))
:perform (asdf:test-op :after (op c)
(funcall (find-symbol (string '#:run-tests)
:org.mapcar.parse-number-tests))))
(defsystem :parse-number-tests
:author "Stelian Ionescu <[email protected]>"
:maintainer "Sharp Lispers <[email protected]>"
:description "Parse-Number test suite"
:license "public domain"
:depends-on (:parse-number)
:components ((:file "tests")))
| 1,003 | Common Lisp | .asd | 22 | 35.727273 | 76 | 0.602656 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 6c8f0cbdd99f2e2c885d0c1a140b0ac7c0cbf07cf48137a414e230dd8f8809bb | 30,672 | [
242587
] |
30,674 | trivial-features.asd | johncorn271828_X_Orrery/dists/quicklisp/software/trivial-features-20150923-git/trivial-features.asd | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; trivial-features.asd --- ASDF system definition.
;;;
;;; Copyright (C) 2007, Luis Oliveira <[email protected]>
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
#-(or sbcl clisp allegro openmcl mcl mkcl lispworks ecl cmu scl cormanlisp abcl xcl mocl)
(error "Sorry, your Lisp is not supported. Patches welcome.")
(defsystem trivial-features
:description "Ensures consistent *FEATURES* across multiple CLs."
:author "Luis Oliveira <[email protected]>"
:licence "MIT"
:components
((:module src
:serial t
:components
(#+allegro (:file "tf-allegro")
#+clisp (:file "tf-clisp")
#+cmu (:file "tf-cmucl")
#+cormanlisp (:file "tf-cormanlisp")
#+ecl (:file "tf-ecl")
#+lispworks (:file "tf-lispworks")
#+openmcl (:file "tf-openmcl")
#+mcl (:file "tf-mcl")
#+mkcl (:file "tf-mkcl")
#+sbcl (:file "tf-sbcl")
#+scl (:file "tf-scl")
#+abcl (:file "tf-abcl")
#+xcl (:file "tf-xcl")
#+mocl (:file "tf-mocl")
))))
(defmethod perform ((o test-op) (c (eql (find-system 'trivial-features))))
(operate 'load-op 'trivial-features-tests)
(operate 'test-op 'trivial-features-tests))
| 2,355 | Common Lisp | .asd | 53 | 41.566038 | 89 | 0.678121 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | a1c5e91e2d96a5eeffdf6f2cbb38909475fd4ebfe4c507dbff4d86a007a1538c | 30,674 | [
41310
] |
30,678 | cffi.asd | johncorn271828_X_Orrery/dists/quicklisp/software/cffi_0.16.1/cffi.asd | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; cffi.asd --- ASDF system definition for CFFI.
;;;
;;; Copyright (C) 2005-2006, James Bielman <[email protected]>
;;; Copyright (C) 2005-2010, Luis Oliveira <[email protected]>
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
;;;
(in-package :asdf)
#-(or openmcl mcl sbcl cmu scl clisp lispworks ecl allegro cormanlisp abcl mkcl)
(error "Sorry, this Lisp is not yet supported. Patches welcome!")
(defsystem :cffi
:version "0.16.1"
:description "The Common Foreign Function Interface"
:author "James Bielman <[email protected]>"
:maintainer "Luis Oliveira <[email protected]>"
:licence "MIT"
:depends-on (:uiop :alexandria :trivial-features :babel)
:components
((:module "src"
:serial t
:components
(#+openmcl (:file "cffi-openmcl")
#+mcl (:file "cffi-mcl")
#+sbcl (:file "cffi-sbcl")
#+cmu (:file "cffi-cmucl")
#+scl (:file "cffi-scl")
#+clisp (:file "cffi-clisp")
#+lispworks (:file "cffi-lispworks")
#+ecl (:file "cffi-ecl")
#+allegro (:file "cffi-allegro")
#+cormanlisp (:file "cffi-corman")
#+abcl (:file "cffi-abcl")
#+mkcl (:file "cffi-mkcl")
(:file "package")
(:file "utils")
(:file "libraries")
(:file "early-types")
(:file "types")
(:file "enum")
(:file "strings")
(:file "structures")
(:file "functions")
(:file "foreign-vars")
(:file "features")))))
(defmethod operation-done-p ((o test-op) (c (eql (find-system :cffi))))
nil)
(defmethod perform ((o test-op) (c (eql (find-system :cffi))))
(operate 'asdf:load-op :cffi-tests)
(operate 'asdf:test-op :cffi-tests))
;; vim: ft=lisp et
| 2,833 | Common Lisp | .asd | 70 | 37.328571 | 80 | 0.670294 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | e1d67f0b7f27e7661b10e9290f1de06561086c5e49fa1c912dd8f9586c035d3c | 30,678 | [
253589
] |
30,680 | cffi-tests.asd | johncorn271828_X_Orrery/dists/quicklisp/software/cffi_0.16.1/cffi-tests.asd | ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*-
;;;
;;; cffi-tests.asd --- ASDF system definition for CFFI unit tests.
;;;
;;; Copyright (C) 2005-2006, James Bielman <[email protected]>
;;; Copyright (C) 2005-2011, Luis Oliveira <[email protected]>
;;;
;;; Permission is hereby granted, free of charge, to any person
;;; obtaining a copy of this software and associated documentation
;;; files (the "Software"), to deal in the Software without
;;; restriction, including without limitation the rights to use, copy,
;;; modify, merge, publish, distribute, sublicense, and/or sell copies
;;; of the Software, and to permit persons to whom the Software is
;;; furnished to do so, subject to the following conditions:
;;;
;;; The above copyright notice and this permission notice shall be
;;; included in all copies or substantial portions of the Software.
;;;
;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
;;; DEALINGS IN THE SOFTWARE.
;;;
(defpackage #:cffi-tests-system
(:use #:cl #:asdf))
(in-package #:cffi-tests-system)
(eval-when (:compile-toplevel :load-toplevel :execute)
(oos 'load-op 'trivial-features))
(defvar *tests-dir* (append (pathname-directory *load-truename*) '("tests")))
(defclass c-test-lib (c-source-file)
())
(defmethod perform ((o load-op) (c c-test-lib))
nil)
(defmethod perform ((o load-source-op) (c c-test-lib))
nil)
(defmethod perform ((o compile-op) (c c-test-lib))
#-windows
(unless (zerop (run-shell-command
"cd ~A; make"
(namestring (make-pathname :name nil :type nil
:directory *tests-dir*))))
(error 'operation-error :component c :operation o)))
;; For the convenience of ECL users.
#+ecl (require 'rt)
(defsystem cffi-tests
:description "Unit tests for CFFI."
:depends-on (cffi-grovel cffi-libffi bordeaux-threads #-ecl rt)
:components
((:module "tests"
:serial t
:components
((:c-test-lib "libtest")
(:file "package")
(:file "bindings")
(:file "funcall")
(:file "defcfun")
(:file "callbacks")
(:file "foreign-globals")
(:file "memory")
(:file "strings")
(:file "struct")
(:file "fsbv")
(:file "union")
(:file "enum")
(:file "misc-types")
(:file "misc")
(:file "grovel")))))
(defmethod operation-done-p ((o test-op) (c (eql (find-system :cffi-tests))))
nil)
(defmethod perform ((o test-op) (c (eql (find-system :cffi-tests))))
(funcall (intern (string '#:run-all-cffi-tests) :cffi-tests)))
;;; vim: ft=lisp et
| 2,983 | Common Lisp | .asd | 76 | 35.486842 | 77 | 0.673921 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 002cfe34e0a3ec6da771f9cfc3b8327a552ebb4dc057f33ae8450ee9ff6d9574 | 30,680 | [
198865
] |
30,682 | split-sequence.asd | johncorn271828_X_Orrery/dists/quicklisp/software/split-sequence-1.2/split-sequence.asd | ;;; -*- Lisp -*-
(defsystem :split-sequence
:author "Arthur Lemmens <[email protected]>"
:maintainer "Sharp Lispers <[email protected]>"
:description "Splits a sequence into a list of subsequences
delimited by objects satisfying a test."
:license "public domain"
:version (:read-file-form "version.lisp-expr")
:components ((:file "split-sequence"))
:in-order-to ((asdf:test-op (asdf:load-op :split-sequence-tests)))
:perform (asdf:test-op :after (op c)
(funcall (intern (symbol-name '#:run!) '#:5am) :split-sequence)))
(defsystem :split-sequence-tests
:author "Arthur Lemmens <[email protected]>"
:maintainer "Sharp Lispers <[email protected]>"
:description "Split-Sequence test suite"
:license "public domain"
:depends-on (:split-sequence :fiveam)
:components ((:file "tests")))
| 851 | Common Lisp | .asd | 19 | 41.421053 | 78 | 0.718072 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 510e6ce207454bdebb3d0d2a99d2b4b3a3db0d91267d21edeafd2e10f34d34ee | 30,682 | [
292769
] |
30,683 | cl-alc.asd | johncorn271828_X_Orrery/dists/quicklisp/software/cl-openal-20150302-git/cl-alc.asd | (asdf:defsystem cl-alc
:version "1.0"
:description "CFFI bindings for OpenAL's ALC API."
:maintainer "Kat Marchán <[email protected]>"
:author "Kat Marchán <[email protected]>"
:licence "public domain"
:depends-on (cffi cl-openal)
:components
((:module alc
:components
((:file "packages")
(:file "bindings" :depends-on ("packages"))
(:file "alc" :depends-on ("packages" "bindings")))))) | 458 | Common Lisp | .asd | 13 | 29.076923 | 66 | 0.626126 | johncorn271828/X_Orrery | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:39:23 AM (Europe/Amsterdam) | 7ccaef4ec1d6e3e00992bb0c8c54187420ff9f1d2c300ebfa42a3e6ee49b6a8e | 30,683 | [
-1
] |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.